Expand ResolvedAst to handle synthetic constructors.

pkg/compiler/lib/src/elements/modelx.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library elements.modelx;
 
 import '../common.dart';
 import '../common/resolution.dart' show Resolution, Parsing;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_constructors.dart';
@@ skipping 2310 matching lines @@
 
 /**
  * A constructor that is not defined in the source code but rather implied by
  * the language semantics.
  *
  * This class is used to represent default constructors and forwarding
  * constructors for mixin applications.
  */
 class SynthesizedConstructorElementX extends ConstructorElementX {
   final ConstructorElement definingConstructor;
-  final bool isDefaultConstructor;
+  ResolvedAst _resolvedAst;
 
   SynthesizedConstructorElementX.notForDefault(
       String name, this.definingConstructor, Element enclosing)
-      : isDefaultConstructor = false,
-        super(name, ElementKind.GENERATIVE_CONSTRUCTOR, Modifiers.EMPTY,
-            enclosing);
+      : super(name, ElementKind.GENERATIVE_CONSTRUCTOR, Modifiers.EMPTY,
+            enclosing) {
+    _resolvedAst = new SynthesizedResolvedAst(
+        this, ResolvedAstKind.FORWARDING_CONSTRUCTOR);
+  }
 
   SynthesizedConstructorElementX.forDefault(
       this.definingConstructor, Element enclosing)
-      : isDefaultConstructor = true,
-        super('', ElementKind.GENERATIVE_CONSTRUCTOR, Modifiers.EMPTY,
+      : super('', ElementKind.GENERATIVE_CONSTRUCTOR, Modifiers.EMPTY,
             enclosing) {
     functionSignature = new FunctionSignatureX(
         type: new FunctionType.synthesized(enclosingClass.thisType));
+    _resolvedAst =
+        new SynthesizedResolvedAst(this, ResolvedAstKind.DEFAULT_CONSTRUCTOR);
+  }
+
+  bool get isDefaultConstructor {
+    return _resolvedAst.kind == ResolvedAstKind.DEFAULT_CONSTRUCTOR;
   }
 
   FunctionExpression parseNode(Parsing parsing) => null;
 
   bool get hasNode => false;
 
   FunctionExpression get node => null;
 
   Token get position => enclosingElement.position;
 
   bool get isSynthesized => true;
 
+  bool get hasResolvedAst => true;
+
+  ResolvedAst get resolvedAst => _resolvedAst;
+
   DartType get type {
     if (isDefaultConstructor) {
       return super.type;
     } else {
       // TODO(johnniwinther): Ensure that the function type substitutes type
       // variables correctly.
       return definingConstructor.type;
     }
   }
 
@@ skipping 319 matching lines @@
     if (origin != null) {
       return 'patch ${super.toString()}';
     } else if (patch != null) {
       return 'origin ${super.toString()}';
     } else {
       return super.toString();
     }
   }
 }
 
+/// This element is used to encode an enum class.
+///
+/// For instance
+///
+///     enum A { b, c, }
+///
+/// is modelled as
+///
+///     class A {
+///       final int index;
+///
+///       const A(this.index);
+///
+///       String toString() {
+///         return const <int, A>{0: 'A.b', 1: 'A.c'}[index];
+///       }
+///
+///       static const A b = const A(0);
+///       static const A c = const A(1);
+///
+///       static const List<A> values = const <A>[b, c];
+///     }
+///
+///  where the `A` class is encoded using this element.
+///
 class EnumClassElementX extends ClassElementX
     implements EnumClassElement, DeclarationSite {
   final Enum node;
   List<FieldElement> _enumValues;
 
   EnumClassElementX(String name, Element enclosing, int id, this.node)
       : super(name, enclosing, id, STATE_NOT_STARTED);
 
   @override
   bool get hasNode => true;
@@ skipping 23 matching lines @@
   void set enumValues(List<FieldElement> values) {
     assert(invariant(this, _enumValues == null,
         message: "enumValues has already been computed for $this."));
     _enumValues = values;
   }
 
   @override
   DeclarationSite get declarationSite => this;
 }
 
+/// This element is used to encode the implicit constructor in an enum class.
+///
+/// For instance
+///
+///     enum A { b, c, }
+///
+/// is modelled as
+///
+///     class A {
+///       final int index;
+///
+///       const A(this.index);
+///
+///       String toString() {
+///         return const <int, A>{0: 'A.b', 1: 'A.c'}[index];
+///       }
+///
+///       static const A b = const A(0);
+///       static const A c = const A(1);
+///
+///       static const List<A> values = const <A>[b, c];
+///     }
+///
+///  where the `const A(...)` constructor is encoded using this element.
+///
 class EnumConstructorElementX extends ConstructorElementX {
   final FunctionExpression node;
 
   EnumConstructorElementX(
       EnumClassElementX enumClass, Modifiers modifiers, this.node)
       : super(
             '', // Name.
             ElementKind.GENERATIVE_CONSTRUCTOR,
             modifiers,
             enumClass);
 
   @override
   bool get hasNode => true;
 
   @override
   FunctionExpression parseNode(Parsing parsing) => node;
 
   @override
   SourceSpan get sourcePosition => enclosingClass.sourcePosition;
 }
 
+/// This element is used to encode the implicit methods in an enum class.
+///
+/// For instance
+///
+///     enum A { b, c, }
+///
+/// is modelled as
+///
+///     class A {
+///       final int index;
+///
+///       const A(this.index);
+///
+///       String toString() {
+///         return const <int, A>{0: 'A.b', 1: 'A.c'}[index];
+///       }
+///
+///       static const A b = const A(0);
+///       static const A c = const A(1);
+///
+///       static const List<A> values = const <A>[b, c];
+///     }
+///
+///  where the `toString` method is encoded using this element.
+///
 class EnumMethodElementX extends MethodElementX {
   final FunctionExpression node;
 
   EnumMethodElementX(
       String name, EnumClassElementX enumClass, Modifiers modifiers, this.node)
       : super(name, ElementKind.FUNCTION, modifiers, enumClass, true);
 
   @override
   bool get hasNode => true;
 
   @override
   FunctionExpression parseNode(Parsing parsing) => node;
 
   @override
   SourceSpan get sourcePosition => enclosingClass.sourcePosition;
 }
 
+/// This element is used to encode the initializing formal of the implicit
+/// constructor in an enum class.
+///
+/// For instance
+///
+///     enum A { b, c, }
+///
+/// is modelled as
+///
+///     class A {
+///       final int index;
+///
+///       const A(this.index);
+///
+///       String toString() {
+///         return const <int, A>{0: 'A.b', 1: 'A.c'}[index];
+///       }
+///
+///       static const A b = const A(0);
+///       static const A c = const A(1);
+///
+///       static const List<A> values = const <A>[b, c];
+///     }
+///
+///  where the `this.index` formal is encoded using this element.
+///
 class EnumFormalElementX extends InitializingFormalElementX {
   EnumFormalElementX(
       ConstructorElement constructor,
       VariableDefinitions variables,
       Identifier identifier,
       EnumFieldElementX fieldElement)
       : super(constructor, variables, identifier, null, fieldElement) {
     typeCache = fieldElement.type;
   }
 
   @override
   SourceSpan get sourcePosition => enclosingClass.sourcePosition;
 }
 
+/// This element is used to encode the implicitly fields in an enum class.
+///
+/// For instance
+///
+///     enum A { b, c, }
+///
+/// is modelled as
+///
+///     class A {
+///       final int index;
+///
+///       const A(this.index);
+///
+///       String toString() {
+///         return const <int, A>{0: 'A.b', 1: 'A.c'}[index];
+///       }
+///
+///       static const A b = const A(0);
+///       static const A c = const A(1);
+///
+///       static const List<A> values = const <A>[b, c];
+///     }
+///
+///  where the `index` and `values` fields are encoded using this element.
+///
 class EnumFieldElementX extends FieldElementX {
   EnumFieldElementX(Identifier name, EnumClassElementX enumClass,
       VariableList variableList, Node definition,
       [Expression initializer])
       : super(name, enumClass, variableList) {
     definitionsCache = new VariableDefinitions(
         null, variableList.modifiers, new NodeList.singleton(definition));
     initializerCache = initializer;
   }
 
   @override
   SourceSpan get sourcePosition => enclosingClass.sourcePosition;
 }
 
+/// This element is used to encode the constant value in an enum class.
+///
+/// For instance
+///
+///     enum A { b, c, }
+///
+/// is modelled as
+///
+///     class A {
+///       final int index;
+///
+///       const A(this.index);
+///
+///       String toString() {
+///         return const <int, A>{0: 'A.b', 1: 'A.c'}[index];
+///       }
+///
+///       static const A b = const A(0);
+///       static const A c = const A(1);
+///
+///       static const List<A> values = const <A>[b, c];
+///     }
+///
+///  where the `b` and `c` fields are encoded using this element.
+///
 class EnumConstantElementX extends EnumFieldElementX
     implements EnumConstantElement {
   final int index;
 
   EnumConstantElementX(
       Identifier name,
       EnumClassElementX enumClass,
       VariableList variableList,
       Node definition,
       Expression initializer,
       this.index)
       : super(name, enumClass, variableList, definition, initializer);
 
   @override
   SourceSpan get sourcePosition {
-    return new SourceSpan(
-        enclosingClass.sourcePosition.uri,
+    return new SourceSpan(enclosingClass.sourcePosition.uri,
         position.charOffset, position.charEnd);
   }
 }
 
 abstract class MixinApplicationElementX extends BaseClassElementX
     with MixinApplicationElementCommon
     implements MixinApplicationElement {
   Link<ConstructorElement> constructors = new Link<ConstructorElement>();
 
   InterfaceType mixinType;
@@ skipping 286 matching lines @@
   /// found through [declaration] since its node define the inheritance relation
   /// for the class. For unpatched elements the defining element is the element
   /// itself.
   AstElement get definingElement;
 
   bool get hasResolvedAst {
     return definingElement.hasNode && definingElement.hasTreeElements;
   }
 
   ResolvedAst get resolvedAst {
-    return new ResolvedAst(
+    return new ParsedResolvedAst(
         declaration, definingElement.node, definingElement.treeElements);
   }
 }