Add ElementX.declarationSite.

dart/sdk/lib/_internal/compiler/implementation/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 'elements.dart';
 import '../helpers/helpers.dart';  // Included for debug helpers.
 import '../tree/tree.dart';
 import '../util/util.dart';
@@ skipping 20 matching lines @@
 
 import '../scanner/scannerlib.dart' show
     EOF_TOKEN,
     ErrorToken,
     Token;
 
 import '../ordered_typeset.dart' show OrderedTypeSet;
 
 import 'visitor.dart' show ElementVisitor;
 
+abstract class DeclarationSite {
+}
+
 abstract class ElementX extends Element {
   static int elementHashCode = 0;
 
   final String name;
   final ElementKind kind;
   final Element enclosingElement;
   final int hashCode = ++elementHashCode;
   Link<MetadataAnnotation> metadata = const Link<MetadataAnnotation>();
 
   ElementX(this.name, this.kind, this.enclosingElement) {
@@ skipping 203 matching lines @@
 
   bool get hasTreeElements => analyzableElement.hasTreeElements;
 
   TreeElements get treeElements => analyzableElement.treeElements;
 
   AnalyzableElement get analyzableElement {
     Element element = outermostEnclosingMemberOrTopLevel;
     if (element.isAbstractField || element.isPrefix) return element.library;
     return element;
   }
+
+  DeclarationSite get declarationSite => null;
 }
 
 class ErroneousElementX extends ElementX implements ErroneousElement {
   final MessageKind messageKind;
   final Map messageArguments;
 
   ErroneousElementX(this.messageKind, this.messageArguments,
                     String name, Element enclosing)
       : super(name, ElementKind.ERROR, enclosing);
 
@@ skipping 799 matching lines @@
 
   accept(ElementVisitor visitor) => visitor.visitTypedefElement(this);
 
   // A typedef cannot be patched therefore defines itself.
   AstElement get definingElement => this;
 }
 
 // This class holds common information for a list of variable or field
 // declarations. It contains the node, and the type. A [VariableElementX]
 // forwards its [computeType] and [parseNode] methods to this class.
-class VariableList {
+class VariableList implements DeclarationSite {
   VariableDefinitions definitions;
   DartType type;
   final Modifiers modifiers;
   Link<MetadataAnnotation> metadata = const Link<MetadataAnnotation>();
 
   VariableList(Modifiers this.modifiers);
 
   VariableList.node(VariableDefinitions node, this.type)
       : this.definitions = node,
         this.modifiers = node.modifiers {
@@ skipping 108 matching lines @@
     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) => visitor.visitVariableElement(this);
+
+  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);
@@ skipping 1472 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }