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; |
+ } |
} |
} |