Version 2.16.0-121.0.dev
Merge commit '08460e7af53559f3a8064f4f0752933fff772d61' into 'dev'
diff --git a/pkg/analyzer/lib/src/dart/ast/utilities.dart b/pkg/analyzer/lib/src/dart/ast/utilities.dart
index 405d684..4db6958 100644
--- a/pkg/analyzer/lib/src/dart/ast/utilities.dart
+++ b/pkg/analyzer/lib/src/dart/ast/utilities.dart
@@ -2095,6 +2095,9 @@
if (identical(node.type, _oldNode)) {
node.type = _newNode as TypeAnnotation;
return true;
+ } else if (identical(node.typeParameters, _oldNode)) {
+ node.typeParameters = _newNode as TypeParameterList;
+ return true;
} else if (identical(node.parameters, _oldNode)) {
node.parameters = _newNode as FormalParameterList;
return true;
@@ -2221,6 +2224,9 @@
if (identical(node.parameters, _oldNode)) {
node.parameters = _newNode as FormalParameterList;
return true;
+ } else if (identical(node.typeParameters, _oldNode)) {
+ node.typeParameters = _newNode as TypeParameterList;
+ return true;
} else if (identical(node.body, _oldNode)) {
node.body = _newNode as FunctionBody;
return true;
@@ -2237,6 +2243,9 @@
} else if (identical(node.argumentList, _oldNode)) {
node.argumentList = _newNode as ArgumentList;
return true;
+ } else if (identical(node.typeArguments, _oldNode)) {
+ node.typeArguments = _newNode as TypeArgumentList;
+ return true;
}
return visitNode(node);
}
@@ -2280,6 +2289,9 @@
} else if (identical(node.parameters, _oldNode)) {
node.parameters = _newNode as FormalParameterList;
return true;
+ } else if (identical(node.typeParameters, _oldNode)) {
+ node.typeParameters = _newNode as TypeParameterList;
+ return true;
}
return visitNormalFormalParameter(node);
}
@@ -2513,6 +2525,9 @@
} else if (identical(node.parameters, _oldNode)) {
node.parameters = _newNode as FormalParameterList;
return true;
+ } else if (identical(node.typeParameters, _oldNode)) {
+ node.typeParameters = _newNode as TypeParameterList;
+ return true;
} else if (identical(node.body, _oldNode)) {
node.body = _newNode as FunctionBody;
return true;
@@ -2531,6 +2546,9 @@
} else if (identical(node.argumentList, _oldNode)) {
node.argumentList = _newNode as ArgumentList;
return true;
+ } else if (identical(node.typeArguments, _oldNode)) {
+ node.typeArguments = _newNode as TypeArgumentList;
+ return true;
}
return visitNode(node);
}
diff --git a/pkg/analyzer/lib/src/test_utilities/find_node.dart b/pkg/analyzer/lib/src/test_utilities/find_node.dart
index 2b94f63..b25d26f 100644
--- a/pkg/analyzer/lib/src/test_utilities/find_node.dart
+++ b/pkg/analyzer/lib/src/test_utilities/find_node.dart
@@ -27,6 +27,10 @@
return result;
}
+ AdjacentStrings adjacentStrings(String search) {
+ return _node(search, (n) => n is AdjacentStrings);
+ }
+
Annotation annotation(String search) {
return _node(search, (n) => n is Annotation);
}
@@ -35,10 +39,18 @@
return _node(search, (n) => true);
}
+ ArgumentList argumentList(String search) {
+ return _node(search, (n) => n is ArgumentList);
+ }
+
AsExpression as_(String search) {
return _node(search, (n) => n is AsExpression);
}
+ AssertStatement assertStatement(String search) {
+ return _node(search, (n) => n is AssertStatement);
+ }
+
AssignmentExpression assignment(String search) {
return _node(search, (n) => n is AssignmentExpression);
}
@@ -55,6 +67,10 @@
return _node(search, (n) => n is Block);
}
+ BlockFunctionBody blockFunctionBody(String search) {
+ return _node(search, (n) => n is BlockFunctionBody);
+ }
+
BooleanLiteral booleanLiteral(String search) {
return _node(search, (n) => n is BooleanLiteral);
}
@@ -83,6 +99,10 @@
return _node(search, (n) => n is CollectionElement);
}
+ Comment comment(String search) {
+ return _node(search, (n) => n is Comment);
+ }
+
CommentReference commentReference(String search) {
return _node(search, (n) => n is CommentReference);
}
@@ -111,6 +131,10 @@
return _node(search, (n) => n is ContinueStatement);
}
+ DeclaredIdentifier declaredIdentifier(String search) {
+ return _node(search, (n) => n is DeclaredIdentifier);
+ }
+
DefaultFormalParameter defaultParameter(String search) {
return _node(search, (n) => n is DefaultFormalParameter);
}
@@ -139,10 +163,18 @@
return _node(search, (n) => n is Expression);
}
+ ExpressionFunctionBody expressionFunctionBody(String search) {
+ return _node(search, (n) => n is ExpressionFunctionBody);
+ }
+
ExpressionStatement expressionStatement(String search) {
return _node(search, (n) => n is ExpressionStatement);
}
+ ExtendsClause extendsClause(String search) {
+ return _node(search, (n) => n is ExtendsClause);
+ }
+
ExtensionDeclaration extensionDeclaration(String search) {
return _node(search, (n) => n is ExtensionDeclaration);
}
@@ -159,6 +191,26 @@
return _node(search, (n) => n is FieldFormalParameter);
}
+ ForEachPartsWithDeclaration forEachPartsWithDeclaration(String search) {
+ return _node(search, (n) => n is ForEachPartsWithDeclaration);
+ }
+
+ ForEachPartsWithIdentifier forEachPartsWithIdentifier(String search) {
+ return _node(search, (n) => n is ForEachPartsWithIdentifier);
+ }
+
+ FormalParameterList formalParameterList(String search) {
+ return _node(search, (n) => n is FormalParameterList);
+ }
+
+ ForPartsWithDeclarations forPartsWithDeclarations(String search) {
+ return _node(search, (n) => n is ForPartsWithDeclarations);
+ }
+
+ ForPartsWithExpression forPartsWithExpression(String search) {
+ return _node(search, (n) => n is ForPartsWithExpression);
+ }
+
ForStatement forStatement(String search) {
return _node(search, (n) => n is ForStatement);
}
@@ -171,6 +223,10 @@
return _node(search, (n) => n is FunctionDeclaration);
}
+ FunctionDeclarationStatement functionDeclarationStatement(String search) {
+ return _node(search, (n) => n is FunctionDeclarationStatement);
+ }
+
FunctionExpression functionExpression(String search) {
return _node(search, (n) => n is FunctionExpression);
}
@@ -199,6 +255,10 @@
return _node(search, (n) => n is GenericTypeAlias);
}
+ HideCombinator hideCombinator(String search) {
+ return _node(search, (n) => n is HideCombinator);
+ }
+
IfElement ifElement(String search) {
return _node(search, (n) => n is IfElement);
}
@@ -207,6 +267,10 @@
return _node(search, (n) => n is IfStatement);
}
+ ImplementsClause implementsClause(String search) {
+ return _node(search, (n) => n is ImplementsClause);
+ }
+
ImplicitCallReference implicitCallReference(String search) {
return _node(search, (n) => n is ImplicitCallReference);
}
@@ -227,6 +291,10 @@
return _node(search, (n) => n is IntegerLiteral);
}
+ InterpolationExpression interpolationExpression(String search) {
+ return _node(search, (n) => n is InterpolationExpression);
+ }
+
IsExpression isExpression(String search) {
return _node(search, (n) => n is IsExpression);
}
@@ -235,14 +303,26 @@
return _node(search, (n) => n is Label);
}
+ LabeledStatement labeledStatement(String search) {
+ return _node(search, (n) => n is LabeledStatement);
+ }
+
LibraryDirective library(String search) {
return _node(search, (n) => n is LibraryDirective);
}
+ LibraryIdentifier libraryIdentifier(String search) {
+ return _node(search, (n) => n is LibraryIdentifier);
+ }
+
ListLiteral listLiteral(String search) {
return _node(search, (n) => n is ListLiteral);
}
+ MapLiteralEntry mapLiteralEntry(String search) {
+ return _node(search, (n) => n is MapLiteralEntry);
+ }
+
MethodDeclaration methodDeclaration(String search) {
return _node(search, (n) => n is MethodDeclaration);
}
@@ -267,6 +347,14 @@
return _node(search, (n) => n is NamedType);
}
+ NativeClause nativeClause(String search) {
+ return _node(search, (n) => n is NativeClause);
+ }
+
+ NativeFunctionBody nativeFunctionBody(String search) {
+ return _node(search, (n) => n is NativeFunctionBody);
+ }
+
NullLiteral nullLiteral(String search) {
return _node(search, (n) => n is NullLiteral);
}
@@ -321,14 +409,26 @@
return _node(search, (n) => n is RethrowExpression);
}
+ ReturnStatement returnStatement(String search) {
+ return _node(search, (n) => n is ReturnStatement);
+ }
+
SetOrMapLiteral setOrMapLiteral(String search) {
return _node(search, (n) => n is SetOrMapLiteral);
}
+ ShowCombinator showCombinator(String search) {
+ return _node(search, (n) => n is ShowCombinator);
+ }
+
SimpleIdentifier simple(String search) {
return _node(search, (_) => true);
}
+ SimpleFormalParameter simpleFormalParameter(String search) {
+ return _node(search, (n) => n is SimpleFormalParameter);
+ }
+
SimpleFormalParameter simpleParameter(String search) {
return _node(search, (n) => n is SimpleFormalParameter);
}
@@ -357,6 +457,14 @@
return _node(search, (n) => n is SuperFormalParameter);
}
+ SwitchCase switchCase(String search) {
+ return _node(search, (n) => n is SwitchCase);
+ }
+
+ SwitchDefault switchDefault(String search) {
+ return _node(search, (n) => n is SwitchDefault);
+ }
+
SwitchStatement switchStatement(String search) {
return _node(search, (n) => n is SwitchStatement);
}
@@ -390,10 +498,18 @@
throw StateError('$name');
}
+ TryStatement tryStatement(String search) {
+ return _node(search, (n) => n is TryStatement);
+ }
+
TypeAnnotation typeAnnotation(String search) {
return _node(search, (n) => n is TypeAnnotation);
}
+ TypeArgumentList typeArgumentList(String search) {
+ return _node(search, (n) => n is TypeArgumentList);
+ }
+
TypedLiteral typedLiteral(String search) {
return _node(search, (n) => n is TypedLiteral);
}
@@ -406,6 +522,10 @@
return _node(search, (n) => n is TypeParameter);
}
+ TypeParameterList typeParameterList(String search) {
+ return _node(search, (n) => n is TypeParameterList);
+ }
+
VariableDeclaration variableDeclaration(String search) {
return _node(search, (n) => n is VariableDeclaration);
}
@@ -414,10 +534,22 @@
return _node(search, (n) => n is VariableDeclarationList);
}
+ VariableDeclarationStatement variableDeclarationStatement(String search) {
+ return _node(search, (n) => n is VariableDeclarationStatement);
+ }
+
WhileStatement whileStatement(String search) {
return _node(search, (n) => n is WhileStatement);
}
+ WithClause withClause(String search) {
+ return _node(search, (n) => n is WithClause);
+ }
+
+ YieldStatement yieldStatement(String search) {
+ return _node(search, (n) => n is YieldStatement);
+ }
+
T _node<T>(String search, bool Function(AstNode) predicate) {
int offset = this.offset(search);
@@ -430,7 +562,7 @@
var result = node.thisOrAncestorMatching(predicate);
if (result == null) {
throw StateError(
- 'The node for |$search| had no matching ancestor in:\n$content');
+ 'The node for |$search| had no matching ancestor in:\n$content\n$unit');
}
return result as T;
}
diff --git a/pkg/analyzer/test/generated/utilities_test.dart b/pkg/analyzer/test/generated/utilities_test.dart
index ce0129d..cd93433 100644
--- a/pkg/analyzer/test/generated/utilities_test.dart
+++ b/pkg/analyzer/test/generated/utilities_test.dart
@@ -7,10 +7,8 @@
import 'package:analyzer/dart/ast/ast.dart';
import 'package:analyzer/dart/ast/token.dart';
import 'package:analyzer/src/dart/analysis/experiments.dart';
-import 'package:analyzer/src/dart/ast/ast_factory.dart';
import 'package:analyzer/src/dart/ast/utilities.dart';
import 'package:analyzer/src/generated/source.dart';
-import 'package:analyzer/src/generated/testing/ast_test_factory.dart';
import 'package:analyzer/src/generated/utilities_collection.dart';
import 'package:analyzer/src/test_utilities/find_node.dart';
import 'package:test/test.dart';
@@ -114,923 +112,6 @@
}
}
-class Getter_NodeReplacerTest_test_annotation
- implements NodeReplacerTest_Getter<Annotation, ArgumentList> {
- @override
- ArgumentList? get(Annotation node) => node.arguments;
-}
-
-class Getter_NodeReplacerTest_test_annotation_2
- implements NodeReplacerTest_Getter<Annotation, Identifier> {
- @override
- Identifier get(Annotation node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_annotation_3
- implements NodeReplacerTest_Getter<Annotation, SimpleIdentifier> {
- @override
- SimpleIdentifier? get(Annotation node) => node.constructorName;
-}
-
-class Getter_NodeReplacerTest_test_annotation_4
- implements NodeReplacerTest_Getter<Annotation, TypeArgumentList> {
- @override
- TypeArgumentList? get(Annotation node) => node.typeArguments;
-}
-
-class Getter_NodeReplacerTest_test_asExpression
- implements NodeReplacerTest_Getter<AsExpression, TypeAnnotation> {
- @override
- TypeAnnotation? get(AsExpression node) => node.type;
-}
-
-class Getter_NodeReplacerTest_test_asExpression_2
- implements NodeReplacerTest_Getter<AsExpression, Expression> {
- @override
- Expression get(AsExpression node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_assertStatement
- implements NodeReplacerTest_Getter<AssertStatement, Expression> {
- @override
- Expression get(AssertStatement node) => node.condition;
-}
-
-class Getter_NodeReplacerTest_test_assertStatement_2
- implements NodeReplacerTest_Getter<AssertStatement, Expression> {
- @override
- Expression? get(AssertStatement node) => node.message;
-}
-
-class Getter_NodeReplacerTest_test_assignmentExpression
- implements NodeReplacerTest_Getter<AssignmentExpression, Expression> {
- @override
- Expression get(AssignmentExpression node) => node.rightHandSide;
-}
-
-class Getter_NodeReplacerTest_test_assignmentExpression_2
- implements NodeReplacerTest_Getter<AssignmentExpression, Expression> {
- @override
- Expression get(AssignmentExpression node) => node.leftHandSide;
-}
-
-class Getter_NodeReplacerTest_test_awaitExpression
- implements NodeReplacerTest_Getter<AwaitExpression, Expression> {
- @override
- Expression get(AwaitExpression node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_binaryExpression
- implements NodeReplacerTest_Getter<BinaryExpression, Expression> {
- @override
- Expression get(BinaryExpression node) => node.leftOperand;
-}
-
-class Getter_NodeReplacerTest_test_binaryExpression_2
- implements NodeReplacerTest_Getter<BinaryExpression, Expression> {
- @override
- Expression get(BinaryExpression node) => node.rightOperand;
-}
-
-class Getter_NodeReplacerTest_test_blockFunctionBody
- implements NodeReplacerTest_Getter<BlockFunctionBody, Block> {
- @override
- Block get(BlockFunctionBody node) => node.block;
-}
-
-class Getter_NodeReplacerTest_test_breakStatement
- implements NodeReplacerTest_Getter<BreakStatement, SimpleIdentifier> {
- @override
- SimpleIdentifier? get(BreakStatement node) => node.label;
-}
-
-class Getter_NodeReplacerTest_test_cascadeExpression
- implements NodeReplacerTest_Getter<CascadeExpression, Expression> {
- @override
- Expression get(CascadeExpression node) => node.target;
-}
-
-class Getter_NodeReplacerTest_test_classDeclaration
- implements NodeReplacerTest_Getter<ClassDeclaration, ImplementsClause> {
- @override
- ImplementsClause? get(ClassDeclaration node) => node.implementsClause;
-}
-
-class Getter_NodeReplacerTest_test_classDeclaration_2
- implements NodeReplacerTest_Getter<ClassDeclaration, WithClause> {
- @override
- WithClause? get(ClassDeclaration node) => node.withClause;
-}
-
-class Getter_NodeReplacerTest_test_classDeclaration_3
- implements NodeReplacerTest_Getter<ClassDeclaration, NativeClause> {
- @override
- NativeClause? get(ClassDeclaration node) => node.nativeClause;
-}
-
-class Getter_NodeReplacerTest_test_classDeclaration_4
- implements NodeReplacerTest_Getter<ClassDeclaration, ExtendsClause> {
- @override
- ExtendsClause? get(ClassDeclaration node) => node.extendsClause;
-}
-
-class Getter_NodeReplacerTest_test_classDeclaration_5
- implements NodeReplacerTest_Getter<ClassDeclaration, TypeParameterList> {
- @override
- TypeParameterList? get(ClassDeclaration node) => node.typeParameters;
-}
-
-class Getter_NodeReplacerTest_test_classDeclaration_6
- implements NodeReplacerTest_Getter<ClassDeclaration, SimpleIdentifier> {
- @override
- SimpleIdentifier get(ClassDeclaration node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_classTypeAlias
- implements NodeReplacerTest_Getter<ClassTypeAlias, NamedType> {
- @override
- NamedType get(ClassTypeAlias node) => node.superclass2;
-}
-
-class Getter_NodeReplacerTest_test_classTypeAlias_2
- implements NodeReplacerTest_Getter<ClassTypeAlias, ImplementsClause> {
- @override
- ImplementsClause? get(ClassTypeAlias node) => node.implementsClause;
-}
-
-class Getter_NodeReplacerTest_test_classTypeAlias_3
- implements NodeReplacerTest_Getter<ClassTypeAlias, WithClause> {
- @override
- WithClause get(ClassTypeAlias node) => node.withClause;
-}
-
-class Getter_NodeReplacerTest_test_classTypeAlias_4
- implements NodeReplacerTest_Getter<ClassTypeAlias, SimpleIdentifier> {
- @override
- SimpleIdentifier get(ClassTypeAlias node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_classTypeAlias_5
- implements NodeReplacerTest_Getter<ClassTypeAlias, TypeParameterList> {
- @override
- TypeParameterList? get(ClassTypeAlias node) => node.typeParameters;
-}
-
-class Getter_NodeReplacerTest_test_commentReference
- implements
- NodeReplacerTest_Getter<CommentReference, CommentReferableExpression> {
- @override
- CommentReferableExpression get(CommentReference node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_compilationUnit
- implements NodeReplacerTest_Getter<CompilationUnit, ScriptTag> {
- @override
- ScriptTag? get(CompilationUnit node) => node.scriptTag;
-}
-
-class Getter_NodeReplacerTest_test_conditionalExpression
- implements NodeReplacerTest_Getter<ConditionalExpression, Expression> {
- @override
- Expression get(ConditionalExpression node) => node.elseExpression;
-}
-
-class Getter_NodeReplacerTest_test_conditionalExpression_2
- implements NodeReplacerTest_Getter<ConditionalExpression, Expression> {
- @override
- Expression get(ConditionalExpression node) => node.thenExpression;
-}
-
-class Getter_NodeReplacerTest_test_conditionalExpression_3
- implements NodeReplacerTest_Getter<ConditionalExpression, Expression> {
- @override
- Expression get(ConditionalExpression node) => node.condition;
-}
-
-class Getter_NodeReplacerTest_test_constructorDeclaration
- implements
- NodeReplacerTest_Getter<ConstructorDeclaration, ConstructorName> {
- @override
- ConstructorName? get(ConstructorDeclaration node) =>
- node.redirectedConstructor;
-}
-
-class Getter_NodeReplacerTest_test_constructorDeclaration_2
- implements
- NodeReplacerTest_Getter<ConstructorDeclaration, SimpleIdentifier> {
- @override
- SimpleIdentifier? get(ConstructorDeclaration node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_constructorDeclaration_3
- implements NodeReplacerTest_Getter<ConstructorDeclaration, Identifier> {
- @override
- Identifier get(ConstructorDeclaration node) => node.returnType;
-}
-
-class Getter_NodeReplacerTest_test_constructorDeclaration_4
- implements
- NodeReplacerTest_Getter<ConstructorDeclaration, FormalParameterList> {
- @override
- FormalParameterList get(ConstructorDeclaration node) => node.parameters;
-}
-
-class Getter_NodeReplacerTest_test_constructorDeclaration_5
- implements NodeReplacerTest_Getter<ConstructorDeclaration, FunctionBody> {
- @override
- FunctionBody? get(ConstructorDeclaration node) => node.body;
-}
-
-class Getter_NodeReplacerTest_test_constructorFieldInitializer
- implements
- NodeReplacerTest_Getter<ConstructorFieldInitializer, SimpleIdentifier> {
- @override
- SimpleIdentifier get(ConstructorFieldInitializer node) => node.fieldName;
-}
-
-class Getter_NodeReplacerTest_test_constructorFieldInitializer_2
- implements
- NodeReplacerTest_Getter<ConstructorFieldInitializer, Expression> {
- @override
- Expression get(ConstructorFieldInitializer node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_constructorName
- implements NodeReplacerTest_Getter<ConstructorName, NamedType> {
- @override
- NamedType get(ConstructorName node) => node.type2;
-}
-
-class Getter_NodeReplacerTest_test_constructorName_2
- implements NodeReplacerTest_Getter<ConstructorName, SimpleIdentifier> {
- @override
- SimpleIdentifier? get(ConstructorName node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_continueStatement
- implements NodeReplacerTest_Getter<ContinueStatement, SimpleIdentifier> {
- @override
- SimpleIdentifier? get(ContinueStatement node) => node.label;
-}
-
-class Getter_NodeReplacerTest_test_declaredIdentifier
- implements NodeReplacerTest_Getter<DeclaredIdentifier, TypeAnnotation> {
- @override
- TypeAnnotation? get(DeclaredIdentifier node) => node.type;
-}
-
-class Getter_NodeReplacerTest_test_declaredIdentifier_2
- implements NodeReplacerTest_Getter<DeclaredIdentifier, SimpleIdentifier> {
- @override
- SimpleIdentifier get(DeclaredIdentifier node) => node.identifier;
-}
-
-class Getter_NodeReplacerTest_test_defaultFormalParameter
- implements
- NodeReplacerTest_Getter<DefaultFormalParameter, NormalFormalParameter> {
- @override
- NormalFormalParameter get(DefaultFormalParameter node) => node.parameter;
-}
-
-class Getter_NodeReplacerTest_test_defaultFormalParameter_2
- implements NodeReplacerTest_Getter<DefaultFormalParameter, Expression> {
- @override
- Expression? get(DefaultFormalParameter node) => node.defaultValue;
-}
-
-class Getter_NodeReplacerTest_test_doStatement
- implements NodeReplacerTest_Getter<DoStatement, Expression> {
- @override
- Expression get(DoStatement node) => node.condition;
-}
-
-class Getter_NodeReplacerTest_test_doStatement_2
- implements NodeReplacerTest_Getter<DoStatement, Statement> {
- @override
- Statement get(DoStatement node) => node.body;
-}
-
-class Getter_NodeReplacerTest_test_enumConstantDeclaration
- implements
- NodeReplacerTest_Getter<EnumConstantDeclaration, SimpleIdentifier> {
- @override
- SimpleIdentifier get(EnumConstantDeclaration node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_enumDeclaration
- implements NodeReplacerTest_Getter<EnumDeclaration, SimpleIdentifier> {
- @override
- SimpleIdentifier get(EnumDeclaration node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_expressionFunctionBody
- implements NodeReplacerTest_Getter<ExpressionFunctionBody, Expression> {
- @override
- Expression get(ExpressionFunctionBody node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_expressionStatement
- implements NodeReplacerTest_Getter<ExpressionStatement, Expression> {
- @override
- Expression get(ExpressionStatement node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_extendsClause
- implements NodeReplacerTest_Getter<ExtendsClause, NamedType> {
- @override
- NamedType get(ExtendsClause node) => node.superclass2;
-}
-
-class Getter_NodeReplacerTest_test_fieldDeclaration
- implements
- NodeReplacerTest_Getter<FieldDeclaration, VariableDeclarationList> {
- @override
- VariableDeclarationList get(FieldDeclaration node) => node.fields;
-}
-
-class Getter_NodeReplacerTest_test_fieldFormalParameter
- implements
- NodeReplacerTest_Getter<FieldFormalParameter, FormalParameterList> {
- @override
- FormalParameterList? get(FieldFormalParameter node) => node.parameters;
-}
-
-class Getter_NodeReplacerTest_test_fieldFormalParameter_2
- implements NodeReplacerTest_Getter<FieldFormalParameter, TypeAnnotation> {
- @override
- TypeAnnotation? get(FieldFormalParameter node) => node.type;
-}
-
-class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier
- implements NodeReplacerTest_Getter<ForStatement, Statement> {
- @override
- Statement get(ForStatement node) => node.body;
-}
-
-class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_2
- implements NodeReplacerTest_Getter<ForStatement, SimpleIdentifier> {
- @override
- SimpleIdentifier get(ForStatement node) =>
- (node.forLoopParts as ForEachPartsWithIdentifier).identifier;
-}
-
-class Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_3
- implements NodeReplacerTest_Getter<ForStatement, Expression> {
- @override
- Expression get(ForStatement node) =>
- (node.forLoopParts as ForEachParts).iterable;
-}
-
-class Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable
- implements NodeReplacerTest_Getter<ForStatement, Expression> {
- @override
- Expression get(ForStatement node) =>
- (node.forLoopParts as ForEachParts).iterable;
-}
-
-class Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_2
- implements NodeReplacerTest_Getter<ForStatement, DeclaredIdentifier> {
- @override
- DeclaredIdentifier get(ForStatement node) =>
- (node.forLoopParts as ForEachPartsWithDeclaration).loopVariable;
-}
-
-class Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_3
- implements NodeReplacerTest_Getter<ForStatement, Statement> {
- @override
- Statement get(ForStatement node) => node.body;
-}
-
-class Getter_NodeReplacerTest_test_forStatement_withInitialization
- implements NodeReplacerTest_Getter<ForStatement, Statement> {
- @override
- Statement get(ForStatement node) => node.body;
-}
-
-class Getter_NodeReplacerTest_test_forStatement_withInitialization_2
- implements NodeReplacerTest_Getter<ForStatement, Expression> {
- @override
- Expression? get(ForStatement node) =>
- (node.forLoopParts as ForParts).condition;
-}
-
-class Getter_NodeReplacerTest_test_forStatement_withInitialization_3
- implements NodeReplacerTest_Getter<ForStatement, Expression> {
- @override
- Expression? get(ForStatement node) =>
- (node.forLoopParts as ForPartsWithExpression).initialization;
-}
-
-class Getter_NodeReplacerTest_test_forStatement_withVariables
- implements NodeReplacerTest_Getter<ForStatement, Statement> {
- @override
- Statement get(ForStatement node) => node.body;
-}
-
-class Getter_NodeReplacerTest_test_forStatement_withVariables_2
- implements NodeReplacerTest_Getter<ForStatement, VariableDeclarationList> {
- @override
- VariableDeclarationList get(ForStatement node) =>
- (node.forLoopParts as ForPartsWithDeclarations).variables;
-}
-
-class Getter_NodeReplacerTest_test_forStatement_withVariables_3
- implements NodeReplacerTest_Getter<ForStatement, Expression> {
- @override
- Expression? get(ForStatement node) =>
- (node.forLoopParts as ForParts).condition;
-}
-
-class Getter_NodeReplacerTest_test_functionDeclaration
- implements NodeReplacerTest_Getter<FunctionDeclaration, TypeAnnotation> {
- @override
- TypeAnnotation? get(FunctionDeclaration node) => node.returnType;
-}
-
-class Getter_NodeReplacerTest_test_functionDeclaration_2
- implements
- NodeReplacerTest_Getter<FunctionDeclaration, FunctionExpression> {
- @override
- FunctionExpression get(FunctionDeclaration node) => node.functionExpression;
-}
-
-class Getter_NodeReplacerTest_test_functionDeclaration_3
- implements NodeReplacerTest_Getter<FunctionDeclaration, SimpleIdentifier> {
- @override
- SimpleIdentifier get(FunctionDeclaration node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_functionDeclarationStatement
- implements
- NodeReplacerTest_Getter<FunctionDeclarationStatement,
- FunctionDeclaration> {
- @override
- FunctionDeclaration get(FunctionDeclarationStatement node) =>
- node.functionDeclaration;
-}
-
-class Getter_NodeReplacerTest_test_functionExpression
- implements
- NodeReplacerTest_Getter<FunctionExpression, FormalParameterList> {
- @override
- FormalParameterList? get(FunctionExpression node) => node.parameters;
-}
-
-class Getter_NodeReplacerTest_test_functionExpression_2
- implements NodeReplacerTest_Getter<FunctionExpression, FunctionBody> {
- @override
- FunctionBody? get(FunctionExpression node) => node.body;
-}
-
-class Getter_NodeReplacerTest_test_functionExpressionInvocation
- implements
- NodeReplacerTest_Getter<FunctionExpressionInvocation, Expression> {
- @override
- Expression get(FunctionExpressionInvocation node) => node.function;
-}
-
-class Getter_NodeReplacerTest_test_functionExpressionInvocation_2
- implements
- NodeReplacerTest_Getter<FunctionExpressionInvocation, ArgumentList> {
- @override
- ArgumentList get(FunctionExpressionInvocation node) => node.argumentList;
-}
-
-class Getter_NodeReplacerTest_test_functionTypeAlias
- implements NodeReplacerTest_Getter<FunctionTypeAlias, TypeParameterList> {
- @override
- TypeParameterList? get(FunctionTypeAlias node) => node.typeParameters;
-}
-
-class Getter_NodeReplacerTest_test_functionTypeAlias_2
- implements NodeReplacerTest_Getter<FunctionTypeAlias, FormalParameterList> {
- @override
- FormalParameterList get(FunctionTypeAlias node) => node.parameters;
-}
-
-class Getter_NodeReplacerTest_test_functionTypeAlias_3
- implements NodeReplacerTest_Getter<FunctionTypeAlias, TypeAnnotation> {
- @override
- TypeAnnotation? get(FunctionTypeAlias node) => node.returnType;
-}
-
-class Getter_NodeReplacerTest_test_functionTypeAlias_4
- implements NodeReplacerTest_Getter<FunctionTypeAlias, SimpleIdentifier> {
- @override
- SimpleIdentifier get(FunctionTypeAlias node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_functionTypedFormalParameter
- implements
- NodeReplacerTest_Getter<FunctionTypedFormalParameter, TypeAnnotation> {
- @override
- TypeAnnotation? get(FunctionTypedFormalParameter node) => node.returnType;
-}
-
-class Getter_NodeReplacerTest_test_functionTypedFormalParameter_2
- implements
- NodeReplacerTest_Getter<FunctionTypedFormalParameter,
- FormalParameterList> {
- @override
- FormalParameterList get(FunctionTypedFormalParameter node) => node.parameters;
-}
-
-class Getter_NodeReplacerTest_test_ifStatement
- implements NodeReplacerTest_Getter<IfStatement, Expression> {
- @override
- Expression get(IfStatement node) => node.condition;
-}
-
-class Getter_NodeReplacerTest_test_ifStatement_2
- implements NodeReplacerTest_Getter<IfStatement, Statement> {
- @override
- Statement? get(IfStatement node) => node.elseStatement;
-}
-
-class Getter_NodeReplacerTest_test_ifStatement_3
- implements NodeReplacerTest_Getter<IfStatement, Statement> {
- @override
- Statement get(IfStatement node) => node.thenStatement;
-}
-
-class Getter_NodeReplacerTest_test_importDirective
- implements NodeReplacerTest_Getter<ImportDirective, SimpleIdentifier> {
- @override
- SimpleIdentifier? get(ImportDirective node) => node.prefix;
-}
-
-class Getter_NodeReplacerTest_test_indexExpression
- implements NodeReplacerTest_Getter<IndexExpression, Expression> {
- @override
- Expression? get(IndexExpression node) => node.target;
-}
-
-class Getter_NodeReplacerTest_test_indexExpression_2
- implements NodeReplacerTest_Getter<IndexExpression, Expression> {
- @override
- Expression get(IndexExpression node) => node.index;
-}
-
-class Getter_NodeReplacerTest_test_instanceCreationExpression
- implements
- NodeReplacerTest_Getter<InstanceCreationExpression, ArgumentList> {
- @override
- ArgumentList get(InstanceCreationExpression node) => node.argumentList;
-}
-
-class Getter_NodeReplacerTest_test_instanceCreationExpression_2
- implements
- NodeReplacerTest_Getter<InstanceCreationExpression, ConstructorName> {
- @override
- ConstructorName get(InstanceCreationExpression node) => node.constructorName;
-}
-
-class Getter_NodeReplacerTest_test_interpolationExpression
- implements NodeReplacerTest_Getter<InterpolationExpression, Expression> {
- @override
- Expression get(InterpolationExpression node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_isExpression
- implements NodeReplacerTest_Getter<IsExpression, Expression> {
- @override
- Expression get(IsExpression node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_isExpression_2
- implements NodeReplacerTest_Getter<IsExpression, TypeAnnotation> {
- @override
- TypeAnnotation? get(IsExpression node) => node.type;
-}
-
-class Getter_NodeReplacerTest_test_label
- implements NodeReplacerTest_Getter<Label, SimpleIdentifier> {
- @override
- SimpleIdentifier get(Label node) => node.label;
-}
-
-class Getter_NodeReplacerTest_test_labeledStatement
- implements NodeReplacerTest_Getter<LabeledStatement, Statement> {
- @override
- Statement get(LabeledStatement node) => node.statement;
-}
-
-class Getter_NodeReplacerTest_test_libraryDirective
- implements NodeReplacerTest_Getter<LibraryDirective, LibraryIdentifier> {
- @override
- LibraryIdentifier get(LibraryDirective node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_mapLiteralEntry
- implements NodeReplacerTest_Getter<MapLiteralEntry, Expression> {
- @override
- Expression get(MapLiteralEntry node) => node.value;
-}
-
-class Getter_NodeReplacerTest_test_mapLiteralEntry_2
- implements NodeReplacerTest_Getter<MapLiteralEntry, Expression> {
- @override
- Expression get(MapLiteralEntry node) => node.key;
-}
-
-class Getter_NodeReplacerTest_test_methodDeclaration
- implements NodeReplacerTest_Getter<MethodDeclaration, TypeAnnotation> {
- @override
- TypeAnnotation? get(MethodDeclaration node) => node.returnType;
-}
-
-class Getter_NodeReplacerTest_test_methodDeclaration_2
- implements NodeReplacerTest_Getter<MethodDeclaration, FunctionBody> {
- @override
- FunctionBody get(MethodDeclaration node) => node.body;
-}
-
-class Getter_NodeReplacerTest_test_methodDeclaration_3
- implements NodeReplacerTest_Getter<MethodDeclaration, SimpleIdentifier> {
- @override
- SimpleIdentifier get(MethodDeclaration node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_methodDeclaration_4
- implements NodeReplacerTest_Getter<MethodDeclaration, FormalParameterList> {
- @override
- FormalParameterList? get(MethodDeclaration node) => node.parameters;
-}
-
-class Getter_NodeReplacerTest_test_methodInvocation
- implements NodeReplacerTest_Getter<MethodInvocation, ArgumentList> {
- @override
- ArgumentList get(MethodInvocation node) => node.argumentList;
-}
-
-class Getter_NodeReplacerTest_test_methodInvocation_2
- implements NodeReplacerTest_Getter<MethodInvocation, Expression> {
- @override
- Expression? get(MethodInvocation node) => node.target;
-}
-
-class Getter_NodeReplacerTest_test_methodInvocation_3
- implements NodeReplacerTest_Getter<MethodInvocation, SimpleIdentifier> {
- @override
- SimpleIdentifier get(MethodInvocation node) => node.methodName;
-}
-
-class Getter_NodeReplacerTest_test_namedExpression
- implements NodeReplacerTest_Getter<NamedExpression, Label> {
- @override
- Label get(NamedExpression node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_namedExpression_2
- implements NodeReplacerTest_Getter<NamedExpression, Expression> {
- @override
- Expression get(NamedExpression node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_nativeClause
- implements NodeReplacerTest_Getter<NativeClause, StringLiteral> {
- @override
- StringLiteral? get(NativeClause node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_nativeFunctionBody
- implements NodeReplacerTest_Getter<NativeFunctionBody, StringLiteral> {
- @override
- StringLiteral? get(NativeFunctionBody node) => node.stringLiteral;
-}
-
-class Getter_NodeReplacerTest_test_parenthesizedExpression
- implements NodeReplacerTest_Getter<ParenthesizedExpression, Expression> {
- @override
- Expression get(ParenthesizedExpression node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_partOfDirective
- implements NodeReplacerTest_Getter<PartOfDirective, LibraryIdentifier> {
- @override
- LibraryIdentifier? get(PartOfDirective node) => node.libraryName;
-}
-
-class Getter_NodeReplacerTest_test_postfixExpression
- implements NodeReplacerTest_Getter<PostfixExpression, Expression> {
- @override
- Expression get(PostfixExpression node) => node.operand;
-}
-
-class Getter_NodeReplacerTest_test_prefixedIdentifier
- implements NodeReplacerTest_Getter<PrefixedIdentifier, SimpleIdentifier> {
- @override
- SimpleIdentifier get(PrefixedIdentifier node) => node.identifier;
-}
-
-class Getter_NodeReplacerTest_test_prefixedIdentifier_2
- implements NodeReplacerTest_Getter<PrefixedIdentifier, SimpleIdentifier> {
- @override
- SimpleIdentifier get(PrefixedIdentifier node) => node.prefix;
-}
-
-class Getter_NodeReplacerTest_test_prefixExpression
- implements NodeReplacerTest_Getter<PrefixExpression, Expression> {
- @override
- Expression get(PrefixExpression node) => node.operand;
-}
-
-class Getter_NodeReplacerTest_test_propertyAccess
- implements NodeReplacerTest_Getter<PropertyAccess, Expression> {
- @override
- Expression? get(PropertyAccess node) => node.target;
-}
-
-class Getter_NodeReplacerTest_test_propertyAccess_2
- implements NodeReplacerTest_Getter<PropertyAccess, SimpleIdentifier> {
- @override
- SimpleIdentifier get(PropertyAccess node) => node.propertyName;
-}
-
-class Getter_NodeReplacerTest_test_redirectingConstructorInvocation
- implements
- NodeReplacerTest_Getter<RedirectingConstructorInvocation,
- SimpleIdentifier> {
- @override
- SimpleIdentifier? get(RedirectingConstructorInvocation node) =>
- node.constructorName;
-}
-
-class Getter_NodeReplacerTest_test_redirectingConstructorInvocation_2
- implements
- NodeReplacerTest_Getter<RedirectingConstructorInvocation,
- ArgumentList> {
- @override
- ArgumentList get(RedirectingConstructorInvocation node) => node.argumentList;
-}
-
-class Getter_NodeReplacerTest_test_returnStatement
- implements NodeReplacerTest_Getter<ReturnStatement, Expression> {
- @override
- Expression? get(ReturnStatement node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_simpleFormalParameter
- implements NodeReplacerTest_Getter<SimpleFormalParameter, TypeAnnotation> {
- @override
- TypeAnnotation? get(SimpleFormalParameter node) => node.type;
-}
-
-class Getter_NodeReplacerTest_test_superConstructorInvocation
- implements
- NodeReplacerTest_Getter<SuperConstructorInvocation, SimpleIdentifier> {
- @override
- SimpleIdentifier? get(SuperConstructorInvocation node) =>
- node.constructorName;
-}
-
-class Getter_NodeReplacerTest_test_superConstructorInvocation_2
- implements
- NodeReplacerTest_Getter<SuperConstructorInvocation, ArgumentList> {
- @override
- ArgumentList get(SuperConstructorInvocation node) => node.argumentList;
-}
-
-class Getter_NodeReplacerTest_test_switchCase
- implements NodeReplacerTest_Getter<SwitchCase, Expression> {
- @override
- Expression get(SwitchCase node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_switchStatement
- implements NodeReplacerTest_Getter<SwitchStatement, Expression> {
- @override
- Expression get(SwitchStatement node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_throwExpression
- implements NodeReplacerTest_Getter<ThrowExpression, Expression> {
- @override
- Expression get(ThrowExpression node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_test_topLevelVariableDeclaration
- implements
- NodeReplacerTest_Getter<TopLevelVariableDeclaration,
- VariableDeclarationList> {
- @override
- VariableDeclarationList get(TopLevelVariableDeclaration node) =>
- node.variables;
-}
-
-class Getter_NodeReplacerTest_test_tryStatement
- implements NodeReplacerTest_Getter<TryStatement, Block> {
- @override
- Block? get(TryStatement node) => node.finallyBlock;
-}
-
-class Getter_NodeReplacerTest_test_tryStatement_2
- implements NodeReplacerTest_Getter<TryStatement, Block> {
- @override
- Block get(TryStatement node) => node.body;
-}
-
-class Getter_NodeReplacerTest_test_typeName
- implements NodeReplacerTest_Getter<NamedType, TypeArgumentList> {
- @override
- TypeArgumentList? get(NamedType node) => node.typeArguments;
-}
-
-class Getter_NodeReplacerTest_test_typeName_2
- implements NodeReplacerTest_Getter<NamedType, Identifier> {
- @override
- Identifier get(NamedType node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_typeParameter
- implements NodeReplacerTest_Getter<TypeParameter, TypeAnnotation> {
- @override
- TypeAnnotation? get(TypeParameter node) => node.bound;
-}
-
-class Getter_NodeReplacerTest_test_typeParameter_2
- implements NodeReplacerTest_Getter<TypeParameter, SimpleIdentifier> {
- @override
- SimpleIdentifier get(TypeParameter node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_variableDeclaration
- implements NodeReplacerTest_Getter<VariableDeclaration, SimpleIdentifier> {
- @override
- SimpleIdentifier get(VariableDeclaration node) => node.name;
-}
-
-class Getter_NodeReplacerTest_test_variableDeclaration_2
- implements NodeReplacerTest_Getter<VariableDeclaration, Expression> {
- @override
- Expression? get(VariableDeclaration node) => node.initializer;
-}
-
-class Getter_NodeReplacerTest_test_variableDeclarationList
- implements
- NodeReplacerTest_Getter<VariableDeclarationList, TypeAnnotation> {
- @override
- TypeAnnotation? get(VariableDeclarationList node) => node.type;
-}
-
-class Getter_NodeReplacerTest_test_variableDeclarationStatement
- implements
- NodeReplacerTest_Getter<VariableDeclarationStatement,
- VariableDeclarationList> {
- @override
- VariableDeclarationList get(VariableDeclarationStatement node) =>
- node.variables;
-}
-
-class Getter_NodeReplacerTest_test_whileStatement
- implements NodeReplacerTest_Getter<WhileStatement, Expression> {
- @override
- Expression get(WhileStatement node) => node.condition;
-}
-
-class Getter_NodeReplacerTest_test_whileStatement_2
- implements NodeReplacerTest_Getter<WhileStatement, Statement> {
- @override
- Statement get(WhileStatement node) => node.body;
-}
-
-class Getter_NodeReplacerTest_test_yieldStatement
- implements NodeReplacerTest_Getter<YieldStatement, Expression> {
- @override
- Expression get(YieldStatement node) => node.expression;
-}
-
-class Getter_NodeReplacerTest_testAnnotatedNode
- implements NodeReplacerTest_Getter<AnnotatedNode, Comment> {
- @override
- Comment? get(AnnotatedNode node) => node.documentationComment;
-}
-
-class Getter_NodeReplacerTest_testNormalFormalParameter
- implements
- NodeReplacerTest_Getter<NormalFormalParameter, SimpleIdentifier> {
- @override
- SimpleIdentifier? get(NormalFormalParameter node) => node.identifier;
-}
-
-class Getter_NodeReplacerTest_testNormalFormalParameter_2
- implements NodeReplacerTest_Getter<NormalFormalParameter, Comment> {
- @override
- Comment? get(NormalFormalParameter node) => node.documentationComment;
-}
-
-class Getter_NodeReplacerTest_testTypedLiteral
- implements NodeReplacerTest_Getter<TypedLiteral, TypeArgumentList> {
- @override
- TypeArgumentList? get(TypedLiteral node) => node.typeArguments;
-}
-
-class Getter_NodeReplacerTest_testUriBasedDirective
- implements NodeReplacerTest_Getter<UriBasedDirective, StringLiteral> {
- @override
- StringLiteral get(UriBasedDirective node) => node.uri;
-}
-
@reflectiveTest
class LineInfoTest {
void test_creation() {
@@ -1097,379 +178,212 @@
}
}
-class ListGetter_NodeReplacerTest_test_adjacentStrings
- extends NodeReplacerTest_ListGetter<AdjacentStrings, StringLiteral> {
- ListGetter_NodeReplacerTest_test_adjacentStrings(int arg0) : super(arg0);
-
- @override
- NodeList<StringLiteral> getList(AdjacentStrings node) => node.strings;
-}
-
-class ListGetter_NodeReplacerTest_test_adjacentStrings_2
- extends NodeReplacerTest_ListGetter<AdjacentStrings, StringLiteral> {
- ListGetter_NodeReplacerTest_test_adjacentStrings_2(int arg0) : super(arg0);
-
- @override
- NodeList<StringLiteral> getList(AdjacentStrings node) => node.strings;
-}
-
-class ListGetter_NodeReplacerTest_test_argumentList
- extends NodeReplacerTest_ListGetter<ArgumentList, Expression> {
- ListGetter_NodeReplacerTest_test_argumentList(int arg0) : super(arg0);
-
- @override
- NodeList<Expression> getList(ArgumentList node) => node.arguments;
-}
-
-class ListGetter_NodeReplacerTest_test_block
- extends NodeReplacerTest_ListGetter<Block, Statement> {
- ListGetter_NodeReplacerTest_test_block(int arg0) : super(arg0);
-
- @override
- NodeList<Statement> getList(Block node) => node.statements;
-}
-
-class ListGetter_NodeReplacerTest_test_cascadeExpression
- extends NodeReplacerTest_ListGetter<CascadeExpression, Expression> {
- ListGetter_NodeReplacerTest_test_cascadeExpression(int arg0) : super(arg0);
-
- @override
- NodeList<Expression> getList(CascadeExpression node) => node.cascadeSections;
-}
-
-class ListGetter_NodeReplacerTest_test_classDeclaration
- extends NodeReplacerTest_ListGetter<ClassDeclaration, ClassMember> {
- ListGetter_NodeReplacerTest_test_classDeclaration(int arg0) : super(arg0);
-
- @override
- NodeList<ClassMember> getList(ClassDeclaration node) => node.members;
-}
-
-class ListGetter_NodeReplacerTest_test_comment
- extends NodeReplacerTest_ListGetter<Comment, CommentReference> {
- ListGetter_NodeReplacerTest_test_comment(int arg0) : super(arg0);
-
- @override
- NodeList<CommentReference> getList(Comment node) => node.references;
-}
-
-class ListGetter_NodeReplacerTest_test_compilationUnit
- extends NodeReplacerTest_ListGetter<CompilationUnit, Directive> {
- ListGetter_NodeReplacerTest_test_compilationUnit(int arg0) : super(arg0);
-
- @override
- NodeList<Directive> getList(CompilationUnit node) => node.directives;
-}
-
-class ListGetter_NodeReplacerTest_test_compilationUnit_2
- extends NodeReplacerTest_ListGetter<CompilationUnit,
- CompilationUnitMember> {
- ListGetter_NodeReplacerTest_test_compilationUnit_2(int arg0) : super(arg0);
-
- @override
- NodeList<CompilationUnitMember> getList(CompilationUnit node) =>
- node.declarations;
-}
-
-class ListGetter_NodeReplacerTest_test_constructorDeclaration
- extends NodeReplacerTest_ListGetter<ConstructorDeclaration,
- ConstructorInitializer> {
- ListGetter_NodeReplacerTest_test_constructorDeclaration(int arg0)
- : super(arg0);
-
- @override
- NodeList<ConstructorInitializer> getList(ConstructorDeclaration node) =>
- node.initializers;
-}
-
-class ListGetter_NodeReplacerTest_test_formalParameterList
- extends NodeReplacerTest_ListGetter<FormalParameterList, FormalParameter> {
- ListGetter_NodeReplacerTest_test_formalParameterList(int arg0) : super(arg0);
-
- @override
- NodeList<FormalParameter> getList(FormalParameterList node) =>
- node.parameters;
-}
-
-class ListGetter_NodeReplacerTest_test_forStatement_withInitialization
- extends NodeReplacerTest_ListGetter<ForStatement, Expression> {
- ListGetter_NodeReplacerTest_test_forStatement_withInitialization(int arg0)
- : super(arg0);
-
- @override
- NodeList<Expression> getList(ForStatement node) =>
- (node.forLoopParts as ForParts).updaters;
-}
-
-class ListGetter_NodeReplacerTest_test_forStatement_withVariables
- extends NodeReplacerTest_ListGetter<ForStatement, Expression> {
- ListGetter_NodeReplacerTest_test_forStatement_withVariables(int arg0)
- : super(arg0);
-
- @override
- NodeList<Expression> getList(ForStatement node) =>
- (node.forLoopParts as ForParts).updaters;
-}
-
-class ListGetter_NodeReplacerTest_test_hideCombinator
- extends NodeReplacerTest_ListGetter<HideCombinator, SimpleIdentifier> {
- ListGetter_NodeReplacerTest_test_hideCombinator(int arg0) : super(arg0);
-
- @override
- NodeList<SimpleIdentifier> getList(HideCombinator node) => node.hiddenNames;
-}
-
-class ListGetter_NodeReplacerTest_test_implementsClause
- extends NodeReplacerTest_ListGetter<ImplementsClause, NamedType> {
- ListGetter_NodeReplacerTest_test_implementsClause(int arg0) : super(arg0);
-
- @override
- NodeList<NamedType> getList(ImplementsClause node) => node.interfaces2;
-}
-
-class ListGetter_NodeReplacerTest_test_labeledStatement
- extends NodeReplacerTest_ListGetter<LabeledStatement, Label> {
- ListGetter_NodeReplacerTest_test_labeledStatement(int arg0) : super(arg0);
-
- @override
- NodeList<Label> getList(LabeledStatement node) => node.labels;
-}
-
-class ListGetter_NodeReplacerTest_test_libraryIdentifier
- extends NodeReplacerTest_ListGetter<LibraryIdentifier, SimpleIdentifier> {
- ListGetter_NodeReplacerTest_test_libraryIdentifier(int arg0) : super(arg0);
-
- @override
- NodeList<SimpleIdentifier> getList(LibraryIdentifier node) => node.components;
-}
-
-class ListGetter_NodeReplacerTest_test_listLiteral
- extends NodeReplacerTest_ListGetter<ListLiteral, CollectionElement> {
- ListGetter_NodeReplacerTest_test_listLiteral(int arg0) : super(arg0);
-
- @override
- NodeList<CollectionElement> getList(ListLiteral node) => node.elements;
-}
-
-class ListGetter_NodeReplacerTest_test_mapLiteral
- extends NodeReplacerTest_ListGetter<SetOrMapLiteral, CollectionElement> {
- ListGetter_NodeReplacerTest_test_mapLiteral(int arg0) : super(arg0);
-
- @override
- NodeList<CollectionElement> getList(SetOrMapLiteral node) => node.elements;
-}
-
-class ListGetter_NodeReplacerTest_test_showCombinator
- extends NodeReplacerTest_ListGetter<ShowCombinator, SimpleIdentifier> {
- ListGetter_NodeReplacerTest_test_showCombinator(int arg0) : super(arg0);
-
- @override
- NodeList<SimpleIdentifier> getList(ShowCombinator node) => node.shownNames;
-}
-
-class ListGetter_NodeReplacerTest_test_stringInterpolation
- extends NodeReplacerTest_ListGetter<StringInterpolation,
- InterpolationElement> {
- ListGetter_NodeReplacerTest_test_stringInterpolation(int arg0) : super(arg0);
-
- @override
- NodeList<InterpolationElement> getList(StringInterpolation node) =>
- node.elements;
-}
-
-class ListGetter_NodeReplacerTest_test_switchStatement
- extends NodeReplacerTest_ListGetter<SwitchStatement, SwitchMember> {
- ListGetter_NodeReplacerTest_test_switchStatement(int arg0) : super(arg0);
-
- @override
- NodeList<SwitchMember> getList(SwitchStatement node) => node.members;
-}
-
-class ListGetter_NodeReplacerTest_test_tryStatement
- extends NodeReplacerTest_ListGetter<TryStatement, CatchClause> {
- ListGetter_NodeReplacerTest_test_tryStatement(int arg0) : super(arg0);
-
- @override
- NodeList<CatchClause> getList(TryStatement node) => node.catchClauses;
-}
-
-class ListGetter_NodeReplacerTest_test_typeArgumentList
- extends NodeReplacerTest_ListGetter<TypeArgumentList, TypeAnnotation> {
- ListGetter_NodeReplacerTest_test_typeArgumentList(int arg0) : super(arg0);
-
- @override
- NodeList<TypeAnnotation> getList(TypeArgumentList node) => node.arguments;
-}
-
-class ListGetter_NodeReplacerTest_test_typeParameterList
- extends NodeReplacerTest_ListGetter<TypeParameterList, TypeParameter> {
- ListGetter_NodeReplacerTest_test_typeParameterList(int arg0) : super(arg0);
-
- @override
- NodeList<TypeParameter> getList(TypeParameterList node) =>
- node.typeParameters;
-}
-
-class ListGetter_NodeReplacerTest_test_variableDeclarationList
- extends NodeReplacerTest_ListGetter<VariableDeclarationList,
- VariableDeclaration> {
- ListGetter_NodeReplacerTest_test_variableDeclarationList(int arg0)
- : super(arg0);
-
- @override
- NodeList<VariableDeclaration> getList(VariableDeclarationList node) =>
- node.variables;
-}
-
-class ListGetter_NodeReplacerTest_test_withClause
- extends NodeReplacerTest_ListGetter<WithClause, NamedType> {
- ListGetter_NodeReplacerTest_test_withClause(int arg0) : super(arg0);
-
- @override
- NodeList<NamedType> getList(WithClause node) => node.mixinTypes2;
-}
-
-class ListGetter_NodeReplacerTest_testAnnotatedNode
- extends NodeReplacerTest_ListGetter<AnnotatedNode, Annotation> {
- ListGetter_NodeReplacerTest_testAnnotatedNode(int arg0) : super(arg0);
-
- @override
- NodeList<Annotation> getList(AnnotatedNode node) => node.metadata;
-}
-
-class ListGetter_NodeReplacerTest_testNamespaceDirective
- extends NodeReplacerTest_ListGetter<NamespaceDirective, Combinator> {
- ListGetter_NodeReplacerTest_testNamespaceDirective(int arg0) : super(arg0);
-
- @override
- NodeList<Combinator> getList(NamespaceDirective node) => node.combinators;
-}
-
-class ListGetter_NodeReplacerTest_testNormalFormalParameter
- extends NodeReplacerTest_ListGetter<NormalFormalParameter, Annotation> {
- ListGetter_NodeReplacerTest_testNormalFormalParameter(int arg0) : super(arg0);
-
- @override
- NodeList<Annotation> getList(NormalFormalParameter node) => node.metadata;
-}
-
-class ListGetter_NodeReplacerTest_testSwitchMember
- extends NodeReplacerTest_ListGetter<SwitchMember, Label> {
- ListGetter_NodeReplacerTest_testSwitchMember(int arg0) : super(arg0);
-
- @override
- NodeList<Label> getList(SwitchMember node) => node.labels;
-}
-
-class ListGetter_NodeReplacerTest_testSwitchMember_2
- extends NodeReplacerTest_ListGetter<SwitchMember, Statement> {
- ListGetter_NodeReplacerTest_testSwitchMember_2(int arg0) : super(arg0);
-
- @override
- NodeList<Statement> getList(SwitchMember node) => node.statements;
-}
-
@reflectiveTest
class NodeReplacerTest {
- /// An empty list of tokens.
- static const List<Token> EMPTY_TOKEN_LIST = <Token>[];
-
void test_adjacentStrings() {
- AdjacentStrings node = AstTestFactory.adjacentStrings(
- [AstTestFactory.string2("a"), AstTestFactory.string2("b")]);
- _assertReplace(node, ListGetter_NodeReplacerTest_test_adjacentStrings_2(0));
- _assertReplace(node, ListGetter_NodeReplacerTest_test_adjacentStrings(1));
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ 'aaa' 'bbb';
+}
+''');
+ var adjacentStrings = findNode.adjacentStrings('aaa');
+ _assertReplaceInList(
+ destination: adjacentStrings,
+ child: adjacentStrings.strings[0],
+ replacement: adjacentStrings.strings[1],
+ );
}
void test_annotation() {
- Annotation node = AstTestFactory.annotation2(
- AstTestFactory.identifier3("C"),
- AstTestFactory.identifier3("c"),
- AstTestFactory.argumentList([AstTestFactory.integer(0)]));
- _assertReplace(node, Getter_NodeReplacerTest_test_annotation());
- _assertReplace(node, Getter_NodeReplacerTest_test_annotation_3());
- _assertReplace(node, Getter_NodeReplacerTest_test_annotation_2());
- }
-
- void test_annotation_generic() {
- Annotation node = AstTestFactory.annotation2(
- AstTestFactory.identifier3("C"),
- AstTestFactory.identifier3("c"),
- AstTestFactory.argumentList([AstTestFactory.integer(0)]),
- typeArguments:
- AstTestFactory.typeArgumentList2([AstTestFactory.namedType4('T')]));
- _assertReplace(node, Getter_NodeReplacerTest_test_annotation());
- _assertReplace(node, Getter_NodeReplacerTest_test_annotation_3());
- _assertReplace(node, Getter_NodeReplacerTest_test_annotation_2());
+ var findNode = _parseStringToFindNode(r'''
+@prefix.A<int>.named(args)
+@prefix.B<double>.named(args)
+void f() {}
+''');
+ _assertReplacementForChildren<Annotation>(
+ destination: findNode.annotation('prefix.A'),
+ source: findNode.annotation('prefix.B'),
+ childAccessors: [
+ (node) => node.arguments!,
+ (node) => node.constructorName!,
+ (node) => node.name,
+ (node) => node.typeArguments!,
+ ],
+ );
}
void test_argumentList() {
- ArgumentList node =
- AstTestFactory.argumentList([AstTestFactory.integer(0)]);
- _assertReplace(node, ListGetter_NodeReplacerTest_test_argumentList(0));
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ g(0, 1);
+}
+''');
+ var argumentList = findNode.argumentList('(0, 1)');
+ _assertReplaceInList(
+ destination: argumentList,
+ child: argumentList.arguments[0],
+ replacement: argumentList.arguments[1],
+ );
}
void test_asExpression() {
- AsExpression node = AstTestFactory.asExpression(
- AstTestFactory.integer(0),
- AstTestFactory.namedType3(
- AstTestFactory.identifier3("a"), [AstTestFactory.namedType4("C")]));
- _assertReplace(node, Getter_NodeReplacerTest_test_asExpression_2());
- _assertReplace(node, Getter_NodeReplacerTest_test_asExpression());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ 0 as int;
+ 1 as int;
+}
+''');
+ _assertReplacementForChildren<AsExpression>(
+ destination: findNode.as_('0 as'),
+ source: findNode.as_('1 as'),
+ childAccessors: [
+ (node) => node.expression,
+ (node) => node.type,
+ ],
+ );
}
void test_assertStatement() {
- AssertStatement node = AstTestFactory.assertStatement(
- AstTestFactory.booleanLiteral(true), AstTestFactory.string2('foo'));
- _assertReplace(node, Getter_NodeReplacerTest_test_assertStatement());
- _assertReplace(node, Getter_NodeReplacerTest_test_assertStatement_2());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ assert(true, 'first');
+ assert(true, 'second');
+}
+''');
+ _assertReplacementForChildren<AssertStatement>(
+ destination: findNode.assertStatement('first'),
+ source: findNode.assertStatement('second'),
+ childAccessors: [
+ (node) => node.condition,
+ (node) => node.message!,
+ ],
+ );
}
void test_assignmentExpression() {
- AssignmentExpression node = AstTestFactory.assignmentExpression(
- AstTestFactory.identifier3("l"),
- TokenType.EQ,
- AstTestFactory.identifier3("r"));
- _assertReplace(node, Getter_NodeReplacerTest_test_assignmentExpression_2());
- _assertReplace(node, Getter_NodeReplacerTest_test_assignmentExpression());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ a = 0;
+ b = 1;
+}
+''');
+ _assertReplacementForChildren<AssignmentExpression>(
+ destination: findNode.assignment('a ='),
+ source: findNode.assignment('b ='),
+ childAccessors: [
+ (node) => node.leftHandSide,
+ (node) => node.rightHandSide,
+ ],
+ );
}
void test_awaitExpression() {
- var node = AstTestFactory.awaitExpression(AstTestFactory.identifier3("A"));
- _assertReplace(node, Getter_NodeReplacerTest_test_awaitExpression());
+ var findNode = _parseStringToFindNode(r'''
+void f() async {
+ await 0;
+ await 1;
+}
+''');
+ _assertReplacementForChildren<AwaitExpression>(
+ destination: findNode.awaitExpression('0'),
+ source: findNode.awaitExpression('1'),
+ childAccessors: [
+ (node) => node.expression,
+ ],
+ );
}
void test_binaryExpression() {
- BinaryExpression node = AstTestFactory.binaryExpression(
- AstTestFactory.identifier3("l"),
- TokenType.PLUS,
- AstTestFactory.identifier3("r"));
- _assertReplace(node, Getter_NodeReplacerTest_test_binaryExpression());
- _assertReplace(node, Getter_NodeReplacerTest_test_binaryExpression_2());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ 0 + 1;
+ 1 + 2;
+}
+''');
+ _assertReplacementForChildren<BinaryExpression>(
+ destination: findNode.binary('0 + 1'),
+ source: findNode.binary('1 + 2'),
+ childAccessors: [
+ (node) => node.leftOperand,
+ (node) => node.rightOperand,
+ ],
+ );
}
void test_block() {
- Block node = AstTestFactory.block([AstTestFactory.emptyStatement()]);
- _assertReplace(node, ListGetter_NodeReplacerTest_test_block(0));
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ print(0);
+ print(1);
+}
+''');
+ var block = findNode.block('{');
+ _assertReplaceInList(
+ destination: block,
+ child: block.statements[0],
+ replacement: block.statements[1],
+ );
}
void test_blockFunctionBody() {
- BlockFunctionBody node =
- AstTestFactory.blockFunctionBody(AstTestFactory.block());
- _assertReplace(node, Getter_NodeReplacerTest_test_blockFunctionBody());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ print('fff');
+}
+
+void g() {
+ print('ggg');
+}
+''');
+ _assertReplacementForChildren<BlockFunctionBody>(
+ destination: findNode.blockFunctionBody('fff'),
+ source: findNode.blockFunctionBody('ggg'),
+ childAccessors: [
+ (node) => node.block,
+ (node) => node.block,
+ ],
+ );
}
void test_breakStatement() {
- BreakStatement node = AstTestFactory.breakStatement2("l");
- _assertReplace(node, Getter_NodeReplacerTest_test_breakStatement());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ while (true) {
+ break first;
+ break second;
+ }
+}
+''');
+ _assertReplacementForChildren<BreakStatement>(
+ destination: findNode.breakStatement('first'),
+ source: findNode.breakStatement('second'),
+ childAccessors: [
+ (node) => node.label!,
+ ],
+ );
}
void test_cascadeExpression() {
- CascadeExpression node = AstTestFactory.cascadeExpression(
- AstTestFactory.integer(0),
- [AstTestFactory.propertyAccess(null, AstTestFactory.identifier3("b"))]);
- _assertReplace(node, Getter_NodeReplacerTest_test_cascadeExpression());
- _assertReplace(node, ListGetter_NodeReplacerTest_test_cascadeExpression(0));
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ 0..foo..bar;
+ 1..foo;
+}
+''');
+ var cascadeExpression = findNode.cascade('0');
+ _assertReplaceInList(
+ destination: cascadeExpression,
+ child: cascadeExpression.cascadeSections[0],
+ replacement: cascadeExpression.cascadeSections[1],
+ );
+
+ _assertReplacementForChildren<CascadeExpression>(
+ destination: findNode.cascade('0'),
+ source: findNode.cascade('1'),
+ childAccessors: [
+ (node) => node.target,
+ ],
+ );
}
void test_catchClause() {
@@ -1479,10 +393,10 @@
try {} on E2 catch (e2, st2) {}
}
''');
- _assertReplace2<CatchClause>(
+ _assertReplacementForChildren<CatchClause>(
destination: findNode.catchClause('(e,'),
source: findNode.catchClause('(e2,'),
- getters: [
+ childAccessors: [
(node) => node.exceptionType!,
(node) => node.exceptionParameter!,
(node) => node.stackTraceParameter!,
@@ -1492,173 +406,292 @@
}
void test_classDeclaration() {
- var node = AstTestFactory.classDeclaration(
- null,
- "A",
- AstTestFactory.typeParameterList(["E"]),
- AstTestFactory.extendsClause(AstTestFactory.namedType4("B")),
- AstTestFactory.withClause([AstTestFactory.namedType4("C")]),
- AstTestFactory.implementsClause([AstTestFactory.namedType4("D")]), [
- AstTestFactory.fieldDeclaration2(
- false, null, [AstTestFactory.variableDeclaration("f")])
- ]);
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- node.nativeClause = AstTestFactory.nativeClause("");
- _assertReplace(node, Getter_NodeReplacerTest_test_classDeclaration_6());
- _assertReplace(node, Getter_NodeReplacerTest_test_classDeclaration_5());
- _assertReplace(node, Getter_NodeReplacerTest_test_classDeclaration_4());
- _assertReplace(node, Getter_NodeReplacerTest_test_classDeclaration_2());
- _assertReplace(node, Getter_NodeReplacerTest_test_classDeclaration());
- _assertReplace(node, Getter_NodeReplacerTest_test_classDeclaration_3());
- _assertReplace(node, ListGetter_NodeReplacerTest_test_classDeclaration(0));
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+/// Comment A.
+@myA1
+@myA2
+class A<T> extends A0 with M implements I {
+ void foo() {}
+ void bar() {}
+}
+
+/// Comment B.
+class B<U> extends B0 with N implements J {}
+''');
+ var A = findNode.classDeclaration('A<T>');
+ _assertAnnotatedNode(A);
+ _assertReplaceInList(
+ destination: A,
+ child: A.members[0],
+ replacement: A.members[1],
+ );
+ _assertReplacementForChildren<ClassDeclaration>(
+ destination: findNode.classDeclaration('A<T>'),
+ source: findNode.classDeclaration('B<U>'),
+ childAccessors: [
+ (node) => node.documentationComment!,
+ (node) => node.extendsClause!,
+ (node) => node.implementsClause!,
+ (node) => node.name,
+ (node) => node.typeParameters!,
+ (node) => node.withClause!,
+ ],
+ );
}
void test_classTypeAlias() {
- var node = AstTestFactory.classTypeAlias(
- "A",
- AstTestFactory.typeParameterList(["E"]),
- null,
- AstTestFactory.namedType4("B"),
- AstTestFactory.withClause([AstTestFactory.namedType4("C")]),
- AstTestFactory.implementsClause([AstTestFactory.namedType4("D")]));
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _assertReplace(node, Getter_NodeReplacerTest_test_classTypeAlias_4());
- _assertReplace(node, Getter_NodeReplacerTest_test_classTypeAlias_5());
- _assertReplace(node, Getter_NodeReplacerTest_test_classTypeAlias());
- _assertReplace(node, Getter_NodeReplacerTest_test_classTypeAlias_3());
- _assertReplace(node, Getter_NodeReplacerTest_test_classTypeAlias_2());
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+/// Comment A.
+@myA1
+@myA2
+class A<T> = A0 with M implements I;
+
+/// Comment B.
+class B<U> = B0 with N implements J;
+''');
+ _assertAnnotatedNode(
+ findNode.classTypeAlias('A<T>'),
+ );
+ _assertReplacementForChildren<ClassTypeAlias>(
+ destination: findNode.classTypeAlias('A<T>'),
+ source: findNode.classTypeAlias('B<U>'),
+ childAccessors: [
+ (node) => node.documentationComment!,
+ (node) => node.superclass2,
+ (node) => node.implementsClause!,
+ (node) => node.name,
+ (node) => node.typeParameters!,
+ (node) => node.withClause,
+ ],
+ );
}
void test_comment() {
- Comment node = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.references.add(
- astFactory.commentReference(null, AstTestFactory.identifier3("x")));
- _assertReplace(node, ListGetter_NodeReplacerTest_test_comment(0));
+ var findNode = _parseStringToFindNode(r'''
+/// Has [foo] and [bar].
+void f() {}
+''');
+ var comment = findNode.comment('Has');
+ _assertReplaceInList(
+ destination: comment,
+ child: comment.references[0],
+ replacement: comment.references[1],
+ );
}
void test_commentReference() {
- CommentReference node =
- astFactory.commentReference(null, AstTestFactory.identifier3("x"));
- _assertReplace(node, Getter_NodeReplacerTest_test_commentReference());
+ var findNode = _parseStringToFindNode(r'''
+/// Has [foo] and [bar].
+void f() {}
+''');
+ _assertReplacementForChildren<CommentReference>(
+ destination: findNode.commentReference('foo'),
+ source: findNode.commentReference('bar'),
+ childAccessors: [
+ (node) => node.expression,
+ ],
+ );
}
void test_compilationUnit() {
- CompilationUnit node = AstTestFactory.compilationUnit8("", [
- AstTestFactory.libraryDirective2("lib")
- ], [
- AstTestFactory.topLevelVariableDeclaration2(
- null, [AstTestFactory.variableDeclaration("X")])
- ]);
- _assertReplace(node, Getter_NodeReplacerTest_test_compilationUnit());
- _assertReplace(node, ListGetter_NodeReplacerTest_test_compilationUnit(0));
- _assertReplace(node, ListGetter_NodeReplacerTest_test_compilationUnit_2(0));
+ var findNode = _parseStringToFindNode(r'''
+import 'a.dart';
+import 'b.dart';
+class A {}
+class B {}
+''');
+ var unit = findNode.unit;
+ _assertReplaceInList(
+ destination: unit,
+ child: unit.directives[0],
+ replacement: unit.directives[1],
+ );
+ _assertReplaceInList(
+ destination: unit,
+ child: unit.declarations[0],
+ replacement: unit.declarations[1],
+ );
}
void test_conditionalExpression() {
- ConditionalExpression node = AstTestFactory.conditionalExpression(
- AstTestFactory.booleanLiteral(true),
- AstTestFactory.integer(0),
- AstTestFactory.integer(1));
- _assertReplace(
- node, Getter_NodeReplacerTest_test_conditionalExpression_3());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_conditionalExpression_2());
- _assertReplace(node, Getter_NodeReplacerTest_test_conditionalExpression());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ true ? 0 : 1;
+ false ? 2 : 3;
+}
+''');
+ _assertReplacementForChildren<ConditionalExpression>(
+ destination: findNode.conditionalExpression('true'),
+ source: findNode.conditionalExpression('false'),
+ childAccessors: [
+ (node) => node.condition,
+ (node) => node.thenExpression,
+ (node) => node.elseExpression,
+ ],
+ );
}
void test_constructorDeclaration() {
- var node = AstTestFactory.constructorDeclaration2(
- null,
- null,
- AstTestFactory.identifier3("C"),
- "d",
- AstTestFactory.formalParameterList(),
- [
- AstTestFactory.constructorFieldInitializer(
- false, "x", AstTestFactory.integer(0))
- ],
- AstTestFactory.emptyFunctionBody());
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- node.redirectedConstructor =
- AstTestFactory.constructorName(AstTestFactory.namedType4("B"), "a");
- _assertReplace(
- node, Getter_NodeReplacerTest_test_constructorDeclaration_3());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_constructorDeclaration_2());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_constructorDeclaration_4());
- _assertReplace(node, Getter_NodeReplacerTest_test_constructorDeclaration());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_constructorDeclaration_5());
- _assertReplace(
- node, ListGetter_NodeReplacerTest_test_constructorDeclaration(0));
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+class A {
+ @myA1
+ @myA2
+ A.named(int a) : b = 0, c = 1;
+}
+
+class B {
+ B.named(int b);
+}
+''');
+ _assertReplacementForChildren<ConstructorDeclaration>(
+ destination: findNode.constructor('A.named'),
+ source: findNode.constructor('B.named'),
+ childAccessors: [
+ (node) => node.body,
+ (node) => node.name!,
+ (node) => node.parameters,
+ (node) => node.returnType,
+ ],
+ );
+ _assertAnnotatedNode(
+ findNode.constructor('A.named'),
+ );
+ }
+
+ void test_constructorDeclaration_redirectedConstructor() {
+ var findNode = _parseStringToFindNode(r'''
+class A {
+ factory A() = R;
+}
+
+class B {
+ factory B() = R;
+}
+''');
+ _assertReplacementForChildren<ConstructorDeclaration>(
+ destination: findNode.constructor('factory A'),
+ source: findNode.constructor('factory B'),
+ childAccessors: [
+ (node) => node.redirectedConstructor!,
+ ],
+ );
}
void test_constructorFieldInitializer() {
- ConstructorFieldInitializer node =
- AstTestFactory.constructorFieldInitializer(
- false, "f", AstTestFactory.integer(0));
- _assertReplace(
- node, Getter_NodeReplacerTest_test_constructorFieldInitializer());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_constructorFieldInitializer_2());
+ var findNode = _parseStringToFindNode(r'''
+class A {
+ A() : a = 0, b = 1;
+}
+''');
+ _assertReplacementForChildren<ConstructorFieldInitializer>(
+ destination: findNode.constructorFieldInitializer('a ='),
+ source: findNode.constructorFieldInitializer('b ='),
+ childAccessors: [
+ (node) => node.fieldName,
+ (node) => node.expression,
+ ],
+ );
}
void test_constructorName() {
- ConstructorName node =
- AstTestFactory.constructorName(AstTestFactory.namedType4("C"), "n");
- _assertReplace(node, Getter_NodeReplacerTest_test_constructorName());
- _assertReplace(node, Getter_NodeReplacerTest_test_constructorName_2());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ new prefix.A.foo();
+ new prefix.B.bar();
+}
+''');
+ _assertReplacementForChildren<ConstructorName>(
+ destination: findNode.constructorName('A.foo'),
+ source: findNode.constructorName('B.bar'),
+ childAccessors: [
+ (node) => node.type2,
+ (node) => node.name!,
+ ],
+ );
}
void test_continueStatement() {
- ContinueStatement node = AstTestFactory.continueStatement("l");
- _assertReplace(node, Getter_NodeReplacerTest_test_continueStatement());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ while (true) {
+ continue first;
+ continue second;
+ }
+}
+''');
+ _assertReplacementForChildren<ContinueStatement>(
+ destination: findNode.continueStatement('first'),
+ source: findNode.continueStatement('second'),
+ childAccessors: [
+ (node) => node.label!,
+ ],
+ );
}
void test_declaredIdentifier() {
- var node =
- AstTestFactory.declaredIdentifier4(AstTestFactory.namedType4("C"), "i");
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _assertReplace(node, Getter_NodeReplacerTest_test_declaredIdentifier());
- _assertReplace(node, Getter_NodeReplacerTest_test_declaredIdentifier_2());
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ for (int i in []) {}
+ for (double j in []) {}
+}
+''');
+ _assertReplacementForChildren<DeclaredIdentifier>(
+ destination: findNode.declaredIdentifier('i in'),
+ source: findNode.declaredIdentifier('j in'),
+ childAccessors: [
+ (node) => node.identifier,
+ (node) => node.type!,
+ ],
+ );
}
void test_defaultFormalParameter() {
- DefaultFormalParameter node = AstTestFactory.positionalFormalParameter(
- AstTestFactory.simpleFormalParameter3("p"), AstTestFactory.integer(0));
- _assertReplace(node, Getter_NodeReplacerTest_test_defaultFormalParameter());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_defaultFormalParameter_2());
+ var findNode = _parseStringToFindNode(r'''
+void f({int a = 0, double b = 1}) {}
+''');
+ _assertReplacementForChildren<DefaultFormalParameter>(
+ destination: findNode.defaultParameter('a ='),
+ source: findNode.defaultParameter('b ='),
+ childAccessors: [
+ (node) => node.parameter,
+ (node) => node.defaultValue!,
+ ],
+ );
}
void test_doStatement() {
- DoStatement node = AstTestFactory.doStatement(
- AstTestFactory.block(), AstTestFactory.booleanLiteral(true));
- _assertReplace(node, Getter_NodeReplacerTest_test_doStatement_2());
- _assertReplace(node, Getter_NodeReplacerTest_test_doStatement());
+ var findNode = _parseStringToFindNode(r'''
+void f({int a = 0, double b = 1}) {}
+''');
+ _assertReplacementForChildren<DefaultFormalParameter>(
+ destination: findNode.defaultParameter('a ='),
+ source: findNode.defaultParameter('b ='),
+ childAccessors: [
+ (node) => node.parameter,
+ (node) => node.defaultValue!,
+ ],
+ );
}
void test_enumConstantDeclaration() {
- EnumConstantDeclaration node = astFactory.enumConstantDeclaration(
- astFactory.endOfLineComment(EMPTY_TOKEN_LIST),
- [AstTestFactory.annotation(AstTestFactory.identifier3("a"))],
- AstTestFactory.identifier3("C"));
- _assertReplace(
- node, Getter_NodeReplacerTest_test_enumConstantDeclaration());
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+enum E {
+ @myA1
+ @myA2
+ aaa,
+ bbb;
+}
+''');
+ _assertAnnotatedNode(
+ findNode.enumConstantDeclaration('aaa'),
+ );
+ _assertReplacementForChildren<EnumConstantDeclaration>(
+ destination: findNode.enumConstantDeclaration('aaa'),
+ source: findNode.enumConstantDeclaration('bbb'),
+ childAccessors: [
+ (node) => node.name,
+ ],
+ );
}
void test_enumDeclaration() {
@@ -1666,10 +699,10 @@
enum E1<T> with M1 implements I1 {one, two}
enum E2<U> with M2 implements I2 {one, two}
''');
- _assertReplace2<EnumDeclaration>(
+ _assertReplacementForChildren<EnumDeclaration>(
destination: findNode.enumDeclaration('enum E1'),
source: findNode.enumDeclaration('enum E2'),
- getters: [
+ childAccessors: [
(node) => node.name,
(node) => node.typeParameters!,
(node) => node.withClause!,
@@ -1703,466 +736,912 @@
}
void test_exportDirective() {
- var node = AstTestFactory.exportDirective2("", [
- AstTestFactory.hideCombinator2(["C"])
- ]);
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _testNamespaceDirective(node);
+ var findNode = _parseStringToFindNode(r'''
+@myA1
+@myA2
+export 'a.dart' hide A show B;
+export 'b.dart';
+''');
+ var export_a = findNode.export('a.dart');
+ _assertAnnotatedNode(export_a);
+ _assertReplaceInList(
+ destination: export_a,
+ child: export_a.combinators[0],
+ replacement: export_a.combinators[1],
+ );
+ _assertReplacementForChildren<ExportDirective>(
+ destination: findNode.export('a.dart'),
+ source: findNode.export('b.dart'),
+ childAccessors: [
+ (node) => node.uri,
+ ],
+ );
}
void test_expressionFunctionBody() {
- ExpressionFunctionBody node =
- AstTestFactory.expressionFunctionBody(AstTestFactory.integer(0));
- _assertReplace(node, Getter_NodeReplacerTest_test_expressionFunctionBody());
+ var findNode = _parseStringToFindNode(r'''
+void f() => 0;
+void g() => 1;
+''');
+ _assertReplacementForChildren<ExpressionFunctionBody>(
+ destination: findNode.expressionFunctionBody('0'),
+ source: findNode.expressionFunctionBody('1'),
+ childAccessors: [
+ (node) => node.expression,
+ ],
+ );
}
void test_expressionStatement() {
- ExpressionStatement node =
- AstTestFactory.expressionStatement(AstTestFactory.integer(0));
- _assertReplace(node, Getter_NodeReplacerTest_test_expressionStatement());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ 0;
+ 1;
+}
+''');
+ _assertReplacementForChildren<ExpressionStatement>(
+ destination: findNode.expressionStatement('0'),
+ source: findNode.expressionStatement('1'),
+ childAccessors: [
+ (node) => node.expression,
+ ],
+ );
}
void test_extendsClause() {
- ExtendsClause node =
- AstTestFactory.extendsClause(AstTestFactory.namedType4("S"));
- _assertReplace(node, Getter_NodeReplacerTest_test_extendsClause());
+ var findNode = _parseStringToFindNode(r'''
+class A extends A0 {}
+class B extends B0 {}
+''');
+ _assertReplacementForChildren<ExtendsClause>(
+ destination: findNode.extendsClause('A0'),
+ source: findNode.extendsClause('B0'),
+ childAccessors: [
+ (node) => node.superclass2,
+ ],
+ );
}
void test_fieldDeclaration() {
- var node = AstTestFactory.fieldDeclaration(
- false,
- null,
- AstTestFactory.namedType4("C"),
- [AstTestFactory.variableDeclaration("c")]);
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _assertReplace(node, Getter_NodeReplacerTest_test_fieldDeclaration());
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+class A {
+ @myA1
+ @myA2
+ int foo = 0;
+ int bar = 0;
+}
+class B extends B0 {}
+''');
+ _assertAnnotatedNode(
+ findNode.fieldDeclaration('foo'),
+ );
+ _assertReplacementForChildren<FieldDeclaration>(
+ destination: findNode.fieldDeclaration('foo'),
+ source: findNode.fieldDeclaration('bar'),
+ childAccessors: [
+ (node) => node.fields,
+ ],
+ );
}
void test_fieldFormalParameter() {
- var node = AstTestFactory.fieldFormalParameter(
- null,
- AstTestFactory.namedType4("C"),
- "f",
- AstTestFactory.formalParameterList());
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata = [
- AstTestFactory.annotation(AstTestFactory.identifier3("a"))
- ];
- _assertReplace(node, Getter_NodeReplacerTest_test_fieldFormalParameter_2());
- _assertReplace(node, Getter_NodeReplacerTest_test_fieldFormalParameter());
- _testNormalFormalParameter(node);
+ var findNode = _parseStringToFindNode(r'''
+class A {
+ A(
+ @myA1
+ @myA2
+ int this.foo<T>(int a),
+ int this.bar<U>(int b),
+ );
+}
+''');
+ var foo = findNode.fieldFormalParameter('foo');
+ _assertFormalParameterMetadata(foo);
+ _assertReplacementForChildren<FieldFormalParameter>(
+ destination: findNode.fieldFormalParameter('foo'),
+ source: findNode.fieldFormalParameter('bar'),
+ childAccessors: [
+ (node) => node.identifier,
+ (node) => node.parameters!,
+ (node) => node.type!,
+ (node) => node.typeParameters!,
+ ],
+ );
+ }
+
+ void test_forEachPartsWithDeclaration() {
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ for (int a in []) {}
+ for (int b in []) {}
+}
+''');
+ _assertReplacementForChildren<ForEachPartsWithDeclaration>(
+ destination: findNode.forEachPartsWithDeclaration('a in'),
+ source: findNode.forEachPartsWithDeclaration('b in'),
+ childAccessors: [
+ (node) => node.loopVariable,
+ (node) => node.iterable,
+ ],
+ );
+ }
+
+ void test_forEachPartsWithIdentifier() {
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ for (a in []) {}
+ for (b in []) {}
+}
+''');
+ _assertReplacementForChildren<ForEachPartsWithIdentifier>(
+ destination: findNode.forEachPartsWithIdentifier('a in'),
+ source: findNode.forEachPartsWithIdentifier('b in'),
+ childAccessors: [
+ (node) => node.identifier,
+ (node) => node.iterable,
+ ],
+ );
}
void test_forEachStatement_withIdentifier() {
- ForStatement node = AstTestFactory.forStatement(
- AstTestFactory.forEachPartsWithIdentifier(
- AstTestFactory.identifier3("i"), AstTestFactory.identifier3("l")),
- AstTestFactory.block());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_2());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_forEachStatement_withIdentifier_3());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_forEachStatement_withIdentifier());
- }
-
- void test_forEachStatement_withLoopVariable() {
- ForStatement node = AstTestFactory.forStatement(
- AstTestFactory.forEachPartsWithDeclaration(
- AstTestFactory.declaredIdentifier3("e"),
- AstTestFactory.identifier3("l")),
- AstTestFactory.block());
- _assertReplace(node,
- Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_2());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable());
- _assertReplace(node,
- Getter_NodeReplacerTest_test_forEachStatement_withLoopVariable_3());
+ var findNode = _parseStringToFindNode(r'''
+void f(int a) {
+ for (a in []) {}
+ for (b in []) {}
+}
+''');
+ _assertReplacementForChildren<ForStatement>(
+ destination: findNode.forStatement('a in'),
+ source: findNode.forStatement('b in'),
+ childAccessors: [
+ (node) => node.body,
+ (node) => node.forLoopParts,
+ ],
+ );
}
void test_formalParameterList() {
- FormalParameterList node = AstTestFactory.formalParameterList(
- [AstTestFactory.simpleFormalParameter3("p")]);
- _assertReplace(
- node, ListGetter_NodeReplacerTest_test_formalParameterList(0));
+ var findNode = _parseStringToFindNode(r'''
+void f(int a, int b) {}
+''');
+ _assertReplaceInList(
+ destination: findNode.formalParameterList('int a'),
+ child: findNode.simpleFormalParameter('int a'),
+ replacement: findNode.simpleFormalParameter('int b'),
+ );
}
- void test_forStatement_withInitialization() {
- ForStatement node = AstTestFactory.forStatement(
- AstTestFactory.forPartsWithExpression(AstTestFactory.identifier3("a"),
- AstTestFactory.booleanLiteral(true), [AstTestFactory.integer(0)]),
- AstTestFactory.block());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_forStatement_withInitialization_3());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_forStatement_withInitialization_2());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_forStatement_withInitialization());
- _assertReplace(node,
- ListGetter_NodeReplacerTest_test_forStatement_withInitialization(0));
+ void test_forPartsWithDeclarations() {
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ for (int i = 0; i < 8; i++, i += 2) {}
+ for (int j = 0; j < 8; j++) {}
+}
+''');
+ var for_i = findNode.forPartsWithDeclarations('i = 0');
+ _assertReplaceInList(
+ destination: for_i,
+ child: for_i.updaters[0],
+ replacement: for_i.updaters[1],
+ );
+ _assertReplacementForChildren<ForPartsWithDeclarations>(
+ destination: for_i,
+ source: findNode.forPartsWithDeclarations('j = 0'),
+ childAccessors: [
+ (node) => node.variables,
+ (node) => node.condition!,
+ ],
+ );
}
- void test_forStatement_withVariables() {
- ForStatement node = AstTestFactory.forStatement(
- AstTestFactory.forPartsWithDeclarations(
- AstTestFactory.variableDeclarationList2(
- null, [AstTestFactory.variableDeclaration("i")]),
- AstTestFactory.booleanLiteral(true),
- [AstTestFactory.integer(0)]),
- AstTestFactory.block());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_forStatement_withVariables_2());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_forStatement_withVariables_3());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_forStatement_withVariables());
- _assertReplace(
- node, ListGetter_NodeReplacerTest_test_forStatement_withVariables(0));
+ void test_forPartsWithExpression() {
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ for (i = 0; i < 8; i++, i += 2) {}
+ for (j = 0; j < 8; j++) {}
+}
+''');
+ var for_i = findNode.forPartsWithExpression('i = 0');
+ _assertReplaceInList(
+ destination: for_i,
+ child: for_i.updaters[0],
+ replacement: for_i.updaters[1],
+ );
+ _assertReplacementForChildren<ForPartsWithExpression>(
+ destination: for_i,
+ source: findNode.forPartsWithExpression('j = 0'),
+ childAccessors: [
+ (node) => node.initialization!,
+ (node) => node.condition!,
+ ],
+ );
}
void test_functionDeclaration() {
- var node = AstTestFactory.functionDeclaration(
- AstTestFactory.namedType4("R"),
- null,
- "f",
- AstTestFactory.functionExpression2(AstTestFactory.formalParameterList(),
- AstTestFactory.blockFunctionBody(AstTestFactory.block())));
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _assertReplace(node, Getter_NodeReplacerTest_test_functionDeclaration());
- _assertReplace(node, Getter_NodeReplacerTest_test_functionDeclaration_3());
- _assertReplace(node, Getter_NodeReplacerTest_test_functionDeclaration_2());
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+@myA1
+@myA2
+int f() => 0;
+double g() => 0;
+''');
+ _assertAnnotatedNode(
+ findNode.functionDeclaration('f()'),
+ );
+ _assertReplacementForChildren<FunctionDeclaration>(
+ destination: findNode.functionDeclaration('f()'),
+ source: findNode.functionDeclaration('g()'),
+ childAccessors: [
+ (node) => node.functionExpression,
+ (node) => node.name,
+ (node) => node.returnType!,
+ ],
+ );
}
void test_functionDeclarationStatement() {
- FunctionDeclarationStatement node =
- AstTestFactory.functionDeclarationStatement(
- AstTestFactory.namedType4("R"),
- null,
- "f",
- AstTestFactory.functionExpression2(
- AstTestFactory.formalParameterList(),
- AstTestFactory.blockFunctionBody(AstTestFactory.block())));
- _assertReplace(
- node, Getter_NodeReplacerTest_test_functionDeclarationStatement());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ void g() {}
+ void h() {}
+}
+''');
+ _assertReplacementForChildren<FunctionDeclarationStatement>(
+ destination: findNode.functionDeclarationStatement('g()'),
+ source: findNode.functionDeclarationStatement('h()'),
+ childAccessors: [
+ (node) => node.functionDeclaration,
+ ],
+ );
}
void test_functionExpression() {
- FunctionExpression node = AstTestFactory.functionExpression2(
- AstTestFactory.formalParameterList(),
- AstTestFactory.blockFunctionBody(AstTestFactory.block()));
- _assertReplace(node, Getter_NodeReplacerTest_test_functionExpression());
- _assertReplace(node, Getter_NodeReplacerTest_test_functionExpression_2());
+ var findNode = _parseStringToFindNode(r'''
+void f<T>(int a) {
+ 0;
+}
+void g<U>(double b) {
+ 1;
+}
+''');
+ _assertReplacementForChildren<FunctionExpression>(
+ destination: findNode.functionExpression('<T>'),
+ source: findNode.functionExpression('<U>'),
+ childAccessors: [
+ (node) => node.body,
+ (node) => node.parameters!,
+ (node) => node.typeParameters!,
+ ],
+ );
}
void test_functionExpressionInvocation() {
- FunctionExpressionInvocation node =
- AstTestFactory.functionExpressionInvocation(
- AstTestFactory.identifier3("f"), [AstTestFactory.integer(0)]);
- _assertReplace(
- node, Getter_NodeReplacerTest_test_functionExpressionInvocation());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_functionExpressionInvocation_2());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ (g)<int>(0);
+ (h)<double>(1);
+}
+''');
+ _assertReplacementForChildren<FunctionExpressionInvocation>(
+ destination: findNode.functionExpressionInvocation('<int>'),
+ source: findNode.functionExpressionInvocation('<double>'),
+ childAccessors: [
+ (node) => node.function,
+ (node) => node.typeArguments!,
+ (node) => node.argumentList,
+ ],
+ );
}
void test_functionTypeAlias() {
- var node = AstTestFactory.typeAlias(
- AstTestFactory.namedType4("R"),
- "F",
- AstTestFactory.typeParameterList(["E"]),
- AstTestFactory.formalParameterList());
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _assertReplace(node, Getter_NodeReplacerTest_test_functionTypeAlias_3());
- _assertReplace(node, Getter_NodeReplacerTest_test_functionTypeAlias_4());
- _assertReplace(node, Getter_NodeReplacerTest_test_functionTypeAlias());
- _assertReplace(node, Getter_NodeReplacerTest_test_functionTypeAlias_2());
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+@myA1
+@myA2
+typedef int F<T>(int a);
+typedef double G<U>(double b);
+''');
+ _assertAnnotatedNode(
+ findNode.functionTypeAlias('int F'),
+ );
+ _assertReplacementForChildren<FunctionTypeAlias>(
+ destination: findNode.functionTypeAlias('int F'),
+ source: findNode.functionTypeAlias('double G'),
+ childAccessors: [
+ (node) => node.name,
+ (node) => node.parameters,
+ (node) => node.returnType!,
+ (node) => node.typeParameters!,
+ ],
+ );
}
void test_functionTypedFormalParameter() {
- var node = AstTestFactory.functionTypedFormalParameter(
- AstTestFactory.namedType4("R"),
- "f",
- [AstTestFactory.simpleFormalParameter3("p")]);
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata = [
- AstTestFactory.annotation(AstTestFactory.identifier3("a"))
- ];
- _assertReplace(
- node, Getter_NodeReplacerTest_test_functionTypedFormalParameter());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_functionTypedFormalParameter_2());
- _testNormalFormalParameter(node);
+ var findNode = _parseStringToFindNode(r'''
+void f(
+ @myA1
+ @myA2
+ int a<T>(int a1),
+ double b<U>(double b2),
+) {}
+''');
+ var a = findNode.functionTypedFormalParameter('a<T>');
+ _assertFormalParameterMetadata(a);
+ _assertReplacementForChildren<FunctionTypedFormalParameter>(
+ destination: findNode.functionTypedFormalParameter('a<T>'),
+ source: findNode.functionTypedFormalParameter('b<U>'),
+ childAccessors: [
+ (node) => node.returnType!,
+ (node) => node.identifier,
+ (node) => node.typeParameters!,
+ (node) => node.parameters,
+ ],
+ );
}
void test_hideCombinator() {
- HideCombinator node = AstTestFactory.hideCombinator2(["A", "B"]);
- _assertReplace(node, ListGetter_NodeReplacerTest_test_hideCombinator(0));
+ var findNode = _parseStringToFindNode(r'''
+import '' hide A, B;
+''');
+ var node = findNode.hideCombinator('hide');
+ _assertReplaceInList(
+ destination: node,
+ child: node.hiddenNames[0],
+ replacement: node.hiddenNames[1],
+ );
}
void test_ifStatement() {
- IfStatement node = AstTestFactory.ifStatement2(
- AstTestFactory.booleanLiteral(true),
- AstTestFactory.block(),
- AstTestFactory.block());
- _assertReplace(node, Getter_NodeReplacerTest_test_ifStatement());
- _assertReplace(node, Getter_NodeReplacerTest_test_ifStatement_3());
- _assertReplace(node, Getter_NodeReplacerTest_test_ifStatement_2());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ if (true) {
+ 0;
+ } else {
+ 1;
+ }
+ if (false) {
+ 2;
+ } else {
+ 3;
+ }
+}
+''');
+ _assertReplacementForChildren<IfStatement>(
+ destination: findNode.ifStatement('true'),
+ source: findNode.ifStatement('false'),
+ childAccessors: [
+ (node) => node.condition,
+ (node) => node.thenStatement,
+ (node) => node.elseStatement!,
+ ],
+ );
}
void test_implementsClause() {
- ImplementsClause node = AstTestFactory.implementsClause(
- [AstTestFactory.namedType4("I"), AstTestFactory.namedType4("J")]);
- _assertReplace(node, ListGetter_NodeReplacerTest_test_implementsClause(0));
+ var findNode = _parseStringToFindNode(r'''
+class A implements I, J {}
+''');
+ var node = findNode.implementsClause('implements');
+ _assertReplaceInList(
+ destination: node,
+ child: node.interfaces2[0],
+ replacement: node.interfaces2[1],
+ );
}
void test_importDirective() {
- var node = AstTestFactory.importDirective3("", "p", [
- AstTestFactory.showCombinator2(["A"]),
- AstTestFactory.hideCombinator2(["B"])
- ]);
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _assertReplace(node, Getter_NodeReplacerTest_test_importDirective());
- _testNamespaceDirective(node);
+ var findNode = _parseStringToFindNode(r'''
+@myA1
+@myA2
+import 'a.dart' hide A show B;
+import 'b.dart';
+''');
+ var import_a = findNode.import('a.dart');
+ _assertAnnotatedNode(import_a);
+ _assertReplaceInList(
+ destination: import_a,
+ child: import_a.combinators[0],
+ replacement: import_a.combinators[1],
+ );
+ _assertReplacementForChildren<ImportDirective>(
+ destination: findNode.import('a.dart'),
+ source: findNode.import('b.dart'),
+ childAccessors: [
+ (node) => node.uri,
+ ],
+ );
}
void test_indexExpression() {
- IndexExpression node = AstTestFactory.indexExpression(
- target: AstTestFactory.identifier3("a"),
- index: AstTestFactory.identifier3("i"),
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ a[0];
+ b[1];
+}
+''');
+ _assertReplacementForChildren<IndexExpression>(
+ destination: findNode.index('[0]'),
+ source: findNode.index('[1]'),
+ childAccessors: [
+ (node) => node.target!,
+ (node) => node.index,
+ ],
);
- _assertReplace(node, Getter_NodeReplacerTest_test_indexExpression());
- _assertReplace(node, Getter_NodeReplacerTest_test_indexExpression_2());
}
void test_instanceCreationExpression() {
- InstanceCreationExpression node =
- AstTestFactory.instanceCreationExpression3(null,
- AstTestFactory.namedType4("C"), "c", [AstTestFactory.integer(2)]);
- _assertReplace(
- node, Getter_NodeReplacerTest_test_instanceCreationExpression_2());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_instanceCreationExpression());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ new A(0);
+ new B(1);
+}
+''');
+ _assertReplacementForChildren<InstanceCreationExpression>(
+ destination: findNode.instanceCreation('A('),
+ source: findNode.instanceCreation('B('),
+ childAccessors: [
+ (node) => node.constructorName,
+ (node) => node.argumentList,
+ ],
+ );
}
void test_interpolationExpression() {
- InterpolationExpression node = AstTestFactory.interpolationExpression2("x");
- _assertReplace(
- node, Getter_NodeReplacerTest_test_interpolationExpression());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ '$foo $bar';
+}
+''');
+ _assertReplacementForChildren<InterpolationExpression>(
+ destination: findNode.interpolationExpression('foo'),
+ source: findNode.interpolationExpression('bar'),
+ childAccessors: [
+ (node) => node.expression,
+ ],
+ );
}
void test_isExpression() {
- IsExpression node = AstTestFactory.isExpression(
- AstTestFactory.identifier3("v"), false, AstTestFactory.namedType4("T"));
- _assertReplace(node, Getter_NodeReplacerTest_test_isExpression());
- _assertReplace(node, Getter_NodeReplacerTest_test_isExpression_2());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ 0 is int;
+ 1 is double;
+}
+''');
+ _assertReplacementForChildren<IsExpression>(
+ destination: findNode.isExpression('0 is'),
+ source: findNode.isExpression('1 is'),
+ childAccessors: [
+ (node) => node.expression,
+ (node) => node.type,
+ ],
+ );
}
void test_label() {
- Label node = AstTestFactory.label2("l");
- _assertReplace(node, Getter_NodeReplacerTest_test_label());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ foo: while (true) {}
+ bar: while (true) {}
+}
+''');
+ _assertReplacementForChildren<Label>(
+ destination: findNode.label('foo:'),
+ source: findNode.label('bar'),
+ childAccessors: [
+ (node) => node.label,
+ ],
+ );
}
void test_labeledStatement() {
- LabeledStatement node = AstTestFactory.labeledStatement(
- [AstTestFactory.label2("l")], AstTestFactory.block());
- _assertReplace(node, ListGetter_NodeReplacerTest_test_labeledStatement(0));
- _assertReplace(node, Getter_NodeReplacerTest_test_labeledStatement());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ foo: bar: 0;
+ baz: 1;
+}
+''');
+ var foo = findNode.labeledStatement('foo');
+ _assertReplaceInList(
+ destination: foo,
+ child: foo.labels[0],
+ replacement: foo.labels[1],
+ );
+ _assertReplacementForChildren<LabeledStatement>(
+ destination: foo,
+ source: findNode.labeledStatement('baz'),
+ childAccessors: [
+ (node) => node.statement,
+ ],
+ );
}
void test_libraryDirective() {
- var node = AstTestFactory.libraryDirective2("lib");
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _assertReplace(node, Getter_NodeReplacerTest_test_libraryDirective());
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+@myA1
+@myA2
+library foo;
+''');
+ var node = findNode.libraryDirective;
+ _assertAnnotatedNode(node);
+ _assertReplacementForChildren<LibraryDirective>(
+ destination: node,
+ source: node,
+ childAccessors: [
+ (node) => node.name,
+ ],
+ );
}
void test_libraryIdentifier() {
- LibraryIdentifier node = AstTestFactory.libraryIdentifier2(["lib"]);
- _assertReplace(node, ListGetter_NodeReplacerTest_test_libraryIdentifier(0));
+ var findNode = _parseStringToFindNode(r'''
+library foo.bar;
+''');
+ var node = findNode.libraryIdentifier('foo');
+ _assertReplaceInList(
+ destination: node,
+ child: node.components[0],
+ replacement: node.components[1],
+ );
}
void test_listLiteral() {
- ListLiteral node = AstTestFactory.listLiteral2(
- null,
- AstTestFactory.typeArgumentList([AstTestFactory.namedType4("E")]),
- [AstTestFactory.identifier3("e")]);
- _assertReplace(node, ListGetter_NodeReplacerTest_test_listLiteral(0));
- _testTypedLiteral(node);
- }
-
- void test_mapLiteral() {
- SetOrMapLiteral node = AstTestFactory.setOrMapLiteral(
- null,
- AstTestFactory.typeArgumentList([AstTestFactory.namedType4("E")]),
- [AstTestFactory.mapLiteralEntry("k", AstTestFactory.identifier3("v"))]);
- _assertReplace(node, ListGetter_NodeReplacerTest_test_mapLiteral(0));
- _testTypedLiteral(node);
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ <int>[0, 1];
+ <double>[];
+}
+''');
+ var node = findNode.listLiteral('[0');
+ _assertReplaceInList(
+ destination: node,
+ child: node.elements[0],
+ replacement: node.elements[1],
+ );
+ _assertReplacementForChildren<ListLiteral>(
+ destination: findNode.listLiteral('<int>'),
+ source: findNode.listLiteral('<double>'),
+ childAccessors: [
+ (node) => node.typeArguments!,
+ ],
+ );
}
void test_mapLiteralEntry() {
- MapLiteralEntry node =
- AstTestFactory.mapLiteralEntry("k", AstTestFactory.identifier3("v"));
- _assertReplace(node, Getter_NodeReplacerTest_test_mapLiteralEntry_2());
- _assertReplace(node, Getter_NodeReplacerTest_test_mapLiteralEntry());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ <int, int>{0: 1, 2: 3};
+}
+''');
+ _assertReplacementForChildren<MapLiteralEntry>(
+ destination: findNode.mapLiteralEntry('0: 1'),
+ source: findNode.mapLiteralEntry('2: 3'),
+ childAccessors: [
+ (node) => node.key,
+ (node) => node.value,
+ ],
+ );
}
void test_methodDeclaration() {
- var node = AstTestFactory.methodDeclaration2(
- null,
- AstTestFactory.namedType4("A"),
- null,
- null,
- AstTestFactory.identifier3("m"),
- AstTestFactory.formalParameterList(),
- AstTestFactory.blockFunctionBody(AstTestFactory.block()));
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _assertReplace(node, Getter_NodeReplacerTest_test_methodDeclaration());
- _assertReplace(node, Getter_NodeReplacerTest_test_methodDeclaration_3());
- _assertReplace(node, Getter_NodeReplacerTest_test_methodDeclaration_4());
- _assertReplace(node, Getter_NodeReplacerTest_test_methodDeclaration_2());
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+class A {
+ @myA1
+ @myA2
+ int foo<T>(int a) {}
+ double bar<U>(double b) {}
+}
+''');
+ var foo = findNode.methodDeclaration('foo');
+ _assertAnnotatedNode(foo);
+ _assertReplacementForChildren<MethodDeclaration>(
+ destination: foo,
+ source: findNode.methodDeclaration('bar'),
+ childAccessors: [
+ (node) => node.returnType!,
+ (node) => node.name,
+ (node) => node.typeParameters!,
+ (node) => node.parameters!,
+ (node) => node.body,
+ ],
+ );
}
void test_methodInvocation() {
- MethodInvocation node = AstTestFactory.methodInvocation(
- AstTestFactory.identifier3("t"), "m", [AstTestFactory.integer(0)]);
- _assertReplace(node, Getter_NodeReplacerTest_test_methodInvocation_2());
- _assertReplace(node, Getter_NodeReplacerTest_test_methodInvocation_3());
- _assertReplace(node, Getter_NodeReplacerTest_test_methodInvocation());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ a.foo<int>(0);
+ b.bar<double>(1);
+}
+''');
+ _assertReplacementForChildren<MethodInvocation>(
+ destination: findNode.methodInvocation('foo'),
+ source: findNode.methodInvocation('bar'),
+ childAccessors: [
+ (node) => node.target!,
+ (node) => node.typeArguments!,
+ (node) => node.argumentList,
+ ],
+ );
}
void test_namedExpression() {
- NamedExpression node =
- AstTestFactory.namedExpression2("l", AstTestFactory.identifier3("v"));
- _assertReplace(node, Getter_NodeReplacerTest_test_namedExpression());
- _assertReplace(node, Getter_NodeReplacerTest_test_namedExpression_2());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ g(foo: 0, bar: 1);
+}
+''');
+ _assertReplacementForChildren<NamedExpression>(
+ destination: findNode.namedExpression('foo'),
+ source: findNode.namedExpression('bar'),
+ childAccessors: [
+ (node) => node.name,
+ (node) => node.expression,
+ ],
+ );
}
void test_nativeClause() {
- NativeClause node = AstTestFactory.nativeClause("");
- _assertReplace(node, Getter_NodeReplacerTest_test_nativeClause());
+ var findNode = _parseStringToFindNode(r'''
+class A native 'foo' {}
+class B native 'bar' {}
+''');
+ _assertReplacementForChildren<NativeClause>(
+ destination: findNode.nativeClause('foo'),
+ source: findNode.nativeClause('bar'),
+ childAccessors: [
+ (node) => node.name!,
+ ],
+ );
}
void test_nativeFunctionBody() {
- NativeFunctionBody node = AstTestFactory.nativeFunctionBody("m");
- _assertReplace(node, Getter_NodeReplacerTest_test_nativeFunctionBody());
+ var findNode = _parseStringToFindNode(r'''
+void f() native 'foo';
+void g() native 'bar';
+''');
+ _assertReplacementForChildren<NativeFunctionBody>(
+ destination: findNode.nativeFunctionBody('foo'),
+ source: findNode.nativeFunctionBody('bar'),
+ childAccessors: [
+ (node) => node.stringLiteral!,
+ ],
+ );
}
void test_parenthesizedExpression() {
- ParenthesizedExpression node =
- AstTestFactory.parenthesizedExpression(AstTestFactory.integer(0));
- _assertReplace(
- node, Getter_NodeReplacerTest_test_parenthesizedExpression());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ (0);
+ (1);
+}
+''');
+ _assertReplacementForChildren<ParenthesizedExpression>(
+ destination: findNode.parenthesized('0'),
+ source: findNode.parenthesized('1'),
+ childAccessors: [
+ (node) => node.expression,
+ ],
+ );
}
void test_partDirective() {
- var node = AstTestFactory.partDirective2("");
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _testUriBasedDirective(node);
+ var findNode = _parseStringToFindNode(r'''
+@myA1
+@myA2
+part 'a.dart';
+part 'b.dart';
+''');
+ var part_a = findNode.part('a.dart');
+ _assertAnnotatedNode(part_a);
+ _assertReplacementForChildren<PartDirective>(
+ destination: findNode.part('a.dart'),
+ source: findNode.part('b.dart'),
+ childAccessors: [
+ (node) => node.uri,
+ ],
+ );
}
void test_partOfDirective() {
- var node = AstTestFactory.partOfDirective(
- AstTestFactory.libraryIdentifier2(["lib"]));
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _assertReplace(node, Getter_NodeReplacerTest_test_partOfDirective());
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+@myA1
+@myA2
+part of 'a.dart';
+''');
+ var partOf_a = findNode.partOf('a.dart');
+ _assertAnnotatedNode(partOf_a);
+ _assertReplacementForChildren<PartOfDirective>(
+ destination: findNode.partOf('a.dart'),
+ source: findNode.partOf('a.dart'),
+ childAccessors: [
+ (node) => node.uri!,
+ ],
+ );
}
void test_postfixExpression() {
- PostfixExpression node = AstTestFactory.postfixExpression(
- AstTestFactory.identifier3("x"), TokenType.MINUS_MINUS);
- _assertReplace(node, Getter_NodeReplacerTest_test_postfixExpression());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ a++;
+ b++;
+}
+''');
+ _assertReplacementForChildren<PostfixExpression>(
+ destination: findNode.postfix('a++'),
+ source: findNode.postfix('b++'),
+ childAccessors: [
+ (node) => node.operand,
+ ],
+ );
}
void test_prefixedIdentifier() {
- PrefixedIdentifier node = AstTestFactory.identifier5("a", "b");
- _assertReplace(node, Getter_NodeReplacerTest_test_prefixedIdentifier_2());
- _assertReplace(node, Getter_NodeReplacerTest_test_prefixedIdentifier());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ a.foo;
+ b.bar;
+}
+''');
+ _assertReplacementForChildren<PrefixedIdentifier>(
+ destination: findNode.prefixed('a.foo'),
+ source: findNode.prefixed('b.bar'),
+ childAccessors: [
+ (node) => node.prefix,
+ (node) => node.identifier,
+ ],
+ );
}
void test_prefixExpression() {
- PrefixExpression node = AstTestFactory.prefixExpression(
- TokenType.PLUS_PLUS, AstTestFactory.identifier3("y"));
- _assertReplace(node, Getter_NodeReplacerTest_test_prefixExpression());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ ++a;
+ ++b;
+}
+''');
+ _assertReplacementForChildren<PrefixExpression>(
+ destination: findNode.prefix('++a'),
+ source: findNode.prefix('++b'),
+ childAccessors: [
+ (node) => node.operand,
+ ],
+ );
}
void test_propertyAccess() {
- PropertyAccess node =
- AstTestFactory.propertyAccess2(AstTestFactory.identifier3("x"), "y");
- _assertReplace(node, Getter_NodeReplacerTest_test_propertyAccess());
- _assertReplace(node, Getter_NodeReplacerTest_test_propertyAccess_2());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ (a).foo;
+ (b).bar;
+}
+''');
+ _assertReplacementForChildren<PropertyAccess>(
+ destination: findNode.propertyAccess('(a)'),
+ source: findNode.propertyAccess('(b)'),
+ childAccessors: [
+ (node) => node.target!,
+ (node) => node.propertyName,
+ ],
+ );
}
void test_redirectingConstructorInvocation() {
- RedirectingConstructorInvocation node =
- AstTestFactory.redirectingConstructorInvocation2(
- "c", [AstTestFactory.integer(0)]);
- _assertReplace(
- node, Getter_NodeReplacerTest_test_redirectingConstructorInvocation());
- _assertReplace(node,
- Getter_NodeReplacerTest_test_redirectingConstructorInvocation_2());
+ var findNode = _parseStringToFindNode(r'''
+class A {
+ A.named();
+ A.foo() : this.named(0);
+ A.bar() : this.named(1);
+}
+''');
+ _assertReplacementForChildren<RedirectingConstructorInvocation>(
+ destination: findNode.redirectingConstructorInvocation('(0)'),
+ source: findNode.redirectingConstructorInvocation('(1)'),
+ childAccessors: [
+ (node) => node.constructorName!,
+ (node) => node.argumentList,
+ ],
+ );
}
void test_returnStatement() {
- ReturnStatement node =
- AstTestFactory.returnStatement2(AstTestFactory.integer(0));
- _assertReplace(node, Getter_NodeReplacerTest_test_returnStatement());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ return 0;
+ return 1;
+}
+''');
+ _assertReplacementForChildren<ReturnStatement>(
+ destination: findNode.returnStatement('0;'),
+ source: findNode.returnStatement('1;'),
+ childAccessors: [
+ (node) => node.expression!,
+ ],
+ );
+ }
+
+ void test_setOrMapLiteral() {
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ <int, int>{0: 1, 2: 3};
+ <double, double>{};
+}
+''');
+ var node = findNode.setOrMapLiteral('<int');
+ _assertReplaceInList(
+ destination: node,
+ child: node.elements[0],
+ replacement: node.elements[1],
+ );
+ _assertReplacementForChildren<SetOrMapLiteral>(
+ destination: findNode.setOrMapLiteral('<int'),
+ source: findNode.setOrMapLiteral('<double'),
+ childAccessors: [
+ (node) => node.typeArguments!,
+ ],
+ );
}
void test_showCombinator() {
- ShowCombinator node = AstTestFactory.showCombinator2(["X", "Y"]);
- _assertReplace(node, ListGetter_NodeReplacerTest_test_showCombinator(0));
+ var findNode = _parseStringToFindNode(r'''
+import '' show A, B;
+''');
+ var node = findNode.showCombinator('show');
+ _assertReplaceInList(
+ destination: node,
+ child: node.shownNames[0],
+ replacement: node.shownNames[1],
+ );
}
void test_simpleFormalParameter() {
- var node = AstTestFactory.simpleFormalParameter4(
- AstTestFactory.namedType4("T"), "p");
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata = [
- AstTestFactory.annotation(AstTestFactory.identifier3("a"))
- ];
- _assertReplace(node, Getter_NodeReplacerTest_test_simpleFormalParameter());
- _testNormalFormalParameter(node);
+ var findNode = _parseStringToFindNode(r'''
+void f(
+ @myA1
+ @myA2
+ int a,
+ int b
+) {}
+''');
+ var a = findNode.simpleFormalParameter('int a');
+ _assertFormalParameterMetadata(a);
+ _assertReplacementForChildren<SimpleFormalParameter>(
+ destination: a,
+ source: findNode.simpleFormalParameter('int b'),
+ childAccessors: [
+ (node) => node.type!,
+ (node) => node.identifier!,
+ ],
+ );
}
void test_stringInterpolation() {
- var unit = parseString(content: 'var v = "first \$x last";').unit;
- var declaration = unit.declarations[0] as TopLevelVariableDeclaration;
- var variable = declaration.variables.variables[0];
- var node = variable.initializer as StringInterpolation;
- _assertReplace(
- node, ListGetter_NodeReplacerTest_test_stringInterpolation(0));
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ 'my $foo other $bar';
+}
+''');
+ var node = findNode.stringInterpolation('foo');
+ _assertReplaceInList(
+ destination: node,
+ child: node.elements[0],
+ replacement: node.elements[1],
+ );
}
void test_superConstructorInvocation() {
- SuperConstructorInvocation node =
- AstTestFactory.superConstructorInvocation2(
- "s", [AstTestFactory.integer(1)]);
- _assertReplace(
- node, Getter_NodeReplacerTest_test_superConstructorInvocation());
- _assertReplace(
- node, Getter_NodeReplacerTest_test_superConstructorInvocation_2());
+ var findNode = _parseStringToFindNode(r'''
+class A {
+ A.foo() : super.first(0);
+ A.bar() : super.second(0);
+}
+''');
+ _assertReplacementForChildren<SuperConstructorInvocation>(
+ destination: findNode.superConstructorInvocation('first'),
+ source: findNode.superConstructorInvocation('second'),
+ childAccessors: [
+ (node) => node.constructorName!,
+ (node) => node.argumentList,
+ ],
+ );
}
@FailingTest(issue: 'https://github.com/dart-lang/sdk/issues/47951')
@@ -2177,10 +1656,10 @@
B.sub2(double super.a2);
}
''');
- _assertReplace2<SuperFormalParameter>(
+ _assertReplacementForChildren<SuperFormalParameter>(
destination: findNode.superFormalParameter('a1'),
source: findNode.superFormalParameter('a2'),
- getters: [
+ childAccessors: [
(node) => node.type!,
(node) => node.identifier,
],
@@ -2199,10 +1678,10 @@
B.sub2(double super.bar2<T2>(int a2),);
}
''');
- _assertReplace2<SuperFormalParameter>(
+ _assertReplacementForChildren<SuperFormalParameter>(
destination: findNode.superFormalParameter('bar1'),
source: findNode.superFormalParameter('bar2'),
- getters: [
+ childAccessors: [
(node) => node.type!,
(node) => node.identifier,
(node) => node.typeParameters!,
@@ -2212,165 +1691,310 @@
}
void test_switchCase() {
- SwitchCase node = AstTestFactory.switchCase2([AstTestFactory.label2("l")],
- AstTestFactory.integer(0), [AstTestFactory.block()]);
- _assertReplace(node, Getter_NodeReplacerTest_test_switchCase());
- _testSwitchMember(node);
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ switch (x) {
+ foo: bar:
+ case 0: 0; 1;
+ case 1: break;
+ }
+}
+''');
+ _assertSwitchMember(
+ findNode.switchCase('case 0'),
+ );
+ _assertReplacementForChildren<SwitchCase>(
+ destination: findNode.switchCase('case 0'),
+ source: findNode.switchCase('case 1'),
+ childAccessors: [
+ (node) => node.expression,
+ ],
+ );
}
void test_switchDefault() {
- SwitchDefault node = AstTestFactory.switchDefault(
- [AstTestFactory.label2("l")], [AstTestFactory.block()]);
- _testSwitchMember(node);
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ switch (x) {
+ foo: bar:
+ default: 0; 1;
+ }
+}
+''');
+ _assertSwitchMember(
+ findNode.switchDefault('default: 0'),
+ );
}
void test_switchStatement() {
- SwitchStatement node =
- AstTestFactory.switchStatement(AstTestFactory.identifier3("x"), [
- AstTestFactory.switchCase2([AstTestFactory.label2("l")],
- AstTestFactory.integer(0), [AstTestFactory.block()]),
- AstTestFactory.switchDefault(
- [AstTestFactory.label2("l")], [AstTestFactory.block()])
- ]);
- _assertReplace(node, Getter_NodeReplacerTest_test_switchStatement());
- _assertReplace(node, ListGetter_NodeReplacerTest_test_switchStatement(0));
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ switch (0) {
+ case 0: break;
+ case 1: break;
+ }
+ switch (1) {}
+}
+''');
+ _assertReplaceInList(
+ destination: findNode.switchStatement('(0)'),
+ child: findNode.switchCase('case 0'),
+ replacement: findNode.switchCase('case 1'),
+ );
+ _assertReplacementForChildren<SwitchStatement>(
+ destination: findNode.switchStatement('(0)'),
+ source: findNode.switchStatement('(1)'),
+ childAccessors: [
+ (node) => node.expression,
+ ],
+ );
}
void test_throwExpression() {
- ThrowExpression node =
- AstTestFactory.throwExpression2(AstTestFactory.identifier3("e"));
- _assertReplace(node, Getter_NodeReplacerTest_test_throwExpression());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ throw 0;
+ throw 1;
+}
+''');
+ _assertReplacementForChildren<ThrowExpression>(
+ destination: findNode.throw_('throw 0'),
+ source: findNode.throw_('throw 1'),
+ childAccessors: [
+ (node) => node.expression,
+ ],
+ );
}
void test_topLevelVariableDeclaration() {
- var node = AstTestFactory.topLevelVariableDeclaration(
- null,
- AstTestFactory.namedType4("T"),
- [AstTestFactory.variableDeclaration("t")]);
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _assertReplace(
- node, Getter_NodeReplacerTest_test_topLevelVariableDeclaration());
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+@myA1
+@myA2
+var a = 0;
+var b = 1;
+''');
+ _assertAnnotatedNode(
+ findNode.topLevelVariableDeclaration('a = 0'),
+ );
+ _assertReplacementForChildren<TopLevelVariableDeclaration>(
+ destination: findNode.topLevelVariableDeclaration('a = 0'),
+ source: findNode.topLevelVariableDeclaration('b = 1'),
+ childAccessors: [
+ (node) => node.variables,
+ ],
+ );
}
void test_tryStatement() {
- TryStatement node = AstTestFactory.tryStatement3(
- AstTestFactory.block(),
- [
- AstTestFactory.catchClause("e", [AstTestFactory.block()])
- ],
- AstTestFactory.block());
- _assertReplace(node, Getter_NodeReplacerTest_test_tryStatement_2());
- _assertReplace(node, Getter_NodeReplacerTest_test_tryStatement());
- _assertReplace(node, ListGetter_NodeReplacerTest_test_tryStatement(0));
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ try { // 0
+ 0;
+ } on E1 {
+ } on E2 {
+ } finally {
+ 1;
+ }
+ try { // 1
+ 2;
+ } finally {
+ 3;
+ }
+}
+''');
+ _assertReplaceInList(
+ destination: findNode.tryStatement('// 0'),
+ child: findNode.catchClause('E1'),
+ replacement: findNode.catchClause('E2'),
+ );
+ _assertReplacementForChildren<TryStatement>(
+ destination: findNode.tryStatement('// 0'),
+ source: findNode.tryStatement('// 1'),
+ childAccessors: [
+ (node) => node.body,
+ (node) => node.finallyBlock!,
+ ],
+ );
}
void test_typeArgumentList() {
- TypeArgumentList node =
- AstTestFactory.typeArgumentList2([AstTestFactory.namedType4("A")]);
- _assertReplace(node, ListGetter_NodeReplacerTest_test_typeArgumentList(0));
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ g<int, double>();
+}
+''');
+ _assertReplaceInList(
+ destination: findNode.typeArgumentList('<int'),
+ child: findNode.namedType('int'),
+ replacement: findNode.namedType('double'),
+ );
}
void test_typeName() {
- NamedType node = AstTestFactory.namedType4(
- "T", [AstTestFactory.namedType4("E"), AstTestFactory.namedType4("F")]);
- _assertReplace(node, Getter_NodeReplacerTest_test_typeName_2());
- _assertReplace(node, Getter_NodeReplacerTest_test_typeName());
+ var findNode = _parseStringToFindNode(r'''
+void f(List<int> a, Set<double> b) {}
+''');
+ _assertReplacementForChildren<NamedType>(
+ destination: findNode.namedType('List<int>'),
+ source: findNode.namedType('Set<double>'),
+ childAccessors: [
+ (node) => node.name,
+ (node) => node.typeArguments!,
+ ],
+ );
}
void test_typeParameter() {
- TypeParameter node =
- AstTestFactory.typeParameter2("E", AstTestFactory.namedType4("B"));
- _assertReplace(node, Getter_NodeReplacerTest_test_typeParameter_2());
- _assertReplace(node, Getter_NodeReplacerTest_test_typeParameter());
+ var findNode = _parseStringToFindNode(r'''
+class A<T extends int, U extends double> {}
+''');
+ _assertReplacementForChildren<TypeParameter>(
+ destination: findNode.typeParameter('T extends'),
+ source: findNode.typeParameter('U extends'),
+ childAccessors: [
+ (node) => node.name,
+ (node) => node.bound!,
+ ],
+ );
}
void test_typeParameterList() {
- TypeParameterList node = AstTestFactory.typeParameterList2(["A", "B"]);
- _assertReplace(node, ListGetter_NodeReplacerTest_test_typeParameterList(0));
+ var findNode = _parseStringToFindNode(r'''
+class A<T, U> {}
+''');
+ var node = findNode.typeParameterList('<T, U>');
+ _assertReplaceInList(
+ destination: node,
+ child: node.typeParameters[0],
+ replacement: node.typeParameters[1],
+ );
}
void test_variableDeclaration() {
- var node =
- AstTestFactory.variableDeclaration2("a", AstTestFactory.nullLiteral());
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _assertReplace(node, Getter_NodeReplacerTest_test_variableDeclaration());
- _assertReplace(node, Getter_NodeReplacerTest_test_variableDeclaration_2());
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ var a = 0;
+ var b = 1;
+}
+''');
+ _assertReplacementForChildren<VariableDeclaration>(
+ destination: findNode.variableDeclaration('a = 0'),
+ source: findNode.variableDeclaration('b = 1'),
+ childAccessors: [
+ (node) => node.name,
+ (node) => node.initializer!,
+ ],
+ );
}
void test_variableDeclarationList() {
- var node = AstTestFactory.variableDeclarationList(
- null,
- AstTestFactory.namedType4("T"),
- [AstTestFactory.variableDeclaration("a")]);
- node.documentationComment = astFactory.endOfLineComment(EMPTY_TOKEN_LIST);
- node.metadata
- .add(AstTestFactory.annotation(AstTestFactory.identifier3("a")));
- _assertReplace(
- node, Getter_NodeReplacerTest_test_variableDeclarationList());
- _assertReplace(
- node, ListGetter_NodeReplacerTest_test_variableDeclarationList(0));
- _testAnnotatedNode(node);
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ int a = 0, b = 1;
+ double c = 2;
+}
+''');
+ _assertReplaceInList(
+ destination: findNode.variableDeclarationList('int a'),
+ child: findNode.variableDeclaration('a = 0'),
+ replacement: findNode.variableDeclaration('b = 1'),
+ );
+ _assertReplacementForChildren<VariableDeclarationList>(
+ destination: findNode.variableDeclarationList('int a'),
+ source: findNode.variableDeclarationList('double c'),
+ childAccessors: [
+ (node) => node.type!,
+ ],
+ );
}
void test_variableDeclarationStatement() {
- VariableDeclarationStatement node =
- AstTestFactory.variableDeclarationStatement(
- null,
- AstTestFactory.namedType4("T"),
- [AstTestFactory.variableDeclaration("a")]);
- _assertReplace(
- node, Getter_NodeReplacerTest_test_variableDeclarationStatement());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ int a = 0;
+ double b = 1;
+}
+''');
+ _assertReplacementForChildren<VariableDeclarationStatement>(
+ destination: findNode.variableDeclarationStatement('int a'),
+ source: findNode.variableDeclarationStatement('double b'),
+ childAccessors: [
+ (node) => node.variables,
+ ],
+ );
}
void test_whileStatement() {
- WhileStatement node = AstTestFactory.whileStatement(
- AstTestFactory.booleanLiteral(true), AstTestFactory.block());
- _assertReplace(node, Getter_NodeReplacerTest_test_whileStatement());
- _assertReplace(node, Getter_NodeReplacerTest_test_whileStatement_2());
+ var findNode = _parseStringToFindNode(r'''
+void f() {
+ while (true) {
+ 0;
+ }
+ while (false) {
+ 1;
+ }
+}
+''');
+ _assertReplacementForChildren<WhileStatement>(
+ destination: findNode.whileStatement('(true)'),
+ source: findNode.whileStatement('(false)'),
+ childAccessors: [
+ (node) => node.condition,
+ (node) => node.body,
+ ],
+ );
}
void test_withClause() {
- WithClause node =
- AstTestFactory.withClause([AstTestFactory.namedType4("M")]);
- _assertReplace(node, ListGetter_NodeReplacerTest_test_withClause(0));
+ var findNode = _parseStringToFindNode(r'''
+class A with M, N {}
+''');
+ var node = findNode.withClause('with');
+ _assertReplaceInList(
+ destination: node,
+ child: node.mixinTypes2[0],
+ replacement: node.mixinTypes2[1],
+ );
}
void test_yieldStatement() {
- var node = AstTestFactory.yieldStatement(AstTestFactory.identifier3("A"));
- _assertReplace(node, Getter_NodeReplacerTest_test_yieldStatement());
+ var findNode = _parseStringToFindNode(r'''
+void f() sync* {
+ yield 0;
+ yield 1;
+}
+''');
+ _assertReplacementForChildren<YieldStatement>(
+ destination: findNode.yieldStatement('yield 0;'),
+ source: findNode.yieldStatement('yield 1'),
+ childAccessors: [
+ (node) => node.expression,
+ ],
+ );
}
- void _assertReplace(AstNode parent, NodeReplacerTest_Getter getter) {
- var child = getter.get(parent);
- if (child != null) {
- NodeReplacer.replace(child, child);
- expect(getter.get(parent), child);
- expect(child.parent, child.parent);
- }
+ /// Asserts that the first annotation can be replaced with the second.
+ /// Expects that [node] has at least 2 annotations.
+ void _assertAnnotatedNode(AnnotatedNode node) {
+ _assertReplaceInList(
+ destination: node,
+ child: node.metadata[0],
+ replacement: node.metadata[1],
+ );
}
- void _assertReplace2<T extends AstNode>({
- required T destination,
- required T source,
- required List<AstNode Function(T node)> getters,
- }) {
- for (var getter in getters) {
- var child = getter(destination);
- expect(child.parent, destination);
-
- var replacement = getter(source);
- NodeReplacer.replace(child, replacement);
- expect(getter(destination), replacement);
- expect(replacement.parent, destination);
- }
+ /// Asserts that the first annotation can be replaced with the second.
+ /// Expects that [node] has at least 2 annotations.
+ void _assertFormalParameterMetadata(FormalParameter node) {
+ _assertReplaceInList(
+ destination: node,
+ child: node.metadata[0],
+ replacement: node.metadata[1],
+ );
}
+ /// Asserts that a [child] node, with parent that is [destination], can
+ /// by replaced with the [replacement], and then its parent is [destination].
void _assertReplaceInList({
required AstNode destination,
required AstNode child,
@@ -2382,6 +2006,40 @@
expect(replacement.parent, destination);
}
+ /// Asserts for each child returned by a function from [childAccessors]
+ /// for [destination] that its parent is actually [destination], and then
+ /// replaces it with a node returned this function for [source]. At the end,
+ /// checks that the function, invoked for [destination] now returns the
+ /// replacement node, and its parent is now [destination].
+ void _assertReplacementForChildren<T extends AstNode>({
+ required T destination,
+ required T source,
+ required List<AstNode Function(T node)> childAccessors,
+ }) {
+ for (var childAccessor in childAccessors) {
+ var child = childAccessor(destination);
+ expect(child.parent, destination);
+
+ var replacement = childAccessor(source);
+ NodeReplacer.replace(child, replacement);
+ expect(childAccessor(destination), replacement);
+ expect(replacement.parent, destination);
+ }
+ }
+
+ void _assertSwitchMember(SwitchMember node) {
+ _assertReplaceInList(
+ destination: node,
+ child: node.labels[0],
+ replacement: node.labels[1],
+ );
+ _assertReplaceInList(
+ destination: node,
+ child: node.statements[0],
+ replacement: node.statements[1],
+ );
+ }
+
FindNode _parseStringToFindNode(String content) {
var parseResult = parseString(
content: content,
@@ -2395,59 +2053,6 @@
);
return FindNode(parseResult.content, parseResult.unit);
}
-
- void _testAnnotatedNode(AnnotatedNode node) {
- _assertReplace(node, Getter_NodeReplacerTest_testAnnotatedNode());
- _assertReplace(node, ListGetter_NodeReplacerTest_testAnnotatedNode(0));
- }
-
- void _testNamespaceDirective(NamespaceDirective node) {
- _assertReplace(node, ListGetter_NodeReplacerTest_testNamespaceDirective(0));
- _testUriBasedDirective(node);
- }
-
- void _testNormalFormalParameter(NormalFormalParameter node) {
- _assertReplace(node, Getter_NodeReplacerTest_testNormalFormalParameter_2());
- _assertReplace(node, Getter_NodeReplacerTest_testNormalFormalParameter());
- _assertReplace(
- node, ListGetter_NodeReplacerTest_testNormalFormalParameter(0));
- }
-
- void _testSwitchMember(SwitchMember node) {
- _assertReplace(node, ListGetter_NodeReplacerTest_testSwitchMember(0));
- _assertReplace(node, ListGetter_NodeReplacerTest_testSwitchMember_2(0));
- }
-
- void _testTypedLiteral(TypedLiteral node) {
- _assertReplace(node, Getter_NodeReplacerTest_testTypedLiteral());
- }
-
- void _testUriBasedDirective(UriBasedDirective node) {
- _assertReplace(node, Getter_NodeReplacerTest_testUriBasedDirective());
- _testAnnotatedNode(node);
- }
-}
-
-abstract class NodeReplacerTest_Getter<P, C extends AstNode> {
- C? get(P parent);
-}
-
-abstract class NodeReplacerTest_ListGetter<P extends AstNode, C extends AstNode>
- implements NodeReplacerTest_Getter<P, C> {
- final int _index;
-
- NodeReplacerTest_ListGetter(this._index);
-
- @override
- C? get(P parent) {
- NodeList<C> list = getList(parent);
- if (list.isEmpty) {
- return null;
- }
- return list[_index];
- }
-
- NodeList<C> getList(P parent);
}
@reflectiveTest
diff --git a/tools/VERSION b/tools/VERSION
index 55cf481..d46a9f8 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 16
PATCH 0
-PRERELEASE 120
+PRERELEASE 121
PRERELEASE_PATCH 0
\ No newline at end of file
