Generate names for anonymous Java classes using enclosing classes and members.

pkg/analyzer/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';
@@ skipping 343 matching lines @@
   /**
    * Analyzes [classDeclaration] and if it is a module, creates [AngularModuleElement]
    * model for it.
    */
   void parseModuleClass() {
     if (!isModule4) {
       return;
     }
     List<AngularModuleElement> childModules = [];
     List<ClassElement> keyTypes = [];
-    _classDeclaration.accept(new RecursiveASTVisitor_10(this, childModules, keyTypes));
+    _classDeclaration.accept(new RecursiveASTVisitor_AngularCompilationUnitBuilder_parseModuleClass(this, childModules, keyTypes));
     AngularModuleElementImpl module = createModuleElement(childModules, keyTypes);
     _classToolkitObjects.add(module);
   }
 
   /**
    * Checks if given [MethodInvocation] is an interesting <code>Module</code> method
    * invocation and remembers corresponding elements into lists.
    */
   void parseModuleInvocation(MethodInvocation node, List<AngularModuleElement> childModules, List<ClassElement> keyTypes) {
     String methodName = node.methodName.name;
@@ skipping 21 matching lines @@
       }
       return;
     }
   }
 
   /**
    * Checks every local variable in the given unit to see if it is a <code>Module</code> and creates
    * [AngularModuleElement] for it.
    */
   void parseModuleVariables(CompilationUnit unit) {
-    unit.accept(new RecursiveASTVisitor_11(this));
+    unit.accept(new RecursiveASTVisitor_AngularCompilationUnitBuilder_parseModuleVariables(this));
   }
 
   void parseNgComponent() {
     bool isValid = true;
     if (!hasStringArgument(_PUBLISH_AS)) {
       reportErrorForAnnotation(AngularCode.MISSING_PUBLISH_AS, []);
       isValid = false;
     }
     AngularSelectorElement selector = null;
     if (!hasStringArgument(_SELECTOR)) {
@@ skipping 222 matching lines @@
   void reportErrorForAnnotation(ErrorCode errorCode, List<Object> arguments) {
     reportError(_annotation, errorCode, arguments);
   }
 
   void reportErrorForArgument(String argumentName, ErrorCode errorCode, List<Object> arguments) {
     Expression argument = getArgument(argumentName);
     reportError(argument, errorCode, arguments);
   }
 }
 
-class RecursiveASTVisitor_10 extends RecursiveASTVisitor<Object> {
+class RecursiveASTVisitor_AngularCompilationUnitBuilder_parseModuleClass extends RecursiveASTVisitor<Object> {
   final AngularCompilationUnitBuilder AngularCompilationUnitBuilder_this;
 
   List<AngularModuleElement> childModules;
 
   List<ClassElement> keyTypes;
 
-  RecursiveASTVisitor_10(this.AngularCompilationUnitBuilder_this, this.childModules, this.keyTypes) : super();
+  RecursiveASTVisitor_AngularCompilationUnitBuilder_parseModuleClass(this.AngularCompilationUnitBuilder_this, this.childModules, this.keyTypes) : super();
 
   Object visitMethodInvocation(MethodInvocation node) {
     if (node.target == null) {
       AngularCompilationUnitBuilder_this.parseModuleInvocation(node, childModules, keyTypes);
     }
     return null;
   }
 }
 
-class RecursiveASTVisitor_11 extends RecursiveASTVisitor<Object> {
+class RecursiveASTVisitor_AngularCompilationUnitBuilder_parseModuleVariables extends RecursiveASTVisitor<Object> {
   final AngularCompilationUnitBuilder AngularCompilationUnitBuilder_this;
 
-  RecursiveASTVisitor_11(this.AngularCompilationUnitBuilder_this) : super();
+  RecursiveASTVisitor_AngularCompilationUnitBuilder_parseModuleVariables(this.AngularCompilationUnitBuilder_this) : super();
 
   LocalVariableElementImpl _variable = null;
 
   Expression _variableInit = null;
 
   List<AngularModuleElement> _childModules = [];
 
   List<ClassElement> _keyTypes = [];
 
   Object visitFunctionDeclaration(FunctionDeclaration node) {
@@ skipping 3232 matching lines @@
           if (prefixElement != null && prefix.name == prefixElement.displayName) {
             return element;
           }
         }
       }
     }
     return null;
   }
 
   void gatherElements(Element element) {
-    element.accept(new GeneralizingElementVisitor_15(this));
+    element.accept(new GeneralizingElementVisitor_DeclarationMatcher_gatherElements(this));
   }
 
   /**
    * Search the most closely enclosing list of parameters for a parameter with the given name.
    *
    * @param node the node defining the parameter with the given name
    * @param parameterName the name of the parameter being searched for
    * @return the element representing the parameter with that name
    */
   ParameterElement getElementForParameter(FormalParameter node, SimpleIdentifier parameterName) {
@@ skipping 41 matching lines @@
 }
 
 /**
  * Instances of the class `DeclarationMismatchException` represent an exception that is
  * thrown when the element model defined by a given AST structure does not match an existing
  * element model.
  */
 class DeclarationMatcher_DeclarationMismatchException extends RuntimeException {
 }
 
-class GeneralizingElementVisitor_15 extends GeneralizingElementVisitor<Object> {
+class GeneralizingElementVisitor_DeclarationMatcher_gatherElements extends GeneralizingElementVisitor<Object> {
   final DeclarationMatcher DeclarationMatcher_this;
 
-  GeneralizingElementVisitor_15(this.DeclarationMatcher_this) : super();
+  GeneralizingElementVisitor_DeclarationMatcher_gatherElements(this.DeclarationMatcher_this) : super();
 
   Object visitElement(Element element) {
     DeclarationMatcher_this._allElements.add(element);
     DeclarationMatcher_this._unmatchedElements.add(element);
     return super.visitElement(element);
   }
 }
 
 /**
  * Instances of the class `DeclarationResolver` are used to resolve declarations in an AST
@@ skipping 5652 matching lines @@
    * Return `true` if the given variable is accessed within a closure in the given
    * [ASTNode] and also mutated somewhere in variable scope. This information is only
    * available for local variables (including parameters).
    *
    * @param variable the variable to check
    * @param target the [ASTNode] to check within
    * @return `true` if this variable is potentially mutated somewhere in the given ASTNode
    */
   bool isVariableAccessedInClosure(Element variable, ASTNode target) {
     List<bool> result = [false];
-    target.accept(new RecursiveASTVisitor_16(result, variable));
+    target.accept(new RecursiveASTVisitor_ResolverVisitor_isVariableAccessedInClosure(result, variable));
     return result[0];
   }
 
   /**
    * Return `true` if the given variable is potentially mutated somewhere in the given
    * [ASTNode]. This information is only available for local variables (including parameters).
    *
    * @param variable the variable to check
    * @param target the [ASTNode] to check within
    * @return `true` if this variable is potentially mutated somewhere in the given ASTNode
    */
   bool isVariablePotentiallyMutatedIn(Element variable, ASTNode target) {
     List<bool> result = [false];
-    target.accept(new RecursiveASTVisitor_17(result, variable));
+    target.accept(new RecursiveASTVisitor_ResolverVisitor_isVariablePotentiallyMutatedIn(result, variable));
     return result[0];
   }
 
   /**
    * If it is appropriate to do so, promotes the current type of the static element associated with
    * the given expression with the given type. Generally speaking, it is appropriate if the given
    * type is more specific than the current type.
    *
    * @param expression the expression used to access the static element whose types might be
    *          promoted
@@ skipping 136 matching lines @@
 
   get typeAnalyzer_J2DAccessor => _typeAnalyzer;
 
   set typeAnalyzer_J2DAccessor(__v) => _typeAnalyzer = __v;
 
   get enclosingClass_J2DAccessor => _enclosingClass;
 
   set enclosingClass_J2DAccessor(__v) => _enclosingClass = __v;
 }
 
-class RecursiveASTVisitor_16 extends RecursiveASTVisitor<Object> {
+class RecursiveASTVisitor_ResolverVisitor_isVariableAccessedInClosure extends RecursiveASTVisitor<Object> {
   List<bool> result;
 
   Element variable;
 
-  RecursiveASTVisitor_16(this.result, this.variable) : super();
+  RecursiveASTVisitor_ResolverVisitor_isVariableAccessedInClosure(this.result, this.variable) : super();
 
   bool _inClosure = false;
 
   Object visitFunctionExpression(FunctionExpression node) {
     bool inClosure = this._inClosure;
     try {
       this._inClosure = true;
       return super.visitFunctionExpression(node);
     } finally {
       this._inClosure = inClosure;
     }
   }
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (result[0]) {
       return null;
     }
     if (_inClosure && identical(node.staticElement, variable)) {
       result[0] = javaBooleanOr(result[0], true);
     }
     return null;
   }
 }
 
-class RecursiveASTVisitor_17 extends RecursiveASTVisitor<Object> {
+class RecursiveASTVisitor_ResolverVisitor_isVariablePotentiallyMutatedIn extends RecursiveASTVisitor<Object> {
   List<bool> result;
 
   Element variable;
 
-  RecursiveASTVisitor_17(this.result, this.variable) : super();
+  RecursiveASTVisitor_ResolverVisitor_isVariablePotentiallyMutatedIn(this.result, this.variable) : super();
 
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     if (result[0]) {
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result[0] = javaBooleanOr(result[0], true);
       }
     }
@@ skipping 1754 matching lines @@
    * @param body the boy of the function whose propagated return type is to be computed
    * @return the propagated return type that was computed
    */
   Type2 computePropagatedReturnType2(FunctionBody body) {
     if (body is ExpressionFunctionBody) {
       ExpressionFunctionBody expressionBody = body;
       return expressionBody.expression.bestType;
     }
     if (body is BlockFunctionBody) {
       List<Type2> result = [null];
-      body.accept(new GeneralizingASTVisitor_18(result));
+      body.accept(new GeneralizingASTVisitor_StaticTypeAnalyzer_computePropagatedReturnType2(result));
       return result[0];
     }
     return null;
   }
 
   /**
    * Compute the static return type of the method or function represented by the given element.
    *
    * @param element the element representing the method or function invoked by the given node
    * @return the static return type that was computed
@@ skipping 342 matching lines @@
       }
     }
     return staticType;
   }
 
   get thisType_J2DAccessor => _thisType;
 
   set thisType_J2DAccessor(__v) => _thisType = __v;
 }
 
-class GeneralizingASTVisitor_18 extends GeneralizingASTVisitor<Object> {
+class GeneralizingASTVisitor_StaticTypeAnalyzer_computePropagatedReturnType2 extends GeneralizingASTVisitor<Object> {
   List<Type2> result;
 
-  GeneralizingASTVisitor_18(this.result) : super();
+  GeneralizingASTVisitor_StaticTypeAnalyzer_computePropagatedReturnType2(this.result) : super();
 
   Object visitExpression(Expression node) => null;
 
   Object visitReturnStatement(ReturnStatement node) {
     Type2 type;
     Expression expression = node.expression;
     if (expression != null) {
       type = expression.bestType;
     } else {
       type = BottomTypeImpl.instance;
@@ skipping 3120 matching lines @@
   }
 
   /**
    * Validates that the given expression is a compile time constant.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param expression the expression to validate
    */
   void validateInitializerExpression(List<ParameterElement> parameterElements, Expression expression) {
-    EvaluationResultImpl result = expression.accept(new ConstantVisitor_21(_typeProvider, this, parameterElements));
+    EvaluationResultImpl result = expression.accept(new ConstantVisitor_ConstantVerifier_validateInitializerExpression(_typeProvider, this, parameterElements));
     reportErrors(result, CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER);
   }
 
   /**
    * Validates that all of the arguments of a constructor initializer are compile time constants.
    *
    * @param parameterElements the elements of parameters of constant constructor, they are
    *          considered as a valid potentially constant expressions
    * @param argumentList the argument list to validate
    */
@@ skipping 25 matching lines @@
         validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
       if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation invocation = initializer;
         validateInitializerInvocationArguments(parameterElements, invocation.argumentList);
       }
     }
   }
 }
 
-class ConstantVisitor_21 extends ConstantVisitor {
+class ConstantVisitor_ConstantVerifier_validateInitializerExpression extends ConstantVisitor {
   final ConstantVerifier ConstantVerifier_this;
 
   List<ParameterElement> parameterElements;
 
-  ConstantVisitor_21(TypeProvider arg0, this.ConstantVerifier_this, this.parameterElements) : super(arg0);
+  ConstantVisitor_ConstantVerifier_validateInitializerExpression(TypeProvider arg0, this.ConstantVerifier_this, this.parameterElements) : super(arg0);
 
   EvaluationResultImpl visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     for (ParameterElement parameterElement in parameterElements) {
       if (identical(parameterElement, element) && parameterElement != null) {
         Type2 type = parameterElement.type;
         if (type != null) {
           if (type.isDynamic) {
             return ConstantVerifier_this.valid(ConstantVerifier_this._typeProvider.objectType, DynamicState.DYNAMIC_STATE);
           } else if (type.isSubtypeOf(ConstantVerifier_this._boolType)) {
@@ skipping 4126 matching lines @@
             firstIteration = false;
             break;
           } else {
             return true;
           }
         }
         if (current != null && !checked.contains(current)) {
           break;
         }
       }
-      current.accept(new GeneralizingElementVisitor_22(target, toCheck));
+      current.accept(new GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(target, toCheck));
       checked.add(current);
     }
   }
 
   /**
    * @return `true` if given [Type] implements operator <i>==</i>, and it is not
    *         <i>int</i> or <i>String</i>.
    */
   bool implementsEqualsWhenNotAllowed(Type2 type) {
     if (type == null || type == _typeProvider.intType || type == _typeProvider.stringType) {
@@ skipping 241 matching lines @@
 
   static final List<INIT_STATE> values = [
       NOT_INIT,
       INIT_IN_DECLARATION,
       INIT_IN_FIELD_FORMAL,
       INIT_IN_INITIALIZERS];
 
   INIT_STATE(String name, int ordinal) : super(name, ordinal);
 }
 
-class GeneralizingElementVisitor_22 extends GeneralizingElementVisitor<Object> {
+class GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference extends GeneralizingElementVisitor<Object> {
   Element target;
 
   List<Element> toCheck;
 
-  GeneralizingElementVisitor_22(this.target, this.toCheck) : super();
+  GeneralizingElementVisitor_ErrorVerifier_hasTypedefSelfReference(this.target, this.toCheck) : super();
 
   bool _inClass = false;
 
   Object visitClassElement(ClassElement element) {
     addTypeToCheck(element.supertype);
     for (InterfaceType mixin in element.mixins) {
       addTypeToCheck(mixin);
     }
     _inClass = !element.isTypedef;
     try {
@@ skipping 101 matching lines @@
    * @param correction the template used to create the correction to be displayed for the error
    */
   ResolverErrorCode.con2(String name, int ordinal, this.type, this.message, String correction) : super(name, ordinal) {
     this.correction10 = correction;
   }
 
   String get correction => correction10;
 
   ErrorSeverity get errorSeverity => type.severity;
 }