| Index: pkg/analyzer/test/dart/element/builder_test.dart
|
| diff --git a/pkg/analyzer/test/dart/element/builder_test.dart b/pkg/analyzer/test/dart/element/builder_test.dart
|
| index 1b19b30a6494cc2e6b8becedc4806c59e85600b3..224b192d1efd379b0d042b7b7b7638e7cb75d489 100644
|
| --- a/pkg/analyzer/test/dart/element/builder_test.dart
|
| +++ b/pkg/analyzer/test/dart/element/builder_test.dart
|
| @@ -25,62 +25,145 @@ import '../../generated/test_support.dart';
|
|
|
| main() {
|
| defineReflectiveSuite(() {
|
| + defineReflectiveTests(ApiElementBuilderTest);
|
| defineReflectiveTests(ElementBuilderTest);
|
| });
|
| }
|
|
|
| @reflectiveTest
|
| -class ElementBuilderTest extends ParserTestCase {
|
| - CompilationUnitElement compilationUnitElement;
|
| - CompilationUnit compilationUnit;
|
| +class ApiElementBuilderTest extends _BaseTest with _ApiElementBuilderTestMixin {
|
| + @override
|
| + AstVisitor createElementBuilder(ElementHolder holder) {
|
| + return new ApiElementBuilder(holder, compilationUnitElement);
|
| + }
|
|
|
| - /**
|
| - * Parse the given [code], pass it through [ElementBuilder], and return the
|
| - * resulting [ElementHolder].
|
| - */
|
| - ElementHolder buildElementsForText(String code) {
|
| - TestLogger logger = new TestLogger();
|
| - AnalysisEngine.instance.logger = logger;
|
| - try {
|
| - compilationUnit = ParserTestCase.parseCompilationUnit(code);
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder =
|
| - new ElementBuilder(holder, compilationUnitElement);
|
| - compilationUnit.accept(builder);
|
| - return holder;
|
| - } finally {
|
| - expect(logger.log, hasLength(0));
|
| - AnalysisEngine.instance.logger = Logger.NULL;
|
| + void test_api_class_field() {
|
| + List<FieldElement> fields = buildElementsForText(r'''
|
| +class C {
|
| + var a = 42;
|
| + var b = () {
|
| + int v = 0;
|
| + localFunction() {}
|
| + };
|
| +}
|
| +''').types[0].fields;
|
| + expect(fields, hasLength(2));
|
| + {
|
| + FieldElement a = fields[0];
|
| + expect(a.displayName, 'a');
|
| + expect(a.initializer, isNull);
|
| + }
|
| + {
|
| + FieldElement b = fields[1];
|
| + expect(b.displayName, 'b');
|
| + expect(b.initializer, isNull);
|
| }
|
| }
|
|
|
| - /**
|
| - * Verify that the given [metadata] has exactly one annotation, and that its
|
| - * [ElementAnnotationImpl] is unresolved.
|
| - */
|
| - void checkAnnotation(NodeList<Annotation> metadata) {
|
| - expect(metadata, hasLength(1));
|
| - expect(metadata[0], new isInstanceOf<AnnotationImpl>());
|
| - AnnotationImpl annotation = metadata[0];
|
| - expect(annotation.elementAnnotation,
|
| - new isInstanceOf<ElementAnnotationImpl>());
|
| - ElementAnnotationImpl elementAnnotation = annotation.elementAnnotation;
|
| - expect(elementAnnotation.element, isNull); // Not yet resolved
|
| - expect(elementAnnotation.compilationUnit, isNotNull);
|
| - expect(elementAnnotation.compilationUnit, compilationUnitElement);
|
| + void test_api_class_method_blockBody() {
|
| + MethodElement method = buildElementsForText(r'''
|
| +class C {
|
| + void m(int a, {int b: 42}) {
|
| + int v = 0;
|
| + localFunction() {}
|
| + }
|
| +}
|
| +''').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));
|
| + {
|
| + ParameterElement a = parameters[0];
|
| + expect(a.displayName, 'a');
|
| + expect(a.initializer, isNull);
|
| + }
|
| + {
|
| + ParameterElement b = parameters[1];
|
| + expect(b.displayName, 'b');
|
| + expect(b.initializer, isNull);
|
| + expect(b.parameters, hasLength(1));
|
| + expect(b.parameters[0].displayName, 'b2');
|
| + }
|
| + {
|
| + var c = parameters[2] as DefaultParameterElementImpl;
|
| + expect(c.displayName, 'c');
|
| + expect(c.initializer, isNull);
|
| + }
|
| + }
|
| +
|
| + void test_api_topLevelVariable() {
|
| + List<TopLevelVariableElement> variables = buildElementsForText(r'''
|
| +var A = 42;
|
| +var B = () {
|
| + int v = 0;
|
| + localFunction(int _) {}
|
| +};
|
| +''').topLevelVariables;
|
| + expect(variables, hasLength(2));
|
| + {
|
| + TopLevelVariableElement a = variables[0];
|
| + expect(a.displayName, 'A');
|
| + expect(a.initializer, isNull);
|
| + }
|
| + {
|
| + TopLevelVariableElement b = variables[1];
|
| + expect(b.displayName, 'B');
|
| + expect(b.initializer, isNull);
|
| + }
|
| }
|
| +}
|
|
|
| +@reflectiveTest
|
| +class ElementBuilderTest extends _BaseTest with _ApiElementBuilderTestMixin {
|
| /**
|
| - * Verify that the given [element] has exactly one annotation, and that its
|
| - * [ElementAnnotationImpl] is unresolved.
|
| + * Parse the given [code], pass it through [ElementBuilder], and return the
|
| + * resulting [ElementHolder].
|
| */
|
| - void checkMetadata(Element element) {
|
| - 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);
|
| + ElementHolder buildElementsForText(String code) {
|
| + ElementHolder holder = new ElementHolder();
|
| + ElementBuilder builder = new ElementBuilder(holder, compilationUnitElement);
|
| + _visitAstOfCode(code, builder);
|
| + return holder;
|
| + }
|
| +
|
| + AstVisitor createElementBuilder(ElementHolder holder) {
|
| + return new ElementBuilder(holder, compilationUnitElement);
|
| }
|
|
|
| void fail_visitMethodDeclaration_setter_duplicate() {
|
| @@ -103,12 +186,61 @@ class C {
|
| compilationUnitElement = new CompilationUnitElementImpl('test.dart');
|
| }
|
|
|
| - void test_metadata_fieldDeclaration() {
|
| - List<FieldElement> fields =
|
| - buildElementsForText('class C { @a int x, y; }').types[0].fields;
|
| - checkMetadata(fields[0]);
|
| - checkMetadata(fields[1]);
|
| - expect(fields[0].metadata, same(fields[1].metadata));
|
| + 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() {
|
| @@ -121,31 +253,6 @@ class C {
|
| expect(localVariables[0].metadata, same(localVariables[1].metadata));
|
| }
|
|
|
| - void test_metadata_topLevelVariableDeclaration() {
|
| - List<TopLevelVariableElement> topLevelVariables =
|
| - buildElementsForText('@a int x, y;').topLevelVariables;
|
| - checkMetadata(topLevelVariables[0]);
|
| - checkMetadata(topLevelVariables[1]);
|
| - expect(topLevelVariables[0].metadata, same(topLevelVariables[1].metadata));
|
| - }
|
| -
|
| - void test_metadata_visitClassDeclaration() {
|
| - ClassElement classElement = buildElementsForText('@a class C {}').types[0];
|
| - checkMetadata(classElement);
|
| - }
|
| -
|
| - void test_metadata_visitClassTypeAlias() {
|
| - ClassElement classElement =
|
| - buildElementsForText('@a class C = D with E;').types[0];
|
| - checkMetadata(classElement);
|
| - }
|
| -
|
| - void test_metadata_visitConstructorDeclaration() {
|
| - ConstructorElement constructorElement =
|
| - buildElementsForText('class C { @a C(); }').types[0].constructors[0];
|
| - checkMetadata(constructorElement);
|
| - }
|
| -
|
| void test_metadata_visitDeclaredIdentifier() {
|
| LocalVariableElement localVariableElement =
|
| buildElementsForText('f() { for (@a var x in y) {} }')
|
| @@ -154,488 +261,1096 @@ class C {
|
| checkMetadata(localVariableElement);
|
| }
|
|
|
| - void test_metadata_visitDefaultFormalParameter_fieldFormalParameter() {
|
| - ParameterElement parameterElement =
|
| - buildElementsForText('class C { var x; C([@a this.x = null]); }')
|
| - .types[0]
|
| - .constructors[0]
|
| - .parameters[0];
|
| - checkMetadata(parameterElement);
|
| - }
|
| + 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));
|
|
|
| - void
|
| - test_metadata_visitDefaultFormalParameter_functionTypedFormalParameter() {
|
| - ParameterElement parameterElement =
|
| - buildElementsForText('f([@a g() = null]) {}').functions[0].parameters[
|
| - 0];
|
| - checkMetadata(parameterElement);
|
| - }
|
| + 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);
|
|
|
| - void test_metadata_visitDefaultFormalParameter_simpleFormalParameter() {
|
| - ParameterElement parameterElement =
|
| - buildElementsForText('f([@a gx = null]) {}').functions[0].parameters[0];
|
| - checkMetadata(parameterElement);
|
| + 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);
|
| }
|
|
|
| - void test_metadata_visitEnumDeclaration() {
|
| - ClassElement classElement =
|
| - buildElementsForText('@a enum E { v }').enums[0];
|
| - checkMetadata(classElement);
|
| + 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);
|
| }
|
|
|
| - void test_metadata_visitExportDirective() {
|
| - buildElementsForText('@a export "foo.dart";');
|
| - expect(compilationUnit.directives[0], new isInstanceOf<ExportDirective>());
|
| - ExportDirective exportDirective = compilationUnit.directives[0];
|
| - checkAnnotation(exportDirective.metadata);
|
| + void test_visitCompilationUnit_codeRange() {
|
| + TopLevelVariableDeclaration topLevelVariableDeclaration = AstFactory
|
| + .topLevelVariableDeclaration(null, AstFactory.typeName4('int'),
|
| + [AstFactory.variableDeclaration('V')]);
|
| + CompilationUnit unit = new 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_metadata_visitFieldFormalParameter() {
|
| - ParameterElement parameterElement =
|
| - buildElementsForText('class C { var x; C(@a this.x); }')
|
| - .types[0]
|
| - .constructors[0]
|
| - .parameters[0];
|
| - checkMetadata(parameterElement);
|
| + void test_visitDeclaredIdentifier_noType() {
|
| + LocalVariableElement variable =
|
| + buildElementsForText('f() { for (var i in []) {} }')
|
| + .functions[0]
|
| + .localVariables[0];
|
| + assertHasCodeRange(variable, 11, 5);
|
| + expect(variable, isNotNull);
|
| + expect(variable.hasImplicitType, isTrue);
|
| + expect(variable.isConst, isFalse);
|
| + expect(variable.isDeprecated, isFalse);
|
| + expect(variable.isFinal, isFalse);
|
| + expect(variable.isOverride, isFalse);
|
| + expect(variable.isPrivate, isFalse);
|
| + expect(variable.isPublic, isTrue);
|
| + expect(variable.isSynthetic, isFalse);
|
| + expect(variable.name, 'i');
|
| }
|
|
|
| - void test_metadata_visitFunctionDeclaration_function() {
|
| - FunctionElement functionElement =
|
| - buildElementsForText('@a f() {}').functions[0];
|
| - checkMetadata(functionElement);
|
| + void test_visitDeclaredIdentifier_type() {
|
| + LocalVariableElement variable =
|
| + buildElementsForText('f() { for (int i in []) {} }')
|
| + .functions[0]
|
| + .localVariables[0];
|
| + assertHasCodeRange(variable, 11, 5);
|
| + expect(variable.hasImplicitType, isFalse);
|
| + expect(variable.isConst, isFalse);
|
| + expect(variable.isDeprecated, isFalse);
|
| + expect(variable.isFinal, isFalse);
|
| + expect(variable.isOverride, isFalse);
|
| + expect(variable.isPrivate, isFalse);
|
| + expect(variable.isPublic, isTrue);
|
| + expect(variable.isSynthetic, isFalse);
|
| + expect(variable.name, 'i');
|
| }
|
|
|
| - void test_metadata_visitFunctionDeclaration_getter() {
|
| - PropertyAccessorElement propertyAccessorElement =
|
| - buildElementsForText('@a get f => null;').accessors[0];
|
| - checkMetadata(propertyAccessorElement);
|
| + 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);
|
| + expect(expression.element, same(function));
|
| + expect(function.hasImplicitReturnType, isTrue);
|
| + expect(function.isSynthetic, isFalse);
|
| + expect(function.typeParameters, hasLength(0));
|
| }
|
|
|
| - void test_metadata_visitFunctionDeclaration_setter() {
|
| - PropertyAccessorElement propertyAccessorElement =
|
| - buildElementsForText('@a set f(value) {}').accessors[0];
|
| - checkMetadata(propertyAccessorElement);
|
| + void test_visitFunctionExpression_inBlockBody() {
|
| + List<FunctionElement> functions =
|
| + buildElementsForText('f() { return () => 42; }').functions[0].functions;
|
| + expect(functions, hasLength(1));
|
| + FunctionElement function = functions[0];
|
| + expect(function, isNotNull);
|
| + expect(function.hasImplicitReturnType, isTrue);
|
| + expect(function.isSynthetic, isFalse);
|
| + expect(function.typeParameters, hasLength(0));
|
| }
|
|
|
| - void test_metadata_visitFunctionTypeAlias() {
|
| - FunctionTypeAliasElement functionTypeAliasElement =
|
| - buildElementsForText('@a typedef F();').typeAliases[0];
|
| - checkMetadata(functionTypeAliasElement);
|
| + void test_visitFunctionExpression_inExpressionBody() {
|
| + List<FunctionElement> functions =
|
| + buildElementsForText('f() => () => 42;').functions[0].functions;
|
| + expect(functions, hasLength(1));
|
| + FunctionElement function = functions[0];
|
| + expect(function, isNotNull);
|
| + expect(function.hasImplicitReturnType, isTrue);
|
| + expect(function.isSynthetic, isFalse);
|
| + expect(function.typeParameters, hasLength(0));
|
| }
|
|
|
| - void test_metadata_visitFunctionTypedFormalParameter() {
|
| - ParameterElement parameterElement =
|
| - buildElementsForText('f(@a g()) {}').functions[0].parameters[0];
|
| - checkMetadata(parameterElement);
|
| + void test_visitFunctionTypeAlias() {
|
| + ElementHolder holder = new ElementHolder();
|
| + ElementBuilder builder = _makeBuilder(holder);
|
| + String aliasName = "F";
|
| + String parameterName = "E";
|
| + FunctionTypeAlias aliasNode = AstFactory.typeAlias(
|
| + null, aliasName, AstFactory.typeParameterList([parameterName]), null);
|
| + aliasNode.documentationComment = AstFactory.documentationComment(
|
| + [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| + aliasNode.endToken.offset = 80;
|
| + aliasNode.accept(builder);
|
| +
|
| + List<FunctionTypeAliasElement> aliases = holder.typeAliases;
|
| + expect(aliases, hasLength(1));
|
| + FunctionTypeAliasElement alias = aliases[0];
|
| + expect(alias, isNotNull);
|
| + assertHasCodeRange(alias, 50, 31);
|
| + expect(alias.documentationComment, '/// aaa');
|
| + expect(alias.name, aliasName);
|
| + expect(alias.parameters, hasLength(0));
|
| + List<TypeParameterElement> typeParameters = alias.typeParameters;
|
| + expect(typeParameters, hasLength(1));
|
| + TypeParameterElement typeParameter = typeParameters[0];
|
| + expect(typeParameter, isNotNull);
|
| + expect(typeParameter.name, parameterName);
|
| }
|
|
|
| - void test_metadata_visitImportDirective() {
|
| - buildElementsForText('@a import "foo.dart";');
|
| - expect(compilationUnit.directives[0], new isInstanceOf<ImportDirective>());
|
| - ImportDirective importDirective = compilationUnit.directives[0];
|
| - checkAnnotation(importDirective.metadata);
|
| + void test_visitFunctionTypedFormalParameter() {
|
| + ElementHolder holder = new ElementHolder();
|
| + ElementBuilder builder = _makeBuilder(holder);
|
| + String parameterName = "p";
|
| + FunctionTypedFormalParameter formalParameter =
|
| + AstFactory.functionTypedFormalParameter(null, parameterName);
|
| + _useParameterInMethod(formalParameter, 100, 110);
|
| + formalParameter.accept(builder);
|
| + List<ParameterElement> parameters = holder.parameters;
|
| + expect(parameters, hasLength(1));
|
| + ParameterElement parameter = parameters[0];
|
| + expect(parameter, isNotNull);
|
| + expect(parameter.name, parameterName);
|
| + expect(parameter.initializer, isNull);
|
| + expect(parameter.isConst, isFalse);
|
| + expect(parameter.isFinal, isFalse);
|
| + expect(parameter.isSynthetic, isFalse);
|
| + expect(parameter.parameterKind, ParameterKind.REQUIRED);
|
| + _assertVisibleRange(parameter, 100, 110);
|
| }
|
|
|
| - void test_metadata_visitLibraryDirective() {
|
| - buildElementsForText('@a library L;');
|
| - expect(compilationUnit.directives[0], new isInstanceOf<LibraryDirective>());
|
| - LibraryDirective libraryDirective = compilationUnit.directives[0];
|
| - checkAnnotation(libraryDirective.metadata);
|
| + void test_visitFunctionTypedFormalParameter_withTypeParameters() {
|
| + ElementHolder holder = new ElementHolder();
|
| + ElementBuilder builder = _makeBuilder(holder);
|
| + String parameterName = "p";
|
| + FunctionTypedFormalParameter formalParameter =
|
| + AstFactory.functionTypedFormalParameter(null, parameterName);
|
| + formalParameter.typeParameters = AstFactory.typeParameterList(['F']);
|
| + _useParameterInMethod(formalParameter, 100, 110);
|
| + formalParameter.accept(builder);
|
| + List<ParameterElement> parameters = holder.parameters;
|
| + expect(parameters, hasLength(1));
|
| + ParameterElement parameter = parameters[0];
|
| + expect(parameter, isNotNull);
|
| + expect(parameter.name, parameterName);
|
| + 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_metadata_visitMethodDeclaration_getter() {
|
| - PropertyAccessorElement propertyAccessorElement =
|
| - buildElementsForText('class C { @a get m => null; }')
|
| - .types[0]
|
| - .accessors[0];
|
| - checkMetadata(propertyAccessorElement);
|
| + void test_visitLabeledStatement() {
|
| + 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_metadata_visitMethodDeclaration_method() {
|
| - MethodElement methodElement =
|
| - buildElementsForText('class C { @a m() {} }').types[0].methods[0];
|
| - checkMetadata(methodElement);
|
| + void test_visitMethodDeclaration_withMembers() {
|
| + MethodElement method = buildElementsForText(
|
| + 'class C { m(p) { var v; try { l: return; } catch (e) {} } }')
|
| + .types[0]
|
| + .methods[0];
|
| + String methodName = "m";
|
| + String parameterName = "p";
|
| + String localVariableName = "v";
|
| + String labelName = "l";
|
| + String exceptionParameterName = "e";
|
| + 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);
|
| + List<LabelElement> labels = method.labels;
|
| + expect(labels, hasLength(1));
|
| + LabelElement label = labels[0];
|
| + expect(label, isNotNull);
|
| + expect(label.name, labelName);
|
| }
|
|
|
| - void test_metadata_visitMethodDeclaration_setter() {
|
| - PropertyAccessorElement propertyAccessorElement =
|
| - buildElementsForText('class C { @a set f(value) {} }')
|
| - .types[0]
|
| - .accessors[0];
|
| - checkMetadata(propertyAccessorElement);
|
| + void test_visitNamedFormalParameter() {
|
| + ElementHolder holder = new ElementHolder();
|
| + ElementBuilder builder = _makeBuilder(holder);
|
| + String parameterName = "p";
|
| + DefaultFormalParameter formalParameter = AstFactory.namedFormalParameter(
|
| + AstFactory.simpleFormalParameter3(parameterName),
|
| + AstFactory.identifier3("42"));
|
| + _useParameterInMethod(formalParameter, 100, 110);
|
| + formalParameter.beginToken.offset = 50;
|
| + formalParameter.endToken.offset = 80;
|
| + formalParameter.accept(builder);
|
| + List<ParameterElement> parameters = holder.parameters;
|
| + expect(parameters, hasLength(1));
|
| + ParameterElement parameter = parameters[0];
|
| + expect(parameter, isNotNull);
|
| + assertHasCodeRange(parameter, 50, 32);
|
| + expect(parameter.name, parameterName);
|
| + expect(parameter.isConst, isFalse);
|
| + expect(parameter.isFinal, isFalse);
|
| + expect(parameter.isSynthetic, isFalse);
|
| + expect(parameter.parameterKind, ParameterKind.NAMED);
|
| + _assertVisibleRange(parameter, 100, 110);
|
| + expect(parameter.defaultValueCode, "42");
|
| + FunctionElement initializer = parameter.initializer;
|
| + expect(initializer, isNotNull);
|
| + expect(initializer.isSynthetic, isTrue);
|
| + expect(initializer.hasImplicitReturnType, isTrue);
|
| }
|
|
|
| - void test_metadata_visitPartDirective() {
|
| - buildElementsForText('@a part "foo.dart";');
|
| - expect(compilationUnit.directives[0], new isInstanceOf<PartDirective>());
|
| - PartDirective partDirective = compilationUnit.directives[0];
|
| - checkAnnotation(partDirective.metadata);
|
| + void test_visitSimpleFormalParameter_noType() {
|
| + // p
|
| + ElementHolder holder = new ElementHolder();
|
| + ElementBuilder builder = _makeBuilder(holder);
|
| + String parameterName = "p";
|
| + SimpleFormalParameter formalParameter =
|
| + AstFactory.simpleFormalParameter3(parameterName);
|
| + _useParameterInMethod(formalParameter, 100, 110);
|
| + formalParameter.accept(builder);
|
| + List<ParameterElement> parameters = holder.parameters;
|
| + expect(parameters, hasLength(1));
|
| + ParameterElement parameter = parameters[0];
|
| + expect(parameter, isNotNull);
|
| + expect(parameter.hasImplicitType, isTrue);
|
| + expect(parameter.initializer, isNull);
|
| + expect(parameter.isConst, isFalse);
|
| + expect(parameter.isFinal, isFalse);
|
| + expect(parameter.isSynthetic, isFalse);
|
| + expect(parameter.name, parameterName);
|
| + expect(parameter.parameterKind, ParameterKind.REQUIRED);
|
| + _assertVisibleRange(parameter, 100, 110);
|
| }
|
|
|
| - void test_metadata_visitPartOfDirective() {
|
| - // We don't build ElementAnnotation objects for `part of` directives, since
|
| - // analyzer ignores them in favor of annotations on the library directive.
|
| - buildElementsForText('@a part of L;');
|
| - expect(compilationUnit.directives[0], new isInstanceOf<PartOfDirective>());
|
| - PartOfDirective partOfDirective = compilationUnit.directives[0];
|
| - expect(partOfDirective.metadata, hasLength(1));
|
| - expect(partOfDirective.metadata[0].elementAnnotation, isNull);
|
| - }
|
| -
|
| - void test_metadata_visitSimpleFormalParameter() {
|
| - ParameterElement parameterElement =
|
| - buildElementsForText('f(@a x) {}').functions[0].parameters[0];
|
| - checkMetadata(parameterElement);
|
| - }
|
| -
|
| - void test_metadata_visitTypeParameter() {
|
| - TypeParameterElement typeParameterElement =
|
| - buildElementsForText('class C<@a T> {}').types[0].typeParameters[0];
|
| - checkMetadata(typeParameterElement);
|
| - }
|
| -
|
| - 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));
|
| -
|
| - 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);
|
| -
|
| - 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);
|
| - }
|
| -
|
| - 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);
|
| - }
|
| -
|
| - void test_visitClassDeclaration_abstract() {
|
| + void test_visitSimpleFormalParameter_type() {
|
| + // T p
|
| ElementHolder holder = new ElementHolder();
|
| ElementBuilder builder = _makeBuilder(holder);
|
| - String className = "C";
|
| - ClassDeclaration classDeclaration = AstFactory.classDeclaration(
|
| - Keyword.ABSTRACT, className, null, null, null, null);
|
| - classDeclaration.accept(builder);
|
| - List<ClassElement> types = holder.types;
|
| - expect(types, hasLength(1));
|
| - ClassElement type = types[0];
|
| - expect(type, isNotNull);
|
| - expect(type.name, className);
|
| - List<TypeParameterElement> typeParameters = type.typeParameters;
|
| - expect(typeParameters, hasLength(0));
|
| - expect(type.isAbstract, isTrue);
|
| - expect(type.isMixinApplication, isFalse);
|
| - expect(type.isSynthetic, isFalse);
|
| - }
|
| -
|
| - void test_visitClassDeclaration_invalidFunctionInAnnotation_class() {
|
| - // https://github.com/dart-lang/sdk/issues/25696
|
| - String code = r'''
|
| -class A {
|
| - const A({f});
|
| -}
|
| -
|
| -@A(f: () {})
|
| -class C {}
|
| -''';
|
| - buildElementsForText(code);
|
| + String parameterName = "p";
|
| + SimpleFormalParameter formalParameter = AstFactory.simpleFormalParameter4(
|
| + AstFactory.typeName4('T'), parameterName);
|
| + _useParameterInMethod(formalParameter, 100, 110);
|
| + formalParameter.accept(builder);
|
| + List<ParameterElement> parameters = holder.parameters;
|
| + expect(parameters, hasLength(1));
|
| + ParameterElement parameter = parameters[0];
|
| + expect(parameter, isNotNull);
|
| + expect(parameter.hasImplicitType, isFalse);
|
| + expect(parameter.initializer, isNull);
|
| + expect(parameter.isConst, isFalse);
|
| + expect(parameter.isFinal, isFalse);
|
| + expect(parameter.isSynthetic, isFalse);
|
| + expect(parameter.name, parameterName);
|
| + expect(parameter.parameterKind, ParameterKind.REQUIRED);
|
| + _assertVisibleRange(parameter, 100, 110);
|
| }
|
|
|
| - void test_visitClassDeclaration_invalidFunctionInAnnotation_method() {
|
| - String code = r'''
|
| -class A {
|
| - const A({f});
|
| -}
|
| -
|
| -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_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);
|
| }
|
|
|
| - void test_visitClassDeclaration_minimal() {
|
| + void test_visitVariableDeclaration_inForEachStatement() {
|
| ElementHolder holder = new ElementHolder();
|
| ElementBuilder builder = _makeBuilder(holder);
|
| - String className = "C";
|
| - ClassDeclaration classDeclaration =
|
| - AstFactory.classDeclaration(null, className, null, null, null, null);
|
| - classDeclaration.documentationComment = AstFactory.documentationComment(
|
| - [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| - classDeclaration.endToken.offset = 80;
|
| - classDeclaration.accept(builder);
|
| - List<ClassElement> types = holder.types;
|
| - expect(types, hasLength(1));
|
| - ClassElement type = types[0];
|
| - expect(type, isNotNull);
|
| - expect(type.name, className);
|
| - List<TypeParameterElement> typeParameters = type.typeParameters;
|
| - expect(typeParameters, hasLength(0));
|
| - expect(type.isAbstract, isFalse);
|
| - expect(type.isMixinApplication, isFalse);
|
| - expect(type.isSynthetic, isFalse);
|
| - expect(type.documentationComment, '/// aaa');
|
| - _assertHasCodeRange(type, 50, 31);
|
| + //
|
| + // m() { for (var v in []) }
|
| + //
|
| + String variableName = "v";
|
| + Statement statement = AstFactory.forEachStatement(
|
| + AstFactory.declaredIdentifier3('v'),
|
| + AstFactory.listLiteral(),
|
| + AstFactory.block());
|
| + _setNodeSourceRange(statement, 100, 110);
|
| + MethodDeclaration method = AstFactory.methodDeclaration2(
|
| + null,
|
| + null,
|
| + null,
|
| + null,
|
| + AstFactory.identifier3("m"),
|
| + AstFactory.formalParameterList(),
|
| + AstFactory.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];
|
| + expect(variableElement.name, variableName);
|
| + _assertVisibleRange(variableElement, 100, 110);
|
| }
|
|
|
| - void test_visitClassDeclaration_parameterized() {
|
| + void test_visitVariableDeclaration_inForStatement() {
|
| ElementHolder holder = new ElementHolder();
|
| ElementBuilder builder = _makeBuilder(holder);
|
| - String className = "C";
|
| - String firstVariableName = "E";
|
| - String secondVariableName = "F";
|
| - ClassDeclaration classDeclaration = AstFactory.classDeclaration(
|
| + //
|
| + // m() { for (T v;;) }
|
| + //
|
| + String variableName = "v";
|
| + ForStatement statement = AstFactory.forStatement2(
|
| + AstFactory.variableDeclarationList(null, AstFactory.typeName4('T'),
|
| + [AstFactory.variableDeclaration('v')]),
|
| null,
|
| - className,
|
| - AstFactory.typeParameterList([firstVariableName, secondVariableName]),
|
| null,
|
| + AstFactory.block());
|
| + _setNodeSourceRange(statement, 100, 110);
|
| + MethodDeclaration method = AstFactory.methodDeclaration2(
|
| null,
|
| - null);
|
| - classDeclaration.accept(builder);
|
| - List<ClassElement> types = holder.types;
|
| - expect(types, hasLength(1));
|
| - ClassElement type = types[0];
|
| - expect(type, isNotNull);
|
| - expect(type.name, className);
|
| - List<TypeParameterElement> typeParameters = type.typeParameters;
|
| - expect(typeParameters, hasLength(2));
|
| - expect(typeParameters[0].name, firstVariableName);
|
| - expect(typeParameters[1].name, secondVariableName);
|
| - expect(type.isAbstract, isFalse);
|
| - expect(type.isMixinApplication, isFalse);
|
| - expect(type.isSynthetic, isFalse);
|
| + null,
|
| + null,
|
| + null,
|
| + AstFactory.identifier3("m"),
|
| + AstFactory.formalParameterList(),
|
| + AstFactory.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];
|
| + expect(variableElement.name, variableName);
|
| + _assertVisibleRange(variableElement, 100, 110);
|
| }
|
|
|
| - void test_visitClassDeclaration_withMembers() {
|
| + void test_visitVariableDeclaration_inMethod() {
|
| ElementHolder holder = new ElementHolder();
|
| ElementBuilder builder = _makeBuilder(holder);
|
| - String className = "C";
|
| - String typeParameterName = "E";
|
| - String fieldName = "f";
|
| - String methodName = "m";
|
| - ClassDeclaration classDeclaration = AstFactory.classDeclaration(
|
| + //
|
| + // m() {T v;}
|
| + //
|
| + String variableName = "v";
|
| + VariableDeclaration variable =
|
| + AstFactory.variableDeclaration2(variableName, null);
|
| + Statement statement = AstFactory.variableDeclarationStatement(
|
| + null, AstFactory.typeName4('T'), [variable]);
|
| + MethodDeclaration method = AstFactory.methodDeclaration2(
|
| null,
|
| - className,
|
| - AstFactory.typeParameterList([typeParameterName]),
|
| null,
|
| null,
|
| - null, [
|
| - AstFactory.fieldDeclaration2(
|
| - false, null, [AstFactory.variableDeclaration(fieldName)]),
|
| - AstFactory.methodDeclaration2(
|
| - null,
|
| - null,
|
| - null,
|
| - null,
|
| - AstFactory.identifier3(methodName),
|
| - AstFactory.formalParameterList(),
|
| - AstFactory.blockFunctionBody2())
|
| - ]);
|
| - classDeclaration.accept(builder);
|
| - List<ClassElement> types = holder.types;
|
| - expect(types, hasLength(1));
|
| - ClassElement type = types[0];
|
| - expect(type, isNotNull);
|
| - expect(type.name, className);
|
| - expect(type.isAbstract, isFalse);
|
| - expect(type.isMixinApplication, isFalse);
|
| - expect(type.isSynthetic, isFalse);
|
| - List<TypeParameterElement> typeParameters = type.typeParameters;
|
| - expect(typeParameters, hasLength(1));
|
| - TypeParameterElement typeParameter = typeParameters[0];
|
| - expect(typeParameter, isNotNull);
|
| - expect(typeParameter.name, typeParameterName);
|
| - List<FieldElement> fields = type.fields;
|
| - expect(fields, hasLength(1));
|
| - FieldElement field = fields[0];
|
| - expect(field, isNotNull);
|
| - expect(field.name, fieldName);
|
| - List<MethodElement> methods = type.methods;
|
| + null,
|
| + AstFactory.identifier3("m"),
|
| + AstFactory.formalParameterList(),
|
| + AstFactory.blockFunctionBody2([statement]));
|
| + _setBlockBodySourceRange(method.body, 100, 110);
|
| + method.accept(builder);
|
| +
|
| + List<MethodElement> methods = holder.methods;
|
| expect(methods, hasLength(1));
|
| - MethodElement method = methods[0];
|
| - expect(method, isNotNull);
|
| - expect(method.name, methodName);
|
| + List<LocalVariableElement> variableElements = methods[0].localVariables;
|
| + expect(variableElements, hasLength(1));
|
| + LocalVariableElement variableElement = variableElements[0];
|
| + expect(variableElement.hasImplicitType, isFalse);
|
| + expect(variableElement.name, variableName);
|
| + _assertVisibleRange(variableElement, 100, 110);
|
| }
|
|
|
| - void test_visitClassTypeAlias() {
|
| - // class B {}
|
| - // class M {}
|
| - // class C = B with M
|
| + void test_visitVariableDeclaration_localNestedInFunction() {
|
| ElementHolder holder = new ElementHolder();
|
| ElementBuilder builder = _makeBuilder(holder);
|
| - ClassElementImpl classB = ElementFactory.classElement2('B', []);
|
| - ConstructorElementImpl constructorB =
|
| - ElementFactory.constructorElement2(classB, '', []);
|
| - constructorB.setModifier(Modifier.SYNTHETIC, true);
|
| - classB.constructors = [constructorB];
|
| - ClassElement classM = ElementFactory.classElement2('M', []);
|
| - WithClause withClause =
|
| - AstFactory.withClause([AstFactory.typeName(classM, [])]);
|
| - ClassTypeAlias alias = AstFactory.classTypeAlias(
|
| - 'C', null, null, AstFactory.typeName(classB, []), withClause, null);
|
| - alias.accept(builder);
|
| - List<ClassElement> types = holder.types;
|
| - expect(types, hasLength(1));
|
| - ClassElement type = types[0];
|
| - expect(alias.element, same(type));
|
| - expect(type.name, equals('C'));
|
| - expect(type.isAbstract, isFalse);
|
| - expect(type.isMixinApplication, isTrue);
|
| - expect(type.isSynthetic, isFalse);
|
| - expect(type.typeParameters, isEmpty);
|
| - expect(type.fields, isEmpty);
|
| - expect(type.methods, isEmpty);
|
| - }
|
| + //
|
| + // var f = () {var v;};
|
| + //
|
| + String variableName = "v";
|
| + VariableDeclaration variable =
|
| + AstFactory.variableDeclaration2(variableName, null);
|
| + Statement statement =
|
| + AstFactory.variableDeclarationStatement2(null, [variable]);
|
| + Expression initializer = AstFactory.functionExpression2(
|
| + AstFactory.formalParameterList(),
|
| + AstFactory.blockFunctionBody2([statement]));
|
| + String fieldName = "f";
|
| + VariableDeclaration field =
|
| + AstFactory.variableDeclaration2(fieldName, initializer);
|
| + FieldDeclaration fieldDeclaration =
|
| + AstFactory.fieldDeclaration2(false, null, [field]);
|
| + fieldDeclaration.accept(builder);
|
|
|
| - void test_visitClassTypeAlias_abstract() {
|
| - // class B {}
|
| - // class M {}
|
| - // abstract class C = B with M
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - ClassElementImpl classB = ElementFactory.classElement2('B', []);
|
| - ConstructorElementImpl constructorB =
|
| - ElementFactory.constructorElement2(classB, '', []);
|
| - constructorB.setModifier(Modifier.SYNTHETIC, true);
|
| - classB.constructors = [constructorB];
|
| - ClassElement classM = ElementFactory.classElement2('M', []);
|
| - WithClause withClause =
|
| - AstFactory.withClause([AstFactory.typeName(classM, [])]);
|
| - ClassTypeAlias classCAst = AstFactory.classTypeAlias('C', null,
|
| - Keyword.ABSTRACT, AstFactory.typeName(classB, []), withClause, null);
|
| - classCAst.accept(builder);
|
| - List<ClassElement> types = holder.types;
|
| - expect(types, hasLength(1));
|
| - ClassElement type = types[0];
|
| - expect(type.isAbstract, isTrue);
|
| - expect(type.isMixinApplication, isTrue);
|
| + 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];
|
| + expect(variableElement.hasImplicitType, isTrue);
|
| + expect(variableElement.isConst, isFalse);
|
| + expect(variableElement.isFinal, isFalse);
|
| + expect(variableElement.isSynthetic, isFalse);
|
| + expect(variableElement.name, variableName);
|
| }
|
|
|
| - void test_visitClassTypeAlias_typeParams() {
|
| - // class B {}
|
| - // class M {}
|
| - // class C<T> = B with M
|
| + void test_visitVariableDeclaration_noInitializer() {
|
| + // var v;
|
| ElementHolder holder = new ElementHolder();
|
| ElementBuilder builder = _makeBuilder(holder);
|
| - ClassElementImpl classB = ElementFactory.classElement2('B', []);
|
| - ConstructorElementImpl constructorB =
|
| - ElementFactory.constructorElement2(classB, '', []);
|
| - constructorB.setModifier(Modifier.SYNTHETIC, true);
|
| - classB.constructors = [constructorB];
|
| - ClassElementImpl classM = ElementFactory.classElement2('M', []);
|
| - WithClause withClause =
|
| - AstFactory.withClause([AstFactory.typeName(classM, [])]);
|
| - ClassTypeAlias classCAst = AstFactory.classTypeAlias(
|
| - 'C',
|
| - AstFactory.typeParameterList(['T']),
|
| - null,
|
| - AstFactory.typeName(classB, []),
|
| - withClause,
|
| - null);
|
| - classCAst.accept(builder);
|
| - List<ClassElement> types = holder.types;
|
| - expect(types, hasLength(1));
|
| - ClassElement type = types[0];
|
| - expect(type.typeParameters, hasLength(1));
|
| - expect(type.typeParameters[0].name, equals('T'));
|
| + String variableName = "v";
|
| + VariableDeclaration variableDeclaration =
|
| + AstFactory.variableDeclaration2(variableName, null);
|
| + AstFactory.variableDeclarationList2(null, [variableDeclaration]);
|
| + variableDeclaration.accept(builder);
|
| +
|
| + List<TopLevelVariableElement> variables = holder.topLevelVariables;
|
| + expect(variables, hasLength(1));
|
| + TopLevelVariableElement variable = variables[0];
|
| + expect(variable, isNotNull);
|
| + expect(variable.hasImplicitType, isTrue);
|
| + expect(variable.initializer, isNull);
|
| + expect(variable.name, variableName);
|
| + expect(variable.isConst, isFalse);
|
| + expect(variable.isFinal, isFalse);
|
| + expect(variable.isSynthetic, isFalse);
|
| + expect(variable.getter, isNotNull);
|
| + expect(variable.setter, isNotNull);
|
| }
|
|
|
| - void test_visitCompilationUnit_codeRange() {
|
| - TopLevelVariableDeclaration topLevelVariableDeclaration = AstFactory
|
| - .topLevelVariableDeclaration(null, AstFactory.typeName4('int'),
|
| - [AstFactory.variableDeclaration('V')]);
|
| - CompilationUnit unit = new CompilationUnit(
|
| - topLevelVariableDeclaration.beginToken,
|
| - null,
|
| - [],
|
| - [topLevelVariableDeclaration],
|
| - topLevelVariableDeclaration.endToken);
|
| + void test_visitVariableDeclaration_top() {
|
| + // final a, b;
|
| ElementHolder holder = new ElementHolder();
|
| ElementBuilder builder = _makeBuilder(holder);
|
| - unit.beginToken.offset = 10;
|
| - unit.endToken.offset = 40;
|
| - unit.accept(builder);
|
| + VariableDeclaration variableDeclaration1 =
|
| + AstFactory.variableDeclaration('a');
|
| + VariableDeclaration variableDeclaration2 =
|
| + AstFactory.variableDeclaration('b');
|
| + TopLevelVariableDeclaration topLevelVariableDeclaration = AstFactory
|
| + .topLevelVariableDeclaration(
|
| + Keyword.FINAL, null, [variableDeclaration1, variableDeclaration2]);
|
| + topLevelVariableDeclaration.documentationComment = AstFactory
|
| + .documentationComment(
|
| + [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| +
|
| + topLevelVariableDeclaration.accept(builder);
|
| + List<TopLevelVariableElement> variables = holder.topLevelVariables;
|
| + expect(variables, hasLength(2));
|
| +
|
| + TopLevelVariableElement variable1 = variables[0];
|
| + expect(variable1, isNotNull);
|
| + expect(variable1.documentationComment, '/// aaa');
|
|
|
| - CompilationUnitElement element = builder.compilationUnitElement;
|
| - _assertHasCodeRange(element, 0, 41);
|
| + TopLevelVariableElement variable2 = variables[1];
|
| + expect(variable2, isNotNull);
|
| + expect(variable2.documentationComment, '/// aaa');
|
| }
|
|
|
| - void test_visitConstructorDeclaration_external() {
|
| + void test_visitVariableDeclaration_top_const_hasInitializer() {
|
| + // const v = 42;
|
| ElementHolder holder = new ElementHolder();
|
| ElementBuilder builder = _makeBuilder(holder);
|
| - String className = "A";
|
| - ConstructorDeclaration constructorDeclaration =
|
| - AstFactory.constructorDeclaration2(
|
| - null,
|
| - null,
|
| - AstFactory.identifier3(className),
|
| - null,
|
| - AstFactory.formalParameterList(),
|
| - null,
|
| - AstFactory.blockFunctionBody2());
|
| - constructorDeclaration.externalKeyword =
|
| - TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
|
| - constructorDeclaration.accept(builder);
|
| - 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));
|
| + String variableName = "v";
|
| + VariableDeclaration variableDeclaration =
|
| + AstFactory.variableDeclaration2(variableName, AstFactory.integer(42));
|
| + AstFactory.variableDeclarationList2(Keyword.CONST, [variableDeclaration]);
|
| + variableDeclaration.accept(builder);
|
| +
|
| + List<TopLevelVariableElement> variables = holder.topLevelVariables;
|
| + expect(variables, hasLength(1));
|
| + TopLevelVariableElement variable = variables[0];
|
| + expect(variable, new isInstanceOf<ConstTopLevelVariableElementImpl>());
|
| + expect(variable.initializer, isNotNull);
|
| + expect(variable.initializer.type, isNotNull);
|
| + expect(variable.initializer.hasImplicitReturnType, isTrue);
|
| + expect(variable.name, variableName);
|
| + expect(variable.hasImplicitType, isTrue);
|
| + expect(variable.isConst, isTrue);
|
| + expect(variable.isFinal, isFalse);
|
| + expect(variable.isSynthetic, isFalse);
|
| + expect(variable.getter, isNotNull);
|
| + expect(variable.setter, isNull);
|
| }
|
|
|
| - void test_visitConstructorDeclaration_factory() {
|
| + void test_visitVariableDeclaration_top_final() {
|
| + // final v;
|
| ElementHolder holder = new ElementHolder();
|
| ElementBuilder builder = _makeBuilder(holder);
|
| - String className = "A";
|
| - ConstructorDeclaration constructorDeclaration =
|
| - AstFactory.constructorDeclaration2(
|
| - null,
|
| - Keyword.FACTORY,
|
| - AstFactory.identifier3(className),
|
| - null,
|
| + String variableName = "v";
|
| + VariableDeclaration variableDeclaration =
|
| + AstFactory.variableDeclaration2(variableName, null);
|
| + AstFactory.variableDeclarationList2(Keyword.FINAL, [variableDeclaration]);
|
| + variableDeclaration.accept(builder);
|
| + List<TopLevelVariableElement> variables = holder.topLevelVariables;
|
| + expect(variables, hasLength(1));
|
| + TopLevelVariableElement variable = variables[0];
|
| + expect(variable, isNotNull);
|
| + expect(variable.hasImplicitType, isTrue);
|
| + expect(variable.initializer, isNull);
|
| + expect(variable.name, variableName);
|
| + expect(variable.isConst, isFalse);
|
| + expect(variable.isFinal, isTrue);
|
| + expect(variable.isSynthetic, isFalse);
|
| + expect(variable.getter, isNotNull);
|
| + expect(variable.setter, isNull);
|
| + }
|
| +
|
| + ElementBuilder _makeBuilder(ElementHolder holder) =>
|
| + new ElementBuilder(holder, compilationUnitElement);
|
| +
|
| + void _setBlockBodySourceRange(BlockFunctionBody body, int offset, int end) {
|
| + _setNodeSourceRange(body.block, offset, end);
|
| + }
|
| +
|
| + void _setNodeSourceRange(AstNode node, int offset, int end) {
|
| + node.beginToken.offset = offset;
|
| + Token endToken = node.endToken;
|
| + endToken.offset = end - endToken.length;
|
| + }
|
| +
|
| + void _useParameterInMethod(
|
| + FormalParameter formalParameter, int blockOffset, int blockEnd) {
|
| + Block block = AstFactory.block();
|
| + block.leftBracket.offset = blockOffset;
|
| + block.rightBracket.offset = blockEnd - 1;
|
| + BlockFunctionBody body = AstFactory.blockFunctionBody(block);
|
| + AstFactory.methodDeclaration2(
|
| + null,
|
| + null,
|
| + null,
|
| + null,
|
| + AstFactory.identifier3("main"),
|
| + AstFactory.formalParameterList([formalParameter]),
|
| + body);
|
| + }
|
| +}
|
| +
|
| +/**
|
| + * 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);
|
| +
|
| + /**
|
| + * Build elements using [ApiElementBuilder].
|
| + */
|
| + ElementHolder buildElementsForAst(AstNode node);
|
| +
|
| + /**
|
| + * Parse the given [code], and build elements using [ApiElementBuilder].
|
| + */
|
| + ElementHolder buildElementsForText(String code);
|
| +
|
| + /**
|
| + * Verify that the given [metadata] has exactly one annotation, and that its
|
| + * [ElementAnnotationImpl] is unresolved.
|
| + */
|
| + void checkAnnotation(NodeList<Annotation> metadata);
|
| +
|
| + /**
|
| + * Verify that the given [element] has exactly one annotation, and that its
|
| + * [ElementAnnotationImpl] is unresolved.
|
| + */
|
| + void checkMetadata(Element element);
|
| +
|
| + void test_metadata_fieldDeclaration() {
|
| + List<FieldElement> fields =
|
| + buildElementsForText('class C { @a int x, y; }').types[0].fields;
|
| + checkMetadata(fields[0]);
|
| + checkMetadata(fields[1]);
|
| + expect(fields[0].metadata, same(fields[1].metadata));
|
| + }
|
| +
|
| + void test_metadata_topLevelVariableDeclaration() {
|
| + List<TopLevelVariableElement> topLevelVariables =
|
| + buildElementsForText('@a int x, y;').topLevelVariables;
|
| + checkMetadata(topLevelVariables[0]);
|
| + checkMetadata(topLevelVariables[1]);
|
| + expect(topLevelVariables[0].metadata, same(topLevelVariables[1].metadata));
|
| + }
|
| +
|
| + void test_metadata_visitClassDeclaration() {
|
| + ClassElement classElement = buildElementsForText('@a class C {}').types[0];
|
| + checkMetadata(classElement);
|
| + }
|
| +
|
| + void test_metadata_visitClassTypeAlias() {
|
| + ClassElement classElement =
|
| + buildElementsForText('@a class C = D with E;').types[0];
|
| + checkMetadata(classElement);
|
| + }
|
| +
|
| + void test_metadata_visitConstructorDeclaration() {
|
| + ConstructorElement constructorElement =
|
| + buildElementsForText('class C { @a C(); }').types[0].constructors[0];
|
| + checkMetadata(constructorElement);
|
| + }
|
| +
|
| + void test_metadata_visitDefaultFormalParameter_fieldFormalParameter() {
|
| + ParameterElement parameterElement =
|
| + buildElementsForText('class C { var x; C([@a this.x = null]); }')
|
| + .types[0]
|
| + .constructors[0]
|
| + .parameters[0];
|
| + checkMetadata(parameterElement);
|
| + }
|
| +
|
| + void
|
| + test_metadata_visitDefaultFormalParameter_functionTypedFormalParameter() {
|
| + ParameterElement parameterElement =
|
| + buildElementsForText('f([@a g() = null]) {}').functions[0].parameters[
|
| + 0];
|
| + checkMetadata(parameterElement);
|
| + }
|
| +
|
| + void test_metadata_visitDefaultFormalParameter_simpleFormalParameter() {
|
| + ParameterElement parameterElement =
|
| + buildElementsForText('f([@a gx = null]) {}').functions[0].parameters[0];
|
| + checkMetadata(parameterElement);
|
| + }
|
| +
|
| + void test_metadata_visitEnumDeclaration() {
|
| + ClassElement classElement =
|
| + buildElementsForText('@a enum E { v }').enums[0];
|
| + checkMetadata(classElement);
|
| + }
|
| +
|
| + void test_metadata_visitExportDirective() {
|
| + buildElementsForText('@a export "foo.dart";');
|
| + expect(compilationUnit.directives[0], new isInstanceOf<ExportDirective>());
|
| + ExportDirective exportDirective = compilationUnit.directives[0];
|
| + checkAnnotation(exportDirective.metadata);
|
| + }
|
| +
|
| + void test_metadata_visitFieldFormalParameter() {
|
| + ParameterElement parameterElement =
|
| + buildElementsForText('class C { var x; C(@a this.x); }')
|
| + .types[0]
|
| + .constructors[0]
|
| + .parameters[0];
|
| + checkMetadata(parameterElement);
|
| + }
|
| +
|
| + void test_metadata_visitFunctionDeclaration_function() {
|
| + FunctionElement functionElement =
|
| + buildElementsForText('@a f() {}').functions[0];
|
| + checkMetadata(functionElement);
|
| + }
|
| +
|
| + void test_metadata_visitFunctionDeclaration_getter() {
|
| + PropertyAccessorElement propertyAccessorElement =
|
| + buildElementsForText('@a get f => null;').accessors[0];
|
| + checkMetadata(propertyAccessorElement);
|
| + }
|
| +
|
| + void test_metadata_visitFunctionDeclaration_setter() {
|
| + PropertyAccessorElement propertyAccessorElement =
|
| + buildElementsForText('@a set f(value) {}').accessors[0];
|
| + checkMetadata(propertyAccessorElement);
|
| + }
|
| +
|
| + void test_metadata_visitFunctionTypeAlias() {
|
| + FunctionTypeAliasElement functionTypeAliasElement =
|
| + buildElementsForText('@a typedef F();').typeAliases[0];
|
| + checkMetadata(functionTypeAliasElement);
|
| + }
|
| +
|
| + void test_metadata_visitFunctionTypedFormalParameter() {
|
| + ParameterElement parameterElement =
|
| + buildElementsForText('f(@a g()) {}').functions[0].parameters[0];
|
| + checkMetadata(parameterElement);
|
| + }
|
| +
|
| + void test_metadata_visitImportDirective() {
|
| + buildElementsForText('@a import "foo.dart";');
|
| + expect(compilationUnit.directives[0], new isInstanceOf<ImportDirective>());
|
| + ImportDirective importDirective = compilationUnit.directives[0];
|
| + checkAnnotation(importDirective.metadata);
|
| + }
|
| +
|
| + void test_metadata_visitLibraryDirective() {
|
| + buildElementsForText('@a library L;');
|
| + expect(compilationUnit.directives[0], new isInstanceOf<LibraryDirective>());
|
| + LibraryDirective libraryDirective = compilationUnit.directives[0];
|
| + checkAnnotation(libraryDirective.metadata);
|
| + }
|
| +
|
| + void test_metadata_visitMethodDeclaration_getter() {
|
| + PropertyAccessorElement propertyAccessorElement =
|
| + buildElementsForText('class C { @a get m => null; }')
|
| + .types[0]
|
| + .accessors[0];
|
| + checkMetadata(propertyAccessorElement);
|
| + }
|
| +
|
| + void test_metadata_visitMethodDeclaration_method() {
|
| + MethodElement methodElement =
|
| + buildElementsForText('class C { @a m() {} }').types[0].methods[0];
|
| + checkMetadata(methodElement);
|
| + }
|
| +
|
| + void test_metadata_visitMethodDeclaration_setter() {
|
| + PropertyAccessorElement propertyAccessorElement =
|
| + buildElementsForText('class C { @a set f(value) {} }')
|
| + .types[0]
|
| + .accessors[0];
|
| + checkMetadata(propertyAccessorElement);
|
| + }
|
| +
|
| + void test_metadata_visitPartDirective() {
|
| + buildElementsForText('@a part "foo.dart";');
|
| + expect(compilationUnit.directives[0], new isInstanceOf<PartDirective>());
|
| + PartDirective partDirective = compilationUnit.directives[0];
|
| + checkAnnotation(partDirective.metadata);
|
| + }
|
| +
|
| + void test_metadata_visitPartOfDirective() {
|
| + // We don't build ElementAnnotation objects for `part of` directives, since
|
| + // analyzer ignores them in favor of annotations on the library directive.
|
| + buildElementsForText('@a part of L;');
|
| + expect(compilationUnit.directives[0], new isInstanceOf<PartOfDirective>());
|
| + PartOfDirective partOfDirective = compilationUnit.directives[0];
|
| + expect(partOfDirective.metadata, hasLength(1));
|
| + expect(partOfDirective.metadata[0].elementAnnotation, isNull);
|
| + }
|
| +
|
| + void test_metadata_visitSimpleFormalParameter() {
|
| + ParameterElement parameterElement =
|
| + buildElementsForText('f(@a x) {}').functions[0].parameters[0];
|
| + checkMetadata(parameterElement);
|
| + }
|
| +
|
| + void test_metadata_visitTypeParameter() {
|
| + TypeParameterElement typeParameterElement =
|
| + buildElementsForText('class C<@a T> {}').types[0].typeParameters[0];
|
| + checkMetadata(typeParameterElement);
|
| + }
|
| +
|
| + void test_visitClassDeclaration_abstract() {
|
| + List<ClassElement> types =
|
| + buildElementsForText('abstract class C {}').types;
|
| + expect(types, hasLength(1));
|
| + ClassElement type = types[0];
|
| + expect(type, isNotNull);
|
| + expect(type.name, 'C');
|
| + List<TypeParameterElement> typeParameters = type.typeParameters;
|
| + expect(typeParameters, hasLength(0));
|
| + expect(type.isAbstract, isTrue);
|
| + expect(type.isMixinApplication, isFalse);
|
| + expect(type.isSynthetic, isFalse);
|
| + }
|
| +
|
| + void test_visitClassDeclaration_invalidFunctionInAnnotation_class() {
|
| + // https://github.com/dart-lang/sdk/issues/25696
|
| + String code = r'''
|
| +class A {
|
| + const A({f});
|
| +}
|
| +
|
| +@A(f: () {})
|
| +class C {}
|
| +''';
|
| + buildElementsForText(code);
|
| + }
|
| +
|
| + void test_visitClassDeclaration_invalidFunctionInAnnotation_method() {
|
| + String code = r'''
|
| +class A {
|
| + const A({f});
|
| +}
|
| +
|
| +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 =
|
| + AstFactory.classDeclaration(null, className, null, null, null, null);
|
| + classDeclaration.documentationComment = AstFactory.documentationComment(
|
| + [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| + classDeclaration.endToken.offset = 80;
|
| +
|
| + ElementHolder holder = buildElementsForAst(classDeclaration);
|
| + List<ClassElement> types = holder.types;
|
| + expect(types, hasLength(1));
|
| + ClassElement type = types[0];
|
| + expect(type, isNotNull);
|
| + expect(type.name, className);
|
| + List<TypeParameterElement> typeParameters = type.typeParameters;
|
| + expect(typeParameters, hasLength(0));
|
| + expect(type.isAbstract, isFalse);
|
| + expect(type.isMixinApplication, isFalse);
|
| + expect(type.isSynthetic, isFalse);
|
| + expect(type.documentationComment, '/// aaa');
|
| + assertHasCodeRange(type, 50, 31);
|
| + }
|
| +
|
| + void test_visitClassDeclaration_parameterized() {
|
| + String className = "C";
|
| + String firstVariableName = "E";
|
| + String secondVariableName = "F";
|
| + ClassDeclaration classDeclaration = AstFactory.classDeclaration(
|
| + null,
|
| + className,
|
| + AstFactory.typeParameterList([firstVariableName, secondVariableName]),
|
| + null,
|
| + null,
|
| + null);
|
| +
|
| + ElementHolder holder = buildElementsForAst(classDeclaration);
|
| + List<ClassElement> types = holder.types;
|
| + expect(types, hasLength(1));
|
| + ClassElement type = types[0];
|
| + expect(type, isNotNull);
|
| + expect(type.name, className);
|
| + List<TypeParameterElement> typeParameters = type.typeParameters;
|
| + expect(typeParameters, hasLength(2));
|
| + expect(typeParameters[0].name, firstVariableName);
|
| + expect(typeParameters[1].name, secondVariableName);
|
| + expect(type.isAbstract, isFalse);
|
| + expect(type.isMixinApplication, isFalse);
|
| + expect(type.isSynthetic, isFalse);
|
| + }
|
| +
|
| + void test_visitClassDeclaration_withMembers() {
|
| + String className = "C";
|
| + String typeParameterName = "E";
|
| + String fieldName = "f";
|
| + String methodName = "m";
|
| + ClassDeclaration classDeclaration = AstFactory.classDeclaration(
|
| + null,
|
| + className,
|
| + AstFactory.typeParameterList([typeParameterName]),
|
| + null,
|
| + null,
|
| + null, [
|
| + AstFactory.fieldDeclaration2(
|
| + false, null, [AstFactory.variableDeclaration(fieldName)]),
|
| + AstFactory.methodDeclaration2(
|
| + null,
|
| + null,
|
| + null,
|
| + null,
|
| + AstFactory.identifier3(methodName),
|
| + AstFactory.formalParameterList(),
|
| + AstFactory.blockFunctionBody2())
|
| + ]);
|
| +
|
| + ElementHolder holder = buildElementsForAst(classDeclaration);
|
| + List<ClassElement> types = holder.types;
|
| + expect(types, hasLength(1));
|
| + ClassElement type = types[0];
|
| + expect(type, isNotNull);
|
| + expect(type.name, className);
|
| + expect(type.isAbstract, isFalse);
|
| + expect(type.isMixinApplication, isFalse);
|
| + expect(type.isSynthetic, isFalse);
|
| + List<TypeParameterElement> typeParameters = type.typeParameters;
|
| + expect(typeParameters, hasLength(1));
|
| + TypeParameterElement typeParameter = typeParameters[0];
|
| + expect(typeParameter, isNotNull);
|
| + expect(typeParameter.name, typeParameterName);
|
| + List<FieldElement> fields = type.fields;
|
| + expect(fields, hasLength(1));
|
| + FieldElement field = fields[0];
|
| + expect(field, isNotNull);
|
| + expect(field.name, fieldName);
|
| + List<MethodElement> methods = type.methods;
|
| + expect(methods, hasLength(1));
|
| + MethodElement method = methods[0];
|
| + expect(method, isNotNull);
|
| + expect(method.name, methodName);
|
| + }
|
| +
|
| + void test_visitClassTypeAlias() {
|
| + // class B {}
|
| + // class M {}
|
| + // class C = B with M
|
| + ClassElementImpl classB = ElementFactory.classElement2('B', []);
|
| + ConstructorElementImpl constructorB =
|
| + ElementFactory.constructorElement2(classB, '', []);
|
| + constructorB.setModifier(Modifier.SYNTHETIC, true);
|
| + classB.constructors = [constructorB];
|
| + ClassElement classM = ElementFactory.classElement2('M', []);
|
| + WithClause withClause =
|
| + AstFactory.withClause([AstFactory.typeName(classM, [])]);
|
| + ClassTypeAlias alias = AstFactory.classTypeAlias(
|
| + 'C', null, null, AstFactory.typeName(classB, []), withClause, null);
|
| +
|
| + ElementHolder holder = buildElementsForAst(alias);
|
| + List<ClassElement> types = holder.types;
|
| + expect(types, hasLength(1));
|
| + ClassElement type = types[0];
|
| + expect(alias.element, same(type));
|
| + expect(type.name, equals('C'));
|
| + expect(type.isAbstract, isFalse);
|
| + expect(type.isMixinApplication, isTrue);
|
| + expect(type.isSynthetic, isFalse);
|
| + expect(type.typeParameters, isEmpty);
|
| + expect(type.fields, isEmpty);
|
| + expect(type.methods, isEmpty);
|
| + }
|
| +
|
| + void test_visitClassTypeAlias_abstract() {
|
| + // class B {}
|
| + // class M {}
|
| + // abstract class C = B with M
|
| + ClassElementImpl classB = ElementFactory.classElement2('B', []);
|
| + ConstructorElementImpl constructorB =
|
| + ElementFactory.constructorElement2(classB, '', []);
|
| + constructorB.setModifier(Modifier.SYNTHETIC, true);
|
| + classB.constructors = [constructorB];
|
| + ClassElement classM = ElementFactory.classElement2('M', []);
|
| + WithClause withClause =
|
| + AstFactory.withClause([AstFactory.typeName(classM, [])]);
|
| + ClassTypeAlias alias = AstFactory.classTypeAlias('C', null,
|
| + Keyword.ABSTRACT, AstFactory.typeName(classB, []), withClause, null);
|
| +
|
| + ElementHolder holder = buildElementsForAst(alias);
|
| + List<ClassElement> types = holder.types;
|
| + expect(types, hasLength(1));
|
| + ClassElement type = types[0];
|
| + expect(type.isAbstract, isTrue);
|
| + expect(type.isMixinApplication, isTrue);
|
| + }
|
| +
|
| + void test_visitClassTypeAlias_typeParams() {
|
| + // class B {}
|
| + // class M {}
|
| + // class C<T> = B with M
|
| + ClassElementImpl classB = ElementFactory.classElement2('B', []);
|
| + ConstructorElementImpl constructorB =
|
| + ElementFactory.constructorElement2(classB, '', []);
|
| + constructorB.setModifier(Modifier.SYNTHETIC, true);
|
| + classB.constructors = [constructorB];
|
| + ClassElementImpl classM = ElementFactory.classElement2('M', []);
|
| + WithClause withClause =
|
| + AstFactory.withClause([AstFactory.typeName(classM, [])]);
|
| + ClassTypeAlias alias = AstFactory.classTypeAlias(
|
| + 'C',
|
| + AstFactory.typeParameterList(['T']),
|
| + null,
|
| + AstFactory.typeName(classB, []),
|
| + withClause,
|
| + null);
|
| +
|
| + ElementHolder holder = buildElementsForAst(alias);
|
| + List<ClassElement> types = holder.types;
|
| + expect(types, hasLength(1));
|
| + ClassElement type = types[0];
|
| + expect(type.typeParameters, hasLength(1));
|
| + expect(type.typeParameters[0].name, equals('T'));
|
| + }
|
| +
|
| + void test_visitConstructorDeclaration_external() {
|
| + String className = "A";
|
| + ConstructorDeclaration constructorDeclaration =
|
| + AstFactory.constructorDeclaration2(
|
| + null,
|
| + null,
|
| + AstFactory.identifier3(className),
|
| + null,
|
| + AstFactory.formalParameterList(),
|
| + null,
|
| + AstFactory.blockFunctionBody2());
|
| + constructorDeclaration.externalKeyword =
|
| + 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.labels, hasLength(0));
|
| + expect(constructor.localVariables, hasLength(0));
|
| + expect(constructor.parameters, hasLength(0));
|
| + }
|
| +
|
| + void test_visitConstructorDeclaration_factory() {
|
| + String className = "A";
|
| + ConstructorDeclaration constructorDeclaration =
|
| + AstFactory.constructorDeclaration2(
|
| + null,
|
| + Keyword.FACTORY,
|
| + AstFactory.identifier3(className),
|
| + null,
|
| AstFactory.formalParameterList(),
|
| null,
|
| AstFactory.blockFunctionBody2());
|
| - constructorDeclaration.accept(builder);
|
| +
|
| + ElementHolder holder = buildElementsForAst(constructorDeclaration);
|
| List<ConstructorElement> constructors = holder.constructors;
|
| expect(constructors, hasLength(1));
|
| ConstructorElement constructor = constructors[0];
|
| @@ -650,8 +1365,6 @@ class C {
|
| }
|
|
|
| void test_visitConstructorDeclaration_minimal() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String className = "A";
|
| ConstructorDeclaration constructorDeclaration =
|
| AstFactory.constructorDeclaration2(
|
| @@ -666,13 +1379,13 @@ class C {
|
| .documentationComment(
|
| [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| constructorDeclaration.endToken.offset = 80;
|
| - constructorDeclaration.accept(builder);
|
|
|
| + ElementHolder holder = buildElementsForAst(constructorDeclaration);
|
| List<ConstructorElement> constructors = holder.constructors;
|
| expect(constructors, hasLength(1));
|
| ConstructorElement constructor = constructors[0];
|
| expect(constructor, isNotNull);
|
| - _assertHasCodeRange(constructor, 50, 31);
|
| + assertHasCodeRange(constructor, 50, 31);
|
| expect(constructor.documentationComment, '/// aaa');
|
| expect(constructor.isExternal, isFalse);
|
| expect(constructor.isFactory, isFalse);
|
| @@ -684,8 +1397,6 @@ class C {
|
| }
|
|
|
| void test_visitConstructorDeclaration_named() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String className = "A";
|
| String constructorName = "c";
|
| ConstructorDeclaration constructorDeclaration =
|
| @@ -697,7 +1408,8 @@ class C {
|
| AstFactory.formalParameterList(),
|
| null,
|
| AstFactory.blockFunctionBody2());
|
| - constructorDeclaration.accept(builder);
|
| +
|
| + ElementHolder holder = buildElementsForAst(constructorDeclaration);
|
| List<ConstructorElement> constructors = holder.constructors;
|
| expect(constructors, hasLength(1));
|
| ConstructorElement constructor = constructors[0];
|
| @@ -714,8 +1426,6 @@ class C {
|
| }
|
|
|
| void test_visitConstructorDeclaration_unnamed() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String className = "A";
|
| ConstructorDeclaration constructorDeclaration =
|
| AstFactory.constructorDeclaration2(
|
| @@ -726,7 +1436,8 @@ class C {
|
| AstFactory.formalParameterList(),
|
| null,
|
| AstFactory.blockFunctionBody2());
|
| - constructorDeclaration.accept(builder);
|
| +
|
| + ElementHolder holder = buildElementsForAst(constructorDeclaration);
|
| List<ConstructorElement> constructors = holder.constructors;
|
| expect(constructors, hasLength(1));
|
| ConstructorElement constructor = constructors[0];
|
| @@ -741,124 +1452,24 @@ class C {
|
| expect(constructorDeclaration.element, same(constructor));
|
| }
|
|
|
| - void test_visitDeclaredIdentifier_noType() {
|
| - LocalVariableElement variable =
|
| - buildElementsForText('f() { for (var i in []) {} }')
|
| - .functions[0]
|
| - .localVariables[0];
|
| - _assertHasCodeRange(variable, 11, 5);
|
| - expect(variable, isNotNull);
|
| - expect(variable.hasImplicitType, isTrue);
|
| - expect(variable.isConst, isFalse);
|
| - expect(variable.isDeprecated, isFalse);
|
| - expect(variable.isFinal, isFalse);
|
| - expect(variable.isOverride, isFalse);
|
| - expect(variable.isPrivate, isFalse);
|
| - expect(variable.isPublic, isTrue);
|
| - expect(variable.isSynthetic, isFalse);
|
| - expect(variable.name, 'i');
|
| - }
|
| -
|
| - void test_visitDeclaredIdentifier_type() {
|
| - LocalVariableElement variable =
|
| - buildElementsForText('f() { for (int i in []) {} }')
|
| - .functions[0]
|
| - .localVariables[0];
|
| - _assertHasCodeRange(variable, 11, 5);
|
| - expect(variable.hasImplicitType, isFalse);
|
| - expect(variable.isConst, isFalse);
|
| - expect(variable.isDeprecated, isFalse);
|
| - expect(variable.isFinal, isFalse);
|
| - expect(variable.isOverride, isFalse);
|
| - expect(variable.isPrivate, isFalse);
|
| - expect(variable.isPublic, isTrue);
|
| - expect(variable.isSynthetic, isFalse);
|
| - expect(variable.name, 'i');
|
| - }
|
| -
|
| - void test_visitDefaultFormalParameter_noType() {
|
| - // p = 0
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String parameterName = 'p';
|
| - DefaultFormalParameter formalParameter =
|
| - AstFactory.positionalFormalParameter(
|
| - AstFactory.simpleFormalParameter3(parameterName),
|
| - AstFactory.integer(0));
|
| - formalParameter.beginToken.offset = 50;
|
| - formalParameter.endToken.offset = 80;
|
| - formalParameter.accept(builder);
|
| -
|
| - 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
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String parameterName = 'p';
|
| - DefaultFormalParameter formalParameter = AstFactory.namedFormalParameter(
|
| - AstFactory.simpleFormalParameter4(
|
| - AstFactory.typeName4('E'), parameterName),
|
| - AstFactory.integer(0));
|
| - formalParameter.accept(builder);
|
| -
|
| - 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_visitEnumDeclaration() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String enumName = "E";
|
| EnumDeclaration enumDeclaration =
|
| AstFactory.enumDeclaration2(enumName, ["ONE"]);
|
| enumDeclaration.documentationComment = AstFactory.documentationComment(
|
| [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| enumDeclaration.endToken.offset = 80;
|
| - enumDeclaration.accept(builder);
|
| + ElementHolder holder = buildElementsForAst(enumDeclaration);
|
| List<ClassElement> enums = holder.enums;
|
| expect(enums, hasLength(1));
|
| ClassElement enumElement = enums[0];
|
| expect(enumElement, isNotNull);
|
| - _assertHasCodeRange(enumElement, 50, 31);
|
| + assertHasCodeRange(enumElement, 50, 31);
|
| expect(enumElement.documentationComment, '/// aaa');
|
| expect(enumElement.name, enumName);
|
| }
|
|
|
| void test_visitFieldDeclaration() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String firstFieldName = "x";
|
| String secondFieldName = "y";
|
| FieldDeclaration fieldDeclaration =
|
| @@ -869,14 +1480,14 @@ class C {
|
| fieldDeclaration.documentationComment = AstFactory.documentationComment(
|
| [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| fieldDeclaration.endToken.offset = 110;
|
| - fieldDeclaration.accept(builder);
|
|
|
| + ElementHolder holder = buildElementsForAst(fieldDeclaration);
|
| List<FieldElement> fields = holder.fields;
|
| expect(fields, hasLength(2));
|
|
|
| FieldElement firstField = fields[0];
|
| expect(firstField, isNotNull);
|
| - _assertHasCodeRange(firstField, 50, 61);
|
| + assertHasCodeRange(firstField, 50, 61);
|
| expect(firstField.documentationComment, '/// aaa');
|
| expect(firstField.name, firstFieldName);
|
| expect(firstField.initializer, isNull);
|
| @@ -886,7 +1497,7 @@ class C {
|
|
|
| FieldElement secondField = fields[1];
|
| expect(secondField, isNotNull);
|
| - _assertHasCodeRange(secondField, 50, 61);
|
| + assertHasCodeRange(secondField, 50, 61);
|
| expect(secondField.documentationComment, '/// aaa');
|
| expect(secondField.name, secondFieldName);
|
| expect(secondField.initializer, isNull);
|
| @@ -896,19 +1507,17 @@ class C {
|
| }
|
|
|
| void test_visitFieldFormalParameter() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String parameterName = "p";
|
| FieldFormalParameter formalParameter =
|
| AstFactory.fieldFormalParameter(null, null, parameterName);
|
| formalParameter.beginToken.offset = 50;
|
| formalParameter.endToken.offset = 80;
|
| - formalParameter.accept(builder);
|
| + ElementHolder holder = buildElementsForAst(formalParameter);
|
| List<ParameterElement> parameters = holder.parameters;
|
| expect(parameters, hasLength(1));
|
| ParameterElement parameter = parameters[0];
|
| expect(parameter, isNotNull);
|
| - _assertHasCodeRange(parameter, 50, 31);
|
| + assertHasCodeRange(parameter, 50, 31);
|
| expect(parameter.name, parameterName);
|
| expect(parameter.initializer, isNull);
|
| expect(parameter.isConst, isFalse);
|
| @@ -919,8 +1528,6 @@ class C {
|
| }
|
|
|
| void test_visitFieldFormalParameter_functionTyped() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String parameterName = "p";
|
| FieldFormalParameter formalParameter = AstFactory.fieldFormalParameter(
|
| null,
|
| @@ -928,7 +1535,7 @@ class C {
|
| parameterName,
|
| AstFactory
|
| .formalParameterList([AstFactory.simpleFormalParameter3("a")]));
|
| - formalParameter.accept(builder);
|
| + ElementHolder holder = buildElementsForAst(formalParameter);
|
| List<ParameterElement> parameters = holder.parameters;
|
| expect(parameters, hasLength(1));
|
| ParameterElement parameter = parameters[0];
|
| @@ -943,15 +1550,13 @@ class C {
|
| }
|
|
|
| void test_visitFormalParameterList() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String firstParameterName = "a";
|
| String secondParameterName = "b";
|
| FormalParameterList parameterList = AstFactory.formalParameterList([
|
| AstFactory.simpleFormalParameter3(firstParameterName),
|
| AstFactory.simpleFormalParameter3(secondParameterName)
|
| ]);
|
| - parameterList.accept(builder);
|
| + ElementHolder holder = buildElementsForAst(parameterList);
|
| List<ParameterElement> parameters = holder.parameters;
|
| expect(parameters, hasLength(2));
|
| expect(parameters[0].name, firstParameterName);
|
| @@ -960,8 +1565,6 @@ class C {
|
|
|
| void test_visitFunctionDeclaration_external() {
|
| // external f();
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String functionName = "f";
|
| FunctionDeclaration declaration = AstFactory.functionDeclaration(
|
| null,
|
| @@ -971,8 +1574,8 @@ class C {
|
| AstFactory.formalParameterList(), AstFactory.emptyFunctionBody()));
|
| declaration.externalKeyword =
|
| TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
|
| - declaration.accept(builder);
|
|
|
| + ElementHolder holder = buildElementsForAst(declaration);
|
| List<FunctionElement> functions = holder.functions;
|
| expect(functions, hasLength(1));
|
| FunctionElement function = functions[0];
|
| @@ -988,8 +1591,6 @@ class C {
|
|
|
| void test_visitFunctionDeclaration_getter() {
|
| // get f() {}
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String functionName = "f";
|
| FunctionDeclaration declaration = AstFactory.functionDeclaration(
|
| null,
|
| @@ -1000,13 +1601,13 @@ class C {
|
| declaration.documentationComment = AstFactory.documentationComment(
|
| [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| declaration.endToken.offset = 80;
|
| - declaration.accept(builder);
|
|
|
| + ElementHolder holder = buildElementsForAst(declaration);
|
| List<PropertyAccessorElement> accessors = holder.accessors;
|
| expect(accessors, hasLength(1));
|
| PropertyAccessorElement accessor = accessors[0];
|
| expect(accessor, isNotNull);
|
| - _assertHasCodeRange(accessor, 50, 31);
|
| + assertHasCodeRange(accessor, 50, 31);
|
| expect(accessor.documentationComment, '/// aaa');
|
| expect(accessor.name, functionName);
|
| expect(declaration.element, same(accessor));
|
| @@ -1025,8 +1626,6 @@ class C {
|
|
|
| void test_visitFunctionDeclaration_plain() {
|
| // T f() {}
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String functionName = "f";
|
| FunctionDeclaration declaration = AstFactory.functionDeclaration(
|
| AstFactory.typeName4('T'),
|
| @@ -1037,13 +1636,13 @@ class C {
|
| declaration.documentationComment = AstFactory.documentationComment(
|
| [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| declaration.endToken.offset = 80;
|
| - declaration.accept(builder);
|
|
|
| + ElementHolder holder = buildElementsForAst(declaration);
|
| List<FunctionElement> functions = holder.functions;
|
| expect(functions, hasLength(1));
|
| FunctionElement function = functions[0];
|
| expect(function, isNotNull);
|
| - _assertHasCodeRange(function, 50, 31);
|
| + assertHasCodeRange(function, 50, 31);
|
| expect(function.documentationComment, '/// aaa');
|
| expect(function.hasImplicitReturnType, isFalse);
|
| expect(function.name, functionName);
|
| @@ -1056,8 +1655,6 @@ class C {
|
|
|
| void test_visitFunctionDeclaration_setter() {
|
| // set f() {}
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String functionName = "f";
|
| FunctionDeclaration declaration = AstFactory.functionDeclaration(
|
| null,
|
| @@ -1068,13 +1665,13 @@ class C {
|
| declaration.documentationComment = AstFactory.documentationComment(
|
| [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| declaration.endToken.offset = 80;
|
| - declaration.accept(builder);
|
|
|
| + ElementHolder holder = buildElementsForAst(declaration);
|
| List<PropertyAccessorElement> accessors = holder.accessors;
|
| expect(accessors, hasLength(1));
|
| PropertyAccessorElement accessor = accessors[0];
|
| expect(accessor, isNotNull);
|
| - _assertHasCodeRange(accessor, 50, 31);
|
| + assertHasCodeRange(accessor, 50, 31);
|
| expect(accessor.documentationComment, '/// aaa');
|
| expect(accessor.hasImplicitReturnType, isTrue);
|
| expect(accessor.name, "$functionName=");
|
| @@ -1093,158 +1690,35 @@ class C {
|
|
|
| void test_visitFunctionDeclaration_typeParameters() {
|
| // f<E>() {}
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String functionName = 'f';
|
| String typeParameterName = 'E';
|
| FunctionExpression expression = AstFactory.functionExpression3(
|
| AstFactory.typeParameterList([typeParameterName]),
|
| AstFactory.formalParameterList(),
|
| AstFactory.blockFunctionBody2());
|
| - FunctionDeclaration declaration =
|
| - AstFactory.functionDeclaration(null, null, functionName, expression);
|
| - declaration.accept(builder);
|
| -
|
| - List<FunctionElement> functions = holder.functions;
|
| - expect(functions, hasLength(1));
|
| - FunctionElement function = functions[0];
|
| - expect(function, isNotNull);
|
| - expect(function.hasImplicitReturnType, isTrue);
|
| - expect(function.name, functionName);
|
| - expect(function.isExternal, isFalse);
|
| - expect(function.isSynthetic, isFalse);
|
| - expect(declaration.element, same(function));
|
| - expect(expression.element, same(function));
|
| - List<TypeParameterElement> typeParameters = function.typeParameters;
|
| - expect(typeParameters, hasLength(1));
|
| - TypeParameterElement typeParameter = typeParameters[0];
|
| - expect(typeParameter, isNotNull);
|
| - expect(typeParameter.name, typeParameterName);
|
| - }
|
| -
|
| - 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);
|
| - expect(expression.element, same(function));
|
| - expect(function.hasImplicitReturnType, isTrue);
|
| - expect(function.isSynthetic, isFalse);
|
| - expect(function.typeParameters, hasLength(0));
|
| - }
|
| -
|
| - void test_visitFunctionExpression_inBlockBody() {
|
| - List<FunctionElement> functions =
|
| - buildElementsForText('f() { return () => 42; }').functions[0].functions;
|
| - expect(functions, hasLength(1));
|
| - FunctionElement function = functions[0];
|
| - expect(function, isNotNull);
|
| - expect(function.hasImplicitReturnType, isTrue);
|
| - expect(function.isSynthetic, isFalse);
|
| - expect(function.typeParameters, hasLength(0));
|
| - }
|
| -
|
| - void test_visitFunctionExpression_inExpressionBody() {
|
| - List<FunctionElement> functions =
|
| - buildElementsForText('f() => () => 42;').functions[0].functions;
|
| - expect(functions, hasLength(1));
|
| - FunctionElement function = functions[0];
|
| - expect(function, isNotNull);
|
| - expect(function.hasImplicitReturnType, isTrue);
|
| - expect(function.isSynthetic, isFalse);
|
| - expect(function.typeParameters, hasLength(0));
|
| - }
|
| -
|
| - void test_visitFunctionTypeAlias() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String aliasName = "F";
|
| - String parameterName = "E";
|
| - FunctionTypeAlias aliasNode = AstFactory.typeAlias(
|
| - null, aliasName, AstFactory.typeParameterList([parameterName]), null);
|
| - aliasNode.documentationComment = AstFactory.documentationComment(
|
| - [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| - aliasNode.endToken.offset = 80;
|
| - aliasNode.accept(builder);
|
| -
|
| - List<FunctionTypeAliasElement> aliases = holder.typeAliases;
|
| - expect(aliases, hasLength(1));
|
| - FunctionTypeAliasElement alias = aliases[0];
|
| - expect(alias, isNotNull);
|
| - _assertHasCodeRange(alias, 50, 31);
|
| - expect(alias.documentationComment, '/// aaa');
|
| - expect(alias.name, aliasName);
|
| - expect(alias.parameters, hasLength(0));
|
| - List<TypeParameterElement> typeParameters = alias.typeParameters;
|
| - expect(typeParameters, hasLength(1));
|
| - TypeParameterElement typeParameter = typeParameters[0];
|
| - expect(typeParameter, isNotNull);
|
| - expect(typeParameter.name, parameterName);
|
| - }
|
| -
|
| - void test_visitFunctionTypedFormalParameter() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String parameterName = "p";
|
| - FunctionTypedFormalParameter formalParameter =
|
| - AstFactory.functionTypedFormalParameter(null, parameterName);
|
| - _useParameterInMethod(formalParameter, 100, 110);
|
| - formalParameter.accept(builder);
|
| - List<ParameterElement> parameters = holder.parameters;
|
| - expect(parameters, hasLength(1));
|
| - ParameterElement parameter = parameters[0];
|
| - expect(parameter, isNotNull);
|
| - expect(parameter.name, parameterName);
|
| - expect(parameter.initializer, isNull);
|
| - expect(parameter.isConst, isFalse);
|
| - expect(parameter.isFinal, isFalse);
|
| - expect(parameter.isSynthetic, isFalse);
|
| - expect(parameter.parameterKind, ParameterKind.REQUIRED);
|
| - _assertVisibleRange(parameter, 100, 110);
|
| - }
|
| -
|
| - void test_visitFunctionTypedFormalParameter_withTypeParameters() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String parameterName = "p";
|
| - FunctionTypedFormalParameter formalParameter =
|
| - AstFactory.functionTypedFormalParameter(null, parameterName);
|
| - formalParameter.typeParameters = AstFactory.typeParameterList(['F']);
|
| - _useParameterInMethod(formalParameter, 100, 110);
|
| - formalParameter.accept(builder);
|
| - List<ParameterElement> parameters = holder.parameters;
|
| - expect(parameters, hasLength(1));
|
| - ParameterElement parameter = parameters[0];
|
| - expect(parameter, isNotNull);
|
| - expect(parameter.name, parameterName);
|
| - 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);
|
| - }
|
| + FunctionDeclaration declaration =
|
| + AstFactory.functionDeclaration(null, null, functionName, expression);
|
|
|
| - void test_visitLabeledStatement() {
|
| - 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);
|
| + ElementHolder holder = buildElementsForAst(declaration);
|
| + List<FunctionElement> functions = holder.functions;
|
| + expect(functions, hasLength(1));
|
| + FunctionElement function = functions[0];
|
| + expect(function, isNotNull);
|
| + expect(function.hasImplicitReturnType, isTrue);
|
| + expect(function.name, functionName);
|
| + expect(function.isExternal, isFalse);
|
| + expect(function.isSynthetic, isFalse);
|
| + expect(declaration.element, same(function));
|
| + expect(expression.element, same(function));
|
| + List<TypeParameterElement> typeParameters = function.typeParameters;
|
| + expect(typeParameters, hasLength(1));
|
| + TypeParameterElement typeParameter = typeParameters[0];
|
| + expect(typeParameter, isNotNull);
|
| + expect(typeParameter.name, typeParameterName);
|
| }
|
|
|
| void test_visitMethodDeclaration_abstract() {
|
| // m();
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String methodName = "m";
|
| MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
|
| null,
|
| @@ -1254,8 +1728,8 @@ class C {
|
| AstFactory.identifier3(methodName),
|
| AstFactory.formalParameterList(),
|
| AstFactory.emptyFunctionBody());
|
| - methodDeclaration.accept(builder);
|
|
|
| + ElementHolder holder = buildElementsForAst(methodDeclaration);
|
| List<MethodElement> methods = holder.methods;
|
| expect(methods, hasLength(1));
|
| MethodElement method = methods[0];
|
| @@ -1312,8 +1786,6 @@ class A {
|
|
|
| void test_visitMethodDeclaration_external() {
|
| // external m();
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String methodName = "m";
|
| MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
|
| null,
|
| @@ -1325,8 +1797,8 @@ class A {
|
| AstFactory.emptyFunctionBody());
|
| methodDeclaration.externalKeyword =
|
| TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
|
| - methodDeclaration.accept(builder);
|
|
|
| + ElementHolder holder = buildElementsForAst(methodDeclaration);
|
| List<MethodElement> methods = holder.methods;
|
| expect(methods, hasLength(1));
|
| MethodElement method = methods[0];
|
| @@ -1346,8 +1818,6 @@ class A {
|
|
|
| void test_visitMethodDeclaration_getter() {
|
| // get m() {}
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String methodName = "m";
|
| MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
|
| null,
|
| @@ -1360,8 +1830,8 @@ class A {
|
| methodDeclaration.documentationComment = AstFactory.documentationComment(
|
| [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| methodDeclaration.endToken.offset = 80;
|
| - methodDeclaration.accept(builder);
|
|
|
| + ElementHolder holder = buildElementsForAst(methodDeclaration);
|
| List<FieldElement> fields = holder.fields;
|
| expect(fields, hasLength(1));
|
| FieldElement field = fields[0];
|
| @@ -1371,7 +1841,7 @@ class A {
|
| expect(field.setter, isNull);
|
| PropertyAccessorElement getter = field.getter;
|
| expect(getter, isNotNull);
|
| - _assertHasCodeRange(getter, 50, 31);
|
| + assertHasCodeRange(getter, 50, 31);
|
| expect(getter.documentationComment, '/// aaa');
|
| expect(getter.hasImplicitReturnType, isTrue);
|
| expect(getter.isAbstract, isFalse);
|
| @@ -1388,8 +1858,6 @@ class A {
|
|
|
| void test_visitMethodDeclaration_getter_abstract() {
|
| // get m();
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String methodName = "m";
|
| MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
|
| null,
|
| @@ -1399,8 +1867,8 @@ class A {
|
| AstFactory.identifier3(methodName),
|
| AstFactory.formalParameterList(),
|
| AstFactory.emptyFunctionBody());
|
| - methodDeclaration.accept(builder);
|
|
|
| + ElementHolder holder = buildElementsForAst(methodDeclaration);
|
| List<FieldElement> fields = holder.fields;
|
| expect(fields, hasLength(1));
|
| FieldElement field = fields[0];
|
| @@ -1425,8 +1893,6 @@ class A {
|
|
|
| void test_visitMethodDeclaration_getter_external() {
|
| // external get m();
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| String methodName = "m";
|
| MethodDeclaration methodDeclaration = AstFactory.methodDeclaration(
|
| null,
|
| @@ -1437,8 +1903,8 @@ class A {
|
| AstFactory.formalParameterList());
|
| methodDeclaration.externalKeyword =
|
| TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
|
| - methodDeclaration.accept(builder);
|
|
|
| + ElementHolder holder = buildElementsForAst(methodDeclaration);
|
| List<FieldElement> fields = holder.fields;
|
| expect(fields, hasLength(1));
|
| FieldElement field = fields[0];
|
| @@ -1458,770 +1924,424 @@ class A {
|
| 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() {}
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String methodName = "m";
|
| - MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
|
| - null,
|
| - AstFactory.typeName4('T'),
|
| - null,
|
| - null,
|
| - AstFactory.identifier3(methodName),
|
| - AstFactory.formalParameterList(),
|
| - AstFactory.blockFunctionBody2());
|
| - methodDeclaration.documentationComment = AstFactory.documentationComment(
|
| - [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| - methodDeclaration.endToken.offset = 80;
|
| - methodDeclaration.accept(builder);
|
| -
|
| - 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) {}
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String methodName = "+";
|
| - MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
|
| - null,
|
| - null,
|
| - null,
|
| - Keyword.OPERATOR,
|
| - AstFactory.identifier3(methodName),
|
| - AstFactory
|
| - .formalParameterList([AstFactory.simpleFormalParameter3("addend")]),
|
| - AstFactory.blockFunctionBody2());
|
| - methodDeclaration.accept(builder);
|
| -
|
| - List<MethodElement> methods = holder.methods;
|
| - expect(methods, hasLength(1));
|
| - MethodElement method = methods[0];
|
| - expect(method, isNotNull);
|
| - expect(method.hasImplicitReturnType, isTrue);
|
| - expect(method.name, methodName);
|
| - expect(method.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() {}
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String methodName = "m";
|
| - MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
|
| - null,
|
| - null,
|
| - Keyword.SET,
|
| - null,
|
| - AstFactory.identifier3(methodName),
|
| - AstFactory.formalParameterList(),
|
| - AstFactory.blockFunctionBody2());
|
| - methodDeclaration.documentationComment = AstFactory.documentationComment(
|
| - [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| - methodDeclaration.endToken.offset = 80;
|
| - methodDeclaration.accept(builder);
|
| -
|
| - List<FieldElement> fields = holder.fields;
|
| - expect(fields, hasLength(1));
|
| - FieldElement field = fields[0];
|
| - expect(field, isNotNull);
|
| - expect(field.name, methodName);
|
| - expect(field.isSynthetic, isTrue);
|
| - expect(field.getter, isNull);
|
| -
|
| - PropertyAccessorElement setter = field.setter;
|
| - expect(setter, isNotNull);
|
| - _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.labels, hasLength(0));
|
| - expect(setter.localVariables, hasLength(0));
|
| - expect(setter.parameters, hasLength(0));
|
| - }
|
| -
|
| - void test_visitMethodDeclaration_setter_abstract() {
|
| - // set m();
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String methodName = "m";
|
| - MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
|
| - null,
|
| - null,
|
| - Keyword.SET,
|
| - null,
|
| - AstFactory.identifier3(methodName),
|
| - AstFactory.formalParameterList(),
|
| - AstFactory.emptyFunctionBody());
|
| - methodDeclaration.accept(builder);
|
| -
|
| - List<FieldElement> fields = holder.fields;
|
| - expect(fields, hasLength(1));
|
| - FieldElement field = fields[0];
|
| - expect(field, isNotNull);
|
| - expect(field.name, methodName);
|
| - expect(field.isSynthetic, isTrue);
|
| - expect(field.getter, isNull);
|
| - 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.labels, hasLength(0));
|
| - expect(setter.localVariables, hasLength(0));
|
| - expect(setter.parameters, hasLength(0));
|
| - }
|
| -
|
| - void test_visitMethodDeclaration_setter_external() {
|
| - // external m();
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String methodName = "m";
|
| - MethodDeclaration methodDeclaration = AstFactory.methodDeclaration(
|
| - null,
|
| - null,
|
| - Keyword.SET,
|
| - null,
|
| - AstFactory.identifier3(methodName),
|
| - AstFactory.formalParameterList());
|
| - methodDeclaration.externalKeyword =
|
| - TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
|
| - methodDeclaration.accept(builder);
|
| -
|
| - List<FieldElement> fields = holder.fields;
|
| - expect(fields, hasLength(1));
|
| - FieldElement field = fields[0];
|
| - expect(field, isNotNull);
|
| - expect(field.name, methodName);
|
| - expect(field.isSynthetic, isTrue);
|
| - expect(field.getter, isNull);
|
| - 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.labels, hasLength(0));
|
| - expect(setter.localVariables, hasLength(0));
|
| - expect(setter.parameters, hasLength(0));
|
| - }
|
| -
|
| - void test_visitMethodDeclaration_static() {
|
| - // static m() {}
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String methodName = "m";
|
| - MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
|
| - Keyword.STATIC,
|
| - null,
|
| - null,
|
| - null,
|
| - AstFactory.identifier3(methodName),
|
| - AstFactory.formalParameterList(),
|
| - AstFactory.blockFunctionBody2());
|
| - methodDeclaration.accept(builder);
|
| - List<MethodElement> methods = holder.methods;
|
| - expect(methods, hasLength(1));
|
| - MethodElement method = methods[0];
|
| - expect(method, isNotNull);
|
| - expect(method.hasImplicitReturnType, isTrue);
|
| - expect(method.name, methodName);
|
| - expect(method.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>() {}
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| + expect(getter.parameters, hasLength(0));
|
| + }
|
| +
|
| + void test_visitMethodDeclaration_minimal() {
|
| + // T m() {}
|
| String methodName = "m";
|
| MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
|
| null,
|
| - null,
|
| + AstFactory.typeName4('T'),
|
| null,
|
| null,
|
| AstFactory.identifier3(methodName),
|
| AstFactory.formalParameterList(),
|
| AstFactory.blockFunctionBody2());
|
| - methodDeclaration.typeParameters = AstFactory.typeParameterList(['E']);
|
| - methodDeclaration.accept(builder);
|
| + methodDeclaration.documentationComment = AstFactory.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);
|
| - expect(method.hasImplicitReturnType, isTrue);
|
| + 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(1));
|
| - expect(method.isAbstract, isFalse);
|
| - expect(method.isExternal, isFalse);
|
| - expect(method.isStatic, isFalse);
|
| - expect(method.isSynthetic, isFalse);
|
| - }
|
| -
|
| - void test_visitMethodDeclaration_withMembers() {
|
| - MethodElement method = buildElementsForText(
|
| - 'class C { m(p) { var v; try { l: return; } catch (e) {} } }')
|
| - .types[0]
|
| - .methods[0];
|
| - String methodName = "m";
|
| - String parameterName = "p";
|
| - String localVariableName = "v";
|
| - String labelName = "l";
|
| - String exceptionParameterName = "e";
|
| - 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);
|
| - 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);
|
| - String parameterName = "p";
|
| - DefaultFormalParameter formalParameter = AstFactory.namedFormalParameter(
|
| - AstFactory.simpleFormalParameter3(parameterName),
|
| - AstFactory.identifier3("42"));
|
| - _useParameterInMethod(formalParameter, 100, 110);
|
| - formalParameter.beginToken.offset = 50;
|
| - formalParameter.endToken.offset = 80;
|
| - formalParameter.accept(builder);
|
| - List<ParameterElement> parameters = holder.parameters;
|
| - expect(parameters, hasLength(1));
|
| - ParameterElement parameter = parameters[0];
|
| - expect(parameter, isNotNull);
|
| - _assertHasCodeRange(parameter, 50, 32);
|
| - expect(parameter.name, parameterName);
|
| - expect(parameter.isConst, isFalse);
|
| - expect(parameter.isFinal, isFalse);
|
| - expect(parameter.isSynthetic, isFalse);
|
| - expect(parameter.parameterKind, ParameterKind.NAMED);
|
| - _assertVisibleRange(parameter, 100, 110);
|
| - expect(parameter.defaultValueCode, "42");
|
| - FunctionElement initializer = parameter.initializer;
|
| - expect(initializer, isNotNull);
|
| - expect(initializer.isSynthetic, isTrue);
|
| - expect(initializer.hasImplicitReturnType, isTrue);
|
| - }
|
| -
|
| - void test_visitSimpleFormalParameter_noType() {
|
| - // p
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String parameterName = "p";
|
| - SimpleFormalParameter formalParameter =
|
| - AstFactory.simpleFormalParameter3(parameterName);
|
| - _useParameterInMethod(formalParameter, 100, 110);
|
| - formalParameter.accept(builder);
|
| - List<ParameterElement> parameters = holder.parameters;
|
| - expect(parameters, hasLength(1));
|
| - ParameterElement parameter = parameters[0];
|
| - expect(parameter, isNotNull);
|
| - expect(parameter.hasImplicitType, isTrue);
|
| - expect(parameter.initializer, isNull);
|
| - expect(parameter.isConst, isFalse);
|
| - expect(parameter.isFinal, isFalse);
|
| - expect(parameter.isSynthetic, isFalse);
|
| - expect(parameter.name, parameterName);
|
| - expect(parameter.parameterKind, ParameterKind.REQUIRED);
|
| - _assertVisibleRange(parameter, 100, 110);
|
| - }
|
| -
|
| - void test_visitSimpleFormalParameter_type() {
|
| - // T p
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String parameterName = "p";
|
| - SimpleFormalParameter formalParameter = AstFactory.simpleFormalParameter4(
|
| - AstFactory.typeName4('T'), parameterName);
|
| - _useParameterInMethod(formalParameter, 100, 110);
|
| - formalParameter.accept(builder);
|
| - List<ParameterElement> parameters = holder.parameters;
|
| - expect(parameters, hasLength(1));
|
| - ParameterElement parameter = parameters[0];
|
| - expect(parameter, isNotNull);
|
| - expect(parameter.hasImplicitType, isFalse);
|
| - expect(parameter.initializer, isNull);
|
| - expect(parameter.isConst, isFalse);
|
| - expect(parameter.isFinal, isFalse);
|
| - expect(parameter.isSynthetic, isFalse);
|
| - expect(parameter.name, parameterName);
|
| - expect(parameter.parameterKind, ParameterKind.REQUIRED);
|
| - _assertVisibleRange(parameter, 100, 110);
|
| - }
|
| -
|
| - void test_visitTypeAlias_minimal() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String aliasName = "F";
|
| - TypeAlias typeAlias = AstFactory.typeAlias(null, aliasName, null, null);
|
| - typeAlias.accept(builder);
|
| - List<FunctionTypeAliasElement> aliases = holder.typeAliases;
|
| - expect(aliases, hasLength(1));
|
| - FunctionTypeAliasElement alias = aliases[0];
|
| - expect(alias, isNotNull);
|
| - expect(alias.name, aliasName);
|
| - expect(alias.type, isNotNull);
|
| - expect(alias.isSynthetic, isFalse);
|
| - }
|
| -
|
| - void test_visitTypeAlias_withFormalParameters() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String aliasName = "F";
|
| - String firstParameterName = "x";
|
| - String secondParameterName = "y";
|
| - TypeAlias typeAlias = AstFactory.typeAlias(
|
| - null,
|
| - aliasName,
|
| - AstFactory.typeParameterList(),
|
| - AstFactory.formalParameterList([
|
| - AstFactory.simpleFormalParameter3(firstParameterName),
|
| - AstFactory.simpleFormalParameter3(secondParameterName)
|
| - ]));
|
| - typeAlias.beginToken.offset = 50;
|
| - typeAlias.endToken.offset = 80;
|
| - typeAlias.accept(builder);
|
| - List<FunctionTypeAliasElement> aliases = holder.typeAliases;
|
| - expect(aliases, hasLength(1));
|
| - FunctionTypeAliasElement alias = aliases[0];
|
| - expect(alias, isNotNull);
|
| - _assertHasCodeRange(alias, 50, 31);
|
| - expect(alias.name, aliasName);
|
| - expect(alias.type, isNotNull);
|
| - expect(alias.isSynthetic, isFalse);
|
| - List<VariableElement> parameters = alias.parameters;
|
| - expect(parameters, hasLength(2));
|
| - expect(parameters[0].name, firstParameterName);
|
| - expect(parameters[1].name, secondParameterName);
|
| - List<TypeParameterElement> typeParameters = alias.typeParameters;
|
| - expect(typeParameters, isNotNull);
|
| - expect(typeParameters, hasLength(0));
|
| - }
|
| -
|
| - void test_visitTypeAlias_withTypeParameters() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String aliasName = "F";
|
| - String firstTypeParameterName = "A";
|
| - String secondTypeParameterName = "B";
|
| - TypeAlias typeAlias = AstFactory.typeAlias(
|
| - null,
|
| - aliasName,
|
| - AstFactory.typeParameterList(
|
| - [firstTypeParameterName, secondTypeParameterName]),
|
| - AstFactory.formalParameterList());
|
| - typeAlias.accept(builder);
|
| - List<FunctionTypeAliasElement> aliases = holder.typeAliases;
|
| - expect(aliases, hasLength(1));
|
| - FunctionTypeAliasElement alias = aliases[0];
|
| - expect(alias, isNotNull);
|
| - expect(alias.name, aliasName);
|
| - expect(alias.type, isNotNull);
|
| - expect(alias.isSynthetic, isFalse);
|
| - List<VariableElement> parameters = alias.parameters;
|
| - expect(parameters, isNotNull);
|
| - expect(parameters, hasLength(0));
|
| - List<TypeParameterElement> typeParameters = alias.typeParameters;
|
| - expect(typeParameters, hasLength(2));
|
| - expect(typeParameters[0].name, firstTypeParameterName);
|
| - expect(typeParameters[1].name, secondTypeParameterName);
|
| - }
|
| -
|
| - void test_visitTypeParameter() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String parameterName = "E";
|
| - TypeParameter typeParameter = AstFactory.typeParameter(parameterName);
|
| - typeParameter.beginToken.offset = 50;
|
| - typeParameter.accept(builder);
|
| - List<TypeParameterElement> typeParameters = holder.typeParameters;
|
| - expect(typeParameters, hasLength(1));
|
| - TypeParameterElement typeParameterElement = typeParameters[0];
|
| - expect(typeParameterElement, isNotNull);
|
| - _assertHasCodeRange(typeParameterElement, 50, 1);
|
| - expect(typeParameterElement.name, parameterName);
|
| - expect(typeParameterElement.bound, isNull);
|
| - expect(typeParameterElement.isSynthetic, isFalse);
|
| - }
|
| -
|
| - void test_visitVariableDeclaration_inConstructor() {
|
| - 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);
|
| - }
|
| -
|
| - void test_visitVariableDeclaration_inForEachStatement() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - //
|
| - // m() { for (var v in []) }
|
| - //
|
| - String variableName = "v";
|
| - Statement statement = AstFactory.forEachStatement(
|
| - AstFactory.declaredIdentifier3('v'),
|
| - AstFactory.listLiteral(),
|
| - AstFactory.block());
|
| - _setNodeSourceRange(statement, 100, 110);
|
| - MethodDeclaration method = AstFactory.methodDeclaration2(
|
| - null,
|
| + 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 = AstFactory.methodDeclaration2(
|
| null,
|
| null,
|
| null,
|
| - AstFactory.identifier3("m"),
|
| - AstFactory.formalParameterList(),
|
| - AstFactory.blockFunctionBody2([statement]));
|
| - _setBlockBodySourceRange(method.body, 200, 220);
|
| - method.accept(builder);
|
| + Keyword.OPERATOR,
|
| + AstFactory.identifier3(methodName),
|
| + AstFactory
|
| + .formalParameterList([AstFactory.simpleFormalParameter3("addend")]),
|
| + AstFactory.blockFunctionBody2());
|
|
|
| + ElementHolder holder = buildElementsForAst(methodDeclaration);
|
| List<MethodElement> methods = holder.methods;
|
| expect(methods, hasLength(1));
|
| - List<LocalVariableElement> variableElements = methods[0].localVariables;
|
| - expect(variableElements, hasLength(1));
|
| - LocalVariableElement variableElement = variableElements[0];
|
| - expect(variableElement.name, variableName);
|
| - _assertVisibleRange(variableElement, 100, 110);
|
| + 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_visitVariableDeclaration_inForStatement() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - //
|
| - // m() { for (T v;;) }
|
| - //
|
| - String variableName = "v";
|
| - ForStatement statement = AstFactory.forStatement2(
|
| - AstFactory.variableDeclarationList(null, AstFactory.typeName4('T'),
|
| - [AstFactory.variableDeclaration('v')]),
|
| + void test_visitMethodDeclaration_setter() {
|
| + // set m() {}
|
| + String methodName = "m";
|
| + MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
|
| null,
|
| null,
|
| - AstFactory.block());
|
| - _setNodeSourceRange(statement, 100, 110);
|
| - MethodDeclaration method = AstFactory.methodDeclaration2(
|
| + Keyword.SET,
|
| null,
|
| + AstFactory.identifier3(methodName),
|
| + AstFactory.formalParameterList(),
|
| + AstFactory.blockFunctionBody2());
|
| + methodDeclaration.documentationComment = AstFactory.documentationComment(
|
| + [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| + methodDeclaration.endToken.offset = 80;
|
| +
|
| + ElementHolder holder = buildElementsForAst(methodDeclaration);
|
| + List<FieldElement> fields = holder.fields;
|
| + expect(fields, hasLength(1));
|
| + FieldElement field = fields[0];
|
| + expect(field, isNotNull);
|
| + expect(field.name, methodName);
|
| + expect(field.isSynthetic, isTrue);
|
| + expect(field.getter, isNull);
|
| +
|
| + PropertyAccessorElement setter = field.setter;
|
| + expect(setter, isNotNull);
|
| + 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.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 = AstFactory.methodDeclaration2(
|
| null,
|
| null,
|
| + Keyword.SET,
|
| null,
|
| - AstFactory.identifier3("m"),
|
| + AstFactory.identifier3(methodName),
|
| AstFactory.formalParameterList(),
|
| - AstFactory.blockFunctionBody2([statement]));
|
| - _setBlockBodySourceRange(method.body, 200, 220);
|
| - method.accept(builder);
|
| + AstFactory.emptyFunctionBody());
|
|
|
| - List<MethodElement> methods = holder.methods;
|
| - expect(methods, hasLength(1));
|
| - List<LocalVariableElement> variableElements = methods[0].localVariables;
|
| - expect(variableElements, hasLength(1));
|
| - LocalVariableElement variableElement = variableElements[0];
|
| - expect(variableElement.name, variableName);
|
| - _assertVisibleRange(variableElement, 100, 110);
|
| + ElementHolder holder = buildElementsForAst(methodDeclaration);
|
| + List<FieldElement> fields = holder.fields;
|
| + expect(fields, hasLength(1));
|
| + FieldElement field = fields[0];
|
| + expect(field, isNotNull);
|
| + expect(field.name, methodName);
|
| + expect(field.isSynthetic, isTrue);
|
| + expect(field.getter, isNull);
|
| + 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.labels, hasLength(0));
|
| + expect(setter.localVariables, hasLength(0));
|
| + expect(setter.parameters, hasLength(0));
|
| }
|
|
|
| - void test_visitVariableDeclaration_inMethod() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - //
|
| - // m() {T v;}
|
| - //
|
| - String variableName = "v";
|
| - VariableDeclaration variable =
|
| - AstFactory.variableDeclaration2(variableName, null);
|
| - Statement statement = AstFactory.variableDeclarationStatement(
|
| - null, AstFactory.typeName4('T'), [variable]);
|
| - MethodDeclaration method = AstFactory.methodDeclaration2(
|
| + void test_visitMethodDeclaration_setter_external() {
|
| + // external m();
|
| + String methodName = "m";
|
| + MethodDeclaration methodDeclaration = AstFactory.methodDeclaration(
|
| + null,
|
| + null,
|
| + Keyword.SET,
|
| null,
|
| + AstFactory.identifier3(methodName),
|
| + AstFactory.formalParameterList());
|
| + methodDeclaration.externalKeyword =
|
| + TokenFactory.tokenFromKeyword(Keyword.EXTERNAL);
|
| +
|
| + ElementHolder holder = buildElementsForAst(methodDeclaration);
|
| + List<FieldElement> fields = holder.fields;
|
| + expect(fields, hasLength(1));
|
| + FieldElement field = fields[0];
|
| + expect(field, isNotNull);
|
| + expect(field.name, methodName);
|
| + expect(field.isSynthetic, isTrue);
|
| + expect(field.getter, isNull);
|
| + 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.labels, hasLength(0));
|
| + expect(setter.localVariables, hasLength(0));
|
| + expect(setter.parameters, hasLength(0));
|
| + }
|
| +
|
| + void test_visitMethodDeclaration_static() {
|
| + // static m() {}
|
| + String methodName = "m";
|
| + MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
|
| + Keyword.STATIC,
|
| null,
|
| null,
|
| null,
|
| - AstFactory.identifier3("m"),
|
| + AstFactory.identifier3(methodName),
|
| AstFactory.formalParameterList(),
|
| - AstFactory.blockFunctionBody2([statement]));
|
| - _setBlockBodySourceRange(method.body, 100, 110);
|
| - method.accept(builder);
|
| -
|
| + AstFactory.blockFunctionBody2());
|
| + ElementHolder holder = buildElementsForAst(methodDeclaration);
|
| List<MethodElement> methods = holder.methods;
|
| expect(methods, hasLength(1));
|
| - List<LocalVariableElement> variableElements = methods[0].localVariables;
|
| - expect(variableElements, hasLength(1));
|
| - LocalVariableElement variableElement = variableElements[0];
|
| - expect(variableElement.hasImplicitType, isFalse);
|
| - expect(variableElement.name, variableName);
|
| - _assertVisibleRange(variableElement, 100, 110);
|
| + 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_visitVariableDeclaration_localNestedInFunction() {
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - //
|
| - // var f = () {var v;};
|
| - //
|
| - String variableName = "v";
|
| - VariableDeclaration variable =
|
| - AstFactory.variableDeclaration2(variableName, null);
|
| - Statement statement =
|
| - AstFactory.variableDeclarationStatement2(null, [variable]);
|
| - Expression initializer = AstFactory.functionExpression2(
|
| + void test_visitMethodDeclaration_typeParameters() {
|
| + // m<E>() {}
|
| + String methodName = "m";
|
| + MethodDeclaration methodDeclaration = AstFactory.methodDeclaration2(
|
| + null,
|
| + null,
|
| + null,
|
| + null,
|
| + AstFactory.identifier3(methodName),
|
| AstFactory.formalParameterList(),
|
| - AstFactory.blockFunctionBody2([statement]));
|
| - String fieldName = "f";
|
| - VariableDeclaration field =
|
| - AstFactory.variableDeclaration2(fieldName, initializer);
|
| - FieldDeclaration fieldDeclaration =
|
| - AstFactory.fieldDeclaration2(false, null, [field]);
|
| - fieldDeclaration.accept(builder);
|
| + AstFactory.blockFunctionBody2());
|
| + methodDeclaration.typeParameters = AstFactory.typeParameterList(['E']);
|
|
|
| - 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];
|
| - expect(variableElement.hasImplicitType, isTrue);
|
| - expect(variableElement.isConst, isFalse);
|
| - expect(variableElement.isFinal, isFalse);
|
| - expect(variableElement.isSynthetic, isFalse);
|
| - expect(variableElement.name, variableName);
|
| + 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_visitVariableDeclaration_noInitializer() {
|
| - // var v;
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String variableName = "v";
|
| - VariableDeclaration variableDeclaration =
|
| - AstFactory.variableDeclaration2(variableName, null);
|
| - AstFactory.variableDeclarationList2(null, [variableDeclaration]);
|
| - variableDeclaration.accept(builder);
|
| + void test_visitTypeAlias_minimal() {
|
| + String aliasName = "F";
|
| + TypeAlias typeAlias = AstFactory.typeAlias(null, aliasName, null, null);
|
| + ElementHolder holder = buildElementsForAst(typeAlias);
|
| + List<FunctionTypeAliasElement> aliases = holder.typeAliases;
|
| + expect(aliases, hasLength(1));
|
| + FunctionTypeAliasElement alias = aliases[0];
|
| + expect(alias, isNotNull);
|
| + expect(alias.name, aliasName);
|
| + expect(alias.type, isNotNull);
|
| + expect(alias.isSynthetic, isFalse);
|
| + }
|
|
|
| - List<TopLevelVariableElement> variables = holder.topLevelVariables;
|
| - expect(variables, hasLength(1));
|
| - TopLevelVariableElement variable = variables[0];
|
| - expect(variable, isNotNull);
|
| - expect(variable.hasImplicitType, isTrue);
|
| - expect(variable.initializer, isNull);
|
| - expect(variable.name, variableName);
|
| - expect(variable.isConst, isFalse);
|
| - expect(variable.isFinal, isFalse);
|
| - expect(variable.isSynthetic, isFalse);
|
| - expect(variable.getter, isNotNull);
|
| - expect(variable.setter, isNotNull);
|
| + void test_visitTypeAlias_withFormalParameters() {
|
| + String aliasName = "F";
|
| + String firstParameterName = "x";
|
| + String secondParameterName = "y";
|
| + TypeAlias typeAlias = AstFactory.typeAlias(
|
| + null,
|
| + aliasName,
|
| + AstFactory.typeParameterList(),
|
| + AstFactory.formalParameterList([
|
| + AstFactory.simpleFormalParameter3(firstParameterName),
|
| + AstFactory.simpleFormalParameter3(secondParameterName)
|
| + ]));
|
| + typeAlias.beginToken.offset = 50;
|
| + typeAlias.endToken.offset = 80;
|
| + ElementHolder holder = buildElementsForAst(typeAlias);
|
| + List<FunctionTypeAliasElement> aliases = holder.typeAliases;
|
| + expect(aliases, hasLength(1));
|
| + FunctionTypeAliasElement alias = aliases[0];
|
| + expect(alias, isNotNull);
|
| + assertHasCodeRange(alias, 50, 31);
|
| + expect(alias.name, aliasName);
|
| + expect(alias.type, isNotNull);
|
| + expect(alias.isSynthetic, isFalse);
|
| + List<VariableElement> parameters = alias.parameters;
|
| + expect(parameters, hasLength(2));
|
| + expect(parameters[0].name, firstParameterName);
|
| + expect(parameters[1].name, secondParameterName);
|
| + List<TypeParameterElement> typeParameters = alias.typeParameters;
|
| + expect(typeParameters, isNotNull);
|
| + expect(typeParameters, hasLength(0));
|
| }
|
|
|
| - void test_visitVariableDeclaration_top() {
|
| - // final a, b;
|
| - ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - VariableDeclaration variableDeclaration1 =
|
| - AstFactory.variableDeclaration('a');
|
| - VariableDeclaration variableDeclaration2 =
|
| - AstFactory.variableDeclaration('b');
|
| - TopLevelVariableDeclaration topLevelVariableDeclaration = AstFactory
|
| - .topLevelVariableDeclaration(
|
| - Keyword.FINAL, null, [variableDeclaration1, variableDeclaration2]);
|
| - topLevelVariableDeclaration.documentationComment = AstFactory
|
| - .documentationComment(
|
| - [TokenFactory.tokenFromString('/// aaa')..offset = 50], []);
|
| + void test_visitTypeAlias_withTypeParameters() {
|
| + String aliasName = "F";
|
| + String firstTypeParameterName = "A";
|
| + String secondTypeParameterName = "B";
|
| + TypeAlias typeAlias = AstFactory.typeAlias(
|
| + null,
|
| + aliasName,
|
| + AstFactory.typeParameterList(
|
| + [firstTypeParameterName, secondTypeParameterName]),
|
| + AstFactory.formalParameterList());
|
| + ElementHolder holder = buildElementsForAst(typeAlias);
|
| + List<FunctionTypeAliasElement> aliases = holder.typeAliases;
|
| + expect(aliases, hasLength(1));
|
| + FunctionTypeAliasElement alias = aliases[0];
|
| + expect(alias, isNotNull);
|
| + expect(alias.name, aliasName);
|
| + expect(alias.type, isNotNull);
|
| + expect(alias.isSynthetic, isFalse);
|
| + List<VariableElement> parameters = alias.parameters;
|
| + expect(parameters, isNotNull);
|
| + expect(parameters, hasLength(0));
|
| + List<TypeParameterElement> typeParameters = alias.typeParameters;
|
| + expect(typeParameters, hasLength(2));
|
| + expect(typeParameters[0].name, firstTypeParameterName);
|
| + expect(typeParameters[1].name, secondTypeParameterName);
|
| + }
|
|
|
| - topLevelVariableDeclaration.accept(builder);
|
| - List<TopLevelVariableElement> variables = holder.topLevelVariables;
|
| - expect(variables, hasLength(2));
|
| + void test_visitTypeParameter() {
|
| + String parameterName = "E";
|
| + TypeParameter typeParameter = AstFactory.typeParameter(parameterName);
|
| + typeParameter.beginToken.offset = 50;
|
| + ElementHolder holder = buildElementsForAst(typeParameter);
|
| + List<TypeParameterElement> typeParameters = holder.typeParameters;
|
| + expect(typeParameters, hasLength(1));
|
| + TypeParameterElement typeParameterElement = typeParameters[0];
|
| + expect(typeParameterElement, isNotNull);
|
| + assertHasCodeRange(typeParameterElement, 50, 1);
|
| + expect(typeParameterElement.name, parameterName);
|
| + expect(typeParameterElement.bound, isNull);
|
| + expect(typeParameterElement.isSynthetic, isFalse);
|
| + }
|
| +}
|
|
|
| - TopLevelVariableElement variable1 = variables[0];
|
| - expect(variable1, isNotNull);
|
| - expect(variable1.documentationComment, '/// aaa');
|
| +abstract class _BaseTest {
|
| + CompilationUnitElement compilationUnitElement;
|
| + CompilationUnit _compilationUnit;
|
|
|
| - TopLevelVariableElement variable2 = variables[1];
|
| - expect(variable2, isNotNull);
|
| - expect(variable2.documentationComment, '/// aaa');
|
| + CompilationUnit get compilationUnit => _compilationUnit;
|
| +
|
| + void assertHasCodeRange(Element element, int offset, int length) {
|
| + ElementImpl elementImpl = element;
|
| + expect(elementImpl.codeOffset, offset);
|
| + expect(elementImpl.codeLength, length);
|
| }
|
|
|
| - void test_visitVariableDeclaration_top_const_hasInitializer() {
|
| - // const v = 42;
|
| + /**
|
| + * Build elements using [ApiElementBuilder].
|
| + */
|
| + ElementHolder buildElementsForAst(AstNode node) {
|
| ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String variableName = "v";
|
| - VariableDeclaration variableDeclaration =
|
| - AstFactory.variableDeclaration2(variableName, AstFactory.integer(42));
|
| - AstFactory.variableDeclarationList2(Keyword.CONST, [variableDeclaration]);
|
| - variableDeclaration.accept(builder);
|
| -
|
| - List<TopLevelVariableElement> variables = holder.topLevelVariables;
|
| - expect(variables, hasLength(1));
|
| - TopLevelVariableElement variable = variables[0];
|
| - expect(variable, new isInstanceOf<ConstTopLevelVariableElementImpl>());
|
| - expect(variable.initializer, isNotNull);
|
| - expect(variable.initializer.type, isNotNull);
|
| - expect(variable.initializer.hasImplicitReturnType, isTrue);
|
| - expect(variable.name, variableName);
|
| - expect(variable.hasImplicitType, isTrue);
|
| - expect(variable.isConst, isTrue);
|
| - expect(variable.isFinal, isFalse);
|
| - expect(variable.isSynthetic, isFalse);
|
| - expect(variable.getter, isNotNull);
|
| - expect(variable.setter, isNull);
|
| + AstVisitor builder = createElementBuilder(holder);
|
| + node.accept(builder);
|
| + return holder;
|
| }
|
|
|
| - void test_visitVariableDeclaration_top_final() {
|
| - // final v;
|
| + /**
|
| + * Parse the given [code], and build elements using [ApiElementBuilder].
|
| + */
|
| + ElementHolder buildElementsForText(String code) {
|
| ElementHolder holder = new ElementHolder();
|
| - ElementBuilder builder = _makeBuilder(holder);
|
| - String variableName = "v";
|
| - VariableDeclaration variableDeclaration =
|
| - AstFactory.variableDeclaration2(variableName, null);
|
| - AstFactory.variableDeclarationList2(Keyword.FINAL, [variableDeclaration]);
|
| - variableDeclaration.accept(builder);
|
| - List<TopLevelVariableElement> variables = holder.topLevelVariables;
|
| - expect(variables, hasLength(1));
|
| - TopLevelVariableElement variable = variables[0];
|
| - expect(variable, isNotNull);
|
| - expect(variable.hasImplicitType, isTrue);
|
| - expect(variable.initializer, isNull);
|
| - expect(variable.name, variableName);
|
| - expect(variable.isConst, isFalse);
|
| - expect(variable.isFinal, isTrue);
|
| - expect(variable.isSynthetic, isFalse);
|
| - expect(variable.getter, isNotNull);
|
| - expect(variable.setter, isNull);
|
| + AstVisitor builder = createElementBuilder(holder);
|
| + _visitAstOfCode(code, builder);
|
| + return holder;
|
| }
|
|
|
| - void _assertHasCodeRange(Element element, int offset, int length) {
|
| - ElementImpl elementImpl = element;
|
| - expect(elementImpl.codeOffset, offset);
|
| - expect(elementImpl.codeLength, length);
|
| + /**
|
| + * Verify that the given [metadata] has exactly one annotation, and that its
|
| + * [ElementAnnotationImpl] is unresolved.
|
| + */
|
| + void checkAnnotation(NodeList<Annotation> metadata) {
|
| + expect(metadata, hasLength(1));
|
| + expect(metadata[0], new isInstanceOf<AnnotationImpl>());
|
| + AnnotationImpl annotation = metadata[0];
|
| + expect(annotation.elementAnnotation,
|
| + new isInstanceOf<ElementAnnotationImpl>());
|
| + ElementAnnotationImpl elementAnnotation = annotation.elementAnnotation;
|
| + expect(elementAnnotation.element, isNull); // Not yet resolved
|
| + expect(elementAnnotation.compilationUnit, isNotNull);
|
| + expect(elementAnnotation.compilationUnit, compilationUnitElement);
|
| }
|
|
|
| - void _assertVisibleRange(LocalElement element, int offset, int end) {
|
| - SourceRange visibleRange = element.visibleRange;
|
| - expect(visibleRange.offset, offset);
|
| - expect(visibleRange.end, end);
|
| + /**
|
| + * Verify that the given [element] has exactly one annotation, and that its
|
| + * [ElementAnnotationImpl] is unresolved.
|
| + */
|
| + void checkMetadata(Element element) {
|
| + 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);
|
| }
|
|
|
| - ElementBuilder _makeBuilder(ElementHolder holder) =>
|
| - new ElementBuilder(holder, new CompilationUnitElementImpl('test.dart'));
|
| + AstVisitor createElementBuilder(ElementHolder holder);
|
|
|
| - void _setBlockBodySourceRange(BlockFunctionBody body, int offset, int end) {
|
| - _setNodeSourceRange(body.block, offset, end);
|
| + void setUp() {
|
| + compilationUnitElement = new CompilationUnitElementImpl('test.dart');
|
| }
|
|
|
| - void _setNodeSourceRange(AstNode node, int offset, int end) {
|
| - node.beginToken.offset = offset;
|
| - Token endToken = node.endToken;
|
| - endToken.offset = end - endToken.length;
|
| + void _assertVisibleRange(LocalElement element, int offset, int end) {
|
| + SourceRange visibleRange = element.visibleRange;
|
| + expect(visibleRange.offset, offset);
|
| + expect(visibleRange.end, end);
|
| }
|
|
|
| - void _useParameterInMethod(
|
| - FormalParameter formalParameter, int blockOffset, int blockEnd) {
|
| - Block block = AstFactory.block();
|
| - block.leftBracket.offset = blockOffset;
|
| - block.rightBracket.offset = blockEnd - 1;
|
| - BlockFunctionBody body = AstFactory.blockFunctionBody(block);
|
| - AstFactory.methodDeclaration2(
|
| - null,
|
| - null,
|
| - null,
|
| - null,
|
| - AstFactory.identifier3("main"),
|
| - AstFactory.formalParameterList([formalParameter]),
|
| - body);
|
| + /**
|
| + * 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 = ParserTestCase.parseCompilationUnit(code);
|
| + compilationUnit.accept(visitor);
|
| + } finally {
|
| + expect(logger.log, hasLength(0));
|
| + AnalysisEngine.instance.logger = Logger.NULL;
|
| + }
|
| }
|
| }
|
|
|
Chromium Code Reviews
Issue 2431783002:
Add (shared) tests for ApiElementBuilder and ElementBuilder. (Closed)
