Make NamedMixinApplicationElementX and EnumClassElementX implement DeclarationSite.

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 27 matching lines @@
 import '../tokens/token_constants.dart' as Tokens show
     EOF_TOKEN;
 import '../tree/tree.dart';
 import '../util/util.dart';
 
 import 'common.dart';
 import 'elements.dart';
 import 'visitor.dart' show
     ElementVisitor;
 
+/// Object that identifies a declaration site.
+///
+/// For most elements, this is the element itself, but for variable declarations
+/// where multi-declarations like `var a, b, c` are allowed, the declaration
+/// site is a separate object.
+// TODO(johnniwinther): Add [beginToken] and [endToken] getters.
 abstract class DeclarationSite {
 }
 
 abstract class ElementX extends Element with ElementCommon {
   static int elementHashCode = 0;
 
   final String name;
   final ElementKind kind;
   final Element enclosingElement;
   final int hashCode = ++elementHashCode;
@@ skipping 2725 matching lines @@
     if (origin != null) {
       return 'patch ${super.toString()}';
     } else if (patch != null) {
       return 'origin ${super.toString()}';
     } else {
       return super.toString();
     }
   }
 }
 
-class EnumClassElementX extends ClassElementX implements EnumClassElement {
+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;
 
   @override
@@ skipping 16 matching lines @@
     assert(invariant(this, _enumValues != null,
         message: "enumValues has not been computed for $this."));
     return _enumValues;
   }
 
   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;
 }
 
 class EnumConstructorElementX extends ConstructorElementX {
   final FunctionExpression node;
 
   EnumConstructorElementX(EnumClassElementX enumClass,
                           Modifiers modifiers,
                           this.node)
       : super('', // Name.
               ElementKind.GENERATIVE_CONSTRUCTOR,
@@ skipping 40 matching lines @@
                     VariableList variableList,
                     Node definition,
                     [Expression initializer])
       : super(name, enumClass, variableList) {
     definitionsCache = new VariableDefinitions(null,
         variableList.modifiers, new NodeList.singleton(definition));
     initializerCache = initializer;
   }
 }
 
-class MixinApplicationElementX extends BaseClassElementX
+abstract class MixinApplicationElementX extends BaseClassElementX
     implements MixinApplicationElement {
-  final Node node;
-  final Modifiers modifiers;
 
   Link<ConstructorElement> constructors = new Link<ConstructorElement>();
 
   InterfaceType mixinType;
 
-  MixinApplicationElementX(String name, Element enclosing, int id,
-                           this.node, this.modifiers)
+  MixinApplicationElementX(String name, Element enclosing, int id)
       : super(name, enclosing, id, STATE_NOT_STARTED);
 
   ClassElement get mixin => mixinType != null ? mixinType.element : null;
 
   bool get isMixinApplication => true;
   bool get isUnnamedMixinApplication => node is! NamedMixinApplication;
   bool get hasConstructor => !constructors.isEmpty;
   bool get hasLocalScopeMembers => !constructors.isEmpty;
 
   get patch => null;
@@ skipping 56 matching lines @@
           "creation.");
     }
     return createTypeVariables(named.typeParameters);
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitMixinApplicationElement(this, arg);
   }
 }
 
+class NamedMixinApplicationElementX extends MixinApplicationElementX
+    implements DeclarationSite {
+  final NamedMixinApplication node;
+
+  NamedMixinApplicationElementX(
+      String name,
+      CompilationUnitElement enclosing,
+      int id,
+      this.node)
+      : super(name, enclosing, id);
+
+  Modifiers get modifiers => node.modifiers;
+
+  DeclarationSite get declarationSite => this;
+}
+
+class UnnamedMixinApplicationElementX extends MixinApplicationElementX {
+  final Node node;
+
+  UnnamedMixinApplicationElementX(
+      String name,
+      CompilationUnitElement enclosing,
+      int id,
+      this.node)
+      : super(name, enclosing, id);
+
+  bool get isAbstract => true;
+}
+
 class LabelDefinitionX implements LabelDefinition {
   final Label label;
   final String labelName;
   final JumpTarget target;
   bool isBreakTarget = false;
   bool isContinueTarget = false;
 
   LabelDefinitionX(Label label, String labelName, this.target)
       : this.label = label,
         this.labelName = labelName;
@@ skipping 203 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }