dart2js-kernel: Recognize some List constructors.

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 1998 matching lines @@
     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);
+      listInstruction = buildLiteralList(elements);
       add(listInstruction);
       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;
@@ skipping 17 matching lines @@
       constructorArgs.add(pop());
     }
 
     // The constructor is a procedure because it's a factory.
     FunctionEntity constructor;
     List<HInstruction> inputs = <HInstruction>[];
     if (constructorArgs.isEmpty) {
       constructor = _commonElements.mapLiteralConstructorEmpty;
     } else {
       constructor = _commonElements.mapLiteralConstructor;
-      HLiteralList argList =
-          new HLiteralList(constructorArgs, commonMasks.extendableArrayType);
+      HLiteralList argList = buildLiteralList(constructorArgs);
       add(argList);
       inputs.add(argList);
     }
 
     assert(
         constructor is ConstructorEntity && constructor.isFactoryConstructor);
 
     InterfaceType type = localsHandler.substInContext(_commonElements.mapType(
         _elementMap.getDartType(mapLiteral.keyType),
         _elementMap.getDartType(mapLiteral.valueType)));
@@ skipping 327 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;
+      handleInvokeFactoryConstructor(invocation, function, typeMask, arguments);
+      return;
+    }
+
+    // Static methods currently ignore the type parameters.
+    _pushStaticInvocation(function, arguments, typeMask);
+  }
+
+  void handleInvokeFactoryConstructor(
+      ir.StaticInvocation invocation,
+      ConstructorEntity function,
+      TypeMask typeMask,
+      List<HInstruction> arguments) {
+    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;
+    }
+
+    bool isFixedList = false; // Any fixed list, e.g. new List(10),  UInt8List.
+
+    // Recognize `new List()` and `new List(n)`.
+    bool isFixedListConstructorCall = false;
+    bool isGrowableListConstructorCall = false;
+    if (commonElements.isUnnamedListConstructor(function) &&
+        invocation.arguments.named.isEmpty) {
+      int argumentCount = invocation.arguments.positional.length;
+      isFixedListConstructorCall = argumentCount == 1;
+      isGrowableListConstructorCall = argumentCount == 0;
+      isFixedList = isFixedListConstructorCall;
+    }
+
+    TypeMask resultType = typeMask;
+
+    bool isJSArrayTypedConstructor =
+        function == commonElements.jsArrayTypedConstructor;
+
+    if (isFixedListConstructorCall) {
+      assert(arguments.length == 1);
+      HInstruction lengthInput = arguments.first;
+      if (!lengthInput.isNumber(closedWorld)) {
+        HTypeConversion conversion = new HTypeConversion(
+            null,
+            HTypeConversion.ARGUMENT_TYPE_CHECK,
+            commonMasks.numType,
+            lengthInput);
+        add(conversion);
+        lengthInput = conversion;
+      }
+      js.Template code = js.js.parseForeignJS('new Array(#)');
+      var behavior = new native.NativeBehavior();
+      // TODO(redemption): Find the full type being created here,
+      // e.g. JSArray<Set<T>>, via 'computeEffectiveTargetType'.
+      var expectedType = closedWorld.elementEnvironment
+          .getRawType(_commonElements.jsArrayClass);
+      behavior.typesInstantiated.add(expectedType);
+      behavior.typesReturned.add(expectedType);
+
+      // The allocation can throw only if the given length is a double or
+      // outside the unsigned 32 bit range.
+      // TODO(sra): Array allocation should be an instruction so that canThrow
+      // can depend on a length type discovered in optimization.
+      bool canThrow = true;
+      if (lengthInput.isUInt32(closedWorld)) {
+        canThrow = false;
       }
 
-      // Factory constructors take type parameters; other static methods ignore
-      // them.
-
+      // TODO(redemption): Pick up site-specific type inference type, which
+      // might be more precise, e.g. a container type.
+      resultType = commonMasks.fixedListType;
+      HForeignCode foreign = new HForeignCode(code, resultType, arguments,
+          nativeBehavior: behavior,
+          throwBehavior: canThrow
+              ? native.NativeThrowBehavior.MAY
+              : native.NativeThrowBehavior.NEVER);
+      push(foreign);
+      // TODO(redemption): Global type analysis tracing may have determined that
+      // the fixed-length property is never checked. If so, we can avoid marking
+      // the array.
+      {
+        js.Template code = js.js.parseForeignJS(r'#.fixed$length = Array');
+        // We set the instruction as [canThrow] to avoid it being dead code.
+        // We need a finer grained side effect.
+        add(new HForeignCode(code, commonMasks.nullType, [stack.last],
+            throwBehavior: native.NativeThrowBehavior.MAY));
+      }
+    } else if (isGrowableListConstructorCall) {
+      push(buildLiteralList(<HInstruction>[]));
+      // TODO(sra): Pick up type inference type, which might be more precise,
+      // e.g. a container type.
+      resultType = commonMasks.growableListType;
+      stack.last.instructionType = resultType;
+    } else if (isJSArrayTypedConstructor) {
+      // TODO(sra): Instead of calling the identity-like factory constructor,
+      // simply select the single argument.
+      // Factory constructors take type parameters.
       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;
+    } else {
+      // Factory constructors take type parameters.
+      if (closedWorld.rtiNeed.classNeedsRti(function.enclosingClass)) {
+        _addTypeArguments(arguments, invocation.arguments);
       }
-      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);
     }
