Add types for map literal construction with kernel code.

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 '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
 import '../common/tasks.dart' show CompilerTask;
@@ skipping 11 matching lines @@
 import '../universe/selector.dart';
 import '../universe/use.dart' show TypeUse;
 import 'graph_builder.dart';
 import 'kernel_ast_adapter.dart';
 import 'kernel_string_builder.dart';
 import 'locals_handler.dart';
 import 'loop_handler.dart';
 import 'nodes.dart';
 import 'ssa_branch_builder.dart';
 import 'type_builder.dart';
+import 'types.dart' show TypeMaskFactory;
 
 class SsaKernelBuilderTask extends CompilerTask {
   final JavaScriptBackend backend;
   final SourceInformationStrategy sourceInformationFactory;
 
   String get name => 'SSA kernel builder';
 
   SsaKernelBuilderTask(JavaScriptBackend backend, this.sourceInformationFactory)
       : backend = backend,
         super(backend.compiler.measurer);
@@ skipping 666 matching lines @@
     stack.add(graph.addConstant(
         astAdapter.getConstantForSymbol(symbolLiteral), compiler));
     registry?.registerConstSymbol(symbolLiteral.value);
   }
 
   @override
   void visitNullLiteral(ir.NullLiteral nullLiteral) {
     stack.add(graph.addConstantNull(compiler));
   }
 
-  HInstruction setRtiIfNeeded(HInstruction object, ir.ListLiteral listLiteral) {
+  /// Set the runtime type information if necessary. Cases where this is needed
+  /// are for classes that are:
+  /// (1) used in a is check with type variables,
+  /// (2) dependencies of classes in (1),
+  /// (3) subclasses of (2) and (3).

[sra1, 2016/11/17 23:51:41]

The code is now a little bit too general, since it is called only for JSArray<E>
We could need JSArray<E> for the reasons (1)...(3).

[Emily Fortuna, 2016/11/18 01:30:35]

Done.

+  HInstruction setRuntimeTypeInfoIfNeeded(
+      HInstruction object, ir.ListLiteral listLiteral) {
     InterfaceType type = localsHandler
         .substInContext(elements.getType(astAdapter.getNode(listLiteral)));
     if (!backend.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(astAdapter.getConstantFor(listLiteral), compiler);
     } else {
       List<HInstruction> elements = <HInstruction>[];
       for (ir.Expression element in listLiteral.expressions) {
         element.accept(this);
         elements.add(pop());
       }
       listInstruction = new HLiteralList(elements, backend.extendableArrayType);
       add(listInstruction);
-      listInstruction = setRtiIfNeeded(listInstruction, listLiteral);
+      listInstruction =
+          setRuntimeTypeInfoIfNeeded(listInstruction, listLiteral);
     }
 
     TypeMask type = astAdapter.typeOfNewList(targetElement, listLiteral);
     if (!type.containsAll(compiler.closedWorld)) {
       listInstruction.instructionType = type;
     }
     stack.add(listInstruction);
   }
 
   @override
@@ skipping 18 matching lines @@
     if (constructorArgs.isEmpty) {
       constructor = astAdapter.mapLiteralConstructorEmpty;
     } else {
       constructor = astAdapter.mapLiteralConstructor;
       HLiteralList argList =
           new HLiteralList(constructorArgs, backend.extendableArrayType);
       add(argList);
       inputs.add(argList);
     }
 
-    // TODO(het): Add type information
-    _pushStaticInvocation(constructor, inputs, backend.dynamicType);
+    assert(constructor.kind == ir.ProcedureKind.Factory);
+
+    InterfaceType type = localsHandler
+        .substInContext(elements.getType(astAdapter.getNode(mapLiteral)));
+
+    ir.Class cls = constructor.enclosingClass;
+
+    if (backend.classNeedsRti(astAdapter.getElement(cls))) {
+      List<HInstruction> typeInputs = <HInstruction>[];
+      type.typeArguments.forEach((DartType argument) {
+        typeInputs
+            .add(typeBuilder.analyzeTypeArgument(argument, sourceElement));
+      });
+
+      // We lift this common call pattern into a helper function to save space
+      // in the output.
+      if (typeInputs.every((HInstruction input) => input.isNull())) {
+        if (constructorArgs.isEmpty) {
+          constructor = astAdapter.mapLiteralUntypedEmptyMaker;
+        } else {
+          constructor = astAdapter.mapLiteralUntypedMaker;
+        }
+      } else {
+        inputs.addAll(typeInputs);
+      }
+    }
+
+    // If runtime type information is needed and the map literal has no type
+    // parameters, 'constructor' is a static function that forwards the call to
+    // the factory constructor without type parameters.
+    assert(constructor.kind == ir.ProcedureKind.Factory);
+
+    // The instruction type will always be a subtype of the mapLiteralClass, but
+    // type inference might discover a more specific type, or find nothing (in
+    // dart2js unit tests).
+    TypeMask mapType = new TypeMask.nonNullSubtype(
+        astAdapter.getElement(astAdapter.mapLiteralClass),
+        compiler.closedWorld);
+    TypeMask returnTypeMask = TypeMaskFactory.inferredReturnTypeForElement(
+        astAdapter.getElement(constructor), compiler);
+    TypeMask instructionType =
+        mapType.intersection(returnTypeMask, compiler.closedWorld);
+
+    // TODO(efortuna): Inlining.

[Siggi Cherem (dart-lang), 2016/11/17 23:56:53]

Let's change the TODO to explicitly say this is for
'currentInlinedInstantiations'?

I think "inlined" there is a misnomer. Maybe it should be called "implicit"
instantiations? The thing is that this is used even when we do no inlining. It's
used to correctly register what types are instantiated from factory
constructors, and hence to know what else to include when tree-shaking. So we'll
need to have this sooner rather than later.

[Emily Fortuna, 2016/11/18 01:30:35]

hmmmm. I added them, but I'm not certain that this does what we want, since we
already have the type itself and don't have to follow it like we do in
builder.dart (see line 5676). The actual type is already passed into
_pushStaticInvocation(instructionType). So I'm not sure why we need to push it
onto that stack as well? I'm inclined to take the added bits of the second
patchset out and also remove the above TODO then. WDYT? Am I not thinking of
some particular use case?

[Siggi Cherem (dart-lang), 2016/11/18 15:47:06]

Stephen/Johnni - please confirm, but I believe we also need them for regular
factory constructors (not just for redirecting constructors).

If I understand this correctly, when we see:

   x = {}

We generate a static call to the factory method:

   factory LinkedHashMap._empty() {
     return new JsLinkedHashMap.es6();
   }

The call doesn't know below that it is a factory method, so even though we will
mark JsLinkedHashMap as instantiated when looking at the body of the method, we
wont include LinkedHashMap unless we add this implicit instantiation.

+    _pushStaticInvocation(constructor, inputs, instructionType);
   }
 
   @override
   void visitMapEntry(ir.MapEntry mapEntry) {
     // Visit value before the key because each will push an expression to the
     // stack, so when we pop them off, the key is popped first, then the value.
     mapEntry.value.accept(this);
     mapEntry.key.accept(this);
   }
 
@@ skipping 253 matching lines @@
     push(new HNot(popBoolified(), backend.boolType));
   }
 
   @override
   void visitStringConcatenation(ir.StringConcatenation stringConcat) {
     KernelStringBuilder stringBuilder = new KernelStringBuilder(this);
     stringConcat.accept(stringBuilder);
     stack.add(stringBuilder.result);
   }
 }