Improve java2dart code style - relax 'don't reference variable name in its initializer'.

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;
 import 'ast.dart' show Identifier, LibraryIdentifier;
 import 'sdk.dart' show DartSdk;
@@ skipping 1672 matching lines @@
       if (javaSetAdd(visitedClasses, currentElement)) {
         for (FieldElement field in currentElement.fields) {
           if (!field.isFinal() && !field.isConst() && !field.isStatic() && !field.isSynthetic()) {
             return true;
           }
         }
         for (InterfaceType mixinType in currentElement.mixins) {
           ClassElement mixinElement = mixinType.element;
           classesToVisit.add(mixinElement);
         }
-        InterfaceType supertype2 = currentElement.supertype;
-        if (supertype2 != null) {
-          ClassElement superElement = supertype2.element;
+        InterfaceType supertype = currentElement.supertype;
+        if (supertype != null) {
+          ClassElement superElement = supertype.element;
           if (superElement != null) {
             classesToVisit.add(superElement);
           }
         }
       }
     }
     return false;
   }
   bool hasReferenceToSuper() => hasModifier(Modifier.REFERENCES_SUPER);
   bool isAbstract() => hasModifier(Modifier.ABSTRACT);
@@ skipping 10 matching lines @@
       }
       for (InterfaceType mixin in currentElement.mixins) {
         ClassElement mixinElement = mixin.element;
         if (mixinElement != null) {
           element = mixinElement.getGetter(getterName);
           if (element != null && element.isAccessibleIn(library)) {
             return element;
           }
         }
       }
