Some cleanups.

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 611 matching lines @@
   bool isContinue() => jumpInstruction is HContinue;
   JumpHandlerEntry(this.jumpInstruction, this.locals);
 }
 
 
 interface JumpHandler default JumpHandlerImpl {
   JumpHandler(SsaBuilder builder, TargetElement target);
   void generateBreak([LabelElement label]);
   void generateContinue([LabelElement label]);
   void forEachBreak(void action(HBreak instruction, LocalsHandler locals));
-  void forEachContinue(void action(HBreak instruction, LocalsHandler locals));
+  void forEachContinue(void action(HContinue instruction,
+                                   LocalsHandler locals));
   void close();
   final TargetElement target;
   List<LabelElement> labels();
 }
 
 // Insert break handler used to avoid null checks when a target isn't
 // used as the target of a break, and therefore doesn't need a break
 // handler associated with it.
 class NullJumpHandler implements JumpHandler {
   const NullJumpHandler();
@@ skipping 1323 matching lines @@
       HStatic target = new HStatic(element);
       add(target);
       List<HInstruction> inputs = <HInstruction>[target];
       addGenericSendArgumentsToList(link, inputs);
       push(new HInvokeStatic(Selector.INVOCATION_0, inputs));
     }
   }
 
   void handleForeignDartClosureToJs(Send node) {
     if (node.arguments.isEmpty() || !node.arguments.tail.isEmpty()) {
-      compiler.cancel('Exactly one argument required', node: node.arguments);
+      compiler.cancel('Exactly one argument required',
+                      node: node.argumentsNode);
     }
     Node closure = node.arguments.head;
     Element element = elements[closure];
     if (!Elements.isStaticOrTopLevelFunction(element)) {
       compiler.cancel(
           'JS_TO_CLOSURE requires a static or top-level method',
           node: closure);
     }
     FunctionElement function = element;
-    FunctionParameters parameters = element.computeParameters(compiler);
+    FunctionParameters parameters = function.computeParameters(compiler);
     if (parameters.optionalParameterCount !== 0) {
       compiler.cancel(
           'JS_TO_CLOSURE does not handle closure with optional parameters',
           node: closure);
     }
     visit(closure);
     List<HInstruction> inputs = <HInstruction>[pop()];
     String invocationName = compiler.namer.closureInvocationName(
         new Selector(SelectorKind.INVOCATION,
                      parameters.requiredParameterCount));
@@ skipping 28 matching lines @@
     Element element = elements[node];
     if (element === null) {
       ClassElement cls = work.element.getEnclosingClass();
       element = cls.lookupSuperMember(Compiler.NO_SUCH_METHOD);
       HStatic target = new HStatic(element);
       add(target);
       HInstruction self = localsHandler.readThis();
       Identifier identifier = node.selector.asIdentifier();
       String name = identifier.source.slowToString();
       // TODO(ahe): Add the arguments to this list.
-      push(new HLiteralList([], true));
+      push(new HLiteralList([]));
       var inputs = <HInstruction>[
           target,
           self,
           graph.addConstantString(new DartString.literal(name)),
           pop()];
       push(new HInvokeSuper(const Selector(SelectorKind.INVOCATION, 2),
                             inputs));
       return;
     }
     HInstruction target = new HStatic(element);
@@ skipping 280 matching lines @@
       return;
     }
 
     List<HInstruction> inputs = <HInstruction>[];
     for (Link<Node> link = node.elements.nodes;
          !link.isEmpty();
          link = link.tail) {
       visit(link.head);
       inputs.add(pop());
     }
-    push(new HLiteralList(inputs, node.isConst()));
+    push(new HLiteralList(inputs));
   }
 
   visitConditional(Conditional node) {
     visit(node.condition);
     HIf condition = new HIf(popBoolified(), true);
     HBasicBlock conditionBlock = close(condition);
     LocalsHandler savedLocals = new LocalsHandler.from(localsHandler);
 
     HBasicBlock thenBlock = addNewBlock();
     conditionBlock.addSuccessor(thenBlock);
@@ skipping 197 matching lines @@
       return;
     }
     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, node.isConst());
+    HLiteralList keyValuePairs = new HLiteralList(inputs);
     HStatic mapMaker = new HStatic(interceptors.getMapMaker());
     add(keyValuePairs);
     add(mapMaker);
     inputs = <HInstruction>[mapMaker, keyValuePairs];
     push(new HInvokeStatic(Selector.INVOCATION_1, inputs));
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
@@ skipping 309 matching lines @@
    */
   HInstruction prefix = null;
 
   StringBuilderVisitor(this.builder, this.offset);
 
   void visit(Node node) {
     node.accept(this);
   }
 
   visitNode(Node node) {
-    compiler.internalError('unexpected node', node: node);
+    builder.compiler.internalError('unexpected node', node: node);
   }
 
   void visitExpression(Node node) {
     flushLiterals();
     node.accept(builder);
     HInstruction asString = buildToString(node, builder.pop());
     prefix = concat(prefix, asString);
   }
 
   void visitLiteralNull(LiteralNull node) {
@@ skipping 102 matching lines @@
                                         false,
                                         <HInstruction>[target, input]));
     return builder.pop();
   }
 
   HInstruction result() {
     flushLiterals();
     return prefix;
   }
 }