+
+    HInstruction newInstance = stack.last;
+
+    if (isFixedList) {
+      // If we inlined a constructor the call-site-specific type from type
+      // inference (e.g. a container type) will not be on the node. Store the
+      // more specialized type on the allocation.
+      newInstance.instructionType = resultType;
+      graph.allocatedFixedLists.add(newInstance);
+    }
+
+    if (rtiNeed.classNeedsRti(commonElements.listClass) &&
+        (isFixedListConstructorCall ||
+            isGrowableListConstructorCall ||
+            isJSArrayTypedConstructor)) {
+      InterfaceType type = _elementMap.createInterfaceType(
+          invocation.target.enclosingClass, invocation.arguments.types);
+      stack.add(_setListRuntimeTypeInfoIfNeeded(pop(), type));
+    }
+
+    // TODO(redemption): For redirecting factory constructors, check or trust
+    // the type.
   }
 
   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 554 matching lines @@
       // arguments), in case the [noSuchMethod] implementation calls
       // [JSInvocationMirror._invokeOn].
       // TODO(johnniwinther): Register this more precisely.
       registry?.registerDynamicUse(new DynamicUse(selector, null));
     }
 
     ConstantValue nameConstant = constantSystem.createString(publicName);
 
     js.Name internalName = namer.invocationName(selector);
 
-    var argumentsInstruction =
-        new HLiteralList(arguments, commonMasks.extendableArrayType);
+    var argumentsInstruction = buildLiteralList(arguments);
     add(argumentsInstruction);
 
     var argumentNames = new List<HInstruction>();
     for (String argumentName in selector.namedArguments) {
       ConstantValue argumentNameConstant =
           constantSystem.createString(argumentName);
       argumentNames.add(graph.addConstant(argumentNameConstant, closedWorld));
     }
-    var argumentNamesInstruction =
-        new HLiteralList(argumentNames, commonMasks.extendableArrayType);
+    var argumentNamesInstruction = buildLiteralList(argumentNames);
     add(argumentNamesInstruction);
 
     ConstantValue kindConstant =
         constantSystem.createInt(selector.invocationMirrorKind);
 
     _pushStaticInvocation(
         _commonElements.createInvocationMirror,
         [
           graph.addConstant(nameConstant, closedWorld),
           graph.addConstantStringFromName(internalName, closedWorld),
@@ skipping 514 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }