Translate private Java members to private Dart members.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // 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;
 
 import 'java_core.dart';
@@ skipping 997 matching lines @@
    * @param source the source that was removed
    */
   void removedSource(Source source) {
     if (source != null) {
       _removed.add(source);
     }
   }
 
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
-    bool needsSeparator = appendSources(builder, _added, false, "added");
-    needsSeparator = appendSources(builder, _changed, needsSeparator, "changed");
-    appendSources(builder, _removed, needsSeparator, "removed");
+    bool needsSeparator = _appendSources(builder, _added, false, "added");
+    needsSeparator = _appendSources(builder, _changed, needsSeparator, "changed");
+    _appendSources(builder, _removed, needsSeparator, "removed");
     int count = removedContainers.length;
     if (count > 0) {
       if (_removed.isEmpty) {
         if (needsSeparator) {
           builder.append("; ");
         }
         builder.append("removed: from ");
         builder.append(count);
         builder.append(" containers");
       } else {
         builder.append(", and more from ");
         builder.append(count);
         builder.append(" containers");
       }
     }
     return builder.toString();
   }
 
   /**
    * Append the given sources to the given builder, prefixed with the given label and possibly a
    * separator.
    *
    * @param builder the builder to which the sources are to be appended
    * @param sources the sources to be appended
    * @param needsSeparator `true` if a separator is needed before the label
    * @param label the label used to prefix the sources
    * @return `true` if future lists of sources will need a separator
    */
-  bool appendSources(JavaStringBuilder builder, List<Source> sources, bool needsSeparator, String label) {
+  bool _appendSources(JavaStringBuilder builder, List<Source> sources, bool needsSeparator, String label) {
     if (sources.isEmpty) {
       return needsSeparator;
     }
     if (needsSeparator) {
       builder.append("; ");
     }
     builder.append(label);
     String prefix = " ";
     for (Source source in sources) {
       builder.append(prefix);
@@ skipping 78 matching lines @@
    * Record that the AST associated with the given source was just read from the cache.
    *
    * @param source the source whose AST was accessed
    */
   void accessedAst(Source source) {
     if (_recentlyUsed.remove(source)) {
       _recentlyUsed.add(source);
       return;
     }
     while (_recentlyUsed.length >= _maxCacheSize) {
-      if (!flushAstFromCache()) {
+      if (!_flushAstFromCache()) {
         break;
       }
     }
     _recentlyUsed.add(source);
   }
 
   /**
    * Return a collection containing all of the map entries mapping sources to cache entries. Clients
    * should not modify the returned collection.
    *
@@ skipping 40 matching lines @@
   }
 
   /**
    * Set the maximum size of the cache to the given size.
    *
    * @param size the maximum number of sources for which AST structures should be kept in the cache
    */
   void set maxCacheSize(int size) {
     _maxCacheSize = size;
     while (_recentlyUsed.length > _maxCacheSize) {
-      if (!flushAstFromCache()) {
+      if (!_flushAstFromCache()) {
         break;
       }
     }
   }
 
   /**
    * Return the number of sources that are mapped to cache entries.
    *
    * @return the number of sources that are mapped to cache entries
    */
   int size() => _sourceMap.length;
 
   /**
    * Record that the AST associated with the given source was just stored to the cache.
    *
    * @param source the source whose AST was stored
    */
   void storedAst(Source source) {
     if (_recentlyUsed.contains(source)) {
       return;
     }
     while (_recentlyUsed.length >= _maxCacheSize) {
-      if (!flushAstFromCache()) {
+      if (!_flushAstFromCache()) {
         break;
       }
     }
     _recentlyUsed.add(source);
   }
 
   /**
    * Attempt to flush one AST structure from the cache.
    *
    * @return `true` if a structure was flushed
    */
-  bool flushAstFromCache() {
-    Source removedSource = removeAstToFlush();
+  bool _flushAstFromCache() {
+    Source removedSource = _removeAstToFlush();
     if (removedSource == null) {
       return false;
     }
     SourceEntry sourceEntry = _sourceMap[removedSource];
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
       htmlCopy.flushAstStructures();
       _sourceMap[removedSource] = htmlCopy;
     } else if (sourceEntry is DartEntry) {
       DartEntryImpl dartCopy = sourceEntry.writableCopy;
       dartCopy.flushAstStructures();
       _sourceMap[removedSource] = dartCopy;
     }
     return true;
   }
 
   /**
    * Remove and return one source from the list of recently used sources whose AST structure can be
    * flushed from the cache. The source that will be returned will be the source that has been
    * unreferenced for the longest period of time but that is not a priority for analysis.
    *
    * @return the source that was removed
    */
-  Source removeAstToFlush() {
+  Source _removeAstToFlush() {
     int sourceToRemove = -1;
     for (int i = 0; i < _recentlyUsed.length; i++) {
       Source source = _recentlyUsed[i];
       RetentionPriority priority = _retentionPolicy.getAstPriority(source, _sourceMap[source]);
       if (identical(priority, RetentionPriority.LOW)) {
         return _recentlyUsed.removeAt(i);
       } else if (identical(priority, RetentionPriority.MEDIUM) && sourceToRemove < 0) {
         sourceToRemove = i;
       }
     }
@@ skipping 685 matching lines @@
     _scanErrorsState = CacheState.INVALID;
     _tokenStream = null;
     _tokenStreamState = CacheState.INVALID;
     _sourceKind = SourceKind.UNKNOWN;
     _sourceKindState = CacheState.INVALID;
     _parseErrors = AnalysisError.NO_ERRORS;
     _parseErrorsState = CacheState.INVALID;
     _parsedUnit = null;
     _parsedUnitAccessed = false;
     _parsedUnitState = CacheState.INVALID;
-    discardCachedResolutionInformation();
+    _discardCachedResolutionInformation();
   }
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void invalidateAllResolutionInformation() {
     if (identical(_parsedUnitState, CacheState.FLUSHED)) {
       DartEntryImpl_ResolutionState state = _resolutionState;
       while (state != null) {
         if (identical(state._resolvedUnitState, CacheState.VALID)) {
           _parsedUnit = state._resolvedUnit;
           _parsedUnitAccessed = true;
           _parsedUnitState = CacheState.VALID;
           break;
         }
         state = state._nextState;
       }
     }
-    discardCachedResolutionInformation();
+    _discardCachedResolutionInformation();
   }
 
   bool get isRefactoringSafe {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       CacheState resolvedState = state._resolvedUnitState;
       if (resolvedState != CacheState.VALID && resolvedState != CacheState.FLUSHED) {
         return false;
       }
       state = state._nextState;
@@ skipping 243 matching lines @@
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       _exportedLibraries = updatedValue(state, _exportedLibraries, Source.EMPTY_ARRAY);
       _exportedLibrariesState = state;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       _importedLibraries = updatedValue(state, _importedLibraries, Source.EMPTY_ARRAY);
       _importedLibrariesState = state;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       _includedParts = updatedValue(state, _includedParts, Source.EMPTY_ARRAY);
       _includedPartsState = state;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
-      _bitmask = updatedValueOfFlag(state, _bitmask, _CLIENT_CODE_INDEX);
+      _bitmask = _updatedValueOfFlag(state, _bitmask, _CLIENT_CODE_INDEX);
       _clientServerState = state;
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
-      _bitmask = updatedValueOfFlag(state, _bitmask, _LAUNCHABLE_INDEX);
+      _bitmask = _updatedValueOfFlag(state, _bitmask, _LAUNCHABLE_INDEX);
       _launchableState = state;
     } else if (identical(descriptor, DartEntry.PARSE_ERRORS)) {
       _parseErrors = updatedValue(state, _parseErrors, AnalysisError.NO_ERRORS);
       _parseErrorsState = state;
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       CompilationUnit newUnit = updatedValue(state, _parsedUnit, null);
       if (newUnit != _parsedUnit) {
         _parsedUnitAccessed = false;
       }
       _parsedUnit = newUnit;
@@ skipping 18 matching lines @@
   /**
    * Set the state of the data represented by the given descriptor in the context of the given
    * library to the given state.
    *
    * @param descriptor the descriptor representing the data whose state is to be set
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @param cacheState the new state of the data represented by the given descriptor
    */
   void setStateInLibrary(DataDescriptor descriptor, Source librarySource, CacheState cacheState) {
-    DartEntryImpl_ResolutionState state = getOrCreateResolutionState(librarySource);
+    DartEntryImpl_ResolutionState state = _getOrCreateResolutionState(librarySource);
     if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
       state._resolutionErrors = updatedValue(cacheState, state._resolutionErrors, AnalysisError.NO_ERRORS);
       state._resolutionErrorsState = cacheState;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       state._resolvedUnit = updatedValue(cacheState, state._resolvedUnit, null);
       state._resolvedUnitState = cacheState;
     } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
       state._verificationErrors = updatedValue(cacheState, state._verificationErrors, AnalysisError.NO_ERRORS);
       state._verificationErrorsState = cacheState;
     } else if (identical(descriptor, DartEntry.HINTS)) {
@@ skipping 52 matching lines @@
   /**
    * Set the value of the data represented by the given descriptor in the context of the given
    * library to the given value, and set the state of that data to [CacheState#VALID].
    *
    * @param descriptor the descriptor representing which data is to have its value set
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @param value the new value of the data represented by the given descriptor and library
    */
   void setValueInLibrary(DataDescriptor descriptor, Source librarySource, Object value) {
-    DartEntryImpl_ResolutionState state = getOrCreateResolutionState(librarySource);
+    DartEntryImpl_ResolutionState state = _getOrCreateResolutionState(librarySource);
     if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
       state._resolutionErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       state._resolutionErrorsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       state._resolvedUnit = value as CompilationUnit;
       state._resolvedUnitState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
       state._verificationErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       state._verificationErrorsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.HINTS)) {
@@ skipping 65 matching lines @@
     builder.append(_clientServerState);
     builder.append("; launchable = ");
     builder.append(_launchableState);
     //    builder.append("; angularElements = ");
     _resolutionState.writeOn(builder);
   }
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
-  void discardCachedResolutionInformation() {
+  void _discardCachedResolutionInformation() {
     _element = null;
     _elementState = CacheState.INVALID;
     _includedParts = Source.EMPTY_ARRAY;
     _includedPartsState = CacheState.INVALID;
     _exportedLibraries = Source.EMPTY_ARRAY;
     _exportedLibrariesState = CacheState.INVALID;
     _importedLibraries = Source.EMPTY_ARRAY;
     _importedLibrariesState = CacheState.INVALID;
     _bitmask = 0;
     _clientServerState = CacheState.INVALID;
     _launchableState = CacheState.INVALID;
     _publicNamespace = null;
     _publicNamespaceState = CacheState.INVALID;
     _resolutionState.invalidateAllResolutionInformation();
   }
 
   /**
    * Return a resolution state for the specified library, creating one as necessary.
    *
    * @param librarySource the library source (not `null`)
    * @return the resolution state (not `null`)
    */
-  DartEntryImpl_ResolutionState getOrCreateResolutionState(Source librarySource) {
+  DartEntryImpl_ResolutionState _getOrCreateResolutionState(Source librarySource) {
     DartEntryImpl_ResolutionState state = _resolutionState;
     if (state._librarySource == null) {
       state._librarySource = librarySource;
       return state;
     }
     while (state._librarySource != librarySource) {
       if (state._nextState == null) {
         DartEntryImpl_ResolutionState newState = new DartEntryImpl_ResolutionState();
         newState._librarySource = librarySource;
         state._nextState = newState;
         return newState;
       }
       state = state._nextState;
     }
     return state;
   }
 
   /**
    * Given that one of the flags is being transitioned to the given state, return the value of the
    * flags that should be kept in the cache.
    *
    * @param state the state to which the data is being transitioned
    * @param currentValue the value of the flags before the transition
    * @param bitMask the mask used to access the bit whose state is being set
    * @return the value of the data that should be kept in the cache
    */
-  int updatedValueOfFlag(CacheState state, int currentValue, int bitIndex) {
+  int _updatedValueOfFlag(CacheState state, int currentValue, int bitIndex) {
     if (identical(state, CacheState.VALID)) {
       throw new IllegalArgumentException("Use setValue() to set the state to VALID");
     } else if (identical(state, CacheState.IN_PROCESS)) {
       //
       // We can leave the current value in the cache for any 'get' methods to access.
       //
       return currentValue;
     }
     return BooleanArray.set(currentValue, bitIndex, false);
   }
@@ skipping 1025 matching lines @@
   List<AnalysisContentStatistics_CacheRow> get cacheRows {
     Iterable<AnalysisContentStatistics_CacheRow> items = _dataMap.values;
     return new List.from(items);
   }
 
   List<AnalysisException> get exceptions => new List.from(_exceptions);
 
   List<Source> get sources => new List.from(_sources);
 
   void putCacheItem(SourceEntry dartEntry, DataDescriptor descriptor) {
-    internalPutCacheItem(dartEntry, descriptor, dartEntry.getState(descriptor));
+    _internalPutCacheItem(dartEntry, descriptor, dartEntry.getState(descriptor));
   }
 
   void putCacheItemInLibrary(DartEntry dartEntry, Source librarySource, DataDescriptor descriptor) {
-    internalPutCacheItem(dartEntry, descriptor, dartEntry.getStateInLibrary(descriptor, librarySource));
+    _internalPutCacheItem(dartEntry, descriptor, dartEntry.getStateInLibrary(descriptor, librarySource));
   }
 
-  void internalPutCacheItem(SourceEntry dartEntry, DataDescriptor rowDesc, CacheState state) {
+  void _internalPutCacheItem(SourceEntry dartEntry, DataDescriptor rowDesc, CacheState state) {
     String rowName = rowDesc.toString();
     AnalysisContentStatisticsImpl_CacheRowImpl row = _dataMap[rowName] as AnalysisContentStatisticsImpl_CacheRowImpl;
     if (row == null) {
       row = new AnalysisContentStatisticsImpl_CacheRowImpl(rowName);
       _dataMap[rowName] = row;
     }
-    row.incState(state);
+    row._incState(state);
     if (identical(state, CacheState.ERROR)) {
       AnalysisException exception = dartEntry.exception;
       if (exception != null) {
         _exceptions.add(exception);
       }
     }
   }
 }
 
 class AnalysisContentStatisticsImpl_CacheRowImpl implements AnalysisContentStatistics_CacheRow {
@@ skipping 18 matching lines @@
   int get flushedCount => _flushedCount;
 
   int get inProcessCount => _inProcessCount;
 
   int get invalidCount => _invalidCount;
 
   int get validCount => _validCount;
 
   int get hashCode => name.hashCode;
 
-  void incState(CacheState state) {
+  void _incState(CacheState state) {
     if (identical(state, CacheState.ERROR)) {
       _errorCount++;
     }
     if (identical(state, CacheState.FLUSHED)) {
       _flushedCount++;
     }
     if (identical(state, CacheState.IN_PROCESS)) {
       _inProcessCount++;
     }
     if (identical(state, CacheState.INVALID)) {
@@ skipping 102 matching lines @@
   void applyChanges(ChangeSet changeSet) {
     if (changeSet.isEmpty) {
       return;
     }
     _recentTasks.clear();
     //
     // First, compute the list of sources that have been removed.
     //
     List<Source> removedSources = new List<Source>.from(changeSet.removedSources);
     for (SourceContainer container in changeSet.removedContainers) {
-      addSourcesInContainer(removedSources, container);
+      _addSourcesInContainer(removedSources, container);
     }
     //
     // Then determine which cached results are no longer valid.
     //
     bool addedDartSource = false;
     for (Source source in changeSet.addedSources) {
-      if (sourceAvailable(source)) {
+      if (_sourceAvailable(source)) {
         addedDartSource = true;
       }
     }
     for (Source source in changeSet.changedSources) {
-      sourceChanged(source);
+      _sourceChanged(source);
     }
     for (Source source in removedSources) {
-      sourceRemoved(source);
+      _sourceRemoved(source);
     }
     if (addedDartSource) {
       // TODO(brianwilkerson) This is hugely inefficient, but we need to re-analyze any libraries
       // that might have been referencing the not-yet-existing source that was just added. Longer
       // term we need to keep track of which libraries are referencing non-existing sources and
       // only re-analyze those libraries.
-      logInformation("Added Dart sources, invalidating all resolution information");
+      _logInformation("Added Dart sources, invalidating all resolution information");
       for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
         Source source = mapEntry.getKey();
         SourceEntry sourceEntry = mapEntry.getValue();
         if (!source.isInSystemLibrary && sourceEntry is DartEntry) {
           DartEntry dartEntry = sourceEntry;
           DartEntryImpl dartCopy = dartEntry.writableCopy;
-          removeFromParts(source, dartEntry);
+          _removeFromParts(source, dartEntry);
           dartCopy.invalidateAllResolutionInformation();
           mapEntry.setValue(dartCopy);
           SourcePriority priority = SourcePriority.UNKNOWN;
           SourceKind kind = dartCopy.kind;
           if (identical(kind, SourceKind.LIBRARY)) {
             priority = SourcePriority.LIBRARY;
           } else if (identical(kind, SourceKind.PART)) {
             priority = SourcePriority.NORMAL_PART;
           }
           _workManager.add(source, priority);
@@ skipping 32 matching lines @@
         }
         return builder.toString();
       }
       nameNode = nameNode.parent;
     }
     return null;
   }
 
   List<AnalysisError> computeErrors(Source source) {
     bool enableHints = _options.hint;
-    SourceEntry sourceEntry = getReadableSourceEntry(source);
+    SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry is DartEntry) {
       List<AnalysisError> errors = new List<AnalysisError>();
       try {
         DartEntry dartEntry = sourceEntry;
-        ListUtilities.addAll(errors, getDartScanData(source, dartEntry, DartEntry.SCAN_ERRORS));
-        dartEntry = getReadableDartEntry(source);
-        ListUtilities.addAll(errors, getDartParseData(source, dartEntry, DartEntry.PARSE_ERRORS));
-        dartEntry = getReadableDartEntry(source);
+        ListUtilities.addAll(errors, _getDartScanData(source, dartEntry, DartEntry.SCAN_ERRORS));
+        dartEntry = _getReadableDartEntry(source);
+        ListUtilities.addAll(errors, _getDartParseData(source, dartEntry, DartEntry.PARSE_ERRORS));
+        dartEntry = _getReadableDartEntry(source);
         if (identical(dartEntry.getValue(DartEntry.SOURCE_KIND), SourceKind.LIBRARY)) {
-          ListUtilities.addAll(errors, getDartResolutionData(source, source, dartEntry, DartEntry.RESOLUTION_ERRORS));
-          dartEntry = getReadableDartEntry(source);
-          ListUtilities.addAll(errors, getDartVerificationData(source, source, dartEntry, DartEntry.VERIFICATION_ERRORS));
+          ListUtilities.addAll(errors, _getDartResolutionData(source, source, dartEntry, DartEntry.RESOLUTION_ERRORS));
+          dartEntry = _getReadableDartEntry(source);
+          ListUtilities.addAll(errors, _getDartVerificationData(source, source, dartEntry, DartEntry.VERIFICATION_ERRORS));
           if (enableHints) {
-            dartEntry = getReadableDartEntry(source);
-            ListUtilities.addAll(errors, getDartHintData(source, source, dartEntry, DartEntry.HINTS));
+            dartEntry = _getReadableDartEntry(source);
+            ListUtilities.addAll(errors, _getDartHintData(source, source, dartEntry, DartEntry.HINTS));
           }
         } else {
           List<Source> libraries = getLibrariesContaining(source);
           for (Source librarySource in libraries) {
-            ListUtilities.addAll(errors, getDartResolutionData(source, librarySource, dartEntry, DartEntry.RESOLUTION_ERRORS));
-            dartEntry = getReadableDartEntry(source);
-            ListUtilities.addAll(errors, getDartVerificationData(source, librarySource, dartEntry, DartEntry.VERIFICATION_ERRORS));
+            ListUtilities.addAll(errors, _getDartResolutionData(source, librarySource, dartEntry, DartEntry.RESOLUTION_ERRORS));
+            dartEntry = _getReadableDartEntry(source);
+            ListUtilities.addAll(errors, _getDartVerificationData(source, librarySource, dartEntry, DartEntry.VERIFICATION_ERRORS));
             if (enableHints) {
-              dartEntry = getReadableDartEntry(source);
-              ListUtilities.addAll(errors, getDartHintData(source, librarySource, dartEntry, DartEntry.HINTS));
+              dartEntry = _getReadableDartEntry(source);
+              ListUtilities.addAll(errors, _getDartHintData(source, librarySource, dartEntry, DartEntry.HINTS));
             }
           }
         }
       } on ObsoleteSourceAnalysisException catch (exception) {
-        AnalysisEngine.instance.logger.logInformation3("Could not compute errors", exception);
+        AnalysisEngine.instance.logger.logInformation2("Could not compute errors", exception);
       }
       if (errors.isEmpty) {
         return AnalysisError.NO_ERRORS;
       }
       return new List.from(errors);
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       try {
-        return getHtmlResolutionData2(source, htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
+        return _getHtmlResolutionData2(source, htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
       } on ObsoleteSourceAnalysisException catch (exception) {
-        AnalysisEngine.instance.logger.logInformation3("Could not compute errors", exception);
+        AnalysisEngine.instance.logger.logInformation2("Could not compute errors", exception);
       }
     }
     return AnalysisError.NO_ERRORS;
   }
 
-  List<Source> computeExportedLibraries(Source source) => getDartDependencyData2(source, DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+  List<Source> computeExportedLibraries(Source source) => _getDartDependencyData2(source, DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
 
-  HtmlElement computeHtmlElement(Source source) => getHtmlResolutionData(source, HtmlEntry.ELEMENT, null);
+  HtmlElement computeHtmlElement(Source source) => _getHtmlResolutionData(source, HtmlEntry.ELEMENT, null);
 
-  List<Source> computeImportedLibraries(Source source) => getDartDependencyData2(source, DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+  List<Source> computeImportedLibraries(Source source) => _getDartDependencyData2(source, DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
 
   SourceKind computeKindOf(Source source) {
-    SourceEntry sourceEntry = getReadableSourceEntry(source);
+    SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     } else if (sourceEntry is DartEntry) {
       try {
-        return getDartParseData(source, sourceEntry, DartEntry.SOURCE_KIND);
+        return _getDartParseData(source, sourceEntry, DartEntry.SOURCE_KIND);
       } on AnalysisException catch (exception) {
         return SourceKind.UNKNOWN;
       }
     }
     return sourceEntry.kind;
   }
 
-  LibraryElement computeLibraryElement(Source source) => getDartResolutionData2(source, source, DartEntry.ELEMENT, null);
+  LibraryElement computeLibraryElement(Source source) => _getDartResolutionData2(source, source, DartEntry.ELEMENT, null);
 
   LineInfo computeLineInfo(Source source) {
-    SourceEntry sourceEntry = getReadableSourceEntry(source);
+    SourceEntry sourceEntry = _getReadableSourceEntry(source);
     try {
       if (sourceEntry is HtmlEntry) {
-        return getHtmlParseData(source, SourceEntry.LINE_INFO, null);
+        return _getHtmlParseData(source, SourceEntry.LINE_INFO, null);
       } else if (sourceEntry is DartEntry) {
-        return getDartScanData2(source, SourceEntry.LINE_INFO, null);
+        return _getDartScanData2(source, SourceEntry.LINE_INFO, null);
       }
     } on ObsoleteSourceAnalysisException catch (exception) {
-      AnalysisEngine.instance.logger.logInformation3("Could not compute ${SourceEntry.LINE_INFO.toString()}", exception);
+      AnalysisEngine.instance.logger.logInformation2("Could not compute ${SourceEntry.LINE_INFO.toString()}", exception);
     }
     return null;
   }
 
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) {
-    DartEntry dartEntry = getReadableDartEntry(source);
+    DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       throw new AnalysisException.con1("computeResolvableCompilationUnit for non-Dart: ${source.fullName}");
     }
-    dartEntry = cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
+    dartEntry = _cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
     DartEntryImpl dartCopy = dartEntry.writableCopy;
     CompilationUnit unit = dartCopy.resolvableCompilationUnit;
     if (unit == null) {
       throw new AnalysisException.con2("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}", dartEntry.exception);
     }
     _cache.put(source, dartCopy);
     return new ResolvableCompilationUnit(dartCopy.modificationTime, unit);
   }
 
   bool exists(Source source) {
@@ skipping 55 matching lines @@
       receiver.accept(contents, _contentCache.getModificationStamp(source));
       return;
     }
     source.getContentsToReceiver(receiver);
   }
 
   Element getElement(ElementLocation location) {
     // TODO(brianwilkerson) This should not be a "get" method.
     try {
       List<String> components = (location as ElementLocationImpl).components;
-      Source librarySource = computeSourceFromEncoding(components[0]);
+      Source librarySource = _computeSourceFromEncoding(components[0]);
       ElementImpl element = computeLibraryElement(librarySource) as ElementImpl;
       for (int i = 1; i < components.length; i++) {
         if (element == null) {
           return null;
         }
         element = element.getChild(components[i]);
       }
       return element;
     } on AnalysisException catch (exception) {
       return null;
     }
   }
 
   AnalysisErrorInfo getErrors(Source source) {
-    SourceEntry sourceEntry = getReadableSourceEntry(source);
+    SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return new AnalysisErrorInfoImpl(dartEntry.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return new AnalysisErrorInfoImpl(htmlEntry.allErrors, htmlEntry.getValue(SourceEntry.LINE_INFO));
     }
     return new AnalysisErrorInfoImpl(AnalysisError.NO_ERRORS, null);
   }
 
   HtmlElement getHtmlElement(Source source) {
-    SourceEntry sourceEntry = getReadableSourceEntry(source);
+    SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry is HtmlEntry) {
       return sourceEntry.getValue(HtmlEntry.ELEMENT);
     }
     return null;
   }
 
   List<Source> getHtmlFilesReferencing(Source source) {
     SourceKind sourceKind = getKindOf(source);
     if (sourceKind == null) {
       return Source.EMPTY_ARRAY;
     }
     List<Source> htmlSources = new List<Source>();
     while (true) {
       if (sourceKind == SourceKind.LIBRARY) {
       } else if (sourceKind == SourceKind.PART) {
         List<Source> librarySources = getLibrariesContaining(source);
         for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
           SourceEntry sourceEntry = entry.getValue();
           if (identical(sourceEntry.kind, SourceKind.HTML)) {
             List<Source> referencedLibraries = (sourceEntry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES);
-            if (containsAny(referencedLibraries, librarySources)) {
+            if (_containsAny(referencedLibraries, librarySources)) {
               htmlSources.add(entry.getKey());
             }
           }
         }
       }
       break;
     }
     if (htmlSources.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(htmlSources);
   }
 
-  List<Source> get htmlSources => getSources(SourceKind.HTML);
+  List<Source> get htmlSources => _getSources(SourceKind.HTML);
 
   SourceKind getKindOf(Source source) {
-    SourceEntry sourceEntry = getReadableSourceEntry(source);
+    SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     }
     return sourceEntry.kind;
   }
 
   List<Source> get launchableClientLibrarySources {
     // TODO(brianwilkerson) This needs to filter out libraries that do not reference dart:html,
     // either directly or indirectly.
     List<Source> sources = new List<Source>();
@@ skipping 19 matching lines @@
       if (identical(sourceEntry.kind, SourceKind.LIBRARY) && !source.isInSystemLibrary) {
         //          DartEntry dartEntry = (DartEntry) sourceEntry;
         //          if (dartEntry.getValue(DartEntry.IS_LAUNCHABLE) && !dartEntry.getValue(DartEntry.IS_CLIENT)) {
         sources.add(source);
       }
     }
     return new List.from(sources);
   }
 
   List<Source> getLibrariesContaining(Source source) {
-    DartEntry dartEntry = getReadableDartEntry(source);
+    DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       return Source.EMPTY_ARRAY;
     }
     return dartEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
   }
 
   List<Source> getLibrariesDependingOn(Source librarySource) {
     List<Source> dependentLibraries = new List<Source>();
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       SourceEntry sourceEntry = entry.getValue();
       if (identical(sourceEntry.kind, SourceKind.LIBRARY)) {
-        if (contains((sourceEntry as DartEntry).getValue(DartEntry.EXPORTED_LIBRARIES), librarySource)) {
+        if (_contains((sourceEntry as DartEntry).getValue(DartEntry.EXPORTED_LIBRARIES), librarySource)) {
           dependentLibraries.add(entry.getKey());
         }
-        if (contains((sourceEntry as DartEntry).getValue(DartEntry.IMPORTED_LIBRARIES), librarySource)) {
+        if (_contains((sourceEntry as DartEntry).getValue(DartEntry.IMPORTED_LIBRARIES), librarySource)) {
           dependentLibraries.add(entry.getKey());
         }
       }
     }
     if (dependentLibraries.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(dependentLibraries);
   }
 
   LibraryElement getLibraryElement(Source source) {
-    SourceEntry sourceEntry = getReadableSourceEntry(source);
+    SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValue(DartEntry.ELEMENT);
     }
     return null;
   }
 
-  List<Source> get librarySources => getSources(SourceKind.LIBRARY);
+  List<Source> get librarySources => _getSources(SourceKind.LIBRARY);
 
   LineInfo getLineInfo(Source source) {
-    SourceEntry sourceEntry = getReadableSourceEntry(source);
+    SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry != null) {
       return sourceEntry.getValue(SourceEntry.LINE_INFO);
     }
     return null;
   }
 
   int getModificationStamp(Source source) {
     int stamp = _contentCache.getModificationStamp(source);
     if (stamp != null) {
       return stamp;
     }
     return source.modificationStamp;
   }
 
   Namespace getPublicNamespace(LibraryElement library) {
     // TODO(brianwilkerson) Rename this to not start with 'get'. Note that this is not part of the
     // API of the interface.
     Source source = library.definingCompilationUnit.source;
-    DartEntry dartEntry = getReadableDartEntry(source);
+    DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       return null;
     }
     Namespace namespace = null;
     if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
       namespace = dartEntry.getValue(DartEntry.PUBLIC_NAMESPACE);
     }
     if (namespace == null) {
       NamespaceBuilder builder = new NamespaceBuilder();
       namespace = builder.createPublicNamespaceForLibrary(library);
-      dartEntry = getReadableDartEntry(source);
+      dartEntry = _getReadableDartEntry(source);
       if (dartEntry == null) {
         AnalysisEngine.instance.logger.logError2("Could not compute the public namespace for ${library.source.fullName}", new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}"));
         return null;
       }
       if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
-        DartEntryImpl dartCopy = getReadableDartEntry(source).writableCopy;
+        DartEntryImpl dartCopy = _getReadableDartEntry(source).writableCopy;
         dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
         _cache.put(source, dartCopy);
       }
     }
     return namespace;
   }
 
   Namespace getPublicNamespace2(Source source) {
     // TODO(brianwilkerson) Rename this to not start with 'get'. Note that this is not part of the
     // API of the interface.
-    DartEntry dartEntry = getReadableDartEntry(source);
+    DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       return null;
     }
     Namespace namespace = dartEntry.getValue(DartEntry.PUBLIC_NAMESPACE);
     if (namespace == null) {
       LibraryElement library = computeLibraryElement(source);
       if (library == null) {
         return null;
       }
       NamespaceBuilder builder = new NamespaceBuilder();
       namespace = builder.createPublicNamespaceForLibrary(library);
-      dartEntry = getReadableDartEntry(source);
+      dartEntry = _getReadableDartEntry(source);
       if (dartEntry == null) {
         throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
       }
       if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
-        DartEntryImpl dartCopy = getReadableDartEntry(source).writableCopy;
+        DartEntryImpl dartCopy = _getReadableDartEntry(source).writableCopy;
         dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
         _cache.put(source, dartCopy);
       }
     }
     return namespace;
   }
 
   List<Source> get refactoringUnsafeSources {
     List<Source> sources = new List<Source>();
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       SourceEntry sourceEntry = entry.getValue();
       if (sourceEntry is DartEntry) {
         if (!sourceEntry.isRefactoringSafe) {
           sources.add(entry.getKey());
         }
       }
     }
     return new List.from(sources);
   }
 
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return getResolvedCompilationUnit2(unitSource, library.source);
   }
 
   CompilationUnit getResolvedCompilationUnit2(Source unitSource, Source librarySource) {
-    SourceEntry sourceEntry = getReadableSourceEntry(unitSource);
+    SourceEntry sourceEntry = _getReadableSourceEntry(unitSource);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
     }
     return null;
   }
 
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) {
-    SourceEntry sourceEntry = getReadableSourceEntry(htmlSource);
+    SourceEntry sourceEntry = _getReadableSourceEntry(htmlSource);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
     }
     return null;
   }
 
   SourceFactory get sourceFactory => _sourceFactory;
 
   /**
    * Return a list of the sources that would be processed by [performAnalysisTask]. This
    * method duplicates, and must therefore be kept in sync with, [getNextAnalysisTask].
    * This method is intended to be used for testing purposes only.
    *
    * @return a list of the sources that would be processed by [performAnalysisTask]
    */
   List<Source> get sourcesNeedingProcessing {
     Set<Source> sources = new Set<Source>();
     bool hintsEnabled = _options.hint;
     //
     // Look for priority sources that need to be analyzed.
     //
     for (Source source in _priorityOrder) {
-      getSourcesNeedingProcessing2(source, _cache.get(source), true, hintsEnabled, sources);
+      _getSourcesNeedingProcessing(source, _cache.get(source), true, hintsEnabled, sources);
     }
     //
     // Look for non-priority sources that need to be analyzed.
     //
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-      getSourcesNeedingProcessing2(entry.getKey(), entry.getValue(), false, hintsEnabled, sources);
+      _getSourcesNeedingProcessing(entry.getKey(), entry.getValue(), false, hintsEnabled, sources);
     }
     return new List<Source>.from(sources);
   }
 
   AnalysisContentStatistics get statistics {
     AnalysisContentStatisticsImpl statistics = new AnalysisContentStatisticsImpl();
     for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
       statistics.addSource(mapEntry.getKey());
       SourceEntry entry = mapEntry.getValue();
       if (entry is DartEntry) {
@@ skipping 32 matching lines @@
     }
     return statistics;
   }
 
   TypeProvider get typeProvider {
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     return new TypeProviderImpl(computeLibraryElement(coreSource));
   }
 
   TimestampedData<CompilationUnit> internalResolveCompilationUnit(Source unitSource, LibraryElement libraryElement) {
-    DartEntry dartEntry = getReadableDartEntry(unitSource);
+    DartEntry dartEntry = _getReadableDartEntry(unitSource);
     if (dartEntry == null) {
       throw new AnalysisException.con1("internalResolveCompilationUnit invoked for non-Dart file: ${unitSource.fullName}");
     }
     Source librarySource = libraryElement.source;
-    dartEntry = cacheDartResolutionData(unitSource, librarySource, dartEntry, DartEntry.RESOLVED_UNIT);
+    dartEntry = _cacheDartResolutionData(unitSource, librarySource, dartEntry, DartEntry.RESOLVED_UNIT);
     return new TimestampedData<CompilationUnit>(dartEntry.modificationTime, dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource));
   }
 
   bool isClientLibrary(Source librarySource) {
-    SourceEntry sourceEntry = getReadableSourceEntry(librarySource);
+    SourceEntry sourceEntry = _getReadableSourceEntry(librarySource);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return dartEntry.getValue(DartEntry.IS_CLIENT) && dartEntry.getValue(DartEntry.IS_LAUNCHABLE);
     }
     return false;
   }
 
   bool isServerLibrary(Source librarySource) {
-    SourceEntry sourceEntry = getReadableSourceEntry(librarySource);
+    SourceEntry sourceEntry = _getReadableSourceEntry(librarySource);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return !dartEntry.getValue(DartEntry.IS_CLIENT) && dartEntry.getValue(DartEntry.IS_LAUNCHABLE);
     }
     return false;
   }
 
   void mergeContext(AnalysisContext context) {
     if (context is InstrumentedAnalysisContextImpl) {
       context = (context as InstrumentedAnalysisContextImpl).basis;
     }
     if (context is! AnalysisContextImpl) {
       return;
     }
     // TODO(brianwilkerson) This does not lock against the other context's cacheLock.
     for (MapEntry<Source, SourceEntry> entry in (context as AnalysisContextImpl)._cache.entrySet()) {
       Source newSource = entry.getKey();
-      SourceEntry existingEntry = getReadableSourceEntry(newSource);
+      SourceEntry existingEntry = _getReadableSourceEntry(newSource);
       if (existingEntry == null) {
         // TODO(brianwilkerson) Decide whether we really need to copy the info.
         _cache.put(newSource, entry.getValue().writableCopy);
       } else {
       }
     }
   }
 
