blob: 06798f19d88eead407251924f9757f92c71812f3 [file] [log] [blame]
// Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
import 'package:analyzer/dart/ast/ast.dart';
import 'package:analyzer/dart/ast/standard_ast_factory.dart';
import 'package:analyzer/dart/ast/token.dart';
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/dart/element/type_provider.dart';
import 'package:analyzer/src/dart/ast/ast.dart';
import 'package:analyzer/src/dart/ast/utilities.dart';
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
import 'package:analyzer/src/generated/testing/element_factory.dart';
import 'package:analyzer/src/generated/testing/test_type_provider.dart';
import 'package:analyzer/src/generated/testing/token_factory.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
import '../../../generated/elements_types_mixin.dart';
import '../../../generated/parser_test.dart' show ParserTestCase;
import '../../../util/ast_type_matchers.dart';
main() {
defineReflectiveSuite(() {
defineReflectiveTests(NodeLocatorTest);
defineReflectiveTests(NodeLocator2Test);
defineReflectiveTests(ResolutionCopierTest);
});
}
@reflectiveTest
class NodeLocator2Test extends ParserTestCase {
void test_onlyStartOffset() {
String code = ' int vv; ';
// 012345678
CompilationUnit unit = parseCompilationUnit(code);
TopLevelVariableDeclaration declaration = unit.declarations[0];
VariableDeclarationList variableList = declaration.variables;
Identifier typeName = (variableList.type as TypeName).name;
SimpleIdentifier varName = variableList.variables[0].name;
expect(NodeLocator2(0).searchWithin(unit), same(unit));
expect(NodeLocator2(1).searchWithin(unit), same(typeName));
expect(NodeLocator2(2).searchWithin(unit), same(typeName));
expect(NodeLocator2(3).searchWithin(unit), same(typeName));
expect(NodeLocator2(4).searchWithin(unit), same(variableList));
expect(NodeLocator2(5).searchWithin(unit), same(varName));
expect(NodeLocator2(6).searchWithin(unit), same(varName));
expect(NodeLocator2(7).searchWithin(unit), same(declaration));
expect(NodeLocator2(8).searchWithin(unit), same(unit));
expect(NodeLocator2(9).searchWithin(unit), isNull);
expect(NodeLocator2(100).searchWithin(unit), isNull);
}
void test_startEndOffset() {
String code = ' int vv; ';
// 012345678
CompilationUnit unit = parseCompilationUnit(code);
TopLevelVariableDeclaration declaration = unit.declarations[0];
VariableDeclarationList variableList = declaration.variables;
Identifier typeName = (variableList.type as TypeName).name;
SimpleIdentifier varName = variableList.variables[0].name;
expect(NodeLocator2(-1, 2).searchWithin(unit), isNull);
expect(NodeLocator2(0, 2).searchWithin(unit), same(unit));
expect(NodeLocator2(1, 2).searchWithin(unit), same(typeName));
expect(NodeLocator2(1, 3).searchWithin(unit), same(typeName));
expect(NodeLocator2(1, 4).searchWithin(unit), same(variableList));
expect(NodeLocator2(5, 6).searchWithin(unit), same(varName));
expect(NodeLocator2(5, 7).searchWithin(unit), same(declaration));
expect(NodeLocator2(5, 8).searchWithin(unit), same(unit));
expect(NodeLocator2(5, 100).searchWithin(unit), isNull);
expect(NodeLocator2(100, 200).searchWithin(unit), isNull);
}
}
@reflectiveTest
class NodeLocatorTest extends ParserTestCase {
void test_range() {
CompilationUnit unit = parseCompilationUnit("library myLib;");
var node = _assertLocate(unit, 4, 10);
expect(node, isLibraryDirective);
}
void test_searchWithin_null() {
NodeLocator locator = NodeLocator(0, 0);
expect(locator.searchWithin(null), isNull);
}
void test_searchWithin_offset() {
CompilationUnit unit = parseCompilationUnit("library myLib;");
var node = _assertLocate(unit, 10, 10);
expect(node, isSimpleIdentifier);
}
void test_searchWithin_offsetAfterNode() {
CompilationUnit unit = parseCompilationUnit(r'''
class A {}
class B {}''');
NodeLocator locator = NodeLocator(1024, 1024);
AstNode node = locator.searchWithin(unit.declarations[0]);
expect(node, isNull);
}
void test_searchWithin_offsetBeforeNode() {
CompilationUnit unit = parseCompilationUnit(r'''
class A {}
class B {}''');
NodeLocator locator = NodeLocator(0, 0);
AstNode node = locator.searchWithin(unit.declarations[1]);
expect(node, isNull);
}
AstNode _assertLocate(
CompilationUnit unit,
int start,
int end,
) {
NodeLocator locator = NodeLocator(start, end);
AstNode node = locator.searchWithin(unit);
expect(node, isNotNull);
expect(locator.foundNode, same(node));
expect(node.offset <= start, isTrue, reason: "Node starts after range");
expect(node.offset + node.length > end, isTrue,
reason: "Node ends before range");
return node;
}
}
@reflectiveTest
class ResolutionCopierTest with ElementsTypesMixin {
@override
final TypeProvider typeProvider = TestTypeProvider();
void test_visitAdjacentStrings() {
AdjacentStrings createNode() => astFactory.adjacentStrings([
astFactory.simpleStringLiteral(null, 'hello'),
astFactory.simpleStringLiteral(null, 'world')
]);
AdjacentStrings fromNode = createNode();
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('B'));
fromNode.staticType = staticType;
AdjacentStrings toNode = createNode();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitAnnotation() {
String annotationName = "proxy";
Annotation fromNode =
AstTestFactory.annotation(AstTestFactory.identifier3(annotationName));
Element element = ElementFactory.topLevelVariableElement2(annotationName);
fromNode.element = element;
Annotation toNode =
AstTestFactory.annotation(AstTestFactory.identifier3(annotationName));
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.element, same(element));
}
void test_visitAsExpression() {
AsExpression fromNode = AstTestFactory.asExpression(
AstTestFactory.identifier3("x"), AstTestFactory.typeName4("A"));
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('B'));
fromNode.staticType = staticType;
AsExpression toNode = AstTestFactory.asExpression(
AstTestFactory.identifier3("x"), AstTestFactory.typeName4("A"));
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitAssignmentExpression() {
AssignmentExpression fromNode = AstTestFactory.assignmentExpression(
AstTestFactory.identifier3("a"),
TokenType.PLUS_EQ,
AstTestFactory.identifier3("b"));
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
MethodElement staticElement = ElementFactory.methodElement("+", staticType);
fromNode.staticElement = staticElement;
fromNode.staticType = staticType;
AssignmentExpression toNode = AstTestFactory.assignmentExpression(
AstTestFactory.identifier3("a"),
TokenType.PLUS_EQ,
AstTestFactory.identifier3("b"));
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticElement, same(staticElement));
expect(toNode.staticType, same(staticType));
}
void test_visitBinaryExpression() {
BinaryExpression fromNode = AstTestFactory.binaryExpression(
AstTestFactory.identifier3("a"),
TokenType.PLUS,
AstTestFactory.identifier3("b"));
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
MethodElement staticElement = ElementFactory.methodElement("+", staticType);
fromNode.staticElement = staticElement;
fromNode.staticType = staticType;
BinaryExpression toNode = AstTestFactory.binaryExpression(
AstTestFactory.identifier3("a"),
TokenType.PLUS,
AstTestFactory.identifier3("b"));
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticElement, same(staticElement));
expect(toNode.staticType, same(staticType));
}
void test_visitBooleanLiteral() {
BooleanLiteral fromNode = AstTestFactory.booleanLiteral(true);
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
BooleanLiteral toNode = AstTestFactory.booleanLiteral(true);
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitCascadeExpression() {
CascadeExpression fromNode = AstTestFactory.cascadeExpression(
AstTestFactory.identifier3("a"), [AstTestFactory.identifier3("b")]);
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
CascadeExpression toNode = AstTestFactory.cascadeExpression(
AstTestFactory.identifier3("a"), [AstTestFactory.identifier3("b")]);
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitCompilationUnit() {
CompilationUnit fromNode = AstTestFactory.compilationUnit();
CompilationUnitElement element = CompilationUnitElementImpl();
fromNode.element = element;
CompilationUnit toNode = AstTestFactory.compilationUnit();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.declaredElement, same(element));
}
void test_visitConditionalExpression() {
ConditionalExpression fromNode = AstTestFactory.conditionalExpression(
AstTestFactory.identifier3("c"),
AstTestFactory.identifier3("a"),
AstTestFactory.identifier3("b"));
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
ConditionalExpression toNode = AstTestFactory.conditionalExpression(
AstTestFactory.identifier3("c"),
AstTestFactory.identifier3("a"),
AstTestFactory.identifier3("b"));
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitConstructorDeclaration() {
String className = "A";
String constructorName = "c";
ConstructorDeclarationImpl fromNode = AstTestFactory.constructorDeclaration(
AstTestFactory.identifier3(className),
constructorName,
AstTestFactory.formalParameterList(),
null);
ConstructorElement element = ElementFactory.constructorElement2(
ElementFactory.classElement2(className), constructorName);
fromNode.declaredElement = element;
ConstructorDeclaration toNode = AstTestFactory.constructorDeclaration(
AstTestFactory.identifier3(className),
constructorName,
AstTestFactory.formalParameterList(),
null);
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.declaredElement, same(element));
}
void test_visitConstructorName() {
ConstructorName fromNode =
AstTestFactory.constructorName(AstTestFactory.typeName4("A"), "c");
ConstructorElement staticElement = ElementFactory.constructorElement2(
ElementFactory.classElement2("A"), "c");
fromNode.staticElement = staticElement;
ConstructorName toNode =
AstTestFactory.constructorName(AstTestFactory.typeName4("A"), "c");
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticElement, same(staticElement));
}
void test_visitDoubleLiteral() {
DoubleLiteral fromNode = AstTestFactory.doubleLiteral(1.0);
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
DoubleLiteral toNode = AstTestFactory.doubleLiteral(1.0);
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitExportDirective() {
ExportDirective fromNode = AstTestFactory.exportDirective2("dart:uri");
ExportElement element = ExportElementImpl(-1);
fromNode.element = element;
ExportDirective toNode = AstTestFactory.exportDirective2("dart:uri");
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.element, same(element));
}
void test_visitFieldDeclaration_abstract() {
FieldDeclaration fromNode = AstTestFactory.fieldDeclaration(
false, Keyword.VAR, null, [AstTestFactory.variableDeclaration('x')],
isAbstract: false);
FieldElement element = FieldElementImpl('x', -1);
fromNode.fields.variables[0].name.staticElement = element;
FieldDeclaration toNode1 = AstTestFactory.fieldDeclaration(
false, Keyword.VAR, null, [AstTestFactory.variableDeclaration('x')],
isAbstract: false);
ResolutionCopier.copyResolutionData(fromNode, toNode1);
// Nodes matched so resolution data should have been copied.
expect(toNode1.fields.variables[0].declaredElement, same(element));
FieldDeclaration toNode2 = AstTestFactory.fieldDeclaration(
false, Keyword.VAR, null, [AstTestFactory.variableDeclaration('x')],
isAbstract: true);
ResolutionCopier.copyResolutionData(fromNode, toNode1);
// Nodes didn't match so resolution data should not have been copied.
expect(toNode2.fields.variables[0].declaredElement, isNull);
}
void test_visitForEachPartsWithDeclaration() {
ForEachPartsWithDeclaration createNode() =>
astFactory.forEachPartsWithDeclaration(
loopVariable: AstTestFactory.declaredIdentifier3('a'),
iterable: AstTestFactory.identifier3('b'));
DartType typeB = interfaceTypeStar(ElementFactory.classElement2('B'));
ForEachPartsWithDeclaration fromNode = createNode();
(fromNode.iterable as SimpleIdentifier).staticType = typeB;
ForEachPartsWithDeclaration toNode = createNode();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect((toNode.iterable as SimpleIdentifier).staticType, same(typeB));
}
void test_visitForEachPartsWithIdentifier() {
ForEachPartsWithIdentifier createNode() =>
astFactory.forEachPartsWithIdentifier(
identifier: AstTestFactory.identifier3('a'),
iterable: AstTestFactory.identifier3('b'));
DartType typeA = interfaceTypeStar(ElementFactory.classElement2('A'));
DartType typeB = interfaceTypeStar(ElementFactory.classElement2('B'));
ForEachPartsWithIdentifier fromNode = createNode();
fromNode.identifier.staticType = typeA;
(fromNode.iterable as SimpleIdentifier).staticType = typeB;
ForEachPartsWithIdentifier toNode = createNode();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.identifier.staticType, same(typeA));
expect((toNode.iterable as SimpleIdentifier).staticType, same(typeB));
}
void test_visitForElement() {
ForElement createNode() => astFactory.forElement(
forLoopParts: astFactory.forEachPartsWithIdentifier(
identifier: AstTestFactory.identifier3('a'),
iterable: AstTestFactory.identifier3('b')),
body: AstTestFactory.identifier3('c'));
DartType typeC = interfaceTypeStar(ElementFactory.classElement2('C'));
ForElement fromNode = createNode();
(fromNode.body as SimpleIdentifier).staticType = typeC;
ForElement toNode = createNode();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect((toNode.body as SimpleIdentifier).staticType, same(typeC));
}
void test_visitForPartsWithDeclarations() {
ForPartsWithDeclarations createNode() =>
astFactory.forPartsWithDeclarations(
variables: AstTestFactory.variableDeclarationList2(
Keyword.VAR, [AstTestFactory.variableDeclaration('a')]),
condition: AstTestFactory.identifier3('b'),
updaters: [AstTestFactory.identifier3('c')]);
DartType typeB = interfaceTypeStar(ElementFactory.classElement2('B'));
DartType typeC = interfaceTypeStar(ElementFactory.classElement2('C'));
ForPartsWithDeclarations fromNode = createNode();
(fromNode.condition as SimpleIdentifier).staticType = typeB;
(fromNode.updaters[0] as SimpleIdentifier).staticType = typeC;
ForPartsWithDeclarations toNode = createNode();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect((toNode.condition as SimpleIdentifier).staticType, same(typeB));
expect((toNode.updaters[0] as SimpleIdentifier).staticType, same(typeC));
}
void test_visitForPartsWithExpression() {
ForPartsWithExpression createNode() => astFactory.forPartsWithExpression(
initialization: AstTestFactory.identifier3('a'),
condition: AstTestFactory.identifier3('b'),
updaters: [AstTestFactory.identifier3('c')]);
DartType typeA = interfaceTypeStar(ElementFactory.classElement2('A'));
DartType typeB = interfaceTypeStar(ElementFactory.classElement2('B'));
DartType typeC = interfaceTypeStar(ElementFactory.classElement2('C'));
ForPartsWithExpression fromNode = createNode();
(fromNode.initialization as SimpleIdentifier).staticType = typeA;
(fromNode.condition as SimpleIdentifier).staticType = typeB;
(fromNode.updaters[0] as SimpleIdentifier).staticType = typeC;
ForPartsWithExpression toNode = createNode();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect((toNode.initialization as SimpleIdentifier).staticType, same(typeA));
expect((toNode.condition as SimpleIdentifier).staticType, same(typeB));
expect((toNode.updaters[0] as SimpleIdentifier).staticType, same(typeC));
}
void test_visitForStatement() {
ForStatement createNode() => astFactory.forStatement(
forLoopParts: astFactory.forEachPartsWithIdentifier(
identifier: AstTestFactory.identifier3('a'),
iterable: AstTestFactory.identifier3('b')),
body: AstTestFactory.expressionStatement(
AstTestFactory.identifier3('c')));
DartType typeA = interfaceTypeStar(ElementFactory.classElement2('A'));
DartType typeB = interfaceTypeStar(ElementFactory.classElement2('B'));
DartType typeC = interfaceTypeStar(ElementFactory.classElement2('C'));
ForStatement fromNode = createNode();
ForEachPartsWithIdentifier fromForLoopParts = fromNode.forLoopParts;
fromForLoopParts.identifier.staticType = typeA;
(fromForLoopParts.iterable as SimpleIdentifier).staticType = typeB;
((fromNode.body as ExpressionStatement).expression as SimpleIdentifier)
.staticType = typeC;
ForStatement toNode = createNode();
ResolutionCopier.copyResolutionData(fromNode, toNode);
ForEachPartsWithIdentifier toForLoopParts = fromNode.forLoopParts;
expect(toForLoopParts.identifier.staticType, same(typeA));
expect(
(toForLoopParts.iterable as SimpleIdentifier).staticType, same(typeB));
expect(
((toNode.body as ExpressionStatement).expression as SimpleIdentifier)
.staticType,
same(typeC));
}
void test_visitFunctionExpression() {
FunctionExpressionImpl fromNode = AstTestFactory.functionExpression2(
AstTestFactory.formalParameterList(),
AstTestFactory.emptyFunctionBody());
MethodElement element = ElementFactory.methodElement(
"m", interfaceTypeStar(ElementFactory.classElement2('C')));
fromNode.declaredElement = element;
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
FunctionExpression toNode = AstTestFactory.functionExpression2(
AstTestFactory.formalParameterList(),
AstTestFactory.emptyFunctionBody());
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.declaredElement, same(element));
expect(toNode.staticType, same(staticType));
}
void test_visitFunctionExpressionInvocation() {
FunctionExpressionInvocation fromNode =
AstTestFactory.functionExpressionInvocation(
AstTestFactory.identifier3("f"));
MethodElement staticElement = ElementFactory.methodElement(
"m", interfaceTypeStar(ElementFactory.classElement2('C')));
fromNode.staticElement = staticElement;
FunctionExpressionInvocation toNode =
AstTestFactory.functionExpressionInvocation(
AstTestFactory.identifier3("f"));
ClassElement elementT = ElementFactory.classElement2('T');
fromNode.typeArguments = AstTestFactory.typeArgumentList(
<TypeAnnotation>[AstTestFactory.typeName(elementT)]);
toNode.typeArguments = AstTestFactory.typeArgumentList(
<TypeAnnotation>[AstTestFactory.typeName4('T')]);
_copyAndVerifyInvocation(fromNode, toNode);
expect(toNode.staticElement, same(staticElement));
}
void test_visitIfElement() {
IfElement createNode() => astFactory.ifElement(
condition: AstTestFactory.identifier3('a'),
thenElement: AstTestFactory.identifier3('b'),
elseElement: AstTestFactory.identifier3('c'));
DartType typeA = interfaceTypeStar(ElementFactory.classElement2('A'));
DartType typeB = interfaceTypeStar(ElementFactory.classElement2('B'));
DartType typeC = interfaceTypeStar(ElementFactory.classElement2('C'));
IfElement fromNode = createNode();
(fromNode.condition as SimpleIdentifier).staticType = typeA;
(fromNode.thenElement as SimpleIdentifier).staticType = typeB;
(fromNode.elseElement as SimpleIdentifier).staticType = typeC;
IfElement toNode = createNode();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.condition.staticType, same(typeA));
expect((toNode.thenElement as SimpleIdentifier).staticType, same(typeB));
expect((toNode.elseElement as SimpleIdentifier).staticType, same(typeC));
}
void test_visitImportDirective() {
ImportDirective fromNode =
AstTestFactory.importDirective3("dart:uri", null);
ImportElement element = ImportElementImpl(0);
fromNode.element = element;
ImportDirective toNode = AstTestFactory.importDirective3("dart:uri", null);
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.element, same(element));
}
void test_visitIndexExpression() {
IndexExpression fromNode = AstTestFactory.indexExpression(
target: AstTestFactory.identifier3("a"),
index: AstTestFactory.integer(0),
);
MethodElement staticElement = ElementFactory.methodElement(
"m", interfaceTypeStar(ElementFactory.classElement2('C')));
AuxiliaryElements auxiliaryElements = AuxiliaryElements(staticElement);
fromNode.auxiliaryElements = auxiliaryElements;
fromNode.staticElement = staticElement;
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
IndexExpression toNode = AstTestFactory.indexExpression(
target: AstTestFactory.identifier3("a"),
index: AstTestFactory.integer(0),
);
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.auxiliaryElements, same(auxiliaryElements));
expect(toNode.staticElement, same(staticElement));
expect(toNode.staticType, same(staticType));
}
void test_visitInstanceCreationExpression() {
InstanceCreationExpression fromNode =
AstTestFactory.instanceCreationExpression2(
Keyword.NEW, AstTestFactory.typeName4("C"));
ConstructorElement staticElement = ElementFactory.constructorElement2(
ElementFactory.classElement2("C"), null);
fromNode.constructorName.staticElement = staticElement;
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
InstanceCreationExpression toNode =
AstTestFactory.instanceCreationExpression2(
Keyword.NEW, AstTestFactory.typeName4("C"));
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.constructorName.staticElement, same(staticElement));
expect(toNode.staticType, same(staticType));
}
void test_visitIntegerLiteral() {
IntegerLiteral fromNode = AstTestFactory.integer(2);
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
IntegerLiteral toNode = AstTestFactory.integer(2);
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitIsExpression() {
IsExpression fromNode = AstTestFactory.isExpression(
AstTestFactory.identifier3("x"), false, AstTestFactory.typeName4("A"));
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
IsExpression toNode = AstTestFactory.isExpression(
AstTestFactory.identifier3("x"), false, AstTestFactory.typeName4("A"));
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitLibraryIdentifier() {
LibraryIdentifier fromNode =
AstTestFactory.libraryIdentifier([AstTestFactory.identifier3("lib")]);
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
LibraryIdentifier toNode =
AstTestFactory.libraryIdentifier([AstTestFactory.identifier3("lib")]);
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitListLiteral() {
ListLiteral createNode() => astFactory.listLiteral(
null,
AstTestFactory.typeArgumentList([AstTestFactory.typeName4('A')]),
null,
[AstTestFactory.identifier3('b')],
null);
DartType typeA = interfaceTypeStar(ElementFactory.classElement2('A'));
DartType typeB = interfaceTypeStar(ElementFactory.classElement2('B'));
DartType typeC = interfaceTypeStar(ElementFactory.classElement2('C'));
ListLiteral fromNode = createNode();
(fromNode.typeArguments.arguments[0] as TypeName).type = typeA;
(fromNode.elements[0] as SimpleIdentifier).staticType = typeB;
fromNode.staticType = typeC;
ListLiteral toNode = createNode();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect((toNode.typeArguments.arguments[0] as TypeName).type, same(typeA));
expect((toNode.elements[0] as SimpleIdentifier).staticType, same(typeB));
expect(fromNode.staticType, same(typeC));
}
void test_visitMapLiteral() {
SetOrMapLiteral fromNode = AstTestFactory.setOrMapLiteral(null, null);
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
SetOrMapLiteral toNode = AstTestFactory.setOrMapLiteral(null, null);
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitMethodInvocation() {
MethodInvocation fromNode = AstTestFactory.methodInvocation2("m");
MethodInvocation toNode = AstTestFactory.methodInvocation2("m");
ClassElement elementT = ElementFactory.classElement2('T');
fromNode.typeArguments = AstTestFactory.typeArgumentList(
<TypeAnnotation>[AstTestFactory.typeName(elementT)]);
toNode.typeArguments = AstTestFactory.typeArgumentList(
<TypeAnnotation>[AstTestFactory.typeName4('T')]);
_copyAndVerifyInvocation(fromNode, toNode);
}
void test_visitNamedExpression() {
NamedExpression fromNode =
AstTestFactory.namedExpression2("n", AstTestFactory.integer(0));
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
NamedExpression toNode =
AstTestFactory.namedExpression2("n", AstTestFactory.integer(0));
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitNullLiteral() {
NullLiteral fromNode = AstTestFactory.nullLiteral();
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
NullLiteral toNode = AstTestFactory.nullLiteral();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitParenthesizedExpression() {
ParenthesizedExpression fromNode =
AstTestFactory.parenthesizedExpression(AstTestFactory.integer(0));
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
ParenthesizedExpression toNode =
AstTestFactory.parenthesizedExpression(AstTestFactory.integer(0));
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitPartDirective() {
PartDirective fromNode = AstTestFactory.partDirective2("part.dart");
LibraryElement element = LibraryElementImpl(null, null, 'lib', -1, 0, true);
fromNode.element = element;
PartDirective toNode = AstTestFactory.partDirective2("part.dart");
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.element, same(element));
}
void test_visitPartOfDirective() {
PartOfDirective fromNode = AstTestFactory.partOfDirective(
AstTestFactory.libraryIdentifier2(["lib"]));
LibraryElement element = LibraryElementImpl(null, null, 'lib', -1, 0, true);
fromNode.element = element;
PartOfDirective toNode = AstTestFactory.partOfDirective(
AstTestFactory.libraryIdentifier2(["lib"]));
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.element, same(element));
}
void test_visitPostfixExpression() {
String variableName = "x";
PostfixExpression fromNode = AstTestFactory.postfixExpression(
AstTestFactory.identifier3(variableName), TokenType.PLUS_PLUS);
MethodElement staticElement = ElementFactory.methodElement(
"+", interfaceTypeStar(ElementFactory.classElement2('C')));
fromNode.staticElement = staticElement;
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
PostfixExpression toNode = AstTestFactory.postfixExpression(
AstTestFactory.identifier3(variableName), TokenType.PLUS_PLUS);
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticElement, same(staticElement));
expect(toNode.staticType, same(staticType));
}
void test_visitPrefixedIdentifier() {
PrefixedIdentifier fromNode = AstTestFactory.identifier5("p", "f");
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
PrefixedIdentifier toNode = AstTestFactory.identifier5("p", "f");
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitPrefixExpression() {
PrefixExpression fromNode = AstTestFactory.prefixExpression(
TokenType.PLUS_PLUS, AstTestFactory.identifier3("x"));
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
MethodElement staticElement = ElementFactory.methodElement(
"+", interfaceTypeStar(ElementFactory.classElement2('C')));
fromNode.staticElement = staticElement;
fromNode.staticType = staticType;
PrefixExpression toNode = AstTestFactory.prefixExpression(
TokenType.PLUS_PLUS, AstTestFactory.identifier3("x"));
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticElement, same(staticElement));
expect(toNode.staticType, same(staticType));
}
void test_visitPropertyAccess() {
PropertyAccess fromNode =
AstTestFactory.propertyAccess2(AstTestFactory.identifier3("x"), "y");
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
PropertyAccess toNode =
AstTestFactory.propertyAccess2(AstTestFactory.identifier3("x"), "y");
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitRedirectingConstructorInvocation() {
RedirectingConstructorInvocation fromNode =
AstTestFactory.redirectingConstructorInvocation();
ConstructorElement staticElement = ElementFactory.constructorElement2(
ElementFactory.classElement2("C"), null);
fromNode.staticElement = staticElement;
RedirectingConstructorInvocation toNode =
AstTestFactory.redirectingConstructorInvocation();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticElement, same(staticElement));
}
void test_visitRethrowExpression() {
RethrowExpression fromNode = AstTestFactory.rethrowExpression();
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
RethrowExpression toNode = AstTestFactory.rethrowExpression();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitSetOrMapLiteral_map() {
SetOrMapLiteral createNode() => astFactory.setOrMapLiteral(
typeArguments: AstTestFactory.typeArgumentList(
[AstTestFactory.typeName4('A'), AstTestFactory.typeName4('B')]),
elements: [AstTestFactory.mapLiteralEntry3('c', 'd')]);
DartType typeA = interfaceTypeStar(ElementFactory.classElement2('A'));
DartType typeB = interfaceTypeStar(ElementFactory.classElement2('B'));
DartType typeC = interfaceTypeStar(ElementFactory.classElement2('C'));
DartType typeD = interfaceTypeStar(ElementFactory.classElement2('D'));
SetOrMapLiteral fromNode = createNode();
(fromNode.typeArguments.arguments[0] as TypeName).type = typeA;
(fromNode.typeArguments.arguments[1] as TypeName).type = typeB;
MapLiteralEntry fromEntry = fromNode.elements[0] as MapLiteralEntry;
(fromEntry.key as SimpleStringLiteral).staticType = typeC;
(fromEntry.value as SimpleStringLiteral).staticType = typeD;
SetOrMapLiteral toNode = createNode();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect((toNode.typeArguments.arguments[0] as TypeName).type, same(typeA));
expect((toNode.typeArguments.arguments[1] as TypeName).type, same(typeB));
MapLiteralEntry toEntry = fromNode.elements[0] as MapLiteralEntry;
expect((toEntry.key as SimpleStringLiteral).staticType, same(typeC));
expect((toEntry.value as SimpleStringLiteral).staticType, same(typeD));
}
void test_visitSetOrMapLiteral_set() {
SetOrMapLiteral createNode() => astFactory.setOrMapLiteral(
typeArguments:
AstTestFactory.typeArgumentList([AstTestFactory.typeName4('A')]),
elements: [AstTestFactory.identifier3('b')]);
DartType typeA = interfaceTypeStar(ElementFactory.classElement2('A'));
DartType typeB = interfaceTypeStar(ElementFactory.classElement2('B'));
SetOrMapLiteral fromNode = createNode();
(fromNode.typeArguments.arguments[0] as TypeName).type = typeA;
(fromNode.elements[0] as SimpleIdentifier).staticType = typeB;
SetOrMapLiteral toNode = createNode();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect((toNode.typeArguments.arguments[0] as TypeName).type, same(typeA));
expect((toNode.elements[0] as SimpleIdentifier).staticType, same(typeB));
}
void test_visitSimpleIdentifier() {
SimpleIdentifier fromNode = AstTestFactory.identifier3("x");
MethodElement staticElement = ElementFactory.methodElement(
"m", interfaceTypeStar(ElementFactory.classElement2('C')));
AuxiliaryElements auxiliaryElements = AuxiliaryElements(staticElement);
fromNode.auxiliaryElements = auxiliaryElements;
fromNode.staticElement = staticElement;
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
SimpleIdentifier toNode = AstTestFactory.identifier3("x");
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.auxiliaryElements, same(auxiliaryElements));
expect(toNode.staticElement, same(staticElement));
expect(toNode.staticType, same(staticType));
}
void test_visitSimpleStringLiteral() {
SimpleStringLiteral fromNode = AstTestFactory.string2("abc");
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
SimpleStringLiteral toNode = AstTestFactory.string2("abc");
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitSpreadElement() {
SpreadElement createNode() => astFactory.spreadElement(
spreadOperator:
TokenFactory.tokenFromType(TokenType.PERIOD_PERIOD_PERIOD),
expression: astFactory.listLiteral(
null, null, null, [AstTestFactory.identifier3('a')], null));
DartType typeA = interfaceTypeStar(ElementFactory.classElement2('A'));
SpreadElement fromNode = createNode();
((fromNode.expression as ListLiteral).elements[0] as SimpleIdentifier)
.staticType = typeA;
SpreadElement toNode = createNode();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(
((toNode.expression as ListLiteral).elements[0] as SimpleIdentifier)
.staticType,
same(typeA));
}
void test_visitStringInterpolation() {
StringInterpolation fromNode =
AstTestFactory.string([AstTestFactory.interpolationString("a", "'a'")]);
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
StringInterpolation toNode =
AstTestFactory.string([AstTestFactory.interpolationString("a", "'a'")]);
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitSuperConstructorInvocation() {
SuperConstructorInvocation fromNode =
AstTestFactory.superConstructorInvocation();
ConstructorElement staticElement = ElementFactory.constructorElement2(
ElementFactory.classElement2("C"), null);
fromNode.staticElement = staticElement;
SuperConstructorInvocation toNode =
AstTestFactory.superConstructorInvocation();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticElement, same(staticElement));
}
void test_visitSuperExpression() {
SuperExpression fromNode = AstTestFactory.superExpression();
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
SuperExpression toNode = AstTestFactory.superExpression();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitSymbolLiteral() {
SymbolLiteral fromNode = AstTestFactory.symbolLiteral(["s"]);
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
SymbolLiteral toNode = AstTestFactory.symbolLiteral(["s"]);
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitThisExpression() {
ThisExpression fromNode = AstTestFactory.thisExpression();
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
ThisExpression toNode = AstTestFactory.thisExpression();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitThrowExpression() {
ThrowExpression fromNode = AstTestFactory.throwExpression();
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
ThrowExpression toNode = AstTestFactory.throwExpression();
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
}
void test_visitTypeName() {
TypeName fromNode = AstTestFactory.typeName4("C");
DartType type = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.type = type;
TypeName toNode = AstTestFactory.typeName4("C");
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.type, same(type));
}
void _copyAndVerifyInvocation(
InvocationExpression fromNode, InvocationExpression toNode) {
DartType staticType = interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticType = staticType;
DartType staticInvokeType =
interfaceTypeStar(ElementFactory.classElement2('C'));
fromNode.staticInvokeType = staticInvokeType;
ResolutionCopier.copyResolutionData(fromNode, toNode);
expect(toNode.staticType, same(staticType));
expect(toNode.staticInvokeType, same(staticInvokeType));
List<TypeAnnotation> fromTypeArguments = toNode.typeArguments.arguments;
List<TypeAnnotation> toTypeArguments = fromNode.typeArguments.arguments;
if (fromTypeArguments != null) {
for (int i = 0; i < fromTypeArguments.length; i++) {
TypeAnnotation toArgument = fromTypeArguments[i];
TypeAnnotation fromArgument = toTypeArguments[i];
expect(toArgument.type, same(fromArgument.type));
}
}
}
}