Issue 22521. Drop '_J2DAccessor' suffixes.

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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.
 
 library engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 10069 matching lines @@
  */
 class ResolverVisitor extends ScopedVisitor {
   /**
    * The manager for the inheritance mappings.
    */
   InheritanceManager _inheritanceManager;
 
   /**
    * The object used to resolve the element associated with the current node.
    */
-  ElementResolver _elementResolver;
+  ElementResolver elementResolver;
 
   /**
    * The object used to compute the type associated with the current node.
    */
-  StaticTypeAnalyzer _typeAnalyzer;
+  StaticTypeAnalyzer typeAnalyzer;
 
   /**
    * The class element representing the class containing the current node,
    * or `null` if the current node is not contained in a class.
    */
   ClassElement enclosingClass = null;
 
   /**
    * The class declaration representing the class containing the current node, or `null` if
    * the current node is not contained in a class.
@@ skipping 44 matching lines @@
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ResolverVisitor.con1(
       Library library, Source source, TypeProvider typeProvider,
       {StaticTypeAnalyzer typeAnalyzer,
       StaticTypeAnalyzerFactory typeAnalyzerFactory})
       : super.con1(library, source, typeProvider) {
     this._inheritanceManager = library.inheritanceManager;
-    this._elementResolver = new ElementResolver(this);
-    this._typeAnalyzer = typeAnalyzer != null
+    this.elementResolver = new ElementResolver(this);
+    this.typeAnalyzer = typeAnalyzer != null
         ? typeAnalyzer
         : (typeAnalyzerFactory != null
             ? typeAnalyzerFactory(this)
             : new StaticTypeAnalyzer(this));
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
   ResolverVisitor.con2(LibraryElement definingLibrary, Source source,
       TypeProvider typeProvider, InheritanceManager inheritanceManager,
       AnalysisErrorListener errorListener)
       : super.con2(definingLibrary, source, typeProvider, errorListener) {
     this._inheritanceManager = inheritanceManager;
-    this._elementResolver = new ElementResolver(this);
-    this._typeAnalyzer = new StaticTypeAnalyzer(this);
+    this.elementResolver = new ElementResolver(this);
+    this.typeAnalyzer = new StaticTypeAnalyzer(this);
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in an AST node.
    *
    * @param definingLibrary the element for the library containing the node being visited
    * @param source the source representing the compilation unit containing the node being visited
    * @param typeProvider the object used to access the types from the core library
    * @param nameScope the scope used to resolve identifiers in the node that will first be visited
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
   ResolverVisitor.con3(LibraryElement definingLibrary, Source source,
       TypeProvider typeProvider, Scope nameScope,
       AnalysisErrorListener errorListener)
       : super.con3(
           definingLibrary, source, typeProvider, nameScope, errorListener) {
     this._inheritanceManager = new InheritanceManager(definingLibrary);
-    this._elementResolver = new ElementResolver(this);
-    this._typeAnalyzer = new StaticTypeAnalyzer(this);
+    this.elementResolver = new ElementResolver(this);
+    this.typeAnalyzer = new StaticTypeAnalyzer(this);
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ResolverVisitor.con4(
       ResolvableLibrary library, Source source, TypeProvider typeProvider)
       : super.con4(library, source, typeProvider) {
     this._inheritanceManager = library.inheritanceManager;
-    this._elementResolver = new ElementResolver(this);
-    this._typeAnalyzer = new StaticTypeAnalyzer(this);
+    this.elementResolver = new ElementResolver(this);
+    this.typeAnalyzer = new StaticTypeAnalyzer(this);
   }
 
-  get elementResolver_J2DAccessor => _elementResolver;
-
-  set elementResolver_J2DAccessor(__v) => _elementResolver = __v;
-
   /**
    * Return the element representing the function containing the current node, or `null` if
    * the current node is not contained in a function.
    *
    * @return the element representing the function containing the current node
    */
   ExecutableElement get enclosingFunction => _enclosingFunction;
 
-  get labelScope_J2DAccessor => _labelScope;
-
-  set labelScope_J2DAccessor(__v) => _labelScope = __v;
-
-  get nameScope_J2DAccessor => _nameScope;
-
-  set nameScope_J2DAccessor(__v) => _nameScope = __v;
-
   /**
    * Return the object keeping track of which elements have had their types overridden.
    *
    * @return the object keeping track of which elements have had their types overridden
    */
   TypeOverrideManager get overrideManager => _overrideManager;
 
   /**
    * Return the object keeping track of which elements have had their types promoted.
    *
    * @return the object keeping track of which elements have had their types promoted
    */
   TypePromotionManager get promoteManager => _promoteManager;
 
-  get typeAnalyzer_J2DAccessor => _typeAnalyzer;
-
-  set typeAnalyzer_J2DAccessor(__v) => _typeAnalyzer = __v;
-
   /**
    * Return the propagated element associated with the given expression whose type can be
    * overridden, or `null` if there is no element whose type can be overridden.
    *
    * @param expression the expression with which the element is associated
    * @return the element associated with the given expression
    */
   VariableElement getOverridablePropagatedElement(Expression expression) {
     Element element = null;
     if (expression is SimpleIdentifier) {
@@ skipping 211 matching lines @@
           _propagateFalseState(leftOperand);
           rightOperand.accept(this);
         } finally {
           _overrideManager.exitScope();
         }
       }
     } else {
       safelyVisit(leftOperand);
       safelyVisit(rightOperand);
     }
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     safelyVisit(_commentBeforeFunction);
     _overrideManager.enterScope();
     try {
       super.visitBlockFunctionBody(node);
     } finally {
       _overrideManager.exitScope();
     }
     return null;
   }
 
   @override
   Object visitBreakStatement(BreakStatement node) {
     //
     // We do not visit the label because it needs to be visited in the context
     // of the statement.
     //
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     //
     // Resolve the metadata in the library scope.
     //
     if (node.metadata != null) {
       node.metadata.accept(this);
     }
     _enclosingClassDeclaration = node;
     //
     // Continue the class resolution.
     //
     ClassElement outerType = enclosingClass;
     try {
       enclosingClass = node.element;
-      _typeAnalyzer.thisType =
+      typeAnalyzer.thisType =
           enclosingClass == null ? null : enclosingClass.type;
       super.visitClassDeclaration(node);
-      node.accept(_elementResolver);
-      node.accept(_typeAnalyzer);
+      node.accept(elementResolver);
+      node.accept(typeAnalyzer);
     } finally {
-      _typeAnalyzer.thisType = outerType == null ? null : outerType.type;
+      typeAnalyzer.thisType = outerType == null ? null : outerType.type;
       enclosingClass = outerType;
       _enclosingClassDeclaration = null;
     }
     return null;
   }
 
   /**
    * Implementation of this method should be synchronized with
    * [visitClassDeclaration].
    */
   visitClassDeclarationIncrementally(ClassDeclaration node) {
     //
     // Resolve the metadata in the library scope.
     //
     if (node.metadata != null) {
       node.metadata.accept(this);
     }
     _enclosingClassDeclaration = node;
     //
     // Continue the class resolution.
     //
     enclosingClass = node.element;
-    _typeAnalyzer.thisType =
-        enclosingClass == null ? null : enclosingClass.type;
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    typeAnalyzer.thisType = enclosingClass == null ? null : enclosingClass.type;
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
   }
 
   @override
   Object visitComment(Comment node) {
     if (node.parent is FunctionDeclaration ||
         node.parent is ConstructorDeclaration ||
         node.parent is MethodDeclaration) {
       if (!identical(node, _commentBeforeFunction)) {
         _commentBeforeFunction = node;
         return null;
       }
     }
     super.visitComment(node);
     _commentBeforeFunction = null;
     return null;
   }
 
   @override
   Object visitCommentReference(CommentReference node) {
     //
     // We do not visit the identifier because it needs to be visited in the
     // context of the reference.
     //
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitCompilationUnit(CompilationUnit node) {
     //
     // TODO(brianwilkerson) The goal of the code below is to visit the
     // declarations in such an order that we can infer type information for
     // top-level variables before we visit references to them. This is better
     // than making no effort, but still doesn't completely satisfy that goal
@@ skipping 19 matching lines @@
       }
       for (int i = 0; i < declarationCount; i++) {
         CompilationUnitMember declaration = declarations[i];
         if (declaration is ClassDeclaration) {
           declaration.accept(this);
         }
       }
     } finally {
       _overrideManager.exitScope();
     }
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitConditionalExpression(ConditionalExpression node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Expression thenExpression = node.thenExpression;
     if (thenExpression != null) {
       _overrideManager.enterScope();
@@ skipping 18 matching lines @@
     Expression elseExpression = node.elseExpression;
     if (elseExpression != null) {
       _overrideManager.enterScope();
       try {
         _propagateFalseState(condition);
         elseExpression.accept(this);
       } finally {
         _overrideManager.exitScope();
       }
     }
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     bool thenIsAbrupt = _isAbruptTerminationExpression(thenExpression);
     bool elseIsAbrupt = _isAbruptTerminationExpression(elseExpression);
     if (elseIsAbrupt && !thenIsAbrupt) {
       _propagateTrueState(condition);
       _propagateState(thenExpression);
     } else if (thenIsAbrupt && !elseIsAbrupt) {
       _propagateFalseState(condition);
       _propagateState(elseExpression);
     }
     return null;
@@ skipping 11 matching lines @@
     return null;
   }
 
   @override
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     //
     // We visit the expression, but do not visit the field name because it needs
     // to be visited in the context of the constructor field initializer node.
     //
     safelyVisit(node.expression);
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitConstructorName(ConstructorName node) {
     //
     // We do not visit either the type name, because it won't be visited anyway,
     // or the name, because it needs to be visited in the context of the
     // constructor name.
     //
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitContinueStatement(ContinueStatement node) {
     //
     // We do not visit the label because it needs to be visited in the context
     // of the statement.
     //
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitDoStatement(DoStatement node) {
     _overrideManager.enterScope();
     try {
       super.visitDoStatement(node);
     } finally {
       _overrideManager.exitScope();
@@ skipping 96 matching lines @@
             DartType iteratorElementType = _getIteratorElementType(iterable);
             overrideVariable(identifierElement, iteratorElementType, true);
             _recordPropagatedType(identifier, iteratorElementType);
           }
         }
         visitStatementInScope(body);
       } finally {
         _overrideManager.exitScope();
       }
     }
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
   }
 
   @override
   Object visitForStatement(ForStatement node) {
     _overrideManager.enterScope();
     try {
       super.visitForStatement(node);
     } finally {
       _overrideManager.exitScope();
     }
@@ skipping 43 matching lines @@
       }
     } finally {
       _enclosingFunction = outerFunction;
     }
     return null;
   }
 
   @override
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     safelyVisit(node.function);
-    node.accept(_elementResolver);
+    node.accept(elementResolver);
     _inferFunctionExpressionsParametersTypes(node.argumentList);
     safelyVisit(node.argumentList);
-    node.accept(_typeAnalyzer);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     // Resolve the metadata in the library scope.
     if (node.metadata != null) {
       node.metadata.accept(this);
     }
     FunctionTypeAlias outerAlias = _enclosingFunctionTypeAlias;
@@ skipping 43 matching lines @@
     if (elseStatement != null) {
       _overrideManager.enterScope();
       try {
         _propagateFalseState(condition);
         visitStatementInScope(elseStatement);
       } finally {
         elseOverrides = _overrideManager.captureLocalOverrides();
         _overrideManager.exitScope();
       }
     }
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     // Join overrides.
     bool thenIsAbrupt = _isAbruptTerminationStatement(thenStatement);
     bool elseIsAbrupt = _isAbruptTerminationStatement(elseStatement);
     if (elseIsAbrupt && !thenIsAbrupt) {
       _propagateTrueState(condition);
       _overrideManager.applyOverrides(thenOverrides);
     } else if (thenIsAbrupt && !elseIsAbrupt) {
       _propagateFalseState(condition);
       _overrideManager.applyOverrides(elseOverrides);
     } else if (!thenIsAbrupt && !elseIsAbrupt) {
@@ skipping 26 matching lines @@
     return null;
   }
 
   @override
   Object visitMethodInvocation(MethodInvocation node) {
     //
     // We visit the target and argument list, but do not visit the method name
     // because it needs to be visited in the context of the invocation.
     //
     safelyVisit(node.target);
-    node.accept(_elementResolver);
+    node.accept(elementResolver);
     _inferFunctionExpressionsParametersTypes(node.argumentList);
     safelyVisit(node.argumentList);
-    node.accept(_typeAnalyzer);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) {
     node.visitChildren(this);
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     //
     // We visit the prefix, but do not visit the identifier because it needs to
     // be visited in the context of the prefix.
     //
     safelyVisit(node.prefix);
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitPropertyAccess(PropertyAccess node) {
     //
     // We visit the target, but do not visit the property name because it needs
     // to be visited in the context of the property access node.
     //
     safelyVisit(node.target);
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     //
     // We visit the argument list, but do not visit the optional identifier
     // because it needs to be visited in the context of the constructor
     // invocation.
     //
     safelyVisit(node.argumentList);
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitShowCombinator(ShowCombinator node) => null;
 
   @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     //
     // We visit the argument list, but do not visit the optional identifier
     // because it needs to be visited in the context of the constructor
     // invocation.
     //
     safelyVisit(node.argumentList);
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
     _overrideManager.enterScope();
     try {
       super.visitSwitchCase(node);
     } finally {
       _overrideManager.exitScope();
@@ skipping 46 matching lines @@
           visitStatementInScope(body);
         } finally {
           _overrideManager.exitScope();
         }
       }
     } finally {
       _implicitLabelScope = outerImplicitScope;
     }
     // TODO(brianwilkerson) If the loop can only be exited because the condition
     // is false, then propagateFalseState(condition);
-    node.accept(_elementResolver);
-    node.accept(_typeAnalyzer);
+    node.accept(elementResolver);
+    node.accept(typeAnalyzer);
     return null;
   }
 
   /**
    * Checks each promoted variable in the current scope for compliance with the following
    * specification statement:
    *
    * If the variable <i>v</i> is accessed by a closure in <i>s<sub>1</sub></i> then the variable
    * <i>v</i> is not potentially mutated anywhere in the scope of <i>v</i>.
    */
@@ skipping 572 matching lines @@
   final Source source;
 
   /**
    * The error listener that will be informed of any errors that are found during resolution.
    */
   AnalysisErrorListener _errorListener;
 
   /**
    * The scope used to resolve identifiers.
    */
-  Scope _nameScope;
+  Scope nameScope;
 
   /**
    * The object used to access the types from the core library.
    */
   final TypeProvider typeProvider;
 
   /**
    * The scope used to resolve unlabeled `break` and `continue` statements.
    */
   ImplicitLabelScope _implicitLabelScope = ImplicitLabelScope.ROOT;
 
   /**
    * The scope used to resolve labels for `break` and `continue` statements, or
    * `null` if no labels have been defined in the current context.
    */
-  LabelScope _labelScope;
+  LabelScope labelScope;
 
   /**
    * The class containing the AST nodes being visited,
    * or `null` if we are not in the scope of a class.
    */
   ClassElement enclosingClass;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ScopedVisitor.con1(Library library, this.source, this.typeProvider) {
     this._definingLibrary = library.libraryElement;
     LibraryScope libraryScope = library.libraryScope;
     this._errorListener = libraryScope.errorListener;
-    this._nameScope = libraryScope;
+    this.nameScope = libraryScope;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
   ScopedVisitor.con2(LibraryElement definingLibrary, this.source,
       this.typeProvider, AnalysisErrorListener errorListener) {
     this._definingLibrary = definingLibrary;
     this._errorListener = errorListener;
-    this._nameScope = new LibraryScope(definingLibrary, errorListener);
+    this.nameScope = new LibraryScope(definingLibrary, errorListener);
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param definingLibrary the element for the library containing the compilation unit being
    *          visited
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    * @param nameScope the scope used to resolve identifiers in the node that will first be visited
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during resolution
    */
   ScopedVisitor.con3(LibraryElement definingLibrary, this.source,
       this.typeProvider, Scope nameScope, AnalysisErrorListener errorListener) {
     this._definingLibrary = definingLibrary;
     this._errorListener = errorListener;
-    this._nameScope = nameScope;
+    this.nameScope = nameScope;
   }
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ScopedVisitor.con4(
       ResolvableLibrary library, this.source, this.typeProvider) {
     this._definingLibrary = library.libraryElement;
     LibraryScope libraryScope = library.libraryScope;
     this._errorListener = libraryScope.errorListener;
-    this._nameScope = libraryScope;
+    this.nameScope = libraryScope;
   }
 
   /**
    * Return the library element for the library containing the compilation unit being resolved.
    *
    * @return the library element for the library containing the compilation unit being resolved
    */
   LibraryElement get definingLibrary => _definingLibrary;
 
   /**
    * Return the implicit label scope in which the current node is being
    * resolved.
    */
   ImplicitLabelScope get implicitLabelScope => _implicitLabelScope;
 
   /**
-   * Return the label scope in which the current node is being resolved.
-   *
-   * @return the label scope in which the current node is being resolved
-   */
-  LabelScope get labelScope => _labelScope;
-
-  /**
-   * Return the name scope in which the current node is being resolved.
-   *
-   * @return the name scope in which the current node is being resolved
-   */
-  Scope get nameScope => _nameScope;
-
-  /**
    * Replaces the current [Scope] with the enclosing [Scope].
    *
    * @return the enclosing [Scope].
    */
   Scope popNameScope() {
-    _nameScope = _nameScope.enclosingScope;
-    return _nameScope;
+    nameScope = nameScope.enclosingScope;
+    return nameScope;
   }
 
   /**
    * Pushes a new [Scope] into the visitor.
    *
    * @return the new [Scope].
    */
   Scope pushNameScope() {
-    Scope newScope = new EnclosedScope(_nameScope);
-    _nameScope = newScope;
-    return _nameScope;
+    Scope newScope = new EnclosedScope(nameScope);
+    nameScope = newScope;
+    return nameScope;
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param node the node specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportErrorForNode(ErrorCode errorCode, AstNode node,
@@ skipping 35 matching lines @@
    * @param node the node to be visited
    */
   void safelyVisit(AstNode node) {
     if (node != null) {
       node.accept(this);
     }
   }
 
   @override
   Object visitBlock(Block node) {
-    Scope outerScope = _nameScope;
+    Scope outerScope = nameScope;
     try {
-      EnclosedScope enclosedScope = new EnclosedScope(_nameScope);
+      EnclosedScope enclosedScope = new EnclosedScope(nameScope);
       _hideNamesDefinedInBlock(enclosedScope, node);
-      _nameScope = enclosedScope;
+      nameScope = enclosedScope;
       super.visitBlock(node);
     } finally {
-      _nameScope = outerScope;
+      nameScope = outerScope;
     }
     return null;
   }
 
   @override
   Object visitBlockFunctionBody(BlockFunctionBody node) {
     ImplicitLabelScope implicitOuterScope = _implicitLabelScope;
     try {
       _implicitLabelScope = ImplicitLabelScope.ROOT;
       super.visitBlockFunctionBody(node);
     } finally {
       _implicitLabelScope = implicitOuterScope;
     }
     return null;
   }
 
   @override
   Object visitCatchClause(CatchClause node) {
     SimpleIdentifier exception = node.exceptionParameter;
     if (exception != null) {
-      Scope outerScope = _nameScope;
+      Scope outerScope = nameScope;
       try {
-        _nameScope = new EnclosedScope(_nameScope);
-        _nameScope.define(exception.staticElement);
+        nameScope = new EnclosedScope(nameScope);
+        nameScope.define(exception.staticElement);
         SimpleIdentifier stackTrace = node.stackTraceParameter;
         if (stackTrace != null) {
-          _nameScope.define(stackTrace.staticElement);
+          nameScope.define(stackTrace.staticElement);
         }
         super.visitCatchClause(node);
       } finally {
-        _nameScope = outerScope;
+        nameScope = outerScope;
       }
     } else {
       super.visitCatchClause(node);
     }
     return null;
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement classElement = node.element;
-    Scope outerScope = _nameScope;
+    Scope outerScope = nameScope;
     try {
       if (classElement == null) {
         AnalysisEngine.instance.logger.logInformation(
             "Missing element for class declaration ${node.name.name} in ${definingLibrary.source.fullName}",
             new CaughtException(new AnalysisException(), null));
         super.visitClassDeclaration(node);
       } else {
         ClassElement outerClass = enclosingClass;
         try {
           enclosingClass = node.element;
-          _nameScope = new TypeParameterScope(_nameScope, classElement);
+          nameScope = new TypeParameterScope(nameScope, classElement);
           visitClassDeclarationInScope(node);
-          _nameScope = new ClassScope(_nameScope, classElement);
+          nameScope = new ClassScope(nameScope, classElement);
           visitClassMembersInScope(node);
         } finally {
           enclosingClass = outerClass;
         }
       }
     } finally {
-      _nameScope = outerScope;
+      nameScope = outerScope;
     }
     return null;
   }
 
   void visitClassDeclarationInScope(ClassDeclaration node) {
     safelyVisit(node.name);
     safelyVisit(node.typeParameters);
     safelyVisit(node.extendsClause);
     safelyVisit(node.withClause);
     safelyVisit(node.implementsClause);
     safelyVisit(node.nativeClause);
   }
 
   void visitClassMembersInScope(ClassDeclaration node) {
     safelyVisit(node.documentationComment);
     node.metadata.accept(this);
     node.members.accept(this);
   }
 
   @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
-    Scope outerScope = _nameScope;
+    Scope outerScope = nameScope;
     try {
       ClassElement element = node.element;
-      _nameScope =
-          new ClassScope(new TypeParameterScope(_nameScope, element), element);
+      nameScope =
+          new ClassScope(new TypeParameterScope(nameScope, element), element);
       super.visitClassTypeAlias(node);
     } finally {
-      _nameScope = outerScope;
+      nameScope = outerScope;
     }
     return null;
   }
 
   @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorElement constructorElement = node.element;
-    Scope outerScope = _nameScope;
+    Scope outerScope = nameScope;
     try {
       if (constructorElement == null) {
         StringBuffer buffer = new StringBuffer();
         buffer.write("Missing element for constructor ");
         buffer.write(node.returnType.name);
         if (node.name != null) {
           buffer.write(".");
           buffer.write(node.name.name);
         }
         buffer.write(" in ");
         buffer.write(definingLibrary.source.fullName);
         AnalysisEngine.instance.logger.logInformation(buffer.toString(),
             new CaughtException(new AnalysisException(), null));
       } else {
-        _nameScope = new FunctionScope(_nameScope, constructorElement);
+        nameScope = new FunctionScope(nameScope, constructorElement);
       }
       super.visitConstructorDeclaration(node);
     } finally {
-      _nameScope = outerScope;
+      nameScope = outerScope;
     }
     return null;
   }
 
   @override
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     VariableElement element = node.element;
     if (element != null) {
-      _nameScope.define(element);
+      nameScope.define(element);
     }
     super.visitDeclaredIdentifier(node);
     return null;
   }
 
   @override
   Object visitDoStatement(DoStatement node) {
     ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
     try {
       _implicitLabelScope = _implicitLabelScope.nest(node);
       visitStatementInScope(node.body);
       safelyVisit(node.condition);
     } finally {
       _implicitLabelScope = outerImplicitScope;
     }
     return null;
   }
 
   @override
   Object visitForEachStatement(ForEachStatement node) {
-    Scope outerNameScope = _nameScope;
+    Scope outerNameScope = nameScope;
     ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
     try {
-      _nameScope = new EnclosedScope(_nameScope);
+      nameScope = new EnclosedScope(nameScope);
       _implicitLabelScope = _implicitLabelScope.nest(node);
       visitForEachStatementInScope(node);
     } finally {
-      _nameScope = outerNameScope;
+      nameScope = outerNameScope;
       _implicitLabelScope = outerImplicitScope;
     }
     return null;
   }
 
   /**
    * Visit the given statement after it's scope has been created. This replaces the normal call to
    * the inherited visit method so that ResolverVisitor can intervene when type propagation is
    * enabled.
    *
@@ skipping 10 matching lines @@
     visitStatementInScope(node.body);
   }
 
   @override
   Object visitFormalParameterList(FormalParameterList node) {
     super.visitFormalParameterList(node);
     // We finished resolving function signature, now include formal parameters
     // scope.  Note: we must not do this if the parent is a
     // FunctionTypedFormalParameter, because in that case we aren't finished
     // resolving the full function signature, just a part of it.
-    if (_nameScope is FunctionScope &&
+    if (nameScope is FunctionScope &&
         node.parent is! FunctionTypedFormalParameter) {
-      (_nameScope as FunctionScope).defineParameters();
+      (nameScope as FunctionScope).defineParameters();
     }
-    if (_nameScope is FunctionTypeScope) {
-      (_nameScope as FunctionTypeScope).defineParameters();
+    if (nameScope is FunctionTypeScope) {
+      (nameScope as FunctionTypeScope).defineParameters();
     }
     return null;
   }
 
   @override
   Object visitForStatement(ForStatement node) {
-    Scope outerNameScope = _nameScope;
+    Scope outerNameScope = nameScope;
     ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
     try {
-      _nameScope = new EnclosedScope(_nameScope);
+      nameScope = new EnclosedScope(nameScope);
       _implicitLabelScope = _implicitLabelScope.nest(node);
       visitForStatementInScope(node);
     } finally {
-      _nameScope = outerNameScope;
+      nameScope = outerNameScope;
       _implicitLabelScope = outerImplicitScope;
     }
     return null;
   }
 
   /**
    * Visit the given statement after it's scope has been created. This replaces the normal call to
    * the inherited visit method so that ResolverVisitor can intervene when type propagation is
    * enabled.
    *
    * @param node the statement to be visited
    */
   void visitForStatementInScope(ForStatement node) {
     safelyVisit(node.variables);
     safelyVisit(node.initialization);
     safelyVisit(node.condition);
     node.updaters.accept(this);
     visitStatementInScope(node.body);
   }
 
   @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement functionElement = node.element;
     if (functionElement != null &&
         functionElement.enclosingElement is! CompilationUnitElement) {
-      _nameScope.define(functionElement);
+      nameScope.define(functionElement);
     }
-    Scope outerScope = _nameScope;
+    Scope outerScope = nameScope;
     try {
       if (functionElement == null) {
         AnalysisEngine.instance.logger.logInformation(
             "Missing element for top-level function ${node.name.name} in ${definingLibrary.source.fullName}",
             new CaughtException(new AnalysisException(), null));
       } else {
-        _nameScope = new FunctionScope(_nameScope, functionElement);
+        nameScope = new FunctionScope(nameScope, functionElement);
       }
       super.visitFunctionDeclaration(node);
     } finally {
-      _nameScope = outerScope;
+      nameScope = outerScope;
     }
     return null;
   }
 
   @override
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is FunctionDeclaration) {
       // We have already created a function scope and don't need to do so again.
       super.visitFunctionExpression(node);
     } else {
-      Scope outerScope = _nameScope;
+      Scope outerScope = nameScope;
       try {
         ExecutableElement functionElement = node.element;
         if (functionElement == null) {
           StringBuffer buffer = new StringBuffer();
           buffer.write("Missing element for function ");
           AstNode parent = node.parent;
           while (parent != null) {
             if (parent is Declaration) {
               Element parentElement = parent.element;
               buffer.write(parentElement == null
                   ? "<unknown> "
                   : "${parentElement.name} ");
             }
             parent = parent.parent;
           }
           buffer.write("in ");
           buffer.write(definingLibrary.source.fullName);
           AnalysisEngine.instance.logger.logInformation(buffer.toString(),
               new CaughtException(new AnalysisException(), null));
         } else {
-          _nameScope = new FunctionScope(_nameScope, functionElement);
+          nameScope = new FunctionScope(nameScope, functionElement);
         }
         super.visitFunctionExpression(node);
       } finally {
-        _nameScope = outerScope;
+        nameScope = outerScope;
       }
     }
     return null;
   }
 
   @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
