parser: add ownership attributes on member vars to AST

Author: tmarsteel

frontend/src/main/kotlin/compiler/ast/AstBaseTypeMemberVariableAttribute.kt

@@ -0,0 +1,29 @@
+package compiler.ast
+
+import compiler.lexer.KeywordToken
+
+sealed class AstBaseTypeMemberVariableAttribute(
+    val attributeName: KeywordToken,
+) {
+    fun conflictsWith(other: AstBaseTypeMemberVariableAttribute) = this.javaClass == other.javaClass && attributeName.keyword != other.attributeName.keyword
+
+    class Ownership(nameToken: KeywordToken) : AstBaseTypeMemberVariableAttribute(nameToken) {
+        override fun equals(other: Any?): Boolean {
+            if (this === other) return true
+            if (other !is Ownership) return false
+
+            if (attributeName.keyword != other.attributeName.keyword) return false
+
+            return true
+        }
+
+        override fun hashCode(): Int {
+            var result = javaClass.hashCode()
+            result = 31 * result + attributeName.hashCode()
+            return result
+        }
+
+        /** TODO: unused? */
+        private enum class OwnershipKind { OWNED, REFERENCED }
+    }
+}

frontend/src/main/kotlin/compiler/ast/BaseTypeDeclaration.kt

@@ -172,7 +172,7 @@ sealed class BaseTypeMemberDeclaration : BaseTypeEntryDeclaration {
 }
 
 class BaseTypeMemberVariableDeclaration(
-    val attributes: List<KeywordToken>,
+    val attributes: BoundBaseTypeMemberVariableAttributes,
     val variableDeclaration: VariableDeclaration,
 ) : BaseTypeMemberDeclaration() {
     override val span = variableDeclaration.declaredAt
@@ -294,7 +294,7 @@ class BaseTypeMemberVariableDeclaration(
                     boundLocalVariableInCtor,
                     variableDeclaration.visibility?.bindTo(typeRootContext)
                         ?: BoundVisibility.default(typeRootContext),
-                    BoundBaseTypeMemberVariableAttributes(attributes),
+                    attributes,
                     getTypeDef,
                     this@BaseTypeMemberVariableDeclaration,
                 )

frontend/src/main/kotlin/compiler/binding/BoundFunctionAttributeList.kt

@@ -4,7 +4,7 @@ import compiler.ast.AstFunctionAttribute
 import compiler.ast.AstVisibility
 import compiler.binding.context.CTContext
 import compiler.diagnostic.Diagnosis
-import compiler.diagnostic.conflictingAttributes
+import compiler.diagnostic.conflictingFunctionAttributes
 import compiler.diagnostic.functionIsMissingAttribute
 import compiler.diagnostic.inefficientAttributes
 import compiler.diagnostic.unsupportedCallingConvention
@@ -80,7 +80,7 @@ class BoundFunctionAttributeList(
             attributes.twoElementPermutationsUnordered()
                 .filter { (a, b) -> conflictsWith(a, b) }
                 .forEach { (a, b) ->
-                    diagnosis.conflictingAttributes(listOf(a, b))
+                    diagnosis.conflictingFunctionAttributes(listOf(a, b))
                 }
 
             attributes

frontend/src/main/kotlin/compiler/binding/basetype/BoundBaseTypeMemberVariableAttributes.kt

@@ -1,25 +1,35 @@
 package compiler.binding.basetype
 
+import compiler.ast.AstBaseTypeMemberVariableAttribute
 import compiler.diagnostic.Diagnosis
+import compiler.diagnostic.conflictingMemberVariableAttributes
 import compiler.diagnostic.duplicateMemberVariableAttributes
-import compiler.diagnostic.invalidMemberVariableAttribute
-import compiler.lexer.KeywordToken
+import compiler.util.twoElementPermutationsUnordered
 
 class BoundBaseTypeMemberVariableAttributes(
-    val astNodes: List<KeywordToken>,
+    val attributes: List<AstBaseTypeMemberVariableAttribute>,
 ) {
-    fun validate(diagnosis: Diagnosis) {
-        val (applicableAttrs, inapplicableAttrs) = astNodes.partition { false } /* no attributes known currently */
-        inapplicableAttrs.forEach {
-            diagnosis.invalidMemberVariableAttribute(it, "${it.keyword.text} is not a valid attribute on member variables")
-        }
+    val ownershipAttribute: AstBaseTypeMemberVariableAttribute.Ownership?
+
+    init {
+        ownershipAttribute = attributes
+            .filterIsInstance<AstBaseTypeMemberVariableAttribute.Ownership>()
+            .firstOrNull()
+    }
 
-        applicableAttrs
-            .groupBy { it.keyword }
+    fun validate(diagnosis: Diagnosis) {
+        attributes
+            .groupBy { it.attributeName.keyword }
             .values
             .filter { it.size > 1 }
             .forEach { dupes ->
                 diagnosis.duplicateMemberVariableAttributes(dupes.first(), dupes.drop(1))
             }
+
+        attributes.twoElementPermutationsUnordered()
+            .filter { (a, b) -> a.conflictsWith(b) }
+            .forEach { (a, b) ->
+                diagnosis.conflictingMemberVariableAttributes(listOf(a, b))
+            }
     }
 }

frontend/src/main/kotlin/compiler/diagnostic/ConflictingBaseTypeMemberVariableAttributesDiagnostic.kt

@@ -0,0 +1,17 @@
+package compiler.diagnostic
+
+import compiler.ast.AstBaseTypeMemberVariableAttribute
+import compiler.diagnostic.rendering.CellBuilder
+
+class ConflictingBaseTypeMemberVariableAttributesDiagnostic(
+    val attributesInConflict: List<AstBaseTypeMemberVariableAttribute>,
+) : Diagnostic(
+    Severity.ERROR,
+    "These attributes contradict each other",
+    attributesInConflict.first().attributeName.span,
+) {
+    context(builder: CellBuilder)
+    override fun renderBody() {
+        builder.sourceHints(*attributesInConflict.map { SourceHint(it.attributeName.span, severity = severity) }.toTypedArray())
+    }
+}

frontend/src/main/kotlin/compiler/diagnostic/DuplicateMemberVariableAttributeDiagnostic.kt

@@ -1,19 +1,19 @@
 package compiler.diagnostic
 
+import compiler.ast.AstBaseTypeMemberVariableAttribute
 import compiler.diagnostic.rendering.CellBuilder
-import compiler.lexer.KeywordToken
 
 class DuplicateMemberVariableAttributeDiagnostic(
-    val duplicates: List<KeywordToken>,
+    val duplicates: List<AstBaseTypeMemberVariableAttribute>,
 ) : Diagnostic(
     Severity.WARNING,
-    "Duplicate member variable attribute ${duplicates.first().keyword.text}",
-    duplicates.first().span,
+    "Duplicate member variable attribute ${duplicates.first().attributeName.keyword.text}",
+    duplicates.first().attributeName.span,
 ) {
     context(builder: CellBuilder)    
     override fun renderBody() {
         with(builder) {
-            sourceHints(duplicates.map { SourceHint(it.span, severity = severity) })
+            sourceHints(duplicates.map { SourceHint(it.attributeName.span, severity = severity) })
         }
     }
 }

frontend/src/main/kotlin/compiler/diagnostic/InvalidBaseTypeMemberVariableAttributeDiagnostic.kt

@@ -1,5 +1,6 @@
 package compiler.diagnostic
 
+import compiler.ast.AstBaseTypeMemberVariableAttribute
 import compiler.ast.AstFunctionAttribute
 import compiler.ast.AstPackageName
 import compiler.ast.BaseTypeConstructorDeclaration
@@ -62,7 +63,6 @@ import compiler.binding.type.BoundTypeReference
 import compiler.binding.type.ErroneousType
 import compiler.binding.type.TypeUseSite
 import compiler.lexer.IdentifierToken
-import compiler.lexer.KeywordToken
 import compiler.lexer.OperatorToken
 import compiler.lexer.Span
 import io.github.tmarsteel.emerge.common.CanonicalElementName
@@ -229,16 +229,16 @@ fun Diagnosis.inefficientAttributes(message: String, attributes: Collection<AstF
     add(ModifierInefficiencyDiagnostic(message, attributes))
 }
 
-fun Diagnosis.conflictingAttributes(attributes: Collection<AstFunctionAttribute>) {
+fun Diagnosis.conflictingFunctionAttributes(attributes: Collection<AstFunctionAttribute>) {
     add(ConflictingFunctionAttributesDiagnostic(attributes))
 }
 
-fun Diagnosis.invalidMemberVariableAttribute(attribute: KeywordToken, reason: String) {
-    add(InvalidBaseTypeMemberVariableAttributeDiagnostic(reason, attribute.span))
+fun Diagnosis.duplicateMemberVariableAttributes(firstMention: AstBaseTypeMemberVariableAttribute, duplicates: List<AstBaseTypeMemberVariableAttribute>) {
+    add(DuplicateMemberVariableAttributeDiagnostic(duplicates))
 }
 
-fun Diagnosis.duplicateMemberVariableAttributes(firstMention: KeywordToken, duplicates: List<KeywordToken>) {
-    add(DuplicateMemberVariableAttributeDiagnostic(duplicates))
+fun Diagnosis.conflictingMemberVariableAttributes(attributesInConflict: List<AstBaseTypeMemberVariableAttribute>) {
+    add(ConflictingBaseTypeMemberVariableAttributesDiagnostic(attributesInConflict))
 }
 
 fun Diagnosis.toplevelFunctionWithOverrideAttribute(attr: AstFunctionAttribute.Override) {

frontend/src/main/kotlin/compiler/diagnostic/factory.kt

@@ -40,6 +40,16 @@ enum class Keyword(val text: String)
     IMMUTABLE("const"),
     EXCLUSIVE("exclusive"),
 
+    OWN("own"),
+    REF("ref"),
+
+    SHARED("shared"),
+    STATIC("static"),
+    ABSTRACT("abstract"),
+    FINAL("final"),
+    SEALED("sealed"),
+    VIRTUAL("virtual"),
+
     NOTHROW("nothrow"),
     PURE("pure"),
     OPERATOR("operator"),

frontend/src/main/kotlin/compiler/lexer/tokens.kt

@@ -18,6 +18,7 @@
 
 package compiler.parser.grammar
 
+import compiler.ast.AstBaseTypeMemberVariableAttribute
 import compiler.ast.AstCodeChunk
 import compiler.ast.AstFunctionAttribute
 import compiler.ast.AstVisibility
@@ -32,7 +33,9 @@ import compiler.ast.TypeParameterBundle
 import compiler.ast.VariableDeclaration
 import compiler.ast.type.TypeParameter
 import compiler.ast.type.TypeReference
+import compiler.binding.basetype.BoundBaseTypeMemberVariableAttributes
 import compiler.lexer.IdentifierToken
+import compiler.lexer.Keyword
 import compiler.lexer.Keyword.CLASS_DEFINITION
 import compiler.lexer.Keyword.CONSTRUCTOR
 import compiler.lexer.Keyword.DESTRUCTOR
@@ -46,14 +49,30 @@ import compiler.parser.grammar.dsl.astTransformation
 import compiler.parser.grammar.dsl.eitherOf
 import compiler.parser.grammar.dsl.sequence
 
+val BaseTypeMemberVariableAttribute = eitherOf {
+    keyword(Keyword.OWN)
+    keyword(Keyword.REF)
+}
+    .astTransformation { tokens ->
+        val keywordToken = tokens.next() as KeywordToken
+        when (keywordToken.keyword) {
+            Keyword.OWN,
+            Keyword.REF -> AstBaseTypeMemberVariableAttribute.Ownership(keywordToken)
+            else -> error("unsupported grammar")
+        }
+    }
+
 val BaseTypeMemberVariableDeclaration = sequence("member variable declaration") {
+    repeating {
+        ref(BaseTypeMemberVariableAttribute)
+    }
     ref(VariableDeclaration)
     operator(NEWLINE)
 }
     .astTransformation { tokens ->
-        val attributes = tokens.takeWhileIsInstanceOf<KeywordToken>()
+        val attributes = tokens.takeWhileIsInstanceOf<AstBaseTypeMemberVariableAttribute>()
         BaseTypeMemberVariableDeclaration(
-            attributes,
+            BoundBaseTypeMemberVariableAttributes(attributes),
             tokens.next() as VariableDeclaration,
         )
     }