Remove AST-hack for multi-field declarations.

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/names.dart' show Identifiers;
 import '../common/resolution.dart' show Resolution, ParsingContext;
 import '../compiler.dart' show Compiler;
@@ skipping 1455 matching lines @@
     constantCache = value;
   }
 }
 
 abstract class VariableElementX extends ElementX
     with AstElementMixin, ConstantVariableMixin
     implements VariableElement {
   final Token token;
   final VariableList variables;
   VariableDefinitions definitionsCache;
+  Expression definitionCache;
   Expression initializerCache;
 
   Modifiers get modifiers => variables.modifiers;
 
   VariableElementX(String name, ElementKind kind, Element enclosingElement,
       VariableList variables, this.token)
       : this.variables = variables,
         super(name, kind, enclosingElement);
 
   // TODO(johnniwinther): Ensure that the [TreeElements] for this variable hold
@@ skipping 12 matching lines @@
   AstElement get definingElement => this;
 
   bool get hasNode => definitionsCache != null;
 
   VariableDefinitions get node {
     assert(invariant(this, definitionsCache != null,
         message: "Node has not been computed for $this."));
     return definitionsCache;
   }
 
+  /// Returns the node that defines this field.
+  ///
+  /// For instance in `var a, b = true`, the definitions nodes for fields 'a'
+  /// and 'b' are the nodes for `a` and `b = true`, respectively.
+  Expression get definition {
+    assert(invariant(this, definitionCache != null,
+        message: "Definition node has not been computed for $this."));
+    return definitionCache;
+  }
+
   Expression get initializer {
     assert(invariant(this, definitionsCache != null,
         message: "Initializer has not been computed for $this."));
     return initializerCache;
   }
 
   Node parseNode(ParsingContext parsing) {
     if (definitionsCache != null) return definitionsCache;
 
     VariableDefinitions definitions = variables.parseNode(this, parsing);
     createDefinitions(definitions);
     return definitionsCache;
   }
 
   void createDefinitions(VariableDefinitions definitions) {
     assert(invariant(this, definitionsCache == null,
         message: "VariableDefinitions has already been computed for $this."));
-    Expression node;
-    int count = 0;
     for (Link<Node> link = definitions.definitions.nodes;
         !link.isEmpty;
         link = link.tail) {
       Expression initializedIdentifier = link.head;
       Identifier identifier = initializedIdentifier.asIdentifier();
       if (identifier == null) {
         SendSet sendSet = initializedIdentifier.asSendSet();
         identifier = sendSet.selector.asIdentifier();
         if (identical(name, identifier.source)) {
-          node = initializedIdentifier;
+          definitionCache = initializedIdentifier;
           initializerCache = sendSet.arguments.first;
         }
       } else if (identical(name, identifier.source)) {
-        node = initializedIdentifier;
+        definitionCache = initializedIdentifier;
       }
-      count++;
     }
-    invariant(definitions, node != null, message: "Could not find '$name'.");
-    if (count == 1) {
-      definitionsCache = definitions;
-    } else {
-      // Create a [VariableDefinitions] node for the single definition of
-      // [node].
-      definitionsCache = new VariableDefinitions(
-          definitions.type,
-          definitions.modifiers,
-          new NodeList(
-              definitions.definitions.beginToken,
-              const Link<Node>().prepend(node),
-              definitions.definitions.endToken));
-    }
+    invariant(definitions, definitionCache != null,
+        message: "Could not find '$name'.");
+    definitionsCache = definitions;
   }
 
   DartType computeType(Resolution resolution) {
     if (variables.type != null) return variables.type;
     // Call [parseNode] to ensure that [definitionsCache] and [initializerCache]
     // are set as a consequence of calling [computeType].
     parseNode(resolution.parsingContext);
     return variables.computeType(this, resolution);
   }
 
@@ skipping 84 matching lines @@
   bool get hasResolvedAst => false;
 
   ResolvedAst get resolvedAst {
     throw new UnsupportedError("resolvedAst");
   }
 
   DynamicType get type => const DynamicType();
 
   Token get token => node.getBeginToken();
 
+  get definitionCache {
+    throw new UnsupportedError("definitionCache");
+  }
+
+  set definitionCache(_) {
+    throw new UnsupportedError("definitionCache=");
+  }
+
   get initializerCache {
     throw new UnsupportedError("initializerCache");
   }
 
   set initializerCache(_) {
     throw new UnsupportedError("initializerCache=");
   }
 
   void createDefinitions(VariableDefinitions definitions) {
     throw new UnsupportedError("createDefinitions");
   }
 
   get initializer => null;
 
+  get definition => null;
+
   bool get isMalformed => true;
 
   get nestedClosures {
     throw new UnsupportedError("nestedClosures");
   }
 
   set nestedClosures(_) {
     throw new UnsupportedError("nestedClosures=");
   }
 
@@ skipping 1323 matching lines @@
 ///  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;
+    definitionCache = definition;
   }
 
   @override
   SourceSpan get sourcePosition => enclosingClass.sourcePosition;
 }
 
 /// This element is used to encode the constant value in an enum class.
 ///
 /// For instance
 ///
@@ skipping 365 matching lines @@
       body = node.asFunctionExpression().body;
     }
     return new ParsedResolvedAst(
         declaration,
         node,
         body,
         definingElement.treeElements,
         definingElement.compilationUnit.script.resourceUri);
   }
 }