Fix most warnings and other minor 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 141 matching lines @@
       functionsCalledInLoop = new Set<FunctionElement>(),
       selectorsCalledInLoop = new Map<SourceString, Selector>(),
       super(backend.compiler);
 
   HGraph build(WorkItem work) {
     return measure(() {
       FunctionElement element = work.element;
       HInstruction.idCounter = 0;
       SsaBuilder builder = new SsaBuilder(this, work);
       HGraph graph;
-      switch (element.kind) {
-        case ElementKind.GENERATIVE_CONSTRUCTOR:
-          graph = compileConstructor(builder, work);
-          break;
-        case ElementKind.GENERATIVE_CONSTRUCTOR_BODY:
-        case ElementKind.FUNCTION:
-        case ElementKind.GETTER:
-        case ElementKind.SETTER:
-          graph = builder.buildMethod(work.element);
-          break;
+      ElementKind kind = element.kind;
+      if (kind === ElementKind.GENERATIVE_CONSTRUCTOR) {
+        graph = compileConstructor(builder, work);
+      } else if (kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY ||

[karlklose, 2012/06/15 12:43:46]

break before ||?

+                 kind === ElementKind.FUNCTION ||
+                 kind === ElementKind.GETTER ||
+                 kind === ElementKind.SETTER) {
+        graph = builder.buildMethod(work.element);
       }
       assert(graph.isValid());
       bool inLoop = functionsCalledInLoop.contains(element);
       if (!inLoop) {
         Selector selector = selectorsCalledInLoop[element.name];
         inLoop = selector !== null && selector.applies(element, compiler);
       }
       graph.calledInLoop = inLoop;
       if (compiler.tracer.enabled) {
         String name;
@@ skipping 724 matching lines @@
                                                   compiledArguments);
     if (!succeeded) {
       // Non-matching super and redirects are compile-time errors and thus
       // checked by the resolver.
       compiler.internalError(
           "Parameters and arguments didn't match for super/redirect call",
           element: constructor);
     }
 
     int index = 0;
-    FunctionSignature parameters = constructor.computeSignature(compiler);
-    parameters.forEachParameter((Element parameter) {
+    FunctionSignature params = constructor.computeSignature(compiler);

[karlklose, 2012/06/15 12:43:46]

I would prefer the name parameters.

[floitsch, 2012/06/15 13:05:17]

Renamed to "signature".

+    params.forEachParameter((Element parameter) {
       HInstruction argument = compiledArguments[index++];
       localsHandler.updateLocal(parameter, argument);
       // Don't forget to update the field, if the parameter is of the
       // form [:this.x:].
       if (parameter.kind == ElementKind.FIELD_PARAMETER) {
         FieldParameterElement fieldParameterElement = parameter;
         fieldValues[fieldParameterElement.fieldElement] = argument;
       }
     });
 
@@ skipping 77 matching lines @@
                       FunctionElement functionElement) {
     FunctionExpression function = functionElement.parseNode(compiler);
     // Note that constructors (like any other static function) do not need
     // to deal with optional arguments. It is the callers job to provide all
     // arguments as if they were positional.
 
     // The initializer list could contain closures.
     openFunction(functionElement, function);
 
     Map<Element, HInstruction> fieldValues = new Map<Element, HInstruction>();
-    FunctionSignature parameters = functionElement.computeSignature(compiler);
-    parameters.forEachParameter((Element element) {
+    FunctionSignature params = functionElement.computeSignature(compiler);
+    params.forEachParameter((Element element) {
       if (element.kind == ElementKind.FIELD_PARAMETER) {
         // If the [element] is a field-parameter (such as [:this.x:] then
         // initialize the field element with its value.
         FieldParameterElement fieldParameterElement = element;
         HInstruction parameterValue = localsHandler.readLocal(element);
         fieldValues[fieldParameterElement.fieldElement] = parameterValue;
       }
     });
 
     final Map<FunctionElement, TreeElements> constructorElements =
@@ skipping 1213 matching lines @@
                       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;
-    FunctionSignature parameters = function.computeSignature(compiler);
-    if (parameters.optionalParameterCount !== 0) {
+    FunctionSignature params = function.computeSignature(compiler);
+    if (params.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));
+        new Selector(SelectorKind.INVOCATION, params.requiredParameterCount));
     push(new HForeign(new DartString.literal('#.$invocationName'),
                       const LiteralDartString('var'),
                       inputs));
   }
 
   visitForeignSend(Send node) {
     Element element = elements[node];
     if (element.name == const SourceString('JS')) {
       handleForeignJs(node);
     } else if (element.name == const SourceString('UNINTERCEPTED')) {
@@ skipping 1146 matching lines @@
 
 /**
  * Visitor that handles generation of string literals (LiteralString,
  * StringInterpolation), and otherwise delegates to the given visitor for
  * non-literal subexpressions.
  * TODO(lrn): Consider whether to handle compile time constant int/boolean
  * expressions as well.
  */
 class StringBuilderVisitor extends AbstractVisitor {
   final SsaBuilder builder;
-  final Node node;
+  final Node diagnosticNode;
 
   /**
    * The string value generated so far.
    */
   HInstruction result = null;
 
-  StringBuilderVisitor(this.builder, this.node);
+  StringBuilderVisitor(this.builder, this.diagnosticNode);
 
   void visit(Node node) {
     node.accept(this);
   }
 
   visitNode(Node node) {
     builder.compiler.internalError('unexpected node', node: node);
   }
 
   void visitExpression(Node node) {
@@ skipping 13 matching lines @@
 
   void visitStringJuxtaposition(StringJuxtaposition node) {
     node.visitChildren(this);
   }
 
   void visitNodeList(NodeList node) {
      node.visitChildren(this);
   }
 
   HInstruction concat(HInstruction left, HInstruction right) {
-    HInstruction instruction = new HStringConcat(left, right, node);
+    HInstruction instruction = new HStringConcat(left, right, diagnosticNode);
     builder.add(instruction);
     return instruction;
   }
 }