Support more type arguments in generic instantiation

The real solution requires more work, so this is to buy us some time.

Change-Id: I033a77d05c0ca7658475d1fe59760ce4e5919f7e
Reviewed-on: https://dart-review.googlesource.com/65541
Reviewed-by: Sigmund Cherem <[email protected]>

Author: johnniwinther

pkg/compiler/lib/src/common_elements.dart

@@ -1115,18 +1115,39 @@ class CommonElements {
   FunctionEntity get hashCodeForNativeObject =>
       _findHelperFunction('hashCodeForNativeObject');
 
-  ClassEntity get instantiation1Class => _findHelperClass('Instantiation1');
-  ClassEntity get instantiation2Class => _findHelperClass('Instantiation2');
-  ClassEntity get instantiation3Class => _findHelperClass('Instantiation3');
-  FunctionEntity get instantiate1 => _findHelperFunction('instantiate1');
-  FunctionEntity get instantiate2 => _findHelperFunction('instantiate2');
-  FunctionEntity get instantiate3 => _findHelperFunction('instantiate3');
+  // TODO(johnniwinther,sra): Support arbitrary type argument count.
+  void _checkTypeArgumentCount(int typeArgumentCount) {
+    assert(typeArgumentCount > 0);
+    if (typeArgumentCount > 20) {
+      failedAt(
+          NO_LOCATION_SPANNABLE,
+          "Unsupported instantiation argument count: "
+          "${typeArgumentCount}");
+    }
+  }
+
+  ClassEntity getInstantiationClass(int typeArgumentCount) {
+    _checkTypeArgumentCount(typeArgumentCount);
+    return _findHelperClass('Instantiation$typeArgumentCount');
+  }
+
+  FunctionEntity getInstantiateFunction(int typeArgumentCount) {
+    _checkTypeArgumentCount(typeArgumentCount);
+    return _findHelperFunction('instantiate$typeArgumentCount');
+  }
+
   FunctionEntity get instantiatedGenericFunctionType =>
       _findHelperFunction('instantiatedGenericFunctionType');
 
   FunctionEntity get extractFunctionTypeObjectFromInternal =>
       _findHelperFunction('extractFunctionTypeObjectFromInternal');
 
+  bool isInstantiationClass(ClassEntity cls) {
+    return cls.library == _jsHelperLibrary &&
+        cls.name != 'Instantiation' &&
+        cls.name.startsWith('Instantiation');
+  }
+
   // From dart:_internal
 
   ClassEntity _symbolImplementationClass;

pkg/compiler/lib/src/js_backend/backend_impact.dart

@@ -768,18 +768,15 @@ class BackendImpacts {
     ]);
   }
 
-  BackendImpact _genericInstantiation;
+  Map<int, BackendImpact> _genericInstantiation = <int, BackendImpact>{};
 
-  BackendImpact get genericInstantiation =>
-      _genericInstantiation ??= new BackendImpact(staticUses: [
-        _commonElements.instantiate1,
-        _commonElements.instantiate2,
-        _commonElements.instantiate3,
+  BackendImpact getGenericInstantiation(int typeArgumentCount) =>
+      _genericInstantiation[typeArgumentCount] ??=
+          new BackendImpact(staticUses: [
+        _commonElements.getInstantiateFunction(typeArgumentCount),
         _commonElements.instantiatedGenericFunctionType,
         _commonElements.extractFunctionTypeObjectFromInternal,
       ], instantiatedClasses: [
-        _commonElements.instantiation1Class,
-        _commonElements.instantiation2Class,
-        _commonElements.instantiation3Class,
+        _commonElements.getInstantiationClass(typeArgumentCount),
       ]);
 }

pkg/compiler/lib/src/js_backend/codegen_listener.dart

@@ -157,14 +157,8 @@ class CodegenEnqueuerListener extends EnqueuerListener {
     } else if (constant is InstantiationConstantValue) {
       // TODO(johnniwinther): Register these using `BackendImpact`.
       impactBuilder.registerTypeUse(new TypeUse.instantiation(
-          _elementEnvironment
-              .getThisType(_commonElements.instantiation1Class)));
-      impactBuilder.registerTypeUse(new TypeUse.instantiation(
-          _elementEnvironment
-              .getThisType(_commonElements.instantiation2Class)));
-      impactBuilder.registerTypeUse(new TypeUse.instantiation(
-          _elementEnvironment
-              .getThisType(_commonElements.instantiation2Class)));
+          _elementEnvironment.getThisType(_commonElements
+              .getInstantiationClass(constant.typeArguments.length))));
       impactBuilder.registerStaticUse(new StaticUse.staticInvoke(
           _commonElements.instantiatedGenericFunctionType,
           CallStructure.TWO_ARGS));

