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

pkg/analyzer/lib/src/generated/index.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.index;
 
 import 'dart:collection' show Queue;
@@ skipping 32 matching lines @@
    *
    * @param indexStore the index store against which this operation is being run
    * @param context the [AnalysisContext] to remove source in
    * @param source the [Source] to remove from index
    */
   RemoveSourceOperation(IndexStore indexStore, AnalysisContext context, this.source) {
     this._indexStore = indexStore;
     this._context = context;
   }
 
+  @override
   bool get isQuery => false;
 
+  @override
   void performOperation() {
     _indexStore.removeSource(_context, source);
   }
 
+  @override
   bool removeWhenSourceRemoved(Source source) => false;
 
+  @override
   String toString() => "RemoveSource(${source.fullName})";
 }
 
 /**
  * The interface [IndexOperation] defines the behavior of objects used to perform operations
  * on an index.
  */
 abstract class IndexOperation {
   /**
    * Return `true` if this operation returns information from the index.
@@ skipping 82 matching lines @@
    * The mapping of unit [Source] to the [Source]s of libraries it is used in.
    */
   Map<AnalysisContext, Map<Source, Set<Source>>> _contextToUnitToLibraries = {};
 
   int _sourceCount = 0;
 
   int _keyCount = 0;
 
   int _locationCount = 0;
 
+  @override
   bool aboutToIndexDart(AnalysisContext context, CompilationUnitElement unitElement) {
     context = unwrapContext(context);
     // may be already disposed in other thread
     if (context.isDisposed) {
       return false;
     }
     // validate unit
     if (unitElement == null) {
       return false;
     }
@@ skipping 44 matching lines @@
         bool hadSource = sourceToKeys.remove(source2) != null;
         if (hadSource) {
           _sourceCount--;
         }
       }
     }
     // OK, we can index
     return true;
   }
 
+  @override
   bool aboutToIndexHtml(AnalysisContext context, HtmlElement htmlElement) {
     context = unwrapContext(context);
     // may be already disposed in other thread
     if (context.isDisposed) {
       return false;
     }
     // remove locations
     Source source = htmlElement.source;
     _removeLocations(context, null, source);
     // remove keys
     {
       Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
       if (sourceToKeys != null) {
         MemoryIndexStoreImpl_Source2 source2 = new MemoryIndexStoreImpl_Source2(null, source);
         bool hadSource = sourceToKeys.remove(source2) != null;
         if (hadSource) {
           _sourceCount--;
         }
       }
     }
     // remember libraries in which unit is used
     _recordUnitInLibrary(context, null, source);
     // OK, we can index
     return true;
   }
 
+  @override
   List<Location> getRelationships(Element element, Relationship relationship) {
     MemoryIndexStoreImpl_ElementRelationKey key = new MemoryIndexStoreImpl_ElementRelationKey(element, relationship);
     Set<Location> locations = _keyToLocations[key];
     if (locations != null) {
       return new List.from(locations);
     }
     return Location.EMPTY_ARRAY;
   }
 
+  @override
   String get statistics => "${_locationCount} relationships in ${_keyCount} keys in ${_sourceCount} sources";
 
   int internalGetKeyCount() => _keyToLocations.length;
 
   int internalGetLocationCount() {
     int count = 0;
     for (Set<Location> locations in _keyToLocations.values) {
       count += locations.length;
     }
     return count;
@@ skipping 16 matching lines @@
     int count = 0;
     Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
     if (sourceToKeys != null) {
       for (Set<MemoryIndexStoreImpl_ElementRelationKey> keys in sourceToKeys.values) {
         count += keys.length;
       }
     }
     return count;
   }
 
+  @override
   void recordRelationship(Element element, Relationship relationship, Location location) {
     if (element == null || location == null) {
       return;
     }
-    location = location.clone();
+    location = location.newClone();
     // at the index level we don't care about Member(s)
     if (element is Member) {
       element = (element as Member).baseElement;
     }
     //    System.out.println(element + " " + relationship + " " + location);
     // prepare information
     AnalysisContext elementContext = element.context;
     AnalysisContext locationContext = location.element.context;
     Source elementSource = element.source;
     Source locationSource = location.element.source;
@@ skipping 63 matching lines @@
       }
       List<Location> locations = sourceToLocations[locationSource2];
       if (locations == null) {
         locations = [];
         sourceToLocations[locationSource2] = locations;
       }
       locations.add(location);
     }
   }
 
