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

pkg/analyzer/lib/src/generated/element.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.element;
 
 import 'dart:collection';
@@ skipping 111 matching lines @@
   ConstructorElement getNamedConstructor(String name);
 
   /**
    * Return the resolved [ClassDeclaration] node that declares this [ClassElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
    * @return the resolved [ClassDeclaration], not `null`.
    */
+  @override
   ClassDeclaration get node;
 
   /**
    * Return the element representing the setter with the given name that is declared in this class,
    * or `null` if this class does not declare a setter with the given name.
    *
    * @param setterName the name of the getter to be returned
    * @return the setter declared in this class with the given name
    */
   PropertyAccessorElement getSetter(String setterName);
@@ skipping 166 matching lines @@
 /**
  * The interface `ClassMemberElement` defines the behavior of elements that are contained
  * within a [ClassElement].
  */
 abstract class ClassMemberElement implements Element {
   /**
    * Return the type in which this member is defined.
    *
    * @return the type in which this member is defined
    */
+  @override
   ClassElement get enclosingElement;
 
   /**
    * Return `true` if this element is a static element. A static element is an element that is
    * not associated with a particular instance, but rather with an entire library or class.
    *
    * @return `true` if this executable element is a static element
    */
   bool get isStatic;
 }
@@ skipping 18 matching lines @@
    *
    * @return the Angular views defined in this compilation unit.
    */
   List<AngularViewElement> get angularViews;
 
   /**
    * Return the library in which this compilation unit is defined.
    *
    * @return the library in which this compilation unit is defined
    */
+  @override
   LibraryElement get enclosingElement;
 
   /**
    * Return an array containing all of the top-level functions contained in this compilation unit.
    *
    * @return the top-level functions contained in this compilation unit
    */
   List<FunctionElement> get functions;
 
   /**
    * Return an array containing all of the function type aliases contained in this compilation unit.
    *
    * @return the function type aliases contained in this compilation unit
    */
   List<FunctionTypeAliasElement> get functionTypeAliases;
 
   /**
    * Return the resolved [CompilationUnit] node that declares this element.
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
    * @return the resolved [CompilationUnit], not `null`.
    */
+  @override
   CompilationUnit get node;
 
   /**
    * Return an array containing all of the top-level variables contained in this compilation unit.
    *
    * @return the top-level variables contained in this compilation unit
    */
   List<TopLevelVariableElement> get topLevelVariables;
 
   /**
@@ skipping 20 matching lines @@
 abstract class ConstructorElement implements ClassMemberElement, ExecutableElement {
   /**
    * Return the resolved [ConstructorDeclaration] node that declares this
    * [ConstructorElement] .
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
    * @return the resolved [ConstructorDeclaration], not `null`.
    */
+  @override
   ConstructorDeclaration get node;
 
   /**
    * Return the constructor to which this constructor is redirecting, or `null` if this constructor
    * does not redirect to another constructor or if the library containing this constructor has
    * not yet been resolved.
    *
    * @return the constructor to which this constructor is redirecting
    */
   ConstructorElement get redirectedConstructor;
