All strong mode cleaning of dart2js.

tests/compiler/dart2js/resolver_test.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.
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 import 'package:compiler/src/constants/expressions.dart';
@@ skipping 116 matching lines @@
       Expect.equals('[ B, L1, A, J2, J1, I2, I1, K2, K1, Object ]',
           classC.allSupertypes.toString());
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.parseScript("""
 class X<T> {}
 class Foo extends X<Foo> {}
 class Bar extends Foo implements X<Bar> {}
 """);
       compiler.resolveStatement("Bar bar;");
-      LibraryElement mainApp = compiler.mainApp;
-      ClassElement classBar = mainApp.find("Bar");
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, collector.warnings.length);
       Expect.equals(1, collector.errors.length);
       Expect.equals(
           MessageKind.MULTI_INHERITANCE, collector.errors.first.message.kind);
       Expect.equals(0, collector.crashes.length);
     }),
   ]);
 }
 
@@ skipping 133 matching lines @@
       ResolverVisitor visitor = new ResolverVisitor(
           compiler.resolution,
           funElement,
           new ResolutionRegistry(
               compiler.backend.target, new CollectingTreeElements(funElement)),
           scope: new MockTypeVariablesScope(fooElement.buildScope()));
       FunctionExpression function =
           (funElement as FunctionElementX).parseNode(compiler.parsingContext);
       visitor.visit(function.body);
       Map mapping = map(visitor);
-      List<Element> values = mapping.values.toList();
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, mapping.length);
       Expect.equals(0, collector.warnings.length);
     }),
     MockCompiler.create((MockCompiler compiler) {
       compiler.resolveStatement("main() { return this; }");
       DiagnosticCollector collector = compiler.diagnosticCollector;
       Expect.equals(0, collector.warnings.length);
       Expect.equals(1, collector.errors.length);
       Expect.equals(MessageKind.NO_INSTANCE_AVAILABLE,
@@ skipping 318 matching lines @@
     Expect.equals(
         new Message(MessageTemplate.TEMPLATES[MessageKind.CANNOT_RESOLVE_TYPE],
             {'typeName': 'bar'}, false),
         collector.errors.first.message);
     collector.clear();
 
     // Add the abstract class to the world and make sure everything is setup
     // correctly.
     compiler.parseScript("abstract class Bar {}");
 
-    ResolverVisitor visitor = new ResolverVisitor(
-        compiler.resolution,
-        null,
-        new ResolutionRegistry(
-            compiler.backend.target, new CollectingTreeElements(null)));
     compiler.resolveStatement("Foo bar;");
 
     LibraryElement mainApp = compiler.mainApp;
     ClassElement fooElement = mainApp.find('Foo');
     ClassElement barElement = mainApp.find('Bar');
 
     Expect.equals(null, barElement.supertype);
     Expect.isTrue(barElement.interfaces.isEmpty);
 
     Expect.equals(barElement.computeType(compiler.resolution),
@@ skipping 922 matching lines @@
       functionName: 'm');
   check(
       '''
     class A {
       m() => () => await - 3;
     }
     main() => new A().m();
   ''',
       className: 'A');
 }