+  @override
   void removeContext(AnalysisContext context) {
     context = unwrapContext(context);
     if (context == null) {
       return;
     }
     // remove sources
     removeSources(context, null);
     // remove context
     _contextToSourceToKeys.remove(context);
     _contextToSourceToLocations.remove(context);
     _contextToLibraryToUnits.remove(context);
     _contextToUnitToLibraries.remove(context);
   }
 
+  @override
   void removeSource(AnalysisContext context, Source unit) {
     context = unwrapContext(context);
     if (context == null) {
       return;
     }
     // remove locations defined in source
     Map<Source, Set<Source>> unitToLibraries = _contextToUnitToLibraries[context];
     if (unitToLibraries != null) {
       Set<Source> libraries = unitToLibraries.remove(unit);
       if (libraries != null) {
@@ skipping 15 matching lines @@
                 }
               }
               _sourceCount--;
             }
           }
         }
       }
     }
   }
 
+  @override
   void removeSources(AnalysisContext context, SourceContainer container) {
     context = unwrapContext(context);
     if (context == null) {
       return;
     }
     // remove sources #1
     Map<MemoryIndexStoreImpl_Source2, Set<MemoryIndexStoreImpl_ElementRelationKey>> sourceToKeys = _contextToSourceToKeys[context];
     if (sourceToKeys != null) {
       List<MemoryIndexStoreImpl_Source2> sources = [];
       for (MemoryIndexStoreImpl_Source2 source2 in sources) {
@@ skipping 80 matching lines @@
 class MemoryIndexStoreImpl_ElementRelationKey {
   Element _element;
 
   Relationship _relationship;
 
   MemoryIndexStoreImpl_ElementRelationKey(Element element, Relationship relationship) {
     this._element = element;
     this._relationship = relationship;
   }
 
+  @override
   bool operator ==(Object obj) {
     MemoryIndexStoreImpl_ElementRelationKey other = obj as MemoryIndexStoreImpl_ElementRelationKey;
     Element otherElement = other._element;
     return identical(other._relationship, _relationship) && otherElement.nameOffset == _element.nameOffset && identical(otherElement.kind, _element.kind) && otherElement.displayName == _element.displayName && otherElement.source == _element.source;
   }
 
+  @override
   int get hashCode => JavaArrays.makeHashCode([
       _element.source,
       _element.nameOffset,
       _element.kind,
       _element.displayName,
       _relationship]);
 
+  @override
   String toString() => "${_element} ${_relationship}";
 }
 
 class MemoryIndexStoreImpl_Source2 {
   Source _librarySource;
 
   Source _unitSource;
 
   MemoryIndexStoreImpl_Source2(Source librarySource, Source unitSource) {
     this._librarySource = librarySource;
     this._unitSource = unitSource;
   }
 
+  @override
   bool operator ==(Object obj) {
     if (identical(obj, this)) {
       return true;
     }
     if (obj is! MemoryIndexStoreImpl_Source2) {
       return false;
     }
     MemoryIndexStoreImpl_Source2 other = obj as MemoryIndexStoreImpl_Source2;
     return other._librarySource == _librarySource && other._unitSource == _unitSource;
   }
 
+  @override
   int get hashCode => JavaArrays.makeHashCode([_librarySource, _unitSource]);
 
+  @override
   String toString() => "${_librarySource} ${_unitSource}";
 }
 
 /**
  * Instances of the [IndexUnitOperation] implement an operation that adds data to the index
  * based on the resolved [CompilationUnit].
  */
 class IndexUnitOperation implements IndexOperation {
   /**
    * The index store against which this operation is being run.
@@ skipping 32 matching lines @@
     this._context = context;
     this._unitElement = unit.element;
     this._source = _unitElement.source;
   }
 
   /**
    * @return the [Source] to be indexed.
    */
   Source get source => _source;
 
+  @override
   bool get isQuery => false;
 
+  @override
   void performOperation() {
     try {
       bool mayIndex = _indexStore.aboutToIndexDart(_context, _unitElement);
       if (!mayIndex) {
         return;
       }
       unit.accept(new IndexContributor(_indexStore));
       unit.accept(new AngularDartIndexContributor(_indexStore));
     } catch (exception) {
       AnalysisEngine.instance.logger.logError2("Could not index ${unit.element.location}", exception);
     }
   }
 
+  @override
   bool removeWhenSourceRemoved(Source source) => this._source == source;
 
+  @override
   String toString() => "IndexUnitOperation(${_source.fullName})";
 }
 
 /**
  * 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 56 matching lines @@
     this._uniqueId = uniqueId;
   }
 
   /**
    * Return the unique identifier for this relationship.
    *
    * @return the unique identifier for this relationship
    */
   String get identifier => _uniqueId;
 
+  @override
   String toString() => _uniqueId;
 }
 
 /**
  * Instances of the [RemoveSourcesOperation] implement an operation that removes from the
  * index any data based on the content of source belonging to a [SourceContainer].
  */
 class RemoveSourcesOperation implements IndexOperation {
   /**
    * The index store against which this operation is being run.
@@ skipping 15 matching lines @@
    *
    * @param indexStore the index store against which this operation is being run
    * @param context the [AnalysisContext] to remove container in
    * @param container the [SourceContainer] to remove from index
    */
   RemoveSourcesOperation(IndexStore indexStore, AnalysisContext context, this.container) {
     this._indexStore = indexStore;
     this._context = context;
   }
 
+  @override
   bool get isQuery => false;
 
+  @override
   void performOperation() {
     _indexStore.removeSources(_context, container);
   }
 
+  @override
   bool removeWhenSourceRemoved(Source source) => false;
 
+  @override
   String toString() => "RemoveSources(${container})";
 }
 
 /**
  * The interface `UniverseElement` defines element to use when we want to request "defines"
  * relations without specifying exact library.
  */
 abstract class UniverseElement implements Element {
   static final UniverseElement INSTANCE = UniverseElementImpl.INSTANCE;
 }
@@ skipping 192 matching lines @@
   /**
    * Initialize a newly created Angular HTML index contributor.
    *
    * @param store the [IndexStore] to record relations into.
    */
   AngularHtmlIndexContributor(IndexStore store) {
     this._store = store;
     _indexContributor = new IndexContributor_AngularHtmlIndexContributor(store, this);
   }
 
+  @override
   void visitExpression(Expression expression) {
     // NgFilter
     if (expression is SimpleIdentifier) {
       SimpleIdentifier identifier = expression;
       Element element = identifier.bestElement;
       if (element is AngularElement) {
         _store.recordRelationship(element, IndexConstants.ANGULAR_REFERENCE, _createLocationForIdentifier(identifier));
         return;
       }
     }
     // index as a normal Dart expression
     expression.accept(_indexContributor);
   }
 
+  @override
   Object visitHtmlUnit(ht.HtmlUnit node) {
     _htmlUnitElement = node.element;
     CompilationUnitElement dartUnitElement = _htmlUnitElement.angularCompilationUnit;
     _indexContributor.enterScope(dartUnitElement);
     return super.visitHtmlUnit(node);
   }
 
+  @override
   Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
     Element element = node.element;
     if (element != null) {
       ht.Token nameToken = node.nameToken;
       Location location = _createLocationForToken(nameToken);
       _store.recordRelationship(element, IndexConstants.ANGULAR_REFERENCE, location);
     }
     return super.visitXmlAttributeNode(node);
   }
 
+  @override
   Object visitXmlTagNode(ht.XmlTagNode node) {
     Element element = node.element;
     if (element != null) {
       // tag
       {
         ht.Token tagToken = node.tagToken;
         Location location = _createLocationForToken(tagToken);
         _store.recordRelationship(element, IndexConstants.ANGULAR_REFERENCE, location);
       }
       // maybe add closing tag range
       ht.Token closingTag = node.closingTag;
       if (closingTag != null) {
         Location location = _createLocationForToken(closingTag);
         _store.recordRelationship(element, IndexConstants.ANGULAR_CLOSING_TAG_REFERENCE, location);
       }
     }
     return super.visitXmlTagNode(node);
   }
 
   Location _createLocationForIdentifier(SimpleIdentifier identifier) => new Location(_htmlUnitElement, identifier.offset, identifier.length);
 
   Location _createLocationForToken(ht.Token token) => new Location(_htmlUnitElement, token.offset, token.length);
 }
 
 class IndexContributor_AngularHtmlIndexContributor extends IndexContributor {
   final AngularHtmlIndexContributor AngularHtmlIndexContributor_this;
 
   IndexContributor_AngularHtmlIndexContributor(IndexStore arg0, this.AngularHtmlIndexContributor_this) : super(arg0);
 
+  @override
   Element peekElement() => AngularHtmlIndexContributor_this._htmlUnitElement;
 
+  @override
   void recordRelationship(Element element, Relationship relationship, Location location) {
     AngularElement angularElement = AngularHtmlUnitResolver.getAngularElement(element);
     if (angularElement != null) {
       element = angularElement;
       relationship = IndexConstants.ANGULAR_REFERENCE;
     }
     super.recordRelationship(element, relationship, location);
   }
 }
 
