Fix dart2js warnings and add test to ensure it stays clean.

pkg/compiler/lib/src/ssa/kernel_ast_adapter.dart

 // Copyright (c) 2016, 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 'package:js_runtime/shared/embedded_names.dart';
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../compiler.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
 import '../common_elements.dart';
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/modelx.dart';
-import '../elements/types.dart';
 import '../js/js.dart' as js;
 import '../js_backend/js_backend.dart';
 import '../kernel/element_adapter.dart';
 import '../kernel/kernel.dart';
-import '../kernel/kernel_debug.dart';
 import '../native/native.dart' as native;
 import '../resolution/tree_elements.dart';
 import '../tree/tree.dart' as ast;
 import '../types/masks.dart';
 import '../types/types.dart';
 import '../universe/selector.dart';
 import '../universe/side_effects.dart';
 import '../world.dart';
 import 'graph_builder.dart';
 import 'jump_handler.dart' show SwitchCaseJumpHandler;
@@ skipping 335 matching lines @@
       return field.constant == null;
     }
     return false;
   }
 
   LibraryElement get jsHelperLibrary => _backend.helpers.jsHelperLibrary;
 
   KernelJumpTarget getJumpTarget(ir.TreeNode node,
       {bool isContinueTarget: false}) {
     return _jumpTargets.putIfAbsent(node, () {
-      if (node is ir.LabeledStatement &&
-          _jumpTargets.containsKey((node as ir.LabeledStatement).body)) {
-        return _jumpTargets[(node as ir.LabeledStatement).body];
+      if (node is ir.LabeledStatement && _jumpTargets.containsKey(node.body)) {
+        return _jumpTargets[node.body];
       }
       return new KernelJumpTarget(node, this,
           makeContinueLabel: isContinueTarget);
     });
   }
 
   ir.Procedure get checkDeferredIsLoaded =>
       kernel.functions[_backend.helpers.checkDeferredIsLoaded];
 
   TypeMask get checkDeferredIsLoadedType =>
@@ skipping 27 matching lines @@
 
   TypeMask get traceFromExceptionType =>
       TypeMaskFactory.inferredReturnTypeForElement(
           _backend.helpers.traceFromException, _globalInferenceResults);
 
   ir.Procedure get streamIteratorConstructor =>
       kernel.functions[_backend.helpers.streamIteratorConstructor];
 
   TypeMask get streamIteratorConstructorType =>
       TypeMaskFactory.inferredReturnTypeForElement(
+          // ignore: UNNECESSARY_CAST
           _backend.helpers.streamIteratorConstructor as FunctionEntity,
           _globalInferenceResults);
 
   ir.Procedure get fallThroughError =>
       kernel.functions[_backend.helpers.fallThroughError];
 
   TypeMask get fallThroughErrorType =>
       TypeMaskFactory.inferredReturnTypeForElement(
           _backend.helpers.fallThroughError, _globalInferenceResults);
 
@@ skipping 167 matching lines @@
 
   ResolutionInterfaceType getInterfaceType(ir.InterfaceType type) =>
       getDartType(type);
 
   ResolutionInterfaceType createInterfaceType(
       ir.Class cls, List<ir.DartType> typeArguments) {
     return new ResolutionInterfaceType(
         getClass(cls), getDartTypes(typeArguments));
   }
 
-  @override
-  InterfaceType getThisType(ir.Class cls) {
-    return getClass(cls).thisType;
-  }
-
   MemberEntity getConstructorBodyEntity(ir.Constructor constructor) {
     AstElement element = getElement(constructor);
     MemberEntity constructorBody =
         ConstructorBodyElementX.createFromResolvedAst(element.resolvedAst);
     assert(constructorBody != null);
     return constructorBody;
   }
 }
 
 /// Visitor that converts kernel dart types into [ResolutionDartType].
@@ skipping 193 matching lines @@
       JumpTarget continueTarget =
           astAdapter.getJumpTarget(switchCase, isContinueTarget: true);
       assert(continueTarget is KernelJumpTarget);
       targetIndexMap[continueTarget] = switchIndex;
       assert(builder.jumpTargets[continueTarget] == null);
       builder.jumpTargets[continueTarget] = this;
       switchIndex++;
     }
   }
 }