Update elements, nodes and visitors for serialization.

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;
@@ skipping 1579 matching lines @@
         message: "Type has not been computed for $this."));
     return variables.type;
   }
 
   bool get isInstanceMember => isClassMember && !isStatic;
 
   // Note: cachedNode.beginToken will not be correct in all
   // cases, for example, for function typed parameters.
   Token get position => token;
 
-  accept(ElementVisitor visitor, arg) {
-    return visitor.visitVariableElement(this, arg);
-  }
-
   DeclarationSite get declarationSite => variables;
 }
 
 class LocalVariableElementX extends VariableElementX
     implements LocalVariableElement {
   LocalVariableElementX(String name,
                         ExecutableElement enclosingElement,
                         VariableList variables,
                         Token token)
       : super(name, ElementKind.VARIABLE, enclosingElement, variables, token) {
     createDefinitions(variables.definitions);
   }
 
   ExecutableElement get executableContext => enclosingElement;
 
   MemberElement get memberContext => executableContext.memberContext;
 
   bool get isLocal => true;
+
+  accept(ElementVisitor visitor, arg) {
+    return visitor.visitLocalVariableElement(this, arg);
+  }
 }
 
 class FieldElementX extends VariableElementX
     with AnalyzableElementX implements FieldElement {
   List<FunctionElement> nestedClosures = new List<FunctionElement>();
 
   FieldElementX(Identifier name,
                 Element enclosingElement,
                 VariableList variables)
     : super(name.source, ElementKind.FIELD, enclosingElement,
@@ skipping 1204 matching lines @@
       : super('', // Name.
               ElementKind.GENERATIVE_CONSTRUCTOR,
               modifiers,
               enumClass);
 
   @override
   bool get hasNode => true;
 
   @override
   FunctionExpression parseNode(Parsing parsing) => node;
+
+  @override
+  SourceSpan get sourcePosition => enclosingClass.sourcePosition;
 }
 
 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;
 }
 
 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;
 }
 
 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;

[Siggi Cherem (dart-lang), 2016/04/08 16:18:24]

why don't we keep the source-position of the enum-member instead?

[Johnni Winther, 2016/04/11 08:18:24]

The enum fields are the synthetic `index` and `values` fields. These should
point the enum and not any of the values.

[Siggi Cherem (dart-lang), 2016/04/11 16:28:18]

Not sure I followed. If I write:

enum C {
  v1,
  v2
}


Are you saying that C.index and C.values are modeled here, but C.v1 and C.v2 are
modeled below in EnumConstantElementX?

If so - let's add comments to both of these classes to clarify (and
EnumConstantElement in elements.dart)

[Johnni Winther, 2016/04/12 07:26:29]

Yes. I'll update the comments.

+}
+
+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,
+        position.charOffset, position.charEnd);
+  }
 }
 
 abstract class MixinApplicationElementX extends BaseClassElementX
     with MixinApplicationElementCommon
     implements MixinApplicationElement {
   Link<ConstructorElement> constructors = new Link<ConstructorElement>();
 
   InterfaceType mixinType;
 
   MixinApplicationElementX(String name, Element enclosing, int id)
@@ skipping 285 matching lines @@
   /// The element whose node defines this element.
   ///
   /// For patched functions the defining element is the patch element found
   /// through [implementation] since its node define the implementation of the
   /// function. For patched classes the defining element is the origin element
   /// 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 => definingElement.hasTreeElements;
+  bool get hasResolvedAst {
+    return definingElement.hasNode && definingElement.hasTreeElements;
+  }
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }