Version 2.11.0-239.0.dev
Merge commit 'f1843b0abed6b43eb2e737b0edd52671c9c31eda' into 'dev'
diff --git a/pkg/analyzer/lib/src/test_utilities/mock_sdk.dart b/pkg/analyzer/lib/src/test_utilities/mock_sdk.dart
index e71bee4..6b23228 100644
--- a/pkg/analyzer/lib/src/test_utilities/mock_sdk.dart
+++ b/pkg/analyzer/lib/src/test_utilities/mock_sdk.dart
@@ -381,8 +381,12 @@
void forEach(void f(E element));
+ E lastWhere(bool test(E element), {E orElse()?});
+
Iterable<R> map<R>(R f(E e));
+ E singleWhere(bool test(E element), {E orElse()?});
+
List<E> toList({bool growable = true});
Set<E> toSet();
diff --git a/pkg/nnbd_migration/lib/instrumentation.dart b/pkg/nnbd_migration/lib/instrumentation.dart
index 387d666..a89962a 100644
--- a/pkg/nnbd_migration/lib/instrumentation.dart
+++ b/pkg/nnbd_migration/lib/instrumentation.dart
@@ -277,6 +277,7 @@
instantiateToBounds,
isCheckComponentType,
isCheckMainType,
+ iteratorMethodReturn,
listLengthConstructor,
literal,
namedParameterNotSupplied,
diff --git a/pkg/nnbd_migration/lib/nnbd_migration.dart b/pkg/nnbd_migration/lib/nnbd_migration.dart
index b222f91..64a6c49 100644
--- a/pkg/nnbd_migration/lib/nnbd_migration.dart
+++ b/pkg/nnbd_migration/lib/nnbd_migration.dart
@@ -291,12 +291,18 @@
/// Optional parameter [warnOnWeakCode] indicates whether weak-only code
/// should be warned about or removed (in the way specified by
/// [removeViaComments]).
+ ///
+ /// Optional parameter [transformWhereOrNull] indicates whether Iterable
+ /// methods should be transformed to their "OrNull" equivalents when possible.
+ /// This feature is a work in progress, so by default they are not
+ /// transformed.
factory NullabilityMigration(NullabilityMigrationListener listener,
LineInfo Function(String) getLineInfo,
{bool permissive,
NullabilityMigrationInstrumentation instrumentation,
bool removeViaComments,
- bool warnOnWeakCode}) = NullabilityMigrationImpl;
+ bool warnOnWeakCode,
+ bool transformWhereOrNull}) = NullabilityMigrationImpl;
/// Check if this migration is being run permissively.
bool get isPermissive;
diff --git a/pkg/nnbd_migration/lib/src/edge_builder.dart b/pkg/nnbd_migration/lib/src/edge_builder.dart
index 962dc5e..282b622 100644
--- a/pkg/nnbd_migration/lib/src/edge_builder.dart
+++ b/pkg/nnbd_migration/lib/src/edge_builder.dart
@@ -32,6 +32,7 @@
import 'package:nnbd_migration/src/utilities/permissive_mode.dart';
import 'package:nnbd_migration/src/utilities/resolution_utils.dart';
import 'package:nnbd_migration/src/utilities/scoped_set.dart';
+import 'package:nnbd_migration/src/utilities/where_or_null_transformer.dart';
import 'package:nnbd_migration/src/variables.dart';
import 'decorated_type_operations.dart';
@@ -213,10 +214,29 @@
final Map<Token, HintComment> _nullCheckHints = {};
- EdgeBuilder(this.typeProvider, this._typeSystem, this._variables, this._graph,
- this.source, this.listener, this._decoratedClassHierarchy,
+ /// Helper that assists us in transforming Iterable methods to their "OrNull"
+ /// equivalents, or `null` if we are not doing such transformations.
+ final WhereOrNullTransformer _whereOrNullTransformer;
+
+ /// Deferred processing that should be performed once we have finished
+ /// evaluating the decorated type of a method invocation.
+ final Map<MethodInvocation, DecoratedType Function(DecoratedType)>
+ _deferredMethodInvocationProcessing = {};
+
+ EdgeBuilder(
+ this.typeProvider,
+ this._typeSystem,
+ this._variables,
+ this._graph,
+ this.source,
+ this.listener,
+ this._decoratedClassHierarchy,
+ bool transformWhereOrNull,
{this.instrumentation})
- : _inheritanceManager = InheritanceManager3();
+ : _inheritanceManager = InheritanceManager3(),
+ _whereOrNullTransformer = transformWhereOrNull
+ ? WhereOrNullTransformer(typeProvider, _typeSystem)
+ : null;
/// Gets the decorated type of [element] from [_variables], performing any
/// necessary substitutions.
@@ -880,6 +900,7 @@
_postDominatedLocals.doScoped(
elements: node.declaredElement.parameters,
action: () => _dispatch(node.body));
+ _variables.recordDecoratedExpressionType(node, _currentFunctionType);
return _currentFunctionType;
} finally {
if (node.parent is! FunctionDeclaration) {
@@ -1228,11 +1249,16 @@
calleeType,
null,
invokeType: node.staticInvokeType);
+ // Do any deferred processing for this method invocation.
+ var deferredProcessing = _deferredMethodInvocationProcessing.remove(node);
+ if (deferredProcessing != null) {
+ expressionType = deferredProcessing(expressionType);
+ }
if (isNullAware) {
expressionType = expressionType.withNode(
NullabilityNode.forLUB(targetType.node, expressionType.node));
- _variables.recordDecoratedExpressionType(node, expressionType);
}
+ _variables.recordDecoratedExpressionType(node, expressionType);
}
_handleArgumentErrorCheckNotNull(node);
_handleQuiverCheckNotNull(node);
@@ -2260,18 +2286,40 @@
sourceType = _makeNullableDynamicType(compoundOperatorInfo);
}
} else {
- var unwrappedExpression = expression.unParenthesized;
- var hard = (questionAssignNode == null &&
- _postDominatedLocals.isReferenceInScope(expression)) ||
- // An edge from a cast should be hard, so that the cast type
- // annotation is appropriately made nullable according to the
- // destination type.
- unwrappedExpression is AsExpression;
- _checkAssignment(edgeOrigin, FixReasonTarget.root,
- source: sourceType,
- destination: destinationType,
- hard: hard,
- sourceIsFunctionLiteral: expression is FunctionExpression);
+ var transformationInfo =
+ _whereOrNullTransformer?.tryTransformOrElseArgument(expression);
+ if (transformationInfo != null) {
+ // Don't build any edges for this argument; if necessary we'll transform
+ // it rather than make things nullable. But do save the nullability of
+ // the return value of the `orElse` method, so that we can later connect
+ // it to the nullability of the value returned from the method
+ // invocation.
+ var extraNullability = sourceType.returnType.node;
+ _deferredMethodInvocationProcessing[
+ transformationInfo.methodInvocation] = (methodInvocationType) {
+ var newNode = NullabilityNode.forInferredType(
+ NullabilityNodeTarget.text(
+ 'return value from ${transformationInfo.originalName}'));
+ var origin = IteratorMethodReturnOrigin(
+ source, transformationInfo.methodInvocation);
+ _graph.connect(methodInvocationType.node, newNode, origin);
+ _graph.connect(extraNullability, newNode, origin);
+ return methodInvocationType.withNode(newNode);
+ };
+ } else {
+ var unwrappedExpression = expression.unParenthesized;
+ var hard = (questionAssignNode == null &&
+ _postDominatedLocals.isReferenceInScope(expression)) ||
+ // An edge from a cast should be hard, so that the cast type
+ // annotation is appropriately made nullable according to the
+ // destination type.
+ unwrappedExpression is AsExpression;
+ _checkAssignment(edgeOrigin, FixReasonTarget.root,
+ source: sourceType,
+ destination: destinationType,
+ hard: hard,
+ sourceIsFunctionLiteral: expression is FunctionExpression);
+ }
}
if (destinationLocalVariable != null) {
_flowAnalysis.write(destinationLocalVariable, sourceType);
diff --git a/pkg/nnbd_migration/lib/src/edge_origin.dart b/pkg/nnbd_migration/lib/src/edge_origin.dart
index 61c6837..81bdf76 100644
--- a/pkg/nnbd_migration/lib/src/edge_origin.dart
+++ b/pkg/nnbd_migration/lib/src/edge_origin.dart
@@ -371,6 +371,19 @@
EdgeOriginKind get kind => EdgeOriginKind.isCheckMainType;
}
+/// An edge origin used for the return type of an iterator method that might be
+/// changed into an extension method from package:collection.
+class IteratorMethodReturnOrigin extends EdgeOrigin {
+ IteratorMethodReturnOrigin(Source source, AstNode node) : super(source, node);
+
+ @override
+ String get description =>
+ 'Call to iterator method with orElse that returns null';
+
+ @override
+ EdgeOriginKind get kind => EdgeOriginKind.iteratorMethodReturn;
+}
+
/// An edge origin used for the type argument of a list constructor that
/// specified an initial length, because that type argument must be nullable.
class ListLengthConstructorOrigin extends EdgeOrigin {
diff --git a/pkg/nnbd_migration/lib/src/fix_aggregator.dart b/pkg/nnbd_migration/lib/src/fix_aggregator.dart
index cc0a510..bf7ff82 100644
--- a/pkg/nnbd_migration/lib/src/fix_aggregator.dart
+++ b/pkg/nnbd_migration/lib/src/fix_aggregator.dart
@@ -9,6 +9,7 @@
import 'package:analyzer/dart/element/nullability_suffix.dart';
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/src/dart/ast/ast.dart';
+import 'package:meta/meta.dart';
import 'package:nnbd_migration/fix_reason_target.dart';
import 'package:nnbd_migration/instrumentation.dart';
import 'package:nnbd_migration/nnbd_migration.dart';
@@ -278,6 +279,46 @@
}
}
+/// Implementation of [NodeChange] specialized for operating on [ArgumentList]
+/// nodes.
+class NodeChangeForArgumentList extends NodeChange<ArgumentList> {
+ /// The set of arguments that should be dropped from this argument list, or
+ /// the empty set if no arguments should be dropped.
+ final Set<Expression> _argumentsToDrop = {};
+
+ NodeChangeForArgumentList() : super._();
+
+ /// Queries the set of arguments that should be dropped from this argument
+ /// list, or the empty set if no arguments should be dropped.
+ @visibleForTesting
+ Iterable<Expression> get argumentsToDrop => _argumentsToDrop;
+
+ @override
+ Iterable<String> get _toStringParts => [
+ if (_argumentsToDrop.isNotEmpty)
+ 'argumentsToDrop: {${_argumentsToDrop.join(', ')}}'
+ ];
+
+ /// Updates `this` so that the given [argument] will be dropped.
+ void dropArgument(Expression argument) {
+ _argumentsToDrop.add(argument);
+ }
+
+ @override
+ EditPlan _apply(ArgumentList node, FixAggregator aggregator) {
+ assert(_argumentsToDrop.every((e) => identical(e.parent, node)));
+ List<EditPlan> innerPlans = [];
+ for (var argument in node.arguments) {
+ if (_argumentsToDrop.contains(argument)) {
+ innerPlans.add(aggregator.planner.removeNode(argument));
+ } else {
+ innerPlans.add(aggregator.planForNode(argument));
+ }
+ }
+ return aggregator.planner.passThrough(node, innerPlans: innerPlans);
+ }
+}
+
/// Implementation of [NodeChange] specialized for operating on [AsExpression]
/// nodes.
class NodeChangeForAsExpression extends NodeChangeForExpression<AsExpression> {
@@ -393,13 +434,35 @@
/// Implementation of [NodeChange] specialized for operating on
/// [CompilationUnit] nodes.
class NodeChangeForCompilationUnit extends NodeChange<CompilationUnit> {
+ /// A map of the imports that should be added, or the empty map if no imports
+ /// should be added.
+ ///
+ /// Each import is expressed as a map entry whose key is the URI to import and
+ /// whose value is the set of symbols to show.
+ final Map<String, Set<String>> _addImports = {};
+
bool removeLanguageVersionComment = false;
NodeChangeForCompilationUnit() : super._();
+ /// Queries a map of the imports that should be added, or the empty map if no
+ /// imports should be added.
+ ///
+ /// Each import is expressed as a map entry whose key is the URI to import and
+ /// whose value is the set of symbols to show.
+ @visibleForTesting
+ Map<String, Set<String>> get addImports => _addImports;
+
@override
- Iterable<String> get _toStringParts =>
- [if (removeLanguageVersionComment) 'removeLanguageVersionComment'];
+ Iterable<String> get _toStringParts => [
+ if (_addImports.isNotEmpty) 'addImports: $_addImports',
+ if (removeLanguageVersionComment) 'removeLanguageVersionComment'
+ ];
+
+ /// Updates `this` so that an import of [uri] will be added, showing [name].
+ void addImport(String uri, String name) {
+ (_addImports[uri] ??= {}).add(name);
+ }
@override
EditPlan _apply(CompilationUnit node, FixAggregator aggregator) {
@@ -412,9 +475,67 @@
NullabilityFixDescription.removeLanguageVersionComment,
const {})));
}
- innerPlans.addAll(aggregator.innerPlansForNode(node));
+ _processDirectives(node, aggregator, innerPlans);
+ for (var declaration in node.declarations) {
+ innerPlans.add(aggregator.planForNode(declaration));
+ }
return aggregator.planner.passThrough(node, innerPlans: innerPlans);
}
+
+ /// Adds the necessary inner plans to [innerPlans] for the directives part of
+ /// [node]. This solely involves adding imports.
+ void _processDirectives(CompilationUnit node, FixAggregator aggregator,
+ List<EditPlan> innerPlans) {
+ List<MapEntry<String, Set<String>>> importsToAdd =
+ _addImports.entries.toList();
+ importsToAdd.sort((x, y) => x.key.compareTo(y.key));
+
+ void insertImport(int offset, MapEntry<String, Set<String>> importToAdd,
+ {String prefix = '', String suffix = '\n'}) {
+ var shownNames = importToAdd.value.toList();
+ shownNames.sort();
+ innerPlans.add(aggregator.planner.insertText(node, offset, [
+ if (prefix.isNotEmpty) AtomicEdit.insert(prefix),
+ AtomicEdit.insert(
+ "import '${importToAdd.key}' show ${shownNames.join(', ')};"),
+ if (suffix.isNotEmpty) AtomicEdit.insert(suffix)
+ ]));
+ }
+
+ if (node.directives.every((d) => d is LibraryDirective)) {
+ while (importsToAdd.isNotEmpty) {
+ insertImport(
+ node.declarations.beginToken.offset, importsToAdd.removeAt(0),
+ suffix: importsToAdd.isEmpty ? '\n\n' : '\n');
+ }
+ } else {
+ for (var directive in node.directives) {
+ while (importsToAdd.isNotEmpty &&
+ _shouldImportGoBefore(importsToAdd.first.key, directive)) {
+ insertImport(directive.offset, importsToAdd.removeAt(0));
+ }
+ innerPlans.add(aggregator.planForNode(directive));
+ }
+ while (importsToAdd.isNotEmpty) {
+ insertImport(node.directives.last.end, importsToAdd.removeAt(0),
+ prefix: '\n', suffix: '');
+ }
+ }
+ }
+
+ /// Determines whether a new import of [newImportUri] should be sorted before
+ /// an existing [directive].
+ bool _shouldImportGoBefore(String newImportUri, Directive directive) {
+ if (directive is ImportDirective) {
+ return newImportUri.compareTo(directive.uriContent) < 0;
+ } else if (directive is LibraryDirective) {
+ // Library directives must come before imports.
+ return false;
+ } else {
+ // Everything else tends to come after imports.
+ return true;
+ }
+ }
}
/// Common infrastructure used by [NodeChange] objects that operate on AST nodes
@@ -749,6 +870,29 @@
}
}
+/// Implementation of [NodeChange] specialized for operating on
+/// [SimpleIdentifier] nodes that represent a method name.
+class NodeChangeForMethodName extends NodeChange<SimpleIdentifier> {
+ /// The name the method name should be changed to, or `null` if no change
+ /// should be made.
+ String replacement;
+
+ NodeChangeForMethodName() : super._();
+
+ @override
+ Iterable<String> get _toStringParts =>
+ [if (replacement != null) 'replacement: $replacement'];
+
+ @override
+ EditPlan _apply(SimpleIdentifier node, FixAggregator aggregator) {
+ if (replacement != null) {
+ return aggregator.planner.replace(node, [AtomicEdit.insert(replacement)]);
+ } else {
+ return aggregator.innerPlanForNode(node);
+ }
+ }
+}
+
/// Common infrastructure used by [NodeChange] objects that operate on AST nodes
/// with that can be null-aware (method invocations and propety accesses).
mixin NodeChangeForNullAware<N extends Expression> on NodeChange<N> {
@@ -831,6 +975,60 @@
}
}
+/// Implementation of [NodeChange] specialized for operating on [ShowCombinator]
+/// nodes.
+class NodeChangeForShowCombinator extends NodeChange<ShowCombinator> {
+ /// A set of the names that should be added, or the empty set if no names
+ /// should be added.
+ final Set<String> _addNames = {};
+
+ NodeChangeForShowCombinator() : super._();
+
+ /// Queries the set of names that should be added, or the empty set if no
+ /// names should be added.
+ @visibleForTesting
+ Iterable<String> get addNames => _addNames;
+
+ @override
+ Iterable<String> get _toStringParts => [
+ if (_addNames.isNotEmpty) 'addNames: $_addNames',
+ ];
+
+ /// Updates `this` so that [name] will be added.
+ void addName(String name) {
+ _addNames.add(name);
+ }
+
+ @override
+ EditPlan _apply(ShowCombinator node, FixAggregator aggregator) {
+ List<EditPlan> innerPlans = [];
+ List<String> namesToAdd = _addNames.toList();
+ namesToAdd.sort();
+
+ void insertName(int offset, String nameToAdd,
+ {String prefix = '', String suffix = ', '}) {
+ innerPlans.add(aggregator.planner.insertText(node, offset, [
+ if (prefix.isNotEmpty) AtomicEdit.insert(prefix),
+ AtomicEdit.insert(nameToAdd),
+ if (suffix.isNotEmpty) AtomicEdit.insert(suffix)
+ ]));
+ }
+
+ for (var shownName in node.shownNames) {
+ while (namesToAdd.isNotEmpty &&
+ namesToAdd.first.compareTo(shownName.name) < 0) {
+ insertName(shownName.offset, namesToAdd.removeAt(0));
+ }
+ innerPlans.add(aggregator.planForNode(shownName));
+ }
+ while (namesToAdd.isNotEmpty) {
+ insertName(node.shownNames.last.end, namesToAdd.removeAt(0),
+ prefix: ', ', suffix: '');
+ }
+ return aggregator.planner.passThrough(node, innerPlans: innerPlans);
+ }
+}
+
/// Implementation of [NodeChange] specialized for operating on
/// [SimpleFormalParameter] nodes.
class NodeChangeForSimpleFormalParameter
@@ -1036,6 +1234,10 @@
NodeChange visitAnnotation(Annotation node) => NodeChangeForAnnotation();
@override
+ NodeChange visitArgumentList(ArgumentList node) =>
+ NodeChangeForArgumentList();
+
+ @override
NodeChange visitAsExpression(AsExpression node) =>
NodeChangeForAsExpression();
@@ -1098,10 +1300,24 @@
NodeChangeForPropertyAccess();
@override
+ NodeChange visitShowCombinator(ShowCombinator node) =>
+ NodeChangeForShowCombinator();
+
+ @override
NodeChange visitSimpleFormalParameter(SimpleFormalParameter node) =>
NodeChangeForSimpleFormalParameter();
@override
+ NodeChange visitSimpleIdentifier(SimpleIdentifier node) {
+ var parent = node.parent;
+ if (parent is MethodInvocation && identical(node, parent.methodName)) {
+ return NodeChangeForMethodName();
+ } else {
+ return super.visitSimpleIdentifier(node);
+ }
+ }
+
+ @override
NodeChange visitTypeName(TypeName node) => NodeChangeForTypeAnnotation();
@override
diff --git a/pkg/nnbd_migration/lib/src/fix_builder.dart b/pkg/nnbd_migration/lib/src/fix_builder.dart
index 9e5e486..55b7a16 100644
--- a/pkg/nnbd_migration/lib/src/fix_builder.dart
+++ b/pkg/nnbd_migration/lib/src/fix_builder.dart
@@ -26,6 +26,7 @@
import 'package:analyzer/src/generated/resolver.dart';
import 'package:analyzer/src/generated/source.dart';
import 'package:analyzer/src/generated/utilities_dart.dart';
+import 'package:meta/meta.dart';
import 'package:nnbd_migration/fix_reason_target.dart';
import 'package:nnbd_migration/instrumentation.dart';
import 'package:nnbd_migration/nnbd_migration.dart';
@@ -37,6 +38,7 @@
import 'package:nnbd_migration/src/utilities/hint_utils.dart';
import 'package:nnbd_migration/src/utilities/permissive_mode.dart';
import 'package:nnbd_migration/src/utilities/resolution_utils.dart';
+import 'package:nnbd_migration/src/utilities/where_or_null_transformer.dart';
import 'package:nnbd_migration/src/variables.dart';
bool _isIncrementOrDecrementOperator(TokenType tokenType) {
@@ -118,6 +120,15 @@
final NullabilityGraph _graph;
+ /// Helper that assists us in transforming Iterable methods to their "OrNull"
+ /// equivalents, or `null` if we are not doing such transformations.
+ final WhereOrNullTransformer _whereOrNullTransformer;
+
+ /// Indicates whether an import of package:collection's `IterableExtension`
+ /// will need to be added.
+ @visibleForTesting
+ bool needsIterableExtension = false;
+
factory FixBuilder(
Source source,
DecoratedClassHierarchy decoratedClassHierarchy,
@@ -128,7 +139,8 @@
NullabilityMigrationListener listener,
CompilationUnit unit,
bool warnOnWeakCode,
- NullabilityGraph graph) {
+ NullabilityGraph graph,
+ bool transformWhereOrNull) {
var migrationResolutionHooks = MigrationResolutionHooksImpl();
return FixBuilder._(
decoratedClassHierarchy,
@@ -143,7 +155,8 @@
unit,
migrationResolutionHooks,
warnOnWeakCode,
- graph);
+ graph,
+ transformWhereOrNull);
}
FixBuilder._(
@@ -156,8 +169,12 @@
this.unit,
this.migrationResolutionHooks,
this.warnOnWeakCode,
- this._graph)
- : typeProvider = _typeSystem.typeProvider {
+ this._graph,
+ bool transformWhereOrNull)
+ : typeProvider = _typeSystem.typeProvider,
+ _whereOrNullTransformer = transformWhereOrNull
+ ? WhereOrNullTransformer(_typeSystem.typeProvider, _typeSystem)
+ : null {
migrationResolutionHooks._fixBuilder = this;
assert(_typeSystem.isNonNullableByDefault);
assert((typeProvider as TypeProviderImpl).isNonNullableByDefault);
@@ -308,6 +325,11 @@
FlowAnalysis<AstNode, Statement, Expression, PromotableElement, DartType>
_flowAnalysis;
+ /// Deferred processing that should be performed once we have finished
+ /// evaluating the type of a method invocation.
+ final Map<MethodInvocation, DartType Function(DartType)>
+ _deferredMethodInvocationProcessing = {};
+
TypeProvider get typeProvider => _fixBuilder.typeProvider;
@override
@@ -584,6 +606,12 @@
DartType _modifyRValueType(Expression node, DartType type,
{DartType context}) {
+ if (node is MethodInvocation) {
+ var deferredProcessing = _deferredMethodInvocationProcessing.remove(node);
+ if (deferredProcessing != null) {
+ type = deferredProcessing(type);
+ }
+ }
var hint =
_fixBuilder._variables.getNullCheckHint(_fixBuilder.source, node);
if (hint != null) {
@@ -602,6 +630,24 @@
context ??=
InferenceContext.getContext(ancestor) ?? DynamicTypeImpl.instance;
if (!_fixBuilder._typeSystem.isSubtypeOf(type, context)) {
+ var transformationInfo =
+ _fixBuilder._whereOrNullTransformer?.tryTransformOrElseArgument(node);
+ if (transformationInfo != null) {
+ // We can fix this by dropping the node and changing the method call.
+ _fixBuilder.needsIterableExtension = true;
+ (_fixBuilder._getChange(transformationInfo.methodInvocation.methodName)
+ as NodeChangeForMethodName)
+ .replacement = transformationInfo.replacementName;
+ (_fixBuilder._getChange(
+ transformationInfo.methodInvocation.argumentList)
+ as NodeChangeForArgumentList)
+ .dropArgument(transformationInfo.orElseArgument);
+ _deferredMethodInvocationProcessing[
+ transformationInfo.methodInvocation] =
+ (methodInvocationType) => _fixBuilder._typeSystem
+ .makeNullable(methodInvocationType as TypeImpl);
+ return type;
+ }
// Either a cast or a null check is needed. We prefer to do a null
// check if we can.
var nonNullType = _fixBuilder._typeSystem.promoteToNonNull(type);
@@ -855,6 +901,21 @@
(_fixBuilder._getChange(node) as NodeChangeForCompilationUnit)
.removeLanguageVersionComment = true;
}
+ if (_fixBuilder.needsIterableExtension) {
+ var packageCollectionImport =
+ _findImportDirective(node, 'package:collection/collection.dart');
+ if (packageCollectionImport != null) {
+ for (var combinator in packageCollectionImport.combinators) {
+ if (combinator is ShowCombinator) {
+ _ensureShows(combinator, 'IterableExtension');
+ }
+ }
+ } else {
+ (_fixBuilder._getChange(node) as NodeChangeForCompilationUnit)
+ .addImport(
+ 'package:collection/collection.dart', 'IterableExtension');
+ }
+ }
super.visitCompilationUnit(node);
}
@@ -930,6 +991,28 @@
}
super.visitVariableDeclarationList(node);
}
+
+ /// Creates the necessary changes to ensure that [combinator] shows [name].
+ void _ensureShows(ShowCombinator combinator, String name) {
+ if (combinator.shownNames.any((shownName) => shownName.name == name)) {
+ return;
+ }
+ (_fixBuilder._getChange(combinator) as NodeChangeForShowCombinator)
+ .addName(name);
+ }
+
+ /// Searches [unit] for an unprefixed import directive whose URI matches
+ /// [uri], returning it if found, or `null` if not found.
+ ImportDirective _findImportDirective(CompilationUnit unit, String uri) {
+ for (var directive in unit.directives) {
+ if (directive is ImportDirective &&
+ directive.prefix == null &&
+ directive.uriContent == uri) {
+ return directive;
+ }
+ }
+ return null;
+ }
}
/// Visitor that computes additional migrations on behalf of [FixBuilder] that
diff --git a/pkg/nnbd_migration/lib/src/nullability_migration_impl.dart b/pkg/nnbd_migration/lib/src/nullability_migration_impl.dart
index 8054089..101e5ea 100644
--- a/pkg/nnbd_migration/lib/src/nullability_migration_impl.dart
+++ b/pkg/nnbd_migration/lib/src/nullability_migration_impl.dart
@@ -59,6 +59,10 @@
final LineInfo Function(String) _getLineInfo;
+ /// Indicates whether we should transform iterable methods taking an "orElse"
+ /// parameter into their "OrNull" equivalents if possible.
+ final bool transformWhereOrNull;
+
/// Prepares to perform nullability migration.
///
/// If [permissive] is `true`, exception handling logic will try to proceed
@@ -72,12 +76,18 @@
/// Optional parameter [warnOnWeakCode] indicates whether weak-only code
/// should be warned about or removed (in the way specified by
/// [removeViaComments]).
+ ///
+ /// Optional parameter [transformWhereOrNull] indicates whether Iterable
+ /// methods should be transformed to their "OrNull" equivalents when possible.
+ /// This feature is a work in progress, so by default they are not
+ /// transformed.
NullabilityMigrationImpl(NullabilityMigrationListener listener,
LineInfo Function(String) getLineInfo,
{bool permissive = false,
NullabilityMigrationInstrumentation instrumentation,
bool removeViaComments = false,
- bool warnOnWeakCode = true})
+ bool warnOnWeakCode = true,
+ bool transformWhereOrNull = false})
: this._(
listener,
NullabilityGraph(instrumentation: instrumentation),
@@ -85,7 +95,8 @@
instrumentation,
removeViaComments,
warnOnWeakCode,
- getLineInfo);
+ getLineInfo,
+ transformWhereOrNull);
NullabilityMigrationImpl._(
this.listener,
@@ -94,7 +105,8 @@
this._instrumentation,
this.removeViaComments,
this.warnOnWeakCode,
- this._getLineInfo) {
+ this._getLineInfo,
+ this.transformWhereOrNull) {
_instrumentation?.immutableNodes(_graph.never, _graph.always);
_postmortemFileWriter?.graph = _graph;
}
@@ -131,7 +143,8 @@
_permissive ? listener : null,
unit,
warnOnWeakCode,
- _graph);
+ _graph,
+ transformWhereOrNull);
try {
DecoratedTypeParameterBounds.current = _decoratedTypeParameterBounds;
fixBuilder.visitAll();
@@ -214,6 +227,7 @@
unit.declaredElement.source,
_permissive ? listener : null,
_decoratedClassHierarchy,
+ transformWhereOrNull,
instrumentation: _instrumentation));
} finally {
DecoratedTypeParameterBounds.current = null;
diff --git a/pkg/nnbd_migration/lib/src/utilities/where_or_null_transformer.dart b/pkg/nnbd_migration/lib/src/utilities/where_or_null_transformer.dart
new file mode 100644
index 0000000..7bc0288
--- /dev/null
+++ b/pkg/nnbd_migration/lib/src/utilities/where_or_null_transformer.dart
@@ -0,0 +1,140 @@
+// Copyright (c) 2020, 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/element/element.dart';
+import 'package:analyzer/dart/element/type_provider.dart';
+import 'package:analyzer/dart/element/type_system.dart';
+
+/// Information about a method call that we might want to transform into its
+/// "OrNull" counterpart. See [WhereOrNullTransformer] for more information.
+class WhereOrNullTransformationInfo {
+ /// AST node of the method invocation.
+ final MethodInvocation methodInvocation;
+
+ /// AST node of the "orElse" argument of the method invocation.
+ final NamedExpression orElseArgument;
+
+ /// Original name of the method being called, prior to transformation.
+ final String originalName;
+
+ /// New method to call, after transformation.
+ final String replacementName;
+
+ WhereOrNullTransformationInfo(this.methodInvocation, this.orElseArgument,
+ this.originalName, this.replacementName);
+}
+
+/// Methods to assist in transforming calls to the `Iterable` methods
+/// `firstWhere`, `lastWhere`, and `singleWhere` into calls to the
+/// `package:collection` methods `firstWhereOrNull`, `lastWhereOrNull`, or
+/// `singleWhereOrNull`, where possible.
+///
+/// An example of the kind of code that can be transformed is:
+///
+/// int firstEven(Iterable<int> x)
+/// => x.firstWhere((x) => x.isEven, orElse: () => null);
+///
+/// We transform this into:
+///
+/// int firstEven(Iterable<int> x)
+/// => x.firstWhereOrNull((x) => x.isEven);
+///
+/// Without this transformation, the migrated result would have been:
+///
+/// int firstEven(Iterable<int?> x)
+/// => x.firstWhere((x) => x.isEven, orElse: () => null);
+///
+/// Which would have placed an otherwise unnecessary nullability requirement on
+/// the type argument of the type of `x`.
+class WhereOrNullTransformer {
+ static const _replacementNames = {
+ 'firstWhere': 'firstWhereOrNull',
+ 'lastWhere': 'lastWhereOrNull',
+ 'singleWhere': 'singleWhereOrNull'
+ };
+
+ final TypeProvider _typeProvider;
+
+ final TypeSystem _typeSystem;
+
+ WhereOrNullTransformer(this._typeProvider, this._typeSystem);
+
+ /// If [expression] is the `orElse` argument of a call that can be
+ /// transformed, returns information about the transformable call; otherwise
+ /// returns `null`.
+ WhereOrNullTransformationInfo tryTransformOrElseArgument(
+ Expression expression) =>
+ _tryTransformMethodInvocation(expression?.parent?.parent?.parent);
+
+ /// Searches [argumentList] for a named argument with the name "orElse". If
+ /// such an argument is found, and no other named arguments are found, it is
+ /// returned; otherwise `null` is returned.
+ NamedExpression _findOrElseArgument(ArgumentList argumentList) {
+ NamedExpression orElseArgument;
+ for (var argument in argumentList.arguments) {
+ if (argument is NamedExpression) {
+ if (argument.name.label.name == 'orElse') {
+ orElseArgument = argument;
+ } else {
+ // The presence of an unexpected named argument means the user is
+ // calling their own override of the method, and presumably they are
+ // using this named argument to trigger a special behavior of their
+ // override. So don't try to replace it.
+ return null;
+ }
+ }
+ }
+ return orElseArgument;
+ }
+
+ /// Determines if [element] is a method that can be transformed; if it can,
+ /// the name of the replacement is returned; otherwise, `null` is returned.
+ String _getTransformableMethodReplacementName(Element element) {
+ if (element is MethodElement) {
+ if (element.isStatic) return null;
+ var replacementName = _replacementNames[element.name];
+ if (replacementName == null) return null;
+ var enclosingElement = element.declaration.enclosingElement;
+ if (enclosingElement is ClassElement) {
+ // If the class is `Iterable` or a subtype of it, we consider the user
+ // to be calling a transformable method.
+ if (_typeSystem.isSubtypeOf(
+ enclosingElement.thisType, _typeProvider.iterableDynamicType)) {
+ return replacementName;
+ }
+ }
+ }
+ return null;
+ }
+
+ /// Checks whether [expression] is of the form `() => null`.
+ bool _isClosureReturningNull(Expression expression) {
+ if (expression is FunctionExpression) {
+ if (expression.typeParameters != null) return false;
+ if (expression.parameters.parameters.isNotEmpty) return false;
+ var body = expression.body;
+ if (body is ExpressionFunctionBody) {
+ if (body.expression is NullLiteral) return true;
+ }
+ }
+ return false;
+ }
+
+ /// If [node] is a call that can be transformed, returns information about the
+ /// transformable call; otherwise returns `null`.
+ WhereOrNullTransformationInfo _tryTransformMethodInvocation(AstNode node) {
+ if (node is MethodInvocation) {
+ var replacementName =
+ _getTransformableMethodReplacementName(node.methodName.staticElement);
+ if (replacementName == null) return null;
+ var orElseArgument = _findOrElseArgument(node.argumentList);
+ if (orElseArgument == null) return null;
+ if (!_isClosureReturningNull(orElseArgument.expression)) return null;
+ return WhereOrNullTransformationInfo(
+ node, orElseArgument, node.methodName.name, replacementName);
+ }
+ return null;
+ }
+}
diff --git a/pkg/nnbd_migration/test/api_test.dart b/pkg/nnbd_migration/test/api_test.dart
index 7205cd2..629a6ac 100644
--- a/pkg/nnbd_migration/test/api_test.dart
+++ b/pkg/nnbd_migration/test/api_test.dart
@@ -53,7 +53,8 @@
var migration = NullabilityMigration(listener, getLineInfo,
permissive: _usePermissiveMode,
removeViaComments: removeViaComments,
- warnOnWeakCode: warnOnWeakCode);
+ warnOnWeakCode: warnOnWeakCode,
+ transformWhereOrNull: true);
for (var path in input.keys) {
if (!(session.getFile(path)).isPart) {
for (var unit in (await session.getResolvedLibrary(path)).units) {
@@ -2749,6 +2750,76 @@
await _checkSingleFileChanges(content, expected);
}
+ Future<void> test_firstWhere_non_nullable() async {
+ var content = '''
+int firstEven(Iterable<int> x)
+ => x.firstWhere((x) => x.isEven, orElse: () => null);
+''';
+ var expected = '''
+import 'package:collection/collection.dart' show IterableExtension;
+
+int? firstEven(Iterable<int> x)
+ => x.firstWhereOrNull((x) => x.isEven);
+''';
+ await _checkSingleFileChanges(content, expected);
+ }
+
+ Future<void> test_firstWhere_non_nullable_with_cast() async {
+ var content = '''
+int firstNonZero(Iterable<num> x)
+ => x.firstWhere((x) => x != 0, orElse: () => null);
+''';
+ var expected = '''
+import 'package:collection/collection.dart' show IterableExtension;
+
+int? firstNonZero(Iterable<num> x)
+ => x.firstWhereOrNull((x) => x != 0) as int?;
+''';
+ await _checkSingleFileChanges(content, expected);
+ }
+
+ Future<void> test_firstWhere_non_nullable_with_non_null_assertion() async {
+ var content = '''
+int/*!*/ firstEven(Iterable<int> x)
+ => x.firstWhere((x) => x.isEven, orElse: () => null);
+''';
+ var expected = '''
+import 'package:collection/collection.dart' show IterableExtension;
+
+int firstEven(Iterable<int> x)
+ => x.firstWhereOrNull((x) => x.isEven)!;
+''';
+ await _checkSingleFileChanges(content, expected);
+ }
+
+ Future<void> test_firstWhere_nullable() async {
+ var content = '''
+int firstEven(Iterable<int> x)
+ => x.firstWhere((x) => x.isEven, orElse: () => null);
+f() => firstEven([null]);
+''';
+ var expected = '''
+int? firstEven(Iterable<int?> x)
+ => x.firstWhere((x) => x!.isEven, orElse: () => null);
+f() => firstEven([null]);
+''';
+ await _checkSingleFileChanges(content, expected);
+ }
+
+ Future<void> test_firstWhere_nullable_with_cast() async {
+ var content = '''
+int firstNonZero(Iterable<num> x)
+ => x.firstWhere((x) => x != 0, orElse: () => null);
+f() => firstNonZero([null]);
+''';
+ var expected = '''
+int? firstNonZero(Iterable<num?> x)
+ => x.firstWhere((x) => x != 0, orElse: () => null) as int?;
+f() => firstNonZero([null]);
+''';
+ await _checkSingleFileChanges(content, expected);
+ }
+
Future<void> test_flow_analysis_complex() async {
var content = '''
int f(int x) {
@@ -4012,6 +4083,34 @@
await _checkSingleFileChanges(content, expected);
}
+ Future<void> test_lastWhere_non_nullable() async {
+ var content = '''
+int lastEven(Iterable<int> x)
+ => x.lastWhere((x) => x.isEven, orElse: () => null);
+''';
+ var expected = '''
+import 'package:collection/collection.dart' show IterableExtension;
+
+int? lastEven(Iterable<int> x)
+ => x.lastWhereOrNull((x) => x.isEven);
+''';
+ await _checkSingleFileChanges(content, expected);
+ }
+
+ Future<void> test_lastWhere_nullable() async {
+ var content = '''
+int lastEven(Iterable<int> x)
+ => x.lastWhere((x) => x.isEven, orElse: () => null);
+f() => lastEven([null]);
+''';
+ var expected = '''
+int? lastEven(Iterable<int?> x)
+ => x.lastWhere((x) => x!.isEven, orElse: () => null);
+f() => lastEven([null]);
+''';
+ await _checkSingleFileChanges(content, expected);
+ }
+
Future<void> test_late_final_hint_instance_field_without_constructor() async {
var content = '''
class C {
@@ -6013,6 +6112,34 @@
await _checkSingleFileChanges(content, expected);
}
+ Future<void> test_singleWhere_non_nullable() async {
+ var content = '''
+int singleEven(Iterable<int> x)
+ => x.singleWhere((x) => x.isEven, orElse: () => null);
+''';
+ var expected = '''
+import 'package:collection/collection.dart' show IterableExtension;
+
+int? singleEven(Iterable<int> x)
+ => x.singleWhereOrNull((x) => x.isEven);
+''';
+ await _checkSingleFileChanges(content, expected);
+ }
+
+ Future<void> test_singleWhere_nullable() async {
+ var content = '''
+int singleEven(Iterable<int> x)
+ => x.singleWhere((x) => x.isEven, orElse: () => null);
+f() => singleEven([null]);
+''';
+ var expected = '''
+int? singleEven(Iterable<int?> x)
+ => x.singleWhere((x) => x!.isEven, orElse: () => null);
+f() => singleEven([null]);
+''';
+ await _checkSingleFileChanges(content, expected);
+ }
+
@FailingTest(issue: 'https://github.com/dart-lang/sdk/issues/40728')
Future<void> test_soft_edge_for_assigned_variable() async {
var content = '''
diff --git a/pkg/nnbd_migration/test/edge_builder_test.dart b/pkg/nnbd_migration/test/edge_builder_test.dart
index 2e9efaa..04aebe5 100644
--- a/pkg/nnbd_migration/test/edge_builder_test.dart
+++ b/pkg/nnbd_migration/test/edge_builder_test.dart
@@ -3126,6 +3126,40 @@
hard: true);
}
+ Future<void> test_firstWhere_edges() async {
+ await analyze('''
+int firstEven(Iterable<int> x)
+ => x.firstWhere((x) => x.isEven, orElse: () => null);
+''');
+
+ // Normally there would be an edge from the return type of `() => null` to
+ // a substitution node that pointed to the type argument to the type of `x`,
+ // and another substitution node would point from this to the return type of
+ // `firstEven`. However, since we may replace `firstWhere` with
+ // `firstWhereOrNull` in order to avoid having to make `x`'s type argument
+ // nullable, we need a synthetic edge to ensure that the return type of
+ // `firstEven` is nullable.
+ var closureReturnType = decoratedExpressionType('() => null').returnType;
+ var firstWhereReturnType = variables
+ .decoratedExpressionType(findNode.methodInvocation('firstWhere'));
+ assertEdge(closureReturnType.node, firstWhereReturnType.node, hard: false);
+
+ // There should also be an edge from a substitution node to the return type
+ // of `firstWhere`, to account for the normal data flow (when the element is
+ // found).
+ var typeParameterType = decoratedTypeAnnotation('int>');
+ var firstWhereType = variables.decoratedElementType(findNode
+ .methodInvocation('firstWhere')
+ .methodName
+ .staticElement
+ .declaration);
+ assertEdge(
+ substitutionNode(
+ typeParameterType.node, firstWhereType.returnType.node),
+ firstWhereReturnType.node,
+ hard: false);
+ }
+
Future<void> test_for_each_element_with_declaration() async {
await analyze('''
void f(List<int> l) {
diff --git a/pkg/nnbd_migration/test/fix_aggregator_test.dart b/pkg/nnbd_migration/test/fix_aggregator_test.dart
index 7486bc1..980e9da 100644
--- a/pkg/nnbd_migration/test/fix_aggregator_test.dart
+++ b/pkg/nnbd_migration/test/fix_aggregator_test.dart
@@ -32,6 +32,209 @@
(testAnalysisResult.typeProvider as TypeProviderImpl)
.asNonNullableByDefault;
+ Future<void> test_addImport_after_library() async {
+ await analyze('''
+library foo;
+
+main() {}
+''');
+ var previewInfo = run({
+ findNode.unit: NodeChangeForCompilationUnit()
+ ..addImport('package:collection/collection.dart', 'IterableExtension')
+ });
+ expect(previewInfo.applyTo(code), '''
+library foo;
+
+import 'package:collection/collection.dart' show IterableExtension;
+
+main() {}
+''');
+ }
+
+ Future<void> test_addImport_after_library_before_other() async {
+ addPackageFile('fixnum', 'fixnum.dart', '');
+ await analyze('''
+library foo;
+
+import 'package:fixnum/fixnum.dart';
+
+main() {}
+''');
+ var previewInfo = run({
+ findNode.unit: NodeChangeForCompilationUnit()
+ ..addImport('package:collection/collection.dart', 'IterableExtension')
+ });
+ expect(previewInfo.applyTo(code), '''
+library foo;
+
+import 'package:collection/collection.dart' show IterableExtension;
+import 'package:fixnum/fixnum.dart';
+
+main() {}
+''');
+ }
+
+ Future<void> test_addImport_atEnd_multiple() async {
+ addPackageFile('args', 'args.dart', '');
+ await analyze('''
+import 'package:args/args.dart';
+
+main() {}
+''');
+ var previewInfo = run({
+ findNode.unit: NodeChangeForCompilationUnit()
+ ..addImport('package:fixnum/fixnum.dart', 'Int32')
+ ..addImport('package:collection/collection.dart', 'IterableExtension')
+ });
+ expect(previewInfo.applyTo(code), '''
+import 'package:args/args.dart';
+import 'package:collection/collection.dart' show IterableExtension;
+import 'package:fixnum/fixnum.dart' show Int32;
+
+main() {}
+''');
+ }
+
+ Future<void> test_addImport_atStart_multiple() async {
+ addPackageFile('fixnum', 'fixnum.dart', '');
+ await analyze('''
+import 'package:fixnum/fixnum.dart';
+
+main() {}
+''');
+ var previewInfo = run({
+ findNode.unit: NodeChangeForCompilationUnit()
+ ..addImport('package:collection/collection.dart', 'IterableExtension')
+ ..addImport('package:args/args.dart', 'ArgParser')
+ });
+ expect(previewInfo.applyTo(code), '''
+import 'package:args/args.dart' show ArgParser;
+import 'package:collection/collection.dart' show IterableExtension;
+import 'package:fixnum/fixnum.dart';
+
+main() {}
+''');
+ }
+
+ Future<void> test_addImport_before_export() async {
+ await analyze('''
+export 'dart:async';
+
+main() {}
+''');
+ var previewInfo = run({
+ findNode.unit: NodeChangeForCompilationUnit()
+ ..addImport('package:collection/collection.dart', 'IterableExtension')
+ });
+ expect(previewInfo.applyTo(code), '''
+import 'package:collection/collection.dart' show IterableExtension;
+export 'dart:async';
+
+main() {}
+''');
+ }
+
+ Future<void> test_addImport_no_previous_imports_multiple() async {
+ await analyze('''
+main() {}
+''');
+ var previewInfo = run({
+ findNode.unit: NodeChangeForCompilationUnit()
+ ..addImport('dart:async', 'Future')
+ ..addImport('dart:math', 'sin')
+ });
+ expect(previewInfo.applyTo(code), '''
+import 'dart:async' show Future;
+import 'dart:math' show sin;
+
+main() {}
+''');
+ }
+
+ Future<void> test_addImport_recursive() async {
+ addPackageFile('args', 'args.dart', '');
+ addPackageFile('fixnum', 'fixnum.dart', 'class Int32 {}');
+ await analyze('''
+import 'package:args/args.dart';
+import 'package:fixnum/fixnum.dart' show Int32;
+
+main() => null;
+''');
+ var previewInfo = run({
+ findNode.unit: NodeChangeForCompilationUnit()
+ ..addImport('package:collection/collection.dart', 'IterableExtension'),
+ findNode.import('package:fixnum').combinators[0]:
+ NodeChangeForShowCombinator()..addName('Int64'),
+ findNode.expression('null'): NodeChangeForExpression()..addNullCheck(null)
+ });
+ expect(previewInfo.applyTo(code), '''
+import 'package:args/args.dart';
+import 'package:collection/collection.dart' show IterableExtension;
+import 'package:fixnum/fixnum.dart' show Int32, Int64;
+
+main() => null!;
+''');
+ }
+
+ Future<void> test_addImport_sort_shown_names() async {
+ await analyze('''
+main() {}
+''');
+ var previewInfo = run({
+ findNode.unit: NodeChangeForCompilationUnit()
+ ..addImport('dart:async', 'Stream')
+ ..addImport('dart:async', 'Future')
+ });
+ expect(previewInfo.applyTo(code), '''
+import 'dart:async' show Future, Stream;
+
+main() {}
+''');
+ }
+
+ Future<void> test_addImport_sorted() async {
+ addPackageFile('args', 'args.dart', '');
+ addPackageFile('fixnum', 'fixnum.dart', '');
+ await analyze('''
+import 'package:args/args.dart';
+import 'package:fixnum/fixnum.dart';
+
+main() {}
+''');
+ var previewInfo = run({
+ findNode.unit: NodeChangeForCompilationUnit()
+ ..addImport('package:collection/collection.dart', 'IterableExtension')
+ });
+ expect(previewInfo.applyTo(code), '''
+import 'package:args/args.dart';
+import 'package:collection/collection.dart' show IterableExtension;
+import 'package:fixnum/fixnum.dart';
+
+main() {}
+''');
+ }
+
+ Future<void> test_addImport_sorted_multiple() async {
+ addPackageFile('collection', 'collection.dart', '');
+ await analyze('''
+import 'package:collection/collection.dart';
+
+main() {}
+''');
+ var previewInfo = run({
+ findNode.unit: NodeChangeForCompilationUnit()
+ ..addImport('package:fixnum/fixnum.dart', 'Int32')
+ ..addImport('package:args/args.dart', 'ArgParser')
+ });
+ expect(previewInfo.applyTo(code), '''
+import 'package:args/args.dart' show ArgParser;
+import 'package:collection/collection.dart';
+import 'package:fixnum/fixnum.dart' show Int32;
+
+main() {}
+''');
+ }
+
Future<void> test_addRequired() async {
await analyze('f({int x}) => 0;');
var previewInfo = run({
@@ -41,6 +244,45 @@
expect(previewInfo.applyTo(code), 'f({required int x}) => 0;');
}
+ Future<void> test_addShownName_atEnd_multiple() async {
+ await analyze("import 'dart:math' show cos;");
+ var previewInfo = run({
+ findNode.import('dart:math').combinators[0]: NodeChangeForShowCombinator()
+ ..addName('tan')
+ ..addName('sin')
+ });
+ expect(previewInfo.applyTo(code), "import 'dart:math' show cos, sin, tan;");
+ }
+
+ Future<void> test_addShownName_atStart_multiple() async {
+ await analyze("import 'dart:math' show tan;");
+ var previewInfo = run({
+ findNode.import('dart:math').combinators[0]: NodeChangeForShowCombinator()
+ ..addName('sin')
+ ..addName('cos')
+ });
+ expect(previewInfo.applyTo(code), "import 'dart:math' show cos, sin, tan;");
+ }
+
+ Future<void> test_addShownName_sorted() async {
+ await analyze("import 'dart:math' show cos, tan;");
+ var previewInfo = run({
+ findNode.import('dart:math').combinators[0]: NodeChangeForShowCombinator()
+ ..addName('sin')
+ });
+ expect(previewInfo.applyTo(code), "import 'dart:math' show cos, sin, tan;");
+ }
+
+ Future<void> test_addShownName_sorted_multiple() async {
+ await analyze("import 'dart:math' show sin;");
+ var previewInfo = run({
+ findNode.import('dart:math').combinators[0]: NodeChangeForShowCombinator()
+ ..addName('tan')
+ ..addName('cos')
+ });
+ expect(previewInfo.applyTo(code), "import 'dart:math' show cos, sin, tan;");
+ }
+
Future<void> test_adjacentFixes() async {
await analyze('f(a, b) => a + b;');
var aRef = findNode.simple('a +');
@@ -54,6 +296,56 @@
expect(previewInfo.applyTo(code), 'f(a, b) => (a! + b!)!;');
}
+ Future<void> test_argument_list_drop_all_arguments() async {
+ var content = '''
+f([int x, int y]) => null;
+g(int x, int y) => f(x, y);
+''';
+ await analyze(content);
+ var previewInfo = run({
+ findNode.methodInvocation('f(x').argumentList: NodeChangeForArgumentList()
+ ..dropArgument(findNode.simple('y);'))
+ ..dropArgument(findNode.simple('x, y'))
+ });
+ expect(previewInfo.applyTo(code), '''
+f([int x, int y]) => null;
+g(int x, int y) => f();
+''');
+ }
+
+ Future<void> test_argument_list_drop_one_argument() async {
+ var content = '''
+f([int x, int y]) => null;
+g(int x, int y) => f(x, y);
+''';
+ await analyze(content);
+ var previewInfo = run({
+ findNode.methodInvocation('f(x').argumentList: NodeChangeForArgumentList()
+ ..dropArgument(findNode.simple('y);'))
+ });
+ expect(previewInfo.applyTo(code), '''
+f([int x, int y]) => null;
+g(int x, int y) => f(x);
+''');
+ }
+
+ Future<void> test_argument_list_recursive_changes() async {
+ var content = '''
+f([int x, int y]) => null;
+g(int x, int y) => f(x, y);
+''';
+ await analyze(content);
+ var previewInfo = run({
+ findNode.methodInvocation('f(x').argumentList: NodeChangeForArgumentList()
+ ..dropArgument(findNode.simple('y);')),
+ findNode.simple('x, y'): NodeChangeForExpression()..addNullCheck(null)
+ });
+ expect(previewInfo.applyTo(code), '''
+f([int x, int y]) => null;
+g(int x, int y) => f(x!);
+''');
+ }
+
Future<void> test_assignment_add_null_check() async {
var content = 'f(int x, int y) => x += y;';
await analyze(content);
@@ -802,6 +1094,23 @@
expect(previewInfo.applyTo(code), 'f(int? x) {}');
}
+ Future<void> test_methodName_change() async {
+ await analyze('f() => f();');
+ var previewInfo = run({
+ findNode.methodInvocation('f();').methodName: NodeChangeForMethodName()
+ ..replacement = 'g'
+ });
+ expect(previewInfo.applyTo(code), 'f() => g();');
+ }
+
+ Future<void> test_methodName_no_change() async {
+ await analyze('f() => f();');
+ var previewInfo = run({
+ findNode.methodInvocation('f();').methodName: NodeChangeForMethodName()
+ });
+ expect(previewInfo, isNull);
+ }
+
Future<void> test_noChangeToTypeAnnotation() async {
await analyze('int x = 0;');
var typeName = findNode.typeName('int');
diff --git a/pkg/nnbd_migration/test/fix_builder_test.dart b/pkg/nnbd_migration/test/fix_builder_test.dart
index 4e3e6e9..0bf7e71 100644
--- a/pkg/nnbd_migration/test/fix_builder_test.dart
+++ b/pkg/nnbd_migration/test/fix_builder_test.dart
@@ -77,6 +77,16 @@
'removeLanguageVersionComment',
true);
+ static final isAddImportOfIterableExtension =
+ TypeMatcher<NodeChangeForCompilationUnit>()
+ .having((c) => c.addImports, 'addImports', {
+ 'package:collection/collection.dart': {'IterableExtension'}
+ });
+
+ static final isAddShowOfIterableExtension =
+ TypeMatcher<NodeChangeForShowCombinator>().having((c) => c.addNames,
+ 'addNames', unorderedEquals(['IterableExtension']));
+
static final isRemoveNullAwareness =
TypeMatcher<NodeChangeForPropertyAccess>()
.having((c) => c.removeNullAwareness, 'removeNullAwareness', true);
@@ -106,11 +116,21 @@
return unit;
}
+ TypeMatcher<NodeChangeForArgumentList> isDropArgument(
+ dynamic argumentsToDrop) =>
+ TypeMatcher<NodeChangeForArgumentList>()
+ .having((c) => c.argumentsToDrop, 'argumentsToDrop', argumentsToDrop);
+
TypeMatcher<AtomicEditInfo> isInfo(description, fixReasons) =>
TypeMatcher<AtomicEditInfo>()
.having((i) => i.description, 'description', description)
.having((i) => i.fixReasons, 'fixReasons', fixReasons);
+ TypeMatcher<NodeChangeForMethodName> isMethodNameChange(
+ dynamic replacement) =>
+ TypeMatcher<NodeChangeForMethodName>()
+ .having((c) => c.replacement, 'replacement', replacement);
+
Map<AstNode, NodeChange> scopedChanges(
FixBuilder fixBuilder, AstNode scope) =>
{
@@ -1342,6 +1362,24 @@
changes: {findNode.simple('y;'): isNullCheck});
}
+ Future<void> test_firstWhere_transform() async {
+ await analyze('''
+_f(Iterable<int> x) => x.firstWhere((n) => n.isEven, orElse: () => null);
+''');
+ var methodInvocation = findNode.methodInvocation('firstWhere');
+ var functionExpression = findNode.functionExpression('() => null');
+ var fixBuilder = visitSubexpression(methodInvocation, 'int?', changes: {
+ methodInvocation.methodName: isMethodNameChange('firstWhereOrNull'),
+ methodInvocation.argumentList:
+ isDropArgument(unorderedEquals([functionExpression.parent])),
+ // Behavior of the function expression and its subexpression don't matter
+ // because they're being dropped.
+ functionExpression.parent: anything,
+ findNode.nullLiteral('null'): anything
+ });
+ expect(fixBuilder.needsIterableExtension, true);
+ }
+
Future<void> test_functionExpressionInvocation_dynamic() async {
await analyze('''
_f(dynamic d) => d();
@@ -1543,6 +1581,75 @@
});
}
+ Future<void> test_import_IterableExtension_already_imported_add_show() async {
+ addPackageFile('collection', 'collection.dart', 'class PriorityQueue {}');
+ await analyze('''
+import 'package:collection/collection.dart' show PriorityQueue;
+
+main() {}
+''');
+ visitAll(injectNeedsIterableExtension: true, changes: {
+ findNode.import('package:collection').combinators[0]:
+ isAddShowOfIterableExtension
+ });
+ }
+
+ Future<void> test_import_IterableExtension_already_imported_all() async {
+ addPackageFile('collection', 'collection.dart', '');
+ await analyze('''
+import 'package:collection/collection.dart';
+
+main() {}
+''');
+ visitAll(injectNeedsIterableExtension: true, changes: {});
+ }
+
+ Future<void>
+ test_import_IterableExtension_already_imported_and_shown() async {
+ addPackageFile('collection', 'collection.dart',
+ 'extension IterableExtension<T> on Iterable<T> {}');
+ await analyze('''
+import 'package:collection/collection.dart' show IterableExtension;
+
+main() {}
+''');
+ visitAll(injectNeedsIterableExtension: true, changes: {});
+ }
+
+ Future<void> test_import_IterableExtension_already_imported_prefixed() async {
+ addPackageFile('collection', 'collection.dart', '');
+ await analyze('''
+import 'package:collection/collection.dart' as c;
+
+main() {}
+''');
+ visitAll(
+ injectNeedsIterableExtension: true,
+ changes: {findNode.unit: isAddImportOfIterableExtension});
+ }
+
+ Future<void> test_import_IterableExtension_other_import() async {
+ addPackageFile(
+ 'foo', 'foo.dart', 'extension IterableExtension<T> on Iterable<T> {}');
+ await analyze('''
+import 'package:foo/foo.dart' show IterableExtension;
+
+main() {}
+''');
+ visitAll(
+ injectNeedsIterableExtension: true,
+ changes: {findNode.unit: isAddImportOfIterableExtension});
+ }
+
+ Future<void> test_import_IterableExtension_simple() async {
+ await analyze('''
+main() {}
+''');
+ visitAll(
+ injectNeedsIterableExtension: true,
+ changes: {findNode.unit: isAddImportOfIterableExtension});
+ }
+
Future<void> test_indexExpression_dynamic() async {
await analyze('''
Object/*!*/ _f(dynamic d, int/*?*/ i) => d[i];
@@ -3295,8 +3402,12 @@
void visitAll(
{Map<AstNode, Matcher> changes = const <Expression, Matcher>{},
- Map<AstNode, Set<Problem>> problems = const <AstNode, Set<Problem>>{}}) {
+ Map<AstNode, Set<Problem>> problems = const <AstNode, Set<Problem>>{},
+ bool injectNeedsIterableExtension = false}) {
var fixBuilder = _createFixBuilder(testUnit);
+ if (injectNeedsIterableExtension) {
+ fixBuilder.needsIterableExtension = true;
+ }
fixBuilder.visitAll();
expect(scopedChanges(fixBuilder, testUnit), changes);
expect(scopedProblems(fixBuilder, testUnit), problems);
@@ -3330,7 +3441,7 @@
expect(scopedProblems(fixBuilder, node), problems);
}
- void visitSubexpression(Expression node, String expectedType,
+ FixBuilder visitSubexpression(Expression node, String expectedType,
{Map<AstNode, Matcher> changes = const <Expression, Matcher>{},
Map<AstNode, Set<Problem>> problems = const <AstNode, Set<Problem>>{},
bool warnOnWeakCode = false}) {
@@ -3340,6 +3451,7 @@
expect(type.getDisplayString(withNullability: true), expectedType);
expect(scopedChanges(fixBuilder, node), changes);
expect(scopedProblems(fixBuilder, node), problems);
+ return fixBuilder;
}
void visitTypeAnnotation(TypeAnnotation node, String expectedType,
@@ -3383,7 +3495,8 @@
null,
scope.thisOrAncestorOfType<CompilationUnit>(),
warnOnWeakCode,
- graph);
+ graph,
+ true);
}
bool _isInScope(AstNode node, AstNode scope) {
diff --git a/pkg/nnbd_migration/test/front_end/region_renderer_test.dart b/pkg/nnbd_migration/test/front_end/region_renderer_test.dart
index 7fad2e6..ab9663c 100644
--- a/pkg/nnbd_migration/test/front_end/region_renderer_test.dart
+++ b/pkg/nnbd_migration/test/front_end/region_renderer_test.dart
@@ -108,8 +108,17 @@
expect(entry.link, isNotNull);
var sdkCoreLib = convertPath('/sdk/lib/core/core.dart');
var sdkCoreLibUriPath = resourceProvider.pathContext.toUri(sdkCoreLib).path;
- expect(entry.link.href,
- equals('$sdkCoreLibUriPath?offset=3730&line=166&authToken=AUTH_TOKEN'));
+ var coreLibText = resourceProvider.getFile(sdkCoreLib).readAsStringSync();
+ var expectedOffset =
+ 'List.from'.allMatches(coreLibText).single.start + 'List.'.length;
+ var expectedLine =
+ '\n'.allMatches(coreLibText.substring(0, expectedOffset)).length + 1;
+ expect(
+ entry.link.href,
+ equals('$sdkCoreLibUriPath?'
+ 'offset=$expectedOffset&'
+ 'line=$expectedLine&'
+ 'authToken=AUTH_TOKEN'));
// On Windows, the path will simply be the absolute path to the core
// library, because there is no relative route from C:\ to D:\. On Posix,
// the path is relative.
diff --git a/pkg/nnbd_migration/test/migration_visitor_test_base.dart b/pkg/nnbd_migration/test/migration_visitor_test_base.dart
index 9fd3eeb..06b0451 100644
--- a/pkg/nnbd_migration/test/migration_visitor_test_base.dart
+++ b/pkg/nnbd_migration/test/migration_visitor_test_base.dart
@@ -149,7 +149,7 @@
var unit = await super.analyze(code);
decoratedClassHierarchy = DecoratedClassHierarchy(variables, graph);
unit.accept(EdgeBuilder(typeProvider, typeSystem, variables, graph,
- testSource, null, decoratedClassHierarchy));
+ testSource, null, decoratedClassHierarchy, true));
return unit;
}
}
diff --git a/pkg/nnbd_migration/test/utilities/test_all.dart b/pkg/nnbd_migration/test/utilities/test_all.dart
index 8a172cc..dd93187 100644
--- a/pkg/nnbd_migration/test/utilities/test_all.dart
+++ b/pkg/nnbd_migration/test/utilities/test_all.dart
@@ -6,12 +6,17 @@
import 'multi_future_tracker_test.dart' as multi_future_tracker_test;
import 'scoped_set_test.dart' as scoped_set_test;
+import 'source_edit_diff_formatter_test.dart'
+ as source_edit_diff_formatter_test;
import 'subprocess_launcher_test.dart' as subprocess_launcher_test;
+import 'where_or_null_transformer_test.dart' as where_or_null_transformer_test;
main() {
defineReflectiveSuite(() {
multi_future_tracker_test.main();
scoped_set_test.main();
+ source_edit_diff_formatter_test.main();
subprocess_launcher_test.main();
+ where_or_null_transformer_test.main();
});
}
diff --git a/pkg/nnbd_migration/test/utilities/where_or_null_transformer_test.dart b/pkg/nnbd_migration/test/utilities/where_or_null_transformer_test.dart
new file mode 100644
index 0000000..27e7033
--- /dev/null
+++ b/pkg/nnbd_migration/test/utilities/where_or_null_transformer_test.dart
@@ -0,0 +1,148 @@
+// Copyright (c) 2020, 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/element/type_provider.dart';
+import 'package:analyzer/dart/element/type_system.dart';
+import 'package:nnbd_migration/src/utilities/where_or_null_transformer.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../abstract_single_unit.dart';
+
+main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(WhereOrNullTransformerTest);
+ });
+}
+
+@reflectiveTest
+class WhereOrNullTransformerTest extends AbstractSingleUnitTest {
+ WhereOrNullTransformer transformer;
+
+ TypeProvider get typeProvider => testAnalysisResult.typeProvider;
+
+ TypeSystem get typeSystem => testAnalysisResult.typeSystem;
+
+ Future<void> analyze(String code) async {
+ await resolveTestUnit(code);
+ transformer = WhereOrNullTransformer(typeProvider, typeSystem);
+ }
+
+ Future<void> test_match() async {
+ await analyze('''
+f(List<int> x) => x.firstWhere((i) => i.isEven, orElse: () => null);
+''');
+ var orElseExpression = findNode.functionExpression('() => null');
+ var transformationInfo =
+ transformer.tryTransformOrElseArgument(orElseExpression);
+ expect(transformationInfo, isNotNull);
+ expect(transformationInfo.methodInvocation,
+ same(findNode.methodInvocation('firstWhere')));
+ expect(transformationInfo.orElseArgument, same(orElseExpression.parent));
+ expect(transformationInfo.originalName, 'firstWhere');
+ expect(transformationInfo.replacementName, 'firstWhereOrNull');
+ }
+
+ Future<void> test_match_extended() async {
+ await analyze('''
+abstract class C implements Iterable<int> {
+ int firstWhere(bool test(int element), {int orElse()}) => null;
+}
+f(C c) => c.firstWhere((i) => i.isEven, orElse: () => null);
+''');
+ var orElseExpression = findNode.functionExpression('() => null');
+ var transformationInfo =
+ transformer.tryTransformOrElseArgument(orElseExpression);
+ expect(transformationInfo, isNotNull);
+ expect(transformationInfo.methodInvocation,
+ same(findNode.methodInvocation('firstWhere((')));
+ expect(transformationInfo.orElseArgument, same(orElseExpression.parent));
+ expect(transformationInfo.originalName, 'firstWhere');
+ expect(transformationInfo.replacementName, 'firstWhereOrNull');
+ }
+
+ Future<void> test_mismatch_misnamed_method() async {
+ await analyze('''
+abstract class C extends Iterable<int> {
+ int fooBar(bool test(int element), {int orElse()});
+}
+f(C c) => c.fooBar((i) => i.isEven, orElse: () => null);
+''');
+ expect(
+ transformer.tryTransformOrElseArgument(
+ findNode.functionExpression('() => null')),
+ isNull);
+ }
+
+ Future<void> test_mismatch_orElse_expression() async {
+ await analyze('''
+f(List<int> x) => x.firstWhere((i) => i.isEven, orElse: () => 0);
+''');
+ expect(
+ transformer
+ .tryTransformOrElseArgument(findNode.functionExpression('() => 0')),
+ isNull);
+ }
+
+ Future<void> test_mismatch_orElse_name() async {
+ await analyze('''
+abstract class C extends Iterable<int> {
+ @override
+ int firstWhere(bool test(int element), {int orElse(), int ifSo()});
+}
+f(C c) => c.firstWhere((i) => i.isEven, ifSo: () => null);
+''');
+ expect(
+ transformer.tryTransformOrElseArgument(
+ findNode.functionExpression('() => null')),
+ isNull);
+ }
+
+ Future<void> test_mismatch_orElse_named_parameter() async {
+ await analyze('''
+f(List<int> x) => x.firstWhere((i) => i.isEven, orElse: ({int x}) => null);
+''');
+ expect(
+ transformer.tryTransformOrElseArgument(
+ findNode.functionExpression(') => null')),
+ isNull);
+ }
+
+ Future<void> test_mismatch_orElse_optional_parameter() async {
+ await analyze('''
+f(List<int> x) => x.firstWhere((i) => i.isEven, orElse: ([int x]) => null);
+''');
+ expect(
+ transformer.tryTransformOrElseArgument(
+ findNode.functionExpression(') => null')),
+ isNull);
+ }
+
+ Future<void> test_mismatch_orElse_presence_of_other_arg() async {
+ await analyze('''
+abstract class C extends Iterable<int> {
+ @override
+ int firstWhere(bool test(int element), {int orElse(), int ifSo()});
+}
+f(C c) => c.firstWhere((i) => i.isEven, orElse: () => null, ifSo: () => null);
+''');
+ expect(
+ transformer.tryTransformOrElseArgument(
+ findNode.functionExpression('() => null,')),
+ isNull);
+ }
+
+ Future<void> test_mismatch_unrelated_type() async {
+ await analyze('''
+abstract class C {
+ int firstWhere(bool test(int element), {int orElse()});
+}
+f(C c) => c.firstWhere((i) => i.isEven, orElse: () => null);
+''');
+ expect(
+ transformer.tryTransformOrElseArgument(
+ findNode.functionExpression('() => null')),
+ isNull);
+ }
+}
diff --git a/tools/VERSION b/tools/VERSION
index f4481ae..1f5a84d 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 11
PATCH 0
-PRERELEASE 238
+PRERELEASE 239
PRERELEASE_PATCH 0
\ No newline at end of file
