Update to use the latest analyzer

lib/src/checker/resolver.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.
 
 /// Encapsulates how to invoke the analyzer resolver and overrides how it
 /// computes types on expressions to use our restricted set of types.
 library dev_compiler.src.checker.resolver;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 512 matching lines @@
       return null;
     }
     if (_visitedInitializers.contains(node)) return null;
     assert(node is! Statement || !skipMethodBodies);
     return super.visitNode(node);
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     if (skipMethodBodies) {
-      node.accept(elementResolver_J2DAccessor);
-      node.accept(typeAnalyzer_J2DAccessor);
+      node.accept(elementResolver);
+      node.accept(typeAnalyzer);
       return null;
     } else {
       return super.visitMethodDeclaration(node);
     }
   }
 
   @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     if (skipMethodBodies) {
-      node.accept(elementResolver_J2DAccessor);
-      node.accept(typeAnalyzer_J2DAccessor);
+      node.accept(elementResolver);
+      node.accept(typeAnalyzer);
       return null;
     } else {
       return super.visitFunctionDeclaration(node);
     }
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     if (skipMethodBodies) {
-      node.accept(elementResolver_J2DAccessor);
-      node.accept(typeAnalyzer_J2DAccessor);
+      node.accept(elementResolver);
+      node.accept(typeAnalyzer);
       return null;
     } else {
       return super.visitConstructorDeclaration(node);
     }
   }
 }
 
 /// Internal state of the resolver, stored so we can reanalyze portions of the
 /// AST quickly, without recomputing everything from the top.
 class _ResolverState {
   final TypePromotionManager_TypePromoteScope promotionScope;
   final TypeOverrideManager_TypeOverrideScope overrideScope;
   final Scope nameScope;
 
   _ResolverState(ResolverVisitor visitor)
       : promotionScope = visitor.promoteManager.currentScope,
         overrideScope = visitor.overrideManager.currentScope,
         nameScope = visitor.nameScope;
 
   void restore(ResolverVisitor visitor) {
     visitor.promoteManager.currentScope = promotionScope;
     visitor.overrideManager.currentScope = overrideScope;
-    visitor.nameScope_J2DAccessor = nameScope;
+    visitor.nameScope = nameScope;
   }
 }
 
 /// Overrides the default [StaticTypeAnalyzer] to adjust rules that are stricter
 /// in the restricted type system and to infer types for untyped local
 /// variables.
 class RestrictedStaticTypeAnalyzer extends StaticTypeAnalyzer {
   final TypeProvider _typeProvider;
 
   RestrictedStaticTypeAnalyzer(ResolverVisitor r)
@@ skipping 119 matching lines @@
     }
   }
 
   // Review note: no longer need to override visitFunctionExpression, this is
   // handled by the analyzer internally.
   // TODO(vsm): in visitbinaryExpression: check computeStaticReturnType result?
   // TODO(vsm): in visitFunctionDeclaration: Should we ever use the expression
   // type in a (...) => expr or just the written type?
 
 }