@@ skipping 197 matching lines @@
 }
 
 /**
  * Implementation of [UniverseElement].
  */
 class UniverseElementImpl extends ElementImpl implements UniverseElement {
   static UniverseElementImpl INSTANCE = new UniverseElementImpl();
 
   UniverseElementImpl() : super("--universe--", -1);
 
+  @override
   accept(ElementVisitor visitor) => null;
 
+  @override
   ElementKind get kind => ElementKind.UNIVERSE;
 }
 
 /**
  * Visits resolved AST and adds relationships into [IndexStore].
  */
 class IndexContributor extends GeneralizingAstVisitor<Object> {
   /**
    * @return the [Location] representing location of the [Element].
    */
@@ skipping 272 matching lines @@
    */
   Element peekElement() {
     for (Element element in _elementStack) {
       if (element != null) {
         return element;
       }
     }
     return null;
   }
 
+  @override
   Object visitAssignmentExpression(AssignmentExpression node) {
     _recordOperatorReference(node.operator, node.bestElement);
     return super.visitAssignmentExpression(node);
   }
 
+  @override
   Object visitBinaryExpression(BinaryExpression node) {
     _recordOperatorReference(node.operator, node.bestElement);
     return super.visitBinaryExpression(node);
   }
 
+  @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement element = node.element;
     enterScope(element);
     try {
       _recordElementDefinition(element, IndexConstants.DEFINES_CLASS);
       {
         ExtendsClause extendsClause = node.extendsClause;
         if (extendsClause != null) {
           TypeName superclassNode = extendsClause.superclass;
           _recordSuperType(superclassNode, IndexConstants.IS_EXTENDED_BY);
@@ skipping 20 matching lines @@
             _recordSuperType(interfaceNode, IndexConstants.IS_IMPLEMENTED_BY);
           }
         }
       }
       return super.visitClassDeclaration(node);
     } finally {
       _exitScope();
     }
   }
 
