Translate Java's @Override into Dart's @override.

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 994 matching lines @@
    * Record that the specified source has been removed.
    *
    * @param source the source that was removed
    */
   void removedSource(Source source) {
     if (source != null) {
       _removed.add(source);
     }
   }
 
+  @override
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     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("; ");
@@ skipping 469 matching lines @@
    * Return the value of the data represented by the given descriptor in the context of the given
    * library, or `null` if the data represented by the descriptor is not in the cache.
    *
    * @param descriptor the descriptor representing which data is to be returned
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @return the value of the data represented by the given descriptor and library
    */
   Object getValueInLibrary(DataDescriptor descriptor, Source librarySource);
 
+  @override
   DartEntryImpl get writableCopy;
 
   /**
    * Return `true` if the data represented by the given descriptor is marked as being invalid.
    * If the descriptor represents library-specific data then this method will return `true` if
    * the data associated with any library it marked as invalid.
    *
    * @param descriptor the descriptor representing which data is being tested
    * @return `true` if the data is marked as being invalid
    */
@@ skipping 186 matching lines @@
       _tokenStream = null;
     }
     if (identical(_parsedUnitState, CacheState.VALID)) {
       _parsedUnitState = CacheState.FLUSHED;
       _parsedUnitAccessed = false;
       _parsedUnit = null;
     }
     _resolutionState.flushAstStructures();
   }
 
+  @override
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     ListUtilities.addAll(errors, _scanErrors);
     ListUtilities.addAll(errors, _parseErrors);
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       ListUtilities.addAll(errors, state._resolutionErrors);
       ListUtilities.addAll(errors, state._verificationErrors);
       ListUtilities.addAll(errors, state._hints);
       state = state._nextState;
     }
     ListUtilities.addAll(errors, _angularErrors);
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
   }
 
+  @override
   CompilationUnit get anyParsedCompilationUnit {
     if (identical(_parsedUnitState, CacheState.VALID)) {
       _parsedUnitAccessed = true;
       return _parsedUnit;
     }
     return anyResolvedCompilationUnit;
   }
 
+  @override
   CompilationUnit get anyResolvedCompilationUnit {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (identical(state._resolvedUnitState, CacheState.VALID)) {
         return state._resolvedUnit;
       }
       state = state._nextState;
     }
     ;
     return null;
   }
 
+  @override
   SourceKind get kind => _sourceKind;
 
   /**
    * Answer an array of library sources containing the receiver's source.
    */
   List<Source> get librariesContaining {
     DartEntryImpl_ResolutionState state = _resolutionState;
     List<Source> result = new List<Source>();
     while (state != null) {
       if (state._librarySource != null) {
@@ skipping 25 matching lines @@
     while (state != null) {
       if (identical(state._resolvedUnitState, CacheState.VALID)) {
         return state._resolvedUnit.accept(new AstCloner()) as CompilationUnit;
       }
       state = state._nextState;
     }
     ;
     return null;
   }
 
+  @override
   CacheState getState(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return _elementState;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return _exportedLibrariesState;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return _importedLibrariesState;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return _includedPartsState;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
@@ skipping 10 matching lines @@
       return _scanErrorsState;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       return _sourceKindState;
     } else if (identical(descriptor, DartEntry.TOKEN_STREAM)) {
       return _tokenStreamState;
     } else {
       return super.getState(descriptor);
     }
   }
 
+  @override
   CacheState getStateInLibrary(DataDescriptor descriptor, Source librarySource) {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource == state._librarySource) {
         if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return state._resolutionErrorsState;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return state._resolvedUnitState;
         } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
           return state._verificationErrorsState;
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return state._hintsState;
         } else {
           throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
         }
       }
       state = state._nextState;
     }
     ;
     if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.RESOLVED_UNIT) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
       return CacheState.INVALID;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
+  @override
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ANGULAR_ERRORS)) {
       return _angularErrors;
     } else if (identical(descriptor, DartEntry.CONTAINING_LIBRARIES)) {
       return new List.from(_containingLibraries);
     } else if (identical(descriptor, DartEntry.ELEMENT)) {
       return _element;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return _exportedLibraries;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
@@ skipping 14 matching lines @@
     } else if (identical(descriptor, DartEntry.SCAN_ERRORS)) {
       return _scanErrors;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       return _sourceKind;
     } else if (identical(descriptor, DartEntry.TOKEN_STREAM)) {
       return _tokenStream;
     }
     return super.getValue(descriptor);
   }
 
+  @override
   Object getValueInLibrary(DataDescriptor descriptor, Source librarySource) {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource == state._librarySource) {
         if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return state._resolutionErrors;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return state._resolvedUnit;
         } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
           return state._verificationErrors;
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return state._hints;
         } else {
           throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
         }
       }
       state = state._nextState;
     }
     ;
     if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
       return AnalysisError.NO_ERRORS;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       return null;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
+  @override
   DartEntryImpl get writableCopy {
     DartEntryImpl copy = new DartEntryImpl();
     copy.copyFrom(this);
     return copy;
   }
 
+  @override
   bool hasInvalidData(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return identical(_elementState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return identical(_exportedLibrariesState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return identical(_importedLibrariesState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return identical(_includedPartsState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
@@ skipping 24 matching lines @@
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return identical(state._hintsState, CacheState.INVALID);
         }
       }
       return false;
     } else {
       return identical(super.getState(descriptor), CacheState.INVALID);
     }
   }
 
+  @override
   void invalidateAllInformation() {
     super.invalidateAllInformation();
     _scanErrors = AnalysisError.NO_ERRORS;
     _scanErrorsState = CacheState.INVALID;
     _tokenStream = null;
     _tokenStreamState = CacheState.INVALID;
     _sourceKind = SourceKind.UNKNOWN;
     _sourceKindState = CacheState.INVALID;
     _parseErrors = AnalysisError.NO_ERRORS;
     _parseErrorsState = CacheState.INVALID;
@@ skipping 15 matching lines @@
           _parsedUnitAccessed = true;
           _parsedUnitState = CacheState.VALID;
           break;
         }
         state = state._nextState;
       }
     }
     _discardCachedResolutionInformation();
   }
 
+  @override
   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;
     }
     return true;
   }
 
+  @override
   void recordContentError() {
     super.recordContentError();
     recordScanError();
   }
 
   /**
    * Record that an error occurred while attempting to resolve the directives in the source
    * represented by this entry.
    */
   void recordDependencyError() {
@@ skipping 215 matching lines @@
    * Set the list of libraries that contain this compilation unit to contain only the given source.
    * This method should only be invoked on entries that represent a library.
    *
    * @param librarySource the source of the single library that the list should contain
    */
   void set containingLibrary(Source librarySource) {
     _containingLibraries.clear();
     _containingLibraries.add(librarySource);
   }
 
+  @override
   void setState(DataDescriptor descriptor, CacheState state) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       _element = updatedValue(state, _element, null);
       _elementState = state;
     } 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;
@@ skipping 54 matching lines @@
       state._verificationErrors = updatedValue(cacheState, state._verificationErrors, AnalysisError.NO_ERRORS);
       state._verificationErrorsState = cacheState;
     } else if (identical(descriptor, DartEntry.HINTS)) {
       state._hints = updatedValue(cacheState, state._hints, AnalysisError.NO_ERRORS);
       state._hintsState = cacheState;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
+  @override
   void setValue(DataDescriptor descriptor, Object value) {
     if (identical(descriptor, DartEntry.ANGULAR_ERRORS)) {
       _angularErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
     } else if (identical(descriptor, DartEntry.ELEMENT)) {
       _element = value as LibraryElement;
       _elementState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       _exportedLibraries = value == null ? Source.EMPTY_ARRAY : (value as List<Source>);
       _exportedLibrariesState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
@@ skipping 51 matching lines @@
       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)) {
       state._hints = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       state._hintsState = CacheState.VALID;
     }
   }
 
+  @override
   void copyFrom(SourceEntryImpl entry) {
     super.copyFrom(entry);
     DartEntryImpl other = entry as DartEntryImpl;
     _scanErrorsState = other._scanErrorsState;
     _scanErrors = other._scanErrors;
     _tokenStreamState = other._tokenStreamState;
     _tokenStream = other._tokenStream;
     _sourceKindState = other._sourceKindState;
     _sourceKind = other._sourceKind;
     _parsedUnitState = other._parsedUnitState;
@@ skipping 12 matching lines @@
     _elementState = other._elementState;
     _element = other._element;
     _publicNamespaceState = other._publicNamespaceState;
     _publicNamespace = other._publicNamespace;
     _clientServerState = other._clientServerState;
     _launchableState = other._launchableState;
     _bitmask = other._bitmask;
     _angularErrors = other._angularErrors;
   }
 
+  @override
   bool get hasErrorState => super.hasErrorState || identical(_scanErrorsState, CacheState.ERROR) || identical(_tokenStreamState, CacheState.ERROR) || identical(_sourceKindState, CacheState.ERROR) || identical(_parsedUnitState, CacheState.ERROR) || identical(_parseErrorsState, CacheState.ERROR) || identical(_importedLibrariesState, CacheState.ERROR) || identical(_exportedLibrariesState, CacheState.ERROR) || identical(_includedPartsState, CacheState.ERROR) || identical(_elementState, CacheState.ERROR) || identical(_publicNamespaceState, CacheState.ERROR) || identical(_clientServerState, CacheState.ERROR) || identical(_launchableState, CacheState.ERROR) || _resolutionState.hasErrorState;
 
+  @override
   void writeOn(JavaStringBuilder builder) {
     builder.append("Dart: ");
     super.writeOn(builder);
     builder.append("; tokenStream = ");
     builder.append(_tokenStreamState);
     builder.append("; scanErrors = ");
     builder.append(_scanErrorsState);
     builder.append("; sourceKind = ");
     builder.append(_sourceKindState);
     builder.append("; parsedUnit = ");
@@ skipping 276 matching lines @@
 
   /**
    * Initialize a newly created descriptor to have the given name.
    *
    * @param name the name of the descriptor
    */
   DataDescriptor(String name) {
     this._name = name;
   }
 
+  @override
   String toString() => _name;
 }
 
 /**
  * The interface `HtmlEntry` defines the behavior of objects that maintain the information
  * cached by an analysis context about an individual HTML file.
  */
 abstract class HtmlEntry implements SourceEntry {
   /**
    * The data descriptor representing the information about an Angular application this source is
@@ skipping 61 matching lines @@
   List<AnalysisError> get allErrors;
 
   /**
    * Return a valid parsed unit, either an unresolved AST structure or the result of resolving the
    * AST structure, or `null` if there is no parsed unit available.
    *
    * @return a valid parsed unit
    */
   ht.HtmlUnit get anyParsedUnit;
 
+  @override
   HtmlEntryImpl get writableCopy;
 }
 
 /**
  * Instances of the class `HtmlEntryImpl` implement an [HtmlEntry].
  */
 class HtmlEntryImpl extends SourceEntryImpl implements HtmlEntry {
   /**
    * The state of the cached parsed (but not resolved) HTML unit.
    */
@@ skipping 116 matching lines @@
     if (identical(_parsedUnitState, CacheState.VALID)) {
       _parsedUnitState = CacheState.FLUSHED;
       _parsedUnit = null;
     }
     if (identical(_resolvedUnitState, CacheState.VALID)) {
       _resolvedUnitState = CacheState.FLUSHED;
       _resolvedUnit = null;
     }
   }
 
