dart2js: Fix hints in code base.

pkg/compiler/lib/src/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;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 2243 matching lines @@
       if (isNativeUpgradeFactory) {
         if (interceptor == null) {
           ConstantValue constant =
               new InterceptorConstantValue(classElement.thisType);
           interceptor = graph.addConstant(constant, compiler);
         }
         bodyCallInputs.add(interceptor);
       }
       bodyCallInputs.add(newObject);
       ResolvedAst resolvedAst = constructor.resolvedAst;
-      TreeElements elements = resolvedAst.elements;
       ast.Node node = resolvedAst.node;
       ClosureClassMap parameterClosureData =
           compiler.closureToClassMapper.getMappingForNestedFunction(node);
 
       FunctionSignature functionSignature = body.functionSignature;
       // Provide the parameters to the generative constructor body.
       functionSignature.orderedForEachParameter((ParameterElement parameter) {
         // If [parameter] is boxed, it will be a field in the box passed as the
         // last parameter. So no need to directly pass it.
         if (!localsHandler.isBoxed(parameter)) {
@@ skipping 504 matching lines @@
 
       if (bodyBlock != null) {
         continueHandlers.add(localsHandler);
         bodyBlock.addSuccessor(updateBlock);
       }
 
       open(updateBlock);
       localsHandler =
           continueHandlers[0].mergeMultiple(continueHandlers, updateBlock);
 
-      HLabeledBlockInformation labelInfo;
       List<LabelDefinition> labels = jumpHandler.labels();
       JumpTarget target = elements.getTargetDefinition(loop);
       if (!labels.isEmpty) {
         beginBodyBlock.setBlockFlow(
             new HLabeledBlockInformation(
                 new HSubGraphBlockInformation(bodyGraph),
                 jumpHandler.labels(),
                 isContinue: true),
             updateBlock);
       } else if (target != null && target.isContinueTarget) {
@@ skipping 115 matching lines @@
       }
       visit(node.condition);
       return popBoolified();
     }
     void buildUpdate() {
       for (ast.Expression expression in node.update) {
         visit(expression);
         assert(!isAborted());
         // The result of the update instruction isn't used, and can just
         // be dropped.
-        HInstruction updateInstruction = pop();
+        pop();
       }
     }
     void buildBody() {
       visit(node.body);
     }
     handleLoop(node, buildInitializer, buildCondition, buildUpdate, buildBody);
   }
 
   visitWhile(ast.While node) {
     assert(isReachable);
@@ skipping 688 matching lines @@
   // (dartbug.com/7182).
   HInstruction buildTypeArgumentRepresentations(DartType type) {
     // Compute the representation of the type arguments, including access
     // to the runtime type information for type variables as instructions.
     if (type.isTypeVariable) {
       return buildLiteralList(<HInstruction>[addTypeVariableReference(type)]);
     } else {
       assert(type.element.isClass);
       InterfaceType interface = type;
       List<HInstruction> inputs = <HInstruction>[];
-      bool first = true;
       List<js.Expression> templates = <js.Expression>[];
       for (DartType argument in interface.typeArguments) {
         // As we construct the template in stages, we have to make sure that for
         // each part the generated sub-template's holes match the index of the
         // inputs that are later used to instantiate it. We do this by starting
         // the indexing with the number of inputs from previous sub-templates.
         templates.add(
             rti.getTypeRepresentationWithPlaceholders(argument, (variable) {
               HInstruction runtimeType = addTypeVariableReference(variable);
               inputs.add(runtimeType);
@@ skipping 2877 matching lines @@
 
     InterfaceType type = elements.getType(node);
     InterfaceType expectedType =
         functionElement.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
     ClassElement cls = constructor.enclosingClass;
 
     if (backend.classNeedsRti(cls)) {
       List<HInstruction> typeInputs = <HInstruction>[];
-      List<DartType> typeVariable = cls.typeVariables;
       expectedType.typeArguments.forEach((DartType argument) {
         typeInputs.add(analyzeTypeArgument(argument));
       });
 
       // We lift this common call pattern into a helper function to save space
       // in the output.
       if (typeInputs.every((HInstruction input) => input.isNull())) {
         if (listInputs.isEmpty) {
           constructor = backend.mapLiteralUntypedEmptyMaker;
         } else {
@@ skipping 277 matching lines @@
    */
   void handleSwitch(
       ast.Node errorNode,
       JumpHandler jumpHandler,
       HInstruction buildExpression(),
       var switchCases,
       Iterable<ConstantValue> getConstants(ast.SwitchCase switchCase),
       bool isDefaultCase(ast.SwitchCase switchCase),
       void buildSwitchCase(ast.SwitchCase switchCase)) {
 
-    Map<ast.CaseMatch, ConstantValue> constants =
-        new Map<ast.CaseMatch, ConstantValue>();
-
     HBasicBlock expressionStart = openNewBlock();
     HInstruction expression = buildExpression();
     if (switchCases.isEmpty) {
       return;
     }
 
     HSwitch switchInstruction = new HSwitch(<HInstruction>[expression]);
     HBasicBlock expressionEnd = close(switchInstruction);
     LocalsHandler savedLocals = localsHandler;
 
@@ skipping 1036 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }