Begin separating API and local element builders.

pkg/analyzer/test/generated/all_the_rest_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.test.generated.all_the_rest_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 599 matching lines @@
     checkMetadata(parameterElement);
   }
 
   void test_metadata_visitTypeParameter() {
     TypeParameterElement typeParameterElement =
         buildElementsForText('class C<@a T> {}').types[0].typeParameters[0];
     checkMetadata(typeParameterElement);
   }
 
   void test_visitCatchClause() {
-    // } catch (e, s) {
-    ElementHolder holder = new ElementHolder();
-    ElementBuilder builder = _makeBuilder(holder);
+    List<LocalVariableElement> variables =
+        buildElementsForText('f() { try {} catch (e, s) {} }')
+            .functions[0]
+            .localVariables;
     String exceptionParameterName = "e";
     String stackParameterName = "s";
-    CatchClause clause =
-        AstFactory.catchClause2(exceptionParameterName, stackParameterName);
-    _setNodeSourceRange(clause, 100, 110);
-    clause.accept(builder);
-
-    List<LocalVariableElement> variables = holder.localVariables;
     expect(variables, hasLength(2));
 
     LocalVariableElement exceptionVariable = variables[0];
     expect(exceptionVariable, isNotNull);
     expect(exceptionVariable.name, exceptionParameterName);
     expect(exceptionVariable.hasImplicitType, isTrue);
     expect(exceptionVariable.isSynthetic, isFalse);
     expect(exceptionVariable.isConst, isFalse);
     expect(exceptionVariable.isFinal, isFalse);
     expect(exceptionVariable.initializer, isNull);
-    _assertVisibleRange(exceptionVariable, 100, 110);
+    _assertVisibleRange(exceptionVariable, 13, 28);
 
     LocalVariableElement stackVariable = variables[1];
     expect(stackVariable, isNotNull);
     expect(stackVariable.name, stackParameterName);
     expect(stackVariable.isSynthetic, isFalse);
     expect(stackVariable.isConst, isFalse);
     expect(stackVariable.isFinal, isFalse);
     expect(stackVariable.initializer, isNull);
-    _assertVisibleRange(stackVariable, 100, 110);
+    _assertVisibleRange(stackVariable, 13, 28);
   }
 
   void test_visitCatchClause_withType() {
-    // } on E catch (e) {
-    ElementHolder holder = new ElementHolder();
-    ElementBuilder builder = _makeBuilder(holder);
+    List<LocalVariableElement> variables =
+        buildElementsForText('f() { try {} on E catch (e) {} }')
+            .functions[0]
+            .localVariables;
     String exceptionParameterName = "e";
-    CatchClause clause = AstFactory.catchClause4(
-        AstFactory.typeName4('E'), exceptionParameterName);
-    clause.accept(builder);
-
-    List<LocalVariableElement> variables = holder.localVariables;
     expect(variables, hasLength(1));
     VariableElement exceptionVariable = variables[0];
     expect(exceptionVariable, isNotNull);
     expect(exceptionVariable.name, exceptionParameterName);
     expect(exceptionVariable.hasImplicitType, isFalse);
   }
 
   void test_visitClassDeclaration_abstract() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
