Handle type variable test and typed list literal.

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;
 import '../common/names.dart';
@@ skipping 99 matching lines @@
       this._typeInferenceMap,
       this.localsMap,
       this.closedWorld,
       this._worldBuilder,
       this.registry,
       this.closureDataLookup,
       // TODO(het): Should sourceInformationBuilder be in GraphBuilder?
       this.sourceInformationBuilder,
       this.functionNode) {
     this.loopHandler = new KernelLoopHandler(this);
-    typeBuilder = new KernelTypeBuilder(_elementMap, this);
+    typeBuilder = new TypeBuilder(this);
     graph.element = targetElement;
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     this.localsHandler = new LocalsHandler(this, targetElement, targetElement,
         contextClass, null, nativeData, interceptorData);
     _targetStack.add(targetElement);
   }
 
   CommonElements get _commonElements => _elementMap.commonElements;
 
@@ skipping 1807 matching lines @@
     registry?.registerConstSymbol(symbolLiteral.value);
   }
 
   @override
   void visitNullLiteral(ir.NullLiteral nullLiteral) {
     stack.add(graph.addConstantNull(closedWorld));
   }
 
   /// Set the runtime type information if necessary.
   HInstruction _setListRuntimeTypeInfoIfNeeded(
-      HInstruction object, ir.ListLiteral listLiteral) {
-    InterfaceType type = localsHandler.substInContext(_commonElements
-        .listType(_elementMap.getDartType(listLiteral.typeArgument)));
+      HInstruction object, InterfaceType type) {
     if (!rtiNeed.classNeedsRti(type.element) || type.treatAsRaw) {
       return object;
     }
     List<HInstruction> arguments = <HInstruction>[];
     for (DartType argument in type.typeArguments) {
       arguments.add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
     }
     // TODO(15489): Register at codegen.
     registry?.registerInstantiation(type);
     return callSetRuntimeTypeInfoWithTypeArguments(type, arguments, object);
   }
 
   @override
   void visitListLiteral(ir.ListLiteral listLiteral) {
     HInstruction listInstruction;
     if (listLiteral.isConst) {
       listInstruction = graph.addConstant(
           _elementMap.getConstantValue(listLiteral), closedWorld);
     } else {
       List<HInstruction> elements = <HInstruction>[];
       for (ir.Expression element in listLiteral.expressions) {
         element.accept(this);
         elements.add(pop());
       }
       listInstruction =
           new HLiteralList(elements, commonMasks.extendableArrayType);
       add(listInstruction);
-      listInstruction =
-          _setListRuntimeTypeInfoIfNeeded(listInstruction, listLiteral);
+      InterfaceType type = localsHandler.substInContext(_commonElements
+          .listType(_elementMap.getDartType(listLiteral.typeArgument)));
+      listInstruction = _setListRuntimeTypeInfoIfNeeded(listInstruction, type);
     }
 
     TypeMask type = _typeInferenceMap.typeOfListLiteral(
         targetElement, listLiteral, closedWorld);
     if (!type.containsAll(closedWorld)) {
       listInstruction.instructionType = type;
     }
     stack.add(listInstruction);
   }
 
@@ skipping 362 matching lines @@
       return;
     }
     FunctionEntity function = _elementMap.getMember(target);
     TypeMask typeMask = _typeInferenceMap.getReturnTypeOf(function);
 
     // TODO(sra): For JS interop external functions, use a different function to
     // build arguments.
     List<HInstruction> arguments =
         _visitArgumentsForStaticTarget(target.function, invocation.arguments);
 
+    // TODO(johnniwinther): Move factory calls to a helper function?
     if (function is ConstructorEntity && function.isFactoryConstructor) {
       if (function.isExternal && function.isFromEnvironmentConstructor) {
         if (invocation.isConst) {
           // Just like all const constructors (see visitConstructorInvocation).
           stack.add(graph.addConstant(
               _elementMap.getConstantValue(invocation), closedWorld));
         } else {
           generateUnsupportedError(
               invocation,
               '${function.enclosingClass.name}.${function.name} '
               'can only be used as a const constructor');
         }
         return;
       }
 
       // Factory constructors take type parameters; other static methods ignore
       // them.
+
       if (closedWorld.rtiNeed.classNeedsRti(function.enclosingClass)) {
         _addTypeArguments(arguments, invocation.arguments);
       }
+
+      _pushStaticInvocation(function, arguments, typeMask);
+
+      bool isFixedListConstructorCall = false;
+      bool isGrowableListConstructorCall = false;
+      if (commonElements.isUnnamedListConstructor(function) &&
+          invocation.arguments.named.isEmpty) {
+        isFixedListConstructorCall =
+            invocation.arguments.positional.length == 1;
+        isGrowableListConstructorCall = invocation.arguments.positional.isEmpty;
+      }
+      bool isJSArrayTypedConstructor =
+          function == commonElements.jsArrayTypedConstructor;
+      if (rtiNeed.classNeedsRti(commonElements.listClass) &&
+          (isFixedListConstructorCall ||
+              isGrowableListConstructorCall ||
+              isJSArrayTypedConstructor)) {
+        InterfaceType type = _elementMap.createInterfaceType(
+            target.enclosingClass, invocation.arguments.types);
+        stack.add(_setListRuntimeTypeInfoIfNeeded(pop(), type));
+      }
+    } else {
+      _pushStaticInvocation(function, arguments, typeMask);
     }
-
-    _pushStaticInvocation(function, 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);
     } else if (name == 'JS_CALL_IN_ISOLATE') {
@@ skipping 1100 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }
-
-class KernelTypeBuilder extends TypeBuilder {
-  KernelToElementMapForBuilding _elementMap;
-
-  KernelTypeBuilder(this._elementMap, GraphBuilder builder) : super(builder);
-
-  @override
-  InterfaceType getThisType(ClassEntity cls) {
-    return _elementMap.elementEnvironment.getThisType(cls);
-  }
-}