Fix warnings in dart2js code and re-enable analyzer coverage.

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 1160 matching lines @@
    */
   void inlineSuperOrRedirect(FunctionElement constructor,
                              Selector selector,
                              Link<Node> arguments,
                              List<FunctionElement> constructors,
                              Map<Element, HInstruction> fieldValues,
                              FunctionElement inlinedFromElement,
                              Node callNode) {
     compiler.withCurrentElement(constructor, () {
       assert(invariant(constructor, constructor.isImplementation));
-      constructors.addLast(constructor);
+      constructors.add(constructor);
 
       List<HInstruction> compiledArguments = new List<HInstruction>();
       bool succeeded =
           inlinedFrom(inlinedFromElement,
                        () => addStaticSendArgumentsToList(selector,
                                                           arguments,
                                                           constructor,
                                                           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);
       }
 
       ClassElement superclass = constructor.getEnclosingClass();
       if (compiler.world.needsRti(superclass)) {
         // If [superclass] needs RTI, we have to give a value to its
         // type parameters. Those values are in the [supertype]
         // declaration of [subclass].
         ClassElement subclass = inlinedFromElement.getEnclosingClass();
-        DartType supertype = subclass.supertype;
+        GenericType supertype = subclass.supertype;

[karlklose, 2013/03/06 09:48:21]

You could instead change the type of ClassElement.supertype to InterfaceType and
inline supertype.

         Link<DartType> typeVariables = superclass.typeVariables;
         supertype.typeArguments.forEach((DartType argument) {
           localsHandler.updateLocal(typeVariables.head.element,
               analyzeTypeArgument(argument, callNode));
           typeVariables = typeVariables.tail;
         });
         // If the supertype is a raw type, we need to set to null the
         // type variables.
         assert(typeVariables.isEmpty
                || superclass.typeVariables == typeVariables);
@@ skipping 2880 matching lines @@
       ConstantHandler handler = compiler.constantHandler;
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
       stack.add(graph.addConstant(constant));
       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());
+      inputs.add(pop());
+      inputs.add(pop());
     }
     HLiteralList keyValuePairs = new HLiteralList(inputs);
     add(keyValuePairs);
     DartType mapType = compiler.mapLiteralClass.computeType(compiler);
     // TODO(ngeoffray): Use the actual implementation type of a map
     // literal.
     pushInvokeHelper1(backend.getMapMaker(), keyValuePairs,
         new HType.nonNullSubtype(mapType, compiler));
   }
 
@@ skipping 978 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;
   }
 }