dart2js-kernel: Bind type variables in generative constructor.

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

 // Copyright (c) 2016, 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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
@@ skipping 140 matching lines @@
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     this.localsHandler = new LocalsHandler(
         this, targetElement, null, nativeData, interceptorData);
     this.astAdapter = new KernelAstAdapter(kernel, compiler.backend,
         resolvedAst, kernel.nodeToAst, kernel.nodeToElement);
     target = astAdapter.getInitialKernelNode(targetElement);
     if (targetElement is ConstructorBodyElement) {
       _targetIsConstructorBody = true;
     }
+    _targetStack.add(target);
   }
 
   HGraph build() {
     // TODO(het): no reason to do this here...
     HInstruction.idCounter = 0;
     if (target is ir.Procedure) {
       _targetFunction = (target as ir.Procedure).function;
       buildFunctionNode(_targetFunction);
     } else if (target is ir.Field) {
       buildField(target);
@@ skipping 41 matching lines @@
     if (typeBuilder.checkOrTrustTypes) {
       ResolutionInterfaceType type = commonElements.boolType;
       return typeBuilder.potentiallyCheckOrTrustType(value, type,
           kind: HTypeConversion.BOOLEAN_CONVERSION_CHECK);
     }
     HInstruction result = new HBoolify(value, commonMasks.boolType);
     add(result);
     return result;
   }
 
+  /// Extend current method parameters with parameters for the class type
+  /// parameters.  If the class has type parameters but does not need them, bind
+  /// to `dynamic` (represented as `null`) so the bindings are available for
+  /// building types up the inheritance chain of generative constructors.
   void _addClassTypeVariablesIfNeeded(ir.Member constructor) {
     var enclosing = constructor.enclosingClass;
-    if (rtiNeed.classNeedsRti(astAdapter.getElement(enclosing))) {
-      enclosing.typeParameters.forEach((ir.TypeParameter typeParameter) {
-        var typeParamElement = astAdapter.getElement(typeParameter);
-        HParameterValue param =
-            addParameter(typeParamElement, commonMasks.nonNullType);
-        // This is a little bit wacky (and n^2) until we make the localsHandler
-        // take Kernel DartTypes instead of just the AST DartTypes.
-        var typeVariableType = astAdapter
-            .getClass(enclosing)
-            .typeVariables
-            .firstWhere(
-                (ResolutionTypeVariableType i) => i.name == typeParameter.name);
-        localsHandler.directLocals[
-            localsHandler.getTypeVariableAsLocal(typeVariableType)] = param;
-      });
-    }
+    bool needParameters;
+    enclosing.typeParameters.forEach((ir.TypeParameter typeParameter) {
+      var typeParamElement = astAdapter.getElement(typeParameter);
+      HInstruction param;
+      needParameters ??=
+          rtiNeed.classNeedsRti(astAdapter.getElement(enclosing));
+      if (needParameters) {
+        param = addParameter(typeParamElement, commonMasks.nonNullType);
+      } else {
+        // Unused, so bind to `dynamic`.
+        param = graph.addConstantNull(closedWorld);
+      }
+      // This is a little bit wacky (and n^2) until we make the localsHandler
+      // take Kernel DartTypes instead of just the AST DartTypes.
+      var typeVariableType = astAdapter
+          .getClass(enclosing)
+          .typeVariables
+          .firstWhere(
+              (ResolutionTypeVariableType i) => i.name == typeParameter.name);
+      localsHandler.directLocals[
+          localsHandler.getTypeVariableAsLocal(typeVariableType)] = param;
+    });
   }
 
-  /// Builds generative constructors.
+  /// Builds a generative constructor.
   ///
-  /// Generative constructors are built in two stages.
+  /// Generative constructors are built in stages, in effect inlining the
+  /// initializers and constructor bodies up the inheritance chain.
   ///
-  /// First, the field values for every instance field for every class in the
-  /// class hierarchy are collected. Then, create a function body that sets
-  /// all of the instance fields to the collected values and call the
-  /// constructor bodies for all constructors in the hierarchy.
+  ///  1. Extend method parameters with parameters the class's type parameters.

[Siggi Cherem (dart-lang), 2017/04/27 00:32:27]

with parameters the => with the

+  ///
+  ///  2. Add type checks for value parameters (might need result of (1)).
+  ///
+  ///  3. Walk inheritance chain to build bindings for type parameters of
+  ///     superclasses and mixed-in classes.
+  ///
+  ///  4. Collect initializer values. Walk up inheritance chain to collect field
+  ///     initializers from field declarations, initializing parameters and
+  ///     initializer.

[Siggi Cherem (dart-lang), 2017/04/27 00:32:27]

"intializer" => "initializer assignments"? or "initializer expressions"?

+  ///
+  ///  5. Create reified type information for instance.

[Siggi Cherem (dart-lang), 2017/04/27 00:32:27]

nit: for instance => for the object instance? (I read it as "For instance, an
example will follow")

+  ///
+  ///  6. Allocate instance and assign initializers and reified type information

[Siggi Cherem (dart-lang), 2017/04/27 00:32:27]

instance => object instance

+  ///     to fields by calling JavaScript constructor.
+  ///
+  ///  7. Walk inheritance chain to call or inline constructor bodies.
+  ///
+  /// All the bindings are put in the constructor's locals handler. The
+  /// implication is that a class cannot be extended or mixed-in twice. If we in
+  /// future support repeated uses of a mixin class, we should do so by cloning

[Siggi Cherem (dart-lang), 2017/04/27 00:32:27]

in future => in the future

+  /// the mixin class in the Kernel input.
   void buildConstructor(ir.Constructor constructor) {
+    ir.Class constructedClass = constructor.enclosingClass;
+
     openFunction();
     _addClassTypeVariablesIfNeeded(constructor);
 
+    // TODO(sra): Type parameter constraint checks.
+
+    // TODO(sra): Checked mode parameter checks.
+
     // Collect field values for the current class.
-    // TODO(het): Does kernel always put field initializers in the constructor
-    //            initializer list? If so then this is unnecessary...
     Map<ir.Field, HInstruction> fieldValues =
-        _collectFieldValues(constructor.enclosingClass);
+        _collectFieldValues(constructedClass);
     List<ir.Constructor> constructorChain = <ir.Constructor>[];
-
     _buildInitializers(constructor, constructorChain, fieldValues);
 
     final constructorArguments = <HInstruction>[];
     // Doing this instead of fieldValues.forEach because we haven't defined the
     // order of the arguments here. We can define that with JElements.
-    astAdapter.getClass(constructor.enclosingClass).forEachInstanceField(
+    astAdapter.getClass(constructedClass).forEachInstanceField(
         (ClassElement enclosingClass, FieldElement member) {
       var value = fieldValues[astAdapter.getFieldFromElement(member)];
+      assert(value != null,
+          'No value for field ${member} aka ${astAdapter.getFieldFromElement(member)}');
       constructorArguments.add(value);
     }, includeSuperAndInjectedMembers: true);
 
-    // TODO(het): If the class needs runtime type information, add it as a
-    // constructor argument.
+    // Create the runtime type information, if needed.
+    bool hasRtiInput = backend.rtiNeed
+        .classNeedsRtiField(astAdapter.getClass(constructedClass));
+    if (hasRtiInput) {
+      // Read the values of the type arguments and create a HTypeInfoExpression
+      // to set on the newly create object.
+      List<HInstruction> typeArguments = <HInstruction>[];
+      for (ir.DartType typeParameter
+          in constructedClass.thisType.typeArguments) {
+        HInstruction argument = localsHandler.readLocal(localsHandler
+            .getTypeVariableAsLocal(astAdapter.getDartType(typeParameter)
+                as ResolutionTypeVariableType));
+        typeArguments.add(argument);
+      }
+
+      HInstruction typeInfo = new HTypeInfoExpression(
+          TypeInfoExpressionKind.INSTANCE,
+          astAdapter.getClass(constructedClass).thisType,
+          typeArguments,
+          commonMasks.dynamicType);
+      add(typeInfo);
+      constructorArguments.add(typeInfo);
+    }
+
     HInstruction newObject = new HCreate(
-        astAdapter.getClass(constructor.enclosingClass),
+        astAdapter.getClass(constructedClass),
         constructorArguments,
         new TypeMask.nonNullExact(
-            astAdapter.getClass(constructor.enclosingClass), closedWorld),
+            astAdapter.getClass(constructedClass), closedWorld),
         instantiatedTypes: <ResolutionInterfaceType>[
-          astAdapter.getClass(constructor.enclosingClass).thisType
+          astAdapter.getClass(constructedClass).thisType
         ],
-        hasRtiInput: false);
+        hasRtiInput: hasRtiInput);
 
     add(newObject);
 
     // Generate calls to the constructor bodies.
 
     for (ir.Constructor body in constructorChain.reversed) {
       if (_isEmptyStatement(body.function.body)) continue;
 
       List<HInstruction> bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
@@ skipping 16 matching lines @@
       });
 
       // If there are locals that escape (i.e. mutated in closures), we pass the
       // box to the constructor.
       ClosureScope scopeData = parameterClosureData
           .capturingScopes[constructorElement.resolvedAst.node];
       if (scopeData != null) {
         bodyCallInputs.add(localsHandler.readLocal(scopeData.boxElement));
       }
 
-      // TODO(sra): Pass type arguments.
+      // Pass type arguments.
+      ir.Class currentClass = body.enclosingClass;
+      if (backend.rtiNeed.classNeedsRti(astAdapter.getClass(currentClass))) {
+        for (ir.DartType typeParameter in currentClass.thisType.typeArguments) {
+          HInstruction argument = localsHandler.readLocal(localsHandler
+              .getTypeVariableAsLocal(astAdapter.getDartType(typeParameter)
+                  as ResolutionTypeVariableType));
+          bodyCallInputs.add(argument);
+        }
+      }
 
       _invokeConstructorBody(body, bodyCallInputs);
     }
 
     closeAndGotoExit(new HReturn(newObject, null));
     closeFunction();
   }
 
   static bool _isEmptyStatement(ir.Statement body) {
     if (body is ir.EmptyStatement) return true;
     if (body is ir.Block) return body.statements.every(_isEmptyStatement);
     return false;
   }
 
   void _invokeConstructorBody(
       ir.Constructor constructor, List<HInstruction> inputs) {
     // TODO(sra): Inline the constructor body.
     MemberEntity constructorBody =
         astAdapter.getConstructorBodyEntity(constructor);
     HInvokeConstructorBody invoke = new HInvokeConstructorBody(
         constructorBody, inputs, commonMasks.nonNullType);
     add(invoke);
   }
 
