mirror of
https://github.com/dart-lang/sdk
synced 2024-11-02 12:24:24 +00:00
67f33caa5f
Change-Id: I0ef4226d30f923996a29af0d8f22c59c0e52f3a4 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/254464 Commit-Queue: Konstantin Shcheglov <scheglov@google.com> Reviewed-by: Samuel Rawlins <srawlins@google.com>
1717 lines
53 KiB
Dart
1717 lines
53 KiB
Dart
// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
import 'package:analyzer/dart/ast/ast.dart';
|
|
import 'package:analyzer/dart/ast/precedence.dart';
|
|
import 'package:analyzer/dart/ast/token.dart';
|
|
import 'package:analyzer/dart/ast/visitor.dart';
|
|
import 'package:analyzer/source/line_info.dart';
|
|
import 'package:nnbd_migration/src/edit_plan.dart';
|
|
import 'package:nnbd_migration/src/utilities/hint_utils.dart';
|
|
import 'package:test/test.dart';
|
|
import 'package:test_reflective_loader/test_reflective_loader.dart';
|
|
|
|
import 'abstract_single_unit.dart';
|
|
|
|
main() {
|
|
defineReflectiveSuite(() {
|
|
defineReflectiveTests(EditPlanTest);
|
|
defineReflectiveTests(EndsInCascadeTest);
|
|
defineReflectiveTests(PrecedenceTest);
|
|
});
|
|
}
|
|
|
|
@reflectiveTest
|
|
class EditPlanTest extends AbstractSingleUnitTest {
|
|
String? code;
|
|
|
|
EditPlanner? _planner;
|
|
|
|
@override
|
|
bool get analyzeWithNnbd => true;
|
|
|
|
EditPlanner? get planner {
|
|
if (_planner == null) createPlanner();
|
|
return _planner;
|
|
}
|
|
|
|
Future<void> analyze(String code) async {
|
|
this.code = code;
|
|
await resolveTestUnit(code);
|
|
}
|
|
|
|
Map<int?, List<AtomicEdit>> checkPlan(EditPlan plan, String expected,
|
|
{String? expectedIncludingInformative}) {
|
|
expectedIncludingInformative ??= expected;
|
|
var changes = planner!.finalize(plan)!;
|
|
expect(changes.applyTo(code!), expected);
|
|
expect(changes.applyTo(code!, includeInformative: true),
|
|
expectedIncludingInformative);
|
|
return changes;
|
|
}
|
|
|
|
void createPlanner({bool removeViaComments = false}) {
|
|
_planner = EditPlanner(testUnit!.lineInfo, code,
|
|
removeViaComments: removeViaComments);
|
|
}
|
|
|
|
NodeProducingEditPlan extract(AstNode inner, AstNode? outer) =>
|
|
planner!.extract(outer, planner!.passThrough(inner));
|
|
|
|
Future<void> test_acceptLateHint() async {
|
|
var code = '/* late */ int x = 0;';
|
|
await analyze(code);
|
|
var hint = getPrefixHint(findNode.simple('int').token)!;
|
|
var changes = checkPlan(
|
|
planner!.acceptPrefixHint(
|
|
planner!.passThrough(findNode.simple('int')), hint),
|
|
'late int x = 0;');
|
|
expect(changes.keys, unorderedEquals([0, 7]));
|
|
expect(changes[7], hasLength(1));
|
|
expect(changes[7]![0].length, 3);
|
|
}
|
|
|
|
Future<void> test_acceptLateHint_space_needed_after() async {
|
|
var code = '/* late */int x = 0;';
|
|
await analyze(code);
|
|
var hint = getPrefixHint(findNode.simple('int').token)!;
|
|
checkPlan(
|
|
planner!.acceptPrefixHint(
|
|
planner!.passThrough(findNode.simple('int')), hint),
|
|
'late int x = 0;');
|
|
}
|
|
|
|
Future<void> test_acceptLateHint_space_needed_before() async {
|
|
var code = '@deprecated/* late */ int x = 0;';
|
|
await analyze(code);
|
|
var hint = getPrefixHint(findNode.simple('int').token)!;
|
|
checkPlan(
|
|
planner!.acceptPrefixHint(
|
|
planner!.passThrough(findNode.simple('int')), hint),
|
|
'@deprecated late int x = 0;');
|
|
}
|
|
|
|
Future<void>
|
|
test_acceptNullabilityHint_function_typed_field_formal_parameter() async {
|
|
await analyze('''
|
|
class C {
|
|
void Function(int) f;
|
|
C(void this.f(int i) /*?*/);
|
|
}
|
|
''');
|
|
var parameter = findNode.fieldFormalParameter('void this.f(int i)');
|
|
var typeName = planner!.passThrough(parameter);
|
|
checkPlan(
|
|
planner!.acceptSuffixHint(
|
|
typeName, getPostfixHint(parameter.parameters!.rightParenthesis)!),
|
|
'''
|
|
class C {
|
|
void Function(int) f;
|
|
C(void this.f(int i)?);
|
|
}
|
|
''');
|
|
}
|
|
|
|
Future<void> test_acceptNullabilityHint_function_typed_parameter() async {
|
|
await analyze('f(void g(int i) /*?*/) {}');
|
|
var parameter = findNode.functionTypedFormalParameter('void g(int i)');
|
|
var typeName = planner!.passThrough(parameter);
|
|
checkPlan(
|
|
planner!.acceptSuffixHint(
|
|
typeName, getPostfixHint(parameter.parameters.rightParenthesis)!),
|
|
'f(void g(int i)?) {}');
|
|
}
|
|
|
|
Future<void> test_acceptNullabilityOrNullCheckHint() async {
|
|
var code = 'int /*?*/ x = 0;';
|
|
await analyze(code);
|
|
var intRef = findNode.simple('int');
|
|
var typeName = planner!.passThrough(intRef);
|
|
checkPlan(
|
|
planner!.acceptSuffixHint(typeName, getPostfixHint(intRef.token)!),
|
|
'int? x = 0;');
|
|
}
|
|
|
|
Future<void> test_acceptNullabilityOrNullCheckHint_inside_extract() async {
|
|
var code = 'f(x) => 3 * x /*!*/ * 4;';
|
|
await analyze(code);
|
|
var xRef = findNode.simple('x /*');
|
|
checkPlan(
|
|
planner!.extract(
|
|
xRef.parent!.parent,
|
|
planner!.acceptSuffixHint(
|
|
planner!.passThrough(xRef), getPostfixHint(xRef.token)!)),
|
|
'f(x) => x!;');
|
|
}
|
|
|
|
Future<void> test_addBinaryPostfix_assignment_right_associative() async {
|
|
await analyze('_f(a, b, c) => a = b;');
|
|
// Admittedly this is sort of a bogus test case, since the code it produces
|
|
// (`(a = b) = c`) is non-grammatical. But we still want to verify that it
|
|
// *doesn't* produce `a = b = c`, which would be grammatical but which would
|
|
// break apart the subexpression `a = b`.
|
|
checkPlan(
|
|
planner!.addBinaryPostfix(
|
|
planner!.passThrough(findNode.assignment('a = b')),
|
|
TokenType.EQ,
|
|
'c'),
|
|
'_f(a, b, c) => (a = b) = c;');
|
|
}
|
|
|
|
Future<void> test_addBinaryPostfix_associative() async {
|
|
await analyze('var x = 1 - 2;');
|
|
checkPlan(
|
|
planner!.addBinaryPostfix(
|
|
planner!.passThrough(findNode.binary('-')), TokenType.MINUS, '3'),
|
|
'var x = 1 - 2 - 3;');
|
|
}
|
|
|
|
Future<void> test_addBinaryPostfix_endsInCascade() async {
|
|
await analyze('f(x) => x..y = 1;');
|
|
checkPlan(
|
|
planner!.addBinaryPostfix(
|
|
planner!.passThrough(findNode.integerLiteral('1')),
|
|
TokenType.PLUS,
|
|
'2'),
|
|
'f(x) => x..y = 1 + 2;');
|
|
}
|
|
|
|
Future<void> test_addBinaryPostfix_equality_non_associative() async {
|
|
await analyze('var x = 1 == 2;');
|
|
checkPlan(
|
|
planner!.addBinaryPostfix(
|
|
planner!.passThrough(findNode.binary('==')), TokenType.EQ_EQ, '3'),
|
|
'var x = (1 == 2) == 3;');
|
|
}
|
|
|
|
Future<void> test_addBinaryPostfix_inner_precedence() async {
|
|
await analyze('var x = 1 < 2;');
|
|
checkPlan(
|
|
planner!.addBinaryPostfix(planner!.passThrough(findNode.binary('<')),
|
|
TokenType.EQ_EQ, 'true'),
|
|
'var x = 1 < 2 == true;');
|
|
checkPlan(
|
|
planner!.addBinaryPostfix(
|
|
planner!.passThrough(findNode.binary('<')), TokenType.AS, 'bool'),
|
|
'var x = (1 < 2) as bool;');
|
|
}
|
|
|
|
Future<void> test_addBinaryPostfix_outer_precedence() async {
|
|
await analyze('var x = 1 == true;');
|
|
checkPlan(
|
|
planner!.addBinaryPostfix(
|
|
planner!.passThrough(findNode.integerLiteral('1')),
|
|
TokenType.LT,
|
|
'2'),
|
|
'var x = 1 < 2 == true;');
|
|
checkPlan(
|
|
planner!.addBinaryPostfix(
|
|
planner!.passThrough(findNode.integerLiteral('1')),
|
|
TokenType.EQ_EQ,
|
|
'2'),
|
|
'var x = (1 == 2) == true;');
|
|
}
|
|
|
|
Future<void> test_addBinaryPostfix_to_expression_function() async {
|
|
await analyze('var x = () => null;');
|
|
checkPlan(
|
|
planner!.addBinaryPostfix(
|
|
planner!.passThrough(findNode.functionExpression('()')),
|
|
TokenType.AS,
|
|
'Object'),
|
|
'var x = (() => null) as Object;');
|
|
}
|
|
|
|
Future<void> test_addBinaryPrefix_allowCascade() async {
|
|
await analyze('f(x) => 1..isEven;');
|
|
checkPlan(
|
|
planner!.addBinaryPrefix(
|
|
'x..y', TokenType.EQ, planner!.passThrough(findNode.cascade('..'))),
|
|
'f(x) => x..y = (1..isEven);');
|
|
checkPlan(
|
|
planner!.addBinaryPrefix(
|
|
'x', TokenType.EQ, planner!.passThrough(findNode.cascade('..')),
|
|
allowCascade: true),
|
|
'f(x) => x = 1..isEven;');
|
|
}
|
|
|
|
Future<void> test_addBinaryPrefix_assignment_right_associative() async {
|
|
await analyze('_f(a, b, c) => b = c;');
|
|
checkPlan(
|
|
planner!.addBinaryPrefix('a', TokenType.EQ,
|
|
planner!.passThrough(findNode.assignment('b = c'))),
|
|
'_f(a, b, c) => a = b = c;');
|
|
}
|
|
|
|
Future<void> test_addBinaryPrefix_associative() async {
|
|
await analyze('var x = 1 - 2;');
|
|
checkPlan(
|
|
planner!.addBinaryPrefix(
|
|
'0', TokenType.MINUS, planner!.passThrough(findNode.binary('-'))),
|
|
'var x = 0 - (1 - 2);');
|
|
}
|
|
|
|
Future<void> test_addBinaryPrefix_outer_precedence() async {
|
|
await analyze('var x = 2 == true;');
|
|
checkPlan(
|
|
planner!.addBinaryPrefix('1', TokenType.LT,
|
|
planner!.passThrough(findNode.integerLiteral('2'))),
|
|
'var x = 1 < 2 == true;');
|
|
checkPlan(
|
|
planner!.addBinaryPrefix('1', TokenType.EQ_EQ,
|
|
planner!.passThrough(findNode.integerLiteral('2'))),
|
|
'var x = (1 == 2) == true;');
|
|
}
|
|
|
|
Future<void> test_addBinaryPrefix_to_expression_function() async {
|
|
await analyze('f(x) => () => null;');
|
|
checkPlan(
|
|
planner!.addBinaryPrefix('x', TokenType.EQ,
|
|
planner!.passThrough(findNode.functionExpression('()'))),
|
|
'f(x) => x = () => null;');
|
|
}
|
|
|
|
Future<void> test_addCommentPostfix_before_closer() async {
|
|
await analyze('f(g) => g(0);');
|
|
checkPlan(
|
|
planner!.addCommentPostfix(
|
|
planner!.passThrough(findNode.integerLiteral('0')), '/* zero */'),
|
|
'f(g) => g(0 /* zero */);');
|
|
}
|
|
|
|
Future<void> test_addCommentPostfix_before_other() async {
|
|
await analyze('f() => 0.isEven;');
|
|
checkPlan(
|
|
planner!.addCommentPostfix(
|
|
planner!.passThrough(findNode.integerLiteral('0')), '/* zero */'),
|
|
'f() => 0 /* zero */ .isEven;');
|
|
}
|
|
|
|
Future<void> test_addCommentPostfix_before_semicolon() async {
|
|
await analyze('f() => 0;');
|
|
checkPlan(
|
|
planner!.addCommentPostfix(
|
|
planner!.passThrough(findNode.integerLiteral('0')), '/* zero */'),
|
|
'f() => 0 /* zero */;');
|
|
}
|
|
|
|
Future<void> test_addCommentPostfix_before_space() async {
|
|
await analyze('f() => 0 + 1;');
|
|
checkPlan(
|
|
planner!.addCommentPostfix(
|
|
planner!.passThrough(findNode.integerLiteral('0')), '/* zero */'),
|
|
'f() => 0 /* zero */ + 1;');
|
|
}
|
|
|
|
Future<void> test_addCommentPostfix_informative() async {
|
|
await analyze('f() => 0.isEven;');
|
|
checkPlan(
|
|
planner!.addCommentPostfix(
|
|
planner!.passThrough(findNode.integerLiteral('0')), '/* zero */',
|
|
isInformative: true),
|
|
'f() => 0.isEven;',
|
|
expectedIncludingInformative: 'f() => 0 /* zero */ .isEven;');
|
|
}
|
|
|
|
Future<void> test_addPostfix_inner_precedence_add_parens() async {
|
|
await analyze('f(x) => -x;');
|
|
checkPlan(
|
|
planner!
|
|
.addPostfix(planner!.passThrough(findNode.prefix('-x')), '.abs()'),
|
|
'f(x) => (-x).abs();');
|
|
}
|
|
|
|
Future<void> test_addPostfix_inner_precedence_no_parens() async {
|
|
await analyze('f(x) => x++;');
|
|
checkPlan(
|
|
planner!.addPostfix(
|
|
planner!.passThrough(findNode.postfix('x++')), '.abs()'),
|
|
'f(x) => x++.abs();');
|
|
}
|
|
|
|
Future<void> test_addPostfix_outer_precedence() async {
|
|
await analyze('f(x) => x/*!*/;');
|
|
checkPlan(
|
|
planner!.addPostfix(
|
|
planner!.passThrough(findNode.simple('x/*!*/')), '.abs()'),
|
|
'f(x) => x.abs()/*!*/;');
|
|
}
|
|
|
|
Future<void> test_addUnaryPostfix_inner_precedence_add_parens() async {
|
|
await analyze('f(x) => -x;');
|
|
checkPlan(
|
|
planner!.addUnaryPostfix(
|
|
planner!.passThrough(findNode.prefix('-x')), TokenType.BANG),
|
|
'f(x) => (-x)!;');
|
|
}
|
|
|
|
Future<void> test_addUnaryPostfix_inner_precedence_no_parens() async {
|
|
await analyze('f(x) => x++;');
|
|
checkPlan(
|
|
planner!.addUnaryPostfix(
|
|
planner!.passThrough(findNode.postfix('x++')), TokenType.BANG),
|
|
'f(x) => x++!;');
|
|
}
|
|
|
|
Future<void> test_addUnaryPostfix_outer_precedence() async {
|
|
await analyze('f(x) => x/*!*/;');
|
|
checkPlan(
|
|
planner!.addUnaryPostfix(
|
|
planner!.passThrough(findNode.simple('x/*!*/')),
|
|
TokenType.PLUS_PLUS),
|
|
'f(x) => x++/*!*/;');
|
|
}
|
|
|
|
Future<void> test_addUnaryPrefix_inner_precedence_add_parens() async {
|
|
await analyze('f(x, y) => x * y;');
|
|
checkPlan(
|
|
planner!.addUnaryPrefix(
|
|
TokenType.MINUS, planner!.passThrough(findNode.binary('*'))),
|
|
'f(x, y) => -(x * y);');
|
|
}
|
|
|
|
Future<void> test_addUnaryPrefix_inner_precedence_no_parens() async {
|
|
await analyze('f(x) => -x;');
|
|
// TODO(paulberry): if we added a `-` instead of a `~`, the result would
|
|
// scan as a single `--` token, so we would need parens. Add support for
|
|
// this corner case.
|
|
checkPlan(
|
|
planner!.addUnaryPrefix(
|
|
TokenType.TILDE, planner!.passThrough(findNode.prefix('-x'))),
|
|
'f(x) => ~-x;');
|
|
}
|
|
|
|
Future<void> test_addUnaryPrefix_outer_precedence_add_parens() async {
|
|
await analyze('f(x) => x!;');
|
|
checkPlan(
|
|
planner!.addUnaryPrefix(
|
|
TokenType.MINUS, planner!.passThrough(findNode.simple('x!'))),
|
|
'f(x) => (-x)!;');
|
|
}
|
|
|
|
Future<void> test_addUnaryPrefix_outer_precedence_no_parens() async {
|
|
await analyze('f(x) => -x;');
|
|
// TODO(paulberry): if we added a `-` instead of a `~`, the result would
|
|
// scan as a single `--` token, so we would need parens. Add support for
|
|
// this corner case.
|
|
checkPlan(
|
|
planner!.addUnaryPrefix(
|
|
TokenType.TILDE, planner!.passThrough(findNode.simple('x;'))),
|
|
'f(x) => -~x;');
|
|
}
|
|
|
|
Future<void> test_cascadeSearchLimit() async {
|
|
// Ok, we have to ask each parent if it represents a cascade section.
|
|
// If we create a passThrough at node N, then when we create an enclosing
|
|
// passThrough, the first thing we'll check is N's parent.
|
|
await analyze('f(a, c) => a..b = c = 1;');
|
|
var cascade = findNode.cascade('..');
|
|
var outerAssignment = findNode.assignment('= c');
|
|
assert(identical(cascade, outerAssignment.parent));
|
|
var innerAssignment = findNode.assignment('= 1');
|
|
assert(identical(outerAssignment, innerAssignment.parent));
|
|
var one = findNode.integerLiteral('1');
|
|
assert(identical(innerAssignment, one.parent));
|
|
// The tests below will be based on an inner plan that adds `..isEven` after
|
|
// the `1`.
|
|
EditPlan makeInnerPlan() => planner!.surround(planner!.passThrough(one),
|
|
suffix: [AtomicEdit.insert('..isEven')], endsInCascade: true);
|
|
{
|
|
// If we make a plan that passes through `c = 1`, containing a plan that
|
|
// adds `..isEven` to `1`, then we don't necessarily want to add parens yet,
|
|
// because we might not keep the cascade section above it.
|
|
var plan =
|
|
planner!.passThrough(innerAssignment, innerPlans: [makeInnerPlan()]);
|
|
// `endsInCascade` returns true because we haven't committed to adding
|
|
// parens, so we need to remember that the presence of `..isEven` may
|
|
// require parens later.
|
|
expect(plan.endsInCascade, true);
|
|
checkPlan(planner!.extract(cascade, plan), 'f(a, c) => c = 1..isEven;');
|
|
}
|
|
{
|
|
// If we make a plan that passes through `..b = c = 1`, containing a plan
|
|
// that adds `..isEven` to `1`, then we do necessarily want to add parens,
|
|
// because we're committed to keeping the cascade section.
|
|
var plan =
|
|
planner!.passThrough(outerAssignment, innerPlans: [makeInnerPlan()]);
|
|
// We can tell that the parens have been finalized because `endsInCascade`
|
|
// returns false now.
|
|
expect(plan.endsInCascade, false);
|
|
checkPlan(plan, 'f(a, c) => a..b = (c = 1..isEven);');
|
|
}
|
|
}
|
|
|
|
Future<void> test_dropNullabilityHint() async {
|
|
var code = 'int /*!*/ x = 0;';
|
|
await analyze(code);
|
|
var intRef = findNode.simple('int');
|
|
var typeName = planner!.passThrough(intRef);
|
|
checkPlan(
|
|
planner!.dropNullabilityHint(typeName, getPostfixHint(intRef.token)!),
|
|
'int x = 0;');
|
|
}
|
|
|
|
Future<void> test_dropNullabilityHint_space_before_must_be_kept() async {
|
|
var code = 'int /*!*/x = 0;';
|
|
await analyze(code);
|
|
var intRef = findNode.simple('int');
|
|
var typeName = planner!.passThrough(intRef);
|
|
var changes = checkPlan(
|
|
planner!.dropNullabilityHint(typeName, getPostfixHint(intRef.token)!),
|
|
'int x = 0;');
|
|
expect(changes.keys, unorderedEquals([code.indexOf('/*')]));
|
|
}
|
|
|
|
Future<void> test_dropNullabilityHint_space_needed() async {
|
|
var code = 'int/*!*/x = 0;';
|
|
await analyze(code);
|
|
var intRef = findNode.simple('int');
|
|
var typeName = planner!.passThrough(intRef);
|
|
checkPlan(
|
|
planner!.dropNullabilityHint(typeName, getPostfixHint(intRef.token)!),
|
|
'int x = 0;');
|
|
}
|
|
|
|
Future<void> test_dropNullabilityHint_tight_no_space_needed() async {
|
|
// We try to minimize how much we alter the source code, so we don't insert
|
|
// a space in this example even though it would look prettier to do so.
|
|
var code = 'void Function()/*!*/x = () {};';
|
|
await analyze(code);
|
|
var functionType = findNode.genericFunctionType('Function');
|
|
var typeName = planner!.passThrough(functionType);
|
|
checkPlan(
|
|
planner!.dropNullabilityHint(
|
|
typeName, getPostfixHint(functionType.endToken)!),
|
|
'void Function()x = () {};');
|
|
}
|
|
|
|
Future<void> test_explainNonNullable() async {
|
|
await analyze('int x = 0;');
|
|
checkPlan(
|
|
planner!.explainNonNullable(
|
|
planner!.passThrough(findNode.typeAnnotation('int'))),
|
|
'int x = 0;',
|
|
expectedIncludingInformative: 'int x = 0;');
|
|
}
|
|
|
|
Future<void> test_extract_add_parens() async {
|
|
await analyze('f(g) => 1 * g(2, 3 + 4, 5);');
|
|
checkPlan(
|
|
extract(
|
|
findNode.binary('+'), findNode.functionExpressionInvocation('+')),
|
|
'f(g) => 1 * (3 + 4);');
|
|
}
|
|
|
|
Future<void> test_extract_inner_endsInCascade() async {
|
|
await analyze('f(a, g) => a..b = g(0, 1..isEven, 2);');
|
|
expect(
|
|
extract(findNode.cascade('1..isEven'),
|
|
findNode.functionExpressionInvocation('g('))
|
|
.endsInCascade,
|
|
true);
|
|
expect(
|
|
extract(findNode.integerLiteral('1'),
|
|
findNode.functionExpressionInvocation('g('))
|
|
.endsInCascade,
|
|
false);
|
|
}
|
|
|
|
Future<void> test_extract_left() async {
|
|
await analyze('var x = 1 + 2;');
|
|
checkPlan(extract(findNode.integerLiteral('1'), findNode.binary('+')),
|
|
'var x = 1;');
|
|
}
|
|
|
|
Future<void> test_extract_no_parens_needed() async {
|
|
await analyze('var x = 1 + 2 * 3;');
|
|
checkPlan(extract(findNode.integerLiteral('2'), findNode.binary('*')),
|
|
'var x = 1 + 2;');
|
|
}
|
|
|
|
Future<void> test_extract_preserve_parens() async {
|
|
// Note: extra spaces to verify that we are really preserving the parens
|
|
// rather than removing them and adding new ones.
|
|
await analyze('var x = ( 1 << 2 ) * 3 + 4;');
|
|
checkPlan(extract(findNode.binary('<<'), findNode.binary('*')),
|
|
'var x = ( 1 << 2 ) + 4;');
|
|
}
|
|
|
|
Future<void> test_extract_remove_parens() async {
|
|
await analyze('var x = (1 + 2) * 3 << 4;');
|
|
checkPlan(extract(findNode.binary('+'), findNode.binary('*')),
|
|
'var x = 1 + 2 << 4;');
|
|
}
|
|
|
|
Future<void> test_extract_remove_redundant_parens() async {
|
|
await analyze('var x = (1 * 2) + 3;');
|
|
var times = findNode.binary('*');
|
|
checkPlan(extract(times, times.parent), 'var x = 1 * 2 + 3;');
|
|
}
|
|
|
|
Future<void> test_extract_try_to_remove_necessary_parens() async {
|
|
// This is a weird corner case. We try to extract the expression `1 + 2`
|
|
// from `( 1 + 2 )`, meaning we should remove parens. But the parens are
|
|
// necessary. So we create fresh ones (without the spaces).
|
|
await analyze('var x = ( 1 + 2 ) * 3;');
|
|
var plus = findNode.binary('+');
|
|
checkPlan(extract(plus, plus.parent), 'var x = (1 + 2) * 3;');
|
|
}
|
|
|
|
Future<void> test_extract_using_comments_inner() async {
|
|
await analyze('var x = 1 + 2 * 3;');
|
|
createPlanner(removeViaComments: true);
|
|
checkPlan(extract(findNode.integerLiteral('2'), findNode.binary('+')),
|
|
'var x = /* 1 + */ 2 /* * 3 */;');
|
|
}
|
|
|
|
Future<void> test_extract_using_comments_left() async {
|
|
await analyze('var x = 1 + 2;');
|
|
createPlanner(removeViaComments: true);
|
|
checkPlan(extract(findNode.integerLiteral('1'), findNode.binary('+')),
|
|
'var x = 1 /* + 2 */;');
|
|
}
|
|
|
|
Future<void> test_extract_using_comments_right() async {
|
|
await analyze('var x = 1 + 2;');
|
|
createPlanner(removeViaComments: true);
|
|
checkPlan(extract(findNode.integerLiteral('2'), findNode.binary('+')),
|
|
'var x = /* 1 + */ 2;');
|
|
}
|
|
|
|
Future<void> test_finalize_compilationUnit() async {
|
|
// Verify that an edit plan referring to the entire compilation unit can be
|
|
// finalized. (This is an important corner case because the entire
|
|
// compilation unit is an AstNode with no parent).
|
|
await analyze('var x = 0;');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(testUnit),
|
|
suffix: [AtomicEdit.insert(' var y = 0;')]),
|
|
'var x = 0; var y = 0;');
|
|
}
|
|
|
|
Future<void> test_informativeMessageForToken() async {
|
|
await analyze('f(x) => x + 1;');
|
|
var sum = findNode.binary('+');
|
|
var info = _MockInfo();
|
|
var changes = checkPlan(
|
|
planner!.passThrough(sum, innerPlans: [
|
|
planner!.informativeMessageForToken(sum, sum.operator, info: info)
|
|
]),
|
|
'f(x) => x + 1;',
|
|
expectedIncludingInformative: 'f(x) => x 1;');
|
|
var expectedOffset = sum.operator.offset;
|
|
expect(changes.keys, unorderedEquals([expectedOffset]));
|
|
expect(changes[expectedOffset], hasLength(1));
|
|
expect(changes[expectedOffset]![0].length, '+'.length);
|
|
expect(changes[expectedOffset]![0].replacement, '');
|
|
expect(changes[expectedOffset]![0].isInformative, isTrue);
|
|
expect(changes[expectedOffset]![0].info, same(info));
|
|
}
|
|
|
|
Future<void> test_insertText() async {
|
|
await analyze('final x = 1;');
|
|
var variableDeclarationList = findNode.variableDeclarationList('final');
|
|
checkPlan(
|
|
planner!.insertText(
|
|
variableDeclarationList,
|
|
variableDeclarationList.variables.first.offset,
|
|
[AtomicEdit.insert('int ')]),
|
|
'final int x = 1;');
|
|
}
|
|
|
|
Future<void> test_makeNullable() async {
|
|
await analyze('int x = 0;');
|
|
checkPlan(
|
|
planner!
|
|
.makeNullable(planner!.passThrough(findNode.typeAnnotation('int'))),
|
|
'int? x = 0;');
|
|
}
|
|
|
|
Future<void> test_passThrough_remove_statement() async {
|
|
await analyze('''
|
|
void f() {
|
|
var x = () {
|
|
1;
|
|
2;
|
|
3;
|
|
};
|
|
}
|
|
''');
|
|
var innerPlan = planner!.removeNode(findNode.statement('2'));
|
|
var outerPlan = planner!.passThrough(findNode.variableDeclaration('x'),
|
|
innerPlans: [innerPlan]);
|
|
checkPlan(outerPlan, '''
|
|
void f() {
|
|
var x = () {
|
|
1;
|
|
3;
|
|
};
|
|
}
|
|
''');
|
|
}
|
|
|
|
Future<void> test_remove_all_list_elements_with_trailing_separator() async {
|
|
await analyze('var x = [ 1, 2, ];');
|
|
var i1 = findNode.integerLiteral('1');
|
|
var i2 = findNode.integerLiteral('2');
|
|
checkPlan(
|
|
planner!.passThrough(i1.parent,
|
|
innerPlans: [planner!.removeNode(i1), planner!.removeNode(i2)]),
|
|
'var x = [];');
|
|
}
|
|
|
|
Future<void> test_remove_argument() async {
|
|
await analyze('f(dynamic d) => d(1, 2, 3);');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var changes =
|
|
checkPlan(planner!.removeNode(i2), 'f(dynamic d) => d(1, 3);');
|
|
expect(changes.keys, [i2.offset]);
|
|
}
|
|
|
|
Future<void> test_remove_class_member() async {
|
|
await analyze('''
|
|
class C {
|
|
int? x;
|
|
int? y;
|
|
int? z;
|
|
}
|
|
''');
|
|
var declaration = findNode.fieldDeclaration('y');
|
|
var changes = checkPlan(planner!.removeNode(declaration), '''
|
|
class C {
|
|
int? x;
|
|
int? z;
|
|
}
|
|
''');
|
|
expect(changes.keys, [declaration.offset - 2]);
|
|
}
|
|
|
|
Future<void>
|
|
test_remove_elements_of_related_lists_at_different_levels() async {
|
|
await analyze('var x = [[1, 2], 3, 4];');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var i3 = findNode.integerLiteral('3');
|
|
checkPlan(
|
|
planner!.passThrough(testUnit,
|
|
innerPlans: [planner!.removeNode(i2), planner!.removeNode(i3)]),
|
|
'var x = [[1], 4];');
|
|
}
|
|
|
|
Future<void>
|
|
test_remove_elements_of_sibling_lists_passThrough_container() async {
|
|
await analyze('var x = [[1, 2], [3, 4]];');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var i3 = findNode.integerLiteral('3');
|
|
checkPlan(
|
|
planner!.passThrough(i2.parent!.parent,
|
|
innerPlans: [planner!.removeNode(i2), planner!.removeNode(i3)]),
|
|
'var x = [[1], [4]];');
|
|
}
|
|
|
|
Future<void> test_remove_elements_of_sibling_lists_passThrough_unit() async {
|
|
await analyze('var x = [[1, 2], [3, 4]];');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var i3 = findNode.integerLiteral('3');
|
|
checkPlan(
|
|
planner!.passThrough(testUnit,
|
|
innerPlans: [planner!.removeNode(i2), planner!.removeNode(i3)]),
|
|
'var x = [[1], [4]];');
|
|
}
|
|
|
|
Future<void> test_remove_enum_constant() async {
|
|
await analyze('''
|
|
enum E {
|
|
A,
|
|
B,
|
|
C
|
|
}
|
|
''');
|
|
var enumConstant = findNode.enumConstantDeclaration('B');
|
|
var changes = checkPlan(planner!.removeNode(enumConstant), '''
|
|
enum E {
|
|
A,
|
|
C
|
|
}
|
|
''');
|
|
expect(changes.keys, [enumConstant.offset - 2]);
|
|
}
|
|
|
|
Future<void> test_remove_field_declaration() async {
|
|
await analyze('''
|
|
class C {
|
|
int? x, y, z;
|
|
}
|
|
''');
|
|
var declaration = findNode.variableDeclaration('y');
|
|
var changes = checkPlan(planner!.removeNode(declaration), '''
|
|
class C {
|
|
int? x, z;
|
|
}
|
|
''');
|
|
expect(changes.keys, [declaration.offset]);
|
|
}
|
|
|
|
Future<void> test_remove_list_element() async {
|
|
await analyze('var x = [1, 2, 3];');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var changes = checkPlan(planner!.removeNode(i2), 'var x = [1, 3];');
|
|
expect(changes.keys, [i2.offset]);
|
|
}
|
|
|
|
Future<void> test_remove_list_element_at_list_end() async {
|
|
await analyze('var x = [1, 2, 3];');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var i3 = findNode.integerLiteral('3');
|
|
var changes = checkPlan(planner!.removeNode(i3), 'var x = [1, 2];');
|
|
expect(changes.keys, [i2.end]);
|
|
}
|
|
|
|
Future<void> test_remove_list_element_singleton() async {
|
|
await analyze('var x = [1];');
|
|
var i1 = findNode.integerLiteral('1');
|
|
checkPlan(planner!.removeNode(i1), 'var x = [];');
|
|
}
|
|
|
|
Future<void> test_remove_list_element_with_trailing_separator() async {
|
|
await analyze('var x = [1, 2, 3, ];');
|
|
var i3 = findNode.integerLiteral('3');
|
|
checkPlan(planner!.removeNode(i3), 'var x = [1, 2, ];');
|
|
}
|
|
|
|
Future<void> test_remove_list_elements() async {
|
|
await analyze('var x = [1, 2, 3, 4, 5];');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var i4 = findNode.integerLiteral('4');
|
|
var changes = checkPlan(
|
|
planner!.passThrough(i2.parent,
|
|
innerPlans: [planner!.removeNode(i2), planner!.removeNode(i4)]),
|
|
'var x = [1, 3, 5];');
|
|
expect(changes.keys, unorderedEquals([i2.offset, i4.offset]));
|
|
}
|
|
|
|
Future<void> test_remove_list_elements_all() async {
|
|
await analyze('var x = [1, 2];');
|
|
var i1 = findNode.integerLiteral('1');
|
|
var i2 = findNode.integerLiteral('2');
|
|
checkPlan(
|
|
planner!.passThrough(i1.parent,
|
|
innerPlans: [planner!.removeNode(i1), planner!.removeNode(i2)]),
|
|
'var x = [];');
|
|
}
|
|
|
|
Future<void> test_remove_list_elements_all_asUnit() async {
|
|
await analyze('var x = [1, 2];');
|
|
var i1 = findNode.integerLiteral('1');
|
|
var i2 = findNode.integerLiteral('2');
|
|
checkPlan(planner!.removeNodes(i1, i2), 'var x = [];');
|
|
}
|
|
|
|
Future<void> test_remove_list_elements_all_passThrough_unit() async {
|
|
await analyze('var x = [1, 2];');
|
|
var i1 = findNode.integerLiteral('1');
|
|
var i2 = findNode.integerLiteral('2');
|
|
checkPlan(
|
|
planner!.passThrough(testUnit,
|
|
innerPlans: [planner!.removeNode(i1), planner!.removeNode(i2)]),
|
|
'var x = [];');
|
|
}
|
|
|
|
Future<void> test_remove_list_elements_at_list_end() async {
|
|
await analyze('var x = [1, 2, 3];');
|
|
var i1 = findNode.integerLiteral('1');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var i3 = findNode.integerLiteral('3');
|
|
var changes = checkPlan(
|
|
planner!.passThrough(i2.parent,
|
|
innerPlans: [planner!.removeNode(i2), planner!.removeNode(i3)]),
|
|
'var x = [1];');
|
|
expect(changes.keys, unorderedEquals([i1.end, i2.end]));
|
|
}
|
|
|
|
Future<void> test_remove_list_elements_at_list_end_asUnit() async {
|
|
await analyze('var x = [1, 2, 3];');
|
|
var i1 = findNode.integerLiteral('1');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var i3 = findNode.integerLiteral('3');
|
|
var changes = checkPlan(planner!.removeNodes(i2, i3), 'var x = [1];');
|
|
expect(changes.keys, [i1.end]);
|
|
}
|
|
|
|
Future<void> test_remove_list_elements_consecutive_asUnit() async {
|
|
await analyze('var x = [1, 2, 3, 4];');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var i3 = findNode.integerLiteral('3');
|
|
var changes = checkPlan(planner!.removeNodes(i2, i3), 'var x = [1, 4];');
|
|
expect(changes.keys, [i2.offset]);
|
|
}
|
|
|
|
Future<void>
|
|
test_remove_list_elements_consecutive_at_list_end_using_comments() async {
|
|
await analyze('var x = [1, 2, 3];');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var i3 = findNode.integerLiteral('3');
|
|
createPlanner(removeViaComments: true);
|
|
checkPlan(
|
|
planner!.passThrough(i2.parent,
|
|
innerPlans: [planner!.removeNode(i2), planner!.removeNode(i3)]),
|
|
'var x = [1/* , 2 *//* , 3 */];');
|
|
}
|
|
|
|
Future<void> test_remove_list_elements_consecutive_using_comments() async {
|
|
await analyze('var x = [1, 2, 3, 4];');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var i3 = findNode.integerLiteral('3');
|
|
createPlanner(removeViaComments: true);
|
|
checkPlan(
|
|
planner!.passThrough(i2.parent,
|
|
innerPlans: [planner!.removeNode(i2), planner!.removeNode(i3)]),
|
|
'var x = [1, /* 2, */ /* 3, */ 4];');
|
|
}
|
|
|
|
Future<void> test_remove_list_elements_using_comments() async {
|
|
await analyze('var x = [1, 2, 3, 4, 5];');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var i4 = findNode.integerLiteral('4');
|
|
createPlanner(removeViaComments: true);
|
|
checkPlan(
|
|
planner!.passThrough(i2.parent,
|
|
innerPlans: [planner!.removeNode(i2), planner!.removeNode(i4)]),
|
|
'var x = [1, /* 2, */ 3, /* 4, */ 5];');
|
|
}
|
|
|
|
Future<void> test_remove_map_element() async {
|
|
await analyze('var x = {1: 2, 3: 4, 5: 6};');
|
|
var entry = findNode.integerLiteral('3').parent!;
|
|
var changes =
|
|
checkPlan(planner!.removeNode(entry), 'var x = {1: 2, 5: 6};');
|
|
expect(changes.keys, [entry.offset]);
|
|
}
|
|
|
|
Future<void>
|
|
test_remove_metadata_from_defaultFormalParameter_all_full_line() async {
|
|
await analyze('''
|
|
f({
|
|
@deprecated
|
|
int? x}) {}''');
|
|
var deprecated = findNode.annotation('@deprecated');
|
|
checkPlan(
|
|
planner!.passThrough(deprecated.parent,
|
|
innerPlans: [planner!.removeNode(deprecated)]),
|
|
'''
|
|
f({
|
|
int? x}) {}''');
|
|
}
|
|
|
|
Future<void> test_remove_metadata_from_method_declaration() async {
|
|
await analyze('''
|
|
class C {
|
|
@deprecated
|
|
f() {}
|
|
}
|
|
''');
|
|
var deprecated = findNode.annotation('@deprecated');
|
|
checkPlan(
|
|
planner!.passThrough(deprecated.parent,
|
|
innerPlans: [planner!.removeNode(deprecated)]),
|
|
'''
|
|
class C {
|
|
f() {}
|
|
}
|
|
''');
|
|
}
|
|
|
|
Future<void> test_remove_parameter() async {
|
|
await analyze('f(int x, int y, int z) => null;');
|
|
var parameter = findNode.simpleFormalParameter('y');
|
|
var changes =
|
|
checkPlan(planner!.removeNode(parameter), 'f(int x, int z) => null;');
|
|
expect(changes.keys, [parameter.offset]);
|
|
}
|
|
|
|
Future<void> test_remove_set_element() async {
|
|
await analyze('var x = {1, 2, 3};');
|
|
var i2 = findNode.integerLiteral('2');
|
|
var changes = checkPlan(planner!.removeNode(i2), 'var x = {1, 3};');
|
|
expect(changes.keys, [i2.offset]);
|
|
}
|
|
|
|
Future<void> test_remove_statement() async {
|
|
await analyze('''
|
|
void f() {
|
|
1;
|
|
2;
|
|
3;
|
|
}
|
|
''');
|
|
checkPlan(planner!.removeNode(findNode.statement('2')), '''
|
|
void f() {
|
|
1;
|
|
3;
|
|
}
|
|
''');
|
|
}
|
|
|
|
Future<void> test_remove_statement_first_of_many_on_line() async {
|
|
await analyze('''
|
|
void f() {
|
|
1;
|
|
2; 3;
|
|
4;
|
|
}
|
|
''');
|
|
checkPlan(planner!.removeNode(findNode.statement('2')), '''
|
|
void f() {
|
|
1;
|
|
3;
|
|
4;
|
|
}
|
|
''');
|
|
}
|
|
|
|
Future<void> test_remove_statement_last_of_many_on_line() async {
|
|
await analyze('''
|
|
void f() {
|
|
1;
|
|
2; 3;
|
|
4;
|
|
}
|
|
''');
|
|
checkPlan(planner!.removeNode(findNode.statement('3')), '''
|
|
void f() {
|
|
1;
|
|
2;
|
|
4;
|
|
}
|
|
''');
|
|
}
|
|
|
|
Future<void> test_remove_statement_middle_of_many_on_line() async {
|
|
await analyze('''
|
|
void f() {
|
|
1;
|
|
2; 3; 4;
|
|
5;
|
|
}
|
|
''');
|
|
checkPlan(planner!.removeNode(findNode.statement('3')), '''
|
|
void f() {
|
|
1;
|
|
2; 4;
|
|
5;
|
|
}
|
|
''');
|
|
}
|
|
|
|
Future<void> test_remove_statement_using_comments() async {
|
|
await analyze('''
|
|
void f() {
|
|
1;
|
|
2;
|
|
3;
|
|
}
|
|
''');
|
|
createPlanner(removeViaComments: true);
|
|
checkPlan(planner!.removeNode(findNode.statement('2')), '''
|
|
void f() {
|
|
1;
|
|
/* 2; */
|
|
3;
|
|
}
|
|
''');
|
|
}
|
|
|
|
Future<void> test_remove_statements_asUnit() async {
|
|
await analyze('''
|
|
void f() {
|
|
1;
|
|
2;
|
|
|
|
3;
|
|
4;
|
|
}
|
|
''');
|
|
var s2 = findNode.statement('2');
|
|
var s3 = findNode.statement('3');
|
|
var changes = checkPlan(planner!.removeNodes(s2, s3), '''
|
|
void f() {
|
|
1;
|
|
4;
|
|
}
|
|
''');
|
|
expect(changes, hasLength(1));
|
|
}
|
|
|
|
Future<void> test_remove_statements_consecutive_three() async {
|
|
await analyze('''
|
|
void f() {
|
|
1;
|
|
2;
|
|
|
|
3;
|
|
|
|
4;
|
|
5;
|
|
}
|
|
''');
|
|
var s2 = findNode.statement('2');
|
|
var s3 = findNode.statement('3');
|
|
var s4 = findNode.statement('4');
|
|
var changes = checkPlan(
|
|
planner!.passThrough(s2.parent, innerPlans: [
|
|
planner!.removeNode(s2),
|
|
planner!.removeNode(s3),
|
|
planner!.removeNode(s4)
|
|
]),
|
|
'''
|
|
void f() {
|
|
1;
|
|
5;
|
|
}
|
|
''');
|
|
expect(changes.keys,
|
|
unorderedEquals([s2.offset - 2, s3.offset - 2, s4.offset - 2]));
|
|
}
|
|
|
|
Future<void> test_remove_statements_consecutive_two() async {
|
|
await analyze('''
|
|
void f() {
|
|
1;
|
|
2;
|
|
|
|
3;
|
|
4;
|
|
}
|
|
''');
|
|
var s2 = findNode.statement('2');
|
|
var s3 = findNode.statement('3');
|
|
var changes = checkPlan(
|
|
planner!.passThrough(s2.parent,
|
|
innerPlans: [planner!.removeNode(s2), planner!.removeNode(s3)]),
|
|
'''
|
|
void f() {
|
|
1;
|
|
4;
|
|
}
|
|
''');
|
|
expect(changes.keys, unorderedEquals([s2.offset - 2, s3.offset - 2]));
|
|
}
|
|
|
|
Future<void> test_remove_statements_nonconsecutive() async {
|
|
await analyze('''
|
|
void f() {
|
|
1;
|
|
2;
|
|
3;
|
|
4;
|
|
5;
|
|
}
|
|
''');
|
|
var s2 = findNode.statement('2');
|
|
var s4 = findNode.statement('4');
|
|
var changes = checkPlan(
|
|
planner!.passThrough(s2.parent,
|
|
innerPlans: [planner!.removeNode(s2), planner!.removeNode(s4)]),
|
|
'''
|
|
void f() {
|
|
1;
|
|
3;
|
|
5;
|
|
}
|
|
''');
|
|
expect(changes, hasLength(2));
|
|
}
|
|
|
|
Future<void> test_remove_statements_singleton() async {
|
|
await analyze('''
|
|
void f() {
|
|
1;
|
|
}
|
|
''');
|
|
checkPlan(planner!.removeNode(findNode.statement('1')), '''
|
|
void f() {}
|
|
''');
|
|
}
|
|
|
|
Future<void> test_remove_statements_singleton_with_following_comment() async {
|
|
await analyze('''
|
|
void f() {
|
|
1;
|
|
// Foo
|
|
}
|
|
''');
|
|
checkPlan(planner!.removeNode(findNode.statement('1')), '''
|
|
void f() {
|
|
// Foo
|
|
}
|
|
''');
|
|
}
|
|
|
|
Future<void> test_remove_statements_singleton_with_preceding_comment() async {
|
|
await analyze('''
|
|
void f() {
|
|
// Foo
|
|
1;
|
|
}
|
|
''');
|
|
checkPlan(planner!.removeNode(findNode.statement('1')), '''
|
|
void f() {
|
|
// Foo
|
|
}
|
|
''');
|
|
}
|
|
|
|
Future<void> test_remove_statements_using_comments() async {
|
|
await analyze('''
|
|
void f() {
|
|
1;
|
|
2;
|
|
3;
|
|
4;
|
|
}
|
|
''');
|
|
createPlanner(removeViaComments: true);
|
|
var s2 = findNode.statement('2');
|
|
var s3 = findNode.statement('3');
|
|
checkPlan(
|
|
planner!.passThrough(s2.parent,
|
|
innerPlans: [planner!.removeNode(s2), planner!.removeNode(s3)]),
|
|
'''
|
|
void f() {
|
|
1;
|
|
/* 2; */
|
|
/* 3; */
|
|
4;
|
|
}
|
|
''');
|
|
}
|
|
|
|
Future<void> test_remove_top_level_declaration() async {
|
|
await analyze('''
|
|
class C {}
|
|
class D {}
|
|
class E {}
|
|
''');
|
|
var declaration = findNode.classDeclaration('D');
|
|
var changes = checkPlan(planner!.removeNode(declaration), '''
|
|
class C {}
|
|
class E {}
|
|
''');
|
|
expect(changes.keys, [declaration.offset]);
|
|
}
|
|
|
|
Future<void> test_remove_top_level_directive() async {
|
|
await analyze('''
|
|
import 'dart:io';
|
|
import 'dart:async';
|
|
import 'dart:math';
|
|
''');
|
|
var directive = findNode.import('async');
|
|
var changes = checkPlan(planner!.removeNode(directive), '''
|
|
import 'dart:io';
|
|
import 'dart:math';
|
|
''');
|
|
expect(changes.keys, [directive.offset]);
|
|
}
|
|
|
|
Future<void> test_remove_type_argument() async {
|
|
await analyze('''
|
|
class C<T, U, V> {}
|
|
C<int, double, String>? c;
|
|
''');
|
|
var typeArgument = findNode.simple('double').parent!;
|
|
var changes = checkPlan(planner!.removeNode(typeArgument), '''
|
|
class C<T, U, V> {}
|
|
C<int, String>? c;
|
|
''');
|
|
expect(changes.keys, [typeArgument.offset]);
|
|
}
|
|
|
|
Future<void> test_remove_type_parameter() async {
|
|
await analyze('class C<T, U, V> {}');
|
|
var parameter = findNode.typeParameter('U');
|
|
var changes = checkPlan(planner!.removeNode(parameter), 'class C<T, V> {}');
|
|
expect(changes.keys, [parameter.offset]);
|
|
}
|
|
|
|
Future<void> test_remove_variable_declaration() async {
|
|
await analyze('int? x, y, z;');
|
|
var declaration = findNode.variableDeclaration('y');
|
|
var changes = checkPlan(planner!.removeNode(declaration), 'int? x, z;');
|
|
expect(changes.keys, [declaration.offset]);
|
|
}
|
|
|
|
Future<void>
|
|
test_removeNullAwarenessFromMethodInvocation_change_arguments() async {
|
|
await analyze('f(x) => x?.m(0);');
|
|
var methodInvocation = findNode.methodInvocation('?.');
|
|
checkPlan(
|
|
planner!.passThrough(methodInvocation, innerPlans: [
|
|
planner!.removeNullAwareness(methodInvocation),
|
|
planner!.passThrough(methodInvocation.argumentList, innerPlans: [
|
|
planner!
|
|
.replace(findNode.integerLiteral('0'), [AtomicEdit.insert('1')])
|
|
])
|
|
]),
|
|
'f(x) => x.m(1);');
|
|
}
|
|
|
|
Future<void>
|
|
test_removeNullAwarenessFromMethodInvocation_change_methodName() async {
|
|
await analyze('f(x) => x?.m();');
|
|
var methodInvocation = findNode.methodInvocation('?.');
|
|
checkPlan(
|
|
planner!.passThrough(methodInvocation, innerPlans: [
|
|
planner!.removeNullAwareness(methodInvocation),
|
|
planner!.replace(findNode.simple('m'), [AtomicEdit.insert('n')])
|
|
]),
|
|
'f(x) => x.n();');
|
|
}
|
|
|
|
Future<void>
|
|
test_removeNullAwarenessFromMethodInvocation_change_target() async {
|
|
await analyze('f(x) => x?.m();');
|
|
var methodInvocation = findNode.methodInvocation('?.');
|
|
checkPlan(
|
|
planner!.passThrough(methodInvocation, innerPlans: [
|
|
planner!.replace(findNode.simple('x?.'), [AtomicEdit.insert('y')]),
|
|
planner!.removeNullAwareness(methodInvocation)
|
|
]),
|
|
'f(x) => y.m();');
|
|
}
|
|
|
|
Future<void>
|
|
test_removeNullAwarenessFromMethodInvocation_change_typeArguments() async {
|
|
await analyze('f(x) => x?.m<int>();');
|
|
var methodInvocation = findNode.methodInvocation('?.');
|
|
checkPlan(
|
|
planner!.passThrough(methodInvocation, innerPlans: [
|
|
planner!.removeNullAwareness(methodInvocation),
|
|
planner!.passThrough(methodInvocation.typeArguments, innerPlans: [
|
|
planner!.replace(findNode.simple('int'), [AtomicEdit.insert('num')])
|
|
])
|
|
]),
|
|
'f(x) => x.m<num>();');
|
|
}
|
|
|
|
Future<void> test_removeNullAwarenessFromMethodInvocation_simple() async {
|
|
await analyze('f(x) => x?.m();');
|
|
var methodInvocation = findNode.methodInvocation('?.');
|
|
checkPlan(
|
|
planner!.passThrough(methodInvocation,
|
|
innerPlans: [planner!.removeNullAwareness(methodInvocation)]),
|
|
'f(x) => x.m();');
|
|
}
|
|
|
|
Future<void> test_removeNullAwarenessFromPropertyAccess_change_both() async {
|
|
await analyze('f(x) => x?.y;');
|
|
var propertyAccess = findNode.propertyAccess('?.');
|
|
checkPlan(
|
|
planner!.passThrough(propertyAccess, innerPlans: [
|
|
(planner!.replace(findNode.simple('x?.'), [AtomicEdit.insert('z')])),
|
|
planner!.removeNullAwareness(propertyAccess),
|
|
planner!.replace(findNode.simple('y'), [AtomicEdit.insert('w')])
|
|
]),
|
|
'f(x) => z.w;');
|
|
}
|
|
|
|
Future<void>
|
|
test_removeNullAwarenessFromPropertyAccess_change_propertyName() async {
|
|
await analyze('f(x) => x?.y;');
|
|
var propertyAccess = findNode.propertyAccess('?.');
|
|
checkPlan(
|
|
planner!.passThrough(propertyAccess, innerPlans: [
|
|
planner!.removeNullAwareness(propertyAccess),
|
|
planner!.replace(findNode.simple('y'), [AtomicEdit.insert('w')])
|
|
]),
|
|
'f(x) => x.w;');
|
|
}
|
|
|
|
Future<void>
|
|
test_removeNullAwarenessFromPropertyAccess_change_target() async {
|
|
await analyze('f(x) => x?.y;');
|
|
var propertyAccess = findNode.propertyAccess('?.');
|
|
checkPlan(
|
|
planner!.passThrough(propertyAccess, innerPlans: [
|
|
planner!.replace(findNode.simple('x?.'), [AtomicEdit.insert('z')]),
|
|
planner!.removeNullAwareness(propertyAccess)
|
|
]),
|
|
'f(x) => z.y;');
|
|
}
|
|
|
|
Future<void> test_removeNullAwarenessFromPropertyAccess_simple() async {
|
|
await analyze('f(x) => x?.y;');
|
|
var propertyAccess = findNode.propertyAccess('?.');
|
|
checkPlan(
|
|
planner!.passThrough(propertyAccess,
|
|
innerPlans: [planner!.removeNullAwareness(propertyAccess)]),
|
|
'f(x) => x.y;');
|
|
}
|
|
|
|
Future<void> test_replace_expression() async {
|
|
await analyze('var x = 1 + 2 * 3;');
|
|
checkPlan(planner!.replace(findNode.binary('*'), [AtomicEdit.insert('6')]),
|
|
'var x = 1 + 6;');
|
|
}
|
|
|
|
Future<void> test_replace_expression_add_parens_due_to_cascade() async {
|
|
await analyze('var x = 1 + 2 * 3;');
|
|
checkPlan(
|
|
planner!.replace(findNode.binary('*'), [AtomicEdit.insert('4..isEven')],
|
|
endsInCascade: true),
|
|
'var x = 1 + (4..isEven);');
|
|
}
|
|
|
|
Future<void> test_replace_expression_add_parens_due_to_precedence() async {
|
|
await analyze('var x = 1 + 2 * 3;');
|
|
checkPlan(
|
|
planner!.replace(findNode.binary('*'), [AtomicEdit.insert('y = z')],
|
|
precedence: Precedence.assignment),
|
|
'var x = 1 + (y = z);');
|
|
}
|
|
|
|
Future<void> test_replaceToken() async {
|
|
await analyze('var x = 1;');
|
|
var variableDeclarationList = findNode.variableDeclarationList('var x');
|
|
checkPlan(
|
|
planner!.replaceToken(
|
|
variableDeclarationList, variableDeclarationList.keyword!, 'int'),
|
|
'int x = 1;');
|
|
}
|
|
|
|
Future<void> test_surround_allowCascade() async {
|
|
await analyze('f(x) => 1..isEven;');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.cascade('..')),
|
|
prefix: [AtomicEdit.insert('x..y = ')]),
|
|
'f(x) => x..y = (1..isEven);');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.cascade('..')),
|
|
prefix: [AtomicEdit.insert('x = ')], allowCascade: true),
|
|
'f(x) => x = 1..isEven;');
|
|
}
|
|
|
|
Future<void> test_surround_associative() async {
|
|
await analyze('var x = 1 - 2;');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.binary('-')),
|
|
suffix: [AtomicEdit.insert(' - 3')],
|
|
innerPrecedence: Precedence.additive,
|
|
associative: true),
|
|
'var x = 1 - 2 - 3;');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.binary('-')),
|
|
prefix: [AtomicEdit.insert('0 - ')],
|
|
innerPrecedence: Precedence.additive),
|
|
'var x = 0 - (1 - 2);');
|
|
}
|
|
|
|
Future<void> test_surround_endsInCascade() async {
|
|
await analyze('f(x) => x..y = 1;');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.integerLiteral('1')),
|
|
suffix: [AtomicEdit.insert(' + 2')]),
|
|
'f(x) => x..y = 1 + 2;');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.integerLiteral('1')),
|
|
suffix: [AtomicEdit.insert('..isEven')], endsInCascade: true),
|
|
'f(x) => x..y = (1..isEven);');
|
|
}
|
|
|
|
Future<void>
|
|
test_surround_endsInCascade_does_not_propagate_through_added_parens() async {
|
|
await analyze('f(a) => a..b = 0;');
|
|
checkPlan(
|
|
planner!.surround(
|
|
planner!.surround(planner!.passThrough(findNode.cascade('..')),
|
|
prefix: [AtomicEdit.insert('1 + ')],
|
|
innerPrecedence: Precedence.additive),
|
|
prefix: [AtomicEdit.insert('true ? ')],
|
|
suffix: [AtomicEdit.insert(' : 2')]),
|
|
'f(a) => true ? 1 + (a..b = 0) : 2;');
|
|
checkPlan(
|
|
planner!.surround(
|
|
planner!.surround(planner!.passThrough(findNode.cascade('..')),
|
|
prefix: [AtomicEdit.insert('throw ')], allowCascade: true),
|
|
prefix: [AtomicEdit.insert('true ? ')],
|
|
suffix: [AtomicEdit.insert(' : 2')]),
|
|
'f(a) => true ? (throw a..b = 0) : 2;');
|
|
}
|
|
|
|
Future<void> test_surround_endsInCascade_internal_throw() async {
|
|
await analyze('f(x, g) => g(0, throw x, 1);');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.simple('x, 1')),
|
|
suffix: [AtomicEdit.insert('..y')], endsInCascade: true),
|
|
'f(x, g) => g(0, throw x..y, 1);');
|
|
}
|
|
|
|
Future<void> test_surround_endsInCascade_propagates() async {
|
|
await analyze('f(a) => a..b = 0;');
|
|
checkPlan(
|
|
planner!.surround(
|
|
planner!.surround(planner!.passThrough(findNode.cascade('..')),
|
|
prefix: [AtomicEdit.insert('throw ')], allowCascade: true),
|
|
prefix: [AtomicEdit.insert('true ? ')],
|
|
suffix: [AtomicEdit.insert(' : 2')]),
|
|
'f(a) => true ? (throw a..b = 0) : 2;');
|
|
checkPlan(
|
|
planner!.surround(
|
|
planner!.surround(
|
|
planner!.passThrough(findNode.integerLiteral('0')),
|
|
prefix: [AtomicEdit.insert('throw ')],
|
|
allowCascade: true),
|
|
prefix: [AtomicEdit.insert('true ? ')],
|
|
suffix: [AtomicEdit.insert(' : 2')]),
|
|
'f(a) => a..b = true ? throw 0 : 2;');
|
|
}
|
|
|
|
Future<void> test_surround_precedence() async {
|
|
await analyze('var x = 1 == true;');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.integerLiteral('1')),
|
|
suffix: [AtomicEdit.insert(' < 2')],
|
|
outerPrecedence: Precedence.relational),
|
|
'var x = 1 < 2 == true;');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.integerLiteral('1')),
|
|
suffix: [AtomicEdit.insert(' == 2')],
|
|
outerPrecedence: Precedence.equality),
|
|
'var x = (1 == 2) == true;');
|
|
}
|
|
|
|
Future<void> test_surround_prefix() async {
|
|
await analyze('var x = 1;');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.integerLiteral('1')),
|
|
prefix: [AtomicEdit.insert('throw ')]),
|
|
'var x = throw 1;');
|
|
}
|
|
|
|
Future<void> test_surround_suffix() async {
|
|
await analyze('var x = 1;');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.integerLiteral('1')),
|
|
suffix: [AtomicEdit.insert('..isEven')]),
|
|
'var x = 1..isEven;');
|
|
}
|
|
|
|
Future<void> test_surround_suffix_parenthesized() async {
|
|
await analyze('var x = (1);');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.integerLiteral('1')),
|
|
suffix: [AtomicEdit.insert('..isEven')]),
|
|
'var x = 1..isEven;');
|
|
}
|
|
|
|
Future<void> test_surround_suffix_parenthesized_passThrough_unit() async {
|
|
await analyze('var x = (1);');
|
|
checkPlan(
|
|
planner!.passThrough(testUnit, innerPlans: [
|
|
planner!.surround(planner!.passThrough(findNode.integerLiteral('1')),
|
|
suffix: [AtomicEdit.insert('..isEven')])
|
|
]),
|
|
'var x = 1..isEven;');
|
|
}
|
|
|
|
Future<void> test_surround_threshold() async {
|
|
await analyze('var x = 1 < 2;');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.binary('<')),
|
|
suffix: [AtomicEdit.insert(' == true')],
|
|
innerPrecedence: Precedence.equality),
|
|
'var x = 1 < 2 == true;');
|
|
checkPlan(
|
|
planner!.surround(planner!.passThrough(findNode.binary('<')),
|
|
suffix: [AtomicEdit.insert(' as bool')],
|
|
innerPrecedence: Precedence.relational),
|
|
'var x = (1 < 2) as bool;');
|
|
}
|
|
}
|
|
|
|
@reflectiveTest
|
|
class EndsInCascadeTest extends AbstractSingleUnitTest {
|
|
Future<void> test_ignore_subexpression_not_at_end() async {
|
|
await resolveTestUnit('f(g) => g(0..isEven, 1);');
|
|
expect(findNode.functionExpressionInvocation('g(').endsInCascade, false);
|
|
expect(findNode.cascade('..').endsInCascade, true);
|
|
}
|
|
|
|
Future<void> test_no_cascade() async {
|
|
await resolveTestUnit('var x = 0;');
|
|
expect(findNode.integerLiteral('0').endsInCascade, false);
|
|
}
|
|
|
|
Future<void> test_stop_searching_when_parens_encountered() async {
|
|
await resolveTestUnit('f(x) => x = (x = 0..isEven);');
|
|
expect(findNode.assignment('= (x').endsInCascade, false);
|
|
expect(findNode.parenthesized('(x =').endsInCascade, false);
|
|
expect(findNode.assignment('= 0').endsInCascade, true);
|
|
expect(findNode.cascade('..').endsInCascade, true);
|
|
}
|
|
}
|
|
|
|
/// Tests of the precedence logic underlying [EditPlan].
|
|
///
|
|
/// The way these tests operate is as follows: we have several short snippets of
|
|
/// Dart code exercising Dart syntax with no unnecessary parentheses. We
|
|
/// recursively visit the AST of each snippet and use [EditPlanner.passThrough]
|
|
/// to create an edit plan based on each AST node. Then we use
|
|
/// [EditPlanner.parensNeededFromContext] to check whether parentheses are
|
|
/// needed around each node, and assert that the result agrees with the set of
|
|
/// parentheses that are actually present.
|
|
@reflectiveTest
|
|
class PrecedenceTest extends AbstractSingleUnitTest {
|
|
Future<void> checkPrecedence(String content) async {
|
|
await resolveTestUnit(content);
|
|
testUnit!.accept(_PrecedenceChecker(testUnit!.lineInfo, testCode));
|
|
}
|
|
|
|
Future<void> test_precedence_as() async {
|
|
await checkPrecedence('''
|
|
f(a) => (a as num) as int;
|
|
g(a, b) => a | b as int;
|
|
''');
|
|
}
|
|
|
|
Future<void> test_precedence_assignment() async {
|
|
await checkPrecedence('f(a, b, c) => a = b = c;');
|
|
}
|
|
|
|
Future<void> test_precedence_assignment_in_cascade_with_parens() async {
|
|
await checkPrecedence('f(a, c, e) => a..b = (c..d = e);');
|
|
}
|
|
|
|
Future<void> test_precedence_await() async {
|
|
await checkPrecedence('''
|
|
f(a) async => await -a;
|
|
g(a, b) async => await (a*b);
|
|
''');
|
|
}
|
|
|
|
Future<void> test_precedence_binary_equality() async {
|
|
await checkPrecedence('''
|
|
f(a, b, c) => (a == b) == c;
|
|
g(a, b, c) => a == (b == c);
|
|
''');
|
|
}
|
|
|
|
Future<void> test_precedence_binary_left_associative() async {
|
|
// Associativity logic is the same for all operators except relational and
|
|
// equality, so we just test `+` as a stand-in for all the others.
|
|
await checkPrecedence('''
|
|
f(a, b, c) => a + b + c;
|
|
g(a, b, c) => a + (b + c);
|
|
''');
|
|
}
|
|
|
|
Future<void> test_precedence_binary_relational() async {
|
|
await checkPrecedence('''
|
|
f(a, b, c) => (a < b) < c;
|
|
g(a, b, c) => a < (b < c);
|
|
''');
|
|
}
|
|
|
|
Future<void> test_precedence_conditional() async {
|
|
await checkPrecedence('''
|
|
g(a, b, c, d, e, f) => a ?? b ? c = d : e = f;
|
|
h(a, b, c, d, e) => (a ? b : c) ? d : e;
|
|
''');
|
|
}
|
|
|
|
Future<void> test_precedence_extension_override() async {
|
|
await checkPrecedence('''
|
|
extension E on Object {
|
|
void f() {}
|
|
}
|
|
void g(x) => E(x).f();
|
|
''');
|
|
}
|
|
|
|
Future<void> test_precedence_functionExpression_ifNotNull() async {
|
|
await checkPrecedence('f(b, c) => ((a) => b) ?? c;');
|
|
}
|
|
|
|
Future<void> test_precedence_functionExpressionInvocation() async {
|
|
await checkPrecedence('''
|
|
f(g) => g[0](1);
|
|
h(x) => (x + 2)(3);
|
|
''');
|
|
}
|
|
|
|
@FailingTest(issue: 'https://github.com/dart-lang/sdk/issues/40536')
|
|
Future<void> test_precedence_ifNotNull_functionExpression() async {
|
|
await checkPrecedence('f(a, c) => a ?? (b) => c;');
|
|
}
|
|
|
|
Future<void> test_precedence_is() async {
|
|
await checkPrecedence('''
|
|
f(a) => (a as num) is int;
|
|
g(a, b) => a | b is int;
|
|
''');
|
|
}
|
|
|
|
Future<void> test_precedence_postfix_and_index() async {
|
|
await checkPrecedence('''
|
|
f(a, b, c) => a[b][c];
|
|
g(a, b) => a[b]++;
|
|
h(a, b) => (-a)[b];
|
|
''');
|
|
}
|
|
|
|
Future<void> test_precedence_prefix() async {
|
|
await checkPrecedence('''
|
|
f(a) => ~-a;
|
|
g(a, b) => -(a*b);
|
|
''');
|
|
}
|
|
|
|
Future<void> test_precedence_prefixedIdentifier() async {
|
|
await checkPrecedence('f(a) => a.b;');
|
|
}
|
|
|
|
Future<void> test_precedence_propertyAccess() async {
|
|
await checkPrecedence('''
|
|
f(a) => a?.b?.c;
|
|
g(a) => (-a)?.b;
|
|
''');
|
|
}
|
|
|
|
Future<void> test_precedence_throw() async {
|
|
await checkPrecedence('''
|
|
f(a, b) => throw a = b;
|
|
g(a, c) => a..b = throw (c..d);
|
|
''');
|
|
}
|
|
|
|
Future<void> test_precedenceChecker_detects_unnecessary_paren() async {
|
|
await resolveTestUnit('var x = (1);');
|
|
expect(
|
|
() =>
|
|
testUnit!.accept(_PrecedenceChecker(testUnit!.lineInfo, testCode)),
|
|
throwsA(TypeMatcher<TestFailure>()));
|
|
}
|
|
}
|
|
|
|
class _MockInfo implements AtomicEditInfo {
|
|
noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
|
|
}
|
|
|
|
class _PrecedenceChecker extends UnifyingAstVisitor<void> {
|
|
final EditPlanner planner;
|
|
|
|
_PrecedenceChecker(LineInfo? lineInfo, String? sourceText)
|
|
: planner = EditPlanner(lineInfo, sourceText);
|
|
|
|
@override
|
|
void visitNode(AstNode node) {
|
|
expect(planner.passThrough(node).parensNeededFromContext(null), false);
|
|
node.visitChildren(this);
|
|
}
|
|
|
|
@override
|
|
void visitParenthesizedExpression(ParenthesizedExpression node) {
|
|
expect(planner.passThrough(node).parensNeededFromContext(null), true);
|
|
node.expression.visitChildren(this);
|
|
}
|
|
}
|