@@ skipping 641 matching lines @@
 abstract class FunctionElement implements ExecutableElement, LocalElement {
   /**
    * Return the resolved [FunctionDeclaration] node that declares this [FunctionElement]
    * .
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
    * @return the resolved [FunctionDeclaration], not `null`.
    */
+  @override
   FunctionDeclaration get node;
 }
 
 /**
  * The interface `FunctionTypeAliasElement` defines the behavior of elements representing a
  * function type alias (`typedef`).
  */
 abstract class FunctionTypeAliasElement implements Element {
   /**
    * Return the compilation unit in which this type alias is defined.
    *
    * @return the compilation unit in which this type alias is defined
    */
+  @override
   CompilationUnitElement get enclosingElement;
 
   /**
    * Return the resolved [FunctionTypeAlias] node that declares this
    * [FunctionTypeAliasElement] .
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
    * @return the resolved [FunctionTypeAlias], not `null`.
    */
+  @override
   FunctionTypeAlias get node;
 
   /**
    * Return an array containing all of the parameters defined by this type alias.
    *
    * @return the parameters defined by this type alias
    */
   List<ParameterElement> get parameters;
 
   /**
@@ skipping 116 matching lines @@
 /**
  * The interface `LabelElement` defines the behavior of elements representing a label
  * associated with a statement.
  */
 abstract class LabelElement implements Element {
   /**
    * Return the executable element in which this label is defined.
    *
    * @return the executable element in which this label is defined
    */
+  @override
   ExecutableElement get enclosingElement;
 }
 
 /**
  * The interface `LibraryElement` defines the behavior of elements representing a library.
  */
 abstract class LibraryElement implements Element {
   /**
    * Return the compilation unit that defines this library.
    *
@@ skipping 168 matching lines @@
  */
 abstract class MethodElement implements ClassMemberElement, ExecutableElement {
   /**
    * Return the resolved [MethodDeclaration] node that declares this [MethodElement].
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
    * @return the resolved [MethodDeclaration], not `null`.
    */
+  @override
   MethodDeclaration get node;
 
   /**
    * Return `true` if this method is abstract. Methods are abstract if they are not external
    * and have no body.
    *
    * @return `true` if this method is abstract
    */
   bool get isAbstract;
 }
@@ skipping 87 matching lines @@
 /**
  * The interface `PrefixElement` defines the behavior common to elements that represent a
  * prefix used to import one or more libraries into another library.
  */
 abstract class PrefixElement implements Element {
   /**
    * Return the library into which other libraries are imported using this prefix.
    *
    * @return the library into which other libraries are imported using this prefix
    */
+  @override
   LibraryElement get enclosingElement;
 
   /**
    * Return an array containing all of the libraries that are imported using this prefix.
    *
    * @return the libraries that are imported using this prefix
    */
   List<LibraryElement> get importedLibraries;
 }
 
@@ skipping 210 matching lines @@
 
   /**
    * Return the resolved [VariableDeclaration] node that declares this [VariableElement]
    * .
    *
    * This method is expensive, because resolved AST might be evicted from cache, so parsing and
    * resolving will be performed.
    *
    * @return the resolved [VariableDeclaration], not `null`.
    */
+  @override
   VariableDeclaration get node;
 
   /**
    * Return the declared type of this variable, or `null` if the variable did not have a
    * declared type (such as if it was declared using the keyword 'var').
    *
    * @return the declared type of this variable
    */
   DartType get type;
 
@@ skipping 220 matching lines @@
    * Returns `true` if property of this kind calls field setter.
    */
   bool callsSetter() => true;
 
   AngularPropertyKind(String name, int ordinal) : super(name, ordinal);
 }
 
 class AngularPropertyKind_TWO_WAY extends AngularPropertyKind {
   AngularPropertyKind_TWO_WAY(String name, int ordinal) : super(name, ordinal);
 
+  @override
   bool callsGetter() => true;
 }
 
 /**
  * The interface `AngularScopeVariableElement` defines the Angular <code>Scope</code>
  * property. They are created for every <code>scope['property'] = value;</code> code snippet.
  */
 abstract class AngularScopePropertyElement implements AngularElement {
   /**
    * An empty array of scope property elements.
@@ skipping 90 matching lines @@
  *         ParameterElement
  *            FieldFormalParameterElement
  * </pre>
  *
  * Subclasses that override a visit method must either invoke the overridden visit method or
  * explicitly invoke the more general visit method. Failure to do so will cause the visit methods
  * for superclasses of the element to not be invoked and will cause the children of the visited node
  * to not be visited.
  */
 class GeneralizingElementVisitor<R> implements ElementVisitor<R> {
+  @override
   R visitAngularComponentElement(AngularComponentElement element) => visitAngularHasSelectorElement(element);
 
+  @override
   R visitAngularControllerElement(AngularControllerElement element) => visitAngularHasSelectorElement(element);
 
+  @override
   R visitAngularDirectiveElement(AngularDirectiveElement element) => visitAngularHasSelectorElement(element);
 
   R visitAngularElement(AngularElement element) => visitToolkitObjectElement(element);
 
+  @override
   R visitAngularFilterElement(AngularFilterElement element) => visitAngularElement(element);
 
   R visitAngularHasSelectorElement(AngularHasSelectorElement element) => visitAngularElement(element);
 
+  @override
   R visitAngularPropertyElement(AngularPropertyElement element) => visitAngularElement(element);
 
+  @override
   R visitAngularScopePropertyElement(AngularScopePropertyElement element) => visitAngularElement(element);
 
+  @override
   R visitAngularSelectorElement(AngularSelectorElement element) => visitAngularElement(element);
 
+  @override
   R visitAngularViewElement(AngularViewElement element) => visitAngularElement(element);
 
+  @override
   R visitClassElement(ClassElement element) => visitElement(element);
 
+  @override
   R visitCompilationUnitElement(CompilationUnitElement element) => visitElement(element);
 
+  @override
   R visitConstructorElement(ConstructorElement element) => visitExecutableElement(element);
 
   R visitElement(Element element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitEmbeddedHtmlScriptElement(EmbeddedHtmlScriptElement element) => visitHtmlScriptElement(element);
 
   R visitExecutableElement(ExecutableElement element) => visitElement(element);
 
+  @override
   R visitExportElement(ExportElement element) => visitElement(element);
 
+  @override
   R visitExternalHtmlScriptElement(ExternalHtmlScriptElement element) => visitHtmlScriptElement(element);
 
+  @override
   R visitFieldElement(FieldElement element) => visitPropertyInducingElement(element);
 
+  @override
   R visitFieldFormalParameterElement(FieldFormalParameterElement element) => visitParameterElement(element);
 
+  @override
   R visitFunctionElement(FunctionElement element) => visitLocalElement(element);
 
+  @override
   R visitFunctionTypeAliasElement(FunctionTypeAliasElement element) => visitElement(element);
 
+  @override
   R visitHtmlElement(HtmlElement element) => visitElement(element);
 
   R visitHtmlScriptElement(HtmlScriptElement element) => visitElement(element);
 
+  @override
   R visitImportElement(ImportElement element) => visitElement(element);
 
+  @override
   R visitLabelElement(LabelElement element) => visitElement(element);
 
+  @override
   R visitLibraryElement(LibraryElement element) => visitElement(element);
 
   R visitLocalElement(LocalElement element) {
     if (element is LocalVariableElement) {
       return visitVariableElement(element);
     } else if (element is ParameterElement) {
       return visitVariableElement(element);
     } else if (element is FunctionElement) {
       return visitExecutableElement(element);
     }
     return null;
   }
 
+  @override
   R visitLocalVariableElement(LocalVariableElement element) => visitLocalElement(element);
 
+  @override
   R visitMethodElement(MethodElement element) => visitExecutableElement(element);
 
+  @override
   R visitMultiplyDefinedElement(MultiplyDefinedElement element) => visitElement(element);
 
+  @override
   R visitParameterElement(ParameterElement element) => visitLocalElement(element);
 
+  @override
   R visitPrefixElement(PrefixElement element) => visitElement(element);
 
+  @override
   R visitPropertyAccessorElement(PropertyAccessorElement element) => visitExecutableElement(element);
 
   R visitPropertyInducingElement(PropertyInducingElement element) => visitVariableElement(element);
 
   R visitToolkitObjectElement(ToolkitObjectElement element) => visitElement(element);
 
+  @override
   R visitTopLevelVariableElement(TopLevelVariableElement element) => visitPropertyInducingElement(element);
 
+  @override
   R visitTypeParameterElement(TypeParameterElement element) => visitElement(element);
 
   R visitVariableElement(VariableElement element) => visitElement(element);
 }
 
 /**
  * Instances of the class `RecursiveElementVisitor` implement an element visitor that will
  * recursively visit all of the element in an element model. For example, using an instance of this
  * class to visit a [CompilationUnitElement] will also cause all of the types in the
  * compilation unit to be visited.
  *
  * Subclasses that override a visit method must either invoke the overridden visit method or must
  * explicitly ask the visited element to visit its children. Failure to do so will cause the
  * children of the visited element to not be visited.
  */
 class RecursiveElementVisitor<R> implements ElementVisitor<R> {
+  @override
   R visitAngularComponentElement(AngularComponentElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitAngularControllerElement(AngularControllerElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitAngularDirectiveElement(AngularDirectiveElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitAngularFilterElement(AngularFilterElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitAngularPropertyElement(AngularPropertyElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitAngularScopePropertyElement(AngularScopePropertyElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitAngularSelectorElement(AngularSelectorElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitAngularViewElement(AngularViewElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitClassElement(ClassElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitCompilationUnitElement(CompilationUnitElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitConstructorElement(ConstructorElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitEmbeddedHtmlScriptElement(EmbeddedHtmlScriptElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitExportElement(ExportElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitExternalHtmlScriptElement(ExternalHtmlScriptElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitFieldElement(FieldElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitFieldFormalParameterElement(FieldFormalParameterElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitFunctionElement(FunctionElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitFunctionTypeAliasElement(FunctionTypeAliasElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitHtmlElement(HtmlElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitImportElement(ImportElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitLabelElement(LabelElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitLibraryElement(LibraryElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitLocalVariableElement(LocalVariableElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitMethodElement(MethodElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitMultiplyDefinedElement(MultiplyDefinedElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitParameterElement(ParameterElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitPrefixElement(PrefixElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitPropertyAccessorElement(PropertyAccessorElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitTopLevelVariableElement(TopLevelVariableElement element) {
     element.visitChildren(this);
     return null;
   }
 
+  @override
   R visitTypeParameterElement(TypeParameterElement element) {
     element.visitChildren(this);
     return null;
   }
 }
 
 /**
  * Instances of the class `SimpleElementVisitor` implement an element visitor that will do
  * nothing when visiting an element. It is intended to be a superclass for classes that use the
  * visitor pattern primarily as a dispatch mechanism (and hence don't need to recursively visit a
  * whole structure) and that only need to visit a small number of element types.
  */
 class SimpleElementVisitor<R> implements ElementVisitor<R> {
+  @override
   R visitAngularComponentElement(AngularComponentElement element) => null;
 
+  @override
   R visitAngularControllerElement(AngularControllerElement element) => null;
 
+  @override
   R visitAngularDirectiveElement(AngularDirectiveElement element) => null;
 
+  @override
   R visitAngularFilterElement(AngularFilterElement element) => null;
 
+  @override
   R visitAngularPropertyElement(AngularPropertyElement element) => null;
 
+  @override
   R visitAngularScopePropertyElement(AngularScopePropertyElement element) => null;
 
+  @override
   R visitAngularSelectorElement(AngularSelectorElement element) => null;
 
+  @override
   R visitAngularViewElement(AngularViewElement element) => null;
 
+  @override
   R visitClassElement(ClassElement element) => null;
 
+  @override
   R visitCompilationUnitElement(CompilationUnitElement element) => null;
 
+  @override
   R visitConstructorElement(ConstructorElement element) => null;
 
+  @override
   R visitEmbeddedHtmlScriptElement(EmbeddedHtmlScriptElement element) => null;
 
+  @override
   R visitExportElement(ExportElement element) => null;
 
+  @override
   R visitExternalHtmlScriptElement(ExternalHtmlScriptElement element) => null;
 
+  @override
   R visitFieldElement(FieldElement element) => null;
 
+  @override
   R visitFieldFormalParameterElement(FieldFormalParameterElement element) => null;
 
+  @override
   R visitFunctionElement(FunctionElement element) => null;
 
+  @override
   R visitFunctionTypeAliasElement(FunctionTypeAliasElement element) => null;
 
+  @override
   R visitHtmlElement(HtmlElement element) => null;
 
+  @override
   R visitImportElement(ImportElement element) => null;
 
+  @override
   R visitLabelElement(LabelElement element) => null;
 
+  @override
   R visitLibraryElement(LibraryElement element) => null;
 
+  @override
   R visitLocalVariableElement(LocalVariableElement element) => null;
 
+  @override
   R visitMethodElement(MethodElement element) => null;
 
+  @override
   R visitMultiplyDefinedElement(MultiplyDefinedElement element) => null;
 
+  @override
   R visitParameterElement(ParameterElement element) => null;
 
+  @override
   R visitPrefixElement(PrefixElement element) => null;
 
+  @override
   R visitPropertyAccessorElement(PropertyAccessorElement element) => null;
 
+  @override
   R visitTopLevelVariableElement(TopLevelVariableElement element) => null;
 
+  @override
   R visitTypeParameterElement(TypeParameterElement element) => null;
 }
 
 /**
  * For AST nodes that could be in both the getter and setter contexts ([IndexExpression]s and
  * [SimpleIdentifier]s), the additional resolved elements are stored in the AST node, in an
  * [AuxiliaryElements]. Since resolved elements are either statically resolved or resolved
  * using propagated type information, this class is a wrapper for a pair of
  * [ExecutableElement]s, not just a single [ExecutableElement].
  */
@@ skipping 79 matching lines @@
    */
   static List<ClassElement> EMPTY_ARRAY = new List<ClassElement>(0);
 
   /**
    * Initialize a newly created class element to have the given name.
    *
    * @param name the name of this element
    */
   ClassElementImpl(Identifier name) : super.forNode(name);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitClassElement(this);
 
+  @override
   List<PropertyAccessorElement> get accessors => _accessors;
 
+  @override
   List<InterfaceType> get allSupertypes {
     List<InterfaceType> list = new List<InterfaceType>();
     _collectAllSupertypes(list);
     return new List.from(list);
   }
 
+  @override
   ElementImpl getChild(String identifier) {
     //
     // The casts in this method are safe because the set methods would have thrown a CCE if any of
     // the elements in the arrays were not of the expected types.
     //
     for (PropertyAccessorElement accessor in _accessors) {
       if ((accessor as PropertyAccessorElementImpl).identifier == identifier) {
         return accessor as PropertyAccessorElementImpl;
       }
     }
@@ skipping 13 matching lines @@
       }
     }
     for (TypeParameterElement typeParameter in _typeParameters) {
       if ((typeParameter as TypeParameterElementImpl).identifier == identifier) {
         return typeParameter as TypeParameterElementImpl;
       }
     }
     return null;
   }
 
+  @override
   List<ConstructorElement> get constructors => _constructors;
 
+  @override
   FieldElement getField(String name) {
     for (FieldElement fieldElement in _fields) {
       if (name == fieldElement.name) {
         return fieldElement;
       }
     }
     return null;
   }
 
+  @override
   List<FieldElement> get fields => _fields;
 
+  @override
   PropertyAccessorElement getGetter(String getterName) {
     for (PropertyAccessorElement accessor in _accessors) {
       if (accessor.isGetter && accessor.name == getterName) {
         return accessor;
       }
     }
     return null;
   }
 
+  @override
   ElementKind get kind => ElementKind.CLASS;
 
+  @override
   MethodElement getMethod(String methodName) {
     for (MethodElement method in _methods) {
       if (method.name == methodName) {
         return method;
       }
     }
     return null;
   }
 
+  @override
   List<MethodElement> get methods => _methods;
 
+  @override
   ConstructorElement getNamedConstructor(String name) {
     for (ConstructorElement element in constructors) {
       String elementName = element.name;
       if (elementName != null && elementName == name) {
         return element;
       }
     }
     return null;
   }
 
+  @override
   ClassDeclaration get node => getNodeMatching((node) => node is ClassDeclaration);
 
+  @override
   PropertyAccessorElement getSetter(String setterName) {
     // TODO (jwren) revisit- should we append '=' here or require clients to include it?
     // Do we need the check for isSetter below?
     if (!StringUtilities.endsWithChar(setterName, 0x3D)) {
       setterName += '=';
     }
     for (PropertyAccessorElement accessor in _accessors) {
       if (accessor.isSetter && accessor.name == setterName) {
         return accessor;
       }
     }
     return null;
   }
 
+  @override
   List<ToolkitObjectElement> get toolkitObjects => _toolkitObjects;
 
+  @override
   List<TypeParameterElement> get typeParameters => _typeParameters;
 
+  @override
   ConstructorElement get unnamedConstructor {
     for (ConstructorElement element in constructors) {
       String name = element.displayName;
       if (name == null || name.isEmpty) {
         return element;
       }
     }
     return null;
   }
 
+  @override
   bool get hasNonFinalField {
     List<ClassElement> classesToVisit = new List<ClassElement>();
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     classesToVisit.add(this);
     while (!classesToVisit.isEmpty) {
       ClassElement currentElement = classesToVisit.removeAt(0);
       if (visitedClasses.add(currentElement)) {
         // check fields
         for (FieldElement field in currentElement.fields) {
           if (!field.isFinal && !field.isConst && !field.isStatic && !field.isSynthetic) {
@@ skipping 12 matching lines @@
           if (superElement != null) {
             classesToVisit.add(superElement);
           }
         }
       }
     }
     // not found
     return false;
   }
 
+  @override
   bool get hasReferenceToSuper => hasModifier(Modifier.REFERENCES_SUPER);
 
+  @override
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
+  @override
   bool get isOrInheritsProxy => _safeIsOrInheritsProxy(this, new Set<ClassElement>());
 
+  @override
   bool get isProxy {
     for (ElementAnnotation annotation in metadata) {
       if (annotation.isProxy) {
         return true;
       }
     }
     return false;
   }
 
+  @override
   bool get isTypedef => hasModifier(Modifier.TYPEDEF);
 
+  @override
   bool get isValidMixin => hasModifier(Modifier.MIXIN);
 
+  @override
   PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library) {
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     ClassElement currentElement = this;
     while (currentElement != null && !visitedClasses.contains(currentElement)) {
       visitedClasses.add(currentElement);
       PropertyAccessorElement element = currentElement.getGetter(getterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in currentElement.mixins) {
         ClassElement mixinElement = mixin.element;
         if (mixinElement != null) {
           element = mixinElement.getGetter(getterName);
           if (element != null && element.isAccessibleIn(library)) {
             return element;
           }
         }
       }
       InterfaceType supertype = currentElement.supertype;
       if (supertype == null) {
         return null;
       }
       currentElement = supertype.element;
     }
     return null;
   }
 
+  @override
   MethodElement lookUpMethod(String methodName, LibraryElement library) {
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     ClassElement currentElement = this;
     while (currentElement != null && !visitedClasses.contains(currentElement)) {
       visitedClasses.add(currentElement);
       MethodElement element = currentElement.getMethod(methodName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in currentElement.mixins) {
         ClassElement mixinElement = mixin.element;
         if (mixinElement != null) {
           element = mixinElement.getMethod(methodName);
           if (element != null && element.isAccessibleIn(library)) {
             return element;
           }
         }
       }
       InterfaceType supertype = currentElement.supertype;
       if (supertype == null) {
         return null;
       }
       currentElement = supertype.element;
     }
     return null;
   }
 
+  @override
   PropertyAccessorElement lookUpSetter(String setterName, LibraryElement library) {
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     ClassElement currentElement = this;
     while (currentElement != null && !visitedClasses.contains(currentElement)) {
       visitedClasses.add(currentElement);
       PropertyAccessorElement element = currentElement.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in currentElement.mixins) {
@@ skipping 115 matching lines @@
 
   /**
    * Set whether this class is a valid mixin to correspond to the given value.
    *
    * @param isValidMixin `true` if this class can be used as a mixin
    */
   void set validMixin(bool isValidMixin) {
     setModifier(Modifier.MIXIN, isValidMixin);
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_constructors, visitor);
     safelyVisitChildren(_fields, visitor);
     safelyVisitChildren(_methods, visitor);
     safelyVisitChildren(_toolkitObjects, visitor);
     safelyVisitChildren(_typeParameters, visitor);
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     String name = displayName;
     if (name == null) {
       builder.append("{unnamed class}");
     } else {
       builder.append(name);
     }
     int variableCount = _typeParameters.length;
     if (variableCount > 0) {
       builder.append("<");
@@ skipping 119 matching lines @@
    */
   List<AngularViewElement> _angularViews = AngularViewElement.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created compilation unit element to have the given name.
    *
    * @param name the name of this element
    */
   CompilationUnitElementImpl(String name) : super(name, -1);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitCompilationUnitElement(this);
 
+  @override
   bool operator ==(Object object) => object != null && runtimeType == object.runtimeType && source == (object as CompilationUnitElementImpl).source;
 
+  @override
   List<PropertyAccessorElement> get accessors => _accessors;
 
+  @override
   List<AngularViewElement> get angularViews => _angularViews;
 
+  @override
   ElementImpl getChild(String identifier) {
     //
     // The casts in this method are safe because the set methods would have thrown a CCE if any of
     // the elements in the arrays were not of the expected types.
     //
     for (PropertyAccessorElement accessor in _accessors) {
       if ((accessor as PropertyAccessorElementImpl).identifier == identifier) {
         return accessor as PropertyAccessorElementImpl;
       }
     }
@@ skipping 13 matching lines @@
       }
     }
     for (ClassElement type in _types) {
       if ((type as ClassElementImpl).identifier == identifier) {
         return type as ClassElementImpl;
       }
     }
     return null;
   }
 
+  @override
   LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
 
+  @override
   List<FunctionElement> get functions => _functions;
 
+  @override
   List<FunctionTypeAliasElement> get functionTypeAliases => _typeAliases;
 
+  @override
   ElementKind get kind => ElementKind.COMPILATION_UNIT;
 
+  @override
   CompilationUnit get node => unit;
 
+  @override
   List<TopLevelVariableElement> get topLevelVariables => _variables;
 
+  @override
   ClassElement getType(String className) {
     for (ClassElement type in _types) {
       if (type.name == className) {
         return type;
       }
     }
     return null;
   }
 
+  @override
   List<ClassElement> get types => _types;
 
+  @override
   int get hashCode => source.hashCode;
 
   /**
    * Set the top-level accessors (getters and setters) contained in this compilation unit to the
    * given accessors.
    *
    * @param the top-level accessors (getters and setters) contained in this compilation unit
    */
   void set accessors(List<PropertyAccessorElement> accessors) {
     for (PropertyAccessorElement accessor in accessors) {
@@ skipping 55 matching lines @@
    *
    * @param types types contained in this compilation unit
    */
   void set types(List<ClassElement> types) {
     for (ClassElement type in types) {
       (type as ClassElementImpl).enclosingElement = this;
     }
     this._types = types;
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_typeAliases, visitor);
     safelyVisitChildren(_types, visitor);
     safelyVisitChildren(_variables, visitor);
     safelyVisitChildren(_angularViews, visitor);
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     if (source == null) {
       builder.append("{compilation unit}");
     } else {
       builder.append(source.fullName);
     }
   }
 
+  @override
   String get identifier => source.encoding;
 
   /**
    * Returns the associated toolkit objects.
    *
    * @param element the [Element] to get toolkit objects for
    * @return the associated toolkit objects, may be empty, but not `null`
    */
   List<ToolkitObjectElement> _getToolkitObjects(Element element) {
     List<ToolkitObjectElement> objects = _toolkitObjects[element];
@@ skipping 24 matching lines @@
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created field element to have the given name.
    *
    * @param name the name of this element
    */
   ConstFieldElementImpl(Identifier name) : super.con1(name);
 
+  @override
   EvaluationResultImpl get evaluationResult => _result;
 
+  @override
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 }
 
 /**
  * Instances of the class `ConstLocalVariableElementImpl` implement a
  * `LocalVariableElement` for a local 'const' variable that has an initializer.
  */
 class ConstLocalVariableElementImpl extends LocalVariableElementImpl {
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created local variable element to have the given name.
    *
    * @param name the name of this element
    */
   ConstLocalVariableElementImpl(Identifier name) : super(name);
 
+  @override
   EvaluationResultImpl get evaluationResult => _result;
 
+  @override
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 }
 
 /**
  * Instances of the class `ConstTopLevelVariableElementImpl` implement a
  * `TopLevelVariableElement` for a top-level 'const' variable that has an initializer.
  */
 class ConstTopLevelVariableElementImpl extends TopLevelVariableElementImpl {
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created top-level variable element to have the given name.
    *
    * @param name the name of this element
    */
   ConstTopLevelVariableElementImpl(Identifier name) : super.con1(name);
 
+  @override
   EvaluationResultImpl get evaluationResult => _result;
 
+  @override
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 }
 
 /**
  * Instances of the class `ConstructorElementImpl` implement a `ConstructorElement`.
  */
 class ConstructorElementImpl extends ExecutableElementImpl implements ConstructorElement {
   /**
@@ skipping 15 matching lines @@
 
   /**
    * Initialize a newly created constructor element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   ConstructorElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
 
+  @override
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
+  @override
   ElementKind get kind => ElementKind.CONSTRUCTOR;
 
+  @override
   ConstructorDeclaration get node => getNodeMatching((node) => node is ConstructorDeclaration);
 
+  @override
   bool get isConst => hasModifier(Modifier.CONST);
 
+  @override
   bool get isDefaultConstructor {
     // unnamed
     String name = this.name;
     if (name != null && name.length != 0) {
       return false;
     }
     // no required parameters
     for (ParameterElement parameter in parameters) {
       if (identical(parameter.parameterKind, ParameterKind.REQUIRED)) {
         return false;
       }
     }
     // OK, can be used as default constructor
     return true;
   }
 
+  @override
   bool get isFactory => hasModifier(Modifier.FACTORY);
 
+  @override
   bool get isStatic => false;
 
   /**
    * Set whether this constructor represents a 'const' constructor to the given value.
    *
    * @param isConst `true` if this constructor represents a 'const' constructor
    */
   void set const2(bool isConst) {
     setModifier(Modifier.CONST, isConst);
   }
 
   /**
    * Set whether this constructor represents a factory method to the given value.
    *
    * @param isFactory `true` if this constructor represents a factory method
    */
   void set factory(bool isFactory) {
     setModifier(Modifier.FACTORY, isFactory);
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     builder.append(enclosingElement.displayName);
     String name = displayName;
     if (name != null && !name.isEmpty) {
       builder.append(".");
       builder.append(name);
     }
     super.appendTo(builder);
   }
 }
 
 /**
  * Instances of the class `DefaultFieldFormalParameterElementImpl` implement a
  * `FieldFormalParameterElementImpl` for parameters that have an initializer.
  */
 class DefaultFieldFormalParameterElementImpl extends FieldFormalParameterElementImpl {
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
   DefaultFieldFormalParameterElementImpl(Identifier name) : super(name);
 
+  @override
   EvaluationResultImpl get evaluationResult => _result;
 
+  @override
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 }
 
 /**
  * Instances of the class `DefaultParameterElementImpl` implement a `ParameterElement`
  * for parameters that have an initializer.
  */
 class DefaultParameterElementImpl extends ParameterElementImpl {
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
   DefaultParameterElementImpl(Identifier name) : super.con1(name);
 
+  @override
   EvaluationResultImpl get evaluationResult => _result;
 
+  @override
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 }
 
 /**
  * Instances of the class `DynamicElementImpl` represent the synthetic element representing
  * the declaration of the type `dynamic`.
  */
 class DynamicElementImpl extends ElementImpl {
@@ skipping 11 matching lines @@
 
   /**
    * Initialize a newly created instance of this class. Instances of this class should <b>not</b> be
    * created except as part of creating the type associated with this element. The single instance
    * of this class should be accessed through the method [getInstance].
    */
   DynamicElementImpl() : super(Keyword.DYNAMIC.syntax, -1) {
     setModifier(Modifier.SYNTHETIC, true);
   }
 
+  @override
   accept(ElementVisitor visitor) => null;
 
+  @override
   ElementKind get kind => ElementKind.DYNAMIC;
 }
 
 /**
  * Instances of the class `ElementAnnotationImpl` implement an [ElementAnnotation].
  */
 class ElementAnnotationImpl implements ElementAnnotation {
   /**
    * The element representing the field, variable, or constructor being used as an annotation.
    */
@@ skipping 26 matching lines @@
   static String _PROXY_VARIABLE_NAME = "proxy";
 
   /**
    * Initialize a newly created annotation.
    *
    * @param element the element representing the field, variable, or constructor being used as an
    *          annotation
    */
   ElementAnnotationImpl(this.element);
 
+  @override
   bool get isDeprecated {
     if (element != null) {
       LibraryElement library = element.library;
       if (library != null && library.isDartCore) {
         if (element is ConstructorElement) {
           ConstructorElement constructorElement = element as ConstructorElement;
           if (constructorElement.enclosingElement.name == _DEPRECATED_CLASS_NAME) {
             return true;
           }
         } else if (element is PropertyAccessorElement && element.name == _DEPRECATED_VARIABLE_NAME) {
           return true;
         }
       }
     }
     return false;
   }
 
+  @override
   bool get isOverride {
     if (element != null) {
       LibraryElement library = element.library;
       if (library != null && library.isDartCore) {
         if (element is PropertyAccessorElement && element.name == _OVERRIDE_VARIABLE_NAME) {
           return true;
         }
       }
     }
     return false;
   }
 
+  @override
   bool get isProxy {
     if (element != null) {
       LibraryElement library = element.library;
       if (library != null && library.isDartCore) {
         if (element is PropertyAccessorElement && element.name == _PROXY_VARIABLE_NAME) {
           return true;
         }
       }
     }
     return false;
   }
 
+  @override
   String toString() => "@${element.toString()}";
 }
 
 /**
  * The abstract class `ElementImpl` implements the behavior common to objects that implement
  * an [Element].
  */
 abstract class ElementImpl implements Element {
   /**
    * The enclosing element of this element, or `null` if this element is at the root of the
@@ skipping 38 matching lines @@
    * Initialize a newly created element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   ElementImpl(String name, this.nameOffset) {
     this._name = StringUtilities.intern(name);
   }
 
+  @override
   String computeDocumentationComment() {
     AnalysisContext context = this.context;
     if (context == null) {
       return null;
     }
     return context.computeDocumentationComment(this);
   }
 
+  @override
   bool operator ==(Object object) {
     if (identical(this, object)) {
       return true;
     }
     if (object == null || hashCode != object.hashCode) {
       return false;
     }
     return object.runtimeType == runtimeType && (object as Element).location == location;
   }
 
+  @override
   Element getAncestor(Predicate<Element> predicate) {
     Element ancestor = _enclosingElement;
     while (ancestor != null && !predicate(ancestor)) {
       ancestor = ancestor.enclosingElement;
     }
     return ancestor;
   }
 
   /**
    * Return the child of this element that is uniquely identified by the given identifier, or
    * `null` if there is no such child.
    *
    * @param identifier the identifier used to select a child
    * @return the child of this element with the given identifier
    */
   ElementImpl getChild(String identifier) => null;
 
+  @override
   AnalysisContext get context {
     if (_enclosingElement == null) {
       return null;
     }
     return _enclosingElement.context;
   }
 
+  @override
   String get displayName => _name;
 
+  @override
   Element get enclosingElement => _enclosingElement;
 
+  @override
   LibraryElement get library => getAncestor((element) => element is LibraryElement);
 
+  @override
   ElementLocation get location => new ElementLocationImpl.con1(this);
 
+  @override
   String get name => _name;
 
+  @override
   AstNode get node => getNodeMatching((node) => node is AstNode);
 
+  @override
   Source get source {
     if (_enclosingElement == null) {
       return null;
     }
     return _enclosingElement.source;
   }
 
+  @override
   CompilationUnit get unit => context.resolveCompilationUnit(source, library);
 
+  @override
   int get hashCode {
     // TODO: We might want to re-visit this optimization in the future.
     // We cache the hash code value as this is a very frequently called method.
     if (_cachedHashCode == 0) {
       _cachedHashCode = location.hashCode;
     }
     return _cachedHashCode;
   }
 
+  @override
   bool isAccessibleIn(LibraryElement library) {
     if (Identifier.isPrivateName(_name)) {
       return library == this.library;
     }
     return true;
   }
 
+  @override
   bool get isDeprecated {
     for (ElementAnnotation annotation in metadata) {
       if (annotation.isDeprecated) {
         return true;
       }
     }
     return false;
   }
 
+  @override
   bool get isOverride {
     for (ElementAnnotation annotation in metadata) {
       if (annotation.isOverride) {
         return true;
       }
     }
     return false;
   }
 
+  @override
   bool get isPrivate {
     String name = displayName;
     if (name == null) {
       return true;
     }
     return Identifier.isPrivateName(name);
   }
 
+  @override
   bool get isPublic => !isPrivate;
 
+  @override
   bool get isSynthetic => hasModifier(Modifier.SYNTHETIC);
 
   /**
    * Set whether this element is synthetic to correspond to the given value.
    *
    * @param isSynthetic `true` if the element is synthetic
    */
   void set synthetic(bool isSynthetic) {
     setModifier(Modifier.SYNTHETIC, isSynthetic);
   }
 
+  @override
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     appendTo(builder);
     return builder.toString();
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
   }
 
   /**
    * Append a textual representation of this type to the given builder.
    *
    * @param builder the builder to which the text is to be appended
    */
   void appendTo(JavaStringBuilder builder) {
     if (_name == null) {
@@ skipping 124 matching lines @@
 
   /**
    * Initialize a newly created location from the given encoded form.
    *
    * @param encoding the encoded form of a location
    */
   ElementLocationImpl.con2(String encoding) {
     this._components = _decode(encoding);
   }
 
+  @override
   bool operator ==(Object object) {
     if (identical(this, object)) {
       return true;
     }
     if (object is! ElementLocationImpl) {
       return false;
     }
     ElementLocationImpl location = object as ElementLocationImpl;
     List<String> otherComponents = location._components;
     int length = _components.length;
@@ skipping 14 matching lines @@
     return true;
   }
 
   /**
    * Return the path to the element whose location is represented by this object.
    *
    * @return the path to the element whose location is represented by this object
    */
   List<String> get components => _components;
 
+  @override
   String get encoding {
     JavaStringBuilder builder = new JavaStringBuilder();
     int length = _components.length;
     for (int i = 0; i < length; i++) {
       if (i > 0) {
         builder.appendChar(_SEPARATOR_CHAR);
       }
       _encode(builder, _components[i]);
     }
     return builder.toString();
   }
 
+  @override
   int get hashCode {
     int result = 1;
     for (int i = 0; i < _components.length; i++) {
       String component = _components[i];
       int componentHash;
       if (i <= 1) {
         componentHash = _hashSourceComponent(component);
       } else {
         componentHash = component.hashCode;
       }
       result = 31 * result + componentHash;
     }
     return result;
   }
 
+  @override
   String toString() => encoding;
 
   /**
    * Decode the encoded form of a location into an array of components.
    *
    * @param encoding the encoded form of a location
    * @return the components that were encoded
    */
   List<String> _decode(String encoding) {
     List<String> components = new List<String>();
@@ skipping 98 matching lines @@
    * The sole constructor for this class, taking two [Element]s.
    *
    * @param first the first element
    * @param second the second element
    */
   ElementPair(Element first, Element second) {
     this._first = first;
     this._second = second;
   }
 
+  @override
   bool operator ==(Object object) {
     if (identical(object, this)) {
       return true;
     }
     if (object is ElementPair) {
       ElementPair elementPair = object;
       return (_first == elementPair._first) && (_second == elementPair._second);
     }
     return false;
   }
 
   /**
    * Return the first element.
    *
    * @return the first element
    */
   Element get firstElt => _first;
 
   /**
    * Return the second element
    *
    * @return the second element
    */
   Element get secondElt => _second;
 
+  @override
   int get hashCode => ObjectUtilities.combineHashCodes(_first.hashCode, _second.hashCode);
 }
 
 /**
  * Instances of the class `EmbeddedHtmlScriptElementImpl` implement an
  * [EmbeddedHtmlScriptElement].
  */
 class EmbeddedHtmlScriptElementImpl extends HtmlScriptElementImpl implements EmbeddedHtmlScriptElement {
   /**
    * The library defined by the script tag's content.
    */
   LibraryElement _scriptLibrary;
 
   /**
    * Initialize a newly created script element to have the specified tag name and offset.
    *
    * @param node the XML node from which this element is derived (not `null`)
    */
   EmbeddedHtmlScriptElementImpl(XmlTagNode node) : super(node);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitEmbeddedHtmlScriptElement(this);
 
+  @override
   ElementKind get kind => ElementKind.EMBEDDED_HTML_SCRIPT;
 
+  @override
   LibraryElement get scriptLibrary => _scriptLibrary;
 
   /**
    * Set the script library defined by the script tag's content.
    *
    * @param scriptLibrary the library or `null` if none
    */
   void set scriptLibrary(LibraryElementImpl scriptLibrary) {
     scriptLibrary.enclosingElement = this;
     this._scriptLibrary = scriptLibrary;
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChild(_scriptLibrary, visitor);
   }
 }
 
 /**
  * The abstract class `ExecutableElementImpl` implements the behavior common to
  * `ExecutableElement`s.
  */
 abstract class ExecutableElementImpl extends ElementImpl implements ExecutableElement {
@@ skipping 41 matching lines @@
 
   /**
    * Initialize a newly created executable element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   ExecutableElementImpl.con2(String name, int nameOffset) : super(name, nameOffset);
 
+  @override
   ElementImpl getChild(String identifier) {
     for (ExecutableElement function in _functions) {
       if ((function as ExecutableElementImpl).identifier == identifier) {
         return function as ExecutableElementImpl;
       }
     }
     for (LabelElement label in _labels) {
       if ((label as LabelElementImpl).identifier == identifier) {
         return label as LabelElementImpl;
       }
     }
     for (VariableElement variable in _localVariables) {
       if ((variable as VariableElementImpl).identifier == identifier) {
         return variable as VariableElementImpl;
       }
     }
     for (ParameterElement parameter in _parameters) {
       if ((parameter as ParameterElementImpl).identifier == identifier) {
         return parameter as ParameterElementImpl;
       }
     }
     return null;
   }
 
+  @override
   List<FunctionElement> get functions => _functions;
 
+  @override
   List<LabelElement> get labels => _labels;
 
+  @override
   List<LocalVariableElement> get localVariables => _localVariables;
 
+  @override
   List<ParameterElement> get parameters => _parameters;
 
+  @override
   bool get isOperator => false;
 
   /**
    * Set the functions defined within this executable element to the given functions.
    *
    * @param functions the functions defined within this executable element
    */
   void set functions(List<FunctionElement> functions) {
     for (FunctionElement function in functions) {
       (function as FunctionElementImpl).enclosingElement = this;
@@ skipping 30 matching lines @@
    *
    * @param parameters the parameters defined by this executable element
    */
   void set parameters(List<ParameterElement> parameters) {
     for (ParameterElement parameter in parameters) {
       (parameter as ParameterElementImpl).enclosingElement = this;
     }
     this._parameters = parameters;
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_labels, visitor);
     safelyVisitChildren(_localVariables, visitor);
     safelyVisitChildren(_parameters, visitor);
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     if (this.kind != ElementKind.GETTER) {
       builder.append("(");
       String closing = null;
       ParameterKind kind = ParameterKind.REQUIRED;
       int parameterCount = _parameters.length;
       for (int i = 0; i < parameterCount; i++) {
         if (i > 0) {
           builder.append(", ");
         }
@@ skipping 46 matching lines @@
    * The combinators that were specified as part of the export directive in the order in which they
    * were specified.
    */
   List<NamespaceCombinator> combinators = NamespaceCombinator.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created export element.
    */
   ExportElementImpl() : super.forNode(null);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitExportElement(this);
 
+  @override
   ElementKind get kind => ElementKind.EXPORT;
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     builder.append("export ");
     (exportedLibrary as LibraryElementImpl).appendTo(builder);
   }
 
+  @override
   String get identifier => exportedLibrary.name;
 }
 
 /**
  * Instances of the class `ExternalHtmlScriptElementImpl` implement an
  * [ExternalHtmlScriptElement].
  */
 class ExternalHtmlScriptElementImpl extends HtmlScriptElementImpl implements ExternalHtmlScriptElement {
   /**
    * The source specified in the `source` attribute or `null` if unspecified.
    */
   Source scriptSource;
 
   /**
    * Initialize a newly created script element to have the specified tag name and offset.
    *
    * @param node the XML node from which this element is derived (not `null`)
    */
   ExternalHtmlScriptElementImpl(XmlTagNode node) : super(node);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitExternalHtmlScriptElement(this);
 
+  @override
   ElementKind get kind => ElementKind.EXTERNAL_HTML_SCRIPT;
 }
 
 /**
  * Instances of the class `FieldElementImpl` implement a `FieldElement`.
  */
 class FieldElementImpl extends PropertyInducingElementImpl implements FieldElement {
   /**
    * An empty array of field elements.
    */
   static List<FieldElement> EMPTY_ARRAY = new List<FieldElement>(0);
 
   /**
    * Initialize a newly created field element to have the given name.
    *
    * @param name the name of this element
    */
   FieldElementImpl.con1(Identifier name) : super.con1(name);
 
   /**
    * Initialize a newly created synthetic field element to have the given name.
    *
    * @param name the name of this element
    */
   FieldElementImpl.con2(String name) : super.con2(name);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
 
+  @override
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
+  @override
   ElementKind get kind => ElementKind.FIELD;
 
+  @override
   bool get isStatic => hasModifier(Modifier.STATIC);
 
   /**
    * Set whether this field is static to correspond to the given value.
    *
    * @param isStatic `true` if the field is static
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
@@ skipping 10 matching lines @@
    */
   FieldElement field;
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    */
   FieldFormalParameterElementImpl(Identifier name) : super.con1(name);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitFieldFormalParameterElement(this);
 
+  @override
   bool get isInitializingFormal => true;
 }
 
 /**
  * Instances of the class `FunctionElementImpl` implement a `FunctionElement`.
  */
 class FunctionElementImpl extends ExecutableElementImpl implements FunctionElement {
   /**
    * The offset to the beginning of the visible range for this element.
    */
@@ skipping 19 matching lines @@
 
   /**
    * Initialize a newly created function element to have no name and the given offset. This is used
    * for function expressions, which have no name.
    *
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   FunctionElementImpl.con2(int nameOffset) : super.con2("", nameOffset);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitFunctionElement(this);
 
+  @override
   ElementKind get kind => ElementKind.FUNCTION;
 
+  @override
   FunctionDeclaration get node => getNodeMatching((node) => node is FunctionDeclaration);
 
+  @override
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
+  @override
   bool get isStatic => enclosingElement is CompilationUnitElement;
 
   /**
    * Set the visible range for this element to the range starting at the given offset with the given
    * length.
    *
    * @param offset the offset to the beginning of the visible range for this element
    * @param length the length of the visible range for this element, or `-1` if this element
    *          does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     String name = displayName;
     if (name != null) {
       builder.append(name);
     }
     super.appendTo(builder);
   }
 
+  @override
   String get identifier => "${name}@${nameOffset}";
 }
 
 /**
  * Instances of the class `FunctionTypeAliasElementImpl` implement a
  * `FunctionTypeAliasElement`.
  */
 class FunctionTypeAliasElementImpl extends ElementImpl implements FunctionTypeAliasElement {
   /**
    * An array containing all of the parameters defined by this type alias.
@@ skipping 20 matching lines @@
    */
   static List<FunctionTypeAliasElement> EMPTY_ARRAY = new List<FunctionTypeAliasElement>(0);
 
   /**
    * Initialize a newly created type alias element to have the given name.
    *
    * @param name the name of this element
    */
   FunctionTypeAliasElementImpl(Identifier name) : super.forNode(name);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitFunctionTypeAliasElement(this);
 
+  @override
   ElementImpl getChild(String identifier) {
     for (VariableElement parameter in _parameters) {
       if ((parameter as VariableElementImpl).identifier == identifier) {
         return parameter as VariableElementImpl;
       }
     }
     for (TypeParameterElement typeParameter in _typeParameters) {
       if ((typeParameter as TypeParameterElementImpl).identifier == identifier) {
         return typeParameter as TypeParameterElementImpl;
       }
     }
     return null;
   }
 
+  @override
   CompilationUnitElement get enclosingElement => super.enclosingElement as CompilationUnitElement;
 
+  @override
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
 
+  @override
   FunctionTypeAlias get node => getNodeMatching((node) => node is FunctionTypeAlias);
 
+  @override
   List<ParameterElement> get parameters => _parameters;
 
+  @override
   List<TypeParameterElement> get typeParameters => _typeParameters;
 
   /**
    * Set the parameters defined by this type alias to the given parameters.
    *
    * @param parameters the parameters defined by this type alias
    */
   void set parameters(List<ParameterElement> parameters) {
     if (parameters != null) {
       for (ParameterElement parameter in parameters) {
@@ skipping 30 matching lines @@
    * Set the type parameters defined for this type to the given parameters without becoming the
    * parent of the parameters. This should only be used by the [TypeResolverVisitor] when
    * creating a synthetic type alias.
    *
    * @param typeParameters the type parameters defined for this type
    */
   void shareTypeParameters(List<TypeParameterElement> typeParameters) {
     this._typeParameters = typeParameters;
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_parameters, visitor);
     safelyVisitChildren(_typeParameters, visitor);
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     builder.append("typedef ");
     builder.append(displayName);
     int typeParameterCount = _typeParameters.length;
     if (typeParameterCount > 0) {
       builder.append("<");
       for (int i = 0; i < typeParameterCount; i++) {
         if (i > 0) {
           builder.append(", ");
         }
@@ skipping 21 matching lines @@
  * Instances of the class `HideElementCombinatorImpl` implement a
  * [HideElementCombinator].
  */
 class HideElementCombinatorImpl implements HideElementCombinator {
   /**
    * The names that are not to be made visible in the importing library even if they are defined in
    * the imported library.
    */
   List<String> hiddenNames = StringUtilities.EMPTY_ARRAY;
 
+  @override
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("show ");
     int count = hiddenNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       builder.append(hiddenNames[i]);
     }
@@ skipping 32 matching lines @@
   CompilationUnitElement angularCompilationUnit;
 
   /**
    * Initialize a newly created HTML element to have the given name.
    *
    * @param context the analysis context in which the HTML file is defined
    * @param name the name of this element
    */
   HtmlElementImpl(this.context, String name) : super(name, -1);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitHtmlElement(this);
 
+  @override
   bool operator ==(Object object) {
     if (identical(object, this)) {
       return true;
     }
     if (object == null) {
       return false;
     }
     return runtimeType == object.runtimeType && source == (object as HtmlElementImpl).source;
   }
 
+  @override
   ElementKind get kind => ElementKind.HTML;
 
+  @override
   List<HtmlScriptElement> get scripts => _scripts;
 
+  @override
   int get hashCode => source.hashCode;
 
   /**
    * Set the scripts contained in the HTML file to the given scripts.
    *
    * @param scripts the scripts
    */
   void set scripts(List<HtmlScriptElement> scripts) {
     if (scripts.length == 0) {
       scripts = HtmlScriptElementImpl.EMPTY_ARRAY;
     }
     for (HtmlScriptElement script in scripts) {
       (script as HtmlScriptElementImpl).enclosingElement = this;
     }
     this._scripts = scripts;
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_scripts, visitor);
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     if (source == null) {
       builder.append("{HTML file}");
     } else {
       builder.append(source.fullName);
     }
   }
 }
 
 /**
@@ skipping 51 matching lines @@
    */
   PrefixElement prefix;
 
   /**
    * Initialize a newly created import element.
    *
    * @param offset the directive offset, may be `-1` if synthetic.
    */
   ImportElementImpl(int offset) : super(null, offset);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitImportElement(this);
 
+  @override
   ElementKind get kind => ElementKind.IMPORT;
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(prefix, visitor);
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     builder.append("import ");
     (importedLibrary as LibraryElementImpl).appendTo(builder);
   }
 
+  @override
   String get identifier => "${(importedLibrary as LibraryElementImpl).identifier}@${nameOffset}";
 }
 
 /**
  * Instances of the class `LabelElementImpl` implement a `LabelElement`.
  */
 class LabelElementImpl extends ElementImpl implements LabelElement {
   /**
    * A flag indicating whether this label is associated with a `switch` statement.
    */
@@ skipping 16 matching lines @@
    * @param name the name of this element
    * @param onSwitchStatement `true` if this label is associated with a `switch`
    *          statement
    * @param onSwitchMember `true` if this label is associated with a `switch` member
    */
   LabelElementImpl(Identifier name, bool onSwitchStatement, bool onSwitchMember) : super.forNode(name) {
     this._onSwitchStatement = onSwitchStatement;
     this._onSwitchMember = onSwitchMember;
   }
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitLabelElement(this);
 
+  @override
   ExecutableElement get enclosingElement => super.enclosingElement as ExecutableElement;
 
+  @override
   ElementKind get kind => ElementKind.LABEL;
 
   /**
    * Return `true` if this label is associated with a `switch` member (`case` or
    * `default`).
    *
    * @return `true` if this label is associated with a `switch` member
    */
   bool get isOnSwitchMember => _onSwitchMember;
 
@@ skipping 88 matching lines @@
   bool _isAngularHtml = false;
 
   /**
    * Initialize a newly created library element to have the given name.
    *
    * @param context the analysis context in which the library is defined
    * @param name the name of this element
    */
   LibraryElementImpl(this.context, LibraryIdentifier name) : super.forNode(name);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
 
+  @override
   bool operator ==(Object object) => object != null && runtimeType == object.runtimeType && _definingCompilationUnit == (object as LibraryElementImpl).definingCompilationUnit;
 
+  @override
   ElementImpl getChild(String identifier) {
     if ((_definingCompilationUnit as CompilationUnitElementImpl).identifier == identifier) {
       return _definingCompilationUnit as CompilationUnitElementImpl;
     }
     for (CompilationUnitElement part in _parts) {
       if ((part as CompilationUnitElementImpl).identifier == identifier) {
         return part as CompilationUnitElementImpl;
       }
     }
     for (ImportElement importElement in _imports) {
       if ((importElement as ImportElementImpl).identifier == identifier) {
         return importElement as ImportElementImpl;
       }
     }
     for (ExportElement exportElement in _exports) {
       if ((exportElement as ExportElementImpl).identifier == identifier) {
         return exportElement as ExportElementImpl;
       }
     }
     return null;
   }
 
+  @override
   CompilationUnitElement get definingCompilationUnit => _definingCompilationUnit;
 
+  @override
   List<LibraryElement> get exportedLibraries {
     Set<LibraryElement> libraries = new Set<LibraryElement>();
     for (ExportElement element in _exports) {
       LibraryElement library = element.exportedLibrary;
       if (library != null) {
         libraries.add(library);
       }
     }
     return new List.from(libraries);
   }
 
+  @override
   List<ExportElement> get exports => _exports;
 
+  @override
   List<LibraryElement> get importedLibraries {
     Set<LibraryElement> libraries = new Set<LibraryElement>();
     for (ImportElement element in _imports) {
       LibraryElement library = element.importedLibrary;
       if (library != null) {
         libraries.add(library);
       }
     }
     return new List.from(libraries);
   }
 
+  @override
   List<ImportElement> get imports => _imports;
 
+  @override
   ElementKind get kind => ElementKind.LIBRARY;
 
+  @override
   LibraryElement get library => this;
 
+  @override
   List<CompilationUnitElement> get parts => _parts;
 
+  @override
   List<PrefixElement> get prefixes {
     Set<PrefixElement> prefixes = new Set<PrefixElement>();
     for (ImportElement element in _imports) {
       PrefixElement prefix = element.prefix;
       if (prefix != null) {
         prefixes.add(prefix);
       }
     }
     return new List.from(prefixes);
   }
 
+  @override
   Source get source {
     if (_definingCompilationUnit == null) {
       return null;
     }
     return _definingCompilationUnit.source;
   }
 
+  @override
   ClassElement getType(String className) {
     ClassElement type = _definingCompilationUnit.getType(className);
     if (type != null) {
       return type;
     }
     for (CompilationUnitElement part in _parts) {
       type = part.getType(className);
       if (type != null) {
         return type;
       }
     }
     return null;
   }
 
+  @override
   List<CompilationUnitElement> get units {
     List<CompilationUnitElement> units = new List<CompilationUnitElement>(1 + _parts.length);
     units[0] = _definingCompilationUnit;
     JavaSystem.arraycopy(_parts, 0, units, 1, _parts.length);
     return units;
   }
 
+  @override
   List<LibraryElement> get visibleLibraries {
     Set<LibraryElement> visibleLibraries = new Set();
     _addVisibleLibraries(visibleLibraries, false);
     return new List.from(visibleLibraries);
   }
 
+  @override
   bool get hasExtUri => hasModifier(Modifier.HAS_EXT_URI);
 
+  @override
   int get hashCode => _definingCompilationUnit.hashCode;
 
+  @override
   bool get isAngularHtml => _isAngularHtml;
 
+  @override
   bool get isBrowserApplication => entryPoint != null && isOrImportsBrowserLibrary;
 
+  @override
   bool get isDartCore => name == "dart.core";
 
+  @override
   bool get isInSdk => StringUtilities.startsWith5(name, 0, 0x64, 0x61, 0x72, 0x74, 0x2E);
 
+  @override
   bool isUpToDate(int timeStamp) {
     Set<LibraryElement> visitedLibraries = new Set();
     return _safeIsUpToDate(this, timeStamp, visitedLibraries);
   }
 
   /**
    * Specifies if this library is created for Angular analysis.
    */
   void set angularHtml(bool isAngularHtml) {
     this._isAngularHtml = isAngularHtml;
@@ skipping 52 matching lines @@
    * @param parts the compilation units that are included in this library using a `part`
    *          directive
    */
   void set parts(List<CompilationUnitElement> parts) {
     for (CompilationUnitElement compilationUnit in parts) {
       (compilationUnit as CompilationUnitElementImpl).enclosingElement = this;
     }
     this._parts = parts;
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_definingCompilationUnit, visitor);
     safelyVisitChildren(_exports, visitor);
     safelyVisitChildren(_imports, visitor);
     safelyVisitChildren(_parts, visitor);
   }
 
+  @override
   String get identifier => _definingCompilationUnit.source.encoding;
 
   /**
    * Recursively fills set of visible libraries for [getVisibleElementsLibraries].
    */
   void _addVisibleLibraries(Set<LibraryElement> visibleLibraries, bool includeExports) {
     // maybe already processed
     if (!visibleLibraries.add(this)) {
       return;
     }
@@ skipping 75 matching lines @@
    */
   static List<LocalVariableElement> EMPTY_ARRAY = new List<LocalVariableElement>(0);
 
   /**
    * Initialize a newly created local variable element to have the given name.
    *
    * @param name the name of this element
    */
   LocalVariableElementImpl(Identifier name) : super.con1(name);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitLocalVariableElement(this);
 
+  @override
   ElementKind get kind => ElementKind.LOCAL_VARIABLE;
 
+  @override
   List<ToolkitObjectElement> get toolkitObjects {
     CompilationUnitElementImpl unit = getAncestor((element) => element is CompilationUnitElementImpl);
     if (unit == null) {
       return ToolkitObjectElement.EMPTY_ARRAY;
     }
     return unit._getToolkitObjects(this);
   }
 
+  @override
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
+  @override
   bool get isPotentiallyMutatedInClosure => _potentiallyMutatedInClosure;
 
+  @override
   bool get isPotentiallyMutatedInScope => _potentiallyMutatedInScope;
 
   /**
    * Specifies that this variable is potentially mutated somewhere in closure.
    */
   void markPotentiallyMutatedInClosure() {
     _potentiallyMutatedInClosure = true;
   }
 
   /**
@@ skipping 22 matching lines @@
    *
    * @param offset the offset to the beginning of the visible range for this element
    * @param length the length of the visible range for this element, or `-1` if this element
    *          does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     builder.append(type);
     builder.append(" ");
     builder.append(displayName);
   }
 
+  @override
   String get identifier => "${super.identifier}@${nameOffset}";
 }
 
 /**
  * Instances of the class `MethodElementImpl` implement a `MethodElement`.
  */
 class MethodElementImpl extends ExecutableElementImpl implements MethodElement {
   /**
    * An empty array of method elements.
    */
   static List<MethodElement> EMPTY_ARRAY = new List<MethodElement>(0);
 
   /**
    * Initialize a newly created method element to have the given name.
    *
    * @param name the name of this element
    */
   MethodElementImpl.con1(Identifier name) : super.con1(name);
 
   /**
    * Initialize a newly created method element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   MethodElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
 
+  @override
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
+  @override
   ElementKind get kind => ElementKind.METHOD;
 
+  @override
   String get name {
     String name = super.name;
     if (isOperator && name == "-") {
       if (parameters.length == 0) {
         return "unary-";
       }
     }
     return super.name;
   }
 
+  @override
   MethodDeclaration get node => getNodeMatching((node) => node is MethodDeclaration);
 
+  @override
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
+  @override
   bool get isOperator {
     String name = displayName;
     if (name.isEmpty) {
       return false;
     }
     int first = name.codeUnitAt(0);
     return !((0x61 <= first && first <= 0x7A) || (0x41 <= first && first <= 0x5A) || first == 0x5F || first == 0x24);
   }
 
+  @override
   bool get isStatic => hasModifier(Modifier.STATIC);
 
   /**
    * Set whether this method is abstract to correspond to the given value.
    *
    * @param isAbstract `true` if the method is abstract
    */
   void set abstract(bool isAbstract) {
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
 
   /**
    * Set whether this method is static to correspond to the given value.
    *
    * @param isStatic `true` if the method is static
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     builder.append(enclosingElement.displayName);
     builder.append(".");
     builder.append(displayName);
     super.appendTo(builder);
   }
 }
 
 /**
  * The enumeration `Modifier` defines constants for all of the modifiers defined by the Dart
@@ skipping 145 matching lines @@
   /**
    * Initialize a newly created element to represent a list of conflicting elements.
    *
    * @param context the analysis context in which the multiply defined elements are defined
    * @param conflictingElements the elements that conflict
    */
   MultiplyDefinedElementImpl(this.context, this.conflictingElements) {
     _name = conflictingElements[0].name;
   }
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitMultiplyDefinedElement(this);
 
+  @override
   String computeDocumentationComment() => null;
 
+  @override
   Element getAncestor(Predicate<Element> predicate) => null;
 
+  @override
   String get displayName => _name;
 
+  @override
   Element get enclosingElement => null;
 
+  @override
   ElementKind get kind => ElementKind.ERROR;
 
+  @override
   LibraryElement get library => null;
 
+  @override
   ElementLocation get location => null;
 
+  @override
   List<ElementAnnotation> get metadata => ElementAnnotationImpl.EMPTY_ARRAY;
 
+  @override
   String get name => _name;
 
+  @override
   int get nameOffset => -1;
 
+  @override
   AstNode get node => null;
 
+  @override
   Source get source => null;
 
+  @override
   DartType get type => DynamicTypeImpl.instance;
 
+  @override
   CompilationUnit get unit => null;
 
+  @override
   bool isAccessibleIn(LibraryElement library) {
     for (Element element in conflictingElements) {
       if (element.isAccessibleIn(library)) {
         return true;
       }
     }
     return false;
   }
 
+  @override
   bool get isDeprecated => false;
 
+  @override
   bool get isOverride => false;
 
+  @override
   bool get isPrivate {
     String name = displayName;
     if (name == null) {
       return false;
     }
     return Identifier.isPrivateName(name);
   }
 
+  @override
   bool get isPublic => !isPrivate;
 
+  @override
   bool get isSynthetic => true;
 
+  @override
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("[");
     int count = conflictingElements.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       (conflictingElements[i] as ElementImpl).appendTo(builder);
     }
     builder.append("]");
     return builder.toString();
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
   }
 }
 
 /**
  * The interface [MultiplyInheritedMethodElementImpl] defines all of the behavior of an
  * [MethodElementImpl], with the additional information of an array of
  * [ExecutableElement]s from which this element was composed.
  */
 class MultiplyInheritedMethodElementImpl extends MethodElementImpl implements MultiplyInheritedExecutableElement {
   /**
    * An array the array of executable elements that were used to compose this element.
    */
   List<ExecutableElement> _elements = MethodElementImpl.EMPTY_ARRAY;
 
   MultiplyInheritedMethodElementImpl(Identifier name) : super.con1(name) {
     synthetic = true;
   }
 
+  @override
   List<ExecutableElement> get inheritedElements => _elements;
 
   void set inheritedElements(List<ExecutableElement> elements) {
     this._elements = elements;
   }
 }
 
 /**
  * The interface [MultiplyInheritedPropertyAccessorElementImpl] defines all of the behavior of
  * an [PropertyAccessorElementImpl], with the additional information of an array of
  * [ExecutableElement]s from which this element was composed.
  */
 class MultiplyInheritedPropertyAccessorElementImpl extends PropertyAccessorElementImpl implements MultiplyInheritedExecutableElement {
   /**
    * An array the array of executable elements that were used to compose this element.
    */
   List<ExecutableElement> _elements = PropertyAccessorElementImpl.EMPTY_ARRAY;
 
   MultiplyInheritedPropertyAccessorElementImpl(Identifier name) : super.con1(name) {
     synthetic = true;
   }
 
+  @override
   List<ExecutableElement> get inheritedElements => _elements;
 
   void set inheritedElements(List<ExecutableElement> elements) {
     this._elements = elements;
   }
 }
 
 /**
  * Instances of the class `ParameterElementImpl` implement a `ParameterElement`.
  */
@@ skipping 55 matching lines @@
 
   /**
    * Initialize a newly created parameter element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   ParameterElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
 
+  @override
   SourceRange get defaultValueRange {
     if (_defaultValueRangeLength < 0) {
       return null;
     }
     return new SourceRange(_defaultValueRangeOffset, _defaultValueRangeLength);
   }
 
+  @override
   ElementKind get kind => ElementKind.PARAMETER;
 
+  @override
   List<ParameterElement> get parameters => _parameters;
 
+  @override
   SourceRange get visibleRange {
     if (_visibleRangeLength < 0) {
       return null;
     }
     return new SourceRange(_visibleRangeOffset, _visibleRangeLength);
   }
 
+  @override
   bool get isInitializingFormal => false;
 
+  @override
   bool get isPotentiallyMutatedInClosure => _potentiallyMutatedInClosure;
 
+  @override
   bool get isPotentiallyMutatedInScope => _potentiallyMutatedInScope;
 
   /**
    * Specifies that this variable is potentially mutated somewhere in closure.
    */
   void markPotentiallyMutatedInClosure() {
     _potentiallyMutatedInClosure = true;
   }
 
   /**
@@ skipping 34 matching lines @@
    *
    * @param offset the offset to the beginning of the visible range for this element
    * @param length the length of the visible range for this element, or `-1` if this element
    *          does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_parameters, visitor);
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     String left = "";
     String right = "";
     while (true) {
       if (parameterKind == ParameterKind.NAMED) {
         left = "{";
         right = "}";
       } else if (parameterKind == ParameterKind.POSITIONAL) {
         left = "[";
         right = "]";
@@ skipping 32 matching lines @@
    */
   static List<PrefixElement> EMPTY_ARRAY = new List<PrefixElement>(0);
 
   /**
    * Initialize a newly created prefix element to have the given name.
    *
    * @param name the name of this element
    */
   PrefixElementImpl(Identifier name) : super.forNode(name);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitPrefixElement(this);
 
+  @override
   LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
 
+  @override
   List<LibraryElement> get importedLibraries => _importedLibraries;
 
+  @override
   ElementKind get kind => ElementKind.PREFIX;
 
   /**
    * Set the libraries that are imported using this prefix to the given libraries.
    *
    * @param importedLibraries the libraries that are imported using this prefix
    */
   void set importedLibraries(List<LibraryElement> importedLibraries) {
     for (LibraryElement library in importedLibraries) {
       (library as LibraryElementImpl).enclosingElement = this;
     }
     this._importedLibraries = importedLibraries;
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     builder.append("as ");
     super.appendTo(builder);
   }
 
+  @override
   String get identifier => "_${super.identifier}";
 }
 
 /**
  * Instances of the class `PropertyAccessorElementImpl` implement a
  * `PropertyAccessorElement`.
  */
 class PropertyAccessorElementImpl extends ExecutableElementImpl implements PropertyAccessorElement {
   /**
    * The variable associated with this accessor.
@@ skipping 16 matching lines @@
    * Initialize a newly created synthetic property accessor element to be associated with the given
    * variable.
    *
    * @param variable the variable with which this access is associated
    */
   PropertyAccessorElementImpl.con2(PropertyInducingElementImpl variable) : super.con2(variable.name, variable.nameOffset) {
     this.variable = variable;
     synthetic = true;
   }
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
 
+  @override
   bool operator ==(Object object) => super == object && identical(isGetter, (object as PropertyAccessorElement).isGetter);
 
+  @override
   PropertyAccessorElement get correspondingGetter {
     if (isGetter || variable == null) {
       return null;
     }
     return variable.getter;
   }
 
+  @override
   PropertyAccessorElement get correspondingSetter {
     if (isSetter || variable == null) {
       return null;
     }
     return variable.setter;
   }
 
+  @override
   ElementKind get kind {
     if (isGetter) {
       return ElementKind.GETTER;
     }
     return ElementKind.SETTER;
   }
 
+  @override
   String get name {
     if (isSetter) {
       return "${super.name}=";
     }
     return super.name;
   }
 
+  @override
   AstNode get node {
     if (isSynthetic) {
       return null;
     }
     if (enclosingElement is ClassElement) {
       return getNodeMatching((node) => node is MethodDeclaration);
     }
     if (enclosingElement is CompilationUnitElement) {
       return getNodeMatching((node) => node is FunctionDeclaration);
     }
     return null;
   }
 
+  @override
   int get hashCode => ObjectUtilities.combineHashCodes(super.hashCode, isGetter ? 1 : 2);
 
+  @override
   bool get isAbstract => hasModifier(Modifier.ABSTRACT);
 
+  @override
   bool get isGetter => hasModifier(Modifier.GETTER);
 
+  @override
   bool get isSetter => hasModifier(Modifier.SETTER);
 
+  @override
   bool get isStatic => hasModifier(Modifier.STATIC);
 
   /**
    * Set whether this accessor is abstract to correspond to the given value.
    *
    * @param isAbstract `true` if the accessor is abstract
    */
   void set abstract(bool isAbstract) {
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
@@ skipping 18 matching lines @@
 
   /**
    * Set whether this accessor is static to correspond to the given value.
    *
    * @param isStatic `true` if the accessor is static
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     builder.append(isGetter ? "get " : "set ");
     builder.append(variable.displayName);
     super.appendTo(builder);
   }
 }
 
 /**
  * Instances of the class `PropertyInducingElementImpl` implement a
  * `PropertyInducingElement`.
@@ skipping 46 matching lines @@
   /**
    * The offset of the character immediately following the last character of this node.
    */
   int end = -1;
 
   /**
    * The offset of the 'show' keyword of this element.
    */
   int offset = 0;
 
+  @override
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append("show ");
     int count = shownNames.length;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       builder.append(shownNames[i]);
     }
@@ skipping 32 matching lines @@
    */
   TopLevelVariableElementImpl.con1(Identifier name) : super.con1(name);
 
   /**
    * Initialize a newly created synthetic top-level variable element to have the given name.
    *
    * @param name the name of this element
    */
   TopLevelVariableElementImpl.con2(String name) : super.con2(name);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
 
+  @override
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
 
+  @override
   bool get isStatic => true;
 }
 
 /**
  * Instances of the class `TypeParameterElementImpl` implement a [TypeParameterElement].
  */
 class TypeParameterElementImpl extends ElementImpl implements TypeParameterElement {
   /**
    * The type defined by this type parameter.
    */
@@ skipping 10 matching lines @@
    */
   static List<TypeParameterElement> EMPTY_ARRAY = new List<TypeParameterElement>(0);
 
   /**
    * Initialize a newly created type parameter element to have the given name.
    *
    * @param name the name of this element
    */
   TypeParameterElementImpl(Identifier name) : super.forNode(name);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitTypeParameterElement(this);
 
+  @override
   ElementKind get kind => ElementKind.TYPE_PARAMETER;
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     builder.append(displayName);
     if (bound != null) {
       builder.append(" extends ");
       builder.append(bound);
     }
   }
 }
 
 /**
@@ skipping 34 matching lines @@
 
   /**
    * Return the result of evaluating this variable's initializer as a compile-time constant
    * expression, or `null` if this variable is not a 'const' variable, if it does not have an
    * initializer, or if the compilation unit containing the variable has not been resolved.
    *
    * @return the result of evaluating this variable's initializer
    */
   EvaluationResultImpl get evaluationResult => null;
 
+  @override
   FunctionElement get initializer => _initializer;
 
+  @override
   VariableDeclaration get node => getNodeMatching((node) => node is VariableDeclaration);
 
+  @override
   bool get isConst => hasModifier(Modifier.CONST);
 
+  @override
   bool get isFinal => hasModifier(Modifier.FINAL);
 
   /**
    * Return `true` if this variable is potentially mutated somewhere in a closure. This
    * information is only available for local variables (including parameters) and only after the
    * compilation unit containing the variable has been resolved.
    *
    * @return `true` if this variable is potentially mutated somewhere in closure
    */
   bool get isPotentiallyMutatedInClosure => false;
@@ skipping 40 matching lines @@
    *
    * @param initializer the function representing this variable's initializer
    */
   void set initializer(FunctionElement initializer) {
     if (initializer != null) {
       (initializer as FunctionElementImpl).enclosingElement = this;
     }
     this._initializer = initializer;
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_initializer, visitor);
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     builder.append(type);
     builder.append(" ");
     builder.append(displayName);
   }
 }
 
 /**
  * Information about Angular application.
  */
@@ skipping 64 matching lines @@
    * Initialize a newly created Angular component to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   AngularComponentElementImpl(String name, int nameOffset, int annotationOffset) : super(name, nameOffset) {
     this._annotationOffset = annotationOffset;
   }
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitAngularComponentElement(this);
 
+  @override
   ElementKind get kind => ElementKind.ANGULAR_COMPONENT;
 
+  @override
   List<AngularPropertyElement> get properties => _properties;
 
+  @override
   List<AngularScopePropertyElement> get scopeProperties => _scopeProperties;
 
   /**
    * Set an array containing all of the properties declared by this component.
    *
    * @param properties the properties to set
    */
   void set properties(List<AngularPropertyElement> properties) {
     for (AngularPropertyElement property in properties) {
       encloseElement(property as AngularPropertyElementImpl);
     }
     this._properties = properties;
   }
 
   /**
    * Set an array containing all of the scope properties declared by this component.
    *
    * @param properties the properties to set
    */
   void set scopeProperties(List<AngularScopePropertyElement> properties) {
     for (AngularScopePropertyElement property in properties) {
       encloseElement(property as AngularScopePropertyElementImpl);
     }
     this._scopeProperties = properties;
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChildren(_properties, visitor);
     safelyVisitChildren(_scopeProperties, visitor);
     super.visitChildren(visitor);
   }
 
+  @override
   String get identifier => "AngularComponent@${_annotationOffset}";
 }
 
 /**
  * Implementation of `AngularControllerElement`.
  */
 class AngularControllerElementImpl extends AngularHasSelectorElementImpl implements AngularControllerElement {
   /**
    * Initialize a newly created Angular controller to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   AngularControllerElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitAngularControllerElement(this);
 
+  @override
   ElementKind get kind => ElementKind.ANGULAR_CONTROLLER;
 }
 
 /**
  * Implementation of `AngularDirectiveElement`.
  */
 class AngularDirectiveElementImpl extends AngularHasSelectorElementImpl implements AngularDirectiveElement {
   /**
    * The offset of the annotation that defines this directive.
    */
   int _offset = 0;
 
   /**
    * The array containing all of the properties declared by this directive.
    */
   List<AngularPropertyElement> _properties = AngularPropertyElement.EMPTY_ARRAY;
 
   /**
    * Initialize a newly created Angular directive to have the given name.
    *
    * @param offset the offset of the annotation that defines this directive
    */
   AngularDirectiveElementImpl(int offset) : super(null, -1) {
     this._offset = offset;
   }
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitAngularDirectiveElement(this);
 
+  @override
   String get displayName => selector.displayName;
 
+  @override
   ElementKind get kind => ElementKind.ANGULAR_DIRECTIVE;
 
+  @override
   List<AngularPropertyElement> get properties => _properties;
 
+  @override
   bool isClass(String name) {
     Element enclosing = enclosingElement;
     return enclosing is ClassElement && enclosing.name == name;
   }
 
   /**
    * Set an array containing all of the properties declared by this directive.
    *
    * @param properties the properties to set
    */
   void set properties(List<AngularPropertyElement> properties) {
     for (AngularPropertyElement property in properties) {
       encloseElement(property as AngularPropertyElementImpl);
     }
     this._properties = properties;
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChildren(_properties, visitor);
     super.visitChildren(visitor);
   }
 
+  @override
   String get identifier => "NgDirective@${_offset}";
 }
 
 /**
  * Implementation of `AngularElement`.
  */
 abstract class AngularElementImpl extends ToolkitObjectElementImpl implements AngularElement {
   /**
    * The [AngularApplication] this element is used in.
    */
   AngularApplication _application;
 
   /**
    * Initialize a newly created Angular element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   AngularElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
+  @override
   AngularApplication get application => _application;
 
   /**
    * Set the [AngularApplication] this element is used in.
    */
   void set application(AngularApplication application) {
     this._application = application;
   }
 }
 
 /**
  * Implementation of `AngularFilterElement`.
  */
 class AngularFilterElementImpl extends AngularElementImpl implements AngularFilterElement {
   /**
    * Initialize a newly created Angular filter to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   AngularFilterElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitAngularFilterElement(this);
 
+  @override
   ElementKind get kind => ElementKind.ANGULAR_FILTER;
 }
 
 /**
  * Implementation of [AngularSelectorElement] based on presence of a class.
  */
 class AngularHasClassSelectorElementImpl extends AngularSelectorElementImpl implements AngularHasClassSelectorElement {
   AngularHasClassSelectorElementImpl(String name, int offset) : super(name, offset);
 
+  @override
   bool apply(XmlTagNode node) {
     XmlAttributeNode attribute = node.getAttribute("class");
     if (attribute != null) {
       String text = attribute.text;
       if (text != null) {
         String name = this.name;
         for (String className in StringUtils.split(text)) {
           if (className == name) {
             return true;
           }
         }
       }
     }
     return false;
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     builder.append(".");
     builder.append(name);
   }
 }
 
 /**
  * Implementation of `AngularSelectorElement`.
  */
 abstract class AngularHasSelectorElementImpl extends AngularElementImpl implements AngularHasSelectorElement {
   /**
    * The selector of this element.
    */
   AngularSelectorElement _selector;
 
   /**
    * Initialize a newly created Angular element to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   AngularHasSelectorElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
+  @override
   AngularSelectorElement get selector => _selector;
 
   /**
    * Set the selector of this selector-based element.
    *
    * @param selector the selector to set
    */
   void set selector(AngularSelectorElement selector) {
     encloseElement(selector as AngularSelectorElementImpl);
     this._selector = selector;
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChild(_selector, visitor);
     super.visitChildren(visitor);
   }
 }
 
 /**
  * Implementation of `AngularPropertyElement`.
  */
 class AngularPropertyElementImpl extends AngularElementImpl implements AngularPropertyElement {
@@ skipping 11 matching lines @@
 
   /**
    * Initialize a newly created Angular property to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   AngularPropertyElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitAngularPropertyElement(this);
 
+  @override
   ElementKind get kind => ElementKind.ANGULAR_PROPERTY;
 }
 
 /**
  * Implementation of `AngularScopePropertyElement`.
  */
 class AngularScopePropertyElementImpl extends AngularElementImpl implements AngularScopePropertyElement {
   /**
    * The type of the property
    */
   final DartType type;
 
   /**
    * Initialize a newly created Angular scope property to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   AngularScopePropertyElementImpl(String name, int nameOffset, this.type) : super(name, nameOffset);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitAngularScopePropertyElement(this);
 
+  @override
   ElementKind get kind => ElementKind.ANGULAR_SCOPE_PROPERTY;
 }
 
 /**
  * Implementation of `AngularFilterElement`.
  */
 abstract class AngularSelectorElementImpl extends AngularElementImpl implements AngularSelectorElement {
   /**
    * Initialize a newly created Angular selector to have the given name.
    *
    * @param name the name of this element
    * @param nameOffset the offset of the name of this element in the file that contains the
    *          declaration of this element
    */
   AngularSelectorElementImpl(String name, int nameOffset) : super(name, nameOffset);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitAngularSelectorElement(this);
 
+  @override
   ElementKind get kind => ElementKind.ANGULAR_SELECTOR;
 }
 
 /**
  * Implementation of [AngularSelectorElement] based on tag name.
  */
 class AngularTagSelectorElementImpl extends AngularSelectorElementImpl implements AngularTagSelectorElement {
   AngularTagSelectorElementImpl(String name, int offset) : super(name, offset);
 
+  @override
   bool apply(XmlTagNode node) {
     String tagName = name;
     return node.tag == tagName;
   }
 
+  @override
   AngularApplication get application => (enclosingElement as AngularElementImpl).application;
 }
 
 /**
  * Implementation of `AngularViewElement`.
  */
 class AngularViewElementImpl extends AngularElementImpl implements AngularViewElement {
   /**
    * The HTML template URI.
    */
   final String templateUri;
 
   /**
    * The offset of the [templateUri] in the [getSource].
    */
   final int templateUriOffset;
 
   /**
    * The HTML template source.
    */
   Source templateSource;
 
   /**
    * Initialize a newly created Angular view.
    */
   AngularViewElementImpl(this.templateUri, this.templateUriOffset) : super(null, -1);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitAngularViewElement(this);
 
+  @override
   ElementKind get kind => ElementKind.ANGULAR_VIEW;
 
+  @override
   String get identifier => "AngularView@${templateUriOffset}";
 }
 
 /**
  * Implementation of [AngularSelectorElement] based on presence of attribute.
  */
 class HasAttributeSelectorElementImpl extends AngularSelectorElementImpl implements AngularHasAttributeSelectorElement {
   HasAttributeSelectorElementImpl(String attributeName, int offset) : super(attributeName, offset);
 
+  @override
   bool apply(XmlTagNode node) {
     String attributeName = name;
     return node.getAttribute(attributeName) != null;
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     builder.append("[");
     builder.append(name);
     builder.append("]");
   }
 }
 
 /**
  * Combination of [AngularTagSelectorElementImpl] and [HasAttributeSelectorElementImpl].
  */
 class IsTagHasAttributeSelectorElementImpl extends AngularSelectorElementImpl {
   final String tagName;
 
   final String attributeName;
 
   IsTagHasAttributeSelectorElementImpl(this.tagName, this.attributeName) : super(null, -1);
 
+  @override
   bool apply(XmlTagNode node) => node.tag == tagName && node.getAttribute(attributeName) != null;
 }
 
 /**
  * Instances of the class `ConstructorMember` represent a constructor element defined in a
  * parameterized type where the values of the type parameters are known.
  */
 class ConstructorMember extends ExecutableMember implements ConstructorElement {
   /**
    * If the given constructor's type is different when any type parameters from the defining type's
@@ skipping 27 matching lines @@
   }
 
   /**
    * Initialize a newly created element to represent a constructor of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   ConstructorMember(ConstructorElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
 
+  @override
   ConstructorElement get baseElement => super.baseElement as ConstructorElement;
 
+  @override
   ClassElement get enclosingElement => baseElement.enclosingElement;
 
+  @override
   ConstructorDeclaration get node => baseElement.node;
 
+  @override
   ConstructorElement get redirectedConstructor => from(baseElement.redirectedConstructor, definingType);
 
+  @override
   bool get isConst => baseElement.isConst;
 
+  @override
   bool get isDefaultConstructor => baseElement.isDefaultConstructor;
 
+  @override
   bool get isFactory => baseElement.isFactory;
 
+  @override
   String toString() {
     ConstructorElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append(baseElement.enclosingElement.displayName);
     String name = displayName;
     if (name != null && !name.isEmpty) {
       builder.append(".");
       builder.append(name);
     }
     builder.append("(");
     int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       builder.append(parameters[i]).toString();
     }
     builder.append(")");
     if (type != null) {
       builder.append(Element.RIGHT_ARROW);
       builder.append(type.returnType);
     }
     return builder.toString();
   }
 
+  @override
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 
 /**
  * The abstract class `ExecutableMember` defines the behavior common to members that represent
  * an executable element defined in a parameterized type where the values of the type parameters are
  * known.
  */
 abstract class ExecutableMember extends Member implements ExecutableElement {
   /**
    * Initialize a newly created element to represent an executable element of the given
    * parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   ExecutableMember(ExecutableElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
 
+  @override
   ExecutableElement get baseElement => super.baseElement as ExecutableElement;
 
+  @override
   List<FunctionElement> get functions {
     //
     // Elements within this element should have type parameters substituted, just like this element.
     //
     throw new UnsupportedOperationException();
   }
 
+  @override
   List<LabelElement> get labels => baseElement.labels;
 
+  @override
   List<LocalVariableElement> get localVariables {
     //
     // Elements within this element should have type parameters substituted, just like this element.
     //
     throw new UnsupportedOperationException();
   }
 
+  @override
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = baseElement.parameters;
     int parameterCount = baseParameters.length;
     if (parameterCount == 0) {
       return baseParameters;
     }
     List<ParameterElement> parameterizedParameters = new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       parameterizedParameters[i] = ParameterMember.from(baseParameters[i], definingType);
     }
     return parameterizedParameters;
   }
 
+  @override
   DartType get returnType => substituteFor(baseElement.returnType);
 
+  @override
   FunctionType get type => substituteFor(baseElement.type);
 
+  @override
   bool get isOperator => baseElement.isOperator;
 
+  @override
   bool get isStatic => baseElement.isStatic;
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     // TODO(brianwilkerson) We need to finish implementing the accessors used below so that we can
     // safely invoke them.
     super.visitChildren(visitor);
     safelyVisitChildren(baseElement.functions, visitor);
     safelyVisitChildren(labels, visitor);
     safelyVisitChildren(baseElement.localVariables, visitor);
     safelyVisitChildren(parameters, visitor);
   }
 }
 
 /**
  * Instances of the class `FieldFormalParameterMember` represent a parameter element defined
  * in a parameterized type where the values of the type parameters are known.
  */
 class FieldFormalParameterMember extends ParameterMember implements FieldFormalParameterElement {
   /**
    * Initialize a newly created element to represent a parameter of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   FieldFormalParameterMember(FieldFormalParameterElement baseElement, ParameterizedType definingType) : super(baseElement, definingType);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitFieldFormalParameterElement(this);
 
+  @override
   FieldElement get field => (baseElement as FieldFormalParameterElement).field;
 }
 
 /**
  * Instances of the class `FieldMember` represent a field element defined in a parameterized
  * type where the values of the type parameters are known.
  */
 class FieldMember extends VariableMember implements FieldElement {
   /**
    * If the given field's type is different when any type parameters from the defining type's
@@ skipping 26 matching lines @@
   }
 
   /**
    * Initialize a newly created element to represent a field of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   FieldMember(FieldElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitFieldElement(this);
 
+  @override
   FieldElement get baseElement => super.baseElement as FieldElement;
 
+  @override
   ClassElement get enclosingElement => baseElement.enclosingElement;
 
+  @override
   PropertyAccessorElement get getter => PropertyAccessorMember.from(baseElement.getter, definingType);
 
+  @override
   PropertyAccessorElement get setter => PropertyAccessorMember.from(baseElement.setter, definingType);
 
+  @override
   bool get isStatic => baseElement.isStatic;
 
+  @override
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 
 /**
  * The abstract class `Member` defines the behavior common to elements that represent members
  * of parameterized types.
  */
 abstract class Member implements Element {
   /**
    * The element on which the parameterized element was created.
    */
   Element _baseElement;
 
   /**
    * The type in which the element is defined.
    */
   ParameterizedType _definingType;
 
   /**
    * Initialize a newly created element to represent the member of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   Member(Element baseElement, ParameterizedType definingType) {
     this._baseElement = baseElement;
     this._definingType = definingType;
   }
 
+  @override
   String computeDocumentationComment() => _baseElement.computeDocumentationComment();
 
+  @override
   Element getAncestor(Predicate<Element> predicate) => baseElement.getAncestor(predicate);
 
   /**
    * Return the element on which the parameterized element was created.
    *
    * @return the element on which the parameterized element was created
    */
   Element get baseElement => _baseElement;
 
+  @override
   AnalysisContext get context => _baseElement.context;
 
+  @override
   String get displayName => _baseElement.displayName;
 
+  @override
   ElementKind get kind => _baseElement.kind;
 
+  @override
   LibraryElement get library => _baseElement.library;
 
+  @override
   ElementLocation get location => _baseElement.location;
 
+  @override
   List<ElementAnnotation> get metadata => _baseElement.metadata;
 
+  @override
   String get name => _baseElement.name;
 
+  @override
   int get nameOffset => _baseElement.nameOffset;
 
+  @override
   AstNode get node => _baseElement.node;
 
+  @override
   Source get source => _baseElement.source;
 
+  @override
   CompilationUnit get unit => _baseElement.unit;
 
+  @override
   bool isAccessibleIn(LibraryElement library) => _baseElement.isAccessibleIn(library);
 
+  @override
   bool get isDeprecated => _baseElement.isDeprecated;
 
+  @override
   bool get isOverride => _baseElement.isOverride;
 
+  @override
   bool get isPrivate => _baseElement.isPrivate;
 
+  @override
   bool get isPublic => _baseElement.isPublic;
 
+  @override
   bool get isSynthetic => _baseElement.isSynthetic;
 
+  @override
   void visitChildren(ElementVisitor visitor) {
   }
 
   /**
    * Return the type in which the element is defined.
    *
    * @return the type in which the element is defined
    */
   ParameterizedType get definingType => _definingType;
 
@@ skipping 86 matching lines @@
   }
 
   /**
    * Initialize a newly created element to represent a method of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   MethodMember(MethodElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
 
+  @override
   MethodElement get baseElement => super.baseElement as MethodElement;
 
+  @override
   ClassElement get enclosingElement => baseElement.enclosingElement;
 
+  @override
   MethodDeclaration get node => baseElement.node;
 
+  @override
   bool get isAbstract => baseElement.isAbstract;
 
+  @override
   String toString() {
     MethodElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append(baseElement.enclosingElement.displayName);
     builder.append(".");
     builder.append(baseElement.displayName);
     builder.append("(");
     int parameterCount = parameters.length;
@@ skipping 53 matching lines @@
   }
 
   /**
    * Initialize a newly created element to represent a parameter of the given parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   ParameterMember(ParameterElement baseElement, ParameterizedType definingType) : super(baseElement, definingType);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
 
+  @override
   Element getAncestor(Predicate<Element> predicate) {
     Element element = baseElement.getAncestor(predicate);
     ParameterizedType definingType = this.definingType;
     if (definingType is InterfaceType) {
       InterfaceType definingInterfaceType = definingType;
       if (element is ConstructorElement) {
         return ConstructorMember.from(element, definingInterfaceType);
       } else if (element is MethodElement) {
         return MethodMember.from(element, definingInterfaceType);
       } else if (element is PropertyAccessorElement) {
         return PropertyAccessorMember.from(element, definingInterfaceType);
       }
     }
     return element;
   }
 
+  @override
   ParameterElement get baseElement => super.baseElement as ParameterElement;
 
+  @override
   SourceRange get defaultValueRange => baseElement.defaultValueRange;
 
+  @override
   Element get enclosingElement => baseElement.enclosingElement;
 
+  @override
   ParameterKind get parameterKind => baseElement.parameterKind;
 
+  @override
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = baseElement.parameters;
     int parameterCount = baseParameters.length;
     if (parameterCount == 0) {
       return baseParameters;
     }
     List<ParameterElement> parameterizedParameters = new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       parameterizedParameters[i] = ParameterMember.from(baseParameters[i], definingType);
     }
     return parameterizedParameters;
   }
 
+  @override
   SourceRange get visibleRange => baseElement.visibleRange;
 
+  @override
   bool get isInitializingFormal => baseElement.isInitializingFormal;
 
+  @override
   String toString() {
     ParameterElement baseElement = this.baseElement;
     String left = "";
     String right = "";
     while (true) {
       if (baseElement.parameterKind == ParameterKind.NAMED) {
         left = "{";
         right = "}";
       } else if (baseElement.parameterKind == ParameterKind.POSITIONAL) {
         left = "[";
         right = "]";
       } else if (baseElement.parameterKind == ParameterKind.REQUIRED) {
       }
       break;
     }
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append(left);
     builder.append(type);
     builder.append(" ");
     builder.append(baseElement.displayName);
     builder.append(right);
     return builder.toString();
   }
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(parameters, visitor);
   }
 }
 
 /**
  * Instances of the class `PropertyAccessorMember` represent a property accessor element
  * defined in a parameterized type where the values of the type parameters are known.
  */
@@ skipping 27 matching lines @@
 
   /**
    * Initialize a newly created element to represent a property accessor of the given parameterized
    * type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   PropertyAccessorMember(PropertyAccessorElement baseElement, InterfaceType definingType) : super(baseElement, definingType);
 
+  @override
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
 
+  @override
   PropertyAccessorElement get baseElement => super.baseElement as PropertyAccessorElement;
 
+  @override
   PropertyAccessorElement get correspondingGetter => from(baseElement.correspondingGetter, definingType);
 
+  @override
   PropertyAccessorElement get correspondingSetter => from(baseElement.correspondingSetter, definingType);
 
+  @override
   Element get enclosingElement => baseElement.enclosingElement;
 
+  @override
   PropertyInducingElement get variable {
     PropertyInducingElement variable = baseElement.variable;
     if (variable is FieldElement) {
       return FieldMember.from(variable, definingType);
     }
     return variable;
   }
 
+  @override
   bool get isAbstract => baseElement.isAbstract;
 
+  @override
   bool get isGetter => baseElement.isGetter;
 
+  @override
   bool get isSetter => baseElement.isSetter;
 
+  @override
   String toString() {
     PropertyAccessorElement baseElement = this.baseElement;
     List<ParameterElement> parameters = this.parameters;
     FunctionType type = this.type;
     JavaStringBuilder builder = new JavaStringBuilder();
     if (isGetter) {
       builder.append("get ");
     } else {
       builder.append("set ");
     }
     builder.append(baseElement.enclosingElement.displayName);
     builder.append(".");
     builder.append(baseElement.displayName);
     builder.append("(");
     int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         builder.append(", ");
       }
       builder.append(parameters[i]).toString();
     }
     builder.append(")");
     if (type != null) {
       builder.append(Element.RIGHT_ARROW);
       builder.append(type.returnType);
     }
     return builder.toString();
   }
 
+  @override
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 
 /**
  * The abstract class `VariableMember` defines the behavior common to members that represent a
  * variable element defined in a parameterized type where the values of the type parameters are
  * known.
  */
 abstract class VariableMember extends Member implements VariableElement {
   /**
    * Initialize a newly created element to represent an executable element of the given
    * parameterized type.
    *
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   VariableMember(VariableElement baseElement, ParameterizedType definingType) : super(baseElement, definingType);
 
+  @override
   VariableElement get baseElement => super.baseElement as VariableElement;
 
+  @override
   FunctionElement get initializer {
     //
     // Elements within this element should have type parameters substituted, just like this element.
     //
     throw new UnsupportedOperationException();
   }
 
+  @override
   VariableDeclaration get node => baseElement.node;
 
+  @override
   DartType get type => substituteFor(baseElement.type);
 
+  @override
   bool get isConst => baseElement.isConst;
 
+  @override
   bool get isFinal => baseElement.isFinal;
 
+  @override
   void visitChildren(ElementVisitor visitor) {
     // TODO(brianwilkerson) We need to finish implementing the accessors used below so that we can
     // safely invoke them.
     super.visitChildren(visitor);
     safelyVisitChild(baseElement.initializer, visitor);
   }
 }
 
 /**
  * The unique instance of the class `BottomTypeImpl` implements the type `bottom`.
  */
 class BottomTypeImpl extends TypeImpl {
   /**
    * The unique instance of this class.
    */
   static BottomTypeImpl _INSTANCE = new BottomTypeImpl();
 
   /**
    * Return the unique instance of this class.
    *
    * @return the unique instance of this class
    */
   static BottomTypeImpl get instance => _INSTANCE;
 
   /**
    * Prevent the creation of instances of this class.
    */
   BottomTypeImpl() : super(null, "<bottom>");
 
+  @override
   bool operator ==(Object object) => identical(object, this);
 
+  @override
   int get hashCode => 0;
 
+  @override
   bool get isBottom => true;
 
+  @override
   bool isSupertypeOf(DartType type) => false;
 
+  @override
   BottomTypeImpl substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes) => this;
 
+  @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) => identical(object, this);
 
+  @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 
+  @override
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 }
 
 /**
  * The unique instance of the class `DynamicTypeImpl` implements the type `dynamic`.
  */
 class DynamicTypeImpl extends TypeImpl {
   /**
    * The unique instance of this class.
    */
   static DynamicTypeImpl _INSTANCE = new DynamicTypeImpl();
 
   /**
    * Return the unique instance of this class.
    *
    * @return the unique instance of this class
    */
   static DynamicTypeImpl get instance => _INSTANCE;
 
   /**
    * Prevent the creation of instances of this class.
    */
   DynamicTypeImpl() : super(new DynamicElementImpl(), Keyword.DYNAMIC.syntax) {
     (element as DynamicElementImpl).type = this;
   }
 
+  @override
   bool operator ==(Object object) => identical(object, this);
 
+  @override
   int get hashCode => 1;
 
+  @override
   bool get isDynamic => true;
 
+  @override
   bool isSupertypeOf(DartType type) => true;
 
+  @override
   DartType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes) {
     int length = parameterTypes.length;
     for (int i = 0; i < length; i++) {
       if (parameterTypes[i] == this) {
         return argumentTypes[i];
       }
     }
     return this;
   }
 
+  @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) => identical(object, this);
 
+  @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     // T is S
     if (identical(this, type)) {
       return true;
     }
     // else
     return withDynamic;
   }
 
+  @override
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) => true;
 }
 
 /**
  * Instances of the class `FunctionTypeImpl` defines the behavior common to objects
  * representing the type of a function, method, constructor, getter, or setter.
  */
 class FunctionTypeImpl extends TypeImpl implements FunctionType {
   /**
    * Return `true` if all of the name/type pairs in the first map are equal to the
@@ skipping 36 matching lines @@
   FunctionTypeImpl.con1(ExecutableElement element) : super(element, element == null ? null : element.name);
 
   /**
    * Initialize a newly created function type to be declared by the given element and to have the
    * given name.
    *
    * @param element the element representing the declaration of the function type
    */
   FunctionTypeImpl.con2(FunctionTypeAliasElement element) : super(element, element == null ? null : element.name);
 
+  @override
   bool operator ==(Object object) => internalEquals(object, new Set<ElementPair>());
 
+  @override
   String get displayName {
     String name = this.name;
     if (name == null || name.length == 0) {
       // TODO(brianwilkerson) Determine whether function types should ever have an empty name.
       List<DartType> normalParameterTypes = this.normalParameterTypes;
       List<DartType> optionalParameterTypes = this.optionalParameterTypes;
       Map<String, DartType> namedParameterTypes = this.namedParameterTypes;
       DartType returnType = this.returnType;
       JavaStringBuilder builder = new JavaStringBuilder();
       builder.append("(");
@@ skipping 49 matching lines @@
       if (returnType == null) {
         builder.append("null");
       } else {
         builder.append(returnType.displayName);
       }
       name = builder.toString();
     }
     return name;
   }
 
+  @override
   Map<String, DartType> get namedParameterTypes {
     LinkedHashMap<String, DartType> namedParameterTypes = new LinkedHashMap<String, DartType>();
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return namedParameterTypes;
     }
     List<DartType> typeParameters = TypeParameterTypeImpl.getTypes(this.typeParameters);
     for (ParameterElement parameter in parameters) {
       if (identical(parameter.parameterKind, ParameterKind.NAMED)) {
         namedParameterTypes[parameter.name] = parameter.type.substitute2(typeArguments, typeParameters);
       }
     }
     return namedParameterTypes;
   }
 
+  @override
   List<DartType> get normalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return TypeImpl.EMPTY_ARRAY;
     }
     List<DartType> typeParameters = TypeParameterTypeImpl.getTypes(this.typeParameters);
     List<DartType> types = new List<DartType>();
     for (ParameterElement parameter in parameters) {
       if (identical(parameter.parameterKind, ParameterKind.REQUIRED)) {
         types.add(parameter.type.substitute2(typeArguments, typeParameters));
       }
     }
     return new List.from(types);
   }
 
+  @override
   List<DartType> get optionalParameterTypes {
     List<ParameterElement> parameters = baseParameters;
     if (parameters.length == 0) {
       return TypeImpl.EMPTY_ARRAY;
     }
     List<DartType> typeParameters = TypeParameterTypeImpl.getTypes(this.typeParameters);
     List<DartType> types = new List<DartType>();
     for (ParameterElement parameter in parameters) {
       if (identical(parameter.parameterKind, ParameterKind.POSITIONAL)) {
         types.add(parameter.type.substitute2(typeArguments, typeParameters));
       }
     }
     return new List.from(types);
   }
 
+  @override
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = this.baseParameters;
     // no parameters, quick return
     int parameterCount = baseParameters.length;
     if (parameterCount == 0) {
       return baseParameters;
     }
     // create specialized parameters
     List<ParameterElement> specializedParameters = new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       specializedParameters[i] = ParameterMember.from(baseParameters[i], this);
     }
     return specializedParameters;
   }
 
+  @override
   DartType get returnType {
     DartType baseReturnType = this.baseReturnType;
     if (baseReturnType == null) {
       // TODO(brianwilkerson) This is a patch. The return type should never be null and we need to
       // understand why it is and fix it.
       return DynamicTypeImpl.instance;
     }
     return baseReturnType.substitute2(typeArguments, TypeParameterTypeImpl.getTypes(typeParameters));
   }
 
+  @override
   List<TypeParameterElement> get typeParameters {
     Element element = this.element;
     if (element is FunctionTypeAliasElement) {
       return element.typeParameters;
     }
     ClassElement definingClass = element.getAncestor((element) => element is ClassElement);
     if (definingClass != null) {
       return definingClass.typeParameters;
     }
     return TypeParameterElementImpl.EMPTY_ARRAY;
   }
 
+  @override
   int get hashCode {
     if (element == null) {
       return 0;
     }
     // Reference the arrays of parameters
     List<DartType> normalParameterTypes = this.normalParameterTypes;
     List<DartType> optionalParameterTypes = this.optionalParameterTypes;
     Iterable<DartType> namedParameterTypes = this.namedParameterTypes.values;
     // Generate the hashCode
     int hashCode = returnType.hashCode;
     for (int i = 0; i < normalParameterTypes.length; i++) {
       hashCode = (hashCode << 1) + normalParameterTypes[i].hashCode;
     }
     for (int i = 0; i < optionalParameterTypes.length; i++) {
       hashCode = (hashCode << 1) + optionalParameterTypes[i].hashCode;
     }
     for (DartType type in namedParameterTypes) {
       hashCode = (hashCode << 1) + type.hashCode;
     }
     return hashCode;
   }
 
+  @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     // trivial base cases
     if (type == null) {
       return false;
     } else if (identical(this, type) || type.isDynamic || type.isDartCoreFunction || type.isObject) {
       return true;
     } else if (type is! FunctionType) {
       return false;
     } else if (this == type) {
       return true;
@@ skipping 81 matching lines @@
             return false;
           }
         }
       }
     }
     DartType tRetType = t.returnType;
     DartType sRetType = s.returnType;
     return sRetType.isVoid || (tRetType as TypeImpl).isMoreSpecificThan2(sRetType, withDynamic, visitedTypePairs);
   }
 
+  @override
   bool isAssignableTo(DartType type) => isSubtypeOf2(type, new Set<TypeImpl_TypePair>());
 
+  @override
   FunctionTypeImpl substitute3(List<DartType> argumentTypes) => substitute2(argumentTypes, typeArguments);
 
+  @override
   FunctionTypeImpl substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes) {
     if (argumentTypes.length != parameterTypes.length) {
       throw new IllegalArgumentException("argumentTypes.length (${argumentTypes.length}) != parameterTypes.length (${parameterTypes.length})");
     }
     if (argumentTypes.length == 0) {
       return this;
     }
     Element element = this.element;
     FunctionTypeImpl newType = (element is ExecutableElement) ? new FunctionTypeImpl.con1(element) : new FunctionTypeImpl.con2(element as FunctionTypeAliasElement);
     newType.typeArguments = TypeImpl.substitute(typeArguments, argumentTypes, parameterTypes);
     return newType;
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     List<DartType> normalParameterTypes = this.normalParameterTypes;
     List<DartType> optionalParameterTypes = this.optionalParameterTypes;
     Map<String, DartType> namedParameterTypes = this.namedParameterTypes;
     DartType returnType = this.returnType;
     builder.append("(");
     bool needsComma = false;
     if (normalParameterTypes.length > 0) {
       for (DartType type in normalParameterTypes) {
         if (needsComma) {
@@ skipping 54 matching lines @@
    */
   List<ParameterElement> get baseParameters {
     Element element = this.element;
     if (element is ExecutableElement) {
       return element.parameters;
     } else {
       return (element as FunctionTypeAliasElement).parameters;
     }
   }
 
+  @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) {
     if (object is! FunctionTypeImpl) {
       return false;
     }
     FunctionTypeImpl otherType = object as FunctionTypeImpl;
     // If the visitedTypePairs already has the pair (this, type), use the elements to determine equality
     ElementPair elementPair = new ElementPair(element, otherType.element);
     if (!visitedElementPairs.add(elementPair)) {
       return elementPair.firstElt == elementPair.secondElt;
     }
     // Compute the result
     bool result = TypeImpl.equalArrays(normalParameterTypes, otherType.normalParameterTypes, visitedElementPairs) && TypeImpl.equalArrays(optionalParameterTypes, otherType.optionalParameterTypes, visitedElementPairs) && _equals(namedParameterTypes, otherType.namedParameterTypes, visitedElementPairs) && (returnType as TypeImpl).internalEquals(otherType.returnType, visitedElementPairs);
     // Remove the pair from our visited pairs list
     visitedElementPairs.remove(elementPair);
     // Return the result
     return result;
   }
 
+  @override
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
     // trivial base cases
     if (type == null) {
       return false;
     } else if (identical(this, type) || type.isDynamic || type.isDartCoreFunction || type.isObject) {
       return true;
     } else if (type is! FunctionType) {
       return false;
     } else if (this == type) {
       return true;
@@ skipping 287 matching lines @@
   InterfaceTypeImpl.con1(ClassElement element) : super(element, element.displayName);
 
   /**
    * Initialize a newly created type to have the given name. This constructor should only be used in
    * cases where there is no declaration of the type.
    *
    * @param name the name of the type
    */
   InterfaceTypeImpl.con2(String name) : super(null, name);
 
+  @override
   bool operator ==(Object object) => internalEquals(object, new Set<ElementPair>());
 
+  @override
   List<PropertyAccessorElement> get accessors {
     List<PropertyAccessorElement> accessors = element.accessors;
     List<PropertyAccessorElement> members = new List<PropertyAccessorElement>(accessors.length);
     for (int i = 0; i < accessors.length; i++) {
       members[i] = PropertyAccessorMember.from(accessors[i], this);
     }
     return members;
   }
 
+  @override
   String get displayName {
     String name = this.name;
     List<DartType> typeArguments = this.typeArguments;
     bool allDynamic = true;
     for (DartType type in typeArguments) {
       if (type != null && !type.isDynamic) {
         allDynamic = false;
         break;
       }
     }
     // If there is at least one non-dynamic type, then list them out
     if (!allDynamic) {
       JavaStringBuilder builder = new JavaStringBuilder();
       builder.append(name);
       builder.append("<");
       for (int i = 0; i < typeArguments.length; i++) {
         if (i != 0) {
           builder.append(", ");
         }
         DartType typeArg = typeArguments[i];
         builder.append(typeArg.displayName);
       }
       builder.append(">");
       name = builder.toString();
     }
     return name;
   }
 
+  @override
   ClassElement get element => super.element as ClassElement;
 
+  @override
   PropertyAccessorElement getGetter(String getterName) => PropertyAccessorMember.from((element as ClassElementImpl).getGetter(getterName), this);
 
+  @override
   List<InterfaceType> get interfaces {
     ClassElement classElement = element;
     List<InterfaceType> interfaces = classElement.interfaces;
     List<TypeParameterElement> typeParameters = classElement.typeParameters;
     List<DartType> parameterTypes = classElement.type.typeArguments;
     if (typeParameters.length == 0) {
       return interfaces;
     }
     int count = interfaces.length;
     List<InterfaceType> typedInterfaces = new List<InterfaceType>(count);
     for (int i = 0; i < count; i++) {
       typedInterfaces[i] = interfaces[i].substitute2(typeArguments, parameterTypes);
     }
     return typedInterfaces;
   }
 
+  @override
   DartType getLeastUpperBound(DartType type) {
     // quick check for self
     if (identical(type, this)) {
       return this;
     }
     // dynamic
     DartType dynamicType = DynamicTypeImpl.instance;
     if (identical(this, dynamicType) || identical(type, dynamicType)) {
       return dynamicType;
     }
@@ skipping 35 matching lines @@
       if (numberOfTypesAtMaxDepth == 1) {
         return s[indexOfLeastUpperBound];
       }
     }
     // illegal state, log and return null- Object at maxDepth == 0 should always return itself as
     // the least upper bound.
     // TODO (jwren) log the error state
     return null;
   }
 
+  @override
   MethodElement getMethod(String methodName) => MethodMember.from((element as ClassElementImpl).getMethod(methodName), this);
 
+  @override
   List<MethodElement> get methods {
     List<MethodElement> methods = element.methods;
     List<MethodElement> members = new List<MethodElement>(methods.length);
     for (int i = 0; i < methods.length; i++) {
       members[i] = MethodMember.from(methods[i], this);
     }
     return members;
   }
 
+  @override
   List<InterfaceType> get mixins {
     ClassElement classElement = element;
     List<InterfaceType> mixins = classElement.mixins;
     List<TypeParameterElement> typeParameters = classElement.typeParameters;
     List<DartType> parameterTypes = classElement.type.typeArguments;
     if (typeParameters.length == 0) {
       return mixins;
     }
     int count = mixins.length;
     List<InterfaceType> typedMixins = new List<InterfaceType>(count);
     for (int i = 0; i < count; i++) {
       typedMixins[i] = mixins[i].substitute2(typeArguments, parameterTypes);
     }
     return typedMixins;
   }
 
+  @override
   PropertyAccessorElement getSetter(String setterName) => PropertyAccessorMember.from((element as ClassElementImpl).getSetter(setterName), this);
 
+  @override
   InterfaceType get superclass {
     ClassElement classElement = element;
     InterfaceType supertype = classElement.supertype;
     if (supertype == null) {
       return null;
     }
     return supertype.substitute2(typeArguments, classElement.type.typeArguments);
   }
 
+  @override
   List<TypeParameterElement> get typeParameters => element.typeParameters;
 
+  @override
   int get hashCode {
     ClassElement element = this.element;
     if (element == null) {
       return 0;
     }
     return element.hashCode;
   }
 
+  @override
   bool get isDartCoreFunction {
     ClassElement element = this.element;
     if (element == null) {
       return false;
     }
     return element.name == "Function" && element.library.isDartCore;
   }
 
+  @override
   bool isDirectSupertypeOf(InterfaceType type) {
     InterfaceType i = this;
     InterfaceType j = type;
     ClassElement jElement = j.element;
     InterfaceType supertype = jElement.supertype;
     //
     // If J has no direct supertype then it is Object, and Object has no direct supertypes.
     //
     if (supertype == null) {
       return false;
@@ skipping 26 matching lines @@
       }
     }
     //
     // J is a mixin application of the mixin of I.
     //
     // TODO(brianwilkerson) Determine whether this needs to be implemented or whether it is covered
     // by the case above.
     return false;
   }
 
+  @override
   bool get isObject => element.supertype == null;
 
+  @override
   ConstructorElement lookUpConstructor(String constructorName, LibraryElement library) {
     // prepare base ConstructorElement
     ConstructorElement constructorElement;
     if (constructorName == null) {
       constructorElement = element.unnamedConstructor;
     } else {
       constructorElement = element.getNamedConstructor(constructorName);
     }
     // not found or not accessible
     if (constructorElement == null || !constructorElement.isAccessibleIn(library)) {
       return null;
     }
     // return member
     return ConstructorMember.from(constructorElement, this);
   }
 
+  @override
   PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library) {
     PropertyAccessorElement element = getGetter(getterName);
     if (element != null && element.isAccessibleIn(library)) {
       return element;
     }
     return lookUpGetterInSuperclass(getterName, library);
   }
 
+  @override
   PropertyAccessorElement lookUpGetterInSuperclass(String getterName, LibraryElement library) {
     for (InterfaceType mixin in mixins) {
       PropertyAccessorElement element = mixin.getGetter(getterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     InterfaceType supertype = superclass;
     ClassElement supertypeElement = supertype == null ? null : supertype.element;
     while (supertype != null && !visitedClasses.contains(supertypeElement)) {
       visitedClasses.add(supertypeElement);
       PropertyAccessorElement element = supertype.getGetter(getterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in supertype.mixins) {
         element = mixin.getGetter(getterName);
         if (element != null && element.isAccessibleIn(library)) {
           return element;
         }
       }
       supertype = supertype.superclass;
       supertypeElement = supertype == null ? null : supertype.element;
     }
     return null;
   }
 
+  @override
   MethodElement lookUpMethod(String methodName, LibraryElement library) {
     MethodElement element = getMethod(methodName);
     if (element != null && element.isAccessibleIn(library)) {
       return element;
     }
     return lookUpMethodInSuperclass(methodName, library);
   }
 
+  @override
   MethodElement lookUpMethodInSuperclass(String methodName, LibraryElement library) {
     for (InterfaceType mixin in mixins) {
       MethodElement element = mixin.getMethod(methodName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     InterfaceType supertype = superclass;
     ClassElement supertypeElement = supertype == null ? null : supertype.element;
     while (supertype != null && !visitedClasses.contains(supertypeElement)) {
       visitedClasses.add(supertypeElement);
       MethodElement element = supertype.getMethod(methodName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in supertype.mixins) {
         element = mixin.getMethod(methodName);
         if (element != null && element.isAccessibleIn(library)) {
           return element;
         }
       }
       supertype = supertype.superclass;
       supertypeElement = supertype == null ? null : supertype.element;
     }
     return null;
   }
 
+  @override
   PropertyAccessorElement lookUpSetter(String setterName, LibraryElement library) {
     PropertyAccessorElement element = getSetter(setterName);
     if (element != null && element.isAccessibleIn(library)) {
       return element;
     }
     return lookUpSetterInSuperclass(setterName, library);
   }
 
+  @override
   PropertyAccessorElement lookUpSetterInSuperclass(String setterName, LibraryElement library) {
     for (InterfaceType mixin in mixins) {
       PropertyAccessorElement element = mixin.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
     }
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     InterfaceType supertype = superclass;
     ClassElement supertypeElement = supertype == null ? null : supertype.element;
     while (supertype != null && !visitedClasses.contains(supertypeElement)) {
       visitedClasses.add(supertypeElement);
       PropertyAccessorElement element = supertype.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in supertype.mixins) {
         element = mixin.getSetter(setterName);
         if (element != null && element.isAccessibleIn(library)) {
           return element;
         }
       }
       supertype = supertype.superclass;
       supertypeElement = supertype == null ? null : supertype.element;
     }
     return null;
   }
 
+  @override
   InterfaceTypeImpl substitute4(List<DartType> argumentTypes) => substitute2(argumentTypes, typeArguments);
 
+  @override
   InterfaceTypeImpl substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes) {
     if (argumentTypes.length != parameterTypes.length) {
       throw new IllegalArgumentException("argumentTypes.length (${argumentTypes.length}) != parameterTypes.length (${parameterTypes.length})");
     }
     if (argumentTypes.length == 0 || typeArguments.length == 0) {
       return this;
     }
     List<DartType> newTypeArguments = TypeImpl.substitute(typeArguments, argumentTypes, parameterTypes);
     if (JavaArrays.equals(newTypeArguments, typeArguments)) {
       return this;
     }
     InterfaceTypeImpl newType = new InterfaceTypeImpl.con1(element);
     newType.typeArguments = newTypeArguments;
     return newType;
   }
 
+  @override
   void appendTo(JavaStringBuilder builder) {
     builder.append(name);
     int argumentCount = typeArguments.length;
     if (argumentCount > 0) {
       builder.append("<");
       for (int i = 0; i < argumentCount; i++) {
         if (i > 0) {
           builder.append(", ");
         }
         (typeArguments[i] as TypeImpl).appendTo(builder);
       }
       builder.append(">");
     }
   }
 
+  @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) {
     if (object is! InterfaceTypeImpl) {
       return false;
     }
     InterfaceTypeImpl otherType = object as InterfaceTypeImpl;
     return (element == otherType.element) && TypeImpl.equalArrays(typeArguments, otherType.typeArguments, visitedElementPairs);
   }
 
+  @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // S is dynamic.
     // The test to determine whether S is dynamic is done here because dynamic is not an instance of
     // InterfaceType.
     //
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is! InterfaceType) {
       return false;
     }
     return _isMoreSpecificThan(type as InterfaceType, new Set<ClassElement>(), withDynamic, visitedTypePairs);
   }
 
+  @override
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // T is a subtype of S, written T <: S, iff [bottom/dynamic]T << S
     //
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is TypeParameterType) {
       return true;
     } else if (type is FunctionType) {
       ClassElement element = this.element;
@@ skipping 183 matching lines @@
   /**
    * Initialize a newly created type to be declared by the given element and to have the given name.
    *
    * @param element the element representing the declaration of the type
    * @param name the name of the type
    */
   TypeImpl(Element element, this.name) {
     this._element = element;
   }
 
+  @override
   String get displayName => name;
 
+  @override
   Element get element => _element;
 
+  @override
   DartType getLeastUpperBound(DartType type) => null;
 
+  @override
   bool isAssignableTo(DartType type) => isAssignableTo2(type, new Set<TypeImpl_TypePair>());
 
   /**
    * Return `true` if this type is assignable to the given type. A type <i>T</i> may be
    * assigned to a type <i>S</i>, written <i>T</i> &hArr; <i>S</i>, iff either <i>T</i> <: <i>S</i>
    * or <i>S</i> <: <i>T</i>.
    *
    * The given set of pairs of types (T1, T2), where each pair indicates that we invoked this method
    * because we are in the process of answering the question of whether T1 is a subtype of T2, is
    * used to prevent infinite loops.
    *
    * @param type the type being compared with this type
    * @param visitedPairs the set of pairs of types used to prevent infinite loops
    * @return `true` if this type is assignable to the given type
    */
   bool isAssignableTo2(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) => isSubtypeOf2(type, visitedTypePairs) || (type as TypeImpl).isSubtypeOf2(this, visitedTypePairs);
 
+  @override
   bool get isBottom => false;
 
+  @override
   bool get isDartCoreFunction => false;
 
+  @override
   bool get isDynamic => false;
 
+  @override
   bool isMoreSpecificThan(DartType type) => isMoreSpecificThan2(type, false, new Set<TypeImpl_TypePair>());
 
   /**
    * Return `true` if this type is more specific than the given type.
    *
    * The given set of pairs of types (T1, T2), where each pair indicates that we invoked this method
    * because we are in the process of answering the question of whether T1 is a subtype of T2, is
    * used to prevent infinite loops.
    *
    * @param type the type being compared with this type
    * @param withDynamic `true` if "dynamic" should be considered as a subtype of any type
    * @param visitedPairs the set of pairs of types used to prevent infinite loops
    * @return `true` if this type is more specific than the given type
    */
   bool isMoreSpecificThan2(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     // If the visitedTypePairs already has the pair (this, type), return false
     TypeImpl_TypePair typePair = new TypeImpl_TypePair(this, type);
     if (!visitedTypePairs.add(typePair)) {
       return false;
     }
     bool result = internalIsMoreSpecificThan(type, withDynamic, visitedTypePairs);
     visitedTypePairs.remove(typePair);
     return result;
   }
 
+  @override
   bool get isObject => false;
 
+  @override
   bool isSubtypeOf(DartType type) => isSubtypeOf2(type, new Set<TypeImpl_TypePair>());
 
   /**
    * Return `true` if this type is a subtype of the given type.
    *
    * The given set of pairs of types (T1, T2), where each pair indicates that we invoked this method
    * because we are in the process of answering the question of whether T1 is a subtype of T2, is
    * used to prevent infinite loops.
    *
    * @param type the type being compared with this type
    * @param visitedPairs the set of pairs of types used to prevent infinite loops
    * @return `true` if this type is a subtype of the given type
    */
   bool isSubtypeOf2(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) {
     // If the visitedTypePairs already has the pair (this, type), return false
     TypeImpl_TypePair typePair = new TypeImpl_TypePair(this, type);
     if (!visitedTypePairs.add(typePair)) {
       return false;
     }
     bool result = internalIsSubtypeOf(type, visitedTypePairs);
     visitedTypePairs.remove(typePair);
     return result;
   }
 
+  @override
   bool isSupertypeOf(DartType type) => type.isSubtypeOf(this);
 
+  @override
   bool get isVoid => false;
 
+  @override
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     appendTo(builder);
     return builder.toString();
   }
 
   /**
    * Append a textual representation of this type to the given builder.
    *
    * @param builder the builder to which the text is to be appended
@@ skipping 16 matching lines @@
 class TypeImpl_TypePair {
   DartType _firstType;
 
   DartType _secondType;
 
   TypeImpl_TypePair(DartType firstType, DartType secondType) {
     this._firstType = firstType;
     this._secondType = secondType;
   }
 
+  @override
   bool operator ==(Object object) {
     if (identical(object, this)) {
       return true;
     }
     if (object is TypeImpl_TypePair) {
       TypeImpl_TypePair typePair = object;
       return _firstType == typePair._firstType && _secondType != null && _secondType == typePair._secondType;
     }
     return false;
   }
 
+  @override
   int get hashCode {
     int firstHashCode = 0;
     if (_firstType != null) {
       firstHashCode = _firstType.element == null ? 0 : _firstType.element.hashCode;
     }
     int secondHashCode = 0;
     if (_secondType != null) {
       secondHashCode = _secondType.element == null ? 0 : _secondType.element.hashCode;
     }
     return firstHashCode + secondHashCode;
@@ skipping 31 matching lines @@
   }
 
   /**
    * Initialize a newly created type parameter type to be declared by the given element and to have
    * the given name.
    *
    * @param element the element representing the declaration of the type parameter
    */
   TypeParameterTypeImpl(TypeParameterElement element) : super(element, element.name);
 
+  @override
   bool operator ==(Object object) => object is TypeParameterTypeImpl && (element == object.element);
 
+  @override
   TypeParameterElement get element => super.element as TypeParameterElement;
 
+  @override
   int get hashCode => element.hashCode;
 
+  @override
   DartType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes) {
     int length = parameterTypes.length;
     for (int i = 0; i < length; i++) {
       if (parameterTypes[i] == this) {
         return argumentTypes[i];
       }
     }
     return this;
   }
 
+  @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) => this == object;
 
+  @override
   bool internalIsMoreSpecificThan(DartType s, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     //
     // A type T is more specific than a type S, written T << S,  if one of the following conditions
     // is met:
     //
     // Reflexivity: T is S.
     //
     if (this == s) {
       return true;
     }
     // S is bottom.
     //
     if (s.isBottom) {
       return true;
     }
     // S is dynamic.
     //
     if (s.isDynamic) {
       return true;
     }
     return _isMoreSpecificThan(s, new Set<DartType>(), withDynamic, visitedTypePairs);
   }
 
+  @override
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) => isMoreSpecificThan2(type, true, new Set<TypeImpl_TypePair>());
 
   bool _isMoreSpecificThan(DartType s, Set<DartType> visitedTypes, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) {
     // T is a type parameter and S is the upper bound of T.
     //
     DartType bound = element.bound;
     if (s == bound) {
       return true;
     }
     // T is a type parameter and S is Object.
@@ skipping 37 matching lines @@
    *
    * @return the unique instance of this class
    */
   static VoidTypeImpl get instance => _INSTANCE;
 
   /**
    * Prevent the creation of instances of this class.
    */
   VoidTypeImpl() : super(null, Keyword.VOID.syntax);
 
+  @override
   bool operator ==(Object object) => identical(object, this);
 
+  @override
   int get hashCode => 2;
 
+  @override
   bool get isVoid => true;
 
+  @override
   VoidTypeImpl substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes) => this;
 
+  @override
   bool internalEquals(Object object, Set<ElementPair> visitedElementPairs) => identical(object, this);
 
+  @override
   bool internalIsMoreSpecificThan(DartType type, bool withDynamic, Set<TypeImpl_TypePair> visitedTypePairs) => isSubtypeOf(type);
 
+  @override
   bool internalIsSubtypeOf(DartType type, Set<TypeImpl_TypePair> visitedTypePairs) => identical(type, this) || identical(type, DynamicTypeImpl.instance);
 }
 
 /**
  * The interface `FunctionType` defines the behavior common to objects representing the type
  * of a function, method, constructor, getter, or setter. Function types come in three variations:
  * <ol>
  * * The types of functions that only have required parameters. These have the general form
  * <i>(T<sub>1</sub>, &hellip;, T<sub>n</sub>) &rarr; T</i>.
  * * The types of functions with optional positional parameters. These have the general form
@@ skipping 93 matching lines @@
    * T<sub>n</sub>, []) &rarr; T.</i>
    *
    * All functions implement the class `Function`. However not all function types are a
    * subtype of `Function`. If an interface type <i>I</i> includes a method named
    * `call()`, and the type of `call()` is the function type <i>F</i>, then <i>I</i> is
    * considered to be a subtype of <i>F</i>.
    *
    * @param type the type being compared with this type
    * @return `true` if this type is a subtype of the given type
    */
+  @override
   bool isSubtypeOf(DartType type);
 
   /**
    * Return the type resulting from substituting the given arguments for this type's parameters.
    * This is fully equivalent to `substitute(argumentTypes, getTypeArguments())`.
    *
    * @param argumentTypes the actual type arguments being substituted for the type parameters
    * @return the result of performing the substitution
    */
   FunctionType substitute3(List<DartType> argumentTypes);
 
+  @override
   FunctionType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes);
 }
 
 /**
  * The interface `InterfaceType` defines the behavior common to objects representing the type
  * introduced by either a class or an interface, or a reference to such a type.
  */
 abstract class InterfaceType implements ParameterizedType {
   /**
    * Return an array containing all of the accessors (getters and setters) declared in this type.
    *
    * @return the accessors declared in this type
    */
   List<PropertyAccessorElement> get accessors;
 
+  @override
   ClassElement get element;
 
   /**
    * Return the element representing the getter with the given name that is declared in this class,
    * or `null` if this class does not declare a getter with the given name.
    *
    * @param getterName the name of the getter to be returned
    * @return the getter declared in this class with the given name
    */
   PropertyAccessorElement getGetter(String getterName);
@@ skipping 16 matching lines @@
    * and let <i>S = (I &cup; S<sub>I</sub>) &cap; (J &cup; S<sub>J</sub>)</i>. Furthermore, we
    * define <i>S<sub>n</sub> = {T | T &isin; S &and; depth(T) = n}</i> for any finite <i>n</i>,
    * where <i>depth(T)</i> is the number of steps in the longest inheritance path from <i>T</i> to
    * <i>Object</i>. Let <i>q</i> be the largest number such that <i>S<sub>q</sub></i> has
    * cardinality one. The least upper bound of <i>I</i> and <i>J</i> is the sole element of
    * <i>S<sub>q</sub></i>.
    *
    * @param type the other type used to compute the least upper bound
    * @return the least upper bound of this type and the given type
    */
+  @override
   DartType getLeastUpperBound(DartType type);
 
   /**
    * Return the element representing the method with the given name that is declared in this class,
    * or `null` if this class does not declare a method with the given name.
    *
    * @param methodName the name of the method to be returned
    * @return the method declared in this class with the given name
    */
   MethodElement getMethod(String methodName);
@@ skipping 59 matching lines @@
    * * Direct supertype: <i>S</i> is a direct supertype of <i>T</i>.
    * * <i>T</i> is a type parameter and <i>S</i> is the upper bound of <i>T</i>.
    * * Covariance: <i>T</i> is of the form <i>I&lt;T<sub>1</sub>, &hellip;, T<sub>n</sub>&gt;</i>
    * and S</i> is of the form <i>I&lt;S<sub>1</sub>, &hellip;, S<sub>n</sub>&gt;</i> and
    * <i>T<sub>i</sub> &laquo; S<sub>i</sub></i>, <i>1 <= i <= n</i>.
    * * Transitivity: <i>T &laquo; U</i> and <i>U &laquo; S</i>.
    *
    * @param type the type being compared with this type
    * @return `true` if this type is more specific than the given type
    */
+  @override
   bool isMoreSpecificThan(DartType type);
 
   /**
    * Return `true` if this type is a subtype of the given type. An interface type <i>T</i> is
    * a subtype of an interface type <i>S</i>, written <i>T</i> <: <i>S</i>, iff
    * <i>[bottom/dynamic]T</i> &laquo; <i>S</i> (<i>T</i> is more specific than <i>S</i>). If an
    * interface type <i>I</i> includes a method named <i>call()</i>, and the type of <i>call()</i> is
    * the function type <i>F</i>, then <i>I</i> is considered to be a subtype of <i>F</i>.
    *
    * @param type the type being compared with this type
    * @return `true` if this type is a subtype of the given type
    */
+  @override
   bool isSubtypeOf(DartType type);
 
   /**
    * Return the element representing the constructor that results from looking up the given
    * constructor in this class with respect to the given library, or `null` if the look up
    * fails. The behavior of this method is defined by the Dart Language Specification in section
    * 12.11.1: <blockquote>If <i>e</i> is of the form <b>new</b> <i>T.id()</i> then let <i>q<i> be
    * the constructor <i>T.id</i>, otherwise let <i>q<i> be the constructor <i>T<i>. Otherwise, if
    * <i>q</i> is not defined or not accessible, a NoSuchMethodException is thrown. </blockquote>
    *
@@ skipping 124 matching lines @@
 
   /**
    * Return the type resulting from substituting the given arguments for this type's parameters.
    * This is fully equivalent to `substitute(argumentTypes, getTypeArguments())`.
    *
    * @param argumentTypes the actual type arguments being substituted for the type parameters
    * @return the result of performing the substitution
    */
   InterfaceType substitute4(List<DartType> argumentTypes);
 
+  @override
   InterfaceType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes);
 }
 
 /**
  * The interface `ParameterizedType` defines the behavior common to objects representing a
  * type with type parameters, such as a class or function type alias.
  */
 abstract class ParameterizedType implements DartType {
   /**
    * Return an array containing the actual types of the type arguments. If this type's element does
@@ skipping 139 matching lines @@
    * @return the result of performing the substitution
    */
   DartType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes);
 }
 
 /**
  * The interface `TypeParameterType` defines the behavior of objects representing the type
  * introduced by a type parameter.
  */
 abstract class TypeParameterType implements DartType {
+  @override
   TypeParameterElement get element;
 }
 
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  */
 abstract class VoidType implements DartType {
+  @override
   VoidType substitute2(List<DartType> argumentTypes, List<DartType> parameterTypes);
 }