Always explicitely give a type to HInvokeStatic, and make the literal map know it's a map.

sdk/lib/_internal/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 2381 matching lines @@
         if (element.isGetter()) {
           Selector selector = elements.getSelector(send);
           if (tryInlineMethod(element, selector, const Link<Node>(), send)) {
             return;
           }
         }
         // TODO(5346): Try to avoid the need for calling [declaration] before
         // creating an [HStatic].
         push(new HStatic(element.declaration));
         if (element.isGetter()) {
-          push(new HInvokeStatic(<HInstruction>[pop()]));
+          push(new HInvokeStatic(<HInstruction>[pop()], HType.UNKNOWN));
         }
       }
     } else if (Elements.isInstanceSend(send, elements)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceGetterWithCompiledReceiver(send, receiver);
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
       // TODO(5346): Try to avoid the need for calling [declaration] before
       // creating an [HStatic].
       push(new HStatic(element.declaration));
       // TODO(ahe): This should be registered in codegen.
@@ skipping 35 matching lines @@
           send);
     }
     stack.add(value);
   }
 
   void generateSetter(SendSet send, Element element, HInstruction value) {
     if (Elements.isStaticOrTopLevelField(element)) {
       if (element.isSetter()) {
         HStatic target = new HStatic(element);
         add(target);
-        addWithPosition(new HInvokeStatic(<HInstruction>[target, value]), send);
+        addWithPosition(
+            new HInvokeStatic(<HInstruction>[target, value], HType.UNKNOWN),
+            send);
       } else {
         value = potentiallyCheckType(value, element.computeType(compiler));
         addWithPosition(new HStaticStore(element, value), send);
       }
       stack.add(value);
     } else if (element == null || Elements.isInstanceField(element)) {
       HInstruction receiver = generateInstanceSendReceiver(send);
       generateInstanceSetterWithCompiledReceiver(send, receiver, value);
     } else if (Elements.isErroneousElement(element)) {
       // An erroneous element indicates an unresolved static setter.
@@ skipping 17 matching lines @@
   }
 
   HInstruction invokeInterceptor(Set<ClassElement> intercepted,
                                  HInstruction receiver,
                                  Send send) {
     HInterceptor interceptor = new HInterceptor(intercepted, receiver);
     add(interceptor);
     return interceptor;
   }
 
-  void pushInvokeHelper0(Element helper) {
+  void pushInvokeHelper0(Element helper, HType type) {
     HInstruction reference = new HStatic(helper);
     add(reference);
     List<HInstruction> inputs = <HInstruction>[reference];
-    HInstruction result = new HInvokeStatic(inputs);
+    HInstruction result = new HInvokeStatic(inputs, type);
     push(result);
   }
 
-  void pushInvokeHelper1(Element helper, HInstruction a0) {
+  void pushInvokeHelper1(Element helper, HInstruction a0, HType type) {
     HInstruction reference = new HStatic(helper);
     add(reference);
     List<HInstruction> inputs = <HInstruction>[reference, a0];
-    HInstruction result = new HInvokeStatic(inputs);
+    HInstruction result = new HInvokeStatic(inputs, type);
     push(result);
   }
 
-  void pushInvokeHelper2(Element helper, HInstruction a0, HInstruction a1) {
+  void pushInvokeHelper2(Element helper,
+                         HInstruction a0,
+                         HInstruction a1,
+                         HType type) {
     HInstruction reference = new HStatic(helper);
     add(reference);
     List<HInstruction> inputs = <HInstruction>[reference, a0, a1];
-    HInstruction result = new HInvokeStatic(inputs);
+    HInstruction result = new HInvokeStatic(inputs, type);
     push(result);
   }
 
-  void pushInvokeHelper3(Element helper, HInstruction a0, HInstruction a1,
-                         HInstruction a2) {
+  void pushInvokeHelper3(Element helper,
+                         HInstruction a0,
+                         HInstruction a1,
+                         HInstruction a2,
+                         HType type) {
     HInstruction reference = new HStatic(helper);
     add(reference);
     List<HInstruction> inputs = <HInstruction>[reference, a0, a1, a2];
-    HInstruction result = new HInvokeStatic(inputs);
+    HInstruction result = new HInvokeStatic(inputs, type);
     push(result);
   }
 
-  void pushInvokeHelper4(Element helper, HInstruction a0, HInstruction a1,
-                         HInstruction a2, HInstruction a3) {
+  void pushInvokeHelper4(Element helper,
+                         HInstruction a0,
+                         HInstruction a1,
+                         HInstruction a2,
+                         HInstruction a3,
+                         HType type) {
     HInstruction reference = new HStatic(helper);
     add(reference);
     List<HInstruction> inputs = <HInstruction>[reference, a0, a1, a2, a3];
-    HInstruction result = new HInvokeStatic(inputs);
+    HInstruction result = new HInvokeStatic(inputs, type);
     push(result);
   }
 
-  void pushInvokeHelper5(Element helper, HInstruction a0, HInstruction a1,
-                         HInstruction a2, HInstruction a3, HInstruction a4) {
+  void pushInvokeHelper5(Element helper,
+                         HInstruction a0,
+                         HInstruction a1,
+                         HInstruction a2,
+                         HInstruction a3,
+                         HInstruction a4,
+                         HType type) {
     HInstruction reference = new HStatic(helper);
     add(reference);
     List<HInstruction> inputs = <HInstruction>[reference, a0, a1, a2, a3, a4];
-    HInstruction result = new HInvokeStatic(inputs);
+    HInstruction result = new HInvokeStatic(inputs, type);
     push(result);
   }
 
   HForeign createForeign(String code, HType type, List<HInstruction> inputs) {
     return new HForeign(new LiteralDartString(code), type, inputs);
   }
 
   HInstruction getRuntimeTypeInfo(HInstruction target) {
-    pushInvokeHelper1(backend.getGetRuntimeTypeInfo(), target);
+    pushInvokeHelper1(backend.getGetRuntimeTypeInfo(), target, HType.UNKNOWN);
     return pop();
   }
 
   // TODO(karlklose): change construction of the representations to be GVN'able
   // (dartbug.com/7182).
   List<HInstruction> buildTypeArgumentRepresentations(DartType type) {
     HInstruction createForeignArray(String code, inputs) {
       return createForeign(code, HType.READABLE_ARRAY, inputs);
     }
     HInstruction typeInfo;
@@ skipping 92 matching lines @@
         int index = 0;
         representations.forEach((HInstruction representation) {
           HInstruction position = graph.addConstantInt(index, constantSystem);
           // Get the index'th type argument from the runtime type information.
           HInstruction typeArgument =
               createForeign('#[#]', HType.UNKNOWN, [typeInfo, position]);
           add(typeArgument);
           // Create the call to isSubtype.
           List<HInstruction> inputs =
               <HInstruction>[isSubtype, typeArgument, representation];
-          HInstruction call = new HInvokeStatic(inputs);
+          HInstruction call = new HInvokeStatic(inputs, HType.BOOLEAN);
           add(call);
           checks.add(call);
           index++;
         });
         instruction = new HIs(type, <HInstruction>[expression]..addAll(checks));
       } else {
         instruction = new HIs(type, <HInstruction>[expression]);
       }
       if (isNot) {
         add(instruction);
@@ skipping 223 matching lines @@
     } else {
       // Call a helper method from the isolate library. The isolate
       // library uses its own isolate structure, that encapsulates
       // Leg's isolate.
       Element element = compiler.isolateHelperLibrary.find(
           const SourceString('_currentIsolate'));
       if (element == null) {
         compiler.cancel(
             'Isolate library and compiler mismatch', node: node);
       }
-      pushInvokeHelper0(element);
+      pushInvokeHelper0(element, HType.UNKNOWN);
     }
   }
 
   void handleForeignJsCallInIsolate(Send node) {
     Link<Node> link = node.arguments;
     if (!compiler.hasIsolateSupport()) {
       // If the isolate library is not used, we just invoke the
       // closure.
       visit(link.tail.head);
       Selector selector = new Selector.callClosure(0);
       push(new HInvokeClosure(selector, <HInstruction>[pop()]));
     } else {
       // Call a helper method from the isolate library.
       Element element = compiler.isolateHelperLibrary.find(
           const SourceString('_callInIsolate'));
       if (element == null) {
         compiler.cancel(
             'Isolate library and compiler mismatch', node: node);
       }
       HStatic target = new HStatic(element);
       add(target);
       List<HInstruction> inputs = <HInstruction>[target];
       addGenericSendArgumentsToList(link, inputs);
-      push(new HInvokeStatic(inputs));
+      push(new HInvokeStatic(inputs, HType.UNKNOWN));
     }
   }
 
   FunctionSignature handleForeignRawFunctionRef(Send node, String name) {
     if (node.arguments.isEmpty || !node.arguments.tail.isEmpty) {
       compiler.cancel('"$name" requires exactly one argument',
                       node: node.argumentsNode);
     }
     Node closure = node.arguments.head;
     Element element = elements[closure];
@@ skipping 116 matching lines @@
     add(argumentNamesInstruction);
 
     Constant kindConstant =
         constantSystem.createInt(selector.invocationMirrorKind);
 
     pushInvokeHelper5(createInvocationMirror,
                       graph.addConstant(nameConstant),
                       graph.addConstant(internalNameConstant),
                       graph.addConstant(kindConstant),
                       argumentsInstruction,
-                      argumentNamesInstruction);
+                      argumentNamesInstruction,
+                      HType.UNKNOWN);
 
     var inputs = <HInstruction>[
         target,
         self,
         pop()];
     push(new HInvokeSuper(inputs));
   }
 
   visitSend(Send node) {
     Element element = elements[node];
@@ skipping 65 matching lines @@
         member = member.getOutermostEnclosingMemberOrTopLevel();
       }
       if (member.isFactoryConstructor()) {
         // The type variable is stored in a parameter of the factory.
         inputs.add(localsHandler.readLocal(type.element));
       } else if (member.isInstanceMember()
                  || member.isGenerativeConstructor()) {
         // The type variable is stored in [this].
         if (typeInfo == null) {
           pushInvokeHelper1(backend.getGetRuntimeTypeInfo(),
-                            localsHandler.readThis());
+                            localsHandler.readThis(),
+                            HType.UNKNOWN);
           typeInfo = pop();
         }
         int index = RuntimeTypeInformation.getTypeVariableIndex(type);
         HInstruction foreign = createForeign('#[$index]', HType.STRING,
                                              <HInstruction>[typeInfo]);
         add(foreign);
         inputs.add(foreign);
       } else {
         // TODO(ngeoffray): Match the VM behavior and throw an
         // exception at runtime.
@@ skipping 30 matching lines @@
     }
 
     HInstruction typeInfo = new HLiteralList(rtiInputs);
     add(typeInfo);
 
     // Set the runtime type information on the object.
     Element typeInfoSetterElement = backend.getSetRuntimeTypeInfo();
     HInstruction typeInfoSetter = new HStatic(typeInfoSetterElement);
     add(typeInfoSetter);
     add(new HInvokeStatic(
-        <HInstruction>[typeInfoSetter, newObject, typeInfo]));
+        <HInstruction>[typeInfoSetter, newObject, typeInfo], HType.UNKNOWN));
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [type] must not be malformed in checked mode.
    */
   visitNewSend(Send node, InterfaceType type) {
     assert(invariant(node,
                      !compiler.enableTypeAssertions || !type.isMalformed,
@@ skipping 109 matching lines @@
       if (!succeeded) {
         generateWrongArgumentCountError(node, element, node.arguments);
         return;
       }
 
       if (isIdenticalFunction) {
         pushWithPosition(new HIdentity(inputs[1], inputs[2]), node);
         return;
       }
 
-      HInvokeStatic instruction = new HInvokeStatic(inputs);
+      HInvokeStatic instruction = new HInvokeStatic(inputs, HType.UNKNOWN);
       // TODO(ngeoffray): Only do this if knowing the return type is
       // useful.
       HType returnType =
           builder.backend.optimisticReturnTypesWithRecompilationOnTypeChange(
               currentElement, element);
       if (returnType != null) instruction.guaranteedType = returnType;
       pushWithPosition(instruction, node);
     } else {
       generateGetter(node, element);
       List<HInstruction> inputs = <HInstruction>[pop()];
@@ skipping 40 matching lines @@
     generateGetter(node, elements[node]);
   }
 
   // TODO(antonm): migrate rest of SsaBuilder to internalError.
   internalError(String reason, {Node node}) {
     compiler.internalError(reason, node: node);
   }
 
   void generateError(Node node, String message, Element helper) {
     HInstruction errorMessage = addConstantString(node, message);
-    pushInvokeHelper1(helper, errorMessage);
+    pushInvokeHelper1(helper, errorMessage, HType.UNKNOWN);
   }
 
   void generateRuntimeError(Node node, String message) {
     generateError(node, message, backend.getThrowRuntimeError());
   }
 
   void generateAbstractClassInstantiationError(Node node, String message) {
     generateError(node,
                   message,
                   backend.getThrowAbstractClassInstantiationError());
@@ skipping 30 matching lines @@
         HInstruction nameConstant =
             graph.addConstantString(new DartString.literal(name),
                                     diagnosticNode, constantSystem);
         existingNames.add(nameConstant);
       }
       existingNamesList = new HLiteralList(existingNames);
       add(existingNamesList);
     } else {
       existingNamesList = graph.addConstantNull(constantSystem);
     }
-    pushInvokeHelper4(helper, receiver, name, arguments, existingNamesList);
+    pushInvokeHelper4(
+        helper, receiver, name, arguments, existingNamesList, HType.UNKNOWN);
   }
 
   /**
    * Generate code to throw a [NoSuchMethodError] exception for calling a
    * method with a wrong number of arguments or mismatching named optional
    * arguments.
    */
   void generateWrongArgumentCountError(Node diagnosticNode,
                                        FunctionElement function,
                                        Link<Node> argumentNodes) {
     List<String> existingArguments = <String>[];
     FunctionSignature signature = function.computeSignature(compiler);
     signature.forEachParameter((Element parameter) {
       existingArguments.add(parameter.name.slowToString());
     });
     generateThrowNoSuchMethod(diagnosticNode,
                               function.name.slowToString(),
                               argumentNodes: argumentNodes,
                               existingArguments: existingArguments);
   }
 
   void generateMalformedSubtypeError(Node node, HInstruction value,
                                      DartType type, String reasons) {
     HInstruction typeString = addConstantString(node, type.toString());
     HInstruction reasonsString = addConstantString(node, reasons);
     Element helper = backend.getThrowMalformedSubtypeError();
-    pushInvokeHelper3(helper, value, typeString, reasonsString);
+    pushInvokeHelper3(helper, value, typeString, reasonsString, HType.UNKNOWN);
   }
 
   visitNewExpression(NewExpression node) {
     Element element = elements[node.send];
     if (!Elements.isErroneousElement(element)) {
       FunctionElement function = element;
       element = function.redirectionTarget;
     }
     if (Elements.isErroneousElement(element)) {
       ErroneousElement error = element;
@@ skipping 506 matching lines @@
     List<HInstruction> inputs = <HInstruction>[];
     for (Link<Node> link = node.entries.nodes;
          !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       inputs.addLast(pop());
       inputs.addLast(pop());
     }
     HLiteralList keyValuePairs = new HLiteralList(inputs);
     add(keyValuePairs);
-    pushInvokeHelper1(backend.getMapMaker(), keyValuePairs);
+    pushInvokeHelper1(backend.getMapMaker(), keyValuePairs,
+        new HType.fromBoundedType(compiler.mapClass.computeType(compiler),
+                                  compiler,
+                                  false));
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
   }
 
   visitNamedArgument(NamedArgument node) {
     visit(node.expression);
   }
@@ skipping 140 matching lines @@
       if (switchCase.isDefaultCase) {
         // An HSwitch has n inputs and n+1 successors, the last being the
         // default case.
         expressionBlock.addSuccessor(block);
         hasDefault = true;
       }
       open(block);
       localsHandler = new LocalsHandler.from(savedLocals);
       visit(switchCase.statements);
       if (!isAborted() && caseIterator.hasNext) {
-        pushInvokeHelper0(getFallThroughErrorElement);
+        pushInvokeHelper0(getFallThroughErrorElement, HType.UNKNOWN);
         HInstruction error = pop();
         close(new HThrow(error));
       }
       statements.add(
           new HSubGraphBlockInformation(new SubGraph(block, lastOpenedBlock)));
     }
 
     // Add a join-block if necessary.
     // We create [joinBlock] early, and then go through the cases that might
     // want to jump to it. In each case, if we add [joinBlock] as a successor
@@ skipping 96 matching lines @@
 
     SwitchCase node = cases.head;
     // Called for the statements on all but the last case block.
     // Ensures that a user expecting a fallthrough gets an error.
     void visitStatementsAndAbort() {
       visit(node.statements);
       if (!isAborted()) {
         compiler.reportWarning(node, 'Missing break at end of switch case');
         Element element =
             compiler.findHelper(const SourceString("getFallThroughError"));
-        pushInvokeHelper0(element);
+        pushInvokeHelper0(element, HType.UNKNOWN);
         HInstruction error = pop();
         close(new HThrow(error));
       }
     }
 
     Link<Node> skipLabels(Link<Node> labelsAndCases) {
       while (!labelsAndCases.isEmpty && labelsAndCases.head is Label) {
         labelsAndCases = labelsAndCases.tail;
       }
       return labelsAndCases;
@@ skipping 116 matching lines @@
       // TODO(kasperl): Bad smell. We shouldn't be constructing elements here.
       // Note that the name of this element is irrelevant.
       Element element = new ElementX(const SourceString('exception'),
                                      ElementKind.PARAMETER,
                                      currentElement);
       exception = new HLocalValue(element);
       add(exception);
       HInstruction oldRethrowableException = rethrowableException;
       rethrowableException = exception;
 
-      pushInvokeHelper1(backend.getExceptionUnwrapper(), exception);
+      pushInvokeHelper1(
+          backend.getExceptionUnwrapper(), exception, HType.UNKNOWN);
       HInvokeStatic unwrappedException = pop();
       tryInstruction.exception = exception;
       Link<Node> link = node.catchBlocks.nodes;
 
       void pushCondition(CatchBlock catchBlock) {
         if (catchBlock.onKeyword != null) {
           DartType type = elements.getType(catchBlock.type);
           if (type == null) {
             compiler.cancel('On with unresolved type',
                             node: catchBlock.type);
@@ skipping 26 matching lines @@
 
       void visitThen() {
         CatchBlock catchBlock = link.head;
         link = link.tail;
         if (catchBlock.exception != null) {
           localsHandler.updateLocal(elements[catchBlock.exception],
                                     unwrappedException);
         }
         Node trace = catchBlock.trace;
         if (trace != null) {
-          pushInvokeHelper1(backend.getTraceFromException(), exception);
+          pushInvokeHelper1(
+              backend.getTraceFromException(), exception, HType.UNKNOWN);
           HInstruction traceInstruction = pop();
           localsHandler.updateLocal(elements[trace], traceInstruction);
         }
         visit(catchBlock);
       }
 
       void visitElse() {
         if (link.isEmpty) {
           close(new HThrow(exception, isRethrow: true));
         } else {
@@ skipping 524 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }