dart2js cps: Support inlining constructors with type arguments.

pkg/compiler/lib/src/cps_ir/cps_ir_nodes.dart

 // Copyright (c) 2013, 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 dart2js.ir_nodes;
 
 import 'dart:collection';
 import 'cps_fragment.dart' show CpsFragment;
 import '../constants/values.dart' as values;
 import '../dart_types.dart' show DartType, InterfaceType, TypeVariableType;
 import '../elements/elements.dart';
@@ skipping 1417 matching lines @@
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {}
 }
 
 /// Creates an instance of a class and initializes its fields and runtime type
 /// information.
 class CreateInstance extends Primitive {
-  final ClassElement classElement;
+  final InterfaceType dartType;
 
   /// Initial values for the fields on the class.
   /// The order corresponds to the order of fields on the class.
   final List<Reference<Primitive>> arguments;
 
   /// The runtime type information structure which contains the type arguments.
   ///
   /// May be `null` to indicate that no type information is needed because the
   /// compiler determined that the type information for instances of this class
   /// is not needed at runtime.
   final List<Reference<Primitive>> typeInformation;
 
   final SourceInformation sourceInformation;
 
-  CreateInstance(this.classElement, List<Primitive> arguments,
+  ClassElement get classElement => dartType.element;
+
+  CreateInstance(this.dartType, List<Primitive> arguments,
       List<Primitive> typeInformation,
       this.sourceInformation)
       : this.arguments = _referenceList(arguments),
         this.typeInformation = _referenceList(typeInformation);
 
   accept(Visitor visitor) => visitor.visitCreateInstance(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
-  toString() => 'CreateInstance($classElement)';
+  toString() => 'CreateInstance($dartType)';
 
   void setParentPointers() {
     _setParentsOnList(arguments, this);
     if (typeInformation != null) _setParentsOnList(typeInformation, this);
   }
 }
 
 /// Obtains the interceptor for the given value.  This is a method table
 /// corresponding to the Dart class of the value.
 ///
@@ skipping 92 matching lines @@
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
   void setParentPointers() {}
 }
 
 class LiteralList extends Primitive {
   /// The List type being created; this is not the type argument.
-  final InterfaceType dartType;
+  InterfaceType dartType;
   final List<Reference<Primitive>> values;
 
   /// If non-null, this is an allocation site-specific type for the list
   /// created here.
   TypeMask allocationSiteType;
 
   LiteralList(this.dartType, List<Primitive> values, {this.allocationSiteType})
       : this.values = _referenceList(values);
 
   accept(Visitor visitor) => visitor.visitLiteralList(this);
@@ skipping 10 matching lines @@
 class LiteralMapEntry {
   final Reference<Primitive> key;
   final Reference<Primitive> value;
 
   LiteralMapEntry(Primitive key, Primitive value)
       : this.key = new Reference<Primitive>(key),
         this.value = new Reference<Primitive>(value);
 }
 
 class LiteralMap extends Primitive {
-  final InterfaceType dartType;
+  InterfaceType dartType;
   final List<LiteralMapEntry> entries;
 
   LiteralMap(this.dartType, this.entries);
 
   accept(Visitor visitor) => visitor.visitLiteralMap(this);
 
   bool get hasValue => true;
   bool get isSafeForElimination => true;
   bool get isSafeForReordering => true;
 
@@ skipping 845 matching lines @@
 
 /// A visitor to copy instances of [Definition] or its subclasses, except for
 /// instances of [Continuation].
 ///
 /// The visitor maintains a map from original definitions to their copies.
 /// When the [copy] method is called for a non-Continuation definition,
 /// a copy is created, added to the map and returned as the result. Copying a
 /// definition assumes that the definitions of all references have already
 /// been copied by the same visitor.
 class DefinitionCopyingVisitor extends Visitor<Definition> {
-  Map<Definition, Definition> _copies = <Definition, Definition>{};
+  final Map<Definition, Definition> _copies = <Definition, Definition>{};
+  DartType concreteType;
 
   /// Put a copy into the map.
   ///
   /// This method should be used instead of directly adding copies to the map.
   Definition putCopy(Definition original, Definition copy) {
     if (copy is Variable) {
       Variable originalVariable = original;
       copy.type = originalVariable.type;
       copy.hint = originalVariable.hint;
     }
     return _copies[original] = copy;
   }
 
   /// Get the copy of a [Reference]'s definition from the map.
   Definition getCopy(Reference reference) => _copies[reference.definition];
 
   /// Map a list of [Reference]s to the list of their definition's copies.
   List<Definition> getList(List<Reference> list) => list.map(getCopy).toList();
 
+  DartType substType(DartType dartType) {
+    return concreteType != null
+        ? dartType.substByContext(concreteType)
+        : dartType;
+  }
+
   /// Copy a non-[Continuation] [Definition].
   Definition copy(Definition node) {
     assert (node is! Continuation);
     return putCopy(node, visit(node));
   }
 
   Definition visit(Node node) => node.accept(this);
 
   visitFunctionDefinition(FunctionDefinition node) {}
   visitLetPrim(LetPrim node) {}
@@ skipping 21 matching lines @@
 
   Definition visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     return new InvokeMethodDirectly(getCopy(node.receiver), node.target,
         node.selector,
         getList(node.arguments),
         node.sourceInformation,
         callingConvention: node.callingConvention);
   }
 
   Definition visitInvokeConstructor(InvokeConstructor node) {
-    return new InvokeConstructor(node.dartType, node.target, node.selector,
+    return new InvokeConstructor(substType(node.dartType), node.target,
+        node.selector,
         getList(node.arguments),
         node.sourceInformation);
   }
 
   Definition visitTypeCast(TypeCast node) {
-    return new TypeCast(getCopy(node.value), node.dartType,
+    return new TypeCast(getCopy(node.value), substType(node.dartType),
         getList(node.typeArguments));
   }
 
   Definition visitSetMutable(SetMutable node) {
     return new SetMutable(getCopy(node.variable), getCopy(node.value));
   }
 
   Definition visitSetStatic(SetStatic node) {
     return new SetStatic(node.element, getCopy(node.value),
         node.sourceInformation);
   }
 
   Definition visitSetField(SetField node) {
     return new SetField(getCopy(node.object), node.field, getCopy(node.value));
   }
 
   Definition visitGetLazyStatic(GetLazyStatic node) {
     return new GetLazyStatic(node.element, node.sourceInformation);
   }
 
   Definition visitAwait(Await node) {
     return new Await(getCopy(node.input));
   }
 
   Definition visitYield(Yield node) {
     return new Yield(getCopy(node.input), node.hasStar);
   }
 
   Definition visitLiteralList(LiteralList node) {
-    return new LiteralList(node.dartType, getList(node.values));
+    return new LiteralList(substType(node.dartType), getList(node.values));
   }
 
   Definition visitLiteralMap(LiteralMap node) {
     List<LiteralMapEntry> entries = node.entries.map((LiteralMapEntry entry) {
       return new LiteralMapEntry(getCopy(entry.key), getCopy(entry.value));
     }).toList();
-    return new LiteralMap(node.dartType, entries);
+    return new LiteralMap(substType(node.dartType), entries);
   }
 
   Definition visitConstant(Constant node) {
     return new Constant(node.value, sourceInformation: node.sourceInformation);
   }
 
   Definition visitGetMutable(GetMutable node) {
     return new GetMutable(getCopy(node.variable));
   }
 
   Definition visitParameter(Parameter node) {
     return new Parameter(node.hint);
   }
 
   Definition visitMutableVariable(MutableVariable node) {
     return new MutableVariable(node.hint);
   }
 
   Definition visitGetStatic(GetStatic node) {
     return new GetStatic(node.element, node.sourceInformation);
   }
 
   Definition visitInterceptor(Interceptor node) {
     return new Interceptor(getCopy(node.input), node.sourceInformation)
         ..interceptedClasses.addAll(node.interceptedClasses);
   }
 
   Definition visitCreateInstance(CreateInstance node) {
-    return new CreateInstance(node.classElement, getList(node.arguments),
+    return new CreateInstance(substType(node.dartType),
+        getList(node.arguments),
         getList(node.typeInformation),
         node.sourceInformation);
   }
 
   Definition visitGetField(GetField node) {
     return new GetField(getCopy(node.object), node.field);
   }
 
   Definition visitCreateBox(CreateBox node) {
     return new CreateBox();
   }
 
   Definition visitReifyRuntimeType(ReifyRuntimeType node) {
     return new ReifyRuntimeType(getCopy(node.value), node.sourceInformation);
   }
 
   Definition visitReadTypeVariable(ReadTypeVariable node) {
     return new ReadTypeVariable(node.variable, getCopy(node.target),
         node.sourceInformation);
   }
 
   Definition visitTypeExpression(TypeExpression node) {
+    // Note: Do not use substType for the TypeExpression's DartType. The type
+    // variables in TypeExpression are not "free", they are bound by the
+    // TypeExpression itself.
     return new TypeExpression(node.dartType, getList(node.arguments));
   }
 
   Definition visitCreateInvocationMirror(CreateInvocationMirror node) {
     return new CreateInvocationMirror(node.selector, getList(node.arguments));
   }
 
   Definition visitTypeTest(TypeTest node) {
-    return new TypeTest(getCopy(node.value), node.dartType,
+    return new TypeTest(getCopy(node.value), substType(node.dartType),
         getList(node.typeArguments));
   }
 
   Definition visitTypeTestViaFlag(TypeTestViaFlag node) {
-    return new TypeTestViaFlag(getCopy(node.interceptor), node.dartType);
+    return new TypeTestViaFlag(getCopy(node.interceptor),
+        substType(node.dartType));
   }
 
   Definition visitApplyBuiltinOperator(ApplyBuiltinOperator node) {
     return new ApplyBuiltinOperator(node.operator, getList(node.arguments),
         node.sourceInformation);
   }
 
   Definition visitApplyBuiltinMethod(ApplyBuiltinMethod node) {
     return new ApplyBuiltinMethod(node.method, getCopy(node.receiver),
         getList(node.arguments),
@@ skipping 82 matching lines @@
     _stack.add(() {
       Expression savedFirst = _first;
       _first = _current = null;
       _processBlock(cont.body);
       _copies[cont].body = _first;
       _first = savedFirst;
       _current = null;
     });
   }
 
-  FunctionDefinition copy(FunctionDefinition node) {
+  /// Creates a copy of [node].
+  ///
+  /// If [concreteType] is given, type variables declared in [concreteType]'s
+  /// class are subsituted with the type arguments used in [concreteType].
+  /// For example, if `List<String>` is given, the type variable of `List`
+  /// is replaced with `String`.  It is for performance reasons that type
+  /// substitution is integrated into the copying operation.
+  FunctionDefinition copy(FunctionDefinition node, {DartType concreteType}) {
     assert(_first == null && _current == null);
     _first = _current = null;
+    _definitions.concreteType = concreteType;
     // Definitions are copied where they are bound, before processing
     // expressions in the scope of their binding.
     Parameter thisParameter = node.thisParameter == null
         ? null
         : _definitions.copy(node.thisParameter);
     List<Parameter> parameters =
         node.parameters.map(_definitions.copy).toList();
     // Though the return continuation's parameter does not have any uses,
     // we still make a proper copy to ensure that hints, type, etc. are
     // copied.
@@ skipping 70 matching lines @@
     plug(new Branch.loose(_definitions.getCopy(node.condition),
         _copies[node.trueContinuation.definition],
         _copies[node.falseContinuation.definition])
       ..isStrictCheck = node.isStrictCheck);
   }
 
   visitUnreachable(Unreachable node) {
     plug(new Unreachable());
   }
 }