Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(222)

Unified Diff: pkg/analyzer/test/dart/element/builder_test.dart

Issue 2431783002: Add (shared) tests for ApiElementBuilder and ElementBuilder. (Closed)
Patch Set: Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « pkg/analyzer/lib/src/dart/element/builder.dart ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
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;
+ }
}
}
« no previous file with comments | « pkg/analyzer/lib/src/dart/element/builder.dart ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698