Add synthetic type variables to unnamed mixin applications.

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;
   Setlet<Node> get superUses;
 
@@ skipping 3806 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, checkMixinType(link.head), link.head);
+          supertype = applyMixin(supertype, checkMixinType(link.head), link.head);

[karlklose, 2013/11/28 15:04:16]

Long line.

[Johnni Winther, 2013/12/03 15:57:38]

Done.

           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 75 matching lines @@
       supertype = applyMixin(supertype, checkMixinType(link.head), link.head);
       link = link.tail;
     }
     doApplyMixinTo(element, supertype, checkMixinType(link.head));
     return element.computeType(compiler);
   }
 
   DartType applyMixin(DartType supertype, DartType mixinType, Node node) {
     String superName = supertype.name;
     String mixinName = mixinType.name;
-    ClassElement mixinApplication = new MixinApplicationElementX(
+    MixinApplicationElementX mixinApplication = new MixinApplicationElementX(

[karlklose, 2013/11/28 15:04:16]

Do you need the implementation (X) class here?

[Johnni Winther, 2013/12/03 15:57:38]

Needed to call computeThisAndRawType.

         "${superName}+${mixinName}",
         element.getCompilationUnit(),
         compiler.getNextFreeClassId(),
         node,
         Modifiers.EMPTY);  // TODO(kasperl): Should this be abstract?
+    // Create synthetic type variables for the mixin application.
+    LinkBuilder<DartType> typeVariablesBuilder = new LinkBuilder<DartType>();
+    element.typeVariables.forEach((TypeVariableType type) {
+      TypeVariableElementX typeVariableElement = new TypeVariableElementX(
+          type.name, mixinApplication, type.element.parseNode(compiler));
+      TypeVariableType typeVariable = new TypeVariableType(typeVariableElement);
+      typeVariablesBuilder.addLast(typeVariable);
+    });
+    Link<DartType> typeVariables = typeVariablesBuilder.toLink();
+    // Setup bounds on the synthetic type variables.
+    Link<DartType> link = typeVariables;
+    element.typeVariables.forEach((TypeVariableType type) {
+      TypeVariableType typeVariable = link.head;
+      TypeVariableElement typeVariableElement = typeVariable.element;
+      typeVariableElement.type = typeVariable;
+      typeVariableElement.bound =
+          type.element.bound.subst(typeVariables, element.typeVariables);
+      link = link.tail;
+    });
+    // Setup this and raw type for the mixin application.
+    mixinApplication.computeThisAndRawType(compiler, typeVariables);
+    // Substitute in synthetic type variables in super and mixin types.
+    supertype = supertype.subst(typeVariables, element.typeVariables);
+    mixinType = mixinType.subst(typeVariables, element.typeVariables);
+
     doApplyMixinTo(mixinApplication, supertype, mixinType);
     mixinApplication.resolutionState = STATE_DONE;
     mixinApplication.supertypeLoadState = STATE_DONE;
-    return mixinApplication.computeType(compiler);
+    // Replace the synthetic type variables by the original type variables in
+    // the returning type (which should be the type actually extended).

[karlklose, 2013/11/28 15:04:16]

'returning type' -> 'returned type'?

[Johnni Winther, 2013/12/03 15:57:38]

Done.

+    InterfaceType mixinThisType = mixinApplication.computeType(compiler);
+    return mixinThisType.subst(element.typeVariables,
+                               mixinThisType.typeArguments);
   }
 
   bool isDefaultConstructor(FunctionElement constructor) {
     return constructor.name == '' &&
         constructor.computeSignature(compiler).parameterCount == 0;
   }
 
   FunctionElement createForwardingConstructor(FunctionElement target,
                                               ClassElement enclosing) {
     return new SynthesizedConstructorElementX(
@@ skipping 176 matching lines @@
            interfaces = interfaces.tail) {
         addAllSupertypes(allSupertypes, interfaces.head);
       }
       allSupertypes.add(compiler, cls.computeType(compiler));
       cls.allSupertypesAndSelf = allSupertypes.toTypeSet();
     } else {
       assert(identical(cls, compiler.objectClass));
       cls.allSupertypesAndSelf =
           new OrderedTypeSet.singleton(cls.computeType(compiler));
     }
- }
+  }
 
   /**
    * Adds [type] and all supertypes of [type] to [allSupertypes] while
    * substituting type variables.
    */
   void addAllSupertypes(OrderedTypeSetBuilder allSupertypes,
                         InterfaceType type) {
     Link<DartType> typeArguments = type.typeArguments;
     ClassElement classElement = type.element;
     Link<DartType> typeVariables = classElement.typeVariables;
@@ skipping 599 matching lines @@
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }
 
 /// Looks up [name] in [scope] and unwraps the result.
 Element lookupInScope(Compiler compiler, Node node,
                       Scope scope, String name) {
   return Elements.unwrap(scope.lookup(name), compiler, node);
 }