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);
 
   HGraph build(CodegenWorkItem work) {
     return measure(() {
       AstElement element = work.element.implementation;
       Kernel kernel = backend.kernelTask.kernel;
       KernelSsaBuilder builder = new KernelSsaBuilder(element, work.resolvedAst,
           backend.compiler, work.registry, sourceInformationFactory, kernel);
       return builder.build();
     });
   }
 }
 
 class KernelSsaBuilder extends ir.Visitor with GraphBuilder {
   ir.Node target;
   final AstElement targetElement;
   final ResolvedAst resolvedAst;
   final CodegenRegistry registry;
 
+  /// A stack of [DartType]s that have been seen during inlining of factory
+  /// constructors.  These types are preserved in [HInvokeStatic]s and
+  /// [HCreate]s inside the inline code and registered during code generation
+  /// for these nodes.
+  // TODO(karlklose): consider removing this and keeping the (substituted) types
+  // of the type variables in an environment (like the [LocalsHandler]).
+  final List<DartType> currentImplicitInstantiations = <DartType>[];
+
   @override
   JavaScriptBackend get backend => compiler.backend;
 
   @override
   TreeElements get elements => resolvedAst.elements;
 
   SourceInformationBuilder sourceInformationBuilder;
   KernelAstAdapter astAdapter;
   LoopHandler<ir.Node> loopHandler;
   TypeBuilder typeBuilder;
@@ skipping 243 matching lines @@
         type, kind, original.instructionType, reifiedType, original);
   }
 
   /// Builds a SSA graph for [procedure].
   void buildProcedure(ir.Procedure procedure) {
     openFunction();
     procedure.function.body.accept(this);
     closeFunction();
   }
 
+  void addImplicitInstantiation(DartType type) {
+    if (type != null) {
+      currentImplicitInstantiations.add(type);
+    }
+  }
+
+  void removeImplicitInstantiation(DartType type) {
+    if (type != null) {
+      currentImplicitInstantiations.removeLast();
+    }
+  }
+
   void openFunction() {
     HBasicBlock block = graph.addNewBlock();
     open(graph.entry);
 
     Node function;
     if (resolvedAst.kind == ResolvedAstKind.PARSED) {
       function = resolvedAst.node;
     }
     localsHandler.startFunction(targetElement, function);
     close(new HGoto()).addSuccessor(block);
@@ skipping 375 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.
+  HInstruction setListRuntimeTypeInfoIfNeeded(
+      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 =
+          setListRuntimeTypeInfoIfNeeded(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);
+
+    addImplicitInstantiation(type);
+    _pushStaticInvocation(constructor, inputs, instructionType);
+    removeImplicitInstantiation(type);
   }
 
   @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 112 matching lines @@
     List<HInstruction> arguments = _visitArguments(invocation.arguments);
 
     _pushStaticInvocation(target, arguments, typeMask);
   }
 
   void _pushStaticInvocation(
       ir.Node target, List<HInstruction> arguments, TypeMask typeMask) {
     HInstruction instruction = new HInvokeStatic(
         astAdapter.getMember(target), arguments, typeMask,
         targetCanThrow: astAdapter.getCanThrow(target));
+    if (currentImplicitInstantiations.isNotEmpty) {
+      instruction.instantiatedTypes =
+          new List<DartType>.from(currentImplicitInstantiations);
+    }
     instruction.sideEffects = astAdapter.getSideEffects(target);
 
     push(instruction);
   }
 
   void _pushDynamicInvocation(
       ir.Node node, TypeMask mask, List<HInstruction> arguments,
       {Selector selector}) {
     HInstruction receiver = arguments.first;
     List<HInstruction> inputs = <HInstruction>[];
@@ skipping 121 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);
   }
 }