Do not use the NamedMixinApplication node for anonymous mixins: otherwise, the [MixinApplicationEle…

sdk/lib/_internal/compiler/implementation/resolution/members.dart

 // Copyright (c) 2012, 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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element get currentElement;
   Set<Node> get superUses;
 
@@ skipping 3234 matching lines @@
     resolveTypeVariableBounds(node.typeParameters);
 
     // Setup the supertype for the element (if there is a cycle in the
     // class hierarchy, it has already been set to Object).
     if (element.supertype == null && node.superclass != null) {
       MixinApplication superMixin = node.superclass.asMixinApplication();
       if (superMixin != null) {
         DartType supertype = resolveSupertype(element, superMixin.superclass);
         Link<Node> link = superMixin.mixins.nodes;
         while (!link.isEmpty) {
-          supertype = applyMixin(supertype, resolveType(link.head));
+          supertype = applyMixin(supertype, resolveType(link.head), node);
           link = link.tail;
         }
         element.supertype = supertype;
       } else {
         element.supertype = resolveSupertype(element, node.superclass);
       }
     }
     // If the super type isn't specified, we provide a default.  The language
     // specifies [Object] but the backend can pick a specific 'implementation'
     // of Object - the JavaScript backend chooses between Object and
@@ skipping 41 matching lines @@
 
     InterfaceType type = element.computeType(compiler);
     scope = new TypeDeclarationScope(scope, element);
     resolveTypeVariableBounds(node.typeParameters);
 
     // Generate anonymous mixin application elements for the
     // intermediate mixin applications (excluding the last).
     DartType supertype = resolveSupertype(element, node.superclass);
     Link<Node> link = node.mixins.nodes;
     while (!link.tail.isEmpty) {
-      supertype = applyMixin(supertype, resolveType(link.head));
+      supertype = applyMixin(supertype, resolveType(link.head), link.head);
       link = link.tail;
     }
     doApplyMixinTo(element, supertype, resolveType(link.head));
     return element.computeType(compiler);
   }
 
-  DartType applyMixin(DartType supertype, DartType mixinType) {
+  DartType applyMixin(DartType supertype, DartType mixinType, Node node) {
     String superName = supertype.name.slowToString();
     String mixinName = mixinType.name.slowToString();
     ClassElement mixinApplication = new MixinApplicationElementX(
         new SourceString("${superName}_${mixinName}"),
         element.getCompilationUnit(),
         compiler.getNextFreeClassId(),
-        element.parseNode(compiler),
+        node,
         Modifiers.EMPTY);  // TODO(kasperl): Should this be abstract?
     doApplyMixinTo(mixinApplication, supertype, mixinType);
     mixinApplication.resolutionState = STATE_DONE;
     mixinApplication.supertypeLoadState = STATE_DONE;
     return mixinApplication.computeType(compiler);
   }
 
   bool isDefaultConstructor(FunctionElement constructor) {
     return constructor.name == const SourceString('') &&
         constructor.computeSignature(compiler).parameterCount == 0;
@@ skipping 728 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }