java2dart improvement - use field if getter/setter are trivial.

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

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.resolver;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
@@ skipping 1010 matching lines @@
   static String _TYPE = "type";
 
   /**
    * The analysis context in which the element model will be built.
    */
   InternalAnalysisContext _context;
 
   /**
    * The error listener to which errors will be reported.
    */
-  RecordingErrorListener _errorListener;
+  RecordingErrorListener errorListener;
 
   /**
    * The modification time of the source for which an element is being built.
    */
   int _modificationStamp = 0;
 
   /**
    * The line information associated with the source for which an element is being built, or
    * `null` if we are not building an element.
    */
@@ skipping 10 matching lines @@
   List<ht.XmlTagNode> _parentNodes;
 
   /**
    * The script elements being built.
    */
   List<HtmlScriptElement> _scripts;
 
   /**
    * A set of the libraries that were resolved while resolving the HTML unit.
    */
-  Set<Library> _resolvedLibraries = new Set<Library>();
+  final Set<Library> resolvedLibraries = new Set<Library>();
 
   /**
    * Initialize a newly created HTML unit builder.
    *
    * @param context the analysis context in which the element model will be built
    */
   HtmlUnitBuilder(InternalAnalysisContext context) {
     this._context = context;
-    this._errorListener = new RecordingErrorListener();
+    this.errorListener = new RecordingErrorListener();
   }
 
   /**
    * Build the HTML element for the given source.
    *
    * @param source the source describing the compilation unit
    * @return the HTML element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
   HtmlElementImpl buildHtmlElement(Source source) => buildHtmlElement2(source, source.modificationStamp, _context.parseHtmlUnit(source));
@@ skipping 11 matching lines @@
     this._modificationStamp = modificationStamp2;
     _lineInfo = _context.computeLineInfo(source2);
     HtmlElementImpl result = new HtmlElementImpl(_context, source2.shortName);
     result.source = source2;
     _htmlElement = result;
     unit.accept(this);
     _htmlElement = null;
     unit.element = result;
     return result;
   }
-
-  /**
-   * Return the listener to which analysis errors will be reported.
-   *
-   * @return the listener to which analysis errors will be reported
-   */
-  RecordingErrorListener get errorListener => _errorListener;
-
-  /**
-   * Return an array containing information about all of the libraries that were resolved.
-   *
-   * @return an array containing the libraries that were resolved
-   */
-  Set<Library> get resolvedLibraries => _resolvedLibraries;
   Object visitHtmlUnit(ht.HtmlUnit node) {
     _parentNodes = new List<ht.XmlTagNode>();
     _scripts = new List<HtmlScriptElement>();
     try {
       node.visitChildren(this);
       _htmlElement.scripts = new List.from(_scripts);
     } finally {
       _scripts = null;
       _parentNodes = null;
     }
@@ skipping 27 matching lines @@
     try {
       if (isScriptNode(node)) {
         Source htmlSource = _htmlElement.source;
         ht.XmlAttributeNode scriptAttribute = getScriptSourcePath(node);
         String scriptSourcePath = scriptAttribute == null ? null : scriptAttribute.text;
         if (identical(node.attributeEnd.type, ht.TokenType.GT) && scriptSourcePath == null) {
           EmbeddedHtmlScriptElementImpl script = new EmbeddedHtmlScriptElementImpl(node);
           String contents = node.content;
           int attributeEnd = node.attributeEnd.end;
           LineInfo_Location location = _lineInfo.getLocation(attributeEnd);
-          sc.StringScanner scanner = new sc.StringScanner(htmlSource, contents, _errorListener);
+          sc.StringScanner scanner = new sc.StringScanner(htmlSource, contents, errorListener);
           scanner.setSourceStart(location.lineNumber, location.columnNumber, attributeEnd);
           sc.Token firstToken = scanner.tokenize();
           List<int> lineStarts = scanner.lineStarts;
-          Parser parser = new Parser(htmlSource, _errorListener);
+          Parser parser = new Parser(htmlSource, errorListener);
           CompilationUnit unit = parser.parseCompilationUnit(firstToken);
           unit.lineInfo = new LineInfo(lineStarts);
           try {
             LibraryResolver resolver = new LibraryResolver(_context);
             LibraryElementImpl library = resolver.resolveEmbeddedLibrary(htmlSource, _modificationStamp, unit, true) as LibraryElementImpl;
             script.scriptLibrary = library;
-            _resolvedLibraries.addAll(resolver.resolvedLibraries);
-            _errorListener.addAll(resolver.errorListener);
+            resolvedLibraries.addAll(resolver.resolvedLibraries);
+            errorListener.addAll(resolver.errorListener);
           } on AnalysisException catch (exception) {
             AnalysisEngine.instance.logger.logError3(exception);
           }
           _scripts.add(script);
         } else {
           ExternalHtmlScriptElementImpl script = new ExternalHtmlScriptElementImpl(node);
           if (scriptSourcePath != null) {
             try {
               scriptSourcePath = Uri.encodeFull(scriptSourcePath);
               parseUriWithException(scriptSourcePath);
@@ skipping 59 matching lines @@
   /**
    * Report an error with the given error code at the given location. Use the given arguments to
    * compose the error message.
    *
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the first character to be highlighted
    * @param length the number of characters to be highlighted
    * @param arguments the arguments used to compose the error message
    */
   void reportError(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
-    _errorListener.onError(new AnalysisError.con2(_htmlElement.source, offset, length, errorCode, arguments));
+    errorListener.onError(new AnalysisError.con2(_htmlElement.source, offset, length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code at the location of the value of the given attribute.
    * Use the given arguments to compose the error message.
    *
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the first character to be highlighted
    * @param length the number of characters to be highlighted
    * @param arguments the arguments used to compose the error message
@@ skipping 3541 matching lines @@
   InheritanceManager _inheritanceManager;
 
   /**
    * The listener to which analysis errors will be reported.
    */
   AnalysisErrorListener _errorListener;
 
   /**
    * The source specifying the defining compilation unit of this library.
    */
-  Source _librarySource;
+  Source librarySource;
 
   /**
    * The library element representing this library.
    */
   LibraryElementImpl _libraryElement;
 
   /**
    * A list containing all of the libraries that are imported into this library.
    */
-  List<Library> _importedLibraries = _EMPTY_ARRAY;
+  List<Library> imports = _EMPTY_ARRAY;
 
   /**
    * A table mapping URI-based directive to the actual URI value.
    */
   Map<UriBasedDirective, String> _directiveUris = new Map<UriBasedDirective, String>();
 
   /**
    * A flag indicating whether this library explicitly imports core.
    */
-  bool _explicitlyImportsCore = false;
+  bool explicitlyImportsCore = false;
 
   /**
    * A list containing all of the libraries that are exported from this library.
    */
-  List<Library> _exportedLibraries = _EMPTY_ARRAY;
+  List<Library> exports = _EMPTY_ARRAY;
 
   /**
    * A table mapping the sources for the compilation units in this library to their corresponding
    * AST structures.
    */
   Map<Source, ResolvableCompilationUnit> _astMap = new Map<Source, ResolvableCompilationUnit>();
 
   /**
    * The library scope used when resolving elements within this library's compilation units.
    */
   LibraryScope _libraryScope;
 
   /**
    * An empty array that can be used to initialize lists of libraries.
    */
   static List<Library> _EMPTY_ARRAY = new List<Library>(0);
 
   /**
    * Initialize a newly created data holder that can maintain the data associated with a library.
    *
    * @param analysisContext the analysis context in which this library is being analyzed
    * @param errorListener the listener to which analysis errors will be reported
    * @param librarySource the source specifying the defining compilation unit of this library
    */
   Library(InternalAnalysisContext analysisContext, AnalysisErrorListener errorListener, Source librarySource) {
     this._analysisContext = analysisContext;
     this._errorListener = errorListener;
-    this._librarySource = librarySource;
+    this.librarySource = librarySource;
     this._libraryElement = analysisContext.getLibraryElement(librarySource) as LibraryElementImpl;
   }
 
   /**
    * Return the AST structure associated with the given source.
    *
    * @param source the source representing the compilation unit whose AST is to be returned
    * @return the AST structure associated with the given source
    * @throws AnalysisException if an AST structure could not be created for the compilation unit
    */
@@ skipping 10 matching lines @@
    * Return an array of the [CompilationUnit]s that make up the library. The first unit is
    * always the defining unit.
    *
    * @return an array of the [CompilationUnit]s that make up the library. The first unit is
    *         always the defining unit
    */
   List<CompilationUnit> get compilationUnits {
     List<CompilationUnit> unitArrayList = new List<CompilationUnit>();
     unitArrayList.add(definingCompilationUnit);
     for (Source source in _astMap.keys.toSet()) {
-      if (_librarySource != source) {
+      if (librarySource != source) {
         unitArrayList.add(getAST(source));
       }
     }
     return new List.from(unitArrayList);
   }
 
   /**
    * Return a collection containing the sources for the compilation units in this library, including
    * the defining compilation unit.
    *
    * @return the sources for the compilation units in this library
    */
   Set<Source> get compilationUnitSources => _astMap.keys.toSet();
 
   /**
    * Return the AST structure associated with the defining compilation unit for this library.
    *
    * @return the AST structure associated with the defining compilation unit for this library
    * @throws AnalysisException if an AST structure could not be created for the defining compilation
    *           unit
    */
-  CompilationUnit get definingCompilationUnit => getAST(_librarySource);
-
-  /**
-   * Return `true` if this library explicitly imports core.
-   *
-   * @return `true` if this library explicitly imports core
-   */
-  bool get explicitlyImportsCore => _explicitlyImportsCore;
-
-  /**
-   * Return an array containing the libraries that are exported from this library.
-   *
-   * @return an array containing the libraries that are exported from this library
-   */
-  List<Library> get exports => _exportedLibraries;
-
-  /**
-   * Return an array containing the libraries that are imported into this library.
-   *
-   * @return an array containing the libraries that are imported into this library
-   */
-  List<Library> get imports => _importedLibraries;
+  CompilationUnit get definingCompilationUnit => getAST(librarySource);
 
   /**
    * Return an array containing the libraries that are either imported or exported from this
    * library.
    *
    * @return the libraries that are either imported or exported from this library
    */
   List<Library> get importsAndExports {
     Set<Library> libraries = new Set<Library>();
-    for (Library library in _importedLibraries) {
+    for (Library library in imports) {
       javaSetAdd(libraries, library);
     }
-    for (Library library in _exportedLibraries) {
+    for (Library library in exports) {
       javaSetAdd(libraries, library);
     }
     return new List.from(libraries);
   }
 
   /**
    * Return the inheritance manager for this library.
    *
    * @return the inheritance manager for this library
    */
   InheritanceManager get inheritanceManager {
     if (_inheritanceManager == null) {
       return _inheritanceManager = new InheritanceManager(_libraryElement);
     }
     return _inheritanceManager;
   }
 
   /**
    * Return the library element representing this library, creating it if necessary.
    *
    * @return the library element representing this library
    */
   LibraryElementImpl get libraryElement {
     if (_libraryElement == null) {
       try {
-        _libraryElement = _analysisContext.computeLibraryElement(_librarySource) as LibraryElementImpl;
+        _libraryElement = _analysisContext.computeLibraryElement(librarySource) as LibraryElementImpl;
       } on AnalysisException catch (exception) {
-        AnalysisEngine.instance.logger.logError2("Could not compute ilbrary element for ${_librarySource.fullName}", exception);
+        AnalysisEngine.instance.logger.logError2("Could not compute ilbrary element for ${librarySource.fullName}", exception);
       }
     }
     return _libraryElement;
   }
 
   /**
    * Return the library scope used when resolving elements within this library's compilation units.
    *
    * @return the library scope used when resolving elements within this library's compilation units
    */
   LibraryScope get libraryScope {
     if (_libraryScope == null) {
       _libraryScope = new LibraryScope(_libraryElement, _errorListener);
     }
     return _libraryScope;
   }
 
   /**
-   * Return the source specifying the defining compilation unit of this library.
-   *
-   * @return the source specifying the defining compilation unit of this library
-   */
-  Source get librarySource => _librarySource;
-
-  /**
    * Return the modification time associated with the given source.
    *
    * @param source the source representing the compilation unit whose modification time is to be
    *          returned
    * @return the modification time associated with the given source
    * @throws AnalysisException if an AST structure could not be created for the compilation unit
    */
   int getModificationTime(Source source) {
     ResolvableCompilationUnit holder = _astMap[source];
     if (holder == null) {
       holder = _analysisContext.computeResolvableCompilationUnit(source);
       _astMap[source] = holder;
     }
     return holder.modificationTime;
   }
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * library, or `null` if the URI is not valid. If the URI is not valid, report the error.
    *
    * @param directive the directive which URI should be resolved
    * @return the result of resolving the URI against the URI of the library
    */
   Source getSource(UriBasedDirective directive) {
     StringLiteral uriLiteral = directive.uri;
     if (uriLiteral is StringInterpolation) {
-      _errorListener.onError(new AnalysisError.con2(_librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION, []));
+      _errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION, []));
       return null;
     }
     String uriContent = uriLiteral.stringValue.trim();
     _directiveUris[directive] = uriContent;
     uriContent = Uri.encodeFull(uriContent);
     try {
       parseUriWithException(uriContent);
-      Source source = _analysisContext.sourceFactory.resolveUri(_librarySource, uriContent);
+      Source source = _analysisContext.sourceFactory.resolveUri(librarySource, uriContent);
       if (source == null || !source.exists()) {
-        _errorListener.onError(new AnalysisError.con2(_librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [uriContent]));
+        _errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [uriContent]));
       }
       return source;
     } on URISyntaxException catch (exception) {
-      _errorListener.onError(new AnalysisError.con2(_librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
+      _errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
     }
     return null;
   }
 
   /**
    * Returns the URI value of the given directive.
    */
   String getUri(UriBasedDirective directive) => _directiveUris[directive];
 
   /**
    * Set the AST structure associated with the defining compilation unit for this library to the
    * given AST structure.
    *
    * @param modificationStamp the modification time of the source from which the compilation unit
    *          was created
    * @param unit the AST structure associated with the defining compilation unit for this library
    */
   void setDefiningCompilationUnit(int modificationStamp, CompilationUnit unit) {
-    _astMap[_librarySource] = new ResolvableCompilationUnit(modificationStamp, unit);
+    _astMap[librarySource] = new ResolvableCompilationUnit(modificationStamp, unit);
   }
 
   /**
-   * Set whether this library explicitly imports core to match the given value.
-   *
-   * @param explicitlyImportsCore `true` if this library explicitly imports core
-   */
-  void set explicitlyImportsCore(bool explicitlyImportsCore2) {
-    this._explicitlyImportsCore = explicitlyImportsCore2;
-  }
-
-  /**
    * Set the libraries that are exported by this library to be those in the given array.
    *
    * @param exportedLibraries the libraries that are exported by this library
    */
   void set exportedLibraries(List<Library> exportedLibraries2) {
-    this._exportedLibraries = exportedLibraries2;
+    this.exports = exportedLibraries2;
   }
 
   /**
    * Set the libraries that are imported into this library to be those in the given array.
    *
    * @param importedLibraries the libraries that are imported into this library
    */
   void set importedLibraries(List<Library> importedLibraries2) {
-    this._importedLibraries = importedLibraries2;
+    this.imports = importedLibraries2;
   }
 
   /**
    * Set the library element representing this library to the given library element.
    *
    * @param libraryElement the library element representing this library
    */
   void set libraryElement(LibraryElementImpl libraryElement2) {
     this._libraryElement = libraryElement2;
     if (_inheritanceManager != null) {
       _inheritanceManager.libraryElement = libraryElement2;
     }
   }
-  String toString() => _librarySource.shortName;
+  String toString() => librarySource.shortName;
 }
 /**
  * Instances of the class `LibraryElementBuilder` build an element model for a single library.
  *
  * @coverage dart.engine.resolver
  */
 class LibraryElementBuilder {
 
   /**
    * The analysis context in which the element model will be built.
@@ skipping 180 matching lines @@
  * Instances of the class `LibraryResolver` are used to resolve one or more mutually dependent
  * libraries within a single context.
  *
  * @coverage dart.engine.resolver
  */
 class LibraryResolver {
 
   /**
    * The analysis context in which the libraries are being analyzed.
    */
-  InternalAnalysisContext _analysisContext;
+  InternalAnalysisContext analysisContext;
 
   /**
    * A flag indicating whether analysis is to generate hint results (e.g. type inference based
    * information and pub best practices).
    */
   bool _enableHints = false;
 
   /**
    * The listener to which analysis errors will be reported, this error listener is either
    * references [recordingErrorListener], or it unions the passed
    * [AnalysisErrorListener] with the [recordingErrorListener].
    */
-  RecordingErrorListener _errorListener;
+  RecordingErrorListener errorListener;
 
   /**
    * A source object representing the core library (dart:core).
    */
   Source _coreLibrarySource;
 
   /**
    * The object representing the core library.
    */
   Library _coreLibrary;
 
   /**
    * The object used to access the types from the core library.
    */
   TypeProvider _typeProvider;
 
   /**
    * A table mapping library sources to the information being maintained for those libraries.
    */
   Map<Source, Library> _libraryMap = new Map<Source, Library>();
 
   /**
    * A collection containing the libraries that are being resolved together.
    */
-  Set<Library> _librariesInCycles;
+  Set<Library> resolvedLibraries;
 
   /**
    * Initialize a newly created library resolver to resolve libraries within the given context.
    *
    * @param analysisContext the analysis context in which the library is being analyzed
    */
   LibraryResolver(InternalAnalysisContext analysisContext) {
-    this._analysisContext = analysisContext;
-    this._errorListener = new RecordingErrorListener();
+    this.analysisContext = analysisContext;
+    this.errorListener = new RecordingErrorListener();
     _coreLibrarySource = analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
     _enableHints = analysisContext.analysisOptions.hint;
   }
 
   /**
-   * Return the analysis context in which the libraries are being analyzed.
-   *
-   * @return the analysis context in which the libraries are being analyzed
-   */
-  InternalAnalysisContext get analysisContext => _analysisContext;
-
-  /**
-   * Return the listener to which analysis errors will be reported.
-   *
-   * @return the listener to which analysis errors will be reported
-   */
-  RecordingErrorListener get errorListener => _errorListener;
-
-  /**
-   * Return an array containing information about all of the libraries that were resolved.
-   *
-   * @return an array containing the libraries that were resolved
-   */
-  Set<Library> get resolvedLibraries => _librariesInCycles;
-
-  /**
    * Resolve the library specified by the given source in the given context. The library is assumed
    * to be embedded in the given source.
    *
    * @param librarySource the source specifying the defining compilation unit of the library to be
    *          resolved
    * @param modificationStamp the time stamp of the source from which the compilation unit was
    *          created
    * @param unit the compilation unit representing the embedded library
    * @param fullAnalysis `true` if a full analysis should be performed
    * @return the element representing the resolved library
    * @throws AnalysisException if the library could not be resolved for some reason
    */
   LibraryElement resolveEmbeddedLibrary(Source librarySource, int modificationStamp, CompilationUnit unit, bool fullAnalysis) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.LibraryResolver.resolveEmbeddedLibrary");
     try {
       instrumentation.metric("fullAnalysis", fullAnalysis);
       instrumentation.data3("fullName", librarySource.fullName);
       Library targetLibrary = createLibrary2(librarySource, modificationStamp, unit);
       _coreLibrary = _libraryMap[_coreLibrarySource];
       if (_coreLibrary == null) {
         _coreLibrary = createLibrary(_coreLibrarySource);
       }
       instrumentation.metric3("createLibrary", "complete");
       computeLibraryDependencies2(targetLibrary, unit);
-      _librariesInCycles = computeLibrariesInCycles(targetLibrary);
+      resolvedLibraries = computeLibrariesInCycles(targetLibrary);
       buildElementModels();
       instrumentation.metric3("buildElementModels", "complete");
       LibraryElement coreElement = _coreLibrary.libraryElement;
       if (coreElement == null) {
         throw new AnalysisException.con1("Could not resolve dart:core");
       }
       buildDirectiveModels();
       instrumentation.metric3("buildDirectiveModels", "complete");
       _typeProvider = new TypeProviderImpl(coreElement);
       buildTypeHierarchies();
@@ skipping 30 matching lines @@
     try {
       instrumentation.metric("fullAnalysis", fullAnalysis);
       instrumentation.data3("fullName", librarySource.fullName);
       Library targetLibrary = createLibrary(librarySource);
       _coreLibrary = _libraryMap[_coreLibrarySource];
       if (_coreLibrary == null) {
         _coreLibrary = createLibrary(_coreLibrarySource);
       }
       instrumentation.metric3("createLibrary", "complete");
       computeLibraryDependencies(targetLibrary);
-      _librariesInCycles = computeLibrariesInCycles(targetLibrary);
+      resolvedLibraries = computeLibrariesInCycles(targetLibrary);
       buildElementModels();
       instrumentation.metric3("buildElementModels", "complete");
       LibraryElement coreElement = _coreLibrary.libraryElement;
       if (coreElement == null) {
         throw new AnalysisException.con1("Could not resolve dart:core");
       }
       buildDirectiveModels();
       instrumentation.metric3("buildDirectiveModels", "complete");
       _typeProvider = new TypeProviderImpl(coreElement);
       buildTypeHierarchies();
       instrumentation.metric3("buildTypeHierarchies", "complete");
       resolveReferencesAndTypes();
       instrumentation.metric3("resolveReferencesAndTypes", "complete");
       performConstantEvaluation();
       instrumentation.metric3("performConstantEvaluation", "complete");
       if (fullAnalysis) {
         runAdditionalAnalyses();
         instrumentation.metric3("runAdditionalAnalyses", "complete");
       }
-      instrumentation.metric2("librariesInCycles", _librariesInCycles.length);
-      for (Library lib in _librariesInCycles) {
+      instrumentation.metric2("librariesInCycles", resolvedLibraries.length);
+      for (Library lib in resolvedLibraries) {
         instrumentation.metric2("librariesInCycles-CompilationUnitSources-Size", lib.compilationUnitSources.length);
       }
       return targetLibrary.libraryElement;
     } finally {
       instrumentation.log();
     }
   }
 
   /**
    * Add a dependency to the given map from the referencing library to the referenced library.
@@ skipping 76 matching lines @@
   }
 
   /**
    * Every library now has a corresponding [LibraryElement], so it is now possible to resolve
    * the import and export directives.
    *
    * @throws AnalysisException if the defining compilation unit for any of the libraries could not
    *           be accessed
    */
   void buildDirectiveModels() {
-    for (Library library in _librariesInCycles) {
+    for (Library library in resolvedLibraries) {
       Map<String, PrefixElementImpl> nameToPrefixMap = new Map<String, PrefixElementImpl>();
       List<ImportElement> imports = new List<ImportElement>();
       List<ExportElement> exports = new List<ExportElement>();
       for (Directive directive in library.definingCompilationUnit.directives) {
         if (directive is ImportDirective) {
           ImportDirective importDirective = directive as ImportDirective;
           Source importedSource = library.getSource(importDirective);
           if (importedSource != null) {
             Library importedLibrary = _libraryMap[importedSource];
             if (importedLibrary != null) {
@@ skipping 12 matching lines @@
                   prefix = new PrefixElementImpl(prefixNode);
                   nameToPrefixMap[prefixName] = prefix;
                 }
                 importElement.prefix = prefix;
                 prefixNode.staticElement = prefix;
               }
               directive.element = importElement;
               imports.add(importElement);
               if (doesCompilationUnitHavePartOfDirective(importedLibrary.getAST(importedSource))) {
                 StringLiteral uriLiteral = importDirective.uri;
-                _errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
+                errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
               }
             }
           }
         } else if (directive is ExportDirective) {
           ExportDirective exportDirective = directive as ExportDirective;
           Source exportedSource = library.getSource(exportDirective);
           if (exportedSource != null) {
             Library exportedLibrary = _libraryMap[exportedSource];
             if (exportedLibrary != null) {
               ExportElementImpl exportElement = new ExportElementImpl();
               exportElement.uri = library.getUri(exportDirective);
               exportElement.combinators = buildCombinators(exportDirective);
               LibraryElement exportedLibraryElement = exportedLibrary.libraryElement;
               if (exportedLibraryElement != null) {
                 exportElement.exportedLibrary = exportedLibraryElement;
               }
               directive.element = exportElement;
               exports.add(exportElement);
               if (doesCompilationUnitHavePartOfDirective(exportedLibrary.getAST(exportedSource))) {
                 StringLiteral uriLiteral = exportDirective.uri;
-                _errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
+                errorListener.onError(new AnalysisError.con2(library.librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY, [uriLiteral.toSource()]));
               }
             }
           }
         }
       }
       Source librarySource = library.librarySource;
       if (!library.explicitlyImportsCore && _coreLibrarySource != librarySource) {
         ImportElementImpl importElement = new ImportElementImpl();
         importElement.importedLibrary = _coreLibrary.libraryElement;
         importElement.synthetic = true;
         imports.add(importElement);
       }
       LibraryElementImpl libraryElement = library.libraryElement;
       libraryElement.imports = new List.from(imports);
       libraryElement.exports = new List.from(exports);
     }
   }
 
   /**
    * Build element models for all of the libraries in the current cycle.
    *
    * @throws AnalysisException if any of the element models cannot be built
    */
   void buildElementModels() {
-    for (Library library in _librariesInCycles) {
+    for (Library library in resolvedLibraries) {
       LibraryElementBuilder builder = new LibraryElementBuilder(this);
       LibraryElementImpl libraryElement = builder.buildLibrary(library);
       library.libraryElement = libraryElement;
     }
   }
 
   /**
    * Resolve the type hierarchy across all of the types declared in the libraries in the current
    * cycle.
    *
    * @throws AnalysisException if any of the type hierarchies could not be resolved
    */
   void buildTypeHierarchies() {
-    for (Library library in _librariesInCycles) {
+    for (Library library in resolvedLibraries) {
       for (Source source in library.compilationUnitSources) {
         TypeResolverVisitor visitor = new TypeResolverVisitor.con1(library, source, _typeProvider);
         library.getAST(source).accept(visitor);
       }
     }
   }
 
   /**
    * Compute a dependency map of libraries reachable from the given library. A dependency map is a
    * table that maps individual libraries to a list of the libraries that either import or export
@@ skipping 28 matching lines @@
 
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of the
    * class [Library] to represent them, and record the references in the library objects.
    *
    * @param library the library to be processed to find libraries that have not yet been traversed
    * @throws AnalysisException if some portion of the library graph could not be traversed
    */
   void computeLibraryDependencies(Library library) {
     Source librarySource = library.librarySource;
-    computeLibraryDependencies3(library, _analysisContext.computeImportedLibraries(librarySource), _analysisContext.computeExportedLibraries(librarySource));
+    computeLibraryDependencies3(library, analysisContext.computeImportedLibraries(librarySource), analysisContext.computeExportedLibraries(librarySource));
   }
 
   /**
    * Recursively traverse the libraries reachable from the given library, creating instances of the
    * class [Library] to represent them, and record the references in the library objects.
    *
    * @param library the library to be processed to find libraries that have not yet been traversed
    * @throws AnalysisException if some portion of the library graph could not be traversed
    */
   void computeLibraryDependencies2(Library library, CompilationUnit unit) {
@@ skipping 72 matching lines @@
 
   /**
    * Create an object to represent the information about the library defined by the compilation unit
    * with the given source.
    *
    * @param librarySource the source of the library's defining compilation unit
    * @return the library object that was created
    * @throws AnalysisException if the library source is not valid
    */
   Library createLibrary(Source librarySource) {
-    Library library = new Library(_analysisContext, _errorListener, librarySource);
+    Library library = new Library(analysisContext, errorListener, librarySource);
     library.definingCompilationUnit;
     _libraryMap[librarySource] = library;
     return library;
   }
 
   /**
    * Create an object to represent the information about the library defined by the compilation unit
    * with the given source.
    *
    * @param librarySource the source of the library's defining compilation unit
    * @param modificationStamp the modification time of the source from which the compilation unit
    *          was created
    * @param unit the compilation unit that defines the library
    * @return the library object that was created
    * @throws AnalysisException if the library source is not valid
    */
   Library createLibrary2(Source librarySource, int modificationStamp, CompilationUnit unit) {
-    Library library = new Library(_analysisContext, _errorListener, librarySource);
+    Library library = new Library(analysisContext, errorListener, librarySource);
     library.setDefiningCompilationUnit(modificationStamp, unit);
     _libraryMap[librarySource] = library;
     return library;
   }
 
   /**
    * Create an object to represent the information about the library defined by the compilation unit
    * with the given source. Return the library object that was created, or `null` if the
    * source is not valid.
    *
    * @param librarySource the source of the library's defining compilation unit
    * @return the library object that was created
    */
   Library createLibraryOrNull(Source librarySource) {
     if (!librarySource.exists()) {
       return null;
     }
-    Library library = new Library(_analysisContext, _errorListener, librarySource);
+    Library library = new Library(analysisContext, errorListener, librarySource);
     _libraryMap[librarySource] = library;
     return library;
   }
 
   /**
    * Return `true` if and only if the passed [CompilationUnit] has a part-of directive.
    *
    * @param node the [CompilationUnit] to test
    * @return `true` if and only if the passed [CompilationUnit] has a part-of directive
    */
@@ skipping 20 matching lines @@
       identifiers[i] = names[i].name;
     }
     return identifiers;
   }
 
   /**
    * Compute a value for all of the constants in the libraries being analyzed.
    */
   void performConstantEvaluation() {
     ConstantValueComputer computer = new ConstantValueComputer();
-    for (Library library in _librariesInCycles) {
+    for (Library library in resolvedLibraries) {
       for (Source source in library.compilationUnitSources) {
         try {
           CompilationUnit unit = library.getAST(source);
           if (unit != null) {
             computer.add(unit);
           }
         } on AnalysisException catch (exception) {
           AnalysisEngine.instance.logger.logError2("Internal Error: Could not access AST for ${source.fullName} during constant evaluation", exception);
         }
       }
     }
     computer.computeValues();
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the libraries in the current cycle.
    *
    * @throws AnalysisException if any of the identifiers could not be resolved or if any of the
    *           libraries could not have their types analyzed
    */
   void resolveReferencesAndTypes() {
-    for (Library library in _librariesInCycles) {
+    for (Library library in resolvedLibraries) {
       resolveReferencesAndTypes2(library);
     }
   }
 
   /**
    * Resolve the identifiers and perform type analysis in the given library.
    *
    * @param library the library to be resolved
    * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
    *           the library cannot be analyzed
@@ skipping 21 matching lines @@
   Source resolveSource(Source librarySource, UriBasedDirective directive) {
     StringLiteral uriLiteral = directive.uri;
     if (uriLiteral is StringInterpolation) {
       return null;
     }
     String uriContent = uriLiteral.stringValue.trim();
     if (uriContent == null || uriContent.isEmpty) {
       return null;
     }
     uriContent = Uri.encodeFull(uriContent);
-    return _analysisContext.sourceFactory.resolveUri(librarySource, uriContent);
+    return analysisContext.sourceFactory.resolveUri(librarySource, uriContent);
   }
 
   /**
    * Run additional analyses, such as the [ConstantVerifier] and [ErrorVerifier]
    * analysis in the current cycle.
    *
    * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
    *           the library cannot be analyzed
    */
   void runAdditionalAnalyses() {
-    for (Library library in _librariesInCycles) {
+    for (Library library in resolvedLibraries) {
       runAdditionalAnalyses2(library);
     }
   }
 
   /**
    * Run additional analyses, such as the [ConstantVerifier] and [ErrorVerifier]
    * analysis in the given library.
    *
    * @param library the library to have the extra analyses processes run
    * @throws AnalysisException if any of the identifiers could not be resolved or if the types in
    *           the library cannot be analyzed
    */
   void runAdditionalAnalyses2(Library library) {
     for (Source source in library.compilationUnitSources) {
-      ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
+      ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       CompilationUnit unit = library.getAST(source);
       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, _typeProvider);
       unit.accept(constantVerifier);
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, library.libraryElement, _typeProvider, library.inheritanceManager);
       unit.accept(errorVerifier);
     }
     if (_enableHints) {
-      HintGenerator hintGenerator = new HintGenerator(library.compilationUnits, _analysisContext, _errorListener);
+      HintGenerator hintGenerator = new HintGenerator(library.compilationUnits, analysisContext, errorListener);
       hintGenerator.generateForLibrary();
     }
   }
 }
 /**
  * This class is a wrapper for an [AnalysisError] which can also be queried after resolution
  * to find out if the error should actually be reported. In this case, these errors are conditional
  * on the non-existence of an `@proxy` annotation.
  *
  * If we have other conditional error codes in the future, we should have this class implement some
@@ skipping 37 matching lines @@
 
   /**
    * The enclosing [ClassElement], this is what will determine if the error code should, or
    * should not, be generated on the source.
    */
   Element _enclosingElement;
 
   /**
    * The conditional analysis error.
    */
-  AnalysisError _analysisError;
+  AnalysisError analysisError;
 
   /**
    * Instantiate a new ProxyConditionalErrorCode with some enclosing element and the conditional
    * analysis error.
    *
    * @param enclosingElement the enclosing element
    * @param analysisError the conditional analysis error
    */
   ProxyConditionalAnalysisError(Element enclosingElement, AnalysisError analysisError) {
     this._enclosingElement = enclosingElement;
-    this._analysisError = analysisError;
+    this.analysisError = analysisError;
   }
 
   /**
-   * Return the analysis error.
-   *
-   * @return the analysis error
-   */
-  AnalysisError get analysisError => _analysisError;
-
-  /**
    * Return `true` iff the enclosing class has the proxy annotation.
    *
    * @return `true` iff the enclosing class has the proxy annotation
    */
   bool shouldIncludeErrorCode() => !classHasProxyAnnotation(_enclosingElement);
 }
 /**
  * Instances of the class `ResolverVisitor` are used to resolve the nodes within a single
  * compilation unit.
  *
@@ skipping 13 matching lines @@
 
   /**
    * The object used to compute the type associated with the current node.
    */
   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;
+  ClassElement enclosingClass = null;
 
   /**
    * The element representing the function containing the current node, or `null` if the
    * current node is not contained in a function.
    */
-  ExecutableElement _enclosingFunction = null;
+  ExecutableElement enclosingFunction = null;
 
   /**
    * The object keeping track of which elements have had their types overridden.
    */
-  TypeOverrideManager _overrideManager = new TypeOverrideManager();
+  final TypeOverrideManager overrideManager = new TypeOverrideManager();
 
   /**
    * Proxy conditional error codes.
    */
-  List<ProxyConditionalAnalysisError> _proxyConditionalAnalysisErrors = new List<ProxyConditionalAnalysisError>();
+  final List<ProxyConditionalAnalysisError> proxyConditionalAnalysisErrors = new List<ProxyConditionalAnalysisError>();
 
   /**
    * 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.con1(Library library, Source source, TypeProvider typeProvider) : super.con1(library, source, typeProvider) {
     this._inheritanceManager = library.inheritanceManager;
     this._elementResolver = new ElementResolver(this);
     this._typeAnalyzer = 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);
   }
-
-  /**
-   * 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;
-  List<ProxyConditionalAnalysisError> get proxyConditionalAnalysisErrors => _proxyConditionalAnalysisErrors;
   Object visitAsExpression(AsExpression node) {
     super.visitAsExpression(node);
     override(node.expression, node.type.type);
     return null;
   }
   Object visitAssertStatement(AssertStatement node) {
     super.visitAssertStatement(node);
     propagateTrueState(node.condition);
     return null;
   }
   Object visitBinaryExpression(BinaryExpression node) {
     sc.TokenType operatorType = node.operator.type;
     Expression leftOperand = node.leftOperand;
     Expression rightOperand = node.rightOperand;
     if (identical(operatorType, sc.TokenType.AMPERSAND_AMPERSAND)) {
       safelyVisit(leftOperand);
       if (rightOperand != null) {
         try {
-          _overrideManager.enterScope();
+          overrideManager.enterScope();
           propagateTrueState(leftOperand);
           rightOperand.accept(this);
         } finally {
-          _overrideManager.exitScope();
+          overrideManager.exitScope();
         }
       }
     } else if (identical(operatorType, sc.TokenType.BAR_BAR)) {
       safelyVisit(leftOperand);
       if (rightOperand != null) {
         try {
-          _overrideManager.enterScope();
+          overrideManager.enterScope();
           propagateFalseState(leftOperand);
           rightOperand.accept(this);
         } finally {
-          _overrideManager.exitScope();
+          overrideManager.exitScope();
         }
       }
     } else {
       safelyVisit(leftOperand);
       safelyVisit(rightOperand);
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitBreakStatement(BreakStatement node) {
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitClassDeclaration(ClassDeclaration node) {
-    ClassElement outerType = _enclosingClass;
+    ClassElement outerType = enclosingClass;
     try {
-      _enclosingClass = node.element;
-      _typeAnalyzer.thisType = _enclosingClass == null ? null : _enclosingClass.type;
+      enclosingClass = node.element;
+      _typeAnalyzer.thisType = enclosingClass == null ? null : enclosingClass.type;
       super.visitClassDeclaration(node);
     } finally {
       _typeAnalyzer.thisType = outerType == null ? null : outerType.type;
-      _enclosingClass = outerType;
+      enclosingClass = outerType;
     }
     return null;
   }
   Object visitCommentReference(CommentReference node) {
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitCompilationUnit(CompilationUnit node) {
     try {
-      _overrideManager.enterScope();
+      overrideManager.enterScope();
       for (Directive directive in node.directives) {
         directive.accept(this);
       }
       List<CompilationUnitMember> classes = new List<CompilationUnitMember>();
       for (CompilationUnitMember declaration in node.declarations) {
         if (declaration is ClassDeclaration) {
           classes.add(declaration);
         } else {
           declaration.accept(this);
         }
       }
       for (CompilationUnitMember declaration in classes) {
         declaration.accept(this);
       }
     } finally {
-      _overrideManager.exitScope();
+      overrideManager.exitScope();
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitConditionalExpression(ConditionalExpression node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Expression thenExpression = node.thenExpression;
     if (thenExpression != null) {
       try {
-        _overrideManager.enterScope();
+        overrideManager.enterScope();
         propagateTrueState(condition);
         thenExpression.accept(this);
       } finally {
-        _overrideManager.exitScope();
+        overrideManager.exitScope();
       }
     }
     Expression elseExpression = node.elseExpression;
     if (elseExpression != null) {
       try {
-        _overrideManager.enterScope();
+        overrideManager.enterScope();
         propagateFalseState(condition);
         elseExpression.accept(this);
       } finally {
-        _overrideManager.exitScope();
+        overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     bool thenIsAbrupt = isAbruptTermination(thenExpression);
     bool elseIsAbrupt = isAbruptTermination(elseExpression);
     if (elseIsAbrupt && !thenIsAbrupt) {
       propagateTrueState(condition);
       propagateState(thenExpression);
     } else if (thenIsAbrupt && !elseIsAbrupt) {
       propagateFalseState(condition);
       propagateState(elseExpression);
     }
     return null;
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
-    ExecutableElement outerFunction = _enclosingFunction;
+    ExecutableElement outerFunction = enclosingFunction;
     try {
-      _enclosingFunction = node.element;
+      enclosingFunction = node.element;
       super.visitConstructorDeclaration(node);
     } finally {
-      _enclosingFunction = outerFunction;
+      enclosingFunction = outerFunction;
     }
     return null;
   }
   Object visitConstructorFieldInitializer(ConstructorFieldInitializer node) {
     safelyVisit(node.expression);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitConstructorName(ConstructorName node) {
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitContinueStatement(ContinueStatement node) {
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitDoStatement(DoStatement node) {
     try {
-      _overrideManager.enterScope();
+      overrideManager.enterScope();
       super.visitDoStatement(node);
     } finally {
-      _overrideManager.exitScope();
+      overrideManager.exitScope();
     }
     return null;
   }
   Object visitFieldDeclaration(FieldDeclaration node) {
     try {
-      _overrideManager.enterScope();
+      overrideManager.enterScope();
       super.visitFieldDeclaration(node);
     } finally {
-      Map<Element, Type2> overrides = _overrideManager.captureOverrides(node.fields);
-      _overrideManager.exitScope();
-      _overrideManager.applyOverrides(overrides);
+      Map<Element, Type2> overrides = overrideManager.captureOverrides(node.fields);
+      overrideManager.exitScope();
+      overrideManager.applyOverrides(overrides);
     }
     return null;
   }
   Object visitForEachStatement(ForEachStatement node) {
     try {
-      _overrideManager.enterScope();
+      overrideManager.enterScope();
       super.visitForEachStatement(node);
     } finally {
-      _overrideManager.exitScope();
+      overrideManager.exitScope();
     }
     return null;
   }
   Object visitForStatement(ForStatement node) {
     try {
-      _overrideManager.enterScope();
+      overrideManager.enterScope();
       super.visitForStatement(node);
     } finally {
-      _overrideManager.exitScope();
+      overrideManager.exitScope();
     }
     return null;
   }
   Object visitFunctionBody(FunctionBody node) {
     try {
-      _overrideManager.enterScope();
+      overrideManager.enterScope();
       super.visitFunctionBody(node);
     } finally {
-      _overrideManager.exitScope();
+      overrideManager.exitScope();
     }
     return null;
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
-    ExecutableElement outerFunction = _enclosingFunction;
+    ExecutableElement outerFunction = enclosingFunction;
     try {
       SimpleIdentifier functionName = node.name;
-      _enclosingFunction = functionName.staticElement as ExecutableElement;
+      enclosingFunction = functionName.staticElement as ExecutableElement;
       super.visitFunctionDeclaration(node);
     } finally {
-      _enclosingFunction = outerFunction;
+      enclosingFunction = outerFunction;
     }
     return null;
   }
   Object visitFunctionExpression(FunctionExpression node) {
-    ExecutableElement outerFunction = _enclosingFunction;
+    ExecutableElement outerFunction = enclosingFunction;
     try {
-      _enclosingFunction = node.element;
-      _overrideManager.enterScope();
+      enclosingFunction = node.element;
+      overrideManager.enterScope();
       super.visitFunctionExpression(node);
     } finally {
-      _overrideManager.exitScope();
-      _enclosingFunction = outerFunction;
+      overrideManager.exitScope();
+      enclosingFunction = outerFunction;
     }
     return null;
   }
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     safelyVisit(node.function);
     node.accept(_elementResolver);
     inferFunctionExpressionsParametersTypes(node.argumentList);
     safelyVisit(node.argumentList);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitHideCombinator(HideCombinator node) => null;
   Object visitIfStatement(IfStatement node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Map<Element, Type2> thenOverrides = null;
     Statement thenStatement = node.thenStatement;
     if (thenStatement != null) {
       try {
-        _overrideManager.enterScope();
+        overrideManager.enterScope();
         propagateTrueState(condition);
         visitStatementInScope(thenStatement);
       } finally {
-        thenOverrides = _overrideManager.captureLocalOverrides();
-        _overrideManager.exitScope();
+        thenOverrides = overrideManager.captureLocalOverrides();
+        overrideManager.exitScope();
       }
     }
     Map<Element, Type2> elseOverrides = null;
     Statement elseStatement = node.elseStatement;
     if (elseStatement != null) {
       try {
-        _overrideManager.enterScope();
+        overrideManager.enterScope();
         propagateFalseState(condition);
         visitStatementInScope(elseStatement);
       } finally {
-        elseOverrides = _overrideManager.captureLocalOverrides();
-        _overrideManager.exitScope();
+        elseOverrides = overrideManager.captureLocalOverrides();
+        overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     bool thenIsAbrupt = isAbruptTermination2(thenStatement);
     bool elseIsAbrupt = isAbruptTermination2(elseStatement);
     if (elseIsAbrupt && !thenIsAbrupt) {
       propagateTrueState(condition);
       if (thenOverrides != null) {
-        _overrideManager.applyOverrides(thenOverrides);
+        overrideManager.applyOverrides(thenOverrides);
       }
     } else if (thenIsAbrupt && !elseIsAbrupt) {
       propagateFalseState(condition);
       if (elseOverrides != null) {
-        _overrideManager.applyOverrides(elseOverrides);
+        overrideManager.applyOverrides(elseOverrides);
       }
     }
     return null;
   }
   Object visitLabel(Label node) => null;
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
   Object visitMethodDeclaration(MethodDeclaration node) {
-    ExecutableElement outerFunction = _enclosingFunction;
+    ExecutableElement outerFunction = enclosingFunction;
     try {
-      _enclosingFunction = node.element;
+      enclosingFunction = node.element;
       super.visitMethodDeclaration(node);
     } finally {
-      _enclosingFunction = outerFunction;
+      enclosingFunction = outerFunction;
     }
     return null;
   }
   Object visitMethodInvocation(MethodInvocation node) {
     safelyVisit(node.target);
     node.accept(_elementResolver);
     inferFunctionExpressionsParametersTypes(node.argumentList);
     safelyVisit(node.argumentList);
     node.accept(_typeAnalyzer);
     return null;
@@ skipping 24 matching lines @@
   }
   Object visitShowCombinator(ShowCombinator node) => null;
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     safelyVisit(node.argumentList);
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
   Object visitSwitchCase(SwitchCase node) {
     try {
-      _overrideManager.enterScope();
+      overrideManager.enterScope();
       super.visitSwitchCase(node);
     } finally {
-      _overrideManager.exitScope();
+      overrideManager.exitScope();
     }
     return null;
   }
   Object visitSwitchDefault(SwitchDefault node) {
     try {
-      _overrideManager.enterScope();
+      overrideManager.enterScope();
       super.visitSwitchDefault(node);
     } finally {
-      _overrideManager.exitScope();
+      overrideManager.exitScope();
     }
     return null;
   }
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     try {
-      _overrideManager.enterScope();
+      overrideManager.enterScope();
       super.visitTopLevelVariableDeclaration(node);
     } finally {
-      Map<Element, Type2> overrides = _overrideManager.captureOverrides(node.variables);
-      _overrideManager.exitScope();
-      _overrideManager.applyOverrides(overrides);
+      Map<Element, Type2> overrides = overrideManager.captureOverrides(node.variables);
+      overrideManager.exitScope();
+      overrideManager.applyOverrides(overrides);
     }
     return null;
   }
   Object visitTypeName(TypeName node) => null;
   Object visitWhileStatement(WhileStatement node) {
     Expression condition = node.condition;
     safelyVisit(condition);
     Statement body = node.body;
     if (body != null) {
       try {
-        _overrideManager.enterScope();
+        overrideManager.enterScope();
         propagateTrueState(condition);
         visitStatementInScope(body);
       } finally {
-        _overrideManager.exitScope();
+        overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
     return null;
   }
 
   /**
-   * Return the class element representing the class containing the current node, or `null` if
-   * the current node is not contained in a class.
-   *
-   * @return the class element representing the class containing the current node
-   */
-  ClassElement get enclosingClass => _enclosingClass;
-
-  /**
-   * 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;
-
-  /**
    * 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) {
       element = ((expression as SimpleIdentifier)).propagatedElement;
@@ skipping 63 matching lines @@
       return;
     }
     if (element is PropertyInducingElement) {
       PropertyInducingElement variable = element as PropertyInducingElement;
       if (!variable.isConst && !variable.isFinal) {
         return;
       }
     }
     Type2 currentType = getBestType(element);
     if (currentType == null || !currentType.isMoreSpecificThan(potentialType)) {
-      _overrideManager.setType(element, potentialType);
+      overrideManager.setType(element, potentialType);
     }
   }
 
   /**
    * Report a conditional analysis error with the given error code and arguments.
    *
    * @param enclosingElement the enclosing element
    * @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 reportErrorProxyConditionalAnalysisError(Element enclosingElement, ErrorCode errorCode, ASTNode node, List<Object> arguments) {
-    _proxyConditionalAnalysisErrors.add(new ProxyConditionalAnalysisError(enclosingElement, new AnalysisError.con2(source, node.offset, node.length, errorCode, arguments)));
+    proxyConditionalAnalysisErrors.add(new ProxyConditionalAnalysisError(enclosingElement, new AnalysisError.con2(source, node.offset, node.length, errorCode, arguments)));
   }
 
   /**
    * Report a conditional analysis error with the given error code and arguments.
    *
    * @param enclosingElement the enclosing element
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the location of the error
    * @param length the length of the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportErrorProxyConditionalAnalysisError2(Element enclosingElement, ErrorCode errorCode, int offset, int length, List<Object> arguments) {
-    _proxyConditionalAnalysisErrors.add(new ProxyConditionalAnalysisError(enclosingElement, new AnalysisError.con2(source, offset, length, errorCode, arguments)));
+    proxyConditionalAnalysisErrors.add(new ProxyConditionalAnalysisError(enclosingElement, new AnalysisError.con2(source, offset, length, errorCode, arguments)));
   }
 
   /**
    * Report a conditional analysis error with the given error code and arguments.
    *
    * @param enclosingElement the enclosing element
    * @param errorCode the error code of the error to be reported
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportErrorProxyConditionalAnalysisError3(Element enclosingElement, ErrorCode errorCode, sc.Token token, List<Object> arguments) {
-    _proxyConditionalAnalysisErrors.add(new ProxyConditionalAnalysisError(enclosingElement, new AnalysisError.con2(source, token.offset, token.length, errorCode, arguments)));
+    proxyConditionalAnalysisErrors.add(new ProxyConditionalAnalysisError(enclosingElement, new AnalysisError.con2(source, token.offset, token.length, errorCode, arguments)));
   }
   void visitForEachStatementInScope(ForEachStatement node) {
     Expression iterator = node.iterator;
     safelyVisit(iterator);
     DeclaredIdentifier loopVariable = node.loopVariable;
     safelyVisit(loopVariable);
     Statement body = node.body;
     if (body != null) {
       try {
-        _overrideManager.enterScope();
+        overrideManager.enterScope();
         if (loopVariable != null && iterator != null) {
           LocalVariableElement loopElement = loopVariable.element;
           if (loopElement != null) {
             Type2 iteratorElementType = getIteratorElementType(iterator);
             override2(loopElement, iteratorElementType);
             recordPropagatedType(loopVariable.identifier, iteratorElementType);
           }
         }
         visitStatementInScope(body);
       } finally {
-        _overrideManager.exitScope();
+        overrideManager.exitScope();
       }
     }
     node.accept(_elementResolver);
     node.accept(_typeAnalyzer);
   }
   void visitForStatementInScope(ForStatement node) {
     safelyVisit(node.variables);
     safelyVisit(node.initialization);
     safelyVisit(node.condition);
-    _overrideManager.enterScope();
+    overrideManager.enterScope();
     try {
       propagateTrueState(node.condition);
       visitStatementInScope(node.body);
       node.updaters.accept(this);
     } finally {
-      _overrideManager.exitScope();
+      overrideManager.exitScope();
     }
   }
 
   /**
    * Return the best type information available for the given element. If the type of the element
    * has been overridden, then return the overriding type. Otherwise, return the static type.
    *
    * @param element the element for which type information is to be returned
    * @return the best type information available for the given element
    */
   Type2 getBestType(Element element) {
-    Type2 bestType = _overrideManager.getType(element);
+    Type2 bestType = overrideManager.getType(element);
     if (bestType == null) {
       if (element is LocalVariableElement) {
         bestType = ((element as LocalVariableElement)).type;
       } else if (element is ParameterElement) {
         bestType = ((element as ParameterElement)).type;
       }
     }
     return bestType;
   }
 
@@ skipping 41 matching lines @@
     FunctionType expectedClosureType = mayByFunctionType as FunctionType;
     closure.propagatedType = expectedClosureType;
     NodeList<FormalParameter> parameters = closure.parameters.parameters;
     List<ParameterElement> expectedParameters = expectedClosureType.parameters;
     for (int i = 0; i < parameters.length && i < expectedParameters.length; i++) {
       FormalParameter parameter = parameters[i];
       ParameterElement element = parameter.element;
       Type2 currentType = getBestType(element);
       Type2 expectedType = expectedParameters[i].type;
       if (currentType == null || expectedType.isMoreSpecificThan(currentType)) {
-        _overrideManager.setType(element, expectedType);
+        overrideManager.setType(element, expectedType);
       }
     }
   }
 
   /**
    * Try to infer types of parameters of the [FunctionExpression] arguments.
    */
   void inferFunctionExpressionsParametersTypes(ArgumentList argumentList) {
     for (Expression argument in argumentList.arguments) {
       ParameterElement parameter = argument.propagatedParameterElement;
@@ skipping 114 matching lines @@
    * @param expression the node whose type is to be recorded
    * @param type the propagated type of the node
    */
   void recordPropagatedType(Expression expression, Type2 type) {
     if (type != null && !type.isDynamic) {
       expression.propagatedType = type;
     }
   }
   get elementResolver_J2DAccessor => _elementResolver;
   set elementResolver_J2DAccessor(__v) => _elementResolver = __v;
-  get labelScope_J2DAccessor => _labelScope;
-  set labelScope_J2DAccessor(__v) => _labelScope = __v;
-  get nameScope_J2DAccessor => _nameScope;
-  set nameScope_J2DAccessor(__v) => _nameScope = __v;
+  get labelScope_J2DAccessor => labelScope;
+  set labelScope_J2DAccessor(__v) => labelScope = __v;
+  get nameScope_J2DAccessor => nameScope;
+  set nameScope_J2DAccessor(__v) => nameScope = __v;
   get typeAnalyzer_J2DAccessor => _typeAnalyzer;
   set typeAnalyzer_J2DAccessor(__v) => _typeAnalyzer = __v;
-  get enclosingClass_J2DAccessor => _enclosingClass;
-  set enclosingClass_J2DAccessor(__v) => _enclosingClass = __v;
+  get enclosingClass_J2DAccessor => enclosingClass;
+  set enclosingClass_J2DAccessor(__v) => enclosingClass = __v;
 }
 /**
  * The abstract class `ScopedVisitor` maintains name and label scopes as an AST structure is
  * being visited.
  *
  * @coverage dart.engine.resolver
  */
 abstract class ScopedVisitor extends GeneralizingASTVisitor<Object> {
 
   /**
    * The element for the library containing the compilation unit being visited.
    */
-  LibraryElement _definingLibrary;
+  LibraryElement definingLibrary;
 
   /**
    * The source representing the compilation unit being visited.
    */
-  Source _source;
+  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.
    */
-  TypeProvider _typeProvider;
+  TypeProvider typeProvider;
 
   /**
    * 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;
 
   /**
    * 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, Source source, TypeProvider typeProvider) {
-    this._definingLibrary = library.libraryElement;
-    this._source = source;
+    this.definingLibrary = library.libraryElement;
+    this.source = source;
     LibraryScope libraryScope = library.libraryScope;
     this._errorListener = libraryScope.errorListener;
-    this._nameScope = libraryScope;
-    this._typeProvider = typeProvider;
+    this.nameScope = libraryScope;
+    this.typeProvider = typeProvider;
   }
 
   /**
    * 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, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
-    this._definingLibrary = definingLibrary;
-    this._source = source;
+    this.definingLibrary = definingLibrary;
+    this.source = source;
     this._errorListener = errorListener;
-    this._nameScope = new LibraryScope(definingLibrary, errorListener);
-    this._typeProvider = typeProvider;
+    this.nameScope = new LibraryScope(definingLibrary, errorListener);
+    this.typeProvider = typeProvider;
   }
 
   /**
-   * 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 object used to access the types from the core library.
-   *
-   * @return the object used to access the types from the core library
-   */
-  TypeProvider get typeProvider => _typeProvider;
-
-  /**
    * Report an error with the given analysis error.
    *
    * @param errorCode analysis error
    */
   void reportError(AnalysisError analysisError) {
     _errorListener.onError(analysisError);
   }
   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;
   }
   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;
   }
   Object visitClassDeclaration(ClassDeclaration node) {
-    Scope outerScope = _nameScope;
+    Scope outerScope = nameScope;
     try {
-      _nameScope = new ClassScope(_nameScope, node.element);
+      nameScope = new ClassScope(nameScope, node.element);
       super.visitClassDeclaration(node);
     } finally {
-      _nameScope = outerScope;
+      nameScope = outerScope;
     }
     return null;
   }
   Object visitClassTypeAlias(ClassTypeAlias node) {
-    Scope outerScope = _nameScope;
+    Scope outerScope = nameScope;
     try {
-      _nameScope = new ClassScope(_nameScope, node.element);
+      nameScope = new ClassScope(nameScope, node.element);
       super.visitClassTypeAlias(node);
     } finally {
-      _nameScope = outerScope;
+      nameScope = outerScope;
     }
     return null;
   }
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
-    Scope outerScope = _nameScope;
+    Scope outerScope = nameScope;
     try {
-      _nameScope = new FunctionScope(_nameScope, node.element);
+      nameScope = new FunctionScope(nameScope, node.element);
       super.visitConstructorDeclaration(node);
     } finally {
-      _nameScope = outerScope;
+      nameScope = outerScope;
     }
     return null;
   }
   Object visitDeclaredIdentifier(DeclaredIdentifier node) {
     VariableElement element = node.element;
     if (element != null) {
-      _nameScope.define(element);
+      nameScope.define(element);
     }
     super.visitDeclaredIdentifier(node);
     return null;
   }
   Object visitDoStatement(DoStatement node) {
-    LabelScope outerLabelScope = _labelScope;
+    LabelScope outerLabelScope = labelScope;
     try {
-      _labelScope = new LabelScope.con1(_labelScope, false, false);
+      labelScope = new LabelScope.con1(labelScope, false, false);
       visitStatementInScope(node.body);
       safelyVisit(node.condition);
     } finally {
-      _labelScope = outerLabelScope;
+      labelScope = outerLabelScope;
     }
     return null;
   }
   Object visitForEachStatement(ForEachStatement node) {
-    Scope outerNameScope = _nameScope;
-    LabelScope outerLabelScope = _labelScope;
+    Scope outerNameScope = nameScope;
+    LabelScope outerLabelScope = labelScope;
     try {
-      _nameScope = new EnclosedScope(_nameScope);
-      _labelScope = new LabelScope.con1(outerLabelScope, false, false);
+      nameScope = new EnclosedScope(nameScope);
+      labelScope = new LabelScope.con1(outerLabelScope, false, false);
       visitForEachStatementInScope(node);
     } finally {
-      _labelScope = outerLabelScope;
-      _nameScope = outerNameScope;
+      labelScope = outerLabelScope;
+      nameScope = outerNameScope;
     }
     return null;
   }
   Object visitForStatement(ForStatement node) {
-    Scope outerNameScope = _nameScope;
-    LabelScope outerLabelScope = _labelScope;
+    Scope outerNameScope = nameScope;
+    LabelScope outerLabelScope = labelScope;
     try {
-      _nameScope = new EnclosedScope(_nameScope);
-      _labelScope = new LabelScope.con1(outerLabelScope, false, false);
+      nameScope = new EnclosedScope(nameScope);
+      labelScope = new LabelScope.con1(outerLabelScope, false, false);
       visitForStatementInScope(node);
     } finally {
-      _labelScope = outerLabelScope;
-      _nameScope = outerNameScope;
+      labelScope = outerLabelScope;
+      nameScope = outerNameScope;
     }
     return null;
   }
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     ExecutableElement function = node.element;
-    Scope outerScope = _nameScope;
+    Scope outerScope = nameScope;
     try {
-      _nameScope = new FunctionScope(_nameScope, function);
+      nameScope = new FunctionScope(nameScope, function);
       super.visitFunctionDeclaration(node);
     } finally {
-      _nameScope = outerScope;
+      nameScope = outerScope;
     }
     if (function.enclosingElement is! CompilationUnitElement) {
-      _nameScope.define(function);
+      nameScope.define(function);
     }
     return null;
   }
   Object visitFunctionExpression(FunctionExpression node) {
     if (node.parent is FunctionDeclaration) {
       super.visitFunctionExpression(node);
     } else {
-      Scope outerScope = _nameScope;
+      Scope outerScope = nameScope;
       try {
         ExecutableElement functionElement = node.element;
         if (functionElement == null) {
         } else {
-          _nameScope = new FunctionScope(_nameScope, functionElement);
+          nameScope = new FunctionScope(nameScope, functionElement);
         }
         super.visitFunctionExpression(node);
       } finally {
-        _nameScope = outerScope;
+        nameScope = outerScope;
       }
     }
     return null;
   }
   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;
   }
   Object visitIfStatement(IfStatement node) {
     safelyVisit(node.condition);
     visitStatementInScope(node.thenStatement);
     visitStatementInScope(node.elseStatement);
     return null;
   }
   Object visitLabeledStatement(LabeledStatement node) {
     LabelScope outerScope = addScopesFor(node.labels);
     try {
       super.visitLabeledStatement(node);
     } finally {
-      _labelScope = outerScope;
+      labelScope = outerScope;
     }
     return null;
   }
   Object visitMethodDeclaration(MethodDeclaration node) {
-    Scope outerScope = _nameScope;
+    Scope outerScope = nameScope;
     try {
-      _nameScope = new FunctionScope(_nameScope, node.element);
+      nameScope = new FunctionScope(nameScope, node.element);
       super.visitMethodDeclaration(node);
     } finally {
-      _nameScope = outerScope;
+      nameScope = outerScope;
     }
     return null;
   }
   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;
   }
   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;
   }
   Object visitSwitchStatement(SwitchStatement node) {
-    LabelScope outerScope = _labelScope;
+    LabelScope outerScope = labelScope;
     try {
-      _labelScope = new LabelScope.con1(outerScope, true, false);
+      labelScope = new LabelScope.con1(outerScope, true, false);
       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.con2(_labelScope, labelName.name, labelElement);
+          labelScope = new LabelScope.con2(labelScope, labelName.name, labelElement);
         }
       }
       super.visitSwitchStatement(node);
     } finally {
-      _labelScope = outerScope;
+      labelScope = outerScope;
     }
     return null;
   }
   Object visitVariableDeclaration(VariableDeclaration 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);
       }
     }
     super.visitVariableDeclaration(node);
     return null;
   }
   Object visitWhileStatement(WhileStatement node) {
-    LabelScope outerScope = _labelScope;
+    LabelScope outerScope = labelScope;
     try {
-      _labelScope = new LabelScope.con1(outerScope, false, false);
+      labelScope = new LabelScope.con1(outerScope, false, false);
       safelyVisit(node.condition);
       visitStatementInScope(node.body);
     } finally {
-      _labelScope = outerScope;
+      labelScope = outerScope;
     }
     return null;
   }
 
   /**
-   * 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;
-
-  /**
-   * Return the source.
-   *
-   * @return the source
-   */
-  Source get source => _source;
-
-  /**
    * 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 reportError5(ErrorCode errorCode, ASTNode node, List<Object> arguments) {
-    _errorListener.onError(new AnalysisError.con2(_source, node.offset, node.length, errorCode, arguments));
+    _errorListener.onError(new AnalysisError.con2(source, node.offset, node.length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param offset the offset of the location of the error
    * @param length the length of the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportError6(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
-    _errorListener.onError(new AnalysisError.con2(_source, offset, length, errorCode, arguments));
+    _errorListener.onError(new AnalysisError.con2(source, offset, length, errorCode, arguments));
   }
 
   /**
    * Report an error with the given error code and arguments.
    *
    * @param errorCode the error code of the error to be reported
    * @param token the token specifying the location of the error
    * @param arguments the arguments to the error, used to compose the error message
    */
   void reportError7(ErrorCode errorCode, sc.Token token, List<Object> arguments) {
-    _errorListener.onError(new AnalysisError.con2(_source, token.offset, token.length, errorCode, arguments));
+    _errorListener.onError(new AnalysisError.con2(source, token.offset, token.length, errorCode, arguments));
   }
 
   /**
    * Visit the given AST node if it is not null.
    *
    * @param node the node to be visited
    */
   void safelyVisit(ASTNode node) {
     if (node != null) {
       node.accept(this);
@@ skipping 31 matching lines @@
   /**
    * 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) {
       visitBlock(node as Block);
     } 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;
       }
     }
   }
 
   /**
    * 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) {
-    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.con2(_labelScope, labelName, labelElement);
+      labelScope = new LabelScope.con2(labelScope, labelName, 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 2910 matching lines @@
  * Instances of the class `EnclosedScope` implement a scope that is lexically enclosed in
  * another scope.
  *
  * @coverage dart.engine.resolver
  */
 class EnclosedScope extends Scope {
 
   /**
    * The scope in which this scope is lexically enclosed.
    */
-  Scope _enclosingScope;
+  Scope enclosingScope;
 
   /**
    * A set of names that will be defined in this scope, but right now are not defined. However
    * according to the scoping rules these names are hidden, even if they were defined in an outer
    * scope.
    */
   Set<String> _hiddenNames = new Set<String>();
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    */
   EnclosedScope(Scope enclosingScope) {
-    this._enclosingScope = enclosingScope;
+    this.enclosingScope = enclosingScope;
   }
-  LibraryElement get definingLibrary => _enclosingScope.definingLibrary;
-  AnalysisErrorListener get errorListener => _enclosingScope.errorListener;
+  LibraryElement get definingLibrary => enclosingScope.definingLibrary;
+  AnalysisErrorListener get errorListener => enclosingScope.errorListener;
 
   /**
    * Hides the name of the given element in this scope. If there is already an element with the
    * given name defined in an outer scope, then it will become unavailable.
    *
    * @param element the element to be hidden in this scope
    */
   void hide(Element element) {
     if (element != null) {
       String name = element.name;
       if (name != null && !name.isEmpty) {
         javaSetAdd(_hiddenNames, name);
       }
     }
   }
-
-  /**
-   * Return the scope in which this scope is lexically enclosed.
-   *
-   * @return the scope in which this scope is lexically enclosed
-   */
-  Scope get enclosingScope => _enclosingScope;
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element element = localLookup(name, referencingLibrary);
     if (element != null) {
       return element;
     }
     if (_hiddenNames.contains(name)) {
       return null;
     }
-    return _enclosingScope.lookup3(identifier, name, referencingLibrary);
+    return enclosingScope.lookup3(identifier, name, referencingLibrary);
   }
 }
 /**
  * Instances of the class `FunctionScope` implement the scope defined by a function.
  *
  * @coverage dart.engine.resolver
  */
 class FunctionScope extends EnclosedScope {
 
   /**
@@ skipping 5291 matching lines @@
   ResolverErrorCode.con2(String name, int ordinal, ErrorType type, String message, String correction) : super(name, ordinal) {
     this._type = type;
     this._message = message;
     this.correction9 = correction;
   }
   String get correction => correction9;
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
 }