Remove ExecutableElement.labels usages 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';
@@ skipping 463 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() {
-    List<LabelElement> labels =
-        buildElementsForText('f() { l: print(42); }').functions[0].labels;
-    expect(labels, hasLength(1));
-    LabelElement label = labels[0];
+    String code = 'f() { l: print(42); }';
+    buildElementsForText(code);
+    LabelElement label = findLabel(code, 'l:');
     expect(label, isNotNull);
     expect(label.name, 'l');
     expect(label.isSynthetic, isFalse);
   }
 
   void test_visitMethodDeclaration_withMembers() {
     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";
@@ skipping 11 matching lines @@
     VariableElement parameter = parameters[0];
     expect(parameter, isNotNull);
     expect(parameter.name, parameterName);
 
     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];
+    LabelElement label = findLabel(code, 'l:');
     expect(label, isNotNull);
     expect(label.name, labelName);
   }
 
   void test_visitNamedFormalParameter() {
     ElementHolder holder = new ElementHolder();
     ElementBuilder builder = _makeBuilder(holder);
     String parameterName = "p";
     DefaultFormalParameter formalParameter =
         AstTestFactory.namedFormalParameter(
@@ skipping 1101 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.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.parameters, hasLength(0));
   }
 
   void test_visitConstructorDeclaration_minimal() {
     String className = "A";
     ConstructorDeclaration constructorDeclaration =
         AstTestFactory.constructorDeclaration2(
             null,
             null,
             AstTestFactory.identifier3(className),
@@ skipping 10 matching lines @@
     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.labels, 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.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.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 269 matching lines @@
         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.labels, 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 47 matching lines @@
         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.labels, 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 24 matching lines @@
     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.labels, 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 13 matching lines @@
     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.labels, 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 14 matching lines @@
     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.labels, 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.labels, 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.labels, 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 26 matching lines @@
     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.labels, 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 14 matching lines @@
     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.labels, 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 15 matching lines @@
     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.labels, 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.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.labels, 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 147 matching lines @@
   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;
   }
 
+  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;
     }
   }
 }