-  CompilationUnit parseCompilationUnit(Source source) => getDartParseData2(source, DartEntry.PARSED_UNIT, null);
+  CompilationUnit parseCompilationUnit(Source source) => _getDartParseData2(source, DartEntry.PARSED_UNIT, null);
 
-  ht.HtmlUnit parseHtmlUnit(Source source) => getHtmlParseData(source, HtmlEntry.PARSED_UNIT, null);
+  ht.HtmlUnit parseHtmlUnit(Source source) => _getHtmlParseData(source, HtmlEntry.PARSED_UNIT, null);
 
   AnalysisResult performAnalysisTask() {
     int getStart = JavaSystem.currentTimeMillis();
     AnalysisTask task = nextAnalysisTask;
     int getEnd = JavaSystem.currentTimeMillis();
-    if (task == null && validateCacheConsistency()) {
+    if (task == null && _validateCacheConsistency()) {
       task = nextAnalysisTask;
     }
     if (task == null) {
-      return new AnalysisResult(getChangeNotices(true), getEnd - getStart, null, -1);
+      return new AnalysisResult(_getChangeNotices(true), getEnd - getStart, null, -1);
     }
     String taskDescriptor = task.toString();
     if (_recentTasks.add(taskDescriptor)) {
-      logInformation("Performing task: ${taskDescriptor}");
+      _logInformation("Performing task: ${taskDescriptor}");
     } else {
-      logInformation("*** Performing repeated task: ${taskDescriptor}");
+      _logInformation("*** Performing repeated task: ${taskDescriptor}");
     }
     int performStart = JavaSystem.currentTimeMillis();
     try {
       task.perform(_resultRecorder);
     } on ObsoleteSourceAnalysisException catch (exception) {
-      AnalysisEngine.instance.logger.logInformation3("Could not perform analysis task: ${taskDescriptor}", exception);
+      AnalysisEngine.instance.logger.logInformation2("Could not perform analysis task: ${taskDescriptor}", exception);
     } on AnalysisException catch (exception) {
       if (exception.cause is! JavaIOException) {
         AnalysisEngine.instance.logger.logError2("Internal error while performing the task: ${task}", exception);
       }
     }
     int performEnd = JavaSystem.currentTimeMillis();
-    return new AnalysisResult(getChangeNotices(false), getEnd - getStart, task.runtimeType.toString(), performEnd - performStart);
+    return new AnalysisResult(_getChangeNotices(false), getEnd - getStart, task.runtimeType.toString(), performEnd - performStart);
   }
 
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML);
     for (MapEntry<Source, LibraryElement> entry in getMapEntrySet(elementMap)) {
       Source librarySource = entry.getKey();
       LibraryElement library = entry.getValue();
       //
       // Cache the element in the library's info.
       //
-      DartEntry dartEntry = getReadableDartEntry(librarySource);
+      DartEntry dartEntry = _getReadableDartEntry(librarySource);
       if (dartEntry != null) {
         DartEntryImpl dartCopy = dartEntry.writableCopy;
-        recordElementData(dartEntry, dartCopy, library, library.source, htmlSource);
+        _recordElementData(dartEntry, dartCopy, library, library.source, htmlSource);
         _cache.put(librarySource, dartCopy);
       }
     }
   }
 
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return resolveCompilationUnit2(unitSource, library.source);
   }
 
-  CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) => getDartResolutionData2(unitSource, librarySource, DartEntry.RESOLVED_UNIT, null);
+  CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) => _getDartResolutionData2(unitSource, librarySource, DartEntry.RESOLVED_UNIT, null);
 
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     computeHtmlElement(htmlSource);
     return parseHtmlUnit(htmlSource);
   }
 
   void set analysisOptions(AnalysisOptions options) {
     bool needsRecompute = this._options.analyzeFunctionBodies != options.analyzeFunctionBodies || this._options.dart2jsHint != options.dart2jsHint || (this._options.hint && !options.hint) || this._options.preserveComments != options.preserveComments;
     int cacheSize = options.cacheSize;
     if (this._options.cacheSize != cacheSize) {
@@ skipping 10 matching lines @@
         JavaSystem.arraycopy(_priorityOrder, 0, newPriorityOrder, 0, maxPriorityOrderSize);
         _priorityOrder = newPriorityOrder;
       }
     }
     this._options.analyzeFunctionBodies = options.analyzeFunctionBodies;
     this._options.dart2jsHint = options.dart2jsHint;
     this._options.hint = options.hint;
     this._options.incremental = options.incremental;
     this._options.preserveComments = options.preserveComments;
     if (needsRecompute) {
-      invalidateAllResolutionInformation();
+      _invalidateAllResolutionInformation();
     }
   }
 
   void set analysisPriorityOrder(List<Source> sources) {
     if (sources == null || sources.isEmpty) {
       _priorityOrder = Source.EMPTY_ARRAY;
     } else {
       while (sources.remove(null)) {
       }
       if (sources.isEmpty) {
@@ skipping 11 matching lines @@
       }
     }
   }
 
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
     _recentTasks.clear();
     String originalContents = _contentCache.setContents(source, contents);
     if (contents != null) {
       if (contents != originalContents) {
         if (_options.incremental) {
-          _incrementalAnalysisCache = IncrementalAnalysisCache.update(_incrementalAnalysisCache, source, originalContents, contents, offset, oldLength, newLength, getReadableSourceEntry(source));
+          _incrementalAnalysisCache = IncrementalAnalysisCache.update(_incrementalAnalysisCache, source, originalContents, contents, offset, oldLength, newLength, _getReadableSourceEntry(source));
         }
-        sourceChanged(source);
+        _sourceChanged(source);
         SourceEntry sourceEntry = _cache.get(source);
         if (sourceEntry != null) {
           SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
           sourceCopy.modificationTime = _contentCache.getModificationStamp(source);
           sourceCopy.setValue(SourceEntry.CONTENT, contents);
           _cache.put(source, sourceCopy);
         }
       }
     } else if (originalContents != null) {
       _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
-      sourceChanged(source);
+      _sourceChanged(source);
     }
   }
 
   void setContents(Source source, String contents) {
     _recentTasks.clear();
     String originalContents = _contentCache.setContents(source, contents);
     if (contents != null) {
       if (contents != originalContents) {
         _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
-        sourceChanged(source);
+        _sourceChanged(source);
         SourceEntry sourceEntry = _cache.get(source);
         if (sourceEntry != null) {
           SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
           sourceCopy.modificationTime = _contentCache.getModificationStamp(source);
           sourceCopy.setValue(SourceEntry.CONTENT, contents);
           _cache.put(source, sourceCopy);
         }
       }
     } else if (originalContents != null) {
       _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
-      sourceChanged(source);
+      _sourceChanged(source);
     }
   }
 
   void set sourceFactory(SourceFactory factory) {
     if (identical(_sourceFactory, factory)) {
       return;
     } else if (factory.context != null) {
       throw new IllegalStateException("Source factories cannot be shared between contexts");
     }
     if (_sourceFactory != null) {
       _sourceFactory.context = null;
     }
     factory.context = this;
     _sourceFactory = factory;
-    invalidateAllResolutionInformation();
+    _invalidateAllResolutionInformation();
   }
 
   /**
    * Record the results produced by performing a [ResolveDartLibraryTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordResolveDartLibraryTaskResults(ResolveDartLibraryTask task) {
     LibraryResolver resolver = task.libraryResolver;
     AnalysisException thrownException = task.exception;
     DartEntry unitEntry = null;
     Source unitSource = task.unitSource;
     if (resolver != null) {
       //
       // The resolver should only be null if an exception was thrown before (or while) it was
       // being created.
       //
       Set<Library> resolvedLibraries = resolver.resolvedLibraries;
       if (resolvedLibraries == null) {
         //
         // The resolved libraries should only be null if an exception was thrown during resolution.
         //
-        unitEntry = getReadableDartEntry(unitSource);
+        unitEntry = _getReadableDartEntry(unitSource);
         if (unitEntry == null) {
           throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
         }
         DartEntryImpl dartCopy = unitEntry.writableCopy;
         dartCopy.recordResolutionError();
         dartCopy.exception = thrownException;
         _cache.put(unitSource, dartCopy);
         _cache.remove(unitSource);
         if (thrownException != null) {
           throw thrownException;
         }
         return dartCopy;
       }
-      if (allModificationTimesMatch(resolvedLibraries)) {
+      if (_allModificationTimesMatch(resolvedLibraries)) {
         Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
         RecordingErrorListener errorListener = resolver.errorListener;
         for (Library library in resolvedLibraries) {
           Source librarySource = library.librarySource;
           for (Source source in library.compilationUnitSources) {
             CompilationUnit unit = library.getAST(source);
             List<AnalysisError> errors = errorListener.getErrorsForSource(source);
             LineInfo lineInfo = getLineInfo(source);
             DartEntry dartEntry = _cache.get(source) as DartEntry;
             int sourceTime = getModificationStamp(source);
             if (dartEntry.modificationTime != sourceTime) {
               // The source has changed without the context being notified. Simulate notification.
-              sourceChanged(source);
-              dartEntry = getReadableDartEntry(source);
+              _sourceChanged(source);
+              dartEntry = _getReadableDartEntry(source);
               if (dartEntry == null) {
                 throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
               }
             }
             DartEntryImpl dartCopy = dartEntry.writableCopy;
             if (thrownException == null) {
               dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
               dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
               dartCopy.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, unit);
               dartCopy.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, errors);
               if (source == librarySource) {
-                recordElementData(dartEntry, dartCopy, library.libraryElement, librarySource, htmlSource);
+                _recordElementData(dartEntry, dartCopy, library.libraryElement, librarySource, htmlSource);
               }
               _cache.storedAst(source);
             } else {
               dartCopy.recordResolutionError();
               _cache.remove(source);
             }
             dartCopy.exception = thrownException;
             _cache.put(source, dartCopy);
             if (source != librarySource) {
               _workManager.add(source, SourcePriority.PRIORITY_PART);
             }
             if (source == unitSource) {
               unitEntry = dartCopy;
             }
-            ChangeNoticeImpl notice = getNotice(source);
+            ChangeNoticeImpl notice = _getNotice(source);
             notice.compilationUnit = unit;
             notice.setErrors(dartCopy.allErrors, lineInfo);
           }
         }
       } else {
         PrintStringWriter writer = new PrintStringWriter();
         writer.println("Library resolution results discarded for");
         for (Library library in resolvedLibraries) {
           for (Source source in library.compilationUnitSources) {
-            DartEntry dartEntry = getReadableDartEntry(source);
+            DartEntry dartEntry = _getReadableDartEntry(source);
             if (dartEntry != null) {
               int resultTime = library.getModificationTime(source);
-              writer.println("  ${debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}");
+              writer.println("  ${_debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}");
               DartEntryImpl dartCopy = dartEntry.writableCopy;
               if (thrownException == null || resultTime >= 0) {
                 //
                 // The analysis was performed on out-of-date sources. Mark the cache so that the
                 // sources will be re-analyzed using the up-to-date sources.
                 //
                 dartCopy.recordResolutionNotInProcess();
               } else {
                 //
                 // We could not determine whether the sources were up-to-date or out-of-date. Mark
                 // the cache so that we won't attempt to re-analyze the sources until there's a
                 // good chance that we'll be able to do so without error.
                 //
                 dartCopy.recordResolutionError();
                 _cache.remove(source);
               }
               dartCopy.exception = thrownException;
               _cache.put(source, dartCopy);
               if (source == unitSource) {
                 unitEntry = dartCopy;
               }
             } else {
-              writer.println("  ${debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, no entry");
+              writer.println("  ${_debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, no entry");
             }
           }
         }
-        logInformation(writer.toString());
+        _logInformation(writer.toString());
       }
     }
     if (thrownException != null) {
       throw thrownException;
     }
     if (unitEntry == null) {
-      unitEntry = getReadableDartEntry(unitSource);
+      unitEntry = _getReadableDartEntry(unitSource);
       if (unitEntry == null) {
         throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
       }
     }
     return unitEntry;
   }
 
   /**
    * Record that we have accessed the AST structure associated with the given source. At the moment,
    * there is no differentiation between the parsed and resolved forms of the AST.
    *
    * @param source the source whose AST structure was accessed
    */