+  @override
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     if (_parseErrors != null) {
       for (AnalysisError error in _parseErrors) {
         errors.add(error);
       }
     }
     if (_resolutionErrors != null) {
       for (AnalysisError error in _resolutionErrors) {
         errors.add(error);
       }
     }
     if (_angularErrors != null) {
       for (AnalysisError error in _angularErrors) {
         errors.add(error);
       }
     }
     if (_hints != null) {
       for (AnalysisError error in _hints) {
         errors.add(error);
       }
     }
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
   }
 
+  @override
   ht.HtmlUnit get anyParsedUnit {
     if (identical(_parsedUnitState, CacheState.VALID)) {
       //      parsedUnitAccessed = true;
       return _parsedUnit;
     }
     if (identical(_resolvedUnitState, CacheState.VALID)) {
       //      resovledUnitAccessed = true;
       return _resolvedUnit;
     }
     return null;
   }
 
+  @override
   SourceKind get kind => SourceKind.HTML;
 
+  @override
   CacheState getState(DataDescriptor descriptor) {
     if (identical(descriptor, HtmlEntry.ANGULAR_APPLICATION)) {
       return _angularApplicationState;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_COMPONENT)) {
       return _angularComponentState;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_ENTRY)) {
       return _angularEntryState;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_ERRORS)) {
       return _angularErrorsState;
     } else if (identical(descriptor, HtmlEntry.ELEMENT)) {
       return _elementState;
     } else if (identical(descriptor, HtmlEntry.PARSE_ERRORS)) {
       return _parseErrorsState;
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       return _parsedUnitState;
     } else if (identical(descriptor, HtmlEntry.RESOLVED_UNIT)) {
       return _resolvedUnitState;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       return _referencedLibrariesState;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       return _resolutionErrorsState;
     } else if (identical(descriptor, HtmlEntry.HINTS)) {
       return _hintsState;
     }
     return super.getState(descriptor);
   }
 
+  @override
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, HtmlEntry.ANGULAR_APPLICATION)) {
       return _angularApplication;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_COMPONENT)) {
       return _angularComponent;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_ENTRY)) {
       return _angularEntry;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_ERRORS)) {
       return _angularErrors;
     } else if (identical(descriptor, HtmlEntry.ELEMENT)) {
       return _element;
     } else if (identical(descriptor, HtmlEntry.PARSE_ERRORS)) {
       return _parseErrors;
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       return _parsedUnit;
     } else if (identical(descriptor, HtmlEntry.RESOLVED_UNIT)) {
       return _resolvedUnit;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       return _referencedLibraries;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       return _resolutionErrors;
     } else if (identical(descriptor, HtmlEntry.HINTS)) {
       return _hints;
     }
     return super.getValue(descriptor);
   }
 
+  @override
   HtmlEntryImpl get writableCopy {
     HtmlEntryImpl copy = new HtmlEntryImpl();
     copy.copyFrom(this);
     return copy;
   }
 
+  @override
   void invalidateAllInformation() {
     super.invalidateAllInformation();
     _parseErrors = AnalysisError.NO_ERRORS;
     _parseErrorsState = CacheState.INVALID;
     _parsedUnit = null;
     _parsedUnitState = CacheState.INVALID;
     _resolvedUnit = null;
     _resolvedUnitState = CacheState.INVALID;
     _referencedLibraries = Source.EMPTY_ARRAY;
     _referencedLibrariesState = CacheState.INVALID;
     invalidateAllResolutionInformation();
   }
 
   /**
    * Invalidate all of the resolution information associated with the HTML file.
    */
   void invalidateAllResolutionInformation() {
     _angularEntry = null;
     _angularEntryState = CacheState.INVALID;
     _angularErrors = AnalysisError.NO_ERRORS;
     _angularErrorsState = CacheState.INVALID;
     _element = null;
     _elementState = CacheState.INVALID;
     _resolutionErrors = AnalysisError.NO_ERRORS;
     _resolutionErrorsState = CacheState.INVALID;
     _hints = AnalysisError.NO_ERRORS;
     _hintsState = CacheState.INVALID;
   }
 
+  @override
   void recordContentError() {
     super.recordContentError();
     recordParseError();
   }
 
   /**
    * Record that an error was encountered while attempting to parse the source associated with this
    * entry.
    */
   void recordParseError() {
     setState(SourceEntry.LINE_INFO, CacheState.ERROR);
     setState(HtmlEntry.PARSE_ERRORS, CacheState.ERROR);
     setState(HtmlEntry.PARSED_UNIT, CacheState.ERROR);
     setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.ERROR);
     recordResolutionError();
   }
 
   /**
    * Record that an error was encountered while attempting to resolve the source associated with
    * this entry.
    */
   void recordResolutionError() {
     setState(HtmlEntry.ANGULAR_ERRORS, CacheState.ERROR);
     setState(HtmlEntry.RESOLVED_UNIT, CacheState.ERROR);
     setState(HtmlEntry.ELEMENT, CacheState.ERROR);
     setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.ERROR);
     setState(HtmlEntry.HINTS, CacheState.ERROR);
   }
 
+  @override
   void setState(DataDescriptor descriptor, CacheState state) {
     if (identical(descriptor, HtmlEntry.ANGULAR_APPLICATION)) {
       _angularApplication = updatedValue(state, _angularApplication, null);
       _angularApplicationState = state;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_COMPONENT)) {
       _angularComponent = updatedValue(state, _angularComponent, null);
       _angularComponentState = state;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_ENTRY)) {
       _angularEntry = updatedValue(state, _angularEntry, null);
       _angularEntryState = state;
@@ skipping 19 matching lines @@
       _resolutionErrors = updatedValue(state, _resolutionErrors, AnalysisError.NO_ERRORS);
       _resolutionErrorsState = state;
     } else if (identical(descriptor, HtmlEntry.HINTS)) {
       _hints = updatedValue(state, _hints, AnalysisError.NO_ERRORS);
       _hintsState = state;
     } else {
       super.setState(descriptor, state);
     }
   }
 
+  @override
   void setValue(DataDescriptor descriptor, Object value) {
     if (identical(descriptor, HtmlEntry.ANGULAR_APPLICATION)) {
       _angularApplication = value as AngularApplication;
       _angularApplicationState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_COMPONENT)) {
       _angularComponent = value as AngularComponentElement;
       _angularComponentState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_ENTRY)) {
       _angularEntry = value as AngularApplication;
       _angularEntryState = CacheState.VALID;
@@ skipping 19 matching lines @@
       _resolutionErrors = value as List<AnalysisError>;
       _resolutionErrorsState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.HINTS)) {
       _hints = value as List<AnalysisError>;
       _hintsState = CacheState.VALID;
     } else {
       super.setValue(descriptor, value);
     }
   }
 
+  @override
   void copyFrom(SourceEntryImpl entry) {
     super.copyFrom(entry);
     HtmlEntryImpl other = entry as HtmlEntryImpl;
     _angularApplicationState = other._angularApplicationState;
     _angularApplication = other._angularApplication;
     _angularComponentState = other._angularComponentState;
     _angularComponent = other._angularComponent;
     _angularEntryState = other._angularEntryState;
     _angularEntry = other._angularEntry;
     _angularErrorsState = other._angularErrorsState;
     _angularErrors = other._angularErrors;
     _parseErrorsState = other._parseErrorsState;
     _parseErrors = other._parseErrors;
     _parsedUnitState = other._parsedUnitState;
     _parsedUnit = other._parsedUnit;
     _resolvedUnitState = other._resolvedUnitState;
     _resolvedUnit = other._resolvedUnit;
     _referencedLibrariesState = other._referencedLibrariesState;
     _referencedLibraries = other._referencedLibraries;
     _resolutionErrors = other._resolutionErrors;
     _resolutionErrorsState = other._resolutionErrorsState;
     _elementState = other._elementState;
     _element = other._element;
     _hints = other._hints;
     _hintsState = other._hintsState;
   }
 
+  @override
   bool get hasErrorState => super.hasErrorState || identical(_parsedUnitState, CacheState.ERROR) || identical(_resolvedUnitState, CacheState.ERROR) || identical(_parseErrorsState, CacheState.ERROR) || identical(_resolutionErrorsState, CacheState.ERROR) || identical(_referencedLibrariesState, CacheState.ERROR) || identical(_elementState, CacheState.ERROR) || identical(_angularErrorsState, CacheState.ERROR) || identical(_hintsState, CacheState.ERROR);
 
+  @override
   void writeOn(JavaStringBuilder builder) {
     builder.append("Html: ");
     super.writeOn(builder);
     builder.append("; parseErrors = ");
     builder.append(_parseErrorsState);
     builder.append("; parsedUnit = ");
     builder.append(_parsedUnitState);
     builder.append("; resolvedUnit = ");
     builder.append(_resolvedUnitState);
     builder.append("; resolutionErrors = ");
@@ skipping 156 matching lines @@
         // This code should never be reached, but is a fail-safe in case an exception is not
         // recorded when it should be.
         //
         exception = new AnalysisException.con1("State set to ERROR without setting an exception");
       }
     } else {
       exception = null;
     }
   }
 
+  @override
   int get modificationTime => _modificationTime;
 
+  @override
   CacheState getState(DataDescriptor descriptor) {
     if (identical(descriptor, SourceEntry.CONTENT)) {
       return _contentState;
     } else if (identical(descriptor, SourceEntry.LINE_INFO)) {
       return _lineInfoState;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
+  @override
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, SourceEntry.CONTENT)) {
       return _content;
     } else if (identical(descriptor, SourceEntry.LINE_INFO)) {
       return _lineInfo;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
@@ skipping 56 matching lines @@
       _content = value as String;
       _contentState = CacheState.VALID;
     } else if (identical(descriptor, SourceEntry.LINE_INFO)) {
       _lineInfo = value as LineInfo;
       _lineInfoState = CacheState.VALID;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
+  @override
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     writeOn(builder);
     return builder.toString();
   }
 
   /**
    * Copy the information from the given cache entry.
    *
    * @param entry the cache entry from which information will be copied
@@ skipping 58 matching lines @@
   Map<String, AnalysisContentStatistics_CacheRow> _dataMap = new Map<String, AnalysisContentStatistics_CacheRow>();
 
   List<Source> _sources = new List<Source>();
 
   Set<AnalysisException> _exceptions = new Set<AnalysisException>();
 
   void addSource(Source source) {
     _sources.add(source);
   }
 
+  @override
   List<AnalysisContentStatistics_CacheRow> get cacheRows {
     Iterable<AnalysisContentStatistics_CacheRow> items = _dataMap.values;
     return new List.from(items);
   }
 
+  @override
   List<AnalysisException> get exceptions => new List.from(_exceptions);
 
+  @override
   List<Source> get sources => new List.from(_sources);
 
   void putCacheItem(SourceEntry dartEntry, DataDescriptor descriptor) {
     _internalPutCacheItem(dartEntry, descriptor, dartEntry.getState(descriptor));
   }
 
   void putCacheItemInLibrary(DartEntry dartEntry, Source librarySource, DataDescriptor descriptor) {
     _internalPutCacheItem(dartEntry, descriptor, dartEntry.getStateInLibrary(descriptor, librarySource));
   }
 
@@ skipping 22 matching lines @@
   int _flushedCount = 0;
 
   int _inProcessCount = 0;
 
   int _invalidCount = 0;
 
   int _validCount = 0;
 
   AnalysisContentStatisticsImpl_CacheRowImpl(this.name);
 
+  @override
   bool operator ==(Object obj) => obj is AnalysisContentStatisticsImpl_CacheRowImpl && obj.name == name;
 
+  @override
   int get errorCount => _errorCount;
 
+  @override
   int get flushedCount => _flushedCount;
 
+  @override
   int get inProcessCount => _inProcessCount;
 
+  @override
   int get invalidCount => _invalidCount;
 
+  @override
   int get validCount => _validCount;
 
+  @override
   int get hashCode => name.hashCode;
 
   void _incState(CacheState state) {
     if (identical(state, CacheState.ERROR)) {
       _errorCount++;
     }
     if (identical(state, CacheState.FLUSHED)) {
       _flushedCount++;
     }
     if (identical(state, CacheState.IN_PROCESS)) {
@@ skipping 94 matching lines @@
   Set<AngularApplication> _angularApplications = new Set();
 
   /**
    * Initialize a newly created analysis context.
    */
   AnalysisContextImpl() : super() {
     _resultRecorder = new AnalysisContextImpl_AnalysisTaskResultRecorder(this);
     _cache = new AnalysisCache(AnalysisOptionsImpl.DEFAULT_CACHE_SIZE, new AnalysisContextImpl_ContextRetentionPolicy(this));
   }
 
+  @override
   void addSourceInfo(Source source, SourceEntry info) {
     // This implementation assumes that the access to the cache does not need to be synchronized
     // because no other object can have access to this context while this method is being invoked.
     _cache.put(source, info);
   }
 
+  @override
   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) {
@@ skipping 35 matching lines @@
             priority = SourcePriority.LIBRARY;
           } else if (identical(kind, SourceKind.PART)) {
             priority = SourcePriority.NORMAL_PART;
           }
           _workManager.add(source, priority);
         }
       }
     }
   }
 
+  @override
   String computeDocumentationComment(Element element) {
     if (element == null) {
       return null;
     }
     Source source = element.source;
     if (source == null) {
       return null;
     }
     CompilationUnit unit = parseCompilationUnit(source);
     if (unit == null) {
@@ skipping 15 matching lines @@
           }
           builder.append(tokens[i].lexeme);
         }
         return builder.toString();
       }
       nameNode = nameNode.parent;
     }
     return null;
   }
 
+  @override
   List<AnalysisError> computeErrors(Source source) {
     bool enableHints = _options.hint;
     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));
@@ skipping 29 matching lines @@
       HtmlEntry htmlEntry = sourceEntry;
       try {
         return _getHtmlResolutionData2(source, htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
       } on ObsoleteSourceAnalysisException catch (exception) {
         AnalysisEngine.instance.logger.logInformation2("Could not compute errors", exception);
       }
     }
     return AnalysisError.NO_ERRORS;
   }
 
+  @override
   List<Source> computeExportedLibraries(Source source) => _getDartDependencyData2(source, DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
 
+  @override
   HtmlElement computeHtmlElement(Source source) => _getHtmlResolutionData(source, HtmlEntry.ELEMENT, null);
 
+  @override
   List<Source> computeImportedLibraries(Source source) => _getDartDependencyData2(source, DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
 
+  @override
   SourceKind computeKindOf(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     } else if (sourceEntry is DartEntry) {
       try {
         return _getDartParseData(source, sourceEntry, DartEntry.SOURCE_KIND);
       } on AnalysisException catch (exception) {
         return SourceKind.UNKNOWN;
       }
     }
     return sourceEntry.kind;
   }
 
+  @override
   LibraryElement computeLibraryElement(Source source) => _getDartResolutionData2(source, source, DartEntry.ELEMENT, null);
 
+  @override
   LineInfo computeLineInfo(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntry(source);
     try {
       if (sourceEntry is HtmlEntry) {
         return _getHtmlParseData(source, SourceEntry.LINE_INFO, null);
       } else if (sourceEntry is DartEntry) {
         return _getDartScanData2(source, SourceEntry.LINE_INFO, null);
       }
     } on ObsoleteSourceAnalysisException catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Could not compute ${SourceEntry.LINE_INFO.toString()}", exception);
     }
     return null;
   }
 
+  @override
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source 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);
     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);
   }
 
+  @override
   void dispose() {
     _disposed = true;
   }
 
+  @override
   bool exists(Source source) {
     if (source == null) {
       return false;
     }
     if (_contentCache.getContents(source) != null) {
       return true;
     }
     return source.exists();
   }
 
+  @override
   AnalysisContext extractContext(SourceContainer container) => extractContextInto(container, AnalysisEngine.instance.createAnalysisContext() as InternalAnalysisContext);
 
+  @override
   InternalAnalysisContext extractContextInto(SourceContainer container, InternalAnalysisContext newContext) {
     List<Source> sourcesToRemove = new List<Source>();
     // Move sources in the specified directory to the new context
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       Source source = entry.getKey();
       if (container.contains(source)) {
         sourcesToRemove.add(source);
         newContext.addSourceInfo(source, entry.getValue().writableCopy);
       }
     }
     return newContext;
   }
 
+  @override
   AnalysisOptions get analysisOptions => _options;
 
+  @override
   CompilationUnitElement getCompilationUnitElement(Source unitSource, Source librarySource) {
     LibraryElement libraryElement = getLibraryElement(librarySource);
     if (libraryElement != null) {
       // try defining unit
       CompilationUnitElement definingUnit = libraryElement.definingCompilationUnit;
       if (definingUnit.source == unitSource) {
         return definingUnit;
       }
       // try parts
       for (CompilationUnitElement partUnit in libraryElement.parts) {
         if (partUnit.source == unitSource) {
           return partUnit;
         }
       }
     }
     return null;
   }
 
+  @override
   TimestampedData<String> getContents(Source source) {
     String contents = _contentCache.getContents(source);
     if (contents != null) {
       return new TimestampedData<String>(_contentCache.getModificationStamp(source), contents);
     }
     return source.contents;
   }
 
+  @override
   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]);
       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;
     }
   }
 
+  @override
   AnalysisErrorInfo getErrors(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(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);
   }
 
+  @override
   HtmlElement getHtmlElement(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry is HtmlEntry) {
       return sourceEntry.getValue(HtmlEntry.ELEMENT);
     }
     return null;
   }
 
+  @override
   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)) {
               htmlSources.add(entry.getKey());
             }
           }
         }
       }
       break;
     }
     if (htmlSources.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(htmlSources);
   }
 
+  @override
   List<Source> get htmlSources => _getSources(SourceKind.HTML);
 
+  @override
   SourceKind getKindOf(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     }
     return sourceEntry.kind;
   }
 
+  @override
   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>();
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       Source source = entry.getKey();
       SourceEntry sourceEntry = entry.getValue();
       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);
   }
 
+  @override
   List<Source> get launchableServerLibrarySources {
     // TODO(brianwilkerson) This needs to filter out libraries that reference dart:html, either
     // directly or indirectly.
     List<Source> sources = new List<Source>();
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       Source source = entry.getKey();
       SourceEntry sourceEntry = entry.getValue();
       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);
   }
 
+  @override
   List<Source> getLibrariesContaining(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
     }
     return Source.EMPTY_ARRAY;
   }
 
+  @override
   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)) {
           dependentLibraries.add(entry.getKey());
         }
         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);
   }
 
+  @override
   LibraryElement getLibraryElement(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValue(DartEntry.ELEMENT);
     }
     return null;
   }
 
+  @override
   List<Source> get librarySources => _getSources(SourceKind.LIBRARY);
 
+  @override
   LineInfo getLineInfo(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry != null) {
       return sourceEntry.getValue(SourceEntry.LINE_INFO);
     }
     return null;
   }
 
+  @override
   int getModificationStamp(Source source) {
     int stamp = _contentCache.getModificationStamp(source);
     if (stamp != null) {
       return stamp;
     }
     return source.modificationStamp;
   }
 
+  @override
   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);
     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);
       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;
         dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
         _cache.put(source, dartCopy);
       }
     }
     return namespace;
   }
 
+  @override
   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);
     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);
       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;
         dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
         _cache.put(source, dartCopy);
       }
     }
     return namespace;
   }
 
+  @override
   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);
   }
 
+  @override
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return getResolvedCompilationUnit2(unitSource, library.source);
   }
 
+  @override
   CompilationUnit getResolvedCompilationUnit2(Source unitSource, Source librarySource) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(unitSource);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
     }
     return null;
   }
 
+  @override
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(htmlSource);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
     }
     return null;
   }
 
+  @override
   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) {
       _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()) {
       _getSourcesNeedingProcessing(entry.getKey(), entry.getValue(), false, hintsEnabled, sources);
     }
     return new List<Source>.from(sources);
   }
 
+  @override
   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) {
         Source source = mapEntry.getKey();
         DartEntry dartEntry = entry;
         SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
         // get library independent values
@@ skipping 22 matching lines @@
         statistics.putCacheItem(htmlEntry, SourceEntry.LINE_INFO);
         statistics.putCacheItem(htmlEntry, HtmlEntry.PARSE_ERRORS);
         statistics.putCacheItem(htmlEntry, HtmlEntry.PARSED_UNIT);
         statistics.putCacheItem(htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
         statistics.putCacheItem(htmlEntry, HtmlEntry.RESOLVED_UNIT);
       }
     }
     return statistics;
   }
 
+  @override
   TypeProvider get typeProvider {
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     return new TypeProviderImpl(computeLibraryElement(coreSource));
   }
 
+  @override
   TimestampedData<CompilationUnit> internalResolveCompilationUnit(Source unitSource, LibraryElement libraryElement) {
     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);
     return new TimestampedData<CompilationUnit>(dartEntry.modificationTime, dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource));
   }
 
+  @override
   bool isClientLibrary(Source 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;
   }
 
+  @override
   bool get isDisposed => _disposed;
 
+  @override
   bool isServerLibrary(Source 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;
   }
 
+  @override
   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);
       if (existingEntry == null) {
         // TODO(brianwilkerson) Decide whether we really need to copy the info.
         _cache.put(newSource, entry.getValue().writableCopy);
       } else {
       }
     }
   }
 
+  @override
   CompilationUnit parseCompilationUnit(Source source) => _getDartParseData2(source, DartEntry.PARSED_UNIT, null);
 
+  @override
   ht.HtmlUnit parseHtmlUnit(Source source) => _getHtmlParseData(source, HtmlEntry.PARSED_UNIT, null);
 
+  @override
   AnalysisResult performAnalysisTask() {
     int getStart = JavaSystem.currentTimeMillis();
     AnalysisTask task = nextAnalysisTask;
     int getEnd = JavaSystem.currentTimeMillis();
     if (task == null && _validateCacheConsistency()) {
       task = nextAnalysisTask;
     }
     if (task == null) {
       return new AnalysisResult(_getChangeNotices(true), getEnd - getStart, null, -1);
     }
@@ skipping 10 matching lines @@
       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);
   }
 
+  @override
   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);
       if (dartEntry != null) {
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         _recordElementData(dartEntry, dartCopy, library, library.source, htmlSource);
         _cache.put(librarySource, dartCopy);
       }
     }
   }
 
+  @override
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return resolveCompilationUnit2(unitSource, library.source);
   }
 
+  @override
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) => _getDartResolutionData2(unitSource, librarySource, DartEntry.RESOLVED_UNIT, null);
 
+  @override
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     computeHtmlElement(htmlSource);
     return parseHtmlUnit(htmlSource);
   }
 
+  @override
   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) {
       this._options.cacheSize = cacheSize;
       _cache.maxCacheSize = cacheSize;
       //
       // Cap the size of the priority list to being less than the cache size. Failure to do so can
       // result in an infinite loop in performAnalysisTask() because re-caching one AST structure
       // can cause another priority source's AST structure to be flushed.
       //
       int maxPriorityOrderSize = cacheSize - _PRIORITY_ORDER_SIZE_DELTA;
       if (_priorityOrder.length > maxPriorityOrderSize) {
         List<Source> newPriorityOrder = new List<Source>(maxPriorityOrderSize);
         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();
     }
   }
 
+  @override
   void set analysisPriorityOrder(List<Source> sources) {
     if (sources == null || sources.isEmpty) {
       _priorityOrder = Source.EMPTY_ARRAY;
     } else {
       while (sources.remove(null)) {
       }
       if (sources.isEmpty) {
         _priorityOrder = Source.EMPTY_ARRAY;
       }
       //
       // Cap the size of the priority list to being less than the cache size. Failure to do so can
       // result in an infinite loop in performAnalysisTask() because re-caching one AST structure
       // can cause another priority source's AST structure to be flushed.
       //
       int count = Math.min(sources.length, _options.cacheSize - _PRIORITY_ORDER_SIZE_DELTA);
       _priorityOrder = new List<Source>(count);
       for (int i = 0; i < count; i++) {
         _priorityOrder[i] = sources[i];
       }
     }
   }
 
+  @override
   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));
         }
         _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);
     }
   }
 
+  @override
   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);
         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);
     }
   }
 
+  @override
   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;
@@ skipping 2766 matching lines @@
 
 /**
  * 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);
 
+  @override
   DartEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task) => AnalysisContextImpl_this._recordGenerateDartErrorsTask(task);
 
+  @override
   DartEntry visitGenerateDartHintsTask(GenerateDartHintsTask task) => AnalysisContextImpl_this._recordGenerateDartHintsTask(task);
 
+  @override
   SourceEntry visitGetContentTask(GetContentTask task) => AnalysisContextImpl_this._recordGetContentsTask(task);
 
+  @override
   DartEntry visitIncrementalAnalysisTask(IncrementalAnalysisTask task) => AnalysisContextImpl_this._recordIncrementalAnalysisTaskResults(task);
 
+  @override
   DartEntry visitParseDartTask(ParseDartTask task) => AnalysisContextImpl_this._recordParseDartTaskResults(task);
 
+  @override
   HtmlEntry visitParseHtmlTask(ParseHtmlTask task) => AnalysisContextImpl_this._recordParseHtmlTaskResults(task);
 
+  @override
   HtmlEntry visitResolveAngularComponentTemplateTask(ResolveAngularComponentTemplateTask task) => AnalysisContextImpl_this._recordResolveAngularComponentTemplateTaskResults(task);
 
+  @override
   HtmlEntry visitResolveAngularEntryHtmlTask(ResolveAngularEntryHtmlTask task) => AnalysisContextImpl_this._recordResolveAngularEntryHtmlTaskResults(task);
 
+  @override
   DartEntry visitResolveDartDependenciesTask(ResolveDartDependenciesTask task) => AnalysisContextImpl_this._recordResolveDartDependenciesTaskResults(task);
 
+  @override
   DartEntry visitResolveDartLibraryTask(ResolveDartLibraryTask task) => AnalysisContextImpl_this.recordResolveDartLibraryTaskResults(task);
 
+  @override
   DartEntry visitResolveDartUnitTask(ResolveDartUnitTask task) => AnalysisContextImpl_this._recordResolveDartUnitTaskResults(task);
 
+  @override
   HtmlEntry visitResolveHtmlTask(ResolveHtmlTask task) => AnalysisContextImpl_this._recordResolveHtmlTaskResults(task);
 
+  @override
   DartEntry visitScanDartTask(ScanDartTask task) => AnalysisContextImpl_this._recordScanDartTaskResults(task);
 }
 
 class AnalysisContextImpl_ContextRetentionPolicy implements CacheRetentionPolicy {
   final AnalysisContextImpl AnalysisContextImpl_this;
 
   AnalysisContextImpl_ContextRetentionPolicy(this.AnalysisContextImpl_this);
 
+  @override
   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)) {
         return RetentionPriority.MEDIUM;
@@ skipping 143 matching lines @@
    *
    * @param options the analysis options whose values are being copied
    */
   AnalysisOptionsImpl.con1(AnalysisOptions options) {
     cacheSize = options.cacheSize;
     dart2jsHint = options.dart2jsHint;
     hint = options.hint;
     incremental = options.incremental;
   }
 
+  @override
   bool get generateSdkErrors => _generateSdkErrors;
 
   /**
    * Set whether errors, warnings and hints should be generated for sources in the SDK to match the
    * given value.
    *
    * @param generate `true` if errors, warnings and hints should be generated for sources in
    *          the SDK
    */
   void set generateSdkErrors(bool generate) {
@@ skipping 39 matching lines @@
    */
   static List<ChangeNoticeImpl> EMPTY_ARRAY = new List<ChangeNoticeImpl>(0);
 
   /**
    * Initialize a newly created notice associated with the given source.
    *
    * @param source the source for which the change is being reported
    */
   ChangeNoticeImpl(this.source);
 
+  @override
   List<AnalysisError> get errors => _errors;
 
+  @override
   LineInfo get lineInfo => _lineInfo;
 
   /**
    * 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.logInformation2("No line info: ${source}", new JavaException());
     }
   }
 
+  @override
   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.
  */
 class DelegatingAnalysisContextImpl extends AnalysisContextImpl {
   /**
    * This references the [InternalAnalysisContext] held onto by the [DartSdk] which is
    * used (instead of this [AnalysisContext]) for SDK sources. This field is set when
    * #setSourceFactory(SourceFactory) is called, and references the analysis context in the
    * [DartUriResolver] in the [SourceFactory], this analysis context assumes that there
    * will be such a resolver.
    */
   InternalAnalysisContext _sdkAnalysisContext;
 
+  @override
   void addSourceInfo(Source source, SourceEntry info) {
     if (source.isInSystemLibrary) {
       _sdkAnalysisContext.addSourceInfo(source, info);
     } else {
       super.addSourceInfo(source, info);
     }
   }
 
+  @override
   List<AnalysisError> computeErrors(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeErrors(source);
     } else {
       return super.computeErrors(source);
     }
   }
 
+  @override
   List<Source> computeExportedLibraries(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeExportedLibraries(source);
     } else {
       return super.computeExportedLibraries(source);
     }
   }
 
+  @override
   HtmlElement computeHtmlElement(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeHtmlElement(source);
     } else {
       return super.computeHtmlElement(source);
     }
   }
 
+  @override
   List<Source> computeImportedLibraries(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeImportedLibraries(source);
     } else {
       return super.computeImportedLibraries(source);
     }
   }
 
+  @override
   SourceKind computeKindOf(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeKindOf(source);
     } else {
       return super.computeKindOf(source);
     }
   }
 
+  @override
   LibraryElement computeLibraryElement(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeLibraryElement(source);
     } else {
       return super.computeLibraryElement(source);
     }
   }
 
+  @override
   LineInfo computeLineInfo(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeLineInfo(source);
     } else {
       return super.computeLineInfo(source);
     }
   }
 
+  @override
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeResolvableCompilationUnit(source);
     } else {
       return super.computeResolvableCompilationUnit(source);
     }
   }
 
+  @override
   AnalysisErrorInfo getErrors(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getErrors(source);
     } else {
       return super.getErrors(source);
     }
   }
 
+  @override
   HtmlElement getHtmlElement(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getHtmlElement(source);
     } else {
       return super.getHtmlElement(source);
     }
   }
 
+  @override
   List<Source> getHtmlFilesReferencing(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getHtmlFilesReferencing(source);
     } else {
       return super.getHtmlFilesReferencing(source);
     }
   }
 
+  @override
   SourceKind getKindOf(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getKindOf(source);
     } else {
       return super.getKindOf(source);
     }
   }
 
+  @override
   List<Source> getLibrariesContaining(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getLibrariesContaining(source);
     } else {
       return super.getLibrariesContaining(source);
     }
   }
 
+  @override
   List<Source> getLibrariesDependingOn(Source librarySource) {
     if (librarySource.isInSystemLibrary) {
       return _sdkAnalysisContext.getLibrariesDependingOn(librarySource);
     } else {
       return super.getLibrariesDependingOn(librarySource);
     }
   }
 
+  @override
   LibraryElement getLibraryElement(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getLibraryElement(source);
     } else {
       return super.getLibraryElement(source);
     }
   }
 
+  @override
   List<Source> get librarySources => ArrayUtils.addAll(super.librarySources, _sdkAnalysisContext.librarySources);
 
+  @override
   LineInfo getLineInfo(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getLineInfo(source);
     } else {
       return super.getLineInfo(source);
     }
   }
 
+  @override
   Namespace getPublicNamespace(LibraryElement library) {
     Source source = library.source;
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getPublicNamespace(library);
     } else {
       return super.getPublicNamespace(library);
     }
   }
 
+  @override
   Namespace getPublicNamespace2(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getPublicNamespace2(source);
     } else {
       return super.getPublicNamespace2(source);
     }
   }
 
+  @override
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     if (unitSource.isInSystemLibrary) {
       return _sdkAnalysisContext.getResolvedCompilationUnit(unitSource, library);
     } else {
       return super.getResolvedCompilationUnit(unitSource, library);
     }
   }
 
+  @override
   CompilationUnit getResolvedCompilationUnit2(Source unitSource, Source librarySource) {
     if (unitSource.isInSystemLibrary) {
       return _sdkAnalysisContext.getResolvedCompilationUnit2(unitSource, librarySource);
     } else {
       return super.getResolvedCompilationUnit2(unitSource, librarySource);
     }
   }
 
+  @override
   bool isClientLibrary(Source librarySource) {
     if (librarySource.isInSystemLibrary) {
       return _sdkAnalysisContext.isClientLibrary(librarySource);
     } else {
       return super.isClientLibrary(librarySource);
     }
   }
 
+  @override
   bool isServerLibrary(Source librarySource) {
     if (librarySource.isInSystemLibrary) {
       return _sdkAnalysisContext.isServerLibrary(librarySource);
     } else {
       return super.isServerLibrary(librarySource);
     }
   }
 
+  @override
   CompilationUnit parseCompilationUnit(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.parseCompilationUnit(source);
     } else {
       return super.parseCompilationUnit(source);
     }
   }
 
+  @override
   ht.HtmlUnit parseHtmlUnit(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.parseHtmlUnit(source);
     } else {
       return super.parseHtmlUnit(source);
     }
   }
 
+  @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     if (elementMap.isEmpty) {
       return;
     }
     // TODO(jwren) we are making the assumption here that the elementMap will have sources from only
     // one library, while this is true with our use of the Analysis Engine, it is not required by
     // the API, revisit to fix cases where the elementMap can have sources both in the sdk and other
     // libraries
     Source source = new JavaIterator(elementMap.keys.toSet()).next();
     if (source.isInSystemLibrary) {
       _sdkAnalysisContext.recordLibraryElements(elementMap);
     } else {
       super.recordLibraryElements(elementMap);
     }
   }
 
+  @override
   CompilationUnit resolveCompilationUnit(Source source, LibraryElement library) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.resolveCompilationUnit(source, library);
     } else {
       return super.resolveCompilationUnit(source, library);
     }
   }
 
+  @override
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) {
     if (unitSource.isInSystemLibrary) {
       return _sdkAnalysisContext.resolveCompilationUnit2(unitSource, librarySource);
     } else {
       return super.resolveCompilationUnit2(unitSource, librarySource);
     }
   }
 
+  @override
   ht.HtmlUnit resolveHtmlUnit(Source unitSource) {
     if (unitSource.isInSystemLibrary) {
       return _sdkAnalysisContext.resolveHtmlUnit(unitSource);
     } else {
       return super.resolveHtmlUnit(unitSource);
     }
   }
 
+  @override
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
     if (source.isInSystemLibrary) {
       _sdkAnalysisContext.setChangedContents(source, contents, offset, oldLength, newLength);
     } else {
       super.setChangedContents(source, contents, offset, oldLength, newLength);
     }
   }
 
+  @override
   void setContents(Source source, String contents) {
     if (source.isInSystemLibrary) {
       _sdkAnalysisContext.setContents(source, contents);
     } else {
       super.setContents(source, contents);
     }
   }
 
+  @override
   void set sourceFactory(SourceFactory factory) {
     super.sourceFactory = factory;
     DartSdk sdk = factory.dartSdk;
     if (sdk != null) {
       _sdkAnalysisContext = sdk.context as InternalAnalysisContext;
       if (_sdkAnalysisContext is DelegatingAnalysisContextImpl) {
         _sdkAnalysisContext = null;
         throw new IllegalStateException("The context provided by an SDK cannot itself be a delegating analysis context");
       }
     } else {
@@ skipping 218 matching lines @@
   /**
    * Create a new [InstrumentedAnalysisContextImpl] with a specified basis context, aka the
    * context to wrap and instrument.
    *
    * @param context some [InstrumentedAnalysisContext] to wrap and instrument
    */
   InstrumentedAnalysisContextImpl.con1(InternalAnalysisContext context) {
     _basis = context;
   }
 
+  @override
   void addSourceInfo(Source source, SourceEntry info) {
     _basis.addSourceInfo(source, info);
   }
 
+  @override
   void applyChanges(ChangeSet changeSet) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-applyChanges");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.applyChanges(changeSet);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   String computeDocumentationComment(Element element) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeDocumentationComment");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeDocumentationComment(element);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   List<AnalysisError> computeErrors(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeErrors");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<AnalysisError> errors = _basis.computeErrors(source);
       instrumentation.metric2("Errors-count", errors.length);
       return errors;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   List<Source> computeExportedLibraries(Source source) => _basis.computeExportedLibraries(source);
 
+  @override
   HtmlElement computeHtmlElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeHtmlElement");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeHtmlElement(source);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   List<Source> computeImportedLibraries(Source source) => _basis.computeImportedLibraries(source);
 
+  @override
   SourceKind computeKindOf(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeKindOf");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeKindOf(source);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   LibraryElement computeLibraryElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeLibraryElement");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeLibraryElement(source);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   LineInfo computeLineInfo(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeLineInfo");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeLineInfo(source);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) => _basis.computeResolvableCompilationUnit(source);
 
+  @override
   void dispose() {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-dispose");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.dispose();
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   bool exists(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-exists");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.exists(source);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   AnalysisContext extractContext(SourceContainer container) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-extractContext");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       InstrumentedAnalysisContextImpl newContext = new InstrumentedAnalysisContextImpl();
       _basis.extractContextInto(container, newContext._basis);
       return newContext;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   InternalAnalysisContext extractContextInto(SourceContainer container, InternalAnalysisContext newContext) => _basis.extractContextInto(container, newContext);
 
+  @override
   AnalysisOptions get analysisOptions {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getAnalysisOptions");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.analysisOptions;
     } finally {
       instrumentation.log();
     }
   }
 
   /**
    * @return the underlying [AnalysisContext].
    */
   AnalysisContext get basis => _basis;
 
+  @override
   CompilationUnitElement getCompilationUnitElement(Source unitSource, Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getCompilationUnitElement");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getCompilationUnitElement(unitSource, librarySource);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   TimestampedData<String> getContents(Source source) => _basis.getContents(source);
 
+  @override
   Element getElement(ElementLocation location) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getElement");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getElement(location);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   AnalysisErrorInfo getErrors(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getErrors");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       AnalysisErrorInfo ret = _basis.getErrors(source);
       if (ret != null) {
         instrumentation.metric2("Errors-count", ret.errors.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   HtmlElement getHtmlElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getHtmlElement");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getHtmlElement(source);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   List<Source> getHtmlFilesReferencing(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getHtmlFilesReferencing");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.getHtmlFilesReferencing(source);
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   List<Source> get htmlSources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getHtmlSources");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.htmlSources;
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   SourceKind getKindOf(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getKindOf");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getKindOf(source);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   List<Source> get launchableClientLibrarySources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLaunchableClientLibrarySources");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.launchableClientLibrarySources;
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   List<Source> get launchableServerLibrarySources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLaunchableServerLibrarySources");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.launchableServerLibrarySources;
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   List<Source> getLibrariesContaining(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibrariesContaining");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.getLibrariesContaining(source);
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log2(2);
     }
   }
 
+  @override
   List<Source> getLibrariesDependingOn(Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibrariesDependingOn");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.getLibrariesDependingOn(librarySource);
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   LibraryElement getLibraryElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibraryElement");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getLibraryElement(source);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   List<Source> get librarySources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibrarySources");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = _basis.librarySources;
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   LineInfo getLineInfo(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLineInfo");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getLineInfo(source);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   int getModificationStamp(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getModificationStamp");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getModificationStamp(source);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   Namespace getPublicNamespace(LibraryElement library) => _basis.getPublicNamespace(library);
 
+  @override
   Namespace getPublicNamespace2(Source source) => _basis.getPublicNamespace2(source);
 
+  @override
   List<Source> get refactoringUnsafeSources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getRefactoringUnsafeSources");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.refactoringUnsafeSources;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getResolvedCompilationUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getResolvedCompilationUnit(unitSource, library);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   CompilationUnit getResolvedCompilationUnit2(Source unitSource, Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getResolvedCompilationUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getResolvedCompilationUnit2(unitSource, librarySource);
     } finally {
       instrumentation.log2(2);
     }
   }
 
+  @override
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getResolvedHtmlUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getResolvedHtmlUnit(htmlSource);
     } finally {
       instrumentation.log2(2);
     }
   }
 
+  @override
   SourceFactory get sourceFactory {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getSourceFactory");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.sourceFactory;
     } finally {
       instrumentation.log2(2);
     }
   }
 
+  @override
   AnalysisContentStatistics get statistics => _basis.statistics;
 
+  @override
   TypeProvider get typeProvider => _basis.typeProvider;
 
+  @override
   TimestampedData<CompilationUnit> internalResolveCompilationUnit(Source unitSource, LibraryElement libraryElement) => _basis.internalResolveCompilationUnit(unitSource, libraryElement);
 