+  withCurrentIrNode(ir.Node node, f()) {
+    compiler.reporter.withCurrentElement(astAdapter.getElement(node), f);
+  }
+
+  /// Sets context for generating code that is the result of inlining
+  /// [inlinedTarget].
+  inlinedFrom(ir.TreeNode inlinedTarget, f()) {
+    withCurrentIrNode(inlinedTarget, () {
+      SourceInformationBuilder oldSourceInformationBuilder =
+          sourceInformationBuilder;
+      // TODO(sra): Update sourceInformationBuilder to Kernel.
+      // sourceInformationBuilder =
+      //   sourceInformationBuilder.forContext(resolvedAst);
+      _targetStack.add(inlinedTarget);
+      var result = f();
+      sourceInformationBuilder = oldSourceInformationBuilder;
+      _targetStack.removeLast();
+      return result;
+    });
+  }
+
   /// Maps the instance fields of a class to their SSA values.
   Map<ir.Field, HInstruction> _collectFieldValues(ir.Class clazz) {
     final fieldValues = <ir.Field, HInstruction>{};
 
     for (var field in clazz.fields) {
       if (field.isInstanceMember) {
         if (field.initializer == null) {
           fieldValues[field] = graph.addConstantNull(closedWorld);
         } else {
           // Gotta update the resolvedAst when we're looking at field values
           // outside the constructor.
           astAdapter.pushResolvedAst(field);
-          field.initializer.accept(this);
-          fieldValues[field] = pop();
+          inlinedFrom(field, () {
+            field.initializer.accept(this);
+            fieldValues[field] = pop();
+          });
           astAdapter.popResolvedAstStack();
         }
       }
     }
 
     return fieldValues;
   }
 
   /// Collects field initializers all the way up the inheritance chain.
   void _buildInitializers(
       ir.Constructor constructor,
       List<ir.Constructor> constructorChain,
       Map<ir.Field, HInstruction> fieldValues) {
+    astAdapter.assertAtResolvedAstFor(constructor);
     constructorChain.add(constructor);
+
     var foundSuperOrRedirectCall = false;
     for (var initializer in constructor.initializers) {
-      if (initializer is ir.SuperInitializer ||
-          initializer is ir.RedirectingInitializer) {
-        foundSuperOrRedirectCall = true;
-        var superOrRedirectConstructor = initializer.target;
-        var arguments = _normalizeAndBuildArguments(
-            superOrRedirectConstructor.function, initializer.arguments);
-        _buildInlinedInitializers(superOrRedirectConstructor, arguments,
-            constructorChain, fieldValues);
-      } else if (initializer is ir.FieldInitializer) {
+      if (initializer is ir.FieldInitializer) {
         initializer.value.accept(this);
         fieldValues[initializer.field] = pop();
+      } else if (initializer is ir.SuperInitializer) {
+        assert(!foundSuperOrRedirectCall);
+        foundSuperOrRedirectCall = true;
+        _inlineSuperInitializer(
+            initializer, constructorChain, fieldValues, constructor);
+      } else if (initializer is ir.RedirectingInitializer) {
+        assert(!foundSuperOrRedirectCall);
+        foundSuperOrRedirectCall = true;
+        _inlineRedirectingInitializer(
+            initializer, constructorChain, fieldValues, constructor);
+      } else if (initializer is ir.LocalInitializer) {
+        assert(false, 'ir.LocalInitializer not handled');
+      } else if (initializer is ir.InvalidInitializer) {
+        assert(false, 'ir.InvalidInitializer not handled');
       }
     }
 
     if (!foundSuperOrRedirectCall) {
-      assert(constructor.enclosingClass == astAdapter.objectClass,
-          'All constructors have super-constructor initializers, except Object()');
+      assert(
+          constructor.enclosingClass == astAdapter.objectClass,
+          'All constructors should have super- or redirecting- initializers,'
+          ' except Object()');
     }
   }
 
   List<HInstruction> _normalizeAndBuildArguments(
       ir.FunctionNode function, ir.Arguments arguments) {
     var signature = astAdapter.getFunctionSignature(function);
     var builtArguments = <HInstruction>[];
     var positionalIndex = 0;
     signature.forEachRequiredParameter((_) {
       arguments.positional[positionalIndex++].accept(this);
@@ skipping 24 matching lines @@
           assert(invariant(element, constantValue != null,
               message: 'No constant computed for $element'));
           builtArguments.add(graph.addConstant(constantValue, closedWorld));
         }
       });
     }
 
     return builtArguments;
   }
 