pkg/compiler/lib/src/js_backend/constant_emitter.dart

@@ -340,24 +340,8 @@ class ConstantEmitter implements ConstantValueVisitor<jsAst.Expression, Null> {
   @override
   jsAst.Expression visitInstantiation(InstantiationConstantValue constant,
       [_]) {
-    // TODO(johnniwinther,sra): Support arbitrary type argument count.
-    ClassEntity cls;
-    switch (constant.typeArguments.length) {
-      case 1:
-        cls = _commonElements.instantiation1Class;
-        break;
-      case 2:
-        cls = _commonElements.instantiation2Class;
-        break;
-      case 3:
-        cls = _commonElements.instantiation3Class;
-        break;
-      default:
-        failedAt(
-            NO_LOCATION_SPANNABLE,
-            "Unsupported instantiation argument count: "
-            "${constant.typeArguments.length}");
-    }
+    ClassEntity cls =
+        _commonElements.getInstantiationClass(constant.typeArguments.length);
     List<jsAst.Expression> fields = <jsAst.Expression>[
       constantReferenceGenerator(constant.function),
       _reifiedTypeArguments(constant, constant.typeArguments)

pkg/compiler/lib/src/js_backend/impact_transformer.dart

@@ -301,9 +301,10 @@ class JavaScriptImpactTransformer extends ImpactTransformer {
     }
 
     if (worldImpact.genericInstantiations.isNotEmpty) {
-      registerImpact(_impacts.genericInstantiation);
       for (GenericInstantiation instantiation
           in worldImpact.genericInstantiations) {
+        registerImpact(_impacts
+            .getGenericInstantiation(instantiation.typeArguments.length));
         _rtiNeedBuilder.registerGenericInstantiation(instantiation);
       }
     }

pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart

@@ -718,9 +718,7 @@ class ProgramBuilder {
       callStubs.add(_buildStubMethod(name, function));
     }
 
-    if (cls == _commonElements.instantiation1Class ||
-        cls == _commonElements.instantiation2Class ||
-        cls == _commonElements.instantiation3Class) {
+    if (_commonElements.isInstantiationClass(cls)) {
       callStubs.addAll(_generateInstantiationStubs(cls));
     }
 

pkg/compiler/lib/src/ssa/builder_kernel.dart

@@ -4364,7 +4364,8 @@ class KernelSsaGraphBuilder extends ir.Visitor
     }
     int typeArgumentCount = node.typeArguments.length;
     bool targetCanThrow = false; // TODO(sra): Is this true?
-    FunctionEntity target = _instantiator(typeArgumentCount);
+    FunctionEntity target =
+        _commonElements.getInstantiateFunction(typeArgumentCount);
     if (target == null) {
       reporter.internalError(
           _elementMap.getSpannable(targetElement, node),
@@ -4384,14 +4385,6 @@ class KernelSsaGraphBuilder extends ir.Visitor
     push(instruction);
   }
 
-  FunctionEntity _instantiator(int count) {
-    // TODO(johnniwinther,sra): Support arbitrary type argument count.
-    if (count == 1) return _commonElements.instantiate1;
-    if (count == 2) return _commonElements.instantiate2;
-    if (count == 3) return _commonElements.instantiate3;
-    return null;
-  }
-
   @override
   void visitMethodInvocation(ir.MethodInvocation node) {
     node.receiver.accept(this);