+  @override
   bool isClientLibrary(Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-isClientLibrary");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.isClientLibrary(librarySource);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   bool get isDisposed {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-isDisposed");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.isDisposed;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   bool isServerLibrary(Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-isServerLibrary");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.isServerLibrary(librarySource);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   void mergeContext(AnalysisContext context) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-mergeContext");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       if (context is InstrumentedAnalysisContextImpl) {
         context = (context as InstrumentedAnalysisContextImpl)._basis;
       }
       _basis.mergeContext(context);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   CompilationUnit parseCompilationUnit(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-parseCompilationUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.parseCompilationUnit(source);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   ht.HtmlUnit parseHtmlUnit(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-parseHtmlUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.parseHtmlUnit(source);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   AnalysisResult performAnalysisTask() {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-performAnalysisTask");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       AnalysisResult result = _basis.performAnalysisTask();
       if (result.changeNotices != null) {
         instrumentation.metric2("ChangeNotice-count", result.changeNotices.length);
       }
       return result;
     } finally {
       instrumentation.log2(2);
     }
   }
 
+  @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     _basis.recordLibraryElements(elementMap);
   }
 
+  @override
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveCompilationUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.resolveCompilationUnit(unitSource, library);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveCompilationUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.resolveCompilationUnit2(unitSource, librarySource);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveHtmlUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.resolveHtmlUnit(htmlSource);
     } on AnalysisException catch (e) {
       _recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   void set analysisOptions(AnalysisOptions options) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setAnalysisOptions");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.analysisOptions = options;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   void set analysisPriorityOrder(List<Source> sources) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setAnalysisPriorityOrder");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.analysisPriorityOrder = sources;
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setChangedContents");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.setChangedContents(source, contents, offset, oldLength, newLength);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   void setContents(Source source, String contents) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setContents");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.setContents(source, contents);
     } finally {
       instrumentation.log();
     }
   }
 
+  @override
   void set sourceFactory(SourceFactory factory) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setSourceFactory");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.sourceFactory = factory;
     } finally {
       instrumentation.log();
     }
   }
@@ skipping 203 matching lines @@
    */
   List<AnalysisError> getErrorsForSource(Source source) {
     Set<AnalysisError> errorsForSource = _errors[source];
     if (errorsForSource == null) {
       return AnalysisError.NO_ERRORS;
     } else {
       return new List.from(errorsForSource);
     }
   }
 
+  @override
   void onError(AnalysisError error) {
     Source source = error.source;
     Set<AnalysisError> errorsForSource = _errors[source];
     if (_errors[source] == null) {
       errorsForSource = new Set<AnalysisError>();
       _errors[source] = errorsForSource;
     }
     errorsForSource.add(error);
   }
 }
 
 /**
  * Instances of the class `ResolutionEraser` remove any resolution information from an AST
  * structure when used to visit that structure.
  */
 class ResolutionEraser extends GeneralizingAstVisitor<Object> {
+  @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitAssignmentExpression(node);
   }
 
+  @override
   Object visitBinaryExpression(BinaryExpression node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitBinaryExpression(node);
   }
 
+  @override
   Object visitCompilationUnit(CompilationUnit node) {
     node.element = null;
     return super.visitCompilationUnit(node);
   }
 
+  @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     node.element = null;
     return super.visitConstructorDeclaration(node);
   }
 
+  @override
   Object visitConstructorName(ConstructorName node) {
     node.staticElement = null;
     return super.visitConstructorName(node);
   }
 
+  @override
   Object visitDirective(Directive node) {
     node.element = null;
     return super.visitDirective(node);
   }
 
+  @override
   Object visitExpression(Expression node) {
     node.staticType = null;
     node.propagatedType = null;
     return super.visitExpression(node);
   }
 
+  @override
   Object visitFunctionExpression(FunctionExpression node) {
     node.element = null;
     return super.visitFunctionExpression(node);
   }
 
+  @override
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitFunctionExpressionInvocation(node);
   }
 
+  @override
   Object visitIndexExpression(IndexExpression node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitIndexExpression(node);
   }
 
+  @override
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     node.staticElement = null;
     return super.visitInstanceCreationExpression(node);
   }
 
+  @override
   Object visitPostfixExpression(PostfixExpression node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitPostfixExpression(node);
   }
 
+  @override
   Object visitPrefixExpression(PrefixExpression node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitPrefixExpression(node);
   }
 
+  @override
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     node.staticElement = null;
     return super.visitRedirectingConstructorInvocation(node);
   }
 
+  @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitSimpleIdentifier(node);
   }
 
+  @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     node.staticElement = null;
     return super.visitSuperConstructorInvocation(node);
   }
 }
 
 /**
  * Instances of the class `ResolvableCompilationUnit` represent a compilation unit that is not
  * referenced by any other objects and for which we have modification stamp information. It is used
  * by the [LibraryResolver] to resolve a library.
@@ skipping 512 matching lines @@
     _resolveInternal(application.elements, component);
   }
 
   /**
    * Resolves [source] as an Angular application entry point.
    */
   void resolveEntryPoint(AngularApplication application) {
     _resolveInternal(application.elements, null);
   }
 
+  @override
   Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
     _parseEmbeddedExpressionsInAttribute(node);
     _resolveExpressions(node.expressions);
     return super.visitXmlAttributeNode(node);
   }
 
+  @override
   Object visitXmlTagNode(ht.XmlTagNode node) {
     bool wasAngular = _isAngular;
     try {
       // new Angular context
       if (node.getAttribute(_NG_APP) != null) {
         _isAngular = true;
         _visitModelDirectives(node);
       }
       // not Angular
       if (!_isAngular) {
@@ skipping 430 matching lines @@
   }
 }
 
 class AngularHtmlUnitResolver_FilteringAnalysisErrorListener implements AnalysisErrorListener {
   AnalysisErrorListener _listener;
 
   AngularHtmlUnitResolver_FilteringAnalysisErrorListener(AnalysisErrorListener listener) {
     this._listener = listener;
   }
 
+  @override
   void onError(AnalysisError error) {
     ErrorCode errorCode = error.errorCode;
     if (identical(errorCode, StaticWarningCode.UNDEFINED_GETTER) || identical(errorCode, StaticWarningCode.UNDEFINED_IDENTIFIER) || identical(errorCode, StaticTypeWarningCode.UNDEFINED_GETTER)) {
       return;
     }
     _listener.onError(error);
   }
 }
 
 class AngularHtmlUnitResolver_FoundAppError extends Error {
 }
 
 class RecursiveXmlVisitor_AngularHtmlUnitResolver_hasAngularAnnotation extends ht.RecursiveXmlVisitor<Object> {
+  @override
   Object visitXmlTagNode(ht.XmlTagNode node) {
     if (node.getAttribute(AngularHtmlUnitResolver._NG_APP) != null) {
       throw new AngularHtmlUnitResolver_FoundAppError();
     }
     return super.visitXmlTagNode(node);
   }
 }
 
 class RecursiveXmlVisitor_AngularHtmlUnitResolver_visitModelDirectives extends ht.RecursiveXmlVisitor<Object> {
   final AngularHtmlUnitResolver AngularHtmlUnitResolver_this;
 
   RecursiveXmlVisitor_AngularHtmlUnitResolver_visitModelDirectives(this.AngularHtmlUnitResolver_this) : super();
 
+  @override
   Object visitXmlTagNode(ht.XmlTagNode node) {
     NgModelProcessor directive = NgModelProcessor.INSTANCE;
     if (directive.canApply(node)) {
       directive._applyTopDeclarations(AngularHtmlUnitResolver_this, node);
     }
     return super.visitXmlTagNode(node);
   }
 }
 
 /**
@@ skipping 21 matching lines @@
   /**
    * The offset of the first character of the closing delimiter.
    */
   int _closingOffset = 0;
 
   AngularMoustacheXmlExpression(int openingOffset, int closingOffset, AngularExpression expression) : super(expression) {
     this._openingOffset = openingOffset;
     this._closingOffset = closingOffset;
   }
 
+  @override
   int get end => _closingOffset + CLOSING_DELIMITER_LENGTH;
 
+  @override
   int get length => _closingOffset + CLOSING_DELIMITER_LENGTH - _openingOffset;
 
+  @override
   int get offset => _openingOffset;
 }
 
 /**
  * Implementation of [AngularXmlExpression] for an [AngularExpression] embedded without
  * any wrapping characters.
  */
 class AngularRawXmlExpression extends AngularXmlExpression {
   AngularRawXmlExpression(AngularExpression expression) : super(expression);
 
+  @override
   int get end => expression.end;
 
+  @override
   int get length => expression.length;
 
+  @override
   int get offset => expression.offset;
 }
 
 /**
  * Abstract Angular specific [XmlExpression].
  */
 abstract class AngularXmlExpression extends ht.XmlExpression {
   /**
    * The expression that is enclosed between the delimiters.
    */
   final AngularExpression expression;
 
   AngularXmlExpression(this.expression);
 
+  @override
   ht.XmlExpression_Reference getReference(int offset) {
     // main expression
     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);
@@ skipping 29 matching lines @@
  * 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);
 
+  @override
   Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
     _visitExpressions(node.expressions);
     return super.visitXmlAttributeNode(node);
   }
 
+  @override
   Object visitXmlTagNode(ht.XmlTagNode node) {
     _visitExpressions(node.expressions);
     return super.visitXmlTagNode(node);
   }
 
   /**
    * Visits [Expression]s of the given [XmlExpression]s.
    */
   void _visitExpressions(List<ht.XmlExpression> expressions) {
     for (ht.XmlExpression xmlExpression in expressions) {
@@ skipping 16 matching lines @@
  * [NgComponentElementProcessor] applies [AngularComponentElement] by parsing mapped
  * attributes as expressions.
  */
 class NgComponentElementProcessor extends NgDirectiveProcessor {
   AngularComponentElement _element;
 
   NgComponentElementProcessor(AngularComponentElement element) {
     this._element = element;
   }
 
+  @override
   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);
           setAngularExpression(attribute, expression);
         }
       }
     }
   }
 
+  @override
   bool canApply(ht.XmlTagNode node) => _element.selector.apply(node);
 }
 
 /**
  * [NgControllerElementProcessor] applies [AngularControllerElement].
  */
 class NgControllerElementProcessor extends NgProcessor {
   AngularControllerElement _element;
 
   NgControllerElementProcessor(AngularControllerElement element) {
     this._element = element;
   }
 
+  @override
   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);
     variable.toolkitObjects = <AngularElement> [_element];
   }
 
+  @override
   bool canApply(ht.XmlTagNode node) => _element.selector.apply(node);
 }
 
 /**
  * [NgDirectiveElementProcessor] applies [AngularDirectiveElement] by parsing mapped
  * attributes as expressions.
  */
 class NgDirectiveElementProcessor extends NgDirectiveProcessor {
   AngularDirectiveElement _element;
 
   NgDirectiveElementProcessor(AngularDirectiveElement element) {
     this._element = element;
   }
 
+  @override
   void apply(AngularHtmlUnitResolver resolver, ht.XmlTagNode node) {
     String selectorAttributeName = null;
     {
       AngularSelectorElement selector = _element.selector;
       if (selector is HasAttributeSelectorElementImpl) {
         selectorAttributeName = selector.name;
         // resolve attribute expression
         ht.XmlAttributeNode attribute = node.getAttribute(selectorAttributeName);
         if (attribute != null) {
           attribute.element = selector;
@@ skipping 23 matching lines @@
             resolver._resolveExpression(expression);
             setAngularExpression(attribute, expression);
           } finally {
             resolver._popNameScope();
           }
         }
       }
     }
   }
 
+  @override
   bool canApply(ht.XmlTagNode node) => _element.selector.apply(node);
 
   /**
    * Support for <code>$event</code> variable in <code>NgEventDirective</code>.
    */
   void _onNgEventDirective(AngularHtmlUnitResolver resolver) {
     if (_element.isClass("NgEventDirective")) {
       DartType dynamicType = resolver.typeProvider.dynamicType;
       resolver._defineVariable(resolver._createLocalVariableWithName(dynamicType, "\$event"));
     }
@@ skipping 48 matching lines @@
 }
 
 /**
  * [NgModelProcessor] describes built-in <code>NgModel</code> directive.
  */
 class NgModelProcessor extends NgDirectiveProcessor {
   static String _NG_MODEL = "ng-model";
 
   static NgModelProcessor INSTANCE = new NgModelProcessor();
 
+  @override
   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);
     // remember expression
     setExpression(attribute, expression);
   }
 