+  @override
   Object visitClassTypeAlias(ClassTypeAlias node) {
     ClassElement element = node.element;
     enterScope(element);
     try {
       _recordElementDefinition(element, IndexConstants.DEFINES_CLASS_ALIAS);
       {
         TypeName superclassNode = node.superclass;
         if (superclassNode != null) {
           _recordSuperType(superclassNode, IndexConstants.IS_EXTENDED_BY);
         }
@@ skipping 13 matching lines @@
             _recordSuperType(interfaceNode, IndexConstants.IS_IMPLEMENTED_BY);
           }
         }
       }
       return super.visitClassTypeAlias(node);
     } finally {
       _exitScope();
     }
   }
 
+  @override
   Object visitCompilationUnit(CompilationUnit node) {
     CompilationUnitElement unitElement = node.element;
     if (unitElement != null) {
       _elementStack.add(unitElement);
       _libraryElement = unitElement.enclosingElement;
       if (_libraryElement != null) {
         return super.visitCompilationUnit(node);
       }
     }
     return null;
   }
 
+  @override
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     ConstructorElement element = node.element;
     // define
     {
       Location location;
       if (node.name != null) {
         int start = node.period.offset;
         int end = node.name.end;
         location = _createLocationFromOffset(start, end - start);
       } else {
         int start = node.returnType.end;
         location = _createLocationFromOffset(start, 0);
       }
       recordRelationship(element, IndexConstants.IS_DEFINED_BY, location);
     }
     // visit children
     enterScope(element);
     try {
       return super.visitConstructorDeclaration(node);
     } finally {
       _exitScope();
     }
   }
 
+  @override
   Object visitConstructorName(ConstructorName node) {
     ConstructorElement element = node.staticElement;
     // in 'class B = A;' actually A constructors are invoked
     if (element != null && element.isSynthetic && element.redirectedConstructor != null) {
       element = element.redirectedConstructor;
     }
     // prepare location
     Location location;
     if (node.name != null) {
       int start = node.period.offset;
       int end = node.name.end;
       location = _createLocationFromOffset(start, end - start);
     } else {
       int start = node.type.end;
       location = _createLocationFromOffset(start, 0);
     }
     // record relationship
     recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
     return super.visitConstructorName(node);
   }
 
+  @override
   Object visitExportDirective(ExportDirective node) {
     ExportElement element = node.element;
     if (element != null) {
       LibraryElement expLibrary = element.exportedLibrary;
       _recordLibraryReference(node, expLibrary);
     }
     return super.visitExportDirective(node);
   }
 
+  @override
   Object visitFormalParameter(FormalParameter node) {
     ParameterElement element = node.element;
     enterScope(element);
     try {
       return super.visitFormalParameter(node);
     } finally {
       _exitScope();
     }
   }
 
+  @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     Element element = node.element;
     _recordElementDefinition(element, IndexConstants.DEFINES_FUNCTION);
     enterScope(element);
     try {
       return super.visitFunctionDeclaration(node);
     } finally {
       _exitScope();
     }
   }
 
+  @override
   Object visitFunctionTypeAlias(FunctionTypeAlias node) {
     Element element = node.element;
     _recordElementDefinition(element, IndexConstants.DEFINES_FUNCTION_TYPE);
     return super.visitFunctionTypeAlias(node);
   }
 
+  @override
   Object visitImportDirective(ImportDirective node) {
     ImportElement element = node.element;
     if (element != null) {
       LibraryElement impLibrary = element.importedLibrary;
       _recordLibraryReference(node, impLibrary);
     }
     return super.visitImportDirective(node);
   }
 
+  @override
   Object visitIndexExpression(IndexExpression node) {
     MethodElement element = node.bestElement;
     if (element is MethodElement) {
       Token operator = node.leftBracket;
       Location location = _createLocationFromToken(operator);
       recordRelationship(element, IndexConstants.IS_INVOKED_BY_QUALIFIED, location);
     }
     return super.visitIndexExpression(node);
   }
 
+  @override
   Object visitMethodDeclaration(MethodDeclaration node) {
     ExecutableElement element = node.element;
     enterScope(element);
     try {
       return super.visitMethodDeclaration(node);
     } finally {
       _exitScope();
     }
   }
 
+  @override
   Object visitMethodInvocation(MethodInvocation node) {
     SimpleIdentifier name = node.methodName;
     Element element = name.bestElement;
     if (element is MethodElement) {
       Location location = _createLocationFromNode(name);
       Relationship relationship;
       if (node.target != null) {
         relationship = IndexConstants.IS_INVOKED_BY_QUALIFIED;
       } else {
         relationship = IndexConstants.IS_INVOKED_BY_UNQUALIFIED;
       }
       recordRelationship(element, relationship, location);
     }
     if (element is FunctionElement) {
       Location location = _createLocationFromNode(name);
       recordRelationship(element, IndexConstants.IS_INVOKED_BY, location);
     }
     _recordImportElementReferenceWithoutPrefix(name);
     return super.visitMethodInvocation(node);
   }
 
+  @override
   Object visitPartDirective(PartDirective node) {
     Element element = node.element;
     Location location = _createLocationFromNode(node.uri);
     recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
     return super.visitPartDirective(node);
   }
 
+  @override
   Object visitPartOfDirective(PartOfDirective node) {
     Location location = _createLocationFromNode(node.libraryName);
     recordRelationship(node.element, IndexConstants.IS_REFERENCED_BY, location);
     return null;
   }
 
+  @override
   Object visitPostfixExpression(PostfixExpression node) {
     _recordOperatorReference(node.operator, node.bestElement);
     return super.visitPostfixExpression(node);
   }
 
+  @override
   Object visitPrefixExpression(PrefixExpression node) {
     _recordOperatorReference(node.operator, node.bestElement);
     return super.visitPrefixExpression(node);
   }
 
+  @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element nameElement = new NameElementImpl(node.name);
     Location location = _createLocationFromNode(node);
     // name in declaration
     if (node.inDeclarationContext()) {
       recordRelationship(nameElement, IndexConstants.IS_DEFINED_BY, location);
       return null;
     }
     // prepare information
     Element element = node.bestElement;
@@ skipping 32 matching lines @@
       } else if (inSetterContext) {
         recordRelationship(element, IndexConstants.IS_WRITTEN_BY, location);
       } else {
         recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
       }
     }
     _recordImportElementReferenceWithoutPrefix(node);
     return super.visitSimpleIdentifier(node);
   }
 
+  @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     ConstructorElement element = node.staticElement;
     Location location;
     if (node.constructorName != null) {
       int start = node.period.offset;
       int end = node.constructorName.end;
       location = _createLocationFromOffset(start, end - start);
     } else {
       int start = node.keyword.end;
       location = _createLocationFromOffset(start, 0);
     }
     recordRelationship(element, IndexConstants.IS_REFERENCED_BY, location);
     return super.visitSuperConstructorInvocation(node);
   }
 
+  @override
   Object visitTopLevelVariableDeclaration(TopLevelVariableDeclaration node) {
     VariableDeclarationList variables = node.variables;
     for (VariableDeclaration variableDeclaration in variables.variables) {
       Element element = variableDeclaration.element;
       _recordElementDefinition(element, IndexConstants.DEFINES_VARIABLE);
     }
     return super.visitTopLevelVariableDeclaration(node);
   }
 
+  @override
   Object visitTypeParameter(TypeParameter node) {
     TypeParameterElement element = node.element;
     enterScope(element);
     try {
       return super.visitTypeParameter(node);
     } finally {
       _exitScope();
     }
   }
 
+  @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     VariableElement element = node.element;
     // record declaration
     {
       SimpleIdentifier name = node.name;
       Location location = _createLocationFromNode(name);
       location = _getLocationWithExpressionType(location, node.initializer);
       recordRelationship(element, IndexConstants.IS_DEFINED_BY, location);
     }
     // visit
     enterScope(element);
     try {
       return super.visitVariableDeclaration(node);
     } finally {
       _exitScope();
     }
   }
 