-      InterfaceType supertype2 = currentElement.supertype;
-      if (supertype2 == null) {
+      InterfaceType supertype = currentElement.supertype;
+      if (supertype == null) {
         return null;
       }
-      currentElement = supertype2.element;
+      currentElement = supertype.element;
     }
     return null;
   }
   MethodElement lookUpMethod(String methodName, LibraryElement library) {
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     ClassElement currentElement = this;
     while (currentElement != null && !visitedClasses.contains(currentElement)) {
       javaSetAdd(visitedClasses, currentElement);
       MethodElement element = currentElement.getMethod(methodName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in currentElement.mixins) {
         ClassElement mixinElement = mixin.element;
         if (mixinElement != null) {
           element = mixinElement.getMethod(methodName);
           if (element != null && element.isAccessibleIn(library)) {
             return element;
           }
         }
       }
-      InterfaceType supertype2 = currentElement.supertype;
-      if (supertype2 == null) {
+      InterfaceType supertype = currentElement.supertype;
+      if (supertype == null) {
         return null;
       }
-      currentElement = supertype2.element;
+      currentElement = supertype.element;
     }
     return null;
   }
   PropertyAccessorElement lookUpSetter(String setterName, LibraryElement library) {
     Set<ClassElement> visitedClasses = new Set<ClassElement>();
     ClassElement currentElement = this;
     while (currentElement != null && !visitedClasses.contains(currentElement)) {
       javaSetAdd(visitedClasses, currentElement);
       PropertyAccessorElement element = currentElement.getSetter(setterName);
       if (element != null && element.isAccessibleIn(library)) {
         return element;
       }
       for (InterfaceType mixin in currentElement.mixins) {
         ClassElement mixinElement = mixin.element;
         if (mixinElement != null) {
           element = mixinElement.getSetter(setterName);
           if (element != null && element.isAccessibleIn(library)) {
             return element;
           }
         }
       }
-      InterfaceType supertype2 = currentElement.supertype;
-      if (supertype2 == null) {
+      InterfaceType supertype = currentElement.supertype;
+      if (supertype == null) {
         return null;
       }
-      currentElement = supertype2.element;
+      currentElement = supertype.element;
     }
     return null;
   }
 
   /**
    * Set whether this class is abstract to correspond to the given value.
    * @param isAbstract {@code true} if the class is abstract
    */
   void set abstract(bool isAbstract) {
     setModifier(Modifier.ABSTRACT, isAbstract);
@@ skipping 150 matching lines @@
           supertypes.add(currentType);
         }
         InterfaceType supertype = currentType.superclass;
         if (supertype != null) {
           typesToVisit.add(supertype);
         }
         for (InterfaceType type in currentElement.interfaces) {
           typesToVisit.add(type);
         }
         for (InterfaceType type in currentElement.mixins) {
-          ClassElement element2 = type.element;
-          if (!visitedClasses.contains(element2)) {
+          ClassElement element = type.element;
+          if (!visitedClasses.contains(element)) {
             supertypes.add(type);
           }
         }
       }
     }
   }
 }
 /**
  * Instances of the class {@code CompilationUnitElementImpl} implement a{@link CompilationUnitElement}.
  * @coverage dart.engine.element
@@ skipping 436 matching lines @@
    * declaration of this element
    */
   ElementImpl.con2(String name2, int nameOffset2) {
     _jtd_constructor_195_impl(name2, nameOffset2);
   }
   _jtd_constructor_195_impl(String name2, int nameOffset2) {
     this._name = StringUtilities.intern(name2);
     this._nameOffset = nameOffset2;
   }
   String computeDocumentationComment() {
-    AnalysisContext context2 = context;
-    if (context2 == null) {
+    AnalysisContext context = this.context;
+    if (context == null) {
       return null;
     }
-    return context2.computeDocumentationComment(this);
+    return context.computeDocumentationComment(this);
   }
   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 202 matching lines @@
     return JavaArrays.equals(_components, location._components);
   }
 
   /**
    * Return the path to the element whose location is represented by this object.
    * @return the path to the element whose location is represented by this object
    */
   List<String> get components => _components;
   String get encoding {
     JavaStringBuilder builder = new JavaStringBuilder();
-    int length2 = _components.length;
-    for (int i = 0; i < length2; i++) {
+    int length = _components.length;
+    for (int i = 0; i < length; i++) {
       if (i > 0) {
         builder.appendChar(_SEPARATOR_CHAR);
       }
       encode(builder, _components[i]);
     }
     return builder.toString();
   }
   int get hashCode => JavaArrays.makeHashCode(_components);
   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 length2 = encoding.length;
-    while (index < length2) {
+    int length = encoding.length;
+    while (index < length) {
       int currentChar = encoding.codeUnitAt(index);
       if (currentChar == _SEPARATOR_CHAR) {
-        if (index + 1 < length2 && encoding.codeUnitAt(index + 1) == _SEPARATOR_CHAR) {
+        if (index + 1 < length && 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 length2 = component.length;
-    for (int i = 0; i < length2; i++) {
+    int length = component.length;
+    for (int i = 0; i < length; 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 939 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 prefix2 = element.prefix;
-      if (prefix2 != null) {
-        javaSetAdd(prefixes, prefix2);
+      PrefixElement prefix = element.prefix;
+      if (prefix != null) {
+        javaSetAdd(prefixes, prefix);
       }
     }
     return new List.from(prefixes);
   }
   Source get source {
     if (_definingCompilationUnit == null) {
       return null;
     }
     return _definingCompilationUnit.source;
   }
@@ skipping 46 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 prefix2 = importElement.prefix as PrefixElementImpl;
-      if (prefix2 != null) {
-        prefix2.enclosingElement = this;
+      PrefixElementImpl prefix = importElement.prefix as PrefixElementImpl;
+      if (prefix != null) {
+        prefix.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) {
@@ skipping 13 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 source2 = library.definingCompilationUnit.source;
-      if (source2 == htmlLibSource) {
+      Source source = library.definingCompilationUnit.source;
+      if (source == 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 86 matching lines @@
    */
   MethodElementImpl.con2(String name, int nameOffset) : super.con2(name, nameOffset) {
     _jtd_constructor_218_impl(name, nameOffset);
   }
   _jtd_constructor_218_impl(String name, int nameOffset) {
   }
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
   ElementKind get kind => ElementKind.METHOD;
   String get name {
-    String name2 = super.name;
-    if (isOperator() && name2 == "-") {
+    String name = super.name;
+    if (isOperator() && name == "-") {
       if (parameters.length == 0) {
         return "unary-";
       }
     }
     return super.name;
   }
   bool isAbstract() => hasModifier(Modifier.ABSTRACT);
   bool isOperator() {
     String name = displayName;
     if (name.isEmpty) {
@@ skipping 750 matching lines @@
    */
   ConstructorMember(ConstructorElement baseElement, InterfaceType definingType) : super(baseElement, definingType) {
   }
   accept(ElementVisitor visitor) => visitor.visitConstructorElement(this);
   ConstructorElement get baseElement => super.baseElement as ConstructorElement;
   ClassElement get enclosingElement => baseElement.enclosingElement;
   ConstructorElement get redirectedConstructor => from(baseElement.redirectedConstructor, definingType);
   bool isConst() => baseElement.isConst();
   bool isFactory() => baseElement.isFactory();
   String toString() {
-    ConstructorElement baseElement2 = baseElement;
-    List<ParameterElement> parameters2 = parameters;
-    FunctionType type2 = type;
+    ConstructorElement baseElement = this.baseElement;
+    List<ParameterElement> parameters = this.parameters;
+    FunctionType type = this.type;
     JavaStringBuilder builder = new JavaStringBuilder();
-    builder.append(baseElement2.enclosingElement.displayName);
+    builder.append(baseElement.enclosingElement.displayName);
     String name = displayName;
     if (name != null && !name.isEmpty) {
       builder.append(".");
       builder.append(name);
     }
     builder.append("(");
-    int parameterCount = parameters2.length;
+    int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         builder.append(", ");
       }
-      builder.append(parameters2[i]).toString();
+      builder.append(parameters[i]).toString();
     }
     builder.append(")");
-    if (type2 != null) {
+    if (type != null) {
       builder.append(" -> ");
-      builder.append(type2.returnType);
+      builder.append(type.returnType);
     }
     return builder.toString();
   }
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 /**
  * The abstract class {@code ExecutableMember} defines the behavior common to members that represent
  * an executable element defined in a parameterized type where the values of the type parameters are
  * known.
  */
@@ skipping 225 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) {
   }
   accept(ElementVisitor visitor) => visitor.visitMethodElement(this);
   MethodElement get baseElement => super.baseElement as MethodElement;
   ClassElement get enclosingElement => baseElement.enclosingElement;
   bool isAbstract() => baseElement.isAbstract();
   String toString() {
-    MethodElement baseElement2 = baseElement;
-    List<ParameterElement> parameters2 = parameters;
-    FunctionType type2 = type;
+    MethodElement baseElement = this.baseElement;
+    List<ParameterElement> parameters = this.parameters;
+    FunctionType type = this.type;
     JavaStringBuilder builder = new JavaStringBuilder();
-    builder.append(baseElement2.enclosingElement.displayName);
+    builder.append(baseElement.enclosingElement.displayName);
     builder.append(".");
-    builder.append(baseElement2.displayName);
+    builder.append(baseElement.displayName);
     builder.append("(");
-    int parameterCount = parameters2.length;
+    int parameterCount = parameters.length;
     for (int i = 0; i < parameterCount; i++) {
       if (i > 0) {
         builder.append(", ");
       }
-      builder.append(parameters2[i]).toString();
+      builder.append(parameters[i]).toString();
     }
     builder.append(")");
-    if (type2 != null) {
+    if (type != null) {
       builder.append(" -> ");
-      builder.append(type2.returnType);
+      builder.append(type.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 24 matching lines @@
   /**
    * Initialize a newly created element to represent a parameter of the given parameterized type.
    * @param baseElement the element on which the parameterized element was created
    * @param definingType the type in which the element is defined
    */
   ParameterMember(ParameterElement baseElement, ParameterizedType definingType) : super(baseElement, definingType) {
   }
   accept(ElementVisitor visitor) => visitor.visitParameterElement(this);
   Element getAncestor(Type elementClass) {
     Element element = baseElement.getAncestor(elementClass);
-    ParameterizedType definingType2 = definingType;
-    if (definingType2 is InterfaceType) {
-      InterfaceType definingInterfaceType = definingType2 as InterfaceType;
+    ParameterizedType definingType = this.definingType;
+    if (definingType is InterfaceType) {
+      InterfaceType definingInterfaceType = definingType as InterfaceType;
       if (element is ConstructorElement) {
         return ConstructorMember.from((element as ConstructorElement), definingInterfaceType) as Element;
       } else if (element is MethodElement) {
         return MethodMember.from((element as MethodElement), definingInterfaceType) as Element;
       } else if (element is PropertyAccessorElement) {
         return PropertyAccessorMember.from((element as PropertyAccessorElement), definingInterfaceType) as Element;
       }
     }
     return element;
   }
   ParameterElement get baseElement => super.baseElement as ParameterElement;
   Element get enclosingElement => baseElement.enclosingElement;
   ParameterKind get parameterKind => baseElement.parameterKind;
   List<ParameterElement> get parameters {
     List<ParameterElement> baseParameters = baseElement.parameters;
     int parameterCount = baseParameters.length;
     if (parameterCount == 0) {
       return baseParameters;
     }
     List<ParameterElement> parameterizedParameters = new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
       parameterizedParameters[i] = ParameterMember.from(baseParameters[i], definingType);
     }
     return parameterizedParameters;
   }
   SourceRange get visibleRange => baseElement.visibleRange;
   bool isInitializingFormal() => baseElement.isInitializingFormal();
   String toString() {
-    ParameterElement baseElement2 = baseElement;
+    ParameterElement baseElement = this.baseElement;
     String left = "";
     String right = "";
     while (true) {
-      if (baseElement2.parameterKind == ParameterKind.NAMED) {
+      if (baseElement.parameterKind == ParameterKind.NAMED) {
         left = "{";
         right = "}";
-      } else if (baseElement2.parameterKind == ParameterKind.POSITIONAL) {
+      } else if (baseElement.parameterKind == ParameterKind.POSITIONAL) {
         left = "[";
         right = "]";
       }
       break;
     }
     JavaStringBuilder builder = new JavaStringBuilder();
     builder.append(left);
     builder.append(type);
     builder.append(" ");
-    builder.append(baseElement2.displayName);
+    builder.append(baseElement.displayName);
     builder.append(right);
     return builder.toString();
   }
   void visitChildren(ElementVisitor<Object> visitor) {
     super.visitChildren(visitor);
     safelyVisitChildren(parameters, visitor);
   }
 }
 /**
  * Instances of the class {@code PropertyAccessorMember} represent a property accessor element
@@ skipping 32 matching lines @@
    * @param definingType the type in which the element is defined
    */
   PropertyAccessorMember(PropertyAccessorElement baseElement, InterfaceType definingType) : super(baseElement, definingType) {
   }
   accept(ElementVisitor visitor) => visitor.visitPropertyAccessorElement(this);
   PropertyAccessorElement get baseElement => super.baseElement as PropertyAccessorElement;
   PropertyAccessorElement get correspondingGetter => from(baseElement.correspondingGetter, definingType);
   PropertyAccessorElement get correspondingSetter => from(baseElement.correspondingSetter, definingType);
   Element get enclosingElement => baseElement.enclosingElement;
   PropertyInducingElement get variable {
-    PropertyInducingElement variable2 = baseElement.variable;
-    if (variable2 is FieldElement) {
-      return FieldMember.from(((variable2 as FieldElement)), definingType);
+    PropertyInducingElement variable = baseElement.variable;
+    if (variable is FieldElement) {
+      return FieldMember.from(((variable as FieldElement)), definingType);
     }
-    return variable2;
+    return variable;
   }
   bool isAbstract() => baseElement.isAbstract();
   bool isGetter() => baseElement.isGetter();
   bool isSetter() => baseElement.isSetter();
   InterfaceType get definingType => super.definingType as InterfaceType;
 }
 /**
  * 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.
@@ skipping 204 matching lines @@
   _jtd_constructor_300_impl(FunctionTypeAliasElement element) {
   }
   bool operator ==(Object object) {
     if (object is! FunctionTypeImpl) {
       return false;
     }
     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;
   }
   String get displayName {
-    String name2 = name;
-    if (name2 == null) {
+    String name = this.name;
+    if (name == null) {
       JavaStringBuilder builder = new JavaStringBuilder();
       builder.append("(");
       bool needsComma = false;
       if (_normalParameterTypes.length > 0) {
         for (Type2 type in _normalParameterTypes) {
           if (needsComma) {
             builder.append(", ");
           } else {
             needsComma = true;
           }
@@ skipping 35 matching lines @@
         }
         builder.append("}");
         needsComma = true;
       }
       builder.append(") -> ");
       if (_returnType == null) {
         builder.append("null");
       } else {
         builder.append(_returnType.displayName);
       }
-      name2 = builder.toString();
+      name = builder.toString();
     }
-    return name2;
+    return name;
   }
   Map<String, Type2> get namedParameterTypes => _namedParameterTypes;
   List<Type2> get normalParameterTypes => _normalParameterTypes;
   List<Type2> get optionalParameterTypes => _optionalParameterTypes;
   List<ParameterElement> get parameters {
-    List<ParameterElement> baseParameters2 = baseParameters;
-    int parameterCount = baseParameters2.length;
+    List<ParameterElement> baseParameters = this.baseParameters;
+    int parameterCount = baseParameters.length;
     if (parameterCount == 0) {
-      return baseParameters2;
+      return baseParameters;
     }
     List<ParameterElement> specializedParameters = new List<ParameterElement>(parameterCount);
     for (int i = 0; i < parameterCount; i++) {
-      specializedParameters[i] = ParameterMember.from(baseParameters2[i], this);
+      specializedParameters[i] = ParameterMember.from(baseParameters[i], this);
     }
     return specializedParameters;
   }
   Type2 get returnType => _returnType;
   List<Type2> get typeArguments => _typeArguments;
   List<TypeVariableElement> get typeVariables {
-    Element element2 = element;
-    if (element2 is FunctionTypeAliasElement) {
-      return ((element2 as FunctionTypeAliasElement)).typeVariables;
+    Element element = this.element;
+    if (element is FunctionTypeAliasElement) {
+      return ((element as FunctionTypeAliasElement)).typeVariables;
     }
     return TypeVariableElementImpl.EMPTY_ARRAY;
   }
   int get hashCode {
-    Element element2 = element;
-    if (element2 == null) {
+    Element element = this.element;
+    if (element == null) {
       return 0;
     }
-    return element2.hashCode;
+    return element.hashCode;
   }
   bool isSubtypeOf(Type2 type) {
     if (type == null) {
       return false;
     } else if (identical(this, type) || type.isDynamic() || type.isDartCoreFunction() || type.isObject()) {
       return true;
     } else if (type is! FunctionType) {
       return false;
     } else if (this == type) {
       return true;
@@ skipping 108 matching lines @@
     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 element2 = element;
-    FunctionTypeImpl newType = (element2 is ExecutableElement) ? new FunctionTypeImpl.con1((element2 as ExecutableElement)) : new FunctionTypeImpl.con2((element2 as FunctionTypeAliasElement));
+    Element element = this.element;
+    FunctionTypeImpl newType = (element is ExecutableElement) ? new FunctionTypeImpl.con1((element as ExecutableElement)) : new FunctionTypeImpl.con2((element 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);
     newType.typeArguments = argumentTypes;
     return newType;
   }
   void appendTo(JavaStringBuilder builder) {
     builder.append("(");
     bool needsComma = false;
@@ skipping 48 matching lines @@
       builder.append("null");
     } else {
       ((_returnType as TypeImpl)).appendTo(builder);
     }
   }
 
   /**
    * @return the base parameter elements of this function element, not {@code null}.
    */
   List<ParameterElement> get baseParameters {
-    Element element2 = element;
-    if (element2 is ExecutableElement) {
-      return ((element2 as ExecutableElement)).parameters;
+    Element element = this.element;
+    if (element is ExecutableElement) {
+      return ((element as ExecutableElement)).parameters;
     } else {
-      return ((element2 as FunctionTypeAliasElement)).parameters;
+      return ((element as FunctionTypeAliasElement)).parameters;
     }
   }
 }
 /**
  * Instances of the class {@code InterfaceTypeImpl} defines the behavior common to objects
  * representing the type introduced by either a class or an interface, or a reference to such a
  * type.
  * @coverage dart.engine.type
  */
 class InterfaceTypeImpl extends TypeImpl implements InterfaceType {
@@ skipping 40 matching lines @@
       List<InterfaceType> superinterfaces = classElement.interfaces;
       int pathLength;
       if (superinterfaces.length > 0) {
         for (InterfaceType superinterface in superinterfaces) {
           pathLength = computeLongestInheritancePathToObject2(superinterface, depth + 1, visitedClasses);
           if (pathLength > longestPath) {
             longestPath = pathLength;
           }
         }
       }
-      InterfaceType supertype2 = classElement.supertype;
-      pathLength = computeLongestInheritancePathToObject2(supertype2, depth + 1, visitedClasses);
+      InterfaceType supertype = classElement.supertype;
+      pathLength = computeLongestInheritancePathToObject2(supertype, depth + 1, visitedClasses);
       if (pathLength > longestPath) {
         longestPath = pathLength;
       }
     } finally {
       visitedClasses.remove(classElement);
     }
     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 element2 = type.element;
-    if (element2 != null && element2 is ClassElement) {
-      ClassElement classElement = element2 as ClassElement;
+    Element element = type.element;
+    if (element != null && element is ClassElement) {
+      ClassElement classElement = element as ClassElement;
       List<InterfaceType> superinterfaces = classElement.interfaces;
       for (InterfaceType superinterface in superinterfaces) {
         if (javaSetAdd(set, superinterface)) {
           computeSuperinterfaceSet2(superinterface, set);
         }
       }
-      InterfaceType supertype2 = classElement.supertype;
-      if (supertype2 != null) {
-        if (javaSetAdd(set, supertype2)) {
-          computeSuperinterfaceSet2(supertype2, set);
+      InterfaceType supertype = classElement.supertype;
+      if (supertype != null) {
+        if (javaSetAdd(set, supertype)) {
+          computeSuperinterfaceSet2(supertype, set);
         }
       }
     }
     return set;
   }
 
   /**
    * Return the intersection of the given sets of types, where intersection is based on the equality
    * of the elements of the types rather than on the equality of the types themselves. In cases
    * where two non-equal types have equal elements, which only happens when the class is
@@ skipping 80 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> interfaces2 = classElement.interfaces;
-    List<TypeVariableElement> typeVariables2 = classElement.typeVariables;
-    if (typeVariables2.length == 0) {
-      return interfaces2;
+    List<InterfaceType> interfaces = classElement.interfaces;
+    List<TypeVariableElement> typeVariables = classElement.typeVariables;
+    if (typeVariables.length == 0) {
+      return interfaces;
     }
-    int count = interfaces2.length;
+    int count = interfaces.length;
     List<InterfaceType> typedInterfaces = new List<InterfaceType>(count);
     for (int i = 0; i < count; i++) {
-      typedInterfaces[i] = interfaces2[i].substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(typeVariables2));
+      typedInterfaces[i] = interfaces[i].substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(typeVariables));
     }
     return typedInterfaces;
   }
   Type2 getLeastUpperBound(Type2 type) {
     if (identical(type, this)) {
       return this;
     }
     Type2 dynamicType = DynamicTypeImpl.instance;
     if (identical(this, dynamicType) || identical(type, dynamicType)) {
       return dynamicType;
@@ skipping 27 matching lines @@
       }
       if (numberOfTypesAtMaxDepth == 1) {
         return s[indexOfLeastUpperBound];
       }
     }
     return null;
   }
   MethodElement getMethod(String methodName) => MethodMember.from(((element as ClassElementImpl)).getMethod(methodName), this);
   List<InterfaceType> get mixins {
     ClassElement classElement = element;
-    List<InterfaceType> mixins2 = classElement.mixins;
-    List<TypeVariableElement> typeVariables2 = classElement.typeVariables;
-    if (typeVariables2.length == 0) {
-      return mixins2;
+    List<InterfaceType> mixins = classElement.mixins;
+    List<TypeVariableElement> typeVariables = classElement.typeVariables;
+    if (typeVariables.length == 0) {
+      return mixins;
     }
-    int count = mixins2.length;
+    int count = mixins.length;
     List<InterfaceType> typedMixins = new List<InterfaceType>(count);
     for (int i = 0; i < count; i++) {
-      typedMixins[i] = mixins2[i].substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(typeVariables2));
+      typedMixins[i] = mixins[i].substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(typeVariables));
     }
     return typedMixins;
   }
   PropertyAccessorElement getSetter(String setterName) => PropertyAccessorMember.from(((element as ClassElementImpl)).getSetter(setterName), this);
   InterfaceType get superclass {
     ClassElement classElement = element;
-    InterfaceType supertype2 = classElement.supertype;
-    if (supertype2 == null) {
+    InterfaceType supertype = classElement.supertype;
+    if (supertype == null) {
       return null;
     }
-    return supertype2.substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(classElement.typeVariables));
+    return supertype.substitute2(_typeArguments, TypeVariableTypeImpl.getTypes(classElement.typeVariables));
   }
   List<Type2> get typeArguments => _typeArguments;
   List<TypeVariableElement> get typeVariables => element.typeVariables;
   int get hashCode {
-    ClassElement element2 = element;
-    if (element2 == null) {
+    ClassElement element = this.element;
+    if (element == null) {
       return 0;
     }
-    return element2.hashCode;
+    return element.hashCode;
   }
   bool isDartCoreFunction() {
-    ClassElement element2 = element;
-    if (element2 == null) {
+    ClassElement element = this.element;
+    if (element == null) {
       return false;
     }
-    return element2.name == "Function" && element2.library.isDartCore();
+    return element.name == "Function" && element.library.isDartCore();
   }
   bool isDirectSupertypeOf(InterfaceType type) {
     ClassElement i = element;
     ClassElement j = type.element;
-    InterfaceType supertype2 = j.supertype;
-    if (supertype2 == null) {
+    InterfaceType supertype = j.supertype;
+    if (supertype == null) {
       return false;
     }
-    ClassElement supertypeElement = supertype2.element;
+    ClassElement supertypeElement = supertype.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 186 matching lines @@
       if (tArguments.length != sArguments.length) {
         return false;
       }
       for (int i = 0; i < tArguments.length; i++) {
         if (!tArguments[i].isMoreSpecificThan(sArguments[i])) {
           return false;
         }
       }
       return true;
     }
-    ClassElement element2 = element;
-    if (element2 == null || visitedClasses.contains(element2)) {
+    ClassElement element = this.element;
+    if (element == null || visitedClasses.contains(element)) {
       return false;
     }
-    javaSetAdd(visitedClasses, element2);
-    InterfaceType supertype2 = element2.supertype;
-    if (supertype2 != null && ((supertype2 as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses)) {
+    javaSetAdd(visitedClasses, element);
+    InterfaceType supertype = element.supertype;
+    if (supertype != null && ((supertype as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses)) {
       return true;
     }
-    for (InterfaceType interfaceType in element2.interfaces) {
+    for (InterfaceType interfaceType in element.interfaces) {
       if (((interfaceType as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses)) {
         return true;
       }
     }
-    for (InterfaceType mixinType in element2.mixins) {
+    for (InterfaceType mixinType in element.mixins) {
       if (((mixinType as InterfaceTypeImpl)).isMoreSpecificThan2(s, visitedClasses)) {
         return true;
       }
     }
     return false;
   }
   bool isSubtypeOf2(InterfaceType type, Set<ClassElement> visitedClasses) {
     InterfaceType typeT = this;
     InterfaceType typeS = type;
     ClassElement elementT = element;
@@ skipping 12 matching lines @@
       }
       for (int i = 0; i < typeTArgs.length; i++) {
         if (!typeTArgs[i].isSubtypeOf(typeSArgs[i])) {
           return false;
         }
       }
       return true;
     } else if (typeS.isDartCoreFunction() && elementT.getMethod("call") != null) {
       return true;
     }
-    InterfaceType supertype2 = elementT.supertype;
-    if (supertype2 != null && ((supertype2 as InterfaceTypeImpl)).isSubtypeOf2(typeS, visitedClasses)) {
+    InterfaceType supertype = elementT.supertype;
+    if (supertype != null && ((supertype as InterfaceTypeImpl)).isSubtypeOf2(typeS, visitedClasses)) {
       return true;
     }
     List<InterfaceType> interfaceTypes = elementT.interfaces;
     for (InterfaceType interfaceType in interfaceTypes) {
       if (((interfaceType as InterfaceTypeImpl)).isSubtypeOf2(typeS, visitedClasses)) {
         return true;
       }
     }
     List<InterfaceType> mixinTypes = elementT.mixins;
     for (InterfaceType mixinType in mixinTypes) {
@@ skipping 13 matching lines @@
 
   /**
    * 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 length2 = types.length;
-    if (length2 == 0) {
+    int length = types.length;
+    if (length == 0) {
       return types;
     }
-    List<Type2> newTypes = new List<Type2>(length2);
-    for (int i = 0; i < length2; i++) {
+    List<Type2> newTypes = new List<Type2>(length);
+    for (int i = 0; i < length; 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 77 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 length2 = parameterTypes.length;
-    for (int i = 0; i < length2; i++) {
+    int length = parameterTypes.length;
+    for (int i = 0; i < length; 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 557 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);
 }