Add AttributeDefinition

(Represented by AttributeDeclaration in the RedHat AST)

CC #46.

source/ceylon/ast/core/AnyAttribute.ceylon

@@ -9,7 +9,7 @@
      shared formal Comparison compare(Other that);
      shared default Boolean empty => iterator().next() is Finished;"
 shared abstract class AnyAttribute()
-        of AttributeDeclaration
+        of AttributeDeclaration | AttributeDefinition
         extends TypedDeclaration() {
 
     shared actual formal [Annotations, Type|Modifier, LIdentifier, AnySpecifier|Block=] children;

source/ceylon/ast/core/AttributeDefinition.ceylon

@@ -0,0 +1,43 @@
+"""An attribute definition, using a specifier.
+   
+   Examples:
+   
+       shared actual String string => "``name`` from ``countryOfOrigin`` of age ``age``";
+       shared actual Null definition = null;"""
+shared class AttributeDefinition(name, type, definition, annotations = Annotations())
+        extends AnyAttribute() {
+
+    shared actual MemberName name;
+    "The type of the attribute.
+     
+     This can be:
+     - a proper [[Type]],
+     - a [[’`value`’ modifier|ValueModifier]] to indicate type inference, or
+     - a [[’`dynamic`’ modifier|DynamicModifier]] to indicate the absence of a type."
+    shared actual Type|ValueModifier|DynamicModifier type;
+    "The definition of the attribute."
+    shared actual AnySpecifier definition;
+    shared actual Annotations annotations;
+
+    shared actual [Annotations, Type|ValueModifier|DynamicModifier, LIdentifier, AnySpecifier] children = [annotations, type, name, definition];
+
+    shared actual Result transform<out Result>(Transformer<Result> transformer)
+            => transformer.transformAttributeDefinition(this);
+
+    shared actual Boolean equals(Object that) {
+        if (is AttributeDefinition that) {
+            return name == that.name && type == that.type && definition == that.definition && annotations == that.annotations;
+        } else {
+            return false;
+        }
+    }
+
+    shared actual Integer hash
+            => 31 * (name.hash + 31 * (type.hash + 31 * (definition.hash + 31 * annotations.hash)));
+
+    shared AttributeDefinition copy(MemberName name = this.name, Type|ValueModifier|DynamicModifier type = this.type, AnySpecifier definition = this.definition, Annotations annotations = this.annotations) {
+        value ret = AttributeDefinition(name, type, definition, annotations);
+        copyExtraInfoTo(ret);
+        return ret;
+    }
+}

source/ceylon/ast/core/CeylonExpressionTransformer.ceylon

@@ -108,6 +108,13 @@ shared class CeylonExpressionTransformer(String indentLevel = "    ") satisfies
                 `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
                 `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
                 ``indent``}";
+    transformAttributeDefinition(AttributeDefinition that)
+            => "AttributeDefinition {
+                `` indent + indentLevel ``name = ``transformWithIndent(that.name)``;
+                `` indent + indentLevel ``type = ``transformWithIndent(that.type)``;
+                `` indent + indentLevel ``definition = ``transformWithIndent(that.definition)``;
+                `` indent + indentLevel ``annotations = ``transformWithIndent(that.annotations)``;
+                ``indent``}";
     transformBaseExpression(BaseExpression that) => "BaseExpression(``transformWithIndent(that.nameAndArgs)``)";
     transformBaseMeta(BaseMeta that) => "BaseMeta(``transformWithIndent(that.nameAndArgs)``)";
     transformBaseType(BaseType that) => "BaseType(``transformWithIndent(that.nameAndArgs)``)";

source/ceylon/ast/core/Editor.ceylon

@@ -84,6 +84,15 @@ shared /* abstract */ class Editor() satisfies NarrowingTransformer<Node> { // T
         }
         return that.copy(transformLIdentifier(that.name), transformTypeOrDynamicModifier(that.type), transformAnnotations(that.annotations));
     }
+    shared actual default AttributeDefinition transformAttributeDefinition(AttributeDefinition that) {
+        Type|ValueModifier|DynamicModifier transformTypeOrValueModifierOrDynamicModifier(Type|ValueModifier|DynamicModifier that) {
+            switch (that)
+            case (is Type) { return transformType(that); }
+            case (is ValueModifier) { return transformValueModifier(that); }
+            case (is DynamicModifier) { return transformDynamicModifier(that); }
+        }
+        return that.copy(transformLIdentifier(that.name), transformTypeOrValueModifierOrDynamicModifier(that.type), transformAnySpecifier(that.definition), transformAnnotations(that.annotations));
+    }
     shared actual default BaseExpression transformBaseExpression(BaseExpression that)
             => that.copy(transformNameWithTypeArguments(that.nameAndArgs));
     shared actual default BaseMeta transformBaseMeta(BaseMeta that)

source/ceylon/ast/core/NarrowingTransformer.ceylon

@@ -6,6 +6,7 @@ shared interface NarrowingTransformer<out Result> satisfies Transformer<Result>
     shared actual default Result transformAnyAttribute(AnyAttribute that) {
         switch (that)
         case (is AttributeDeclaration) { return transformAttributeDeclaration(that); }
+        case (is AttributeDefinition) { return transformAttributeDefinition(that); }
     }
     shared actual default Result transformAnySpecifier(AnySpecifier that) {
         switch (that)

source/ceylon/ast/core/Transformer.ceylon

@@ -28,6 +28,7 @@ shared interface Transformer<out Result> {
     shared formal Result transformAssignmentOperation(AssignmentOperation that);
     shared formal Result transformAtom(Atom that);
     shared formal Result transformAttributeDeclaration(AttributeDeclaration that);
+    shared formal Result transformAttributeDefinition(AttributeDefinition that);
     shared formal Result transformBaseExpression(BaseExpression that);
     shared formal Result transformBaseMeta(BaseMeta that);
     shared formal Result transformBaseType(BaseType that);

source/ceylon/ast/core/Visitor.ceylon

@@ -28,6 +28,7 @@ shared /* abstract */ class Visitor() satisfies WideningTransformer<Anything> {
     transformAssignmentOperation(AssignmentOperation that) => visitAssignmentOperation(that);
     transformAtom(Atom that) => visitAtom(that);
     transformAttributeDeclaration(AttributeDeclaration that) => visitAttributeDeclaration(that);
+    transformAttributeDefinition(AttributeDefinition that) => visitAttributeDefinition(that);
     transformBaseExpression(BaseExpression that) => visitBaseExpression(that);
     transformBaseMeta(BaseMeta that) => visitBaseMeta(that);
     transformBaseType(BaseType that) => visitBaseType(that);
@@ -193,6 +194,7 @@ shared /* abstract */ class Visitor() satisfies WideningTransformer<Anything> {
     shared default void visitAssignmentOperation(AssignmentOperation that) => super.transformAssignmentOperation(that);
     shared default void visitAtom(Atom that) => super.transformAtom(that);
     shared default void visitAttributeDeclaration(AttributeDeclaration that) => super.transformAttributeDeclaration(that);
+    shared default void visitAttributeDefinition(AttributeDefinition that) => super.transformAttributeDefinition(that);
     shared default void visitBaseExpression(BaseExpression that) => super.transformBaseExpression(that);
     shared default void visitBaseMeta(BaseMeta that) => super.transformBaseMeta(that);
     shared default void visitBaseType(BaseType that) => super.transformBaseType(that);

source/ceylon/ast/core/WideningTransformer.ceylon

@@ -19,6 +19,7 @@ shared interface WideningTransformer<out Result> satisfies Transformer<Result> {
     shared actual default Result transformAssignmentOperation(AssignmentOperation that) => transformBinaryOperation(that);
     shared actual default Result transformAtom(Atom that) => transformPrimary(that);
     shared actual default Result transformAttributeDeclaration(AttributeDeclaration that) => transformAnyAttribute(that);
+    shared actual default Result transformAttributeDefinition(AttributeDefinition that) => transformAnyAttribute(that);
     shared actual default Result transformBaseExpression(BaseExpression that) => transformPrimary(that);
     shared actual default Result transformBaseMeta(BaseMeta that) => transformMeta(that);
     shared actual default Result transformBaseType(BaseType that) => transformSimpleType(that);

source/ceylon/ast/redhat/AnyAttribute.ceylon

@@ -12,7 +12,13 @@ import com.redhat.ceylon.compiler.typechecker.tree {
 shared AnyAttribute anyAttributeToCeylon(JAnyAttribute anyAttribute) {
     assert (is JAttributeDeclaration anyAttribute);
     switch (anyAttribute)
-    case (is JAttributeDeclaration) { return attributeDeclarationToCeylon(anyAttribute); }
+    case (is JAttributeDeclaration) {
+        if (anyAttribute.specifierOrInitializerExpression exists) {
+            return attributeDefinitionToCeylon(anyAttribute);
+        } else {
+            return attributeDeclarationToCeylon(anyAttribute);
+        }
+    }
 }
 
 "Compiles the given [[code]] for an Any Attribute

source/ceylon/ast/redhat/AttributeDefinition.ceylon

@@ -0,0 +1,46 @@
+import ceylon.ast.core {
+    AttributeDefinition,
+    Type,
+    ValueModifier,
+    DynamicModifier
+}
+import com.redhat.ceylon.compiler.typechecker.tree {
+    Tree {
+        JAttributeDeclaration=AttributeDeclaration,
+        JDynamicModifier=DynamicModifier,
+        JSpecifierExpression=SpecifierExpression,
+        JStaticType=StaticType,
+        JValueModifier=ValueModifier
+    }
+}
+
+"Converts a RedHat AST [[AttributeDeclaration|JAttributeDeclaration]] to a `ceylon.ast` [[AttributeDefinition]]."
+shared AttributeDefinition attributeDefinitionToCeylon(JAttributeDeclaration attributeDefinition) {
+    "Must be defined"
+    // The other case type of SpecifierOrInitializerExpression, InitializerExpression, is obsolete
+    assert (is JSpecifierExpression definition = attributeDefinition.specifierOrInitializerExpression);
+    assert (is JStaticType|JValueModifier|JDynamicModifier jType = attributeDefinition.type);
+    Type|ValueModifier|DynamicModifier type;
+    switch (jType)
+    case (is JStaticType) { type = typeToCeylon(jType); }
+    case (is JValueModifier) { type = valueModifierToCeylon(jType); }
+    case (is JDynamicModifier) { type = dynamicModifierToCeylon(jType); }
+    return AttributeDefinition {
+        annotations = annotationsToCeylon(attributeDefinition.annotationList);
+        type = type;
+        name = lIdentifierToCeylon(attributeDefinition.identifier);
+        definition = anySpecifierToCeylon(definition);
+    };
+}
+
+"Compiles the given [[code]] for an Attribute Definition
+ into an [[AttributeDefinition]] using the Ceylon compiler
+ (more specifically, the rule for a `declaration`)."
+shared AttributeDefinition? compileAttributeDefinition(String code) {
+    if (is JAttributeDeclaration jDeclaration = createParser(code).declaration(),
+        jDeclaration.specifierOrInitializerExpression exists) {
+        return attributeDefinitionToCeylon(jDeclaration);
+    } else {
+        return null;
+    }
+}

source/ceylon/ast/redhat/RedHatTransformer.ceylon

@@ -420,6 +420,20 @@ shared class RedHatTransformer(TokenFactory tokens) satisfies NarrowingTransform
         return ret;
     }
 
+    shared actual JAttributeDeclaration transformAttributeDefinition(AttributeDefinition that) {
+        JAttributeDeclaration ret = JAttributeDeclaration(null);
+        ret.annotationList = transformAnnotations(that.annotations);
+        value type = that.type;
+        switch (type)
+        case (is Type) { ret.type = transformType(type); }
+        case (is ValueModifier) { ret.type = transformValueModifier(type); }
+        case (is DynamicModifier) { ret.type = transformDynamicModifier(type); }
+        ret.identifier = transformLIdentifier(that.name);
+        ret.specifierOrInitializerExpression = transformAnySpecifier(that.definition);
+        ret.endToken = tokens.token(";", semicolon);
+        return ret;
+    }
+
     shared actual JBaseMemberOrTypeExpression transformBaseExpression(BaseExpression that) {
         JBaseMemberOrTypeExpression ret;
         value name = that.nameAndArgs.name;