+  @override
   Object visitVariableDeclarationList(VariableDeclarationList node) {
     NodeList<VariableDeclaration> variables = node.variables;
     if (variables != null) {
       // use first VariableDeclaration as Element for Location(s) in type
       {
         TypeName type = node.type;
         if (type != null) {
           for (VariableDeclaration variableDeclaration in variables) {
             enterScope(variableDeclaration.element);
             try {
@@ skipping 181 matching lines @@
   int _periodEnd = 0;
 }
 
 /**
  * Special [Element] which is used to index references to the name without specifying concrete
  * kind of this name - field, method or something else.
  */
 class NameElementImpl extends ElementImpl {
   NameElementImpl(String name) : super("name:${name}", -1);
 
+  @override
   accept(ElementVisitor visitor) => null;
 
+  @override
   ElementKind get kind => ElementKind.NAME;
 }
 
 /**
  * Visits resolved [CompilationUnit] and adds Angular specific relationships into
  * [IndexStore].
  */
 class AngularDartIndexContributor extends GeneralizingAstVisitor<Object> {
   IndexStore _store;
 
   AngularDartIndexContributor(IndexStore store) {
     this._store = store;
   }
 
+  @override
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement classElement = node.element;
     if (classElement != null) {
       List<ToolkitObjectElement> toolkitObjects = classElement.toolkitObjects;
       for (ToolkitObjectElement object in toolkitObjects) {
         if (object is AngularComponentElement) {
           _indexComponent(object);
         }
         if (object is AngularDirectiveElement) {
           AngularDirectiveElement directive = object;
           _indexDirective(directive);
         }
       }
     }
     // stop visiting
     return null;
   }
 
+  @override
   Object visitCompilationUnitMember(CompilationUnitMember node) => null;
 
   void _indexComponent(AngularComponentElement component) {
     _indexProperties(component.properties);
   }
 
   void _indexDirective(AngularDirectiveElement directive) {
     _indexProperties(directive.properties);
   }
 
@@ skipping 47 matching lines @@
   /**
    * Initialize a newly created operation that will remove the specified resource.
    *
    * @param indexStore the index store against which this operation is being run
    * @param context the [AnalysisContext] to remove
    */
   RemoveContextOperation(IndexStore indexStore, this.context) {
     this._indexStore = indexStore;
   }
 
+  @override
   bool get isQuery => false;
 
+  @override
   void performOperation() {
     _indexStore.removeContext(context);
   }
 
+  @override
   bool removeWhenSourceRemoved(Source source) => false;
 
+  @override
   String toString() => "RemoveContext(${context})";
 }
 
 /**
  * Instances of the [IndexHtmlUnitOperation] implement an operation that adds data to the
  * index based on the resolved [HtmlUnit].
  */
 class IndexHtmlUnitOperation implements IndexOperation {
   /**
    * The index store against which this operation is being run.
@@ skipping 32 matching lines @@
     this._context = context;
     this._htmlElement = unit.element;
     this._source = _htmlElement.source;
   }
 
   /**
    * @return the [Source] to be indexed.
    */
   Source get source => _source;
 
+  @override
   bool get isQuery => false;
 
+  @override
   void performOperation() {
     try {
       bool mayIndex = _indexStore.aboutToIndexHtml(_context, _htmlElement);
       if (!mayIndex) {
         return;
       }
       AngularHtmlIndexContributor contributor = new AngularHtmlIndexContributor(_indexStore);
       unit.accept(contributor);
     } catch (exception) {
       AnalysisEngine.instance.logger.logError2("Could not index ${unit.element.location}", exception);
     }
   }
 
+  @override
   bool removeWhenSourceRemoved(Source source) => this._source == source;
 
+  @override
   String toString() => "IndexHtmlUnitOperation(${_source.fullName})";
 }
 
 /**
  * Instances of the class <code>Location</code> represent a location related to an element. The
  * location is expressed as an offset and length, but the offset is relative to the resource
  * containing the element rather than the start of the element within that resource.
  */
 class Location {
   /**
@@ skipping 28 matching lines @@
    * @param element the [Element] containing this location
    * @param offset the offset of this location within the resource containing the element
    * @param length the length of this location
    */
   Location(this.element, this.offset, this.length) {
     if (element == null) {
       throw new IllegalArgumentException("element location cannot be null");
     }
   }
 
-  Location clone() => new Location(element, offset, length);
+  /**
+   * Returns a clone of this [Location].
+   */
+  Location newClone() => new Location(element, offset, length);
 
+  @override
   String toString() => "[${offset} - ${(offset + length)}) in ${element}";
 }
 
 /**
  * [IndexStore] which keeps all information in memory, but can write it to stream and read
  * later.
  */
 abstract class MemoryIndexStore implements IndexStore {
 }
 
@@ skipping 11 matching lines @@
   final RelationshipCallback callback;
 
   /**
    * Initialize a newly created operation that will access the locations that have a specified
    * relationship with a specified element.
    */
   GetRelationshipsOperation(IndexStore indexStore, this.element, this.relationship, this.callback) {
     this._indexStore = indexStore;
   }
 
+  @override
   bool get isQuery => true;
 
+  @override
   void performOperation() {
     List<Location> locations;
     locations = _indexStore.getRelationships(element, relationship);
     callback.hasRelationships(element, relationship, locations);
   }
 
+  @override
   bool removeWhenSourceRemoved(Source source) => false;
 
+  @override
   String toString() => "GetRelationships(${element}, ${relationship})";
 }
 
 /**
  * [Location] with attached data.
  */
 class LocationWithData<D> extends Location {
   final D data;
 
   LocationWithData.con1(Location location, this.data) : super(location.element, location.offset, location.length);
 
   LocationWithData.con2(Element element, int offset, int length, this.data) : super(element, offset, length);
 
-  Location clone() => new LocationWithData<D>.con2(element, offset, length, data);
+  @override
+  Location newClone() => new LocationWithData<D>.con2(element, offset, length, data);
 }
 
 /**
  * The interface <code>RelationshipCallback</code> defines the behavior of objects that are invoked
  * with the results of a query about a given relationship.
  */
 abstract class RelationshipCallback {
   /**
    * This method is invoked when the locations that have a specified relationship with a specified
    * element are available. For example, if the element is a field and the relationship is the
    * is-referenced-by relationship, then this method will be invoked with each location at which the
    * field is referenced.
    *
    * @param element the [Element] that has the relationship with the locations
    * @param relationship the relationship between the given element and the locations
    * @param locations the locations that were found
    */
   void hasRelationships(Element element, Relationship relationship, List<Location> locations);
 }