Version 1.1.0-dev.5.9

dart/sdk/lib/_internal/compiler/implementation/dart_types.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.
 
 library dart_types;
 
 import 'dart:math' show min;
 
 import 'dart2jslib.dart' show Compiler, invariant, Script, Message;
 import 'elements/modelx.dart'
@@ skipping 42 matching lines @@
    * The notation is known from this lambda calculus rule:
    *
    *     (lambda x.e0)e1 -> [e1/x]e0.
    *
    * See [TypeVariableType] for a motivation for this method.
    *
    * Invariant: There must be the same number of [arguments] and [parameters].
    */
   DartType subst(Link<DartType> arguments, Link<DartType> parameters);
 
+  /// Performs the substitution of the type arguments of [type] for their
+  /// corresponding type variables in this type.
+  DartType substByContext(GenericType type) =>
+      subst(type.typeArguments, type.element.typeVariables);
+
   /**
    * Returns the unaliased type of this type.
    *
    * The unaliased type of a typedef'd type is the unaliased type to which its
    * name is bound. The unaliased version of any other type is the type itself.
    *
    * For example, the unaliased type of [: typedef A Func<A,B>(B b) :] is the
    * function type [: (B) -> A :] and the unaliased type of
    * [: Func<int,String> :] is the function type [: (String) -> int :].
    */
@@ skipping 717 matching lines @@
 
   TypeKind get kind => TypeKind.TYPEDEF;
 
   String get name => element.name;
 
   DartType unalias(Compiler compiler) {
     // TODO(ahe): This should be [ensureResolved].
     compiler.resolveTypedef(element);
     element.checkCyclicReference(compiler);
     DartType definition = element.alias.unalias(compiler);
-    TypedefType declaration = element.computeType(compiler);
-    return definition.subst(typeArguments, declaration.typeArguments);
+    return definition.substByContext(this);
   }
 
   int get hashCode => super.hashCode;
 
   TypedefType asRaw() => super.asRaw();
 
   accept(DartTypeVisitor visitor, var argument) {
     return visitor.visitTypedefType(this, argument);
   }
 }
@@ skipping 70 matching lines @@
           // TODO(johnniwinther): Add check of assignment to field with no
           // setter.
           FunctionType functionType =
               abstractFieldElement.getter.computeType(compiler);
           type = functionType.returnType;
         }
       } else {
         type = element.computeType(compiler);
       }
       if (!declarer.element.typeVariables.isEmpty) {
-        type = type.subst(declarer.typeArguments,
-                          declarer.element.typeVariables);
-        type = type.subst(receiver.typeArguments,
-                          receiver.element.typeVariables);
+        type = type.substByContext(declarer);
+        type = type.substByContext(receiver);
       }
       cachedType = type;
     }
     return cachedType;
   }
 
   String toString() {
     return '$receiver.${element.name}';
   }
 }
@@ skipping 392 matching lines @@
    * declared on [element]. Calls [checkTypeVariableBound] on each type
    * argument and bound.
    */
   void checkTypeVariableBounds(GenericType type,
                                CheckTypeVariableBound checkTypeVariableBound) {
     TypeDeclarationElement element = type.element;
     Link<DartType> typeArguments = type.typeArguments;
     Link<DartType> typeVariables = element.typeVariables;
     while (!typeVariables.isEmpty && !typeArguments.isEmpty) {
       TypeVariableType typeVariable = typeVariables.head;
-      DartType bound = typeVariable.element.bound.subst(
-          type.typeArguments, element.typeVariables);
+      DartType bound = typeVariable.element.bound.substByContext(type);
       DartType typeArgument = typeArguments.head;
       checkTypeVariableBound(type, typeArgument, typeVariable, bound);
       typeVariables = typeVariables.tail;
       typeArguments = typeArguments.tail;
     }
     assert(typeVariables.isEmpty && typeArguments.isEmpty);
   }
 
   /**
    * Helper method for performing substitution of a linked list of types.
@@ skipping 174 matching lines @@
   static List<DartType> sorted(Iterable<DartType> types) {
     return types.toList()..sort(compare);
   }
 
   /// Computes the least upper bound of two interface types [a] and [b].
   InterfaceType computeLeastUpperBoundInterfaces(InterfaceType a,
                                                  InterfaceType b) {
 
     /// Returns the set of supertypes of [type] at depth [depth].
     Set<DartType> getSupertypesAtDepth(InterfaceType type, int depth) {
-      ClassElement cls = type.element;
-      OrderedTypeSet types = cls.allSupertypesAndSelf;
-      Link<DartType> typeVariables = cls.typeVariables;
-      Link<DartType> typeArguments = type.typeArguments;
+      OrderedTypeSet types = type.element.allSupertypesAndSelf;
       Set<DartType> set = new Set<DartType>();
-      types.forEach(depth, (DartType type) {
-        set.add(type.subst(typeArguments, typeVariables));
+      types.forEach(depth, (DartType supertype) {
+        set.add(supertype.substByContext(type));
       });
       return set;
     }
 
     ClassElement aClass = a.element;
     ClassElement bClass = b.element;
     int maxCommonDepth = min(aClass.hierarchyDepth, bClass.hierarchyDepth);
     for (int depth = maxCommonDepth; depth >= 0; depth--) {
       Set<DartType> aTypeSet = getSupertypesAtDepth(a, depth);
       Set<DartType> bTypeSet = getSupertypesAtDepth(b, depth);
@@ skipping 232 matching lines @@
   }
 
   bool visitGenericType(GenericType type, DartType argument) {
     if (argument is GenericType) {
       if (type.element != argument.element) return false;
       return visitTypes(type.typeArguments, argument.typeArguments);
     }
     return false;
   }
 }