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

pkg/analyzer_experimental/lib/src/generated/resolver.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.resolver;
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'source.dart';
 import 'error.dart';
 import 'scanner.dart' as sc;
@@ skipping 15 matching lines @@
 class CompilationUnitBuilder {
 
   /**
    * Build the compilation unit element for the given source.
    *
    * @param source the source describing the compilation unit
    * @param unit the AST structure representing the compilation unit
    * @return the compilation unit element that was built
    * @throws AnalysisException if the analysis could not be performed
    */
-  CompilationUnitElementImpl buildCompilationUnit(Source source2, CompilationUnit unit) {
+  CompilationUnitElementImpl buildCompilationUnit(Source source, CompilationUnit unit) {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.resolve.start();
     if (unit == null) {
       return null;
     }
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = new ElementBuilder(holder);
     unit.accept(builder);
-    CompilationUnitElementImpl element = new CompilationUnitElementImpl(source2.shortName);
+    CompilationUnitElementImpl element = new CompilationUnitElementImpl(source.shortName);
     element.accessors = holder.accessors;
     element.functions = holder.functions;
-    element.source = source2;
+    element.source = source;
     element.typeAliases = holder.typeAliases;
     element.types = holder.types;
     element.topLevelVariables = holder.topLevelVariables;
     unit.element = element;
     timeCounter.stop();
     return element;
   }
 }
 /**
  * Instances of the class `ElementBuilder` traverse an AST structure and build the element
@@ skipping 628 matching lines @@
     return null;
   }
 
   /**
    * Return `true` if the given token is a token for the given keyword.
    *
    * @param token the token being tested
    * @param keyword the keyword being tested for
    * @return `true` if the given token is a token for the given keyword
    */
-  bool matches(sc.Token token, sc.Keyword keyword2) => token != null && identical(token.type, sc.TokenType.KEYWORD) && identical(((token as sc.KeywordToken)).keyword, keyword2);
+  bool matches(sc.Token token, sc.Keyword keyword) => token != null && identical(token.type, sc.TokenType.KEYWORD) && identical(((token as sc.KeywordToken)).keyword, keyword);
 
   /**
    * Sets the visible source range for formal parameter.
    */
   void setParameterVisibleRange(FormalParameter node, ParameterElementImpl element) {
     FunctionBody body = getFunctionBody(node);
     if (body != null) {
       element.setVisibleRange(body.offset, body.length);
     }
   }
@@ skipping 403 matching lines @@
 
   /**
    * Build the HTML element for the given source.
    *
    * @param source the source describing the compilation unit
    * @param modificationStamp the modification time of the source for which an element is being
    *          built
    * @param unit the AST structure representing the HTML
    * @throws AnalysisException if the analysis could not be performed
    */
-  HtmlElementImpl buildHtmlElement2(Source source2, int modificationStamp2, ht.HtmlUnit unit) {
-    this._modificationStamp = modificationStamp2;
-    _lineInfo = _context.computeLineInfo(source2);
-    HtmlElementImpl result = new HtmlElementImpl(_context, source2.shortName);
-    result.source = source2;
+  HtmlElementImpl buildHtmlElement2(Source source, int modificationStamp, ht.HtmlUnit unit) {
+    this._modificationStamp = modificationStamp;
+    _lineInfo = _context.computeLineInfo(source);
+    HtmlElementImpl result = new HtmlElementImpl(_context, source.shortName);
+    result.source = source;
     _htmlElement = result;
     unit.accept(this);
     _htmlElement = null;
     unit.element = result;
     return result;
   }
   Object visitHtmlUnit(ht.HtmlUnit node) {
     _parentNodes = new List<ht.XmlTagNode>();
     _scripts = new List<HtmlScriptElement>();
     try {
@@ skipping 154 matching lines @@
  * Instances of the class `BestPracticesVerifier` traverse an AST structure looking for
  * violations of Dart best practices.
  *
  * @coverage dart.engine.resolver
  */
 class BestPracticesVerifier extends RecursiveASTVisitor<Object> {
   static String _GETTER = "getter";
   static String _HASHCODE_GETTER_NAME = "hashCode";
   static String _METHOD = "method";
   static String _NULL_TYPE_NAME = "Null";
-  static String _OBJECT_TYPE_NAME = "Object";
   static String _SETTER = "setter";
   static String _TO_INT_METHOD_NAME = "toInt";
 
   /**
    * Given a parenthesized expression, this returns the parent (or recursively grand-parent) of the
    * expression that is a parenthesized expression, but whose parent is not a parenthesized
    * expression.
    *
    * For example given the code `(((e)))`: `(e) -> (((e)))`.
    *
@@ skipping 77 matching lines @@
       if (node.notOperator == null) {
         _errorReporter.reportError2(HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node, []);
       } else {
         _errorReporter.reportError2(HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node, []);
       }
       return true;
     }
     Element rhsElement = rhsType.element;
     LibraryElement libraryElement = rhsElement != null ? rhsElement.library : null;
     if (libraryElement != null && libraryElement.isDartCore) {
-      if ((rhsType.isObject && rhsNameStr == _OBJECT_TYPE_NAME) || (expression is NullLiteral && rhsNameStr == _NULL_TYPE_NAME)) {
+      if (rhsType.isObject || (expression is NullLiteral && rhsNameStr == _NULL_TYPE_NAME)) {
         if (node.notOperator == null) {
           _errorReporter.reportError2(HintCode.UNNECESSARY_TYPE_CHECK_TRUE, node, []);
         } else {
           _errorReporter.reportError2(HintCode.UNNECESSARY_TYPE_CHECK_FALSE, node, []);
         }
         return true;
       } else if (rhsNameStr == _NULL_TYPE_NAME) {
         if (node.notOperator == null) {
           _errorReporter.reportError2(HintCode.TYPE_CHECK_IS_NULL, node, []);
         } else {
@@ skipping 662 matching lines @@
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     SimpleIdentifier prefixIdentifier = node.prefix;
     Element element = prefixIdentifier.staticElement;
     if (element is PrefixElement) {
       _unusedImports.remove(_prefixElementMap[element]);
       return null;
     }
     return visitIdentifier(element, prefixIdentifier.name);
   }
   Object visitSimpleIdentifier(SimpleIdentifier node) => visitIdentifier(node.staticElement, node.name);
-  void set inDefiningCompilationUnit(bool inDefiningCompilationUnit2) {
-    this._inDefiningCompilationUnit = inDefiningCompilationUnit2;
+  void set inDefiningCompilationUnit(bool inDefiningCompilationUnit) {
+    this._inDefiningCompilationUnit = inDefiningCompilationUnit;
   }
 
   /**
    * Recursively add any exported library elements into the [libraryMap].
    */
   void addAdditionalLibrariesForExports(LibraryElement library, ImportDirective importDirective, List<LibraryElement> exportPath) {
     if (exportPath.contains(library)) {
       return;
     }
     exportPath.add(library);
@@ skipping 278 matching lines @@
    */
   ParameterElement _enclosingParameter;
 
   /**
    * Resolve the declarations within the given compilation unit to the elements rooted at the given
    * element.
    *
    * @param unit the compilation unit to be resolved
    * @param element the root of the element model used to resolve the AST nodes
    */
-  void resolve(CompilationUnit unit, CompilationUnitElement element2) {
-    _enclosingUnit = element2;
-    unit.element = element2;
+  void resolve(CompilationUnit unit, CompilationUnitElement element) {
+    _enclosingUnit = element;
+    unit.element = element;
     unit.accept(this);
   }
   Object visitCatchClause(CatchClause node) {
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     if (exceptionParameter != null) {
       List<LocalVariableElement> localVariables = _enclosingExecutable.localVariables;
       find3(localVariables, exceptionParameter);
       SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
       if (stackTraceParameter != null) {
         find3(localVariables, stackTraceParameter);
@@ skipping 337 matching lines @@
 
   /**
    * Return the export element from the given array whose library has the given source, or
    * `null` if there is no such export.
    *
    * @param exports the export elements being searched
    * @param source the source of the library associated with the export element to being searched
    *          for
    * @return the export element whose library has the given source
    */
-  ExportElement find5(List<ExportElement> exports, Source source2) {
+  ExportElement find5(List<ExportElement> exports, Source source) {
     for (ExportElement export in exports) {
-      if (export.exportedLibrary.source == source2) {
+      if (export.exportedLibrary.source == source) {
         return export;
       }
     }
     return null;
   }
 
   /**
    * Return the import element from the given array whose library has the given source and that has
    * the given prefix, or `null` if there is no such import.
    *
    * @param imports the import elements being searched
    * @param source the source of the library associated with the import element to being searched
    *          for
    * @param prefix the prefix with which the library was imported
    * @return the import element whose library has the given source and prefix
    */
-  ImportElement find6(List<ImportElement> imports, Source source2, SimpleIdentifier prefix2) {
+  ImportElement find6(List<ImportElement> imports, Source source, SimpleIdentifier prefix) {
     for (ImportElement element in imports) {
-      if (element.importedLibrary.source == source2) {
+      if (element.importedLibrary.source == source) {
         PrefixElement prefixElement = element.prefix;
-        if (prefix2 == null) {
+        if (prefix == null) {
           if (prefixElement == null) {
             return element;
           }
         } else {
-          if (prefixElement != null && prefix2.name == prefixElement.displayName) {
+          if (prefixElement != null && prefix.name == prefixElement.displayName) {
             return element;
           }
         }
       }
     }
     return null;
   }
 
   /**
    * Search the most closely enclosing list of parameters for a parameter with the given name.
@@ skipping 960 matching lines @@
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
    * the list of parameters that correspond to the list of arguments. Return the parameters that
    * correspond to the arguments, or `null` if no correspondence could be computed.
    *
    * @param argumentList the list of arguments being passed to the element
    * @param executableElement the element that will be invoked with the arguments
    * @return the parameters that correspond to the arguments
    */
-  List<ParameterElement> computeCorrespondingParameters(ArgumentList argumentList, Element element2) {
-    if (element2 is PropertyAccessorElement) {
-      FunctionType getterType = ((element2 as PropertyAccessorElement)).type;
+  List<ParameterElement> computeCorrespondingParameters(ArgumentList argumentList, Element element) {
+    if (element is PropertyAccessorElement) {
+      FunctionType getterType = ((element as PropertyAccessorElement)).type;
       if (getterType != null) {
         Type2 getterReturnType = getterType.returnType;
         if (getterReturnType is InterfaceType) {
           MethodElement callMethod = ((getterReturnType as InterfaceType)).lookUpMethod(CALL_METHOD_NAME, _resolver.definingLibrary);
           if (callMethod != null) {
             return resolveArgumentsToParameters(false, argumentList, callMethod);
           }
         } else if (getterReturnType is FunctionType) {
           Element functionElement = ((getterReturnType as FunctionType)).element;
           if (functionElement is ExecutableElement) {
             return resolveArgumentsToParameters(false, argumentList, functionElement as ExecutableElement);
           }
         }
       }
-    } else if (element2 is ExecutableElement) {
-      return resolveArgumentsToParameters(false, argumentList, element2 as ExecutableElement);
-    } else if (element2 is VariableElement) {
-      VariableElement variable = element2 as VariableElement;
+    } else if (element is ExecutableElement) {
+      return resolveArgumentsToParameters(false, argumentList, element as ExecutableElement);
+    } else if (element is VariableElement) {
+      VariableElement variable = element as VariableElement;
       Type2 type = variable.type;
       if (type is FunctionType) {
         FunctionType functionType = type as FunctionType;
         List<ParameterElement> parameters = functionType.parameters;
         return resolveArgumentsToParameters2(false, argumentList, parameters);
       } else if (type is InterfaceType) {
         MethodElement callMethod = ((type as InterfaceType)).lookUpMethod(CALL_METHOD_NAME, _resolver.definingLibrary);
         if (callMethod != null) {
           List<ParameterElement> parameters = callMethod.parameters;
           return resolveArgumentsToParameters2(false, argumentList, parameters);
@@ skipping 556 matching lines @@
 
   /**
    * Validates that the given [Element] is the constant variable; or resolves it as a
    * constructor invocation.
    *
    * @param annotation the [Annotation] to resolve
    * @param element the current known [Element] of the annotation, or [ClassElement]
    * @param nameNode the name of the invoked constructor, may be `null` if unnamed constructor
    *          or not a constructor invocation
    */
-  void resolveAnnotationElement(Annotation annotation, Element element2, SimpleIdentifier nameNode) {
-    if (element2 is PropertyAccessorElement) {
-      PropertyAccessorElement accessorElement = element2 as PropertyAccessorElement;
+  void resolveAnnotationElement(Annotation annotation, Element element, SimpleIdentifier nameNode) {
+    if (element is PropertyAccessorElement) {
+      PropertyAccessorElement accessorElement = element as PropertyAccessorElement;
       if (!accessorElement.isSynthetic) {
         _resolver.reportError5(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
         return;
       }
       VariableElement variableElement = accessorElement.variable;
       if (!variableElement.isConst) {
         _resolver.reportError5(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
       }
       return;
     }
-    if (element2 is ClassElement) {
+    if (element is ClassElement) {
       if (nameNode == null) {
         nameNode = annotation.constructorName;
       }
       String name = nameNode != null ? nameNode.name : null;
       ConstructorElement constructor;
       {
-        InterfaceType interfaceType = new InterfaceTypeImpl.con1(element2 as ClassElement);
+        InterfaceType interfaceType = new InterfaceTypeImpl.con1(element as ClassElement);
         LibraryElement definingLibrary = _resolver.definingLibrary;
         constructor = interfaceType.lookUpConstructor(name, definingLibrary);
       }
       if (constructor == null) {
         _resolver.reportError5(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
         return;
       }
       annotation.element = constructor;
       if (nameNode != null) {
         nameNode.staticElement = constructor;
       }
       resolveAnnotationConstructorInvocationArguments(annotation, constructor);
       return;
     }
-    if (element2 != null) {
+    if (element != null) {
       _resolver.reportError5(CompileTimeErrorCode.INVALID_ANNOTATION, annotation, []);
     }
   }
 
   /**
    * Given a list of arguments and the element that will be invoked using those argument, compute
    * the list of parameters that correspond to the list of arguments. Return the parameters that
    * correspond to the arguments, or `null` if no correspondence could be computed.
    *
    * @param reportError if `true` then compile-time error should be reported; if `false`
@@ skipping 507 matching lines @@
       return null;
     }
     return substituteTypeArgumentsInMemberFromInheritance(iteratorMember.type, memberName, interfaceType);
   }
 
   /**
    * Set the new library element context.
    *
    * @param library the new library element
    */
-  void set libraryElement(LibraryElement library2) {
-    this._library = library2;
+  void set libraryElement(LibraryElement library) {
+    this._library = library;
   }
 
   /**
    * This method takes some inherited [FunctionType], and resolves all the parameterized types
    * in the function type, dependent on the class in which it is being overridden.
    *
    * @param baseFunctionType the function type that is being overridden
    * @param memberName the name of the member, this is used to lookup the inheritance path of the
    *          override
    * @param definingType the type that is overriding the member
@@ skipping 606 matching lines @@
    */
   void setDefiningCompilationUnit(int modificationStamp, CompilationUnit unit) {
     _astMap[librarySource] = new ResolvableCompilationUnit(modificationStamp, unit);
   }
 
   /**
    * Set the libraries that are exported by this library to be those in the given array.
    *
    * @param exportedLibraries the libraries that are exported by this library
    */
-  void set exportedLibraries(List<Library> exportedLibraries2) {
-    this.exports = exportedLibraries2;
+  void set exportedLibraries(List<Library> exportedLibraries) {
+    this.exports = exportedLibraries;
   }
 
   /**
    * Set the libraries that are imported into this library to be those in the given array.
    *
    * @param importedLibraries the libraries that are imported into this library
    */
-  void set importedLibraries(List<Library> importedLibraries2) {
-    this.imports = importedLibraries2;
+  void set importedLibraries(List<Library> importedLibraries) {
+    this.imports = importedLibraries;
   }
 
   /**
    * Set the library element representing this library to the given library element.
    *
    * @param libraryElement the library element representing this library
    */
-  void set libraryElement(LibraryElementImpl libraryElement2) {
-    this._libraryElement = libraryElement2;
+  void set libraryElement(LibraryElementImpl libraryElement) {
+    this._libraryElement = libraryElement;
     if (_inheritanceManager != null) {
-      _inheritanceManager.libraryElement = libraryElement2;
+      _inheritanceManager.libraryElement = libraryElement;
     }
   }
   String toString() => librarySource.shortName;
 }
 /**
  * Instances of the class `LibraryElementBuilder` build an element model for a single library.
  *
  * @coverage dart.engine.resolver
  */
 class LibraryElementBuilder {
@@ skipping 868 matching lines @@
    * The name of the meta library name, from the meta pub package.
    */
   static String _META_LIBRARY_NAME = "meta";
 
   /**
    * Return `true` if the given element represents a class that has the proxy annotation.
    *
    * @param element the class being tested
    * @return `true` if the given element represents a class that has the proxy annotation
    */
-  static bool classHasProxyAnnotation(Element element2) {
-    if (element2 is ClassElement) {
-      ClassElement classElement = element2 as ClassElement;
+  static bool classHasProxyAnnotation(Element element) {
+    if (element is ClassElement) {
+      ClassElement classElement = element as ClassElement;
       List<ElementAnnotation> annotations = classElement.metadata;
       for (ElementAnnotation annotation in annotations) {
         Element elementAnnotation = annotation.element;
         if (elementAnnotation != null) {
           LibraryElement lib = elementAnnotation.library;
           if (elementAnnotation.name == _PROXY_ANNOTATION_NAME && lib != null && lib.name == _META_LIBRARY_NAME) {
             return true;
           }
         }
       }
@@ skipping 740 matching lines @@
     }
   }
 
   /**
    * Return `true` if the given expression terminates abruptly (that is, if any expression
    * following the given expression will not be reached).
    *
    * @param expression the expression being tested
    * @return `true` if the given expression terminates abruptly
    */
-  bool isAbruptTermination(Expression expression2) {
-    while (expression2 is ParenthesizedExpression) {
-      expression2 = ((expression2 as ParenthesizedExpression)).expression;
+  bool isAbruptTermination(Expression expression) {
+    while (expression is ParenthesizedExpression) {
+      expression = ((expression as ParenthesizedExpression)).expression;
     }
-    return expression2 is ThrowExpression || expression2 is RethrowExpression;
+    return expression is ThrowExpression || expression is RethrowExpression;
   }
 
   /**
    * Return `true` if the given statement terminates abruptly (that is, if any statement
    * following the given statement will not be reached).
    *
    * @param statement the statement being tested
    * @return `true` if the given statement terminates abruptly
    */
   bool isAbruptTermination2(Statement statement) {
@@ skipping 267 matching lines @@
     try {
       nameScope = new EnclosedScope(nameScope);
       labelScope = new LabelScope.con1(outerLabelScope, false, false);
       visitForEachStatementInScope(node);
     } finally {
       labelScope = outerLabelScope;
       nameScope = outerNameScope;
     }
     return null;
   }
+  Object visitFormalParameterList(FormalParameterList node) {
+    super.visitFormalParameterList(node);
+    if (nameScope is FunctionScope) {
+      ((nameScope as FunctionScope)).defineParameters();
+    }
+    if (nameScope is FunctionTypeScope) {
+      ((nameScope as FunctionTypeScope)).defineParameters();
+    }
+    return null;
+  }
   Object visitForStatement(ForStatement node) {
     Scope outerNameScope = nameScope;
     LabelScope outerLabelScope = labelScope;
     try {
       nameScope = new EnclosedScope(nameScope);
       labelScope = new LabelScope.con1(outerLabelScope, false, false);
       visitForStatementInScope(node);
     } finally {
       labelScope = outerLabelScope;
       nameScope = outerNameScope;
@@ skipping 389 matching lines @@
     _typeProvider = resolver.typeProvider;
     _dynamicType = _typeProvider.dynamicType;
     _overrideManager = resolver.overrideManager;
   }
 
   /**
    * Set the type of the class being analyzed to the given type.
    *
    * @param thisType the type representing the class containing the nodes being analyzed
    */
-  void set thisType(InterfaceType thisType2) {
-    this._thisType = thisType2;
+  void set thisType(InterfaceType thisType) {
+    this._thisType = thisType;
   }
 
   /**
    * The Dart Language Specification, 12.5: <blockquote>The static type of a string literal is
    * `String`.</blockquote>
    */
   Object visitAdjacentStrings(AdjacentStrings node) {
     recordStaticType(node, _typeProvider.stringType);
     return null;
   }
@@ skipping 2108 matching lines @@
   Object visitSuperExpression(SuperExpression node) {
     _hasReferenceToSuper = true;
     return super.visitSuperExpression(node);
   }
   Object visitTypeName(TypeName node) {
     super.visitTypeName(node);
     Identifier typeName = node.name;
     TypeArgumentList argumentList = node.typeArguments;
     Element element = nameScope.lookup(typeName, definingLibrary);
     if (element == null) {
-      if (typeName.name == _dynamicType.name) {
-        setElement(typeName, _dynamicType.element);
+      if (typeName.name == this._dynamicType.name) {
+        setElement(typeName, this._dynamicType.element);
         if (argumentList != null) {
         }
-        typeName.staticType = _dynamicType;
-        node.type = _dynamicType;
+        typeName.staticType = this._dynamicType;
+        node.type = this._dynamicType;
         return null;
       }
       VoidTypeImpl voidType = VoidTypeImpl.instance;
       if (typeName.name == voidType.name) {
         if (argumentList != null) {
         }
         typeName.staticType = voidType;
         node.type = voidType;
         return null;
       }
@@ skipping 55 matching lines @@
         reportError5(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, typeName, [typeName.name]);
       } else {
         reportError5(StaticWarningCode.UNDEFINED_CLASS, typeName, [typeName.name]);
       }
       elementValid = false;
     }
     if (!elementValid) {
       if (element is MultiplyDefinedElement) {
         setElement(typeName, element);
       } else {
-        setElement(typeName, _dynamicType.element);
+        setElement(typeName, this._dynamicType.element);
       }
-      typeName.staticType = _dynamicType;
-      node.type = _dynamicType;
+      typeName.staticType = this._dynamicType;
+      node.type = this._dynamicType;
       return null;
     }
     Type2 type = null;
     if (element is ClassElement) {
       setElement(typeName, element);
       type = ((element as ClassElement)).type;
     } else if (element is FunctionTypeAliasElement) {
       setElement(typeName, element);
       type = ((element as FunctionTypeAliasElement)).type;
     } else if (element is TypeParameterElement) {
@@ skipping 21 matching lines @@
       } else {
         ASTNode parent = typeName.parent;
         while (parent is TypeName) {
           parent = parent.parent;
         }
         if (parent is ExtendsClause || parent is ImplementsClause || parent is WithClause || parent is ClassTypeAlias) {
         } else {
           reportError5(StaticWarningCode.NOT_A_TYPE, typeName, [typeName.name]);
         }
       }
-      setElement(typeName, _dynamicType.element);
-      typeName.staticType = _dynamicType;
-      node.type = _dynamicType;
+      setElement(typeName, this._dynamicType.element);
+      typeName.staticType = this._dynamicType;
+      node.type = this._dynamicType;
       return null;
     }
     if (argumentList != null) {
       NodeList<TypeName> arguments = argumentList.arguments;
       int argumentCount = arguments.length;
       List<Type2> parameters = getTypeArguments(type);
       int parameterCount = parameters.length;
       int count = Math.min(argumentCount, parameterCount);
       List<Type2> typeArguments = new List<Type2>();
       for (int i = 0; i < count; i++) {
         Type2 argumentType = getType3(arguments[i]);
         if (argumentType != null) {
           typeArguments.add(argumentType);
         }
       }
       if (argumentCount != parameterCount) {
         reportError5(getInvalidTypeParametersErrorCode(node), node, [typeName.name, parameterCount, argumentCount]);
       }
       argumentCount = typeArguments.length;
       if (argumentCount < parameterCount) {
         for (int i = argumentCount; i < parameterCount; i++) {
-          typeArguments.add(_dynamicType);
+          typeArguments.add(this._dynamicType);
         }
       }
       if (type is InterfaceTypeImpl) {
         InterfaceTypeImpl interfaceType = type as InterfaceTypeImpl;
         type = interfaceType.substitute4(new List.from(typeArguments));
       } else if (type is FunctionTypeImpl) {
         FunctionTypeImpl functionType = type as FunctionTypeImpl;
         type = functionType.substitute3(new List.from(typeArguments));
       } else {
       }
@@ skipping 399 matching lines @@
   }
 
   /**
    * Given a parameter element, create a function type based on the given return type and parameter
    * list and associate the created type with the element.
    *
    * @param element the parameter element whose type is to be set
    * @param returnType the (possibly `null`) return type of the function
    * @param parameterList the list of parameters to the function
    */
-  void setFunctionTypedParameterType(ParameterElementImpl element, TypeName returnType2, FormalParameterList parameterList) {
+  void setFunctionTypedParameterType(ParameterElementImpl element, TypeName returnType, FormalParameterList parameterList) {
     List<ParameterElement> parameters = getElements(parameterList);
     FunctionTypeAliasElementImpl aliasElement = new FunctionTypeAliasElementImpl(null);
     aliasElement.synthetic = true;
     aliasElement.shareParameters(parameters);
-    aliasElement.returnType = computeReturnType(returnType2);
+    aliasElement.returnType = computeReturnType(returnType);
     FunctionTypeImpl type = new FunctionTypeImpl.con2(aliasElement);
     ClassElement definingClass = element.getAncestor(ClassElement);
     if (definingClass != null) {
       aliasElement.shareTypeParameters(definingClass.typeParameters);
       type.typeArguments = definingClass.type.typeArguments;
     } else {
       FunctionTypeAliasElement alias = element.getAncestor(FunctionTypeAliasElement);
       while (alias != null && alias.isSynthetic) {
         alias = alias.getAncestor(FunctionTypeAliasElement);
       }
@@ skipping 116 matching lines @@
     }
     return enclosingScope.lookup3(identifier, name, referencingLibrary);
   }
 }
 /**
  * Instances of the class `FunctionScope` implement the scope defined by a function.
  *
  * @coverage dart.engine.resolver
  */
 class FunctionScope extends EnclosedScope {
+  ExecutableElement _functionElement;
+  bool _parametersDefined = false;
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    * @param functionElement the element representing the type represented by this scope
    */
   FunctionScope(Scope enclosingScope, ExecutableElement functionElement) : super(new EnclosedScope(enclosingScope)) {
-    defineParameters(functionElement);
+    this._functionElement = functionElement;
   }
 
   /**
    * Define the parameters for the given function in the scope that encloses this function.
-   *
-   * @param functionElement the element representing the function represented by this scope
    */
-  void defineParameters(ExecutableElement functionElement) {
+  void defineParameters() {
+    if (_parametersDefined) {
+      return;
+    }
+    _parametersDefined = true;
     Scope parameterScope = enclosingScope;
-    if (functionElement.enclosingElement is ExecutableElement) {
-      String name = functionElement.name;
+    if (_functionElement.enclosingElement is ExecutableElement) {
+      String name = _functionElement.name;
       if (name != null && !name.isEmpty) {
-        parameterScope.define(functionElement);
+        parameterScope.define(_functionElement);
       }
     }
-    for (ParameterElement parameter in functionElement.parameters) {
+    for (ParameterElement parameter in _functionElement.parameters) {
       if (!parameter.isInitializingFormal) {
         parameterScope.define(parameter);
       }
     }
   }
 }
 /**
  * Instances of the class `FunctionTypeScope` implement the scope defined by a function type
  * alias.
  *
  * @coverage dart.engine.resolver
  */
 class FunctionTypeScope extends EnclosedScope {
+  FunctionTypeAliasElement _typeElement;
+  bool _parametersDefined = false;
 
   /**
    * Initialize a newly created scope enclosed within another scope.
    *
    * @param enclosingScope the scope in which this scope is lexically enclosed
    * @param typeElement the element representing the type alias represented by this scope
    */
   FunctionTypeScope(Scope enclosingScope, FunctionTypeAliasElement typeElement) : super(new EnclosedScope(enclosingScope)) {
-    defineTypeParameters(typeElement);
-    defineParameters(typeElement);
+    this._typeElement = typeElement;
+    defineTypeParameters();
   }
 
   /**
    * Define the parameters for the function type alias.
    *
    * @param typeElement the element representing the type represented by this scope
    */
-  void defineParameters(FunctionTypeAliasElement typeElement) {
-    for (ParameterElement parameter in typeElement.parameters) {
+  void defineParameters() {
+    if (_parametersDefined) {
+      return;
+    }
+    _parametersDefined = true;
+    for (ParameterElement parameter in _typeElement.parameters) {
       define(parameter);
     }
   }
 
   /**
    * Define the type parameters for the function type alias.
    *
    * @param typeElement the element representing the type represented by this scope
    */
-  void defineTypeParameters(FunctionTypeAliasElement typeElement) {
+  void defineTypeParameters() {
     Scope typeParameterScope = enclosingScope;
-    for (TypeParameterElement typeParameter in typeElement.typeParameters) {
+    for (TypeParameterElement typeParameter in _typeElement.typeParameters) {
       typeParameterScope.define(typeParameter);
     }
   }
 }
 /**
  * Instances of the class `LabelScope` represent a scope in which a single label is defined.
  *
  * @coverage dart.engine.resolver
  */
 class LabelScope {
@@ skipping 140 matching lines @@
       String libName1 = "", libName2 = "";
       List<Element> conflictingMembers = ((foundElement as MultiplyDefinedElementImpl)).conflictingElements;
       LibraryElement enclosingLibrary = conflictingMembers[0].getAncestor(LibraryElement);
       if (enclosingLibrary != null) {
         libName1 = enclosingLibrary.definingCompilationUnit.displayName;
       }
       enclosingLibrary = conflictingMembers[1].getAncestor(LibraryElement);
       if (enclosingLibrary != null) {
         libName2 = enclosingLibrary.definingCompilationUnit.displayName;
       }
-      _errorListener.onError(new AnalysisError.con2(source2, identifier.offset, identifier.length, StaticWarningCode.AMBIGUOUS_IMPORT, [foundEltName, libName1, libName2]));
+      _errorListener.onError(new AnalysisError.con2(source, identifier.offset, identifier.length, StaticWarningCode.AMBIGUOUS_IMPORT, [foundEltName, libName1, libName2]));
       return foundElement;
     }
     if (foundElement != null) {
       defineWithoutChecking2(name, foundElement);
     }
     return foundElement;
   }
 
   /**
    * Create all of the namespaces associated with the libraries imported into this library. The
@@ skipping 57 matching lines @@
   }
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     if (existing is PrefixElement) {
       int offset = duplicate.nameOffset;
       if (duplicate is PropertyAccessorElement) {
         PropertyAccessorElement accessor = duplicate as PropertyAccessorElement;
         if (accessor.isSynthetic) {
           offset = accessor.variable.nameOffset;
         }
       }
-      return new AnalysisError.con2(source2, offset, duplicate.displayName.length, CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER, [existing.displayName]);
+      return new AnalysisError.con2(source, offset, duplicate.displayName.length, CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER, [existing.displayName]);
     }
     return super.getErrorForDuplicate(existing, duplicate);
   }
 
   /**
    * Add to this scope all of the public top-level names that are defined in the given compilation
    * unit.
    *
    * @param compilationUnit the compilation unit defining the top-level names to be added to this
    *          scope
@@ skipping 149 matching lines @@
       definedNames[entry.getKey()] = entry.getValue();
     }
   }
 
   /**
    * Add all of the names in the given namespace to the given mapping table.
    *
    * @param definedNames the mapping table to which the names in the given namespace are to be added
    * @param namespace the namespace containing the names to be added to this namespace
    */
-  void addAll2(Map<String, Element> definedNames2, Namespace namespace) {
+  void addAll2(Map<String, Element> definedNames, Namespace namespace) {
     if (namespace != null) {
-      addAll(definedNames2, namespace.definedNames);
+      addAll(definedNames, namespace.definedNames);
     }
   }
 
   /**
    * Add the given element to the given mapping table if it has a publicly visible name.
    *
    * @param definedNames the mapping table to which the public name is to be added
    * @param element the element to be added
    */
   void addIfPublic(Map<String, Element> definedNames, Element element) {
@@ skipping 227 matching lines @@
    * Return the error code to be used when reporting that a name being defined locally conflicts
    * with another element of the same name in the local scope.
    *
    * @param existing the first element to be declared with the conflicting name
    * @param duplicate another element declared with the conflicting name
    * @return the error code used to report duplicate names within a scope
    */
   AnalysisError getErrorForDuplicate(Element existing, Element duplicate) {
     Source source = duplicate.source;
     if (source == null) {
-      source = source2;
+      source = this.source;
     }
     return new AnalysisError.con2(source, duplicate.nameOffset, duplicate.displayName.length, CompileTimeErrorCode.DUPLICATE_DEFINITION, [existing.displayName]);
   }
 
   /**
    * Return the listener that is to be informed when an error is encountered.
    *
    * @return the listener that is to be informed when an error is encountered
    */
   AnalysisErrorListener get errorListener;
 
   /**
    * Return the source object representing the compilation unit with which errors related to this
    * scope should be associated.
    *
    * @return the source object with which errors should be associated
    */
-  Source get source2 => definingLibrary.definingCompilationUnit.source;
+  Source get source => definingLibrary.definingCompilationUnit.source;
 
   /**
    * Return the element with which the given name is associated, or `null` if the name is not
    * defined within this scope. This method only returns elements that are directly defined within
    * this scope, not elements that are defined in an enclosing scope.
    *
    * @param name the name associated with the element to be returned
    * @param referencingLibrary the library that contains the reference to the name, used to
    *          implement library-level privacy
    * @return the element with which the given name is associated
@@ skipping 184 matching lines @@
     return null;
   }
 
   /**
    * If the given result represents one or more errors, report those errors. Except for special
    * cases, use the given error code rather than the one reported in the error.
    *
    * @param result the result containing any errors that need to be reported
    * @param errorCode the error code to be used if the result represents an error
    */
-  void reportErrors(EvaluationResultImpl result, ErrorCode errorCode2) {
+  void reportErrors(EvaluationResultImpl result, ErrorCode errorCode) {
     if (result is ErrorResult) {
       for (ErrorResult_ErrorData data in ((result as ErrorResult)).errorData) {
         ErrorCode dataErrorCode = data.errorCode;
         if (identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_INT) || identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM)) {
           _errorReporter.reportError2(dataErrorCode, data.node, []);
         } else {
-          _errorReporter.reportError2(errorCode2, data.node, []);
+          _errorReporter.reportError2(errorCode, data.node, []);
         }
       }
     }
   }
 
   /**
    * Validate that the given expression is a compile time constant. Return the value of the compile
    * time constant, or `null` if the expression is not a compile time constant.
    *
    * @param expression the expression to be validated
@@ skipping 36 matching lines @@
     }
     validateConstantArguments(argumentList);
   }
 
   /**
    * Validate that the default value associated with each of the parameters in the given list is a
    * compile time constant.
    *
    * @param parameters the list of parameters to be validated
    */
-  void validateDefaultValues(FormalParameterList parameters2) {
-    if (parameters2 == null) {
+  void validateDefaultValues(FormalParameterList parameters) {
+    if (parameters == null) {
       return;
     }
-    for (FormalParameter parameter in parameters2.parameters) {
+    for (FormalParameter parameter in parameters.parameters) {
       if (parameter is DefaultFormalParameter) {
         DefaultFormalParameter defaultParameter = parameter as DefaultFormalParameter;
         Expression defaultValue = defaultParameter.defaultValue;
         if (defaultValue != null) {
           EvaluationResultImpl result = validate(defaultValue, CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE);
           VariableElementImpl element = parameter.element as VariableElementImpl;
           element.evaluationResult = result;
         }
       }
     }
@@ skipping 864 matching lines @@
    * @see CompileTimeErrorCode#INVALID_OVERRIDE_POSITIONAL
    * @see CompileTimeErrorCode#INVALID_OVERRIDE_NAMED
    * @see StaticWarningCode#INVALID_GETTER_OVERRIDE_RETURN_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_RETURN_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_OPTIONAL_PARAM_TYPE
    * @see StaticWarningCode#INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE
    * @see StaticWarningCode#INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES
    */
-  bool checkForAllInvalidOverrideErrorCodes(ExecutableElement executableElement, List<ParameterElement> parameters2, List<ASTNode> parameterLocations, SimpleIdentifier errorNameTarget) {
+  bool checkForAllInvalidOverrideErrorCodes(ExecutableElement executableElement, List<ParameterElement> parameters, List<ASTNode> parameterLocations, SimpleIdentifier errorNameTarget) {
     String executableElementName = executableElement.name;
     ExecutableElement overriddenExecutable = _inheritanceManager.lookupInheritance(_enclosingClass, executableElementName);
     bool isGetter = false;
     bool isSetter = false;
     if (executableElement is PropertyAccessorElement) {
       PropertyAccessorElement accessorElement = executableElement as PropertyAccessorElement;
       isGetter = accessorElement.isGetter;
       isSetter = accessorElement.isSetter;
     }
     if (overriddenExecutable == null) {
@@ skipping 99 matching lines @@
     JavaIterator<MapEntry<String, Type2>> overriddenNamedPTIterator = new JavaIterator(getMapEntrySet(overriddenNamedPT));
     while (overriddenNamedPTIterator.hasNext) {
       MapEntry<String, Type2> overriddenNamedPTEntry = overriddenNamedPTIterator.next();
       Type2 overridingType = overridingNamedPT[overriddenNamedPTEntry.getKey()];
       if (overridingType == null) {
         continue;
       }
       if (!overriddenNamedPTEntry.getValue().isAssignableTo(overridingType)) {
         ParameterElement parameterToSelect = null;
         ASTNode parameterLocationToSelect = null;
-        for (int i = 0; i < parameters2.length; i++) {
-          ParameterElement parameter = parameters2[i];
+        for (int i = 0; i < parameters.length; i++) {
+          ParameterElement parameter = parameters[i];
           if (identical(parameter.parameterKind, ParameterKind.NAMED) && overriddenNamedPTEntry.getKey() == parameter.name) {
             parameterToSelect = parameter;
             parameterLocationToSelect = parameterLocations[i];
             break;
           }
         }
         if (parameterToSelect != null) {
           _errorReporter.reportError2(StaticWarningCode.INVALID_METHOD_OVERRIDE_NAMED_PARAM_TYPE, parameterLocationToSelect, [
               overridingType.displayName,
               overriddenNamedPTEntry.getValue().displayName,
               overriddenExecutable.enclosingElement.displayName]);
           return true;
         }
       }
     }
     bool foundError = false;
     List<ASTNode> formalParameters = new List<ASTNode>();
     List<ParameterElementImpl> parameterElts = new List<ParameterElementImpl>();
     List<ParameterElementImpl> overriddenParameterElts = new List<ParameterElementImpl>();
     List<ParameterElement> overriddenPEs = overriddenExecutable.parameters;
-    for (int i = 0; i < parameters2.length; i++) {
-      ParameterElement parameter = parameters2[i];
+    for (int i = 0; i < parameters.length; i++) {
+      ParameterElement parameter = parameters[i];
       if (parameter.parameterKind.isOptional) {
         formalParameters.add(parameterLocations[i]);
         parameterElts.add(parameter as ParameterElementImpl);
       }
     }
     for (ParameterElement parameterElt in overriddenPEs) {
       if (parameterElt.parameterKind.isOptional) {
         if (parameterElt is ParameterElementImpl) {
           overriddenParameterElts.add(parameterElt as ParameterElementImpl);
         } else if (parameterElt is ParameterMember) {
@@ skipping 531 matching lines @@
 
   /**
    * This verifies that the passed switch statement does not have a case expression with the
    * operator '==' overridden.
    *
    * @param node the switch statement to evaluate
    * @param type the common type of all 'case' expressions
    * @return `true` if and only if an error code is generated on the passed node
    * @see CompileTimeErrorCode#CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS
    */
-  bool checkForCaseExpressionTypeImplementsEquals(SwitchStatement node, Type2 type2) {
-    if (type2 == null || type2 == _typeProvider.intType || type2 == _typeProvider.stringType) {
+  bool checkForCaseExpressionTypeImplementsEquals(SwitchStatement node, Type2 type) {
+    if (type == null || type == _typeProvider.intType || type == _typeProvider.stringType) {
       return false;
     }
-    Element element = type2.element;
+    Element element = type.element;
     if (element is! ClassElement) {
       return false;
     }
     ClassElement classElement = element as ClassElement;
     MethodElement method = classElement.lookUpMethod("==", _currentLibrary);
     if (method == null || method.enclosingElement.type.isObject) {
       return false;
     }
     _errorReporter.reportError4(CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS, node.keyword, [element.displayName]);
     return true;
@@ skipping 983 matching lines @@
 
   /**
    * This checks that if the given "target" is not a type reference then the "name" is reference to
    * an instance member.
    *
    * @param target the target of the name access to evaluate
    * @param name the accessed name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#INSTANCE_ACCESS_TO_STATIC_MEMBER
    */
-  bool checkForInstanceAccessToStaticMember(Expression target, SimpleIdentifier name2) {
+  bool checkForInstanceAccessToStaticMember(Expression target, SimpleIdentifier name) {
     if (target == null) {
       return false;
     }
     if (_isInComment) {
       return false;
     }
-    Element element = name2.staticElement;
+    Element element = name.staticElement;
     if (element is! ExecutableElement) {
       return false;
     }
     ExecutableElement executableElement = element as ExecutableElement;
     if (executableElement.enclosingElement is! ClassElement) {
       return false;
     }
     if (!executableElement.isStatic) {
       return false;
     }
     if (isTypeReference(target)) {
       return false;
     }
-    _errorReporter.reportError2(StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER, name2, [name2.name]);
+    _errorReporter.reportError2(StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER, name, [name.name]);
     return true;
   }
 
   /**
    * This verifies that an 'int' can be assigned to the parameter corresponding to the given
    * expression. This is used for prefix and postfix expressions where the argument value is
    * implicit.
    *
    * @param argument the expression to which the operator is being applied
    * @return `true` if and only if an error code is generated on the passed node
@@ skipping 974 matching lines @@
 
   /**
    * This checks that if the given "target" is the type reference then the "name" is not the
    * reference to a instance member.
    *
    * @param target the target of the name access to evaluate
    * @param name the accessed name to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#STATIC_ACCESS_TO_INSTANCE_MEMBER
    */
-  bool checkForStaticAccessToInstanceMember(Expression target, SimpleIdentifier name2) {
-    Element element = name2.staticElement;
+  bool checkForStaticAccessToInstanceMember(Expression target, SimpleIdentifier name) {
+    Element element = name.staticElement;
     if (element is! ExecutableElement) {
       return false;
     }
     ExecutableElement memberElement = element as ExecutableElement;
     if (memberElement.isStatic) {
       return false;
     }
     if (!isTypeReference(target)) {
       return false;
     }
-    _errorReporter.reportError2(StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, name2, [name2.name]);
+    _errorReporter.reportError2(StaticWarningCode.STATIC_ACCESS_TO_INSTANCE_MEMBER, name, [name.name]);
     return true;
   }
 
   /**
    * This checks that the type of the passed 'switch' expression is assignable to the type of the
    * 'case' members.
    *
    * @param node the 'switch' statement to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticWarningCode#SWITCH_EXPRESSION_NOT_ASSIGNABLE
@@ skipping 168 matching lines @@
   }
 
   /**
    * This checks that if the given name is a reference to a static member it is defined in the
    * enclosing class rather than in a superclass.
    *
    * @param name the name to be evaluated
    * @return `true` if and only if an error code is generated on the passed node
    * @see StaticTypeWarningCode#UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER
    */
-  bool checkForUnqualifiedReferenceToNonLocalStaticMember(SimpleIdentifier name2) {
-    Element element = name2.staticElement;
+  bool checkForUnqualifiedReferenceToNonLocalStaticMember(SimpleIdentifier name) {
+    Element element = name.staticElement;
     if (element == null || element is TypeParameterElement) {
       return false;
     }
     Element enclosingElement = element.enclosingElement;
     if (enclosingElement is! ClassElement) {
       return false;
     }
     if ((element is MethodElement && !((element as MethodElement)).isStatic) || (element is PropertyAccessorElement && !((element as PropertyAccessorElement)).isStatic)) {
       return false;
     }
     if (identical(enclosingElement, _enclosingClass)) {
       return false;
     }
-    _errorReporter.reportError2(StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER, name2, [name2.name]);
+    _errorReporter.reportError2(StaticTypeWarningCode.UNQUALIFIED_REFERENCE_TO_NON_LOCAL_STATIC_MEMBER, name, [name.name]);
     return true;
   }
 
   /**
    * This verifies the passed operator-method declaration, has correct number of parameters.
    *
    * This method assumes that the method declaration was tested to be an operator declaration before
    * being called.
    *
    * @param node the method declaration to evaluate
@@ skipping 475 matching lines @@
   ResolverErrorCode.con2(String name, int ordinal, ErrorType type, String message, String correction) : super(name, ordinal) {
     this._type = type;
     this._message = message;
     this.correction9 = correction;
   }
   String get correction => correction9;
   ErrorSeverity get errorSeverity => _type.severity;
   String get message => _message;
   ErrorType get type => _type;
 }