kernel -> ssa: implement literal maps

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/tasks.dart' show CompilerTask;
 import '../compiler.dart';
@@ skipping 52 matching lines @@
       this.registry,
       SourceInformationStrategy sourceInformationFactory,
       Kernel kernel) {
     graph.element = targetElement;
     // TODO(het): Should sourceInformationBuilder be in GraphBuilder?
     this.sourceInformationBuilder =
         sourceInformationFactory.createBuilderForContext(resolvedAst);
     graph.sourceInformation =
         sourceInformationBuilder.buildVariableDeclaration();
     this.localsHandler = new LocalsHandler(this, targetElement, null, compiler);
-    this.astAdapter = new KernelAstAdapter(
-        compiler.backend,
-        resolvedAst,
-        kernel.nodeToAst,
-        kernel.nodeToElement,
-        kernel.fields,
-        kernel.functions,
-        kernel.classes,
-        kernel.libraries);
+    this.astAdapter = new KernelAstAdapter(kernel, compiler.backend,
+        resolvedAst, kernel.nodeToAst, kernel.nodeToElement);
     Element originTarget = targetElement;
     if (originTarget.isPatch) {
       originTarget = originTarget.origin;
     }
     if (originTarget is FunctionElement) {
       target = kernel.functions[originTarget];
     } else if (originTarget is FieldElement) {
       target = kernel.fields[originTarget];
     }
   }
@@ skipping 201 matching lines @@
       listInstruction = new HLiteralList(elements, backend.extendableArrayType);
       add(listInstruction);
       // TODO(het): set runtime type info
     }
 
     // TODO(het): Set the instruction type to the list type given by inference
     stack.add(listInstruction);
   }
 
   @override
+  void visitMapLiteral(ir.MapLiteral mapLiteral) {
+    if (mapLiteral.isConst) {
+      stack.add(
+          graph.addConstant(astAdapter.getConstantFor(mapLiteral), compiler));
+      return;
+    }
+
+    // The map literal constructors take the key-value pairs as a List
+    List<HInstruction> constructorArgs = <HInstruction>[];
+    for (ir.MapEntry mapEntry in mapLiteral.entries) {
+      mapEntry.accept(this);
+      constructorArgs.add(pop());
+      constructorArgs.add(pop());
+    }
+
+    // The constructor is a procedure because it's a factory.
+    ir.Procedure constructor;
+    List<HInstruction> inputs = <HInstruction>[];
+    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);
+  }
+
+  @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);
+  }
+
+  @override
   void visitStaticGet(ir.StaticGet staticGet) {
     var staticTarget = staticGet.target;
     Element element = astAdapter.getElement(staticTarget).declaration;
     if (staticTarget is ir.Procedure &&
         staticTarget.kind == ir.ProcedureKind.Getter) {
       // Invoke the getter
       _pushStaticInvocation(
           target, const <HInstruction>[], astAdapter.returnTypeOf(target));
     } else {
       push(new HStatic(element, astAdapter.inferredTypeOf(staticTarget)));
@@ skipping 95 matching lines @@
     ir.Procedure target = invocation.target;
     TypeMask typeMask = astAdapter.returnTypeOf(target);
 
     List<HInstruction> arguments = _visitArguments(invocation.arguments);
 
     _pushStaticInvocation(target, arguments, typeMask);
   }
 
   void _pushStaticInvocation(
       ir.Node target, List<HInstruction> arguments, TypeMask typeMask) {
-    bool targetCanThrow = astAdapter.getCanThrow(target);
-
     HInstruction instruction = new HInvokeStatic(
         astAdapter.getElement(target).declaration, arguments, typeMask,
-        targetCanThrow: targetCanThrow);
+        targetCanThrow: astAdapter.getCanThrow(target));
     instruction.sideEffects = astAdapter.getSideEffects(target);
 
     push(instruction);
   }
 
   // TODO(het): Decide when to inline
   @override
   void visitMethodInvocation(ir.MethodInvocation invocation) {
     invocation.receiver.accept(this);
     HInstruction receiver = pop();
@@ skipping 99 matching lines @@
   void visitThisExpression(ir.ThisExpression thisExpression) {
     stack.add(localsHandler.readThis());
   }
 
   @override
   void visitNot(ir.Not not) {
     not.operand.accept(this);
     push(new HNot(popBoolified(), backend.boolType));
   }
 }