Stop using ExecutableElement.functions in tests.

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';
 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/dart/error/syntactic_errors.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_test_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
+import 'package:analyzer/src/generated/testing/element_search.dart';
+import 'package:analyzer/src/generated/testing/node_search.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(() {
@@ skipping 42 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.functions, isEmpty);
+    expect(
+        findDeclaredIdentifiersByName(compilationUnit, 'v')
+            .single
+            .staticElement,
+        isNull);
+    expect(
+        findDeclaredIdentifiersByName(compilationUnit, 'localFunction')
+            .single
+            .staticElement,
+        isNull);
   }
 
   void test_api_topLevelFunction_blockBody() {
-    FunctionElement function = buildElementsForText(r'''
+    FunctionElement topLevelFunction = buildElementsForText(r'''
 void topLevelFunction() {
   int v = 0;
   localFunction() {}
 }
 ''').functions[0];
-    expect(function.functions, isEmpty);
+    expect(topLevelFunction, isNotNull);
+    expect(topLevelFunction.name, 'topLevelFunction');
+    expect(
+        findDeclaredIdentifiersByName(compilationUnit, 'v')
+            .single
+            .staticElement,
+        isNull);
+    expect(
+        findDeclaredIdentifiersByName(compilationUnit, 'localFunction')
+            .single
+            .staticElement,
+        isNull);
   }
 
   void test_api_topLevelFunction_expressionBody() {
-    FunctionElement function = buildElementsForText(r'''
+    FunctionElement topLevelFunction = buildElementsForText(r'''
 topLevelFunction() => () {
   int localVar = 0;
 };
 ''').functions[0];
-    expect(function.functions, isEmpty);
+    expect(topLevelFunction, isNotNull);
+    expect(topLevelFunction.name, 'topLevelFunction');
+    expect(
+        findDeclaredIdentifiersByName(compilationUnit, 'localVar')
+            .single
+            .staticElement,
+        isNull);
   }
 
   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 245 matching lines @@
     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];
+    buildElementsForText('f() { return () => 42; }');
+    FunctionDeclaration f = compilationUnit.declarations[0];
+    BlockFunctionBody fBody = f.functionExpression.body;
+    ReturnStatement returnStatement = fBody.block.statements[0];
+    FunctionExpression closure = returnStatement.expression;
+    FunctionElement function = closure.element;
     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];
+    buildElementsForText('f() => () => 42;');
+    FunctionDeclaration f = compilationUnit.declarations[0];
+    ExpressionFunctionBody fBody = f.functionExpression.body;
+    FunctionExpression closure = fBody.expression;
+    FunctionElement function = closure.element;
     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";
@@ skipping 422 matching lines @@
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     //
     // var f = () {var v;};
     //
     String variableName = "v";
     VariableDeclaration variable =
         AstTestFactory.variableDeclaration2(variableName, null);
     Statement statement =
         AstTestFactory.variableDeclarationStatement2(null, [variable]);
-    Expression initializer = AstTestFactory.functionExpression2(
+    FunctionExpression initializer = AstTestFactory.functionExpression2(
         AstTestFactory.formalParameterList(),
         AstTestFactory.blockFunctionBody2([statement]));
     String fieldName = "f";
     VariableDeclaration field =
         AstTestFactory.variableDeclaration2(fieldName, initializer);
     FieldDeclaration fieldDeclaration =
         AstTestFactory.fieldDeclaration2(false, null, [field]);
     fieldDeclaration.accept(builder);
 
     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));
+    expect(initializer.element, new isInstanceOf<FunctionElement>());
     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;
@@ skipping 151 matching lines @@
     var mainAst = _compilationUnit.declarations.single as FunctionDeclaration;
 
     // Build API elements.
     FunctionElementImpl main;
     {
       ElementHolder holder = new ElementHolder();
       _compilationUnit
           .accept(new ApiElementBuilder(holder, compilationUnitElement));
       main = holder.functions.single as FunctionElementImpl;
     }
-    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.encloseElements(holder.functions);
     main.encloseElements(holder.localVariables);
 
+    var f1 = findLocalFunction(code, 'f1() {');
+    var f2 = findLocalFunction(code, 'f2() {');
     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(v2.enclosingElement, f1);