-    Scope outerScope = _nameScope;
+    Scope outerScope = nameScope;
     try {
-      _nameScope = new FunctionTypeScope(_nameScope, node.element);
+      nameScope = new FunctionTypeScope(nameScope, node.element);
       super.visitFunctionTypeAlias(node);
     } finally {
-      _nameScope = outerScope;
+      nameScope = outerScope;
     }
     return null;
   }
 
   @override
   Object visitIfStatement(IfStatement node) {
     safelyVisit(node.condition);
     visitStatementInScope(node.thenStatement);
     visitStatementInScope(node.elseStatement);
     return null;
   }
 
   @override
   Object visitLabeledStatement(LabeledStatement node) {
     LabelScope outerScope = _addScopesFor(node.labels, node.unlabeled);
     try {
       super.visitLabeledStatement(node);
     } finally {
-      _labelScope = outerScope;
+      labelScope = outerScope;
     }
     return null;
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
-    Scope outerScope = _nameScope;
+    Scope outerScope = nameScope;
     try {
       ExecutableElement methodElement = node.element;
       if (methodElement == null) {
         AnalysisEngine.instance.logger.logInformation(
             "Missing element for method ${node.name.name} in ${definingLibrary.source.fullName}",
             new CaughtException(new AnalysisException(), null));
       } else {
-        _nameScope = new FunctionScope(_nameScope, methodElement);
+        nameScope = new FunctionScope(nameScope, methodElement);
       }
       super.visitMethodDeclaration(node);
     } finally {
-      _nameScope = outerScope;
+      nameScope = outerScope;
     }
     return null;
   }
 
   /**
    * Visit the given statement after it's scope has been created. This is used by ResolverVisitor to
    * correctly visit the 'then' and 'else' statements of an 'if' statement.
    *
    * @param node the statement to be visited
    */
   void visitStatementInScope(Statement node) {
     if (node is Block) {
       // Don't create a scope around a block because the block will create it's
       // own scope.
       visitBlock(node);
     } else if (node != null) {
-      Scope outerNameScope = _nameScope;
+      Scope outerNameScope = nameScope;
       try {
-        _nameScope = new EnclosedScope(_nameScope);
+        nameScope = new EnclosedScope(nameScope);
         node.accept(this);
       } finally {
-        _nameScope = outerNameScope;
+        nameScope = outerNameScope;
       }
     }
   }
 
   @override
   Object visitSwitchCase(SwitchCase node) {
     node.expression.accept(this);
-    Scope outerNameScope = _nameScope;
+    Scope outerNameScope = nameScope;
     try {
-      _nameScope = new EnclosedScope(_nameScope);
+      nameScope = new EnclosedScope(nameScope);
       node.statements.accept(this);
     } finally {
-      _nameScope = outerNameScope;
+      nameScope = outerNameScope;
     }
     return null;
   }
 
   @override
   Object visitSwitchDefault(SwitchDefault node) {
-    Scope outerNameScope = _nameScope;
+    Scope outerNameScope = nameScope;
     try {
-      _nameScope = new EnclosedScope(_nameScope);
+      nameScope = new EnclosedScope(nameScope);
       node.statements.accept(this);
     } finally {
-      _nameScope = outerNameScope;
+      nameScope = outerNameScope;
     }
     return null;
   }
 
   @override
   Object visitSwitchStatement(SwitchStatement node) {
-    LabelScope outerScope = _labelScope;
+    LabelScope outerScope = labelScope;
     ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
     try {
       _implicitLabelScope = _implicitLabelScope.nest(node);
       for (SwitchMember member in node.members) {
         for (Label label in member.labels) {
           SimpleIdentifier labelName = label.label;
           LabelElement labelElement = labelName.staticElement as LabelElement;
-          _labelScope =
-              new LabelScope(_labelScope, labelName.name, member, labelElement);
+          labelScope =
+              new LabelScope(labelScope, labelName.name, member, labelElement);
         }
       }
       super.visitSwitchStatement(node);
     } finally {
-      _labelScope = outerScope;
+      labelScope = outerScope;
       _implicitLabelScope = outerImplicitScope;
     }
     return null;
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     if (node.parent.parent is! TopLevelVariableDeclaration &&
         node.parent.parent is! FieldDeclaration) {
       VariableElement element = node.element;
       if (element != null) {
-        _nameScope.define(element);
+        nameScope.define(element);
       }
     }
     return null;
   }
 
   @override
   Object visitWhileStatement(WhileStatement node) {
     safelyVisit(node.condition);
     ImplicitLabelScope outerImplicitScope = _implicitLabelScope;
     try {
       _implicitLabelScope = _implicitLabelScope.nest(node);
       visitStatementInScope(node.body);
     } finally {
       _implicitLabelScope = outerImplicitScope;
     }
     return null;
   }
 
   /**
    * Add scopes for each of the given labels.
    *
    * @param labels the labels for which new scopes are to be added
    * @return the scope that was in effect before the new scopes were added
    */
   LabelScope _addScopesFor(NodeList<Label> labels, AstNode node) {
-    LabelScope outerScope = _labelScope;
+    LabelScope outerScope = labelScope;
     for (Label label in labels) {
       SimpleIdentifier labelNameNode = label.label;
       String labelName = labelNameNode.name;
       LabelElement labelElement = labelNameNode.staticElement as LabelElement;
-      _labelScope = new LabelScope(_labelScope, labelName, node, labelElement);
+      labelScope = new LabelScope(labelScope, labelName, node, labelElement);
     }
     return outerScope;
   }
 
   /**
    * Marks the local declarations of the given [Block] hidden in the enclosing scope.
    * According to the scoping rules name is hidden if block defines it, but name is defined after
    * its declaration statement.
    */
   void _hideNamesDefinedInBlock(EnclosedScope scope, Block block) {
@@ skipping 3005 matching lines @@
   }
 
   bool isCatchException(LocalVariableElement element) {
     return catchExceptionElements.contains(element);
   }
 
   bool isCatchStackTrace(LocalVariableElement element) {
     return catchStackTraceElements.contains(element);
   }
 }