Issue 13584. Fix for Java/Dart local variable scoping mismatch.

pkg/analyzer_experimental/lib/src/generated/element.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 library engine.element;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'utilities_collection.dart';
 import 'source.dart';
 import 'scanner.dart' show Keyword;
 import 'ast.dart' show Identifier, LibraryIdentifier;
@@ skipping 1794 matching lines @@
    * @param name the name of this element
    */
   ClassElementImpl(Identifier name) : super.con1(name);
   accept(ElementVisitor visitor) => visitor.visitClassElement(this);
   List<PropertyAccessorElement> get accessors => _accessors;
   List<InterfaceType> get allSupertypes {
     List<InterfaceType> list = new List<InterfaceType>();
     collectAllSupertypes(list);
     return new List.from(list);
   }
-  ElementImpl getChild(String identifier2) {
+  ElementImpl getChild(String identifier) {
     for (PropertyAccessorElement accessor in _accessors) {
-      if (((accessor as PropertyAccessorElementImpl)).identifier == identifier2) {
+      if (((accessor as PropertyAccessorElementImpl)).identifier == identifier) {
         return accessor as PropertyAccessorElementImpl;
       }
     }
     for (ConstructorElement constructor in _constructors) {
-      if (((constructor as ConstructorElementImpl)).identifier == identifier2) {
+      if (((constructor as ConstructorElementImpl)).identifier == identifier) {
         return constructor as ConstructorElementImpl;
       }
     }
     for (FieldElement field in _fields) {
-      if (((field as FieldElementImpl)).identifier == identifier2) {
+      if (((field as FieldElementImpl)).identifier == identifier) {
         return field as FieldElementImpl;
       }
     }
     for (MethodElement method in _methods) {
-      if (((method as MethodElementImpl)).identifier == identifier2) {
+      if (((method as MethodElementImpl)).identifier == identifier) {
         return method as MethodElementImpl;
       }
     }
     for (TypeParameterElement typeParameter in _typeParameters) {
-      if (((typeParameter as TypeParameterElementImpl)).identifier == identifier2) {
+      if (((typeParameter as TypeParameterElementImpl)).identifier == identifier) {
         return typeParameter as TypeParameterElementImpl;
       }
     }
     return null;
   }
   List<ConstructorElement> get constructors => _constructors;
 
   /**
    * Given some name, this returns the [FieldElement] with the matching name, if there is no
    * such field, then `null` is returned.
    *
    * @param name some name to lookup a field element with
    * @return the matching field element, or `null` if no such element was found
    */
-  FieldElement getField(String name2) {
+  FieldElement getField(String name) {
     for (FieldElement fieldElement in _fields) {
-      if (name2 == fieldElement.name) {
+      if (name == fieldElement.name) {
         return fieldElement;
       }
     }
     return null;
   }
   List<FieldElement> get fields => _fields;
   PropertyAccessorElement getGetter(String getterName) {
     for (PropertyAccessorElement accessor in _accessors) {
       if (accessor.isGetter && accessor.name == getterName) {
         return accessor;
       }
     }
     return null;
   }
   List<InterfaceType> get interfaces => _interfaces;
   ElementKind get kind => ElementKind.CLASS;
   MethodElement getMethod(String methodName) {
     for (MethodElement method in _methods) {
       if (method.name == methodName) {
         return method;
       }
     }
     return null;
   }
   List<MethodElement> get methods => _methods;
   List<InterfaceType> get mixins => _mixins;
-  ConstructorElement getNamedConstructor(String name2) {
+  ConstructorElement getNamedConstructor(String name) {
     for (ConstructorElement element in constructors) {
       String elementName = element.name;
-      if (elementName != null && elementName == name2) {
+      if (elementName != null && elementName == name) {
         return element;
       }
     }
     return null;
   }
   PropertyAccessorElement getSetter(String setterName) {
     if (!setterName.endsWith("=")) {
       setterName += '=';
     }
     for (PropertyAccessorElement accessor in _accessors) {
@@ skipping 132 matching lines @@
    */
   void set abstract(bool isAbstract) {
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
 
   /**
    * Set the accessors contained in this class to the given accessors.
    *
    * @param accessors the accessors contained in this class
    */
-  void set accessors(List<PropertyAccessorElement> accessors2) {
-    for (PropertyAccessorElement accessor in accessors2) {
+  void set accessors(List<PropertyAccessorElement> accessors) {
+    for (PropertyAccessorElement accessor in accessors) {
       ((accessor as PropertyAccessorElementImpl)).enclosingElement = this;
     }
-    this._accessors = accessors2;
+    this._accessors = accessors;
   }
 
   /**
    * Set the constructors contained in this class to the given constructors.
    *
    * @param constructors the constructors contained in this class
    */
-  void set constructors(List<ConstructorElement> constructors2) {
-    for (ConstructorElement constructor in constructors2) {
+  void set constructors(List<ConstructorElement> constructors) {
+    for (ConstructorElement constructor in constructors) {
       ((constructor as ConstructorElementImpl)).enclosingElement = this;
     }
-    this._constructors = constructors2;
+    this._constructors = constructors;
   }
 
   /**
    * Set the fields contained in this class to the given fields.
    *
    * @param fields the fields contained in this class
    */
-  void set fields(List<FieldElement> fields2) {
-    for (FieldElement field in fields2) {
+  void set fields(List<FieldElement> fields) {
+    for (FieldElement field in fields) {
       ((field as FieldElementImpl)).enclosingElement = this;
     }
-    this._fields = fields2;
+    this._fields = fields;
   }
 
   /**
    * Set whether this class references 'super' to the given value.
    *
    * @param isReferencedSuper `true` references 'super'
    */
   void set hasReferenceToSuper2(bool isReferencedSuper) {
     setModifier(Modifier.REFERENCES_SUPER, isReferencedSuper);
   }
 
   /**
    * Set the interfaces that are implemented by this class to the given types.
    *
    * @param the interfaces that are implemented by this class
    */
-  void set interfaces(List<InterfaceType> interfaces2) {
-    this._interfaces = interfaces2;
+  void set interfaces(List<InterfaceType> interfaces) {
+    this._interfaces = interfaces;
   }
 
   /**
    * Set the methods contained in this class to the given methods.
    *
    * @param methods the methods contained in this class
    */
-  void set methods(List<MethodElement> methods2) {
-    for (MethodElement method in methods2) {
+  void set methods(List<MethodElement> methods) {
+    for (MethodElement method in methods) {
       ((method as MethodElementImpl)).enclosingElement = this;
     }
-    this._methods = methods2;
+    this._methods = methods;
   }
 
   /**
    * Set the mixins that are applied to the class being extended in order to derive the superclass
    * of this class to the given types.
    *
    * @param mixins the mixins that are applied to derive the superclass of this class
    */
-  void set mixins(List<InterfaceType> mixins2) {
-    this._mixins = mixins2;
+  void set mixins(List<InterfaceType> mixins) {
+    this._mixins = mixins;
   }
 
   /**
    * Set the superclass of the class to the given type.
    *
    * @param supertype the superclass of the class
    */
-  void set supertype(InterfaceType supertype2) {
-    this._supertype = supertype2;
+  void set supertype(InterfaceType supertype) {
+    this._supertype = supertype;
   }
 
   /**
    * Set the type defined by the class to the given type.
    *
    * @param type the type defined by the class
    */
-  void set type(InterfaceType type2) {
-    this._type = type2;
+  void set type(InterfaceType type) {
+    this._type = type;
   }
 
   /**
    * Set whether this class is defined by a typedef construct to correspond to the given value.
    *
    * @param isTypedef `true` if the class is defined by a typedef construct
    */
   void set typedef(bool isTypedef) {
     setModifier(Modifier.TYPEDEF, isTypedef);
   }
 
   /**
    * Set the type parameters defined for this class to the given type parameters.
    *
    * @param typeParameters the type parameters defined for this class
    */
-  void set typeParameters(List<TypeParameterElement> typeParameters2) {
-    for (TypeParameterElement typeParameter in typeParameters2) {
+  void set typeParameters(List<TypeParameterElement> typeParameters) {
+    for (TypeParameterElement typeParameter in typeParameters) {
       ((typeParameter as TypeParameterElementImpl)).enclosingElement = this;
     }
-    this._typeParameters = typeParameters2;
+    this._typeParameters = typeParameters;
   }
 
   /**
    * 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);
   }
@@ skipping 105 matching lines @@
 
   /**
    * Initialize a newly created compilation unit element to have the given name.
    *
    * @param name the name of this element
    */
   CompilationUnitElementImpl(String name) : super.con2(name, -1);
   accept(ElementVisitor visitor) => visitor.visitCompilationUnitElement(this);
   bool operator ==(Object object) => object != null && runtimeType == object.runtimeType && _source == ((object as CompilationUnitElementImpl)).source;
   List<PropertyAccessorElement> get accessors => _accessors;
-  ElementImpl getChild(String identifier2) {
+  ElementImpl getChild(String identifier) {
     for (PropertyAccessorElement accessor in _accessors) {
-      if (((accessor as PropertyAccessorElementImpl)).identifier == identifier2) {
+      if (((accessor as PropertyAccessorElementImpl)).identifier == identifier) {
         return accessor as PropertyAccessorElementImpl;
       }
     }
     for (VariableElement variable in _variables) {
-      if (((variable as VariableElementImpl)).identifier == identifier2) {
+      if (((variable as VariableElementImpl)).identifier == identifier) {
         return variable as VariableElementImpl;
       }
     }
     for (ExecutableElement function in _functions) {
-      if (((function as ExecutableElementImpl)).identifier == identifier2) {
+      if (((function as ExecutableElementImpl)).identifier == identifier) {
         return function as ExecutableElementImpl;
       }
     }
     for (FunctionTypeAliasElement typeAlias in _typeAliases) {
-      if (((typeAlias as FunctionTypeAliasElementImpl)).identifier == identifier2) {
+      if (((typeAlias as FunctionTypeAliasElementImpl)).identifier == identifier) {
         return typeAlias as FunctionTypeAliasElementImpl;
       }
     }
     for (ClassElement type in _types) {
-      if (((type as ClassElementImpl)).identifier == identifier2) {
+      if (((type as ClassElementImpl)).identifier == identifier) {
         return type as ClassElementImpl;
       }
     }
     return null;
   }
   LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
   List<FunctionElement> get functions => _functions;
   List<FunctionTypeAliasElement> get functionTypeAliases => _typeAliases;
   String get identifier => source.encoding;
   ElementKind get kind => ElementKind.COMPILATION_UNIT;
@@ skipping 10 matching lines @@
   List<ClassElement> get types => _types;
   String get uri => _uri;
   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> accessors2) {
-    for (PropertyAccessorElement accessor in accessors2) {
+  void set accessors(List<PropertyAccessorElement> accessors) {
+    for (PropertyAccessorElement accessor in accessors) {
       ((accessor as PropertyAccessorElementImpl)).enclosingElement = this;
     }
-    this._accessors = accessors2;
+    this._accessors = accessors;
   }
 
   /**
    * Set the top-level functions contained in this compilation unit to the given functions.
    *
    * @param functions the top-level functions contained in this compilation unit
    */
-  void set functions(List<FunctionElement> functions2) {
-    for (FunctionElement function in functions2) {
+  void set functions(List<FunctionElement> functions) {
+    for (FunctionElement function in functions) {
       ((function as FunctionElementImpl)).enclosingElement = this;
     }
-    this._functions = functions2;
+    this._functions = functions;
   }
 
   /**
    * Set the source that corresponds to this compilation unit to the given source.
    *
    * @param source the source that corresponds to this compilation unit
    */
-  void set source(Source source2) {
-    this._source = source2;
+  void set source(Source source) {
+    this._source = source;
   }
 
   /**
    * Set the top-level variables contained in this compilation unit to the given variables.
    *
    * @param variables the top-level variables contained in this compilation unit
    */
-  void set topLevelVariables(List<TopLevelVariableElement> variables2) {
-    for (TopLevelVariableElement field in variables2) {
+  void set topLevelVariables(List<TopLevelVariableElement> variables) {
+    for (TopLevelVariableElement field in variables) {
       ((field as TopLevelVariableElementImpl)).enclosingElement = this;
     }
-    this._variables = variables2;
+    this._variables = variables;
   }
 
   /**
    * Set the function type aliases contained in this compilation unit to the given type aliases.
    *
    * @param typeAliases the function type aliases contained in this compilation unit
    */
-  void set typeAliases(List<FunctionTypeAliasElement> typeAliases2) {
-    for (FunctionTypeAliasElement typeAlias in typeAliases2) {
+  void set typeAliases(List<FunctionTypeAliasElement> typeAliases) {
+    for (FunctionTypeAliasElement typeAlias in typeAliases) {
       ((typeAlias as FunctionTypeAliasElementImpl)).enclosingElement = this;
     }
-    this._typeAliases = typeAliases2;
+    this._typeAliases = typeAliases;
   }
 
   /**
    * Set the types contained in this compilation unit to the given types.
    *
    * @param types types contained in this compilation unit
    */
-  void set types(List<ClassElement> types2) {
-    for (ClassElement type in types2) {
+  void set types(List<ClassElement> types) {
+    for (ClassElement type in types) {
       ((type as ClassElementImpl)).enclosingElement = this;
     }
-    this._types = types2;
+    this._types = types;
   }
 
   /**
    * Set the URI that is specified by the "part" directive in the enclosing library.
    *
    * @param uri the URI that is specified by the "part" directive in the enclosing library.
    */
-  void set uri(String uri2) {
-    this._uri = uri2;
+  void set uri(String uri) {
+    this._uri = uri;
   }
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_typeAliases, visitor);
     safelyVisitChildren(_types, visitor);
     safelyVisitChildren(_variables, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
@@ skipping 15 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);
   EvaluationResultImpl get evaluationResult => _result;
-  void set evaluationResult(EvaluationResultImpl result2) {
-    this._result = result2;
+  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.
  *
  * @coverage dart.engine.element
  */
 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);
   EvaluationResultImpl get evaluationResult => _result;
-  void set evaluationResult(EvaluationResultImpl result2) {
-    this._result = result2;
+  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);
   EvaluationResultImpl get evaluationResult => _result;
-  void set evaluationResult(EvaluationResultImpl result2) {
-    this._result = result2;
+  void set evaluationResult(EvaluationResultImpl result) {
+    this._result = result;
   }
 }
 /**
  * Instances of the class `ConstructorElementImpl` implement a `ConstructorElement`.
  *
  * @coverage dart.engine.element
  */
 class ConstructorElementImpl extends ExecutableElementImpl implements ConstructorElement {
 
   /**
@@ skipping 48 matching lines @@
    */
   void set factory(bool isFactory) {
     setModifier(Modifier.FACTORY, isFactory);
   }
 
   /**
    * Sets the constructor to which this constructor is redirecting.
    *
    * @param redirectedConstructor the constructor to which this constructor is redirecting
    */
-  void set redirectedConstructor(ConstructorElement redirectedConstructor2) {
-    this._redirectedConstructor = redirectedConstructor2;
+  void set redirectedConstructor(ConstructorElement redirectedConstructor) {
+    this._redirectedConstructor = redirectedConstructor;
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append(enclosingElement.displayName);
     String name = displayName;
     if (name != null && !name.isEmpty) {
       builder.append(".");
       builder.append(name);
     }
     super.appendTo(builder);
   }
@@ skipping 11 matching lines @@
    */
   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);
   EvaluationResultImpl get evaluationResult => _result;
-  void set evaluationResult(EvaluationResultImpl result2) {
-    this._result = result2;
+  void set evaluationResult(EvaluationResultImpl result) {
+    this._result = result;
   }
 }
 /**
  * Instances of the class `DefaultParameterElementImpl` implement a `ParameterElement`
  * for parameters that have an initializer.
  *
  * @coverage dart.engine.element
  */
 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);
   EvaluationResultImpl get evaluationResult => _result;
-  void set evaluationResult(EvaluationResultImpl result2) {
-    this._result = result2;
+  void set evaluationResult(EvaluationResultImpl result) {
+    this._result = result;
   }
 }
 /**
  * Instances of the class `DynamicElementImpl` represent the synthetic element representing
  * the declaration of the type `dynamic`.
  *
  * @coverage dart.engine.element
  */
 class DynamicElementImpl extends ElementImpl {
 
@@ skipping 149 matching lines @@
       return null;
     }
     return _enclosingElement.source;
   }
   int get hashCode {
     if (_cachedHashCode == 0) {
       _cachedHashCode = location.hashCode;
     }
     return _cachedHashCode;
   }
-  bool isAccessibleIn(LibraryElement library2) {
+  bool isAccessibleIn(LibraryElement library) {
     if (Identifier.isPrivateName(_name)) {
-      return library2 == library;
+      return library == this.library;
     }
     return true;
   }
   bool get isSynthetic => hasModifier(Modifier.SYNTHETIC);
 
   /**
    * Set the metadata associate with this element to the given array of annotations.
    *
    * @param metadata the metadata to be associated with this element
    */
-  void set metadata(List<ElementAnnotation> metadata2) {
-    this._metadata = metadata2;
+  void set metadata(List<ElementAnnotation> metadata) {
+    this._metadata = metadata;
   }
 
   /**
    * Set the offset of the name of this element in the file that contains the declaration of this
    * element to the given value. This is normally done via the constructor, but this method is
    * provided to support unnamed constructors.
    *
    * @param nameOffset the offset to the beginning of the name
    */
-  void set nameOffset(int nameOffset2) {
-    this._nameOffset = nameOffset2;
+  void set nameOffset(int nameOffset) {
+    this._nameOffset = nameOffset;
   }
 
   /**
    * 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);
   }
@@ skipping 276 matching lines @@
   EmbeddedHtmlScriptElementImpl(XmlTagNode node) : super(node);
   accept(ElementVisitor visitor) => visitor.visitEmbeddedHtmlScriptElement(this);
   ElementKind get kind => ElementKind.EMBEDDED_HTML_SCRIPT;
   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 scriptLibrary2) {
-    scriptLibrary2.enclosingElement = this;
-    this._scriptLibrary = scriptLibrary2;
+  void set scriptLibrary(LibraryElementImpl scriptLibrary) {
+    scriptLibrary.enclosingElement = this;
+    this._scriptLibrary = scriptLibrary;
   }
   void visitChildren(ElementVisitor visitor) {
     safelyVisitChild(_scriptLibrary, visitor);
   }
 }
 /**
  * The abstract class `ExecutableElementImpl` implements the behavior common to
  * `ExecutableElement`s.
  *
  * @coverage dart.engine.element
@@ skipping 43 matching lines @@
   ExecutableElementImpl.con1(Identifier name) : super.con1(name);
 
   /**
    * 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.con2(name, nameOffset);
-  ElementImpl getChild(String identifier2) {
+  ElementImpl getChild(String identifier) {
     for (ExecutableElement function in _functions) {
-      if (((function as ExecutableElementImpl)).identifier == identifier2) {
+      if (((function as ExecutableElementImpl)).identifier == identifier) {
         return function as ExecutableElementImpl;
       }
     }
     for (LabelElement label in _labels) {
-      if (((label as LabelElementImpl)).identifier == identifier2) {
+      if (((label as LabelElementImpl)).identifier == identifier) {
         return label as LabelElementImpl;
       }
     }
     for (VariableElement variable in _localVariables) {
-      if (((variable as VariableElementImpl)).identifier == identifier2) {
+      if (((variable as VariableElementImpl)).identifier == identifier) {
         return variable as VariableElementImpl;
       }
     }
     for (ParameterElement parameter in _parameters) {
-      if (((parameter as ParameterElementImpl)).identifier == identifier2) {
+      if (((parameter as ParameterElementImpl)).identifier == identifier) {
         return parameter as ParameterElementImpl;
       }
     }
     return null;
   }
   List<FunctionElement> get functions => _functions;
   List<LabelElement> get labels => _labels;
   List<LocalVariableElement> get localVariables => _localVariables;
   List<ParameterElement> get parameters => _parameters;
   Type2 get returnType => _returnType;
   FunctionType get type => _type;
   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> functions2) {
-    for (FunctionElement function in functions2) {
+  void set functions(List<FunctionElement> functions) {
+    for (FunctionElement function in functions) {
       ((function as FunctionElementImpl)).enclosingElement = this;
     }
-    this._functions = functions2;
+    this._functions = functions;
   }
 
   /**
    * Set the labels defined within this executable element to the given labels.
    *
    * @param labels the labels defined within this executable element
    */
-  void set labels(List<LabelElement> labels2) {
-    for (LabelElement label in labels2) {
+  void set labels(List<LabelElement> labels) {
+    for (LabelElement label in labels) {
       ((label as LabelElementImpl)).enclosingElement = this;
     }
-    this._labels = labels2;
+    this._labels = labels;
   }
 
   /**
    * Set the local variables defined within this executable element to the given variables.
    *
    * @param localVariables the local variables defined within this executable element
    */
-  void set localVariables(List<LocalVariableElement> localVariables2) {
-    for (LocalVariableElement variable in localVariables2) {
+  void set localVariables(List<LocalVariableElement> localVariables) {
+    for (LocalVariableElement variable in localVariables) {
       ((variable as LocalVariableElementImpl)).enclosingElement = this;
     }
-    this._localVariables = localVariables2;
+    this._localVariables = localVariables;
   }
 
   /**
    * Set the parameters defined by this executable element to the given parameters.
    *
    * @param parameters the parameters defined by this executable element
    */
-  void set parameters(List<ParameterElement> parameters2) {
-    for (ParameterElement parameter in parameters2) {
+  void set parameters(List<ParameterElement> parameters) {
+    for (ParameterElement parameter in parameters) {
       ((parameter as ParameterElementImpl)).enclosingElement = this;
     }
-    this._parameters = parameters2;
+    this._parameters = parameters;
   }
 
   /**
    * Set the return type defined by this executable element.
    *
    * @param returnType the return type defined by this executable element
    */
-  void set returnType(Type2 returnType2) {
-    this._returnType = returnType2;
+  void set returnType(Type2 returnType) {
+    this._returnType = returnType;
   }
 
   /**
    * Set the type of function defined by this executable element to the given type.
    *
    * @param type the type of function defined by this executable element
    */
-  void set type(FunctionType type2) {
-    this._type = type2;
+  void set type(FunctionType type) {
+    this._type = type;
   }
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_labels, visitor);
     safelyVisitChildren(_localVariables, visitor);
     safelyVisitChildren(_parameters, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("(");
@@ skipping 43 matching lines @@
   LibraryElement get exportedLibrary => _exportedLibrary;
   ElementKind get kind => ElementKind.EXPORT;
   String get uri => _uri;
 
   /**
    * Set the combinators that were specified as part of the export directive to the given array of
    * combinators.
    *
    * @param combinators the combinators that were specified as part of the export directive
    */
-  void set combinators(List<NamespaceCombinator> combinators2) {
-    this._combinators = combinators2;
+  void set combinators(List<NamespaceCombinator> combinators) {
+    this._combinators = combinators;
   }
 
   /**
    * Set the library that is exported from this library by this import directive to the given
    * library.
    *
    * @param exportedLibrary the library that is exported from this library
    */
-  void set exportedLibrary(LibraryElement exportedLibrary2) {
-    this._exportedLibrary = exportedLibrary2;
+  void set exportedLibrary(LibraryElement exportedLibrary) {
+    this._exportedLibrary = exportedLibrary;
   }
 
   /**
    * Set the URI that is specified by this directive.
    *
    * @param uri the URI that is specified by this directive.
    */
-  void set uri(String uri2) {
-    this._uri = uri2;
+  void set uri(String uri) {
+    this._uri = uri;
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("export ");
     ((_exportedLibrary as LibraryElementImpl)).appendTo(builder);
   }
   String get identifier => _exportedLibrary.name;
 }
 /**
  * Instances of the class `ExternalHtmlScriptElementImpl` implement an
  * [ExternalHtmlScriptElement].
@@ skipping 15 matching lines @@
   ExternalHtmlScriptElementImpl(XmlTagNode node) : super(node);
   accept(ElementVisitor visitor) => visitor.visitExternalHtmlScriptElement(this);
   ElementKind get kind => ElementKind.EXTERNAL_HTML_SCRIPT;
   Source get scriptSource => _scriptSource;
 
   /**
    * Set the source specified in the `source` attribute.
    *
    * @param scriptSource the script source or `null` if unspecified
    */
-  void set scriptSource(Source scriptSource2) {
-    this._scriptSource = scriptSource2;
+  void set scriptSource(Source scriptSource) {
+    this._scriptSource = scriptSource;
   }
 }
 /**
  * Instances of the class `FieldElementImpl` implement a `FieldElement`.
  *
  * @coverage dart.engine.element
  */
 class FieldElementImpl extends PropertyInducingElementImpl implements FieldElement {
 
   /**
@@ skipping 50 matching lines @@
   FieldFormalParameterElementImpl(Identifier name) : super.con1(name);
   accept(ElementVisitor visitor) => visitor.visitFieldFormalParameterElement(this);
   FieldElement get field => _field;
   bool get isInitializingFormal => true;
 
   /**
    * Set the field element associated with this field formal parameter to the given element.
    *
    * @param field the new field element
    */
-  void set field(FieldElement field2) {
-    this._field = field2;
+  void set field(FieldElement field) {
+    this._field = field;
   }
 }
 /**
  * Instances of the class `FunctionElementImpl` implement a `FunctionElement`.
  *
  * @coverage dart.engine.element
  */
 class FunctionElementImpl extends ExecutableElementImpl implements FunctionElement {
 
   /**
@@ skipping 98 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.con1(name);
   accept(ElementVisitor visitor) => visitor.visitFunctionTypeAliasElement(this);
-  ElementImpl getChild(String identifier2) {
+  ElementImpl getChild(String identifier) {
     for (VariableElement parameter in _parameters) {
-      if (((parameter as VariableElementImpl)).identifier == identifier2) {
+      if (((parameter as VariableElementImpl)).identifier == identifier) {
         return parameter as VariableElementImpl;
       }
     }
     for (TypeParameterElement typeParameter in _typeParameters) {
-      if (((typeParameter as TypeParameterElementImpl)).identifier == identifier2) {
+      if (((typeParameter as TypeParameterElementImpl)).identifier == identifier) {
         return typeParameter as TypeParameterElementImpl;
       }
     }
     return null;
   }
   CompilationUnitElement get enclosingElement => super.enclosingElement as CompilationUnitElement;
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
   List<ParameterElement> get parameters => _parameters;
   Type2 get returnType => _returnType;
   FunctionType get type => _type;
   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> parameters2) {
-    if (parameters2 != null) {
-      for (ParameterElement parameter in parameters2) {
+  void set parameters(List<ParameterElement> parameters) {
+    if (parameters != null) {
+      for (ParameterElement parameter in parameters) {
         ((parameter as ParameterElementImpl)).enclosingElement = this;
       }
     }
-    this._parameters = parameters2;
+    this._parameters = parameters;
   }
 
   /**
    * Set the return type defined by this type alias.
    *
    * @param returnType the return type defined by this type alias
    */
-  void set returnType(Type2 returnType2) {
-    this._returnType = returnType2;
+  void set returnType(Type2 returnType) {
+    this._returnType = returnType;
   }
 
   /**
    * Set the type of function defined by this type alias to the given type.
    *
    * @param type the type of function defined by this type alias
    */
-  void set type(FunctionType type2) {
-    this._type = type2;
+  void set type(FunctionType type) {
+    this._type = type;
   }
 
   /**
    * Set the type parameters defined for this type to the given parameters.
    *
    * @param typeParameters the type parameters defined for this type
    */
-  void set typeParameters(List<TypeParameterElement> typeParameters2) {
-    for (TypeParameterElement typeParameter in typeParameters2) {
+  void set typeParameters(List<TypeParameterElement> typeParameters) {
+    for (TypeParameterElement typeParameter in typeParameters) {
       ((typeParameter as TypeParameterElementImpl)).enclosingElement = this;
     }
-    this._typeParameters = typeParameters2;
+    this._typeParameters = typeParameters;
   }
 
   /**
    * Set the parameters defined by this type alias 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 parameters the parameters defined by this type alias
    */
-  void shareParameters(List<ParameterElement> parameters2) {
-    this._parameters = parameters2;
+  void shareParameters(List<ParameterElement> parameters) {
+    this._parameters = parameters;
   }
 
   /**
    * 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> typeParameters2) {
-    this._typeParameters = typeParameters2;
+  void shareTypeParameters(List<TypeParameterElement> typeParameters) {
+    this._typeParameters = typeParameters;
   }
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_parameters, visitor);
     safelyVisitChildren(_typeParameters, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("typedef ");
     builder.append(displayName);
     int typeParameterCount = _typeParameters.length;
@@ skipping 36 matching lines @@
    */
   List<String> _hiddenNames = StringUtilities.EMPTY_ARRAY;
   List<String> get hiddenNames => _hiddenNames;
 
   /**
    * Set the names that are not to be made visible in the importing library even if they are defined
    * in the imported library to the given names.
    *
    * @param hiddenNames the names that are not to be made visible in the importing library
    */
-  void set hiddenNames(List<String> hiddenNames2) {
-    this._hiddenNames = hiddenNames2;
+  void set hiddenNames(List<String> hiddenNames) {
+    this._hiddenNames = hiddenNames;
   }
   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 43 matching lines @@
   ElementKind get kind => ElementKind.HTML;
   List<HtmlScriptElement> get scripts => _scripts;
   Source get source => _source;
   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> scripts2) {
-    if (scripts2.length == 0) {
-      scripts2 = HtmlScriptElementImpl.EMPTY_ARRAY;
+  void set scripts(List<HtmlScriptElement> scripts) {
+    if (scripts.length == 0) {
+      scripts = HtmlScriptElementImpl.EMPTY_ARRAY;
     }
-    for (HtmlScriptElement script in scripts2) {
+    for (HtmlScriptElement script in scripts) {
       ((script as HtmlScriptElementImpl)).enclosingElement = this;
     }
-    this._scripts = scripts2;
+    this._scripts = scripts;
   }
 
   /**
    * Set the source that corresponds to this HTML file to the given source.
    *
    * @param source the source that corresponds to this HTML file
    */
-  void set source(Source source2) {
-    this._source = source2;
+  void set source(Source source) {
+    this._source = source;
   }
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_scripts, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     if (_source == null) {
       builder.append("{HTML file}");
     } else {
       builder.append(_source.fullName);
@@ skipping 58 matching lines @@
   ElementKind get kind => ElementKind.IMPORT;
   PrefixElement get prefix => _prefix;
   String get uri => _uri;
 
   /**
    * Set the combinators that were specified as part of the import directive to the given array of
    * combinators.
    *
    * @param combinators the combinators that were specified as part of the import directive
    */
-  void set combinators(List<NamespaceCombinator> combinators2) {
-    this._combinators = combinators2;
+  void set combinators(List<NamespaceCombinator> combinators) {
+    this._combinators = combinators;
   }
 
   /**
    * Set the library that is imported into this library by this import directive to the given
    * library.
    *
    * @param importedLibrary the library that is imported into this library
    */
-  void set importedLibrary(LibraryElement importedLibrary2) {
-    this._importedLibrary = importedLibrary2;
+  void set importedLibrary(LibraryElement importedLibrary) {
+    this._importedLibrary = importedLibrary;
   }
 
   /**
    * Set the prefix that was specified as part of the import directive to the given prefix.
    *
    * @param prefix the prefix that was specified as part of the import directive
    */
-  void set prefix(PrefixElement prefix2) {
-    this._prefix = prefix2;
+  void set prefix(PrefixElement prefix) {
+    this._prefix = prefix;
   }
 
   /**
    * Set the URI that is specified by this directive.
    *
    * @param uri the URI that is specified by this directive.
    */
-  void set uri(String uri2) {
-    this._uri = uri2;
+  void set uri(String uri) {
+    this._uri = uri;
   }
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_prefix, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("import ");
     ((_importedLibrary as LibraryElementImpl)).appendTo(builder);
   }
   String get identifier => ((_importedLibrary as LibraryElementImpl)).identifier;
@@ skipping 116 matching lines @@
    * 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(AnalysisContext context, LibraryIdentifier name) : super.con1(name) {
     this._context = context;
   }
   accept(ElementVisitor visitor) => visitor.visitLibraryElement(this);
   bool operator ==(Object object) => object != null && runtimeType == object.runtimeType && _definingCompilationUnit == ((object as LibraryElementImpl)).definingCompilationUnit;
-  ElementImpl getChild(String identifier2) {
-    if (((_definingCompilationUnit as CompilationUnitElementImpl)).identifier == identifier2) {
+  ElementImpl getChild(String identifier) {
+    if (((_definingCompilationUnit as CompilationUnitElementImpl)).identifier == identifier) {
       return _definingCompilationUnit as CompilationUnitElementImpl;
     }
     for (CompilationUnitElement part in _parts) {
-      if (((part as CompilationUnitElementImpl)).identifier == identifier2) {
+      if (((part as CompilationUnitElementImpl)).identifier == identifier) {
         return part as CompilationUnitElementImpl;
       }
     }
     for (ImportElement importElement in _imports) {
-      if (((importElement as ImportElementImpl)).identifier == identifier2) {
+      if (((importElement as ImportElementImpl)).identifier == identifier) {
         return importElement as ImportElementImpl;
       }
     }
     for (ExportElement exportElement in _exports) {
-      if (((exportElement as ExportElementImpl)).identifier == identifier2) {
+      if (((exportElement as ExportElementImpl)).identifier == identifier) {
         return exportElement as ExportElementImpl;
       }
     }
     return null;
   }
   AnalysisContext get context => _context;
   CompilationUnitElement get definingCompilationUnit => _definingCompilationUnit;
   FunctionElement get entryPoint => _entryPoint;
   List<LibraryElement> get exportedLibraries {
     Set<LibraryElement> libraries = new Set<LibraryElement>();
@@ skipping 57 matching lines @@
   bool isUpToDate2(int timeStamp) {
     Set<LibraryElement> visitedLibraries = new Set();
     return isUpToDate(this, timeStamp, visitedLibraries);
   }
 
   /**
    * Set the compilation unit that defines this library to the given compilation unit.
    *
    * @param definingCompilationUnit the compilation unit that defines this library
    */
-  void set definingCompilationUnit(CompilationUnitElement definingCompilationUnit2) {
-    ((definingCompilationUnit2 as CompilationUnitElementImpl)).enclosingElement = this;
-    this._definingCompilationUnit = definingCompilationUnit2;
+  void set definingCompilationUnit(CompilationUnitElement definingCompilationUnit) {
+    ((definingCompilationUnit as CompilationUnitElementImpl)).enclosingElement = this;
+    this._definingCompilationUnit = definingCompilationUnit;
   }
 
   /**
    * Set the entry point for this library to the given function.
    *
    * @param entryPoint the entry point for this library
    */
-  void set entryPoint(FunctionElement entryPoint2) {
-    this._entryPoint = entryPoint2;
+  void set entryPoint(FunctionElement entryPoint) {
+    this._entryPoint = entryPoint;
   }
 
   /**
    * Set the specifications of all of the exports defined in this library to the given array.
    *
    * @param exports the specifications of all of the exports defined in this library
    */
-  void set exports(List<ExportElement> exports2) {
-    for (ExportElement exportElement in exports2) {
+  void set exports(List<ExportElement> exports) {
+    for (ExportElement exportElement in exports) {
       ((exportElement as ExportElementImpl)).enclosingElement = this;
     }
-    this._exports = exports2;
+    this._exports = exports;
   }
 
   /**
    * Set the specifications of all of the imports defined in this library to the given array.
    *
    * @param imports the specifications of all of the imports defined in this library
    */
-  void set imports(List<ImportElement> imports2) {
-    for (ImportElement importElement in imports2) {
+  void set imports(List<ImportElement> imports) {
+    for (ImportElement importElement in imports) {
       ((importElement as ImportElementImpl)).enclosingElement = this;
       PrefixElementImpl prefix = importElement.prefix as PrefixElementImpl;
       if (prefix != null) {
         prefix.enclosingElement = this;
       }
     }
-    this._imports = imports2;
+    this._imports = imports;
   }
 
   /**
    * Set the compilation units that are included in this library using a `part` directive.
    *
    * @param parts the compilation units that are included in this library using a `part`
    *          directive
    */
-  void set parts(List<CompilationUnitElement> parts2) {
-    for (CompilationUnitElement compilationUnit in parts2) {
+  void set parts(List<CompilationUnitElement> parts) {
+    for (CompilationUnitElement compilationUnit in parts) {
       ((compilationUnit as CompilationUnitElementImpl)).enclosingElement = this;
     }
-    this._parts = parts2;
+    this._parts = parts;
   }
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_definingCompilationUnit, visitor);
     safelyVisitChildren(_exports, visitor);
     safelyVisitChildren(_imports, visitor);
     safelyVisitChildren(_parts, visitor);
   }
 
   /**
@@ skipping 397 matching lines @@
   void setDefaultValueRange(int offset, int length) {
     _defaultValueRangeOffset = offset;
     _defaultValueRangeLength = length;
   }
 
   /**
    * Set the kind of this parameter to the given kind.
    *
    * @param parameterKind the new kind of this parameter
    */
-  void set parameterKind(ParameterKind parameterKind2) {
-    this._parameterKind = parameterKind2;
+  void set parameterKind(ParameterKind parameterKind) {
+    this._parameterKind = parameterKind;
   }
 
   /**
    * Set the parameters defined by this executable element to the given parameters.
    *
    * @param parameters the parameters defined by this executable element
    */
-  void set parameters(List<ParameterElement> parameters2) {
-    for (ParameterElement parameter in parameters2) {
+  void set parameters(List<ParameterElement> parameters) {
+    for (ParameterElement parameter in parameters) {
       ((parameter as ParameterElementImpl)).enclosingElement = this;
     }
-    this._parameters = parameters2;
+    this._parameters = parameters;
   }
 
   /**
    * 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
    */
@@ skipping 51 matching lines @@
   accept(ElementVisitor visitor) => visitor.visitPrefixElement(this);
   LibraryElement get enclosingElement => super.enclosingElement as LibraryElement;
   List<LibraryElement> get importedLibraries => _importedLibraries;
   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> importedLibraries2) {
-    for (LibraryElement library in importedLibraries2) {
+  void set importedLibraries(List<LibraryElement> importedLibraries) {
+    for (LibraryElement library in importedLibraries) {
       ((library as LibraryElementImpl)).enclosingElement = this;
     }
-    this._importedLibraries = importedLibraries2;
+    this._importedLibraries = importedLibraries;
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("as ");
     super.appendTo(builder);
   }
+  String get identifier => "_${super.identifier}";
 }
 /**
  * Instances of the class `PropertyAccessorElementImpl` implement a
  * `PropertyAccessorElement`.
  *
  * @coverage dart.engine.element
  */
 class PropertyAccessorElementImpl extends ExecutableElementImpl implements PropertyAccessorElement {
 
   /**
@@ skipping 89 matching lines @@
    */
   void set static(bool isStatic) {
     setModifier(Modifier.STATIC, isStatic);
   }
 
   /**
    * Set the variable associated with this accessor to the given variable.
    *
    * @param variable the variable associated with this accessor
    */
-  void set variable(PropertyInducingElement variable2) {
-    this._variable = variable2;
+  void set variable(PropertyInducingElement variable) {
+    this._variable = variable;
   }
   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 34 matching lines @@
     synthetic = true;
   }
   PropertyAccessorElement get getter => _getter;
   PropertyAccessorElement get setter => _setter;
 
   /**
    * Set the getter associated with this element to the given accessor.
    *
    * @param getter the getter associated with this element
    */
-  void set getter(PropertyAccessorElement getter2) {
-    this._getter = getter2;
+  void set getter(PropertyAccessorElement getter) {
+    this._getter = getter;
   }
 
   /**
    * Set the setter associated with this element to the given accessor.
    *
    * @param setter the setter associated with this element
    */
-  void set setter(PropertyAccessorElement setter2) {
-    this._setter = setter2;
+  void set setter(PropertyAccessorElement setter) {
+    this._setter = setter;
   }
 }
 /**
  * Instances of the class `ShowElementCombinatorImpl` implement a
  * [ShowElementCombinator].
  *
  * @coverage dart.engine.element
  */
 class ShowElementCombinatorImpl implements ShowElementCombinator {
 
   /**
    * The names that are to be made visible in the importing library if they are defined in the
    * imported library.
    */
   List<String> _shownNames = StringUtilities.EMPTY_ARRAY;
   List<String> get shownNames => _shownNames;
 
   /**
    * Set the names that are to be made visible in the importing library if they are defined in the
    * imported library to the given names.
    *
    * @param shownNames the names that are to be made visible in the importing library
    */
-  void set shownNames(List<String> shownNames2) {
-    this._shownNames = shownNames2;
+  void set shownNames(List<String> shownNames) {
+    this._shownNames = shownNames;
   }
   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 63 matching lines @@
   accept(ElementVisitor visitor) => visitor.visitTypeParameterElement(this);
   Type2 get bound => _bound;
   ElementKind get kind => ElementKind.TYPE_PARAMETER;
   TypeParameterType get type => _type;
 
   /**
    * Set the type representing the bound associated with this parameter to the given type.
    *
    * @param bound the type representing the bound associated with this parameter
    */
-  void set bound(Type2 bound2) {
-    this._bound = bound2;
+  void set bound(Type2 bound) {
+    this._bound = bound;
   }
 
   /**
    * Set the type defined by this type parameter to the given type
    *
    * @param type the type defined by this type parameter
    */
-  void set type(TypeParameterType type2) {
-    this._type = type2;
+  void set type(TypeParameterType type) {
+    this._type = type;
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append(displayName);
     if (_bound != null) {
       builder.append(" extends ");
       builder.append(_bound);
     }
   }
 }
 /**
@@ skipping 74 matching lines @@
    */
   void set final2(bool isFinal) {
     setModifier(Modifier.FINAL, isFinal);
   }
 
   /**
    * Set the function representing this variable's initializer to the given function.
    *
    * @param initializer the function representing this variable's initializer
    */
-  void set initializer(FunctionElement initializer2) {
-    if (initializer2 != null) {
-      ((initializer2 as FunctionElementImpl)).enclosingElement = this;
+  void set initializer(FunctionElement initializer) {
+    if (initializer != null) {
+      ((initializer as FunctionElementImpl)).enclosingElement = this;
     }
-    this._initializer = initializer2;
+    this._initializer = initializer;
   }
 
   /**
    * Set the declared type of this variable to the given type.
    *
    * @param type the declared type of this variable
    */
-  void set type(Type2 type2) {
-    this._type = type2;
+  void set type(Type2 type) {
+    this._type = type;
   }
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_initializer, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append(type);
     builder.append(" ");
     builder.append(displayName);
   }
@@ skipping 902 matching lines @@
       }
     }
     return s.returnType == VoidTypeImpl.instance || t.returnType.isAssignableTo(s.returnType);
   }
 
   /**
    * Set the actual types of the type arguments to the given types.
    *
    * @param typeArguments the actual types of the type arguments
    */
-  void set typeArguments(List<Type2> typeArguments2) {
-    this._typeArguments = typeArguments2;
+  void set typeArguments(List<Type2> typeArguments) {
+    this._typeArguments = typeArguments;
   }
   FunctionTypeImpl substitute3(List<Type2> argumentTypes) => substitute2(argumentTypes, typeArguments);
   FunctionTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> 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;
@@ skipping 445 matching lines @@
   }
   bool isMoreSpecificThan(Type2 type) {
     if (identical(type, DynamicTypeImpl.instance)) {
       return true;
     } else if (type is! InterfaceType) {
       return false;
     }
     return isMoreSpecificThan2(type as InterfaceType, new Set<ClassElement>());
   }
   bool get isObject => element.supertype == null;
-  bool isSubtypeOf(Type2 type2) {
-    if (identical(type2, DynamicTypeImpl.instance)) {
+  bool isSubtypeOf(Type2 type) {
+    if (identical(type, DynamicTypeImpl.instance)) {
       return true;
-    } else if (type2 is TypeParameterType) {
+    } else if (type is TypeParameterType) {
       return true;
-    } else if (type2 is FunctionType) {
+    } else if (type is FunctionType) {
       ClassElement element = this.element;
       MethodElement callMethod = element.lookUpMethod("call", element.library);
       if (callMethod != null) {
-        return callMethod.type.isSubtypeOf(type2);
+        return callMethod.type.isSubtypeOf(type);
       }
       return false;
-    } else if (type2 is! InterfaceType) {
+    } else if (type is! InterfaceType) {
       return false;
-    } else if (this == type2) {
+    } else if (this == type) {
       return true;
     }
-    return isSubtypeOf2(type2 as InterfaceType, new Set<ClassElement>());
+    return isSubtypeOf2(type as InterfaceType, new Set<ClassElement>());
   }
   ConstructorElement lookUpConstructor(String constructorName, LibraryElement library) {
     ConstructorElement constructorElement;
     if (constructorName == null) {
       constructorElement = element.unnamedConstructor;
     } else {
       constructorElement = element.getNamedConstructor(constructorName);
     }
     if (constructorElement == null || !constructorElement.isAccessibleIn(library)) {
       return null;
@@ skipping 101 matching lines @@
       supertypeElement = supertype == null ? null : supertype.element;
     }
     return null;
   }
 
   /**
    * Set the actual types of the type arguments to those in the given array.
    *
    * @param typeArguments the actual types of the type arguments
    */
-  void set typeArguments(List<Type2> typeArguments2) {
-    this._typeArguments = typeArguments2;
+  void set typeArguments(List<Type2> typeArguments) {
+    this._typeArguments = typeArguments;
   }
   InterfaceTypeImpl substitute4(List<Type2> argumentTypes) => substitute2(argumentTypes, typeArguments);
   InterfaceTypeImpl substitute2(List<Type2> argumentTypes, List<Type2> 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<Type2> newTypeArguments = TypeImpl.substitute(_typeArguments, argumentTypes, parameterTypes);
@@ skipping 18 matching lines @@
       builder.append(">");
     }
   }
   bool isMoreSpecificThan2(InterfaceType s, Set<ClassElement> visitedClasses) {
     if (this == s) {
       return true;
     }
     if (s.isDirectSupertypeOf(this)) {
       return true;
     }
-    ClassElement tElement = element;
+    ClassElement tElement = this.element;
     ClassElement sElement = s.element;
     if (tElement == sElement) {
       List<Type2> tArguments = typeArguments;
       List<Type2> sArguments = s.typeArguments;
       if (tArguments.length != sArguments.length) {
         return false;
       }
       for (int i = 0; i < tArguments.length; i++) {
         if (!tArguments[i].isMoreSpecificThan(sArguments[i])) {
           return false;
@@ skipping 15 matching lines @@
         return true;
       }
     }
     for (InterfaceType mixinType in element.mixins) {
       if (((mixinType as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses)) {
         return true;
       }
     }
     return false;
   }
-  bool isSubtypeOf2(InterfaceType type2, Set<ClassElement> visitedClasses) {
+  bool isSubtypeOf2(InterfaceType type, Set<ClassElement> visitedClasses) {
     InterfaceType typeT = this;
-    InterfaceType typeS = type2;
+    InterfaceType typeS = type;
     ClassElement elementT = element;
     if (elementT == null || visitedClasses.contains(elementT)) {
       return false;
     }
     javaSetAdd(visitedClasses, elementT);
     typeT = substitute2(_typeArguments, elementT.type.typeArguments);
     if (typeT == typeS) {
       return true;
     } else if (elementT == typeS.element) {
       List<Type2> typeTArgs = typeT.typeArguments;
@@ skipping 791 matching lines @@
 }
 /**
  * The interface `VoidType` defines the behavior of the unique object representing the type
  * `void`.
  *
  * @coverage dart.engine.type
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }