Add instantiate method on ParameterizedType and InterfaceType.

pkg/analyzer/test/generated/resolver_test.dart

 // Copyright (c) 2014, 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 analyzer.test.generated.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 219 matching lines @@
       futureElement.constructors = <ConstructorElement>[futureConstructor];
       //   Future then(onValue(T value), { Function onError });
       TypeDefiningElement futureThenR = DynamicElementImpl.instance;
       if (context.analysisOptions.strongMode) {
         futureThenR = ElementFactory.typeParameterWithType('R');
       }
       FunctionElementImpl thenOnValue = ElementFactory.functionElement3(
           'onValue', futureThenR, [futureElement.typeParameters[0]], null);
       thenOnValue.synthetic = true;
 
-      DartType futureRType = futureElement.type.substitute4([futureThenR.type]);
+      DartType futureRType = futureElement.type.instantiate([futureThenR.type]);
       MethodElementImpl thenMethod = ElementFactory
           .methodElementWithParameters(futureElement, "then", futureRType, [
         ElementFactory.requiredParameter2("onValue", thenOnValue.type),
         ElementFactory.namedParameter2("onError", provider.functionType)
       ]);
       if (!futureThenR.type.isDynamic) {
         thenMethod.typeParameters = [futureThenR];
       }
       thenOnValue.enclosingElement = thenMethod;
       thenOnValue.type = new FunctionTypeImpl(thenOnValue);
@@ skipping 13 matching lines @@
       // StreamSubscription
       ClassElementImpl streamSubscriptionElement =
           ElementFactory.classElement2("StreamSubscription", ["T"]);
       // Stream
       ClassElementImpl streamElement =
           ElementFactory.classElement2("Stream", ["T"]);
       streamElement.constructors = <ConstructorElement>[
         ElementFactory.constructorElement2(streamElement, null)
       ];
       DartType returnType = streamSubscriptionElement.type
-          .substitute4(streamElement.type.typeArguments);
+          .instantiate(streamElement.type.typeArguments);
       FunctionElementImpl listenOnData = ElementFactory.functionElement3(
           'onData',
           VoidTypeImpl.instance.element,
           <TypeDefiningElement>[streamElement.typeParameters[0]],
           null);
       listenOnData.synthetic = true;
       List<DartType> parameterTypes = <DartType>[listenOnData.type,];
       // TODO(brianwilkerson) This is missing the optional parameters.
       MethodElementImpl listenMethod =
           ElementFactory.methodElement('listen', returnType, parameterTypes);
