Add type annotations to remove warnings and fix a bug.

lib/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 2180 matching lines @@
     } 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.
       compiler.enqueuer.codegen.registerGetOfStaticFunction(element);
     } else if (Elements.isErroneousElement(element)) {
       // An erroneous element indicates an unresolved static getter.
       generateThrowNoSuchMethod(send,
                                 getTargetName(element, 'get'),
-                                const Link<Node>());
+                                argumentNodes: const Link<Node>());
     } else {
       stack.add(localsHandler.readLocal(element));
     }
   }
 
   void generateInstanceSetterWithCompiledReceiver(Send send,
                                                   HInstruction receiver,
                                                   HInstruction value) {
     assert(Elements.isInstanceSend(send, elements));
     Selector selector = elements.getSelector(send);
@@ skipping 28 matching lines @@
         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.
       generateThrowNoSuchMethod(send,
                                 getTargetName(element, 'set'),
-                                send.arguments);
+                                argumentNodes: send.arguments);
     } else {
       stack.add(value);
       // If the value does not already have a name, give it here.
       if (value.sourceElement == null) {
         value.sourceElement = element;
       }
       HInstruction checked = potentiallyCheckType(value, element);
       if (!identical(checked, value)) {
         pop();
         stack.add(checked);
@@ skipping 706 matching lines @@
     // the 'new' is done.
     if (isListConstructor && compiler.world.needsRti(compiler.listClass)) {
       handleListConstructor(type, node, newInstance);
     }
   }
 
   visitStaticSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     if (element.isErroneous()) {
-      generateThrowNoSuchMethod(node, getTargetName(element), node.arguments);
+      generateThrowNoSuchMethod(node,
+                                getTargetName(element),
+                                argumentNodes: node.arguments);
       return;
     }
     if (identical(element, compiler.assertMethod) && !compiler.enableUserAssertions) {
       stack.add(graph.addConstantNull(constantSystem));
       return;
     }
     compiler.ensure(!element.isGenerativeConstructor());
     if (element.isFunction()) {
       if (tryInlineMethod(element, selector, node.arguments)) {
         return;
@@ skipping 58 matching lines @@
   }
 
   void generateAbstractClassInstantiationError(Node node, String message) {
     generateError(node,
                   message,
                   interceptors.getThrowAbstractClassInstantiationError());
   }
 
   void generateThrowNoSuchMethod(Node diagnosticNode,
                                  String methodName,
-                                 [Link<Node> argumentNodes,
-                                  List<HInstruction> argumentValues]) {
+                                 {Link<Node> argumentNodes,
+                                  List<HInstruction> argumentValues}) {
     Element helper =
         compiler.findHelper(const SourceString('throwNoSuchMethod'));
     Constant receiverConstant =
         constantSystem.createString(new DartString.empty(), diagnosticNode);
     HInstruction receiver = graph.addConstant(receiverConstant);
     DartString dartString = new DartString.literal(methodName);
     Constant nameConstant =
         constantSystem.createString(dartString, diagnosticNode);
     HInstruction name = graph.addConstant(nameConstant);
     if (argumentValues == null) {
       argumentValues = <HInstruction>[];
       argumentNodes.forEach((argumentNode) {
         visit(argumentNode);
         HInstruction value = pop();
         argumentValues.add(value);
       });
     }
     HInstruction arguments = new HLiteralList(argumentValues);
     add(arguments);
     pushInvokeHelper3(helper, receiver, name, arguments);
   }
 
   visitNewExpression(NewExpression node) {
     Element element = elements[node.send];
     if (Elements.isErroneousElement(element)) {
       ErroneousElement error = element;
       if (error.messageKind == MessageKind.CANNOT_FIND_CONSTRUCTOR) {
         generateThrowNoSuchMethod(node.send,
                                   getTargetName(error, 'constructor'),
-                                  node.send.arguments);
+                                  argumentNodes: node.send.arguments);
       } else if (error.messageKind == MessageKind.CANNOT_RESOLVE) {
         Message message = error.messageKind.message(error.messageArguments);
         generateRuntimeError(node.send, message.toString());
       } else {
         compiler.internalError('unexpected unresolved constructor call',
                                node: node);
       }
     } else if (node.isConst()) {
       // TODO(karlklose): add type representation
       ConstantHandler handler = compiler.constantHandler;
@@ skipping 357 matching lines @@
         variable = elements[node.declaredIdentifier];
       } else {
         assert(node.declaredIdentifier.asVariableDefinitions() != null);
         VariableDefinitions variableDefinitions = node.declaredIdentifier;
         variable = elements[variableDefinitions.definitions.nodes.head];
       }
       HInstruction oldVariable = pop();
       if (variable.isErroneous()) {
         generateThrowNoSuchMethod(node,
                                   getTargetName(variable, 'set'),
-                                  <HInstruction>[oldVariable]);
+                                  argumentValues: <HInstruction>[oldVariable]);
         pop();
       } else {
         localsHandler.updateLocal(variable, oldVariable);
       }
 
       visit(node.body);
     }
     handleLoop(node, buildInitializer, buildCondition, () {}, buildBody);
   }
 
@@ skipping 1022 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;
   }
 }