Add instantiate method on ParameterizedType and InterfaceType.

pkg/analyzer/lib/src/task/strong/checker.dart

 // Copyright (c) 2015, 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.
 
 // TODO(jmesserly): this was ported from package:dev_compiler, and needs to be
 // refactored to fit into analyzer.
 library analyzer.src.task.strong.checker;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 319 matching lines @@
     // Check that the expression is an Iterable.
     var expr = node.iterable;
     var iterableType = node.awaitKeyword != null
         ? typeProvider.streamType
         : typeProvider.iterableType;
     var loopVariable = node.identifier != null
         ? node.identifier
         : node.loopVariable?.identifier;
     if (loopVariable != null) {
       var iteratorType = loopVariable.staticType;
-      var checkedType = iterableType.substitute4([iteratorType]);
+      var checkedType = iterableType.instantiate([iteratorType]);
       checkAssignment(expr, checkedType);
     }
     node.visitChildren(this);
   }
 
   @override
   void visitForStatement(ForStatement node) {
     if (node.condition != null) {
       checkBoolean(node.condition);
     }
@@ skipping 290 matching lines @@
       // not match the return or yield type.  We should have already gotten an
       // analyzer error in this case.
       return;
     }
     InterfaceType futureType = typeProvider.futureType;
     DartType actualType = expression?.staticType;
     if (body.isAsynchronous &&
         !body.isGenerator &&
         actualType is InterfaceType &&
         actualType.element == futureType.element) {
-      type = futureType.substitute4([type]);
+      type = futureType.instantiate([type]);
     }
     // TODO(vsm): Enforce void or dynamic (to void?) when expression is null.
     if (expression != null) checkAssignment(expression, type);
   }
 
   void _checkRuntimeTypeCheck(AstNode node, TypeName typeName) {
     var type = getType(typeName);
     if (!rules.isGroundType(type)) {
       _recordMessage(new NonGroundTypeCheckInfo(node, type));
     }
@@ skipping 84 matching lines @@
         // Iterable<T> -> T
         expectedType = typeProvider.iterableType;
       } else {
         // T -> T
         return type;
       }
     }
     if (yieldStar) {
       if (type.isDynamic) {
         // Ensure it's at least a Stream / Iterable.
-        return expectedType.substitute4([typeProvider.dynamicType]);
+        return expectedType.instantiate([typeProvider.dynamicType]);
       } else {
         // Analyzer will provide a separate error if expected type
         // is not compatible with type.
         return type;
       }
     }
     if (type.isDynamic) {
       return type;
     } else if (type is InterfaceType && type.element == expectedType.element) {
       return type.typeArguments[0];
@@ skipping 509 matching lines @@
     } while (!current.isObject && !visited.contains(current));
   }
 
   void _recordMessage(StaticInfo info) {
     if (info == null) return;
     var error = info.toAnalysisError();
     if (error.errorCode.errorSeverity == ErrorSeverity.ERROR) _failure = true;
     _reporter.onError(error);
   }
 }