-  void accessedAst(Source source) {
+  void _accessedAst(Source source) {
     _cache.accessedAst(source);
   }
 
   /**
    * Add all of the sources contained in the given source container to the given list of sources.
    *
    * Note: This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param sources the list to which sources are to be added
    * @param container the source container containing the sources to be added to the list
    */
-  void addSourcesInContainer(List<Source> sources, SourceContainer container) {
+  void _addSourcesInContainer(List<Source> sources, SourceContainer container) {
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       Source source = entry.getKey();
       if (container.contains(source)) {
         sources.add(source);
       }
     }
   }
 
   /**
    * Return `true` if the modification times of the sources used by the given library resolver
    * to resolve one or more libraries are consistent with the modification times in the cache.
    *
    * @param resolver the library resolver used to resolve one or more libraries
    * @return `true` if we should record the results of the resolution
    * @throws AnalysisException if any of the modification times could not be determined (this should
    *           not happen)
    */
-  bool allModificationTimesMatch(Set<Library> resolvedLibraries) {
+  bool _allModificationTimesMatch(Set<Library> resolvedLibraries) {
     bool allTimesMatch = true;
     for (Library library in resolvedLibraries) {
       for (Source source in library.compilationUnitSources) {
-        DartEntry dartEntry = getReadableDartEntry(source);
+        DartEntry dartEntry = _getReadableDartEntry(source);
         if (dartEntry == null) {
           // This shouldn't be possible because we should never have performed the task if the
           // source didn't represent a Dart file, but check to be safe.
           throw new AnalysisException.con1("Internal error: attempting to resolve non-Dart file as a Dart file: ${source.fullName}");
         }
         int sourceTime = getModificationStamp(source);
         int resultTime = library.getModificationTime(source);
         if (sourceTime != resultTime) {
           // The source has changed without the context being notified. Simulate notification.
-          sourceChanged(source);
+          _sourceChanged(source);
           allTimesMatch = false;
         }
       }
     }
     return allTimesMatch;
   }
 
   /**
    * Given a source for a Dart file, return a cache entry in which the state of the data represented
    * by the given descriptor is either [CacheState#VALID] or [CacheState#ERROR]. This
    * method assumes that the data can be produced by resolving the directives in the source if they
    * are not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  DartEntry cacheDartDependencyData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
+  DartEntry _cacheDartDependencyData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getState(descriptor);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
-      dartEntry = cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
+      dartEntry = _cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
       dartEntry = new ResolveDartDependenciesTask(this, source, dartEntry.modificationTime, dartEntry.anyParsedCompilationUnit).perform(_resultRecorder) as DartEntry;
       state = dartEntry.getState(descriptor);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * the state of the data represented by the given descriptor is either [CacheState#VALID] or
    * [CacheState#ERROR]. This method assumes that the data can be produced by generating hints
    * for the library if the data is not already cached.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  DartEntry cacheDartHintData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
+  DartEntry _cacheDartHintData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getStateInLibrary(descriptor, librarySource);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
       dartEntry = new GenerateDartHintsTask(this, getLibraryElement(librarySource)).perform(_resultRecorder) as DartEntry;
       state = dartEntry.getStateInLibrary(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file, return a cache entry in which the state of the data represented
    * by the given descriptor is either [CacheState#VALID] or [CacheState#ERROR]. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  DartEntry cacheDartParseData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
+  DartEntry _cacheDartParseData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       CompilationUnit unit = dartEntry.anyParsedCompilationUnit;
       if (unit != null) {
         return dartEntry;
       }
     }
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getState(descriptor);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
-      dartEntry = cacheDartScanData(source, dartEntry, DartEntry.TOKEN_STREAM);
+      dartEntry = _cacheDartScanData(source, dartEntry, DartEntry.TOKEN_STREAM);
       dartEntry = new ParseDartTask(this, source, dartEntry.modificationTime, dartEntry.getValue(DartEntry.TOKEN_STREAM)).perform(_resultRecorder) as DartEntry;
       state = dartEntry.getState(descriptor);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * the state of the data represented by the given descriptor is either [CacheState#VALID] or
    * [CacheState#ERROR]. This method assumes that the data can be produced by resolving the
    * source in the context of the library if it is not already cached.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  DartEntry cacheDartResolutionData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
+  DartEntry _cacheDartResolutionData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = (identical(descriptor, DartEntry.ELEMENT)) ? dartEntry.getState(descriptor) : dartEntry.getStateInLibrary(descriptor, librarySource);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
       // TODO(brianwilkerson) As an optimization, if we already have the element model for the
@@ skipping 11 matching lines @@
    * cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be scanned
    */
-  DartEntry cacheDartScanData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
+  DartEntry _cacheDartScanData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getState(descriptor);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
       try {
@@ skipping 17 matching lines @@
    * [CacheState#ERROR]. This method assumes that the data can be produced by verifying the
    * source in the given library if the data is not already cached.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  DartEntry cacheDartVerificationData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
+  DartEntry _cacheDartVerificationData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getStateInLibrary(descriptor, librarySource);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
       dartEntry = new GenerateDartErrorsTask(this, unitSource, getLibraryElement(librarySource)).perform(_resultRecorder) as DartEntry;
@@ skipping 10 matching lines @@
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the source representing the HTML file
    * @param htmlEntry the cache entry associated with the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  HtmlEntry cacheHtmlParseData(Source source, HtmlEntry htmlEntry, DataDescriptor descriptor) {
+  HtmlEntry _cacheHtmlParseData(Source source, HtmlEntry htmlEntry, DataDescriptor descriptor) {
     if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       ht.HtmlUnit unit = htmlEntry.anyParsedUnit;
       if (unit != null) {
         return htmlEntry;
       }
     }
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = htmlEntry.getState(descriptor);
@@ skipping 25 matching lines @@
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the source representing the HTML file
    * @param dartEntry the cache entry associated with the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  HtmlEntry cacheHtmlResolutionData(Source source, HtmlEntry htmlEntry, DataDescriptor descriptor) {
+  HtmlEntry _cacheHtmlResolutionData(Source source, HtmlEntry htmlEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = htmlEntry.getState(descriptor);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
-      htmlEntry = cacheHtmlParseData(source, htmlEntry, HtmlEntry.PARSED_UNIT);
+      htmlEntry = _cacheHtmlParseData(source, htmlEntry, HtmlEntry.PARSED_UNIT);
       htmlEntry = new ResolveHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(HtmlEntry.PARSED_UNIT)).perform(_resultRecorder) as HtmlEntry;
       state = htmlEntry.getState(descriptor);
     }
     return htmlEntry;
   }
 
   /**
    * Given the encoded form of a source, use the source factory to reconstitute the original source.
    *
    * @param encoding the encoded form of a source
    * @return the source represented by the encoding
    */
-  Source computeSourceFromEncoding(String encoding) => _sourceFactory.fromEncoding(encoding);
+  Source _computeSourceFromEncoding(String encoding) => _sourceFactory.fromEncoding(encoding);
 
   /**
    * Return `true` if the given array of sources contains the given source.
    *
    * @param sources the sources being searched
    * @param targetSource the source being searched for
    * @return `true` if the given source is in the array
    */
-  bool contains(List<Source> sources, Source targetSource) {
+  bool _contains(List<Source> sources, Source targetSource) {
     for (Source source in sources) {
       if (source == targetSource) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Return `true` if the given array of sources contains any of the given target sources.
    *
    * @param sources the sources being searched
    * @param targetSources the sources being searched for
    * @return `true` if any of the given target sources are in the array
    */
-  bool containsAny(List<Source> sources, List<Source> targetSources) {
+  bool _containsAny(List<Source> sources, List<Source> targetSources) {
     for (Source targetSource in targetSources) {
-      if (contains(sources, targetSource)) {
+      if (_contains(sources, targetSource)) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Create a [GetContentTask] for the given source, marking the content as being in-process.
    *
    * @param source the source whose content is to be accessed
    * @param sourceEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData createGetContentTask(Source source, SourceEntry sourceEntry) {
+  AnalysisContextImpl_TaskData _createGetContentTask(Source source, SourceEntry sourceEntry) {
     SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
     sourceCopy.setState(SourceEntry.CONTENT, CacheState.IN_PROCESS);
     _cache.put(source, sourceCopy);
     return new AnalysisContextImpl_TaskData(new GetContentTask(this, source), false, null);
   }
 
   /**
    * Create a [ParseDartTask] for the given source, marking the parse errors as being
    * in-process.
    *
    * @param source the source whose content is to be parsed
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData createParseDartTask(Source source, DartEntry dartEntry) {
+  AnalysisContextImpl_TaskData _createParseDartTask(Source source, DartEntry dartEntry) {
     if (dartEntry.getState(DartEntry.TOKEN_STREAM) != CacheState.VALID) {
-      return createScanDartTask(source, dartEntry);
+      return _createScanDartTask(source, dartEntry);
     }
     Token tokenStream = dartEntry.getValue(DartEntry.TOKEN_STREAM);
     DartEntryImpl dartCopy = dartEntry.writableCopy;
     dartCopy.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
     dartCopy.setState(DartEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
     _cache.put(source, dartCopy);
     return new AnalysisContextImpl_TaskData(new ParseDartTask(this, source, dartCopy.modificationTime, tokenStream), false, null);
   }
 
   /**
    * Create a [ParseHtmlTask] for the given source, marking the parse errors as being
    * in-process.
    *
    * @param source the source whose content is to be parsed
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData createParseHtmlTask(Source source, HtmlEntry htmlEntry) {
+  AnalysisContextImpl_TaskData _createParseHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
-      return createGetContentTask(source, htmlEntry);
+      return _createGetContentTask(source, htmlEntry);
     }
     String content = htmlEntry.getValue(SourceEntry.CONTENT);
     HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
     htmlCopy.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
     htmlCopy.setState(HtmlEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
     _cache.put(source, htmlCopy);
     return new AnalysisContextImpl_TaskData(new ParseHtmlTask(this, source, htmlCopy.modificationTime, content), false, null);
   }
 
   /**
    * Create a [ResolveDartDependenciesTask] for the given source, marking the exported
    * libraries as being in-process.
    *
    * @param source the source whose content is to be used to resolve dependencies
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData createResolveDartDependenciesTask(Source source, DartEntry dartEntry) {
+  AnalysisContextImpl_TaskData _createResolveDartDependenciesTask(Source source, DartEntry dartEntry) {
     CompilationUnit unit = dartEntry.anyParsedCompilationUnit;
     if (unit == null) {
-      return createParseDartTask(source, dartEntry);
+      return _createParseDartTask(source, dartEntry);
     }
     DartEntryImpl dartCopy = dartEntry.writableCopy;
     dartCopy.setState(DartEntry.EXPORTED_LIBRARIES, CacheState.IN_PROCESS);
     _cache.put(source, dartCopy);
     return new AnalysisContextImpl_TaskData(new ResolveDartDependenciesTask(this, source, dartCopy.modificationTime, unit), false, null);
   }
 
   /**
    * Create a [ResolveHtmlTask] for the given source, marking the resolved unit as being
    * in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData createResolveHtmlTask(Source source, HtmlEntry htmlEntry) {
+  AnalysisContextImpl_TaskData _createResolveHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.PARSED_UNIT) != CacheState.VALID) {
-      return createParseHtmlTask(source, htmlEntry);
+      return _createParseHtmlTask(source, htmlEntry);
     }
     HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
     htmlCopy.setState(HtmlEntry.RESOLVED_UNIT, CacheState.IN_PROCESS);
     _cache.put(source, htmlCopy);
     return new AnalysisContextImpl_TaskData(new ResolveHtmlTask(this, source, htmlCopy.modificationTime, htmlCopy.getValue(HtmlEntry.PARSED_UNIT)), false, null);
   }
 
   /**
    * Create a [ScanDartTask] for the given source, marking the scan errors as being
    * in-process.
    *
    * @param source the source whose content is to be scanned
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData createScanDartTask(Source source, DartEntry dartEntry) {
+  AnalysisContextImpl_TaskData _createScanDartTask(Source source, DartEntry dartEntry) {
     if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
-      return createGetContentTask(source, dartEntry);
+      return _createGetContentTask(source, dartEntry);
     }
     String content = dartEntry.getValue(SourceEntry.CONTENT);
     DartEntryImpl dartCopy = dartEntry.writableCopy;
     dartCopy.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
     dartCopy.setState(DartEntry.SCAN_ERRORS, CacheState.IN_PROCESS);
     _cache.put(source, dartCopy);
     return new AnalysisContextImpl_TaskData(new ScanDartTask(this, source, dartCopy.modificationTime, content), false, null);
   }
 
   /**
    * Create a source information object suitable for the given source. Return the source information
    * object that was created, or `null` if the source should not be tracked by this context.
    *
    * @param source the source for which an information object is being created
    * @return the source information object that was created
    */
-  SourceEntry createSourceEntry(Source source) {
+  SourceEntry _createSourceEntry(Source source) {
     String name = source.shortName;
     if (AnalysisEngine.isHtmlFileName(name)) {
       HtmlEntryImpl htmlEntry = new HtmlEntryImpl();
       htmlEntry.modificationTime = getModificationStamp(source);
       _cache.put(source, htmlEntry);
       return htmlEntry;
     } else {
       DartEntryImpl dartEntry = new DartEntryImpl();
       dartEntry.modificationTime = getModificationStamp(source);
       _cache.put(source, dartEntry);
       return dartEntry;
     }
   }
 
   /**
    * Return a string with debugging information about the given source (the full name and
    * modification stamp of the source).
    *
    * @param source the source for which a debugging string is to be produced
    * @return debugging information about the given source
    */
-  String debuggingString(Source source) => "'${source.fullName}' [${getModificationStamp(source)}]";
+  String _debuggingString(Source source) => "'${source.fullName}' [${getModificationStamp(source)}]";
 
   /**
    * Return an array containing all of the change notices that are waiting to be returned. If there
    * are no notices, then return either `null` or an empty array, depending on the value of
    * the argument.
    *
    * @param nullIfEmpty `true` if `null` should be returned when there are no notices
    * @return the change notices that are waiting to be returned
    */
-  List<ChangeNotice> getChangeNotices(bool nullIfEmpty) {
+  List<ChangeNotice> _getChangeNotices(bool nullIfEmpty) {
     if (_pendingNotices.isEmpty) {
       if (nullIfEmpty) {
         return null;
       }
       return ChangeNoticeImpl.EMPTY_ARRAY;
     }
     List<ChangeNotice> notices = new List.from(_pendingNotices.values);
     _pendingNotices.clear();
     return notices;
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source. This method assumes that the data can be produced by resolving the
    * directives in the source if they are not already cached.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  Object getDartDependencyData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
-    dartEntry = cacheDartDependencyData(source, dartEntry, descriptor);
+  Object _getDartDependencyData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
+    dartEntry = _cacheDartDependencyData(source, dartEntry, descriptor);
     return dartEntry.getValue(descriptor);
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not a Dart file. This
    * method assumes that the data can be produced by resolving the directives in the source if they
    * are not already cached.
    *
    * @param source the source representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not a Dart file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  Object getDartDependencyData2(Source source, DataDescriptor descriptor, Object defaultValue) {
-    DartEntry dartEntry = getReadableDartEntry(source);
+  Object _getDartDependencyData2(Source source, DataDescriptor descriptor, Object defaultValue) {
+    DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       return defaultValue;
     }
     try {
-      return getDartDependencyData(source, dartEntry, descriptor);
+      return _getDartDependencyData(source, dartEntry, descriptor);
     } on ObsoleteSourceAnalysisException catch (exception) {
-      AnalysisEngine.instance.logger.logInformation3("Could not compute ${descriptor.toString()}", exception);
+      AnalysisEngine.instance.logger.logInformation2("Could not compute ${descriptor.toString()}", exception);
       return defaultValue;
     }
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return the data represented by
    * the given descriptor that is associated with that source. This method assumes that the data can
    * be produced by generating hints for the library if it is not already cached.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the entry representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  Object getDartHintData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
-    dartEntry = cacheDartHintData(unitSource, librarySource, dartEntry, descriptor);
+  Object _getDartHintData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
+    dartEntry = _cacheDartHintData(unitSource, librarySource, dartEntry, descriptor);
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return dartEntry.getValue(descriptor);
     }
     return dartEntry.getValueInLibrary(descriptor, librarySource);
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source. This method assumes that the data can be produced by parsing the
    * source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  Object getDartParseData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
-    dartEntry = cacheDartParseData(source, dartEntry, descriptor);
+  Object _getDartParseData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
+    dartEntry = _cacheDartParseData(source, dartEntry, descriptor);
     if (identical(descriptor, DartEntry.PARSED_UNIT)) {
-      accessedAst(source);
+      _accessedAst(source);
       return dartEntry.anyParsedCompilationUnit;
     }
     return dartEntry.getValue(descriptor);
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not a Dart file. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the source representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not a Dart file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  Object getDartParseData2(Source source, DataDescriptor descriptor, Object defaultValue) {
-    DartEntry dartEntry = getReadableDartEntry(source);
+  Object _getDartParseData2(Source source, DataDescriptor descriptor, Object defaultValue) {
+    DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       return defaultValue;
     }
     try {
-      return getDartParseData(source, dartEntry, descriptor);
+      return _getDartParseData(source, dartEntry, descriptor);
     } on ObsoleteSourceAnalysisException catch (exception) {
-      AnalysisEngine.instance.logger.logInformation3("Could not compute ${descriptor.toString()}", exception);
+      AnalysisEngine.instance.logger.logInformation2("Could not compute ${descriptor.toString()}", exception);
       return defaultValue;
     }
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return the data represented by
    * the given descriptor that is associated with that source. This method assumes that the data can
    * be produced by resolving the source in the context of the library if it is not already cached.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the entry representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  Object getDartResolutionData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
-    dartEntry = cacheDartResolutionData(unitSource, librarySource, dartEntry, descriptor);
+  Object _getDartResolutionData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
+    dartEntry = _cacheDartResolutionData(unitSource, librarySource, dartEntry, descriptor);
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return dartEntry.getValue(descriptor);
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
-      accessedAst(unitSource);
+      _accessedAst(unitSource);
     }
     return dartEntry.getValueInLibrary(descriptor, librarySource);
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return the data represented by
    * the given descriptor that is associated with that source, or the given default value if the
    * source is not a Dart file. This method assumes that the data can be produced by resolving the
    * source in the context of the library if it is not already cached.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not a Dart file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  Object getDartResolutionData2(Source unitSource, Source librarySource, DataDescriptor descriptor, Object defaultValue) {
-    DartEntry dartEntry = getReadableDartEntry(unitSource);
+  Object _getDartResolutionData2(Source unitSource, Source librarySource, DataDescriptor descriptor, Object defaultValue) {
+    DartEntry dartEntry = _getReadableDartEntry(unitSource);
     if (dartEntry == null) {
       return defaultValue;
     }
     try {
-      return getDartResolutionData(unitSource, librarySource, dartEntry, descriptor);
+      return _getDartResolutionData(unitSource, librarySource, dartEntry, descriptor);
     } on ObsoleteSourceAnalysisException catch (exception) {
-      AnalysisEngine.instance.logger.logInformation3("Could not compute ${descriptor.toString()}", exception);
+      AnalysisEngine.instance.logger.logInformation2("Could not compute ${descriptor.toString()}", exception);
       return defaultValue;
     }
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source. This method assumes that the data can be produced by scanning the
    * source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be scanned
    */
-  Object getDartScanData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
-    dartEntry = cacheDartScanData(source, dartEntry, descriptor);
+  Object _getDartScanData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
+    dartEntry = _cacheDartScanData(source, dartEntry, descriptor);
     return dartEntry.getValue(descriptor);
   }
 
   /**
    * Given a source for a Dart file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not a Dart file. This
    * method assumes that the data can be produced by scanning the source if it is not already
    * cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the source representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not a Dart file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be scanned
    */
-  Object getDartScanData2(Source source, DataDescriptor descriptor, Object defaultValue) {
-    DartEntry dartEntry = getReadableDartEntry(source);
+  Object _getDartScanData2(Source source, DataDescriptor descriptor, Object defaultValue) {
+    DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       return defaultValue;
     }
     try {
-      return getDartScanData(source, dartEntry, descriptor);
+      return _getDartScanData(source, dartEntry, descriptor);
     } on ObsoleteSourceAnalysisException catch (exception) {
-      AnalysisEngine.instance.logger.logInformation3("Could not compute ${descriptor.toString()}", exception);
+      AnalysisEngine.instance.logger.logInformation2("Could not compute ${descriptor.toString()}", exception);
       return defaultValue;
     }
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return the data represented by
    * the given descriptor that is associated with that source. This method assumes that the data can
    * be produced by verifying the source within the given library if it is not already cached.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the entry representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  Object getDartVerificationData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
-    dartEntry = cacheDartVerificationData(unitSource, librarySource, dartEntry, descriptor);
+  Object _getDartVerificationData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
+    dartEntry = _cacheDartVerificationData(unitSource, librarySource, dartEntry, descriptor);
     return dartEntry.getValueInLibrary(descriptor, librarySource);
   }
 
   /**
    * Given a source for an HTML file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not an HTML file. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the source representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not an HTML file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
-  Object getHtmlParseData(Source source, DataDescriptor descriptor, Object defaultValue) {
-    HtmlEntry htmlEntry = getReadableHtmlEntry(source);
+  Object _getHtmlParseData(Source source, DataDescriptor descriptor, Object defaultValue) {
+    HtmlEntry htmlEntry = _getReadableHtmlEntry(source);
     if (htmlEntry == null) {
       return defaultValue;
     }
-    htmlEntry = cacheHtmlParseData(source, htmlEntry, descriptor);
+    htmlEntry = _cacheHtmlParseData(source, htmlEntry, descriptor);
     if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
-      accessedAst(source);
+      _accessedAst(source);
       return htmlEntry.anyParsedUnit;
     }
     return htmlEntry.getValue(descriptor);
   }
 
   /**
    * Given a source for an HTML file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not an HTML file. This
    * method assumes that the data can be produced by resolving the source if it is not already
    * cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the source representing the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not an HTML file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  Object getHtmlResolutionData(Source source, DataDescriptor descriptor, Object defaultValue) {
-    HtmlEntry htmlEntry = getReadableHtmlEntry(source);
+  Object _getHtmlResolutionData(Source source, DataDescriptor descriptor, Object defaultValue) {
+    HtmlEntry htmlEntry = _getReadableHtmlEntry(source);
     if (htmlEntry == null) {
       return defaultValue;
     }
     try {
-      return getHtmlResolutionData2(source, htmlEntry, descriptor);
+      return _getHtmlResolutionData2(source, htmlEntry, descriptor);
     } on ObsoleteSourceAnalysisException catch (exception) {
-      AnalysisEngine.instance.logger.logInformation3("Could not compute ${descriptor.toString()}", exception);
+      AnalysisEngine.instance.logger.logInformation2("Could not compute ${descriptor.toString()}", exception);
       return defaultValue;
     }
   }
 
   /**
    * Given a source for an HTML file, return the data represented by the given descriptor that is
    * associated with that source. This method assumes that the data can be produced by resolving the
    * source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the source representing the HTML file
    * @param htmlEntry the entry representing the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
-  Object getHtmlResolutionData2(Source source, HtmlEntry htmlEntry, DataDescriptor descriptor) {
-    htmlEntry = cacheHtmlResolutionData(source, htmlEntry, descriptor);
+  Object _getHtmlResolutionData2(Source source, HtmlEntry htmlEntry, DataDescriptor descriptor) {
+    htmlEntry = _cacheHtmlResolutionData(source, htmlEntry, descriptor);
     if (identical(descriptor, HtmlEntry.RESOLVED_UNIT)) {
-      accessedAst(source);
+      _accessedAst(source);
     }
     return htmlEntry.getValue(descriptor);
   }
 
   /**
    * Look through the cache for a task that needs to be performed. Return the task that was found,
    * or `null` if there is no more work to be done.
    *
    * @return the next task that needs to be performed
    */
   AnalysisTask get nextAnalysisTask {
     bool hintsEnabled = _options.hint;
     bool sdkErrorsEnabled = _options.generateSdkErrors;
     bool hasBlockedTask = false;
     //
     // Look for incremental analysis
     //
     if (_incrementalAnalysisCache != null && _incrementalAnalysisCache.hasWork) {
       AnalysisTask task = new IncrementalAnalysisTask(this, _incrementalAnalysisCache);
       _incrementalAnalysisCache = null;
       return task;
     }
     //
     // Look for a priority source that needs to be analyzed.
     //
     for (Source source in _priorityOrder) {
-      AnalysisContextImpl_TaskData taskData = getNextNondependentAnalysisTask(source, true, hintsEnabled, sdkErrorsEnabled);
+      AnalysisContextImpl_TaskData taskData = _getNextNondependentAnalysisTask(source, true, hintsEnabled, sdkErrorsEnabled);
       AnalysisTask task = taskData.task;
       if (task != null) {
         return task;
       } else if (taskData.isBlocked) {
         hasBlockedTask = true;
       }
     }
     //
     // Look for a non-priority source that needs to be analyzed.
     //
     Source source = _workManager.nextSource;
     while (source != null) {
-      AnalysisContextImpl_TaskData taskData = getNextNondependentAnalysisTask(source, false, hintsEnabled, sdkErrorsEnabled);
+      AnalysisContextImpl_TaskData taskData = _getNextNondependentAnalysisTask(source, false, hintsEnabled, sdkErrorsEnabled);
       AnalysisTask task = taskData.task;
       if (task != null) {
         return task;
       } else if (taskData.isBlocked) {
         hasBlockedTask = true;
       } else {
         _workManager.remove(source);
       }
       source = _workManager.nextSource;
     }
@@ skipping 23 matching lines @@
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source to be checked
    * @param sourceEntry the cache entry associated with the source
    * @param isPriority `true` if the source is a priority source
    * @param hintsEnabled `true` if hints are currently enabled
    * @param sdkErrorsEnabled `true` if errors, warnings and hints should be generated for
    *          sources in the SDK
    * @return the next task that needs to be performed for the given source
    */
-  AnalysisContextImpl_TaskData getNextAnalysisTaskForSource(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled, bool sdkErrorsEnabled) {
+  AnalysisContextImpl_TaskData _getNextAnalysisTaskForSource(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled, bool sdkErrorsEnabled) {
     if (sourceEntry == null) {
       return new AnalysisContextImpl_TaskData(null, false, null);
     }
     CacheState contentState = sourceEntry.getState(SourceEntry.CONTENT);
     if (identical(contentState, CacheState.INVALID)) {
-      return createGetContentTask(source, sourceEntry);
+      return _createGetContentTask(source, sourceEntry);
     } else if (identical(contentState, CacheState.IN_PROCESS)) {
       // We are already in the process of getting the content. There's nothing else we can do with
       // this source until that's complete.
       return new AnalysisContextImpl_TaskData(null, true, null);
     }
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       CacheState scanErrorsState = dartEntry.getState(DartEntry.SCAN_ERRORS);
       if (identical(scanErrorsState, CacheState.INVALID) || (isPriority && identical(scanErrorsState, CacheState.FLUSHED))) {
-        return createScanDartTask(source, dartEntry);
+        return _createScanDartTask(source, dartEntry);
       }
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
       if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
-        return createParseDartTask(source, dartEntry);
+        return _createParseDartTask(source, dartEntry);
       }
       if (isPriority && parseErrorsState != CacheState.ERROR) {
         CompilationUnit parseUnit = dartEntry.anyParsedCompilationUnit;
         if (parseUnit == null) {
-          return createParseDartTask(source, dartEntry);
+          return _createParseDartTask(source, dartEntry);
         }
       }
       CacheState exportState = dartEntry.getState(DartEntry.EXPORTED_LIBRARIES);
       if (identical(exportState, CacheState.INVALID) || (isPriority && identical(exportState, CacheState.FLUSHED))) {
-        return createResolveDartDependenciesTask(source, dartEntry);
+        return _createResolveDartDependenciesTask(source, dartEntry);
       }
       List<Source> librariesContaining = dartEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
       for (Source librarySource in librariesContaining) {
         SourceEntry libraryEntry = _cache.get(librarySource);
         if (libraryEntry is DartEntry) {
           CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
           if (identical(elementState, CacheState.INVALID) || (isPriority && identical(elementState, CacheState.FLUSHED))) {
             DartEntryImpl libraryCopy = libraryEntry.writableCopy;
             libraryCopy.setState(DartEntry.ELEMENT, CacheState.IN_PROCESS);
             _cache.put(librarySource, libraryCopy);
@@ skipping 37 matching lines @@
                 }
               }
             }
           }
         }
       }
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       CacheState parseErrorsState = htmlEntry.getState(HtmlEntry.PARSE_ERRORS);
       if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
-        return createParseHtmlTask(source, htmlEntry);
+        return _createParseHtmlTask(source, htmlEntry);
       }
       if (isPriority && parseErrorsState != CacheState.ERROR) {
         ht.HtmlUnit parsedUnit = htmlEntry.anyParsedUnit;
         if (parsedUnit == null) {
-          return createParseHtmlTask(source, htmlEntry);
+          return _createParseHtmlTask(source, htmlEntry);
         }
       }
       CacheState resolvedUnitState = htmlEntry.getState(HtmlEntry.RESOLVED_UNIT);
       if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
-        return createResolveHtmlTask(source, htmlEntry);
+        return _createResolveHtmlTask(source, htmlEntry);
       }
       // Angular support
       if (_options.analyzeAngular) {
         // try to resolve as an Angular entry point
         CacheState angularEntryState = htmlEntry.getState(HtmlEntry.ANGULAR_ENTRY);
         if (identical(angularEntryState, CacheState.INVALID)) {
           if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
-            return createResolveHtmlTask(source, htmlEntry);
+            return _createResolveHtmlTask(source, htmlEntry);
           }
           HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
           htmlCopy.setState(HtmlEntry.ANGULAR_ENTRY, CacheState.IN_PROCESS);
           _cache.put(source, htmlCopy);
           return new AnalysisContextImpl_TaskData(new ResolveAngularEntryHtmlTask(this, source, htmlCopy.modificationTime, htmlCopy.getValue(HtmlEntry.RESOLVED_UNIT)), false, null);
         }
         // try to resolve as an Angular application part
         CacheState angularErrorsState = htmlEntry.getState(HtmlEntry.ANGULAR_ERRORS);
         if (identical(angularErrorsState, CacheState.INVALID)) {
           if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
-            return createResolveHtmlTask(source, htmlEntry);
+            return _createResolveHtmlTask(source, htmlEntry);
           }
           AngularApplication application = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
           // try to resolve as an Angular template
           AngularComponentElement component = htmlEntry.getValue(HtmlEntry.ANGULAR_COMPONENT);
           HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
           htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.IN_PROCESS);
           _cache.put(source, htmlCopy);
           return new AnalysisContextImpl_TaskData(new ResolveAngularComponentTemplateTask(this, source, htmlCopy.modificationTime, htmlCopy.getValue(HtmlEntry.RESOLVED_UNIT), component, application), false, null);
         }
       }
     }
     return new AnalysisContextImpl_TaskData(null, false, null);
   }
 
-  AnalysisContextImpl_TaskData getNextNondependentAnalysisTask(Source source, bool isPriority, bool hintsEnabled, bool sdkErrorsEnabled) {
-    AnalysisContextImpl_TaskData taskData = getNextAnalysisTaskForSource(source, _cache.get(source), isPriority, hintsEnabled, sdkErrorsEnabled);
+  AnalysisContextImpl_TaskData _getNextNondependentAnalysisTask(Source source, bool isPriority, bool hintsEnabled, bool sdkErrorsEnabled) {
+    AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(source, _cache.get(source), isPriority, hintsEnabled, sdkErrorsEnabled);
     if (taskData.task != null || taskData.isBlocked) {
       return taskData;
     }
     while (taskData.dependentSource != null) {
-      taskData = getNextAnalysisTaskForSource(source, _cache.get(source), isPriority, hintsEnabled, sdkErrorsEnabled);
+      taskData = _getNextAnalysisTaskForSource(source, _cache.get(source), isPriority, hintsEnabled, sdkErrorsEnabled);
       if (taskData.task != null || taskData.isBlocked) {
         return taskData;
       }
     }
     return new AnalysisContextImpl_TaskData(null, false, null);
   }
 
   /**
    * Return a change notice for the given source, creating one if one does not already exist.
    *
    * @param source the source for which changes are being reported
    * @return a change notice for the given source
    */
-  ChangeNoticeImpl getNotice(Source source) {
+  ChangeNoticeImpl _getNotice(Source source) {
     ChangeNoticeImpl notice = _pendingNotices[source];
     if (notice == null) {
       notice = new ChangeNoticeImpl(source);
       _pendingNotices[source] = notice;
     }
     return notice;
   }
 
   /**
    * Return the cache entry associated with the given source, or `null` if the source is not a
    * Dart file.
    *
    * @param source the source for which a cache entry is being sought
    * @return the source cache entry associated with the given source
    */
-  DartEntry getReadableDartEntry(Source source) {
+  DartEntry _getReadableDartEntry(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
-      sourceEntry = createSourceEntry(source);
+      sourceEntry = _createSourceEntry(source);
     }
     if (sourceEntry is DartEntry) {
       return sourceEntry as DartEntry;
     }
     return null;
   }
 
   /**
    * Return the cache entry associated with the given source, or `null` if the source is not
    * an HTML file.
    *
    * @param source the source for which a cache entry is being sought
    * @return the source cache entry associated with the given source
    */
-  HtmlEntry getReadableHtmlEntry(Source source) {
+  HtmlEntry _getReadableHtmlEntry(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
-      sourceEntry = createSourceEntry(source);
+      sourceEntry = _createSourceEntry(source);
     }
     if (sourceEntry is HtmlEntry) {
       return sourceEntry as HtmlEntry;
     }
     return null;
   }
 
   /**
    * Return the cache entry associated with the given source, or `null` if there is no entry
    * associated with the source.
    *
    * @param source the source for which a cache entry is being sought
    * @return the source cache entry associated with the given source
    */
-  SourceEntry getReadableSourceEntry(Source source) {
+  SourceEntry _getReadableSourceEntry(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
-      sourceEntry = createSourceEntry(source);
+      sourceEntry = _createSourceEntry(source);
     }
     return sourceEntry;
   }
 
   /**
    * Return an array containing all of the sources known to this context that have the given kind.
    *
    * @param kind the kind of sources to be returned
    * @return all of the sources known to this context that have the given kind
    */
-  List<Source> getSources(SourceKind kind) {
+  List<Source> _getSources(SourceKind kind) {
     List<Source> sources = new List<Source>();
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       if (identical(entry.getValue().kind, kind)) {
         sources.add(entry.getKey());
       }
     }
     return new List.from(sources);
   }
 
   /**
    * Look at the given source to see whether a task needs to be performed related to it. If so, add
    * the source to the set of sources that need to be processed. This method duplicates, and must
    * therefore be kept in sync with,
    * [getNextAnalysisTask]. This method is intended to
    * be used for testing purposes only.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source to be checked
    * @param sourceEntry the cache entry associated with the source
    * @param isPriority `true` if the source is a priority source
    * @param hintsEnabled `true` if hints are currently enabled
    * @param sources the set to which sources should be added
    */
-  void getSourcesNeedingProcessing2(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled, Set<Source> sources) {
+  void _getSourcesNeedingProcessing(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled, Set<Source> sources) {
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       CacheState scanErrorsState = dartEntry.getState(DartEntry.SCAN_ERRORS);
       if (identical(scanErrorsState, CacheState.INVALID) || (isPriority && identical(scanErrorsState, CacheState.FLUSHED))) {
         sources.add(source);
         return;
       }
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
       if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
         sources.add(source);
@@ skipping 74 matching lines @@
         }
       }
     }
   }
 
   /**
    * Invalidate all of the resolution results computed by this context.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    */
-  void invalidateAllResolutionInformation() {
+  void _invalidateAllResolutionInformation() {
     for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
       Source source = mapEntry.getKey();
       SourceEntry sourceEntry = mapEntry.getValue();
       if (sourceEntry is HtmlEntry) {
         HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
         htmlCopy.invalidateAllResolutionInformation();
         mapEntry.setValue(htmlCopy);
       } else if (sourceEntry is DartEntry) {
         DartEntry dartEntry = sourceEntry;
-        removeFromParts(source, dartEntry);
+        _removeFromParts(source, dartEntry);
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         dartCopy.invalidateAllResolutionInformation();
         mapEntry.setValue(dartCopy);
         _workManager.add(source, SourcePriority.UNKNOWN);
       }
     }
   }
 
   /**
    * In response to a change to Angular entry point [HtmlElement], invalidate any results that
    * depend on it.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * <b>Note:</b> Any cache entries that were accessed before this method was invoked must be
    * re-accessed after this method returns.
    *
    * @param entryCopy the [HtmlEntryImpl] of the (maybe) Angular entry point being invalidated
    */
-  void invalidateAngularResolution(HtmlEntryImpl entryCopy) {
+  void _invalidateAngularResolution(HtmlEntryImpl entryCopy) {
     AngularApplication application = entryCopy.getValue(HtmlEntry.ANGULAR_ENTRY);
     if (application == null) {
       return;
     }
     _angularApplications.remove(application);
     // invalidate Entry
     entryCopy.setState(HtmlEntry.ANGULAR_ENTRY, CacheState.INVALID);
     // reset HTML sources
     List<AngularElement> oldAngularElements = application.elements;
     for (AngularElement angularElement in oldAngularElements) {
       if (angularElement is AngularHasTemplateElement) {
         AngularHasTemplateElement hasTemplate = angularElement;
         Source templateSource = hasTemplate.templateSource;
         if (templateSource != null) {
-          HtmlEntry htmlEntry = getReadableHtmlEntry(templateSource);
+          HtmlEntry htmlEntry = _getReadableHtmlEntry(templateSource);
           HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
           htmlCopy.setValue(HtmlEntry.ANGULAR_APPLICATION, null);
           htmlCopy.setValue(HtmlEntry.ANGULAR_COMPONENT, null);
           htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
           _cache.put(templateSource, htmlCopy);
           _workManager.add(templateSource, SourcePriority.HTML);
         }
       }
     }
     // reset Dart sources
     List<Source> oldElementSources = application.elementSources;
     for (Source elementSource in oldElementSources) {
-      DartEntry dartEntry = getReadableDartEntry(elementSource);
+      DartEntry dartEntry = _getReadableDartEntry(elementSource);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       dartCopy.setValue(DartEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
       _cache.put(elementSource, dartCopy);
       // notify about (disappeared) Angular errors
-      ChangeNoticeImpl notice = getNotice(elementSource);
+      ChangeNoticeImpl notice = _getNotice(elementSource);
       notice.setErrors(dartCopy.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
     }
   }
 
   /**
    * In response to a change to at least one of the compilation units in the given library,
    * invalidate any results that are dependent on the result of resolving that library.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * <b>Note:</b> Any cache entries that were accessed before this method was invoked must be
    * re-accessed after this method returns.
    *
    * @param librarySource the source of the library being invalidated
    * @param writer the writer to which debugging information should be written
    */
-  void invalidateLibraryResolution(Source librarySource, PrintStringWriter writer) {
+  void _invalidateLibraryResolution(Source librarySource, PrintStringWriter writer) {
     // TODO(brianwilkerson) This could be optimized. There's no need to flush all of these caches if
     // the public namespace hasn't changed, which will be a fairly common case. The question is
     // whether we can afford the time to compute the namespace to look for differences.
-    DartEntry libraryEntry = getReadableDartEntry(librarySource);
+    DartEntry libraryEntry = _getReadableDartEntry(librarySource);
     if (libraryEntry != null) {
       List<Source> includedParts = libraryEntry.getValue(DartEntry.INCLUDED_PARTS);
       DartEntryImpl libraryCopy = libraryEntry.writableCopy;
       int oldTime = libraryCopy.modificationTime;
       libraryCopy.invalidateAllResolutionInformation();
       _cache.put(librarySource, libraryCopy);
       _workManager.add(librarySource, SourcePriority.LIBRARY);
       if (writer != null) {
-        writer.println("  Invalidated library source: ${debuggingString(librarySource)} (previously modified at ${oldTime})");
+        writer.println("  Invalidated library source: ${_debuggingString(librarySource)} (previously modified at ${oldTime})");
       }
       for (Source partSource in includedParts) {
         SourceEntry partEntry = _cache.get(partSource);
         if (partEntry is DartEntry) {
           DartEntryImpl partCopy = partEntry.writableCopy;
           oldTime = partCopy.modificationTime;
           if (partEntry != libraryCopy) {
             partCopy.removeContainingLibrary(librarySource);
             _workManager.add(librarySource, SourcePriority.NORMAL_PART);
           }
           partCopy.invalidateAllResolutionInformation();
           _cache.put(partSource, partCopy);
           if (writer != null) {
-            writer.println("  Invalidated part source: ${debuggingString(partSource)} (previously modified at ${oldTime})");
+            writer.println("  Invalidated part source: ${_debuggingString(partSource)} (previously modified at ${oldTime})");
           }
         }
       }
     }
     // invalidate Angular applications
     List<AngularApplication> angularApplicationsCopy = [];
     for (AngularApplication application in angularApplicationsCopy) {
       if (application.dependsOn(librarySource)) {
         Source entryPointSource = application.entryPoint;
-        HtmlEntry entry = getReadableHtmlEntry(entryPointSource);
+        HtmlEntry entry = _getReadableHtmlEntry(entryPointSource);
         HtmlEntryImpl entryCopy = entry.writableCopy;
-        invalidateAngularResolution(entryCopy);
+        _invalidateAngularResolution(entryCopy);
         _cache.put(entryPointSource, entryCopy);
         _workManager.add(entryPointSource, SourcePriority.HTML);
       }
     }
   }
 
   /**
    * Return `true` if this library is, or depends on, dart:html.
    *
    * @param library the library being tested
    * @param visitedLibraries a collection of the libraries that have been visited, used to prevent
    *          infinite recursion
    * @return `true` if this library is, or depends on, dart:html
    */
-  bool isClient(LibraryElement library, Source htmlSource, Set<LibraryElement> visitedLibraries) {
+  bool _isClient(LibraryElement library, Source htmlSource, Set<LibraryElement> visitedLibraries) {
     if (visitedLibraries.contains(library)) {
       return false;
     }
     if (library.source == htmlSource) {
       return true;
     }
     visitedLibraries.add(library);
     for (LibraryElement imported in library.importedLibraries) {
-      if (isClient(imported, htmlSource, visitedLibraries)) {
+      if (_isClient(imported, htmlSource, visitedLibraries)) {
         return true;
       }
     }
     for (LibraryElement exported in library.exportedLibraries) {
-      if (isClient(exported, htmlSource, visitedLibraries)) {
+      if (_isClient(exported, htmlSource, visitedLibraries)) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Log the given debugging information.
    *
    * @param message the message to be added to the log
    */
-  void logInformation(String message) {
+  void _logInformation(String message) {
     AnalysisEngine.instance.logger.logInformation(message);
   }
 
   /**
    * Log the given debugging information.
    *
    * @param message the message to be added to the log
    * @param exception the exception to be included in the log entry
    */
-  void logInformation2(String message, Exception exception) {
+  void _logInformation2(String message, Exception exception) {
     if (exception == null) {
       AnalysisEngine.instance.logger.logInformation(message);
     } else {
-      AnalysisEngine.instance.logger.logInformation3(message, exception);
+      AnalysisEngine.instance.logger.logInformation2(message, exception);
     }
   }
 
   /**
    * Updates [HtmlEntry]s that correspond to the previously known and new Angular application
    * information.
    */
-  void recordAngularEntryPoint(HtmlEntryImpl entry, ResolveAngularEntryHtmlTask task) {
+  void _recordAngularEntryPoint(HtmlEntryImpl entry, ResolveAngularEntryHtmlTask task) {
     AngularApplication application = task.application;
     if (application != null) {
       _angularApplications.add(application);
       // if this is an entry point, then we already resolved it
       entry.setValue(HtmlEntry.ANGULAR_ERRORS, task.entryErrors);
       // schedule HTML templates analysis
       List<AngularElement> newAngularElements = application.elements;
       for (AngularElement angularElement in newAngularElements) {
         if (angularElement is AngularHasTemplateElement) {
           AngularHasTemplateElement hasTemplate = angularElement;
           Source templateSource = hasTemplate.templateSource;
           if (templateSource != null) {
-            HtmlEntry htmlEntry = getReadableHtmlEntry(templateSource);
+            HtmlEntry htmlEntry = _getReadableHtmlEntry(templateSource);
             HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
             htmlCopy.setValue(HtmlEntry.ANGULAR_APPLICATION, application);
             if (hasTemplate is AngularComponentElement) {
               AngularComponentElement component = hasTemplate;
               htmlCopy.setValue(HtmlEntry.ANGULAR_COMPONENT, component);
             }
             htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
             _cache.put(templateSource, htmlCopy);
             _workManager.add(templateSource, SourcePriority.HTML);
           }
         }
       }
       // update Dart sources errors
       List<Source> newElementSources = application.elementSources;
       for (Source elementSource in newElementSources) {
-        DartEntry dartEntry = getReadableDartEntry(elementSource);
+        DartEntry dartEntry = _getReadableDartEntry(elementSource);
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         dartCopy.setValue(DartEntry.ANGULAR_ERRORS, task.getErrors(elementSource));
         _cache.put(elementSource, dartCopy);
         // notify about Dart errors
-        ChangeNoticeImpl notice = getNotice(elementSource);
+        ChangeNoticeImpl notice = _getNotice(elementSource);
         notice.setErrors(dartCopy.allErrors, computeLineInfo(elementSource));
       }
     }
     // remember Angular entry point
     entry.setValue(HtmlEntry.ANGULAR_ENTRY, application);
   }
 
   /**
    * Given a cache entry and a library element, record the library element and other information
    * gleaned from the element in the cache entry.
    *
    * @param dartEntry the original cache entry from which the copy was made
    * @param dartCopy the cache entry in which data is to be recorded
    * @param library the library element used to record information
    * @param librarySource the source for the library used to record information
    * @param htmlSource the source for the HTML library
    */
-  void recordElementData(DartEntry dartEntry, DartEntryImpl dartCopy, LibraryElement library, Source librarySource, Source htmlSource) {
+  void _recordElementData(DartEntry dartEntry, DartEntryImpl dartCopy, LibraryElement library, Source librarySource, Source htmlSource) {
     dartCopy.setValue(DartEntry.ELEMENT, library);
     dartCopy.setValue(DartEntry.IS_LAUNCHABLE, library.entryPoint != null);
-    dartCopy.setValue(DartEntry.IS_CLIENT, isClient(library, htmlSource, new Set<LibraryElement>()));
+    dartCopy.setValue(DartEntry.IS_CLIENT, _isClient(library, htmlSource, new Set<LibraryElement>()));
     // TODO(brianwilkerson) Understand why we're doing this both here and in
     // ResolveDartDependenciesTask and whether we should also be capturing the imported and exported
     // sources here.
-    removeFromParts(librarySource, dartEntry);
+    _removeFromParts(librarySource, dartEntry);
     List<CompilationUnitElement> parts = library.parts;
     int count = parts.length;
     List<Source> unitSources = new List<Source>(count + 1);
     unitSources[0] = library.definingCompilationUnit.source;
     for (int i = 0; i < count; i++) {
       Source unitSource = parts[i].source;
       unitSources[i + 1] = unitSource;
-      DartEntry unitEntry = getReadableDartEntry(unitSource);
+      DartEntry unitEntry = _getReadableDartEntry(unitSource);
       if (unitSource != null) {
         DartEntryImpl unitCopy = unitEntry.writableCopy;
         unitCopy.addContainingLibrary(librarySource);
         _cache.put(unitSource, unitCopy);
       }
     }
     dartCopy.setValue(DartEntry.INCLUDED_PARTS, unitSources);
   }
 
   /**
    * Record the results produced by performing a [GenerateDartErrorsTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
-  DartEntry recordGenerateDartErrorsTask(GenerateDartErrorsTask task) {
+  DartEntry _recordGenerateDartErrorsTask(GenerateDartErrorsTask task) {
     Source source = task.source;
     Source librarySource = task.libraryElement.source;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! DartEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent a Dart file, but check to be safe.
       throw new AnalysisException.con1("Internal error: attempting to verify non-Dart file as a Dart file: ${source.fullName}");
     }
     dartEntry = sourceEntry as DartEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (dartEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
-        sourceChanged(source);
-        dartEntry = getReadableDartEntry(source);
+        _sourceChanged(source);
+        dartEntry = _getReadableDartEntry(source);
         if (dartEntry == null) {
           throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
         }
       }
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
         dartCopy.setValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, task.errors);
-        ChangeNoticeImpl notice = getNotice(source);
+        ChangeNoticeImpl notice = _getNotice(source);
         notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
       } else {
         dartCopy.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.ERROR);
       }
       dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
       dartEntry = dartCopy;
     } else {
-      logInformation2("Generated errors discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
+      _logInformation2("Generated errors discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null || resultTime >= 0) {
         //
         // The analysis was performed on out-of-date sources. Mark the cache so that the source
         // will be re-verified using the up-to-date sources.
         //
         //          dartCopy.setState(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.INVALID);
-        removeFromParts(source, dartEntry);
+        _removeFromParts(source, dartEntry);
         dartCopy.invalidateAllInformation();
         dartCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
         _workManager.add(source, SourcePriority.UNKNOWN);
       } else {
         //
         // We could not determine whether the sources were up-to-date or out-of-date. Mark the
         // cache so that we won't attempt to re-verify the source until there's a good chance
         // that we'll be able to do so without error.
         //
@@ skipping 10 matching lines @@
   }
 
   /**
    * Record the results produced by performing a [GenerateDartHintsTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
-  DartEntry recordGenerateDartHintsTask(GenerateDartHintsTask task) {
+  DartEntry _recordGenerateDartHintsTask(GenerateDartHintsTask task) {
     Source librarySource = task.libraryElement.source;
     AnalysisException thrownException = task.exception;
     DartEntry libraryEntry = null;
     Map<Source, TimestampedData<List<AnalysisError>>> hintMap = task.hintMap;
     if (hintMap == null) {
       // We don't have any information about which sources to mark as invalid other than the library
       // source.
       SourceEntry sourceEntry = _cache.get(librarySource);
       if (sourceEntry == null) {
         throw new ObsoleteSourceAnalysisException(librarySource);
@@ skipping 22 matching lines @@
       }
       DartEntry dartEntry = sourceEntry as DartEntry;
       if (unitSource == librarySource) {
         libraryEntry = dartEntry;
       }
       int sourceTime = getModificationStamp(unitSource);
       int resultTime = results.modificationTime;
       if (sourceTime == resultTime) {
         if (dartEntry.modificationTime != sourceTime) {
           // The source has changed without the context being notified. Simulate notification.
-          sourceChanged(unitSource);
-          dartEntry = getReadableDartEntry(unitSource);
+          _sourceChanged(unitSource);
+          dartEntry = _getReadableDartEntry(unitSource);
           if (dartEntry == null) {
             throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
           }
         }
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         if (thrownException == null) {
           dartCopy.setValueInLibrary(DartEntry.HINTS, librarySource, results.data);
-          ChangeNoticeImpl notice = getNotice(unitSource);
+          ChangeNoticeImpl notice = _getNotice(unitSource);
           notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
         } else {
           dartCopy.setStateInLibrary(DartEntry.HINTS, librarySource, CacheState.ERROR);
         }
         dartCopy.exception = thrownException;
         _cache.put(unitSource, dartCopy);
         dartEntry = dartCopy;
       } else {
-        logInformation2("Generated hints discarded for ${debuggingString(unitSource)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
+        _logInformation2("Generated hints discarded for ${_debuggingString(unitSource)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
         if (identical(dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource), CacheState.IN_PROCESS)) {
           DartEntryImpl dartCopy = dartEntry.writableCopy;
           if (thrownException == null || resultTime >= 0) {
             //
             // The analysis was performed on out-of-date sources. Mark the cache so that the sources
             // will be re-analyzed using the up-to-date sources.
             //
             //              dartCopy.setState(DartEntry.HINTS, librarySource, CacheState.INVALID);
-            removeFromParts(unitSource, dartEntry);
+            _removeFromParts(unitSource, dartEntry);
             dartCopy.invalidateAllInformation();
             dartCopy.modificationTime = sourceTime;
             _cache.removedAst(unitSource);
             _workManager.add(unitSource, SourcePriority.UNKNOWN);
           } else {
             //
             // We could not determine whether the sources were up-to-date or out-of-date. Mark the
             // cache so that we won't attempt to re-analyze the sources until there's a good chance
             // that we'll be able to do so without error.
             //
@@ skipping 11 matching lines @@
     return libraryEntry;
   }
 
   /**
    * Record the results produced by performing a [GetContentTask].
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
-  SourceEntry recordGetContentsTask(GetContentTask task) {
+  SourceEntry _recordGetContentsTask(GetContentTask task) {
     if (!task.isComplete) {
       return null;
     }
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     SourceEntry sourceEntry = null;
     sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     }
@@ skipping 14 matching lines @@
     return sourceEntry;
   }
 
   /**
    * Record the results produced by performing a [IncrementalAnalysisTask].
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
-  DartEntry recordIncrementalAnalysisTaskResults(IncrementalAnalysisTask task) {
+  DartEntry _recordIncrementalAnalysisTaskResults(IncrementalAnalysisTask task) {
     CompilationUnit unit = task.compilationUnit;
     if (unit != null) {
-      ChangeNoticeImpl notice = getNotice(task.source);
+      ChangeNoticeImpl notice = _getNotice(task.source);
       notice.compilationUnit = unit;
       _incrementalAnalysisCache = IncrementalAnalysisCache.cacheResult(task.cache, unit);
     }
     return null;
   }
 
   /**
    * Record the results produced by performing a [ParseDartTask]. If the results were computed
    * from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
-  DartEntry recordParseDartTaskResults(ParseDartTask task) {
+  DartEntry _recordParseDartTaskResults(ParseDartTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! DartEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent a Dart file, but check to be safe.
       throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${source.fullName}");
     }
     dartEntry = sourceEntry as DartEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (dartEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
-        sourceChanged(source);
-        dartEntry = getReadableDartEntry(source);
+        _sourceChanged(source);
+        dartEntry = _getReadableDartEntry(source);
         if (dartEntry == null) {
           throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
         }
       }
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
         if (task.hasPartOfDirective && !task.hasLibraryDirective) {
           dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
           dartCopy.removeContainingLibrary(source);
           _workManager.add(source, SourcePriority.NORMAL_PART);
         } else {
           dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
           dartCopy.containingLibrary = source;
           _workManager.add(source, SourcePriority.LIBRARY);
         }
         dartCopy.setValue(DartEntry.PARSED_UNIT, task.compilationUnit);
         dartCopy.setValue(DartEntry.PARSE_ERRORS, task.errors);
         _cache.storedAst(source);
-        ChangeNoticeImpl notice = getNotice(source);
+        ChangeNoticeImpl notice = _getNotice(source);
         notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
         // Verify that the incrementally parsed and resolved unit in the incremental cache
         // is structurally equivalent to the fully parsed unit
         _incrementalAnalysisCache = IncrementalAnalysisCache.verifyStructure(_incrementalAnalysisCache, source, task.compilationUnit);
       } else {
-        removeFromParts(source, dartEntry);
+        _removeFromParts(source, dartEntry);
         dartCopy.recordParseError();
         _cache.removedAst(source);
       }
       dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
       dartEntry = dartCopy;
     } else {
-      logInformation2("Parse results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
+      _logInformation2("Parse results discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null || resultTime >= 0) {
         //
         // The analysis was performed on out-of-date sources. Mark the cache so that the sources
         // will be re-analyzed using the up-to-date sources.
         //
         //          dartCopy.recordParseNotInProcess();
-        removeFromParts(source, dartEntry);
+        _removeFromParts(source, dartEntry);
         dartCopy.invalidateAllInformation();
         dartCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
         _workManager.add(source, SourcePriority.UNKNOWN);
       } else {
         //
         // We could not determine whether the sources were up-to-date or out-of-date. Mark the
         // cache so that we won't attempt to re-analyze the sources until there's a good chance
         // that we'll be able to do so without error.
         //
@@ skipping 10 matching lines @@
   }
 
   /**
    * Record the results produced by performing a [ParseHtmlTask]. If the results were computed
    * from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
-  HtmlEntry recordParseHtmlTaskResults(ParseHtmlTask task) {
+  HtmlEntry _recordParseHtmlTaskResults(ParseHtmlTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! HtmlEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent an HTML file, but check to be safe.
       throw new AnalysisException.con1("Internal error: attempting to parse non-HTML file as a HTML file: ${source.fullName}");
     }
     htmlEntry = sourceEntry as HtmlEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (htmlEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
-        sourceChanged(source);
-        htmlEntry = getReadableHtmlEntry(source);
+        _sourceChanged(source);
+        htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
           throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
       if (thrownException == null) {
         LineInfo lineInfo = task.lineInfo;
         ht.HtmlUnit unit = task.htmlUnit;
         htmlCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
         htmlCopy.setValue(HtmlEntry.PARSED_UNIT, unit);
         htmlCopy.setValue(HtmlEntry.PARSE_ERRORS, task.errors);
         htmlCopy.setValue(HtmlEntry.REFERENCED_LIBRARIES, task.referencedLibraries);
         _cache.storedAst(source);
-        ChangeNoticeImpl notice = getNotice(source);
+        ChangeNoticeImpl notice = _getNotice(source);
         notice.setErrors(htmlCopy.allErrors, lineInfo);
       } else {
         htmlCopy.recordParseError();
         _cache.removedAst(source);
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
-      logInformation2("Parse results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
+      _logInformation2("Parse results discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
       HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
       if (thrownException == null || resultTime >= 0) {
         //
         // The analysis was performed on out-of-date sources. Mark the cache so that the sources
         // will be re-analyzed using the up-to-date sources.
         //
         //          if (htmlCopy.getState(SourceEntry.LINE_INFO) == CacheState.IN_PROCESS) {
         //            htmlCopy.setState(SourceEntry.LINE_INFO, CacheState.INVALID);
         //          }
         //          if (htmlCopy.getState(HtmlEntry.PARSED_UNIT) == CacheState.IN_PROCESS) {
@@ skipping 26 matching lines @@
     return htmlEntry;
   }
 
   /**
    * Record the results produced by performing a [ResolveAngularComponentTemplateTask]. If the
    * results were computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @throws AnalysisException if the results could not be recorded
    */
-  HtmlEntry recordResolveAngularComponentTemplateTaskResults(ResolveAngularComponentTemplateTask task) {
+  HtmlEntry _recordResolveAngularComponentTemplateTaskResults(ResolveAngularComponentTemplateTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! HtmlEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent an HTML file, but check to be safe.
       throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
     htmlEntry = sourceEntry as HtmlEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (htmlEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
-        sourceChanged(source);
-        htmlEntry = getReadableHtmlEntry(source);
+        _sourceChanged(source);
+        htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
           throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
         htmlCopy.setValue(HtmlEntry.ANGULAR_ERRORS, task.resolutionErrors);
         // notify about errors
-        ChangeNoticeImpl notice = getNotice(source);
+        ChangeNoticeImpl notice = _getNotice(source);
         notice.htmlUnit = task.resolvedUnit;
         notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       } else {
         htmlCopy.recordResolutionError();
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
@@ skipping 32 matching lines @@
     return htmlEntry;
   }
 
   /**
    * Record the results produced by performing a [ResolveAngularEntryHtmlTask]. If the results
    * were computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @throws AnalysisException if the results could not be recorded
    */
-  HtmlEntry recordResolveAngularEntryHtmlTaskResults(ResolveAngularEntryHtmlTask task) {
+  HtmlEntry _recordResolveAngularEntryHtmlTaskResults(ResolveAngularEntryHtmlTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! HtmlEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent an HTML file, but check to be safe.
       throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
     htmlEntry = sourceEntry as HtmlEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (htmlEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
-        sourceChanged(source);
-        htmlEntry = getReadableHtmlEntry(source);
+        _sourceChanged(source);
+        htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
           throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
         htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
-        recordAngularEntryPoint(htmlCopy, task);
+        _recordAngularEntryPoint(htmlCopy, task);
         _cache.storedAst(source);
-        ChangeNoticeImpl notice = getNotice(source);
+        ChangeNoticeImpl notice = _getNotice(source);
         notice.htmlUnit = task.resolvedUnit;
         notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       } else {
         htmlCopy.recordResolutionError();
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
@@ skipping 33 matching lines @@
   }
 
   /**
    * Record the results produced by performing a [ResolveDartDependenciesTask]. If the results
    * were computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
-  DartEntry recordResolveDartDependenciesTaskResults(ResolveDartDependenciesTask task) {
+  DartEntry _recordResolveDartDependenciesTaskResults(ResolveDartDependenciesTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! DartEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent a Dart file, but check to be safe.
       throw new AnalysisException.con1("Internal error: attempting to resolve Dart dependencies in a non-Dart file: ${source.fullName}");
     }
     dartEntry = sourceEntry as DartEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (dartEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
-        sourceChanged(source);
-        dartEntry = getReadableDartEntry(source);
+        _sourceChanged(source);
+        dartEntry = _getReadableDartEntry(source);
         if (dartEntry == null) {
           throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
         }
       }
-      removeFromParts(source, dartEntry);
+      _removeFromParts(source, dartEntry);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
         List<Source> newParts = task.includedSources;
         for (int i = 0; i < newParts.length; i++) {
           Source partSource = newParts[i];
-          DartEntry partEntry = getReadableDartEntry(partSource);
+          DartEntry partEntry = _getReadableDartEntry(partSource);
           if (partEntry != null && partEntry != dartEntry) {
             DartEntryImpl partCopy = partEntry.writableCopy;
             partCopy.addContainingLibrary(source);
             _cache.put(partSource, partCopy);
           }
         }
         dartCopy.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources);
         dartCopy.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
         dartCopy.setValue(DartEntry.INCLUDED_PARTS, newParts);
       } else {
         dartCopy.recordDependencyError();
       }
       dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
       dartEntry = dartCopy;
     } else {
-      logInformation2("Dependency resolution results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
+      _logInformation2("Dependency resolution results discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null || resultTime >= 0) {
         //
         // The analysis was performed on out-of-date sources. Mark the cache so that the sources
         // will be re-analyzed using the up-to-date sources.
         //
         //          dartCopy.recordDependencyNotInProcess();
-        removeFromParts(source, dartEntry);
+        _removeFromParts(source, dartEntry);
         dartCopy.invalidateAllInformation();
         dartCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
         _workManager.add(source, SourcePriority.UNKNOWN);
       } else {
         //
         // We could not determine whether the sources were up-to-date or out-of-date. Mark the
         // cache so that we won't attempt to re-analyze the sources until there's a good chance
         // that we'll be able to do so without error.
         //
@@ skipping 12 matching lines @@
   }
 
   /**
    * Record the results produced by performing a [ResolveDartUnitTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
-  DartEntry recordResolveDartUnitTaskResults(ResolveDartUnitTask task) {
+  DartEntry _recordResolveDartUnitTaskResults(ResolveDartUnitTask task) {
     Source unitSource = task.source;
     Source librarySource = task.librarySource;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
     SourceEntry sourceEntry = _cache.get(unitSource);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(unitSource);
     } else if (sourceEntry is! DartEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent a Dart file, but check to be safe.
       throw new AnalysisException.con1("Internal error: attempting to resolve non-Dart file as a Dart file: ${unitSource.fullName}");
     }
     dartEntry = sourceEntry as DartEntry;
     int sourceTime = getModificationStamp(unitSource);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (dartEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
-        sourceChanged(unitSource);
-        dartEntry = getReadableDartEntry(unitSource);
+        _sourceChanged(unitSource);
+        dartEntry = _getReadableDartEntry(unitSource);
         if (dartEntry == null) {
           throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
         }
       }
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
         dartCopy.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, task.resolvedUnit);
         _cache.storedAst(unitSource);
       } else {
         dartCopy.setStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource, CacheState.ERROR);
         _cache.removedAst(unitSource);
       }
       dartCopy.exception = thrownException;
       _cache.put(unitSource, dartCopy);
       dartEntry = dartCopy;
     } else {
-      logInformation2("Resolution results discarded for ${debuggingString(unitSource)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
+      _logInformation2("Resolution results discarded for ${_debuggingString(unitSource)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null || resultTime >= 0) {
         //
         // The analysis was performed on out-of-date sources. Mark the cache so that the sources
         // will be re-analyzed using the up-to-date sources.
         //
         //          if (dartCopy.getState(DartEntry.RESOLVED_UNIT) == CacheState.IN_PROCESS) {
         //            dartCopy.setState(DartEntry.RESOLVED_UNIT, librarySource, CacheState.INVALID);
         //          }
-        removeFromParts(unitSource, dartEntry);
+        _removeFromParts(unitSource, dartEntry);
         dartCopy.invalidateAllInformation();
         dartCopy.modificationTime = sourceTime;
         _cache.removedAst(unitSource);
         _workManager.add(unitSource, SourcePriority.UNKNOWN);
       } else {
         //
         // We could not determine whether the sources were up-to-date or out-of-date. Mark the
         // cache so that we won't attempt to re-analyze the sources until there's a good chance
         // that we'll be able to do so without error.
         //
@@ skipping 10 matching lines @@
   }
 
   /**
    * Record the results produced by performing a [ResolveHtmlTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
-  HtmlEntry recordResolveHtmlTaskResults(ResolveHtmlTask task) {
+  HtmlEntry _recordResolveHtmlTaskResults(ResolveHtmlTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! HtmlEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent an HTML file, but check to be safe.
       throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
     htmlEntry = sourceEntry as HtmlEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (htmlEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
-        sourceChanged(source);
-        htmlEntry = getReadableHtmlEntry(source);
+        _sourceChanged(source);
+        htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
           throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
         htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED);
         htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
         htmlCopy.setValue(HtmlEntry.ELEMENT, task.element);
         htmlCopy.setValue(HtmlEntry.RESOLUTION_ERRORS, task.resolutionErrors);
         _cache.storedAst(source);
-        ChangeNoticeImpl notice = getNotice(source);
+        ChangeNoticeImpl notice = _getNotice(source);
         notice.htmlUnit = task.resolvedUnit;
         notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       } else {
         htmlCopy.recordResolutionError();
         _cache.removedAst(source);
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
-      logInformation2("Resolution results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
+      _logInformation2("Resolution results discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null || resultTime >= 0) {
         //
         // The analysis was performed on out-of-date sources. Mark the cache so that the sources
         // will be re-analyzed using the up-to-date sources.
         //
         //          if (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
         //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
         //          }
         //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
@@ skipping 21 matching lines @@
   }
 
   /**
    * Record the results produced by performing a [ScanDartTask]. If the results were computed
    * from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
-  DartEntry recordScanDartTaskResults(ScanDartTask task) {
+  DartEntry _recordScanDartTaskResults(ScanDartTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! DartEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent a Dart file, but check to be safe.
       throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${source.fullName}");
     }
     dartEntry = sourceEntry as DartEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (dartEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
-        sourceChanged(source);
-        dartEntry = getReadableDartEntry(source);
+        _sourceChanged(source);
+        dartEntry = _getReadableDartEntry(source);
         if (dartEntry == null) {
           throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
         }
       }
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
         LineInfo lineInfo = task.lineInfo;
         dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
         dartCopy.setValue(DartEntry.TOKEN_STREAM, task.tokenStream);
         dartCopy.setValue(DartEntry.SCAN_ERRORS, task.errors);
         _cache.storedAst(source);
         _workManager.add(source, SourcePriority.NORMAL_PART);
-        ChangeNoticeImpl notice = getNotice(source);
+        ChangeNoticeImpl notice = _getNotice(source);
         notice.setErrors(dartEntry.allErrors, lineInfo);
       } else {
-        removeFromParts(source, dartEntry);
+        _removeFromParts(source, dartEntry);
         dartCopy.recordScanError();
         _cache.removedAst(source);
       }
       dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
       dartEntry = dartCopy;
     } else {
-      logInformation2("Scan results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
+      _logInformation2("Scan results discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null || resultTime >= 0) {
         //
         // The analysis was performed on out-of-date sources. Mark the cache so that the sources
         // will be re-analyzed using the up-to-date sources.
         //
         //          dartCopy.recordScanNotInProcess();
-        removeFromParts(source, dartEntry);
+        _removeFromParts(source, dartEntry);
         dartCopy.invalidateAllInformation();
         dartCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
         _workManager.add(source, SourcePriority.UNKNOWN);
       } else {
         //
         // We could not determine whether the sources were up-to-date or out-of-date. Mark the
         // cache so that we won't attempt to re-analyze the sources until there's a good chance
         // that we'll be able to do so without error.
         //
@@ skipping 11 matching lines @@
 
   /**
    * Remove the given library from the list of containing libraries for all of the parts referenced
    * by the given entry.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param librarySource the library to be removed
    * @param dartEntry the entry containing the list of included parts
    */
-  void removeFromParts(Source librarySource, DartEntry dartEntry) {
+  void _removeFromParts(Source librarySource, DartEntry dartEntry) {
     List<Source> oldParts = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
     for (int i = 0; i < oldParts.length; i++) {
       Source partSource = oldParts[i];
-      DartEntry partEntry = getReadableDartEntry(partSource);
+      DartEntry partEntry = _getReadableDartEntry(partSource);
       if (partEntry != null && partEntry != dartEntry) {
         DartEntryImpl partCopy = partEntry.writableCopy;
         partCopy.removeContainingLibrary(librarySource);
         if (partCopy.librariesContaining.length == 0 && !exists(partSource)) {
           _cache.remove(partSource);
         } else {
           _cache.put(partSource, partCopy);
         }
       }
     }
   }
 
   /**
    * Remove the given source from the priority order if it is in the list.
    *
    * @param source the source to be removed
    */
-  void removeFromPriorityOrder(Source source) {
+  void _removeFromPriorityOrder(Source source) {
     int count = _priorityOrder.length;
     List<Source> newOrder = new List<Source>();
     for (int i = 0; i < count; i++) {
       if (_priorityOrder[i] != source) {
         newOrder.add(_priorityOrder[i]);
       }
     }
     if (newOrder.length < count) {
       analysisPriorityOrder = newOrder;
     }
   }
 
   /**
    * Create an entry for the newly added source. Return `true` if the new source is a Dart
    * file.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been added
    * @return `true` if the new source is a Dart file
    */
-  bool sourceAvailable(Source source) {
+  bool _sourceAvailable(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
-      sourceEntry = createSourceEntry(source);
-      logInformation("Added new source: ${debuggingString(source)}");
+      sourceEntry = _createSourceEntry(source);
+      _logInformation("Added new source: ${_debuggingString(source)}");
     } else {
       SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
       int oldTime = sourceCopy.modificationTime;
       sourceCopy.modificationTime = getModificationStamp(source);
       // TODO(brianwilkerson) Understand why we're not invalidating the cache.
       _cache.put(source, sourceCopy);
-      logInformation("Added new source: ${debuggingString(source)} (previously modified at ${oldTime})");
+      _logInformation("Added new source: ${_debuggingString(source)} (previously modified at ${oldTime})");
     }
     if (sourceEntry is HtmlEntry) {
       _workManager.add(source, SourcePriority.HTML);
     } else {
       _workManager.add(source, SourcePriority.UNKNOWN);
     }
     return sourceEntry is DartEntry;
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been changed
    */
-  void sourceChanged(Source source) {
+  void _sourceChanged(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null || sourceEntry.modificationTime == getModificationStamp(source)) {
       // Either we have removed this source, in which case we don't care that it is changed, or we
       // have already invalidated the cache and don't need to invalidate it again.
       if (sourceEntry == null) {
-        logInformation("Modified source, but there is no entry: ${debuggingString(source)}");
+        _logInformation("Modified source, but there is no entry: ${_debuggingString(source)}");
       } else {
-        logInformation("Modified source, but modification time matches: ${debuggingString(source)}");
+        _logInformation("Modified source, but modification time matches: ${_debuggingString(source)}");
       }
       return;
     }
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
       int oldTime = htmlCopy.modificationTime;
       htmlCopy.modificationTime = getModificationStamp(source);
-      invalidateAngularResolution(htmlCopy);
+      _invalidateAngularResolution(htmlCopy);
       htmlCopy.invalidateAllInformation();
       _cache.put(source, htmlCopy);
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.HTML);
-      logInformation("Modified HTML source: ${debuggingString(source)} (previously modified at ${oldTime})");
+      _logInformation("Modified HTML source: ${_debuggingString(source)} (previously modified at ${oldTime})");
     } else if (sourceEntry is DartEntry) {
       List<Source> containingLibraries = getLibrariesContaining(source);
       Set<Source> librariesToInvalidate = new Set<Source>();
       for (Source containingLibrary in containingLibraries) {
         librariesToInvalidate.add(containingLibrary);
         for (Source dependentLibrary in getLibrariesDependingOn(containingLibrary)) {
           librariesToInvalidate.add(dependentLibrary);
         }
       }
       PrintStringWriter writer = new PrintStringWriter();
       int oldTime = sourceEntry.modificationTime;
-      writer.println("Modified Dart source: ${debuggingString(source)} (previously modified at ${oldTime})");
+      writer.println("Modified Dart source: ${_debuggingString(source)} (previously modified at ${oldTime})");
       for (Source library in librariesToInvalidate) {
         //    for (Source library : containingLibraries) {
-        invalidateLibraryResolution(library, writer);
+        _invalidateLibraryResolution(library, writer);
       }
-      removeFromParts(source, _cache.get(source) as DartEntry);
+      _removeFromParts(source, _cache.get(source) as DartEntry);
       DartEntryImpl dartCopy = (_cache.get(source) as DartEntry).writableCopy;
       dartCopy.modificationTime = getModificationStamp(source);
       dartCopy.invalidateAllInformation();
       _cache.put(source, dartCopy);
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.UNKNOWN);
-      logInformation(writer.toString());
+      _logInformation(writer.toString());
     }
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been deleted
    */
-  void sourceRemoved(Source source) {
+  void _sourceRemoved(Source source) {
     PrintStringWriter writer = new PrintStringWriter();
-    writer.println("Removed source: ${debuggingString(source)}");
+    writer.println("Removed source: ${_debuggingString(source)}");
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
-      invalidateAngularResolution(htmlCopy);
+      _invalidateAngularResolution(htmlCopy);
     } else if (sourceEntry is DartEntry) {
       Set<Source> libraries = new Set<Source>();
       for (Source librarySource in getLibrariesContaining(source)) {
         libraries.add(librarySource);
         for (Source dependentLibrary in getLibrariesDependingOn(librarySource)) {
           libraries.add(dependentLibrary);
         }
       }
       for (Source librarySource in libraries) {
-        invalidateLibraryResolution(librarySource, writer);
+        _invalidateLibraryResolution(librarySource, writer);
       }
     }
     _cache.remove(source);
     _workManager.remove(source);
-    removeFromPriorityOrder(source);
-    logInformation(writer.toString());
+    _removeFromPriorityOrder(source);
+    _logInformation(writer.toString());
   }
 
   /**
    * Check the cache for any invalid entries (entries whose modification time does not match the
    * modification time of the source associated with the entry). Invalid entries will be marked as
    * invalid so that the source will be re-analyzed.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @return `true` if at least one entry was invalid
    */
-  bool validateCacheConsistency() {
+  bool _validateCacheConsistency() {
     int consistencyCheckStart = JavaSystem.nanoTime();
     List<Source> missingSources = new List<Source>();
     int inconsistentCount = 0;
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       Source source = entry.getKey();
       SourceEntry sourceEntry = entry.getValue();
       int sourceTime = getModificationStamp(source);
       if (sourceTime != sourceEntry.modificationTime) {
-        sourceChanged(source);
+        _sourceChanged(source);
         inconsistentCount++;
       }
       if (sourceEntry.exception != null) {
         if (!exists(source)) {
           missingSources.add(source);
         }
       }
     }
     int consistencyCheckEnd = JavaSystem.nanoTime();
     PrintStringWriter writer = new PrintStringWriter();
     writer.print("Consistency check took ");
     writer.print((consistencyCheckEnd - consistencyCheckStart) / 1000000.0);
     writer.println(" ms and found");
     writer.print("  ");
     writer.print(inconsistentCount);
     writer.println(" inconsistent entries");
     writer.print("  ");
     writer.print(missingSources.length);
     writer.println(" missing sources");
     for (Source source in missingSources) {
       writer.print("    ");
       writer.println(source.fullName);
     }
-    logInformation(writer.toString());
+    _logInformation(writer.toString());
     return inconsistentCount > 0;
   }
 }
 
 /**
  * Instances of the class `AnalysisTaskResultRecorder` are used by an analysis context to
  * record the results of a task.
  */
 class AnalysisContextImpl_AnalysisTaskResultRecorder implements AnalysisTaskVisitor<SourceEntry> {
   final AnalysisContextImpl AnalysisContextImpl_this;
 
   AnalysisContextImpl_AnalysisTaskResultRecorder(this.AnalysisContextImpl_this);
 
-  DartEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task) => AnalysisContextImpl_this.recordGenerateDartErrorsTask(task);
+  DartEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task) => AnalysisContextImpl_this._recordGenerateDartErrorsTask(task);
 
-  DartEntry visitGenerateDartHintsTask(GenerateDartHintsTask task) => AnalysisContextImpl_this.recordGenerateDartHintsTask(task);
+  DartEntry visitGenerateDartHintsTask(GenerateDartHintsTask task) => AnalysisContextImpl_this._recordGenerateDartHintsTask(task);
 
-  SourceEntry visitGetContentTask(GetContentTask task) => AnalysisContextImpl_this.recordGetContentsTask(task);
+  SourceEntry visitGetContentTask(GetContentTask task) => AnalysisContextImpl_this._recordGetContentsTask(task);
 
-  DartEntry visitIncrementalAnalysisTask(IncrementalAnalysisTask task) => AnalysisContextImpl_this.recordIncrementalAnalysisTaskResults(task);
+  DartEntry visitIncrementalAnalysisTask(IncrementalAnalysisTask task) => AnalysisContextImpl_this._recordIncrementalAnalysisTaskResults(task);
 
-  DartEntry visitParseDartTask(ParseDartTask task) => AnalysisContextImpl_this.recordParseDartTaskResults(task);
+  DartEntry visitParseDartTask(ParseDartTask task) => AnalysisContextImpl_this._recordParseDartTaskResults(task);
 
-  HtmlEntry visitParseHtmlTask(ParseHtmlTask task) => AnalysisContextImpl_this.recordParseHtmlTaskResults(task);
+  HtmlEntry visitParseHtmlTask(ParseHtmlTask task) => AnalysisContextImpl_this._recordParseHtmlTaskResults(task);
 
-  HtmlEntry visitResolveAngularComponentTemplateTask(ResolveAngularComponentTemplateTask task) => AnalysisContextImpl_this.recordResolveAngularComponentTemplateTaskResults(task);
+  HtmlEntry visitResolveAngularComponentTemplateTask(ResolveAngularComponentTemplateTask task) => AnalysisContextImpl_this._recordResolveAngularComponentTemplateTaskResults(task);
 
-  HtmlEntry visitResolveAngularEntryHtmlTask(ResolveAngularEntryHtmlTask task) => AnalysisContextImpl_this.recordResolveAngularEntryHtmlTaskResults(task);
+  HtmlEntry visitResolveAngularEntryHtmlTask(ResolveAngularEntryHtmlTask task) => AnalysisContextImpl_this._recordResolveAngularEntryHtmlTaskResults(task);
 
-  DartEntry visitResolveDartDependenciesTask(ResolveDartDependenciesTask task) => AnalysisContextImpl_this.recordResolveDartDependenciesTaskResults(task);
+  DartEntry visitResolveDartDependenciesTask(ResolveDartDependenciesTask task) => AnalysisContextImpl_this._recordResolveDartDependenciesTaskResults(task);
 
   DartEntry visitResolveDartLibraryTask(ResolveDartLibraryTask task) => AnalysisContextImpl_this.recordResolveDartLibraryTaskResults(task);
 
-  DartEntry visitResolveDartUnitTask(ResolveDartUnitTask task) => AnalysisContextImpl_this.recordResolveDartUnitTaskResults(task);
+  DartEntry visitResolveDartUnitTask(ResolveDartUnitTask task) => AnalysisContextImpl_this._recordResolveDartUnitTaskResults(task);
 
-  HtmlEntry visitResolveHtmlTask(ResolveHtmlTask task) => AnalysisContextImpl_this.recordResolveHtmlTaskResults(task);
+  HtmlEntry visitResolveHtmlTask(ResolveHtmlTask task) => AnalysisContextImpl_this._recordResolveHtmlTaskResults(task);
 
-  DartEntry visitScanDartTask(ScanDartTask task) => AnalysisContextImpl_this.recordScanDartTaskResults(task);
+  DartEntry visitScanDartTask(ScanDartTask task) => AnalysisContextImpl_this._recordScanDartTaskResults(task);
 }
 
 class AnalysisContextImpl_ContextRetentionPolicy implements CacheRetentionPolicy {
   final AnalysisContextImpl AnalysisContextImpl_this;
 
   AnalysisContextImpl_ContextRetentionPolicy(this.AnalysisContextImpl_this);
 
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) {
     for (Source prioritySource in AnalysisContextImpl_this._priorityOrder) {
       if (source == prioritySource) {
         return RetentionPriority.HIGH;
       }
     }
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
-      if (astIsNeeded(dartEntry)) {
+      if (_astIsNeeded(dartEntry)) {
         return RetentionPriority.MEDIUM;
       }
     }
     return RetentionPriority.LOW;
   }
 
-  bool astIsNeeded(DartEntry dartEntry) => dartEntry.hasInvalidData(DartEntry.HINTS) || dartEntry.hasInvalidData(DartEntry.VERIFICATION_ERRORS) || dartEntry.hasInvalidData(DartEntry.RESOLUTION_ERRORS);
+  bool _astIsNeeded(DartEntry dartEntry) => dartEntry.hasInvalidData(DartEntry.HINTS) || dartEntry.hasInvalidData(DartEntry.VERIFICATION_ERRORS) || dartEntry.hasInvalidData(DartEntry.RESOLUTION_ERRORS);
 }
 
 /**
  * Instances of the class `TaskData` represent information about the next task to be
  * performed. Each data has an implicit associated source: the source that might need to be
  * analyzed. There are essentially three states that can be represented:
  * * If [getTask] returns a non-`null` value, then that is the task that should
  * be executed to further analyze the associated source.
  * * Otherwise, if [isBlocked] returns `true`, then there is no work that can be
  * done, but analysis for the associated source is not complete.
@@ skipping 201 matching lines @@
    * Set the errors that changed as a result of the analysis to the given errors and set the line
    * information to the given line information.
    *
    * @param errors the errors that changed as a result of the analysis
    * @param lineInfo the line information associated with the source
    */
   void setErrors(List<AnalysisError> errors, LineInfo lineInfo) {
     this._errors = errors;
     this._lineInfo = lineInfo;
     if (lineInfo == null) {
-      AnalysisEngine.instance.logger.logInformation3("No line info: ${source}", new JavaException());
+      AnalysisEngine.instance.logger.logInformation2("No line info: ${source}", new JavaException());
     }
   }
 
   String toString() => "Changes for ${source.fullName}";
 }
 
 /**
  * Instances of the class `DelegatingAnalysisContextImpl` extend [AnalysisContextImpl
  ] to delegate sources to the appropriate analysis context. For instance, if the
  * source is in a system library then the analysis context from the [DartSdk] is used.
@@ skipping 459 matching lines @@
  * [AnalysisContext] by recording instrumentation data and delegating to
  * another analysis context to do the non-instrumentation work.
  */
 class InstrumentedAnalysisContextImpl implements InternalAnalysisContext {
   /**
    * Record an exception that was thrown during analysis.
    *
    * @param instrumentation the instrumentation builder being used to record the exception
    * @param exception the exception being reported
    */
-  static void recordAnalysisException(InstrumentationBuilder instrumentation, AnalysisException exception) {
+  static void _recordAnalysisException(InstrumentationBuilder instrumentation, AnalysisException exception) {
     instrumentation.record(exception);
   }
 
   /**
    * The unique identifier used to identify this analysis context in the instrumentation data.
    */
   String _contextId = UUID.randomUUID().toString();
 
   /**
    * The analysis context to which all of the non-instrumentation work is delegated.
@@ skipping 53 matching lines @@
   }
 
   List<Source> computeExportedLibraries(Source source) => _basis.computeExportedLibraries(source);
 
   HtmlElement computeHtmlElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeHtmlElement");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeHtmlElement(source);
     } on AnalysisException catch (e) {
-      recordAnalysisException(instrumentation, e);
+      _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   List<Source> computeImportedLibraries(Source source) => _basis.computeImportedLibraries(source);
 
   SourceKind computeKindOf(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeKindOf");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeKindOf(source);
     } finally {
       instrumentation.log();
     }
   }
 
   LibraryElement computeLibraryElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeLibraryElement");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeLibraryElement(source);
     } on AnalysisException catch (e) {
-      recordAnalysisException(instrumentation, e);
+      _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   LineInfo computeLineInfo(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeLineInfo");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeLineInfo(source);
     } on AnalysisException catch (e) {
-      recordAnalysisException(instrumentation, e);
+      _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) => _basis.computeResolvableCompilationUnit(source);
 
   bool exists(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-exists");
@@ skipping 314 matching lines @@
       instrumentation.log();
     }
   }
 
   CompilationUnit parseCompilationUnit(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-parseCompilationUnit");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.parseCompilationUnit(source);
     } on AnalysisException catch (e) {
-      recordAnalysisException(instrumentation, e);
+      _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   ht.HtmlUnit parseHtmlUnit(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-parseHtmlUnit");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.parseHtmlUnit(source);
     } on AnalysisException catch (e) {
-      recordAnalysisException(instrumentation, e);
+      _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   AnalysisResult performAnalysisTask() {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-performAnalysisTask");
     try {
       instrumentation.metric3("contextId", _contextId);
@@ skipping 10 matching lines @@
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     _basis.recordLibraryElements(elementMap);
   }
 
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveCompilationUnit");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.resolveCompilationUnit(unitSource, library);
     } on AnalysisException catch (e) {
-      recordAnalysisException(instrumentation, e);
+      _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveCompilationUnit");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.resolveCompilationUnit2(unitSource, librarySource);
     } on AnalysisException catch (e) {
-      recordAnalysisException(instrumentation, e);
+      _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveHtmlUnit");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.resolveHtmlUnit(htmlSource);
     } on AnalysisException catch (e) {
-      recordAnalysisException(instrumentation, e);
+      _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   void set analysisOptions(AnalysisOptions options) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setAnalysisOptions");
     try {
       instrumentation.metric3("contextId", _contextId);
@@ skipping 673 matching lines @@
    */
   static bool hasAngularAnnotation(ht.HtmlUnit htmlUnit) {
     try {
       htmlUnit.accept(new RecursiveXmlVisitor_AngularHtmlUnitResolver_hasAngularAnnotation());
     } on AngularHtmlUnitResolver_FoundAppError catch (e) {
       return true;
     }
     return false;
   }
 
-  static SimpleIdentifier createIdentifier(String name, int offset) {
-    StringToken token = createStringToken(name, offset);
+  static SimpleIdentifier _createIdentifier(String name, int offset) {
+    StringToken token = _createStringToken(name, offset);
     return new SimpleIdentifier(token);
   }
 
   /**
    * Adds [AngularElement] declared by the given top-level [Element].
    *
    * @param angularElements the list to fill with top-level [AngularElement]s
    * @param classElement the [ClassElement] to get [AngularElement]s from
    */
-  static void addAngularElementsFromClass(Set<AngularElement> angularElements, ClassElement classElement) {
+  static void _addAngularElementsFromClass(Set<AngularElement> angularElements, ClassElement classElement) {
     for (ToolkitObjectElement toolkitObject in classElement.toolkitObjects) {
       if (toolkitObject is AngularElement) {
         angularElements.add(toolkitObject);
       }
     }
   }
 
   /**
    * Returns the array of all top-level Angular elements that could be used in this library.
    *
    * @param libraryElement the [LibraryElement] to analyze
    * @return the array of all top-level Angular elements that could be used in this library
    */
-  static void addAngularElementsFromLibrary(Set<AngularElement> angularElements, LibraryElement library, Set<LibraryElement> visited) {
+  static void _addAngularElementsFromLibrary(Set<AngularElement> angularElements, LibraryElement library, Set<LibraryElement> visited) {
     if (library == null) {
       return;
     }
     if (!visited.add(library)) {
       return;
     }
     // add Angular elements from current library
     for (CompilationUnitElement unit in library.units) {
       angularElements.addAll(unit.angularViews);
       for (ClassElement type in unit.types) {
-        addAngularElementsFromClass(angularElements, type);
+        _addAngularElementsFromClass(angularElements, type);
       }
     }
     // handle imports
     for (ImportElement importElement in library.imports) {
       LibraryElement importedLibrary = importElement.importedLibrary;
-      addAngularElementsFromLibrary(angularElements, importedLibrary, visited);
+      _addAngularElementsFromLibrary(angularElements, importedLibrary, visited);
     }
   }
 
-  static StringToken createStringToken(String name, int offset) => new StringToken(TokenType.IDENTIFIER, name, offset);
+  static StringToken _createStringToken(String name, int offset) => new StringToken(TokenType.IDENTIFIER, name, offset);
 
   /**
    * Returns the array of all top-level Angular elements that could be used in this library.
    *
    * @param libraryElement the [LibraryElement] to analyze
    * @return the array of all top-level Angular elements that could be used in this library
    */
-  static List<AngularElement> getAngularElements(Set<LibraryElement> libraries, LibraryElement libraryElement) {
+  static List<AngularElement> _getAngularElements(Set<LibraryElement> libraries, LibraryElement libraryElement) {
     Set<AngularElement> angularElements = new Set();
-    addAngularElementsFromLibrary(angularElements, libraryElement, libraries);
+    _addAngularElementsFromLibrary(angularElements, libraryElement, libraries);
     return new List.from(angularElements);
   }
 
   /**
    * Returns the external Dart [CompilationUnit] referenced by the given [HtmlUnit].
    */
-  static CompilationUnit getDartUnit(AnalysisContext context, ht.HtmlUnit unit) {
+  static CompilationUnit _getDartUnit(AnalysisContext context, ht.HtmlUnit unit) {
     for (HtmlScriptElement script in unit.element.scripts) {
       if (script is ExternalHtmlScriptElement) {
         Source scriptSource = script.scriptSource;
         if (scriptSource != null) {
           return context.resolveCompilationUnit2(scriptSource, scriptSource);
         }
       }
     }
     return null;
   }
 
-  static Set<Source> getLibrarySources(Set<LibraryElement> libraries) {
+  static Set<Source> _getLibrarySources(Set<LibraryElement> libraries) {
     Set<Source> sources = new Set();
     for (LibraryElement library in libraries) {
       sources.add(library.source);
     }
     return sources;
   }
 
   InternalAnalysisContext _context;
 
   TypeProvider _typeProvider;
@@ skipping 40 matching lines @@
   /**
    * The [AngularApplication] for the Web application with this entry point, may be
    * `null` if not an entry point.
    */
   AngularApplication calculateAngularApplication() {
     // check if Angular at all
     if (!hasAngularAnnotation(_unit)) {
       return null;
     }
     // prepare resolved Dart unit
-    CompilationUnit dartUnit = getDartUnit(_context, _unit);
+    CompilationUnit dartUnit = _getDartUnit(_context, _unit);
     if (dartUnit == null) {
       return null;
     }
     // prepare accessible Angular elements
     LibraryElement libraryElement = dartUnit.element.library;
     Set<LibraryElement> libraries = new Set();
-    List<AngularElement> angularElements = getAngularElements(libraries, libraryElement);
+    List<AngularElement> angularElements = _getAngularElements(libraries, libraryElement);
     // resolve AngularComponentElement template URIs
     // TODO(scheglov) resolve to HtmlElement to allow F3 ?
     Set<Source> angularElementsSources = new Set();
     for (AngularElement angularElement in angularElements) {
       if (angularElement is AngularHasTemplateElement) {
         AngularHasTemplateElement hasTemplate = angularElement;
         angularElementsSources.add(angularElement.source);
         String templateUri = hasTemplate.templateUri;
         if (templateUri == null) {
           continue;
@@ skipping 15 matching lines @@
           }
           if (hasTemplate is AngularViewElementImpl) {
             hasTemplate.templateSource = templateSource;
           }
         } on URISyntaxException catch (exception) {
           _errorListener.onError(new AnalysisError.con2(angularElement.source, hasTemplate.templateUriOffset, templateUri.length, AngularCode.INVALID_URI, [templateUri]));
         }
       }
     }
     // create AngularApplication
-    AngularApplication application = new AngularApplication(_source, getLibrarySources(libraries), angularElements, new List.from(angularElementsSources));
+    AngularApplication application = new AngularApplication(_source, _getLibrarySources(libraries), angularElements, new List.from(angularElementsSources));
     // set AngularApplication for each AngularElement
     for (AngularElement angularElement in angularElements) {
       (angularElement as AngularElementImpl).application = application;
     }
     // done
     return application;
   }
 
   /**
    * Resolves [source] as an [AngularComponentElement] template file.
    *
    * @param application the Angular application we are resolving for
    * @param component the [AngularComponentElement] to resolve template for, not `null`
    */
   void resolveComponentTemplate(AngularApplication application, AngularComponentElement component) {
     _isAngular = true;
-    resolveInternal(application.elements, component);
+    _resolveInternal(application.elements, component);
   }
 
   /**
    * Resolves [source] as an Angular application entry point.
    */
   void resolveEntryPoint(AngularApplication application) {
-    resolveInternal(application.elements, null);
+    _resolveInternal(application.elements, null);
   }
 
   Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
-    parseEmbeddedExpressionsInAttribute(node);
-    resolveExpressions(node.expressions);
+    _parseEmbeddedExpressionsInAttribute(node);
+    _resolveExpressions(node.expressions);
     return super.visitXmlAttributeNode(node);
   }
 
   Object visitXmlTagNode(ht.XmlTagNode node) {
     bool wasAngular = _isAngular;
     try {
       // new Angular context
       if (node.getAttribute(_NG_APP) != null) {
         _isAngular = true;
-        visitModelDirectives(node);
+        _visitModelDirectives(node);
       }
       // not Angular
       if (!_isAngular) {
         return super.visitXmlTagNode(node);
       }
       // process node in separate name scope
-      pushNameScope();
+      _pushNameScope();
       try {
-        parseEmbeddedExpressionsInTag(node);
+        _parseEmbeddedExpressionsInTag(node);
         // apply processors
         for (NgProcessor processor in _processors) {
           if (processor.canApply(node)) {
             processor.apply(this, node);
           }
         }
         // resolve expressions
-        resolveExpressions(node.expressions);
+        _resolveExpressions(node.expressions);
         // process children
         return super.visitXmlTagNode(node);
       } finally {
-        popNameScope();
+        _popNameScope();
       }
     } finally {
       _isAngular = wasAngular;
     }
   }
 
   /**
    * Creates new [LocalVariableElementImpl] with given type and identifier.
    *
    * @param type the [Type] of the variable
    * @param identifier the identifier to create variable for
    * @return the new [LocalVariableElementImpl]
    */
-  LocalVariableElementImpl createLocalVariableFromIdentifier(Type2 type, SimpleIdentifier identifier) {
+  LocalVariableElementImpl _createLocalVariableFromIdentifier(Type2 type, SimpleIdentifier identifier) {
     LocalVariableElementImpl variable = new LocalVariableElementImpl(identifier);
     _definedVariables.add(variable);
     variable.type = type;
     return variable;
   }
 
   /**
    * Creates new [LocalVariableElementImpl] with given name and type.
    *
    * @param type the [Type] of the variable
    * @param name the name of the variable
    * @return the new [LocalVariableElementImpl]
    */
-  LocalVariableElementImpl createLocalVariableWithName(Type2 type, String name) {
-    SimpleIdentifier identifier = createIdentifier(name, 0);
-    return createLocalVariableFromIdentifier(type, identifier);
+  LocalVariableElementImpl _createLocalVariableWithName(Type2 type, String name) {
+    SimpleIdentifier identifier = _createIdentifier(name, 0);
+    return _createLocalVariableFromIdentifier(type, identifier);
   }
 
   /**
    * Declares the given [LocalVariableElementImpl] in the [topNameScope].
    */
-  void defineTopVariable(LocalVariableElementImpl variable) {
-    recordDefinedVariable(variable);
+  void _defineTopVariable(LocalVariableElementImpl variable) {
+    _recordDefinedVariable(variable);
     _topNameScope.define(variable);
-    recordTypeLibraryInjected(variable);
+    _recordTypeLibraryInjected(variable);
   }
 
   /**
    * Declares the given [LocalVariableElementImpl] in the current [nameScope].
    */
-  void defineVariable(LocalVariableElementImpl variable) {
-    recordDefinedVariable(variable);
+  void _defineVariable(LocalVariableElementImpl variable) {
+    _recordDefinedVariable(variable);
     _nameScope.define(variable);
-    recordTypeLibraryInjected(variable);
+    _recordTypeLibraryInjected(variable);
   }
 
   /**
    * @return the [AngularElement] with the given name, maybe `null`.
    */
-  AngularElement findAngularElement(String name) {
+  AngularElement _findAngularElement(String name) {
     for (AngularElement element in _angularElements) {
       if (name == element.name) {
         return element;
       }
     }
     return null;
   }
 
   /**
    * @return the [TypeProvider] of the [AnalysisContext].
    */
   TypeProvider get typeProvider => _typeProvider;
 
   /**
    * Parses given [String] as an [AngularExpression] at the given offset.
    */
-  AngularExpression parseAngularExpression(String contents, int startIndex, int endIndex, int offset) {
-    Token token = scanDart(contents, startIndex, endIndex, offset);
-    return parseAngularExpressionInToken(token);
+  AngularExpression _parseAngularExpression(String contents, int startIndex, int endIndex, int offset) {
+    Token token = _scanDart(contents, startIndex, endIndex, offset);
+    return _parseAngularExpressionInToken(token);
   }
 
-  AngularExpression parseAngularExpressionInToken(Token token) {
-    List<Token> tokens = splitAtBar(token);
-    Expression mainExpression = parseDartExpressionInToken(tokens[0]);
+  AngularExpression _parseAngularExpressionInToken(Token token) {
+    List<Token> tokens = _splitAtBar(token);
+    Expression mainExpression = _parseDartExpressionInToken(tokens[0]);
     // parse filters
     List<AngularFilterNode> filters = [];
     for (int i = 1; i < tokens.length; i++) {
       Token filterToken = tokens[i];
       Token barToken = filterToken;
       filterToken = filterToken.next;
       // TODO(scheglov) report missing identifier
-      SimpleIdentifier name = parseDartExpressionInToken(filterToken) as SimpleIdentifier;
+      SimpleIdentifier name = _parseDartExpressionInToken(filterToken) as SimpleIdentifier;
       filterToken = name.endToken.next;
       // parse arguments
       List<AngularFilterArgument> arguments = [];
       while (filterToken.type != TokenType.EOF) {
         // skip ":"
         Token colonToken = filterToken;
         if (identical(colonToken.type, TokenType.COLON)) {
           filterToken = filterToken.next;
         } else {
-          reportErrorForToken(AngularCode.MISSING_FILTER_COLON, colonToken, []);
+          _reportErrorForToken(AngularCode.MISSING_FILTER_COLON, colonToken, []);
         }
         // parse argument
-        Expression argument = parseDartExpressionInToken(filterToken);
+        Expression argument = _parseDartExpressionInToken(filterToken);
         arguments.add(new AngularFilterArgument(colonToken, argument));
         // next token
         filterToken = argument.endToken.next;
       }
       filters.add(new AngularFilterNode(barToken, name, arguments));
     }
     // done
     return new AngularExpression(mainExpression, filters);
   }
 
   /**
    * Parses given [String] as an [Expression] at the given offset.
    */
-  Expression parseDartExpression(String contents, int startIndex, int endIndex, int offset) {
-    Token token = scanDart(contents, startIndex, endIndex, offset);
-    return parseDartExpressionInToken(token);
+  Expression _parseDartExpression(String contents, int startIndex, int endIndex, int offset) {
+    Token token = _scanDart(contents, startIndex, endIndex, offset);
+    return _parseDartExpressionInToken(token);
   }
 
-  Expression parseDartExpressionInToken(Token token) {
+  Expression _parseDartExpressionInToken(Token token) {
     Parser parser = new Parser(_source, _errorListener);
     return parser.parseExpression(token);
   }
 
-  void popNameScope() {
+  void _popNameScope() {
     _nameScope = _resolver.popNameScope();
   }
 
-  void pushNameScope() {
+  void _pushNameScope() {
     _nameScope = _resolver.pushNameScope();
   }
 
   /**
    * Reports given [ErrorCode] at the given [AstNode].
    */
-  void reportErrorForNode(ErrorCode errorCode, AstNode node, List<Object> arguments) {
-    reportErrorForOffset(errorCode, node.offset, node.length, arguments);
+  void _reportErrorForNode(ErrorCode errorCode, AstNode node, List<Object> arguments) {
+    _reportErrorForOffset(errorCode, node.offset, node.length, arguments);
   }
 
   /**
    * Reports given [ErrorCode] at the given position.
    */
-  void reportErrorForOffset(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
+  void _reportErrorForOffset(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(_source, offset, length, errorCode, arguments));
   }
 
   /**
    * Reports given [ErrorCode] at the given [Token].
    */
-  void reportErrorForToken(ErrorCode errorCode, Token token, List<Object> arguments) {
-    reportErrorForOffset(errorCode, token.offset, token.length, arguments);
+  void _reportErrorForToken(ErrorCode errorCode, Token token, List<Object> arguments) {
+    _reportErrorForOffset(errorCode, token.offset, token.length, arguments);
   }
 
-  void resolveExpression(AngularExpression angularExpression) {
+  void _resolveExpression(AngularExpression angularExpression) {
     List<Expression> dartExpressions = angularExpression.expressions;
     for (Expression dartExpression in dartExpressions) {
-      resolveNode(dartExpression);
+      _resolveNode(dartExpression);
     }
   }
 
   /**
    * Resolves given [AstNode] using [resolver].
    */
-  void resolveNode(AstNode node) {
+  void _resolveNode(AstNode node) {
     node.accept(_resolver);
   }
 
-  Token scanDart(String contents, int startIndex, int endIndex, int offset) => ht.HtmlParser.scanDartSource(_source, _lineInfo, contents.substring(startIndex, endIndex), offset + startIndex, _errorListener);
+  Token _scanDart(String contents, int startIndex, int endIndex, int offset) => ht.HtmlParser.scanDartSource(_source, _lineInfo, contents.substring(startIndex, endIndex), offset + startIndex, _errorListener);
 
   /**
    * Puts into [libraryElement] an artificial [LibraryElementImpl] for this HTML
    * [Source].
    */
-  void createLibraryElement() {
+  void _createLibraryElement() {
     // create CompilationUnitElementImpl
     String unitName = _source.shortName;
     _unitElement = new CompilationUnitElementImpl(unitName);
     _unitElement.source = _source;
     // create LibraryElementImpl
     _libraryElement = new LibraryElementImpl(_context, null);
     _libraryElement.definingCompilationUnit = _unitElement;
     _libraryElement.angularHtml = true;
     _injectedLibraries.add(_libraryElement);
     // create FunctionElementImpl
     _functionElement = new FunctionElementImpl.con2(0);
     _unitElement.functions = <FunctionElement> [_functionElement];
   }
 
   /**
    * Creates new [NgProcessor] for the given [AngularElement], maybe `null` if not
    * supported.
    */
-  NgProcessor createProcessor(AngularElement element) {
+  NgProcessor _createProcessor(AngularElement element) {
     if (element is AngularComponentElement) {
       AngularComponentElement component = element;
       return new NgComponentElementProcessor(component);
     }
     if (element is AngularControllerElement) {
       AngularControllerElement controller = element;
       return new NgControllerElementProcessor(controller);
     }
     if (element is AngularDirectiveElement) {
       AngularDirectiveElement directive = element;
       return new NgDirectiveElementProcessor(directive);
     }
     return null;
   }
 
   /**
    * Puts into [resolver] an [ResolverVisitor] to resolve [Expression]s in
    * [source].
    */
-  void createResolver() {
+  void _createResolver() {
     InheritanceManager inheritanceManager = new InheritanceManager(_libraryElement);
     _resolver = new ResolverVisitor.con2(_libraryElement, _source, _typeProvider, inheritanceManager, _errorListener);
     _topNameScope = _resolver.pushNameScope();
     // add Scope variables - no type, no location, just to avoid warnings
     {
       Type2 type = _typeProvider.dynamicType;
-      _topNameScope.define(createLocalVariableWithName(type, "\$id"));
-      _topNameScope.define(createLocalVariableWithName(type, "\$parent"));
-      _topNameScope.define(createLocalVariableWithName(type, "\$root"));
+      _topNameScope.define(_createLocalVariableWithName(type, "\$id"));
+      _topNameScope.define(_createLocalVariableWithName(type, "\$parent"));
+      _topNameScope.define(_createLocalVariableWithName(type, "\$root"));
     }
   }
 
   /**
    * Defines variable for the given [AngularElement] with type of the enclosing
    * [ClassElement].
    */
-  void defineTopVariable_forClassElement(AngularElement element) {
+  void _defineTopVariable_forClassElement(AngularElement element) {
     ClassElement classElement = element.enclosingElement as ClassElement;
     InterfaceType type = classElement.type;
-    LocalVariableElementImpl variable = createLocalVariableWithName(type, element.name);
-    defineTopVariable(variable);
+    LocalVariableElementImpl variable = _createLocalVariableWithName(type, element.name);
+    _defineTopVariable(variable);
     variable.toolkitObjects = <AngularElement> [element];
   }
 
   /**
    * Defines variable for the given [AngularScopePropertyElement].
    */
-  void defineTopVariable_forScopeProperty(AngularScopePropertyElement element) {
+  void _defineTopVariable_forScopeProperty(AngularScopePropertyElement element) {
     Type2 type = element.type;
-    LocalVariableElementImpl variable = createLocalVariableWithName(type, element.name);
-    defineTopVariable(variable);
+    LocalVariableElementImpl variable = _createLocalVariableWithName(type, element.name);
+    _defineTopVariable(variable);
     variable.toolkitObjects = <AngularElement> [element];
   }
 
   /**
    * Parse the value of the given token for embedded expressions, and add any embedded expressions
    * that are found to the given list of expressions.
    *
    * @param expressions the list to which embedded expressions are to be added
    * @param token the token whose value is to be parsed
    */
-  void parseEmbeddedExpressions(List<AngularMoustacheXmlExpression> expressions, ht.Token token) {
+  void _parseEmbeddedExpressions(List<AngularMoustacheXmlExpression> expressions, ht.Token token) {
     // prepare Token information
     String lexeme = token.lexeme;
     int offset = token.offset;
     // find expressions between {{ and }}
     int startIndex = StringUtilities.indexOf2(lexeme, 0, AngularMoustacheXmlExpression.OPENING_DELIMITER_CHAR, AngularMoustacheXmlExpression.OPENING_DELIMITER_CHAR);
     while (startIndex >= 0) {
       int endIndex = StringUtilities.indexOf2(lexeme, startIndex + AngularMoustacheXmlExpression.OPENING_DELIMITER_LENGTH, AngularMoustacheXmlExpression.CLOSING_DELIMITER_CHAR, AngularMoustacheXmlExpression.CLOSING_DELIMITER_CHAR);
       if (endIndex < 0) {
         // TODO(brianwilkerson) Should we report this error or will it be reported by something else?
         return;
       } else if (startIndex + AngularMoustacheXmlExpression.OPENING_DELIMITER_LENGTH < endIndex) {
         startIndex += AngularMoustacheXmlExpression.OPENING_DELIMITER_LENGTH;
-        AngularExpression expression = parseAngularExpression(lexeme, startIndex, endIndex, offset);
+        AngularExpression expression = _parseAngularExpression(lexeme, startIndex, endIndex, offset);
         expressions.add(new AngularMoustacheXmlExpression(startIndex, endIndex, expression));
       }
       startIndex = StringUtilities.indexOf2(lexeme, endIndex + AngularMoustacheXmlExpression.CLOSING_DELIMITER_LENGTH, AngularMoustacheXmlExpression.OPENING_DELIMITER_CHAR, AngularMoustacheXmlExpression.OPENING_DELIMITER_CHAR);
     }
   }
 
-  void parseEmbeddedExpressionsInAttribute(ht.XmlAttributeNode node) {
+  void _parseEmbeddedExpressionsInAttribute(ht.XmlAttributeNode node) {
     List<AngularMoustacheXmlExpression> expressions = [];
-    parseEmbeddedExpressions(expressions, node.valueToken);
+    _parseEmbeddedExpressions(expressions, node.valueToken);
     if (!expressions.isEmpty) {
       node.expressions = new List.from(expressions);
     }
   }
 
-  void parseEmbeddedExpressionsInTag(ht.XmlTagNode node) {
+  void _parseEmbeddedExpressionsInTag(ht.XmlTagNode node) {
     List<AngularMoustacheXmlExpression> expressions = [];
     ht.Token token = node.attributeEnd;
     ht.Token endToken = node.endToken;
     bool inChild = false;
     while (token != endToken) {
       for (ht.XmlTagNode child in node.tagNodes) {
         if (identical(token, child.beginToken)) {
           inChild = true;
           break;
         }
         if (identical(token, child.endToken)) {
           inChild = false;
           break;
         }
       }
       if (!inChild && identical(token.type, ht.TokenType.TEXT)) {
-        parseEmbeddedExpressions(expressions, token);
+        _parseEmbeddedExpressions(expressions, token);
       }
       token = token.next;
     }
     node.expressions = new List.from(expressions);
   }
 
-  void recordDefinedVariable(LocalVariableElementImpl variable) {
+  void _recordDefinedVariable(LocalVariableElementImpl variable) {
     _definedVariables.add(variable);
     _functionElement.localVariables = new List.from(_definedVariables);
   }
 
   /**
    * When we inject variable, we give access to the library of its type.
    */
-  void recordTypeLibraryInjected(LocalVariableElementImpl variable) {
+  void _recordTypeLibraryInjected(LocalVariableElementImpl variable) {
     LibraryElement typeLibrary = variable.type.element.library;
     _injectedLibraries.add(typeLibrary);
   }
 
-  void resolveExpressions(List<ht.XmlExpression> expressions) {
+  void _resolveExpressions(List<ht.XmlExpression> expressions) {
     for (ht.XmlExpression xmlExpression in expressions) {
       if (xmlExpression is AngularXmlExpression) {
         AngularXmlExpression angularXmlExpression = xmlExpression;
-        resolveXmlExpression(angularXmlExpression);
+        _resolveXmlExpression(angularXmlExpression);
       }
     }
   }
 
   /**
    * Resolves Angular specific expressions and elements in the [source].
    *
    * @param angularElements the [AngularElement]s accessible in the component's library, not
    *          `null`
    * @param component the [AngularComponentElement] to resolve template for, maybe
    *          `null` if not a component template
    */
-  void resolveInternal(List<AngularElement> angularElements, AngularComponentElement component) {
+  void _resolveInternal(List<AngularElement> angularElements, AngularComponentElement component) {
     this._angularElements = angularElements;
     // add built-in processors
     _processors.add(NgModelProcessor.INSTANCE);
     // _processors.add(NgRepeatProcessor.INSTANCE);
     // add element's libraries
     for (AngularElement angularElement in angularElements) {
       _injectedLibraries.add(angularElement.library);
     }
     // prepare Dart library
-    createLibraryElement();
+    _createLibraryElement();
     (_unit.element as HtmlElementImpl).angularCompilationUnit = _unitElement;
     // prepare Dart resolver
-    createResolver();
+    _createResolver();
     // maybe resolving component template
     if (component != null) {
-      defineTopVariable_forClassElement(component);
+      _defineTopVariable_forClassElement(component);
       for (AngularScopePropertyElement scopeProperty in component.scopeProperties) {
-        defineTopVariable_forScopeProperty(scopeProperty);
+        _defineTopVariable_forScopeProperty(scopeProperty);
       }
     }
     // add processors
     for (AngularElement angularElement in angularElements) {
-      NgProcessor processor = createProcessor(angularElement);
+      NgProcessor processor = _createProcessor(angularElement);
       if (processor != null) {
         _processors.add(processor);
       }
     }
     // define filters
     for (AngularElement angularElement in angularElements) {
       if (angularElement is AngularFilterElement) {
-        defineTopVariable_forClassElement(angularElement);
+        _defineTopVariable_forClassElement(angularElement);
       }
     }
     // run this HTML visitor
     _unit.accept(this);
     // simulate imports for injects
     {
       List<ImportElement> imports = [];
       for (LibraryElement injectedLibrary in _injectedLibraries) {
         ImportElementImpl importElement = new ImportElementImpl(-1);
         importElement.importedLibrary = injectedLibrary;
         imports.add(importElement);
       }
       _libraryElement.imports = new List.from(imports);
     }
     // push conditional errors
     for (ProxyConditionalAnalysisError conditionalCode in _resolver.proxyConditionalAnalysisErrors) {
       _resolver.reportError(conditionalCode.analysisError);
     }
   }
 
-  void resolveXmlExpression(AngularXmlExpression angularXmlExpression) {
+  void _resolveXmlExpression(AngularXmlExpression angularXmlExpression) {
     AngularExpression angularExpression = angularXmlExpression.expression;
-    resolveExpression(angularExpression);
+    _resolveExpression(angularExpression);
   }
 
-  List<Token> splitAtBar(Token token) {
+  List<Token> _splitAtBar(Token token) {
     List<Token> tokens = [];
     tokens.add(token);
     while (token.type != TokenType.EOF) {
       if (identical(token.type, TokenType.BAR)) {
         tokens.add(token);
         Token eofToken = new Token(TokenType.EOF, 0);
         token.previous.setNext(eofToken);
       }
       token = token.next;
     }
     return tokens;
   }
 
   /**
    * The "ng-model" directive is special, it contributes to the top-level name scope. These models
    * can be used before actual "ng-model" attribute in HTML. So, we need to define them once we
    * found [NG_APP] context.
    */
-  void visitModelDirectives(ht.XmlTagNode appNode) {
+  void _visitModelDirectives(ht.XmlTagNode appNode) {
     appNode.accept(new RecursiveXmlVisitor_AngularHtmlUnitResolver_visitModelDirectives(this));
   }
 }
 
 class AngularHtmlUnitResolver_FilteringAnalysisErrorListener implements AnalysisErrorListener {
   AnalysisErrorListener _listener;
 
   AngularHtmlUnitResolver_FilteringAnalysisErrorListener(AnalysisErrorListener listener) {
     this._listener = listener;
   }
@@ skipping 20 matching lines @@
 }
 
 class RecursiveXmlVisitor_AngularHtmlUnitResolver_visitModelDirectives extends ht.RecursiveXmlVisitor<Object> {
   final AngularHtmlUnitResolver AngularHtmlUnitResolver_this;
 
   RecursiveXmlVisitor_AngularHtmlUnitResolver_visitModelDirectives(this.AngularHtmlUnitResolver_this) : super();
 
   Object visitXmlTagNode(ht.XmlTagNode node) {
     NgModelProcessor directive = NgModelProcessor.INSTANCE;
     if (directive.canApply(node)) {
-      directive.applyTopDeclarations(AngularHtmlUnitResolver_this, node);
+      directive._applyTopDeclarations(AngularHtmlUnitResolver_this, node);
     }
     return super.visitXmlTagNode(node);
   }
 }
 
 /**
  * Implementation of [AngularXmlExpression] for an [AngularExpression] enclosed between
  * <code>{{</code> and <code>}}</code>.
  */
 class AngularMoustacheXmlExpression extends AngularXmlExpression {
@@ skipping 51 matching lines @@
 abstract class AngularXmlExpression extends ht.XmlExpression {
   /**
    * The expression that is enclosed between the delimiters.
    */
   final AngularExpression expression;
 
   AngularXmlExpression(this.expression);
 
   ht.XmlExpression_Reference getReference(int offset) {
     // main expression
-    ht.XmlExpression_Reference reference = getReferenceAtNode(expression.expression, offset);
+    ht.XmlExpression_Reference reference = _getReferenceAtNode(expression.expression, offset);
     if (reference != null) {
       return reference;
     }
     // filters
     for (AngularFilterNode filter in expression.filters) {
       // filter name
-      reference = getReferenceAtNode(filter.name, offset);
+      reference = _getReferenceAtNode(filter.name, offset);
       if (reference != null) {
         return reference;
       }
       // filter arguments
       for (AngularFilterArgument filterArgument in filter.arguments) {
-        reference = getReferenceAtNode(filterArgument.expression, offset);
+        reference = _getReferenceAtNode(filterArgument.expression, offset);
         if (reference != null) {
           return reference;
         }
       }
     }
     return null;
   }
 
   /**
    * If the given [AstNode] has an [Element] at the given offset, then returns
    * [Reference] with this [Element].
    */
-  ht.XmlExpression_Reference getReferenceAtNode(AstNode root, int offset) {
+  ht.XmlExpression_Reference _getReferenceAtNode(AstNode root, int offset) {
     AstNode node = new NodeLocator.con1(offset).searchWithin(root);
     if (node != null) {
       Element element = ElementLocator.locate(node);
       return new ht.XmlExpression_Reference(element, node.offset, node.length);
     }
     return null;
   }
 }
 
 /**
  * Recursively visits [HtmlUnit] and every embedded [Expression].
  */
 abstract class ExpressionVisitor extends ht.RecursiveXmlVisitor<Object> {
   /**
    * Visits the given [Expression]s embedded into tag or attribute.
    *
    * @param expression the [Expression] to visit, not `null`
    */
   void visitExpression(Expression expression);
 
   Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
-    visitExpressions(node.expressions);
+    _visitExpressions(node.expressions);
     return super.visitXmlAttributeNode(node);
   }
 
   Object visitXmlTagNode(ht.XmlTagNode node) {
-    visitExpressions(node.expressions);
+    _visitExpressions(node.expressions);
     return super.visitXmlTagNode(node);
   }
 
   /**
    * Visits [Expression]s of the given [XmlExpression]s.
    */
-  void visitExpressions(List<ht.XmlExpression> expressions) {
+  void _visitExpressions(List<ht.XmlExpression> expressions) {
     for (ht.XmlExpression xmlExpression in expressions) {
       if (xmlExpression is AngularXmlExpression) {
         AngularXmlExpression angularXmlExpression = xmlExpression;
         List<Expression> dartExpressions = angularXmlExpression.expression.expressions;
         for (Expression dartExpression in dartExpressions) {
           visitExpression(dartExpression);
         }
       }
       if (xmlExpression is ht.RawXmlExpression) {
         ht.RawXmlExpression rawXmlExpression = xmlExpression;
@@ skipping 17 matching lines @@
   void apply(AngularHtmlUnitResolver resolver, ht.XmlTagNode node) {
     node.element = _element.selector;
     for (AngularPropertyElement property in _element.properties) {
       String name = property.name;
       ht.XmlAttributeNode attribute = node.getAttribute(name);
       if (attribute != null) {
         attribute.element = property;
         // resolve if binding
         if (property.propertyKind != AngularPropertyKind.ATTR) {
           AngularExpression expression = parseAngularExpression(resolver, attribute);
-          resolver.resolveExpression(expression);
+          resolver._resolveExpression(expression);
           setAngularExpression(attribute, expression);
         }
       }
     }
   }
 
   bool canApply(ht.XmlTagNode node) => _element.selector.apply(node);
 }
 
 /**
  * [NgControllerElementProcessor] applies [AngularControllerElement].
  */
 class NgControllerElementProcessor extends NgProcessor {
   AngularControllerElement _element;
 
   NgControllerElementProcessor(AngularControllerElement element) {
     this._element = element;
   }
 
   void apply(AngularHtmlUnitResolver resolver, ht.XmlTagNode node) {
     InterfaceType type = (_element.enclosingElement as ClassElement).type;
     String name = _element.name;
-    LocalVariableElementImpl variable = resolver.createLocalVariableWithName(type, name);
-    resolver.defineVariable(variable);
+    LocalVariableElementImpl variable = resolver._createLocalVariableWithName(type, name);
+    resolver._defineVariable(variable);
     variable.toolkitObjects = <AngularElement> [_element];
   }
 
   bool canApply(ht.XmlTagNode node) => _element.selector.apply(node);
 }
 
 /**
  * [NgDirectiveElementProcessor] applies [AngularDirectiveElement] by parsing mapped
  * attributes as expressions.
  */
@@ skipping 26 matching lines @@
       }
       // resolve attribute expression
       ht.XmlAttributeNode attribute = node.getAttribute(name);
       if (attribute != null) {
         // if not resolved as the selector, resolve as a property
         if (name != selectorAttributeName) {
           attribute.element = property;
         }
         // resolve if binding
         if (property.propertyKind != AngularPropertyKind.ATTR) {
-          resolver.pushNameScope();
+          resolver._pushNameScope();
           try {
-            onNgEventDirective(resolver);
+            _onNgEventDirective(resolver);
             AngularExpression expression = parseAngularExpression(resolver, attribute);
-            resolver.resolveExpression(expression);
+            resolver._resolveExpression(expression);
             setAngularExpression(attribute, expression);
           } finally {
-            resolver.popNameScope();
+            resolver._popNameScope();
           }
         }
       }
     }
   }
 
   bool canApply(ht.XmlTagNode node) => _element.selector.apply(node);
 
   /**
    * Support for <code>$event</code> variable in <code>NgEventDirective</code>.
    */
-  void onNgEventDirective(AngularHtmlUnitResolver resolver) {
+  void _onNgEventDirective(AngularHtmlUnitResolver resolver) {
     if (_element.isClass("NgEventDirective")) {
       Type2 dynamicType = resolver.typeProvider.dynamicType;
-      resolver.defineVariable(resolver.createLocalVariableWithName(dynamicType, "\$event"));
+      resolver._defineVariable(resolver._createLocalVariableWithName(dynamicType, "\$event"));
     }
   }
 }
 
 /**
  * [NgDirectiveProcessor] describes any <code>NgDirective</code> annotation instance.
  */
 abstract class NgDirectiveProcessor extends NgProcessor {
   static AngularRawXmlExpression newAngularRawXmlExpression(AngularExpression e) => new AngularRawXmlExpression(e);
 
   static ht.RawXmlExpression newRawXmlExpression(Expression e) => new ht.RawXmlExpression(e);
 
   AngularExpression parseAngularExpression(AngularHtmlUnitResolver resolver, ht.XmlAttributeNode attribute) {
-    Token token = scanAttribute(resolver, attribute);
-    return resolver.parseAngularExpressionInToken(token);
+    Token token = _scanAttribute(resolver, attribute);
+    return resolver._parseAngularExpressionInToken(token);
   }
 
   Expression parseDartExpression(AngularHtmlUnitResolver resolver, ht.XmlAttributeNode attribute) {
-    Token token = scanAttribute(resolver, attribute);
-    return resolver.parseDartExpressionInToken(token);
+    Token token = _scanAttribute(resolver, attribute);
+    return resolver._parseDartExpressionInToken(token);
   }
 
   /**
    * Sets single [AngularExpression] for [XmlAttributeNode].
    */
   void setAngularExpression(ht.XmlAttributeNode attribute, AngularExpression expression) {
-    setExpression2(attribute, newAngularRawXmlExpression(expression));
+    _setExpression(attribute, newAngularRawXmlExpression(expression));
   }
 
   /**
    * Sets single [Expression] for [XmlAttributeNode].
    */
   void setExpression(ht.XmlAttributeNode attribute, Expression expression) {
-    setExpression2(attribute, newRawXmlExpression(expression));
+    _setExpression(attribute, newRawXmlExpression(expression));
   }
 
   void setExpressions(ht.XmlAttributeNode attribute, List<ht.XmlExpression> xmlExpressions) {
     attribute.expressions = new List.from(xmlExpressions);
   }
 
-  Token scanAttribute(AngularHtmlUnitResolver resolver, ht.XmlAttributeNode attribute) {
+  Token _scanAttribute(AngularHtmlUnitResolver resolver, ht.XmlAttributeNode attribute) {
     int offset = attribute.valueToken.offset + 1;
     String value = attribute.text;
-    return resolver.scanDart(value, 0, value.length, offset);
+    return resolver._scanDart(value, 0, value.length, offset);
   }
 
-  void setExpression2(ht.XmlAttributeNode attribute, ht.XmlExpression xmlExpression) {
+  void _setExpression(ht.XmlAttributeNode attribute, ht.XmlExpression xmlExpression) {
     attribute.expressions = <ht.XmlExpression> [xmlExpression];
   }
 }
 
 /**
  * [NgModelProcessor] describes built-in <code>NgModel</code> directive.
  */
 class NgModelProcessor extends NgDirectiveProcessor {
   static String _NG_MODEL = "ng-model";
 
   static NgModelProcessor INSTANCE = new NgModelProcessor();
 
   void apply(AngularHtmlUnitResolver resolver, ht.XmlTagNode node) {
     ht.XmlAttributeNode attribute = node.getAttribute(_NG_MODEL);
     Expression expression = parseDartExpression(resolver, attribute);
     // identifiers have been already handled by "apply top"
     if (expression is SimpleIdentifier) {
       return;
     }
     // resolve
-    resolver.resolveNode(expression);
+    resolver._resolveNode(expression);
     // remember expression
     setExpression(attribute, expression);
   }
 
   bool canApply(ht.XmlTagNode node) => node.getAttribute(_NG_MODEL) != null;
 
   /**
    * This method is used to define top-level [VariableElement]s for each "ng-model" with
    * simple identifier model.
    */
-  void applyTopDeclarations(AngularHtmlUnitResolver resolver, ht.XmlTagNode node) {
+  void _applyTopDeclarations(AngularHtmlUnitResolver resolver, ht.XmlTagNode node) {
     ht.XmlAttributeNode attribute = node.getAttribute(_NG_MODEL);
     Expression expression = parseDartExpression(resolver, attribute);
     // if not identifier, then not a top-level model, delay until "apply"
     if (expression is! SimpleIdentifier) {
       return;
     }
     SimpleIdentifier identifier = expression as SimpleIdentifier;
     // define variable Element
     InterfaceType type = resolver.typeProvider.stringType;
-    LocalVariableElementImpl element = resolver.createLocalVariableFromIdentifier(type, identifier);
-    resolver.defineTopVariable(element);
+    LocalVariableElementImpl element = resolver._createLocalVariableFromIdentifier(type, identifier);
+    resolver._defineTopVariable(element);
     // remember expression
     identifier.staticElement = element;
     identifier.staticType = type;
     setExpression(attribute, identifier);
   }
 }
 
 /**
  * [NgProcessor] is used to apply an Angular feature.
  */
@@ skipping 57 matching lines @@
 
   /**
    * Perform this analysis task and use the given visitor to visit this task after it has completed.
    *
    * @param visitor the visitor used to visit this task after it has completed
    * @return the value returned by the visitor
    * @throws AnalysisException if the visitor throws the exception
    */
   Object perform(AnalysisTaskVisitor visitor) {
     try {
-      safelyPerform();
+      _safelyPerform();
     } on AnalysisException catch (exception) {
       _thrownException = exception;
-      AnalysisEngine.instance.logger.logInformation3("Task failed: ${taskDescription}", exception);
+      AnalysisEngine.instance.logger.logInformation2("Task failed: ${taskDescription}", exception);
     }
     return accept(visitor);
   }
 
   String toString() => taskDescription;
 
   /**
    * Return a textual description of this task.
    *
    * @return a textual description of this task
    */
   String get taskDescription;
 
   /**
    * Perform this analysis task, protected by an exception handler.
    *
    * @throws AnalysisException if an exception occurs while performing the task
    */
   void internalPerform();
 
   /**
    * Perform this analysis task, ensuring that all exceptions are wrapped in an
    * [AnalysisException].
    *
    * @throws AnalysisException if any exception occurs while performing the task
    */
-  void safelyPerform() {
+  void _safelyPerform() {
     try {
       internalPerform();
     } on AnalysisException catch (exception) {
       throw exception;
     } on JavaException catch (exception) {
       throw new AnalysisException.con3(exception);
     }
   }
 }
 
@@ skipping 248 matching lines @@
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     List<CompilationUnitElement> parts = libraryElement.parts;
     int partCount = parts.length;
     List<CompilationUnit> compilationUnits = new List<CompilationUnit>(partCount + 1);
     Map<Source, TimestampedData<CompilationUnit>> timestampMap = new Map<Source, TimestampedData<CompilationUnit>>();
     //
     // Get all of the (fully resolved) compilation units that will be analyzed.
     //
     Source unitSource = libraryElement.definingCompilationUnit.source;
-    TimestampedData<CompilationUnit> resolvedUnit = getCompilationUnit(unitSource);
+    TimestampedData<CompilationUnit> resolvedUnit = _getCompilationUnit(unitSource);
     timestampMap[unitSource] = resolvedUnit;
     CompilationUnit unit = resolvedUnit.data;
     if (unit == null) {
       throw new AnalysisException.con1("Internal error: GenerateDartHintsTask failed to access resolved compilation unit for ${unitSource.fullName}");
     }
     compilationUnits[0] = unit;
     for (int i = 0; i < partCount; i++) {
       unitSource = parts[i].source;
-      resolvedUnit = getCompilationUnit(unitSource);
+      resolvedUnit = _getCompilationUnit(unitSource);
       timestampMap[unitSource] = resolvedUnit;
       unit = resolvedUnit.data;
       if (unit == null) {
         throw new AnalysisException.con1("Internal error: GenerateDartHintsTask failed to access resolved compilation unit for ${unitSource.fullName}");
       }
       compilationUnits[i + 1] = unit;
     }
     //
     // Analyze all of the units.
     //
@@ skipping 11 matching lines @@
     }
   }
 
   /**
    * Return the resolved compilation unit associated with the given source.
    *
    * @param unitSource the source for the compilation unit whose resolved AST is to be returned
    * @return the resolved compilation unit associated with the given source
    * @throws AnalysisException if the resolved compilation unit could not be computed
    */
-  TimestampedData<CompilationUnit> getCompilationUnit(Source unitSource) => context.internalResolveCompilationUnit(unitSource, libraryElement);
+  TimestampedData<CompilationUnit> _getCompilationUnit(Source unitSource) => context.internalResolveCompilationUnit(unitSource, libraryElement);
 }
 
 /**
  * Instances of the class `GetContentTask` get the contents of a source.
  */
 class GetContentTask extends AnalysisTask {
   /**
    * The source to be read.
    */
   final Source source;
@@ skipping 681 matching lines @@
   }
 
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartDependenciesTask(this);
 
   /**
    * Return an array containing the sources referenced by 'export' directives, or an empty array if
    * the task has not yet been performed or if an exception occurred.
    *
    * @return an array containing the sources referenced by 'export' directives
    */
-  List<Source> get exportedSources => toArray(_exportedSources);
+  List<Source> get exportedSources => _toArray(_exportedSources);
 
   /**
    * Return an array containing the sources referenced by 'import' directives, or an empty array if
    * the task has not yet been performed or if an exception occurred.
    *
    * @return an array containing the sources referenced by 'import' directives
    */
-  List<Source> get importedSources => toArray(_importedSources);
+  List<Source> get importedSources => _toArray(_importedSources);
 
   /**
    * Return an array containing the sources referenced by 'part' directives, or an empty array if
    * the task has not yet been performed or if an exception occurred.
    *
    * @return an array containing the sources referenced by 'part' directives
    */
-  List<Source> get includedSources => toArray(_includedSources);
+  List<Source> get includedSources => _toArray(_includedSources);
 
   String get taskDescription {
     if (source == null) {
       return "resolve dart dependencies null source";
     }
     return "resolve dart dependencies ${source.fullName}";
   }
 
   void internalPerform() {
     TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
     try {
       for (Directive directive in _unit.directives) {
         if (directive is ExportDirective) {
-          Source exportSource = resolveSource(source, directive);
+          Source exportSource = _resolveSource(source, directive);
           if (exportSource != null) {
             _exportedSources.add(exportSource);
           }
         } else if (directive is ImportDirective) {
-          Source importSource = resolveSource(source, directive);
+          Source importSource = _resolveSource(source, directive);
           if (importSource != null) {
             _importedSources.add(importSource);
           }
         } else if (directive is PartDirective) {
-          Source partSource = resolveSource(source, directive);
+          Source partSource = _resolveSource(source, directive);
           if (partSource != null) {
             _includedSources.add(partSource);
           }
         }
       }
     } finally {
       timeCounterParse.stop();
     }
   }
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * given library, or `null` if the URI is not valid.
    *
    * @param librarySource the source representing the library containing the directive
    * @param directive the directive which URI should be resolved
    * @return the result of resolving the URI against the URI of the library
    */
-  Source resolveSource(Source librarySource, UriBasedDirective directive) {
+  Source _resolveSource(Source librarySource, UriBasedDirective directive) {
     StringLiteral uriLiteral = directive.uri;
     if (uriLiteral is StringInterpolation) {
       return null;
     }
     String uriContent = uriLiteral.stringValue.trim();
     if (uriContent == null) {
       return null;
     }
     uriContent = Uri.encodeFull(uriContent);
     try {
       parseUriWithException(uriContent);
       return context.sourceFactory.resolveUri(librarySource, uriContent);
     } on URISyntaxException catch (exception) {
       return null;
     }
   }
 
   /**
    * Efficiently convert the given set of sources to an array.
    *
    * @param sources the set to be converted
    * @return an array containing all of the sources in the given set
    */
-  List<Source> toArray(Set<Source> sources) {
+  List<Source> _toArray(Set<Source> sources) {
     int size = sources.length;
     if (size == 0) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(sources);
   }
 }
 
 /**
  * Instances of the class `ResolveDartLibraryTask` parse a specific Dart library.
@@ skipping 117 matching lines @@
     TypeProvider typeProvider = (_libraryElement.context as InternalAnalysisContext).typeProvider;
     ResolvableCompilationUnit resolvableUnit = context.computeResolvableCompilationUnit(source);
     _modificationTime = resolvableUnit.modificationTime;
     CompilationUnit unit = resolvableUnit.compilationUnit;
     if (unit == null) {
       throw new AnalysisException.con1("Internal error: computeResolvableCompilationUnit returned a value without a parsed Dart unit");
     }
     //
     // Resolve names in declarations.
     //
-    new DeclarationResolver().resolve(unit, find(_libraryElement, source));
+    new DeclarationResolver().resolve(unit, _find(_libraryElement, source));
     //
     // Resolve the type names.
     //
     RecordingErrorListener errorListener = new RecordingErrorListener();
     TypeResolverVisitor typeResolverVisitor = new TypeResolverVisitor.con2(_libraryElement, source, typeProvider, errorListener);
     unit.accept(typeResolverVisitor);
     //
     // Resolve the rest of the structure
     //
     InheritanceManager inheritanceManager = new InheritanceManager(_libraryElement);
@@ skipping 26 matching lines @@
 
   /**
    * Search the compilation units that are part of the given library and return the element
    * representing the compilation unit with the given source. Return `null` if there is no
    * such compilation unit.
    *
    * @param libraryElement the element representing the library being searched through
    * @param unitSource the source for the compilation unit whose element is to be returned
    * @return the element representing the compilation unit
    */
-  CompilationUnitElement find(LibraryElement libraryElement, Source unitSource) {
+  CompilationUnitElement _find(LibraryElement libraryElement, Source unitSource) {
     CompilationUnitElement element = libraryElement.definingCompilationUnit;
     if (element.source == unitSource) {
       return element;
     }
     for (CompilationUnitElement partElement in libraryElement.parts) {
       if (partElement.source == unitSource) {
         return partElement;
       }
     }
     return null;
@@ skipping 242 matching lines @@
    * @param exception the exception being logged
    */
   void logInformation(String message);
 
   /**
    * Log the given exception as one representing an informational message.
    *
    * @param message an explanation of why the error occurred or what it means
    * @param exception the exception being logged
    */
-  void logInformation3(String message, Exception exception);
+  void logInformation2(String message, Exception exception);
 }
 
 /**
  * Implementation of [Logger] that does nothing.
  */
 class Logger_NullLogger implements Logger {
   void logError(String message) {
   }
 
   void logError2(String message, Exception exception) {
   }
 
   void logInformation(String message) {
   }
 
-  void logInformation3(String message, Exception exception) {
+  void logInformation2(String message, Exception exception) {
   }
 }