+  /// Creates localsHandler bindings for type parameters of a Supertype.
+  void _bindSupertypeTypeParameters(ir.Supertype supertype) {
+    ir.Class cls = supertype.classNode;
+    var parameters = cls.typeParameters;
+    var arguments = supertype.typeArguments;
+    assert(arguments.length == parameters.length);
+
+    for (int i = 0; i < parameters.length; i++) {
+      ir.DartType argument = arguments[i];
+      ir.TypeParameter parameter = parameters[i];
+
+      localsHandler.updateLocal(
+          localsHandler.getTypeVariableAsLocal(
+              astAdapter.getDartType(new ir.TypeParameterType(parameter))),
+          typeBuilder.analyzeTypeArgument(
+              astAdapter.getDartType(argument), sourceElement));
+    }
+  }
+
+  /// Inlines the given redirecting [constructor]'s initializers by collecting
+  /// its field values and building its constructor initializers. We visit super
+  /// constructors all the way up to the [Object] constructor.
+  void _inlineRedirectingInitializer(
+      ir.RedirectingInitializer initializer,
+      List<ir.Constructor> constructorChain,
+      Map<ir.Field, HInstruction> fieldValues,
+      ir.Constructor caller) {
+    var superOrRedirectConstructor = initializer.target;
+    var arguments = _normalizeAndBuildArguments(
+        superOrRedirectConstructor.function, initializer.arguments);
+
+    // Redirecting initializer already has [localsHandler] bindings for type
+    // parameters from the redirecting constructor.
+
+    // For redirecting constructors, the fields will be initialized later by the
+    // effective target, so we don't do it here.
+
+    _inlineSuperOrRedirectCommon(initializer, superOrRedirectConstructor,
+        arguments, constructorChain, fieldValues, caller);
+  }
+
   /// Inlines the given super [constructor]'s initializers by collecting its
   /// field values and building its constructor initializers. We visit super
   /// constructors all the way up to the [Object] constructor.
-  void _buildInlinedInitializers(
+  void _inlineSuperInitializer(
+      ir.SuperInitializer initializer,
+      List<ir.Constructor> constructorChain,
+      Map<ir.Field, HInstruction> fieldValues,
+      ir.Constructor caller) {
+    var target = initializer.target;
+    var arguments =
+        _normalizeAndBuildArguments(target.function, initializer.arguments);
+
+    ir.Class callerClass = caller.enclosingClass;
+    _bindSupertypeTypeParameters(callerClass.supertype);
+    if (callerClass.mixedInType != null) {
+      _bindSupertypeTypeParameters(callerClass.mixedInType);
+    }
+
+    ir.Class cls = target.enclosingClass;
+
+    inlinedFrom(target, () {
+      fieldValues.addAll(_collectFieldValues(cls));
+    });
+
+    _inlineSuperOrRedirectCommon(
+        initializer, target, arguments, constructorChain, fieldValues, caller);
+  }
+
+  void _inlineSuperOrRedirectCommon(
+      ir.Initializer initializer,
       ir.Constructor constructor,
       List<HInstruction> arguments,
       List<ir.Constructor> constructorChain,
-      Map<ir.Field, HInstruction> fieldValues) {
-    // TODO(het): Handle RTI if class needs it
-    fieldValues.addAll(_collectFieldValues(constructor.enclosingClass));
-
+      Map<ir.Field, HInstruction> fieldValues,
+      ir.Constructor caller) {
     var signature = astAdapter.getFunctionSignature(constructor.function);
     var index = 0;
     signature.orderedForEachParameter((ParameterElement parameter) {
       HInstruction argument = arguments[index++];
       // Because we are inlining the initializer, we must update
       // what was given as parameter. This will be used in case
       // there is a parameter check expression in the initializer.
       parameters[parameter] = argument;
       localsHandler.updateLocal(parameter, argument);
     });
 
-    // TODO(het): set the locals handler state as if we were inlining the
-    // constructor.
-    _buildInitializers(constructor, constructorChain, fieldValues);
+    // Set the locals handler state as if we were inlining the constructor.
+    astAdapter.pushResolvedAst(constructor);
+    ResolvedAst resolvedAst = astAdapter.getElement(constructor).resolvedAst;
+    ClosureClassMap oldClosureData = localsHandler.closureData;
+    ClosureClassMap newClosureData =
+        compiler.closureToClassMapper.getClosureToClassMapping(resolvedAst);
+    localsHandler.closureData = newClosureData;
+    if (resolvedAst.kind == ResolvedAstKind.PARSED) {
+      localsHandler.enterScope(
+          resolvedAst.node, astAdapter.getElement(constructor));
+    }
+    inlinedFrom(constructor, () {
+      _buildInitializers(constructor, constructorChain, fieldValues);
+    });
+    localsHandler.closureData = oldClosureData;
+    astAdapter.popResolvedAstStack();
   }
 
   /// Builds generative constructor body.
   void buildConstructorBody(ir.Constructor constructor) {
     openFunction();
+    _addClassTypeVariablesIfNeeded(constructor);
     constructor.function.body.accept(this);
     closeFunction();
   }
 
   /// Builds a SSA graph for FunctionNodes, found in FunctionExpressions and
   /// Procedures.
   void buildFunctionNode(ir.FunctionNode functionNode) {
     openFunction();
     if (functionNode.parent is ir.Procedure &&
         (functionNode.parent as ir.Procedure).kind ==
@@ skipping 65 matching lines @@
     push(trap);
   }
 
   /// Returns the current source element. This is used by the type builder.
   ///
   /// The returned element is a declaration element.
   // TODO(efortuna): Update this when we implement inlining.
   // TODO(sra): Re-implement type builder using Kernel types and the
   // `target` for context.
   @override
-  Element get sourceElement => _sourceElementForTarget(target);
+  Element get sourceElement => _sourceElementForTarget(_targetStack.last);
+
+  List<ir.Node> _targetStack = <ir.Node>[];
 
   Element _sourceElementForTarget(ir.Node target) {
     // For closure-converted (i.e. local functions) the source element is the
     // 'call' method of the class that represents the closure.
-    if (target is ir.FunctionExpression) {
+    Element callMethodOfClosureClass() {
       LocalFunctionElement element = astAdapter.getElement(target);
       ClosureClassMap classMap =
           closureToClassMapper.getClosureToClassMapping(element.resolvedAst);
       return classMap.callElement;
     }
+
+    if (target is ir.FunctionExpression) {
+      return callMethodOfClosureClass();
+    }
     if (target is ir.FunctionDeclaration) {
-      LocalFunctionElement element = astAdapter.getElement(target);
-      ClosureClassMap classMap =
-          closureToClassMapper.getClosureToClassMapping(element.resolvedAst);
-      return classMap.callElement;
+      return callMethodOfClosureClass();
     }
     Element element = astAdapter.getElement(target);
     return element;
   }
 
   @override
   void visitCheckLibraryIsLoaded(ir.CheckLibraryIsLoaded checkLoad) {
     HInstruction prefixConstant = graph.addConstantString(
         new DartString.literal(checkLoad.import.name), closedWorld);
     var prefixElement = astAdapter.getElement(checkLoad.import);
@@ skipping 1437 matching lines @@
       ir.FunctionNode target, ir.Arguments arguments) {
     // Visit arguments in source order, then re-order and fill in defaults.
     var values = _visitPositionalArguments(arguments);
 
     while (values.length < target.positionalParameters.length) {
       ir.VariableDeclaration parameter =
           target.positionalParameters[values.length];
       values.add(_defaultValueForParameter(parameter));
     }
 
-    if (arguments.named.isEmpty) return values;
+    if (arguments.named.isNotEmpty) {
+      var namedValues = <String, HInstruction>{};
+      for (ir.NamedExpression argument in arguments.named) {
+        argument.value.accept(this);
+        namedValues[argument.name] = pop();
+      }
 
-    var namedValues = <String, HInstruction>{};
-    for (ir.NamedExpression argument in arguments.named) {
-      argument.value.accept(this);
-      namedValues[argument.name] = pop();
+      // Visit named arguments in parameter-position order, selecting provided
+      // or default value.
+      // TODO(sra): Ensure the stored order is canonical so we don't have to
+      // sort. The old builder uses CallStructure.makeArgumentList which depends
+      // on the old element model.
+      var namedParameters = target.namedParameters.toList()
+        ..sort((ir.VariableDeclaration a, ir.VariableDeclaration b) =>
+            a.name.compareTo(b.name));
+      for (ir.VariableDeclaration parameter in namedParameters) {
+        HInstruction value = namedValues[parameter.name];
+        if (value == null) {
+          values.add(_defaultValueForParameter(parameter));
+        } else {
+          values.add(value);
+          namedValues.remove(parameter.name);
+        }
+      }
+      assert(namedValues.isEmpty);
     }
 
-    // Visit named arguments in parameter-position order, selecting provided or
-    // default value.
-    // TODO(sra): Ensure the stored order is canonical so we don't have to
-    // sort. The old builder uses CallStructure.makeArgumentList which depends
-    // on the old element model.
-    var namedParameters = target.namedParameters.toList()
-      ..sort((ir.VariableDeclaration a, ir.VariableDeclaration b) =>
-          a.name.compareTo(b.name));
-    for (ir.VariableDeclaration parameter in namedParameters) {
-      HInstruction value = namedValues[parameter.name];
-      if (value == null) {
-        values.add(_defaultValueForParameter(parameter));
-      } else {
-        values.add(value);
-        namedValues.remove(parameter.name);
-      }
+    return values;
+  }
+
+  void _addTypeArguments(List<HInstruction> values, ir.Arguments arguments) {
+    // need to translate type to
+    for (ir.DartType type in arguments.types) {
+      values.add(typeBuilder.analyzeTypeArgument(
+          astAdapter.getDartType(type), sourceElement));
     }
-    assert(namedValues.isEmpty);
-
-    return values;
   }
 
   HInstruction _defaultValueForParameter(ir.VariableDeclaration parameter) {
     ir.Expression initializer = parameter.initializer;
     if (initializer == null) return graph.addConstantNull(closedWorld);
     // TODO(sra): Evaluate constant in ir.Node domain.
     ConstantValue constant =
         astAdapter.getConstantForParameterDefaultValue(initializer);
     if (constant == null) return graph.addConstantNull(closedWorld);
     return graph.addConstant(constant, closedWorld);
   }
 
   @override
   void visitStaticInvocation(ir.StaticInvocation invocation) {
     ir.Procedure target = invocation.target;
     if (astAdapter.isInForeignLibrary(target)) {
       handleInvokeStaticForeign(invocation, target);
       return;
     }
     TypeMask typeMask = astAdapter.returnTypeOf(target);
 
     // TODO(sra): For JS interop external functions, use a different function to
     // build arguments.
     List<HInstruction> arguments =
         _visitArgumentsForStaticTarget(target.function, invocation.arguments);
 
+    // Factory constructors take type parameters; other static methods ignore
+    // them.
+    if (target.kind == ir.ProcedureKind.Factory) {
+      if (backend.rtiNeed
+          .classNeedsRti(astAdapter.getClass(target.enclosingClass))) {
+        _addTypeArguments(arguments, invocation.arguments);
+      }
+    }
+
     _pushStaticInvocation(target, arguments, typeMask);
   }
 
   void handleInvokeStaticForeign(
       ir.StaticInvocation invocation, ir.Procedure target) {
     String name = target.name.name;
     if (name == 'JS') {
       handleForeignJs(invocation);
     } else if (name == 'JS_CURRENT_ISOLATE_CONTEXT') {
       handleForeignJsCurrentIsolateContext(invocation);
@@ skipping 692 matching lines @@
     _buildInvokeSuper(astAdapter.getSelector(invocation),
         _containingClass(invocation), invocation.interfaceTarget, arguments);
   }
 
   @override
   void visitConstructorInvocation(ir.ConstructorInvocation invocation) {
     ir.Constructor target = invocation.target;
     // TODO(sra): For JS-interop targets, process arguments differently.
     List<HInstruction> arguments =
         _visitArgumentsForStaticTarget(target.function, invocation.arguments);
+    if (backend.rtiNeed
+        .classNeedsRti(astAdapter.getClass(target.enclosingClass))) {
+      _addTypeArguments(arguments, invocation.arguments);
+    }
     TypeMask typeMask = new TypeMask.nonNullExact(
         astAdapter.getClass(target.enclosingClass), closedWorld);
     _pushStaticInvocation(target, arguments, typeMask);
   }
 
   @override
   void visitIsExpression(ir.IsExpression isExpression) {
     isExpression.operand.accept(this);
     HInstruction expression = pop();
     pushIsTest(isExpression, isExpression.type, expression);
@@ skipping 419 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }