Revert "Compute correct constructor type for synthesized mixin constructors."

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 627 matching lines @@
     while (!seen.isEmpty) {
       FunctionElementX factory = seen.removeLast();
 
       TreeElements treeElements =
           compiler.enqueuer.resolution.getCachedElements(factory);
       FunctionExpression functionNode = factory.parseNode(compiler);
       Return redirectionNode = functionNode.body;
       InterfaceType factoryType =
           treeElements.getType(redirectionNode.expression);
 
-      targetType = targetType.substByContext(factoryType);
+      targetType = targetType.subst(factoryType.typeArguments,
+                                    factoryType.element.typeVariables);
       factory.redirectionTarget = target;
       factory.redirectionTargetType = targetType;
     }
   }
 
   /**
    * Load and resolve the supertypes of [cls].
    *
    * Warning: do not call this method directly. It should only be
    * called by [resolveClass] and [ClassSupertypeResolver].
@@ skipping 2071 matching lines @@
               node.selector, field.name, MessageKind.CANNOT_RESOLVE_GETTER);
           compiler.backend.registerThrowNoSuchMethod(mapping);
         }
       } else if (target.impliesType()) {
         setter = warnAndCreateErroneousElement(
             node.selector, target.name, MessageKind.ASSIGNING_TYPE);
         compiler.backend.registerThrowNoSuchMethod(mapping);
       } else if (target.modifiers.isFinal() ||
                  target.modifiers.isConst() ||
                  (target.isFunction() &&
-                  Elements.isStaticOrTopLevelFunction(target) &&
+                  Elements.isStaticOrTopLevelFunction(target) && 
                   !target.isSetter())) {
         if (target.isFunction()) {
           setter = warnAndCreateErroneousElement(
               node.selector, target.name, MessageKind.ASSIGNING_METHOD);
         } else {
           setter = warnAndCreateErroneousElement(
               node.selector, target.name, MessageKind.CANNOT_RESOLVE_SETTER);
         }
         compiler.backend.registerThrowNoSuchMethod(mapping);
       }
@@ skipping 1407 matching lines @@
           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;
     Link<DartType> supertypes = classElement.allSupertypes;
     assert(invariant(element, supertypes != null,
         message: "Supertypes not computed on $classElement "
                  "during resolution of $element"));
     while (!supertypes.isEmpty) {
       DartType supertype = supertypes.head;
-      allSupertypes.add(compiler, supertype.substByContext(type));
+      allSupertypes.add(compiler,
+                        supertype.subst(typeArguments, typeVariables));
       supertypes = supertypes.tail;
     }
   }
 
   isBlackListed(DartType type) {
     LibraryElement lib = element.getLibrary();
     return
       !identical(lib, compiler.coreLibrary) &&
       !identical(lib, compiler.jsHelperLibrary) &&
       !identical(lib, compiler.interceptorsLibrary) &&
@@ skipping 580 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);
 }