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;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_constructors.dart';
@@ skipping 1528 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, variables,
@@ skipping 1167 matching lines @@
             '', // 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;
+}
+
+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 279 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);
   }
 }