Add tests showing using LocalElementBuilder separately, for variable or body.

pkg/analyzer/test/dart/element/builder_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.dart.element.builder_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/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/builder.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/testing/token_factory.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../../generated/parser_test.dart';
 import '../../generated/test_support.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(ApiElementBuilderTest);
     defineReflectiveTests(ElementBuilderTest);
+    defineReflectiveTests(LocalElementBuilderTest);
   });
 }
 
 @reflectiveTest
 class ApiElementBuilderTest extends _BaseTest with _ApiElementBuilderTestMixin {
   @override
   AstVisitor createElementBuilder(ElementHolder holder) {
     return new ApiElementBuilder(holder, compilationUnitElement);
   }
 
@@ skipping 139 matching lines @@
       expect(accessor.variable.setter, same(accessor));
     }
   }
 
   @override
   void setUp() {
     super.setUp();
     compilationUnitElement = new CompilationUnitElementImpl('test.dart');
   }
 
-  void test_visitDefaultFormalParameter_noType() {
-    // p = 0
-    String parameterName = 'p';
-    DefaultFormalParameter formalParameter =
-    AstFactory.positionalFormalParameter(
-        AstFactory.simpleFormalParameter3(parameterName),
-        AstFactory.integer(0));
-    formalParameter.beginToken.offset = 50;
-    formalParameter.endToken.offset = 80;
-
-    ElementHolder holder = buildElementsForAst(formalParameter);
-    List<ParameterElement> parameters = holder.parameters;
-    expect(parameters, hasLength(1));
-    ParameterElement parameter = parameters[0];
-    assertHasCodeRange(parameter, 50, 31);
-    expect(parameter.hasImplicitType, isTrue);
-    expect(parameter.initializer, isNotNull);
-    expect(parameter.initializer.type, isNotNull);
-    expect(parameter.initializer.hasImplicitReturnType, isTrue);
-    expect(parameter.isConst, isFalse);
-    expect(parameter.isDeprecated, isFalse);
-    expect(parameter.isFinal, isFalse);
-    expect(parameter.isInitializingFormal, isFalse);
-    expect(parameter.isOverride, isFalse);
-    expect(parameter.isPrivate, isFalse);
-    expect(parameter.isPublic, isTrue);
-    expect(parameter.isSynthetic, isFalse);
-    expect(parameter.name, parameterName);
-  }
-
-  void test_visitDefaultFormalParameter_type() {
-    // E p = 0
-    String parameterName = 'p';
-    DefaultFormalParameter formalParameter = AstFactory.namedFormalParameter(
-        AstFactory.simpleFormalParameter4(
-            AstFactory.typeName4('E'), parameterName),
-        AstFactory.integer(0));
-
-    ElementHolder holder = buildElementsForAst(formalParameter);
-    List<ParameterElement> parameters = holder.parameters;
-    expect(parameters, hasLength(1));
-    ParameterElement parameter = parameters[0];
-    expect(parameter.hasImplicitType, isFalse);
-    expect(parameter.initializer, isNotNull);
-    expect(parameter.initializer.type, isNotNull);
-    expect(parameter.initializer.hasImplicitReturnType, isTrue);
-    expect(parameter.isConst, isFalse);
-    expect(parameter.isDeprecated, isFalse);
-    expect(parameter.isFinal, isFalse);
-    expect(parameter.isInitializingFormal, isFalse);
-    expect(parameter.isOverride, isFalse);
-    expect(parameter.isPrivate, isFalse);
-    expect(parameter.isPublic, isTrue);
-    expect(parameter.isSynthetic, isFalse);
-    expect(parameter.name, parameterName);
-  }
-
   void test_metadata_localVariableDeclaration() {
     List<LocalVariableElement> localVariables =
         buildElementsForText('f() { @a int x, y; }')
             .functions[0]
             .localVariables;
     checkMetadata(localVariables[0]);
     checkMetadata(localVariables[1]);
     expect(localVariables[0].metadata, same(localVariables[1].metadata));
   }
 
@@ skipping 94 matching lines @@
     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, 'i');
   }
 