@@ skipping 10302 matching lines @@
     super.setUp();
     _listener = new GatheringErrorListener();
     _analyzer = _createAnalyzer();
   }
 
   void test_flatten_derived() {
     // class Derived<T> extends Future<T> { ... }
     ClassElementImpl derivedClass =
         ElementFactory.classElement2('Derived', ['T']);
     derivedClass.supertype = _typeProvider.futureType
-        .substitute4([derivedClass.typeParameters[0].type]);
+        .instantiate([derivedClass.typeParameters[0].type]);
     InterfaceType intType = _typeProvider.intType;
     DartType dynamicType = _typeProvider.dynamicType;
-    InterfaceType derivedIntType = derivedClass.type.substitute4([intType]);
+    InterfaceType derivedIntType = derivedClass.type.instantiate([intType]);
     // flatten(Derived) = dynamic
     InterfaceType derivedDynamicType =
-        derivedClass.type.substitute4([dynamicType]);
+        derivedClass.type.instantiate([dynamicType]);
     expect(_flatten(derivedDynamicType), dynamicType);
     // flatten(Derived<int>) = int
     expect(_flatten(derivedIntType), intType);
     // flatten(Derived<Derived>) = Derived
-    expect(_flatten(derivedClass.type.substitute4([derivedDynamicType])),
+    expect(_flatten(derivedClass.type.instantiate([derivedDynamicType])),
         derivedDynamicType);
     // flatten(Derived<Derived<int>>) = Derived<int>
-    expect(_flatten(derivedClass.type.substitute4([derivedIntType])),
+    expect(_flatten(derivedClass.type.instantiate([derivedIntType])),
         derivedIntType);
   }
 
   void test_flatten_inhibit_recursion() {
     // class A extends B
     // class B extends A
     ClassElementImpl classA = ElementFactory.classElement2('A', []);
     ClassElementImpl classB = ElementFactory.classElement2('B', []);
     classA.supertype = classB.type;
     classB.supertype = classA.type;
     // flatten(A) = A and flatten(B) = B, since neither class contains Future
     // in its class hierarchy.  Even though there is a loop in the class
     // hierarchy, flatten() should terminate.
     expect(_flatten(classA.type), classA.type);
     expect(_flatten(classB.type), classB.type);
   }
 
   void test_flatten_related_derived_types() {
     InterfaceType intType = _typeProvider.intType;
     InterfaceType numType = _typeProvider.numType;
     // class Derived<T> extends Future<T>
     ClassElementImpl derivedClass =
         ElementFactory.classElement2('Derived', ['T']);
     derivedClass.supertype = _typeProvider.futureType
-        .substitute4([derivedClass.typeParameters[0].type]);
+        .instantiate([derivedClass.typeParameters[0].type]);
     InterfaceType derivedType = derivedClass.type;
     // class A extends Derived<int> implements Derived<num> { ... }
     ClassElementImpl classA =
-        ElementFactory.classElement('A', derivedType.substitute4([intType]));
+        ElementFactory.classElement('A', derivedType.instantiate([intType]));
     classA.interfaces = <InterfaceType>[
-      derivedType.substitute4([numType])
+      derivedType.instantiate([numType])
     ];
     // class B extends Future<num> implements Future<int> { ... }
     ClassElementImpl classB =
-        ElementFactory.classElement('B', derivedType.substitute4([numType]));
+        ElementFactory.classElement('B', derivedType.instantiate([numType]));
     classB.interfaces = <InterfaceType>[
-      derivedType.substitute4([intType])
+      derivedType.instantiate([intType])
     ];
     // flatten(A) = flatten(B) = int, since int is more specific than num.
     // The code in flatten() that inhibits infinite recursion shouldn't be
     // fooled by the fact that Derived appears twice in the type hierarchy.
     expect(_flatten(classA.type), intType);
     expect(_flatten(classB.type), intType);
   }
 
   void test_flatten_related_types() {
     InterfaceType futureType = _typeProvider.futureType;
     InterfaceType intType = _typeProvider.intType;
     InterfaceType numType = _typeProvider.numType;
     // class A extends Future<int> implements Future<num> { ... }
     ClassElementImpl classA =
-        ElementFactory.classElement('A', futureType.substitute4([intType]));
+        ElementFactory.classElement('A', futureType.instantiate([intType]));
     classA.interfaces = <InterfaceType>[
-      futureType.substitute4([numType])
+      futureType.instantiate([numType])
     ];
     // class B extends Future<num> implements Future<int> { ... }
     ClassElementImpl classB =
-        ElementFactory.classElement('B', futureType.substitute4([numType]));
+        ElementFactory.classElement('B', futureType.instantiate([numType]));
     classB.interfaces = <InterfaceType>[
-      futureType.substitute4([intType])
+      futureType.instantiate([intType])
     ];
     // flatten(A) = flatten(B) = int, since int is more specific than num.
     expect(_flatten(classA.type), intType);
     expect(_flatten(classB.type), intType);
   }
 
   void test_flatten_simple() {
     InterfaceType intType = _typeProvider.intType;
     DartType dynamicType = _typeProvider.dynamicType;
     InterfaceType futureDynamicType = _typeProvider.futureDynamicType;
     InterfaceType futureIntType =
-        _typeProvider.futureType.substitute4([intType]);
+        _typeProvider.futureType.instantiate([intType]);
     InterfaceType futureFutureDynamicType =
-        _typeProvider.futureType.substitute4([futureDynamicType]);
+        _typeProvider.futureType.instantiate([futureDynamicType]);
     InterfaceType futureFutureIntType =
-        _typeProvider.futureType.substitute4([futureIntType]);
+        _typeProvider.futureType.instantiate([futureIntType]);
     // flatten(int) = int
     expect(_flatten(intType), intType);
     // flatten(dynamic) = dynamic
     expect(_flatten(dynamicType), dynamicType);
     // flatten(Future) = dynamic
     expect(_flatten(futureDynamicType), dynamicType);
     // flatten(Future<int>) = int
     expect(_flatten(futureIntType), intType);
     // flatten(Future<Future>) = dynamic
     expect(_flatten(futureFutureDynamicType), dynamicType);
     // flatten(Future<Future<int>>) = int
     expect(_flatten(futureFutureIntType), intType);
   }
 
   void test_flatten_unrelated_types() {
     InterfaceType futureType = _typeProvider.futureType;
     InterfaceType intType = _typeProvider.intType;
     InterfaceType stringType = _typeProvider.stringType;
     // class A extends Future<int> implements Future<String> { ... }
     ClassElementImpl classA =
-        ElementFactory.classElement('A', futureType.substitute4([intType]));
+        ElementFactory.classElement('A', futureType.instantiate([intType]));
     classA.interfaces = <InterfaceType>[
-      futureType.substitute4([stringType])
+      futureType.instantiate([stringType])
     ];
     // class B extends Future<String> implements Future<int> { ... }
     ClassElementImpl classB =
-        ElementFactory.classElement('B', futureType.substitute4([stringType]));
+        ElementFactory.classElement('B', futureType.instantiate([stringType]));
     classB.interfaces = <InterfaceType>[
-      futureType.substitute4([intType])
+      futureType.instantiate([intType])
     ];
     // flatten(A) = A and flatten(B) = B, since neither string nor int is more
     // specific than the other.
     expect(_flatten(classA.type), classA.type);
     expect(_flatten(classB.type), classB.type);
   }
 
   void test_visitAdjacentStrings() {
     // "a" "b"
     Expression node = AstFactory
@@ skipping 52 matching lines @@
     Expression node = AstFactory.assignmentExpression(
         _resolvedVariable(intType, "i"), TokenType.EQ, _resolvedInteger(0));
     expect(_analyze(node), same(intType));
     _listener.assertNoErrors();
   }
 
   void test_visitAwaitExpression_flattened() {
     // await e, where e has type Future<Future<int>>
     InterfaceType intType = _typeProvider.intType;
     InterfaceType futureIntType =
-        _typeProvider.futureType.substitute4(<DartType>[intType]);
+        _typeProvider.futureType.instantiate(<DartType>[intType]);
     InterfaceType futureFutureIntType =
-        _typeProvider.futureType.substitute4(<DartType>[futureIntType]);
+        _typeProvider.futureType.instantiate(<DartType>[futureIntType]);
     Expression node =
         AstFactory.awaitExpression(_resolvedVariable(futureFutureIntType, 'e'));
     expect(_analyze(node), same(intType));
     _listener.assertNoErrors();
   }
 
   void test_visitAwaitExpression_simple() {
     // await e, where e has type Future<int>
     InterfaceType intType = _typeProvider.intType;
     InterfaceType futureIntType =
-        _typeProvider.futureType.substitute4(<DartType>[intType]);
+        _typeProvider.futureType.instantiate(<DartType>[intType]);
     Expression node =
         AstFactory.awaitExpression(_resolvedVariable(futureIntType, 'e'));
     expect(_analyze(node), same(intType));
     _listener.assertNoErrors();
   }
 
   void test_visitBinaryExpression_equals() {
     // 2 == 3
     Expression node = AstFactory.binaryExpression(
         _resolvedInteger(2), TokenType.EQ_EQ, _resolvedInteger(3));
@@ skipping 175 matching lines @@
     DartType resultType = _analyze(node);
     _assertFunctionType(
         _typeProvider.futureDynamicType, null, null, null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_async_expression() {
     // () async => e, where e has type int
     InterfaceType intType = _typeProvider.intType;
     InterfaceType futureIntType =
-        _typeProvider.futureType.substitute4(<DartType>[intType]);
+        _typeProvider.futureType.instantiate(<DartType>[intType]);
     Expression expression = _resolvedVariable(intType, 'e');
     ExpressionFunctionBody body = AstFactory.expressionFunctionBody(expression);
     body.keyword = TokenFactory.tokenFromString('async');
     FunctionExpression node =
         _resolvedFunctionExpression(AstFactory.formalParameterList([]), body);
     DartType resultType = _analyze(node);
     _assertFunctionType(futureIntType, null, null, null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_async_expression_flatten() {
     // () async => e, where e has type Future<int>
     InterfaceType intType = _typeProvider.intType;
     InterfaceType futureIntType =
-        _typeProvider.futureType.substitute4(<DartType>[intType]);
+        _typeProvider.futureType.instantiate(<DartType>[intType]);
     Expression expression = _resolvedVariable(futureIntType, 'e');
     ExpressionFunctionBody body = AstFactory.expressionFunctionBody(expression);
     body.keyword = TokenFactory.tokenFromString('async');
     FunctionExpression node =
         _resolvedFunctionExpression(AstFactory.formalParameterList([]), body);
     DartType resultType = _analyze(node);
     _assertFunctionType(futureIntType, null, null, null, resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitFunctionExpression_async_expression_flatten_twice() {
     // () async => e, where e has type Future<Future<int>>
     InterfaceType intType = _typeProvider.intType;
     InterfaceType futureIntType =
-        _typeProvider.futureType.substitute4(<DartType>[intType]);
+        _typeProvider.futureType.instantiate(<DartType>[intType]);
     InterfaceType futureFutureIntType =
-        _typeProvider.futureType.substitute4(<DartType>[futureIntType]);
+        _typeProvider.futureType.instantiate(<DartType>[futureIntType]);
     Expression expression = _resolvedVariable(futureFutureIntType, 'e');
     ExpressionFunctionBody body = AstFactory.expressionFunctionBody(expression);
     body.keyword = TokenFactory.tokenFromString('async');
     FunctionExpression node =
         _resolvedFunctionExpression(AstFactory.formalParameterList([]), body);
     DartType resultType = _analyze(node);
     _assertFunctionType(futureIntType, null, null, null, resultType);
     _listener.assertNoErrors();
   }
 
@@ skipping 240 matching lines @@
 
   void test_visitIndexExpression_typeParameters() {
     // List<int> list = ...
     // list[0]
     InterfaceType intType = _typeProvider.intType;
     InterfaceType listType = _typeProvider.listType;
     // (int) -> E
     MethodElement methodElement = getMethod(listType, "[]");
     // "list" has type List<int>
     SimpleIdentifier identifier = AstFactory.identifier3("list");
-    InterfaceType listOfIntType = listType.substitute4(<DartType>[intType]);
+    InterfaceType listOfIntType = listType.instantiate(<DartType>[intType]);
     identifier.staticType = listOfIntType;
     // list[0] has MethodElement element (int) -> E
     IndexExpression indexExpression =
         AstFactory.indexExpression(identifier, AstFactory.integer(0));
     MethodElement indexMethod = MethodMember.from(methodElement, listOfIntType);
     indexExpression.staticElement = indexMethod;
     // analyze and assert result of the index expression
     expect(_analyze(indexExpression), same(intType));
     _listener.assertNoErrors();
   }
 
   void test_visitIndexExpression_typeParameters_inSetterContext() {
     // List<int> list = ...
     // list[0] = 0;
     InterfaceType intType = _typeProvider.intType;
     InterfaceType listType = _typeProvider.listType;
     // (int, E) -> void
     MethodElement methodElement = getMethod(listType, "[]=");
     // "list" has type List<int>
     SimpleIdentifier identifier = AstFactory.identifier3("list");
-    InterfaceType listOfIntType = listType.substitute4(<DartType>[intType]);
+    InterfaceType listOfIntType = listType.instantiate(<DartType>[intType]);
     identifier.staticType = listOfIntType;
     // list[0] has MethodElement element (int) -> E
     IndexExpression indexExpression =
         AstFactory.indexExpression(identifier, AstFactory.integer(0));
     MethodElement indexMethod = MethodMember.from(methodElement, listOfIntType);
     indexExpression.staticElement = indexMethod;
     // list[0] should be in a setter context
     AstFactory.assignmentExpression(
         indexExpression, TokenType.EQ, AstFactory.integer(0));
     // analyze and assert result of the index expression
@@ skipping 25 matching lines @@
     ClassElementImpl elementC = ElementFactory.classElement2("C", ["E"]);
     ClassElementImpl elementI = ElementFactory.classElement2("I");
     ConstructorElementImpl constructor =
         ElementFactory.constructorElement2(elementC, null);
     elementC.constructors = <ConstructorElement>[constructor];
     constructor.returnType = elementC.type;
     FunctionTypeImpl constructorType = new FunctionTypeImpl(constructor);
     constructor.type = constructorType;
     TypeName typeName =
         AstFactory.typeName(elementC, [AstFactory.typeName(elementI)]);
-    typeName.type = elementC.type.substitute4(<DartType>[elementI.type]);
+    typeName.type = elementC.type.instantiate(<DartType>[elementI.type]);
     InstanceCreationExpression node =
         AstFactory.instanceCreationExpression2(null, typeName);
     node.staticElement = constructor;
     InterfaceType interfaceType = _analyze(node) as InterfaceType;
     List<DartType> typeArgs = interfaceType.typeArguments;
     expect(typeArgs.length, 1);
     expect(typeArgs[0], elementI.type);
     _listener.assertNoErrors();
   }
 
@@ skipping 35 matching lines @@
     expect(_analyze(node), same(_typeProvider.boolType));
     _listener.assertNoErrors();
   }
 
   void test_visitListLiteral_empty() {
     // []
     Expression node = AstFactory.listLiteral();
     DartType resultType = _analyze(node);
     _assertType2(
         _typeProvider.listType
-            .substitute4(<DartType>[_typeProvider.dynamicType]),
+            .instantiate(<DartType>[_typeProvider.dynamicType]),
         resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitListLiteral_nonEmpty() {
     // [0]
     Expression node = AstFactory.listLiteral([_resolvedInteger(0)]);
     DartType resultType = _analyze(node);
     _assertType2(
         _typeProvider.listType
-            .substitute4(<DartType>[_typeProvider.dynamicType]),
+            .instantiate(<DartType>[_typeProvider.dynamicType]),
         resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMapLiteral_empty() {
     // {}
     Expression node = AstFactory.mapLiteral2();
     DartType resultType = _analyze(node);
     _assertType2(
-        _typeProvider.mapType.substitute4(
+        _typeProvider.mapType.instantiate(
             <DartType>[_typeProvider.dynamicType, _typeProvider.dynamicType]),
         resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMapLiteral_nonEmpty() {
     // {"k" : 0}
     Expression node = AstFactory
         .mapLiteral2([AstFactory.mapLiteralEntry("k", _resolvedInteger(0))]);
     DartType resultType = _analyze(node);
     _assertType2(
-        _typeProvider.mapType.substitute4(
+        _typeProvider.mapType.instantiate(
             <DartType>[_typeProvider.dynamicType, _typeProvider.dynamicType]),
         resultType);
     _listener.assertNoErrors();
   }
 
   void test_visitMethodInvocation_then() {
     // then()
     Expression node = AstFactory.methodInvocation(null, "then");
     _analyze(node);
     _listener.assertNoErrors();
@@ skipping 2301 matching lines @@
   var x = cOfString.f/*<int>*/('hi');
 }
 ''');
     MethodInvocation f = _findIdentifier('f/*<int>*/').parent;
     FunctionType ft = f.staticInvokeType;
     expect(ft.toString(), '(String) → List<int>');
     expect('${ft.typeArguments}/${ft.typeParameters}', '[String, int]/[E, T]');
 
     SimpleIdentifier x = _findIdentifier('x');
     expect(x.staticType,
-        typeProvider.listType.substitute4([typeProvider.intType]));
+        typeProvider.listType.instantiate([typeProvider.intType]));
   }
 
   void test_genericMethod_functionExpressionInvocation_explicit() {
     _resolveTestUnit(r'''
 class C<E> {
   /*=T*/ f/*<T>*/(/*=T*/ e) => null;
   static /*=T*/ g/*<T>*/(/*=T*/ e) => null;
   static final h = g;
 }
 
@@ skipping 1469 matching lines @@
   await for (var e in stream) {
     e;
   }
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     InterfaceType listOfStringType =
-        typeProvider.listType.substitute4([typeProvider.stringType]);
+        typeProvider.listType.instantiate([typeProvider.stringType]);
     // in the declaration
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "e in", (node) => node is SimpleIdentifier);
       expect(identifier.propagatedType, equals(listOfStringType));
     }
     // in the loop body
     {
       SimpleIdentifier identifier = EngineTestCase.findNode(
           unit, code, "e;", (node) => node is SimpleIdentifier);
@@ skipping 2124 matching lines @@
 
   void _resolveTestUnit(String code) {
     testCode = code;
     testSource = addSource(testCode);
     LibraryElement library = resolve2(testSource);
     assertNoErrors(testSource);
     verify([testSource]);
     testUnit = resolveCompilationUnit(testSource, library);
   }
 }