Implement super in mixins.

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';
 import '../constants/constructors.dart';
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../diagnostics/messages.dart' show MessageTemplate;
 import '../ordered_typeset.dart' show OrderedTypeSet;
 import '../resolution/class_members.dart' show ClassMemberMixin;
 import '../resolution/scope.dart'
-    show ClassScope, LibraryScope, Scope, TypeDeclarationScope;
+    show ClassScope, LibraryScope, MixinApplicationScope, NoScope, Scope,
+        TypeDeclarationScope;
 import '../resolution/resolution.dart' show AnalyzableElementX;
 import '../resolution/tree_elements.dart' show TreeElements;
 import '../resolution/typedefs.dart' show TypedefCyclicVisitor;
 import '../script.dart';
 import '../tokens/token.dart' show ErrorToken, Token;
 import '../tokens/token_constants.dart' as Tokens show EOF_TOKEN;
 import '../tree/tree.dart';
 import '../util/util.dart';
 
 import 'common.dart';
@@ skipping 1345 matching lines @@
   List<MetadataAnnotation> metadataInternal;
 
   VariableList(Modifiers this.modifiers);
 
   VariableList.node(VariableDefinitions node, this.type)
       : this.definitions = node,
         this.modifiers = node.modifiers {
     assert(modifiers != null);
   }
 
+  VariableList.internal(this.modifiers);
+
   Iterable<MetadataAnnotation> get metadata {
     return metadataInternal != null
         ? metadataInternal
         : const <MetadataAnnotation>[];
   }
 
   void set metadata(List<MetadataAnnotation> metadata) {
     if (metadata.isEmpty) {
       // For a multi declaration like:
       //
       //    @foo @bar var a, b, c
       //
       // the metadata list is reported through the declaration of `a`, and `b`
       // and `c` report an empty list of metadata.
       return;
     }
     assert(metadataInternal == null);
     metadataInternal = metadata;
   }
 
   VariableDefinitions parseNode(Element element, Parsing parsing) {
     return definitions;
   }
 
   DartType computeType(Element element, Resolution resolution) => type;
 
   bool get isMalformed => false;
+
+  VariableList copy() {
+    return new VariableList.internal(modifiers)
+        ..definitions = definitions
+        ..type = type
+        ..metadataInternal = metadataInternal;
+  }
 }
 
 abstract class ConstantVariableMixin implements VariableElement {
   ConstantExpression constantCache;
 
   ConstantExpression get constant {
     if (isPatch) {
       ConstantVariableMixin originVariable = origin;
       return originVariable.constant;
     }
@@ skipping 167 matching lines @@
 
   bool get isMalformed => variables.isMalformed;
 
   void reuseElement() {
     super.reuseElement();
     nestedClosures.clear();
   }
 
   FieldElementX copyWithEnclosing(Element enclosingElement) {
     return new FieldElementX(
-        new Identifier(token), enclosingElement, variables);
+        new Identifier(token), enclosingElement, variables.copy());
   }
 }
 
 /// A field that was synthesized to recover from a compile-time error.
 class ErroneousFieldElementX extends ElementX
     with ConstantVariableMixin
     implements FieldElementX {
   final VariableList variables;
 
   ErroneousFieldElementX(Identifier name, Element enclosingElement)
@@ skipping 1215 matching lines @@
   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>();
+  Link<ConstructorElement> constructors = const Link<ConstructorElement>();
+  Link<Element> members = const Link<Element>();
 
   InterfaceType mixinType;
 
   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;
   get origin => null;
 
   bool get hasNode => true;
 
   Token get position => node.getBeginToken();
 
   Node parseNode(Parsing parsing) => node;
 
   void addMember(Element element, DiagnosticReporter reporter) {
-    throw new UnsupportedError("Cannot add member to $this.");
+    members = members.prepend(element);
   }
 
   void addToScope(Element element, DiagnosticReporter reporter) {
     reporter.internalError(this, 'Cannot add to scope of $this.');
   }
 
   void addConstructor(FunctionElement constructor) {
     constructors = constructors.prepend(constructor);
   }
 
@@ skipping 10 matching lines @@
           node,
           "Type variables on unnamed mixin applications must be set on "
           "creation.");
     }
     return createTypeVariables(named.typeParameters);
   }
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitMixinApplicationElement(this, arg);
   }
+
+  @override
+  void forEachLocalMember(void f(Element member)) {
+    constructors.forEach(f);
+    members.forEach(f);
+  }
+
+  buildScope() {

[Johnni Winther, 2016/06/30 14:16:30]

Add @override and return type.

+    Scope parentScope = mixin?.buildScope();
+    if (parentScope == null) {
+      parentScope = new NoScope();
+    }
+    return new MixinApplicationScope(parentScope, this);
+  }
 }
 
 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;
+
+  bool get isUnnamedMixinApplication => false;
 }
 
 class UnnamedMixinApplicationElementX extends MixinApplicationElementX {
   final Node node;
 
   UnnamedMixinApplicationElementX(
       String name, CompilationUnitElement enclosing, int id, this.node)
       : super(name, enclosing, id);
 
   bool get isAbstract => true;
+
+  bool get isUnnamedMixinApplication => 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)
@@ skipping 205 matching lines @@
 
   bool get hasResolvedAst {
     return definingElement.hasNode && definingElement.hasTreeElements;
   }
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(
         declaration, definingElement.node, definingElement.treeElements);
   }
 }