Migrate SimpleResolverTest from task model.
R=brianwilkerson@google.com
Change-Id: Icb45287e7f63f5139468eed5b84c45822f6da5ed
Reviewed-on: https://dart-review.googlesource.com/c/92846
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>
diff --git a/pkg/analyzer/lib/src/test_utilities/find_element.dart b/pkg/analyzer/lib/src/test_utilities/find_element.dart
index f1362ce..86b3e1f 100644
--- a/pkg/analyzer/lib/src/test_utilities/find_element.dart
+++ b/pkg/analyzer/lib/src/test_utilities/find_element.dart
@@ -128,6 +128,10 @@
throw StateError('Not found: $name');
}
+ FieldFormalParameterElement fieldFormalParameter(String name) {
+ return parameter(name) as FieldFormalParameterElement;
+ }
+
FunctionElement function(String name) {
for (var function in unitElement.functions) {
if (function.name == name) {
@@ -333,6 +337,9 @@
for (var method in class_.methods) {
findIn(method.parameters);
}
+ for (var accessor in class_.accessors) {
+ findIn(accessor.parameters);
+ }
}
if (result != null) {
diff --git a/pkg/analyzer/lib/src/test_utilities/find_node.dart b/pkg/analyzer/lib/src/test_utilities/find_node.dart
index bb9f453..21883f7 100644
--- a/pkg/analyzer/lib/src/test_utilities/find_node.dart
+++ b/pkg/analyzer/lib/src/test_utilities/find_node.dart
@@ -35,6 +35,10 @@
return _node(search, (n) => n is Block);
}
+ BreakStatement breakStatement(String search) {
+ return _node(search, (n) => n is BreakStatement);
+ }
+
CascadeExpression cascade(String search) {
return _node(search, (n) => n is CascadeExpression);
}
@@ -55,10 +59,22 @@
return _node(search, (n) => n is ConstructorDeclaration);
}
+ ConstructorFieldInitializer constructorFieldInitializer(String search) {
+ return _node(search, (n) => n is ConstructorFieldInitializer);
+ }
+
+ ContinueStatement continueStatement(String search) {
+ return _node(search, (n) => n is ContinueStatement);
+ }
+
DefaultFormalParameter defaultParameter(String search) {
return _node(search, (n) => n is DefaultFormalParameter);
}
+ DoStatement doStatement(String search) {
+ return _node(search, (n) => n is DoStatement);
+ }
+
ExportDirective export(String search) {
return _node(search, (n) => n is ExportDirective);
}
@@ -75,6 +91,14 @@
return _node(search, (n) => n is FieldFormalParameter);
}
+ ForEachStatement forEachStatement(String search) {
+ return _node(search, (n) => n is ForEachStatement);
+ }
+
+ ForStatement forStatement(String search) {
+ return _node(search, (n) => n is ForStatement);
+ }
+
FunctionBody functionBody(String search) {
return _node(search, (n) => n is FunctionBody);
}
@@ -87,6 +111,10 @@
return _node(search, (n) => n is FunctionExpression);
}
+ FunctionTypeAlias functionTypeAlias(String search) {
+ return _node(search, (n) => n is FunctionTypeAlias);
+ }
+
GenericFunctionType genericFunctionType(String search) {
return _node(search, (n) => n is GenericFunctionType);
}
@@ -183,6 +211,10 @@
return _node(search, (n) => n is SuperExpression);
}
+ SwitchStatement switchStatement(String search) {
+ return _node(search, (n) => n is SwitchStatement);
+ }
+
ThisExpression this_(String search) {
return _node(search, (n) => n is ThisExpression);
}
@@ -211,6 +243,10 @@
return _node(search, (n) => n is VariableDeclaration);
}
+ WhileStatement whileStatement(String search) {
+ return _node(search, (n) => n is WhileStatement);
+ }
+
AstNode _node(String search, bool Function(AstNode) predicate) {
var index = content.indexOf(search);
if (content.indexOf(search, index + 1) != -1) {
diff --git a/pkg/analyzer/test/generated/simple_resolver_test.dart b/pkg/analyzer/test/generated/simple_resolver_test.dart
index c4b5223..a4d99bb 100644
--- a/pkg/analyzer/test/generated/simple_resolver_test.dart
+++ b/pkg/analyzer/test/generated/simple_resolver_test.dart
@@ -3,20 +3,13 @@
// BSD-style license that can be found in the LICENSE file.
import 'package:analyzer/dart/ast/ast.dart';
-import 'package:analyzer/dart/ast/standard_resolution_map.dart';
-import 'package:analyzer/dart/ast/visitor.dart';
import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/type.dart';
-import 'package:analyzer/exception/exception.dart';
import 'package:analyzer/src/error/codes.dart';
-import 'package:analyzer/src/generated/source_io.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
-import '../util/element_type_matchers.dart';
-import '../utils.dart';
+import '../src/dart/resolution/driver_resolution.dart';
import 'resolver_test_case.dart';
-import 'test_support.dart';
main() {
defineReflectiveSuite(() {
@@ -24,111 +17,109 @@
});
}
-/// TODO(paulberry): migrate this test away from the task model.
-/// See dartbug.com/35734.
@reflectiveTest
-class SimpleResolverTest extends ResolverTestCase {
+class SimpleResolverTest extends DriverResolutionTest {
test_argumentResolution_required_matching() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
void f() {
g(1, 2, 3);
}
void g(a, b, c) {}
}''');
- _validateArgumentResolution(source, [0, 1, 2]);
+ await _validateArgumentResolution([0, 1, 2]);
}
test_argumentResolution_required_tooFew() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
void f() {
g(1, 2);
}
void g(a, b, c) {}
}''');
- _validateArgumentResolution(source, [0, 1]);
+ await _validateArgumentResolution([0, 1]);
}
test_argumentResolution_required_tooMany() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
void f() {
g(1, 2, 3);
}
void g(a, b) {}
}''');
- _validateArgumentResolution(source, [0, 1, -1]);
+ await _validateArgumentResolution([0, 1, -1]);
}
test_argumentResolution_requiredAndNamed_extra() async {
- Source source = addSource(r'''
+ addTestFile('''
class A {
void f() {
g(1, 2, c: 3, d: 4);
}
void g(a, b, {c}) {}
}''');
- _validateArgumentResolution(source, [0, 1, 2, -1]);
+ await _validateArgumentResolution([0, 1, 2, -1]);
}
test_argumentResolution_requiredAndNamed_matching() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
void f() {
g(1, 2, c: 3);
}
void g(a, b, {c}) {}
}''');
- _validateArgumentResolution(source, [0, 1, 2]);
+ await _validateArgumentResolution([0, 1, 2]);
}
test_argumentResolution_requiredAndNamed_missing() async {
- Source source = addSource(r'''
+ addTestFile('''
class A {
void f() {
g(1, 2, d: 3);
}
void g(a, b, {c, d}) {}
}''');
- _validateArgumentResolution(source, [0, 1, 3]);
+ await _validateArgumentResolution([0, 1, 3]);
}
test_argumentResolution_requiredAndPositional_fewer() async {
- Source source = addSource(r'''
+ addTestFile('''
class A {
void f() {
g(1, 2, 3);
}
void g(a, b, [c, d]) {}
}''');
- _validateArgumentResolution(source, [0, 1, 2]);
+ await _validateArgumentResolution([0, 1, 2]);
}
test_argumentResolution_requiredAndPositional_matching() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
void f() {
g(1, 2, 3, 4);
}
void g(a, b, [c, d]) {}
}''');
- _validateArgumentResolution(source, [0, 1, 2, 3]);
+ await _validateArgumentResolution([0, 1, 2, 3]);
}
test_argumentResolution_requiredAndPositional_more() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
void f() {
g(1, 2, 3, 4);
}
void g(a, b, [c]) {}
}''');
- _validateArgumentResolution(source, [0, 1, 2, -1]);
+ await _validateArgumentResolution([0, 1, 2, -1]);
}
test_argumentResolution_setter_propagated() async {
- CompilationUnit unit = await resolveSource(r'''
+ addTestFile(r'''
main() {
var a = new A();
a.sss = 0;
@@ -136,20 +127,17 @@
class A {
set sss(x) {}
}''');
- // find "a.sss = 0"
- AssignmentExpression assignment;
- {
- var statements = AstFinder.getStatementsInTopLevelFunction(unit, 'main');
- var statement = statements[1] as ExpressionStatement;
- assignment = statement.expression as AssignmentExpression;
- }
- // get parameter
- Expression rhs = assignment.rightHandSide;
- expect(rhs.staticParameterElement, isNotNull);
+ await resolveTestFile();
+
+ var rhs = findNode.assignment(' = 0;').rightHandSide;
+ expect(
+ rhs.staticParameterElement,
+ findElement.parameter('x'),
+ );
}
test_argumentResolution_setter_propagated_propertyAccess() async {
- CompilationUnit unit = await resolveSource(r'''
+ addTestFile(r'''
main() {
var a = new A();
a.b.sss = 0;
@@ -160,20 +148,17 @@
class B {
set sss(x) {}
}''');
- // find "a.b.sss = 0"
- AssignmentExpression assignment;
- {
- var statements = AstFinder.getStatementsInTopLevelFunction(unit, 'main');
- var statement = statements[1] as ExpressionStatement;
- assignment = statement.expression as AssignmentExpression;
- }
- // get parameter
- Expression rhs = assignment.rightHandSide;
- expect(rhs.staticParameterElement, isNotNull);
+ await resolveTestFile();
+
+ var rhs = findNode.assignment(' = 0;').rightHandSide;
+ expect(
+ rhs.staticParameterElement,
+ findElement.parameter('x'),
+ );
}
test_argumentResolution_setter_static() async {
- CompilationUnit unit = await resolveSource(r'''
+ addTestFile(r'''
main() {
A a = new A();
a.sss = 0;
@@ -181,26 +166,17 @@
class A {
set sss(x) {}
}''');
- // find "a.sss = 0"
- AssignmentExpression assignment;
- {
- var statements = AstFinder.getStatementsInTopLevelFunction(unit, 'main');
- var statement = statements[1] as ExpressionStatement;
- assignment = statement.expression as AssignmentExpression;
- }
- // get parameter
- Expression rhs = assignment.rightHandSide;
- ParameterElement parameter = rhs.staticParameterElement;
- expect(parameter, isNotNull);
- expect(parameter.displayName, "x");
- // validate
- ClassElement classA = unit.declaredElement.types[0];
- PropertyAccessorElement setter = classA.accessors[0];
- expect(setter.parameters[0], same(parameter));
+ await resolveTestFile();
+
+ var rhs = findNode.assignment(' = 0;').rightHandSide;
+ expect(
+ rhs.staticParameterElement,
+ findElement.parameter('x'),
+ );
}
test_argumentResolution_setter_static_propertyAccess() async {
- CompilationUnit unit = await resolveSource(r'''
+ addTestFile(r'''
main() {
A a = new A();
a.b.sss = 0;
@@ -211,28 +187,19 @@
class B {
set sss(x) {}
}''');
- // find "a.b.sss = 0"
- AssignmentExpression assignment;
- {
- var statements = AstFinder.getStatementsInTopLevelFunction(unit, 'main');
- var statement = statements[1] as ExpressionStatement;
- assignment = statement.expression as AssignmentExpression;
- }
- // get parameter
- Expression rhs = assignment.rightHandSide;
- ParameterElement parameter = rhs.staticParameterElement;
- expect(parameter, isNotNull);
- expect(parameter.displayName, "x");
- // validate
- ClassElement classB = unit.declaredElement.types[1];
- PropertyAccessorElement setter = classB.accessors[0];
- expect(setter.parameters[0], same(parameter));
+ await resolveTestFile();
+
+ var rhs = findNode.assignment(' = 0;').rightHandSide;
+ expect(
+ rhs.staticParameterElement,
+ findElement.parameter('x'),
+ );
}
test_breakTarget_labeled() async {
// Verify that the target of the label is correctly found and is recorded
// as the unlabeled portion of the statement.
- String text = r'''
+ addTestFile(r'''
void f() {
loop1: while (true) {
loop2: for (int i = 0; i < 10; i++) {
@@ -241,70 +208,65 @@
}
}
}
-''';
- CompilationUnit unit = await resolveSource(text);
- WhileStatement whileStatement = EngineTestCase.findNode(
- unit, text, 'while (true)', (n) => n is WhileStatement);
- ForStatement forStatement =
- EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
- BreakStatement break1 = EngineTestCase.findNode(
- unit, text, 'break loop1', (n) => n is BreakStatement);
- BreakStatement break2 = EngineTestCase.findNode(
- unit, text, 'break loop2', (n) => n is BreakStatement);
+''');
+ await resolveTestFile();
+
+ var break1 = findNode.breakStatement('break loop1;');
+ var whileStatement = findNode.whileStatement('while (');
expect(break1.target, same(whileStatement));
+
+ var break2 = findNode.breakStatement('break loop2;');
+ var forStatement = findNode.forStatement('for (');
expect(break2.target, same(forStatement));
}
test_breakTarget_unlabeledBreakFromDo() async {
- String text = r'''
+ addTestFile('''
void f() {
do {
break;
} while (true);
}
-''';
- CompilationUnit unit = await resolveSource(text);
- DoStatement doStatement =
- EngineTestCase.findNode(unit, text, 'do', (n) => n is DoStatement);
- BreakStatement breakStatement = EngineTestCase.findNode(
- unit, text, 'break', (n) => n is BreakStatement);
+''');
+ await resolveTestFile();
+
+ var doStatement = findNode.doStatement('do {');
+ var breakStatement = findNode.breakStatement('break;');
expect(breakStatement.target, same(doStatement));
}
test_breakTarget_unlabeledBreakFromFor() async {
- String text = r'''
+ addTestFile(r'''
void f() {
for (int i = 0; i < 10; i++) {
break;
}
}
-''';
- CompilationUnit unit = await resolveSource(text);
- ForStatement forStatement =
- EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
- BreakStatement breakStatement = EngineTestCase.findNode(
- unit, text, 'break', (n) => n is BreakStatement);
+''');
+ await resolveTestFile();
+
+ var forStatement = findNode.forStatement('for (');
+ var breakStatement = findNode.breakStatement('break;');
expect(breakStatement.target, same(forStatement));
}
test_breakTarget_unlabeledBreakFromForEach() async {
- String text = r'''
+ addTestFile('''
void f() {
for (x in []) {
break;
}
}
-''';
- CompilationUnit unit = await resolveSource(text);
- ForEachStatement forStatement = EngineTestCase.findNode(
- unit, text, 'for', (n) => n is ForEachStatement);
- BreakStatement breakStatement = EngineTestCase.findNode(
- unit, text, 'break', (n) => n is BreakStatement);
+''');
+ await resolveTestFile();
+
+ var forStatement = findNode.forEachStatement('for (');
+ var breakStatement = findNode.breakStatement('break;');
expect(breakStatement.target, same(forStatement));
}
test_breakTarget_unlabeledBreakFromSwitch() async {
- String text = r'''
+ addTestFile(r'''
void f() {
while (true) {
switch (0) {
@@ -313,35 +275,33 @@
}
}
}
-''';
- CompilationUnit unit = await resolveSource(text);
- SwitchStatement switchStatement = EngineTestCase.findNode(
- unit, text, 'switch', (n) => n is SwitchStatement);
- BreakStatement breakStatement = EngineTestCase.findNode(
- unit, text, 'break', (n) => n is BreakStatement);
+''');
+ await resolveTestFile();
+
+ var switchStatement = findNode.switchStatement('switch (');
+ var breakStatement = findNode.breakStatement('break;');
expect(breakStatement.target, same(switchStatement));
}
test_breakTarget_unlabeledBreakFromWhile() async {
- String text = r'''
+ addTestFile(r'''
void f() {
while (true) {
break;
}
}
-''';
- CompilationUnit unit = await resolveSource(text);
- WhileStatement whileStatement = EngineTestCase.findNode(
- unit, text, 'while', (n) => n is WhileStatement);
- BreakStatement breakStatement = EngineTestCase.findNode(
- unit, text, 'break', (n) => n is BreakStatement);
+''');
+ await resolveTestFile();
+
+ var whileStatement = findNode.whileStatement('while (');
+ var breakStatement = findNode.breakStatement('break;');
expect(breakStatement.target, same(whileStatement));
}
test_breakTarget_unlabeledBreakToOuterFunction() async {
// Verify that unlabeled break statements can't resolve to loops in an
// outer function.
- String text = r'''
+ addTestFile(r'''
void f() {
while (true) {
void g() {
@@ -349,40 +309,34 @@
}
}
}
-''';
- CompilationUnit unit = await resolveSource(text);
- BreakStatement breakStatement = EngineTestCase.findNode(
- unit, text, 'break', (n) => n is BreakStatement);
+''');
+ await resolveTestFile();
+
+ var breakStatement = findNode.breakStatement('break;');
expect(breakStatement.target, isNull);
}
test_class_definesCall() async {
- Source source = addSource(r'''
+ await assertNoErrorsInCode(r'''
class A {
int call(int x) { return x; }
}
int f(A a) {
return a(0);
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
}
test_class_extends_implements() async {
- Source source = addSource(r'''
+ await assertNoErrorsInCode(r'''
class A extends B implements C {}
class B {}
class C {}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
}
test_continueTarget_labeled() async {
// Verify that the target of the label is correctly found and is recorded
// as the unlabeled portion of the statement.
- String text = r'''
+ addTestFile('''
void f() {
loop1: while (true) {
loop2: for (int i = 0; i < 10; i++) {
@@ -391,86 +345,80 @@
}
}
}
-''';
- CompilationUnit unit = await resolveSource(text);
- WhileStatement whileStatement = EngineTestCase.findNode(
- unit, text, 'while (true)', (n) => n is WhileStatement);
- ForStatement forStatement =
- EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
- ContinueStatement continue1 = EngineTestCase.findNode(
- unit, text, 'continue loop1', (n) => n is ContinueStatement);
- ContinueStatement continue2 = EngineTestCase.findNode(
- unit, text, 'continue loop2', (n) => n is ContinueStatement);
+''');
+ await resolveTestFile();
+
+ var continue1 = findNode.continueStatement('continue loop1');
+ var whileStatement = findNode.whileStatement('while (');
expect(continue1.target, same(whileStatement));
+
+ var continue2 = findNode.continueStatement('continue loop2');
+ var forStatement = findNode.forStatement('for (');
expect(continue2.target, same(forStatement));
}
test_continueTarget_unlabeledContinueFromDo() async {
- String text = r'''
+ addTestFile('''
void f() {
do {
continue;
} while (true);
}
-''';
- CompilationUnit unit = await resolveSource(text);
- DoStatement doStatement =
- EngineTestCase.findNode(unit, text, 'do', (n) => n is DoStatement);
- ContinueStatement continueStatement = EngineTestCase.findNode(
- unit, text, 'continue', (n) => n is ContinueStatement);
+''');
+ await resolveTestFile();
+
+ var doStatement = findNode.doStatement('do {');
+ var continueStatement = findNode.continueStatement('continue;');
expect(continueStatement.target, same(doStatement));
}
test_continueTarget_unlabeledContinueFromFor() async {
- String text = r'''
+ addTestFile('''
void f() {
for (int i = 0; i < 10; i++) {
continue;
}
}
-''';
- CompilationUnit unit = await resolveSource(text);
- ForStatement forStatement =
- EngineTestCase.findNode(unit, text, 'for', (n) => n is ForStatement);
- ContinueStatement continueStatement = EngineTestCase.findNode(
- unit, text, 'continue', (n) => n is ContinueStatement);
+''');
+ await resolveTestFile();
+
+ var forStatement = findNode.forStatement('for (');
+ var continueStatement = findNode.continueStatement('continue;');
expect(continueStatement.target, same(forStatement));
}
test_continueTarget_unlabeledContinueFromForEach() async {
- String text = r'''
+ addTestFile(r'''
void f() {
for (x in []) {
continue;
}
}
-''';
- CompilationUnit unit = await resolveSource(text);
- ForEachStatement forStatement = EngineTestCase.findNode(
- unit, text, 'for', (n) => n is ForEachStatement);
- ContinueStatement continueStatement = EngineTestCase.findNode(
- unit, text, 'continue', (n) => n is ContinueStatement);
+''');
+ await resolveTestFile();
+
+ var forStatement = findNode.forEachStatement('for (');
+ var continueStatement = findNode.continueStatement('continue;');
expect(continueStatement.target, same(forStatement));
}
test_continueTarget_unlabeledContinueFromWhile() async {
- String text = r'''
+ addTestFile(r'''
void f() {
while (true) {
continue;
}
}
-''';
- CompilationUnit unit = await resolveSource(text);
- WhileStatement whileStatement = EngineTestCase.findNode(
- unit, text, 'while', (n) => n is WhileStatement);
- ContinueStatement continueStatement = EngineTestCase.findNode(
- unit, text, 'continue', (n) => n is ContinueStatement);
+''');
+ await resolveTestFile();
+
+ var whileStatement = findNode.whileStatement('while (');
+ var continueStatement = findNode.continueStatement('continue;');
expect(continueStatement.target, same(whileStatement));
}
test_continueTarget_unlabeledContinueSkipsSwitch() async {
- String text = r'''
+ addTestFile(r'''
void f() {
while (true) {
switch (0) {
@@ -479,19 +427,18 @@
}
}
}
-''';
- CompilationUnit unit = await resolveSource(text);
- WhileStatement whileStatement = EngineTestCase.findNode(
- unit, text, 'while', (n) => n is WhileStatement);
- ContinueStatement continueStatement = EngineTestCase.findNode(
- unit, text, 'continue', (n) => n is ContinueStatement);
+''');
+ await resolveTestFile();
+
+ var whileStatement = findNode.whileStatement('while (');
+ var continueStatement = findNode.continueStatement('continue;');
expect(continueStatement.target, same(whileStatement));
}
test_continueTarget_unlabeledContinueToOuterFunction() async {
// Verify that unlabeled continue statements can't resolve to loops in an
// outer function.
- String text = r'''
+ addTestFile(r'''
void f() {
while (true) {
void g() {
@@ -499,77 +446,76 @@
}
}
}
-''';
- CompilationUnit unit = await resolveSource(text);
- ContinueStatement continueStatement = EngineTestCase.findNode(
- unit, text, 'continue', (n) => n is ContinueStatement);
+''');
+ await resolveTestFile();
+
+ var continueStatement = findNode.continueStatement('continue;');
expect(continueStatement.target, isNull);
}
test_empty() async {
- Source source = addSource("");
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ addTestFile('');
+ await resolveTestFile();
+ assertNoTestErrors();
}
test_entryPoint_exported() async {
- addNamedSource("/two.dart", r'''
-library two;
-main() {}''');
- Source source = addNamedSource("/one.dart", r'''
-library one;
-export 'two.dart';''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- FunctionElement main = library.entryPoint;
+ newFile('/test/lib/a.dart', content: r'''
+main() {}
+''');
+
+ addTestFile(r'''
+export 'a.dart';
+''');
+ await resolveTestFile();
+ assertNoTestErrors();
+
+ var library = result.libraryElement;
+ var main = library.entryPoint;
+
expect(main, isNotNull);
expect(main.library, isNot(same(library)));
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
}
test_entryPoint_local() async {
- Source source = addNamedSource("/one.dart", r'''
-library one;
-main() {}''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- FunctionElement main = library.entryPoint;
+ addTestFile(r'''
+main() {}
+''');
+ await resolveTestFile();
+ assertNoTestErrors();
+
+ var library = result.libraryElement;
+ var main = library.entryPoint;
+
expect(main, isNotNull);
expect(main.library, same(library));
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
}
test_entryPoint_none() async {
- Source source = addNamedSource("/one.dart", "library one;");
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
+ addTestFile('');
+ await resolveTestFile();
+ assertNoTestErrors();
+
+ var library = result.libraryElement;
expect(library.entryPoint, isNull);
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
}
test_enum_externalLibrary() async {
- addNamedSource("/my_lib.dart", r'''
-library my_lib;
-enum EEE {A, B, C}''');
- Source source = addSource(r'''
-import 'my_lib.dart';
-main() {
- EEE e = null;
-}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ newFile('/test/lib/a.dart', content: r'''
+enum EEE {A, B, C}
+''');
+ addTestFile(r'''
+import 'a.dart';
+
+void f(EEE e) {}
+''');
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
}
test_extractedMethodAsConstant() async {
- Source source = addSource(r'''
+ await assertNoErrorsInCode(r'''
abstract class Comparable<T> {
int compareTo(T other);
static int compare(Comparable a, Comparable b) => a.compareTo(b);
@@ -577,64 +523,55 @@
class A {
void sort([compare = Comparable.compare]) {}
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ verifyTestResolved();
}
test_fieldFormalParameter() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
int x;
int y;
A(this.x) : y = x {}
}''');
- CompilationUnit unit =
- analysisContext2.resolveCompilationUnit2(source, source);
- ClassDeclaration classA = unit.declarations[0];
- FieldDeclaration field = classA.members[0];
- ConstructorDeclaration constructor = classA.members[2];
- ParameterElement paramElement =
- constructor.parameters.parameters[0].declaredElement;
- expect(paramElement, isFieldFormalParameterElement);
- expect((paramElement as FieldFormalParameterElement).field,
- field.fields.variables[0].declaredElement);
- ConstructorFieldInitializer initializer = constructor.initializers[0];
- SimpleIdentifier identifierX = initializer.expression;
- expect(identifierX.staticElement, paramElement);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ var xParameter = findNode.fieldFormalParameter('this.x');
+
+ var xParameterElement =
+ xParameter.declaredElement as FieldFormalParameterElement;
+ expect(xParameterElement.field, findElement.field('x'));
+
+ assertElement(
+ findNode.simple('x {}'),
+ xParameterElement,
+ );
}
test_forEachLoops_nonConflicting() async {
- Source source = addSource(r'''
+ await assertNoErrorsInCode(r'''
f() {
List list = [1,2,3];
for (int x in list) {}
for (int x in list) {}
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ verifyTestResolved();
}
test_forLoops_nonConflicting() async {
- Source source = addSource(r'''
+ await assertNoErrorsInCode(r'''
f() {
for (int i = 0; i < 3; i++) {
}
for (int i = 0; i < 3; i++) {
}
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ verifyTestResolved();
}
test_functionTypeAlias() async {
- Source source = addSource(r'''
+ await assertNoErrorsInCode(r'''
typedef bool P(e);
class A {
P p;
@@ -642,13 +579,11 @@
if (p(e)) {}
}
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ verifyTestResolved();
}
test_getter_and_setter_fromMixins_bare_identifier() async {
- Source source = addSource('''
+ addTestFile('''
class B {}
class M1 {
get x => null;
@@ -664,24 +599,21 @@
}
}
''');
- var analysisResult = await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
// Verify that both the getter and setter for "x" in C.f() refer to the
// accessors defined in M2.
- List<Statement> statements =
- AstFinder.getStatementsInMethod(analysisResult.unit, 'C', 'f');
- var statement = statements[0] as ExpressionStatement;
- AssignmentExpression assignment = statement.expression;
- SimpleIdentifier leftHandSide = assignment.leftHandSide;
+ var leftHandSide = findNode.simple('x +=');
expect(
- resolutionMap
- .staticElementForIdentifier(leftHandSide)
- .enclosingElement
- .name,
- 'M2');
- expect(leftHandSide.auxiliaryElements.staticElement.enclosingElement.name,
- 'M2');
+ leftHandSide.staticElement,
+ findElement.setter('x', of: 'M2'),
+ );
+ expect(
+ leftHandSide.auxiliaryElements.staticElement,
+ findElement.getter('x', of: 'M2'),
+ );
}
@failingTest
@@ -689,7 +621,7 @@
// TODO(paulberry): it appears that auxiliaryElements isn't properly set on
// a SimpleIdentifier that's inside a property access. This bug should be
// fixed.
- Source source = addSource(r'''
+ addTestFile(r'''
class B {}
class M1 {
get x => null;
@@ -704,30 +636,24 @@
new C().x += 1;
}
''');
- var analysisResult = await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ assertNoTestErrors();
+ verifyTestResolved();
+
// Verify that both the getter and setter for "x" in "new C().x" refer to
// the accessors defined in M2.
- List<Statement> statements =
- AstFinder.getStatementsInTopLevelFunction(analysisResult.unit, 'main');
- var statement = statements[0] as ExpressionStatement;
- AssignmentExpression assignment = statement.expression;
- PropertyAccess propertyAccess = assignment.leftHandSide;
+ var leftHandSide = findNode.simple('x +=');
expect(
- resolutionMap
- .staticElementForIdentifier(propertyAccess.propertyName)
- .enclosingElement
- .name,
- 'M2');
+ leftHandSide.staticElement,
+ findElement.setter('x', of: 'M2'),
+ );
expect(
- propertyAccess
- .propertyName.auxiliaryElements.staticElement.enclosingElement.name,
- 'M2');
+ leftHandSide.auxiliaryElements.staticElement,
+ findElement.getter('x', of: 'M2'),
+ );
}
test_getter_fromMixins_bare_identifier() async {
- Source source = addSource('''
+ addTestFile('''
class B {}
class M1 {
get x => null;
@@ -741,21 +667,20 @@
}
}
''');
- var analysisResult = await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
// Verify that the getter for "x" in C.f() refers to the getter defined in
// M2.
- var statements =
- AstFinder.getStatementsInMethod(analysisResult.unit, 'C', 'f');
- var statement = statements[0] as ReturnStatement;
- SimpleIdentifier x = statement.expression;
- expect(resolutionMap.staticElementForIdentifier(x).enclosingElement.name,
- 'M2');
+ expect(
+ findNode.simple('x;').staticElement,
+ findElement.getter('x', of: 'M2'),
+ );
}
test_getter_fromMixins_property_access() async {
- Source source = addSource('''
+ addTestFile('''
class B {}
class M1 {
get x => null;
@@ -768,26 +693,20 @@
var y = new C().x;
}
''');
- var analysisResult = await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
// Verify that the getter for "x" in "new C().x" refers to the getter
// defined in M2.
- List<Statement> statements =
- AstFinder.getStatementsInTopLevelFunction(analysisResult.unit, 'main');
- var statement = statements[0] as VariableDeclarationStatement;
- PropertyAccess propertyAccess =
- statement.variables.variables[0].initializer;
expect(
- resolutionMap
- .staticElementForIdentifier(propertyAccess.propertyName)
- .enclosingElement
- .name,
- 'M2');
+ findNode.simple('x;').staticElement,
+ findElement.getter('x', of: 'M2'),
+ );
}
test_getterAndSetterWithDifferentTypes() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
int get f => 0;
void set f(String s) {}
@@ -795,38 +714,35 @@
g (A a) {
a.f = a.f.toString();
}''');
- await computeAnalysisResult(source);
- assertErrors(
- source, [StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
- verify([source]);
+ await resolveTestFile();
+ assertTestErrors([StaticWarningCode.MISMATCHED_GETTER_AND_SETTER_TYPES]);
+ verifyTestResolved();
}
test_hasReferenceToSuper() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {}
class B {toString() => super.toString();}''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- List<ClassElement> classes = unit.types;
- expect(classes, hasLength(2));
- expect(classes[0].hasReferenceToSuper, isFalse);
- expect(classes[1].hasReferenceToSuper, isTrue);
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
+ var a = findElement.class_('A');
+ expect(a.hasReferenceToSuper, isFalse);
+
+ var b = findElement.class_('B');
+ expect(b.hasReferenceToSuper, isTrue);
}
test_import_hide() async {
- addNamedSource("/lib1.dart", r'''
-library lib1;
+ newFile('/test/lib/lib1.dart', content: r'''
set foo(value) {}
class A {}''');
- addNamedSource("/lib2.dart", r'''
-library lib2;
+
+ newFile('/test/lib/lib2.dart', content: r'''
set foo(value) {}''');
- Source source = addNamedSource("/lib3.dart", r'''
+
+ addTestFile(r'''
import 'lib1.dart' hide foo;
import 'lib2.dart';
@@ -834,26 +750,25 @@
foo = 0;
}
A a;''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
}
test_import_prefix() async {
- addNamedSource("/two.dart", r'''
-library two;
+ newFile('/test/lib/a.dart', content: r'''
f(int x) {
return x * x;
}''');
- Source source = addNamedSource("/one.dart", r'''
-library one;
-import 'two.dart' as _two;
+
+ addTestFile(r'''
+import 'a.dart' as _a;
main() {
- _two.f(0);
+ _a.f(0);
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
}
test_import_prefix_doesNotExist() async {
@@ -862,7 +777,7 @@
// single error generated when the only problem is that an imported file
// does not exist.
//
- Source source = addNamedSource("/a.dart", r'''
+ addTestFile('''
import 'missing.dart' as p;
int a = p.q + p.r.s;
String b = p.t(a) + p.u(v: 0);
@@ -879,9 +794,9 @@
H(int i) : super(i);
}
''');
- await computeAnalysisResult(source);
- assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
- verify([source]);
+ await resolveTestFile();
+ assertTestErrors([CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
+ verifyTestResolved();
}
test_import_show_doesNotExist() async {
@@ -890,7 +805,7 @@
// single error generated when the only problem is that an imported file
// does not exist.
//
- Source source = addNamedSource("/a.dart", r'''
+ addTestFile('''
import 'missing.dart' show q, r, t, u, T, U, V, W;
int a = q + r.s;
String b = t(a) + u(v: 0);
@@ -907,28 +822,28 @@
H(int i) : super(i);
}
''');
- await computeAnalysisResult(source);
- assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
- verify([source]);
+ await resolveTestFile();
+ assertTestErrors([CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
+ verifyTestResolved();
}
+ @failingTest
test_import_spaceInUri() async {
- addNamedSource("/sub folder/lib.dart", r'''
-library lib;
+ // TODO(scheglov) Fix this. The problem is in `package` URI resolver.
+ newFile('/test/lib/sub folder/a.dart', content: r'''
foo() {}''');
- Source source = addNamedSource("/app.dart", r'''
-import 'sub folder/lib.dart';
+
+ await assertNoErrorsInCode(r'''
+import 'sub folder/a.dart';
main() {
foo();
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ verifyTestResolved();
}
test_indexExpression_typeParameters() async {
- Source source = addSource(r'''
+ await assertNoErrorsInCode(r'''
f() {
List<int> a;
a[0];
@@ -937,24 +852,22 @@
List<List<List<int>>> c;
c[0][0][0];
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ verifyTestResolved();
}
test_indexExpression_typeParameters_invalidAssignmentWarning() async {
- Source source = addSource(r'''
+ addTestFile(r'''
f() {
List<List<int>> b;
b[0][0] = 'hi';
}''');
- await computeAnalysisResult(source);
- assertErrors(source, [StaticTypeWarningCode.INVALID_ASSIGNMENT]);
- verify([source]);
+ await resolveTestFile();
+ assertTestErrors([StaticTypeWarningCode.INVALID_ASSIGNMENT]);
+ verifyTestResolved();
}
test_indirectOperatorThroughCall() async {
- Source source = addSource(r'''
+ await assertNoErrorsInCode(r'''
class A {
B call() { return new B(); }
}
@@ -970,113 +883,91 @@
main() {
g(f()[0]);
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ verifyTestResolved();
}
test_invoke_dynamicThroughGetter() async {
- Source source = addSource(r'''
+ await assertNoErrorsInCode(r'''
class A {
List get X => [() => 0];
m(A a) {
X.last;
}
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ verifyTestResolved();
}
test_isValidMixin_badSuperclass() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A extends B {}
class B {}
class C = Object with A;''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- ClassElement a = unit.getType('A');
+ await resolveTestFile();
+ assertTestErrors([CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
+ verifyTestResolved();
+
+ var a = findElement.class_('A');
expect(a.isValidMixin, isFalse);
- await computeAnalysisResult(source);
- assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
- verify([source]);
}
test_isValidMixin_constructor() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
A() {}
}
class C = Object with A;''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- ClassElement a = unit.getType('A');
- expect(a.isValidMixin, isFalse);
- await computeAnalysisResult(source);
- assertErrors(
- source,
+ await resolveTestFile();
+ assertTestErrors(
[CompileTimeErrorCode.MIXIN_CLASS_DECLARES_CONSTRUCTOR],
);
- verify([source]);
+ verifyTestResolved();
+
+ var a = findElement.class_('A');
+ expect(a.isValidMixin, isFalse);
}
test_isValidMixin_factoryConstructor() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
factory A() => null;
}
class C = Object with A;''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- ClassElement a = unit.getType('A');
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
+ var a = findElement.class_('A');
expect(a.isValidMixin, isTrue);
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
}
test_isValidMixin_super() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
toString() {
return super.toString();
}
}
class C = Object with A;''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- ClassElement a = unit.getType('A');
+ await resolveTestFile();
+ assertTestErrors([CompileTimeErrorCode.MIXIN_REFERENCES_SUPER]);
+ verifyTestResolved();
+
+ var a = findElement.class_('A');
expect(a.isValidMixin, isFalse);
- await computeAnalysisResult(source);
- assertErrors(source, [CompileTimeErrorCode.MIXIN_REFERENCES_SUPER]);
- verify([source]);
}
test_isValidMixin_valid() async {
- Source source = addSource('''
+ await assertNoErrorsInCode('''
class A {}
class C = Object with A;''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- ClassElement a = unit.getType('A');
+ verifyTestResolved();
+
+ var a = findElement.class_('A');
expect(a.isValidMixin, isTrue);
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
}
test_labels_switch() async {
- Source source = addSource(r'''
+ await assertNoErrorsInCode(r'''
void doSwitch(int target) {
switch (target) {
l0: case 0:
@@ -1087,269 +978,174 @@
continue l1;
}
}''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ verifyTestResolved();
}
test_localVariable_types_invoked() async {
- Source source = addSource(r'''
+ addTestFile(r'''
const A = null;
main() {
var myVar = (int p) => 'foo';
myVar(42);
}''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnit unit =
- analysisContext.resolveCompilationUnit(source, library);
- expect(unit, isNotNull);
- List<bool> found = [false];
- List<CaughtException> thrownException = new List<CaughtException>(1);
- unit.accept(new _SimpleResolverTest_localVariable_types_invoked(
- this, found, thrownException));
- if (thrownException[0] != null) {
- throw new AnalysisException(
- "Exception", new CaughtException(thrownException[0], null));
- }
- expect(found[0], isTrue);
+ await resolveTestFile();
+
+ var node = findNode.simple('myVar(42)');
+ assertType(node, '(int) → String');
}
test_metadata_class() async {
- Source source = addSource(r'''
+ addTestFile(r'''
const A = null;
@A class C<A> {}''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unitElement = library.definingCompilationUnit;
- expect(unitElement, isNotNull);
- List<ClassElement> classes = unitElement.types;
- expect(classes, hasLength(1));
- List<ElementAnnotation> annotations = classes[0].metadata;
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
+ var annotations = findElement.class_('C').metadata;
expect(annotations, hasLength(1));
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
- CompilationUnit unit = resolveCompilationUnit(source, library);
- NodeList<CompilationUnitMember> declarations = unit.declarations;
- expect(declarations, hasLength(2));
-
- TopLevelVariableDeclaration variableDeclaration = declarations[0];
- ClassDeclaration classDeclaration = declarations[1];
-
- PropertyInducingElement expectedElement =
- variableDeclaration.variables.variables[0].name.staticElement;
-
- Element actualElement = classDeclaration.metadata[0].name.staticElement;
- expect(actualElement, same(expectedElement.getter));
+ var cDeclaration = findNode.classDeclaration('C<A>');
+ assertElement(
+ cDeclaration.metadata[0].name,
+ findElement.topGet('A'),
+ );
}
test_metadata_field() async {
- Source source = addSource(r'''
+ addTestFile(r'''
const A = null;
class C {
@A int f;
}''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- List<ClassElement> classes = unit.types;
- expect(classes, hasLength(1));
- FieldElement field = classes[0].fields[0];
- List<ElementAnnotation> annotations = field.metadata;
- expect(annotations, hasLength(1));
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
+ var metadata = findElement.field('f').metadata;
+ expect(metadata, hasLength(1));
}
test_metadata_fieldFormalParameter() async {
- Source source = addSource(r'''
+ addTestFile(r'''
const A = null;
class C {
int f;
C(@A this.f);
}''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- List<ClassElement> classes = unit.types;
- expect(classes, hasLength(1));
- List<ConstructorElement> constructors = classes[0].constructors;
- expect(constructors, hasLength(1));
- List<ParameterElement> parameters = constructors[0].parameters;
- expect(parameters, hasLength(1));
- List<ElementAnnotation> annotations = parameters[0].metadata;
- expect(annotations, hasLength(1));
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
+ var metadata = findElement.fieldFormalParameter('f').metadata;
+ expect(metadata, hasLength(1));
}
test_metadata_function() async {
- Source source = addSource(r'''
+ addTestFile(r'''
const A = null;
@A f() {}''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- List<FunctionElement> functions = unit.functions;
- expect(functions, hasLength(1));
- List<ElementAnnotation> annotations = functions[0].metadata;
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
+ var annotations = findElement.topFunction('f').metadata;
expect(annotations, hasLength(1));
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
}
test_metadata_functionTypedParameter() async {
- Source source = addSource(r'''
+ addTestFile(r'''
const A = null;
f(@A int p(int x)) {}''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- List<FunctionElement> functions = unit.functions;
- expect(functions, hasLength(1));
- List<ParameterElement> parameters = functions[0].parameters;
- expect(parameters, hasLength(1));
- List<ElementAnnotation> annotations1 = parameters[0].metadata;
- expect(annotations1, hasLength(1));
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
+ var metadata = findElement.parameter('p').metadata;
+ expect(metadata, hasLength(1));
}
test_metadata_libraryDirective() async {
- Source source = addSource(r'''
+ addTestFile(r'''
@A library lib;
const A = null;''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- List<ElementAnnotation> annotations = library.metadata;
- expect(annotations, hasLength(1));
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
+ var metadata = result.libraryElement.metadata;
+ expect(metadata, hasLength(1));
}
test_metadata_method() async {
- Source source = addSource(r'''
+ addTestFile(r'''
const A = null;
class C {
@A void m() {}
}''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- List<ClassElement> classes = unit.types;
- expect(classes, hasLength(1));
- MethodElement method = classes[0].methods[0];
- List<ElementAnnotation> annotations = method.metadata;
- expect(annotations, hasLength(1));
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
+ var metadata = findElement.method('m').metadata;
+ expect(metadata, hasLength(1));
}
test_metadata_namedParameter() async {
- Source source = addSource(r'''
+ addTestFile(r'''
const A = null;
f({@A int p : 0}) {}''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- List<FunctionElement> functions = unit.functions;
- expect(functions, hasLength(1));
- List<ParameterElement> parameters = functions[0].parameters;
- expect(parameters, hasLength(1));
- List<ElementAnnotation> annotations1 = parameters[0].metadata;
- expect(annotations1, hasLength(1));
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
+ var metadata = findElement.parameter('p').metadata;
+ expect(metadata, hasLength(1));
}
test_metadata_positionalParameter() async {
- Source source = addSource(r'''
+ addTestFile(r'''
const A = null;
f([@A int p = 0]) {}''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- List<FunctionElement> functions = unit.functions;
- expect(functions, hasLength(1));
- List<ParameterElement> parameters = functions[0].parameters;
- expect(parameters, hasLength(1));
- List<ElementAnnotation> annotations1 = parameters[0].metadata;
- expect(annotations1, hasLength(1));
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
+ var metadata = findElement.parameter('p').metadata;
+ expect(metadata, hasLength(1));
}
test_metadata_simpleParameter() async {
- Source source = addSource(r'''
+ addTestFile(r'''
const A = null;
f(@A p1, @A int p2) {}''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unit = library.definingCompilationUnit;
- expect(unit, isNotNull);
- List<FunctionElement> functions = unit.functions;
- expect(functions, hasLength(1));
- List<ParameterElement> parameters = functions[0].parameters;
- expect(parameters, hasLength(2));
- List<ElementAnnotation> annotations1 = parameters[0].metadata;
- expect(annotations1, hasLength(1));
- List<ElementAnnotation> annotations2 = parameters[1].metadata;
- expect(annotations2, hasLength(1));
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
+ expect(findElement.parameter('p1').metadata, hasLength(1));
+ expect(findElement.parameter('p2').metadata, hasLength(1));
}
test_metadata_typedef() async {
- Source source = addSource(r'''
+ addTestFile(r'''
const A = null;
@A typedef F<A>();''');
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- CompilationUnitElement unitElement = library.definingCompilationUnit;
- expect(unitElement, isNotNull);
- List<FunctionTypeAliasElement> aliases = unitElement.functionTypeAliases;
- expect(aliases, hasLength(1));
- List<ElementAnnotation> annotations = aliases[0].metadata;
- expect(annotations, hasLength(1));
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
- CompilationUnit unit = resolveCompilationUnit(source, library);
- NodeList<CompilationUnitMember> declarations = unit.declarations;
- expect(declarations, hasLength(2));
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
- TopLevelVariableDeclaration variableDeclaration = declarations[0];
- FunctionTypeAlias functionTypeAlias = declarations[1];
+ expect(
+ findElement.genericTypeAlias('F').metadata,
+ hasLength(1),
+ );
- PropertyInducingElement expectedElement =
- variableDeclaration.variables.variables[0].name.staticElement;
-
- Element actualElement = functionTypeAlias.metadata[0].name.staticElement;
- expect(actualElement, same(expectedElement.getter));
+ var actualElement = findNode.annotation('@A').name.staticElement;
+ expect(actualElement, findElement.topGet('A'));
}
test_method_fromMixin() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class B {
bar() => 1;
}
@@ -1361,13 +1157,13 @@
bar() => super.bar();
foo() => super.foo();
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
}
test_method_fromMixins() async {
- Source source = addSource('''
+ addTestFile('''
class B {}
class M1 {
void f() {}
@@ -1380,24 +1176,18 @@
new C().f();
}
''');
- var analysisResult = await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
- // Verify that the "f" in "new C().f()" refers to the "f" defined in M2.
- List<Statement> statements =
- AstFinder.getStatementsInTopLevelFunction(analysisResult.unit, 'main');
- var statement = statements[0] as ExpressionStatement;
- MethodInvocation expr = statement.expression;
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
expect(
- resolutionMap
- .staticElementForIdentifier(expr.methodName)
- .enclosingElement
- .name,
- 'M2');
+ findNode.simple('f();').staticElement,
+ findElement.method('f', of: 'M2'),
+ );
}
test_method_fromMixins_bare_identifier() async {
- Source source = addSource('''
+ addTestFile('''
class B {}
class M1 {
void f() {}
@@ -1411,25 +1201,18 @@
}
}
''');
- var analysisResult = await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
- // Verify that the call to f() in C.g() refers to the method defined in M2.
- List<Statement> statements =
- AstFinder.getStatementsInMethod(analysisResult.unit, 'C', 'g');
- var statement = statements[0] as ExpressionStatement;
- MethodInvocation invocation = statement.expression;
- SimpleIdentifier methodName = invocation.methodName;
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
expect(
- resolutionMap
- .staticElementForIdentifier(methodName)
- .enclosingElement
- .name,
- 'M2');
+ findNode.simple('f();').staticElement,
+ findElement.method('f', of: 'M2'),
+ );
}
test_method_fromMixins_invoked_from_outside_class() async {
- Source source = addSource('''
+ addTestFile('''
class B {}
class M1 {
void f() {}
@@ -1442,25 +1225,18 @@
new C().f();
}
''');
- var analysisResult = await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
- // Verify that the call to f() in "new C().f()" refers to the method
- // defined in M2.
- List<Statement> statements =
- AstFinder.getStatementsInTopLevelFunction(analysisResult.unit, 'main');
- var statement = statements[0] as ExpressionStatement;
- MethodInvocation invocation = statement.expression;
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
expect(
- resolutionMap
- .staticElementForIdentifier(invocation.methodName)
- .enclosingElement
- .name,
- 'M2');
+ findNode.simple('f();').staticElement,
+ findElement.method('f', of: 'M2'),
+ );
}
test_method_fromSuperclassMixin() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
void m1() {}
}
@@ -1471,13 +1247,13 @@
f(C c) {
c.m1();
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
}
test_methodCascades() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
void m1() {}
void m2() {}
@@ -1487,13 +1263,13 @@
..m2();
}
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
}
test_methodCascades_withSetter() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
String name;
void m1() {}
@@ -1505,23 +1281,23 @@
..m2();
}
}''');
- // failing with error code: INVOCATION_OF_NON_FUNCTION
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
}
test_resolveAgainstNull() async {
- Source source = addSource(r'''
+ addTestFile(r'''
f(var p) {
return null == p;
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
}
test_setter_fromMixins_bare_identifier() async {
- Source source = addSource('''
+ addTestFile('''
class B {}
class M1 {
set x(value) {}
@@ -1535,26 +1311,18 @@
}
}
''');
- var analysisResult = await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
- // Verify that the setter for "x" in C.f() refers to the setter defined in
- // M2.
- List<Statement> statements =
- AstFinder.getStatementsInMethod(analysisResult.unit, 'C', 'f');
- var statement = statements[0] as ExpressionStatement;
- AssignmentExpression assignment = statement.expression;
- SimpleIdentifier leftHandSide = assignment.leftHandSide;
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
expect(
- resolutionMap
- .staticElementForIdentifier(leftHandSide)
- .enclosingElement
- .name,
- 'M2');
+ findNode.simple('x = ').staticElement,
+ findElement.setter('x', of: 'M2'),
+ );
}
test_setter_fromMixins_property_access() async {
- Source source = addSource('''
+ addTestFile('''
class B {}
class M1 {
set x(value) {}
@@ -1567,26 +1335,18 @@
new C().x = 1;
}
''');
- var analysisResult = await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
- // Verify that the setter for "x" in "new C().x" refers to the setter
- // defined in M2.
- List<Statement> statements =
- AstFinder.getStatementsInTopLevelFunction(analysisResult.unit, 'main');
- var statement = statements[0] as ExpressionStatement;
- AssignmentExpression assignment = statement.expression;
- PropertyAccess propertyAccess = assignment.leftHandSide;
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
+
expect(
- resolutionMap
- .staticElementForIdentifier(propertyAccess.propertyName)
- .enclosingElement
- .name,
- 'M2');
+ findNode.simple('x = ').staticElement,
+ findElement.setter('x', of: 'M2'),
+ );
}
test_setter_inherited() async {
- Source source = addSource(r'''
+ addTestFile(r'''
class A {
int get x => 0;
set x(int p) {}
@@ -1595,49 +1355,41 @@
int get x => super.x == null ? 0 : super.x;
int f() => x = 1;
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
}
test_setter_static() async {
- Source source = addSource(r'''
+ addTestFile(r'''
set s(x) {
}
main() {
s = 123;
}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
- }
-
- @failingTest
- test_staticInvocation() async {
- Source source = addSource(r'''
-class A {
- static int get g => (a,b) => 0;
-}
-class B {
- f() {
- A.g(1,0);
- }
-}''');
- await computeAnalysisResult(source);
- assertNoErrors(source);
- verify([source]);
+ await resolveTestFile();
+ assertNoTestErrors();
+ verifyTestResolved();
}
/**
- * Resolve the given source and verify that the arguments in a specific method invocation were
- * correctly resolved.
+ * Verify that all of the identifiers in the [result] have been resolved.
+ */
+ void verifyTestResolved() {
+ var verifier = new ResolutionVerifier();
+ result.unit.accept(verifier);
+ verifier.assertResolved();
+ }
+
+ /**
+ * Resolve the test file and verify that the arguments in a specific method
+ * invocation were correctly resolved.
*
- * The source is expected to be source for a compilation unit, the first declaration is expected
- * to be a class, the first member of which is expected to be a method with a block body, and the
- * first statement in the body is expected to be an expression statement whose expression is a
- * method invocation. It is the arguments to that method invocation that are tested. The method
- * invocation can contain errors.
+ * The file is expected to define a method named `g`, and has exactly one
+ * [MethodInvocation] in a statement ending with `);`. It is the arguments to
+ * that method invocation that are tested. The method invocation can contain
+ * errors.
*
* The arguments were resolved correctly if the number of expressions in the list matches the
* length of the array of indices and if, for each index in the array of indices, the parameter to
@@ -1645,66 +1397,33 @@
* parameters at that index. Arguments that should not be resolved to a parameter because of an
* error can be denoted by including a negative index in the array of indices.
*
- * @param source the source to be resolved
* @param indices the array of indices used to associate arguments with parameters
* @throws Exception if the source could not be resolved or if the structure of the source is not
* valid
*/
- void _validateArgumentResolution(Source source, List<int> indices) {
- LibraryElement library = resolve2(source);
- expect(library, isNotNull);
- ClassElement classElement = library.definingCompilationUnit.types[0];
- List<ParameterElement> parameters = classElement.methods[1].parameters;
- CompilationUnit unit = resolveCompilationUnit(source, library);
- expect(unit, isNotNull);
- ClassDeclaration classDeclaration =
- unit.declarations[0] as ClassDeclaration;
- MethodDeclaration methodDeclaration =
- classDeclaration.members[0] as MethodDeclaration;
- Block block = (methodDeclaration.body as BlockFunctionBody).block;
- ExpressionStatement statement = block.statements[0] as ExpressionStatement;
- MethodInvocation invocation = statement.expression as MethodInvocation;
- NodeList<Expression> arguments = invocation.argumentList.arguments;
- int argumentCount = arguments.length;
+ Future<void> _validateArgumentResolution(List<int> indices) async {
+ await resolveTestFile();
+
+ var g = findElement.method('g');
+ var parameters = g.parameters;
+
+ var invocation = findNode.methodInvocation(');');
+
+ var arguments = invocation.argumentList.arguments;
+
+ var argumentCount = arguments.length;
expect(argumentCount, indices.length);
- for (int i = 0; i < argumentCount; i++) {
- Expression argument = arguments[i];
- ParameterElement element = argument.staticParameterElement;
- int index = indices[i];
+
+ for (var i = 0; i < argumentCount; i++) {
+ var argument = arguments[i];
+ var actualParameter = argument.staticParameterElement;
+
+ var index = indices[i];
if (index < 0) {
- expect(element, isNull);
+ expect(actualParameter, isNull);
} else {
- expect(element, same(parameters[index]));
- }
- }
- }
-}
-
-class _SimpleResolverTest_localVariable_types_invoked
- extends RecursiveAstVisitor<void> {
- final SimpleResolverTest test;
-
- List<bool> found;
-
- List<CaughtException> thrownException;
-
- _SimpleResolverTest_localVariable_types_invoked(
- this.test, this.found, this.thrownException)
- : super();
-
- @override
- void visitSimpleIdentifier(SimpleIdentifier node) {
- if (node.name == "myVar" && node.parent is MethodInvocation) {
- try {
- found[0] = true;
- // check static type
- DartType staticType = node.staticType;
- expect(staticType is FunctionType, isTrue);
- FunctionType functionType = staticType;
- expect(functionType.parameters[0].type, test.typeProvider.intType);
- expect(functionType.returnType, test.typeProvider.stringType);
- } on AnalysisException catch (e, stackTrace) {
- thrownException[0] = new CaughtException(e, stackTrace);
+ var expectedParameter = parameters[index];
+ expect(actualParameter, same(expectedParameter));
}
}
}