+  @override
   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) {
     ht.XmlAttributeNode attribute = node.getAttribute(_NG_MODEL);
     Expression expression = parseDartExpression(resolver, attribute);
     // if not identifier, then not a top-level model, delay until "apply"
@@ skipping 83 matching lines @@
   Object perform(AnalysisTaskVisitor visitor) {
     try {
       _safelyPerform();
     } on AnalysisException catch (exception) {
       _thrownException = exception;
       AnalysisEngine.instance.logger.logInformation2("Task failed: ${taskDescription}", exception);
     }
     return accept(visitor);
   }
 
+  @override
   String toString() => taskDescription;
 
   /**
    * Return a textual description of this task.
    *
    * @return a textual description of this task
    */
   String get taskDescription;
 
   /**
@@ skipping 171 matching lines @@
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source for which errors and warnings are to be produced
    * @param libraryElement the element model for the library containing the source
    */
   GenerateDartErrorsTask(InternalAnalysisContext context, this.source, this.libraryElement) : super(context);
 
+  @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitGenerateDartErrorsTask(this);
 
   /**
    * Return the errors that were generated for the source.
    *
    * @return the errors that were generated for the source
    */
   List<AnalysisError> get errors => _errors;
 
   /**
    * Return the time at which the contents of the source that was verified were last modified, or a
    * negative value if the task has not yet been performed or if an exception occurred.
    *
    * @return the time at which the contents of the source that was verified were last modified
    */
   int get modificationTime => _modificationTime;
 
+  @override
   String get taskDescription => "generate errors and warnings for ${source.fullName}";
 
+  @override
   void internalPerform() {
     InternalAnalysisContext context = this.context;
     TimestampedData<CompilationUnit> data = context.internalResolveCompilationUnit(source, libraryElement);
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.errors.start();
     try {
       _modificationTime = data.modificationTime;
       CompilationUnit unit = data.data;
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       TypeProvider typeProvider = context.typeProvider;
@@ skipping 31 matching lines @@
   Map<Source, TimestampedData<List<AnalysisError>>> _hintMap;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param libraryElement the element model for the library being analyzed
    */
   GenerateDartHintsTask(InternalAnalysisContext context, this.libraryElement) : super(context);
 
+  @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitGenerateDartHintsTask(this);
 
   /**
    * Return a table mapping the sources that were analyzed to the hints that were generated for the
    * sources, or `null` if the task has not been performed or if the analysis did not complete
    * normally.
    *
    * @return a table mapping the sources that were analyzed to the hints that were generated for the
    *         sources
    */
   Map<Source, TimestampedData<List<AnalysisError>>> get hintMap => _hintMap;
 
+  @override
   String get taskDescription {
     Source librarySource = libraryElement.source;
     if (librarySource == null) {
       return "generate Dart hints for library without source";
     }
     return "generate Dart hints for ${librarySource.fullName}";
   }
 
+  @override
   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;
@@ skipping 71 matching lines @@
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param contentData the time-stamped contents of the source
    */
   GetContentTask(InternalAnalysisContext context, this.source) : super(context) {
     if (source == null) {
       throw new IllegalArgumentException("Cannot get contents of null source");
     }
   }
 
+  @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitGetContentTask(this);
 
   /**
    * Return the contents of the source, or `null` if the task has not completed or if there
    * was an exception while getting the contents.
    *
    * @return the contents of the source
    */
   String get content => _content;
 
   /**
    * Return the time at which the contents of the source that was parsed were last modified, or a
    * negative value if the task has not yet been performed or if an exception occurred.
    *
    * @return the time at which the contents of the source that was parsed were last modified
    */
   int get modificationTime => _modificationTime;
 
   /**
    * Return `true` if this task is complete. Unlike most tasks, this task is allowed to be
    * visited more than once in order to support asynchronous IO. If the task is not complete when it
    * is visited synchronously as part of the [AnalysisTask#perform]
    * method, it will be visited again, using the same visitor, when the IO operation has been
    * performed.
    *
    * @return `true` if this task is complete
    */
   bool get isComplete => _complete;
 
+  @override
   String get taskDescription => "get contents of ${source.fullName}";
 
+  @override
   void internalPerform() {
     _complete = true;
     try {
       TimestampedData<String> data = context.getContents(source);
       _content = data.data;
       _modificationTime = data.modificationTime;
     } on JavaException catch (exception) {
       throw new AnalysisException.con2("Could not get contents of ${source}", exception);
     }
   }
@@ skipping 14 matching lines @@
   CompilationUnit _updatedUnit;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param cache the incremental analysis cache used to perform the analysis
    */
   IncrementalAnalysisTask(InternalAnalysisContext context, this.cache) : super(context);
 
+  @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitIncrementalAnalysisTask(this);
 
   /**
    * Return the compilation unit that was produced by incrementally updating the existing
    * compilation unit, or `null` if the task has not yet been performed, could not be
    * performed, or if an exception occurred.
    *
    * @return the compilation unit
    */
   CompilationUnit get compilationUnit => _updatedUnit;
 
   /**
    * Return the source that is to be incrementally analyzed.
    *
    * @return the source
    */
   Source get source => cache != null ? cache.source : null;
 
+  @override
   String get taskDescription => "incremental analysis ${(cache != null ? cache.source : "null")}";
 
+  @override
   void internalPerform() {
     if (cache == null) {
       return;
     }
     // Only handle small changes
     if (cache.oldLength > 0 || cache.newLength > 30) {
       return;
     }
     // Produce an updated token stream
     CharacterReader reader = new CharSequenceReader(cache.newContents);
@@ skipping 78 matching lines @@
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param modificationTime the time at which the contents of the source were last modified
    * @param tokenStream the head of the token stream used for parsing
    */
   ParseDartTask(InternalAnalysisContext context, this.source, this.modificationTime, Token tokenStream) : super(context) {
     this._tokenStream = tokenStream;
   }
 
+  @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitParseDartTask(this);
 
   /**
    * Return the compilation unit that was produced by parsing the source, or `null` if the
    * task has not yet been performed or if an exception occurred.
    *
    * @return the compilation unit that was produced by parsing the source
    */
   CompilationUnit get compilationUnit => _unit;
 
@@ skipping 14 matching lines @@
   bool get hasLibraryDirective => _containsLibraryDirective;
 
   /**
    * Return `true` if the source contains a 'part of' directive, or `false` if the task
    * has not yet been performed or if an exception occurred.
    *
    * @return `true` if the source contains a 'part of' directive
    */
   bool get hasPartOfDirective => _containsPartOfDirective;
 
+  @override
   String get taskDescription {
     if (source == null) {
       return "parse as dart null source";
     }
     return "parse as dart ${source.fullName}";
   }
 
+  @override
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     InternalAnalysisContext context = this.context;
     //
     // Then parse the token stream.
     //
     TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
     try {
       Parser parser = new Parser(source, errorListener);
       parser.parseFunctionBodies = context.analysisOptions.analyzeFunctionBodies;
@@ skipping 67 matching lines @@
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param modificationTime the time at which the contents of the source were last modified
    * @param content the contents of the source
    */
   ParseHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, String content) : super(context) {
     this._content = content;
   }
 
+  @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitParseHtmlTask(this);
 
   /**
    * Return the errors that were produced by scanning and parsing the source, or `null` if the
    * task has not yet been performed or if an exception occurred.
    *
    * @return the errors that were produced by scanning and parsing the source
    */
   List<AnalysisError> get errors => _errors;
 
@@ skipping 12 matching lines @@
    */
   LineInfo get lineInfo => _lineInfo;
 
   /**
    * Return an array containing the sources of the libraries that are referenced within the HTML.
    *
    * @return the sources of the libraries that are referenced within the HTML
    */
   List<Source> get referencedLibraries => _referencedLibraries;
 
+  @override
   String get taskDescription {
     if (source == null) {
       return "parse as html null source";
     }
     return "parse as html ${source.fullName}";
   }
 
+  @override
   void internalPerform() {
     try {
       ht.AbstractScanner scanner = new ht.StringScanner(source, _content);
       scanner.passThroughElements = <String> [_TAG_SCRIPT];
       ht.Token token = scanner.tokenize();
       _lineInfo = new LineInfo(scanner.lineStarts);
       RecordingErrorListener errorListener = new RecordingErrorListener();
       _unit = new ht.HtmlParser(source, errorListener).parse(token, _lineInfo);
       _errors = errorListener.getErrorsForSource(source);
       _referencedLibraries = librarySources;
@@ skipping 17 matching lines @@
   }
 }
 
 class RecursiveXmlVisitor_ParseHtmlTask_getLibrarySources extends ht.RecursiveXmlVisitor<Object> {
   final ParseHtmlTask ParseHtmlTask_this;
 
   List<Source> libraries;
 
   RecursiveXmlVisitor_ParseHtmlTask_getLibrarySources(this.ParseHtmlTask_this, this.libraries) : super();
 
+  @override
   Object visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) {
     ht.XmlAttributeNode scriptAttribute = null;
     for (ht.XmlAttributeNode attribute in node.attributes) {
       if (javaStringEqualsIgnoreCase(attribute.name, ParseHtmlTask._ATTRIBUTE_SRC)) {
         scriptAttribute = attribute;
       }
     }
     if (scriptAttribute != null) {
       try {
         Uri uri = new Uri(path: scriptAttribute.text);
@@ skipping 58 matching lines @@
    * @param unit the HTML unit to be resolved
    * @param component the component that uses this HTML template, not `null`
    * @param application the Angular application to resolve in context of
    */
   ResolveAngularComponentTemplateTask(InternalAnalysisContext context, this.source, this.modificationTime, ht.HtmlUnit unit, AngularComponentElement component, AngularApplication application) : super(context) {
     this._unit = unit;
     this._component = component;
     this._application = application;
   }
 
+  @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveAngularComponentTemplateTask(this);
 
   List<AnalysisError> get resolutionErrors => _resolutionErrors;
 
   /**
    * Return the [HtmlUnit] that was resolved by this task.
    *
    * @return the [HtmlUnit] that was resolved by this task
    */
   ht.HtmlUnit get resolvedUnit => _resolvedUnit;
 
+  @override
   String get taskDescription => "resolving Angular template ${source}";
 
+  @override
   void internalPerform() {
     //
     // Prepare for resolution.
     //
     RecordingErrorListener errorListener = new RecordingErrorListener();
     LineInfo lineInfo = context.getLineInfo(source);
     //
     // Perform resolution.
     //
     if (_application != null) {
@@ skipping 53 matching lines @@
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be resolved
    * @param modificationTime the time at which the contents of the source were last modified
    * @param unit the HTML unit to be resolved
    */
   ResolveAngularEntryHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, ht.HtmlUnit unit) : super(context) {
     this._unit = unit;
   }
 
+  @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveAngularEntryHtmlTask(this);
 
   /**
    * Returns the [AngularApplication] for the Web application with this Angular entry point,
    * maybe `null` if not an Angular entry point.
    */
   AngularApplication get application => _application;
 
   HtmlElement get element => _element;
 
   /**
    * The resolution errors that were discovered while resolving the source.
    */
   List<AnalysisError> get entryErrors => _errorListener.getErrorsForSource(source);
 
   /**
    * Returns [AnalysisError]s recorded for the given [Source].
    */
   List<AnalysisError> getErrors(Source source) => _errorListener.getErrorsForSource(source);
 
   /**
    * Return the [HtmlUnit] that was resolved by this task.
    *
    * @return the [HtmlUnit] that was resolved by this task
    */
   ht.HtmlUnit get resolvedUnit => _resolvedUnit;
 
+  @override
   String get taskDescription {
     if (source == null) {
       return "resolve as Angular entry point null source";
     }
     return "resolve as Angular entry point ${source.fullName}";
   }
 
+  @override
   void internalPerform() {
     //
     // Prepare for resolution.
     //
     LineInfo lineInfo = context.getLineInfo(source);
     //
     // Try to resolve as an Angular entry point.
     //
     _application = new AngularHtmlUnitResolver(context, _errorListener, source, lineInfo, _unit).calculateAngularApplication();
     //
@@ skipping 49 matching lines @@
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param modificationTime the time at which the contents of the source were last modified
    * @param unit the compilation unit used to resolve the dependencies
    */
   ResolveDartDependenciesTask(InternalAnalysisContext context, this.source, this.modificationTime, CompilationUnit unit) : super(context) {
     this._unit = unit;
   }
 
+  @override
   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);
 
   /**
    * 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);
 
   /**
    * 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);
 
+  @override
   String get taskDescription {
     if (source == null) {
       return "resolve dart dependencies null source";
     }
     return "resolve dart dependencies ${source.fullName}";
   }
 
+  @override
   void internalPerform() {
     TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
     try {
       for (Directive directive in _unit.directives) {
         if (directive is ExportDirective) {
           Source exportSource = _resolveSource(source, directive);
           if (exportSource != null) {
             _exportedSources.add(exportSource);
           }
         } else if (directive is ImportDirective) {
@@ skipping 75 matching lines @@
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param unitSource the source representing the file whose compilation unit is to be returned
    * @param librarySource the source representing the library to be resolved
    */
   ResolveDartLibraryTask(InternalAnalysisContext context, this.unitSource, this.librarySource) : super(context);
 
+  @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartLibraryTask(this);
 
   /**
    * Return the library resolver holding information about the libraries that were resolved.
    *
    * @return the library resolver holding information about the libraries that were resolved
    */
   LibraryResolver get libraryResolver => _resolver;
 
+  @override
   String get taskDescription {
     if (librarySource == null) {
       return "resolve library null source";
     }
     return "resolve library ${librarySource.fullName}";
   }
 
+  @override
   void internalPerform() {
     _resolver = new LibraryResolver(context);
     _resolver.resolveLibrary(librarySource, true);
   }
 }
 
 /**
  * Instances of the class `ResolveDartUnitTask` resolve a single Dart file based on a existing
  * element model.
  */
@@ skipping 22 matching lines @@
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param libraryElement the element model for the library containing the source
    */
   ResolveDartUnitTask(InternalAnalysisContext context, this.source, LibraryElement libraryElement) : super(context) {
     this._libraryElement = libraryElement;
   }
 
+  @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartUnitTask(this);
 
   /**
    * Return the source for the library containing the source that is to be resolved.
    *
    * @return the source for the library containing the source that is to be resolved
    */
   Source get librarySource => _libraryElement.source;
 
   /**
    * Return the time at which the contents of the source that was parsed were last modified, or a
    * negative value if the task has not yet been performed or if an exception occurred.
    *
    * @return the time at which the contents of the source that was parsed were last modified
    */
   int get modificationTime => _modificationTime;
 
   /**
    * Return the compilation unit that was resolved by this task.
    *
    * @return the compilation unit that was resolved by this task
    */
   CompilationUnit get resolvedUnit => _resolvedUnit;
 
+  @override
   String get taskDescription {
     Source librarySource = _libraryElement.source;
     if (librarySource == null) {
       return "resolve unit null source";
     }
     return "resolve unit ${librarySource.fullName}";
   }
 
+  @override
   void internalPerform() {
     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.
@@ skipping 98 matching lines @@
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be resolved
    * @param modificationTime the time at which the contents of the source were last modified
    * @param unit the HTML unit to be resolved
    */
   ResolveHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, ht.HtmlUnit unit) : super(context) {
     this._unit = unit;
   }
 
+  @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveHtmlTask(this);
 
   HtmlElement get element => _element;
 
   List<AnalysisError> get resolutionErrors => _resolutionErrors;
 
   /**
    * Return the [HtmlUnit] that was resolved by this task.
    *
    * @return the [HtmlUnit] that was resolved by this task
    */
   ht.HtmlUnit get resolvedUnit => _resolvedUnit;
 
+  @override
   String get taskDescription {
     if (source == null) {
       return "resolve as html null source";
     }
     return "resolve as html ${source.fullName}";
   }
 
+  @override
   void internalPerform() {
     //
     // Build the standard HTML element.
     //
     HtmlUnitBuilder builder = new HtmlUnitBuilder(context);
     _element = builder.buildHtmlElement(source, modificationTime, _unit);
     RecordingErrorListener errorListener = builder.errorListener;
     //
     // Record all resolution errors.
     //
@@ skipping 44 matching lines @@
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param modificationTime the time at which the contents of the source were last modified
    * @param content the contents of the source
    */
   ScanDartTask(InternalAnalysisContext context, this.source, this.modificationTime, String content) : super(context) {
     this._content = content;
   }
 
+  @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitScanDartTask(this);
 
   /**
    * Return the errors that were produced by scanning the source, or `null` if the task has
    * not yet been performed or if an exception occurred.
    *
    * @return the errors that were produced by scanning the source
    */
   List<AnalysisError> get errors => _errors;
 
   /**
    * Return the line information that was produced, or `null` if the task has not yet been
    * performed or if an exception occurred.
    *
    * @return the line information that was produced
    */
   LineInfo get lineInfo => _lineInfo;
 
   /**
    * Return the token stream that was produced by scanning the source, or `null` if the task
    * has not yet been performed or if an exception occurred.
    *
    * @return the token stream that was produced by scanning the source
    */
   Token get tokenStream => _tokenStream;
 
+  @override
   String get taskDescription {
     if (source == null) {
       return "scan as dart null source";
     }
     return "scan as dart ${source.fullName}";
   }
 
+  @override
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     TimeCounter_TimeCounterHandle timeCounterScan = PerformanceStatistics.scan.start();
     try {
       Scanner scanner = new Scanner(source, new CharSequenceReader(_content), errorListener);
       scanner.preserveComments = context.analysisOptions.preserveComments;
       _tokenStream = scanner.tokenize();
       _lineInfo = new LineInfo(scanner.lineStarts);
       _errors = errorListener.getErrorsForSource(source);
     } on JavaException catch (exception) {
@@ skipping 20 matching lines @@
    *
    * @return the unique instance of this class
    */
   static WaitForAsyncTask get instance => _UniqueInstance;
 
   /**
    * Prevent the creation of instances of this class.
    */
   WaitForAsyncTask() : super(null);
 
+  @override
   accept(AnalysisTaskVisitor visitor) => null;
 
+  @override
   String get taskDescription => "Waiting for async analysis";
 
+  @override
   void internalPerform() {
   }
 }
 
 /**
  * The interface `Logger` defines the behavior of objects that can be used to receive
  * information about errors within the analysis engine. Implementations usually write this
  * information to a file, but can also record the information for later use (such as during testing)
  * or even ignore the information.
  */
@@ skipping 29 matching lines @@
    * @param message an explanation of why the error occurred or what it means
    * @param exception the exception being logged
    */
   void logInformation2(String message, Exception exception);
 }
 
 /**
  * Implementation of [Logger] that does nothing.
  */
 class Logger_NullLogger implements Logger {
+  @override
   void logError(String message) {
   }
 
+  @override
   void logError2(String message, Exception exception) {
   }
 
+  @override
   void logInformation(String message) {
   }
 
+  @override
   void logInformation2(String message, Exception exception) {
   }
 }