@@ skipping 393 matching lines @@
     expect(constructor.isFactory, isFalse);
     expect(constructor.name, "");
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
     expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, hasLength(0));
     expect(constructorDeclaration.element, same(constructor));
   }
 
   void test_visitDeclaredIdentifier_noType() {
-    // var i
-    ElementHolder holder = new ElementHolder();
-    ElementBuilder builder = _makeBuilder(holder);
-    var variableName = 'i';
-    DeclaredIdentifier identifier =
-        AstFactory.declaredIdentifier3(variableName);
-    AstFactory.forEachStatement(
-        identifier, AstFactory.nullLiteral(), AstFactory.emptyStatement());
-    identifier.beginToken.offset = 50;
-    identifier.endToken.offset = 80;
-    identifier.accept(builder);
-
-    List<LocalVariableElement> variables = holder.localVariables;
-    expect(variables, hasLength(1));
-    LocalVariableElement variable = variables[0];
-    _assertHasCodeRange(variable, 50, 31);
+    LocalVariableElement variable =
+        buildElementsForText('f() { for (var i in []) {} }')
+            .functions[0]
+            .localVariables[0];
+    _assertHasCodeRange(variable, 11, 5);
     expect(variable, isNotNull);
     expect(variable.hasImplicitType, isTrue);
     expect(variable.isConst, isFalse);
     expect(variable.isDeprecated, isFalse);
     expect(variable.isFinal, isFalse);
     expect(variable.isOverride, isFalse);
     expect(variable.isPrivate, isFalse);
     expect(variable.isPublic, isTrue);
     expect(variable.isSynthetic, isFalse);
-    expect(variable.name, variableName);
+    expect(variable.name, 'i');
   }
 
   void test_visitDeclaredIdentifier_type() {
-    // E i
-    ElementHolder holder = new ElementHolder();
-    ElementBuilder builder = _makeBuilder(holder);
-    var variableName = 'i';
-    DeclaredIdentifier identifier =
-        AstFactory.declaredIdentifier4(AstFactory.typeName4('E'), variableName);
-    AstFactory.forEachStatement(
-        identifier, AstFactory.nullLiteral(), AstFactory.emptyStatement());
-    identifier.beginToken.offset = 50;
-    identifier.endToken.offset = 80;
-    identifier.accept(builder);
-
-    List<LocalVariableElement> variables = holder.localVariables;
-    expect(variables, hasLength(1));
-    LocalVariableElement variable = variables[0];
-    expect(variable, isNotNull);
-    _assertHasCodeRange(variable, 50, 31);
+    LocalVariableElement variable =
+        buildElementsForText('f() { for (int i in []) {} }')
+            .functions[0]
+            .localVariables[0];
+    _assertHasCodeRange(variable, 11, 5);
     expect(variable.hasImplicitType, isFalse);
     expect(variable.isConst, isFalse);
     expect(variable.isDeprecated, isFalse);
     expect(variable.isFinal, isFalse);
     expect(variable.isOverride, isFalse);
     expect(variable.isPrivate, isFalse);
     expect(variable.isPublic, isTrue);
     expect(variable.isSynthetic, isFalse);
-    expect(variable.name, variableName);
+    expect(variable.name, 'i');
   }
 
   void test_visitDefaultFormalParameter_noType() {
     // p = 0
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     String parameterName = 'p';
     DefaultFormalParameter formalParameter =
         AstFactory.positionalFormalParameter(
             AstFactory.simpleFormalParameter3(parameterName),
@@ skipping 344 matching lines @@
     List<FunctionElement> functions = holder.functions;
     expect(functions, hasLength(1));
     FunctionElement function = functions[0];
     expect(function, isNotNull);
     expect(expression.element, same(function));
     expect(function.hasImplicitReturnType, isTrue);
     expect(function.isSynthetic, isFalse);
     expect(function.typeParameters, hasLength(0));
   }
 
+  void test_visitFunctionExpression_inBlockBody() {
+    List<FunctionElement> functions =
+        buildElementsForText('f() { return () => 42; }').functions[0].functions;
+    expect(functions, hasLength(1));
+    FunctionElement function = functions[0];
+    expect(function, isNotNull);
+    expect(function.hasImplicitReturnType, isTrue);
+    expect(function.isSynthetic, isFalse);
+    expect(function.typeParameters, hasLength(0));
+  }
+
+  void test_visitFunctionExpression_inExpressionBody() {
+    List<FunctionElement> functions =
+        buildElementsForText('f() => () => 42;').functions[0].functions;
+    expect(functions, hasLength(1));
+    FunctionElement function = functions[0];
+    expect(function, isNotNull);
+    expect(function.hasImplicitReturnType, isTrue);
+    expect(function.isSynthetic, isFalse);
+    expect(function.typeParameters, hasLength(0));
+  }
+
   void test_visitFunctionTypeAlias() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     String aliasName = "F";
     String parameterName = "E";
     FunctionTypeAlias aliasNode = AstFactory.typeAlias(
         null, aliasName, AstFactory.typeParameterList([parameterName]), null);
     aliasNode.documentationComment = AstFactory.documentationComment(
         [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
     aliasNode.endToken.offset = 80;
@@ skipping 52 matching lines @@
     expect(parameter.initializer, isNull);
     expect(parameter.isConst, isFalse);
     expect(parameter.isFinal, isFalse);
     expect(parameter.isSynthetic, isFalse);
     expect(parameter.parameterKind, ParameterKind.REQUIRED);
     expect(parameter.typeParameters, hasLength(1));
     _assertVisibleRange(parameter, 100, 110);
   }
 
   void test_visitLabeledStatement() {
-    ElementHolder holder = new ElementHolder();
-    ElementBuilder builder = _makeBuilder(holder);
-    String labelName = "l";
-    LabeledStatement statement = AstFactory.labeledStatement(
-        [AstFactory.label2(labelName)], AstFactory.breakStatement());
-    statement.accept(builder);
-    List<LabelElement> labels = holder.labels;
+    List<LabelElement> labels =
+        buildElementsForText('f() { l: print(42); }').functions[0].labels;
     expect(labels, hasLength(1));
     LabelElement label = labels[0];
     expect(label, isNotNull);
-    expect(label.name, labelName);
+    expect(label.name, 'l');
     expect(label.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_abstract() {
     // m();
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
         null,
@@ skipping 459 matching lines @@
     expect(method.localVariables, hasLength(0));
     expect(method.parameters, hasLength(0));
     expect(method.typeParameters, hasLength(1));
     expect(method.isAbstract, isFalse);
     expect(method.isExternal, isFalse);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_withMembers() {
-    // m(p) { var v; try { l: return; } catch (e) {} }
-    ElementHolder holder = new ElementHolder();
-    ElementBuilder builder = _makeBuilder(holder);
+    MethodElement method = buildElementsForText(
+            'class C { m(p) { var v; try { l: return; } catch (e) {} } }')
+        .types[0]
+        .methods[0];
     String methodName = "m";
     String parameterName = "p";
     String localVariableName = "v";
     String labelName = "l";
     String exceptionParameterName = "e";
-    MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
-        null,
-        null,
-        null,
-        null,
-        AstFactory.identifier3(methodName),
-        AstFactory.formalParameterList(
-            [AstFactory.simpleFormalParameter3(parameterName)]),
-        AstFactory.blockFunctionBody2([
-          AstFactory.variableDeclarationStatement2(
-              Keyword.VAR, [AstFactory.variableDeclaration(localVariableName)]),
-          AstFactory.tryStatement2(
-              AstFactory.block([
-                AstFactory.labeledStatement([AstFactory.label2(labelName)],
-                    AstFactory.returnStatement())
-              ]),
-              [AstFactory.catchClause(exceptionParameterName)])
-        ]));
-    methodDeclaration.accept(builder);
-
-    List<MethodElement> methods = holder.methods;
-    expect(methods, hasLength(1));
-    MethodElement method = methods[0];
     expect(method, isNotNull);
     expect(method.hasImplicitReturnType, isTrue);
     expect(method.name, methodName);
     expect(method.typeParameters, hasLength(0));
     expect(method.isAbstract, isFalse);
     expect(method.isExternal, isFalse);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
     List<VariableElement> parameters = method.parameters;
     expect(parameters, hasLength(1));
@@ skipping 183 matching lines @@
     expect(typeParameters, hasLength(1));
     TypeParameterElement typeParameterElement = typeParameters[0];
     expect(typeParameterElement, isNotNull);
     _assertHasCodeRange(typeParameterElement, 50, 1);
     expect(typeParameterElement.name, parameterName);
     expect(typeParameterElement.bound, isNull);
     expect(typeParameterElement.isSynthetic, isFalse);
   }
 
   void test_visitVariableDeclaration_inConstructor() {
-    ElementHolder holder = new ElementHolder();
-    ElementBuilder builder = _makeBuilder(holder);
-    //
-    // C() {var v;}
-    //
-    String variableName = "v";
-    VariableDeclaration variable =
-        AstFactory.variableDeclaration2(variableName, null);
-    VariableDeclarationStatement statement =
-        AstFactory.variableDeclarationStatement2(Keyword.VAR, [variable]);
-    ConstructorDeclaration constructor = AstFactory.constructorDeclaration2(
-        null,
-        null,
-        AstFactory.identifier3("C"),
-        "C",
-        AstFactory.formalParameterList(),
-        null,
-        AstFactory.blockFunctionBody2([statement]));
-    statement.beginToken.offset = 50;
-    statement.endToken.offset = 80;
-    _setBlockBodySourceRange(constructor.body, 100, 110);
-    constructor.accept(builder);
-
-    List<ConstructorElement> constructors = holder.constructors;
+    List<ConstructorElement> constructors =
+        buildElementsForText('class C { C() { var v = 1; } }')
+            .types[0]
+            .constructors;
     expect(constructors, hasLength(1));
     List<LocalVariableElement> variableElements =
         constructors[0].localVariables;
     expect(variableElements, hasLength(1));
     LocalVariableElement variableElement = variableElements[0];
-    _assertHasCodeRange(variableElement, 50, 31);
+    _assertHasCodeRange(variableElement, 16, 10);
     expect(variableElement.hasImplicitType, isTrue);
-    expect(variableElement.name, variableName);
-    _assertVisibleRange(variableElement, 100, 110);
+    expect(variableElement.name, 'v');
+    _assertVisibleRange(variableElement, 14, 28);
   }
 
   void test_visitVariableDeclaration_inForEachStatement() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     //
     // m() { for (var v in []) }
     //
     String variableName = "v";
     Statement statement = AstFactory.forEachStatement(
@@ skipping 2191 matching lines @@
     expect(UriKind.fromEncoding(0x70), same(UriKind.PACKAGE_URI));
     expect(UriKind.fromEncoding(0x58), same(null));
   }
 
   void test_getEncoding() {
     expect(UriKind.DART_URI.encoding, 0x64);
     expect(UriKind.FILE_URI.encoding, 0x66);
     expect(UriKind.PACKAGE_URI.encoding, 0x70);
   }
 }