-      expect(f1.functions, hasLength(1));
       {
-        FunctionElement f2 = f1.functions[0];
         expect(f2.name, 'f2');
         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;
     // Build API elements.
@@ skipping 55 matching lines @@
     FunctionElementImpl main;
     {
       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;
-    expect(main.functions, hasLength(1));
-    FunctionElement f = main.functions[0];
+
+    List<FunctionElement> functions = holder.functions;
+    main.encloseElements(functions);
+
+    FunctionElement f = findElementsByName(unit, 'f').single;
     expect(f.parameters, hasLength(1));
     expect(f.parameters[0].initializer, isNotNull);
   }
 
   void test_visitFieldFormalParameter() {
     CompilationUnit unit = parseCompilationUnit(
         r'''
 main() {
   f(a, this.b) {}
 }
@@ skipping 291 matching lines @@
 class C {
   @A(f: () {})
   void m() {}
 }
 ''';
     ElementHolder holder = buildElementsForText(code);
     ClassElement elementC = holder.types[1];
     expect(elementC, isNotNull);
     MethodElement methodM = elementC.methods[0];
     expect(methodM, isNotNull);
-    expect(methodM.functions, isEmpty);
   }
 
   void test_visitClassDeclaration_minimal() {
     String className = "C";
     ClassDeclaration classDeclaration = AstTestFactory.classDeclaration(
         null, className, null, null, null, null);
     classDeclaration.documentationComment = AstTestFactory.documentationComment(
         [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
     classDeclaration.endToken.offset = 80;
 
@@ skipping 190 matching lines @@
         TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
 
     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.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.parameters, hasLength(0));
   }
 
   void test_visitConstructorDeclaration_minimal() {
     String className = "A";
     ConstructorDeclaration constructorDeclaration =
         AstTestFactory.constructorDeclaration2(
             null,
             null,
             AstTestFactory.identifier3(className),
             null,
             AstTestFactory.formalParameterList(),
             null,
             AstTestFactory.blockFunctionBody2());
     constructorDeclaration.documentationComment = AstTestFactory
         .documentationComment(
             [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
     constructorDeclaration.endToken.offset = 80;
 
     ElementHolder holder = buildElementsForAst(constructorDeclaration);
     List<ConstructorElement> constructors = holder.constructors;
     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.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.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.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 268 matching lines @@
         AstTestFactory.formalParameterList(),
         AstTestFactory.emptyFunctionBody());
 
     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.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 46 matching lines @@
     methodDeclaration.externalKeyword =
         TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
 
     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.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 23 matching lines @@
     expect(getter, isNotNull);
     assertHasCodeRange(getter, 50, 31);
     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.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_getter_abstract() {
     // get m();
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstTestFactory.methodDeclaration2(
         null,
         null,
         Keyword.GET,
@@ skipping 12 matching lines @@
     expect(field.setter, isNull);
     PropertyAccessorElement getter = field.getter;
     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.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_getter_external() {
     // external get m();
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstTestFactory.methodDeclaration(
         null,
         null,
         Keyword.GET,
@@ skipping 13 matching lines @@
     expect(field.setter, isNull);
     PropertyAccessorElement getter = field.getter;
     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.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_minimal() {
     // T m() {}
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstTestFactory.methodDeclaration2(
         null,
         AstTestFactory.typeName4('T'),
         null,
         null,
         AstTestFactory.identifier3(methodName),
         AstTestFactory.formalParameterList(),
         AstTestFactory.blockFunctionBody2());
     methodDeclaration.documentationComment = AstTestFactory
         .documentationComment(
             [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
     methodDeclaration.endToken.offset = 80;
 
     ElementHolder holder = buildElementsForAst(methodDeclaration);
     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.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) {}
     String methodName = "+";
     MethodDeclaration methodDeclaration = AstTestFactory.methodDeclaration2(
         null,
         null,
         null,
         Keyword.OPERATOR,
         AstTestFactory.identifier3(methodName),
         AstTestFactory.formalParameterList(
             [AstTestFactory.simpleFormalParameter3("addend")]),
         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.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 25 matching lines @@
     assertHasCodeRange(setter, 50, 31);
     expect(setter.documentationComment, '/// aaa');
     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.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_setter_abstract() {
     // set m();
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstTestFactory.methodDeclaration2(
         null,
         null,
         Keyword.SET,
@@ skipping 13 matching lines @@
     PropertyAccessorElement setter = field.setter;
     expect(setter, isNotNull);
     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.parameters, hasLength(0));
   }
 
   void test_visitMethodDeclaration_setter_external() {
     // external m();
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstTestFactory.methodDeclaration(
         null,
         null,
         Keyword.SET,
@@ skipping 14 matching lines @@
     PropertyAccessorElement setter = field.setter;
     expect(setter, isNotNull);
     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.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.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>() {}
     String methodName = "m";
     MethodDeclaration methodDeclaration = AstTestFactory.methodDeclaration2(
         null,
         null,
         null,
         null,
         AstTestFactory.identifier3(methodName),
         AstTestFactory.formalParameterList(),
         AstTestFactory.blockFunctionBody2());
     methodDeclaration.typeParameters = AstTestFactory.typeParameterList(['E']);
 
     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.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 143 matching lines @@
     expect(elementAnnotation.compilationUnit, isNotNull);
     expect(elementAnnotation.compilationUnit, compilationUnitElement);
   }
 
   AstVisitor createElementBuilder(ElementHolder holder);
 
   SimpleIdentifier findIdentifier(String code, String prefix) {
     return EngineTestCase.findSimpleIdentifier(compilationUnit, code, prefix);
   }
 
+  LabelElement findLabel(String code, String prefix) {
+    return findIdentifier(code, prefix).staticElement;
+  }
+
+  FunctionElement findLocalFunction(String code, String prefix) {
+    return findIdentifier(code, prefix).staticElement;
+  }
+
   LocalVariableElement findLocalVariable(String code, String prefix) {
     return findIdentifier(code, prefix).staticElement;
   }
 
-  LabelElement findLabel(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;
     }
   }
 }