+  void test_visitDefaultFormalParameter_noType() {
+    // p = 0
+    String parameterName = 'p';
+    DefaultFormalParameter formalParameter =
+        AstFactory.positionalFormalParameter(
+            AstFactory.simpleFormalParameter3(parameterName),
+            AstFactory.integer(0));
+    formalParameter.beginToken.offset = 50;
+    formalParameter.endToken.offset = 80;
+
+    ElementHolder holder = buildElementsForAst(formalParameter);
+    List<ParameterElement> parameters = holder.parameters;
+    expect(parameters, hasLength(1));
+    ParameterElement parameter = parameters[0];
+    assertHasCodeRange(parameter, 50, 31);
+    expect(parameter.hasImplicitType, isTrue);
+    expect(parameter.initializer, isNotNull);
+    expect(parameter.initializer.type, isNotNull);
+    expect(parameter.initializer.hasImplicitReturnType, isTrue);
+    expect(parameter.isConst, isFalse);
+    expect(parameter.isDeprecated, isFalse);
+    expect(parameter.isFinal, isFalse);
+    expect(parameter.isInitializingFormal, isFalse);
+    expect(parameter.isOverride, isFalse);
+    expect(parameter.isPrivate, isFalse);
+    expect(parameter.isPublic, isTrue);
+    expect(parameter.isSynthetic, isFalse);
+    expect(parameter.name, parameterName);
+  }
+
+  void test_visitDefaultFormalParameter_type() {
+    // E p = 0
+    String parameterName = 'p';
+    DefaultFormalParameter formalParameter = AstFactory.namedFormalParameter(
+        AstFactory.simpleFormalParameter4(
+            AstFactory.typeName4('E'), parameterName),
+        AstFactory.integer(0));
+
+    ElementHolder holder = buildElementsForAst(formalParameter);
+    List<ParameterElement> parameters = holder.parameters;
+    expect(parameters, hasLength(1));
+    ParameterElement parameter = parameters[0];
+    expect(parameter.hasImplicitType, isFalse);
+    expect(parameter.initializer, isNotNull);
+    expect(parameter.initializer.type, isNotNull);
+    expect(parameter.initializer.hasImplicitReturnType, isTrue);
+    expect(parameter.isConst, isFalse);
+    expect(parameter.isDeprecated, isFalse);
+    expect(parameter.isFinal, isFalse);
+    expect(parameter.isInitializingFormal, isFalse);
+    expect(parameter.isOverride, isFalse);
+    expect(parameter.isPrivate, isFalse);
+    expect(parameter.isPublic, isTrue);
+    expect(parameter.isSynthetic, isFalse);
+    expect(parameter.name, parameterName);
+  }
+
   void test_visitFunctionExpression() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     FunctionExpression expression = AstFactory.functionExpression2(
         AstFactory.formalParameterList(), AstFactory.blockFunctionBody2());
     expression.accept(builder);
     List<FunctionElement> functions = holder.functions;
     expect(functions, hasLength(1));
     FunctionElement function = functions[0];
     expect(function, isNotNull);
@@ skipping 502 matching lines @@
         null,
         null,
         null,
         null,
         AstFactory.identifier3("main"),
         AstFactory.formalParameterList([formalParameter]),
         body);
   }
 }
 
+@reflectiveTest
+class LocalElementBuilderTest extends _BaseTest {
+  @override
+  AstVisitor createElementBuilder(ElementHolder holder) {
+    return new LocalElementBuilder(holder, compilationUnitElement);
+  }
+
+  void test_buildLocalElements() {
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit(r'''
+main() {
+  int v1;
+  f1() {
+    int v2;
+    f2() {
+      int v3;
+    }
+  }
+}
+''');
+    var mainAst = unit.declarations.single as FunctionDeclaration;
+    // Build API elements.
+    FunctionElementImpl main;
+    {
+      ElementHolder holder = new ElementHolder();
+      unit.accept(new ApiElementBuilder(holder, compilationUnitElement));
+      main = holder.functions.single as FunctionElementImpl;
+    }
+    expect(main.localVariables, isEmpty);
+    expect(main.functions, isEmpty);
+    // Build local elements in body.
+    ElementHolder holder = new ElementHolder();
+    FunctionBody mainBody = mainAst.functionExpression.body;
+    mainBody.accept(new LocalElementBuilder(holder, compilationUnitElement));
+    main.functions = holder.functions;
+    main.localVariables = holder.localVariables;
+    expect(main.localVariables.map((v) => v.name), ['v1']);
+    expect(main.functions, hasLength(1));
+    {
+      FunctionElement f1 = main.functions[0];
+      expect(f1.name, 'f1');
+      expect(f1.localVariables.map((v) => v.name), ['v2']);
+      expect(f1.functions, hasLength(1));
+      {
+        FunctionElement f2 = f1.functions[0];
+        expect(f2.name, 'f2');
+        expect(f2.localVariables.map((v) => v.name), ['v3']);
+        expect(f2.functions, isEmpty);
+      }
+    }
+  }
+
+  void test_buildParameterInitializer() {
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit('f({p: 42}) {}');
+    var function = unit.declarations.single as FunctionDeclaration;
+    var parameter = function.functionExpression.parameters.parameters.single
+        as DefaultFormalParameter;
+    // Build API elements.
+    {
+      ElementHolder holder = new ElementHolder();
+      unit.accept(new ApiElementBuilder(holder, compilationUnitElement));
+    }
+    // Validate the parameter element.
+    var parameterElement = parameter.element as ParameterElementImpl;
+    expect(parameterElement, isNotNull);
+    expect(parameterElement.initializer, isNull);
+    // Build the initializer element.
+    new LocalElementBuilder(new ElementHolder(), compilationUnitElement)
+        .buildParameterInitializer(parameterElement, parameter.defaultValue);
+    expect(parameterElement.initializer, isNotNull);
+  }
+
+  void test_buildVariableInitializer() {
+    CompilationUnit unit = ParserTestCase.parseCompilationUnit('var V = 42;');
+    TopLevelVariableDeclaration topLevelDecl =
+        unit.declarations[0] as TopLevelVariableDeclaration;
+    VariableDeclaration variable = topLevelDecl.variables.variables.single;
+    // Build the variable element.
+    {
+      ElementHolder holder = new ElementHolder();
+      unit.accept(new ApiElementBuilder(holder, compilationUnitElement));
+    }
+    // Validate the variable element.
+    var variableElement = variable.element as VariableElementImpl;
+    expect(variableElement, isNotNull);
+    expect(variableElement.initializer, isNull);
+    // Build the initializer element.
+    new LocalElementBuilder(new ElementHolder(), compilationUnitElement)
+        .buildVariableInitializer(variableElement, variable.initializer);
+    expect(variableElement.initializer, isNotNull);
+  }
+
+  void test_visitVariableDeclaration_local() {
+    var holder = buildElementsForText('class C { m() { T v = null; } }');
+    List<LocalVariableElement> variableElements = holder.localVariables;
+    expect(variableElements, hasLength(1));
+    LocalVariableElement variableElement = variableElements[0];
+    expect(variableElement.hasImplicitType, isFalse);
+    expect(variableElement.name, 'v');
+    expect(variableElement.initializer, isNotNull);
+    _assertVisibleRange(variableElement, 14, 29);
+  }
+}
+
 /**
  * Mixin with test methods for testing element building in [ApiElementBuilder].
  * It is used to test the [ApiElementBuilder] itself, and its usage by
  * [ElementBuilder].
  */
 abstract class _ApiElementBuilderTestMixin {
   CompilationUnit get compilationUnit;
 
   void assertHasCodeRange(Element element, int offset, int length);
 
@@ skipping 1446 matching lines @@
     AnalysisEngine.instance.logger = logger;
     try {
       _compilationUnit = ParserTestCase.parseCompilationUnit(code);
       compilationUnit.accept(visitor);
     } finally {
       expect(logger.log, hasLength(0));
       AnalysisEngine.instance.logger = Logger.NULL;
     }
   }
 }