Generate unique names less aggressively.

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 'source.dart';
 import 'scanner.dart' show Keyword;
@@ skipping 1306 matching lines @@
    */
   ClassElementImpl(Identifier name) : super.con1(name) {
   }
   accept(ElementVisitor visitor) => visitor.visitClassElement(this);
   List<PropertyAccessorElement> get accessors => _accessors;
   List<InterfaceType> get allSupertypes {
     Set<InterfaceType> list = new Set<InterfaceType>();
     collectAllSupertypes(list);
     return new List.from(list);
   }
-  ElementImpl getChild(String identifier27) {
+  ElementImpl getChild(String identifier2) {
     for (PropertyAccessorElement accessor in _accessors) {
-      if (((accessor as PropertyAccessorElementImpl)).identifier == identifier27) {
+      if (((accessor as PropertyAccessorElementImpl)).identifier == identifier2) {
         return accessor as PropertyAccessorElementImpl;
       }
     }
     for (ConstructorElement constructor in _constructors) {
-      if (((constructor as ConstructorElementImpl)).identifier == identifier27) {
+      if (((constructor as ConstructorElementImpl)).identifier == identifier2) {
         return constructor as ConstructorElementImpl;
       }
     }
     for (FieldElement field in _fields) {
-      if (((field as FieldElementImpl)).identifier == identifier27) {
+      if (((field as FieldElementImpl)).identifier == identifier2) {
         return field as FieldElementImpl;
       }
     }
     for (MethodElement method in _methods) {
-      if (((method as MethodElementImpl)).identifier == identifier27) {
+      if (((method as MethodElementImpl)).identifier == identifier2) {
         return method as MethodElementImpl;
       }
     }
     for (TypeVariableElement typeVariable in _typeVariables) {
-      if (((typeVariable as TypeVariableElementImpl)).identifier == identifier27) {
+      if (((typeVariable as TypeVariableElementImpl)).identifier == identifier2) {
         return typeVariable as TypeVariableElementImpl;
       }
     }
     return null;
   }
   List<ConstructorElement> get constructors => _constructors;
   /**
    * Given some name, this returns the {@link FieldElement} with the matching name, if there is no
    * such field, then {@code null} is returned.
    * @param name some name to lookup a field element with
    * @return the matching field element, or {@code null} if no such element was found
    */
-  FieldElement getField(String name27) {
+  FieldElement getField(String name2) {
     for (FieldElement fieldElement in _fields) {
-      if (name27 == fieldElement.name) {
+      if (name2 == fieldElement.name) {
         return fieldElement;
       }
     }
     return null;
   }
   List<FieldElement> get fields => _fields;
   /**
    * Return the element representing the getter with the given name that is declared in this class,
    * or {@code null} if this class does not declare a getter with the given name.
    * @param getterName the name of the getter to be returned
@@ skipping 18 matching lines @@
   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 name28) {
+  ConstructorElement getNamedConstructor(String name2) {
     for (ConstructorElement element in constructors) {
       String elementName = element.name;
-      if (elementName != null && elementName == name28) {
+      if (elementName != null && elementName == name2) {
         return element;
       }
     }
     return null;
   }
   /**
    * Return the element representing the setter with the given name that is declared in this class,
    * or {@code 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) {
     for (PropertyAccessorElement accessor in _accessors) {
       if (accessor.isSetter() && accessor.name == setterName) {
         return accessor;
       }
     }
     return null;
   }
   InterfaceType get supertype => _supertype;
   InterfaceType get type => _type;
   List<TypeVariableElement> get typeVariables => _typeVariables;
   ConstructorElement get unnamedConstructor {
     for (ConstructorElement element in constructors) {
-      String name12 = element.name;
-      if (name12 == null || name12.isEmpty) {
+      String name2 = element.name;
+      if (name2 == null || name2.isEmpty) {
         return element;
       }
     }
     return null;
   }
   bool isAbstract() => hasModifier(Modifier.ABSTRACT);
   bool isTypedef() => hasModifier(Modifier.TYPEDEF);
   bool isValidMixin() => hasModifier(Modifier.MIXIN);
   PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library) {
     PropertyAccessorElement element = getGetter(getterName);
@@ skipping 136 matching lines @@
    * 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;
   }
   /**
    * Set the type defined by the class to the given type.
    * @param type the type defined by the class
    */
-  void set type(InterfaceType type5) {
-    this._type = type5;
+  void set type(InterfaceType type2) {
+    this._type = type2;
   }
   /**
    * Set whether this class is defined by a typedef construct to correspond to the given value.
    * @param isTypedef {@code true} if the class is defined by a typedef construct
    */
   void set typedef(bool isTypedef) {
     setModifier(Modifier.TYPEDEF, isTypedef);
   }
   /**
    * Set the type variables defined for this class to the given type variables.
@@ skipping 14 matching lines @@
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_accessors, visitor);
     safelyVisitChildren(_constructors, visitor);
     safelyVisitChildren(_fields, visitor);
     safelyVisitChildren(_methods, visitor);
     safelyVisitChildren(_typeVariables, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
-    String name13 = name;
-    if (name13 == null) {
+    String name2 = name;
+    if (name2 == null) {
       builder.append("{unnamed class}");
     } else {
-      builder.append(name13);
+      builder.append(name2);
     }
     int variableCount = _typeVariables.length;
     if (variableCount > 0) {
       builder.append("<");
       for (int i = 0; i < variableCount; i++) {
         if (i > 0) {
           builder.append(", ");
         }
         ((_typeVariables[i] as TypeVariableElementImpl)).appendTo(builder);
       }
@@ skipping 55 matching lines @@
   static List<CompilationUnitElement> EMPTY_ARRAY = new List<CompilationUnitElement>(0);
   /**
    * 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 identifier28) {
+  ElementImpl getChild(String identifier2) {
     for (PropertyAccessorElement accessor in _accessors) {
-      if (((accessor as PropertyAccessorElementImpl)).identifier == identifier28) {
+      if (((accessor as PropertyAccessorElementImpl)).identifier == identifier2) {
         return accessor as PropertyAccessorElementImpl;
       }
     }
     for (VariableElement variable in _variables) {
-      if (((variable as VariableElementImpl)).identifier == identifier28) {
+      if (((variable as VariableElementImpl)).identifier == identifier2) {
         return variable as VariableElementImpl;
       }
     }
     for (ExecutableElement function in _functions) {
-      if (((function as ExecutableElementImpl)).identifier == identifier28) {
+      if (((function as ExecutableElementImpl)).identifier == identifier2) {
         return function as ExecutableElementImpl;
       }
     }
     for (FunctionTypeAliasElement typeAlias in _typeAliases) {
-      if (((typeAlias as FunctionTypeAliasElementImpl)).identifier == identifier28) {
+      if (((typeAlias as FunctionTypeAliasElementImpl)).identifier == identifier2) {
         return typeAlias as FunctionTypeAliasElementImpl;
       }
     }
     for (ClassElement type in _types) {
-      if (((type as ClassElementImpl)).identifier == identifier28) {
+      if (((type as ClassElementImpl)).identifier == identifier2) {
         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;
   Source get source => _source;
   List<TopLevelVariableElement> get topLevelVariables => _variables;
   ClassElement getType(String className) {
     for (ClassElement type in _types) {
       if (type.name == className) {
         return type;
       }
     }
     return null;
   }
   List<ClassElement> get types => _types;
   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> accessors3) {
-    for (PropertyAccessorElement accessor in accessors3) {
+  void set accessors(List<PropertyAccessorElement> accessors2) {
+    for (PropertyAccessorElement accessor in accessors2) {
       ((accessor as PropertyAccessorElementImpl)).enclosingElement = this;
     }
-    this._accessors = accessors3;
+    this._accessors = accessors2;
   }
   /**
    * 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) {
       ((function as FunctionElementImpl)).enclosingElement = this;
     }
     this._functions = functions2;
   }
   /**
    * 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 source5) {
-    this._source = source5;
+  void set source(Source source2) {
+    this._source = source2;
   }
   /**
    * 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) {
       ((field as TopLevelVariableElementImpl)).enclosingElement = this;
     }
     this._variables = variables2;
@@ skipping 63 matching lines @@
    * 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 result3) {
-    this._result = result3;
+  void set evaluationResult(EvaluationResultImpl result2) {
+    this._result = result2;
   }
 }
 /**
  * Instances of the class {@code ConstParameterElementImpl} implement a {@code ParameterElement} for
  * a 'const' parameter that has an initializer.
  * @coverage dart.engine.element
  */
 class ConstParameterElementImpl 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
    */
   ConstParameterElementImpl(Identifier name) : super(name) {
   }
   EvaluationResultImpl get evaluationResult => _result;
-  void set evaluationResult(EvaluationResultImpl result4) {
-    this._result = result4;
+  void set evaluationResult(EvaluationResultImpl result2) {
+    this._result = result2;
   }
 }
 /**
  * Instances of the class {@code ConstTopLevelVariableElementImpl} implement a{@code 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 result5) {
-    this._result = result5;
+  void set evaluationResult(EvaluationResultImpl result2) {
+    this._result = result2;
   }
 }
 /**
  * Instances of the class {@code ConstructorElementImpl} implement a {@code ConstructorElement}.
  * @coverage dart.engine.element
  */
 class ConstructorElementImpl extends ExecutableElementImpl implements ConstructorElement {
   /**
    * An empty array of constructor elements.
    */
@@ skipping 19 matching lines @@
   }
   /**
    * Set whether this constructor represents a factory method to the given value.
    * @param isFactory {@code true} if this constructor represents a factory method
    */
   void set factory(bool isFactory) {
     setModifier(Modifier.FACTORY, isFactory);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append(enclosingElement.name);
-    String name14 = name;
-    if (name14 != null && !name14.isEmpty) {
+    String name2 = name;
+    if (name2 != null && !name2.isEmpty) {
       builder.append(".");
-      builder.append(name14);
+      builder.append(name2);
     }
     super.appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code DynamicElementImpl} represent the synthetic element representing
  * the declaration of the type {@code dynamic}.
  * @coverage dart.engine.element
  */
 class DynamicElementImpl extends ElementImpl {
@@ skipping 18 matching lines @@
   ElementKind get kind => ElementKind.DYNAMIC;
   /**
    * Return the type defined by this element.
    * @return the type defined by this element
    */
   DynamicTypeImpl get type => _type;
   /**
    * Set the type defined by this element to the given type.
    * @param type the type defined by this element
    */
-  void set type(DynamicTypeImpl type6) {
-    this._type = type6;
+  void set type(DynamicTypeImpl type2) {
+    this._type = type2;
   }
 }
 /**
  * The abstract class {@code ElementImpl} implements the behavior common to objects that implement
  * an {@link Element}.
  * @coverage dart.engine.element
  */
 abstract class ElementImpl implements Element {
   /**
    * The enclosing element of this element, or {@code null} if this element is at the root of the
@@ skipping 18 matching lines @@
    */
   List<Annotation> _metadata = AnnotationImpl.EMPTY_ARRAY;
   /**
    * A cached copy of the calculated hashCode for this element.
    */
   int _cachedHashCode = 0;
   /**
    * Initialize a newly created element to have the given name.
    * @param name the name of this element
    */
-  ElementImpl.con1(Identifier name29) {
-    _jtd_constructor_188_impl(name29);
+  ElementImpl.con1(Identifier name2) {
+    _jtd_constructor_188_impl(name2);
   }
-  _jtd_constructor_188_impl(Identifier name29) {
-    _jtd_constructor_189_impl(name29 == null ? "" : name29.name, name29 == null ? -1 : name29.offset);
+  _jtd_constructor_188_impl(Identifier name2) {
+    _jtd_constructor_189_impl(name2 == null ? "" : name2.name, name2 == null ? -1 : name2.offset);
   }
   /**
    * 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.con2(String name9, int nameOffset2) {
-    _jtd_constructor_189_impl(name9, nameOffset2);
+  ElementImpl.con2(String name2, int nameOffset2) {
+    _jtd_constructor_189_impl(name2, nameOffset2);
   }
-  _jtd_constructor_189_impl(String name9, int nameOffset2) {
-    this._name = StringUtilities.intern(name9);
+  _jtd_constructor_189_impl(String name2, int nameOffset2) {
+    this._name = StringUtilities.intern(name2);
     this._nameOffset = nameOffset2;
   }
   bool operator ==(Object object) => object != null && object.runtimeType == runtimeType && ((object as Element)).location == location;
   Element getAncestor(Type elementClass) {
     Element ancestor = _enclosingElement;
     while (ancestor != null && !isInstanceOf(ancestor, elementClass)) {
       ancestor = ancestor.enclosingElement;
     }
     return ancestor as Element;
   }
@@ skipping 20 matching lines @@
       return null;
     }
     return _enclosingElement.source;
   }
   int get hashCode {
     if (_cachedHashCode == 0) {
       _cachedHashCode = location.hashCode;
     }
     return _cachedHashCode;
   }
-  bool isAccessibleIn(LibraryElement library37) {
+  bool isAccessibleIn(LibraryElement library2) {
     if (Identifier.isPrivateName(_name)) {
-      return library37 == library;
+      return library2 == library;
     }
     return true;
   }
   bool 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<Annotation> metadata3) {
-    this._metadata = metadata3;
+  void set metadata(List<Annotation> metadata2) {
+    this._metadata = metadata2;
   }
   /**
    * 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 nameOffset3) {
-    this._nameOffset = nameOffset3;
+  void set nameOffset(int nameOffset2) {
+    this._nameOffset = nameOffset2;
   }
   /**
    * Set whether this element is synthetic to correspond to the given value.
    * @param isSynthetic {@code true} if the element is synthetic
    */
   void set synthetic(bool isSynthetic) {
     setModifier(Modifier.SYNTHETIC, isSynthetic);
   }
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
@@ skipping 144 matching lines @@
   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>();
     JavaStringBuilder builder = new JavaStringBuilder();
     int index = 0;
-    int length3 = encoding.length;
-    while (index < length3) {
+    int length2 = encoding.length;
+    while (index < length2) {
       int currentChar = encoding.codeUnitAt(index);
       if (currentChar == _SEPARATOR_CHAR) {
-        if (index + 1 < length3 && encoding.codeUnitAt(index + 1) == _SEPARATOR_CHAR) {
+        if (index + 1 < length2 && encoding.codeUnitAt(index + 1) == _SEPARATOR_CHAR) {
           builder.appendChar(_SEPARATOR_CHAR);
           index += 2;
         } else {
           components.add(builder.toString());
           builder.length = 0;
           index++;
         }
       } else {
         builder.appendChar(currentChar);
         index++;
       }
     }
     if (builder.length > 0) {
       components.add(builder.toString());
     }
     return new List.from(components);
   }
   /**
    * Append an encoded form of the given component to the given builder.
    * @param builder the builder to which the encoded component is to be appended
    * @param component the component to be appended to the builder
    */
   void encode(JavaStringBuilder builder, String component) {
-    int length4 = component.length;
-    for (int i = 0; i < length4; i++) {
+    int length2 = component.length;
+    for (int i = 0; i < length2; i++) {
       int currentChar = component.codeUnitAt(i);
       if (currentChar == _SEPARATOR_CHAR) {
         builder.appendChar(_SEPARATOR_CHAR);
       }
       builder.appendChar(currentChar);
     }
   }
 }
 /**
  * Instances of the class {@code EmbeddedHtmlScriptElementImpl} implement an{@link EmbeddedHtmlScriptElement}.
@@ skipping 67 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.con2(name, nameOffset) {
     _jtd_constructor_194_impl(name, nameOffset);
   }
   _jtd_constructor_194_impl(String name, int nameOffset) {
   }
-  ElementImpl getChild(String identifier29) {
+  ElementImpl getChild(String identifier2) {
     for (ExecutableElement function in _functions) {
-      if (((function as ExecutableElementImpl)).identifier == identifier29) {
+      if (((function as ExecutableElementImpl)).identifier == identifier2) {
         return function as ExecutableElementImpl;
       }
     }
     for (LabelElement label in _labels) {
-      if (((label as LabelElementImpl)).identifier == identifier29) {
+      if (((label as LabelElementImpl)).identifier == identifier2) {
         return label as LabelElementImpl;
       }
     }
     for (VariableElement variable in _localVariables) {
-      if (((variable as VariableElementImpl)).identifier == identifier29) {
+      if (((variable as VariableElementImpl)).identifier == identifier2) {
         return variable as VariableElementImpl;
       }
     }
     for (ParameterElement parameter in _parameters) {
-      if (((parameter as ParameterElementImpl)).identifier == identifier29) {
+      if (((parameter as ParameterElementImpl)).identifier == identifier2) {
         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;
   FunctionType get type => _type;
   bool 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> functions3) {
-    for (FunctionElement function in functions3) {
+  void set functions(List<FunctionElement> functions2) {
+    for (FunctionElement function in functions2) {
       ((function as FunctionElementImpl)).enclosingElement = this;
     }
-    this._functions = functions3;
+    this._functions = functions2;
   }
   /**
    * 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) {
       ((label as LabelElementImpl)).enclosingElement = this;
     }
     this._labels = labels2;
   }
   /**
    * 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) {
       ((variable as LocalVariableElementImpl)).enclosingElement = this;
     }
     this._localVariables = localVariables2;
   }
   /**
    * 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> parameters7) {
-    for (ParameterElement parameter in parameters7) {
+  void set parameters(List<ParameterElement> parameters2) {
+    for (ParameterElement parameter in parameters2) {
       ((parameter as ParameterElementImpl)).enclosingElement = this;
     }
-    this._parameters = parameters7;
+    this._parameters = parameters2;
   }
   /**
    * 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 type7) {
-    this._type = type7;
+  void set type(FunctionType type2) {
+    this._type = type2;
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_labels, visitor);
     safelyVisitChildren(_localVariables, visitor);
     safelyVisitChildren(_parameters, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("(");
@@ skipping 207 matching lines @@
    * 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 {@code -1} if this element
    * does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
     _visibleRangeLength = length;
   }
   void appendTo(JavaStringBuilder builder) {
-    String name15 = name;
-    if (name15 != null) {
-      builder.append(name15);
+    String name2 = name;
+    if (name2 != null) {
+      builder.append(name2);
     }
     super.appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code FunctionTypeAliasElementImpl} implement a{@code FunctionTypeAliasElement}.
  * @coverage dart.engine.element
  */
 class FunctionTypeAliasElementImpl extends ElementImpl implements FunctionTypeAliasElement {
   /**
@@ skipping 12 matching lines @@
    * An empty array of type alias elements.
    */
   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 identifier30) {
+  ElementImpl getChild(String identifier2) {
     for (VariableElement parameter in _parameters) {
-      if (((parameter as VariableElementImpl)).identifier == identifier30) {
+      if (((parameter as VariableElementImpl)).identifier == identifier2) {
         return parameter as VariableElementImpl;
       }
     }
     for (TypeVariableElement typeVariable in _typeVariables) {
-      if (((typeVariable as TypeVariableElementImpl)).identifier == identifier30) {
+      if (((typeVariable as TypeVariableElementImpl)).identifier == identifier2) {
         return typeVariable as TypeVariableElementImpl;
       }
     }
     return null;
   }
   CompilationUnitElement get enclosingElement => super.enclosingElement as CompilationUnitElement;
   ElementKind get kind => ElementKind.FUNCTION_TYPE_ALIAS;
   List<ParameterElement> get parameters => _parameters;
   FunctionType get type => _type;
   List<TypeVariableElement> get typeVariables => _typeVariables;
   /**
    * 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> parameters8) {
-    if (parameters8 != null) {
-      for (ParameterElement parameter in parameters8) {
+  void set parameters(List<ParameterElement> parameters2) {
+    if (parameters2 != null) {
+      for (ParameterElement parameter in parameters2) {
         ((parameter as ParameterElementImpl)).enclosingElement = this;
       }
     }
-    this._parameters = parameters8;
+    this._parameters = parameters2;
   }
   /**
    * 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 type8) {
-    this._type = type8;
+  void set type(FunctionType type2) {
+    this._type = type2;
   }
   /**
    * Set the type variables defined for this type to the given variables.
    * @param typeVariables the type variables defined for this type
    */
-  void set typeVariables(List<TypeVariableElement> typeVariables3) {
-    for (TypeVariableElement variable in typeVariables3) {
+  void set typeVariables(List<TypeVariableElement> typeVariables2) {
+    for (TypeVariableElement variable in typeVariables2) {
       ((variable as TypeVariableElementImpl)).enclosingElement = this;
     }
-    this._typeVariables = typeVariables3;
+    this._typeVariables = typeVariables2;
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_parameters, visitor);
     safelyVisitChildren(_typeVariables, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("typedef ");
     builder.append(name);
     int variableCount = _typeVariables.length;
@@ skipping 105 matching lines @@
     }
     for (HtmlScriptElement script in scripts2) {
       ((script as HtmlScriptElementImpl)).enclosingElement = this;
     }
     this._scripts = scripts2;
   }
   /**
    * 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 source6) {
-    this._source = source6;
+  void set source(Source source2) {
+    this._source = source2;
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(_scripts, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     if (_source == null) {
       builder.append("{HTML file}");
     } else {
       builder.append(_source.fullName);
@@ skipping 43 matching lines @@
   accept(ElementVisitor visitor) => visitor.visitImportElement(this);
   List<NamespaceCombinator> get combinators => _combinators;
   LibraryElement get importedLibrary => _importedLibrary;
   ElementKind get kind => ElementKind.IMPORT;
   PrefixElement get prefix => _prefix;
   /**
    * 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> combinators3) {
-    this._combinators = combinators3;
+  void set combinators(List<NamespaceCombinator> combinators2) {
+    this._combinators = combinators2;
   }
   /**
    * 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 importedLibrary3) {
-    this._importedLibrary = importedLibrary3;
+  void set importedLibrary(LibraryElement importedLibrary2) {
+    this._importedLibrary = importedLibrary2;
   }
   /**
    * 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 prefix3) {
-    this._prefix = prefix3;
+  void set prefix(PrefixElement prefix2) {
+    this._prefix = prefix2;
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_prefix, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("import ");
     ((_importedLibrary as LibraryElementImpl)).appendTo(builder);
   }
 }
@@ skipping 104 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 identifier31) {
-    if (((_definingCompilationUnit as CompilationUnitElementImpl)).identifier == identifier31) {
+  ElementImpl getChild(String identifier2) {
+    if (((_definingCompilationUnit as CompilationUnitElementImpl)).identifier == identifier2) {
       return _definingCompilationUnit as CompilationUnitElementImpl;
     }
     for (CompilationUnitElement part in _parts) {
-      if (((part as CompilationUnitElementImpl)).identifier == identifier31) {
+      if (((part as CompilationUnitElementImpl)).identifier == identifier2) {
         return part as CompilationUnitElementImpl;
       }
     }
     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 17 matching lines @@
     }
     return new List.from(libraries);
   }
   List<ImportElement> get imports => _imports;
   ElementKind get kind => ElementKind.LIBRARY;
   LibraryElement get library => this;
   List<CompilationUnitElement> get parts => _parts;
   List<PrefixElement> get prefixes {
     Set<PrefixElement> prefixes = new Set<PrefixElement>();
     for (ImportElement element in _imports) {
-      PrefixElement prefix4 = element.prefix;
-      if (prefix4 != null) {
-        javaSetAdd(prefixes, prefix4);
+      PrefixElement prefix2 = element.prefix;
+      if (prefix2 != null) {
+        javaSetAdd(prefixes, prefix2);
       }
     }
     return new List.from(prefixes);
   }
   Source get source {
     if (_definingCompilationUnit == null) {
       return null;
     }
     return _definingCompilationUnit.source;
   }
@@ skipping 42 matching lines @@
     }
     this._exports = exports2;
   }
   /**
    * 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) {
       ((importElement as ImportElementImpl)).enclosingElement = this;
-      PrefixElementImpl prefix5 = importElement.prefix as PrefixElementImpl;
-      if (prefix5 != null) {
-        prefix5.enclosingElement = this;
+      PrefixElementImpl prefix2 = importElement.prefix as PrefixElementImpl;
+      if (prefix2 != null) {
+        prefix2.enclosingElement = this;
       }
     }
     this._imports = imports2;
   }
   /**
    * Set the compilation units that are included in this library using a {@code part} directive.
    * @param parts the compilation units that are included in this library using a {@code part}directive
    */
   void set parts(List<CompilationUnitElement> parts2) {
     for (CompilationUnitElement compilationUnit in parts2) {
@@ skipping 11 matching lines @@
   /**
    * Answer {@code true} if the receiver directly or indirectly imports the dart:html libraries.
    * @return {@code true} if the receiver directly or indirectly imports the dart:html libraries
    */
   bool isOrImportsBrowserLibrary() {
     List<LibraryElement> visited = new List<LibraryElement>();
     Source htmlLibSource = _context.sourceFactory.forUri(DartSdk.DART_HTML);
     visited.add(this);
     for (int index = 0; index < visited.length; index++) {
       LibraryElement library = visited[index];
-      Source source14 = library.definingCompilationUnit.source;
-      if (source14 == htmlLibSource) {
+      Source source2 = library.definingCompilationUnit.source;
+      if (source2 == htmlLibSource) {
         return true;
       }
       for (LibraryElement importedLibrary in library.importedLibraries) {
         if (!visited.contains(importedLibrary)) {
           visited.add(importedLibrary);
         }
       }
       for (LibraryElement exportedLibrary in library.exportedLibraries) {
         if (!visited.contains(exportedLibrary)) {
           visited.add(exportedLibrary);
@@ skipping 79 matching lines @@
   MethodElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset) {
     _jtd_constructor_212_impl(name, nameOffset);
   }
   _jtd_constructor_212_impl(String name, int nameOffset) {
   }
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.METHOD;
   bool isAbstract() => hasModifier(Modifier.ABSTRACT);
   bool isOperator() {
-    String name16 = name;
-    if (name16.isEmpty) {
+    String name2 = name;
+    if (name2.isEmpty) {
       return false;
     }
-    int first = name16.codeUnitAt(0);
+    int first = name2.codeUnitAt(0);
     return !((0x61 <= first && first <= 0x7A) || (0x41 <= first && first <= 0x5A) || first == 0x5F || first == 0x24);
   }
   bool isStatic() => hasModifier(Modifier.STATIC);
   /**
    * Set whether this method is abstract to correspond to the given value.
    * @param isAbstract {@code true} if the method is abstract
    */
   void set abstract(bool isAbstract) {
     setModifier(Modifier.ABSTRACT, isAbstract);
   }
@@ skipping 186 matching lines @@
    * 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;
   }
   /**
    * 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> parameters9) {
-    for (ParameterElement parameter in parameters9) {
+  void set parameters(List<ParameterElement> parameters2) {
+    for (ParameterElement parameter in parameters2) {
       ((parameter as ParameterElementImpl)).enclosingElement = this;
     }
-    this._parameters = parameters9;
+    this._parameters = parameters2;
   }
   /**
    * 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 {@code -1} if this element
    * does not have a visible range
    */
   void setVisibleRange(int offset, int length) {
     _visibleRangeOffset = offset;
@@ skipping 118 matching lines @@
    * Set whether this accessor is a setter to correspond to the given value.
    * @param isSetter {@code true} if the accessor is a setter
    */
   void set setter(bool isSetter) {
     setModifier(Modifier.SETTER, isSetter);
   }
   /**
    * Set the variable associated with this accessor to the given variable.
    * @param variable the variable associated with this accessor
    */
-  void set variable(PropertyInducingElement variable3) {
-    this._variable = variable3;
+  void set variable(PropertyInducingElement variable2) {
+    this._variable = variable2;
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append(isGetter() ? "get " : "set ");
     builder.append(variable.name);
     super.appendTo(builder);
   }
 }
 /**
  * Instances of the class {@code PropertyInducingElementImpl} implement a{@code PropertyInducingElement}.
  * @coverage dart.engine.element
@@ skipping 147 matching lines @@
    * Set the type representing the bound associated with this variable to the given type.
    * @param bound the type representing the bound associated with this variable
    */
   void set bound(Type2 bound2) {
     this._bound = bound2;
   }
   /**
    * Set the type defined by this type variable to the given type
    * @param type the type defined by this type variable
    */
-  void set type(TypeVariableType type9) {
-    this._type = type9;
+  void set type(TypeVariableType type2) {
+    this._type = type2;
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append(name);
     if (_bound != null) {
       builder.append(" extends ");
       builder.append(_bound);
     }
   }
 }
 /**
@@ skipping 64 matching lines @@
    * Set whether this variable is final to correspond to the given value.
    * @param isFinal {@code true} if the variable is final
    */
   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 initializer3) {
-    if (initializer3 != null) {
-      ((initializer3 as FunctionElementImpl)).enclosingElement = this;
+  void set initializer(FunctionElement initializer2) {
+    if (initializer2 != null) {
+      ((initializer2 as FunctionElementImpl)).enclosingElement = this;
     }
-    this._initializer = initializer3;
+    this._initializer = initializer2;
   }
   /**
    * Set the declared type of this variable to the given type.
    * @param type the declared type of this variable
    */
-  void set type(Type2 type10) {
-    this._type = type10;
+  void set type(Type2 type2) {
+    this._type = type2;
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChild(_initializer, visitor);
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append(type);
     builder.append(" ");
     builder.append(name);
   }
@@ skipping 190 matching lines @@
    * @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) {
   }
   MethodElement get baseElement => super.baseElement as MethodElement;
   ClassElement get enclosingElement => baseElement.enclosingElement;
   bool isAbstract() => baseElement.isAbstract();
   String toString() {
     MethodElement baseElement2 = baseElement;
-    List<ParameterElement> parameters12 = parameters;
-    FunctionType type13 = type;
+    List<ParameterElement> parameters2 = parameters;
+    FunctionType type2 = type;
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append(baseElement2.enclosingElement.name);
     builder.append(".");
     builder.append(baseElement2.name);
     builder.append("(");
-    int parameterCount = parameters12.length;
+    int parameterCount = parameters2.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         builder.append(", ");
       }
-      builder.append(parameters12[i]).toString();
+      builder.append(parameters2[i]).toString();
     }
     builder.append(")");
-    if (type13 != null) {
+    if (type2 != null) {
       builder.append(" -> ");
-      builder.append(type13.returnType);
+      builder.append(type2.returnType);
     }
     return builder.toString();
   }
 }
 /**
  * Instances of the class {@code ParameterMember} represent a parameter element defined in a
  * parameterized type where the values of the type parameters are known.
  */
 class ParameterMember extends VariableMember implements ParameterElement {
   /**
@@ skipping 46 matching lines @@
     }
     List<ParameterElement> parameterizedParameters = new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       parameterizedParameters[i] = ParameterMember.from(baseParameters[i], definingType);
     }
     return parameterizedParameters;
   }
   SourceRange get visibleRange => baseElement.visibleRange;
   bool isInitializingFormal() => baseElement.isInitializingFormal();
   String toString() {
-    ParameterElement baseElement3 = baseElement;
+    ParameterElement baseElement2 = baseElement;
     String left = "";
     String right = "";
     while (true) {
-      if (baseElement3.parameterKind == ParameterKind.NAMED) {
+      if (baseElement2.parameterKind == ParameterKind.NAMED) {
         left = "{";
         right = "}";
-      } else if (baseElement3.parameterKind == ParameterKind.POSITIONAL) {
+      } else if (baseElement2.parameterKind == ParameterKind.POSITIONAL) {
         left = "[";
         right = "]";
       }
       break;
     }
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append(left);
     builder.append(type);
     builder.append(" ");
-    builder.append(baseElement3.name);
+    builder.append(baseElement2.name);
     builder.append(right);
     return builder.toString();
   }
 }
 /**
  * Instances of the class {@code PropertyAccessorMember} represent a property accessor element
  * defined in a parameterized type where the values of the type parameters are known.
  */
 class PropertyAccessorMember extends ExecutableMember implements PropertyAccessorElement {
   /**
@@ skipping 23 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) {
   }
   PropertyAccessorElement get baseElement => super.baseElement as PropertyAccessorElement;
   Element get enclosingElement => baseElement.enclosingElement;
   PropertyInducingElement get variable {
-    PropertyInducingElement variable4 = baseElement.variable;
-    if (variable4 is FieldElement) {
-      return FieldMember.from(((variable4 as FieldElement)), definingType);
+    PropertyInducingElement variable2 = baseElement.variable;
+    if (variable2 is FieldElement) {
+      return FieldMember.from(((variable2 as FieldElement)), definingType);
     }
-    return variable4;
+    return variable2;
   }
   bool isGetter() => baseElement.isGetter();
   bool isSetter() => baseElement.isSetter();
 }
 /**
  * The abstract class {@code 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 {
@@ skipping 164 matching lines @@
     }
     FunctionTypeImpl otherType = object as FunctionTypeImpl;
     return element == otherType.element && JavaArrays.equals(_normalParameterTypes, otherType._normalParameterTypes) && JavaArrays.equals(_optionalParameterTypes, otherType._optionalParameterTypes) && equals2(_namedParameterTypes, otherType._namedParameterTypes) && _returnType == otherType._returnType;
   }
   Map<String, Type2> get namedParameterTypes => _namedParameterTypes;
   List<Type2> get normalParameterTypes => _normalParameterTypes;
   List<Type2> get optionalParameterTypes => _optionalParameterTypes;
   Type2 get returnType => _returnType;
   List<Type2> get typeArguments => _typeArguments;
   int get hashCode {
-    Element element53 = element;
-    if (element53 == null) {
+    Element element2 = element;
+    if (element2 == null) {
       return 0;
     }
-    return element53.hashCode;
+    return element2.hashCode;
   }
   bool isSubtypeOf(Type2 type) {
     if (type == null) {
       return false;
     } else if (identical(this, type) || type.isDynamic() || type.isDartCoreFunction()) {
       return true;
     } else if (type is! FunctionType) {
       return false;
     } else if (this == type) {
       return true;
@@ skipping 72 matching lines @@
    * array.
    * @param optionalParameterTypes the types of the optional parameters of this type of function
    */
   void set optionalParameterTypes(List<Type2> optionalParameterTypes2) {
     this._optionalParameterTypes = optionalParameterTypes2;
   }
   /**
    * Set the type of object returned by this type of function to the given type.
    * @param returnType the type of object returned by this type of function
    */
-  void set returnType(Type2 returnType3) {
-    this._returnType = returnType3;
+  void set returnType(Type2 returnType2) {
+    this._returnType = returnType2;
   }
   /**
    * 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> typeArguments4) {
-    this._typeArguments = typeArguments4;
+  void set typeArguments(List<Type2> typeArguments2) {
+    this._typeArguments = typeArguments2;
   }
   FunctionTypeImpl substitute4(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 element54 = element;
-    FunctionTypeImpl newType = (element54 is ExecutableElement) ? new FunctionTypeImpl.con1((element54 as ExecutableElement)) : new FunctionTypeImpl.con2((element54 as FunctionTypeAliasElement));
+    Element element2 = element;
+    FunctionTypeImpl newType = (element2 is ExecutableElement) ? new FunctionTypeImpl.con1((element2 as ExecutableElement)) : new FunctionTypeImpl.con2((element2 as FunctionTypeAliasElement));
     newType.returnType = _returnType.substitute2(argumentTypes, parameterTypes);
     newType.normalParameterTypes = TypeImpl.substitute(_normalParameterTypes, argumentTypes, parameterTypes);
     newType.optionalParameterTypes = TypeImpl.substitute(_optionalParameterTypes, argumentTypes, parameterTypes);
     newType._namedParameterTypes = substitute3(_namedParameterTypes, argumentTypes, parameterTypes);
     return newType;
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("(");
     bool needsComma = false;
     if (_normalParameterTypes.length > 0) {
@@ skipping 95 matching lines @@
     int longestPath = 1;
     int pathLength;
     if (superinterfaces.length > 0) {
       for (InterfaceType superinterface in superinterfaces) {
         pathLength = computeLongestInheritancePathToObject2(superinterface, depth + 1);
         if (pathLength > longestPath) {
           longestPath = pathLength;
         }
       }
     }
-    InterfaceType supertype3 = classElement.supertype;
-    pathLength = computeLongestInheritancePathToObject2(supertype3, depth + 1);
+    InterfaceType supertype2 = classElement.supertype;
+    pathLength = computeLongestInheritancePathToObject2(supertype2, depth + 1);
     if (pathLength > longestPath) {
       longestPath = pathLength;
     }
     return longestPath;
   }
   /**
    * Returns the set of all superinterfaces of the passed {@link Type}. This is a recursive method,
    * callers should call the public {@link #computeSuperinterfaceSet(Type)}.
    * @param type the {@link Type} to compute the set of superinterfaces of
    * @param set a {@link HashSet} used recursively by this method
    * @return the {@link Set} of superinterfaces of the passed {@link Type}
    * @see #computeSuperinterfaceSet(Type)
    * @see #getLeastUpperBound(Type)
    */
   static Set<InterfaceType> computeSuperinterfaceSet2(InterfaceType type, Set<InterfaceType> set) {
-    Element element55 = type.element;
-    if (element55 != null && element55 is ClassElement) {
-      ClassElement classElement = element55 as ClassElement;
+    Element element2 = type.element;
+    if (element2 != null && element2 is ClassElement) {
+      ClassElement classElement = element2 as ClassElement;
       List<InterfaceType> superinterfaces = classElement.interfaces;
       for (InterfaceType superinterface in superinterfaces) {
         javaSetAdd(set, superinterface);
         computeSuperinterfaceSet2(superinterface, set);
       }
-      InterfaceType supertype4 = classElement.supertype;
-      if (supertype4 != null) {
-        javaSetAdd(set, supertype4);
-        computeSuperinterfaceSet2(supertype4, set);
+      InterfaceType supertype2 = classElement.supertype;
+      if (supertype2 != null) {
+        javaSetAdd(set, supertype2);
+        computeSuperinterfaceSet2(supertype2, set);
       }
     }
     return set;
   }
   /**
    * An array containing the actual types of the type arguments.
    */
   List<Type2> _typeArguments = TypeImpl.EMPTY_ARRAY;
   /**
    * Initialize a newly created type to be declared by the given element.
@@ skipping 18 matching lines @@
     if (object is! InterfaceTypeImpl) {
       return false;
     }
     InterfaceTypeImpl otherType = object as InterfaceTypeImpl;
     return element == otherType.element && JavaArrays.equals(_typeArguments, otherType._typeArguments);
   }
   ClassElement get element => super.element as ClassElement;
   PropertyAccessorElement getGetter(String getterName) => PropertyAccessorMember.from(((element as ClassElementImpl)).getGetter(getterName), this);
   List<InterfaceType> get interfaces {
     ClassElement classElement = element;
-    List<InterfaceType> interfaces4 = classElement.interfaces;
-    List<TypeVariableElement> typeVariables7 = classElement.typeVariables;
-    if (typeVariables7.length == 0) {
-      return interfaces4;
+    List<InterfaceType> interfaces2 = classElement.interfaces;
+    List<TypeVariableElement> typeVariables2 = classElement.typeVariables;
+    if (typeVariables2.length == 0) {
+      return interfaces2;
     }
-    int count = interfaces4.length;
+    int count = interfaces2.length;
     List<InterfaceType> typedInterfaces = new List<InterfaceType>(count);
     for (int i = 0; i < count; i++) {
-      typedInterfaces[i] = interfaces4[i].substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(typeVariables7));
+      typedInterfaces[i] = interfaces2[i].substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(typeVariables2));
     }
     return typedInterfaces;
   }
-  Type2 getLeastUpperBound(Type2 type39) {
+  Type2 getLeastUpperBound(Type2 type2) {
     Type2 dynamicType = DynamicTypeImpl.instance;
-    if (identical(this, dynamicType) || identical(type39, dynamicType)) {
+    if (identical(this, dynamicType) || identical(type2, dynamicType)) {
       return dynamicType;
     }
-    if (type39 == null || type39 is! InterfaceType) {
+    if (type2 == null || type2 is! InterfaceType) {
       return null;
     }
     InterfaceType i = this;
-    InterfaceType j = type39 as InterfaceType;
+    InterfaceType j = type2 as InterfaceType;
     Set<InterfaceType> si = computeSuperinterfaceSet(i);
     Set<InterfaceType> sj = computeSuperinterfaceSet(j);
     javaSetAdd(si, i.element.type);
     javaSetAdd(sj, j.element.type);
     si.retainAll(sj);
     Set<InterfaceType> s = si;
     List<InterfaceType> sn = new List.from(s);
     List<int> depths = new List<int>.filled(sn.length, 0);
     int maxDepth = 0;
     for (int n = 0; n < sn.length; n++) {
@@ skipping 13 matching lines @@
       }
       if (numberOfTypesAtMaxDepth == 1) {
         return sn[indexOfLeastUpperBound];
       }
     }
     return null;
   }
   MethodElement getMethod(String methodName) => MethodMember.from(((element as ClassElementImpl)).getMethod(methodName), this);
   List<InterfaceType> get mixins {
     ClassElement classElement = element;
-    List<InterfaceType> mixins3 = classElement.mixins;
-    List<TypeVariableElement> typeVariables8 = classElement.typeVariables;
-    if (typeVariables8.length == 0) {
-      return mixins3;
+    List<InterfaceType> mixins2 = classElement.mixins;
+    List<TypeVariableElement> typeVariables2 = classElement.typeVariables;
+    if (typeVariables2.length == 0) {
+      return mixins2;
     }
-    int count = mixins3.length;
+    int count = mixins2.length;
     List<InterfaceType> typedMixins = new List<InterfaceType>(count);
     for (int i = 0; i < count; i++) {
-      typedMixins[i] = mixins3[i].substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(typeVariables8));
+      typedMixins[i] = mixins2[i].substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(typeVariables2));
     }
     return typedMixins;
   }
   PropertyAccessorElement getSetter(String setterName) => PropertyAccessorMember.from(((element as ClassElementImpl)).getSetter(setterName), this);
   InterfaceType get superclass {
     ClassElement classElement = element;
-    InterfaceType supertype5 = classElement.supertype;
-    if (supertype5 == null) {
+    InterfaceType supertype2 = classElement.supertype;
+    if (supertype2 == null) {
       return null;
     }
-    return supertype5.substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(classElement.typeVariables));
+    return supertype2.substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(classElement.typeVariables));
   }
   List<Type2> get typeArguments => _typeArguments;
   int get hashCode {
-    ClassElement element56 = element;
-    if (element56 == null) {
+    ClassElement element2 = element;
+    if (element2 == null) {
       return 0;
     }
-    return element56.hashCode;
+    return element2.hashCode;
   }
   bool isDartCoreFunction() {
-    ClassElement element57 = element;
-    if (element57 == null) {
+    ClassElement element2 = element;
+    if (element2 == null) {
       return false;
     }
-    return element57.name == "Function" && element57.library.isDartCore();
+    return element2.name == "Function" && element2.library.isDartCore();
   }
   bool isDirectSupertypeOf(InterfaceType type) {
     ClassElement i = element;
     ClassElement j = type.element;
-    InterfaceType supertype6 = j.supertype;
-    if (supertype6 == null) {
+    InterfaceType supertype2 = j.supertype;
+    if (supertype2 == null) {
       return false;
     }
-    ClassElement supertypeElement = supertype6.element;
+    ClassElement supertypeElement = supertype2.element;
     if (supertypeElement == i) {
       return true;
     }
     for (InterfaceType interfaceType in j.interfaces) {
       if (interfaceType.element == i) {
         return true;
       }
     }
     for (InterfaceType mixinType in j.mixins) {
       if (mixinType.element == i) {
@@ skipping 60 matching lines @@
       if (typeTArgs.length != typeSArgs.length) {
         return false;
       }
       for (int i = 0; i < typeTArgs.length; i++) {
         if (!typeTArgs[i].isSubtypeOf(typeSArgs[i])) {
           return false;
         }
       }
       return true;
     }
-    Type2 supertype7 = elementT.supertype;
-    if (supertype7 == null) {
+    Type2 supertype2 = elementT.supertype;
+    if (supertype2 == null) {
       return false;
     }
     List<Type2> interfaceTypes = elementT.interfaces;
     for (Type2 interfaceType in interfaceTypes) {
       if (interfaceType.isSubtypeOf(typeS)) {
         return true;
       }
     }
     List<Type2> mixinTypes = elementT.mixins;
     for (Type2 mixinType in mixinTypes) {
       if (mixinType == typeS) {
         return true;
       }
     }
-    return supertype7.isSubtypeOf(typeS);
+    return supertype2.isSubtypeOf(typeS);
   }
   PropertyAccessorElement lookUpGetter(String getterName, LibraryElement library) {
     PropertyAccessorElement element = getGetter(getterName);
     if (element != null && element.isAccessibleIn(library)) {
       return element;
     }
     for (InterfaceType mixin in mixins) {
       element = mixin.getGetter(getterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
@@ skipping 48 matching lines @@
         return element;
       }
       supertype = supertype.superclass;
     }
     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> typeArguments5) {
-    this._typeArguments = typeArguments5;
+  void set typeArguments(List<Type2> typeArguments2) {
+    this._typeArguments = typeArguments2;
   }
   InterfaceTypeImpl substitute5(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) {
       return this;
     }
     InterfaceTypeImpl newType = new InterfaceTypeImpl.con1(element);
@@ skipping 23 matching lines @@
 abstract class TypeImpl implements Type2 {
   /**
    * Return an array containing the results of using the given argument types and parameter types to
    * perform a substitution on all of the given types.
    * @param types the types on which a substitution is to be performed
    * @param argumentTypes the argument types for the substitution
    * @param parameterTypes the parameter types for the substitution
    * @return the result of performing the substitution on each of the types
    */
   static List<Type2> substitute(List<Type2> types, List<Type2> argumentTypes, List<Type2> parameterTypes) {
-    int length6 = types.length;
-    if (length6 == 0) {
+    int length2 = types.length;
+    if (length2 == 0) {
       return types;
     }
-    List<Type2> newTypes = new List<Type2>(length6);
-    for (int i = 0; i < length6; i++) {
+    List<Type2> newTypes = new List<Type2>(length2);
+    for (int i = 0; i < length2; i++) {
       newTypes[i] = types[i].substitute2(argumentTypes, parameterTypes);
     }
     return newTypes;
   }
   /**
    * The element representing the declaration of this type, or {@code null} if the type has not, or
    * cannot, be associated with an element.
    */
   Element _element;
   /**
@@ skipping 68 matching lines @@
   }
   bool operator ==(Object object) => object is TypeVariableTypeImpl && element == ((object as TypeVariableTypeImpl)).element;
   TypeVariableElement get element => super.element as TypeVariableElement;
   int get hashCode => element.hashCode;
   bool isMoreSpecificThan(Type2 type) {
     Type2 upperBound = element.bound;
     return type == upperBound;
   }
   bool isSubtypeOf(Type2 type) => true;
   Type2 substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes) {
-    int length7 = parameterTypes.length;
-    for (int i = 0; i < length7; i++) {
+    int length2 = parameterTypes.length;
+    for (int i = 0; i < length2; i++) {
       if (parameterTypes[i] == this) {
         return argumentTypes[i];
       }
     }
     return this;
   }
 }
 /**
  * The unique instance of the class {@code VoidTypeImpl} implements the type {@code void}.
  * @coverage dart.engine.type
@@ skipping 423 matching lines @@
 abstract class TypeVariableType implements Type2 {
   TypeVariableElement get element;
 }
 /**
  * The interface {@code VoidType} defines the behavior of the unique object representing the type{@code void}.
  * @coverage dart.engine.type
  */
 abstract class VoidType implements Type2 {
   VoidType substitute2(List<Type2> argumentTypes, List<Type2> parameterTypes);
 }