New analyzer snapshot.

pkg/analyzer/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';
@@ skipping 1102 matching lines @@
   static String _SRC = "src";
 
   /**
    * 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.
    */
-  final Set<Library> resolvedLibraries = new Set<Library>();
+  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 12 matching lines @@
     _lineInfo = _context.computeLineInfo(source);
     HtmlElementImpl result = new HtmlElementImpl(_context, source.shortName);
     result.source = source;
     _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 visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) {
     if (_parentNodes.contains(node)) {
       return reportCircularity(node);
     }
     _parentNodes.add(node);
     try {
       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);
         try {
           LibraryResolver resolver = new LibraryResolver(_context);
           LibraryElementImpl library = resolver.resolveEmbeddedLibrary(htmlSource, _modificationStamp, node.script, 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);
         }
         node.scriptElement = script;
         _scripts.add(script);
       } else {
         ExternalHtmlScriptElementImpl script = new ExternalHtmlScriptElementImpl(node);
         if (scriptSourcePath != null) {
           try {
             scriptSourcePath = Uri.encodeFull(scriptSourcePath);
@@ skipping 93 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 1195 matching lines @@
       String fullName = source.fullName;
       if (fullName != null) {
         return fullName.replaceAll(r'\', '/');
       }
     }
     return null;
   }
 }
 
 /**
+ * Instances of the class `ReturnDetector` determine whether the visited AST node is
+ * guaranteed (modulo exceptions) to terminate by executing a return statement.
+ */
+class ReturnDetector extends UnifyingASTVisitor<bool> {
+  bool visitBlock(Block node) => visitStatements(node.statements);
+
+  bool visitBlockFunctionBody(BlockFunctionBody node) => node.block.accept(this);
+
+  bool visitIfStatement(IfStatement node) {
+    Statement thenStatement = node.thenStatement;
+    Statement elseStatement = node.elseStatement;
+    if (thenStatement == null || elseStatement == null) {
+      return false;
+    }
+    return thenStatement.accept(this) && elseStatement.accept(this);
+  }
+
+  bool visitNode(ASTNode node) => false;
+
+  bool visitReturnStatement(ReturnStatement node) => true;
+
+  bool visitSwitchCase(SwitchCase node) => visitStatements(node.statements);
+
+  bool visitSwitchDefault(SwitchDefault node) => visitStatements(node.statements);
+
+  bool visitSwitchStatement(SwitchStatement node) {
+    bool hasDefault = false;
+    for (SwitchMember member in node.members) {
+      if (!member.accept(this)) {
+        return false;
+      }
+      if (member is SwitchDefault) {
+        hasDefault = true;
+      }
+    }
+    return hasDefault;
+  }
+
+  bool visitStatements(NodeList<Statement> statements) {
+    for (int i = statements.length - 1; i >= 0; i--) {
+      if (statements[i].accept(this)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+/**
  * Instances of the class `ToDoFinder` find to-do comments in Dart code.
  */
 class ToDoFinder {
   /**
    * The error reporter by which to-do comments will be reported.
    */
   ErrorReporter _errorReporter;
 
   /**
    * Initialize a newly created to-do finder to report to-do comments to the given reporter.
@@ skipping 3308 matching lines @@
 /**
  * Instances of the class `SyntheticIdentifier` implement an identifier that can be used to
  * look up names in the lexical scope when there is no identifier in the AST structure. There is
  * no identifier in the AST when the parser could not distinguish between a method invocation and
  * an invocation of a top-level function imported with a prefix.
  */
 class ElementResolver_SyntheticIdentifier extends Identifier {
   /**
    * The name of the synthetic identifier.
    */
-  String _name;
+  final String name;
 
   /**
    * Initialize a newly created synthetic identifier to have the given name.
    *
    * @param name the name of the synthetic identifier
    */
-  ElementResolver_SyntheticIdentifier(String name) {
-    this._name = name;
-  }
+  ElementResolver_SyntheticIdentifier(this.name);
 
   accept(ASTVisitor visitor) => null;
 
   sc.Token get beginToken => null;
 
   Element get bestElement => null;
 
   sc.Token get endToken => null;
 
-  String get name => _name;
-
   int get precedence => 16;
 
   Element get propagatedElement => null;
 
   Element get staticElement => null;
 
   void visitChildren(ASTVisitor visitor) {
   }
 }
 
@@ skipping 668 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;
+  final 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> imports = _EMPTY_ARRAY;
+  List<Library> _importedLibraries = _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;
 
   /**
    * A list containing all of the libraries that are exported from this library.
    */
-  List<Library> exports = _EMPTY_ARRAY;
+  List<Library> _exportedLibraries = _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);
 
   /**
    * The prefix of a URI using the dart-ext scheme to reference a native code library.
    */
   static String _DART_EXT_SCHEME = "dart-ext:";
 
   /**
    * 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) {
+  Library(InternalAnalysisContext analysisContext, AnalysisErrorListener errorListener, this.librarySource) {
     this._analysisContext = analysisContext;
     this._errorListener = errorListener;
-    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 35 matching lines @@
   /**
    * 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 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;
+
+  /**
    * 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 imports) {
+    for (Library library in _importedLibraries) {
       libraries.add(library);
     }
-    for (Library library in exports) {
+    for (Library library in _exportedLibraries) {
       libraries.add(library);
     }
     return new List.from(libraries);
   }
 
   /**
    * Return the inheritance manager for this library.
    *
    * @return the inheritance manager for this library
    */
@@ skipping 108 matching lines @@
   void setDefiningCompilationUnit(int modificationStamp, CompilationUnit unit) {
     _astMap[librarySource] = new ResolvableCompilationUnit(modificationStamp, unit);
   }
 
   /**
    * 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> exportedLibraries) {
-    this.exports = exportedLibraries;
+    this._exportedLibraries = exportedLibraries;
   }
 
   /**
    * 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> importedLibraries) {
-    this.imports = importedLibraries;
+    this._importedLibraries = importedLibraries;
   }
 
   /**
    * Set the library element representing this library to the given library element.
    *
    * @param libraryElement the library element representing this library
    */
   void set libraryElement(LibraryElementImpl libraryElement) {
     this._libraryElement = libraryElement;
     if (_inheritanceManager != null) {
@@ skipping 195 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;
+  final InternalAnalysisContext analysisContext;
 
   /**
    * 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> resolvedLibraries;
+  Set<Library> _librariesInCycles;
 
   /**
    * 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();
+  LibraryResolver(this.analysisContext) {
+    this._errorListener = new RecordingErrorListener();
     _coreLibrarySource = analysisContext.sourceFactory.forUri(DartSdk.DART_CORE);
   }
 
   /**
+   * 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);
-      resolvedLibraries = computeLibrariesInCycles(targetLibrary);
+      _librariesInCycles = 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 29 matching lines @@
       Library targetLibrary = createLibrary(librarySource);
       _coreLibrary = _libraryMap[_coreLibrarySource];
       if (_coreLibrary == null) {
         _coreLibrary = createLibraryOrNull(_coreLibrarySource);
         if (_coreLibrary == null) {
           throw new AnalysisException.con1("Core library does not exist");
         }
       }
       instrumentation.metric3("createLibrary", "complete");
       computeLibraryDependencies(targetLibrary);
-      resolvedLibraries = computeLibrariesInCycles(targetLibrary);
+      _librariesInCycles = 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");
-      instrumentation.metric2("librariesInCycles", resolvedLibraries.length);
-      for (Library lib in resolvedLibraries) {
+      instrumentation.metric2("librariesInCycles", _librariesInCycles.length);
+      for (Library lib in _librariesInCycles) {
         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 78 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 resolvedLibraries) {
+    for (Library library in _librariesInCycles) {
       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 17 matching lines @@
                 if (prefix == null) {
                   prefix = new PrefixElementImpl(prefixNode);
                   nameToPrefixMap[prefixName] = prefix;
                 }
                 importElement.prefix = prefix;
                 prefixNode.staticElement = prefix;
               }
               directive.element = importElement;
               imports.add(importElement);
               if (analysisContext.computeKindOf(importedSource) != SourceKind.LIBRARY) {
-                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 (analysisContext.computeKindOf(exportedSource) != SourceKind.LIBRARY) {
                 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 resolvedLibraries) {
+    for (Library library in _librariesInCycles) {
       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() {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
     try {
-      for (Library library in resolvedLibraries) {
+      for (Library library in _librariesInCycles) {
         for (Source source in library.compilationUnitSources) {
           TypeResolverVisitor visitor = new TypeResolverVisitor.con1(library, source, _typeProvider);
           library.getAST(source).accept(visitor);
         }
       }
     } finally {
       timeCounter.stop();
     }
   }
 
@@ skipping 124 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 an array containing the lexical identifiers associated with the nodes in the given list.
    *
    * @param names the AST nodes representing the identifiers
    * @return the lexical identifiers associated with the nodes in the list
    */
   List<String> getIdentifiers(NodeList<SimpleIdentifier> names) {
     int count = names.length;
     List<String> identifiers = new List<String>(count);
     for (int i = 0; i < count; i++) {
       identifiers[i] = names[i].name;
     }
     return identifiers;
   }
 
   /**
    * Compute a value for all of the constants in the libraries being analyzed.
    */
   void performConstantEvaluation() {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
     try {
       ConstantValueComputer computer = new ConstantValueComputer();
-      for (Library library in resolvedLibraries) {
+      for (Library library in _librariesInCycles) {
         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();
     } finally {
       timeCounter.stop();
     }
   }
 
   /**
    * 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 resolvedLibraries) {
+    for (Library library in _librariesInCycles) {
       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 40 matching lines @@
 }
 
 /**
  * This class is used to replace uses of `HashMap<String, ExecutableElement>` which are not as
  * performant as this class.
  */
 class MemberMap {
   /**
    * The current size of this map.
    */
-  int size = 0;
+  int _size = 0;
 
   /**
    * The array of keys.
    */
   List<String> _keys;
 
   /**
    * The array of ExecutableElement values.
    */
   List<ExecutableElement> _values;
 
   /**
    * Default constructor.
    */
   MemberMap() : this.con1(10);
 
   /**
    * This constructor takes an initial capacity of the map.
    *
    * @param initialCapacity the initial capacity
    */
   MemberMap.con1(int initialCapacity) {
     initArrays(initialCapacity);
   }
 
   /**
    * Copy constructor.
    */
   MemberMap.con2(MemberMap memberMap) {
-    initArrays(memberMap.size + 5);
-    for (int i = 0; i < memberMap.size; i++) {
+    initArrays(memberMap._size + 5);
+    for (int i = 0; i < memberMap._size; i++) {
       _keys[i] = memberMap._keys[i];
       _values[i] = memberMap._values[i];
     }
-    size = memberMap.size;
+    _size = memberMap._size;
   }
 
   /**
    * Given some key, return the ExecutableElement value from the map, if the key does not exist in
    * the map, `null` is returned.
    *
    * @param key some key to look up in the map
    * @return the associated ExecutableElement value from the map, if the key does not exist in the
    *         map, `null` is returned
    */
   ExecutableElement get(String key) {
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < _size; i++) {
       if (_keys[i] != null && _keys[i] == key) {
         return _values[i];
       }
     }
     return null;
   }
 
   /**
    * Get and return the key at the specified location. If the key/value pair has been removed from
    * the set, then `null` is returned.
    *
    * @param i some non-zero value less than size
    * @return the key at the passed index
    * @throw ArrayIndexOutOfBoundsException this exception is thrown if the passed index is less than
    *        zero or greater than or equal to the capacity of the arrays
    */
   String getKey(int i) => _keys[i];
 
   /**
+   * The size of the map.
+   *
+   * @return the size of the map.
+   */
+  int get size => _size;
+
+  /**
    * Get and return the ExecutableElement at the specified location. If the key/value pair has been
    * removed from the set, then then `null` is returned.
    *
    * @param i some non-zero value less than size
    * @return the key at the passed index
    * @throw ArrayIndexOutOfBoundsException this exception is thrown if the passed index is less than
    *        zero or greater than or equal to the capacity of the arrays
    */
   ExecutableElement getValue(int i) => _values[i];
 
   /**
    * Given some key/value pair, store the pair in the map. If the key exists already, then the new
    * value overrides the old value.
    *
    * @param key the key to store in the map
    * @param value the ExecutableElement value to store in the map
    */
   void put(String key, ExecutableElement value) {
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < _size; i++) {
       if (_keys[i] != null && _keys[i] == key) {
         _values[i] = value;
         return;
       }
     }
-    if (size == _keys.length) {
-      int newArrayLength = size * 2;
+    if (_size == _keys.length) {
+      int newArrayLength = _size * 2;
       List<String> keys_new_array = new List<String>(newArrayLength);
       List<ExecutableElement> values_new_array = new List<ExecutableElement>(newArrayLength);
-      for (int i = 0; i < size; i++) {
+      for (int i = 0; i < _size; i++) {
         keys_new_array[i] = _keys[i];
       }
-      for (int i = 0; i < size; i++) {
+      for (int i = 0; i < _size; i++) {
         values_new_array[i] = _values[i];
       }
       _keys = keys_new_array;
       _values = values_new_array;
     }
-    _keys[size] = key;
-    _values[size] = value;
-    size++;
+    _keys[_size] = key;
+    _values[_size] = value;
+    _size++;
   }
 
   /**
    * Given some String key, this method replaces the associated key and value pair with `null`
    * . The size is not decremented with this call, instead it is expected that the users check for
    * `null`.
    *
    * @param key the key of the key/value pair to remove from the map
    */
   void remove(String key) {
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < _size; i++) {
       if (_keys[i] == key) {
         _keys[i] = null;
         _values[i] = null;
         return;
       }
     }
   }
 
   /**
    * Sets the ExecutableElement at the specified location.
@@ skipping 34 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;
+  final 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) {
+  ProxyConditionalAnalysisError(Element enclosingElement, this.analysisError) {
     this._enclosingElement = enclosingElement;
-    this.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);
 }
 
@@ skipping 16 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.
    */
-  final TypeOverrideManager overrideManager = new TypeOverrideManager();
+  TypeOverrideManager _overrideManager = new TypeOverrideManager();
 
   /**
    * The object keeping track of which elements have had their types promoted.
    */
-  final TypePromotionManager promoteManager = new TypePromotionManager();
+  TypePromotionManager _promoteManager = new TypePromotionManager();
 
   /**
    * Proxy conditional error codes.
    */
-  final List<ProxyConditionalAnalysisError> proxyConditionalAnalysisErrors = new List<ProxyConditionalAnalysisError>();
+  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;
@@ skipping 26 matching lines @@
    * @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);
   }
 
+  /**
+   * 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;
+
+  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();
-          promoteManager.enterScope();
+          _overrideManager.enterScope();
+          _promoteManager.enterScope();
           propagateTrueState(leftOperand);
           promoteTypes(leftOperand);
           clearTypePromotionsIfPotentiallyMutatedIn(leftOperand);
           clearTypePromotionsIfPotentiallyMutatedIn(rightOperand);
           clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(rightOperand);
           rightOperand.accept(this);
         } finally {
-          overrideManager.exitScope();
-          promoteManager.exitScope();
+          _overrideManager.exitScope();
+          _promoteManager.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 visitBlockFunctionBody(BlockFunctionBody node) {
     try {
-      overrideManager.enterScope();
+      _overrideManager.enterScope();
       super.visitBlockFunctionBody(node);
     } finally {
-      overrideManager.exitScope();
+      _overrideManager.exitScope();
     }
     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();
       NodeList<Directive> directives = node.directives;
       int directiveCount = directives.length;
       for (int i = 0; i < directiveCount; i++) {
         directives[i].accept(this);
       }
       NodeList<CompilationUnitMember> declarations = node.declarations;
       int declarationCount = declarations.length;
       for (int i = 0; i < declarationCount; i++) {
         CompilationUnitMember declaration = declarations[i];
         if (declaration is! ClassDeclaration) {
           declaration.accept(this);
         }
       }
       for (int i = 0; i < declarationCount; i++) {
         CompilationUnitMember declaration = declarations[i];
         if (declaration is ClassDeclaration) {
           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();
-        promoteManager.enterScope();
+        _overrideManager.enterScope();
+        _promoteManager.enterScope();
         propagateTrueState(condition);
         promoteTypes(condition);
         clearTypePromotionsIfPotentiallyMutatedIn(thenExpression);
         clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenExpression);
         thenExpression.accept(this);
       } finally {
-        overrideManager.exitScope();
-        promoteManager.exitScope();
+        _overrideManager.exitScope();
+        _promoteManager.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 visitExpressionFunctionBody(ExpressionFunctionBody node) {
     try {
-      overrideManager.enterScope();
+      _overrideManager.enterScope();
       super.visitExpressionFunctionBody(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 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();
-        promoteManager.enterScope();
+        _overrideManager.enterScope();
+        _promoteManager.enterScope();
         propagateTrueState(condition);
         promoteTypes(condition);
         clearTypePromotionsIfPotentiallyMutatedIn(thenStatement);
         clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(thenStatement);
         visitStatementInScope(thenStatement);
       } finally {
-        thenOverrides = overrideManager.captureLocalOverrides();
-        overrideManager.exitScope();
-        promoteManager.exitScope();
+        thenOverrides = _overrideManager.captureLocalOverrides();
+        _overrideManager.exitScope();
+        _promoteManager.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);
@@ skipping 32 matching lines @@
 
   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 92 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;
     SimpleIdentifier identifier = node.identifier;
     safelyVisit(loopVariable);
     safelyVisit(identifier);
     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);
           }
         } else if (identifier != null && iterator != null) {
           Element identifierElement = identifier.staticElement;
           if (identifierElement is VariableElement) {
             Type2 iteratorElementType = getIteratorElementType(iterator);
             override2(identifierElement as VariableElement, iteratorElementType);
             recordPropagatedType(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();
     }
   }
 
   /**
    * 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>.
    */
   void clearTypePromotionsIfAccessedInClosureAndProtentiallyMutated(ASTNode target) {
-    for (Element element in promoteManager.promotedElements) {
+    for (Element element in _promoteManager.promotedElements) {
       if ((element as VariableElementImpl).isPotentiallyMutatedInScope) {
         if (isVariableAccessedInClosure(element, target)) {
-          promoteManager.setType(element, null);
+          _promoteManager.setType(element, null);
         }
       }
     }
   }
 
   /**
    * Checks each promoted variable in the current scope for compliance with the following
    * specification statement:
    *
    * <i>v</i> is not potentially mutated in <i>s<sub>1</sub></i> or within a closure.
    */
   void clearTypePromotionsIfPotentiallyMutatedIn(ASTNode target) {
-    for (Element element in promoteManager.promotedElements) {
+    for (Element element in _promoteManager.promotedElements) {
       if (isVariablePotentiallyMutatedIn(element, target)) {
-        promoteManager.setType(element, null);
+        _promoteManager.setType(element, null);
       }
     }
   }
 
   /**
    * 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 80 matching lines @@
    * @param expression the expression used to access the static element whose types might be
    *          promoted
    * @param potentialType the potential type of the elements
    */
   void promote(Expression expression, Type2 potentialType) {
     VariableElement element = getPromotionStaticElement(expression);
     if (element != null) {
       if ((element as VariableElementImpl).isPotentiallyMutatedInClosure) {
         return;
       }
-      Type2 type = promoteManager.getType(element);
+      Type2 type = _promoteManager.getType(element);
       if (type == null) {
         type = expression.staticType;
       }
       if (type == null || type.isDynamic) {
         return;
       }
       if (potentialType == null || potentialType.isDynamic) {
         return;
       }
       if (!potentialType.isMoreSpecificThan(type)) {
         return;
       }
-      promoteManager.setType(element, potentialType);
+      _promoteManager.setType(element, potentialType);
     }
   }
 
   /**
    * Promotes type information using given condition.
    */
   void promoteTypes(Expression condition) {
     if (condition is BinaryExpression) {
       BinaryExpression binary = condition as BinaryExpression;
       if (identical(binary.operator.type, sc.TokenType.AMPERSAND_AMPERSAND)) {
@@ skipping 87 matching lines @@
   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;
+  get labelScope_J2DAccessor => _labelScope;
 
-  set labelScope_J2DAccessor(__v) => labelScope = __v;
+  set labelScope_J2DAccessor(__v) => _labelScope = __v;
 
-  get nameScope_J2DAccessor => nameScope;
+  get nameScope_J2DAccessor => _nameScope;
 
-  set nameScope_J2DAccessor(__v) => nameScope = __v;
+  set nameScope_J2DAccessor(__v) => _nameScope = __v;
 
   get typeAnalyzer_J2DAccessor => _typeAnalyzer;
 
   set typeAnalyzer_J2DAccessor(__v) => _typeAnalyzer = __v;
 
-  get enclosingClass_J2DAccessor => enclosingClass;
+  get enclosingClass_J2DAccessor => _enclosingClass;
 
-  set enclosingClass_J2DAccessor(__v) => enclosingClass = __v;
+  set enclosingClass_J2DAccessor(__v) => _enclosingClass = __v;
 }
 
 class RecursiveASTVisitor_8 extends RecursiveASTVisitor<Object> {
   List<bool> result;
 
   Element variable;
 
   RecursiveASTVisitor_8(this.result, this.variable) : super();
 
   bool _inClosure = false;
@@ skipping 42 matching lines @@
 /**
  * The abstract class `ScopedVisitor` maintains name and label scopes as an AST structure is
  * being visited.
  *
  * @coverage dart.engine.resolver
  */
 abstract class ScopedVisitor extends UnifyingASTVisitor<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;
+  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.
    */
-  TypeProvider typeProvider;
+  final 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;
+  ScopedVisitor.con1(Library library, this.source, this.typeProvider) {
+    this._definingLibrary = library.libraryElement;
     LibraryScope libraryScope = library.libraryScope;
     this._errorListener = libraryScope.errorListener;
-    this.nameScope = libraryScope;
-    this.typeProvider = typeProvider;
+    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, Source source, TypeProvider typeProvider, AnalysisErrorListener errorListener) {
-    this.definingLibrary = definingLibrary;
-    this.source = source;
+  ScopedVisitor.con2(LibraryElement definingLibrary, this.source, this.typeProvider, AnalysisErrorListener errorListener) {
+    this._definingLibrary = definingLibrary;
     this._errorListener = errorListener;
-    this.nameScope = new LibraryScope(definingLibrary, errorListener);
-    this.typeProvider = typeProvider;
+    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, Source source, TypeProvider typeProvider, Scope nameScope, AnalysisErrorListener errorListener) {
-    this.definingLibrary = definingLibrary;
-    this.source = source;
+  ScopedVisitor.con3(LibraryElement definingLibrary, this.source, this.typeProvider, Scope nameScope, AnalysisErrorListener errorListener) {
+    this._definingLibrary = definingLibrary;
     this._errorListener = errorListener;
-    this.nameScope = nameScope;
-    this.typeProvider = typeProvider;
+    this._nameScope = nameScope;
   }
 
   /**
+   * 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;
+
+  /**
    * 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 visitFormalParameterList(FormalParameterList node) {
     super.visitFormalParameterList(node);
-    if (nameScope is FunctionScope) {
-      (nameScope as FunctionScope).defineParameters();
+    if (_nameScope is FunctionScope) {
+      (_nameScope as FunctionScope).defineParameters();
     }
-    if (nameScope is FunctionTypeScope) {
-      (nameScope as FunctionTypeScope).defineParameters();
+    if (_nameScope is FunctionTypeScope) {
+      (_nameScope as FunctionTypeScope).defineParameters();
     }
     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) {
     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;
   }
 
   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;
+
+  /**
    * 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 reportError6(ErrorCode errorCode, ASTNode node, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(source, node.offset, node.length, errorCode, arguments));
   }
 
@@ skipping 63 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 3468 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;
+  final Scope enclosingScope;
 
   /**
    * A table mapping names that will be defined in this scope, but right now are not initialized.
    * According to the scoping rules these names are hidden, even if they were defined in an outer
    * scope.
    */
   Map<String, Element> _hiddenElements = new Map<String, Element>();
 
   /**
+   * A flag indicating whether there are any names defined in this scope.
+   */
+  bool _hasHiddenName = false;
+
+  /**
    * 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;
-  }
+  EnclosedScope(this.enclosingScope);
 
-  Scope get enclosingScope => _enclosingScope;
-
-  AnalysisErrorListener get errorListener => _enclosingScope.errorListener;
+  AnalysisErrorListener get errorListener => enclosingScope.errorListener;
 
   /**
    * Record that given element is declared in this scope, but hasn't been initialized yet, so it is
    * error to use. If there is already an element with the given name defined in an outer scope,
    * then it will become unavailable.
    *
    * @param element the element declared, but not initialized in this scope
    */
   void hide(Element element) {
     if (element != null) {
       String name = element.name;
       if (name != null && !name.isEmpty) {
         _hiddenElements[name] = element;
+        _hasHiddenName = true;
       }
     }
   }
 
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element element = localLookup(name, referencingLibrary);
     if (element != null) {
       return element;
     }
-    Element hiddenElement = _hiddenElements[name];
-    if (hiddenElement != null) {
-      errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION, []));
-      return hiddenElement;
+    if (_hasHiddenName) {
+      Element hiddenElement = _hiddenElements[name];
+      if (hiddenElement != null) {
+        errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION, []));
+        return hiddenElement;
+      }
     }
-    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 {
   ExecutableElement _functionElement;
@@ skipping 106 matching lines @@
 
   /**
    * The marker used to look up a label element for an unlabeled `break` or `continue`.
    */
   static String EMPTY_LABEL = "";
 
   /**
    * The label element returned for scopes that can be the target of an unlabeled `break` or
    * `continue`.
    */
-  static SimpleIdentifier _EMPTY_LABEL_IDENTIFIER = new SimpleIdentifier.full(new sc.StringToken(sc.TokenType.IDENTIFIER, "", 0));
+  static SimpleIdentifier _EMPTY_LABEL_IDENTIFIER = new SimpleIdentifier(new sc.StringToken(sc.TokenType.IDENTIFIER, "", 0));
 
   /**
    * Initialize a newly created scope to represent the potential target of an unlabeled
    * `break` or `continue`.
    *
    * @param outerScope the label scope enclosing the new label scope
    * @param onSwitchStatement `true` if this label is associated with a `switch`
    *          statement
    * @param onSwitchMember `true` if this label is associated with a `switch` member
    */
@@ skipping 47 matching lines @@
  */
 class LibraryImportScope extends Scope {
   /**
    * The element representing the library in which this scope is enclosed.
    */
   LibraryElement _definingLibrary;
 
   /**
    * The listener that is to be informed when an error is encountered.
    */
-  AnalysisErrorListener _errorListener;
+  final AnalysisErrorListener errorListener;
 
   /**
    * A list of the namespaces representing the names that are available in this scope from imported
    * libraries.
    */
   List<Namespace> _importedNamespaces;
 
   /**
    * Initialize a newly created scope representing the names imported into the given library.
    *
    * @param definingLibrary the element representing the library that imports the names defined in
    *          this scope
    * @param errorListener the listener that is to be informed when an error is encountered
    */
-  LibraryImportScope(LibraryElement definingLibrary, AnalysisErrorListener errorListener) {
+  LibraryImportScope(LibraryElement definingLibrary, this.errorListener) {
     this._definingLibrary = definingLibrary;
-    this._errorListener = errorListener;
     createImportedNamespaces(definingLibrary);
   }
 
   void define(Element element) {
     if (!Scope.isPrivateName(element.displayName)) {
       super.define(element);
     }
   }
 
-  AnalysisErrorListener get errorListener => _errorListener;
-
   Element lookup3(Identifier identifier, String name, LibraryElement referencingLibrary) {
     Element foundElement = localLookup(name, referencingLibrary);
     if (foundElement != null) {
       return foundElement;
     }
     for (Namespace nameSpace in _importedNamespaces) {
       Element element = nameSpace.get(name);
       if (element != null) {
         if (foundElement == null) {
           foundElement = element;
         } else if (foundElement != element) {
           foundElement = MultiplyDefinedElementImpl.fromElements(_definingLibrary.context, foundElement, element);
         }
       }
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       foundElement = removeSdkElements(identifier, name, foundElement as MultiplyDefinedElementImpl);
     }
     if (foundElement is MultiplyDefinedElementImpl) {
       String foundEltName = foundElement.displayName;
       List<Element> conflictingMembers = (foundElement as MultiplyDefinedElementImpl).conflictingElements;
       String libName1 = getLibraryName(conflictingMembers[0], "");
       String libName2 = getLibraryName(conflictingMembers[1], "");
-      _errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, StaticWarningCode.AMBIGUOUS_IMPORT, [foundEltName, libName1, libName2]));
+      errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, StaticWarningCode.AMBIGUOUS_IMPORT, [foundEltName, libName1, libName2]));
       return foundElement;
     }
     if (foundElement != null) {
       defineWithoutChecking2(name, foundElement);
     }
     return foundElement;
   }
 
   /**
    * Create all of the namespaces associated with the libraries imported into this library. The
@@ skipping 48 matching lines @@
     for (Element member in conflictingMembers) {
       if (member.library.isInSdk) {
         sdkElement = member;
       } else {
         conflictingMembers[to++] = member;
       }
     }
     if (sdkElement != null && to > 0) {
       String sdkLibName = getLibraryName(sdkElement, "");
       String otherLibName = getLibraryName(conflictingMembers[0], "");
-      _errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, StaticWarningCode.CONFLICTING_DART_IMPORT, [name, sdkLibName, otherLibName]));
+      errorListener.onError(new AnalysisError.con2(getSource(identifier), identifier.offset, identifier.length, StaticWarningCode.CONFLICTING_DART_IMPORT, [name, sdkLibName, otherLibName]));
     }
     if (to == length) {
       return foundElement;
     } else if (to == 1) {
       return conflictingMembers[0];
     } else if (to == 0) {
       AnalysisEngine.instance.logger.logInformation("Multiply defined SDK element: ${foundElement}");
       return foundElement;
     }
     List<Element> remaining = new List<Element>(to);
@@ skipping 375 matching lines @@
    */
   static bool isPrivateName(String name) => name != null && name.startsWith(PRIVATE_NAME_PREFIX);
 
   /**
    * A table mapping names that are defined in this scope to the element representing the thing
    * declared with that name.
    */
   Map<String, Element> _definedNames = new Map<String, Element>();
 
   /**
+   * A flag indicating whether there are any names defined in this scope.
+   */
+  bool _hasName = false;
+
+  /**
    * Add the given element to this scope. If there is already an element with the given name defined
    * in this scope, then an error will be generated and the original element will continue to be
    * mapped to the name. If there is an element with the given name in an enclosing scope, then a
    * warning will be generated but the given element will hide the inherited element.
    *
    * @param element the element to be added to this scope
    */
   void define(Element element) {
     String name = getName(element);
     if (name != null && !name.isEmpty) {
       if (_definedNames.containsKey(name)) {
         errorListener.onError(getErrorForDuplicate(_definedNames[name], element));
       } else {
         _definedNames[name] = element;
+        _hasName = true;
       }
     }
   }
 
   /**
    * Return the scope in which this scope is lexically enclosed.
    *
    * @return the scope in which this scope is lexically enclosed
    */
   Scope get enclosingScope => null;
 
   /**
    * Return the element with which the given identifier is associated, or `null` if the name
    * is not defined within this scope.
    *
    * @param identifier the identifier associated with the element to be returned
    * @param referencingLibrary the library that contains the reference to the name, used to
    *          implement library-level privacy
    * @return the element with which the given identifier is associated
    */
   Element lookup(Identifier identifier, LibraryElement referencingLibrary) => lookup3(identifier, identifier.name, referencingLibrary);
 
   /**
    * Add the given element to this scope without checking for duplication or hiding.
    *
    * @param element the element to be added to this scope
    */
   void defineWithoutChecking(Element element) {
     _definedNames[getName(element)] = element;
+    _hasName = true;
   }
 
   /**
    * Add the given element to this scope without checking for duplication or hiding.
    *
    * @param name the name of the element to be added
    * @param element the element to be added to this scope
    */
   void defineWithoutChecking2(String name, Element element) {
     _definedNames[name] = element;
+    _hasName = true;
   }
 
   /**
    * Return the error code to be used when reporting that a name being defined locally conflicts
    * with another element of the same name in the local scope.
    *
    * @param existing the first element to be declared with the conflicting name
    * @param duplicate another element declared with the conflicting name
    * @return the error code used to report duplicate names within a scope
    */
@@ skipping 30 matching lines @@
   /**
    * Return the element with which the given name is associated, or `null` if the name is not
    * defined within this scope. This method only returns elements that are directly defined within
    * this scope, not elements that are defined in an enclosing scope.
    *
    * @param name the name associated with the element to be returned
    * @param referencingLibrary the library that contains the reference to the name, used to
    *          implement library-level privacy
    * @return the element with which the given name is associated
    */
-  Element localLookup(String name, LibraryElement referencingLibrary) => _definedNames[name];
+  Element localLookup(String name, LibraryElement referencingLibrary) {
+    if (_hasName) {
+      return _definedNames[name];
+    }
+    return null;
+  }
 
   /**
    * Return the element with which the given name is associated, or `null` if the name is not
    * defined within this scope.
    *
    * @param identifier the identifier node to lookup element for, used to report correct kind of a
    *          problem and associate problem with
    * @param name the name associated with the element to be returned
    * @param referencingLibrary the library that contains the reference to the name, used to
    *          implement library-level privacy
@@ skipping 4873 matching lines @@
   static final ResolverErrorCode MISSING_LIBRARY_DIRECTIVE_WITH_PART = new ResolverErrorCode.con1('MISSING_LIBRARY_DIRECTIVE_WITH_PART', 2, ErrorType.COMPILE_TIME_ERROR, "Libraries that have parts must have a library directive");
 
   static final List<ResolverErrorCode> values = [
       BREAK_LABEL_ON_SWITCH_MEMBER,
       CONTINUE_LABEL_ON_SWITCH,
       MISSING_LIBRARY_DIRECTIVE_WITH_PART];
 
   /**
    * The type of this error.
    */
-  ErrorType _type;
+  final ErrorType type;
 
   /**
    * The template used to create the message to be displayed for this error.
    */
-  String _message;
+  final String message;
 
   /**
    * The template used to create the correction to be displayed for this error, or `null` if
    * there is no correction information for this error.
    */
   String correction9;
 
   /**
    * Initialize a newly created error code to have the given type and message.
    *
    * @param type the type of this error
    * @param message the message template used to create the message to be displayed for the error
    */
-  ResolverErrorCode.con1(String name, int ordinal, ErrorType type, String message) : super(name, ordinal) {
-    this._type = type;
-    this._message = message;
-  }
+  ResolverErrorCode.con1(String name, int ordinal, this.type, this.message) : super(name, ordinal);
 
   /**
    * Initialize a newly created error code to have the given type, message and correction.
    *
    * @param type the type of this error
    * @param message the template used to create the message to be displayed for the error
    * @param correction the template used to create the correction to be displayed for the error
    */
-  ResolverErrorCode.con2(String name, int ordinal, ErrorType type, String message, String correction) : super(name, ordinal) {
-    this._type = type;
-    this._message = message;
+  ResolverErrorCode.con2(String name, int ordinal, this.type, this.message, String correction) : super(name, ordinal) {
     this.correction9 = correction;
   }
 
   String get correction => correction9;
 
-  ErrorSeverity get errorSeverity => _type.severity;
-
-  String get message => _message;
-
-  ErrorType get type => _type;
+  ErrorSeverity get errorSeverity => type.severity;
 }