Substitution added to DartType

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 operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 1912 matching lines @@
     if (node.isRedirectingFactoryBody) {
       handleRedirectingFactoryBody(node);
     } else {
       visit(node.expression);
     }
   }
 
   void handleRedirectingFactoryBody(Return node) {
     Element redirectionTarget = resolveRedirectingFactory(node);
     var type = mapping.getType(node.expression);
-    if (type is InterfaceType && !type.arguments.isEmpty) {
+    if (type is InterfaceType && !type.typeArguments.isEmpty) {
       unimplemented(node.expression, 'type arguments on redirecting factory');
     }
     useElement(node.expression, redirectionTarget);
     assert(invariant(node, enclosingElement.isFactoryConstructor()));
     FunctionElement constructor = enclosingElement;
     if (constructor.modifiers.isConst() &&
         !redirectionTarget.modifiers.isConst()) {
       error(node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
     }
     // TODO(ahe): Check that this doesn't lead to a cycle.  For now,
@@ skipping 99 matching lines @@
     if (argument.element.isTypeVariable()) {
       // Register a dependency between the class where the type
       // variable is, and the annotation. If the annotation requires
       // runtime type information, then the class of the type variable
       // does too.
       compiler.world.registerRtiDependency(
           annotation.element,
           argument.element.enclosingElement);
     } else if (argument is InterfaceType) {
       InterfaceType type = argument;
-      type.arguments.forEach((DartType argument) {
+      type.typeArguments.forEach((DartType argument) {
         analyzeTypeArgument(type, argument);
       });
     }
   }
 
   DartType resolveTypeAnnotation(TypeAnnotation node) {
     // TODO(johnniwinther): Remove this together with the named arguments
     // on [TypeResolver.resolveTypeAnnotation].
     void checkAndUseType(TypeAnnotation annotation, DartType type) {
       useType(annotation, type);
       if (type != null &&
           identical(type.kind, TypeKind.TYPE_VARIABLE) &&
           enclosingElement.isInStaticMember()) {
         warning(annotation, MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
                 [type]);
       }
     }
 
     Function report = typeRequired ? error : warning;
     DartType type = typeResolver.resolveTypeAnnotation(
         node, scope, onFailure: report, whenResolved: checkAndUseType);
     if (type == null) return null;
     if (inCheckContext) {
       compiler.enqueuer.resolution.registerIsCheck(type);
     }
     if (typeRequired || inCheckContext) {
       if (type is InterfaceType) {
         InterfaceType itf = type;
-        itf.arguments.forEach((DartType argument) {
+        itf.typeArguments.forEach((DartType argument) {
           analyzeTypeArgument(type, argument);
         });
       }
       // TODO(ngeoffray): Also handle cases like:
       // 1) a is T
       // 2) T a (in checked mode).
     }
     return type;
   }
 
@@ skipping 1026 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }