dart2js cps: Support inlining constructors with type arguments.

pkg/compiler/lib/src/cps_ir/inline.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.
 
 library cps_ir.optimization.inline;
 
 import 'cps_fragment.dart';
 import 'cps_ir_builder.dart' show ThisParameterLocal;
 import 'cps_ir_nodes.dart';
 import 'optimizers.dart';
@@ skipping 110 matching lines @@
       List<TypeMask> arguments) {
     _putInternal(element, callStructure, receiver, arguments, false, null);
   }
 
   /// Look up a tuple in the cache.
   ///
   /// A positive lookup result return the IR function definition.  A negative
   /// lookup result returns [NO_INLINE].  If there is no cached result,
   /// [ABSENT] is returned.
   get(ExecutableElement element, CallStructure callStructure, TypeMask receiver,
-      List<TypeMask> arguments) {
+      List<TypeMask> arguments, DartType concreteType) {
     List<CacheEntry> entries = map[element];
     if (entries != null) {
       for (CacheEntry entry in entries) {
         if (entry.match(callStructure, receiver, arguments)) {
           if (entry.decision) {
-            FunctionDefinition function = copier.copy(entry.function);
+            FunctionDefinition function = copier.copy(entry.function,
+                concreteType: concreteType);
             ParentVisitor.setParents(function);
             return function;
           }
           return NO_INLINE;
         }
       }
     }
     return ABSENT;
   }
 }
@@ skipping 204 matching lines @@
 
   // Given an invocation and a known target, possibly perform inlining.
   //
   // An optional call structure indicates a dynamic call.  Calls that are
   // already resolved statically have a null call structure.
   //
   // The [Primitive] representing the result of the inlined call is returned
   // if the call was inlined, and the inlined function body is available in
   // [_fragment].  If the call was not inlined, null is returned.
   Primitive tryInlining(InvocationPrimitive invoke, FunctionElement target,
-                        CallStructure callStructure) {
+                        CallStructure callStructure,
+                        {GenericType concreteType}) {
     // Quick checks: do not inline or even cache calls to targets without an
     // AST node, targets that are asynchronous or generator functions, or
     // targets containing a try statement.
     if (!target.hasNode) return null;
     if (target.asyncMarker != AsyncMarker.SYNC) return null;
     // V8 does not optimize functions containing a try statement.  Inlining
     // code containing a try statement will make the optimizable calling code
     // become unoptimizable.
     if (target.resolvedAst.elements.containsTryStatement) {
       return null;
     }
 
     Reference<Primitive> dartReceiver = invoke.dartReceiverReference;
     TypeMask abstractReceiver =
         dartReceiver == null ? null : abstractType(dartReceiver);
     // The receiver is non-null in a method body, unless the receiver is known
     // to be `null` (isEmpty covers `null` and unreachable).
     TypeMask abstractReceiverInMethod = abstractReceiver == null
         ? null
         : abstractReceiver.isEmpty
             ? abstractReceiver
             : abstractReceiver.nonNullable();
     List<TypeMask> abstractArguments =
         invoke.arguments.map(abstractType).toList();
     var cachedResult = _inliner.cache.get(target, callStructure,
         abstractReceiverInMethod,
-        abstractArguments);
+        abstractArguments,
+        concreteType);
 
     // Negative inlining result in the cache.
     if (cachedResult == InliningCache.NO_INLINE) return null;
 
     Primitive finish(FunctionDefinition function) {
       _fragment = new CpsFragment(invoke.sourceInformation);
       Primitive receiver = invoke.receiver?.definition;
       List<Primitive> arguments =
           invoke.arguments.map((Reference ref) => ref.definition).toList();
       // Add a null check to the inlined function body if necessary.  The
@@ skipping 116 matching lines @@
 
   @override
   Primitive visitInvokeMethodDirectly(InvokeMethodDirectly node) {
     if (node.selector.isGetter != node.target.isGetter) return null;
     if (node.selector.isSetter != node.target.isSetter) return null;
     return tryInlining(node, node.target, null);
   }
 
   @override
   Primitive visitInvokeConstructor(InvokeConstructor node) {
-    if (node.dartType is GenericType) {
-      // We cannot inline a constructor invocation containing type arguments
-      // because CreateInstance in the body does not know the type arguments.
-      // We would incorrectly instantiate a class like A instead of A<B>.
-      // TODO(kmillikin): try to fix this.
-      GenericType generic = node.dartType;
-      if (generic.typeArguments.any((DartType t) => !t.isDynamic)) return null;
-    }
-    return tryInlining(node, node.target, null);
+    return tryInlining(node, node.target, null, concreteType: node.dartType);
   }
 }