Remove other usages of ExecutableElement.localVariables.

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/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 61 matching lines @@
   }
 }
 ''').types[0].methods[0];
     {
       expect(method.parameters, hasLength(2));
       expect(method.parameters[0].displayName, 'a');
       expect(method.parameters[0].initializer, isNull);
       expect(method.parameters[1].displayName, 'b');
       expect(method.parameters[1].initializer, isNull);
     }
-    expect(method.localVariables, isEmpty);
     expect(method.functions, isEmpty);
   }
 
   void test_api_topLevelFunction_blockBody() {
     FunctionElement function = buildElementsForText(r'''
 void topLevelFunction() {
   int v = 0;
   localFunction() {}
 }
 ''').functions[0];
-    expect(function.localVariables, isEmpty);
     expect(function.functions, isEmpty);
   }
 
   void test_api_topLevelFunction_expressionBody() {
     FunctionElement function = buildElementsForText(r'''
 topLevelFunction() => () {
   int localVar = 0;
 };
 ''').functions[0];
-    expect(function.localVariables, isEmpty);
     expect(function.functions, isEmpty);
   }
 
   void test_api_topLevelFunction_parameters() {
     FunctionElement function = buildElementsForText(r'''
 void topLevelFunction(int a, int b(double b2), {c: () {int c2; c3() {} }}) {
 }
 ''').functions[0];
     List<ParameterElement> parameters = function.parameters;
     expect(parameters, hasLength(3));
@@ skipping 69 matching lines @@
     }
   }
 
   @override
   void setUp() {
     super.setUp();
     compilationUnitElement = new CompilationUnitElementImpl('test.dart');
   }
 
   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));
+    var code = 'f() { @a int x, y; }';
+    buildElementsForText(code);
+    var x = findLocalVariable(code, 'x, ');
+    var y = findLocalVariable(code, 'x, ');
+    checkMetadata(x);
+    checkMetadata(y);
+    expect(x.metadata, same(y.metadata));
   }
 
   void test_metadata_visitDeclaredIdentifier() {
-    LocalVariableElement localVariableElement =
-        buildElementsForText('f() { for (@a var x in y) {} }')
-            .functions[0]
-            .localVariables[0];
-    checkMetadata(localVariableElement);
+    var code = 'f() { for (@a var x in y) {} }';
+    buildElementsForText(code);
+    var x = findLocalVariable(code, 'x in');
+    checkMetadata(x);
   }
 
   void test_visitCatchClause() {
-    List<LocalVariableElement> variables =
-        buildElementsForText('f() { try {} catch (e, s) {} }')
-            .functions[0]
-            .localVariables;
-    String exceptionParameterName = "e";
-    String stackParameterName = "s";
-    expect(variables, hasLength(2));
+    var code = 'f() { try {} catch (e, s) {} }';
+    buildElementsForText(code);
+    var e = findLocalVariable(code, 'e, ');
+    var s = findLocalVariable(code, 's) {}');
 
-    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, 13, 28);
+    expect(e, isNotNull);
+    expect(e.name, 'e');
+    expect(e.hasImplicitType, isTrue);
+    expect(e.isSynthetic, isFalse);
+    expect(e.isConst, isFalse);
+    expect(e.isFinal, isFalse);
+    expect(e.initializer, isNull);
+    _assertVisibleRange(e, 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, 13, 28);
+    expect(s, isNotNull);
+    expect(s.name, 's');
+    expect(s.isSynthetic, isFalse);
+    expect(s.isConst, isFalse);
+    expect(s.isFinal, isFalse);
+    expect(s.initializer, isNull);
+    _assertVisibleRange(s, 13, 28);
   }
 
   void test_visitCatchClause_withType() {
-    List<LocalVariableElement> variables =
-        buildElementsForText('f() { try {} on E catch (e) {} }')
-            .functions[0]
-            .localVariables;
-    String exceptionParameterName = "e";
-    expect(variables, hasLength(1));
-    VariableElement exceptionVariable = variables[0];
-    expect(exceptionVariable, isNotNull);
-    expect(exceptionVariable.name, exceptionParameterName);
-    expect(exceptionVariable.hasImplicitType, isFalse);
+    var code = 'f() { try {} on E catch (e) {} }';
+    buildElementsForText(code);
+    var e = findLocalVariable(code, 'e) {}');
+    expect(e, isNotNull);
+    expect(e.name, 'e');
+    expect(e.hasImplicitType, isFalse);
   }
 
   void test_visitCompilationUnit_codeRange() {
     TopLevelVariableDeclaration topLevelVariableDeclaration = AstTestFactory
         .topLevelVariableDeclaration(null, AstTestFactory.typeName4('int'),
             [AstTestFactory.variableDeclaration('V')]);
     CompilationUnit unit = astFactory.compilationUnit(
         topLevelVariableDeclaration.beginToken,
         null,
         [],
         [topLevelVariableDeclaration],
         topLevelVariableDeclaration.endToken);
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     unit.beginToken.offset = 10;
     unit.endToken.offset = 40;
     unit.accept(builder);
 
     assertHasCodeRange(compilationUnitElement, 0, 41);
   }
 
   void test_visitDeclaredIdentifier_noType() {
-    LocalVariableElement variable =
-        buildElementsForText('f() { for (var i in []) {} }')
-            .functions[0]
-            .localVariables[0];
+    var code = 'f() { for (var i in []) {} }';
+    buildElementsForText(code);
+    var variable = findLocalVariable(code, 'i in');
     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, 'i');
   }
 
   void test_visitDeclaredIdentifier_type() {
-    LocalVariableElement variable =
-        buildElementsForText('f() { for (int i in []) {} }')
-            .functions[0]
-            .localVariables[0];
+    var code = 'f() { for (int i in []) {} }';
+    buildElementsForText(code);
+    var variable = findLocalVariable(code, 'i in');
     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, 'i');
@@ skipping 195 matching lines @@
     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, 'l');
     expect(label.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_withMembers() {
-    MethodElement method = buildElementsForText(
-            'class C { m(p) { var v; try { l: return; } catch (e) {} } }')
-        .types[0]
-        .methods[0];
+    var code = 'class C { m(p) { var v; try { l: return; } catch (e) {} } }';
+    MethodElement method = buildElementsForText(code).types[0].methods[0];
     String methodName = "m";
     String parameterName = "p";
-    String localVariableName = "v";
     String labelName = "l";
-    String exceptionParameterName = "e";
     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));
     VariableElement parameter = parameters[0];
     expect(parameter, isNotNull);
     expect(parameter.name, parameterName);
-    List<VariableElement> localVariables = method.localVariables;
-    expect(localVariables, hasLength(2));
-    VariableElement firstVariable = localVariables[0];
-    VariableElement secondVariable = localVariables[1];
-    expect(firstVariable, isNotNull);
-    expect(secondVariable, isNotNull);
-    expect(
-        (firstVariable.name == localVariableName &&
-                secondVariable.name == exceptionParameterName) ||
-            (firstVariable.name == exceptionParameterName &&
-                secondVariable.name == localVariableName),
-        isTrue);
+
+    var v = findLocalVariable(code, 'v;');
+    expect(v.name, 'v');
+
+    var e = findLocalVariable(code, 'e) {}');
+    expect(e.name, 'e');
+
     List<LabelElement> labels = method.labels;
     expect(labels, hasLength(1));
     LabelElement label = labels[0];
     expect(label, isNotNull);
     expect(label.name, labelName);
   }
 
   void test_visitNamedFormalParameter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
@@ skipping 174 matching lines @@
     List<FieldElement> fields = holder.fields;
     expect(fields, hasLength(1));
     FieldElementImpl field = fields[0];
     expect(field, isNotNull);
     PropertyAccessorElementImpl setter = field.setter;
     expect(setter, isNotNull);
     expect(setter.parameters[0].isCovariant, isTrue);
   }
 
   void test_visitVariableDeclaration_inConstructor() {
-    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, 16, 10);
-    expect(variableElement.hasImplicitType, isTrue);
-    expect(variableElement.name, 'v');
-    _assertVisibleRange(variableElement, 14, 28);
+    var code = 'class C { C() { var v = 1; } }';
+    buildElementsForText(code);
+    var v = findLocalVariable(code, 'v =');
+    assertHasCodeRange(v, 16, 10);
+    expect(v.hasImplicitType, isTrue);
+    expect(v.name, 'v');
+    _assertVisibleRange(v, 14, 28);
   }
 
   void test_visitVariableDeclaration_inForEachStatement() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     //
     // m() { for (var v in []) }
     //
     String variableName = "v";
-    Statement statement = AstTestFactory.forEachStatement(
-        AstTestFactory.declaredIdentifier3('v'),
-        AstTestFactory.listLiteral(),
-        AstTestFactory.block());
+    DeclaredIdentifier variableIdentifier =
+        AstTestFactory.declaredIdentifier3('v');
+    Statement statement = AstTestFactory.forEachStatement(variableIdentifier,
+        AstTestFactory.listLiteral(), AstTestFactory.block());
     _setNodeSourceRange(statement, 100, 110);
     MethodDeclaration method = AstTestFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstTestFactory.identifier3("m"),
         AstTestFactory.formalParameterList(),
         AstTestFactory.blockFunctionBody2([statement]));
     _setBlockBodySourceRange(method.body, 200, 220);
     method.accept(builder);
 
     List<MethodElement> methods = holder.methods;
     expect(methods, hasLength(1));
-    List<LocalVariableElement> variableElements = methods[0].localVariables;
-    expect(variableElements, hasLength(1));
-    LocalVariableElement variableElement = variableElements[0];
+    LocalVariableElement variableElement = variableIdentifier.element;
     expect(variableElement.name, variableName);
     _assertVisibleRange(variableElement, 100, 110);
   }
 
   void test_visitVariableDeclaration_inForStatement() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     //
     // m() { for (T v;;) }
     //
     String variableName = "v";
+    VariableDeclaration variableIdentifier =
+        AstTestFactory.variableDeclaration('v');
     ForStatement statement = AstTestFactory.forStatement2(
         AstTestFactory.variableDeclarationList(
-            null,
-            AstTestFactory.typeName4('T'),
-            [AstTestFactory.variableDeclaration('v')]),
+            null, AstTestFactory.typeName4('T'), [variableIdentifier]),
         null,
         null,
         AstTestFactory.block());
     _setNodeSourceRange(statement, 100, 110);
     MethodDeclaration method = AstTestFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstTestFactory.identifier3("m"),
         AstTestFactory.formalParameterList(),
         AstTestFactory.blockFunctionBody2([statement]));
     _setBlockBodySourceRange(method.body, 200, 220);
     method.accept(builder);
 
     List<MethodElement> methods = holder.methods;
     expect(methods, hasLength(1));
-    List<LocalVariableElement> variableElements = methods[0].localVariables;
-    expect(variableElements, hasLength(1));
-    LocalVariableElement variableElement = variableElements[0];
+    LocalVariableElement variableElement = variableIdentifier.element;
     expect(variableElement.name, variableName);
     _assertVisibleRange(variableElement, 100, 110);
   }
 
   void test_visitVariableDeclaration_inMethod() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     //
     // m() {T v;}
     //
     String variableName = "v";
     VariableDeclaration variable =
         AstTestFactory.variableDeclaration2(variableName, null);
     Statement statement = AstTestFactory.variableDeclarationStatement(
         null, AstTestFactory.typeName4('T'), [variable]);
     MethodDeclaration method = AstTestFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstTestFactory.identifier3("m"),
         AstTestFactory.formalParameterList(),
         AstTestFactory.blockFunctionBody2([statement]));
     _setBlockBodySourceRange(method.body, 100, 110);
     method.accept(builder);
 
     List<MethodElement> methods = holder.methods;
     expect(methods, hasLength(1));
-    List<LocalVariableElement> variableElements = methods[0].localVariables;
-    expect(variableElements, hasLength(1));
-    LocalVariableElement variableElement = variableElements[0];
+    LocalVariableElement variableElement = variable.element;
     expect(variableElement.hasImplicitType, isFalse);
     expect(variableElement.name, variableName);
     _assertVisibleRange(variableElement, 100, 110);
   }
 
   void test_visitVariableDeclaration_localNestedInFunction() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     //
     // var f = () {var v;};
@@ skipping 15 matching lines @@
 
     List<FieldElement> variables = holder.fields;
     expect(variables, hasLength(1));
     FieldElement fieldElement = variables[0];
     expect(fieldElement, isNotNull);
     FunctionElement initializerElement = fieldElement.initializer;
     expect(initializerElement, isNotNull);
     expect(initializerElement.hasImplicitReturnType, isTrue);
     List<FunctionElement> functionElements = initializerElement.functions;
     expect(functionElements, hasLength(1));
-    List<LocalVariableElement> variableElements =
-        functionElements[0].localVariables;
-    expect(variableElements, hasLength(1));
-    LocalVariableElement variableElement = variableElements[0];
+    LocalVariableElement variableElement = variable.element;
     expect(variableElement.hasImplicitType, isTrue);
     expect(variableElement.isConst, isFalse);
     expect(variableElement.isFinal, isFalse);
     expect(variableElement.isSynthetic, isFalse);
     expect(variableElement.name, variableName);
   }
 
   void test_visitVariableDeclaration_noInitializer() {
     // var v;
     ElementHolder holder = new ElementHolder();
@@ skipping 128 matching lines @@
 }
 
 @reflectiveTest
 class LocalElementBuilderTest extends _BaseTest {
   @override
   AstVisitor createElementBuilder(ElementHolder holder) {
     return new LocalElementBuilder(holder, compilationUnitElement);
   }
 
   void test_buildLocalElements() {
-    CompilationUnit unit = parseCompilationUnit(r'''
+    var code = r'''
 main() {
   int v1;
   f1() {
     int v2;
     f2() {
       int v3;
     }
   }
 }
-''');
-    var mainAst = unit.declarations.single as FunctionDeclaration;
+''';
+    _compilationUnit = parseCompilationUnit(code);
+    var mainAst = _compilationUnit.declarations.single as FunctionDeclaration;
+
     // Build API elements.
     FunctionElementImpl main;
     {
       ElementHolder holder = new ElementHolder();
-      unit.accept(new ApiElementBuilder(holder, compilationUnitElement));
+      _compilationUnit
+          .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']);
+
+    var v1 = findLocalVariable(code, 'v1;');
+    var v2 = findLocalVariable(code, 'v2;');
+    var v3 = findLocalVariable(code, 'v3;');
+
+    expect(v1.enclosingElement, main);
     expect(main.functions, hasLength(1));
     {
       FunctionElement f1 = main.functions[0];
       expect(f1.name, 'f1');
-      expect(f1.localVariables.map((v) => v.name), ['v2']);
+      expect(v2.enclosingElement, f1);
       expect(f1.functions, hasLength(1));
       {
         FunctionElement f2 = f1.functions[0];
         expect(f2.name, 'f2');
-        expect(f2.localVariables.map((v) => v.name), ['v3']);
+        expect(v3.enclosingElement, f2);
         expect(f2.functions, isEmpty);
       }
     }
   }
 
   void test_buildParameterInitializer() {
     CompilationUnit unit = parseCompilationUnit('f({p: 42}) {}');
     var function = unit.declarations.single as FunctionDeclaration;
     var parameter = function.functionExpression.parameters.parameters.single
         as DefaultFormalParameter;
@@ skipping 57 matching lines @@
     {
       ElementHolder holder = new ElementHolder();
       unit.accept(new ApiElementBuilder(holder, compilationUnitElement));
       main = holder.functions.single as FunctionElementImpl;
     }
     // 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.functions, hasLength(1));
     FunctionElement f = main.functions[0];
     expect(f.parameters, hasLength(1));
     expect(f.parameters[0].initializer, isNotNull);
   }
 
   void test_visitFieldFormalParameter() {
     CompilationUnit unit = parseCompilationUnit(
         r'''
 main() {
@@ skipping 24 matching lines @@
     ParameterElement a = parameters[0].element;
     expect(a, isNotNull);
     expect(a.name, 'a');
 
     ParameterElement b = parameters[1].element;
     expect(b, isNotNull);
     expect(b.name, 'b');
   }
 
   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);
+    var code = 'class C { m() { T v = null; } }';
+    buildElementsForText(code);
+    LocalVariableElement element = findIdentifier(code, 'v =').staticElement;
+    expect(element.hasImplicitType, isFalse);
+    expect(element.name, 'v');
+    expect(element.initializer, isNotNull);
+    _assertVisibleRange(element, 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;
@@ skipping 455 matching lines @@
     ElementHolder holder = buildElementsForAst(constructorDeclaration);
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isExternal, isTrue);
     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));
   }
 
   void test_visitConstructorDeclaration_factory() {
     String className = "A";
     ConstructorDeclaration constructorDeclaration =
         AstTestFactory.constructorDeclaration2(
             null,
             Keyword.FACTORY,
             AstTestFactory.identifier3(className),
             null,
             AstTestFactory.formalParameterList(),
             null,
             AstTestFactory.blockFunctionBody2());
 
     ElementHolder holder = buildElementsForAst(constructorDeclaration);
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isExternal, isFalse);
     expect(constructor.isFactory, isTrue);
     expect(constructor.name, "");
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
-    expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, hasLength(0));
   }
 
   void test_visitConstructorDeclaration_minimal() {
     String className = "A";
     ConstructorDeclaration constructorDeclaration =
         AstTestFactory.constructorDeclaration2(
             null,
             null,
             AstTestFactory.identifier3(className),
@@ skipping 11 matching lines @@
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     assertHasCodeRange(constructor, 50, 31);
     expect(constructor.documentationComment, '/// aaa');
     expect(constructor.isExternal, isFalse);
     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));
   }
 
   void test_visitConstructorDeclaration_named() {
     String className = "A";
     String constructorName = "c";
     ConstructorDeclaration constructorDeclaration =
         AstTestFactory.constructorDeclaration2(
             null,
             null,
             AstTestFactory.identifier3(className),
             constructorName,
             AstTestFactory.formalParameterList(),
             null,
             AstTestFactory.blockFunctionBody2());
 
     ElementHolder holder = buildElementsForAst(constructorDeclaration);
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isExternal, isFalse);
     expect(constructor.isFactory, isFalse);
     expect(constructor.name, constructorName);
     expect(constructor.functions, hasLength(0));
     expect(constructor.labels, hasLength(0));
-    expect(constructor.localVariables, hasLength(0));
     expect(constructor.parameters, hasLength(0));
     expect(constructorDeclaration.name.staticElement, same(constructor));
     expect(constructorDeclaration.element, same(constructor));
   }
 
   void test_visitConstructorDeclaration_unnamed() {
     String className = "A";
     ConstructorDeclaration constructorDeclaration =
         AstTestFactory.constructorDeclaration2(
             null,
             null,
             AstTestFactory.identifier3(className),
             null,
             AstTestFactory.formalParameterList(),
             null,
             AstTestFactory.blockFunctionBody2());
 
     ElementHolder holder = buildElementsForAst(constructorDeclaration);
     List<ConstructorElement> constructors = holder.constructors;
     expect(constructors, hasLength(1));
     ConstructorElement constructor = constructors[0];
     expect(constructor, isNotNull);
     expect(constructor.isExternal, isFalse);
     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_visitEnumDeclaration() {
     String enumName = "E";
     EnumDeclaration enumDeclaration =
         AstTestFactory.enumDeclaration2(enumName, ["ONE"]);
     enumDeclaration.documentationComment = AstTestFactory.documentationComment(
         [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
@@ skipping 270 matching lines @@
 
     ElementHolder holder = buildElementsForAst(methodDeclaration);
     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.functions, hasLength(0));
     expect(method.labels, hasLength(0));
-    expect(method.localVariables, hasLength(0));
     expect(method.parameters, hasLength(0));
     expect(method.typeParameters, hasLength(0));
     expect(method.isAbstract, isTrue);
     expect(method.isExternal, isFalse);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_duplicateField_synthetic() {
     buildElementsForText(r'''
@@ skipping 48 matching lines @@
 
     ElementHolder holder = buildElementsForAst(methodDeclaration);
     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.functions, hasLength(0));
     expect(method.labels, hasLength(0));
-    expect(method.localVariables, hasLength(0));
     expect(method.parameters, hasLength(0));
     expect(method.typeParameters, hasLength(0));
     expect(method.isAbstract, isFalse);
     expect(method.isExternal, isTrue);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_getter() {
     // get m() {}
@@ skipping 25 matching lines @@
     expect(getter.documentationComment, '/// aaa');
     expect(getter.hasImplicitReturnType, isTrue);
     expect(getter.isAbstract, isFalse);
     expect(getter.isExternal, isFalse);
     expect(getter.isGetter, isTrue);
     expect(getter.isSynthetic, isFalse);
     expect(getter.name, methodName);
     expect(getter.variable, field);
     expect(getter.functions, hasLength(0));
     expect(getter.labels, hasLength(0));
-    expect(getter.localVariables, hasLength(0));
     expect(getter.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_getter_abstract() {
     // get m();
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstTestFactory.methodDeclaration2(
         null,
         null,
         Keyword.GET,
@@ skipping 14 matching lines @@
     expect(getter, isNotNull);
     expect(getter.hasImplicitReturnType, isTrue);
     expect(getter.isAbstract, isTrue);
     expect(getter.isExternal, isFalse);
     expect(getter.isGetter, isTrue);
     expect(getter.isSynthetic, isFalse);
     expect(getter.name, methodName);
     expect(getter.variable, field);
     expect(getter.functions, hasLength(0));
     expect(getter.labels, hasLength(0));
-    expect(getter.localVariables, hasLength(0));
     expect(getter.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_getter_external() {
     // external get m();
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstTestFactory.methodDeclaration(
         null,
         null,
         Keyword.GET,
@@ skipping 15 matching lines @@
     expect(getter, isNotNull);
     expect(getter.hasImplicitReturnType, isTrue);
     expect(getter.isAbstract, isFalse);
     expect(getter.isExternal, isTrue);
     expect(getter.isGetter, isTrue);
     expect(getter.isSynthetic, isFalse);
     expect(getter.name, methodName);
     expect(getter.variable, field);
     expect(getter.functions, hasLength(0));
     expect(getter.labels, hasLength(0));
-    expect(getter.localVariables, hasLength(0));
     expect(getter.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_minimal() {
     // T m() {}
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstTestFactory.methodDeclaration2(
         null,
         AstTestFactory.typeName4('T'),
         null,
@@ skipping 10 matching lines @@
     List<MethodElement> methods = holder.methods;
     expect(methods, hasLength(1));
     MethodElement method = methods[0];
     expect(method, isNotNull);
     assertHasCodeRange(method, 50, 31);
     expect(method.documentationComment, '/// aaa');
     expect(method.hasImplicitReturnType, isFalse);
     expect(method.name, methodName);
     expect(method.functions, hasLength(0));
     expect(method.labels, hasLength(0));
-    expect(method.localVariables, hasLength(0));
     expect(method.parameters, hasLength(0));
     expect(method.typeParameters, hasLength(0));
     expect(method.isAbstract, isFalse);
     expect(method.isExternal, isFalse);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_operator() {
     // operator +(addend) {}
@@ skipping 10 matching lines @@
 
     ElementHolder holder = buildElementsForAst(methodDeclaration);
     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.functions, hasLength(0));
     expect(method.labels, hasLength(0));
-    expect(method.localVariables, hasLength(0));
     expect(method.parameters, hasLength(1));
     expect(method.typeParameters, hasLength(0));
     expect(method.isAbstract, isFalse);
     expect(method.isExternal, isFalse);
     expect(method.isStatic, isFalse);
     expect(method.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_setter() {
     // set m() {}
@@ skipping 27 matching lines @@
     expect(setter.hasImplicitReturnType, isTrue);
     expect(setter.isAbstract, isFalse);
     expect(setter.isExternal, isFalse);
     expect(setter.isSetter, isTrue);
     expect(setter.isSynthetic, isFalse);
     expect(setter.name, "$methodName=");
     expect(setter.displayName, methodName);
     expect(setter.variable, field);
     expect(setter.functions, hasLength(0));
     expect(setter.labels, hasLength(0));
-    expect(setter.localVariables, hasLength(0));
     expect(setter.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_setter_abstract() {
     // set m();
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstTestFactory.methodDeclaration2(
         null,
         null,
         Keyword.SET,
@@ skipping 15 matching lines @@
     expect(setter.hasImplicitReturnType, isTrue);
     expect(setter.isAbstract, isTrue);
     expect(setter.isExternal, isFalse);
     expect(setter.isSetter, isTrue);
     expect(setter.isSynthetic, isFalse);
     expect(setter.name, "$methodName=");
     expect(setter.displayName, methodName);
     expect(setter.variable, field);
     expect(setter.functions, hasLength(0));
     expect(setter.labels, hasLength(0));
-    expect(setter.localVariables, hasLength(0));
     expect(setter.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_setter_external() {
     // external m();
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstTestFactory.methodDeclaration(
         null,
         null,
         Keyword.SET,
@@ skipping 16 matching lines @@
     expect(setter.hasImplicitReturnType, isTrue);
     expect(setter.isAbstract, isFalse);
     expect(setter.isExternal, isTrue);
     expect(setter.isSetter, isTrue);
     expect(setter.isSynthetic, isFalse);
     expect(setter.name, "$methodName=");
     expect(setter.displayName, methodName);
     expect(setter.variable, field);
     expect(setter.functions, hasLength(0));
     expect(setter.labels, hasLength(0));
-    expect(setter.localVariables, hasLength(0));
     expect(setter.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_static() {
     // static m() {}
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstTestFactory.methodDeclaration2(
         Keyword.STATIC,
         null,
         null,
         null,
         AstTestFactory.identifier3(methodName),
         AstTestFactory.formalParameterList(),
         AstTestFactory.blockFunctionBody2());
     ElementHolder holder = buildElementsForAst(methodDeclaration);
     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.functions, hasLength(0));
     expect(method.labels, hasLength(0));
-    expect(method.localVariables, hasLength(0));
     expect(method.parameters, hasLength(0));
     expect(method.typeParameters, hasLength(0));
     expect(method.isAbstract, isFalse);
     expect(method.isExternal, isFalse);
     expect(method.isStatic, isTrue);
     expect(method.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_typeParameters() {
     // m<E>() {}
@@ skipping 10 matching lines @@
 
     ElementHolder holder = buildElementsForAst(methodDeclaration);
     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.functions, hasLength(0));
     expect(method.labels, hasLength(0));
-    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_visitTypeAlias_minimal() {
     String aliasName = "F";
@@ skipping 139 matching lines @@
     expect(element.metadata, hasLength(1));
     expect(element.metadata[0], new isInstanceOf<ElementAnnotationImpl>());
     ElementAnnotationImpl elementAnnotation = element.metadata[0];
     expect(elementAnnotation.element, isNull); // Not yet resolved
     expect(elementAnnotation.compilationUnit, isNotNull);
     expect(elementAnnotation.compilationUnit, compilationUnitElement);
   }
 
   AstVisitor createElementBuilder(ElementHolder holder);
 
+  SimpleIdentifier findIdentifier(String code, String prefix) {
+    return EngineTestCase.findSimpleIdentifier(compilationUnit, code, prefix);
+  }
+
+  LocalVariableElement findLocalVariable(String code, String prefix) {
+    return findIdentifier(code, prefix).staticElement;
+  }
+
   void setUp() {
     compilationUnitElement = new CompilationUnitElementImpl('test.dart');
   }
 
   void _assertVisibleRange(LocalElement element, int offset, int end) {
     SourceRange visibleRange = element.visibleRange;
     expect(visibleRange.offset, offset);
     expect(visibleRange.end, end);
   }
 
   /**
    * Parse the given [code], and visit it with the given [visitor].
    * Fail if any error is logged.
    */
   void _visitAstOfCode(String code, AstVisitor visitor) {
     TestLogger logger = new TestLogger();
     AnalysisEngine.instance.logger = logger;
     try {
       _compilationUnit = parseCompilationUnit(code);
       compilationUnit.accept(visitor);
     } finally {
       expect(logger.log, hasLength(0));
       AnalysisEngine.instance.logger = Logger.NULL;
     }
   }
 }