Resolve obvious deprecation warnings on bleeding edge

lib/src/codegen/reify_coercions.dart

 // Copyright (c) 2015, 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:analyzer/analyzer.dart' as analyzer;
-import 'package:analyzer/src/generated/ast.dart';
-import 'package:analyzer/src/generated/element.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/ast/utilities.dart' show NodeReplacer;
 import 'package:analyzer/src/generated/type_system.dart'
     show StrongTypeSystemImpl;
 import 'package:logging/logging.dart' as logger;
 
 import '../info.dart';
-
+import '../utils.dart' show getStaticType;
 import 'ast_builder.dart';
 
 final _log = new logger.Logger('dev_compiler.reify_coercions');
 
 class NewTypeIdDesc {
   /// If null, then this is not a library level identifier (i.e. it's
   /// a type parameter, or a special type like void, dynamic, etc)
   LibraryElement importedFrom;
 
   /// True => use/def in same library
@@ skipping 28 matching lines @@
     } else if (info is DownCast) {
       return _visitDownCast(info, node);
     }
     return super.visitExpression(node);
   }
 
   ///////////////// Private //////////////////////////////////
 
   Object _visitInferredTypeBase(InferredTypeBase node, Expression expr) {
     DartType t = node.type;
-    if (!_typeSystem.isSubtypeOf(_getStaticType(expr), t)) {
-      if (_getStaticType(expr).isDynamic) {
+    if (!_typeSystem.isSubtypeOf(getStaticType(expr), t)) {
+      if (getStaticType(expr).isDynamic) {
         var cast = Coercion.cast(expr.staticType, t);
         var info = new DynamicCast(_typeSystem, expr, cast);
         CoercionInfo.set(expr, info);
       }
     }
     expr.visitChildren(this);
     return null;
   }
 
   Object _visitDownCast(DownCast node, Expression expr) {
     var parent = expr.parent;
     expr.visitChildren(this);
     Expression newE = coerceExpression(expr, node.cast);
     if (!identical(expr, newE)) {
       var replaced = parent.accept(new NodeReplacer(expr, newE));
       // It looks like NodeReplacer will always return true.
       // It does throw IllegalArgumentException though, if child is not found.
       assert(replaced);
     }
     return null;
   }
 
-  DartType _getStaticType(Expression expr) {
-    return expr.staticType ?? DynamicTypeImpl.instance;
-  }
-
   /// Coerce [e] using [c], returning a new expression.
   Expression coerceExpression(Expression e, Coercion c) {
     assert(c != null);
     assert(c is! CoercionError);
     if (e is NamedExpression) {
       Expression inner = coerceExpression(e.expression, c);
       return new NamedExpression(e.name, inner);
     }
     if (c is Cast) return _castExpression(e, c);
     assert(c is Identity);
     return e;
   }
 
   ///////////////// Private //////////////////////////////////
 
   Expression _castExpression(Expression e, Cast c) {
     // We use an empty name in the AST, because the JS code generator only cares
     // about the target type. It does not look at the AST name.
     var typeName = new TypeName(AstBuilder.identifierFromString(''), null);
     typeName.type = c.toType;
     var cast = AstBuilder.asExpression(e, typeName);
     cast.staticType = c.toType;
     return cast;
   }
 }