Version 2.18.0-275.0.dev
Merge commit '33295f8247d4dfc259f1a275598434316db34a16' into 'dev'
diff --git a/CHANGELOG.md b/CHANGELOG.md
index cfad1f4..acadd9a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -57,6 +57,27 @@
collected earlier than they were before
(see issue [#36983](https://github.com/dart-lang/sdk/issues/36983) for details).
+
+### Tools
+
+#### Dart command line
+
+#### Linter
+
+Updated the Linter to `1.26.0`, which includes changes that
+
+- add new lint: `combinators_ordering`.
+- fix `use_colored_box` and `use_decorated_box` to not over-report on containers without
+ a child.
+- fix `unnecessary_parenthesis` false positives on a map-or-set literal at the start of
+ an expression statement.
+- fix `prefer_final_locals` false positives reporting on fields.
+- fix `unnecessary_overrides` to allow overrides on `@Protected`members.
+- fix `avoid_multiple_declarations_per_line` false positives in `for` statements.
+- fix `prefer_final_locals` false positives on declaration lists with at least one
+ non-final variable.
+- fix`use_build_context_synchronously` to handle `await`s in `if` conditions.
+
## 2.18.0
### Language
diff --git a/DEPS b/DEPS
index 4a6f2e9..f7fc977 100644
--- a/DEPS
+++ b/DEPS
@@ -122,7 +122,7 @@
"intl_rev": "e9b573679de5e703d89a242b9dca331c772979ef",
"jinja2_rev": "2222b31554f03e62600cd7e383376a7c187967a1",
"json_rpc_2_rev": "805e6536dd961d66f6b8cd46d8f3e61774f957c9",
- "linter_rev": "1ddc70948d94f2449fec69a95e3ceb7b6b6c8348", # manually rev'd
+ "linter_rev": "b4afc10055f3009478da1eac1827f9fef42c3759", # 1.26.0
"lints_rev": "8294e5648ab49474541527e2911e72e4c5aefe55",
"logging_rev": "f6979e3bc3b6e1847a08335b7eb6304e18986195",
"markdown_rev": "e3f4bd28c9e61b522f75f291d4d6cfcfeccd83ee", # b/236358256
diff --git a/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart b/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart
index fbcedf8..ced5a9b 100644
--- a/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/flow_analysis/flow_analysis.dart
@@ -26,27 +26,29 @@
/// closure.
class AssignedVariables<Node extends Object, Variable extends Object> {
/// Mapping from a node to the info for that node.
- final Map<Node, AssignedVariablesNodeInfo<Variable>> _info =
- new Map<Node, AssignedVariablesNodeInfo<Variable>>.identity();
+ final Map<Node, AssignedVariablesNodeInfo> _info =
+ new Map<Node, AssignedVariablesNodeInfo>.identity();
/// Info for the variables written or captured anywhere in the code being
/// analyzed.
- final AssignedVariablesNodeInfo<Variable> _anywhere =
- new AssignedVariablesNodeInfo<Variable>();
+ final AssignedVariablesNodeInfo _anywhere = new AssignedVariablesNodeInfo();
/// Stack of info for nodes that have been entered but not yet left.
- final List<AssignedVariablesNodeInfo<Variable>> _stack = [
- new AssignedVariablesNodeInfo<Variable>()
+ final List<AssignedVariablesNodeInfo> _stack = [
+ new AssignedVariablesNodeInfo()
];
/// When assertions are enabled, the set of info objects that have been
/// retrieved by [deferNode] but not yet sent to [storeNode].
- final Set<AssignedVariablesNodeInfo<Variable>> _deferredInfos =
- new Set<AssignedVariablesNodeInfo<Variable>>.identity();
+ final Set<AssignedVariablesNodeInfo> _deferredInfos =
+ new Set<AssignedVariablesNodeInfo>.identity();
/// Keeps track of whether [finish] has been called.
bool _isFinished = false;
+ final PromotionKeyStore<Variable> _promotionKeyStore =
+ new PromotionKeyStore<Variable>();
+
/// This method should be called during pre-traversal, to mark the start of a
/// loop statement, switch statement, try statement, loop collection element,
/// local function, closure, or late variable initializer which might need to
@@ -60,7 +62,7 @@
/// switch expression should not.
void beginNode() {
assert(!_isFinished);
- _stack.add(new AssignedVariablesNodeInfo<Variable>());
+ _stack.add(new AssignedVariablesNodeInfo());
}
/// This method should be called during pre-traversal, to indicate that the
@@ -70,8 +72,9 @@
/// is to allow for error recovery in the analyzer).
void declare(Variable variable) {
assert(!_isFinished);
- _stack.last._declared.add(variable);
- _anywhere._declared.add(variable);
+ int variableKey = _promotionKeyStore.keyForVariable(variable);
+ _stack.last._declared.add(variableKey);
+ _anywhere._declared.add(variableKey);
}
/// This method may be called during pre-traversal, to mark the end of a
@@ -87,15 +90,15 @@
/// time, the caller should pass the returned data to [storeNodeInfo].
///
/// See [beginNode] for more details.
- AssignedVariablesNodeInfo<Variable> deferNode(
+ AssignedVariablesNodeInfo deferNode(
{bool isClosureOrLateVariableInitializer: false}) {
assert(!_isFinished);
- AssignedVariablesNodeInfo<Variable> info = _stack.removeLast();
+ AssignedVariablesNodeInfo info = _stack.removeLast();
info._read.removeAll(info._declared);
info._written.removeAll(info._declared);
info._readCaptured.removeAll(info._declared);
info._captured.removeAll(info._declared);
- AssignedVariablesNodeInfo<Variable> last = _stack.last;
+ AssignedVariablesNodeInfo last = _stack.last;
last._read.addAll(info._read);
last._written.addAll(info._written);
last._readCaptured.addAll(info._readCaptured);
@@ -124,8 +127,8 @@
/// calls.
void discardNode() {
assert(!_isFinished);
- AssignedVariablesNodeInfo<Variable> discarded = _stack.removeLast();
- AssignedVariablesNodeInfo<Variable> last = _stack.last;
+ AssignedVariablesNodeInfo discarded = _stack.removeLast();
+ AssignedVariablesNodeInfo last = _stack.last;
last._declared.addAll(discarded._declared);
last._read.addAll(discarded._read);
last._written.addAll(discarded._written);
@@ -161,15 +164,14 @@
assert(
_deferredInfos.isEmpty, "Deferred infos not stored: $_deferredInfos");
assert(_stack.length == 1, "Unexpected stack: $_stack");
- AssignedVariablesNodeInfo<Variable> last = _stack.last;
- Set<Variable> undeclaredReads = last._read.difference(last._declared);
+ AssignedVariablesNodeInfo last = _stack.last;
+ Set<int> undeclaredReads = last._read.difference(last._declared);
assert(undeclaredReads.isEmpty,
'Variables read from but not declared: $undeclaredReads');
- Set<Variable> undeclaredWrites = last._written.difference(last._declared);
+ Set<int> undeclaredWrites = last._written.difference(last._declared);
assert(undeclaredWrites.isEmpty,
'Variables written to but not declared: $undeclaredWrites');
- Set<Variable> undeclaredCaptures =
- last._captured.difference(last._declared);
+ Set<int> undeclaredCaptures = last._captured.difference(last._declared);
assert(undeclaredCaptures.isEmpty,
'Variables captured but not declared: $undeclaredCaptures');
return true;
@@ -184,21 +186,22 @@
/// This is used by the front end when building for-elements in lists, maps,
/// and sets; their initializers are partially built after building their
/// loop conditions but before completely building their bodies.
- AssignedVariablesNodeInfo<Variable> popNode() {
+ AssignedVariablesNodeInfo popNode() {
assert(!_isFinished);
return _stack.removeLast();
}
/// Call this method to un-do the effect of [popNode].
- void pushNode(AssignedVariablesNodeInfo<Variable> node) {
+ void pushNode(AssignedVariablesNodeInfo node) {
assert(!_isFinished);
_stack.add(node);
}
void read(Variable variable) {
assert(!_isFinished);
- _stack.last._read.add(variable);
- _anywhere._read.add(variable);
+ int variableKey = _promotionKeyStore.keyForVariable(variable);
+ _stack.last._read.add(variableKey);
+ _anywhere._read.add(variableKey);
}
/// Call this method to register that the node [from] for which information
@@ -207,7 +210,7 @@
// general elements in the front-end.
void reassignInfo(Node from, Node to) {
assert(!_info.containsKey(to), "Node $to already has info: ${_info[to]}");
- AssignedVariablesNodeInfo<Variable>? info = _info.remove(from);
+ AssignedVariablesNodeInfo? info = _info.remove(from);
assert(
info != null,
'No information for $from (${from.hashCode}) in '
@@ -218,7 +221,7 @@
/// This method may be called at any time between a call to [deferNode] and
/// the call to [finish], to store assigned variable info for the node.
- void storeInfo(Node node, AssignedVariablesNodeInfo<Variable> info) {
+ void storeInfo(Node node, AssignedVariablesNodeInfo info) {
assert(!_isFinished);
// Caller should not try to store the same piece of info more than once.
assert(_deferredInfos.remove(info));
@@ -237,12 +240,13 @@
/// variable.
void write(Variable variable) {
assert(!_isFinished);
- _stack.last._written.add(variable);
- _anywhere._written.add(variable);
+ int variableKey = _promotionKeyStore.keyForVariable(variable);
+ _stack.last._written.add(variableKey);
+ _anywhere._written.add(variableKey);
}
/// Queries the information stored for the given [node].
- AssignedVariablesNodeInfo<Variable> _getInfoForNode(Node node) {
+ AssignedVariablesNodeInfo _getInfoForNode(Node node) {
return _info[node] ??
(throw new StateError('No information for $node (${node.hashCode}) in '
'{${_info.keys.map((k) => '$k (${k.hashCode})').join(',')}}'));
@@ -260,26 +264,28 @@
/// Not intended to be used by clients of flow analysis.
class AssignedVariablesForTesting<Node extends Object, Variable extends Object>
extends AssignedVariables<Node, Variable> {
- Set<Variable> get capturedAnywhere => _anywhere._captured;
+ Set<int> get capturedAnywhere => _anywhere._captured;
- Set<Variable> get declaredAtTopLevel => _stack.first._declared;
+ Set<int> get declaredAtTopLevel => _stack.first._declared;
- Set<Variable> get readAnywhere => _anywhere._read;
+ Set<int> get readAnywhere => _anywhere._read;
- Set<Variable> get readCapturedAnywhere => _anywhere._readCaptured;
+ Set<int> get readCapturedAnywhere => _anywhere._readCaptured;
- Set<Variable> get writtenAnywhere => _anywhere._written;
+ Set<int> get writtenAnywhere => _anywhere._written;
- Set<Variable> capturedInNode(Node node) => _getInfoForNode(node)._captured;
+ Set<int> capturedInNode(Node node) => _getInfoForNode(node)._captured;
- Set<Variable> declaredInNode(Node node) => _getInfoForNode(node)._declared;
+ Set<int> declaredInNode(Node node) => _getInfoForNode(node)._declared;
bool isTracked(Node node) => _info.containsKey(node);
- Set<Variable> readCapturedInNode(Node node) =>
- _getInfoForNode(node)._readCaptured;
+ int keyForVariable(Variable variable) =>
+ _promotionKeyStore.keyForVariable(variable);
- Set<Variable> readInNode(Node node) => _getInfoForNode(node)._read;
+ Set<int> readCapturedInNode(Node node) => _getInfoForNode(node)._readCaptured;
+
+ Set<int> readInNode(Node node) => _getInfoForNode(node)._read;
String toString() {
StringBuffer sb = new StringBuffer();
@@ -289,24 +295,26 @@
return sb.toString();
}
- Set<Variable> writtenInNode(Node node) => _getInfoForNode(node)._written;
+ Variable variableForKey(int key) => _promotionKeyStore.variableForKey(key);
+
+ Set<int> writtenInNode(Node node) => _getInfoForNode(node)._written;
}
/// Information tracked by [AssignedVariables] for a single node.
-class AssignedVariablesNodeInfo<Variable extends Object> {
- final Set<Variable> _read = new Set<Variable>.identity();
+class AssignedVariablesNodeInfo {
+ final Set<int> _read = {};
/// The set of local variables that are potentially written in the node.
- final Set<Variable> _written = new Set<Variable>.identity();
+ final Set<int> _written = {};
- final Set<Variable> _readCaptured = new Set<Variable>.identity();
+ final Set<int> _readCaptured = {};
/// The set of local variables for which a potential write is captured by a
/// local function or closure inside the node.
- final Set<Variable> _captured = new Set<Variable>.identity();
+ final Set<int> _captured = {};
/// The set of local variables that are declared in the node.
- final Set<Variable> _declared = new Set<Variable>.identity();
+ final Set<int> _declared = {};
String toString() =>
'AssignedVariablesNodeInfo(_written=$_written, _captured=$_captured, '
@@ -346,17 +354,17 @@
/// Information gathered by flow analysis about an argument to either
/// `identical` or `operator ==`.
-class EqualityInfo<Variable extends Object, Type extends Object> {
+class EqualityInfo<Type extends Object> {
/// The [ExpressionInfo] for the expression. This is used to determine
/// whether the expression is a `null` literal.
- final ExpressionInfo<Variable, Type>? _expressionInfo;
+ final ExpressionInfo<Type>? _expressionInfo;
/// The type of the expression on the LHS of `==` or `!=`.
final Type _type;
/// If the LHS of `==` or `!=` is a reference, the thing being referred to.
/// Otherwise `null`.
- final ReferenceWithType<Variable, Type>? _reference;
+ final ReferenceWithType<Type>? _reference;
EqualityInfo._(this._expressionInfo, this._type, this._reference);
@@ -368,27 +376,26 @@
/// A collection of flow models representing the possible outcomes of evaluating
/// an expression that are relevant to flow analysis.
-class ExpressionInfo<Variable extends Object, Type extends Object> {
+class ExpressionInfo<Type extends Object> {
/// The state after the expression evaluates, if we don't care what it
/// evaluates to.
- final FlowModel<Variable, Type> after;
+ final FlowModel<Type> after;
/// The state after the expression evaluates, if it evaluates to `true`.
- final FlowModel<Variable, Type> ifTrue;
+ final FlowModel<Type> ifTrue;
/// The state after the expression evaluates, if it evaluates to `false`.
- final FlowModel<Variable, Type> ifFalse;
+ final FlowModel<Type> ifFalse;
ExpressionInfo(this.after, this.ifTrue, this.ifFalse);
/// Computes a new [ExpressionInfo] based on this one, but with the roles of
/// [ifTrue] and [ifFalse] reversed.
- ExpressionInfo<Variable, Type> invert() =>
- new ExpressionInfo<Variable, Type>(after, ifFalse, ifTrue);
+ ExpressionInfo<Type> invert() =>
+ new ExpressionInfo<Type>(after, ifFalse, ifTrue);
- ExpressionInfo<Variable, Type>? rebaseForward(
- TypeOperations<Type> typeOperations,
- FlowModel<Variable, Type> base) =>
+ ExpressionInfo<Type>? rebaseForward(
+ TypeOperations<Type> typeOperations, FlowModel<Type> base) =>
new ExpressionInfo(base, ifTrue.rebaseForward(typeOperations, base),
ifFalse.rebaseForward(typeOperations, base));
@@ -509,25 +516,22 @@
///
/// Note: the return type is nullable because legacy type promotion doesn't
/// need to record information about equality operands.
- EqualityInfo<Variable, Type>? equalityOperand_end(
- Expression operand, Type type);
+ EqualityInfo<Type>? equalityOperand_end(Expression operand, Type type);
/// Call this method just after visiting the operands of a binary `==` or `!=`
/// expression, or an invocation of `identical`.
///
/// [leftOperandInfo] and [rightOperandInfo] should be the values returned by
/// [equalityOperand_end].
- void equalityOperation_end(
- Expression wholeExpression,
- EqualityInfo<Variable, Type>? leftOperandInfo,
- EqualityInfo<Variable, Type>? rightOperandInfo,
+ void equalityOperation_end(Expression wholeExpression,
+ EqualityInfo<Type>? leftOperandInfo, EqualityInfo<Type>? rightOperandInfo,
{bool notEqual = false});
/// Retrieves the [ExpressionInfo] associated with [target], if known. Will
/// return `null` if (a) no info is associated with [target], or (b) another
/// expression with info has been visited more recently than [target]. For
/// testing only.
- ExpressionInfo<Variable, Type>? expressionInfoForTesting(Expression target);
+ ExpressionInfo<Type>? expressionInfoForTesting(Expression target);
/// This method should be called at the conclusion of flow analysis for a top
/// level function or method. Performs assertion checks.
@@ -801,7 +805,7 @@
/// is not associated with an SSA node because it is write captured. For
/// testing only.
@visibleForTesting
- SsaNode<Variable, Type>? ssaNodeForTesting(Variable variable);
+ SsaNode<Type>? ssaNodeForTesting(Variable variable);
/// Call this method just before visiting one of the cases in the body of a
/// switch statement. See [switchStatement_expressionEnd] for details.
@@ -1144,17 +1148,14 @@
}
@override
- EqualityInfo<Variable, Type>? equalityOperand_end(
- Expression operand, Type type) =>
+ EqualityInfo<Type>? equalityOperand_end(Expression operand, Type type) =>
_wrap('equalityOperand_end($operand, $type)',
() => _wrapped.equalityOperand_end(operand, type),
isQuery: true);
@override
- void equalityOperation_end(
- Expression wholeExpression,
- EqualityInfo<Variable, Type>? leftOperandInfo,
- EqualityInfo<Variable, Type>? rightOperandInfo,
+ void equalityOperation_end(Expression wholeExpression,
+ EqualityInfo<Type>? leftOperandInfo, EqualityInfo<Type>? rightOperandInfo,
{bool notEqual = false}) {
_wrap(
'equalityOperation_end($wholeExpression, $leftOperandInfo, '
@@ -1165,7 +1166,7 @@
}
@override
- ExpressionInfo<Variable, Type>? expressionInfoForTesting(Expression target) {
+ ExpressionInfo<Type>? expressionInfoForTesting(Expression target) {
return _wrap('expressionInfoForTesting($target)',
() => _wrapped.expressionInfoForTesting(target),
isQuery: true);
@@ -1423,7 +1424,7 @@
}
@override
- SsaNode<Variable, Type>? ssaNodeForTesting(Variable variable) {
+ SsaNode<Type>? ssaNodeForTesting(Variable variable) {
return _wrap('ssaNodeForTesting($variable)',
() => _wrapped.ssaNodeForTesting(variable),
isQuery: true);
@@ -1617,10 +1618,11 @@
/// Instances of this class are immutable, so the methods below that "update"
/// the state actually leave `this` unchanged and return a new state object.
@visibleForTesting
-class FlowModel<Variable extends Object, Type extends Object> {
+class FlowModel<Type extends Object> {
final Reachability reachable;
- /// For each variable being tracked by flow analysis, the variable's model.
+ /// For each promotable thing being tracked by flow analysis, the
+ /// corresponding model.
///
/// Flow analysis has no awareness of scope, so variables that are out of
/// scope are retained in the map until such time as their declaration no
@@ -1632,13 +1634,12 @@
/// analysis results for error-free code, because it is an error to refer to a
/// variable that is no longer in scope.
///
- /// `null` is allowed as a special key; it represents the pseudo-variable
- /// `this`. (This is needed so that we can explain why `this` is not
- /// promoted, and why properties of `this` are not promoted).
- final Map<Variable?, VariableModel<Variable, Type> /*!*/ > variableInfo;
+ /// Keys are the unique integers assigned by
+ /// [_FlowAnalysisImpl._promotionKeyStore].
+ final Map<int, VariableModel<Type> /*!*/ > variableInfo;
/// The empty map, used to [join] variables.
- final Map<Variable?, VariableModel<Variable, Type>> _emptyVariableMap = {};
+ final Map<int, VariableModel<Type>> _emptyVariableMap = {};
/// Creates a state object with the given [reachable] status. All variables
/// are assumed to be unpromoted and already assigned, so joining another
@@ -1654,7 +1655,7 @@
// ignore:unnecessary_null_comparison
assert(reachable != null);
assert(() {
- for (VariableModel<Variable, Type> value in variableInfo.values) {
+ for (VariableModel<Type> value in variableInfo.values) {
// ignore:unnecessary_null_comparison
assert(value != null);
}
@@ -1678,27 +1679,24 @@
/// an exception, so we want to reinstate the results of any promotions and
/// assignments that occurred during the `try` block, to the extent that they
/// weren't invalidated by later assignments in the `finally` block.
- FlowModel<Variable, Type> attachFinally(
- TypeOperations<Type> typeOperations,
- FlowModel<Variable, Type> beforeFinally,
- FlowModel<Variable, Type> afterFinally) {
+ FlowModel<Type> attachFinally(TypeOperations<Type> typeOperations,
+ FlowModel<Type> beforeFinally, FlowModel<Type> afterFinally) {
// Code that follows the `try/finally` is reachable iff the end of the `try`
// block is reachable _and_ the end of the `finally` block is reachable.
Reachability newReachable = afterFinally.reachable.rebaseForward(reachable);
// Consider each variable that is common to all three models.
- Map<Variable?, VariableModel<Variable, Type>> newVariableInfo =
- <Variable?, VariableModel<Variable, Type>>{};
+ Map<int, VariableModel<Type>> newVariableInfo =
+ <int, VariableModel<Type>>{};
bool variableInfoMatchesThis = true;
bool variableInfoMatchesAfterFinally = true;
- for (MapEntry<Variable?, VariableModel<Variable, Type>> entry
- in variableInfo.entries) {
- Variable? variable = entry.key;
- VariableModel<Variable, Type> thisModel = entry.value;
- VariableModel<Variable, Type>? beforeFinallyModel =
- beforeFinally.variableInfo[variable];
- VariableModel<Variable, Type>? afterFinallyModel =
- afterFinally.variableInfo[variable];
+ for (MapEntry<int, VariableModel<Type>> entry in variableInfo.entries) {
+ int promotionKey = entry.key;
+ VariableModel<Type> thisModel = entry.value;
+ VariableModel<Type>? beforeFinallyModel =
+ beforeFinally.variableInfo[promotionKey];
+ VariableModel<Type>? afterFinallyModel =
+ afterFinally.variableInfo[promotionKey];
if (beforeFinallyModel == null || afterFinallyModel == null) {
// The variable is in `this` model but not in one of the `finally`
// models. This happens when the variable is declared inside the `try`
@@ -1711,7 +1709,7 @@
// because any write captures in the `try` block are conservatively
// considered to take effect in the `finally` block too.
List<Type>? newPromotedTypes;
- SsaNode<Variable, Type>? newSsaNode;
+ SsaNode<Type>? newSsaNode;
if (beforeFinallyModel.ssaNode == afterFinallyModel.ssaNode) {
// The finally clause doesn't write to the variable, so we want to keep
// all promotions that were done to it in both the try and finally
@@ -1737,7 +1735,7 @@
// The `finally` block inherited the "unassigned" state from the `try`
// block so we can just inherit from it.
bool newUnassigned = afterFinallyModel.unassigned;
- VariableModel<Variable, Type> newModel = VariableModel._identicalOrNew(
+ VariableModel<Type> newModel = VariableModel._identicalOrNew(
thisModel,
afterFinallyModel,
newPromotedTypes,
@@ -1745,7 +1743,7 @@
newAssigned,
newUnassigned,
newSsaNode);
- newVariableInfo[variable] = newModel;
+ newVariableInfo[promotionKey] = newModel;
if (!identical(newModel, thisModel)) variableInfoMatchesThis = false;
if (!identical(newModel, afterFinallyModel)) {
variableInfoMatchesAfterFinally = false;
@@ -1756,8 +1754,8 @@
// erroneously think that `newVariableInfo` matches `afterFinally`. If so,
// correct that.
if (variableInfoMatchesAfterFinally) {
- for (Variable? variable in afterFinally.variableInfo.keys) {
- if (!variableInfo.containsKey(variable)) {
+ for (int promotionKey in afterFinally.variableInfo.keys) {
+ if (!variableInfo.containsKey(promotionKey)) {
variableInfoMatchesAfterFinally = false;
break;
}
@@ -1796,55 +1794,55 @@
/// and only remove promotions if it can be shown that they aren't restored
/// later in the loop body. If we switch to a fixed point analysis, we should
/// be able to remove this method.
- FlowModel<Variable, Type> conservativeJoin(
- Iterable<Variable> writtenVariables,
- Iterable<Variable> capturedVariables) {
- Map<Variable?, VariableModel<Variable, Type>>? newVariableInfo;
+ FlowModel<Type> conservativeJoin(
+ Iterable<int> writtenVariables, Iterable<int> capturedVariables) {
+ Map<int, VariableModel<Type>>? newVariableInfo;
- for (Variable variable in writtenVariables) {
- VariableModel<Variable, Type>? info = variableInfo[variable];
+ for (int variableKey in writtenVariables) {
+ VariableModel<Type>? info = variableInfo[variableKey];
if (info == null) continue;
- VariableModel<Variable, Type> newInfo =
+ VariableModel<Type> newInfo =
info.discardPromotionsAndMarkNotUnassigned();
if (!identical(info, newInfo)) {
- (newVariableInfo ??=
- new Map<Variable?, VariableModel<Variable, Type>>.of(
- variableInfo))[variable] = newInfo;
+ (newVariableInfo ??= new Map<int, VariableModel<Type>>.of(
+ variableInfo))[variableKey] = newInfo;
}
}
- for (Variable variable in capturedVariables) {
- VariableModel<Variable, Type>? info = variableInfo[variable];
+ for (int variableKey in capturedVariables) {
+ VariableModel<Type>? info = variableInfo[variableKey];
if (info == null) continue;
if (!info.writeCaptured) {
- (newVariableInfo ??=
- new Map<Variable?, VariableModel<Variable, Type>>.of(
- variableInfo))[variable] = info.writeCapture();
+ (newVariableInfo ??= new Map<int, VariableModel<Type>>.of(
+ variableInfo))[variableKey] = info.writeCapture();
}
}
- FlowModel<Variable, Type> result = newVariableInfo == null
+ FlowModel<Type> result = newVariableInfo == null
? this
- : new FlowModel<Variable, Type>.withInfo(reachable, newVariableInfo);
+ : new FlowModel<Type>.withInfo(reachable, newVariableInfo);
return result;
}
- /// Register a declaration of the [variable].
+ /// Register a declaration of the variable whose key is [variableKey].
/// Should also be called for function parameters.
///
/// A local variable is [initialized] if its declaration has an initializer.
/// A function parameter is always initialized, so [initialized] is `true`.
- FlowModel<Variable, Type> declare(Variable variable, bool initialized) {
- VariableModel<Variable, Type> newInfoForVar =
+ FlowModel<Type> declare<Variable extends Object>(
+ Variable variable, int variableKey, bool initialized) {
+ VariableModel<Type> newInfoForVar =
new VariableModel.fresh(assigned: initialized);
- return _updateVariableInfo(new VariableReference(variable), newInfoForVar);
+ return _updateVariableInfo(
+ new VariableReference(variable, variableKey), newInfoForVar);
}
- /// Gets the info for the given [variable], creating it if it doesn't exist.
- VariableModel<Variable, Type> infoFor(Variable variable) =>
- variableInfo[variable] ?? new VariableModel.fresh();
+ /// Gets the info for the given [promotionKey], creating it if it doesn't
+ /// exist.
+ VariableModel<Type> infoFor(int promotionKey) =>
+ variableInfo[promotionKey] ?? new VariableModel.fresh();
/// Builds a [FlowModel] based on `this`, but extending the `tested` set to
/// include types from [other]. This is used at the bottom of certain kinds
@@ -1852,29 +1850,25 @@
/// consistently treated as "of interest" in code that follows the loop,
/// regardless of the type of loop.
@visibleForTesting
- FlowModel<Variable, Type> inheritTested(
- TypeOperations<Type> typeOperations, FlowModel<Variable, Type> other) {
- Map<Variable?, VariableModel<Variable, Type>> newVariableInfo =
- <Variable?, VariableModel<Variable, Type>>{};
- Map<Variable?, VariableModel<Variable, Type>> otherVariableInfo =
- other.variableInfo;
+ FlowModel<Type> inheritTested(
+ TypeOperations<Type> typeOperations, FlowModel<Type> other) {
+ Map<int, VariableModel<Type>> newVariableInfo =
+ <int, VariableModel<Type>>{};
+ Map<int, VariableModel<Type>> otherVariableInfo = other.variableInfo;
bool changed = false;
- for (MapEntry<Variable?, VariableModel<Variable, Type>> entry
- in variableInfo.entries) {
- Variable? variable = entry.key;
- VariableModel<Variable, Type> variableModel = entry.value;
- VariableModel<Variable, Type>? otherVariableModel =
- otherVariableInfo[variable];
- VariableModel<Variable, Type> newVariableModel =
- otherVariableModel == null
- ? variableModel
- : VariableModel.inheritTested(
- typeOperations, variableModel, otherVariableModel.tested);
- newVariableInfo[variable] = newVariableModel;
+ for (MapEntry<int, VariableModel<Type>> entry in variableInfo.entries) {
+ int promotionKey = entry.key;
+ VariableModel<Type> variableModel = entry.value;
+ VariableModel<Type>? otherVariableModel = otherVariableInfo[promotionKey];
+ VariableModel<Type> newVariableModel = otherVariableModel == null
+ ? variableModel
+ : VariableModel.inheritTested(
+ typeOperations, variableModel, otherVariableModel.tested);
+ newVariableInfo[promotionKey] = newVariableModel;
if (!identical(newVariableModel, variableModel)) changed = true;
}
if (changed) {
- return new FlowModel<Variable, Type>.withInfo(reachable, newVariableInfo);
+ return new FlowModel<Type>.withInfo(reachable, newVariableInfo);
} else {
return this;
}
@@ -1890,26 +1884,26 @@
/// example, if a variable is promoted in `this` but not in [base], then it
/// will be promoted in the output model, provided that hasn't been reassigned
/// since then (which would make the promotion unsound).
- FlowModel<Variable, Type> rebaseForward(
- TypeOperations<Type> typeOperations, FlowModel<Variable, Type> base) {
+ FlowModel<Type> rebaseForward(
+ TypeOperations<Type> typeOperations, FlowModel<Type> base) {
// The rebased model is reachable iff both `this` and the new base are
// reachable.
Reachability newReachable = reachable.rebaseForward(base.reachable);
// Consider each variable in the new base model.
- Map<Variable?, VariableModel<Variable, Type>> newVariableInfo =
- <Variable?, VariableModel<Variable, Type>>{};
+ Map<int, VariableModel<Type>> newVariableInfo =
+ <int, VariableModel<Type>>{};
bool variableInfoMatchesThis = true;
bool variableInfoMatchesBase = true;
- for (MapEntry<Variable?, VariableModel<Variable, Type>> entry
+ for (MapEntry<int, VariableModel<Type>> entry
in base.variableInfo.entries) {
- Variable? variable = entry.key;
- VariableModel<Variable, Type> baseModel = entry.value;
- VariableModel<Variable, Type>? thisModel = variableInfo[variable];
+ int promotionKey = entry.key;
+ VariableModel<Type> baseModel = entry.value;
+ VariableModel<Type>? thisModel = variableInfo[promotionKey];
if (thisModel == null) {
// The variable has newly came into scope since `thisModel`, so the
// information in `baseModel` is up to date.
- newVariableInfo[variable] = baseModel;
+ newVariableInfo[promotionKey] = baseModel;
variableInfoMatchesThis = false;
continue;
}
@@ -1943,7 +1937,7 @@
// The variable is definitely unassigned if it was definitely unassigned
// in both `this` model and the new base model.
bool newUnassigned = thisModel.unassigned && baseModel.unassigned;
- VariableModel<Variable, Type> newModel = VariableModel._identicalOrNew(
+ VariableModel<Type> newModel = VariableModel._identicalOrNew(
thisModel,
baseModel,
newPromotedTypes,
@@ -1951,7 +1945,7 @@
newAssigned,
newUnassigned,
newWriteCaptured ? null : baseModel.ssaNode);
- newVariableInfo[variable] = newModel;
+ newVariableInfo[promotionKey] = newModel;
if (!identical(newModel, thisModel)) variableInfoMatchesThis = false;
if (!identical(newModel, baseModel)) variableInfoMatchesBase = false;
}
@@ -1959,8 +1953,8 @@
// present in `this` that aren't present in `base`, we may erroneously think
// that `newVariableInfo` matches `this`. If so, correct that.
if (variableInfoMatchesThis) {
- for (Variable? variable in variableInfo.keys) {
- if (!base.variableInfo.containsKey(variable)) {
+ for (int promotionKey in variableInfo.keys) {
+ if (!base.variableInfo.containsKey(promotionKey)) {
variableInfoMatchesThis = false;
break;
}
@@ -1980,17 +1974,17 @@
}
/// Updates the state to indicate that the control flow path is unreachable.
- FlowModel<Variable, Type> setUnreachable() {
+ FlowModel<Type> setUnreachable() {
if (!reachable.locallyReachable) return this;
- return new FlowModel<Variable, Type>.withInfo(
+ return new FlowModel<Type>.withInfo(
reachable.setUnreachable(), variableInfo);
}
/// Returns a [FlowModel] indicating the result of creating a control flow
/// split. See [Reachability.split] for more information.
- FlowModel<Variable, Type> split() =>
- new FlowModel<Variable, Type>.withInfo(reachable.split(), variableInfo);
+ FlowModel<Type> split() =>
+ new FlowModel<Type>.withInfo(reachable.split(), variableInfo);
@override
String toString() => '($reachable, $variableInfo)';
@@ -2000,29 +1994,27 @@
///
/// Note that the state is only changed if the previous type of [variable] was
/// potentially nullable.
- ExpressionInfo<Variable, Type> tryMarkNonNullable(
- TypeOperations<Type> typeOperations,
- ReferenceWithType<Variable, Type> referenceWithType) {
- VariableModel<Variable, Type> info =
+ ExpressionInfo<Type> tryMarkNonNullable(TypeOperations<Type> typeOperations,
+ ReferenceWithType<Type> referenceWithType) {
+ VariableModel<Type> info =
referenceWithType.reference.getInfo(variableInfo);
if (info.writeCaptured) {
- return new _TrivialExpressionInfo<Variable, Type>(this);
+ return new _TrivialExpressionInfo<Type>(this);
}
Type previousType = referenceWithType.type;
Type newType = typeOperations.promoteToNonNull(previousType);
if (typeOperations.isSameType(newType, previousType)) {
- return new _TrivialExpressionInfo<Variable, Type>(this);
+ return new _TrivialExpressionInfo<Type>(this);
}
assert(typeOperations.isSubtypeOf(newType, previousType));
- FlowModel<Variable, Type> modelIfSuccessful = _finishTypeTest(
+ FlowModel<Type> modelIfSuccessful = _finishTypeTest(
typeOperations, referenceWithType.reference, info, null, newType);
- FlowModel<Variable, Type> modelIfFailed = this;
+ FlowModel<Type> modelIfFailed = this;
- return new ExpressionInfo<Variable, Type>(
- this, modelIfSuccessful, modelIfFailed);
+ return new ExpressionInfo<Type>(this, modelIfSuccessful, modelIfFailed);
}
/// Returns an [ExpressionInfo] indicating the result of casting the given
@@ -2034,11 +2026,9 @@
///
/// TODO(paulberry): if the type is non-nullable, should this method mark the
/// variable as definitely assigned? Does it matter?
- FlowModel<Variable, Type> tryPromoteForTypeCast(
- TypeOperations<Type> typeOperations,
- ReferenceWithType<Variable, Type> referenceWithType,
- Type type) {
- VariableModel<Variable, Type> info =
+ FlowModel<Type> tryPromoteForTypeCast(TypeOperations<Type> typeOperations,
+ ReferenceWithType<Type> referenceWithType, Type type) {
+ VariableModel<Type> info =
referenceWithType.reference.getInfo(variableInfo);
if (info.writeCaptured) {
return this;
@@ -2065,18 +2055,18 @@
///
/// TODO(paulberry): if the type is non-nullable, should this method mark the
/// variable as definitely assigned? Does it matter?
- ExpressionInfo<Variable, Type> tryPromoteForTypeCheck(
+ ExpressionInfo<Type> tryPromoteForTypeCheck(
TypeOperations<Type> typeOperations,
- ReferenceWithType<Variable, Type> referenceWithType,
+ ReferenceWithType<Type> referenceWithType,
Type type) {
- VariableModel<Variable, Type> info =
+ VariableModel<Type> info =
referenceWithType.reference.getInfo(variableInfo);
if (info.writeCaptured) {
- return new _TrivialExpressionInfo<Variable, Type>(this);
+ return new _TrivialExpressionInfo<Type>(this);
}
Type previousType = referenceWithType.type;
- FlowModel<Variable, Type> modelIfSuccessful = this;
+ FlowModel<Type> modelIfSuccessful = this;
Type? typeIfSuccess = typeOperations.tryPromoteToType(type, previousType);
if (typeIfSuccess != null &&
!typeOperations.isSameType(typeIfSuccess, previousType)) {
@@ -2098,52 +2088,53 @@
} else {
typeIfFailed = factoredType;
}
- FlowModel<Variable, Type> modelIfFailed = _finishTypeTest(
+ FlowModel<Type> modelIfFailed = _finishTypeTest(
typeOperations, referenceWithType.reference, info, type, typeIfFailed);
- return new ExpressionInfo<Variable, Type>(
- this, modelIfSuccessful, modelIfFailed);
+ return new ExpressionInfo<Type>(this, modelIfSuccessful, modelIfFailed);
}
/// Returns a [FlowModel] indicating the result of removing a control flow
/// split. See [Reachability.unsplit] for more information.
- FlowModel<Variable, Type> unsplit() =>
- new FlowModel<Variable, Type>.withInfo(reachable.unsplit(), variableInfo);
+ FlowModel<Type> unsplit() =>
+ new FlowModel<Type>.withInfo(reachable.unsplit(), variableInfo);
/// Removes control flow splits until a [FlowModel] is obtained whose
/// reachability has the given [parent].
- FlowModel<Variable, Type> unsplitTo(Reachability parent) {
+ FlowModel<Type> unsplitTo(Reachability parent) {
if (identical(this.reachable.parent, parent)) return this;
Reachability reachable = this.reachable.unsplit();
while (!identical(reachable.parent, parent)) {
reachable = reachable.unsplit();
}
- return new FlowModel<Variable, Type>.withInfo(reachable, variableInfo);
+ return new FlowModel<Type>.withInfo(reachable, variableInfo);
}
- /// Updates the state to indicate that an assignment was made to the given
- /// [variable]. The variable is marked as definitely assigned, and any
- /// previous type promotion is removed.
+ /// Updates the state to indicate that an assignment was made to [variable],
+ /// whose key is [variableKey]. The variable is marked as definitely
+ /// assigned, and any previous type promotion is removed.
///
/// If there is any chance that the write will cause a demotion, the caller
/// must pass in a non-null value for [nonPromotionReason] describing the
/// reason for any potential demotion.
- FlowModel<Variable, Type> write(
+ FlowModel<Type> write<Variable extends Object>(
NonPromotionReason? nonPromotionReason,
Variable variable,
+ int variableKey,
Type writtenType,
- SsaNode<Variable, Type> newSsaNode,
+ SsaNode<Type> newSsaNode,
Operations<Variable, Type> operations,
{bool promoteToTypeOfInterest = true}) {
- VariableModel<Variable, Type>? infoForVar = variableInfo[variable];
+ VariableModel<Type>? infoForVar = variableInfo[variableKey];
if (infoForVar == null) return this;
- VariableModel<Variable, Type> newInfoForVar = infoForVar.write(
- nonPromotionReason, variable, writtenType, operations, newSsaNode,
+ VariableModel<Type> newInfoForVar = infoForVar.write(nonPromotionReason,
+ variable, variableKey, writtenType, operations, newSsaNode,
promoteToTypeOfInterest: promoteToTypeOfInterest);
if (identical(newInfoForVar, infoForVar)) return this;
- return _updateVariableInfo(new VariableReference(variable), newInfoForVar);
+ return _updateVariableInfo(
+ new VariableReference(variable, variableKey), newInfoForVar);
}
/// Common algorithm for [tryMarkNonNullable], [tryPromoteForTypeCast],
@@ -2157,10 +2148,10 @@
/// - [promotedType] should be a subtype of the currently-promoted type (i.e.
/// no redundant or side-promotions)
/// - The variable should not be write-captured.
- FlowModel<Variable, Type> _finishTypeTest(
+ FlowModel<Type> _finishTypeTest(
TypeOperations<Type> typeOperations,
- Reference<Variable, Type> reference,
- VariableModel<Variable, Type> info,
+ Reference<Type> reference,
+ VariableModel<Type> info,
Type? testedType,
Type? promotedType,
) {
@@ -2187,7 +2178,7 @@
? this
: _updateVariableInfo(
reference,
- new VariableModel<Variable, Type>(
+ new VariableModel<Type>(
promotedTypes: newPromotedTypes,
tested: newTested,
assigned: info.assigned,
@@ -2199,14 +2190,14 @@
/// Returns a new [FlowModel] where the information for [reference] is
/// replaced with [model].
- FlowModel<Variable, Type> _updateVariableInfo(
- Reference<Variable, Type> reference, VariableModel<Variable, Type> model,
+ FlowModel<Type> _updateVariableInfo(
+ Reference<Type> reference, VariableModel<Type> model,
{Reachability? reachable}) {
reachable ??= this.reachable;
- Map<Variable?, VariableModel<Variable, Type>> newVariableInfo =
- new Map<Variable?, VariableModel<Variable, Type>>.of(variableInfo);
+ Map<int, VariableModel<Type>> newVariableInfo =
+ new Map<int, VariableModel<Type>>.of(variableInfo);
reference.storeInfo(newVariableInfo, model);
- return new FlowModel<Variable, Type>.withInfo(reachable, newVariableInfo);
+ return new FlowModel<Type>.withInfo(reachable, newVariableInfo);
}
/// Forms a new state to reflect a control flow path that might have come from
@@ -2218,12 +2209,11 @@
/// are kept only if they are common to both input states; if a variable is
/// promoted to one type in one state and a subtype in the other state, the
/// less specific type promotion is kept.
- static FlowModel<Variable, Type>
- join<Variable extends Object, Type extends Object>(
+ static FlowModel<Type> join<Type extends Object>(
TypeOperations<Type> typeOperations,
- FlowModel<Variable, Type>? first,
- FlowModel<Variable, Type>? second,
- Map<Variable?, VariableModel<Variable, Type>> emptyVariableMap,
+ FlowModel<Type>? first,
+ FlowModel<Type>? second,
+ Map<int, VariableModel<Type>> emptyVariableMap,
) {
if (first == null) return second!;
if (second == null) return first;
@@ -2240,9 +2230,11 @@
Reachability newReachable =
Reachability.join(first.reachable, second.reachable);
- Map<Variable?, VariableModel<Variable, Type>> newVariableInfo =
- FlowModel.joinVariableInfo(typeOperations, first.variableInfo,
- second.variableInfo, emptyVariableMap);
+ Map<int, VariableModel<Type>> newVariableInfo = FlowModel.joinVariableInfo(
+ typeOperations,
+ first.variableInfo,
+ second.variableInfo,
+ emptyVariableMap);
return FlowModel._identicalOrNew(
first, second, newReachable, newVariableInfo);
@@ -2250,33 +2242,29 @@
/// Joins two "variable info" maps. See [join] for details.
@visibleForTesting
- static Map<Variable?, VariableModel<Variable, Type>>
- joinVariableInfo<Variable extends Object, Type extends Object>(
+ static Map<int, VariableModel<Type>> joinVariableInfo<Type extends Object>(
TypeOperations<Type> typeOperations,
- Map<Variable?, VariableModel<Variable, Type>> first,
- Map<Variable?, VariableModel<Variable, Type>> second,
- Map<Variable?, VariableModel<Variable, Type>> emptyMap,
+ Map<int, VariableModel<Type>> first,
+ Map<int, VariableModel<Type>> second,
+ Map<int, VariableModel<Type>> emptyMap,
) {
if (identical(first, second)) return first;
if (first.isEmpty || second.isEmpty) {
return emptyMap;
}
- Map<Variable?, VariableModel<Variable, Type>> result =
- <Variable?, VariableModel<Variable, Type>>{};
+ Map<int, VariableModel<Type>> result = <int, VariableModel<Type>>{};
bool alwaysFirst = true;
bool alwaysSecond = true;
- for (MapEntry<Variable?, VariableModel<Variable, Type>> entry
- in first.entries) {
- Variable? variable = entry.key;
- VariableModel<Variable, Type>? secondModel = second[variable];
+ for (MapEntry<int, VariableModel<Type>> entry in first.entries) {
+ int promotionKey = entry.key;
+ VariableModel<Type>? secondModel = second[promotionKey];
if (secondModel == null) {
alwaysFirst = false;
} else {
- VariableModel<Variable, Type> joined =
- VariableModel.join<Variable, Type>(
- typeOperations, entry.value, secondModel);
- result[variable] = joined;
+ VariableModel<Type> joined =
+ VariableModel.join<Type>(typeOperations, entry.value, secondModel);
+ result[promotionKey] = joined;
if (!identical(joined, entry.value)) alwaysFirst = false;
if (!identical(joined, secondModel)) alwaysSecond = false;
}
@@ -2290,12 +2278,11 @@
/// Models the result of joining the flow models [first] and [second] at the
/// merge of two control flow paths.
- static FlowModel<Variable, Type>
- merge<Variable extends Object, Type extends Object>(
+ static FlowModel<Type> merge<Type extends Object>(
TypeOperations<Type> typeOperations,
- FlowModel<Variable, Type>? first,
- FlowModel<Variable, Type>? second,
- Map<Variable?, VariableModel<Variable, Type>> emptyVariableMap,
+ FlowModel<Type>? first,
+ FlowModel<Type>? second,
+ Map<int, VariableModel<Type>> emptyVariableMap,
) {
if (first == null) return second!.unsplit();
if (second == null) return first.unsplit();
@@ -2312,9 +2299,11 @@
Reachability newReachable =
Reachability.join(first.reachable, second.reachable).unsplit();
- Map<Variable?, VariableModel<Variable, Type>> newVariableInfo =
- FlowModel.joinVariableInfo(typeOperations, first.variableInfo,
- second.variableInfo, emptyVariableMap);
+ Map<int, VariableModel<Type>> newVariableInfo = FlowModel.joinVariableInfo(
+ typeOperations,
+ first.variableInfo,
+ second.variableInfo,
+ emptyVariableMap);
return FlowModel._identicalOrNew(
first, second, newReachable, newVariableInfo);
@@ -2322,12 +2311,11 @@
/// Creates a new [FlowModel] object, unless it is equivalent to either
/// [first] or [second], in which case one of those objects is re-used.
- static FlowModel<Variable, Type>
- _identicalOrNew<Variable extends Object, Type extends Object>(
- FlowModel<Variable, Type> first,
- FlowModel<Variable, Type> second,
- Reachability newReachable,
- Map<Variable?, VariableModel<Variable, Type>> newVariableInfo) {
+ static FlowModel<Type> _identicalOrNew<Type extends Object>(
+ FlowModel<Type> first,
+ FlowModel<Type> second,
+ Reachability newReachable,
+ Map<int, VariableModel<Type>> newVariableInfo) {
if (first.reachable == newReachable &&
identical(first.variableInfo, newVariableInfo)) {
return first;
@@ -2337,23 +2325,20 @@
return second;
}
- return new FlowModel<Variable, Type>.withInfo(
- newReachable, newVariableInfo);
+ return new FlowModel<Type>.withInfo(newReachable, newVariableInfo);
}
/// Determines whether the given "variableInfo" maps are equivalent.
///
/// The equivalence check is shallow; if two variables' models are not
/// identical, we return `false`.
- static bool _variableInfosEqual<Variable extends Object, Type extends Object>(
- Map<Variable?, VariableModel<Variable, Type>> p1,
- Map<Variable?, VariableModel<Variable, Type>> p2) {
+ static bool _variableInfosEqual<Type extends Object>(
+ Map<int, VariableModel<Type>> p1, Map<int, VariableModel<Type>> p2) {
if (p1.length != p2.length) return false;
if (!p1.keys.toSet().containsAll(p2.keys)) return false;
- for (MapEntry<Variable?, VariableModel<Variable, Type>> entry
- in p1.entries) {
- VariableModel<Variable, Type> p1Value = entry.value;
- VariableModel<Variable, Type>? p2Value = p2[entry.key];
+ for (MapEntry<int, VariableModel<Type>> entry in p1.entries) {
+ VariableModel<Type> p1Value = entry.value;
+ VariableModel<Type>? p2Value = p2[entry.key];
if (!identical(p1Value, p2Value)) {
return false;
}
@@ -2426,6 +2411,48 @@
extends TypeOperations<Type> implements VariableOperations<Variable, Type> {
}
+/// This data structure assigns a unique integer identifier to everything that
+/// might undergo promotion in the user's code (local variables and properties).
+/// An integer identifier is also assigned to `this` (even though `this` is not
+/// promotable), because promotable properties can be reached using `this` as a
+/// starting point.
+@visibleForTesting
+class PromotionKeyStore<Variable extends Object> {
+ @visibleForTesting
+
+ /// Special promotion key to represent `this`.
+ late final int thisPromotionKey = _makeNewKey(null);
+
+ final Map<Variable, int> _variableKeys = new Map<Variable, int>.identity();
+
+ final List<Variable?> _keyToVariable = [];
+
+ /// List of maps indicating the set of properties of each promotable entity
+ /// being tracked by flow analysis. The list is indexed by the promotion key
+ /// of the target, and the map is indexed by the property name.
+ ///
+ /// Null list elements are considered equivalent to an empty map (this allows
+ /// us so save memory due to the fact that most entries will not be accessed).
+ final List<Map<String, int>?> _properties = [];
+
+ int getProperty(int targetKey, String propertyName) =>
+ (_properties[targetKey] ??= {})[propertyName] ??= _makeNewKey(null);
+
+ @visibleForTesting
+ int keyForVariable(Variable variable) =>
+ _variableKeys[variable] ??= _makeNewKey(variable);
+
+ @visibleForTesting
+ Variable variableForKey(int variableKey) => _keyToVariable[variableKey]!;
+
+ int _makeNewKey(Variable? variable) {
+ int key = _keyToVariable.length;
+ _keyToVariable.add(variable);
+ _properties.add(null);
+ return key;
+ }
+}
+
/// Non-promotion reason describing the situation where an expression was not
/// promoted due to the fact that it's a property get.
class PropertyNotPromoted<Type extends Object> extends NonPromotionReason {
@@ -2605,39 +2632,45 @@
/// other references in order to give useful error messages to the user about
/// why promotion did not occur.
@visibleForTesting
-abstract class Reference<Variable extends Object, Type extends Object> {
+abstract class Reference<Type extends Object> {
+ /// The reference's corresponding key, as assigned by [PromotionKeyStore].
+ final int promotionKey;
+
+ Reference(this.promotionKey);
+
/// Gets the info for this reference, creating it if it doesn't exist.
- VariableModel<Variable, Type> getInfo(
- Map<Variable?, VariableModel<Variable, Type>> variableInfo) =>
- _getInfo(variableInfo) ?? new VariableModel<Variable, Type>.fresh();
+ VariableModel<Type> getInfo(Map<int, VariableModel<Type>> variableInfo) =>
+ _getInfo(variableInfo) ?? new VariableModel<Type>.fresh();
/// Gets a map of non-promotion reasons associated with this reference. This
/// is the map that will be returned from [FlowAnalysis.whyNotPromoted].
Map<Type, NonPromotionReason> Function() getNonPromotionReasons(
- Map<Variable?, VariableModel<Variable, Type>> variableInfo,
+ Map<int, VariableModel<Type>> variableInfo,
Type staticType,
- Operations<Variable, Type> operations);
+ TypeOperations<Type> operations);
/// Creates a reference representing a get of a property called [propertyName]
/// on the reference represented by `this`.
- Reference<Variable, Type> propertyGet(
+ Reference<Type> propertyGet(PromotionKeyStore promotionKeyStore,
String propertyName, Object? propertyMember) =>
- new _PropertyGetReference<Variable, Type>(
- this, propertyName, propertyMember);
+ new _PropertyGetReference<Type>(propertyName, propertyMember,
+ promotionKeyStore.getProperty(promotionKey, propertyName));
/// Stores info for this reference in [variableInfo].
- void storeInfo(Map<Variable?, VariableModel<Variable, Type>> variableInfo,
- VariableModel<Variable, Type> variableModel);
+ void storeInfo(Map<int, VariableModel<Type>> variableInfo,
+ VariableModel<Type> variableModel) {
+ variableInfo[promotionKey] = variableModel;
+ }
/// Gets the info for this reference, or `null` if it doesn't exist.
- VariableModel<Variable, Type>? _getInfo(
- Map<Variable?, VariableModel<Variable, Type>> variableInfo);
+ VariableModel<Type>? _getInfo(Map<int, VariableModel<Type>> variableInfo) =>
+ variableInfo[promotionKey];
}
/// Container object combining a [Reference] object with its static type.
@visibleForTesting
-class ReferenceWithType<Variable extends Object, Type extends Object> {
- final Reference<Variable, Type> reference;
+class ReferenceWithType<Type extends Object> {
+ final Reference<Type> reference;
final Type type;
@@ -2656,7 +2689,7 @@
/// (https://en.wikipedia.org/wiki/Static_single_assignment_form) except that it
/// does not store a complete IR of the code being analyzed.
@visibleForTesting
-class SsaNode<Variable extends Object, Type extends Object> {
+class SsaNode<Type extends Object> {
/// Expando mapping SSA nodes to debug ids. Only used by `toString`.
static final Expando<int> _debugIds = new Expando<int>();
@@ -2671,7 +2704,7 @@
/// [_TrivialExpressionInfo]) because such information does not lead to
/// promotions.
@visibleForTesting
- final ExpressionInfo<Variable, Type>? expressionInfo;
+ final ExpressionInfo<Type>? expressionInfo;
SsaNode(this.expressionInfo);
@@ -2776,7 +2809,7 @@
/// Instances of this class are immutable, so the methods below that "update"
/// the state actually leave `this` unchanged and return a new state object.
@visibleForTesting
-class VariableModel<Variable extends Object, Type extends Object> {
+class VariableModel<Type extends Object> {
/// Sequence of types that the variable has been promoted to, where each
/// element of the sequence is a subtype of the previous. Null if the
/// variable hasn't been promoted.
@@ -2799,24 +2832,18 @@
/// value has changed since a time in the past.
///
/// `null` if the variable has been write captured.
- final SsaNode<Variable, Type>? ssaNode;
+ final SsaNode<Type>? ssaNode;
/// Non-promotion history of this variable.
final NonPromotionHistory<Type>? nonPromotionHistory;
- /// Promotion information for properties of this variable. We don't actually
- /// promote properties, but we track the promotions that would occur if we
- /// did, so that we can report those as non-promotion reasons.
- final Map<String, VariableModel<Variable, Type>> properties;
-
VariableModel(
{required this.promotedTypes,
required this.tested,
required this.assigned,
required this.unassigned,
required this.ssaNode,
- this.nonPromotionHistory,
- this.properties = const {}}) {
+ this.nonPromotionHistory}) {
assert(!(assigned && unassigned),
"Can't be both definitely assigned and unassigned");
assert(promotedTypes == null || promotedTypes!.isNotEmpty);
@@ -2834,9 +2861,8 @@
: promotedTypes = null,
tested = const [],
unassigned = !assigned,
- ssaNode = new SsaNode<Variable, Type>(null),
- nonPromotionHistory = null,
- properties = const {};
+ ssaNode = new SsaNode<Type>(null),
+ nonPromotionHistory = null;
/// Indicates whether the variable has been write captured.
bool get writeCaptured => ssaNode == null;
@@ -2846,27 +2872,15 @@
///
/// Used by [conservativeJoin] to update the state of variables at the top of
/// loops whose bodies write to them.
- VariableModel<Variable, Type> discardPromotionsAndMarkNotUnassigned() {
- return new VariableModel<Variable, Type>(
+ VariableModel<Type> discardPromotionsAndMarkNotUnassigned() {
+ return new VariableModel<Type>(
promotedTypes: null,
tested: tested,
assigned: assigned,
unassigned: false,
- ssaNode: writeCaptured ? null : new SsaNode<Variable, Type>(null));
+ ssaNode: writeCaptured ? null : new SsaNode<Type>(null));
}
- /// Updates `this` with a new set of properties.
- VariableModel<Variable, Type> setProperties(
- Map<String, VariableModel<Variable, Type>> newProperties) =>
- new VariableModel<Variable, Type>(
- promotedTypes: promotedTypes,
- tested: tested,
- unassigned: unassigned,
- assigned: assigned,
- ssaNode: ssaNode,
- nonPromotionHistory: nonPromotionHistory,
- properties: newProperties);
-
@override
String toString() {
List<String> parts = [ssaNode.toString()];
@@ -2888,9 +2902,6 @@
if (nonPromotionHistory != null) {
parts.add('nonPromotionHistory: $nonPromotionHistory');
}
- if (properties.isNotEmpty) {
- parts.add('properties: $properties');
- }
return 'VariableModel(${parts.join(', ')})';
}
@@ -2900,15 +2911,16 @@
/// If there is any chance that the write will cause a demotion, the caller
/// must pass in a non-null value for [nonPromotionReason] describing the
/// reason for any potential demotion.
- VariableModel<Variable, Type> write(
+ VariableModel<Type> write<Variable extends Object>(
NonPromotionReason? nonPromotionReason,
Variable variable,
+ int variableKey,
Type writtenType,
Operations<Variable, Type> operations,
- SsaNode<Variable, Type> newSsaNode,
+ SsaNode<Type> newSsaNode,
{required bool promoteToTypeOfInterest}) {
if (writeCaptured) {
- return new VariableModel<Variable, Type>(
+ return new VariableModel<Type>(
promotedTypes: promotedTypes,
tested: tested,
assigned: true,
@@ -2928,7 +2940,7 @@
// TODO(paulberry): remove demotions from demotionResult.nonPromotionHistory
// that are no longer in effect due to re-promotion.
if (identical(promotedTypes, newPromotedTypes) && assigned) {
- return new VariableModel<Variable, Type>(
+ return new VariableModel<Type>(
promotedTypes: promotedTypes,
tested: tested,
assigned: assigned,
@@ -2943,7 +2955,7 @@
newTested = tested;
}
- return new VariableModel<Variable, Type>(
+ return new VariableModel<Type>(
promotedTypes: newPromotedTypes,
tested: newTested,
assigned: true,
@@ -2954,8 +2966,8 @@
/// Returns a new [VariableModel] reflecting the fact that the variable has
/// been write-captured.
- VariableModel<Variable, Type> writeCapture() {
- return new VariableModel<Variable, Type>(
+ VariableModel<Type> writeCapture() {
+ return new VariableModel<Type>(
promotedTypes: null,
tested: const [],
assigned: assigned,
@@ -3123,14 +3135,13 @@
/// are consistently treated as "of interest" in code that follows the loop,
/// regardless of the type of loop.
@visibleForTesting
- static VariableModel<Variable, Type>
- inheritTested<Variable extends Object, Type extends Object>(
- TypeOperations<Type> typeOperations,
- VariableModel<Variable, Type> model,
- List<Type> tested) {
+ static VariableModel<Type> inheritTested<Type extends Object>(
+ TypeOperations<Type> typeOperations,
+ VariableModel<Type> model,
+ List<Type> tested) {
List<Type> newTested = joinTested(tested, model.tested, typeOperations);
if (identical(newTested, model.tested)) return model;
- return new VariableModel<Variable, Type>(
+ return new VariableModel<Type>(
promotedTypes: model.promotedTypes,
tested: newTested,
assigned: model.assigned,
@@ -3139,11 +3150,10 @@
}
/// Joins two variable models. See [FlowModel.join] for details.
- static VariableModel<Variable, Type>
- join<Variable extends Object, Type extends Object>(
- TypeOperations<Type> typeOperations,
- VariableModel<Variable, Type> first,
- VariableModel<Variable, Type> second) {
+ static VariableModel<Type> join<Type extends Object>(
+ TypeOperations<Type> typeOperations,
+ VariableModel<Type> first,
+ VariableModel<Type> second) {
List<Type>? newPromotedTypes = joinPromotedTypes(
first.promotedTypes, second.promotedTypes, typeOperations);
newPromotedTypes = typeOperations.refinePromotedTypes(
@@ -3154,11 +3164,11 @@
List<Type> newTested = newWriteCaptured
? const []
: joinTested(first.tested, second.tested, typeOperations);
- SsaNode<Variable, Type>? newSsaNode = newWriteCaptured
+ SsaNode<Type>? newSsaNode = newWriteCaptured
? null
: first.ssaNode == second.ssaNode
? first.ssaNode
- : new SsaNode<Variable, Type>(null);
+ : new SsaNode<Type>(null);
return _identicalOrNew(first, second, newPromotedTypes, newTested,
newAssigned, newUnassigned, newWriteCaptured ? null : newSsaNode);
}
@@ -3167,11 +3177,8 @@
/// chains. Briefly, we intersect given chains. The chains are totally
/// ordered subsets of a global partial order. Their intersection is a
/// subset of each, and as such is also totally ordered.
- static List<Type>?
- joinPromotedTypes<Variable extends Object, Type extends Object>(
- List<Type>? chain1,
- List<Type>? chain2,
- TypeOperations<Type> typeOperations) {
+ static List<Type>? joinPromotedTypes<Type extends Object>(List<Type>? chain1,
+ List<Type>? chain2, TypeOperations<Type> typeOperations) {
if (chain1 == null) return chain1;
if (chain2 == null) return chain2;
@@ -3214,10 +3221,8 @@
/// - The sense of equality for the union operation is determined by
/// [TypeOperations.isSameType].
/// - The types of interests lists are considered immutable.
- static List<Type> joinTested<Variable extends Object, Type extends Object>(
- List<Type> types1,
- List<Type> types2,
- TypeOperations<Type> typeOperations) {
+ static List<Type> joinTested<Type extends Object>(List<Type> types1,
+ List<Type> types2, TypeOperations<Type> typeOperations) {
// Ensure that types1 is the shorter list.
if (types1.length > types2.length) {
List<Type> tmp = types1;
@@ -3291,24 +3296,22 @@
? [promoted]
: (promotedTypes.toList()..add(promoted));
- static List<Type>
- _addTypeToUniqueList<Variable extends Object, Type extends Object>(
- List<Type> types, Type newType, TypeOperations<Type> typeOperations) {
+ static List<Type> _addTypeToUniqueList<Type extends Object>(
+ List<Type> types, Type newType, TypeOperations<Type> typeOperations) {
if (_typeListContains(typeOperations, types, newType)) return types;
return new List<Type>.of(types)..add(newType);
}
/// Creates a new [VariableModel] object, unless it is equivalent to either
/// [first] or [second], in which case one of those objects is re-used.
- static VariableModel<Variable, Type>
- _identicalOrNew<Variable extends Object, Type extends Object>(
- VariableModel<Variable, Type> first,
- VariableModel<Variable, Type> second,
- List<Type>? newPromotedTypes,
- List<Type> newTested,
- bool newAssigned,
- bool newUnassigned,
- SsaNode<Variable, Type>? newSsaNode) {
+ static VariableModel<Type> _identicalOrNew<Type extends Object>(
+ VariableModel<Type> first,
+ VariableModel<Type> second,
+ List<Type>? newPromotedTypes,
+ List<Type> newTested,
+ bool newAssigned,
+ bool newUnassigned,
+ SsaNode<Type>? newSsaNode) {
if (identical(first.promotedTypes, newPromotedTypes) &&
identical(first.tested, newTested) &&
first.assigned == newAssigned &&
@@ -3322,7 +3325,7 @@
second.ssaNode == newSsaNode) {
return second;
} else {
- return new VariableModel<Variable, Type>(
+ return new VariableModel<Type>(
promotedTypes: newPromotedTypes,
tested: newTested,
assigned: newAssigned,
@@ -3331,7 +3334,7 @@
}
}
- static bool _typeListContains<Variable extends Object, Type extends Object>(
+ static bool _typeListContains<Type extends Object>(
TypeOperations<Type> typeOperations, List<Type> list, Type searchType) {
for (Type type in list) {
if (typeOperations.isSameType(type, searchType)) return true;
@@ -3351,18 +3354,18 @@
/// (or function parameter).
@visibleForTesting
class VariableReference<Variable extends Object, Type extends Object>
- extends Reference<Variable, Type> {
+ extends Reference<Type> {
/// The variable being referred to.
final Variable variable;
- VariableReference(this.variable);
+ VariableReference(this.variable, super.promotionKey);
@override
Map<Type, NonPromotionReason> Function() getNonPromotionReasons(
- Map<Variable?, VariableModel<Variable, Type>> variableInfo,
+ Map<int, VariableModel<Type>> variableInfo,
Type staticType,
- Operations<Variable, Type> operations) {
- VariableModel<Variable, Type>? currentVariableInfo = variableInfo[variable];
+ covariant Operations<Variable, Type> operations) {
+ VariableModel<Type>? currentVariableInfo = variableInfo[promotionKey];
if (currentVariableInfo == null) {
return () => {};
}
@@ -3384,27 +3387,15 @@
}
@override
- void storeInfo(Map<Variable?, VariableModel<Variable, Type>> variableInfo,
- VariableModel<Variable, Type> variableModel) {
- variableInfo[variable] = variableModel;
- }
-
- @override
- String toString() => 'VariableReference($variable)';
-
- @override
- VariableModel<Variable, Type>? _getInfo(
- Map<Variable?, VariableModel<Variable, Type>> variableInfo) =>
- variableInfo[variable];
+ String toString() => 'VariableReference($variable, $promotionKey)';
}
class WhyNotPromotedInfo {}
/// [_FlowContext] representing an assert statement or assert initializer.
-class _AssertContext<Variable extends Object, Type extends Object>
- extends _SimpleContext<Variable, Type> {
+class _AssertContext<Type extends Object> extends _SimpleContext<Type> {
/// Flow models associated with the condition being asserted.
- ExpressionInfo<Variable, Type>? _conditionInfo;
+ ExpressionInfo<Type>? _conditionInfo;
_AssertContext(super.previous);
@@ -3416,10 +3407,9 @@
/// [_FlowContext] representing a language construct that branches on a boolean
/// condition, such as an `if` statement, conditional expression, or a logical
/// binary operator.
-class _BranchContext<Variable extends Object, Type extends Object>
- extends _FlowContext {
+class _BranchContext<Type extends Object> extends _FlowContext {
/// Flow models associated with the condition being branched on.
- final ExpressionInfo<Variable, Type>? _conditionInfo;
+ final ExpressionInfo<Type>? _conditionInfo;
_BranchContext(this._conditionInfo);
@@ -3429,15 +3419,14 @@
/// [_FlowContext] representing a language construct that can be targeted by
/// `break` or `continue` statements, such as a loop or switch statement.
-class _BranchTargetContext<Variable extends Object, Type extends Object>
- extends _FlowContext {
+class _BranchTargetContext<Type extends Object> extends _FlowContext {
/// Accumulated flow model for all `break` statements seen so far, or `null`
/// if no `break` statements have been seen yet.
- FlowModel<Variable, Type>? _breakModel;
+ FlowModel<Type>? _breakModel;
/// Accumulated flow model for all `continue` statements seen so far, or
/// `null` if no `continue` statements have been seen yet.
- FlowModel<Variable, Type>? _continueModel;
+ FlowModel<Type>? _continueModel;
/// The reachability checkpoint associated with this loop or switch statement.
/// When analyzing deeply nested `break` and `continue` statements, their flow
@@ -3453,13 +3442,12 @@
}
/// [_FlowContext] representing a conditional expression.
-class _ConditionalContext<Variable extends Object, Type extends Object>
- extends _BranchContext<Variable, Type> {
+class _ConditionalContext<Type extends Object> extends _BranchContext<Type> {
/// Flow models associated with the value of the conditional expression in the
/// circumstance where the "then" branch is taken.
- ExpressionInfo<Variable, Type>? _thenInfo;
+ ExpressionInfo<Type>? _thenInfo;
- _ConditionalContext(ExpressionInfo<Variable, Type> super.conditionInfo);
+ _ConditionalContext(ExpressionInfo<Type> super.conditionInfo);
@override
String toString() => '_ConditionalContext(conditionInfo: $_conditionInfo, '
@@ -3494,11 +3482,9 @@
/// The mapping from [Statement]s that can act as targets for `break` and
/// `continue` statements (i.e. loops and switch statements) to the to their
/// context information.
- final Map<Statement, _BranchTargetContext<Variable, Type>>
- _statementToContext = {};
+ final Map<Statement, _BranchTargetContext<Type>> _statementToContext = {};
- FlowModel<Variable, Type> _current =
- new FlowModel<Variable, Type>(Reachability.initial);
+ FlowModel<Type> _current = new FlowModel<Type>(Reachability.initial);
/// The most recently visited expression for which an [ExpressionInfo] object
/// exists, or `null` if no expression has been visited that has a
@@ -3507,7 +3493,7 @@
/// If [_expressionWithInfo] is not `null`, the [ExpressionInfo] object
/// corresponding to it. Otherwise `null`.
- ExpressionInfo<Variable, Type>? _expressionInfo;
+ ExpressionInfo<Type>? _expressionInfo;
/// The most recently visited expression which was a reference, or `null` if
/// no such expression has been visited.
@@ -3515,7 +3501,7 @@
/// If [_expressionVariable] is not `null`, the reference corresponding to it.
/// Otherwise `null`.
- ReferenceWithType<Variable, Type>? _expressionReference;
+ ReferenceWithType<Type>? _expressionReference;
final AssignedVariables<Node, Variable> _assignedVariables;
@@ -3526,19 +3512,20 @@
/// analyzing old language versions).
final bool respectImplicitlyTypedVarInitializers;
+ final PromotionKeyStore<Variable> _promotionKeyStore;
+
_FlowAnalysisImpl(this.operations, this._assignedVariables,
- {required this.respectImplicitlyTypedVarInitializers}) {
+ {required this.respectImplicitlyTypedVarInitializers})
+ : _promotionKeyStore = _assignedVariables._promotionKeyStore {
if (!_assignedVariables._isFinished) {
_assignedVariables.finish();
}
- AssignedVariablesNodeInfo<Variable> anywhere = _assignedVariables._anywhere;
- Set<Variable> implicitlyDeclaredVars = {
- ...anywhere._read,
- ...anywhere._written
- };
+ AssignedVariablesNodeInfo anywhere = _assignedVariables._anywhere;
+ Set<int> implicitlyDeclaredVars = {...anywhere._read, ...anywhere._written};
implicitlyDeclaredVars.removeAll(anywhere._declared);
- for (Variable variable in implicitlyDeclaredVars) {
- declare(variable, true);
+ for (int variableKey in implicitlyDeclaredVars) {
+ _current = _current.declare(
+ _promotionKeyStore.variableForKey(variableKey), variableKey, true);
}
}
@@ -3547,7 +3534,7 @@
@override
void asExpression_end(Expression subExpression, Type type) {
- ReferenceWithType<Variable, Type>? referenceWithType =
+ ReferenceWithType<Type>? referenceWithType =
_getExpressionReference(subExpression);
if (referenceWithType == null) return;
_current =
@@ -3556,9 +3543,8 @@
@override
void assert_afterCondition(Expression condition) {
- _AssertContext<Variable, Type> context =
- _stack.last as _AssertContext<Variable, Type>;
- ExpressionInfo<Variable, Type> conditionInfo = _expressionEnd(condition);
+ _AssertContext<Type> context = _stack.last as _AssertContext<Type>;
+ ExpressionInfo<Type> conditionInfo = _expressionEnd(condition);
context._conditionInfo = conditionInfo;
_current = conditionInfo.ifFalse;
}
@@ -3566,19 +3552,18 @@
@override
void assert_begin() {
_current = _current.split();
- _stack.add(new _AssertContext<Variable, Type>(_current));
+ _stack.add(new _AssertContext<Type>(_current));
}
@override
void assert_end() {
- _AssertContext<Variable, Type> context =
- _stack.removeLast() as _AssertContext<Variable, Type>;
+ _AssertContext<Type> context = _stack.removeLast() as _AssertContext<Type>;
_current = _merge(context._previous, context._conditionInfo!.ifTrue);
}
@override
void booleanLiteral(Expression expression, bool value) {
- FlowModel<Variable, Type> unreachable = _current.setUnreachable();
+ FlowModel<Type> unreachable = _current.setUnreachable();
_storeExpressionInfo(
expression,
value
@@ -3593,8 +3578,8 @@
@override
void conditional_elseBegin(Expression thenExpression) {
- _ConditionalContext<Variable, Type> context =
- _stack.last as _ConditionalContext<Variable, Type>;
+ _ConditionalContext<Type> context =
+ _stack.last as _ConditionalContext<Type>;
context._thenInfo = _expressionEnd(thenExpression);
_current = context._conditionInfo!.ifFalse;
}
@@ -3602,10 +3587,10 @@
@override
void conditional_end(
Expression conditionalExpression, Expression elseExpression) {
- _ConditionalContext<Variable, Type> context =
- _stack.removeLast() as _ConditionalContext<Variable, Type>;
- ExpressionInfo<Variable, Type> thenInfo = context._thenInfo!;
- ExpressionInfo<Variable, Type> elseInfo = _expressionEnd(elseExpression);
+ _ConditionalContext<Type> context =
+ _stack.removeLast() as _ConditionalContext<Type>;
+ ExpressionInfo<Type> thenInfo = context._thenInfo!;
+ ExpressionInfo<Type> elseInfo = _expressionEnd(elseExpression);
_storeExpressionInfo(
conditionalExpression,
new ExpressionInfo(
@@ -3616,22 +3601,23 @@
@override
void conditional_thenBegin(Expression condition, Node conditionalExpression) {
- ExpressionInfo<Variable, Type> conditionInfo = _expressionEnd(condition);
+ ExpressionInfo<Type> conditionInfo = _expressionEnd(condition);
_stack.add(new _ConditionalContext(conditionInfo));
_current = conditionInfo.ifTrue;
}
@override
void declare(Variable variable, bool initialized) {
- _current = _current.declare(variable, initialized);
+ _current = _current.declare(
+ variable, _promotionKeyStore.keyForVariable(variable), initialized);
}
@override
void doStatement_bodyBegin(Statement doStatement) {
- AssignedVariablesNodeInfo<Variable> info =
+ AssignedVariablesNodeInfo info =
_assignedVariables._getInfoForNode(doStatement);
- _BranchTargetContext<Variable, Type> context =
- new _BranchTargetContext<Variable, Type>(_current.reachable);
+ _BranchTargetContext<Type> context =
+ new _BranchTargetContext<Type>(_current.reachable);
_stack.add(context);
_current = _current.conservativeJoin(info._written, info._captured).split();
_statementToContext[doStatement] = context;
@@ -3639,39 +3625,34 @@
@override
void doStatement_conditionBegin() {
- _BranchTargetContext<Variable, Type> context =
- _stack.last as _BranchTargetContext<Variable, Type>;
+ _BranchTargetContext<Type> context =
+ _stack.last as _BranchTargetContext<Type>;
_current = _join(_current, context._continueModel);
}
@override
void doStatement_end(Expression condition) {
- _BranchTargetContext<Variable, Type> context =
- _stack.removeLast() as _BranchTargetContext<Variable, Type>;
+ _BranchTargetContext<Type> context =
+ _stack.removeLast() as _BranchTargetContext<Type>;
_current = _merge(_expressionEnd(condition).ifFalse, context._breakModel);
}
@override
- EqualityInfo<Variable, Type> equalityOperand_end(
- Expression operand, Type type) =>
- new EqualityInfo<Variable, Type>._(
+ EqualityInfo<Type> equalityOperand_end(Expression operand, Type type) =>
+ new EqualityInfo<Type>._(
_getExpressionInfo(operand), type, _getExpressionReference(operand));
@override
- void equalityOperation_end(
- Expression wholeExpression,
- EqualityInfo<Variable, Type>? leftOperandInfo,
- EqualityInfo<Variable, Type>? rightOperandInfo,
+ void equalityOperation_end(Expression wholeExpression,
+ EqualityInfo<Type>? leftOperandInfo, EqualityInfo<Type>? rightOperandInfo,
{bool notEqual = false}) {
// Note: leftOperandInfo and rightOperandInfo are nullable in the base class
// to account for the fact that legacy type promotion doesn't record
// information about legacy operands. But since we are currently in full
// (post null safety) flow analysis logic, we can safely assume that they
// are not null.
- ReferenceWithType<Variable, Type>? lhsReference =
- leftOperandInfo!._reference;
- ReferenceWithType<Variable, Type>? rhsReference =
- rightOperandInfo!._reference;
+ ReferenceWithType<Type>? lhsReference = leftOperandInfo!._reference;
+ ReferenceWithType<Type>? rhsReference = rightOperandInfo!._reference;
TypeClassification leftOperandTypeClassification =
operations.classifyType(leftOperandInfo._type);
TypeClassification rightOperandTypeClassification =
@@ -3689,15 +3670,15 @@
// but weak mode it might produce an "equal" result. We don't want flow
// analysis behavior to depend on mode, so we conservatively assume that
// either result is possible.
- } else if (leftOperandInfo._expressionInfo is _NullInfo<Variable, Type> &&
+ } else if (leftOperandInfo._expressionInfo is _NullInfo<Type> &&
rhsReference != null) {
- ExpressionInfo<Variable, Type> equalityInfo =
+ ExpressionInfo<Type> equalityInfo =
_current.tryMarkNonNullable(operations, rhsReference);
_storeExpressionInfo(
wholeExpression, notEqual ? equalityInfo : equalityInfo.invert());
- } else if (rightOperandInfo._expressionInfo is _NullInfo<Variable, Type> &&
+ } else if (rightOperandInfo._expressionInfo is _NullInfo<Type> &&
lhsReference != null) {
- ExpressionInfo<Variable, Type> equalityInfo =
+ ExpressionInfo<Type> equalityInfo =
_current.tryMarkNonNullable(operations, lhsReference);
_storeExpressionInfo(
wholeExpression, notEqual ? equalityInfo : equalityInfo.invert());
@@ -3705,7 +3686,7 @@
}
@override
- ExpressionInfo<Variable, Type>? expressionInfoForTesting(Expression target) =>
+ ExpressionInfo<Type>? expressionInfoForTesting(Expression target) =>
identical(target, _expressionWithInfo) ? _expressionInfo : null;
@override
@@ -3716,11 +3697,11 @@
@override
void for_bodyBegin(Statement? node, Expression? condition) {
- ExpressionInfo<Variable, Type> conditionInfo = condition == null
+ ExpressionInfo<Type> conditionInfo = condition == null
? new ExpressionInfo(_current, _current, _current.setUnreachable())
: _expressionEnd(condition);
- _WhileContext<Variable, Type> context = new _WhileContext<Variable, Type>(
- _current.reachable.parent!, conditionInfo);
+ _WhileContext<Type> context =
+ new _WhileContext<Type>(_current.reachable.parent!, conditionInfo);
_stack.add(context);
if (node != null) {
_statementToContext[node] = context;
@@ -3730,18 +3711,16 @@
@override
void for_conditionBegin(Node node) {
- AssignedVariablesNodeInfo<Variable> info =
- _assignedVariables._getInfoForNode(node);
+ AssignedVariablesNodeInfo info = _assignedVariables._getInfoForNode(node);
_current = _current.conservativeJoin(info._written, info._captured).split();
}
@override
void for_end() {
- _WhileContext<Variable, Type> context =
- _stack.removeLast() as _WhileContext<Variable, Type>;
+ _WhileContext<Type> context = _stack.removeLast() as _WhileContext<Type>;
// Tail of the stack: falseCondition, break
- FlowModel<Variable, Type>? breakState = context._breakModel;
- FlowModel<Variable, Type> falseCondition = context._conditionInfo.ifFalse;
+ FlowModel<Type>? breakState = context._breakModel;
+ FlowModel<Type> falseCondition = context._conditionInfo.ifFalse;
_current =
_merge(falseCondition, breakState).inheritTested(operations, _current);
@@ -3749,26 +3728,23 @@
@override
void for_updaterBegin() {
- _WhileContext<Variable, Type> context =
- _stack.last as _WhileContext<Variable, Type>;
+ _WhileContext<Type> context = _stack.last as _WhileContext<Type>;
_current = _join(_current, context._continueModel);
}
@override
void forEach_bodyBegin(Node node) {
- AssignedVariablesNodeInfo<Variable> info =
- _assignedVariables._getInfoForNode(node);
+ AssignedVariablesNodeInfo info = _assignedVariables._getInfoForNode(node);
_current = _current.conservativeJoin(info._written, info._captured).split();
- _SimpleStatementContext<Variable, Type> context =
- new _SimpleStatementContext<Variable, Type>(
- _current.reachable.parent!, _current);
+ _SimpleStatementContext<Type> context =
+ new _SimpleStatementContext<Type>(_current.reachable.parent!, _current);
_stack.add(context);
}
@override
void forEach_end() {
- _SimpleStatementContext<Variable, Type> context =
- _stack.removeLast() as _SimpleStatementContext<Variable, Type>;
+ _SimpleStatementContext<Type> context =
+ _stack.removeLast() as _SimpleStatementContext<Type>;
_current = _merge(_current, context._previous);
}
@@ -3784,8 +3760,7 @@
@override
void functionExpression_begin(Node node) {
- AssignedVariablesNodeInfo<Variable> info =
- _assignedVariables._getInfoForNode(node);
+ AssignedVariablesNodeInfo info = _assignedVariables._getInfoForNode(node);
_current = _current.conservativeJoin(const [], info._written);
_stack.add(new _FunctionExpressionContext(_current));
_current = _current.conservativeJoin(_assignedVariables._anywhere._written,
@@ -3794,14 +3769,14 @@
@override
void functionExpression_end() {
- _SimpleContext<Variable, Type> context =
- _stack.removeLast() as _FunctionExpressionContext<Variable, Type>;
+ _SimpleContext<Type> context =
+ _stack.removeLast() as _FunctionExpressionContext<Type>;
_current = context._previous;
}
@override
void handleBreak(Statement target) {
- _BranchTargetContext<Variable, Type>? context = _statementToContext[target];
+ _BranchTargetContext<Type>? context = _statementToContext[target];
if (context != null) {
context._breakModel =
_join(context._breakModel, _current.unsplitTo(context._checkpoint));
@@ -3811,7 +3786,7 @@
@override
void handleContinue(Statement target) {
- _BranchTargetContext<Variable, Type>? context = _statementToContext[target];
+ _BranchTargetContext<Type>? context = _statementToContext[target];
if (context != null) {
context._continueModel = _join(
context._continueModel, _current.unsplitTo(context._checkpoint));
@@ -3826,27 +3801,27 @@
@override
void ifNullExpression_end() {
- _IfNullExpressionContext<Variable, Type> context =
- _stack.removeLast() as _IfNullExpressionContext<Variable, Type>;
+ _IfNullExpressionContext<Type> context =
+ _stack.removeLast() as _IfNullExpressionContext<Type>;
_current = _merge(_current, context._previous);
}
@override
void ifNullExpression_rightBegin(
Expression leftHandSide, Type leftHandSideType) {
- ReferenceWithType<Variable, Type>? lhsReference =
+ ReferenceWithType<Type>? lhsReference =
_getExpressionReference(leftHandSide);
- FlowModel<Variable, Type> promoted;
+ FlowModel<Type> promoted;
_current = _current.split();
if (lhsReference != null) {
- ExpressionInfo<Variable, Type> promotionInfo =
+ ExpressionInfo<Type> promotionInfo =
_current.tryMarkNonNullable(operations, lhsReference);
_current = promotionInfo.ifFalse;
promoted = promotionInfo.ifTrue;
} else {
promoted = _current;
}
- _stack.add(new _IfNullExpressionContext<Variable, Type>(promoted));
+ _stack.add(new _IfNullExpressionContext<Type>(promoted));
}
@override
@@ -3856,18 +3831,16 @@
@override
void ifStatement_elseBegin() {
- _IfContext<Variable, Type> context =
- _stack.last as _IfContext<Variable, Type>;
+ _IfContext<Type> context = _stack.last as _IfContext<Type>;
context._afterThen = _current;
_current = context._conditionInfo!.ifFalse;
}
@override
void ifStatement_end(bool hasElse) {
- _IfContext<Variable, Type> context =
- _stack.removeLast() as _IfContext<Variable, Type>;
- FlowModel<Variable, Type> afterThen;
- FlowModel<Variable, Type> afterElse;
+ _IfContext<Type> context = _stack.removeLast() as _IfContext<Type>;
+ FlowModel<Type> afterThen;
+ FlowModel<Type> afterElse;
if (hasElse) {
afterThen = context._afterThen!;
afterElse = _current;
@@ -3880,7 +3853,7 @@
@override
void ifStatement_thenBegin(Expression condition, Node ifNode) {
- ExpressionInfo<Variable, Type> conditionInfo = _expressionEnd(condition);
+ ExpressionInfo<Type> conditionInfo = _expressionEnd(condition);
_stack.add(new _IfContext(conditionInfo));
_current = conditionInfo.ifTrue;
}
@@ -3891,7 +3864,8 @@
{required bool isFinal,
required bool isLate,
required bool isImplicitlyTyped}) {
- ExpressionInfo<Variable, Type>? expressionInfo;
+ int variableKey = _promotionKeyStore.keyForVariable(variable);
+ ExpressionInfo<Type>? expressionInfo;
if (isLate) {
// Don't get expression info for late variables, since we don't know when
// they'll be initialized.
@@ -3903,17 +3877,17 @@
} else {
expressionInfo = _getExpressionInfo(initializerExpression);
}
- SsaNode<Variable, Type> newSsaNode = new SsaNode<Variable, Type>(
+ SsaNode<Type> newSsaNode = new SsaNode<Type>(
expressionInfo is _TrivialExpressionInfo ? null : expressionInfo);
_current = _current.write(
- null, variable, initializerType, newSsaNode, operations,
+ null, variable, variableKey, initializerType, newSsaNode, operations,
promoteToTypeOfInterest: !isImplicitlyTyped && !isFinal);
if (isImplicitlyTyped && operations.isTypeParameterType(initializerType)) {
_current = _current
.tryPromoteForTypeCheck(
operations,
- new ReferenceWithType<Variable, Type>(
- new VariableReference<Variable, Type>(variable),
+ new ReferenceWithType<Type>(
+ new VariableReference<Variable, Type>(variable, variableKey),
promotedType(variable) ?? operations.variableType(variable)),
initializerType)
.ifTrue;
@@ -3922,17 +3896,19 @@
@override
bool isAssigned(Variable variable) {
- return _current.infoFor(variable).assigned;
+ return _current
+ .infoFor(_promotionKeyStore.keyForVariable(variable))
+ .assigned;
}
@override
void isExpression_end(Expression isExpression, Expression subExpression,
bool isNot, Type type) {
- ReferenceWithType<Variable, Type>? subExpressionReference =
+ ReferenceWithType<Type>? subExpressionReference =
_getExpressionReference(subExpression);
if (subExpressionReference != null) {
- ExpressionInfo<Variable, Type> expressionInfo = _current
- .tryPromoteForTypeCheck(operations, subExpressionReference, type);
+ ExpressionInfo<Type> expressionInfo = _current.tryPromoteForTypeCheck(
+ operations, subExpressionReference, type);
_storeExpressionInfo(
isExpression, isNot ? expressionInfo.invert() : expressionInfo);
}
@@ -3940,22 +3916,24 @@
@override
bool isUnassigned(Variable variable) {
- return _current.infoFor(variable).unassigned;
+ return _current
+ .infoFor(_promotionKeyStore.keyForVariable(variable))
+ .unassigned;
}
@override
void labeledStatement_begin(Statement node) {
_current = _current.split();
- _BranchTargetContext<Variable, Type> context =
- new _BranchTargetContext<Variable, Type>(_current.reachable.parent!);
+ _BranchTargetContext<Type> context =
+ new _BranchTargetContext<Type>(_current.reachable.parent!);
_stack.add(context);
_statementToContext[node] = context;
}
@override
void labeledStatement_end() {
- _BranchTargetContext<Variable, Type> context =
- _stack.removeLast() as _BranchTargetContext<Variable, Type>;
+ _BranchTargetContext<Type> context =
+ _stack.removeLast() as _BranchTargetContext<Type>;
_current = _merge(_current, context._breakModel);
}
@@ -3987,12 +3965,11 @@
@override
void logicalBinaryOp_end(Expression wholeExpression, Expression rightOperand,
{required bool isAnd}) {
- _BranchContext<Variable, Type> context =
- _stack.removeLast() as _BranchContext<Variable, Type>;
- ExpressionInfo<Variable, Type> rhsInfo = _expressionEnd(rightOperand);
+ _BranchContext<Type> context = _stack.removeLast() as _BranchContext<Type>;
+ ExpressionInfo<Type> rhsInfo = _expressionEnd(rightOperand);
- FlowModel<Variable, Type> trueResult;
- FlowModel<Variable, Type> falseResult;
+ FlowModel<Type> trueResult;
+ FlowModel<Type> falseResult;
if (isAnd) {
trueResult = rhsInfo.ifTrue;
falseResult = _join(context._conditionInfo!.ifFalse, rhsInfo.ifFalse);
@@ -4009,20 +3986,20 @@
@override
void logicalBinaryOp_rightBegin(Expression leftOperand, Node wholeExpression,
{required bool isAnd}) {
- ExpressionInfo<Variable, Type> conditionInfo = _expressionEnd(leftOperand);
- _stack.add(new _BranchContext<Variable, Type>(conditionInfo));
+ ExpressionInfo<Type> conditionInfo = _expressionEnd(leftOperand);
+ _stack.add(new _BranchContext<Type>(conditionInfo));
_current = isAnd ? conditionInfo.ifTrue : conditionInfo.ifFalse;
}
@override
void logicalNot_end(Expression notExpression, Expression operand) {
- ExpressionInfo<Variable, Type> conditionInfo = _expressionEnd(operand);
+ ExpressionInfo<Type> conditionInfo = _expressionEnd(operand);
_storeExpressionInfo(notExpression, conditionInfo.invert());
}
@override
void nonNullAssert_end(Expression operand) {
- ReferenceWithType<Variable, Type>? operandReference =
+ ReferenceWithType<Type>? operandReference =
_getExpressionReference(operand);
if (operandReference != null) {
_current =
@@ -4032,8 +4009,8 @@
@override
void nullAwareAccess_end() {
- _NullAwareAccessContext<Variable, Type> context =
- _stack.removeLast() as _NullAwareAccessContext<Variable, Type>;
+ _NullAwareAccessContext<Type> context =
+ _stack.removeLast() as _NullAwareAccessContext<Type>;
_current = _merge(_current, context._previous);
}
@@ -4042,9 +4019,8 @@
// ignore:unnecessary_null_comparison
assert(targetType != null);
_current = _current.split();
- _stack.add(new _NullAwareAccessContext<Variable, Type>(_current));
- ReferenceWithType<Variable, Type>? targetReference =
- _getExpressionReference(target);
+ _stack.add(new _NullAwareAccessContext<Type>(_current));
+ ReferenceWithType<Type>? targetReference = _getExpressionReference(target);
if (targetReference != null) {
_current =
_current.tryMarkNonNullable(operations, targetReference).ifTrue;
@@ -4064,32 +4040,35 @@
@override
Type? promotedType(Variable variable) {
- return _current.infoFor(variable).promotedTypes?.last;
+ return _current
+ .infoFor(_promotionKeyStore.keyForVariable(variable))
+ .promotedTypes
+ ?.last;
}
@override
void propertyGet(Expression wholeExpression, Expression target,
String propertyName, Object? propertyMember, Type staticType) {
- Reference<Variable, Type>? reference =
- _getExpressionReference(target)?.reference;
+ Reference<Type>? reference = _getExpressionReference(target)?.reference;
if (reference != null) {
_storeExpressionReference(
wholeExpression,
- new ReferenceWithType<Variable, Type>(
- reference.propertyGet(propertyName, propertyMember), staticType));
+ new ReferenceWithType<Type>(
+ reference.propertyGet(
+ _promotionKeyStore, propertyName, propertyMember),
+ staticType));
}
}
@override
- SsaNode<Variable, Type>? ssaNodeForTesting(Variable variable) =>
- _current.variableInfo[variable]?.ssaNode;
+ SsaNode<Type>? ssaNodeForTesting(Variable variable) => _current
+ .variableInfo[_promotionKeyStore.keyForVariable(variable)]?.ssaNode;
@override
void switchStatement_beginCase(bool hasLabel, Node node) {
- AssignedVariablesNodeInfo<Variable> info =
- _assignedVariables._getInfoForNode(node);
- _SimpleStatementContext<Variable, Type> context =
- _stack.last as _SimpleStatementContext<Variable, Type>;
+ AssignedVariablesNodeInfo info = _assignedVariables._getInfoForNode(node);
+ _SimpleStatementContext<Type> context =
+ _stack.last as _SimpleStatementContext<Type>;
if (hasLabel) {
_current =
context._previous.conservativeJoin(info._written, info._captured);
@@ -4100,9 +4079,9 @@
@override
void switchStatement_end(bool isExhaustive) {
- _SimpleStatementContext<Variable, Type> context =
- _stack.removeLast() as _SimpleStatementContext<Variable, Type>;
- FlowModel<Variable, Type>? breakState = context._breakModel;
+ _SimpleStatementContext<Type> context =
+ _stack.removeLast() as _SimpleStatementContext<Type>;
+ FlowModel<Type>? breakState = context._breakModel;
// It is allowed to "fall off" the end of a switch statement, so join the
// current state to any breaks that were found previously.
@@ -4117,9 +4096,8 @@
@override
void switchStatement_expressionEnd(Statement switchStatement) {
_current = _current.split();
- _SimpleStatementContext<Variable, Type> context =
- new _SimpleStatementContext<Variable, Type>(
- _current.reachable.parent!, _current);
+ _SimpleStatementContext<Type> context =
+ new _SimpleStatementContext<Type>(_current.reachable.parent!, _current);
_stack.add(context);
_statementToContext[switchStatement] = context;
}
@@ -4128,8 +4106,9 @@
void thisOrSuper(Expression expression, Type staticType) {
_storeExpressionReference(
expression,
- new ReferenceWithType<Variable, Type>(
- new _ThisReference<Variable, Type>(), staticType));
+ new ReferenceWithType<Type>(
+ new _ThisReference<Type>(_promotionKeyStore.thisPromotionKey),
+ staticType));
}
@override
@@ -4137,29 +4116,27 @@
Object? propertyMember, Type staticType) {
_storeExpressionReference(
expression,
- new ReferenceWithType<Variable, Type>(
- new _ThisReference<Variable, Type>()
- .propertyGet(propertyName, propertyMember),
+ new ReferenceWithType<Type>(
+ new _ThisReference<Type>(_promotionKeyStore.thisPromotionKey)
+ .propertyGet(_promotionKeyStore, propertyName, propertyMember),
staticType));
}
@override
void tryCatchStatement_bodyBegin() {
_current = _current.split();
- _stack.add(new _TryContext<Variable, Type>(_current));
+ _stack.add(new _TryContext<Type>(_current));
}
@override
void tryCatchStatement_bodyEnd(Node body) {
- FlowModel<Variable, Type> afterBody = _current;
+ FlowModel<Type> afterBody = _current;
- _TryContext<Variable, Type> context =
- _stack.last as _TryContext<Variable, Type>;
- FlowModel<Variable, Type> beforeBody = context._previous;
+ _TryContext<Type> context = _stack.last as _TryContext<Type>;
+ FlowModel<Type> beforeBody = context._previous;
- AssignedVariablesNodeInfo<Variable> info =
- _assignedVariables._getInfoForNode(body);
- FlowModel<Variable, Type> beforeCatch =
+ AssignedVariablesNodeInfo info = _assignedVariables._getInfoForNode(body);
+ FlowModel<Type> beforeCatch =
beforeBody.conservativeJoin(info._written, info._captured);
context._beforeCatch = beforeCatch;
@@ -4169,51 +4146,52 @@
@override
void tryCatchStatement_catchBegin(
Variable? exceptionVariable, Variable? stackTraceVariable) {
- _TryContext<Variable, Type> context =
- _stack.last as _TryContext<Variable, Type>;
+ _TryContext<Type> context = _stack.last as _TryContext<Type>;
_current = context._beforeCatch!;
if (exceptionVariable != null) {
- _current = _current.declare(exceptionVariable, true);
+ int exceptionVariableKey =
+ _promotionKeyStore.keyForVariable(exceptionVariable);
+ _current =
+ _current.declare(exceptionVariable, exceptionVariableKey, true);
}
if (stackTraceVariable != null) {
- _current = _current.declare(stackTraceVariable, true);
+ int stackTraceVariableKey =
+ _promotionKeyStore.keyForVariable(stackTraceVariable);
+ _current =
+ _current.declare(stackTraceVariable, stackTraceVariableKey, true);
}
}
@override
void tryCatchStatement_catchEnd() {
- _TryContext<Variable, Type> context =
- _stack.last as _TryContext<Variable, Type>;
+ _TryContext<Type> context = _stack.last as _TryContext<Type>;
context._afterBodyAndCatches =
_join(context._afterBodyAndCatches, _current);
}
@override
void tryCatchStatement_end() {
- _TryContext<Variable, Type> context =
- _stack.removeLast() as _TryContext<Variable, Type>;
+ _TryContext<Type> context = _stack.removeLast() as _TryContext<Type>;
_current = context._afterBodyAndCatches!.unsplit();
}
@override
void tryFinallyStatement_bodyBegin() {
- _stack.add(new _TryFinallyContext<Variable, Type>(_current));
+ _stack.add(new _TryFinallyContext<Type>(_current));
}
@override
void tryFinallyStatement_end() {
- _TryFinallyContext<Variable, Type> context =
- _stack.removeLast() as _TryFinallyContext<Variable, Type>;
+ _TryFinallyContext<Type> context =
+ _stack.removeLast() as _TryFinallyContext<Type>;
_current = context._afterBodyAndCatches!
.attachFinally(operations, context._beforeFinally, _current);
}
@override
void tryFinallyStatement_finallyBegin(Node body) {
- AssignedVariablesNodeInfo<Variable> info =
- _assignedVariables._getInfoForNode(body);
- _TryFinallyContext<Variable, Type> context =
- _stack.last as _TryFinallyContext<Variable, Type>;
+ AssignedVariablesNodeInfo info = _assignedVariables._getInfoForNode(body);
+ _TryFinallyContext<Type> context = _stack.last as _TryFinallyContext<Type>;
context._afterBodyAndCatches = _current;
_current = _join(_current,
context._previous.conservativeJoin(info._written, info._captured));
@@ -4222,16 +4200,16 @@
@override
Type? variableRead(Expression expression, Variable variable) {
+ int variableKey = _promotionKeyStore.keyForVariable(variable);
VariableReference<Variable, Type> variableReference =
- new VariableReference<Variable, Type>(variable);
- VariableModel<Variable, Type> variableModel =
+ new VariableReference<Variable, Type>(variable, variableKey);
+ VariableModel<Type> variableModel =
variableReference.getInfo(_current.variableInfo);
Type? promotedType = variableModel.promotedTypes?.last;
Type currentType = promotedType ?? operations.variableType(variable);
_storeExpressionReference(expression,
- new ReferenceWithType<Variable, Type>(variableReference, currentType));
- ExpressionInfo<Variable, Type>? expressionInfo = variableModel
- .ssaNode?.expressionInfo
+ new ReferenceWithType<Type>(variableReference, currentType));
+ ExpressionInfo<Type>? expressionInfo = variableModel.ssaNode?.expressionInfo
?.rebaseForward(operations, _current);
if (expressionInfo != null) {
_storeExpressionInfo(expression, expressionInfo);
@@ -4242,9 +4220,9 @@
@override
void whileStatement_bodyBegin(
Statement whileStatement, Expression condition) {
- ExpressionInfo<Variable, Type> conditionInfo = _expressionEnd(condition);
- _WhileContext<Variable, Type> context = new _WhileContext<Variable, Type>(
- _current.reachable.parent!, conditionInfo);
+ ExpressionInfo<Type> conditionInfo = _expressionEnd(condition);
+ _WhileContext<Type> context =
+ new _WhileContext<Type>(_current.reachable.parent!, conditionInfo);
_stack.add(context);
_statementToContext[whileStatement] = context;
_current = conditionInfo.ifTrue;
@@ -4253,15 +4231,13 @@
@override
void whileStatement_conditionBegin(Node node) {
_current = _current.split();
- AssignedVariablesNodeInfo<Variable> info =
- _assignedVariables._getInfoForNode(node);
+ AssignedVariablesNodeInfo info = _assignedVariables._getInfoForNode(node);
_current = _current.conservativeJoin(info._written, info._captured);
}
@override
void whileStatement_end() {
- _WhileContext<Variable, Type> context =
- _stack.removeLast() as _WhileContext<Variable, Type>;
+ _WhileContext<Type> context = _stack.removeLast() as _WhileContext<Type>;
_current = _merge(context._conditionInfo.ifFalse, context._breakModel)
.inheritTested(operations, _current);
}
@@ -4269,8 +4245,7 @@
@override
Map<Type, NonPromotionReason> Function() whyNotPromoted(Expression target) {
if (identical(target, _expressionWithReference)) {
- ReferenceWithType<Variable, Type>? referenceWithType =
- _expressionReference;
+ ReferenceWithType<Type>? referenceWithType = _expressionReference;
if (referenceWithType != null) {
return referenceWithType.reference.getNonPromotionReasons(
_current.variableInfo, referenceWithType.type, operations);
@@ -4282,21 +4257,23 @@
@override
Map<Type, NonPromotionReason> Function() whyNotPromotedImplicitThis(
Type staticType) {
- return new _ThisReference<Variable, Type>()
+ return new _ThisReference<Type>(_promotionKeyStore.thisPromotionKey)
.getNonPromotionReasons(_current.variableInfo, staticType, operations);
}
@override
void write(Node node, Variable variable, Type writtenType,
Expression? writtenExpression) {
- ExpressionInfo<Variable, Type>? expressionInfo = writtenExpression == null
+ int variableKey = _promotionKeyStore.keyForVariable(variable);
+ ExpressionInfo<Type>? expressionInfo = writtenExpression == null
? null
: _getExpressionInfo(writtenExpression);
- SsaNode<Variable, Type> newSsaNode = new SsaNode<Variable, Type>(
+ SsaNode<Type> newSsaNode = new SsaNode<Type>(
expressionInfo is _TrivialExpressionInfo ? null : expressionInfo);
_current = _current.write(
new DemoteViaExplicitWrite<Variable>(variable, node),
variable,
+ variableKey,
writtenType,
newSsaNode,
operations);
@@ -4319,16 +4296,16 @@
/// be the last expression that was traversed). If there is no
/// [ExpressionInfo] associated with the [expression], then a fresh
/// [ExpressionInfo] is created recording the current flow analysis state.
- ExpressionInfo<Variable, Type> _expressionEnd(Expression expression) =>
+ ExpressionInfo<Type> _expressionEnd(Expression expression) =>
_getExpressionInfo(expression) ?? new _TrivialExpressionInfo(_current);
/// Gets the [ExpressionInfo] associated with the [expression] (which should
/// be the last expression that was traversed). If there is no
/// [ExpressionInfo] associated with the [expression], then `null` is
/// returned.
- ExpressionInfo<Variable, Type>? _getExpressionInfo(Expression expression) {
+ ExpressionInfo<Type>? _getExpressionInfo(Expression expression) {
if (identical(expression, _expressionWithInfo)) {
- ExpressionInfo<Variable, Type>? expressionInfo = _expressionInfo;
+ ExpressionInfo<Type>? expressionInfo = _expressionInfo;
_expressionInfo = null;
return expressionInfo;
} else {
@@ -4339,11 +4316,9 @@
/// Gets the [Reference] associated with the [expression] (which should be the
/// last expression that was traversed). If there is no [Reference]
/// associated with the [expression], then `null` is returned.
- ReferenceWithType<Variable, Type>? _getExpressionReference(
- Expression? expression) {
+ ReferenceWithType<Type>? _getExpressionReference(Expression? expression) {
if (identical(expression, _expressionWithReference)) {
- ReferenceWithType<Variable, Type>? expressionReference =
- _expressionReference;
+ ReferenceWithType<Type>? expressionReference = _expressionReference;
_expressionReference = null;
return expressionReference;
} else {
@@ -4351,19 +4326,17 @@
}
}
- FlowModel<Variable, Type> _join(FlowModel<Variable, Type>? first,
- FlowModel<Variable, Type>? second) =>
+ FlowModel<Type> _join(FlowModel<Type>? first, FlowModel<Type>? second) =>
FlowModel.join(operations, first, second, _current._emptyVariableMap);
- FlowModel<Variable, Type> _merge(
- FlowModel<Variable, Type> first, FlowModel<Variable, Type>? second) =>
+ FlowModel<Type> _merge(FlowModel<Type> first, FlowModel<Type>? second) =>
FlowModel.merge(operations, first, second, _current._emptyVariableMap);
/// Associates [expression], which should be the most recently visited
/// expression, with the given [expressionInfo] object, and updates the
/// current flow model state to correspond to it.
void _storeExpressionInfo(
- Expression expression, ExpressionInfo<Variable, Type> expressionInfo) {
+ Expression expression, ExpressionInfo<Type> expressionInfo) {
_expressionWithInfo = expression;
_expressionInfo = expressionInfo;
_current = expressionInfo.after;
@@ -4371,8 +4344,8 @@
/// Associates [expression], which should be the most recently visited
/// expression, with the given [Reference] object.
- void _storeExpressionReference(Expression expression,
- ReferenceWithType<Variable, Type> expressionReference) {
+ void _storeExpressionReference(
+ Expression expression, ReferenceWithType<Type> expressionReference) {
_expressionWithReference = expression;
_expressionReference = expressionReference;
}
@@ -4383,8 +4356,8 @@
abstract class _FlowContext {}
/// [_FlowContext] representing a function expression.
-class _FunctionExpressionContext<Variable extends Object, Type extends Object>
- extends _SimpleContext<Variable, Type> {
+class _FunctionExpressionContext<Type extends Object>
+ extends _SimpleContext<Type> {
_FunctionExpressionContext(super.previous);
@override
@@ -4392,13 +4365,12 @@
}
/// [_FlowContext] representing an `if` statement.
-class _IfContext<Variable extends Object, Type extends Object>
- extends _BranchContext<Variable, Type> {
+class _IfContext<Type extends Object> extends _BranchContext<Type> {
/// Flow model associated with the state of program execution after the `if`
/// statement executes, in the circumstance where the "then" branch is taken.
- FlowModel<Variable, Type>? _afterThen;
+ FlowModel<Type>? _afterThen;
- _IfContext(ExpressionInfo<Variable, Type> super.conditionInfo);
+ _IfContext(ExpressionInfo<Type> super.conditionInfo);
@override
String toString() =>
@@ -4406,8 +4378,8 @@
}
/// [_FlowContext] representing an "if-null" (`??`) expression.
-class _IfNullExpressionContext<Variable extends Object, Type extends Object>
- extends _SimpleContext<Variable, Type> {
+class _IfNullExpressionContext<Type extends Object>
+ extends _SimpleContext<Type> {
_IfNullExpressionContext(super.previous);
@override
@@ -4416,14 +4388,14 @@
/// Contextual information tracked by legacy type promotion about a binary "and"
/// expression (`&&`).
-class _LegacyBinaryAndContext<Variable extends Object, Type extends Object>
- extends _LegacyContext<Variable, Type> {
+class _LegacyBinaryAndContext<Type extends Object>
+ extends _LegacyContext<Type> {
/// Types that were shown by the LHS of the "and" expression.
- final Map<Variable, Type> _lhsShownTypes;
+ final Map<int, Type> _lhsShownTypes;
/// Information about variables that might be assigned by the RHS of the "and"
/// expression.
- final AssignedVariablesNodeInfo<Variable> _assignedVariablesInfoForRhs;
+ final AssignedVariablesNodeInfo _assignedVariablesInfoForRhs;
_LegacyBinaryAndContext(super.previousKnownTypes, this._lhsShownTypes,
this._assignedVariablesInfoForRhs);
@@ -4431,22 +4403,22 @@
/// Contextual information tracked by legacy type promotion about a statement or
/// expression.
-class _LegacyContext<Variable, Type> {
+class _LegacyContext<Type> {
/// The set of known types in effect before the statement or expression in
/// question was encountered.
- final Map<Variable, Type> _previousKnownTypes;
+ final Map<int, Type> _previousKnownTypes;
_LegacyContext(this._previousKnownTypes);
}
/// Data tracked by legacy type promotion about an expression.
-class _LegacyExpressionInfo<Variable, Type> {
+class _LegacyExpressionInfo<Type> {
/// Variables whose types are "shown" by the expression in question.
///
/// For example, the spec says that the expression `x is T` "shows" `x` to
/// have type `T`, so accordingly, the [_LegacyExpressionInfo] for `x is T`
/// will have an entry in this map that maps `x` to `T`.
- final Map<Variable, Type> _shownTypes;
+ final Map<int, Type> _shownTypes;
_LegacyExpressionInfo(this._shownTypes);
@@ -4474,14 +4446,14 @@
/// If [_expressionWithInfo] is not `null`, the [_LegacyExpressionInfo] object
/// corresponding to it. Otherwise `null`.
- _LegacyExpressionInfo<Variable, Type>? _expressionInfo;
+ _LegacyExpressionInfo<Type>? _expressionInfo;
/// The set of type promotions currently in effect.
- Map<Variable, Type> _knownTypes = {};
+ Map<int, Type> _knownTypes = {};
/// Stack of [_LegacyContext] objects representing the statements and
/// expressions that are currently being visited.
- final List<_LegacyContext<Variable, Type>> _contextStack = [];
+ final List<_LegacyContext<Type>> _contextStack = [];
/// Stack for tracking writes occurring on the LHS of a binary "and" (`&&`)
/// operation. Whenever we visit a write, we update the top entry in this
@@ -4489,9 +4461,12 @@
/// a fresh empty entry onto this stack; accordingly, upon reaching the RHS of
/// the binary "and", the top entry of the stack contains the set of variables
/// written to during the LHS of the "and".
- final List<Set<Variable>> _writeStackForAnd = [{}];
+ final List<Set<int>> _writeStackForAnd = [{}];
- _LegacyTypePromotion(this._operations, this._assignedVariables);
+ final PromotionKeyStore<Variable> _promotionKeyStore;
+
+ _LegacyTypePromotion(this._operations, this._assignedVariables)
+ : _promotionKeyStore = _assignedVariables._promotionKeyStore;
@override
bool get isReachable => true;
@@ -4544,19 +4519,16 @@
void doStatement_end(Expression condition) {}
@override
- EqualityInfo<Variable, Type>? equalityOperand_end(
- Expression operand, Type type) =>
+ EqualityInfo<Type>? equalityOperand_end(Expression operand, Type type) =>
null;
@override
- void equalityOperation_end(
- Expression wholeExpression,
- EqualityInfo<Variable, Type>? leftOperandInfo,
- EqualityInfo<Variable, Type>? rightOperandInfo,
+ void equalityOperation_end(Expression wholeExpression,
+ EqualityInfo<Type>? leftOperandInfo, EqualityInfo<Type>? rightOperandInfo,
{bool notEqual = false}) {}
@override
- ExpressionInfo<Variable, Type>? expressionInfoForTesting(Expression target) {
+ ExpressionInfo<Type>? expressionInfoForTesting(Expression target) {
throw new StateError(
'expressionInfoForTesting requires null-aware flow analysis');
}
@@ -4648,19 +4620,18 @@
@override
void isExpression_end(Expression isExpression, Expression subExpression,
bool isNot, Type type) {
- _LegacyExpressionInfo<Variable, Type>? expressionInfo =
+ _LegacyExpressionInfo<Type>? expressionInfo =
_getExpressionInfo(subExpression);
if (!isNot && expressionInfo is _LegacyVariableReadInfo<Variable, Type>) {
Variable variable = expressionInfo._variable;
+ int variableKey = expressionInfo._variableKey;
Type currentType =
- _knownTypes[variable] ?? _operations.variableType(variable);
+ _knownTypes[variableKey] ?? _operations.variableType(variable);
Type? promotedType = _operations.tryPromoteToType(type, currentType);
if (promotedType != null &&
!_operations.isSameType(currentType, promotedType)) {
- _storeExpressionInfo(
- isExpression,
- new _LegacyExpressionInfo<Variable, Type>(
- {variable: promotedType}));
+ _storeExpressionInfo(isExpression,
+ new _LegacyExpressionInfo<Type>({variableKey: promotedType}));
}
}
}
@@ -4691,13 +4662,13 @@
void logicalBinaryOp_end(Expression wholeExpression, Expression rightOperand,
{required bool isAnd}) {
if (!isAnd) return;
- _LegacyBinaryAndContext<Variable, Type> context =
- _contextStack.removeLast() as _LegacyBinaryAndContext<Variable, Type>;
+ _LegacyBinaryAndContext<Type> context =
+ _contextStack.removeLast() as _LegacyBinaryAndContext<Type>;
_knownTypes = context._previousKnownTypes;
- AssignedVariablesNodeInfo<Variable> assignedVariablesInfoForRhs =
+ AssignedVariablesNodeInfo assignedVariablesInfoForRhs =
context._assignedVariablesInfoForRhs;
- Map<Variable, Type> lhsShownTypes = context._lhsShownTypes;
- Map<Variable, Type> rhsShownTypes =
+ Map<int, Type> lhsShownTypes = context._lhsShownTypes;
+ Map<int, Type> rhsShownTypes =
_getExpressionInfo(rightOperand)?._shownTypes ?? {};
// A logical boolean expression b of the form `e1 && e2` shows that a local
// variable v has type T if both of the following conditions hold:
@@ -4715,12 +4686,12 @@
// type T2? The de facto behavior we have had for a long time is to combine
// the two types in the same way we would combine it if c were first
// promoted to T1 and then had a successful `is T2` check.
- Map<Variable, Type> newShownTypes = {};
- for (MapEntry<Variable, Type> entry in lhsShownTypes.entries) {
+ Map<int, Type> newShownTypes = {};
+ for (MapEntry<int, Type> entry in lhsShownTypes.entries) {
if (assignedVariablesInfoForRhs._written.contains(entry.key)) continue;
newShownTypes[entry.key] = entry.value;
}
- for (MapEntry<Variable, Type> entry in rhsShownTypes.entries) {
+ for (MapEntry<int, Type> entry in rhsShownTypes.entries) {
if (assignedVariablesInfoForRhs._written.contains(entry.key)) continue;
Type? previouslyShownType = newShownTypes[entry.key];
if (previouslyShownType == null) {
@@ -4734,24 +4705,24 @@
}
}
}
- _storeExpressionInfo(wholeExpression,
- new _LegacyExpressionInfo<Variable, Type>(newShownTypes));
+ _storeExpressionInfo(
+ wholeExpression, new _LegacyExpressionInfo<Type>(newShownTypes));
}
@override
void logicalBinaryOp_rightBegin(Expression leftOperand, Node wholeExpression,
{required bool isAnd}) {
- Set<Variable> variablesWrittenOnLhs = _writeStackForAnd.removeLast();
+ Set<int> variablesWrittenOnLhs = _writeStackForAnd.removeLast();
_writeStackForAnd.last.addAll(variablesWrittenOnLhs);
if (!isAnd) return;
- AssignedVariablesNodeInfo<Variable> info =
+ AssignedVariablesNodeInfo info =
_assignedVariables._getInfoForNode(wholeExpression);
- Map<Variable, Type> lhsShownTypes =
+ Map<int, Type> lhsShownTypes =
_getExpressionInfo(leftOperand)?._shownTypes ?? {};
- _contextStack.add(new _LegacyBinaryAndContext<Variable, Type>(
- _knownTypes, lhsShownTypes, info));
- Map<Variable, Type>? newKnownTypes;
- for (MapEntry<Variable, Type> entry in lhsShownTypes.entries) {
+ _contextStack.add(
+ new _LegacyBinaryAndContext<Type>(_knownTypes, lhsShownTypes, info));
+ Map<int, Type>? newKnownTypes;
+ for (MapEntry<int, Type> entry in lhsShownTypes.entries) {
// Given a statement of the form `e1 && e2`, if e1 shows that a
// local variable v has type T, then the type of v is known to be T in
// e2, unless any of the following are true:
@@ -4770,7 +4741,7 @@
_assignedVariables._anywhere._written.contains(entry.key)) {
continue;
}
- (newKnownTypes ??= new Map<Variable, Type>.of(_knownTypes))[entry.key] =
+ (newKnownTypes ??= new Map<int, Type>.of(_knownTypes))[entry.key] =
entry.value;
}
if (newKnownTypes != null) _knownTypes = newKnownTypes;
@@ -4799,7 +4770,8 @@
@override
Type? promotedType(Variable variable) {
- return _knownTypes[variable];
+ int variableKey = _promotionKeyStore.keyForVariable(variable);
+ return _knownTypes[variableKey];
}
@override
@@ -4807,7 +4779,7 @@
String propertyName, Object? propertyMember, Type staticType) {}
@override
- SsaNode<Variable, Type>? ssaNodeForTesting(Variable variable) {
+ SsaNode<Type>? ssaNodeForTesting(Variable variable) {
throw new StateError('ssaNodeForTesting requires null-aware flow analysis');
}
@@ -4854,9 +4826,10 @@
@override
Type? variableRead(Expression expression, Variable variable) {
- _storeExpressionInfo(
- expression, new _LegacyVariableReadInfo<Variable, Type>(variable));
- return _knownTypes[variable];
+ int variableKey = _promotionKeyStore.keyForVariable(variable);
+ _storeExpressionInfo(expression,
+ new _LegacyVariableReadInfo<Variable, Type>(variable, variableKey));
+ return _knownTypes[variableKey];
}
@override
@@ -4883,19 +4856,17 @@
@override
void write(Node node, Variable variable, Type writtenType,
Expression? writtenExpression) {
- _writeStackForAnd.last.add(variable);
+ int variableKey = _promotionKeyStore.keyForVariable(variable);
+ _writeStackForAnd.last.add(variableKey);
}
void _conditionalOrIf_thenBegin(Expression condition, Node node) {
- _contextStack.add(new _LegacyContext<Variable, Type>(_knownTypes));
- AssignedVariablesNodeInfo<Variable> info =
- _assignedVariables._getInfoForNode(node);
- Map<Variable, Type>? newKnownTypes;
- _LegacyExpressionInfo<Variable, Type>? expressionInfo =
- _getExpressionInfo(condition);
+ _contextStack.add(new _LegacyContext<Type>(_knownTypes));
+ AssignedVariablesNodeInfo info = _assignedVariables._getInfoForNode(node);
+ Map<int, Type>? newKnownTypes;
+ _LegacyExpressionInfo<Type>? expressionInfo = _getExpressionInfo(condition);
if (expressionInfo != null) {
- for (MapEntry<Variable, Type> entry
- in expressionInfo._shownTypes.entries) {
+ for (MapEntry<int, Type> entry in expressionInfo._shownTypes.entries) {
// Given an expression of the form n1?n2:n3 or a statement of the form
// `if (n1) n2 else n3`, if n1 shows that a local variable v has type T,
// then the type of v is known to be T in n2, unless any of the
@@ -4913,7 +4884,7 @@
_assignedVariables._anywhere._written.contains(entry.key)) {
continue;
}
- (newKnownTypes ??= new Map<Variable, Type>.of(_knownTypes))[entry.key] =
+ (newKnownTypes ??= new Map<int, Type>.of(_knownTypes))[entry.key] =
entry.value;
}
if (newKnownTypes != null) _knownTypes = newKnownTypes;
@@ -4926,21 +4897,20 @@
print(' expressionWithInfo: $_expressionWithInfo');
print(' expressionInfo: $_expressionInfo');
print(' contextStack:');
- for (_LegacyContext<Variable, Type> stackEntry in _contextStack.reversed) {
+ for (_LegacyContext<Type> stackEntry in _contextStack.reversed) {
print(' $stackEntry');
}
print(' writeStackForAnd:');
- for (Set<Variable> stackEntry in _writeStackForAnd.reversed) {
+ for (Set<int> stackEntry in _writeStackForAnd.reversed) {
print(' $stackEntry');
}
}
/// Gets the [_LegacyExpressionInfo] associated with [expression], if any;
/// otherwise returns `null`.
- _LegacyExpressionInfo<Variable, Type>? _getExpressionInfo(
- Expression expression) {
+ _LegacyExpressionInfo<Type>? _getExpressionInfo(Expression expression) {
if (identical(expression, _expressionWithInfo)) {
- _LegacyExpressionInfo<Variable, Type>? expressionInfo = _expressionInfo;
+ _LegacyExpressionInfo<Type>? expressionInfo = _expressionInfo;
_expressionInfo = null;
return expressionInfo;
} else {
@@ -4950,8 +4920,8 @@
/// Associates [expressionInfo] with [expression] for use by a future call to
/// [_getExpressionInfo].
- void _storeExpressionInfo(Expression expression,
- _LegacyExpressionInfo<Variable, Type> expressionInfo) {
+ void _storeExpressionInfo(
+ Expression expression, _LegacyExpressionInfo<Type> expressionInfo) {
_expressionWithInfo = expression;
_expressionInfo = expressionInfo;
}
@@ -4960,22 +4930,25 @@
/// Data tracked by legacy type promotion about an expression that reads the
/// value of a local variable.
class _LegacyVariableReadInfo<Variable, Type>
- implements _LegacyExpressionInfo<Variable, Type> {
+ implements _LegacyExpressionInfo<Type> {
/// The variable being referred to.
final Variable _variable;
- _LegacyVariableReadInfo(this._variable);
+ /// The variable's corresponding key, as assigned by [PromotionKeyStore].
+ final int _variableKey;
+
+ _LegacyVariableReadInfo(this._variable, this._variableKey);
@override
- Map<Variable, Type> get _shownTypes => {};
+ Map<int, Type> get _shownTypes => {};
@override
String toString() => 'LegacyVariableReadInfo($_variable, $_shownTypes)';
}
/// [_FlowContext] representing a null aware access (`?.`).
-class _NullAwareAccessContext<Variable extends Object, Type extends Object>
- extends _SimpleContext<Variable, Type> {
+class _NullAwareAccessContext<Type extends Object>
+ extends _SimpleContext<Type> {
_NullAwareAccessContext(super.previous);
@override
@@ -4983,21 +4956,20 @@
}
/// [ExpressionInfo] representing a `null` literal.
-class _NullInfo<Variable extends Object, Type extends Object>
- implements ExpressionInfo<Variable, Type> {
+class _NullInfo<Type extends Object> implements ExpressionInfo<Type> {
@override
- final FlowModel<Variable, Type> after;
+ final FlowModel<Type> after;
_NullInfo(this.after);
@override
- FlowModel<Variable, Type> get ifFalse => after;
+ FlowModel<Type> get ifFalse => after;
@override
- FlowModel<Variable, Type> get ifTrue => after;
+ FlowModel<Type> get ifTrue => after;
@override
- ExpressionInfo<Variable, Type> invert() {
+ ExpressionInfo<Type> invert() {
// This should only happen if `!null` is encountered. That should never
// happen for a properly typed program, but we need to handle it so we can
// give reasonable errors for an improperly typed program.
@@ -5005,20 +4977,13 @@
}
@override
- ExpressionInfo<Variable, Type>? rebaseForward(
- TypeOperations<Type> typeOperations,
- FlowModel<Variable, Type> base) =>
+ ExpressionInfo<Type>? rebaseForward(
+ TypeOperations<Type> typeOperations, FlowModel<Type> base) =>
null;
}
/// [Reference] object representing a property get applied to another reference.
-class _PropertyGetReference<Variable extends Object, Type extends Object>
- extends Reference<Variable, Type> {
- /// The target of the property get. For example a property get of the form
- /// `a.b`, where `a` is a local variable, has a target which is a reference to
- /// `a`.
- final Reference<Variable, Type> target;
-
+class _PropertyGetReference<Type extends Object> extends Reference<Type> {
/// The name of the property.
final String propertyName;
@@ -5027,11 +4992,12 @@
/// [FlowAnalysis.thisOrSuperPropertyGet].
final Object? propertyMember;
- _PropertyGetReference(this.target, this.propertyName, this.propertyMember);
+ _PropertyGetReference(
+ this.propertyName, this.propertyMember, super.promotionKey);
@override
Map<Type, NonPromotionReason> Function() getNonPromotionReasons(
- Map<Variable?, VariableModel<Variable, Type>> variableInfo,
+ Map<int, VariableModel<Type>> variableInfo,
Type staticType,
TypeOperations<Type> typeOperations) {
List<Type>? promotedTypes = _getInfo(variableInfo)?.promotedTypes;
@@ -5049,39 +5015,20 @@
}
@override
- void storeInfo(Map<Variable?, VariableModel<Variable, Type>> variableInfo,
- VariableModel<Variable, Type> variableModel) {
- VariableModel<Variable, Type> targetInfo = target.getInfo(variableInfo);
- Map<String, VariableModel<Variable, Type>> newProperties =
- new Map<String, VariableModel<Variable, Type>>.of(
- targetInfo.properties);
- newProperties[propertyName] = variableModel;
- target.storeInfo(variableInfo, targetInfo.setProperties(newProperties));
- }
-
- @override
String toString() =>
- '_PropertyGetReference($target, $propertyName, $propertyMember)';
-
- @override
- VariableModel<Variable, Type>? _getInfo(
- Map<Variable?, VariableModel<Variable, Type>> variableInfo) {
- VariableModel<Variable, Type> targetInfo = target.getInfo(variableInfo);
- return targetInfo.properties[propertyName];
- }
+ '_PropertyGetReference($propertyName, $propertyMember, $promotionKey)';
}
/// [_FlowContext] representing a language construct for which flow analysis
/// must store a flow model state to be retrieved later, such as a `try`
/// statement, function expression, or "if-null" (`??`) expression.
-abstract class _SimpleContext<Variable extends Object, Type extends Object>
- extends _FlowContext {
+abstract class _SimpleContext<Type extends Object> extends _FlowContext {
/// The stored state. For a `try` statement, this is the state from the
/// beginning of the `try` block. For a function expression, this is the
/// state at the point the function expression was created. For an "if-null"
/// expression, this is the state after execution of the expression before the
/// `??`.
- final FlowModel<Variable, Type> _previous;
+ final FlowModel<Type> _previous;
_SimpleContext(this._previous);
}
@@ -5090,12 +5037,12 @@
/// `break` or `continue` statements, and for which flow analysis must store a
/// flow model state to be retrieved later. Examples include "for each" and
/// `switch` statements.
-class _SimpleStatementContext<Variable extends Object, Type extends Object>
- extends _BranchTargetContext<Variable, Type> {
+class _SimpleStatementContext<Type extends Object>
+ extends _BranchTargetContext<Type> {
/// The stored state. For a "for each" statement, this is the state after
/// evaluation of the iterable. For a `switch` statement, this is the state
/// after evaluation of the switch expression.
- final FlowModel<Variable, Type> _previous;
+ final FlowModel<Type> _previous;
_SimpleStatementContext(super.checkpoint, this._previous);
@@ -5106,11 +5053,12 @@
}
/// [Reference] object representing an implicit or explicit reference to `this`.
-class _ThisReference<Variable extends Object, Type extends Object>
- extends Reference<Variable, Type> {
+class _ThisReference<Type extends Object> extends Reference<Type> {
+ _ThisReference(super.promotionKey);
+
@override
Map<Type, NonPromotionReason> Function() getNonPromotionReasons(
- Map<Variable?, VariableModel<Variable, Type>> variableInfo,
+ Map<int, VariableModel<Type>> variableInfo,
Type staticType,
TypeOperations<Type> typeOperations) {
List<Type>? promotedTypes = _getInfo(variableInfo)?.promotedTypes;
@@ -5125,58 +5073,45 @@
}
return () => {};
}
-
- @override
- void storeInfo(Map<Variable?, VariableModel<Variable, Type>> variableInfo,
- VariableModel<Variable, Type> variableModel) {
- variableInfo[null] = variableModel;
- }
-
- @override
- VariableModel<Variable, Type>? _getInfo(
- Map<Variable?, VariableModel<Variable, Type>> variableInfo) =>
- variableInfo[null];
}
/// Specialization of [ExpressionInfo] for the case where the information we
/// have about the expression is trivial (meaning we know by construction that
/// the expression's [after], [ifTrue], and [ifFalse] models are all the same).
-class _TrivialExpressionInfo<Variable extends Object, Type extends Object>
- implements ExpressionInfo<Variable, Type> {
+class _TrivialExpressionInfo<Type extends Object>
+ implements ExpressionInfo<Type> {
@override
- final FlowModel<Variable, Type> after;
+ final FlowModel<Type> after;
_TrivialExpressionInfo(this.after);
@override
- FlowModel<Variable, Type> get ifFalse => after;
+ FlowModel<Type> get ifFalse => after;
@override
- FlowModel<Variable, Type> get ifTrue => after;
+ FlowModel<Type> get ifTrue => after;
@override
- ExpressionInfo<Variable, Type> invert() => this;
+ ExpressionInfo<Type> invert() => this;
@override
- ExpressionInfo<Variable, Type> rebaseForward(
- TypeOperations<Type> typeOperations,
- FlowModel<Variable, Type> base) =>
+ ExpressionInfo<Type> rebaseForward(
+ TypeOperations<Type> typeOperations, FlowModel<Type> base) =>
new _TrivialExpressionInfo(base);
}
/// [_FlowContext] representing a try statement.
-class _TryContext<Variable extends Object, Type extends Object>
- extends _SimpleContext<Variable, Type> {
+class _TryContext<Type extends Object> extends _SimpleContext<Type> {
/// If the statement is a "try/catch" statement, the flow model representing
/// program state at the top of any `catch` block.
- FlowModel<Variable, Type>? _beforeCatch;
+ FlowModel<Type>? _beforeCatch;
/// If the statement is a "try/catch" statement, the accumulated flow model
/// representing program state after the `try` block or one of the `catch`
/// blocks has finished executing. If the statement is a "try/finally"
/// statement, the flow model representing program state after the `try` block
/// has finished executing.
- FlowModel<Variable, Type>? _afterBodyAndCatches;
+ FlowModel<Type>? _afterBodyAndCatches;
_TryContext(super.previous);
@@ -5186,21 +5121,19 @@
'afterBodyAndCatches: $_afterBodyAndCatches)';
}
-class _TryFinallyContext<Variable extends Object, Type extends Object>
- extends _TryContext<Variable, Type> {
+class _TryFinallyContext<Type extends Object> extends _TryContext<Type> {
/// The flow model representing program state at the top of the `finally`
/// block.
- late final FlowModel<Variable, Type> _beforeFinally;
+ late final FlowModel<Type> _beforeFinally;
_TryFinallyContext(super.previous);
}
/// [_FlowContext] representing a `while` loop (or a C-style `for` loop, which
/// is functionally similar).
-class _WhileContext<Variable extends Object, Type extends Object>
- extends _BranchTargetContext<Variable, Type> {
+class _WhileContext<Type extends Object> extends _BranchTargetContext<Type> {
/// Flow models associated with the loop condition.
- final ExpressionInfo<Variable, Type> _conditionInfo;
+ final ExpressionInfo<Type> _conditionInfo;
_WhileContext(super.checkpoint, this._conditionInfo);
diff --git a/pkg/_fe_analyzer_shared/test/flow_analysis/assigned_variables_test.dart b/pkg/_fe_analyzer_shared/test/flow_analysis/assigned_variables_test.dart
index 8676f23..f3ab112 100644
--- a/pkg/_fe_analyzer_shared/test/flow_analysis/assigned_variables_test.dart
+++ b/pkg/_fe_analyzer_shared/test/flow_analysis/assigned_variables_test.dart
@@ -21,7 +21,8 @@
isClosureOrLateVariableInitializer: true);
assignedVariables.read(v3);
assignedVariables.finish();
- expect(assignedVariables.readCapturedAnywhere, {v2});
+ expect(assignedVariables.readCapturedAnywhere,
+ {assignedVariables.keyForVariable(v2)});
});
test('readCapturedAnywhere does not record variables local to a closure', () {
@@ -36,7 +37,8 @@
assignedVariables.endNode(_Node(),
isClosureOrLateVariableInitializer: true);
assignedVariables.finish();
- expect(assignedVariables.readCapturedAnywhere, {v1});
+ expect(assignedVariables.readCapturedAnywhere,
+ {assignedVariables.keyForVariable(v1)});
});
test('capturedAnywhere records assignments in closures', () {
@@ -54,7 +56,8 @@
isClosureOrLateVariableInitializer: true);
assignedVariables.write(v3);
assignedVariables.finish();
- expect(assignedVariables.capturedAnywhere, {v2});
+ expect(assignedVariables.capturedAnywhere,
+ {assignedVariables.keyForVariable(v2)});
});
test('capturedAnywhere does not record variables local to a closure', () {
@@ -69,7 +72,8 @@
assignedVariables.endNode(_Node(),
isClosureOrLateVariableInitializer: true);
assignedVariables.finish();
- expect(assignedVariables.capturedAnywhere, {v1});
+ expect(assignedVariables.capturedAnywhere,
+ {assignedVariables.keyForVariable(v1)});
});
test('readAnywhere records all reads', () {
@@ -87,7 +91,11 @@
isClosureOrLateVariableInitializer: true);
assignedVariables.read(v3);
assignedVariables.finish();
- expect(assignedVariables.readAnywhere, {v1, v2, v3});
+ expect(assignedVariables.readAnywhere, {
+ assignedVariables.keyForVariable(v1),
+ assignedVariables.keyForVariable(v2),
+ assignedVariables.keyForVariable(v3)
+ });
});
test('writtenAnywhere records all assignments', () {
@@ -105,7 +113,11 @@
isClosureOrLateVariableInitializer: true);
assignedVariables.write(v3);
assignedVariables.finish();
- expect(assignedVariables.writtenAnywhere, {v1, v2, v3});
+ expect(assignedVariables.writtenAnywhere, {
+ assignedVariables.keyForVariable(v1),
+ assignedVariables.keyForVariable(v2),
+ assignedVariables.keyForVariable(v3)
+ });
});
test('readInNode ignores reads outside the node', () {
@@ -132,7 +144,8 @@
var node = _Node();
assignedVariables.endNode(node);
assignedVariables.finish();
- expect(assignedVariables.readInNode(node), {v1});
+ expect(assignedVariables.readInNode(node),
+ {assignedVariables.keyForVariable(v1)});
});
test('readInNode records reads in a nested node', () {
@@ -146,7 +159,8 @@
var node = _Node();
assignedVariables.endNode(node);
assignedVariables.finish();
- expect(assignedVariables.readInNode(node), {v1});
+ expect(assignedVariables.readInNode(node),
+ {assignedVariables.keyForVariable(v1)});
});
test('readInNode records reads in a closure', () {
@@ -158,7 +172,8 @@
var node = _Node();
assignedVariables.endNode(node, isClosureOrLateVariableInitializer: true);
assignedVariables.finish();
- expect(assignedVariables.readInNode(node), {v1});
+ expect(assignedVariables.readInNode(node),
+ {assignedVariables.keyForVariable(v1)});
});
test('writtenInNode ignores assignments outside the node', () {
@@ -185,7 +200,8 @@
var node = _Node();
assignedVariables.endNode(node);
assignedVariables.finish();
- expect(assignedVariables.writtenInNode(node), {v1});
+ expect(assignedVariables.writtenInNode(node),
+ {assignedVariables.keyForVariable(v1)});
});
test('writtenInNode records assignments in a nested node', () {
@@ -199,7 +215,8 @@
var node = _Node();
assignedVariables.endNode(node);
assignedVariables.finish();
- expect(assignedVariables.writtenInNode(node), {v1});
+ expect(assignedVariables.writtenInNode(node),
+ {assignedVariables.keyForVariable(v1)});
});
test('writtenInNode records assignments in a closure', () {
@@ -211,7 +228,8 @@
var node = _Node();
assignedVariables.endNode(node, isClosureOrLateVariableInitializer: true);
assignedVariables.finish();
- expect(assignedVariables.writtenInNode(node), {v1});
+ expect(assignedVariables.writtenInNode(node),
+ {assignedVariables.keyForVariable(v1)});
});
test('readCapturedInNode ignores reads in non-nested closures', () {
@@ -250,8 +268,10 @@
var outerNode = _Node();
assignedVariables.endNode(outerNode);
assignedVariables.finish();
- expect(assignedVariables.readCapturedInNode(innerNode), {v1});
- expect(assignedVariables.readCapturedInNode(outerNode), {v1});
+ expect(assignedVariables.readCapturedInNode(innerNode),
+ {assignedVariables.keyForVariable(v1)});
+ expect(assignedVariables.readCapturedInNode(outerNode),
+ {assignedVariables.keyForVariable(v1)});
});
test('capturedInNode ignores assignments in non-nested closures', () {
@@ -290,8 +310,10 @@
var outerNode = _Node();
assignedVariables.endNode(outerNode);
assignedVariables.finish();
- expect(assignedVariables.capturedInNode(innerNode), {v1});
- expect(assignedVariables.capturedInNode(outerNode), {v1});
+ expect(assignedVariables.capturedInNode(innerNode),
+ {assignedVariables.keyForVariable(v1)});
+ expect(assignedVariables.capturedInNode(outerNode),
+ {assignedVariables.keyForVariable(v1)});
});
group('Variables do not percolate beyond the scope they were declared in',
@@ -371,7 +393,12 @@
assignedVariables.discardNode();
assignedVariables.endNode(node);
assignedVariables.finish();
- expect(assignedVariables.declaredInNode(node), unorderedEquals([v1, v2]));
+ expect(
+ assignedVariables.declaredInNode(node),
+ unorderedEquals([
+ assignedVariables.keyForVariable(v1),
+ assignedVariables.keyForVariable(v2)
+ ]));
});
test('discardNode percolates reads to enclosing node', () {
@@ -388,7 +415,12 @@
assignedVariables.discardNode();
assignedVariables.endNode(node);
assignedVariables.finish();
- expect(assignedVariables.readInNode(node), unorderedEquals([v1, v2]));
+ expect(
+ assignedVariables.readInNode(node),
+ unorderedEquals([
+ assignedVariables.keyForVariable(v1),
+ assignedVariables.keyForVariable(v2)
+ ]));
});
test('discardNode percolates writes to enclosing node', () {
@@ -405,7 +437,12 @@
assignedVariables.discardNode();
assignedVariables.endNode(node);
assignedVariables.finish();
- expect(assignedVariables.writtenInNode(node), unorderedEquals([v1, v2]));
+ expect(
+ assignedVariables.writtenInNode(node),
+ unorderedEquals([
+ assignedVariables.keyForVariable(v1),
+ assignedVariables.keyForVariable(v2)
+ ]));
});
test('discardNode percolates read captures to enclosing node', () {
@@ -426,7 +463,11 @@
assignedVariables.endNode(node);
assignedVariables.finish();
expect(
- assignedVariables.readCapturedInNode(node), unorderedEquals([v1, v2]));
+ assignedVariables.readCapturedInNode(node),
+ unorderedEquals([
+ assignedVariables.keyForVariable(v1),
+ assignedVariables.keyForVariable(v2)
+ ]));
});
test('discardNode percolates write captures to enclosing node', () {
@@ -446,7 +487,12 @@
assignedVariables.discardNode();
assignedVariables.endNode(node);
assignedVariables.finish();
- expect(assignedVariables.capturedInNode(node), unorderedEquals([v1, v2]));
+ expect(
+ assignedVariables.capturedInNode(node),
+ unorderedEquals([
+ assignedVariables.keyForVariable(v1),
+ assignedVariables.keyForVariable(v2)
+ ]));
});
test('deferNode allows deferring of node info', () {
@@ -472,9 +518,16 @@
var node = _Node();
assignedVariables.storeInfo(node, info);
assignedVariables.finish();
- expect(assignedVariables.declaredInNode(node), [v3]);
- expect(assignedVariables.writtenInNode(node), unorderedEquals([v1, v2]));
- expect(assignedVariables.capturedInNode(node), [v2]);
+ expect(assignedVariables.declaredInNode(node),
+ [assignedVariables.keyForVariable(v3)]);
+ expect(
+ assignedVariables.writtenInNode(node),
+ unorderedEquals([
+ assignedVariables.keyForVariable(v1),
+ assignedVariables.keyForVariable(v2)
+ ]));
+ expect(assignedVariables.capturedInNode(node),
+ [assignedVariables.keyForVariable(v2)]);
});
}
diff --git a/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart b/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart
index a3700cd..d2195c0 100644
--- a/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart
+++ b/pkg/_fe_analyzer_shared/test/flow_analysis/flow_analysis_test.dart
@@ -13,7 +13,7 @@
test('asExpression_end promotes variables', () {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaBeforePromotion;
+ late SsaNode<Type> ssaBeforePromotion;
h.run([
declare(x, initialized: true),
getSsaNodes((nodes) => ssaBeforePromotion = nodes[x]!),
@@ -186,7 +186,7 @@
test('equalityOp(x != null) promotes true branch', () {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaBeforePromotion;
+ late SsaNode<Type> ssaBeforePromotion;
h.run([
declare(x, initialized: true),
getSsaNodes((nodes) => ssaBeforePromotion = nodes[x]!),
@@ -255,7 +255,7 @@
test('equalityOp(x == null) promotes false branch', () {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaBeforePromotion;
+ late SsaNode<Type> ssaBeforePromotion;
h.run([
declare(x, initialized: true),
getSsaNodes((nodes) => ssaBeforePromotion = nodes[x]!),
@@ -289,7 +289,7 @@
test('equalityOp(null != x) promotes true branch', () {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaBeforePromotion;
+ late SsaNode<Type> ssaBeforePromotion;
h.run([
declare(x, initialized: true),
getSsaNodes((nodes) => ssaBeforePromotion = nodes[x]!),
@@ -319,7 +319,7 @@
test('equalityOp(null == x) promotes false branch', () {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaBeforePromotion;
+ late SsaNode<Type> ssaBeforePromotion;
h.run([
declare(x, initialized: true),
getSsaNodes((nodes) => ssaBeforePromotion = nodes[x]!),
@@ -441,7 +441,7 @@
test('doStatement_bodyBegin() un-promotes', () {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaBeforeLoop;
+ late SsaNode<Type> ssaBeforeLoop;
h.run([
declare(x, initialized: true),
x.expr.as_('int').stmt,
@@ -608,7 +608,7 @@
test('for_conditionBegin() un-promotes', () {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaBeforeLoop;
+ late SsaNode<Type> ssaBeforeLoop;
h.run([
declare(x, initialized: true),
x.expr.as_('int').stmt,
@@ -750,8 +750,8 @@
var h = Harness();
var x = Var('x', 'int?');
var y = Var('x', 'int?');
- late SsaNode<Var, Type> xSsaInsideLoop;
- late SsaNode<Var, Type> ySsaInsideLoop;
+ late SsaNode<Type> xSsaInsideLoop;
+ late SsaNode<Type> ySsaInsideLoop;
h.run([
declare(x, initialized: true),
declare(y, initialized: true),
@@ -779,8 +779,8 @@
var h = Harness();
var x = Var('x', 'int?');
var y = Var('x', 'int?');
- late SsaNode<Var, Type> xSsaInsideLoop;
- late SsaNode<Var, Type> ySsaInsideLoop;
+ late SsaNode<Type> xSsaInsideLoop;
+ late SsaNode<Type> ySsaInsideLoop;
h.run([
declare(x, initialized: true),
declare(y, initialized: true),
@@ -806,7 +806,7 @@
test('forEach_bodyBegin() un-promotes', () {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaBeforeLoop;
+ late SsaNode<Type> ssaBeforeLoop;
h.run([
declare(x, initialized: true),
x.expr.as_('int').stmt,
@@ -966,7 +966,7 @@
var h = Harness();
var x = Var('x', 'int?');
var y = Var('y', 'int?');
- late SsaNode<Var, Type> ssaBeforeFunction;
+ late SsaNode<Type> ssaBeforeFunction;
h.run([
declare(x, initialized: true), declare(y, initialized: true),
x.expr.as_('int').stmt, y.expr.as_('int').stmt,
@@ -1229,7 +1229,7 @@
var x = Var('x', 'bool');
var y = Var('y', 'bool');
var z = Var('z', 'bool');
- late SsaNode<Var, Type> xSsaNodeBeforeIf;
+ late SsaNode<Type> xSsaNodeBeforeIf;
h.run([
declare(w, initialized: true),
declare(x, initialized: true),
@@ -1258,7 +1258,7 @@
'unreachable', () {
var h = Harness();
var x = Var('x', 'Object');
- late SsaNode<Var, Type> xSsaNodeBeforeIf;
+ late SsaNode<Type> xSsaNodeBeforeIf;
h.run([
declare(x, initialized: true),
getSsaNodes((nodes) {
@@ -1279,7 +1279,7 @@
'unreachable', () {
var h = Harness();
var x = Var('x', 'Object');
- late SsaNode<Var, Type> xSsaNodeBeforeIf;
+ late SsaNode<Type> xSsaNodeBeforeIf;
h.run([
declare(x, initialized: true),
getSsaNodes((nodes) {
@@ -1386,7 +1386,7 @@
var h = Harness();
var x = Var('x', 'Object');
var y = Var('y', 'int?');
- late ExpressionInfo<Var, Type> writtenValueInfo;
+ late ExpressionInfo<Type> writtenValueInfo;
h.run([
declare(y, initialized: true),
declareInitialized(
@@ -1487,7 +1487,7 @@
{bool inverted = false}) {
var h = Harness();
var x = Var('x', declaredType);
- late SsaNode<Var, Type> ssaBeforePromotion;
+ late SsaNode<Type> ssaBeforePromotion;
h.run([
declare(x, initialized: true),
getSsaNodes((nodes) => ssaBeforePromotion = nodes[x]!),
@@ -1778,7 +1778,7 @@
test('nonNullAssert_end(x) promotes', () {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaBeforePromotion;
+ late SsaNode<Type> ssaBeforePromotion;
h.run([
declare(x, initialized: true),
getSsaNodes((nodes) => ssaBeforePromotion = nodes[x]!),
@@ -1791,7 +1791,7 @@
test('nullAwareAccess temporarily promotes', () {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaBeforePromotion;
+ late SsaNode<Type> ssaBeforePromotion;
h.run([
declare(x, initialized: true),
getSsaNodes((nodes) => ssaBeforePromotion = nodes[x]!),
@@ -1991,7 +1991,7 @@
test('switchStatement_beginCase(true) un-promotes', () {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaBeforeSwitch;
+ late SsaNode<Type> ssaBeforeSwitch;
h.run([
declare(x, initialized: true),
x.expr.as_('int').stmt,
@@ -2142,7 +2142,7 @@
() {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaAfterTry;
+ late SsaNode<Type> ssaAfterTry;
h.run([
declare(x, initialized: true),
x.expr.as_('int').stmt,
@@ -2277,8 +2277,8 @@
'body', () {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaAtStartOfTry;
- late SsaNode<Var, Type> ssaAfterTry;
+ late SsaNode<Type> ssaAtStartOfTry;
+ late SsaNode<Type> ssaAfterTry;
h.run([
declare(x, initialized: true),
x.expr.as_('int').stmt,
@@ -2348,8 +2348,8 @@
var h = Harness();
var x = Var('x', 'int?');
var y = Var('y', 'int?');
- late SsaNode<Var, Type> xSsaAtEndOfFinally;
- late SsaNode<Var, Type> ySsaAtEndOfFinally;
+ late SsaNode<Type> xSsaAtEndOfFinally;
+ late SsaNode<Type> ySsaAtEndOfFinally;
h.run([
declare(x, initialized: true), declare(y, initialized: true),
try_([
@@ -2387,10 +2387,10 @@
var h = Harness();
var x = Var('x', 'int?');
var y = Var('y', 'int?');
- late SsaNode<Var, Type> xSsaAtEndOfTry;
- late SsaNode<Var, Type> ySsaAtEndOfTry;
- late SsaNode<Var, Type> xSsaAtEndOfFinally;
- late SsaNode<Var, Type> ySsaAtEndOfFinally;
+ late SsaNode<Type> xSsaAtEndOfTry;
+ late SsaNode<Type> ySsaAtEndOfTry;
+ late SsaNode<Type> xSsaAtEndOfFinally;
+ late SsaNode<Type> ySsaAtEndOfFinally;
h.run([
declare(x, initialized: true), declare(y, initialized: true),
try_([
@@ -2872,7 +2872,7 @@
test('whileStatement_conditionBegin() un-promotes', () {
var h = Harness();
var x = Var('x', 'int?');
- late SsaNode<Var, Type> ssaBeforeLoop;
+ late SsaNode<Type> ssaBeforeLoop;
h.run([
declare(x, initialized: true),
x.expr.as_('int').stmt,
@@ -2962,8 +2962,8 @@
var h = Harness();
var x = Var('x', 'int?');
var y = Var('x', 'int?');
- late SsaNode<Var, Type> xSsaInsideLoop;
- late SsaNode<Var, Type> ySsaInsideLoop;
+ late SsaNode<Type> xSsaInsideLoop;
+ late SsaNode<Type> ySsaInsideLoop;
h.run([
declare(x, initialized: true),
declare(y, initialized: true),
@@ -2991,8 +2991,8 @@
var h = Harness();
var x = Var('x', 'int?');
var y = Var('x', 'int?');
- late SsaNode<Var, Type> xSsaInsideLoop;
- late SsaNode<Var, Type> ySsaInsideLoop;
+ late SsaNode<Type> xSsaInsideLoop;
+ late SsaNode<Type> ySsaInsideLoop;
h.run([
declare(x, initialized: true),
declare(y, initialized: true),
@@ -3019,8 +3019,8 @@
var h = Harness();
var x = Var('x', 'Object');
var y = Var('y', 'int?');
- late SsaNode<Var, Type> ssaBeforeWrite;
- late ExpressionInfo<Var, Type> writtenValueInfo;
+ late SsaNode<Type> ssaBeforeWrite;
+ late ExpressionInfo<Type> writtenValueInfo;
h.run([
declare(x, initialized: true),
declare(y, initialized: true),
@@ -3045,8 +3045,8 @@
var h = Harness();
var x = Var('x', 'Object');
var y = Var('y', 'int?');
- late SsaNode<Var, Type> ssaBeforeWrite;
- late ExpressionInfo<Var, Type> writtenValueInfo;
+ late SsaNode<Type> ssaBeforeWrite;
+ late ExpressionInfo<Type> writtenValueInfo;
h.run([
declare(x, initialized: true),
declare(y, initialized: true),
@@ -3079,8 +3079,8 @@
var h = Harness();
var x = Var('x', 'int?');
var y = Var('y', 'int?');
- late SsaNode<Var, Type> xSsaBeforeWrite;
- late SsaNode<Var, Type> ySsa;
+ late SsaNode<Type> xSsaBeforeWrite;
+ late SsaNode<Type> ySsa;
h.run([
declare(x, initialized: true),
declare(y, initialized: true),
@@ -3100,7 +3100,7 @@
var h = Harness();
var x = Var('x', 'Object');
var y = Var('y', 'int?');
- late SsaNode<Var, Type> ssaBeforeWrite;
+ late SsaNode<Type> ssaBeforeWrite;
h.run([
declare(x, initialized: true),
declare(y, initialized: true),
@@ -3125,7 +3125,7 @@
test('write() permits expression to be null', () {
var h = Harness();
var x = Var('x', 'Object');
- late SsaNode<Var, Type> ssaBeforeWrite;
+ late SsaNode<Type> ssaBeforeWrite;
h.run([
declare(x, initialized: true),
getSsaNodes((nodes) => ssaBeforeWrite = nodes[x]!),
@@ -3363,15 +3363,14 @@
var objectQVar = Var('x', 'Object?');
var nullVar = Var('x', 'Null');
group('setUnreachable', () {
- var unreachable =
- FlowModel<Var, Type>(Reachability.initial.setUnreachable());
- var reachable = FlowModel<Var, Type>(Reachability.initial);
+ var unreachable = FlowModel<Type>(Reachability.initial.setUnreachable());
+ var reachable = FlowModel<Type>(Reachability.initial);
test('unchanged', () {
expect(unreachable.setUnreachable(), same(unreachable));
});
test('changed', () {
- void _check(FlowModel<Var, Type> initial) {
+ void _check(FlowModel<Type> initial) {
var s = initial.setUnreachable();
expect(s, isNot(same(initial)));
expect(s.reachable.overallReachable, false);
@@ -3383,33 +3382,33 @@
});
test('split', () {
- var s1 = FlowModel<Var, Type>(Reachability.initial);
+ var s1 = FlowModel<Type>(Reachability.initial);
var s2 = s1.split();
expect(s2.reachable.parent, same(s1.reachable));
});
test('unsplit', () {
- var s1 = FlowModel<Var, Type>(Reachability.initial.split());
+ var s1 = FlowModel<Type>(Reachability.initial.split());
var s2 = s1.unsplit();
expect(s2.reachable, same(Reachability.initial));
});
group('unsplitTo', () {
test('no change', () {
- var s1 = FlowModel<Var, Type>(Reachability.initial.split());
+ var s1 = FlowModel<Type>(Reachability.initial.split());
var result = s1.unsplitTo(s1.reachable.parent!);
expect(result, same(s1));
});
test('unsplit once, reachable', () {
- var s1 = FlowModel<Var, Type>(Reachability.initial.split());
+ var s1 = FlowModel<Type>(Reachability.initial.split());
var s2 = s1.split();
var result = s2.unsplitTo(s1.reachable.parent!);
expect(result.reachable, same(s1.reachable));
});
test('unsplit once, unreachable', () {
- var s1 = FlowModel<Var, Type>(Reachability.initial.split());
+ var s1 = FlowModel<Type>(Reachability.initial.split());
var s2 = s1.split().setUnreachable();
var result = s2.unsplitTo(s1.reachable.parent!);
expect(result.reachable.locallyReachable, false);
@@ -3417,7 +3416,7 @@
});
test('unsplit twice, reachable', () {
- var s1 = FlowModel<Var, Type>(Reachability.initial.split());
+ var s1 = FlowModel<Type>(Reachability.initial.split());
var s2 = s1.split();
var s3 = s2.split();
var result = s3.unsplitTo(s1.reachable.parent!);
@@ -3425,7 +3424,7 @@
});
test('unsplit twice, top unreachable', () {
- var s1 = FlowModel<Var, Type>(Reachability.initial.split());
+ var s1 = FlowModel<Type>(Reachability.initial.split());
var s2 = s1.split();
var s3 = s2.split().setUnreachable();
var result = s3.unsplitTo(s1.reachable.parent!);
@@ -3434,7 +3433,7 @@
});
test('unsplit twice, previous unreachable', () {
- var s1 = FlowModel<Var, Type>(Reachability.initial.split());
+ var s1 = FlowModel<Type>(Reachability.initial.split());
var s2 = s1.split().setUnreachable();
var s3 = s2.split();
var result = s3.unsplitTo(s1.reachable.parent!);
@@ -3446,38 +3445,39 @@
group('tryPromoteForTypeCheck', () {
test('unpromoted -> unchanged (same)', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial);
+ var s1 = FlowModel<Type>(Reachability.initial);
var s2 = s1._tryPromoteForTypeCheck(h, intVar, 'int').ifTrue;
expect(s2, same(s1));
});
test('unpromoted -> unchanged (supertype)', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial);
+ var s1 = FlowModel<Type>(Reachability.initial);
var s2 = s1._tryPromoteForTypeCheck(h, intVar, 'Object').ifTrue;
expect(s2, same(s1));
});
test('unpromoted -> unchanged (unrelated)', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial);
+ var s1 = FlowModel<Type>(Reachability.initial);
var s2 = s1._tryPromoteForTypeCheck(h, intVar, 'String').ifTrue;
expect(s2, same(s1));
});
test('unpromoted -> subtype', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial);
+ var s1 = FlowModel<Type>(Reachability.initial);
var s2 = s1._tryPromoteForTypeCheck(h, intQVar, 'int').ifTrue;
expect(s2.reachable.overallReachable, true);
expect(s2.variableInfo, {
- intQVar: _matchVariableModel(chain: ['int'], ofInterest: ['int'])
+ _promotionKeyStore.keyForVariable(intQVar):
+ _matchVariableModel(chain: ['int'], ofInterest: ['int'])
});
});
test('promoted -> unchanged (same)', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
+ var s1 = FlowModel<Type>(Reachability.initial)
._tryPromoteForTypeCheck(h, objectQVar, 'int')
.ifTrue;
var s2 = s1._tryPromoteForTypeCheck(h, objectQVar, 'int').ifTrue;
@@ -3486,7 +3486,7 @@
test('promoted -> unchanged (supertype)', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
+ var s1 = FlowModel<Type>(Reachability.initial)
._tryPromoteForTypeCheck(h, objectQVar, 'int')
.ifTrue;
var s2 = s1._tryPromoteForTypeCheck(h, objectQVar, 'Object').ifTrue;
@@ -3495,7 +3495,7 @@
test('promoted -> unchanged (unrelated)', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
+ var s1 = FlowModel<Type>(Reachability.initial)
._tryPromoteForTypeCheck(h, objectQVar, 'int')
.ifTrue;
var s2 = s1._tryPromoteForTypeCheck(h, objectQVar, 'String').ifTrue;
@@ -3504,13 +3504,13 @@
test('promoted -> subtype', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
+ var s1 = FlowModel<Type>(Reachability.initial)
._tryPromoteForTypeCheck(h, objectQVar, 'int?')
.ifTrue;
var s2 = s1._tryPromoteForTypeCheck(h, objectQVar, 'int').ifTrue;
expect(s2.reachable.overallReachable, true);
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['int?', 'int'], ofInterest: ['int?', 'int'])
});
});
@@ -3522,21 +3522,21 @@
test('without declaration', () {
// This should not happen in valid code, but test that we don't crash.
var h = Harness();
- var s = FlowModel<Var, Type>(Reachability.initial).write(
- null, objectQVar, Type('Object?'), new SsaNode<Var, Type>(null), h);
+ var s = FlowModel<Type>(Reachability.initial)._write(
+ null, objectQVar, Type('Object?'), new SsaNode<Type>(null), h);
expect(s.variableInfo[objectQVar], isNull);
});
test('unchanged', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, true);
- var s2 = s1.write(
- null, objectQVar, Type('Object?'), new SsaNode<Var, Type>(null), h);
+ var s1 =
+ FlowModel<Type>(Reachability.initial)._declare(objectQVar, true);
+ var s2 = s1._write(
+ null, objectQVar, Type('Object?'), new SsaNode<Type>(null), h);
expect(s2, isNot(same(s1)));
expect(s2.reachable, same(s1.reachable));
expect(
- s2.infoFor(objectQVar),
+ s2._infoFor(objectQVar),
_matchVariableModel(
chain: null,
ofInterest: isEmpty,
@@ -3546,13 +3546,13 @@
test('marks as assigned', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, false);
- var s2 = s1.write(
- null, objectQVar, Type('int?'), new SsaNode<Var, Type>(null), h);
+ var s1 =
+ FlowModel<Type>(Reachability.initial)._declare(objectQVar, false);
+ var s2 = s1._write(
+ null, objectQVar, Type('int?'), new SsaNode<Type>(null), h);
expect(s2.reachable.overallReachable, true);
expect(
- s2.infoFor(objectQVar),
+ s2._infoFor(objectQVar),
_matchVariableModel(
chain: null,
ofInterest: isEmpty,
@@ -3562,16 +3562,17 @@
test('un-promotes fully', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(objectQVar, true)
._tryPromoteForTypeCheck(h, objectQVar, 'int')
.ifTrue;
- expect(s1.variableInfo, contains(objectQVar));
- var s2 = s1.write(_MockNonPromotionReason(), objectQVar, Type('int?'),
- new SsaNode<Var, Type>(null), h);
+ expect(s1.variableInfo,
+ contains(_promotionKeyStore.keyForVariable(objectQVar)));
+ var s2 = s1._write(_MockNonPromotionReason(), objectQVar, Type('int?'),
+ new SsaNode<Type>(null), h);
expect(s2.reachable.overallReachable, true);
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: null,
ofInterest: isEmpty,
assigned: true,
@@ -3581,24 +3582,24 @@
test('un-promotes partially, when no exact match', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(objectQVar, true)
._tryPromoteForTypeCheck(h, objectQVar, 'num?')
.ifTrue
._tryPromoteForTypeCheck(h, objectQVar, 'int')
.ifTrue;
expect(s1.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['num?', 'int'],
ofInterest: ['num?', 'int'],
assigned: true,
unassigned: false)
});
- var s2 = s1.write(_MockNonPromotionReason(), objectQVar, Type('num'),
- new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(_MockNonPromotionReason(), objectQVar, Type('num'),
+ new SsaNode<Type>(null), h);
expect(s2.reachable.overallReachable, true);
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['num?', 'num'],
ofInterest: ['num?', 'int'],
assigned: true,
@@ -3608,8 +3609,8 @@
test('un-promotes partially, when exact match', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(objectQVar, true)
._tryPromoteForTypeCheck(h, objectQVar, 'num?')
.ifTrue
._tryPromoteForTypeCheck(h, objectQVar, 'num')
@@ -3617,17 +3618,17 @@
._tryPromoteForTypeCheck(h, objectQVar, 'int')
.ifTrue;
expect(s1.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['num?', 'num', 'int'],
ofInterest: ['num?', 'num', 'int'],
assigned: true,
unassigned: false)
});
- var s2 = s1.write(_MockNonPromotionReason(), objectQVar, Type('num'),
- new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(_MockNonPromotionReason(), objectQVar, Type('num'),
+ new SsaNode<Type>(null), h);
expect(s2.reachable.overallReachable, true);
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['num?', 'num'],
ofInterest: ['num?', 'num', 'int'],
assigned: true,
@@ -3637,25 +3638,25 @@
test('leaves promoted, when exact match', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(objectQVar, true)
._tryPromoteForTypeCheck(h, objectQVar, 'num?')
.ifTrue
._tryPromoteForTypeCheck(h, objectQVar, 'num')
.ifTrue;
expect(s1.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['num?', 'num'],
ofInterest: ['num?', 'num'],
assigned: true,
unassigned: false)
});
- var s2 = s1.write(
- null, objectQVar, Type('num'), new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(
+ null, objectQVar, Type('num'), new SsaNode<Type>(null), h);
expect(s2.reachable.overallReachable, true);
expect(s2.variableInfo, isNot(same(s1.variableInfo)));
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['num?', 'num'],
ofInterest: ['num?', 'num'],
assigned: true,
@@ -3665,25 +3666,25 @@
test('leaves promoted, when writing a subtype', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(objectQVar, true)
._tryPromoteForTypeCheck(h, objectQVar, 'num?')
.ifTrue
._tryPromoteForTypeCheck(h, objectQVar, 'num')
.ifTrue;
expect(s1.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['num?', 'num'],
ofInterest: ['num?', 'num'],
assigned: true,
unassigned: false)
});
- var s2 = s1.write(
- null, objectQVar, Type('int'), new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(
+ null, objectQVar, Type('int'), new SsaNode<Type>(null), h);
expect(s2.reachable.overallReachable, true);
expect(s2.variableInfo, isNot(same(s1.variableInfo)));
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['num?', 'num'],
ofInterest: ['num?', 'num'],
assigned: true,
@@ -3696,15 +3697,16 @@
var h = Harness();
var x = Var('x', 'int?');
- var s1 = FlowModel<Var, Type>(Reachability.initial).declare(x, true);
+ var s1 = FlowModel<Type>(Reachability.initial)._declare(x, true);
expect(s1.variableInfo, {
- x: _matchVariableModel(chain: null),
+ _promotionKeyStore.keyForVariable(x):
+ _matchVariableModel(chain: null),
});
- var s2 =
- s1.write(null, x, Type('int'), new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(null, x, Type('int'), new SsaNode<Type>(null), h);
expect(s2.variableInfo, {
- x: _matchVariableModel(chain: ['int']),
+ _promotionKeyStore.keyForVariable(x):
+ _matchVariableModel(chain: ['int']),
});
});
@@ -3712,40 +3714,42 @@
var h = Harness();
var x = Var('x', 'int?');
- var s1 = FlowModel<Var, Type>(Reachability.initial).declare(x, true);
+ var s1 = FlowModel<Type>(Reachability.initial)._declare(x, true);
expect(s1.variableInfo, {
- x: _matchVariableModel(chain: null),
+ _promotionKeyStore.keyForVariable(x):
+ _matchVariableModel(chain: null),
});
- var s2 = s1.conservativeJoin([], [x]);
+ var s2 = s1._conservativeJoin([], [x]);
expect(s2.variableInfo, {
- x: _matchVariableModel(chain: null, writeCaptured: true),
+ _promotionKeyStore.keyForVariable(x):
+ _matchVariableModel(chain: null, writeCaptured: true),
});
// 'x' is write-captured, so not promoted
- var s3 =
- s2.write(null, x, Type('int'), new SsaNode<Var, Type>(null), h);
+ var s3 = s2._write(null, x, Type('int'), new SsaNode<Type>(null), h);
expect(s3.variableInfo, {
- x: _matchVariableModel(chain: null, writeCaptured: true),
+ _promotionKeyStore.keyForVariable(x):
+ _matchVariableModel(chain: null, writeCaptured: true),
});
});
test('when promoted', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(objectQVar, true)
._tryPromoteForTypeCheck(h, objectQVar, 'int?')
.ifTrue;
expect(s1.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['int?'],
ofInterest: ['int?'],
),
});
- var s2 = s1.write(
- null, objectQVar, Type('int'), new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(
+ null, objectQVar, Type('int'), new SsaNode<Type>(null), h);
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['int?', 'int'],
ofInterest: ['int?'],
),
@@ -3754,20 +3758,20 @@
test('when not promoted', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(objectQVar, true)
._tryPromoteForTypeCheck(h, objectQVar, 'int?')
.ifFalse;
expect(s1.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['Object'],
ofInterest: ['int?'],
),
});
- var s2 = s1.write(
- null, objectQVar, Type('int'), new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(
+ null, objectQVar, Type('int'), new SsaNode<Type>(null), h);
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['Object', 'int'],
ofInterest: ['int?'],
),
@@ -3777,20 +3781,20 @@
test('Promotes to type of interest when not previously promoted', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(objectQVar, true)
._tryPromoteForTypeCheck(h, objectQVar, 'num?')
.ifFalse;
expect(s1.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['Object'],
ofInterest: ['num?'],
),
});
- var s2 = s1.write(_MockNonPromotionReason(), objectQVar, Type('num?'),
- new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(_MockNonPromotionReason(), objectQVar, Type('num?'),
+ new SsaNode<Type>(null), h);
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['num?'],
ofInterest: ['num?'],
),
@@ -3799,22 +3803,22 @@
test('Promotes to type of interest when previously promoted', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(objectQVar, true)
._tryPromoteForTypeCheck(h, objectQVar, 'num?')
.ifTrue
._tryPromoteForTypeCheck(h, objectQVar, 'int?')
.ifFalse;
expect(s1.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['num?', 'num'],
ofInterest: ['num?', 'int?'],
),
});
- var s2 = s1.write(_MockNonPromotionReason(), objectQVar, Type('int?'),
- new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(_MockNonPromotionReason(), objectQVar, Type('int?'),
+ new SsaNode<Type>(null), h);
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['num?', 'int?'],
ofInterest: ['num?', 'int?'],
),
@@ -3868,23 +3872,22 @@
test('; first', () {
var x = Var('x', 'Object?');
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(x, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(x, true)
._tryPromoteForTypeCheck(h, x, 'B?')
.ifFalse
._tryPromoteForTypeCheck(h, x, 'A?')
.ifFalse;
expect(s1.variableInfo, {
- x: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(x): _matchVariableModel(
chain: ['Object'],
ofInterest: ['A?', 'B?'],
),
});
- var s2 =
- s1.write(null, x, Type('C'), new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(null, x, Type('C'), new SsaNode<Type>(null), h);
expect(s2.variableInfo, {
- x: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(x): _matchVariableModel(
chain: ['Object', 'B'],
ofInterest: ['A?', 'B?'],
),
@@ -3894,23 +3897,22 @@
test('; second', () {
var x = Var('x', 'Object?');
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(x, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(x, true)
._tryPromoteForTypeCheck(h, x, 'A?')
.ifFalse
._tryPromoteForTypeCheck(h, x, 'B?')
.ifFalse;
expect(s1.variableInfo, {
- x: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(x): _matchVariableModel(
chain: ['Object'],
ofInterest: ['A?', 'B?'],
),
});
- var s2 =
- s1.write(null, x, Type('C'), new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(null, x, Type('C'), new SsaNode<Type>(null), h);
expect(s2.variableInfo, {
- x: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(x): _matchVariableModel(
chain: ['Object', 'B'],
ofInterest: ['A?', 'B?'],
),
@@ -3920,23 +3922,22 @@
test('; nullable and non-nullable', () {
var x = Var('x', 'Object?');
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(x, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(x, true)
._tryPromoteForTypeCheck(h, x, 'A')
.ifFalse
._tryPromoteForTypeCheck(h, x, 'A?')
.ifFalse;
expect(s1.variableInfo, {
- x: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(x): _matchVariableModel(
chain: ['Object'],
ofInterest: ['A', 'A?'],
),
});
- var s2 =
- s1.write(null, x, Type('B'), new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(null, x, Type('B'), new SsaNode<Type>(null), h);
expect(s2.variableInfo, {
- x: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(x): _matchVariableModel(
chain: ['Object', 'A'],
ofInterest: ['A', 'A?'],
),
@@ -3947,25 +3948,27 @@
group('; ambiguous', () {
test('; no promotion', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(objectQVar, true)
._tryPromoteForTypeCheck(h, objectQVar, 'num?')
.ifFalse
._tryPromoteForTypeCheck(h, objectQVar, 'num*')
.ifFalse;
expect(s1.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar):
+ _matchVariableModel(
chain: ['Object'],
ofInterest: ['num?', 'num*'],
),
});
- var s2 = s1.write(
- null, objectQVar, Type('int'), new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(
+ null, objectQVar, Type('int'), new SsaNode<Type>(null), h);
// It's ambiguous whether to promote to num? or num*, so we don't
// promote.
expect(s2, isNot(same(s1)));
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar):
+ _matchVariableModel(
chain: ['Object'],
ofInterest: ['num?', 'num*'],
),
@@ -3975,24 +3978,24 @@
test('exact match', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(objectQVar, true)
._tryPromoteForTypeCheck(h, objectQVar, 'num?')
.ifFalse
._tryPromoteForTypeCheck(h, objectQVar, 'num*')
.ifFalse;
expect(s1.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['Object'],
ofInterest: ['num?', 'num*'],
),
});
- var s2 = s1.write(_MockNonPromotionReason(), objectQVar, Type('num?'),
- new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(_MockNonPromotionReason(), objectQVar,
+ Type('num?'), new SsaNode<Type>(null), h);
// It's ambiguous whether to promote to num? or num*, but since the
// written type is exactly num?, we use that.
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar): _matchVariableModel(
chain: ['num?'],
ofInterest: ['num?', 'num*'],
),
@@ -4007,23 +4010,23 @@
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(x, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(x, true)
._tryPromoteForTypeCheck(h, x, 'num?')
.ifTrue
._tryPromoteForTypeCheck(h, x, 'int?')
.ifTrue;
expect(s1.variableInfo, {
- x: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(x): _matchVariableModel(
chain: ['num?', 'int?'],
ofInterest: ['num?', 'int?'],
),
});
- var s2 = s1.write(_MockNonPromotionReason(), x, Type('double'),
- new SsaNode<Var, Type>(null), h);
+ var s2 = s1._write(_MockNonPromotionReason(), x, Type('double'),
+ new SsaNode<Type>(null), h);
expect(s2.variableInfo, {
- x: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(x): _matchVariableModel(
chain: ['num?', 'num'],
ofInterest: ['num?', 'int?'],
),
@@ -4035,18 +4038,20 @@
var objectQVar = Var('x', 'Object?');
test('initialized', () {
- var s = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, true);
+ var s =
+ FlowModel<Type>(Reachability.initial)._declare(objectQVar, true);
expect(s.variableInfo, {
- objectQVar: _matchVariableModel(assigned: true, unassigned: false),
+ _promotionKeyStore.keyForVariable(objectQVar):
+ _matchVariableModel(assigned: true, unassigned: false),
});
});
test('not initialized', () {
- var s = FlowModel<Var, Type>(Reachability.initial)
- .declare(objectQVar, false);
+ var s =
+ FlowModel<Type>(Reachability.initial)._declare(objectQVar, false);
expect(s.variableInfo, {
- objectQVar: _matchVariableModel(assigned: false, unassigned: true),
+ _promotionKeyStore.keyForVariable(objectQVar):
+ _matchVariableModel(assigned: false, unassigned: true),
});
});
});
@@ -4054,23 +4059,23 @@
group('markNonNullable', () {
test('unpromoted -> unchanged', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial);
+ var s1 = FlowModel<Type>(Reachability.initial);
var s2 = s1._tryMarkNonNullable(h, intVar).ifTrue;
expect(s2, same(s1));
});
test('unpromoted -> promoted', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial);
+ var s1 = FlowModel<Type>(Reachability.initial);
var s2 = s1._tryMarkNonNullable(h, intQVar).ifTrue;
expect(s2.reachable.overallReachable, true);
- expect(s2.infoFor(intQVar),
+ expect(s2._infoFor(intQVar),
_matchVariableModel(chain: ['int'], ofInterest: []));
});
test('promoted -> unchanged', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
+ var s1 = FlowModel<Type>(Reachability.initial)
._tryPromoteForTypeCheck(h, objectQVar, 'int')
.ifTrue;
var s2 = s1._tryMarkNonNullable(h, objectQVar).ifTrue;
@@ -4079,23 +4084,23 @@
test('promoted -> re-promoted', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
+ var s1 = FlowModel<Type>(Reachability.initial)
._tryPromoteForTypeCheck(h, objectQVar, 'int?')
.ifTrue;
var s2 = s1._tryMarkNonNullable(h, objectQVar).ifTrue;
expect(s2.reachable.overallReachable, true);
expect(s2.variableInfo, {
- objectQVar:
+ _promotionKeyStore.keyForVariable(objectQVar):
_matchVariableModel(chain: ['int?', 'int'], ofInterest: ['int?'])
});
});
test('promote to Never', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial);
+ var s1 = FlowModel<Type>(Reachability.initial);
var s2 = s1._tryMarkNonNullable(h, nullVar).ifTrue;
expect(s2.reachable.overallReachable, false);
- expect(s2.infoFor(nullVar),
+ expect(s2._infoFor(nullVar),
_matchVariableModel(chain: ['Never'], ofInterest: []));
});
});
@@ -4103,46 +4108,51 @@
group('conservativeJoin', () {
test('unchanged', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
- .declare(intQVar, true)
+ var s1 = FlowModel<Type>(Reachability.initial)
+ ._declare(intQVar, true)
._tryPromoteForTypeCheck(h, objectQVar, 'int')
.ifTrue;
- var s2 = s1.conservativeJoin([intQVar], []);
+ var s2 = s1._conservativeJoin([intQVar], []);
expect(s2, isNot(same(s1)));
expect(s2.reachable, same(s1.reachable));
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(chain: ['int'], ofInterest: ['int']),
- intQVar: _matchVariableModel(chain: null, ofInterest: [])
+ _promotionKeyStore.keyForVariable(objectQVar):
+ _matchVariableModel(chain: ['int'], ofInterest: ['int']),
+ _promotionKeyStore.keyForVariable(intQVar):
+ _matchVariableModel(chain: null, ofInterest: [])
});
});
test('written', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
+ var s1 = FlowModel<Type>(Reachability.initial)
._tryPromoteForTypeCheck(h, objectQVar, 'int')
.ifTrue
._tryPromoteForTypeCheck(h, intQVar, 'int')
.ifTrue;
- var s2 = s1.conservativeJoin([intQVar], []);
+ var s2 = s1._conservativeJoin([intQVar], []);
expect(s2.reachable.overallReachable, true);
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(chain: ['int'], ofInterest: ['int']),
- intQVar: _matchVariableModel(chain: null, ofInterest: ['int'])
+ _promotionKeyStore.keyForVariable(objectQVar):
+ _matchVariableModel(chain: ['int'], ofInterest: ['int']),
+ _promotionKeyStore.keyForVariable(intQVar):
+ _matchVariableModel(chain: null, ofInterest: ['int'])
});
});
test('write captured', () {
var h = Harness();
- var s1 = FlowModel<Var, Type>(Reachability.initial)
+ var s1 = FlowModel<Type>(Reachability.initial)
._tryPromoteForTypeCheck(h, objectQVar, 'int')
.ifTrue
._tryPromoteForTypeCheck(h, intQVar, 'int')
.ifTrue;
- var s2 = s1.conservativeJoin([], [intQVar]);
+ var s2 = s1._conservativeJoin([], [intQVar]);
expect(s2.reachable.overallReachable, true);
expect(s2.variableInfo, {
- objectQVar: _matchVariableModel(chain: ['int'], ofInterest: ['int']),
- intQVar: _matchVariableModel(
+ _promotionKeyStore.keyForVariable(objectQVar):
+ _matchVariableModel(chain: ['int'], ofInterest: ['int']),
+ _promotionKeyStore.keyForVariable(intQVar): _matchVariableModel(
chain: null, ofInterest: isEmpty, unassigned: false)
});
});
@@ -4151,7 +4161,7 @@
group('rebaseForward', () {
test('reachability', () {
var h = Harness();
- var reachable = FlowModel<Var, Type>(Reachability.initial);
+ var reachable = FlowModel<Type>(Reachability.initial);
var unreachable = reachable.setUnreachable();
expect(reachable.rebaseForward(h, reachable), same(reachable));
expect(reachable.rebaseForward(h, unreachable), same(unreachable));
@@ -4169,22 +4179,22 @@
var b = Var('b', 'int');
var c = Var('c', 'int');
var d = Var('d', 'int');
- var s0 = FlowModel<Var, Type>(Reachability.initial)
- .declare(a, false)
- .declare(b, false)
- .declare(c, false)
- .declare(d, false);
+ var s0 = FlowModel<Type>(Reachability.initial)
+ ._declare(a, false)
+ ._declare(b, false)
+ ._declare(c, false)
+ ._declare(d, false);
var s1 = s0
- .write(null, a, Type('int'), new SsaNode<Var, Type>(null), h)
- .write(null, b, Type('int'), new SsaNode<Var, Type>(null), h);
+ ._write(null, a, Type('int'), new SsaNode<Type>(null), h)
+ ._write(null, b, Type('int'), new SsaNode<Type>(null), h);
var s2 = s0
- .write(null, a, Type('int'), new SsaNode<Var, Type>(null), h)
- .write(null, c, Type('int'), new SsaNode<Var, Type>(null), h);
+ ._write(null, a, Type('int'), new SsaNode<Type>(null), h)
+ ._write(null, c, Type('int'), new SsaNode<Type>(null), h);
var result = s1.rebaseForward(h, s2);
- expect(result.infoFor(a).assigned, true);
- expect(result.infoFor(b).assigned, true);
- expect(result.infoFor(c).assigned, true);
- expect(result.infoFor(d).assigned, false);
+ expect(result._infoFor(a).assigned, true);
+ expect(result._infoFor(b).assigned, true);
+ expect(result._infoFor(c).assigned, true);
+ expect(result._infoFor(d).assigned, false);
});
test('write captured', () {
@@ -4193,29 +4203,29 @@
var b = Var('b', 'int');
var c = Var('c', 'int');
var d = Var('d', 'int');
- var s0 = FlowModel<Var, Type>(Reachability.initial)
- .declare(a, false)
- .declare(b, false)
- .declare(c, false)
- .declare(d, false);
+ var s0 = FlowModel<Type>(Reachability.initial)
+ ._declare(a, false)
+ ._declare(b, false)
+ ._declare(c, false)
+ ._declare(d, false);
// In s1, a and b are write captured. In s2, a and c are.
- var s1 = s0.conservativeJoin([a, b], [a, b]);
- var s2 = s1.conservativeJoin([a, c], [a, c]);
+ var s1 = s0._conservativeJoin([a, b], [a, b]);
+ var s2 = s1._conservativeJoin([a, c], [a, c]);
var result = s1.rebaseForward(h, s2);
expect(
- result.infoFor(a),
+ result._infoFor(a),
_matchVariableModel(writeCaptured: true, unassigned: false),
);
expect(
- result.infoFor(b),
+ result._infoFor(b),
_matchVariableModel(writeCaptured: true, unassigned: false),
);
expect(
- result.infoFor(c),
+ result._infoFor(c),
_matchVariableModel(writeCaptured: true, unassigned: false),
);
expect(
- result.infoFor(d),
+ result._infoFor(d),
_matchVariableModel(writeCaptured: false, unassigned: true),
);
});
@@ -4223,16 +4233,16 @@
test('write captured and promoted', () {
var h = Harness();
var a = Var('a', 'num');
- var s0 = FlowModel<Var, Type>(Reachability.initial).declare(a, false);
+ var s0 = FlowModel<Type>(Reachability.initial)._declare(a, false);
// In s1, a is write captured. In s2 it's promoted.
- var s1 = s0.conservativeJoin([a], [a]);
+ var s1 = s0._conservativeJoin([a], [a]);
var s2 = s0._tryPromoteForTypeCheck(h, a, 'int').ifTrue;
expect(
- s1.rebaseForward(h, s2).infoFor(a),
+ s1.rebaseForward(h, s2)._infoFor(a),
_matchVariableModel(writeCaptured: true, chain: isNull),
);
expect(
- s2.rebaseForward(h, s1).infoFor(a),
+ s2.rebaseForward(h, s1)._infoFor(a),
_matchVariableModel(writeCaptured: true, chain: isNull),
);
});
@@ -4242,11 +4252,11 @@
List<String>? expectedChain) {
var h = Harness();
var x = Var('x', 'Object?');
- var s0 = FlowModel<Var, Type>(Reachability.initial).declare(x, true);
+ var s0 = FlowModel<Type>(Reachability.initial)._declare(x, true);
var s1 = s0;
if (unsafe) {
- s1 = s1.write(
- null, x, Type('Object?'), new SsaNode<Var, Type>(null), h);
+ s1 =
+ s1._write(null, x, Type('Object?'), new SsaNode<Type>(null), h);
}
if (thisType != null) {
s1 = s1._tryPromoteForTypeCheck(h, x, thisType).ifTrue;
@@ -4256,10 +4266,12 @@
: s0._tryPromoteForTypeCheck(h, x, otherType).ifTrue;
var result = s2.rebaseForward(h, s1);
if (expectedChain == null) {
- expect(result.variableInfo, contains(x));
- expect(result.infoFor(x).promotedTypes, isNull);
+ expect(result.variableInfo,
+ contains(_promotionKeyStore.keyForVariable(x)));
+ expect(result._infoFor(x).promotedTypes, isNull);
} else {
- expect(result.infoFor(x).promotedTypes!.map((t) => t.type).toList(),
+ expect(
+ result._infoFor(x).promotedTypes!.map((t) => t.type).toList(),
expectedChain);
}
}
@@ -4300,31 +4312,31 @@
var h = Harness();
var x = Var('x', 'Object?');
var initialModel =
- FlowModel<Var, Type>(Reachability.initial).declare(x, true);
+ FlowModel<Type>(Reachability.initial)._declare(x, true);
for (var t in before) {
initialModel = initialModel._tryPromoteForTypeCheck(h, x, t).ifTrue;
}
- _checkChain(initialModel.infoFor(x).promotedTypes, before);
+ _checkChain(initialModel._infoFor(x).promotedTypes, before);
var tryModel = initialModel;
for (var t in inTry) {
tryModel = tryModel._tryPromoteForTypeCheck(h, x, t).ifTrue;
}
var expectedTryChain = before.toList()..addAll(inTry);
- _checkChain(tryModel.infoFor(x).promotedTypes, expectedTryChain);
+ _checkChain(tryModel._infoFor(x).promotedTypes, expectedTryChain);
var finallyModel = initialModel;
for (var t in inFinally) {
finallyModel = finallyModel._tryPromoteForTypeCheck(h, x, t).ifTrue;
}
var expectedFinallyChain = before.toList()..addAll(inFinally);
_checkChain(
- finallyModel.infoFor(x).promotedTypes, expectedFinallyChain);
+ finallyModel._infoFor(x).promotedTypes, expectedFinallyChain);
var result = tryModel.rebaseForward(h, finallyModel);
- _checkChain(result.infoFor(x).promotedTypes, expectedResult);
+ _checkChain(result._infoFor(x).promotedTypes, expectedResult);
// And verify that the inputs are unchanged.
- _checkChain(initialModel.infoFor(x).promotedTypes, before);
- _checkChain(tryModel.infoFor(x).promotedTypes, expectedTryChain);
+ _checkChain(initialModel._infoFor(x).promotedTypes, before);
+ _checkChain(tryModel._infoFor(x).promotedTypes, expectedTryChain);
_checkChain(
- finallyModel.infoFor(x).promotedTypes, expectedFinallyChain);
+ finallyModel._infoFor(x).promotedTypes, expectedFinallyChain);
}
_check(['Object'], ['num', 'int'], ['Iterable', 'List'],
@@ -4351,15 +4363,15 @@
test('types of interest', () {
var h = Harness();
var a = Var('a', 'Object');
- var s0 = FlowModel<Var, Type>(Reachability.initial).declare(a, false);
+ var s0 = FlowModel<Type>(Reachability.initial)._declare(a, false);
var s1 = s0._tryPromoteForTypeCheck(h, a, 'int').ifFalse;
var s2 = s0._tryPromoteForTypeCheck(h, a, 'String').ifFalse;
expect(
- s1.rebaseForward(h, s2).infoFor(a),
+ s1.rebaseForward(h, s2)._infoFor(a),
_matchVariableModel(ofInterest: ['int', 'String']),
);
expect(
- s2.rebaseForward(h, s1).infoFor(a),
+ s2.rebaseForward(h, s1)._infoFor(a),
_matchVariableModel(ofInterest: ['int', 'String']),
);
});
@@ -4367,8 +4379,8 @@
test('variable present in one state but not the other', () {
var h = Harness();
var x = Var('x', 'Object?');
- var s0 = FlowModel<Var, Type>(Reachability.initial);
- var s1 = s0.declare(x, true);
+ var s0 = FlowModel<Type>(Reachability.initial);
+ var s1 = s0._declare(x, true);
expect(s1.rebaseForward(h, s0), same(s0));
expect(s0.rebaseForward(h, s1), same(s1));
});
@@ -4536,23 +4548,23 @@
});
group('join', () {
- var x = Var('x', 'Object?');
- var y = Var('y', 'Object?');
- var z = Var('z', 'Object?');
- var w = Var('w', 'Object?');
+ var x = _promotionKeyStore.keyForVariable(Var('x', 'Object?'));
+ var y = _promotionKeyStore.keyForVariable(Var('y', 'Object?'));
+ var z = _promotionKeyStore.keyForVariable(Var('z', 'Object?'));
+ var w = _promotionKeyStore.keyForVariable(Var('w', 'Object?'));
var intType = Type('int');
var intQType = Type('int?');
var stringType = Type('String');
- const emptyMap = const <Var, VariableModel<Var, Type>>{};
+ const emptyMap = const <int, VariableModel<Type>>{};
- VariableModel<Var, Type> model(List<Type>? promotionChain,
+ VariableModel<Type> model(List<Type>? promotionChain,
{List<Type>? typesOfInterest, bool assigned = false}) =>
- VariableModel<Var, Type>(
+ VariableModel<Type>(
promotedTypes: promotionChain,
tested: typesOfInterest ?? promotionChain ?? [],
assigned: assigned,
unassigned: !assigned,
- ssaNode: new SsaNode<Var, Type>(null));
+ ssaNode: new SsaNode<Type>(null));
group('without input reuse', () {
test('promoted with unpromoted', () {
@@ -4587,7 +4599,7 @@
x: model([intType]),
y: model([stringType])
};
- var p2 = <Var, VariableModel<Var, Type>>{};
+ var p2 = <int, VariableModel<Type>>{};
expect(FlowModel.joinVariableInfo(h, p1, p2, emptyMap), same(emptyMap));
expect(FlowModel.joinVariableInfo(h, p2, p1, emptyMap), same(emptyMap));
});
@@ -4724,19 +4736,19 @@
});
group('merge', () {
- var x = Var('x', 'Object?');
+ var x = _promotionKeyStore.keyForVariable(Var('x', 'Object?'));
var intType = Type('int');
var stringType = Type('String');
- const emptyMap = const <Var, VariableModel<Var, Type>>{};
+ const emptyMap = const <int, VariableModel<Type>>{};
- VariableModel<Var, Type> varModel(List<Type>? promotionChain,
+ VariableModel<Type> varModel(List<Type>? promotionChain,
{bool assigned = false}) =>
- VariableModel<Var, Type>(
+ VariableModel<Type>(
promotedTypes: promotionChain,
tested: promotionChain ?? [],
assigned: assigned,
unassigned: !assigned,
- ssaNode: new SsaNode<Var, Type>(null));
+ ssaNode: new SsaNode<Type>(null));
test('first is null', () {
var h = Harness();
@@ -4817,18 +4829,18 @@
});
group('inheritTested', () {
- var x = Var('x', 'Object?');
+ var x = _promotionKeyStore.keyForVariable(Var('x', 'Object?'));
var intType = Type('int');
var stringType = Type('String');
- const emptyMap = const <Var, VariableModel<Var, Type>>{};
+ const emptyMap = const <int, VariableModel<Type>>{};
- VariableModel<Var, Type> model(List<Type> typesOfInterest) =>
- VariableModel<Var, Type>(
+ VariableModel<Type> model(List<Type> typesOfInterest) =>
+ VariableModel<Type>(
promotedTypes: null,
tested: typesOfInterest,
assigned: true,
unassigned: false,
- ssaNode: new SsaNode<Var, Type>(null));
+ ssaNode: new SsaNode<Type>(null));
test('inherits types of interest from other', () {
var h = Harness();
@@ -5821,6 +5833,8 @@
});
}
+final _promotionKeyStore = PromotionKeyStore();
+
/// Returns the appropriate matcher for expecting an assertion error to be
/// thrown or not, based on whether assertions are enabled.
Matcher get _asserts {
@@ -5873,7 +5887,7 @@
Matcher assignedMatcher = wrapMatcher(assigned);
Matcher unassignedMatcher = wrapMatcher(unassigned);
Matcher writeCapturedMatcher = wrapMatcher(writeCaptured);
- return predicate((VariableModel<Var, Type> model) {
+ return predicate((VariableModel<Type> model) {
if (!chainMatcher.matches(model.promotedTypes, {})) return false;
if (!ofInterestMatcher.matches(model.tested, {})) return false;
if (!assignedMatcher.matches(model.assigned, {})) return false;
@@ -5900,18 +5914,50 @@
fail('Unexpected call to accept');
}
-extension on FlowModel<Var, Type> {
- ExpressionInfo<Var, Type> _tryMarkNonNullable(Harness h, Var variable) =>
+extension on FlowModel<Type> {
+ FlowModel<Type> _conservativeJoin(
+ Iterable<Var> writtenVariables, Iterable<Var> capturedVariables) =>
+ conservativeJoin([
+ for (Var v in writtenVariables) _promotionKeyStore.keyForVariable(v)
+ ], [
+ for (Var v in capturedVariables) _promotionKeyStore.keyForVariable(v)
+ ]);
+
+ FlowModel<Type> _declare(Var variable, bool initialized) => this.declare(
+ variable, _promotionKeyStore.keyForVariable(variable), initialized);
+
+ VariableModel<Type> _infoFor(Var variable) =>
+ infoFor(_promotionKeyStore.keyForVariable(variable));
+
+ ExpressionInfo<Type> _tryMarkNonNullable(Harness h, Var variable) =>
tryMarkNonNullable(h, _varRefWithType(variable));
- ExpressionInfo<Var, Type> _tryPromoteForTypeCheck(
+ ExpressionInfo<Type> _tryPromoteForTypeCheck(
Harness h, Var variable, String type) =>
tryPromoteForTypeCheck(h, _varRefWithType(variable), Type(type));
- Reference<Var, Type> _varRef(Var variable) =>
- new VariableReference<Var, Type>(variable);
+ Reference<Type> _varRef(Var variable) => new VariableReference<Var, Type>(
+ variable, _promotionKeyStore.keyForVariable(variable));
- ReferenceWithType<Var, Type> _varRefWithType(Var variable) =>
- new ReferenceWithType<Var, Type>(_varRef(variable),
- variableInfo[variable]?.promotedTypes?.last ?? variable.type);
+ ReferenceWithType<Type> _varRefWithType(Var variable) =>
+ new ReferenceWithType<Type>(
+ _varRef(variable),
+ variableInfo[_promotionKeyStore.keyForVariable(variable)]
+ ?.promotedTypes
+ ?.last ??
+ variable.type);
+
+ FlowModel<Type> _write(
+ NonPromotionReason? nonPromotionReason,
+ Var variable,
+ Type writtenType,
+ SsaNode<Type> newSsaNode,
+ Operations<Var, Type> operations) =>
+ write(
+ nonPromotionReason,
+ variable,
+ _promotionKeyStore.keyForVariable(variable),
+ writtenType,
+ newSsaNode,
+ operations);
}
diff --git a/pkg/_fe_analyzer_shared/test/mini_ast.dart b/pkg/_fe_analyzer_shared/test/mini_ast.dart
index 2267aaa..4d4c3ed 100644
--- a/pkg/_fe_analyzer_shared/test/mini_ast.dart
+++ b/pkg/_fe_analyzer_shared/test/mini_ast.dart
@@ -193,8 +193,7 @@
/// [ExpressionInfo] associated with it. If the expression has no flow
/// analysis information associated with it, `null` will be passed to
/// [callback].
- Expression getExpressionInfo(
- void Function(ExpressionInfo<Var, Type>?) callback) =>
+ Expression getExpressionInfo(void Function(ExpressionInfo<Type>?) callback) =>
new _GetExpressionInfo(this, callback);
/// If `this` is an expression `x`, creates the expression `x ?? other`.
@@ -604,8 +603,7 @@
/// Gets the SSA node associated with [variable] at the current point in
/// control flow, or `null` if the variable has been write captured.
- SsaNode<Var, Type>? operator [](Var variable) =>
- _flow.ssaNodeForTesting(variable);
+ SsaNode<Type>? operator [](Var variable) => _flow.ssaNodeForTesting(variable);
}
/// Representation of a statement in the pseudo-Dart language used for flow
@@ -1171,7 +1169,7 @@
class _GetExpressionInfo extends Expression {
final Expression target;
- final void Function(ExpressionInfo<Var, Type>?) callback;
+ final void Function(ExpressionInfo<Type>?) callback;
_GetExpressionInfo(this.target, this.callback);
@@ -1413,7 +1411,7 @@
flow.logicalBinaryOp_begin();
}
var leftType = analyzeExpression(lhs);
- EqualityInfo<Var, Type>? leftInfo;
+ EqualityInfo<Type>? leftInfo;
if (isEquals) {
leftInfo = flow.equalityOperand_end(lhs, leftType);
} else if (isLogical) {
diff --git a/pkg/analysis_server/benchmark/benchmarks.dart b/pkg/analysis_server/benchmark/benchmarks.dart
index 9dea223..7257714 100644
--- a/pkg/analysis_server/benchmark/benchmarks.dart
+++ b/pkg/analysis_server/benchmark/benchmarks.dart
@@ -33,7 +33,7 @@
);
runner.addCommand(ListCommand(benchmarks));
runner.addCommand(RunCommand(benchmarks));
- runner.run(args);
+ await runner.run(args);
}
String get analysisServerSrcPath {
diff --git a/pkg/analysis_server/benchmark/integration/driver.dart b/pkg/analysis_server/benchmark/integration/driver.dart
index b52e80a..5c16d36 100644
--- a/pkg/analysis_server/benchmark/integration/driver.dart
+++ b/pkg/analysis_server/benchmark/integration/driver.dart
@@ -112,7 +112,7 @@
logger.log(Level.FINE, 'requesting server shutdown');
// Give the server a short time to comply with the shutdown request; if it
// doesn't exit, then forcibly terminate it.
- sendServerShutdown();
+ unawaited(sendServerShutdown());
await server.exitCode.timeout(timeout, onTimeout: () {
return server.kill('server failed to exit');
});
diff --git a/pkg/analysis_server/benchmark/perf/memory_tests.dart b/pkg/analysis_server/benchmark/perf/memory_tests.dart
index 488c61c..6bc4b74 100644
--- a/pkg/analysis_server/benchmark/perf/memory_tests.dart
+++ b/pkg/analysis_server/benchmark/perf/memory_tests.dart
@@ -195,7 +195,7 @@
@override
Future<void> shutdown() async {
_test.tearDown();
- _logger.shutdown();
+ await _logger.shutdown();
}
@override
@@ -254,7 +254,7 @@
total += heapUsage['heapUsage'] + heapUsage['externalUsage'] as int;
}
- service.dispose();
+ await service.dispose();
return total;
}
diff --git a/pkg/analysis_server/doc/tutorial/quick_assist.md b/pkg/analysis_server/doc/tutorial/quick_assist.md
new file mode 100644
index 0000000..b42dab9
--- /dev/null
+++ b/pkg/analysis_server/doc/tutorial/quick_assist.md
@@ -0,0 +1,337 @@
+# Writing a quick assist
+
+This document describes what a quick assist is and outlines the basic steps for
+writing a quick assist.
+
+## Overview
+
+A quick assist is an automated code edit that is both local in scope and doesn't
+require any user input. By 'local in scope' we mean that the assist only needs
+information from the local library (the library in which it is invoked) and will
+only make changes to the local library. If a code edit requires user input,
+might depend on knowledge from outside the local library, or could make changes
+outside the local library, then it should probably be implemented using a
+refactoring.
+
+Unlike quick fixes, quick assists are displayed even when there are no
+diagnostics being reported against the code. They are not intended to fix
+problems that are being reported, but are used to perform common and
+straightforward code transformations.
+
+In this document we'll use a simple example of writing an assist to convert a
+decimal representation of an integer into a hexadecimal representation. While
+this wouldn't be a good assist to offer, it's simple enough that the details of
+the implementation won't mask the general process used to implement an assist.
+
+## Design considerations
+
+Because quick assists are computed on demand, they need to be computed quickly.
+(Some clients request quick assists every time the user repositions the cursor.)
+That places a performance requirement on quick assists, one that requires that
+the code to compute a quick assist can't perform any potentially lengthy
+computations such as searching all of the user's code or accessing the network.
+That, in turn, generally means that assists can only support localized changes.
+They can add or remove text in the local library, but generally can't do more
+than that.
+
+Unlike quick fixes, there is no signal to indicate which assists might apply at
+a given location in the code. That means that we have to test every assist to
+see whether it's appropriate, which puts a practical limit on the number of
+assists that we can implement. (Even if each assist only takes 100 milliseconds
+to determine whether it applies, if we have 100 assists it will take 10 seconds
+to return the list of assists to the user, which is too slow.) That means that
+we need to be discerning about which assists are implemented and work to make
+assists return quickly if they are not appropriate.
+
+## Describing the assist
+
+Each assist has an instance of the class `AssistKind` associated with it. The
+existing assists for Dart are defined in the class `DartAssistKind`. An
+assist kind has an identifier, a priority, and a message.
+
+The identifier is used by some LSP-based clients to provide user-defined
+shortcuts. It's a hierarchical dot-separated identifier and should follow the
+pattern seen in the existing assist kinds.
+
+The priority is used to order the list of assists when presented to the user.
+The larger the value the closer to the top of the list it will appear. If you're
+implementing an assist for Dart files, you should use one of the constants
+defined in `DartAssistKindPriority` (typically
+`DartAssistKindPriority.DEFAULT`), or add a new constant if there's a need for
+it.
+
+The message is what will be displayed to the user by the client. This should be
+a sentence fragment (no terminating period) that would be appropriate as a label
+in a menu or on a button. It should describe the change that will be made to the
+user's code.
+
+Create a static field whose value is an `AssistKind` describing the assist
+you're implementing. For our example you might define a new constant in
+`DartAssistKind` like this:
+
+```dart
+static const CONVERT_TO_HEX = AssistKind(
+ 'dart.assist.convert.toHex',
+ DartAssistKindPriority.DEFAULT,
+ "Convert to hexadecimal",
+);
+```
+
+### Implementing the assist, part 1
+
+To implement the assist you'll create a subclass of `CorrectionProducer`. Most
+of the existing correction producers are in the directory
+`analysis_server/lib/src/services/correction/dart`, so we'll start by creating
+a file named `convert_to_hex.dart` in that directory that contains the following
+(with the year updated appropriately):
+
+```dart
+// Copyright (c) 2022, 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:analysis_server/src/services/correction/assist.dart';
+import 'package:analysis_server/src/services/correction/dart/abstract_producer.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer_plugin/utilities/assist/assist.dart';
+import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
+import 'package:analyzer_plugin/utilities/range_factory.dart';
+
+class ConvertToHex extends CorrectionProducer {
+ @override
+ AssistKind get assistKind => DartAssistKind.CONVERT_TO_HEX;
+
+ @override
+ Future<void> compute(ChangeBuilder builder) async {
+ }
+}
+```
+
+The `compute` method is where the assist will be built. We'll come back to it in
+"Implementing the assist, part 2".
+
+The `assistKind` getter is how you associate the assist kind we created earlier
+with the assist produced by the `compute` method.
+
+There's another getter you might need to override. The message associated with
+the assist kind is actually a template that can be filled in at runtime. The
+placeholders in the message are denoted by integers inside curly braces (such as
+`{0}`). The integers are indexes into a list of replacement values (hence, zero
+based), and the getter `assistArguments` returns the list of replacement values.
+The message we used above doesn't have any placeholders, but if we'd written the
+message as `"Convert to '{0}'"`, then we could return the replacement values by
+implementing:
+
+```dart
+String _hexRepresentation = '';
+
+@override
+List<Object> get assistArguments => [_hexRepresentation];
+```
+
+and assigning the replacement string to the field inside the `compute` method.
+
+If you don't implement this getter, then the inherited getter will return an
+empty list. The number of elements in the list must match the largest index used
+in the message. If it doesn't, an exception will be thrown at runtime.
+
+### Testing the assist
+
+Before we look at implementing the `compute` method, we should probably write
+some tests. Even if you don't normally use a test-driven approach to coding, we
+recommend it in this case because writing the tests can help you think of corner
+cases that the implementation will need to handle. The corresponding tests are
+in the directory `analysis_server/test/src/services/correction/assist`, so we'll
+create a file named `convert_to_hex_test.dart` that contains the following:
+
+```dart
+// Copyright (c) 2022, 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:analysis_server/src/services/correction/assist.dart';
+import 'package:analyzer_plugin/utilities/assist/assist.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import 'assist_processor.dart';
+
+void main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(ConvertToHexTest);
+ });
+}
+
+@reflectiveTest
+class ConvertToHexTest extends AssistProcessorTest {
+ @override
+ AssistKind get kind => DartAssistKind.CONVERT_TO_HEX;
+}
+```
+
+This getter tells the test framework to expect an assist of the returned kind.
+
+The test can then be written in a method that looks something like this:
+
+```dart
+Future<void> test_positive() async {
+ await resolveTestCode('''
+var c = /*caret*/42;
+''');
+ await assertHasAssist('''
+var c = 0x2a;
+''');
+}
+```
+
+The test framework will look for the marker `/*caret*/`, remember it's offset,
+create a file containing the first piece of code with the marker removed, run
+the assist over the code, use our correction producer to build an edit, apply
+the edit to the file, and textually compare the results with the second piece of
+code.
+
+### Registering the assist
+
+Before we can run the test, we need to register the correction producer so that
+it can be run.
+
+The list of assists is computed by the `AssistProcessor`, which has two static
+lists named `generators` and `multiGenerators` that contain the correction
+producers used to compute the assists.
+
+Actually, the lists contain functions used to create the producers. We do that
+so that producers can't accidentally carry state over from one use to the next.
+These functions are usually a tear-off of the correction producer's constructor.
+
+The last step is to add your correction producer to the list named `generators`.
+We'll talk about the other list in "Multi-assist producers".
+
+At this point you should be able to run the test and see it failing.
+
+### Implementing the assist, part 2
+
+We're now at a point where we can finish the implementation of the assist by
+implementing the `compute` method.
+
+The correction producer has access to most of the information you should need in
+order to write the assist. The change builder passed to `compute` is how you
+construct the edit that will be sent back to the client.
+
+The first step in the implementation of any assist is to find the location in
+the AST where the cursor is positioned and verify that all the conditions on
+which the assist is predicated are valid. For example, for our assist we'll need
+to ensure that the cursor is on an integer literal, that the literal consists of
+decimal digits, and that the value is a valid integer.
+
+Finding the AST node is easy because it's done for you by the assist processor
+before `compute` is invoked. All you have to do is use the getter `node` to find
+the node at the cursor.
+
+```dart
+@override
+Future<void> compute(ChangeBuilder builder) async {
+ var node = this.node;
+}
+```
+
+Then we need to verify that this node is an integer literal:
+
+```dart
+@override
+Future<void> compute(ChangeBuilder builder) async {
+ var node = this.node;
+ if (node is! IntegerLiteral) {
+ return;
+ }
+}
+```
+
+If it isn't, then we'll return. Because we haven't used the builder to create a
+assist, returning now means that no assist from this producer will be sent to
+the client.
+
+We'll also check that the integer has the right form and is valid:
+
+```dart
+@override
+Future<void> compute(ChangeBuilder builder) async {
+ var node = this.node;
+ if (node is! IntegerLiteral) {
+ return;
+ }
+ var value = node.value;
+ if (value == null) {
+ return;
+ }
+ if (node.literal.lexeme.contains(RegExp('[^0-9]'))) {
+ return;
+ }
+}
+```
+
+After all those checks we now know that we have a decimal integer that we can
+convert. Note that we check for a `null` value before checking for non-decimal
+digits because it's a faster check and we want the assist to fail as quickly as
+possible.
+
+We're now ready to create the edit. To do that we're going to use the
+`ChangeBuilder` passed to the `compute` method. In the example below we'll
+introduce a couple of the methods on `ChangeBuilder`, but for more information
+you can read [Creating `SourceChange`s](https://github.com/dart-lang/sdk/blob/main/pkg/analyzer_plugin/doc/tutorial/creating_edits.md).
+
+```dart
+@override
+Future<void> compute(ChangeBuilder builder) async {
+ var node = this.node;
+ if (node is! IntegerLiteral) {
+ return;
+ }
+ var value = node.value;
+ if (value == null) {
+ return;
+ }
+ if (node.literal.lexeme.contains(RegExp('[^0-9]'))) {
+ return;
+ }
+ await builder.addDartFileEdit(file, (builder) {
+ var hexDigits = value.toRadixString(16);
+ builder.addSimpleReplacement(range.node(node), '0x$hexDigits');
+ });
+}
+```
+
+We're using `addDartFileEdit` to create an edit in a `.dart` file. In this case
+the edit is simple: we're just replacing one representation of the integer
+literal with a representation of the same value in a different base. The getter
+`range` returns a `RangeFactory`, a utility class with lots of methods to make
+it easier to create `SourceRange`s.
+
+We're missing several test cases. Minimally we should test that the assist works
+correctly with negative values (it doesn't), and that it will not produce an
+edit if the integer literal isn't valid. We'll leave adding such tests as an
+exercise for the reader.
+
+In this example we're just making a simple replacement, so we're avoiding any
+need to worry about formatting. As a general principle we don't attempt to
+format the code after it's been modified, but we do make an effort to leave the
+code in a reasonably readable state. There's a getter (`eol`) that you can use
+to get the end-of-line marker that should be used in the file, and there's
+another getter (`utils`) that will return an object with several utility methods
+that help with things like getting the right indentation for nested code.
+
+### Multi-assist producers
+
+We skipped over the list named `multiGenerators` earlier, promising that we'd
+return to it later. You'll probably never have a need for it, but in case you do
+this section will hopefully tell you what you need to know.
+
+There's a subclass of `CorrectionProducer` named `MultiCorrectionProducer` and
+this list is how you register one of them. That class exists for rare cases
+where you need to use a single correction producer to produce multiple assists.
+This is generally only needed when you can't know in advance the maximum number
+of assists that might need to be produced. For example, there's a set of assists
+to wrap a Flutter `Widget` in another widget, but the set of widgets that can
+wrap a given widget depends on the widget being wrapped.
+
+If you are able to enumerate the possible assists ahead of time, then you're
+probably better off to create one subclass of `CorrectionProducer` for each of
+the assists.
diff --git a/pkg/analysis_server/lib/src/analysis_server.dart b/pkg/analysis_server/lib/src/analysis_server.dart
index f553073..64db45c 100644
--- a/pkg/analysis_server/lib/src/analysis_server.dart
+++ b/pkg/analysis_server/lib/src/analysis_server.dart
@@ -805,7 +805,7 @@
_refactoringManager = RefactoringManager(this, refactoringWorkspace);
}
- Future<void> _scheduleAnalysisImplementedNotification() async {
+ void _scheduleAnalysisImplementedNotification() {
var files = analysisServices[AnalysisService.IMPLEMENTED];
if (files != null) {
scheduleImplementedNotification(this, files);
diff --git a/pkg/analysis_server/lib/src/cider/rename.dart b/pkg/analysis_server/lib/src/cider/rename.dart
index 8d967e5..d1b71bd 100644
--- a/pkg/analysis_server/lib/src/cider/rename.dart
+++ b/pkg/analysis_server/lib/src/cider/rename.dart
@@ -53,7 +53,7 @@
} else if (element is ConstructorElement) {
status = validateConstructorName(name);
_analyzePossibleConflicts(element, status, name);
- } else if (element is ImportElement) {
+ } else if (element is ImportElement2) {
status = validateImportPrefixName(name);
}
@@ -156,7 +156,7 @@
replaceMatches.addMatch(result.path, result.matches.toList());
}
}
- } else if (element is ImportElement) {
+ } else if (element is ImportElement2) {
var replaceInfo = <ReplaceInfo>[];
for (var match in matches) {
for (var ref in match.references) {
@@ -214,29 +214,28 @@
lineInfo.getLocation(element.setter!.nameOffset),
element.setter!.nameLength));
}
- } else if (element is ImportElement) {
- var prefix = element.prefix;
+ } else if (element is ImportElement2) {
var unit =
(await canRename._fileResolver.resolve2(path: sourcePath)).unit;
- var index = element.library.imports.indexOf(element);
+ var index = element.library.imports2.indexOf(element);
var node = unit.directives.whereType<ImportDirective>().elementAt(index);
+ final prefixNode = node.prefix;
if (newName.isEmpty) {
// We should not get `prefix == null` because we check in
// `checkNewName` that the new name is different.
- if (prefix == null) {
- return infos;
+ if (prefixNode != null) {
+ var prefixEnd = prefixNode.end;
+ infos.add(ReplaceInfo(newName, lineInfo.getLocation(node.uri.end),
+ prefixEnd - node.uri.end));
}
- var prefixEnd = prefix.nameOffset + prefix.nameLength;
- infos.add(ReplaceInfo(newName, lineInfo.getLocation(node.uri.end),
- prefixEnd - node.uri.end));
} else {
- if (prefix == null) {
+ if (prefixNode == null) {
var uriEnd = node.uri.end;
infos.add(
ReplaceInfo(' as $newName', lineInfo.getLocation(uriEnd), 0));
} else {
- var offset = prefix.nameOffset;
- var length = prefix.nameLength;
+ var offset = prefixNode.offset;
+ var length = prefixNode.length;
infos.add(ReplaceInfo(newName, lineInfo.getLocation(offset), length));
}
}
@@ -387,7 +386,7 @@
if (element is ConstructorElement) {
return true;
}
- if (element is ImportElement) {
+ if (element is ImportElement2) {
return true;
}
if (element is LabelElement || element is LocalElement) {
diff --git a/pkg/analysis_server/lib/src/computer/computer_call_hierarchy.dart b/pkg/analysis_server/lib/src/computer/computer_call_hierarchy.dart
new file mode 100644
index 0000000..5218d75
--- /dev/null
+++ b/pkg/analysis_server/lib/src/computer/computer_call_hierarchy.dart
@@ -0,0 +1,477 @@
+// Copyright (c) 2022, 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:analysis_server/src/protocol_server.dart' as protocol;
+import 'package:analysis_server/src/search/element_references.dart';
+import 'package:analysis_server/src/services/search/search_engine.dart';
+import 'package:analyzer/dart/analysis/results.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/source/source_range.dart';
+import 'package:analyzer/src/dart/ast/element_locator.dart';
+import 'package:analyzer/src/dart/ast/utilities.dart';
+
+/// A [CallHierarchyItem] and a set of ranges that call to or from it.
+class CallHierarchyCalls {
+ final CallHierarchyItem item;
+ final List<SourceRange> ranges;
+
+ CallHierarchyCalls(this.item, [List<SourceRange>? ranges])
+ : ranges = ranges ?? [];
+}
+
+/// An item that can appear in a Call Hierarchy.
+///
+/// Items are the containers that can contain calls to other items. This
+/// includes not only functions and methods, but classes (because they can call
+/// functions in class field initializers) and files (because they can call
+/// functions in top level variable initializers).
+///
+/// Implicit constructors are represented using the location of their classes
+/// (since do not themselves have a range) but a [kind] of
+/// [CallHierarchyKind.constructor].
+class CallHierarchyItem {
+ /// The kind of this item in the Call Hierarchy.
+ ///
+ /// This may be used to select an icon to show in the Call Hierarchy tree.
+ final CallHierarchyKind kind;
+
+ // The user-visible name for this item in the Call Hierarchy.
+ final String displayName;
+
+ /// The file that contains the declaration of this item.
+ final String file;
+
+ /// The range of the name at the declaration of this item.
+ final SourceRange range;
+
+ // TODO(dantup): This class will need to contain two ranges (codeRange +
+ // selectionRange) for LSP.
+
+ CallHierarchyItem.forElement(
+ Element element, {
+ required this.range,
+ }) : displayName = element is CompilationUnitElement
+ ? element.source.shortName
+ : element is PropertyAccessorElement
+ ? element.isGetter
+ ? 'get ${element.displayName}'
+ : 'set ${element.displayName}'
+ : element.displayName,
+ file = element.source!.fullName,
+ kind = CallHierarchyKind.forElement(element);
+
+ CallHierarchyItem.forProtocolElement(
+ protocol.Element element, {
+ required this.range,
+ }) : displayName = element.name,
+ file = element.location!.file,
+ kind = CallHierarchyKind.forProtocolElement(element);
+}
+
+/// Kinds of [CallHierarchyItem] that can make calls to other
+/// [CallHierarchyItem]s.
+enum CallHierarchyKind {
+ class_,
+ constructor,
+ extension,
+ file,
+ function,
+ method,
+ mixin,
+ property,
+ unknown;
+
+ static const _elementMapping = {
+ ElementKind.CLASS: class_,
+ ElementKind.COMPILATION_UNIT: file,
+ ElementKind.CONSTRUCTOR: constructor,
+ ElementKind.EXTENSION: extension,
+ ElementKind.FUNCTION: function,
+ ElementKind.GETTER: property,
+ ElementKind.METHOD: method,
+ ElementKind.SETTER: property,
+ };
+
+ static const _protocolElementMapping = {
+ protocol.ElementKind.CLASS: class_,
+ protocol.ElementKind.COMPILATION_UNIT: file,
+ protocol.ElementKind.CONSTRUCTOR: constructor,
+ protocol.ElementKind.EXTENSION: extension,
+ protocol.ElementKind.FUNCTION: function,
+ protocol.ElementKind.GETTER: property,
+ protocol.ElementKind.METHOD: method,
+ protocol.ElementKind.MIXIN: mixin,
+ protocol.ElementKind.SETTER: property,
+ };
+
+ static CallHierarchyKind forElement(Element element) =>
+ _elementMapping[element.kind] ?? unknown;
+
+ static CallHierarchyKind forProtocolElement(protocol.Element element) =>
+ _protocolElementMapping[element.kind] ?? unknown;
+}
+
+/// A computer for Call Hierarchies.
+///
+/// Call Hierarchies are computed lazily and roughly follow the LSP model, which
+/// is:
+///
+/// 1. Client calls `findTarget(int offset)` to locate a starting point for
+/// navigation. The starting point is always based on the declaration of
+/// the executable code even if invoked at a call site.
+/// 2. Client passes the returned target into `findIncomingCalls()` or
+/// `findOutgoingCalls()` to find relevant calls in to/out of that item.
+/// The result will contain a set of other items, along with the ranges
+/// of the calls in or out.
+///
+/// It is expected that clients will call the methods above at different times
+/// (as the user expands items in a tree). It is up to the caller to handle
+/// cases where a target may no longer be valid (due to file modifications) that
+/// may result in inconsistent results.
+class DartCallHierarchyComputer {
+ final ResolvedUnitResult _result;
+
+ DartCallHierarchyComputer(this._result);
+
+ /// Finds incoming calls to [target], returning the elements that call them
+ /// and ranges of those calls within.
+ Future<List<CallHierarchyCalls>> findIncomingCalls(
+ CallHierarchyItem target,
+ SearchEngine searchEngine,
+ ) async {
+ assert(target.file == _result.path);
+ final node = _findTargetNode(target.range.offset);
+ var element = _getElementOfNode(node);
+ if (element == null) {
+ return [];
+ }
+
+ // Implicit constructors are handled using the Class element and a kind of
+ // `constructor`, because we need to locate them using an `offset`, which
+ // implicit constructors do not have.
+ // Here, we map them back to the synthetic constructor element.
+ final isImplicitConstructor =
+ element is ClassElement && target.kind == CallHierarchyKind.constructor;
+ if (isImplicitConstructor) {
+ element = element.unnamedConstructor;
+ }
+
+ // We only find incoming calls to executable elements.
+ if (element is! ExecutableElement) {
+ return [];
+ }
+
+ final computer = ElementReferencesComputer(searchEngine);
+ final references = await computer.compute(element, false);
+
+ // Group results by their container, since we only want to return a single
+ // entry for a body, with a set of ranges within.
+ final resultsByContainer = <protocol.Element, CallHierarchyCalls>{};
+ // We may need to fetch parsed results for the other files, reuse them
+ // across calls.
+ final parsedUnits = <String, SomeParsedUnitResult?>{};
+ for (final reference in references) {
+ final container = _getContainer(reference.path);
+ if (container == null) {
+ continue;
+ }
+
+ // Create an item for a container the first time we see it.
+ final containerCalls = resultsByContainer.putIfAbsent(
+ container,
+ () => CallHierarchyCalls(CallHierarchyItem.forProtocolElement(
+ container,
+ range: _rangeForProtocolElement(container),
+ )),
+ );
+
+ // Add this match to the containers results.
+ final range = _rangeForSearchResult(reference, parsedUnits);
+ containerCalls.ranges.add(range);
+ }
+
+ return resultsByContainer.values.toList();
+ }
+
+ /// Finds outgoing calls from [target], returning the elements that are called
+ /// and the ranges that call them.
+ Future<List<CallHierarchyCalls>> findOutgoingCalls(
+ CallHierarchyItem target,
+ ) async {
+ assert(target.file == _result.path);
+ final node = _findTargetNode(target.range.offset);
+ if (node == null) {
+ return [];
+ }
+
+ // Don't look for outbound calls in things that aren't functions.
+ if (!(node is FunctionDeclaration ||
+ node is ConstructorDeclaration ||
+ node is MethodDeclaration)) {
+ return [];
+ }
+
+ final referenceNodes = <AstNode>{};
+ node.accept(_OutboundCallVisitor(node, referenceNodes.add));
+
+ // Group results by their target, since we only want to return a single
+ // entry for each target, with a set of ranges that call it.
+ final resultsByTarget = <Element, CallHierarchyCalls>{};
+ for (final referenceNode in referenceNodes) {
+ final target = _getElementOfNode(referenceNode);
+ if (target == null) {
+ continue;
+ }
+
+ // Create an item for a target the first time we see it.
+ final calls = resultsByTarget.putIfAbsent(
+ target,
+ () => CallHierarchyCalls(CallHierarchyItem.forElement(
+ target,
+ range: _rangeForElement(target),
+ )),
+ );
+
+ // Add this call to the targets results.
+ final range = _rangeForNode(referenceNode);
+ calls.ranges.add(range);
+ }
+
+ return resultsByTarget.values.toList();
+ }
+
+ /// Finds a target for starting call hierarchy navigation at [offset].
+ ///
+ /// If [offset] is an invocation, returns information about the [Element] it
+ /// refers to.
+ CallHierarchyItem? findTarget(int offset) {
+ final node = _findTargetNode(offset);
+ final element = _getElementOfNode(node);
+
+ // We only return targets that are executable elements.
+ return element is ExecutableElement
+ ? CallHierarchyItem.forElement(element,
+ range: _rangeForElement(element))
+ : null;
+ }
+
+ /// Finds a target node for call hierarchy navigation at [offset].
+ AstNode? _findTargetNode(int offset) {
+ var node = NodeLocator(offset).searchWithin(_result.unit);
+ if (node is SimpleIdentifier &&
+ node.parent != null &&
+ node.parent is! VariableDeclaration &&
+ node.parent is! AssignmentExpression) {
+ node = node.parent;
+ }
+
+ // For consistency with other places, we only treat the type name as the
+ // constructor for unnamed constructor (since we use the constructors name
+ // as the target).
+ if (node is NamedType) {
+ final parent = node.parent;
+ if (parent is ConstructorName) {
+ final name = parent.name;
+ if (name != null && offset < name.offset) {
+ return null;
+ }
+ }
+ } else if (node is ConstructorDeclaration) {
+ final name = node.name;
+ if (name != null && offset < name.offset) {
+ return null;
+ }
+ }
+
+ return node;
+ }
+
+ /// Returns the enclosing element (class, function body, compliation unit) for
+ /// the reference [element].
+ ///
+ /// This is used to construct (and group calls by) a [CallHierarchyItem] that
+ /// contains calls.
+ protocol.Element? _getContainer(List<protocol.Element> elements) {
+ return elements.firstWhere((parent) =>
+ parent.kind == protocol.ElementKind.CLASS ||
+ parent.kind == protocol.ElementKind.COMPILATION_UNIT ||
+ parent.kind == protocol.ElementKind.CONSTRUCTOR ||
+ parent.kind == protocol.ElementKind.ENUM ||
+ parent.kind == protocol.ElementKind.EXTENSION ||
+ parent.kind == protocol.ElementKind.FUNCTION ||
+ parent.kind == protocol.ElementKind.GETTER ||
+ parent.kind == protocol.ElementKind.METHOD ||
+ parent.kind == protocol.ElementKind.MIXIN ||
+ parent.kind == protocol.ElementKind.SETTER);
+ }
+
+ /// Return the [Element] of the given [node], or `null` if [node] is `null`,
+ /// does not have an element, or the element is not a valid target for call
+ /// hierarchy.
+ Element? _getElementOfNode(AstNode? node) {
+ if (node == null) {
+ return null;
+ }
+ final parent = node.parent;
+
+ // ElementLocator returns the class for default constructor calls and null
+ // for constructor names.
+ if (node is NamedType && parent is ConstructorName) {
+ return parent.staticElement;
+ } else if (node is ConstructorName) {
+ return node.staticElement;
+ } else if (node is PropertyAccess) {
+ node = node.propertyName;
+ }
+
+ final element = ElementLocator.locate(node);
+
+ // Don't consider synthetic getter/setter for a field to be executable
+ // since they don't contain any executable code.
+ if (element is PropertyAccessorElement && element.isSynthetic) {
+ return null;
+ }
+
+ return element;
+ }
+
+ /// Returns the [SourceRange] to use for [element].
+ ///
+ /// The returned range covers only the name of the target and does not include
+ /// any parameter list.
+ SourceRange _rangeForElement(Element element) {
+ // For synthetic items (like implicit constructors), use the nonSynthetic
+ // element for the location.
+ element = element.nonSynthetic;
+ return SourceRange(element.nameOffset, element.nameLength);
+ }
+
+ /// Returns the [SourceRange] to use for [node].
+ ///
+ /// The returned range covers only the name of the target and does not include
+ /// the argument list.
+ SourceRange _rangeForNode(AstNode node) {
+ if (node is MethodInvocation) {
+ return SourceRange(
+ node.methodName.offset,
+ node.methodName.length,
+ );
+ } else if (node is InstanceCreationExpression) {
+ return SourceRange(
+ node.constructorName.offset,
+ node.constructorName.length,
+ );
+ } else if (node is PropertyAccess) {
+ return SourceRange(
+ node.propertyName.offset,
+ node.propertyName.length,
+ );
+ }
+ return SourceRange(node.offset, node.length);
+ }
+
+ /// Returns the [SourceRange] to use for [element].
+ ///
+ /// The returned range covers only the name of the target and does not include
+ /// any parameter list.
+ SourceRange _rangeForProtocolElement(protocol.Element element) {
+ return SourceRange(element.location!.offset, element.location!.length);
+ }
+
+ /// Returns the [SourceRange] for [match].
+ ///
+ /// Usually this is the range returned from the search index, but sometimes it
+ /// will be adjusted to reflect the source range that should be highlighted
+ /// for this call. For example, an unnamed constructor may be given a range
+ /// covering the type name (whereas the index has a zero-width range after the
+ /// type name).
+ SourceRange _rangeForSearchResult(
+ protocol.SearchResult match,
+ Map<String, SomeParsedUnitResult?> parsedUnits,
+ ) {
+ var offset = match.location.offset;
+ var length = match.location.length;
+ final file = match.location.file;
+ final result = parsedUnits.putIfAbsent(
+ file,
+ () => _result.session.getParsedUnit(file),
+ );
+
+ if (result is ParsedUnitResult) {
+ final node = NodeLocator(offset).searchWithin(result.unit);
+ if (node != null && !node.isSynthetic) {
+ final parent = node.parent;
+ // Handle named constructors which have their `.` included in the
+ // search index range, but we just want to highlight the name.
+ if (node is SimpleIdentifier && parent is MethodInvocation) {
+ offset = parent.methodName.offset;
+ length = parent.methodName.length;
+ } else if (length == 0) {
+ // If the search index length was 0, prefer the nodes range.
+ offset = node.offset;
+ length = node.length;
+ }
+ }
+ }
+
+ return SourceRange(offset, length);
+ }
+}
+
+/// Collects outbound calls from a node.
+class _OutboundCallVisitor extends RecursiveAstVisitor<void> {
+ final AstNode root;
+ final void Function(AstNode) collect;
+
+ _OutboundCallVisitor(this.root, this.collect);
+
+ @override
+ void visitConstructorName(ConstructorName node) {
+ collect(node.name ?? node);
+ super.visitConstructorName(node);
+ }
+
+ @override
+ void visitFunctionDeclaration(FunctionDeclaration node) {
+ // Only descend into function declarations if they are the target/root
+ // function.
+ if (node == root) {
+ super.visitFunctionDeclaration(node);
+ }
+ }
+
+ @override
+ void visitFunctionReference(FunctionReference node) {
+ collect(node);
+ super.visitFunctionReference(node);
+ }
+
+ @override
+ void visitMethodInvocation(MethodInvocation node) {
+ collect(node.methodName);
+ super.visitMethodInvocation(node);
+ }
+
+ @override
+ void visitPrefixedIdentifier(PrefixedIdentifier node) {
+ collect(node.identifier);
+ super.visitPrefixedIdentifier(node);
+ }
+
+ @override
+ void visitPropertyAccess(PropertyAccess node) {
+ collect(node.propertyName);
+ super.visitPropertyAccess(node);
+ }
+
+ @override
+ void visitSimpleIdentifier(SimpleIdentifier node) {
+ if (node.staticElement is FunctionElement && !node.inDeclarationContext()) {
+ collect(node);
+ }
+ super.visitSimpleIdentifier(node);
+ }
+}
diff --git a/pkg/analysis_server/lib/src/computer/import_elements_computer.dart b/pkg/analysis_server/lib/src/computer/import_elements_computer.dart
index a29230f..e1a152f 100644
--- a/pkg/analysis_server/lib/src/computer/import_elements_computer.dart
+++ b/pkg/analysis_server/lib/src/computer/import_elements_computer.dart
@@ -339,7 +339,7 @@
/// [importedElements]. They will match if they import the same library using
/// the same prefix.
bool _matches(ImportDirective import, ImportedElements importedElements) {
- var importElement = import.element;
+ var importElement = import.element2;
if (importElement == null) {
return false;
}
diff --git a/pkg/analysis_server/lib/src/domains/completion/available_suggestions.dart b/pkg/analysis_server/lib/src/domains/completion/available_suggestions.dart
index c7ec048..e98d0fa 100644
--- a/pkg/analysis_server/lib/src/domains/completion/available_suggestions.dart
+++ b/pkg/analysis_server/lib/src/domains/completion/available_suggestions.dart
@@ -97,7 +97,7 @@
var uniqueElements = _UniqueImportedElements();
var existingImports = <protocol.ExistingImport>[];
- var importElementList = resolvedUnit.libraryElement.imports;
+ var importElementList = resolvedUnit.libraryElement.imports2;
for (var import in importElementList) {
var importedLibrary = import.importedLibrary;
if (importedLibrary == null) continue;
diff --git a/pkg/analysis_server/lib/src/handler/legacy/analysis_reanalyze.dart b/pkg/analysis_server/lib/src/handler/legacy/analysis_reanalyze.dart
index 988d2e9..cbf090a 100644
--- a/pkg/analysis_server/lib/src/handler/legacy/analysis_reanalyze.dart
+++ b/pkg/analysis_server/lib/src/handler/legacy/analysis_reanalyze.dart
@@ -16,14 +16,14 @@
@override
Future<void> handle() async {
- server.options.analytics?.sendEvent('analysis', 'reanalyze');
+ unawaited(server.options.analytics?.sendEvent('analysis', 'reanalyze'));
await server.reanalyze();
//
// Restart all of the plugins. This is an async operation that will happen
// in the background.
//
- server.pluginManager.restartPlugins();
+ unawaited(server.pluginManager.restartPlugins());
sendResult(AnalysisReanalyzeResult());
}
diff --git a/pkg/analysis_server/lib/src/handler/legacy/analysis_set_analysis_roots.dart b/pkg/analysis_server/lib/src/handler/legacy/analysis_set_analysis_roots.dart
index 6f2c5e2..d01a068 100644
--- a/pkg/analysis_server/lib/src/handler/legacy/analysis_set_analysis_roots.dart
+++ b/pkg/analysis_server/lib/src/handler/legacy/analysis_set_analysis_roots.dart
@@ -21,8 +21,11 @@
var includedPathList = params.included;
var excludedPathList = params.excluded;
- server.options.analytics?.sendEvent('analysis', 'setAnalysisRoots',
- value: includedPathList.length);
+ unawaited(server.options.analytics?.sendEvent(
+ 'analysis',
+ 'setAnalysisRoots',
+ value: includedPathList.length,
+ ));
server.analyticsManager.startedSetAnalysisRoots(params);
// validate
diff --git a/pkg/analysis_server/lib/src/handler/legacy/analytics_send_event.dart b/pkg/analysis_server/lib/src/handler/legacy/analytics_send_event.dart
index afb36ff..2051bd6 100644
--- a/pkg/analysis_server/lib/src/handler/legacy/analytics_send_event.dart
+++ b/pkg/analysis_server/lib/src/handler/legacy/analytics_send_event.dart
@@ -25,7 +25,7 @@
}
var params = AnalyticsSendEventParams.fromRequest(request);
- analytics.sendEvent(_clientId, params.action);
+ unawaited(analytics.sendEvent(_clientId, params.action));
sendResult(AnalyticsSendEventResult());
}
}
diff --git a/pkg/analysis_server/lib/src/handler/legacy/analytics_send_timing.dart b/pkg/analysis_server/lib/src/handler/legacy/analytics_send_timing.dart
index bddc7d0..476abfa 100644
--- a/pkg/analysis_server/lib/src/handler/legacy/analytics_send_timing.dart
+++ b/pkg/analysis_server/lib/src/handler/legacy/analytics_send_timing.dart
@@ -25,7 +25,8 @@
}
var params = AnalyticsSendTimingParams.fromRequest(request);
- analytics.sendTiming(params.event, params.millis, category: _clientId);
+ unawaited(
+ analytics.sendTiming(params.event, params.millis, category: _clientId));
sendResult(AnalyticsSendTimingResult());
}
}
diff --git a/pkg/analysis_server/lib/src/handler/legacy/completion_get_suggestions.dart b/pkg/analysis_server/lib/src/handler/legacy/completion_get_suggestions.dart
index 62907af..c29308e 100644
--- a/pkg/analysis_server/lib/src/handler/legacy/completion_get_suggestions.dart
+++ b/pkg/analysis_server/lib/src/handler/legacy/completion_get_suggestions.dart
@@ -41,7 +41,7 @@
}
var performance = OperationPerformanceImpl('<root>');
- performance.runAsync(
+ await performance.runAsync(
'request',
(performance) async {
if (file.endsWith('.yaml')) {
diff --git a/pkg/analysis_server/lib/src/handler/legacy/completion_get_suggestions2.dart b/pkg/analysis_server/lib/src/handler/legacy/completion_get_suggestions2.dart
index d889bbd..e96ab6a 100644
--- a/pkg/analysis_server/lib/src/handler/legacy/completion_get_suggestions2.dart
+++ b/pkg/analysis_server/lib/src/handler/legacy/completion_get_suggestions2.dart
@@ -147,7 +147,7 @@
}
var performance = OperationPerformanceImpl('<root>');
- performance.runAsync(
+ await performance.runAsync(
'request',
(performance) async {
var resolvedUnit = await performance.runAsync(
diff --git a/pkg/analysis_server/lib/src/handler/legacy/edit_format.dart b/pkg/analysis_server/lib/src/handler/legacy/edit_format.dart
index bf77274..d09c2ee 100644
--- a/pkg/analysis_server/lib/src/handler/legacy/edit_format.dart
+++ b/pkg/analysis_server/lib/src/handler/legacy/edit_format.dart
@@ -20,7 +20,7 @@
@override
Future<void> handle() async {
- server.options.analytics?.sendEvent('edit', 'format');
+ unawaited(server.options.analytics?.sendEvent('edit', 'format'));
var params = EditFormatParams.fromRequest(request);
var file = params.file;
diff --git a/pkg/analysis_server/lib/src/handler/legacy/edit_get_postfix_completion.dart b/pkg/analysis_server/lib/src/handler/legacy/edit_get_postfix_completion.dart
index ba79981..db908dd 100644
--- a/pkg/analysis_server/lib/src/handler/legacy/edit_get_postfix_completion.dart
+++ b/pkg/analysis_server/lib/src/handler/legacy/edit_get_postfix_completion.dart
@@ -18,7 +18,10 @@
@override
Future<void> handle() async {
- server.options.analytics?.sendEvent('edit', 'getPostfixCompletion');
+ unawaited(server.options.analytics?.sendEvent(
+ 'edit',
+ 'getPostfixCompletion',
+ ));
var params = EditGetPostfixCompletionParams.fromRequest(request);
var file = params.file;
diff --git a/pkg/analysis_server/lib/src/handler/legacy/edit_organize_directives.dart b/pkg/analysis_server/lib/src/handler/legacy/edit_organize_directives.dart
index 99967a5..2f06e89 100644
--- a/pkg/analysis_server/lib/src/handler/legacy/edit_organize_directives.dart
+++ b/pkg/analysis_server/lib/src/handler/legacy/edit_organize_directives.dart
@@ -21,7 +21,10 @@
@override
Future<void> handle() async {
// TODO(brianwilkerson) Move analytics tracking out of [handleRequest].
- server.options.analytics?.sendEvent('edit', 'organizeDirectives');
+ unawaited(server.options.analytics?.sendEvent(
+ 'edit',
+ 'organizeDirectives',
+ ));
var params = EditOrganizeDirectivesParams.fromRequest(request);
var file = params.file;
diff --git a/pkg/analysis_server/lib/src/handler/legacy/search_find_element_references.dart b/pkg/analysis_server/lib/src/handler/legacy/search_find_element_references.dart
index ccdbbaf..a0bdfbb 100644
--- a/pkg/analysis_server/lib/src/handler/legacy/search_find_element_references.dart
+++ b/pkg/analysis_server/lib/src/handler/legacy/search_find_element_references.dart
@@ -25,8 +25,8 @@
var file = params.file;
// prepare element
var element = await server.getElementAtOffset(file, params.offset);
- if (element is ImportElement) {
- element = element.prefix;
+ if (element is ImportElement2) {
+ element = element.prefix?.element;
}
if (element is FieldFormalParameterElement) {
element = element.field;
diff --git a/pkg/analysis_server/lib/src/lsp/handlers/handler_completion.dart b/pkg/analysis_server/lib/src/lsp/handlers/handler_completion.dart
index 5cd9ec2..5d42f49 100644
--- a/pkg/analysis_server/lib/src/lsp/handlers/handler_completion.dart
+++ b/pkg/analysis_server/lib/src/lsp/handlers/handler_completion.dart
@@ -223,7 +223,7 @@
Map<String, Set<String>> _buildLookupOfImportedSymbols(
ResolvedUnitResult unit) {
final alreadyImportedSymbols = <String, Set<String>>{};
- final importElementList = unit.libraryElement.imports;
+ final importElementList = unit.libraryElement.imports2;
for (var import in importElementList) {
final importedLibrary = import.importedLibrary;
if (importedLibrary == null) continue;
diff --git a/pkg/analysis_server/lib/src/lsp/handlers/handler_execute_command.dart b/pkg/analysis_server/lib/src/lsp/handlers/handler_execute_command.dart
index e75e0f1..2454202 100644
--- a/pkg/analysis_server/lib/src/lsp/handlers/handler_execute_command.dart
+++ b/pkg/analysis_server/lib/src/lsp/handlers/handler_execute_command.dart
@@ -52,11 +52,11 @@
? ProgressReporter.serverCreated(server)
: ProgressReporter.noop;
- // To make parsing arguments easier in commands, instead of a
+ // To make passing arguments easier in commands, instead of a
// `List<Object?>` we now use `Map<String, Object?>`.
//
// However, some handlers still support the list for compatibility so we
- // must allow the to convert a `List` to a `Map`.
+ // must allow them to convert a `List` to a `Map`.
final arguments = params.arguments ?? const [];
Map<String, Object?> commandParams;
if (arguments.length == 1 && arguments[0] is Map<String, Object?>) {
diff --git a/pkg/analysis_server/lib/src/lsp/handlers/handler_references.dart b/pkg/analysis_server/lib/src/lsp/handlers/handler_references.dart
index 0f72ab1..07fd4ff 100644
--- a/pkg/analysis_server/lib/src/lsp/handlers/handler_references.dart
+++ b/pkg/analysis_server/lib/src/lsp/handlers/handler_references.dart
@@ -56,8 +56,8 @@
Future<ErrorOr<List<Location>?>> _getReferences(String path, int offset,
ReferenceParams params, ResolvedUnitResult unit) async {
var element = await server.getElementAtOffset(path, offset);
- if (element is ImportElement) {
- element = element.prefix;
+ if (element is ImportElement2) {
+ element = element.prefix?.element;
}
if (element is FieldFormalParameterElement) {
element = element.field;
diff --git a/pkg/analysis_server/lib/src/plugin/plugin_manager.dart b/pkg/analysis_server/lib/src/plugin/plugin_manager.dart
index 9c89392..df45853 100644
--- a/pkg/analysis_server/lib/src/plugin/plugin_manager.dart
+++ b/pkg/analysis_server/lib/src/plugin/plugin_manager.dart
@@ -343,12 +343,12 @@
_pluginMap[path] = plugin;
try {
var session = await plugin.start(byteStorePath, sdkPath);
- session?.onDone.then((_) {
+ unawaited(session?.onDone.then((_) {
if (_pluginMap[path] == plugin) {
_pluginMap.remove(path);
_notifyPluginsChanged();
}
- });
+ }));
} catch (exception, stackTrace) {
// Record the exception (for debugging purposes) and record the fact
// that we should not try to communicate with the plugin.
@@ -534,9 +534,9 @@
//
_pluginMap[path] = plugin;
var session = await plugin.start(byteStorePath, sdkPath);
- session?.onDone.then((_) {
+ unawaited(session?.onDone.then((_) {
_pluginMap.remove(path);
- });
+ }));
//
// Re-initialize the plugin.
//
@@ -993,7 +993,7 @@
name = result.name;
version = result.version;
if (!isCompatible) {
- sendRequest(PluginShutdownParams());
+ unawaited(sendRequest(PluginShutdownParams()));
info.reportException(CaughtException(
PluginException('Plugin is not compatible.'), StackTrace.current));
return false;
diff --git a/pkg/analysis_server/lib/src/server/dev_server.dart b/pkg/analysis_server/lib/src/server/dev_server.dart
index d59e2fa..863667e 100644
--- a/pkg/analysis_server/lib/src/server/dev_server.dart
+++ b/pkg/analysis_server/lib/src/server/dev_server.dart
@@ -129,14 +129,15 @@
}
});
- _channel.sendRequest(Request('${_nextId++}', 'server.setSubscriptions', {
+ await _channel
+ .sendRequest(Request('${_nextId++}', 'server.setSubscriptions', {
'subscriptions': ['STATUS'],
}));
directories =
directories.map((dir) => path.normalize(path.absolute(dir))).toList();
- _channel.sendRequest(Request(
+ await _channel.sendRequest(Request(
'${_nextId++}',
'analysis.setAnalysisRoots',
{'included': directories, 'excluded': []},
diff --git a/pkg/analysis_server/lib/src/server/driver.dart b/pkg/analysis_server/lib/src/server/driver.dart
index 7234c5b..f553451 100644
--- a/pkg/analysis_server/lib/src/server/driver.dart
+++ b/pkg/analysis_server/lib/src/server/driver.dart
@@ -428,7 +428,7 @@
}
await instrumentationService.shutdown();
- socketServer.analysisServer!.shutdown();
+ unawaited(socketServer.analysisServer!.shutdown());
try {
tempDriverDir.deleteSync(recursive: true);
@@ -454,7 +454,7 @@
httpServer.close();
}
await instrumentationService.shutdown();
- socketServer.analysisServer!.shutdown();
+ unawaited(socketServer.analysisServer!.shutdown());
if (sendPort == null) exit(0);
});
},
@@ -502,7 +502,7 @@
// Only shutdown the server and exit if the server is not already
// handling the shutdown.
if (!socketServer.analysisServer!.willExit) {
- socketServer.analysisServer!.shutdown();
+ unawaited(socketServer.analysisServer!.shutdown());
exit(0);
}
});
diff --git a/pkg/analysis_server/lib/src/server/http_server.dart b/pkg/analysis_server/lib/src/server/http_server.dart
index 9826d89..eb8835a 100644
--- a/pkg/analysis_server/lib/src/server/http_server.dart
+++ b/pkg/analysis_server/lib/src/server/http_server.dart
@@ -2,6 +2,7 @@
// 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 'dart:async';
import 'dart:io';
import 'package:analysis_server/src/socket_server.dart';
@@ -102,7 +103,7 @@
response.headers.contentType = ContentType.text;
response.write(
'WebSocket connections not supported (${request.uri.path}).');
- response.close();
+ unawaited(response.close());
} else {
_returnUnknownRequest(request);
}
diff --git a/pkg/analysis_server/lib/src/services/completion/dart/imported_reference_contributor.dart b/pkg/analysis_server/lib/src/services/completion/dart/imported_reference_contributor.dart
index 56c5db2..1296ec4 100644
--- a/pkg/analysis_server/lib/src/services/completion/dart/imported_reference_contributor.dart
+++ b/pkg/analysis_server/lib/src/services/completion/dart/imported_reference_contributor.dart
@@ -18,14 +18,14 @@
}
// Traverse imports including dart:core
- var imports = request.libraryElement.imports;
+ var imports = request.libraryElement.imports2;
for (var importElement in imports) {
var libraryElement = importElement.importedLibrary;
if (libraryElement != null) {
_buildSuggestions(
libraryElement: libraryElement,
namespace: importElement.namespace,
- prefix: importElement.prefix?.name,
+ prefix: importElement.prefix?.element.name,
);
if (libraryElement.isDartCore &&
request.opType.includeTypeNameSuggestions) {
diff --git a/pkg/analysis_server/lib/src/services/completion/dart/library_member_contributor.dart b/pkg/analysis_server/lib/src/services/completion/dart/library_member_contributor.dart
index 86e8275..2aced27 100644
--- a/pkg/analysis_server/lib/src/services/completion/dart/library_member_contributor.dart
+++ b/pkg/analysis_server/lib/src/services/completion/dart/library_member_contributor.dart
@@ -22,18 +22,18 @@
if (targetId is SimpleIdentifier && !request.target.isCascade) {
var elem = targetId.staticElement;
if (elem is PrefixElement && !elem.isSynthetic) {
- var imports = request.libraryElement.imports;
+ var imports = request.libraryElement.imports2;
_buildSuggestions(elem, imports);
}
}
}
- void _buildSuggestions(PrefixElement elem, List<ImportElement> imports) {
+ void _buildSuggestions(PrefixElement elem, List<ImportElement2> imports) {
var parent = request.target.containingNode.parent;
var typesOnly = parent is NamedType;
var isConstructor = parent?.parent is ConstructorName;
for (var importElem in imports) {
- if (importElem.prefix?.name == elem.name) {
+ if (importElem.prefix?.element.name == elem.name) {
var library = importElem.importedLibrary;
if (library != null) {
builder.libraryUriStr = library.source.uri.toString();
@@ -65,7 +65,7 @@
}
}
// If the import is `deferred` then suggest `loadLibrary`.
- if (!typesOnly && importElem.isDeferred) {
+ if (!typesOnly && importElem.prefix is DeferredImportElementPrefix) {
builder.suggestLoadLibraryFunction(library.loadLibraryFunction);
}
builder.libraryUriStr = null;
diff --git a/pkg/analysis_server/lib/src/services/completion/dart/library_prefix_contributor.dart b/pkg/analysis_server/lib/src/services/completion/dart/library_prefix_contributor.dart
index 553c1ec..4e025b9 100644
--- a/pkg/analysis_server/lib/src/services/completion/dart/library_prefix_contributor.dart
+++ b/pkg/analysis_server/lib/src/services/completion/dart/library_prefix_contributor.dart
@@ -15,9 +15,9 @@
return;
}
- var imports = request.libraryElement.imports;
+ var imports = request.libraryElement.imports2;
for (var element in imports) {
- var prefix = element.prefix?.name;
+ var prefix = element.prefix?.element.name;
if (prefix != null && prefix.isNotEmpty) {
var libraryElement = element.importedLibrary;
if (libraryElement != null) {
diff --git a/pkg/analysis_server/lib/src/services/completion/dart/not_imported_contributor.dart b/pkg/analysis_server/lib/src/services/completion/dart/not_imported_contributor.dart
index 9949e2b..39c8edd 100644
--- a/pkg/analysis_server/lib/src/services/completion/dart/not_imported_contributor.dart
+++ b/pkg/analysis_server/lib/src/services/completion/dart/not_imported_contributor.dart
@@ -46,7 +46,7 @@
}
var importedLibraries = Set<LibraryElement>.identity();
- for (var import in request.libraryElement.imports) {
+ for (var import in request.libraryElement.imports2) {
var importedLibrary = import.importedLibrary;
if (importedLibrary != null) {
if (import.combinators.isEmpty) {
diff --git a/pkg/analysis_server/lib/src/services/correction/dart/change_to.dart b/pkg/analysis_server/lib/src/services/correction/dart/change_to.dart
index 67c2ff4..eb77c8c 100644
--- a/pkg/analysis_server/lib/src/services/correction/dart/change_to.dart
+++ b/pkg/analysis_server/lib/src/services/correction/dart/change_to.dart
@@ -112,8 +112,8 @@
}
}
// Check elements from imports.
- for (var importElement in resolvedResult.libraryElement.imports) {
- if (importElement.prefix?.name == prefixName) {
+ for (var importElement in resolvedResult.libraryElement.imports2) {
+ if (importElement.prefix?.element.name == prefixName) {
var namespace = getImportNamespace(importElement);
finder._updateList(namespace.values);
}
@@ -220,8 +220,8 @@
}
}
// Check unprefixed imports.
- for (var importElement in resolvedResult.libraryElement.imports) {
- if (importElement.prefix?.name == prefixName) {
+ for (var importElement in resolvedResult.libraryElement.imports2) {
+ if (importElement.prefix?.element.name == prefixName) {
var namespace = getImportNamespace(importElement);
finder._updateList(namespace.values);
}
diff --git a/pkg/analysis_server/lib/src/services/correction/dart/create_class.dart b/pkg/analysis_server/lib/src/services/correction/dart/create_class.dart
index 00cbb7d..1107023 100644
--- a/pkg/analysis_server/lib/src/services/correction/dart/create_class.dart
+++ b/pkg/analysis_server/lib/src/services/correction/dart/create_class.dart
@@ -72,8 +72,9 @@
filePath = file;
prefix = '$eol$eol';
} else {
- for (var import in libraryElement.imports) {
- if (prefixElement is PrefixElement && import.prefix == prefixElement) {
+ for (var import in libraryElement.imports2) {
+ if (prefixElement is PrefixElement &&
+ import.prefix?.element == prefixElement) {
var library = import.importedLibrary;
if (library != null) {
targetUnit = library.definingCompilationUnit;
diff --git a/pkg/analysis_server/lib/src/services/correction/dart/create_mixin.dart b/pkg/analysis_server/lib/src/services/correction/dart/create_mixin.dart
index 01698d0..d66cd28 100644
--- a/pkg/analysis_server/lib/src/services/correction/dart/create_mixin.dart
+++ b/pkg/analysis_server/lib/src/services/correction/dart/create_mixin.dart
@@ -69,8 +69,9 @@
filePath = file;
prefix = '$eol$eol';
} else {
- for (var import in libraryElement.imports) {
- if (prefixElement is PrefixElement && import.prefix == prefixElement) {
+ for (var import in libraryElement.imports2) {
+ if (prefixElement is PrefixElement &&
+ import.prefix?.element == prefixElement) {
var library = import.importedLibrary;
if (library != null) {
targetUnit = library.definingCompilationUnit;
diff --git a/pkg/analysis_server/lib/src/services/correction/dart/data_driven.dart b/pkg/analysis_server/lib/src/services/correction/dart/data_driven.dart
index ba96a6c..41ed6d7 100644
--- a/pkg/analysis_server/lib/src/services/correction/dart/data_driven.dart
+++ b/pkg/analysis_server/lib/src/services/correction/dart/data_driven.dart
@@ -10,7 +10,8 @@
import 'package:analysis_server/src/services/correction/fix/data_driven/transform.dart';
import 'package:analysis_server/src/services/correction/fix/data_driven/transform_set.dart';
import 'package:analysis_server/src/services/correction/fix/data_driven/transform_set_manager.dart';
-import 'package:analyzer/dart/element/element.dart' show LibraryElement;
+import 'package:analyzer/dart/element/element.dart'
+ show DirectiveUriWithRelativeUri, LibraryElement;
import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
import 'package:meta/meta.dart';
@@ -24,13 +25,13 @@
Stream<CorrectionProducer> get producers async* {
var importedUris = <Uri>[];
var library = resolvedResult.libraryElement;
- for (var importElement in library.imports) {
+ for (var importElement in library.imports2) {
// TODO(brianwilkerson) Filter based on combinators to help avoid making
// invalid suggestions.
var uri = importElement.uri;
- if (uri != null) {
+ if (uri is DirectiveUriWithRelativeUri) {
// The [uri] is `null` if the literal string is not a valid URI.
- importedUris.add(Uri.parse(uri));
+ importedUris.add(uri.relativeUri);
}
}
var matchers = ElementMatcher.matchersForNode(node);
diff --git a/pkg/analysis_server/lib/src/services/correction/dart/import_add_show.dart b/pkg/analysis_server/lib/src/services/correction/dart/import_add_show.dart
index 20fa0ec..c2d0ee8 100644
--- a/pkg/analysis_server/lib/src/services/correction/dart/import_add_show.dart
+++ b/pkg/analysis_server/lib/src/services/correction/dart/import_add_show.dart
@@ -30,7 +30,7 @@
return;
}
// prepare whole import namespace
- var importElement = importDirective.element;
+ var importElement = importDirective.element2;
if (importElement == null) {
return;
}
diff --git a/pkg/analysis_server/lib/src/services/correction/dart/import_library.dart b/pkg/analysis_server/lib/src/services/correction/dart/import_library.dart
index e6b8f80..ab3f3b4 100644
--- a/pkg/analysis_server/lib/src/services/correction/dart/import_library.dart
+++ b/pkg/analysis_server/lib/src/services/correction/dart/import_library.dart
@@ -164,7 +164,7 @@
// is, then we can check the extension elements without needing to perform
// additional analysis.
var foundImport = false;
- for (var imp in libraryElement.imports) {
+ for (var imp in libraryElement.imports2) {
// prepare element
var importedLibrary = imp.importedLibrary;
if (importedLibrary == null || importedLibrary != libraryToImport) {
@@ -244,7 +244,7 @@
// may be there is an existing import,
// but it is with prefix and we don't use this prefix
var alreadyImportedWithPrefix = <LibraryElement>{};
- for (var imp in libraryElement.imports) {
+ for (var imp in libraryElement.imports2) {
// prepare element
var libraryElement = imp.importedLibrary;
if (libraryElement == null) {
@@ -261,7 +261,7 @@
continue;
}
// may be apply prefix
- var prefix = imp.prefix;
+ var prefix = imp.prefix?.element;
if (prefix != null) {
yield _ImportLibraryPrefix(libraryElement, prefix);
continue;
diff --git a/pkg/analysis_server/lib/src/services/correction/error_fix_status.yaml b/pkg/analysis_server/lib/src/services/correction/error_fix_status.yaml
index b1fe5b7..3549471 100644
--- a/pkg/analysis_server/lib/src/services/correction/error_fix_status.yaml
+++ b/pkg/analysis_server/lib/src/services/correction/error_fix_status.yaml
@@ -1628,6 +1628,8 @@
status: needsEvaluation
LintCode.close_sinks:
status: needsEvaluation
+LintCode.combinators_ordering:
+ status: needsEvaluation
LintCode.comment_references:
status: needsEvaluation
LintCode.conditional_uri_does_not_exist:
diff --git a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_matcher.dart b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_matcher.dart
index 0c23da3..f87525e 100644
--- a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_matcher.dart
+++ b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/element_matcher.dart
@@ -122,7 +122,7 @@
if (library == null) {
return null;
}
- for (var importElement in library.imports) {
+ for (var importElement in library.imports2) {
// TODO(brianwilkerson) Filter based on combinators to help avoid making
// invalid suggestions.
var uri = importElement.importedLibrary?.source.uri;
diff --git a/pkg/analysis_server/lib/src/services/correction/namespace.dart b/pkg/analysis_server/lib/src/services/correction/namespace.dart
index affc53d..c97452d 100644
--- a/pkg/analysis_server/lib/src/services/correction/namespace.dart
+++ b/pkg/analysis_server/lib/src/services/correction/namespace.dart
@@ -14,13 +14,13 @@
return _getExportNamespaceForLibrary(library)[name];
}
-/// Return the [ImportElement] that is referenced by [prefixNode], or `null` if
+/// Return the [ImportElement2] that is referenced by [prefixNode], or `null` if
/// the node does not reference a prefix or if we cannot determine which import
/// is being referenced.
-ImportElement? getImportElement(SimpleIdentifier prefixNode) {
+ImportElement2? getImportElement(SimpleIdentifier prefixNode) {
var parent = prefixNode.parent;
if (parent is ImportDirective) {
- return parent.element;
+ return parent.element2;
}
return _getImportElementInfo(prefixNode);
}
@@ -31,27 +31,27 @@
return namespace.definedNames;
}
-/// Return the [ImportElement] that declared [prefix] and imports [element].
+/// Return the [ImportElement2] that declared [prefix] and imports [element].
///
/// [libraryElement] - the [LibraryElement] where reference is.
/// [prefix] - the import prefix, maybe `null`.
/// [element] - the referenced element.
-/// [importElementsMap] - the cache of [Element]s imported by [ImportElement]s.
-ImportElement? _getImportElement(LibraryElement libraryElement, String prefix,
- Element element, Map<ImportElement, Set<Element>> importElementsMap) {
+/// [importElementsMap] - the cache of [Element]s imported by [ImportElement2]s.
+ImportElement2? _getImportElement(LibraryElement libraryElement, String prefix,
+ Element element, Map<ImportElement2, Set<Element>> importElementsMap) {
if (element.enclosingElement is! CompilationUnitElement) {
return null;
}
var usedLibrary = element.library;
// find ImportElement that imports used library with used prefix
- List<ImportElement>? candidates;
- for (var importElement in libraryElement.imports) {
+ List<ImportElement2>? candidates;
+ for (var importElement in libraryElement.imports2) {
// required library
if (importElement.importedLibrary != usedLibrary) {
continue;
}
// required prefix
- var prefixElement = importElement.prefix;
+ var prefixElement = importElement.prefix?.element;
if (prefixElement == null) {
continue;
}
@@ -95,9 +95,9 @@
return null;
}
-/// Returns the [ImportElement] that is referenced by [prefixNode] with a
+/// Returns the [ImportElement2] that is referenced by [prefixNode] with a
/// [PrefixElement], maybe `null`.
-ImportElement? _getImportElementInfo(SimpleIdentifier prefixNode) {
+ImportElement2? _getImportElementInfo(SimpleIdentifier prefixNode) {
// prepare environment
var parent = prefixNode.parent;
var unit = prefixNode.thisOrAncestorOfType<CompilationUnit>();
@@ -124,7 +124,7 @@
}
// find ImportElement
var prefix = prefixNode.name;
- var importElementsMap = <ImportElement, Set<Element>>{};
+ var importElementsMap = <ImportElement2, Set<Element>>{};
return _getImportElement(
libraryElement, prefix, usedElement, importElementsMap);
}
diff --git a/pkg/analysis_server/lib/src/services/correction/util.dart b/pkg/analysis_server/lib/src/services/correction/util.dart
index 3c1c745..603fb4e 100644
--- a/pkg/analysis_server/lib/src/services/correction/util.dart
+++ b/pkg/analysis_server/lib/src/services/correction/util.dart
@@ -326,8 +326,8 @@
return Precedence.none;
}
-/// Returns the namespace of the given [ImportElement].
-Map<String, Element> getImportNamespace(ImportElement imp) {
+/// Returns the namespace of the given [ImportElement2].
+Map<String, Element> getImportNamespace(ImportElement2 imp) {
return imp.namespace.definedNames;
}
@@ -1215,8 +1215,8 @@
/// Return the import element used to import given [element] into the library.
/// May be `null` if was not imported, i.e. declared in the same library.
- ImportElement? _getImportElement(Element element) {
- for (var imp in _library.imports) {
+ ImportElement2? _getImportElement(Element element) {
+ for (var imp in _library.imports2) {
var definedNames = getImportNamespace(imp);
if (definedNames.containsValue(element)) {
return imp;
@@ -1270,7 +1270,7 @@
// ensure import
var importElement = _getImportElement(element);
if (importElement != null) {
- var prefix = importElement.prefix;
+ var prefix = importElement.prefix?.element;
if (prefix != null) {
sb.write(prefix.displayName);
sb.write('.');
diff --git a/pkg/analysis_server/lib/src/services/refactoring/refactoring.dart b/pkg/analysis_server/lib/src/services/refactoring/refactoring.dart
index 7d76a4a..76dd47b 100644
--- a/pkg/analysis_server/lib/src/services/refactoring/refactoring.dart
+++ b/pkg/analysis_server/lib/src/services/refactoring/refactoring.dart
@@ -413,7 +413,7 @@
if (element is ConstructorElement) {
return RenameConstructorRefactoringImpl(workspace, session, element);
}
- if (element is ImportElement) {
+ if (element is ImportElement2) {
return RenameImportRefactoringImpl(workspace, session, element);
}
if (element is LabelElement) {
@@ -452,7 +452,7 @@
}
// Use the prefix offset/length when renaming an import directive.
- if (node is ImportDirective && element is ImportElement) {
+ if (node is ImportDirective && element is ImportElement2) {
var prefix = node.prefix;
if (prefix != null) {
offset = prefix.offset;
diff --git a/pkg/analysis_server/lib/src/services/refactoring/rename.dart b/pkg/analysis_server/lib/src/services/refactoring/rename.dart
index 7f93bf1..66c74f0 100644
--- a/pkg/analysis_server/lib/src/services/refactoring/rename.dart
+++ b/pkg/analysis_server/lib/src/services/refactoring/rename.dart
@@ -114,8 +114,8 @@
static String _getOldName(Element element) {
if (element is ConstructorElement) {
return element.name;
- } else if (element is ImportElement) {
- var prefix = element.prefix;
+ } else if (element is ImportElement2) {
+ var prefix = element.prefix?.element;
if (prefix != null) {
return prefix.displayName;
}
diff --git a/pkg/analysis_server/lib/src/services/refactoring/rename_import.dart b/pkg/analysis_server/lib/src/services/refactoring/rename_import.dart
index 2a0bf1f..94f6500 100644
--- a/pkg/analysis_server/lib/src/services/refactoring/rename_import.dart
+++ b/pkg/analysis_server/lib/src/services/refactoring/rename_import.dart
@@ -16,16 +16,16 @@
import 'package:analyzer/src/generated/source.dart';
import 'package:analyzer_plugin/utilities/range_factory.dart';
-/// A [Refactoring] for renaming [ImportElement]s.
+/// A [Refactoring] for renaming [ImportElement2]s.
class RenameImportRefactoringImpl extends RenameRefactoringImpl {
final AnalysisSession session;
RenameImportRefactoringImpl(
- RefactoringWorkspace workspace, this.session, ImportElement element)
+ RefactoringWorkspace workspace, this.session, ImportElement2 element)
: super(workspace, element);
@override
- ImportElement get element => super.element as ImportElement;
+ ImportElement2 get element => super.element as ImportElement2;
@override
String get refactoringName {
@@ -49,32 +49,28 @@
Future<void> fillChange() async {
// update declaration
{
- var prefix = element.prefix;
+ final node = await _findNode();
+ if (node == null) {
+ return;
+ }
+
+ final prefixNode = node.prefix;
SourceEdit? edit;
if (newName.isEmpty) {
// We should not get `prefix == null` because we check in
// `checkNewName` that the new name is different.
- if (prefix == null) {
- return;
- }
- var node = await _findNode();
- if (node != null) {
+ if (prefixNode != null) {
var uriEnd = node.uri.end;
- var prefixEnd = prefix.nameOffset + prefix.nameLength;
+ var prefixEnd = prefixNode.end;
edit = newSourceEdit_range(
range.startOffsetEndOffset(uriEnd, prefixEnd), '');
}
} else {
- if (prefix == null) {
- var node = await _findNode();
- if (node != null) {
- var uriEnd = node.uri.end;
- edit = newSourceEdit_range(SourceRange(uriEnd, 0), ' as $newName');
- }
+ if (prefixNode == null) {
+ var uriEnd = node.uri.end;
+ edit = newSourceEdit_range(SourceRange(uriEnd, 0), ' as $newName');
} else {
- var offset = prefix.nameOffset;
- var length = prefix.nameLength;
- edit = newSourceEdit_range(SourceRange(offset, length), newName);
+ edit = newSourceEdit_range(range.node(prefixNode), newName);
}
}
if (edit != null) {
@@ -111,7 +107,7 @@
return null;
}
var unit = unitResult.unit;
- var index = library.imports.indexOf(element);
+ var index = library.imports2.indexOf(element);
return unit.directives.whereType<ImportDirective>().elementAt(index);
}
diff --git a/pkg/analysis_server/lib/src/services/refactoring/rename_unit_member.dart b/pkg/analysis_server/lib/src/services/refactoring/rename_unit_member.dart
index 0479329..4f25f31 100644
--- a/pkg/analysis_server/lib/src/services/refactoring/rename_unit_member.dart
+++ b/pkg/analysis_server/lib/src/services/refactoring/rename_unit_member.dart
@@ -183,7 +183,7 @@
return true;
}
// check imports
- for (var importElement in atLibrary.imports) {
+ for (var importElement in atLibrary.imports2) {
// ignore if imported with prefix
if (importElement.prefix != null) {
continue;
diff --git a/pkg/analysis_server/lib/src/services/search/search_engine.dart b/pkg/analysis_server/lib/src/services/search/search_engine.dart
index 09df9a4..0b88104 100644
--- a/pkg/analysis_server/lib/src/services/search/search_engine.dart
+++ b/pkg/analysis_server/lib/src/services/search/search_engine.dart
@@ -87,9 +87,7 @@
/// Instances of the class [SearchMatch] represent a match found by
/// [SearchEngine].
abstract class SearchMatch {
- /// Return the [Element] containing the match. Can return `null` if the unit
- /// does not exist, or its element was invalidated, or the element cannot be
- /// found, etc.
+ /// Return the [Element] containing the match.
Element get element;
/// The absolute path of the file containing the match.
diff --git a/pkg/analysis_server/lib/src/status/ast_writer.dart b/pkg/analysis_server/lib/src/status/ast_writer.dart
index b9f610a..b98c3d6 100644
--- a/pkg/analysis_server/lib/src/status/ast_writer.dart
+++ b/pkg/analysis_server/lib/src/status/ast_writer.dart
@@ -87,7 +87,7 @@
} else if (node is GenericFunctionType) {
properties['type'] = node.type;
} else if (node is ImportDirective) {
- properties['element'] = node.element;
+ properties['element'] = node.element2;
properties['selectedSource'] = node.selectedSource;
properties['uriSource'] = node.uriSource;
} else if (node is IndexExpression) {
diff --git a/pkg/analysis_server/lib/src/status/element_writer.dart b/pkg/analysis_server/lib/src/status/element_writer.dart
index bc09cd5..560fc23 100644
--- a/pkg/analysis_server/lib/src/status/element_writer.dart
+++ b/pkg/analysis_server/lib/src/status/element_writer.dart
@@ -99,9 +99,9 @@
properties['returnType'] = element.returnType;
properties['type'] = element.type;
}
- if (element is ImportElement) {
+ if (element is ImportElement2) {
properties['combinators'] = element.combinators;
- properties['isDeferred'] = element.isDeferred;
+ properties['isDeferred'] = element.prefix is DeferredImportElementPrefix;
properties['library'] = element.library;
}
if (element is LibraryElement) {
diff --git a/pkg/analysis_server/lib/src/status/pages.dart b/pkg/analysis_server/lib/src/status/pages.dart
index 66538d6..130a190 100644
--- a/pkg/analysis_server/lib/src/status/pages.dart
+++ b/pkg/analysis_server/lib/src/status/pages.dart
@@ -2,6 +2,7 @@
// 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 'dart:async';
import 'dart:convert';
import 'dart:io';
@@ -192,7 +193,7 @@
var path = request.uri.path;
if (path == '/') {
- respondRedirect(request, pages.first.path);
+ unawaited(respondRedirect(request, pages.first.path));
return;
}
@@ -201,7 +202,7 @@
var response = request.response;
response.headers.contentType = ContentType.html;
response.write(await page.generate(request.uri.queryParameters));
- response.close();
+ unawaited(response.close());
return;
}
}
@@ -216,7 +217,7 @@
response.statusCode = HttpStatus.internalServerError;
response.headers.contentType = ContentType.text;
response.write('$e\n\n$st');
- response.close();
+ unawaited(response.close());
}
}
}
diff --git a/pkg/analysis_server/test/analysis/notification_errors_test.dart b/pkg/analysis_server/test/analysis/notification_errors_test.dart
index 4c93ced..fcec6cf 100644
--- a/pkg/analysis_server/test/analysis/notification_errors_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_errors_test.dart
@@ -339,7 +339,6 @@
expect(error.location.file, testFile.path);
expect(error.severity, AnalysisErrorSeverity.INFO);
expect(error.type, AnalysisErrorType.LINT);
- expect(error.message, lint.description);
}
Future<void> test_notInAnalysisRoot() async {
diff --git a/pkg/analysis_server/test/completion_test_support.dart b/pkg/analysis_server/test/completion_test_support.dart
index cdf6b9b..a0ebd67 100644
--- a/pkg/analysis_server/test/completion_test_support.dart
+++ b/pkg/analysis_server/test/completion_test_support.dart
@@ -79,7 +79,8 @@
.toList();
}
- Future runTest(LocationSpec spec, [Map<String, String>? extraFiles]) async {
+ Future<void> runTest(LocationSpec spec,
+ [Map<String, String>? extraFiles]) async {
await super.setUp();
try {
@@ -102,7 +103,7 @@
assertHasNoCompletion(result);
}
} finally {
- super.tearDown();
+ await super.tearDown();
}
}
}
diff --git a/pkg/analysis_server/test/domain_analysis_test.dart b/pkg/analysis_server/test/domain_analysis_test.dart
index b3f9c9b..1c94ed1 100644
--- a/pkg/analysis_server/test/domain_analysis_test.dart
+++ b/pkg/analysis_server/test/domain_analysis_test.dart
@@ -1458,7 +1458,7 @@
/// Repeat a few times, eventually there will be no work to do.
Future<void> _waitAnalysisComplete() async {
for (var i = 0; i < 128; i++) {
- pumpEventQueue();
+ await pumpEventQueue();
await server.onAnalysisComplete;
}
}
diff --git a/pkg/analysis_server/test/domain_execution_test.dart b/pkg/analysis_server/test/domain_execution_test.dart
index a9f288c..8532002 100644
--- a/pkg/analysis_server/test/domain_execution_test.dart
+++ b/pkg/analysis_server/test/domain_execution_test.dart
@@ -130,7 +130,7 @@
@override
Future<void> tearDown() async {
await _disposeExecutionContext();
- super.tearDown();
+ await super.tearDown();
}
Future<void> test_createAndDeleteMultipleContexts() async {
diff --git a/pkg/analysis_server/test/edit/refactoring_test.dart b/pkg/analysis_server/test/edit/refactoring_test.dart
index f90d1e6..e397c48 100644
--- a/pkg/analysis_server/test/edit/refactoring_test.dart
+++ b/pkg/analysis_server/test/edit/refactoring_test.dart
@@ -2,6 +2,8 @@
// 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 'dart:async';
+
import 'package:analysis_server/protocol/protocol.dart';
import 'package:analysis_server/protocol/protocol_generated.dart';
import 'package:analysis_server/src/services/refactoring/refactoring_manager.dart';
@@ -877,8 +879,7 @@
var request =
EditGetAvailableRefactoringsParams(testFile.path, offset, length)
.toRequest('0');
- serverChannel.sendRequest(request);
- var response = await serverChannel.waitForResponse(request);
+ var response = await serverChannel.sendRequest(request);
var result = EditGetAvailableRefactoringsResult.fromResponse(response);
kinds = result.kinds;
}
@@ -2250,7 +2251,8 @@
print(otherName);
}
''');
- server.getAnalysisDriver(testFile.path)!.getResult(testFile.path);
+ unawaited(
+ server.getAnalysisDriver(testFile.path)!.getResult(testFile.path));
// send the second request, with the same kind, file and offset
await waitForTasksFinished();
result = await getRefactoringResult(() {
diff --git a/pkg/analysis_server/test/integration/analysis/update_content_list_test.dart b/pkg/analysis_server/test/integration/analysis/update_content_list_test.dart
index b41a1df..1b7f70e 100644
--- a/pkg/analysis_server/test/integration/analysis/update_content_list_test.dart
+++ b/pkg/analysis_server/test/integration/analysis/update_content_list_test.dart
@@ -27,6 +27,7 @@
// Create a dummy file
writeFile(pathname, '// dummy text');
await standardAnalysisSetup();
+ await analysisFinished;
// Override file contents with badText.
await sendAnalysisUpdateContent({pathname: AddContentOverlay(badText)});
await analysisFinished;
diff --git a/pkg/analysis_server/test/lsp/definition_test.dart b/pkg/analysis_server/test/lsp/definition_test.dart
index 1577e53..8c6c351 100644
--- a/pkg/analysis_server/test/lsp/definition_test.dart
+++ b/pkg/analysis_server/test/lsp/definition_test.dart
@@ -173,6 +173,17 @@
await testContents(contents);
}
+ Future<void> test_fieldFormalParam() async {
+ final contents = '''
+class A {
+ final String [[a]];
+ A(this.^a});
+}
+''';
+
+ await testContents(contents);
+ }
+
Future<void> test_fromPlugins() async {
final pluginAnalyzedFilePath = join(projectFolderPath, 'lib', 'foo.foo');
final pluginAnalyzedFileUri = Uri.file(pluginAnalyzedFilePath);
@@ -402,6 +413,19 @@
await testContents(contents);
}
+ Future<void> test_superFormalParam() async {
+ final contents = '''
+class A {
+ A({required int [[a]]});
+}
+class B extends A {
+ B({required super.^a}) : assert(a > 0);
+}
+''';
+
+ await testContents(contents);
+ }
+
Future<void> test_type() async {
final contents = '''
f() {
diff --git a/pkg/analysis_server/test/services/completion/dart/completion_manager_test.dart b/pkg/analysis_server/test/services/completion/dart/completion_manager_test.dart
index fb80d3e..62bd4a5 100644
--- a/pkg/analysis_server/test/services/completion/dart/completion_manager_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/completion_manager_test.dart
@@ -59,10 +59,10 @@
var directives = resolvedUnit.unit.directives;
- var imports = request.libraryElement.imports;
+ var imports = request.libraryElement.imports2;
expect(imports, hasLength(directives.length + 1));
- ImportElement importNamed(String expectedUri) {
+ ImportElement2 importNamed(String expectedUri) {
var uriList = <String>[];
for (var importElement in imports) {
var uri = importElement.importedLibrary!.source.uri.toString();
diff --git a/pkg/analysis_server/test/services/completion/dart/location/field_formal_parameter_test.dart b/pkg/analysis_server/test/services/completion/dart/location/field_formal_parameter_test.dart
index 68b4c68..556b765 100644
--- a/pkg/analysis_server/test/services/completion/dart/location/field_formal_parameter_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/location/field_formal_parameter_test.dart
@@ -31,7 +31,7 @@
mixin SuperFormalParameterTestCases on AbstractCompletionDriverTest {
Future<void> test_class_replacement_left() async {
- _checkContainers(
+ await _checkContainers(
declarations: 'var field = 0;',
constructorParameters: 'this.f^',
validator: (response) {
@@ -48,7 +48,7 @@
}
Future<void> test_class_replacement_right() async {
- _checkContainers(
+ await _checkContainers(
declarations: 'var field = 0;',
constructorParameters: 'this.^f',
validator: (response) {
@@ -105,7 +105,7 @@
}
Future<void> test_class_suggestions_onlyNotSpecified_optionalNamed() async {
- _checkContainers(
+ await _checkContainers(
declarations: 'final int x; final int y;',
constructorParameters: '{this.x, this.^}',
validator: (response) {
@@ -123,7 +123,7 @@
Future<void>
test_class_suggestions_onlyNotSpecified_requiredPositional() async {
- _checkContainers(
+ await _checkContainers(
declarations: 'final int x; final int y;',
constructorParameters: 'this.x, this.^',
validator: (response) {
diff --git a/pkg/analysis_server/test/services/refactoring/rename_import_test.dart b/pkg/analysis_server/test/services/refactoring/rename_import_test.dart
index 8ad640e..d8a7f3c 100644
--- a/pkg/analysis_server/test/services/refactoring/rename_import_test.dart
+++ b/pkg/analysis_server/test/services/refactoring/rename_import_test.dart
@@ -236,6 +236,6 @@
void _createRefactoring(String search) {
var directive = findNode.import(search);
- createRenameRefactoringForElement(directive.element);
+ createRenameRefactoringForElement(directive.element2);
}
}
diff --git a/pkg/analysis_server/test/src/computer/call_hierarchy_computer_test.dart b/pkg/analysis_server/test/src/computer/call_hierarchy_computer_test.dart
new file mode 100644
index 0000000..6bc39cc
--- /dev/null
+++ b/pkg/analysis_server/test/src/computer/call_hierarchy_computer_test.dart
@@ -0,0 +1,1312 @@
+// Copyright (c) 2022, 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:analysis_server/src/computer/computer_call_hierarchy.dart';
+import 'package:analysis_server/src/services/search/search_engine.dart';
+import 'package:analysis_server/src/services/search/search_engine_internal.dart';
+import 'package:analyzer/dart/analysis/results.dart';
+import 'package:analyzer/source/source_range.dart';
+import 'package:test/test.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../../abstract_single_unit.dart';
+
+void main() {
+ defineReflectiveSuite(() {
+ defineReflectiveTests(CallHierarchyComputerFindTargetTest);
+ defineReflectiveTests(CallHierarchyComputerIncomingCallsTest);
+ defineReflectiveTests(CallHierarchyComputerOutgoingCallsTest);
+ });
+}
+
+/// Matches a [CallHierarchyItem] with the given name/kind/file.
+Matcher _isItem(CallHierarchyKind kind, String displayName, String file,
+ SourceRange range) =>
+ TypeMatcher<CallHierarchyItem>()
+ .having((e) => e.kind, 'kind', kind)
+ .having((e) => e.displayName, 'displayName', displayName)
+ .having((e) => e.file, 'file', file)
+ .having((e) => e.range, 'range', range);
+
+/// Matches a [CallHierarchyCalls] result with the given element/ranges.
+Matcher _isResult(
+ CallHierarchyKind kind,
+ String displayName,
+ String file,
+ SourceRange range, {
+ List<SourceRange>? ranges,
+}) {
+ var matcher = TypeMatcher<CallHierarchyCalls>()
+ .having((c) => c.item, 'item', _isItem(kind, displayName, file, range));
+
+ if (ranges != null) {
+ matcher = matcher.having((c) => c.ranges, 'ranges', ranges);
+ }
+
+ return matcher;
+}
+
+abstract class AbstractCallHierarchyTest extends AbstractSingleUnitTest {
+ final startOfFile = SourceRange(0, 0);
+
+ // Gets the expected range that follows the string [prefix] in [code] with a
+ // length of [match.length].
+ SourceRange rangeAfterPrefix(String prefix, String code, String match) =>
+ SourceRange(
+ withoutMarkers(code).indexOf(prefix) + prefix.length, match.length);
+
+ // Gets the expected range that starts at [search] in [code] with a
+ // length of [match.length].
+ SourceRange rangeAtSearch(String search, String code, [String? match]) {
+ final index = withoutMarkers(code).indexOf(search);
+ expect(index, greaterThanOrEqualTo(0));
+ return SourceRange(index, (match ?? search).length);
+ }
+
+ String withoutMarkers(String code) => code.replaceAll('^', '');
+}
+
+@reflectiveTest
+class CallHierarchyComputerFindTargetTest extends AbstractCallHierarchyTest {
+ late String otherFile;
+
+ Future<void> expectNoTarget(String content) async {
+ await expectTarget(content, isNull);
+ }
+
+ Future<void> expectTarget(String content, Matcher matcher) async {
+ final target = await findTarget(content);
+ expect(target, matcher);
+ }
+
+ Future<CallHierarchyItem?> findTarget(String code) async {
+ final marker = code.indexOf('^');
+ expect(marker, greaterThanOrEqualTo(0));
+ addTestSource(withoutMarkers(code));
+ final result =
+ await (await session).getResolvedUnit(testFile) as ResolvedUnitResult;
+
+ return DartCallHierarchyComputer(result).findTarget(marker);
+ }
+
+ @override
+ void setUp() {
+ super.setUp();
+ otherFile = convertPath('$testPackageLibPath/other.dart');
+ }
+
+ Future<void> test_args() async {
+ await expectNoTarget('main(int ^a) {}');
+ }
+
+ Future<void> test_block() async {
+ await expectNoTarget('f() {^}');
+ }
+
+ Future<void> test_comment() async {
+ await expectNoTarget('f() {} // this is a ^comment');
+ }
+
+ Future<void> test_constructor() async {
+ final contents = '''
+class Foo {
+ Fo^o(String a) {}
+}
+ ''';
+
+ final target = await findTarget(contents);
+ expect(
+ target,
+ _isItem(
+ CallHierarchyKind.constructor,
+ 'Foo',
+ testFile,
+ rangeAtSearch('Foo(', contents, 'Foo'),
+ ),
+ );
+ }
+
+ Future<void> test_constructorCall() async {
+ final contents = '''
+import 'other.dart';
+
+f() {
+ final foo = Fo^o();
+}
+ ''';
+
+ final otherContents = '''
+class Foo {
+ Foo();
+}
+ ''';
+
+ addSource(otherFile, otherContents);
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.constructor,
+ 'Foo',
+ otherFile,
+ rangeAtSearch('Foo(', otherContents, 'Foo'),
+ ));
+ }
+
+ Future<void> test_extension_method() async {
+ final contents = '''
+extension StringExtension on String {
+ void myMet^hod() {}
+}
+ ''';
+
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.method,
+ 'myMethod',
+ testFile,
+ rangeAtSearch('myMethod', contents),
+ ));
+ }
+
+ Future<void> test_extension_methodCall() async {
+ final contents = '''
+import 'other.dart';
+
+f() {
+ ''.myMet^hod();
+}
+ ''';
+
+ final otherContents = '''
+extension StringExtension on String {
+ void myMethod() {}
+}
+ ''';
+
+ addSource(otherFile, otherContents);
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.method,
+ 'myMethod',
+ otherFile,
+ rangeAtSearch('myMethod', otherContents),
+ ));
+ }
+
+ Future<void> test_function() async {
+ final contents = '''
+void myFun^ction() {}
+ ''';
+
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.function,
+ 'myFunction',
+ testFile,
+ rangeAtSearch('myFunction', contents),
+ ));
+ }
+
+ Future<void> test_functionCall() async {
+ final contents = '''
+import 'other.dart' as f;
+
+f() {
+ f.myFun^ction();
+}
+ ''';
+
+ final otherContents = '''
+void myFunction() {}
+ ''';
+
+ addSource(otherFile, otherContents);
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.function,
+ 'myFunction',
+ otherFile,
+ rangeAtSearch('myFunction', otherContents),
+ ));
+ }
+
+ Future<void> test_getter() async {
+ final contents = '''
+class Foo {
+ String get fo^o => '';
+}
+ ''';
+
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.property,
+ 'get foo',
+ testFile,
+ rangeAtSearch('foo', contents),
+ ));
+ }
+
+ Future<void> test_getterCall() async {
+ final contents = '''
+import 'other.dart';
+
+f() {
+ final foo = ba^r;
+}
+ ''';
+
+ final otherContents = '''
+String get bar => '';
+ ''';
+
+ addSource(otherFile, otherContents);
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.property,
+ 'get bar',
+ otherFile,
+ rangeAtSearch('bar', otherContents),
+ ));
+ }
+
+ Future<void> test_implicitConstructorCall() async {
+ // Even if a constructor is implicit, we might want to be able to get the
+ // incoming calls, so we should return the class location as a stand-in
+ // (although with the Kind still set to constructor).
+ final contents = '''
+import 'other.dart';
+
+f() {
+ final foo = Fo^o();
+}
+ ''';
+
+ final otherContents = '''
+class Foo {}
+ ''';
+
+ addSource(otherFile, otherContents);
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.constructor,
+ 'Foo',
+ otherFile,
+ rangeAtSearch('Foo {', otherContents, 'Foo'),
+ ));
+ }
+
+ Future<void> test_method() async {
+ final contents = '''
+class Foo {
+ void myMet^hod() {}
+}
+ ''';
+
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.method,
+ 'myMethod',
+ testFile,
+ rangeAtSearch('myMethod', contents),
+ ));
+ }
+
+ Future<void> test_methodCall() async {
+ final contents = '''
+import 'other.dart';
+
+f() {
+ Foo().myMet^hod();
+}
+ ''';
+
+ final otherContents = '''
+class Foo {
+ void myMethod() {}
+}
+ ''';
+
+ addSource(otherFile, otherContents);
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.method,
+ 'myMethod',
+ otherFile,
+ rangeAtSearch('myMethod', otherContents),
+ ));
+ }
+
+ Future<void> test_mixin_method() async {
+ final contents = '''
+mixin Bar {
+ void myMet^hod() {}
+}
+ ''';
+
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.method,
+ 'myMethod',
+ testFile,
+ rangeAtSearch('myMethod', contents),
+ ));
+ }
+
+ Future<void> test_mixin_methodCall() async {
+ final contents = '''
+import 'other.dart';
+
+f() {
+ Foo().myMet^hod();
+}
+ ''';
+
+ final otherContents = '''
+class Bar {
+ void myMethod() {}
+}
+
+class Foo with Bar {}
+ ''';
+
+ addSource(otherFile, otherContents);
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.method,
+ 'myMethod',
+ otherFile,
+ rangeAtSearch('myMethod', otherContents),
+ ));
+ }
+
+ Future<void> test_namedConstructor() async {
+ final contents = '''
+class Foo {
+ Foo.Ba^r(String a) {}
+}
+ ''';
+
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.constructor,
+ 'Foo.Bar',
+ testFile,
+ rangeAtSearch('Bar', contents),
+ ));
+ }
+
+ Future<void> test_namedConstructor_typeName() async {
+ final contents = '''
+class Foo {
+ Fo^o.Bar(String a) {}
+}
+ ''';
+
+ await expectNoTarget(contents);
+ }
+
+ Future<void> test_namedConstructorCall() async {
+ final contents = '''
+import 'other.dart';
+
+f() {
+ final foo = Foo.Ba^r();
+}
+ ''';
+
+ final otherContents = '''
+class Foo {
+ Foo.Bar();
+}
+ ''';
+
+ addSource(otherFile, otherContents);
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.constructor,
+ 'Foo.Bar',
+ otherFile,
+ rangeAtSearch('Bar', otherContents),
+ ));
+ }
+
+ Future<void> test_namedConstructorCall_typeName() async {
+ final contents = '''
+import 'other.dart';
+
+f() {
+ final foo = Fo^o.Bar();
+}
+ ''';
+
+ final otherContents = '''
+class Foo {
+ Foo.Bar();
+}
+ ''';
+
+ addSource(otherFile, otherContents);
+ await expectNoTarget(contents);
+ }
+
+ Future<void> test_setter() async {
+ final contents = '''
+class Foo {
+ set fo^o(Strin value) {};
+}
+ ''';
+
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.property,
+ 'set foo',
+ testFile,
+ rangeAtSearch('foo', contents),
+ ));
+ }
+
+ Future<void> test_setterCall() async {
+ final contents = '''
+import 'other.dart';
+
+f() {
+ ba^r = '';
+}
+ ''';
+
+ final otherContents = '''
+set bar(String value) {}
+ ''';
+
+ addSource(otherFile, otherContents);
+ await expectTarget(
+ contents,
+ _isItem(
+ CallHierarchyKind.property,
+ 'set bar',
+ otherFile,
+ rangeAtSearch('bar', otherContents),
+ ));
+ }
+
+ Future<void> test_whitespace() async {
+ await expectNoTarget(' ^ f() {}');
+ }
+}
+
+@reflectiveTest
+class CallHierarchyComputerIncomingCallsTest extends AbstractCallHierarchyTest {
+ late String otherFile;
+ late SearchEngine searchEngine;
+
+ Future<List<CallHierarchyCalls>> findIncomingCalls(String code) async {
+ final marker = code.indexOf('^');
+ expect(marker, greaterThanOrEqualTo(0));
+ addTestSource(withoutMarkers(code));
+ final session_ = await session;
+
+ var result = await session_.getResolvedUnit(testFile) as ResolvedUnitResult;
+ expect(result.errors, isEmpty);
+ var computer = DartCallHierarchyComputer(result);
+ // It's possible that the target is in a different file (because we were
+ // invoked on a call and not a declaration), so fetch the resolved unit
+ // for the target.
+ final target = computer.findTarget(marker)!;
+ if (target.file != testFile) {
+ result =
+ await session_.getResolvedUnit(target.file) as ResolvedUnitResult;
+ expect(result.errors, isEmpty);
+ computer = DartCallHierarchyComputer(result);
+ }
+ return computer.findIncomingCalls(target, searchEngine);
+ }
+
+ @override
+ void setUp() {
+ super.setUp();
+ otherFile = convertPath('$testPackageLibPath/other.dart');
+ searchEngine = SearchEngineImpl([
+ driverFor(testPackageRootPath),
+ ]);
+ }
+
+ Future<void> test_constructor() async {
+ final contents = '''
+class Foo {
+ Fo^o();
+}
+ ''';
+
+ final otherContents = '''
+import 'test.dart';
+
+final foo1 = Foo();
+class Bar {
+ final foo2 = Foo();
+ Foo get foo3 => Foo();
+ Bar() {
+ final foo4 = Foo();
+ }
+ void bar() {
+ final foo5 = Foo();
+ final foo6 = Foo();
+ }
+}
+ ''';
+
+ // Gets the expected range that follows the string [prefix].
+ SourceRange rangeAfter(String prefix) =>
+ rangeAfterPrefix(prefix, otherContents, 'Foo');
+
+ addSource(otherFile, otherContents);
+ final calls = await findIncomingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.file, 'other.dart', otherFile, startOfFile,
+ ranges: [
+ rangeAfter('foo1 = '),
+ ]),
+ _isResult(CallHierarchyKind.class_, 'Bar', otherFile,
+ rangeAtSearch('Bar {', otherContents, 'Bar'),
+ ranges: [
+ rangeAfter('foo2 = '),
+ ]),
+ _isResult(CallHierarchyKind.property, 'foo3', otherFile,
+ rangeAtSearch('foo3', otherContents),
+ ranges: [
+ rangeAfter('foo3 => '),
+ ]),
+ _isResult(CallHierarchyKind.constructor, 'Bar', otherFile,
+ rangeAtSearch('Bar() {', otherContents, 'Bar'),
+ ranges: [
+ rangeAfter('foo4 = '),
+ ]),
+ _isResult(CallHierarchyKind.method, 'bar', otherFile,
+ rangeAtSearch('bar() {', otherContents, 'bar'),
+ ranges: [
+ rangeAfter('foo5 = '),
+ rangeAfter('foo6 = '),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_extension_method() async {
+ final contents = '''
+extension StringExtension on String {
+ void myMet^hod() {}
+}
+ ''';
+
+ final otherContents = '''
+import 'test.dart';
+
+void f() {
+ ''.myMethod();
+}
+ ''';
+
+ // Gets the expected range that follows the string [prefix].
+ SourceRange rangeAfter(String prefix) =>
+ rangeAfterPrefix(prefix, otherContents, 'myMethod');
+
+ addSource(otherFile, otherContents);
+ final calls = await findIncomingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.function, 'f', otherFile,
+ rangeAtSearch('f() {', otherContents, 'f'),
+ ranges: [
+ rangeAfter("''."),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_function() async {
+ final contents = '''
+String myFun^ction() => '';
+ ''';
+
+ final otherContents = '''
+import 'test.dart';
+
+final foo1 = myFunction();
+
+class Bar {
+ final foo2 = myFunction();
+ String get foo3 => myFunction();
+ Bar() {
+ final foo4 = myFunction();
+ }
+ void bar() {
+ final foo5 = myFunction();
+ final foo6 = myFunction();
+ }
+}
+ ''';
+
+ // Gets the expected range that follows the string [prefix].
+ SourceRange rangeAfter(String prefix) =>
+ rangeAfterPrefix(prefix, otherContents, 'myFunction');
+
+ addSource(otherFile, otherContents);
+ final calls = await findIncomingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.file, 'other.dart', otherFile, startOfFile,
+ ranges: [
+ rangeAfter('foo1 = '),
+ ]),
+ _isResult(CallHierarchyKind.class_, 'Bar', otherFile,
+ rangeAtSearch('Bar {', otherContents, 'Bar'),
+ ranges: [
+ rangeAfter('foo2 = '),
+ ]),
+ _isResult(CallHierarchyKind.property, 'foo3', otherFile,
+ rangeAtSearch('foo3', otherContents),
+ ranges: [
+ rangeAfter('foo3 => '),
+ ]),
+ _isResult(CallHierarchyKind.constructor, 'Bar', otherFile,
+ rangeAtSearch('Bar() {', otherContents, 'Bar'),
+ ranges: [
+ rangeAfter('foo4 = '),
+ ]),
+ _isResult(CallHierarchyKind.method, 'bar', otherFile,
+ rangeAtSearch('bar() {', otherContents, 'bar'),
+ ranges: [
+ rangeAfter('foo5 = '),
+ rangeAfter('foo6 = '),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_getter() async {
+ final contents = '''
+String get f^oo => '';
+ ''';
+
+ final otherContents = '''
+import 'test.dart';
+
+final foo1 = foo;
+class Bar {
+ final foo2 = foo;
+ Foo get foo3 => foo;
+ Bar() {
+ final foo4 = foo;
+ }
+ void bar() {
+ final foo5 = foo;
+ final foo6 = foo;
+ }
+}
+ ''';
+
+ // Gets the expected range that follows the string [prefix].
+ SourceRange rangeAfter(String prefix) =>
+ rangeAfterPrefix(prefix, otherContents, 'foo');
+
+ addSource(otherFile, otherContents);
+ final calls = await findIncomingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.file, 'other.dart', otherFile, startOfFile,
+ ranges: [
+ rangeAfter('foo1 = '),
+ ]),
+ _isResult(CallHierarchyKind.class_, 'Bar', otherFile,
+ rangeAtSearch('Bar {', otherContents, 'Bar'),
+ ranges: [
+ rangeAfter('foo2 = '),
+ ]),
+ _isResult(CallHierarchyKind.property, 'foo3', otherFile,
+ rangeAtSearch('foo3', otherContents),
+ ranges: [
+ rangeAfter('foo3 => '),
+ ]),
+ _isResult(CallHierarchyKind.constructor, 'Bar', otherFile,
+ rangeAtSearch('Bar() {', otherContents, 'Bar'),
+ ranges: [
+ rangeAfter('foo4 = '),
+ ]),
+ _isResult(CallHierarchyKind.method, 'bar', otherFile,
+ rangeAtSearch('bar() {', otherContents, 'bar'),
+ ranges: [
+ rangeAfter('foo5 = '),
+ rangeAfter('foo6 = '),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_implicitConstructor() async {
+ // We still expect to be able to navigate with implicit constructors. This
+ // is done by the target being the class, but with a kind of Constructor.
+ final contents = '''
+// ignore_for_file: unused_local_variable
+import 'other.dart';
+
+f() {
+ final foo1 = Fo^o();
+}
+ ''';
+
+ final otherContents = '''
+class Foo {}
+
+final foo2 = Foo();
+ ''';
+
+ // Gets the expected range that follows the string [prefix].
+ SourceRange rangeAfter(String prefix, String code) =>
+ rangeAfterPrefix(prefix, code, 'Foo');
+
+ addSource(otherFile, otherContents);
+ final calls = await findIncomingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.function, 'f', testFile,
+ rangeAtSearch('f() {', contents, 'f'),
+ ranges: [
+ rangeAfter('foo1 = ', contents),
+ ]),
+ _isResult(CallHierarchyKind.file, 'other.dart', otherFile, startOfFile,
+ ranges: [
+ rangeAfter('foo2 = ', otherContents),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_method() async {
+ final contents = '''
+class Foo {
+ void myMet^hod() {}
+}
+ ''';
+
+ final otherContents = '''
+import 'test.dart';
+
+void f() {
+ Foo().myMethod();
+ final tearoff = Foo().myMethod;
+}
+ ''';
+
+ // Gets the expected range that follows the string [prefix].
+ SourceRange rangeAfter(String prefix) =>
+ rangeAfterPrefix(prefix, otherContents, 'myMethod');
+
+ addSource(otherFile, otherContents);
+ final calls = await findIncomingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.function, 'f', otherFile,
+ rangeAtSearch('f() {', otherContents, 'f'),
+ ranges: [
+ rangeAfter('Foo().'),
+ rangeAfter('tearoff = Foo().'),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_mixin_method() async {
+ final contents = '''
+mixin Bar {
+ void myMet^hod() {}
+}
+
+class Foo with Bar {}
+ ''';
+
+ final otherContents = '''
+import 'test.dart';
+
+void f() {
+ Foo().myMethod();
+}
+ ''';
+
+ // Gets the expected range that follows the string [prefix].
+ SourceRange rangeAfter(String prefix) =>
+ rangeAfterPrefix(prefix, otherContents, 'myMethod');
+
+ addSource(otherFile, otherContents);
+ final calls = await findIncomingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.function, 'f', otherFile,
+ rangeAtSearch('f() {', otherContents, 'f'),
+ ranges: [
+ rangeAfter('Foo().'),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_namedConstructor() async {
+ final contents = '''
+class Foo {
+ Foo.B^ar();
+}
+ ''';
+
+ final otherContents = '''
+import 'test.dart';
+
+f() {
+ final foo = Foo.Bar();
+}
+ ''';
+
+ // Gets the expected range that follows the string [prefix].
+ SourceRange rangeAfter(String prefix) =>
+ rangeAfterPrefix(prefix, otherContents, 'Bar');
+
+ addSource(otherFile, otherContents);
+ final calls = await findIncomingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.function, 'f', otherFile,
+ rangeAtSearch('f() {', otherContents, 'f'),
+ ranges: [
+ rangeAfter('foo = Foo.'),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_setter() async {
+ final contents = '''
+set fo^o(String value) {}
+ ''';
+
+ final otherContents = '''
+import 'test.dart';
+
+class Bar {
+ Bar() {
+ /*1*/foo = '';
+ }
+ void bar() {
+ /*2*/foo = '';
+ /*3*/foo = '';
+ }
+}
+ ''';
+
+ // Gets the expected range that follows the string [prefix].
+ SourceRange rangeAfter(String prefix) =>
+ rangeAfterPrefix(prefix, otherContents, 'foo');
+
+ addSource(otherFile, otherContents);
+ final calls = await findIncomingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.constructor, 'Bar', otherFile,
+ rangeAtSearch('Bar() {', otherContents, 'Bar'),
+ ranges: [
+ rangeAfter('/*1*/'),
+ ]),
+ _isResult(CallHierarchyKind.method, 'bar', otherFile,
+ rangeAtSearch('bar() {', otherContents, 'bar'),
+ ranges: [
+ rangeAfter('/*2*/'),
+ rangeAfter('/*3*/'),
+ ]),
+ ]),
+ );
+ }
+}
+
+@reflectiveTest
+class CallHierarchyComputerOutgoingCallsTest extends AbstractCallHierarchyTest {
+ late String otherFile;
+
+ Future<List<CallHierarchyCalls>> findOutgoingCalls(String code) async {
+ final marker = code.indexOf('^');
+ expect(marker, greaterThanOrEqualTo(0));
+ addTestSource(withoutMarkers(code));
+ final session_ = await session;
+
+ var result = await session_.getResolvedUnit(testFile) as ResolvedUnitResult;
+ expect(result.errors, isEmpty);
+ var computer = DartCallHierarchyComputer(result);
+ // It's possible that the target is in a different file (because we were
+ // invoked on a call and not a declaration), so fetch the resolved unit
+ // for the target.
+ final target = computer.findTarget(marker)!;
+ if (target.file != testFile) {
+ result =
+ await session_.getResolvedUnit(target.file) as ResolvedUnitResult;
+ expect(result.errors, isEmpty);
+ computer = DartCallHierarchyComputer(result);
+ }
+ return computer.findOutgoingCalls(target);
+ }
+
+ @override
+ void setUp() {
+ super.setUp();
+ otherFile = convertPath('$testPackageLibPath/other.dart');
+ }
+
+ Future<void> test_constructor() async {
+ final contents = '''
+// ignore_for_file: unused_local_variable
+import 'other.dart';
+
+class Foo {
+ Fo^o() {
+ final a = A();
+ final constructorTearoffA = A.new;
+ final b = B();
+ final constructorTearoffB = B.new;
+ }
+}
+ ''';
+
+ final otherContents = '''
+class A {
+ A();
+}
+
+class B {
+}
+ ''';
+
+ addSource(otherFile, otherContents);
+ final calls = await findOutgoingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.constructor, 'A', otherFile,
+ rangeAtSearch('A();', otherContents, 'A'),
+ ranges: [
+ rangeAtSearch('A()', contents, 'A'),
+ rangeAfterPrefix('constructorTearoffA = A.', contents, 'new'),
+ ]),
+ _isResult(CallHierarchyKind.constructor, 'B', otherFile,
+ rangeAtSearch('B {', otherContents, 'B'),
+ ranges: [
+ rangeAtSearch('B()', contents, 'B'),
+ rangeAfterPrefix('constructorTearoffB = B.', contents, 'new'),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_extension_method() async {
+ final contents = '''
+// ignore_for_file: unused_local_variable
+import 'other.dart';
+
+extension StringExtension on String {
+ void fo^o() {
+ ''.bar();
+ final tearoff = ''.bar;
+ }
+}
+ ''';
+
+ final otherContents = '''
+extension StringExtension on String {
+ bar() {}
+}
+ ''';
+
+ addSource(otherFile, otherContents);
+ final calls = await findOutgoingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.method, 'bar', otherFile,
+ rangeAtSearch('bar() {', otherContents, 'bar'),
+ ranges: [
+ rangeAtSearch('bar();', contents, 'bar'),
+ rangeAtSearch('bar;', contents, 'bar'),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_function() async {
+ final contents = '''
+// ignore_for_file: unused_local_variable
+import 'other.dart';
+
+void fo^o() {
+ void nested() {
+ f(); // not a call of 'foo'
+ }
+ f(); // 1
+ final tearoff = f;
+ nested();
+ final nestedTearoff = nested;
+}
+ ''';
+
+ final otherContents = '''
+void f() {}
+ ''';
+
+ addSource(otherFile, otherContents);
+ final calls = await findOutgoingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.function, 'f', otherFile,
+ rangeAtSearch('f() {', otherContents, 'f'),
+ ranges: [
+ rangeAtSearch('f(); // 1', contents, 'f'),
+ rangeAfterPrefix('tearoff = ', contents, 'f'),
+ ]),
+ _isResult(CallHierarchyKind.function, 'nested', testFile,
+ rangeAtSearch('nested() {', contents, 'nested'),
+ ranges: [
+ rangeAtSearch('nested();', contents, 'nested'),
+ rangeAfterPrefix('nestedTearoff = ', contents, 'nested'),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_getter() async {
+ final contents = '''
+// ignore_for_file: unused_local_variable
+import 'other.dart';
+
+String get fo^o {
+ final a = A();
+ final b = a.b;
+ final c = A().b;
+ return '';
+}
+ ''';
+
+ final otherContents = '''
+class A {
+ String get b => '';
+}
+ ''';
+
+ addSource(otherFile, otherContents);
+ final calls = await findOutgoingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.constructor, 'A', otherFile,
+ rangeAtSearch('A {', otherContents, 'A')),
+ _isResult(CallHierarchyKind.property, 'get b', otherFile,
+ rangeAtSearch('b => ', otherContents, 'b'),
+ ranges: [
+ rangeAfterPrefix('a.', contents, 'b'),
+ rangeAfterPrefix('A().', contents, 'b'),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_implicitConstructor() async {
+ // We can still begin navigating from an implicit constructor (so we can
+ // search for inbound calls), so we should ensure that trying to fetch
+ // outbound calls returns empty (and doesn't fail).
+ final contents = '''
+// ignore_for_file: unused_local_variable
+import 'other.dart';
+
+f() {
+ final foo1 = Fo^o();
+}
+ ''';
+
+ final otherContents = '''
+class Foo {}
+ ''';
+
+ addSource(otherFile, otherContents);
+ final calls = await findOutgoingCalls(contents);
+ expect(calls, isEmpty);
+ }
+
+ Future<void> test_method() async {
+ final contents = '''
+// ignore_for_file: unused_local_variable
+import 'other.dart';
+
+class Foo {
+ void fo^o() {
+ final a = A();
+ a.bar();
+ final tearoff = a.bar;
+ // non-calls
+ var x = 1;
+ var y = x;
+ a.field;
+ }
+}
+ ''';
+
+ final otherContents = '''
+class A {
+ String field;
+ void bar() {}
+}
+ ''';
+
+ addSource(otherFile, otherContents);
+ final calls = await findOutgoingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.constructor, 'A', otherFile,
+ rangeAtSearch('A {', otherContents, 'A')),
+ _isResult(CallHierarchyKind.method, 'bar', otherFile,
+ rangeAtSearch('bar() {', otherContents, 'bar'),
+ ranges: [
+ rangeAfterPrefix('a.', contents, 'bar'),
+ rangeAfterPrefix('tearoff = a.', contents, 'bar'),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_mixin_method() async {
+ final contents = '''
+// ignore_for_file: unused_local_variable
+import 'other.dart';
+
+mixin MyMixin {
+ void f^() {
+ final a = A();
+ a.foo();
+ A().foo();
+ final tearoff = a.foo;
+ }
+}
+ ''';
+
+ final otherContents = '''
+mixin OtherMixin {
+ void foo() {}
+}
+
+class A with OtherMixin {}
+ ''';
+
+ addSource(otherFile, otherContents);
+ final calls = await findOutgoingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.constructor, 'A', otherFile,
+ rangeAtSearch('A with', otherContents, 'A')),
+ _isResult(CallHierarchyKind.method, 'foo', otherFile,
+ rangeAtSearch('foo() {', otherContents, 'foo'),
+ ranges: [
+ rangeAfterPrefix('a.', contents, 'foo'),
+ rangeAfterPrefix('A().', contents, 'foo'),
+ rangeAfterPrefix('tearoff = a.', contents, 'foo'),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_namedConstructor() async {
+ final contents = '''
+// ignore_for_file: unused_local_variable
+import 'other.dart';
+
+class Foo {
+ Foo.B^ar() {
+ final a = A.named();
+ final constructorTearoff = A.named;
+ }
+}
+ ''';
+
+ final otherContents = '''
+void f() {}
+class A {
+ A.named();
+}
+ ''';
+
+ addSource(otherFile, otherContents);
+ final calls = await findOutgoingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.constructor, 'A.named', otherFile,
+ rangeAtSearch('named', otherContents),
+ ranges: [
+ rangeAfterPrefix('a = A.', contents, 'named'),
+ rangeAfterPrefix('constructorTearoff = A.', contents, 'named'),
+ ]),
+ ]),
+ );
+ }
+
+ Future<void> test_setter() async {
+ final contents = '''
+import 'other.dart';
+
+set fo^o(String value) {
+ final a = A();
+ a.b = '';
+ A().b = '';
+}
+ ''';
+
+ final otherContents = '''
+class A {
+ set b(String value) {}
+}
+ ''';
+
+ addSource(otherFile, otherContents);
+ final calls = await findOutgoingCalls(contents);
+ expect(
+ calls,
+ unorderedEquals([
+ _isResult(CallHierarchyKind.constructor, 'A', otherFile,
+ rangeAtSearch('A {', otherContents, 'A')),
+ _isResult(CallHierarchyKind.property, 'set b', otherFile,
+ rangeAtSearch('b(String ', otherContents, 'b'),
+ ranges: [
+ rangeAfterPrefix('a.', contents, 'b'),
+ rangeAfterPrefix('A().', contents, 'b'),
+ ]),
+ ]),
+ );
+ }
+}
diff --git a/pkg/analysis_server/test/src/computer/test_all.dart b/pkg/analysis_server/test/src/computer/test_all.dart
index af15c51..65087cc 100644
--- a/pkg/analysis_server/test/src/computer/test_all.dart
+++ b/pkg/analysis_server/test/src/computer/test_all.dart
@@ -4,6 +4,7 @@
import 'package:test_reflective_loader/test_reflective_loader.dart';
+import 'call_hierarchy_computer_test.dart' as call_hierarchy_computer;
import 'closing_labels_computer_test.dart' as closing_labels_computer;
import 'color_computer_test.dart' as color_computer;
import 'folding_computer_test.dart' as folding_computer;
@@ -15,6 +16,7 @@
void main() {
defineReflectiveSuite(() {
+ call_hierarchy_computer.main();
closing_labels_computer.main();
color_computer.main();
folding_computer.main();
diff --git a/pkg/analysis_server/test/src/domains/completion/available_suggestion_sets_test.dart b/pkg/analysis_server/test/src/domains/completion/available_suggestion_sets_test.dart
index 15124db..3ab015e 100644
--- a/pkg/analysis_server/test/src/domains/completion/available_suggestion_sets_test.dart
+++ b/pkg/analysis_server/test/src/domains/completion/available_suggestion_sets_test.dart
@@ -45,7 +45,7 @@
// Delete the file, the set should be removed.
deleteFile(path);
- waitForSetWithUriRemoved(uriStr);
+ await waitForSetWithUriRemoved(uriStr);
}
Future<void> test_suggestion_class() async {
diff --git a/pkg/analysis_server/test/src/services/correction/assist/assign_to_local_variable_test.dart b/pkg/analysis_server/test/src/services/correction/assist/assign_to_local_variable_test.dart
index 3751d7f..c544b19 100644
--- a/pkg/analysis_server/test/src/services/correction/assist/assign_to_local_variable_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/assist/assign_to_local_variable_test.dart
@@ -102,7 +102,7 @@
final data['table'][] //marker
}
''');
- assertNoAssistAt('] //marker');
+ await assertNoAssistAt('] //marker');
}
Future<void> test_throw() async {
diff --git a/pkg/analysis_server/test/src/services/correction/fix/create_field_test.dart b/pkg/analysis_server/test/src/services/correction/fix/create_field_test.dart
index af26bc4..6f64621 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/create_field_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/create_field_test.dart
@@ -3,7 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
import 'package:analysis_server/src/services/correction/fix.dart';
-import 'package:analyzer/src/error/codes.dart';
import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ -364,25 +363,6 @@
await assertNoFix();
}
- Future<void> test_inPart_imported() async {
- addSource('$testPackageLibPath/a.dart', '''
-part of lib;
-class A {}
-''');
-
- await resolveTestCode('''
-import 'package:test/a.dart';
-
-void f(A a) {
- int v = a.test;
- print(v);
-}
-''');
- await assertNoFix(errorFilter: (e) {
- return e.errorCode == CompileTimeErrorCode.UNDEFINED_GETTER;
- });
- }
-
Future<void> test_inPart_self() async {
await resolveTestCode('''
part of lib;
diff --git a/pkg/analysis_server/test/src/services/correction/fix/create_getter_test.dart b/pkg/analysis_server/test/src/services/correction/fix/create_getter_test.dart
index 7566168..ed0884c 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/create_getter_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/create_getter_test.dart
@@ -3,7 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
import 'package:analysis_server/src/services/correction/fix.dart';
-import 'package:analyzer/src/error/codes.dart';
import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ -306,26 +305,6 @@
''');
}
- Future<void> test_qualified_instance_inPart_imported() async {
- addSource('$testPackageLibPath/a.dart', '''
-part of lib;
-
-class A {}
-''');
-
- await resolveTestCode('''
-import 'package:test/a.dart';
-
-void f(A a) {
- int v = a.test;
- print(v);
-}
-''');
- await assertNoFix(errorFilter: (e) {
- return e.errorCode == CompileTimeErrorCode.UNDEFINED_GETTER;
- });
- }
-
Future<void> test_qualified_instance_inPart_self() async {
await resolveTestCode('''
part of lib;
diff --git a/pkg/analysis_server/test/src/services/correction/fix/create_setter_test.dart b/pkg/analysis_server/test/src/services/correction/fix/create_setter_test.dart
index fea7674..930c68e 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/create_setter_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/create_setter_test.dart
@@ -3,7 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
import 'package:analysis_server/src/services/correction/fix.dart';
-import 'package:analyzer/src/error/codes.dart';
import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ -301,25 +300,6 @@
''');
}
- Future<void> test_qualified_instance_inPart_imported() async {
- addSource('$testPackageLibPath/a.dart', '''
-part of lib;
-
-class A {}
-''');
-
- await resolveTestCode('''
-import 'package:test/a.dart';
-
-void f(A a) {
- a.test = 0;
-}
-''');
- await assertNoFix(errorFilter: (e) {
- return e.errorCode == CompileTimeErrorCode.UNDEFINED_SETTER;
- });
- }
-
Future<void> test_qualified_instance_inPart_self() async {
await resolveTestCode('''
part of lib;
diff --git a/pkg/analysis_server/test/src/services/correction/fix/data_driven/sdk_fix_test.dart b/pkg/analysis_server/test/src/services/correction/fix/data_driven/sdk_fix_test.dart
index 181cf6d..fb75558 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/data_driven/sdk_fix_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/data_driven/sdk_fix_test.dart
@@ -87,6 +87,6 @@
await resolveTestCode('''
var x = '';
''');
- assertNoExceptions();
+ await assertNoExceptions();
}
}
diff --git a/pkg/analysis_server/test/src/services/correction/fix/remove_empty_catch_test.dart b/pkg/analysis_server/test/src/services/correction/fix/remove_empty_catch_test.dart
index 1e5bf88..a7b3898 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/remove_empty_catch_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/remove_empty_catch_test.dart
@@ -67,7 +67,7 @@
} catch 2;
}
''');
- assertNoExceptions();
+ await assertNoExceptions();
}
Future<void> test_singleCatch_finally_newLine() async {
diff --git a/pkg/analysis_server/test/stress/utilities/server.dart b/pkg/analysis_server/test/stress/utilities/server.dart
index 93daac0..1e0a635 100644
--- a/pkg/analysis_server/test/stress/utilities/server.dart
+++ b/pkg/analysis_server/test/stress/utilities/server.dart
@@ -572,11 +572,11 @@
// stdout.writeln('Launching $serverPath');
// stdout.writeln('$dartBinary ${arguments.join(' ')}');
_process = await Process.start(dartBinary, arguments);
- _process!.exitCode.then((int code) {
+ unawaited(_process!.exitCode.then((int code) {
if (code != 0) {
throw StateError('Server terminated with exit code $code');
}
- });
+ }));
_listenToOutput();
var completer = Completer<void>();
_serverConnectedCompleter = completer;
diff --git a/pkg/analysis_server/tool/code_completion/completion_metrics_client.dart b/pkg/analysis_server/tool/code_completion/completion_metrics_client.dart
index 0fa0e39..dc94890 100644
--- a/pkg/analysis_server/tool/code_completion/completion_metrics_client.dart
+++ b/pkg/analysis_server/tool/code_completion/completion_metrics_client.dart
@@ -38,7 +38,8 @@
var options = CompletionMetricsOptions(result);
var stopwatch = Stopwatch()..start();
var client = _AnalysisServerClient(Directory(_sdk.sdkPath), targets);
- _CompletionClientMetricsComputer(rootPath, options, client).computeMetrics();
+ await _CompletionClientMetricsComputer(rootPath, options, client)
+ .computeMetrics();
stopwatch.stop();
var duration = Duration(milliseconds: stopwatch.elapsedMilliseconds);
@@ -289,7 +290,7 @@
_process = process;
_shutdownResponseReceived = false;
// This callback hookup can't throw.
- process.exitCode.whenComplete(() {
+ unawaited(process.exitCode.whenComplete(() {
_process = null;
if (!_shutdownResponseReceived) {
@@ -312,7 +313,7 @@
_onCrash.complete();
}
- });
+ }));
final errorStream = process.stderr
.transform<String>(utf8.decoder)
@@ -326,7 +327,7 @@
_streamController('server.error').stream.listen(_handleServerError);
- _sendCommand('server.setSubscriptions', params: <String, dynamic>{
+ await _sendCommand('server.setSubscriptions', params: <String, dynamic>{
'subscriptions': <String>['STATUS'],
});
diff --git a/pkg/analyzer/lib/dart/ast/ast.dart b/pkg/analyzer/lib/dart/ast/ast.dart
index 070e789..5b3cd79 100644
--- a/pkg/analyzer/lib/dart/ast/ast.dart
+++ b/pkg/analyzer/lib/dart/ast/ast.dart
@@ -2877,9 +2877,14 @@
/// imported URI is not deferred.
Token? get deferredKeyword;
+ @Deprecated('Use element2 instead')
@override
ImportElement? get element;
+ /// Return the element associated with this directive, or `null` if the AST
+ /// structure has not been resolved.
+ ImportElement2? get element2;
+
/// The token representing the 'import' keyword.
Token get importKeyword;
diff --git a/pkg/analyzer/lib/dart/element/element.dart b/pkg/analyzer/lib/dart/element/element.dart
index 22fae35..8d6f524 100644
--- a/pkg/analyzer/lib/dart/element/element.dart
+++ b/pkg/analyzer/lib/dart/element/element.dart
@@ -504,6 +504,11 @@
InterfaceType get returnType;
}
+/// [ImportElementPrefix] that is used together with `deferred`.
+///
+/// Clients may not extend, implement or mix-in this class.
+abstract class DeferredImportElementPrefix implements ImportElementPrefix {}
+
/// Meaning of a URI referenced in a directive.
///
/// Clients may not extend, implement or mix-in this class.
@@ -1099,8 +1104,11 @@
R? visitGenericFunctionTypeElement(GenericFunctionTypeElement element);
+ @Deprecated('Override visitImportElement2() instead')
R? visitImportElement(ImportElement element);
+ R? visitImportElement2(ImportElement2 element);
+
R? visitLabelElement(LabelElement element);
R? visitLibraryAugmentationElement(LibraryAugmentationElement element);
@@ -1342,6 +1350,7 @@
/// A single import directive within a library.
///
/// Clients may not extend, implement or mix-in this class.
+@Deprecated('Use ImportElement2 instead')
abstract class ImportElement implements UriReferencedElement {
/// Return a list containing the combinators that were specified as part of
/// the import directive in the order in which they were specified.
@@ -1362,6 +1371,40 @@
PrefixElement? get prefix;
}
+/// A single import directive within a library.
+///
+/// Clients may not extend, implement or mix-in this class.
+abstract class ImportElement2 implements _ExistingElement {
+ /// Return a list containing the combinators that were specified as part of
+ /// the import directive in the order in which they were specified.
+ List<NamespaceCombinator> get combinators;
+
+ /// Returns the [LibraryElement], if [uri] is a [DirectiveUriWithLibrary].
+ LibraryElement? get importedLibrary;
+
+ /// The offset of the `import` keyword.
+ int get importKeywordOffset;
+
+ /// The [Namespace] that this directive contributes to the containing library.
+ Namespace get namespace;
+
+ /// Return the prefix that was specified as part of the import directive, or
+ /// `null` if there was no prefix specified.
+ ImportElementPrefix? get prefix;
+
+ /// The interpretation of the URI specified in the directive.
+ DirectiveUri get uri;
+}
+
+/// Usage of a [PrefixElement] in an `import` directive.
+///
+/// Clients may not extend, implement or mix-in this class.
+abstract class ImportElementPrefix {
+ /// Return the prefix that was specified as part of the import directive, or
+ /// `null` if there was no prefix specified.
+ PrefixElement get element;
+}
+
/// A label associated with a statement.
///
/// Clients may not extend, implement or mix-in this class.
@@ -1516,8 +1559,12 @@
FeatureSet get featureSet;
/// Return a list containing all of the imports defined in this library.
+ @Deprecated('Use imports2 instead')
List<ImportElement> get imports;
+ /// Return a list containing all of the imports defined in this library.
+ List<ImportElement2> get imports2;
+
bool get isNonNullableByDefault;
/// The language version for this library.
@@ -1726,8 +1773,12 @@
LibraryOrAugmentationElement get enclosingElement2;
/// Return the imports that share this prefix.
+ @Deprecated('Use imports2 instead')
List<ImportElement> get imports;
+ /// Return the imports that share this prefix.
+ List<ImportElement2> get imports2;
+
@override
String get name;
diff --git a/pkg/analyzer/lib/dart/element/visitor.dart b/pkg/analyzer/lib/dart/element/visitor.dart
index 86e4839..4735d6f 100644
--- a/pkg/analyzer/lib/dart/element/visitor.dart
+++ b/pkg/analyzer/lib/dart/element/visitor.dart
@@ -126,10 +126,14 @@
R? visitGenericFunctionTypeElement(GenericFunctionTypeElement element) =>
visitElement(element);
+ @Deprecated('Override visitImportElement2() instead')
@override
R? visitImportElement(ImportElement element) => visitElement(element);
@override
+ R? visitImportElement2(ImportElement2 element) => visitElement(element);
+
+ @override
R? visitLabelElement(LabelElement element) => visitElement(element);
@override
@@ -272,6 +276,7 @@
return null;
}
+ @Deprecated('Override visitImportElement2() instead')
@override
R? visitImportElement(ImportElement element) {
element.visitChildren(this);
@@ -279,6 +284,12 @@
}
@override
+ R? visitImportElement2(ImportElement2 element) {
+ element.visitChildren(this);
+ return null;
+ }
+
+ @override
R? visitLabelElement(LabelElement element) {
element.visitChildren(this);
return null;
@@ -405,10 +416,14 @@
R? visitGenericFunctionTypeElement(GenericFunctionTypeElement element) =>
null;
+ @Deprecated('Override visitImportElement2() instead')
@override
R? visitImportElement(ImportElement element) => null;
@override
+ R? visitImportElement2(ImportElement2 element) => null;
+
+ @override
R? visitLabelElement(LabelElement element) => null;
@override
@@ -498,10 +513,14 @@
R? visitGenericFunctionTypeElement(GenericFunctionTypeElement element) =>
_throw(element);
+ @Deprecated('Override visitImportElement2() instead')
@override
R? visitImportElement(ImportElement element) => _throw(element);
@override
+ R? visitImportElement2(ImportElement2 element) => _throw(element);
+
+ @override
R? visitLabelElement(LabelElement element) => _throw(element);
@override
diff --git a/pkg/analyzer/lib/src/dart/analysis/driver.dart b/pkg/analyzer/lib/src/dart/analysis/driver.dart
index a55028c..3058d67 100644
--- a/pkg/analyzer/lib/src/dart/analysis/driver.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/driver.dart
@@ -85,7 +85,7 @@
/// TODO(scheglov) Clean up the list of implicitly analyzed files.
class AnalysisDriver implements AnalysisDriverGeneric {
/// The version of data format, should be incremented on every format change.
- static const int DATA_VERSION = 229;
+ static const int DATA_VERSION = 230;
/// The number of exception contexts allowed to write. Once this field is
/// zero, we stop writing any new exception contexts in this process.
diff --git a/pkg/analyzer/lib/src/dart/analysis/file_state.dart b/pkg/analyzer/lib/src/dart/analysis/file_state.dart
index 4675824..8ec05f7 100644
--- a/pkg/analyzer/lib/src/dart/analysis/file_state.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/file_state.dart
@@ -212,7 +212,7 @@
/// Information about a single `export` directive.
class ExportDirectiveState<U extends DirectiveUri> extends DirectiveState {
- final UnlinkedNamespaceDirective directive;
+ final UnlinkedExportDirective directive;
final U selectedUri;
final NamespaceDirectiveUris uris;
@@ -927,14 +927,14 @@
UnlinkedPartOfNameDirective? partOfNameDirective;
UnlinkedPartOfUriDirective? partOfUriDirective;
var augmentations = <UnlinkedImportAugmentationDirective>[];
- var exports = <UnlinkedNamespaceDirective>[];
- var imports = <UnlinkedNamespaceDirective>[];
+ var exports = <UnlinkedExportDirective>[];
+ var imports = <UnlinkedImportDirective>[];
var parts = <UnlinkedPartDirective>[];
var macroClasses = <MacroClass>[];
var hasDartCoreImport = false;
for (var directive in unit.directives) {
if (directive is ExportDirective) {
- var builder = _serializeNamespaceDirective(directive);
+ var builder = _serializeExport(directive);
exports.add(builder);
} else if (directive is AugmentationImportDirectiveImpl) {
augmentations.add(
@@ -943,7 +943,7 @@
),
);
} else if (directive is ImportDirectiveImpl) {
- var builder = _serializeNamespaceDirective(directive);
+ var builder = _serializeImport(directive);
imports.add(builder);
if (builder.uri == 'dart:core') {
hasDartCoreImport = true;
@@ -1016,9 +1016,12 @@
}
if (!isDartCore && !hasDartCoreImport) {
imports.add(
- UnlinkedNamespaceDirective(
+ UnlinkedImportDirective(
+ combinators: [],
configurations: [],
- isSyntheticDartCoreImport: true,
+ importKeywordOffset: -1,
+ isSyntheticDartCore: true,
+ prefix: null,
uri: 'dart:core',
),
);
@@ -1081,19 +1084,69 @@
return true;
}
- static UnlinkedNamespaceDirective _serializeNamespaceDirective(
- NamespaceDirective directive) {
- return UnlinkedNamespaceDirective(
- configurations: directive.configurations.map((configuration) {
- var name = configuration.name.components.join('.');
- var value = configuration.value?.stringValue ?? '';
- return UnlinkedNamespaceDirectiveConfiguration(
- name: name,
- value: value,
- uri: configuration.uri.stringValue,
+ static List<UnlinkedCombinator> _serializeCombinators(
+ List<Combinator> combinators,
+ ) {
+ return combinators.map((combinator) {
+ if (combinator is ShowCombinator) {
+ return UnlinkedCombinator(
+ keywordOffset: combinator.keyword.offset,
+ endOffset: combinator.end,
+ isShow: true,
+ names: combinator.shownNames.map((e) => e.name).toList(),
);
- }).toList(),
- uri: directive.uri.stringValue,
+ } else {
+ combinator as HideCombinator;
+ return UnlinkedCombinator(
+ keywordOffset: combinator.keyword.offset,
+ endOffset: combinator.end,
+ isShow: false,
+ names: combinator.hiddenNames.map((e) => e.name).toList(),
+ );
+ }
+ }).toList();
+ }
+
+ static List<UnlinkedNamespaceDirectiveConfiguration> _serializeConfigurations(
+ List<Configuration> configurations,
+ ) {
+ return configurations.map((configuration) {
+ var name = configuration.name.components.join('.');
+ var value = configuration.value?.stringValue ?? '';
+ return UnlinkedNamespaceDirectiveConfiguration(
+ name: name,
+ value: value,
+ uri: configuration.uri.stringValue,
+ );
+ }).toList();
+ }
+
+ static UnlinkedExportDirective _serializeExport(ExportDirective node) {
+ return UnlinkedExportDirective(
+ combinators: _serializeCombinators(node.combinators),
+ configurations: _serializeConfigurations(node.configurations),
+ uri: node.uri.stringValue,
+ );
+ }
+
+ static UnlinkedImportDirective _serializeImport(ImportDirective node) {
+ UnlinkedImportDirectivePrefix? unlinkedPrefix;
+ final prefix = node.prefix;
+ if (prefix != null) {
+ unlinkedPrefix = UnlinkedImportDirectivePrefix(
+ deferredOffset: node.deferredKeyword?.offset,
+ asOffset: node.asKeyword!.offset,
+ name: prefix.name,
+ nameOffset: prefix.offset,
+ );
+ }
+
+ return UnlinkedImportDirective(
+ combinators: _serializeCombinators(node.combinators),
+ configurations: _serializeConfigurations(node.configurations),
+ importKeywordOffset: node.importKeyword.offset,
+ uri: node.uri.stringValue,
+ prefix: unlinkedPrefix,
);
}
}
@@ -1651,7 +1704,7 @@
/// Information about a single `import` directive.
class ImportDirectiveState<U extends DirectiveUri> extends DirectiveState {
- final UnlinkedNamespaceDirective directive;
+ final UnlinkedImportDirective directive;
final U selectedUri;
final NamespaceDirectiveUris uris;
@@ -1671,7 +1724,7 @@
/// into a [Source].
Source? get importedSource => null;
- bool get isSyntheticDartCoreImport => directive.isSyntheticDartCoreImport;
+ bool get isSyntheticDartCore => directive.isSyntheticDartCore;
}
/// [ImportDirectiveWithUri] that has a valid URI that references a file.
diff --git a/pkg/analyzer/lib/src/dart/analysis/index.dart b/pkg/analyzer/lib/src/dart/analysis/index.dart
index 1a47eb1..695b5cd 100644
--- a/pkg/analyzer/lib/src/dart/analysis/index.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/index.dart
@@ -730,7 +730,7 @@
@override
void visitImportDirective(ImportDirective node) {
- ImportElement? element = node.element;
+ final element = node.element2;
recordUriReference(element?.importedLibrary, node.uri);
super.visitImportDirective(node);
}
diff --git a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
index 2fc3001..fbbea18 100644
--- a/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/library_analyzer.dart
@@ -582,7 +582,7 @@
} else if (directive is ImportDirectiveImpl) {
_resolveImportDirective(
directive: directive,
- importElement: _libraryElement.imports[importIndex],
+ importElement: _libraryElement.imports2[importIndex],
importState: _library.imports[importIndex],
libraryErrorReporter: libraryErrorReporter,
);
@@ -715,12 +715,12 @@
void _resolveImportDirective({
required ImportDirectiveImpl directive,
- required ImportElement importElement,
+ required ImportElement2 importElement,
required ImportDirectiveState importState,
required ErrorReporter libraryErrorReporter,
}) {
directive.element = importElement;
- directive.prefix?.staticElement = importElement.prefix;
+ directive.prefix?.staticElement = importElement.prefix?.element;
_resolveNamespaceDirective(
directive: directive,
primaryUriNode: directive.uri,
diff --git a/pkg/analyzer/lib/src/dart/analysis/search.dart b/pkg/analyzer/lib/src/dart/analysis/search.dart
index 657f117..51c397e 100644
--- a/pkg/analyzer/lib/src/dart/analysis/search.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/search.dart
@@ -130,13 +130,13 @@
class ImportElementReferencesVisitor extends RecursiveAstVisitor<void> {
final List<SearchResult> results = <SearchResult>[];
- final ImportElement importElement;
+ final ImportElement2 importElement;
final CompilationUnitElement enclosingUnitElement;
late final Set<Element> importedElements;
ImportElementReferencesVisitor(
- ImportElement element, this.enclosingUnitElement)
+ ImportElement2 element, this.enclosingUnitElement)
: importElement = element {
importedElements = element.namespace.definedNames.values.toSet();
}
@@ -153,7 +153,7 @@
return;
}
if (importElement.prefix != null) {
- if (node.staticElement == importElement.prefix) {
+ if (node.staticElement == importElement.prefix?.element) {
var parent = node.parent;
if (parent is PrefixedIdentifier && parent.prefix == node) {
var element = parent.writeOrReadElement?.declaration;
@@ -262,7 +262,7 @@
element, (n) => n is Block, searchedFiles);
}
return _searchReferences_Function(element, searchedFiles);
- } else if (element is ImportElement) {
+ } else if (element is ImportElement2) {
return _searchReferences_Import(element, searchedFiles);
} else if (kind == ElementKind.LABEL ||
kind == ElementKind.LOCAL_VARIABLE) {
@@ -556,7 +556,7 @@
}
Future<List<SearchResult>> _searchReferences_Import(
- ImportElement element, SearchedFiles searchedFiles) async {
+ ImportElement2 element, SearchedFiles searchedFiles) async {
String path = element.source.fullName;
if (!searchedFiles.add(path, this)) {
return const <SearchResult>[];
diff --git a/pkg/analyzer/lib/src/dart/analysis/unlinked_data.dart b/pkg/analyzer/lib/src/dart/analysis/unlinked_data.dart
index 116cd36..43877b2 100644
--- a/pkg/analyzer/lib/src/dart/analysis/unlinked_data.dart
+++ b/pkg/analyzer/lib/src/dart/analysis/unlinked_data.dart
@@ -90,6 +90,71 @@
}
}
+class UnlinkedCombinator {
+ final int keywordOffset;
+ final int endOffset;
+ final bool isShow;
+ final List<String> names;
+
+ UnlinkedCombinator({
+ required this.keywordOffset,
+ required this.endOffset,
+ required this.isShow,
+ required this.names,
+ });
+
+ factory UnlinkedCombinator.read(SummaryDataReader reader) {
+ return UnlinkedCombinator(
+ keywordOffset: reader.readUInt30(),
+ endOffset: reader.readUInt30(),
+ isShow: reader.readBool(),
+ names: reader.readStringUtf8List(),
+ );
+ }
+
+ void write(BufferedSink sink) {
+ sink.writeUInt30(keywordOffset);
+ sink.writeUInt30(endOffset);
+ sink.writeBool(isShow);
+ sink.writeStringUtf8Iterable(names);
+ }
+}
+
+/// Unlinked information about an `export` directive.
+class UnlinkedExportDirective extends UnlinkedNamespaceDirective {
+ UnlinkedExportDirective({
+ required super.combinators,
+ required super.configurations,
+ required super.uri,
+ });
+
+ factory UnlinkedExportDirective.read(SummaryDataReader reader) {
+ return UnlinkedExportDirective(
+ combinators: reader.readTypedList(
+ () => UnlinkedCombinator.read(reader),
+ ),
+ configurations: reader.readTypedList(
+ () => UnlinkedNamespaceDirectiveConfiguration.read(reader),
+ ),
+ uri: reader.readOptionalStringUtf8(),
+ );
+ }
+
+ void write(BufferedSink sink) {
+ sink.writeList<UnlinkedCombinator>(
+ combinators,
+ (x) => x.write(sink),
+ );
+ sink.writeList<UnlinkedNamespaceDirectiveConfiguration>(
+ configurations,
+ (x) {
+ x.write(sink);
+ },
+ );
+ sink.writeOptionalStringUtf8(uri);
+ }
+}
+
class UnlinkedImportAugmentationDirective {
final String? uri;
@@ -110,6 +175,89 @@
}
}
+/// Unlinked information about an 'import' directive.
+class UnlinkedImportDirective extends UnlinkedNamespaceDirective {
+ final int importKeywordOffset;
+ final bool isSyntheticDartCore;
+ final UnlinkedImportDirectivePrefix? prefix;
+
+ UnlinkedImportDirective({
+ required super.combinators,
+ required super.configurations,
+ required this.importKeywordOffset,
+ this.isSyntheticDartCore = false,
+ required this.prefix,
+ required super.uri,
+ });
+
+ factory UnlinkedImportDirective.read(SummaryDataReader reader) {
+ return UnlinkedImportDirective(
+ combinators: reader.readTypedList(
+ () => UnlinkedCombinator.read(reader),
+ ),
+ configurations: reader.readTypedList(
+ () => UnlinkedNamespaceDirectiveConfiguration.read(reader),
+ ),
+ importKeywordOffset: reader.readUInt30() - 1,
+ isSyntheticDartCore: reader.readBool(),
+ prefix: reader.readOptionalObject(
+ UnlinkedImportDirectivePrefix.read,
+ ),
+ uri: reader.readOptionalStringUtf8(),
+ );
+ }
+
+ void write(BufferedSink sink) {
+ sink.writeList<UnlinkedCombinator>(
+ combinators,
+ (x) => x.write(sink),
+ );
+ sink.writeList<UnlinkedNamespaceDirectiveConfiguration>(
+ configurations,
+ (x) {
+ x.write(sink);
+ },
+ );
+ sink.writeUInt30(1 + importKeywordOffset);
+ sink.writeBool(isSyntheticDartCore);
+ sink.writeOptionalObject<UnlinkedImportDirectivePrefix>(
+ prefix,
+ (x) => x.write(sink),
+ );
+ sink.writeOptionalStringUtf8(uri);
+ }
+}
+
+class UnlinkedImportDirectivePrefix {
+ final int? deferredOffset;
+ final int asOffset;
+ final String name;
+ final int nameOffset;
+
+ UnlinkedImportDirectivePrefix({
+ required this.deferredOffset,
+ required this.asOffset,
+ required this.name,
+ required this.nameOffset,
+ });
+
+ factory UnlinkedImportDirectivePrefix.read(SummaryDataReader reader) {
+ return UnlinkedImportDirectivePrefix(
+ deferredOffset: reader.readOptionalUInt30(),
+ asOffset: reader.readUInt30(),
+ name: reader.readStringUtf8(),
+ nameOffset: reader.readUInt30(),
+ );
+ }
+
+ void write(BufferedSink sink) {
+ sink.writeOptionalUInt30(deferredOffset);
+ sink.writeUInt30(asOffset);
+ sink.writeStringUtf8(name);
+ sink.writeUInt30(nameOffset);
+ }
+}
+
class UnlinkedLibraryAugmentationDirective {
final String? uri;
final UnlinkedSourceRange uriRange;
@@ -154,43 +302,16 @@
}
}
-/// Unlinked information about a namespace directive.
-class UnlinkedNamespaceDirective {
- /// The configurations that control which library will actually be used.
+abstract class UnlinkedNamespaceDirective {
+ final List<UnlinkedCombinator> combinators;
final List<UnlinkedNamespaceDirectiveConfiguration> configurations;
-
- final bool isSyntheticDartCoreImport;
-
- /// The URI referenced by this directive, nad used by default when none
- /// of the [configurations] matches.
final String? uri;
UnlinkedNamespaceDirective({
+ required this.combinators,
required this.configurations,
- this.isSyntheticDartCoreImport = false,
required this.uri,
});
-
- factory UnlinkedNamespaceDirective.read(SummaryDataReader reader) {
- return UnlinkedNamespaceDirective(
- configurations: reader.readTypedList(
- () => UnlinkedNamespaceDirectiveConfiguration.read(reader),
- ),
- uri: reader.readOptionalStringUtf8(),
- isSyntheticDartCoreImport: reader.readBool(),
- );
- }
-
- void write(BufferedSink sink) {
- sink.writeList<UnlinkedNamespaceDirectiveConfiguration>(
- configurations,
- (x) {
- x.write(sink);
- },
- );
- sink.writeOptionalStringUtf8(uri);
- sink.writeBool(isSyntheticDartCoreImport);
- }
}
/// Unlinked information about a namespace directive configuration.
@@ -342,10 +463,10 @@
final List<UnlinkedImportAugmentationDirective> augmentations;
/// `export` directives.
- final List<UnlinkedNamespaceDirective> exports;
+ final List<UnlinkedExportDirective> exports;
/// `import` directives.
- final List<UnlinkedNamespaceDirective> imports;
+ final List<UnlinkedImportDirective> imports;
/// Encoded informative data.
final Uint8List informativeBytes;
@@ -397,10 +518,10 @@
() => UnlinkedImportAugmentationDirective.read(reader),
),
exports: reader.readTypedList(
- () => UnlinkedNamespaceDirective.read(reader),
+ () => UnlinkedExportDirective.read(reader),
),
imports: reader.readTypedList(
- () => UnlinkedNamespaceDirective.read(reader),
+ () => UnlinkedImportDirective.read(reader),
),
informativeBytes: reader.readUint8List(),
libraryAugmentationDirective: reader.readOptionalObject(
@@ -431,10 +552,10 @@
sink.writeList<UnlinkedImportAugmentationDirective>(augmentations, (x) {
x.write(sink);
});
- sink.writeList<UnlinkedNamespaceDirective>(exports, (x) {
+ sink.writeList<UnlinkedExportDirective>(exports, (x) {
x.write(sink);
});
- sink.writeList<UnlinkedNamespaceDirective>(imports, (x) {
+ sink.writeList<UnlinkedImportDirective>(imports, (x) {
x.write(sink);
});
sink.writeUint8List(informativeBytes);
diff --git a/pkg/analyzer/lib/src/dart/ast/ast.dart b/pkg/analyzer/lib/src/dart/ast/ast.dart
index 60e5845..b8d68c1 100644
--- a/pkg/analyzer/lib/src/dart/ast/ast.dart
+++ b/pkg/analyzer/lib/src/dart/ast/ast.dart
@@ -15,6 +15,7 @@
import 'package:analyzer/dart/element/type.dart';
import 'package:analyzer/src/dart/ast/to_source_visitor.dart';
import 'package:analyzer/src/dart/ast/token.dart';
+import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/resolver/typed_literal_resolver.dart';
import 'package:analyzer/src/fasta/token_utils.dart' as util show findPrevious;
import 'package:analyzer/src/generated/resolver.dart';
@@ -6420,8 +6421,18 @@
_becomeParentOf(_prefix);
}
+ @Deprecated('Use element2 instead')
@override
- ImportElement? get element => super.element as ImportElement?;
+ ImportElement? get element {
+ final element2 = this.element2;
+ if (element2 != null) {
+ return ImportElementImpl(element2);
+ }
+ return null;
+ }
+
+ @override
+ ImportElement2? get element2 => super.element as ImportElement2?;
@override
Token get firstTokenAfterCommentAndMetadata => importKeyword;
@@ -6439,7 +6450,7 @@
@override
LibraryElement? get uriElement {
- return element?.importedLibrary;
+ return element2?.importedLibrary;
}
@override
@@ -8995,11 +9006,11 @@
bool get isDeferred {
Element? element = _prefix.staticElement;
if (element is PrefixElement) {
- List<ImportElement> imports = element.imports;
+ final imports = element.imports2;
if (imports.length != 1) {
return false;
}
- return imports[0].isDeferred;
+ return imports[0].prefix is DeferredImportElementPrefix;
}
return false;
}
diff --git a/pkg/analyzer/lib/src/dart/ast/element_locator.dart b/pkg/analyzer/lib/src/dart/ast/element_locator.dart
index e0bfc35..dd37049 100644
--- a/pkg/analyzer/lib/src/dart/ast/element_locator.dart
+++ b/pkg/analyzer/lib/src/dart/ast/element_locator.dart
@@ -111,7 +111,7 @@
@override
Element? visitImportDirective(ImportDirective node) {
- return node.element;
+ return node.element2;
}
@override
diff --git a/pkg/analyzer/lib/src/dart/element/display_string_builder.dart b/pkg/analyzer/lib/src/dart/element/display_string_builder.dart
index e9ff526..c3e6e47 100644
--- a/pkg/analyzer/lib/src/dart/element/display_string_builder.dart
+++ b/pkg/analyzer/lib/src/dart/element/display_string_builder.dart
@@ -138,9 +138,9 @@
_writeFormalParameters(element.parameters, forElement: true);
}
- void writeImportElement(ImportElementImpl element) {
+ void writeImportElement(ImportElement2Impl element) {
_write('import ');
- (element.importedLibrary as LibraryElementImpl).appendTo(this);
+ _writeDirectiveUri(element.uri);
}
void writeInterfaceType(InterfaceType type) {
@@ -164,15 +164,7 @@
void writePartElement(PartElementImpl element) {
_write('part ');
-
- final uri = element.uri;
- if (uri is DirectiveUriWithUnitImpl) {
- _write('unit ${uri.unit.source.uri}');
- } else if (uri is DirectiveUriWithSourceImpl) {
- _write('source ${uri.source}');
- } else {
- _write('<unknown>');
- }
+ _writeDirectiveUri(element.uri);
}
void writePrefixElement(PrefixElementImpl element) {
@@ -241,6 +233,16 @@
_buffer.write(str);
}
+ void _writeDirectiveUri(DirectiveUri uri) {
+ if (uri is DirectiveUriWithUnitImpl) {
+ _write('unit ${uri.unit.source.uri}');
+ } else if (uri is DirectiveUriWithSourceImpl) {
+ _write('source ${uri.source}');
+ } else {
+ _write('<unknown>');
+ }
+ }
+
void _writeFormalParameters(
List<ParameterElement> parameters, {
required bool forElement,
diff --git a/pkg/analyzer/lib/src/dart/element/element.dart b/pkg/analyzer/lib/src/dart/element/element.dart
index 8d2924b8..4215c02 100644
--- a/pkg/analyzer/lib/src/dart/element/element.dart
+++ b/pkg/analyzer/lib/src/dart/element/element.dart
@@ -1662,21 +1662,32 @@
}
}
+class DeferredImportElementPrefixImpl extends ImportElementPrefixImpl
+ implements DeferredImportElementPrefix {
+ DeferredImportElementPrefixImpl({
+ required super.element,
+ });
+}
+
class DirectiveUriImpl implements DirectiveUri {}
-class DirectiveUriWithLibraryImpl extends DirectiveUriWithRelativeUriImpl
+class DirectiveUriWithLibraryImpl extends DirectiveUriWithSourceImpl
implements DirectiveUriWithLibrary {
@override
- final LibraryElementImpl library;
+ late LibraryElementImpl library;
DirectiveUriWithLibraryImpl({
required super.relativeUriString,
required super.relativeUri,
+ required super.source,
required this.library,
});
- @override
- Source get source => library.source;
+ DirectiveUriWithLibraryImpl.read({
+ required super.relativeUriString,
+ required super.relativeUri,
+ required super.source,
+ });
}
class DirectiveUriWithRelativeUriImpl
@@ -3613,42 +3624,38 @@
}
}
-/// A concrete implementation of an [ImportElement].
-class ImportElementImpl extends UriReferencedElementImpl
- implements ImportElement {
- @override
- LibraryElement? importedLibrary;
-
- @override
- PrefixElement? prefix;
-
+class ImportElement2Impl extends _ExistingElementImpl
+ implements ImportElement2 {
@override
List<NamespaceCombinator> combinators = const [];
- /// The cached value of [namespace].
+ @override
+ final int importKeywordOffset;
+
+ @override
+ final ImportElementPrefix? prefix;
+
+ @override
+ final DirectiveUri uri;
+
Namespace? _namespace;
- /// Initialize a newly created import element at the given [offset].
- /// The offset may be `-1` if the import is synthetic.
- ImportElementImpl(int offset) : super(null, offset);
+ ImportElement2Impl({
+ required this.importKeywordOffset,
+ required this.prefix,
+ required this.uri,
+ }) : super(null, importKeywordOffset);
@override
- CompilationUnitElementImpl get enclosingUnit {
- var enclosingLibrary = enclosingElement as LibraryElementImpl;
- return enclosingLibrary._definingCompilationUnit;
- }
+ int get hashCode => identityHashCode(this);
@override
- String get identifier => "${importedLibrary?.identifier}@$nameOffset";
-
- @override
- bool get isDeferred {
- return hasModifier(Modifier.DEFERRED);
- }
-
- /// Set whether this import is for a deferred library.
- set isDeferred(bool isDeferred) {
- setModifier(Modifier.DEFERRED, isDeferred);
+ LibraryElement? get importedLibrary {
+ final uri = this.uri;
+ if (uri is DirectiveUriWithLibrary) {
+ return uri.library;
+ }
+ return null;
}
@override
@@ -3656,25 +3663,264 @@
@override
Namespace get namespace {
- return _namespace ??=
- NamespaceBuilder().createImportNamespaceForDirective(this);
+ final uri = this.uri;
+ if (uri is DirectiveUriWithLibrary) {
+ return _namespace ??=
+ NamespaceBuilder().createImportNamespaceForDirective(
+ importedLibrary: uri.library,
+ combinators: combinators,
+ prefix: prefix?.element,
+ );
+ }
+ return Namespace.EMPTY;
}
@override
- T? accept<T>(ElementVisitor<T> visitor) => visitor.visitImportElement(this);
+ bool operator ==(Object other) {
+ return identical(this, other);
+ }
+
+ @override
+ T? accept<T>(ElementVisitor<T> visitor) {
+ return visitor.visitImportElement2(this);
+ }
@override
void appendTo(ElementDisplayStringBuilder builder) {
builder.writeImportElement(this);
}
+}
+
+/// A concrete implementation of an [ImportElement].
+@Deprecated('Use ImportElement2 instead')
+class ImportElementImpl extends ElementImpl implements ImportElement {
+ final ImportElement2 base;
+
+ ImportElementImpl(this.base) : super(base.name, base.nameOffset);
+
+ @override
+ List<NamespaceCombinator> get combinators => base.combinators;
+
+ @override
+ AnalysisContext get context => base.context;
+
+ @override
+ Element get declaration => base.declaration;
+
+ @override
+ String get displayName => base.displayName;
+
+ @override
+ String? get documentationComment => base.documentationComment;
+
+ @override
+ Element? get enclosingElement => base.enclosingElement;
+
+ @override
+ bool get hasAlwaysThrows => base.hasAlwaysThrows;
+
+ @override
+ bool get hasDeprecated => base.hasDeprecated;
+
+ @override
+ bool get hasDoNotStore => base.hasDoNotStore;
+
+ @override
+ bool get hasFactory => base.hasFactory;
+
+ @override
+ bool get hasInternal => base.hasInternal;
+
+ @override
+ bool get hasIsTest => base.hasIsTest;
+
+ @override
+ bool get hasIsTestGroup => base.hasIsTestGroup;
+
+ @override
+ bool get hasJS => base.hasJS;
+
+ @override
+ bool get hasLiteral => base.hasLiteral;
+
+ @override
+ bool get hasMustCallSuper => base.hasMustCallSuper;
+
+ @override
+ bool get hasNonVirtual => base.hasNonVirtual;
+
+ @override
+ bool get hasOptionalTypeArgs => base.hasOptionalTypeArgs;
+
+ @override
+ bool get hasOverride => base.hasOverride;
+
+ @override
+ bool get hasProtected => base.hasProtected;
+
+ @override
+ bool get hasRequired => base.hasRequired;
+
+ @override
+ bool get hasSealed => base.hasSealed;
+
+ @override
+ bool get hasUseResult => base.hasUseResult;
+
+ @override
+ bool get hasVisibleForOverriding => base.hasVisibleForOverriding;
+
+ @override
+ bool get hasVisibleForTemplate => base.hasVisibleForTemplate;
+
+ @override
+ bool get hasVisibleForTesting => base.hasVisibleForTesting;
+
+ @override
+ int get id => base.id;
+
+ @override
+ String get identifier => 'import@$nameOffset';
+
+ @override
+ LibraryElement? get importedLibrary {
+ final uri = base.uri;
+ if (uri is DirectiveUriWithLibrary) {
+ return uri.library;
+ }
+ return null;
+ }
+
+ @override
+ bool get isDeferred => base.prefix is DeferredImportElementPrefix;
+
+ @override
+ bool get isPrivate => base.isPrivate;
+
+ @override
+ bool get isPublic => base.isPublic;
+
+ @override
+ bool get isSynthetic => base.isSynthetic;
+
+ @override
+ ElementKind get kind => base.kind;
+
+ @override
+ LibraryElementImpl get library => base.library as LibraryElementImpl;
+
+ @override
+ Source get librarySource => base.librarySource;
+
+ @override
+ ElementLocation get location => base.location!;
+
+ @override
+ List<ElementAnnotation> get metadata => base.metadata;
+
+ @override
+ String? get name => base.name;
+
+ @override
+ int get nameLength => base.nameLength;
+
+ @override
+ int get nameOffset => base.nameOffset;
+
+ @override
+ Namespace get namespace => base.namespace;
+
+ @override
+ Element get nonSynthetic => this;
+
+ @override
+ PrefixElement? get prefix => base.prefix?.element;
+
+ @override
+ AnalysisSession? get session => base.session;
+
+ @override
+ Source get source => base.source;
+
+ @override
+ String? get uri {
+ final uri = base.uri;
+ if (uri is DirectiveUriWithRelativeUriString) {
+ return uri.relativeUriString;
+ } else {
+ return null;
+ }
+ }
+
+ @override
+ // TODO: implement uriEnd
+ int get uriEnd => throw UnimplementedError();
+
+ @override
+ // TODO: implement uriOffset
+ int get uriOffset => throw UnimplementedError();
+
+ @override
+ bool operator ==(Object other) {
+ return identical(this, other);
+ }
+
+ @override
+ T? accept<T>(ElementVisitor<T> visitor) {
+ return visitor.visitImportElement(this);
+ }
+
+ @override
+ String getDisplayString(
+ {required bool withNullability, bool multiline = false}) {
+ return base.getDisplayString(
+ withNullability: withNullability,
+ multiline: multiline,
+ );
+ }
+
+ @override
+ String getExtendedDisplayName(String? shortName) {
+ return base.getExtendedDisplayName(shortName);
+ }
+
+ @Deprecated('Use isAccessibleIn2() instead')
+ @override
+ bool isAccessibleIn(LibraryElement? library) {
+ return base.isAccessibleIn(library);
+ }
+
+ @override
+ bool isAccessibleIn2(LibraryElement library) {
+ return base.isAccessibleIn2(library);
+ }
+
+ @override
+ E thisOrAncestorMatching<E extends Element>(
+ bool Function(Element p1) predicate) {
+ return base.thisOrAncestorMatching(predicate) as E;
+ }
+
+ @override
+ E? thisOrAncestorOfType<E extends Element>() {
+ return base.thisOrAncestorOfType();
+ }
@override
void visitChildren(ElementVisitor visitor) {
- super.visitChildren(visitor);
- prefix?.accept(visitor);
+ base.visitChildren(visitor);
}
}
+class ImportElementPrefixImpl implements ImportElementPrefix {
+ @override
+ final PrefixElement element;
+
+ ImportElementPrefixImpl({
+ required this.element,
+ });
+}
+
/// A concrete implementation of a [LabelElement].
class LabelElementImpl extends ElementImpl implements LabelElement {
/// A flag indicating whether this label is associated with a `switch`
@@ -3736,6 +3982,10 @@
FeatureSet get featureSet => augmented.featureSet;
@override
+ // TODO: implement imports2
+ List<ImportElement2> get imports2 => throw UnimplementedError();
+
+ @override
bool get isNonNullableByDefault => augmented.isNonNullableByDefault;
@override
@@ -3897,20 +4147,24 @@
@override
List<LibraryElement> get importedLibraries {
- HashSet<LibraryElement> libraries = HashSet<LibraryElement>();
- for (ImportElement element in imports) {
- var library = element.importedLibrary;
- if (library != null) {
- libraries.add(library);
- }
- }
- return libraries.toList(growable: false);
+ return imports2
+ .map((import) => import.uri)
+ .whereType<DirectiveUriWithLibrary>()
+ .map((uri) => uri.library)
+ .toSet()
+ .toList();
+ }
+
+ @Deprecated('Use imports2 instead')
+ @override
+ List<ImportElement> get imports {
+ return imports2.map(ImportElementImpl.new).toList();
}
@override
- List<ImportElement> get imports {
+ List<ImportElement2> get imports2 {
linkedData?.read(this);
- return _imports;
+ return _imports2;
}
@override
@@ -4018,7 +4272,7 @@
@override
List<PrefixElement> get prefixes =>
- _prefixes ??= buildPrefixesFromImports(imports);
+ _prefixes ??= buildPrefixesFromImports(imports2);
@override
Namespace get publicNamespace {
@@ -4124,8 +4378,8 @@
required String? prefix,
required String name,
}) {
- for (var importElement in imports) {
- if (importElement.prefix?.name == prefix &&
+ for (var importElement in imports2) {
+ if (importElement.prefix?.element.name == prefix &&
importElement.importedLibrary?.isSynthetic != false) {
var showCombinators = importElement.combinators
.whereType<ShowElementCombinator>()
@@ -4193,10 +4447,10 @@
}
static List<PrefixElement> buildPrefixesFromImports(
- List<ImportElement> imports) {
+ List<ImportElement2> imports) {
HashSet<PrefixElement> prefixes = HashSet<PrefixElement>();
- for (ImportElement element in imports) {
- var prefix = element.prefix;
+ for (ImportElement2 element in imports) {
+ var prefix = element.prefix?.element;
if (prefix != null) {
prefixes.add(prefix);
}
@@ -4233,7 +4487,7 @@
/// A list containing specifications of all of the imports defined in this
/// library.
- List<ImportElement> _imports = _Sentinel.importElement;
+ List<ImportElement2> _imports2 = _Sentinel.importElement2;
/// A list containing specifications of all of the exports defined in this
/// library.
@@ -4297,32 +4551,29 @@
@override
String get identifier => '${_definingCompilationUnit.source.uri}';
+ @Deprecated('Use imports2 instead')
@override
List<ImportElement> get imports {
- return _imports;
+ return _imports2.map(ImportElementImpl.new).toList();
}
/// Set the specifications of all of the imports defined in this library to
/// the given list of [imports].
- set imports(List<ImportElement> imports) {
- for (ImportElement importElement in imports) {
- (importElement as ImportElementImpl).enclosingElement = this;
- var prefix = importElement.prefix as PrefixElementImpl?;
- if (prefix != null) {
- prefix.enclosingElement = this;
- }
+ set imports2(List<ImportElement2> imports) {
+ for (final importElement in imports) {
+ (importElement as ImportElement2Impl).enclosingElement = this;
}
- _imports = imports;
+ _imports2 = imports;
_prefixes = null;
}
- List<ImportElement> get imports_unresolved {
- return _imports;
+ List<ImportElement2> get imports_unresolved {
+ return _imports2;
}
@override
List<PrefixElement> get prefixes =>
- _prefixes ??= buildPrefixesFromImports(imports);
+ _prefixes ??= buildPrefixesFromImports(imports2);
@override
AnalysisSessionImpl get session;
@@ -4337,16 +4588,18 @@
super.visitChildren(visitor);
_definingCompilationUnit.accept(visitor);
safelyVisitChildren(exports, visitor);
+ // ignore: deprecated_member_use_from_same_package
safelyVisitChildren(imports, visitor);
+ safelyVisitChildren(imports2, visitor);
}
static List<PrefixElement> buildPrefixesFromImports(
- List<ImportElement> imports) {
+ List<ImportElement2> imports) {
HashSet<PrefixElement> prefixes = HashSet<PrefixElement>();
- for (ImportElement element in imports) {
- var prefix = element.prefix;
+ for (final import in imports) {
+ var prefix = import.prefix;
if (prefix != null) {
- prefixes.add(prefix);
+ prefixes.add(prefix.element);
}
}
return prefixes.toList(growable: false);
@@ -5227,6 +5480,7 @@
LibraryOrAugmentationElementImpl get enclosingElement2 =>
super.enclosingElement as LibraryOrAugmentationElementImpl;
+ @Deprecated('Use imports2 instead')
@override
List<ImportElement> get imports {
return enclosingElement2.imports
@@ -5235,6 +5489,13 @@
}
@override
+ List<ImportElement2> get imports2 {
+ return enclosingElement2.imports2
+ .where((import) => import.prefix?.element == this)
+ .toList();
+ }
+
+ @override
ElementKind get kind => ElementKind.PREFIX;
@override
@@ -6271,7 +6532,7 @@
static final List<FieldElement> fieldElement = List.unmodifiable([]);
static final List<AugmentationImportElement> augmentationImportElement =
List.unmodifiable([]);
- static final List<ImportElement> importElement = List.unmodifiable([]);
+ static final List<ImportElement2> importElement2 = List.unmodifiable([]);
static final List<MethodElement> methodElement = List.unmodifiable([]);
static final List<PropertyAccessorElement> propertyAccessorElement =
List.unmodifiable([]);
diff --git a/pkg/analyzer/lib/src/dart/element/scope.dart b/pkg/analyzer/lib/src/dart/element/scope.dart
index f57b6e0..1fab302 100644
--- a/pkg/analyzer/lib/src/dart/element/scope.dart
+++ b/pkg/analyzer/lib/src/dart/element/scope.dart
@@ -118,6 +118,16 @@
_element.prefixes.forEach(_addGetter);
_element.units.forEach(_addUnitElements);
+
+ // TODO(scheglov) I don't understand why it used to work, but broke now.
+ // Now: when I'm adding `ImportElement2`.
+ // We used to get it from `exportedReference`, but this is wrong.
+ // These elements are declared in dart:core itself.
+ final reference = _element.reference!;
+ if (reference.name == 'dart:core') {
+ _addGetter(DynamicElementImpl.instance);
+ _addGetter(NeverElementImpl.instance);
+ }
}
void _addExtension(ExtensionElement element) {
@@ -155,9 +165,11 @@
PrefixScope(this._library, PrefixElement? prefix) {
final elementFactory = _library.session.elementFactory;
- for (final import in _library.imports) {
- if (import.prefix == prefix) {
- final importedLibrary = import.importedLibrary;
+ for (final import in _library.imports2) {
+ final importedUri = import.uri;
+ if (importedUri is DirectiveUriWithLibrary &&
+ import.prefix?.element == prefix) {
+ final importedLibrary = importedUri.library;
if (importedLibrary is LibraryElementImpl) {
final combinators = import.combinators.build();
for (final exportedReference in importedLibrary.exportedReferences) {
@@ -172,7 +184,7 @@
_add(importedElement);
}
}
- if (import.isDeferred) {
+ if (import.prefix is DeferredImportElementPrefix) {
_deferredLibrary ??= importedLibrary;
}
}
diff --git a/pkg/analyzer/lib/src/dart/micro/resolve_file.dart b/pkg/analyzer/lib/src/dart/micro/resolve_file.dart
index 055b894..0e87bbf 100644
--- a/pkg/analyzer/lib/src/dart/micro/resolve_file.dart
+++ b/pkg/analyzer/lib/src/dart/micro/resolve_file.dart
@@ -288,7 +288,7 @@
if (element is LocalVariableElement ||
(element is ParameterElement && !element.isNamed)) {
await collectReferences2(element.source!.fullName, performance!);
- } else if (element is ImportElement) {
+ } else if (element is ImportElement2) {
return await _searchReferences_Import(element);
} else {
var result = performance!.run('getFilesContaining', (performance) {
@@ -842,7 +842,7 @@
}
Future<List<CiderSearchMatch>> _searchReferences_Import(
- ImportElement element) async {
+ ImportElement2 element) async {
var results = <CiderSearchMatch>[];
LibraryElement libraryElement = element.library;
for (CompilationUnitElement unitElement in libraryElement.units) {
diff --git a/pkg/analyzer/lib/src/dart/micro/utils.dart b/pkg/analyzer/lib/src/dart/micro/utils.dart
index fc88c98..a4e9419 100644
--- a/pkg/analyzer/lib/src/dart/micro/utils.dart
+++ b/pkg/analyzer/lib/src/dart/micro/utils.dart
@@ -28,7 +28,7 @@
if (node is SimpleIdentifier && element is PrefixElement) {
var parent = node.parent;
if (parent is ImportDirective) {
- element = parent.element;
+ element = parent.element2;
} else {
element = _getImportElementInfo(node);
}
@@ -62,27 +62,27 @@
return constructor;
}
-/// Return the [ImportElement] that declared [prefix] and imports [element].
+/// Return the [ImportElement2] that declared [prefix] and imports [element].
///
/// [libraryElement] - the [LibraryElement] where reference is.
/// [prefix] - the import prefix, maybe `null`.
/// [element] - the referenced element.
-/// [importElementsMap] - the cache of [Element]s imported by [ImportElement]s.
-ImportElement? _getImportElement(LibraryElement libraryElement, String prefix,
- Element element, Map<ImportElement, Set<Element>> importElementsMap) {
+/// [importElementsMap] - the cache of [Element]s imported by [ImportElement2]s.
+ImportElement2? _getImportElement(LibraryElement libraryElement, String prefix,
+ Element element, Map<ImportElement2, Set<Element>> importElementsMap) {
if (element.enclosingElement is! CompilationUnitElement) {
return null;
}
var usedLibrary = element.library;
// find ImportElement that imports used library with used prefix
- List<ImportElement>? candidates;
- for (var importElement in libraryElement.imports) {
+ List<ImportElement2>? candidates;
+ for (var importElement in libraryElement.imports2) {
// required library
if (importElement.importedLibrary != usedLibrary) {
continue;
}
// required prefix
- var prefixElement = importElement.prefix;
+ var prefixElement = importElement.prefix?.element;
if (prefixElement == null) {
continue;
}
@@ -126,9 +126,9 @@
return null;
}
-/// Returns the [ImportElement] that is referenced by [prefixNode] with a
+/// Returns the [ImportElement2] that is referenced by [prefixNode] with a
/// [PrefixElement], maybe `null`.
-ImportElement? _getImportElementInfo(SimpleIdentifier prefixNode) {
+ImportElement2? _getImportElementInfo(SimpleIdentifier prefixNode) {
// prepare environment
var parent = prefixNode.parent;
var unit = prefixNode.thisOrAncestorOfType<CompilationUnit>();
@@ -155,7 +155,7 @@
}
// find ImportElement
var prefix = prefixNode.name;
- var importElementsMap = <ImportElement, Set<Element>>{};
+ var importElementsMap = <ImportElement2, Set<Element>>{};
return _getImportElement(
libraryElement, prefix, usedElement, importElementsMap);
}
diff --git a/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart
index 0906db3..79d5949 100644
--- a/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/binary_expression_resolver.dart
@@ -111,7 +111,7 @@
left = node.leftOperand;
var flow = _resolver.flowAnalysis.flow;
- EqualityInfo<PromotableElement, DartType>? leftInfo;
+ EqualityInfo<DartType>? leftInfo;
var leftExtensionOverride = left is ExtensionOverride;
if (!leftExtensionOverride) {
leftInfo = flow?.equalityOperand_end(left, left.typeOrThrow);
diff --git a/pkg/analyzer/lib/src/dart/resolver/invocation_inferrer.dart b/pkg/analyzer/lib/src/dart/resolver/invocation_inferrer.dart
index b9fcb2c..729d28a 100644
--- a/pkg/analyzer/lib/src/dart/resolver/invocation_inferrer.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/invocation_inferrer.dart
@@ -203,8 +203,7 @@
Substitution.fromPairs(rawType.typeFormals, inferrer.partialInfer());
}
- List<EqualityInfo<PromotableElement, DartType>?>? identicalInfo =
- _isIdentical ? [] : null;
+ List<EqualityInfo<DartType>?>? identicalInfo = _isIdentical ? [] : null;
var parameterMap = _computeParameterMap(rawType?.parameters ?? const []);
var deferredFunctionLiterals = _visitArguments(
parameterMap: parameterMap,
@@ -434,8 +433,7 @@
/// If the invocation being processed is a call to `identical`, informs flow
/// analysis about it, so that it can do appropriate promotions.
- void _recordIdenticalInfo(
- List<EqualityInfo<PromotableElement, DartType>?>? identicalInfo) {
+ void _recordIdenticalInfo(List<EqualityInfo<DartType>?>? identicalInfo) {
var flow = resolver.flowAnalysis.flow;
if (identicalInfo != null) {
flow?.equalityOperation_end(argumentList.parent as Expression,
@@ -446,7 +444,7 @@
/// Resolves any function literals that were deferred by [_visitArguments].
void _resolveDeferredFunctionLiterals(
{required List<_DeferredParamInfo> deferredFunctionLiterals,
- List<EqualityInfo<PromotableElement, DartType>?>? identicalInfo,
+ List<EqualityInfo<DartType>?>? identicalInfo,
Substitution? substitution,
GenericInferrer? inferrer}) {
var flow = resolver.flowAnalysis.flow;
@@ -481,7 +479,7 @@
/// returned.
List<_DeferredParamInfo>? _visitArguments(
{required Map<Object, ParameterElement> parameterMap,
- List<EqualityInfo<PromotableElement, DartType>?>? identicalInfo,
+ List<EqualityInfo<DartType>?>? identicalInfo,
Substitution? substitution,
GenericInferrer? inferrer}) {
assert(whyNotPromotedList.isEmpty);
diff --git a/pkg/analyzer/lib/src/dart/resolver/method_invocation_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/method_invocation_resolver.dart
index 6d951b3..13368ab 100644
--- a/pkg/analyzer/lib/src/dart/resolver/method_invocation_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/method_invocation_resolver.dart
@@ -665,8 +665,9 @@
// Note: prefix?.bar is reported as an error in ElementResolver.
if (name == FunctionElement.LOAD_LIBRARY_NAME) {
- var imports = prefix.imports;
- if (imports.length == 1 && imports[0].isDeferred) {
+ var imports = prefix.imports2;
+ if (imports.length == 1 &&
+ imports[0].prefix is DeferredImportElementPrefix) {
var importedLibrary = imports[0].importedLibrary;
var element = importedLibrary?.loadLibraryFunction;
element = _resolver.toLegacyElement(element);
diff --git a/pkg/analyzer/lib/src/dart/resolver/resolution_visitor.dart b/pkg/analyzer/lib/src/dart/resolver/resolution_visitor.dart
index 781f48e..5f94025 100644
--- a/pkg/analyzer/lib/src/dart/resolver/resolution_visitor.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/resolution_visitor.dart
@@ -757,8 +757,8 @@
@override
void visitImportDirective(ImportDirective node) {
- var element = node.element;
- if (element is ImportElementImpl) {
+ var element = node.element2;
+ if (element is ImportElement2Impl) {
_setOrCreateMetadataElements(element, node.metadata);
}
diff --git a/pkg/analyzer/lib/src/dart/resolver/scope.dart b/pkg/analyzer/lib/src/dart/resolver/scope.dart
index 84552fb..79865a7 100644
--- a/pkg/analyzer/lib/src/dart/resolver/scope.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/scope.dart
@@ -158,18 +158,13 @@
/// Create a namespace representing the import namespace of the given
/// [element].
- Namespace createImportNamespaceForDirective(ImportElement element) {
- var importedLibrary = element.importedLibrary;
- if (importedLibrary == null) {
- //
- // The imported library will be null if the URI does not reference a valid
- // library.
- //
- return Namespace.EMPTY;
- }
+ Namespace createImportNamespaceForDirective({
+ required LibraryElement importedLibrary,
+ required List<NamespaceCombinator> combinators,
+ required PrefixElement? prefix,
+ }) {
Map<String, Element> exportedNames = _getExportMapping(importedLibrary);
- exportedNames = _applyCombinators(exportedNames, element.combinators);
- var prefix = element.prefix;
+ exportedNames = _applyCombinators(exportedNames, combinators);
if (prefix != null) {
return PrefixedNamespace(prefix.name, exportedNames);
}
diff --git a/pkg/analyzer/lib/src/error/best_practices_verifier.dart b/pkg/analyzer/lib/src/error/best_practices_verifier.dart
index 4f5dc3e..bd89227 100644
--- a/pkg/analyzer/lib/src/error/best_practices_verifier.dart
+++ b/pkg/analyzer/lib/src/error/best_practices_verifier.dart
@@ -584,8 +584,9 @@
@override
void visitImportDirective(ImportDirective node) {
_deprecatedVerifier.importDirective(node);
- var importElement = node.element;
- if (importElement != null && importElement.isDeferred) {
+ var importElement = node.element2;
+ if (importElement != null &&
+ importElement.prefix is DeferredImportElementPrefix) {
_checkForLoadLibraryFunction(node, importElement);
}
_invalidAccessVerifier.verifyImport(node);
@@ -1039,7 +1040,7 @@
return;
}
- var importElement = node.element;
+ var importElement = node.element2;
if (importElement == null) {
return;
}
@@ -1234,14 +1235,14 @@
/// The import has already been determined to be deferred when this is called.
///
/// @param node the import directive to evaluate
- /// @param importElement the [ImportElement] retrieved from the node
+ /// @param importElement the [ImportElement2] retrieved from the node
/// @return `true` if and only if an error code is generated on the passed
/// node
/// See [CompileTimeErrorCode.IMPORT_DEFERRED_LIBRARY_WITH_LOAD_FUNCTION].
bool _checkForLoadLibraryFunction(
- ImportDirective node, ImportElement importElement) {
+ ImportDirective node, ImportElement2 importElement) {
var importedLibrary = importElement.importedLibrary;
- var prefix = importElement.prefix;
+ var prefix = importElement.prefix?.element;
if (importedLibrary == null || prefix == null) {
return false;
}
diff --git a/pkg/analyzer/lib/src/error/dead_code_verifier.dart b/pkg/analyzer/lib/src/error/dead_code_verifier.dart
index 1890e65..9339c45 100644
--- a/pkg/analyzer/lib/src/error/dead_code_verifier.dart
+++ b/pkg/analyzer/lib/src/error/dead_code_verifier.dart
@@ -62,7 +62,7 @@
@override
void visitImportDirective(ImportDirective node) {
- ImportElement? importElement = node.element;
+ final importElement = node.element2;
if (importElement != null) {
// The element is null when the URI is invalid, but not when the URI is
// valid but refers to a non-existent file.
diff --git a/pkg/analyzer/lib/src/error/duplicate_definition_verifier.dart b/pkg/analyzer/lib/src/error/duplicate_definition_verifier.dart
index 55cd57b4..9e725a5 100644
--- a/pkg/analyzer/lib/src/error/duplicate_definition_verifier.dart
+++ b/pkg/analyzer/lib/src/error/duplicate_definition_verifier.dart
@@ -318,8 +318,8 @@
}
}
- for (ImportElement importElement in _currentLibrary.imports) {
- var prefix = importElement.prefix;
+ for (final importElement in _currentLibrary.imports2) {
+ var prefix = importElement.prefix?.element;
if (prefix != null) {
definedGetters[prefix.name] = prefix;
}
diff --git a/pkg/analyzer/lib/src/error/imports_verifier.dart b/pkg/analyzer/lib/src/error/imports_verifier.dart
index 52781b7..4c990ff 100644
--- a/pkg/analyzer/lib/src/error/imports_verifier.dart
+++ b/pkg/analyzer/lib/src/error/imports_verifier.dart
@@ -390,7 +390,7 @@
for (int i = 0; i < length; i++) {
ImportDirective unusedImport = _unusedImports[i];
// Check that the imported URI exists and isn't dart:core
- var importElement = unusedImport.element;
+ var importElement = unusedImport.element2;
if (importElement != null) {
var libraryElement = importElement.importedLibrary;
if (libraryElement == null ||
@@ -776,7 +776,7 @@
Namespace? computeNamespace(ImportDirective importDirective) {
var namespace = this[importDirective];
if (namespace == null) {
- var importElement = importDirective.element;
+ var importElement = importDirective.element2;
if (importElement != null) {
namespace = importElement.namespace;
this[importDirective] = namespace;
diff --git a/pkg/analyzer/lib/src/generated/element_resolver.dart b/pkg/analyzer/lib/src/generated/element_resolver.dart
index 9ae6c75..26fca88 100644
--- a/pkg/analyzer/lib/src/generated/element_resolver.dart
+++ b/pkg/analyzer/lib/src/generated/element_resolver.dart
@@ -26,7 +26,7 @@
/// * An identifier within the declaration of that name should resolve to the
/// element being declared.
/// * An identifier denoting a prefix should resolve to the element
-/// representing the import that defines the prefix (an [ImportElement]).
+/// representing the import that defines the prefix (an [ImportElement2]).
/// * An identifier denoting a variable should resolve to the element
/// representing the variable (a [VariableElement]).
/// * An identifier denoting a parameter should resolve to the element
@@ -56,7 +56,7 @@
/// specified library does not exist.
/// 5. Every [ImportDirective] and [ExportDirective] should resolve to the
/// element representing the library being specified by the directive unless
-/// the specified library does not exist (an [ImportElement] or
+/// the specified library does not exist (an [ImportElement2] or
/// [ExportElement]).
/// 6. The identifier representing the prefix in an [ImportDirective] should
/// resolve to the element representing the prefix (a [PrefixElement]).
@@ -240,7 +240,7 @@
}
}
}
- var importElement = node.element;
+ var importElement = node.element2;
if (importElement != null) {
// The element is null when the URI is invalid
var library = importElement.importedLibrary;
diff --git a/pkg/analyzer/lib/src/generated/error_verifier.dart b/pkg/analyzer/lib/src/generated/error_verifier.dart
index 01f79da..28d5b16 100644
--- a/pkg/analyzer/lib/src/generated/error_verifier.dart
+++ b/pkg/analyzer/lib/src/generated/error_verifier.dart
@@ -857,14 +857,14 @@
@override
void visitImportDirective(ImportDirective node) {
- var importElement = node.element;
+ var importElement = node.element2;
if (node.prefix != null) {
_checkForBuiltInIdentifierAsName(node.prefix!,
CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_PREFIX_NAME);
}
if (importElement != null) {
_checkForImportInternalLibrary(node, importElement);
- if (importElement.isDeferred) {
+ if (importElement.prefix is DeferredImportElementPrefix) {
_checkForDeferredImportOfExtensions(node, importElement);
}
}
@@ -2299,7 +2299,7 @@
/// Report a diagnostic if there are any extensions in the imported library
/// that are not hidden.
void _checkForDeferredImportOfExtensions(
- ImportDirective directive, ImportElement importElement) {
+ ImportDirective directive, ImportElement2 importElement) {
for (var element in importElement.namespace.definedNames.values) {
if (element is ExtensionElement) {
errorReporter.reportErrorForNode(
@@ -2872,12 +2872,12 @@
/// Check that if the visiting library is not system, then any given library
/// should not be SDK internal library. The [importElement] is the
- /// [ImportElement] retrieved from the node, if the element in the node was
+ /// [ImportElement2] retrieved from the node, if the element in the node was
/// `null`, then this method is not called
///
/// See [CompileTimeErrorCode.IMPORT_INTERNAL_LIBRARY].
void _checkForImportInternalLibrary(
- ImportDirective directive, ImportElement importElement) {
+ ImportDirective directive, ImportElement2 importElement) {
if (_isInSystemLibrary) {
return;
}
@@ -5096,7 +5096,7 @@
if (library == null) {
return '';
}
- List<ImportElement> imports = _currentLibrary.imports;
+ final imports = _currentLibrary.imports2;
int count = imports.length;
for (int i = 0; i < count; i++) {
if (identical(imports[i].importedLibrary, library)) {
diff --git a/pkg/analyzer/lib/src/generated/testing/element_factory.dart b/pkg/analyzer/lib/src/generated/testing/element_factory.dart
index 68896c6..49121ab4 100644
--- a/pkg/analyzer/lib/src/generated/testing/element_factory.dart
+++ b/pkg/analyzer/lib/src/generated/testing/element_factory.dart
@@ -195,16 +195,6 @@
return getter;
}
- static ImportElementImpl importFor(
- LibraryElement importedLibrary, PrefixElement? prefix,
- [List<NamespaceCombinator> combinators = const <NamespaceCombinator>[]]) {
- ImportElementImpl spec = ImportElementImpl(0);
- spec.importedLibrary = importedLibrary;
- spec.prefix = prefix;
- spec.combinators = combinators;
- return spec;
- }
-
static LibraryElementImpl library(
AnalysisContext context, String libraryName) {
String fileName = "/$libraryName.dart";
diff --git a/pkg/analyzer/lib/src/summary2/ast_binary_tag.dart b/pkg/analyzer/lib/src/summary2/ast_binary_tag.dart
index 83c6aea..a59dff8 100644
--- a/pkg/analyzer/lib/src/summary2/ast_binary_tag.dart
+++ b/pkg/analyzer/lib/src/summary2/ast_binary_tag.dart
@@ -16,6 +16,12 @@
withNothing,
}
+enum ImportElementPrefixKind {
+ isDeferred,
+ isNotDeferred,
+ isNull,
+}
+
class Tag {
static const int Nothing = 0;
static const int Something = 1;
@@ -103,6 +109,7 @@
static const int MemberLegacyWithoutTypeArguments = 1;
static const int MemberLegacyWithTypeArguments = 2;
static const int MemberWithTypeArguments = 3;
+ static const int ImportPrefixElement = 4;
static const int ParameterKindRequiredPositional = 1;
static const int ParameterKindOptionalPositional = 2;
diff --git a/pkg/analyzer/lib/src/summary2/bundle_reader.dart b/pkg/analyzer/lib/src/summary2/bundle_reader.dart
index aa14833f..268706f 100644
--- a/pkg/analyzer/lib/src/summary2/bundle_reader.dart
+++ b/pkg/analyzer/lib/src/summary2/bundle_reader.dart
@@ -370,12 +370,15 @@
unitElement: unitElement,
);
- for (var import in element.imports) {
- import as ImportElementImpl;
+ for (var import in element.imports2) {
+ import as ImportElement2Impl;
import.metadata = reader._readAnnotationList(
unitElement: unitElement,
);
- import.importedLibrary = reader.readElement() as LibraryElementImpl?;
+ final uri = import.uri;
+ if (uri is DirectiveUriWithLibraryImpl) {
+ uri.library = reader.libraryOfUri(uri.source.uri);
+ }
}
for (var export in element.exports) {
@@ -445,14 +448,22 @@
libraryElement.reference = _reference;
libraryElement.languageVersion = _readLanguageVersion();
- libraryElement.imports = _reader.readTypedList(_readImportElement);
+ libraryElement.imports2 = _reader.readTypedList(() {
+ return _readImportElement(
+ libraryElement: libraryElement,
+ );
+ });
libraryElement.exports = _reader.readTypedList(_readExportElement);
LibraryElementFlags.read(_reader, libraryElement);
- var unitContainerRef = _reference.getChild('@unit');
+ for (final import in libraryElement.imports2) {
+ final prefixElement = import.prefix?.element;
+ if (prefixElement is PrefixElementImpl) {
+ libraryElement.encloseElement(prefixElement);
+ }
+ }
libraryElement.definingCompilationUnit = _readUnitElement(
- unitContainerRef: unitContainerRef,
libraryElement: libraryElement,
librarySource: librarySource,
unitSource: librarySource,
@@ -460,7 +471,6 @@
libraryElement.parts2 = _reader.readTypedList(() {
return _readPartElement(
- unitContainerRef: unitContainerRef,
libraryElement: libraryElement,
);
});
@@ -581,7 +591,6 @@
}
DirectiveUri _readDirectiveUri({
- required Reference unitContainerRef,
required LibraryElementImpl libraryElement,
}) {
DirectiveUriWithRelativeUriStringImpl readWithRelativeUriString() {
@@ -608,12 +617,15 @@
final sourceUriStr = _reader.readStringReference();
final sourceUri = Uri.parse(sourceUriStr);
- final source = sourceFactory.forUri2(sourceUri)!;
+ final source = sourceFactory.forUri2(sourceUri);
+
+ // TODO(scheglov) https://github.com/dart-lang/sdk/issues/49431
+ final fixedSource = source ?? sourceFactory.forUri('dart:math')!;
return DirectiveUriWithSourceImpl(
relativeUriString: parent.relativeUriString,
relativeUri: parent.relativeUri,
- source: source,
+ source: fixedSource,
);
}
@@ -623,7 +635,6 @@
case DirectiveUriKind.withUnit:
final parent = readWithSource();
final unitElement = _readUnitElement(
- unitContainerRef: unitContainerRef,
libraryElement: libraryElement,
librarySource: libraryElement.source,
unitSource: parent.source,
@@ -634,8 +645,12 @@
unit: unitElement,
);
case DirectiveUriKind.withLibrary:
- // TODO: Handle this case.
- throw UnimplementedError();
+ final parent = readWithSource();
+ return DirectiveUriWithLibraryImpl.read(
+ relativeUriString: parent.relativeUriString,
+ relativeUri: parent.relativeUri,
+ source: parent.source,
+ );
case DirectiveUriKind.withSource:
return readWithSource();
case DirectiveUriKind.withRelativeUri:
@@ -859,21 +874,53 @@
});
}
- ImportElementImpl _readImportElement() {
- var element = ImportElementImpl(-1);
+ ImportElement2Impl _readImportElement({
+ required LibraryElementImpl libraryElement,
+ }) {
+ final uri = _readDirectiveUri(
+ libraryElement: libraryElement,
+ );
+ final prefix = _readImportElementPrefix();
+ final combinators = _reader.readTypedList(_readNamespaceCombinator);
+
+ final element = ImportElement2Impl(
+ importKeywordOffset: -1,
+ uri: uri,
+ prefix: prefix,
+ )..combinators = combinators;
ImportElementFlags.read(_reader, element);
- element.uri = _reader.readOptionalStringReference();
- var prefixName = _reader.readOptionalStringReference();
- if (prefixName != null) {
- var reference = _reference.getChild('@prefix').getChild(prefixName);
- var prefixElement =
- PrefixElementImpl(prefixName, -1, reference: reference);
- element.prefix = prefixElement;
- }
- element.combinators = _reader.readTypedList(_readNamespaceCombinator);
return element;
}
+ ImportElementPrefixImpl? _readImportElementPrefix() {
+ PrefixElementImpl buildElement(String name) {
+ final reference = _reference.getChild('@prefix').getChild(name);
+ final existing = reference.element;
+ if (existing is PrefixElementImpl) {
+ return existing;
+ } else {
+ return PrefixElementImpl(name, -1, reference: reference);
+ }
+ }
+
+ final kindIndex = _reader.readByte();
+ final kind = ImportElementPrefixKind.values[kindIndex];
+ switch (kind) {
+ case ImportElementPrefixKind.isDeferred:
+ final name = _reader.readStringReference();
+ return DeferredImportElementPrefixImpl(
+ element: buildElement(name),
+ );
+ case ImportElementPrefixKind.isNotDeferred:
+ final name = _reader.readStringReference();
+ return ImportElementPrefixImpl(
+ element: buildElement(name),
+ );
+ case ImportElementPrefixKind.isNull:
+ return null;
+ }
+ }
+
LibraryLanguageVersion _readLanguageVersion() {
var packageMajor = _reader.readUInt30();
var packageMinor = _reader.readUInt30();
@@ -1044,11 +1091,9 @@
}
PartElement _readPartElement({
- required Reference unitContainerRef,
required LibraryElementImpl libraryElement,
}) {
final uri = _readDirectiveUri(
- unitContainerRef: unitContainerRef,
libraryElement: libraryElement,
);
@@ -1272,7 +1317,6 @@
}
CompilationUnitElementImpl _readUnitElement({
- required Reference unitContainerRef,
required LibraryElementImpl libraryElement,
required Source librarySource,
required Source unitSource,
@@ -1285,7 +1329,8 @@
lineInfo: LineInfo([0]),
);
- var unitReference = unitContainerRef.getChild('${unitSource.uri}');
+ final unitContainerRef = _reference.getChild('@unit');
+ final unitReference = unitContainerRef.getChild('${unitSource.uri}');
unitElement.setLinkedData(
unitReference,
CompilationUnitElementLinkedData(
@@ -1423,6 +1468,10 @@
this._reader,
);
+ LibraryElementImpl libraryOfUri(Uri uri) {
+ return _elementFactory.libraryOfUri2(uri);
+ }
+
int readByte() {
return _reader.readByte();
}
diff --git a/pkg/analyzer/lib/src/summary2/bundle_writer.dart b/pkg/analyzer/lib/src/summary2/bundle_writer.dart
index 1008851..1d6844a 100644
--- a/pkg/analyzer/lib/src/summary2/bundle_writer.dart
+++ b/pkg/analyzer/lib/src/summary2/bundle_writer.dart
@@ -102,7 +102,7 @@
_writeFeatureSet(libraryElement.featureSet);
_writeLanguageVersion(libraryElement.languageVersion);
_resolutionSink._writeAnnotationList(libraryElement.metadata);
- _writeList(libraryElement.imports, _writeImportElement);
+ _writeList(libraryElement.imports2, _writeImportElement);
_writeList(libraryElement.exports, _writeExportElement);
for (final partElement in libraryElement.parts2) {
_resolutionSink._writeAnnotationList(partElement.metadata);
@@ -190,8 +190,8 @@
}
if (element is DirectiveUriWithLibrary) {
- // TODO(scheglov) implement
- throw UnimplementedError();
+ _sink.writeByte(DirectiveUriKind.withLibrary.index);
+ writeWithSource(element);
} else if (element is DirectiveUriWithUnit) {
_sink.writeByte(DirectiveUriKind.withUnit.index);
writeWithSource(element);
@@ -317,14 +317,25 @@
});
}
- void _writeImportElement(ImportElement element) {
- element as ImportElementImpl;
- ImportElementFlags.write(_sink, element);
- _sink._writeOptionalStringReference(element.uri);
- _sink._writeOptionalStringReference(element.prefix?.name);
- _sink.writeList(element.combinators, _writeNamespaceCombinator);
+ void _writeImportElement(ImportElement2 element) {
+ element as ImportElement2Impl;
_resolutionSink._writeAnnotationList(element.metadata);
- _resolutionSink.writeElement(element.importedLibrary);
+ _writeDirectiveUri(element.uri);
+ _writeImportElementPrefix(element.prefix);
+ _sink.writeList(element.combinators, _writeNamespaceCombinator);
+ ImportElementFlags.write(_sink, element);
+ }
+
+ void _writeImportElementPrefix(ImportElementPrefix? prefix) {
+ if (prefix is DeferredImportElementPrefix) {
+ _sink.writeByte(ImportElementPrefixKind.isDeferred.index);
+ _sink._writeStringReference(prefix.element.name);
+ } else if (prefix is ImportElementPrefix) {
+ _sink.writeByte(ImportElementPrefixKind.isNotDeferred.index);
+ _sink._writeStringReference(prefix.element.name);
+ } else {
+ _sink.writeByte(ImportElementPrefixKind.isNull.index);
+ }
}
void _writeLanguageVersion(LibraryLanguageVersion version) {
diff --git a/pkg/analyzer/lib/src/summary2/element_builder.dart b/pkg/analyzer/lib/src/summary2/element_builder.dart
index e53f62f..da83e3f 100644
--- a/pkg/analyzer/lib/src/summary2/element_builder.dart
+++ b/pkg/analyzer/lib/src/summary2/element_builder.dart
@@ -26,9 +26,8 @@
final CompilationUnitElementImpl _unitElement;
final _exports = <ExportElement>[];
- final _imports = <ImportElement>[];
var _isFirstLibraryDirective = true;
- var _hasCoreImport = false;
+ var _importDirectiveIndex = 0;
var _partDirectiveIndex = 0;
_EnclosingContext _enclosingContext;
@@ -66,17 +65,6 @@
_libraryElement.exports = _exports;
- if (!_hasCoreImport) {
- final dartCore = _linker.elementFactory.dartCoreElement;
- _imports.add(
- ImportElementImpl(-1)
- ..importedLibrary = dartCore
- ..isSynthetic = true
- ..uri = 'dart:core',
- );
- }
- _libraryElement.imports = _imports;
-
if (_isFirstLibraryDirective) {
_isFirstLibraryDirective = false;
var firstDirective = unit.directives.firstOrNull;
@@ -757,39 +745,11 @@
@override
void visitImportDirective(covariant ImportDirectiveImpl node) {
- var uriStr = node.uri.stringValue;
-
- var element = ImportElementImpl(node.importKeyword.offset);
- element.combinators = _buildCombinators(node.combinators);
-
- try {
- element.importedLibrary = _selectLibrary(node);
- } on ArgumentError {
- // TODO(scheglov) Remove this when using `ImportDirectiveState`.
- }
-
- element.isDeferred = node.deferredKeyword != null;
- element.metadata = _buildAnnotations(node.metadata);
- element.uri = uriStr;
-
- var prefixNode = node.prefix;
- if (prefixNode != null) {
- element.prefix = PrefixElementImpl(
- prefixNode.name,
- prefixNode.offset,
- reference: _libraryBuilder.reference
- .getChild('@prefix')
- .getChild(prefixNode.name),
- );
- }
-
- node.element = element;
-
- _imports.add(element);
-
- if (uriStr == 'dart:core') {
- _hasCoreImport = true;
- }
+ final index = _importDirectiveIndex++;
+ final importElement = _libraryElement.imports2[index];
+ importElement as ImportElement2Impl;
+ importElement.metadata = _buildAnnotations(node.metadata);
+ node.element = importElement;
}
@override
diff --git a/pkg/analyzer/lib/src/summary2/element_flags.dart b/pkg/analyzer/lib/src/summary2/element_flags.dart
index a8ba866..eae765c 100644
--- a/pkg/analyzer/lib/src/summary2/element_flags.dart
+++ b/pkg/analyzer/lib/src/summary2/element_flags.dart
@@ -151,18 +151,15 @@
}
class ImportElementFlags {
- static const int _isDeferred = 1 << 0;
- static const int _isSynthetic = 1 << 1;
+ static const int _isSynthetic = 1 << 0;
- static void read(SummaryDataReader reader, ImportElementImpl element) {
+ static void read(SummaryDataReader reader, ImportElement2Impl element) {
var byte = reader.readByte();
- element.isDeferred = (byte & _isDeferred) != 0;
element.isSynthetic = (byte & _isSynthetic) != 0;
}
- static void write(BufferedSink sink, ImportElementImpl element) {
+ static void write(BufferedSink sink, ImportElement2Impl element) {
var result = 0;
- result |= element.isDeferred ? _isDeferred : 0;
result |= element.isSynthetic ? _isSynthetic : 0;
sink.writeByte(result);
}
diff --git a/pkg/analyzer/lib/src/summary2/informative_data.dart b/pkg/analyzer/lib/src/summary2/informative_data.dart
index 086c90d..b684e30 100644
--- a/pkg/analyzer/lib/src/summary2/informative_data.dart
+++ b/pkg/analyzer/lib/src/summary2/informative_data.dart
@@ -448,16 +448,16 @@
element.documentationComment = info.docComment;
}
- forCorrespondingPairs<ImportElement, _InfoImport>(
+ forCorrespondingPairs<ImportElement2, _InfoImport>(
element.imports_unresolved,
info.imports,
(element, info) {
- element as ImportElementImpl;
+ element as ImportElement2Impl;
element.nameOffset = info.nameOffset;
- var prefix = element.prefix;
- if (prefix is PrefixElementImpl) {
- prefix.nameOffset = info.prefixOffset;
+ final prefixElement = element.prefix?.element;
+ if (prefixElement is PrefixElementImpl) {
+ prefixElement.nameOffset = info.prefixOffset;
}
_applyToCombinators(element.combinators, info.combinators);
@@ -487,7 +487,7 @@
info.libraryConstantOffsets,
(applier) {
applier.applyToMetadata(element);
- applier.applyToDirectives(element.imports);
+ applier.applyToImports(element.imports2);
applier.applyToDirectives(element.exports);
applier.applyToPartDirectives(element.parts2);
},
@@ -1691,6 +1691,12 @@
}
}
+ void applyToImports(List<ImportElement2> elements) {
+ for (var element in elements) {
+ applyToMetadata(element);
+ }
+ }
+
void applyToMetadata(Element element) {
for (var annotation in element.metadata) {
var node = (annotation as ElementAnnotationImpl).annotationAst;
diff --git a/pkg/analyzer/lib/src/summary2/library_builder.dart b/pkg/analyzer/lib/src/summary2/library_builder.dart
index 83db6a1..2e9b765 100644
--- a/pkg/analyzer/lib/src/summary2/library_builder.dart
+++ b/pkg/analyzer/lib/src/summary2/library_builder.dart
@@ -132,6 +132,8 @@
/// Build elements for declarations in the library units, add top-level
/// declarations to the local scope, for combining into export scopes.
void buildElements() {
+ element.imports2 = kind.imports.map(_buildImport).toList();
+
for (var linkingUnit in units) {
var elementBuilder = ElementBuilder(
libraryBuilder: this,
@@ -402,6 +404,121 @@
}
}
+ ImportElement2Impl _buildImport(ImportDirectiveState state) {
+ final importPrefix = state.directive.prefix.mapOrNull((unlinked) {
+ if (unlinked.deferredOffset != null) {
+ return DeferredImportElementPrefixImpl(
+ element: _buildPrefix(
+ name: unlinked.name,
+ nameOffset: unlinked.nameOffset,
+ ),
+ );
+ } else {
+ return ImportElementPrefixImpl(
+ element: _buildPrefix(
+ name: unlinked.name,
+ nameOffset: unlinked.nameOffset,
+ ),
+ );
+ }
+ });
+
+ final combinators = state.directive.combinators.map((unlinked) {
+ if (unlinked.isShow) {
+ return ShowElementCombinatorImpl()
+ ..offset = unlinked.keywordOffset
+ ..end = unlinked.endOffset
+ ..shownNames = unlinked.names;
+ } else {
+ // TODO(scheglov) Why no offsets?
+ return HideElementCombinatorImpl()..hiddenNames = unlinked.names;
+ }
+ }).toList();
+
+ final DirectiveUri uri;
+ if (state is ImportDirectiveWithFile) {
+ final importedLibraryKind = state.importedLibrary;
+ if (importedLibraryKind != null) {
+ final importedFile = importedLibraryKind.file;
+ final importedUri = importedFile.uri;
+ final elementFactory = linker.elementFactory;
+ final importedLibrary = elementFactory.libraryOfUri2(importedUri);
+ uri = DirectiveUriWithLibraryImpl(
+ relativeUriString: state.selectedUri.relativeUriStr,
+ relativeUri: state.selectedUri.relativeUri,
+ source: importedLibrary.source,
+ library: importedLibrary,
+ );
+ } else {
+ uri = DirectiveUriWithSourceImpl(
+ relativeUriString: state.selectedUri.relativeUriStr,
+ relativeUri: state.selectedUri.relativeUri,
+ source: state.importedSource,
+ );
+ }
+ } else if (state is ImportDirectiveWithInSummarySource) {
+ final importedLibrarySource = state.importedLibrarySource;
+ if (importedLibrarySource != null) {
+ final importedUri = importedLibrarySource.uri;
+ final elementFactory = linker.elementFactory;
+ final importedLibrary = elementFactory.libraryOfUri2(importedUri);
+ uri = DirectiveUriWithLibraryImpl(
+ relativeUriString: state.selectedUri.relativeUriStr,
+ relativeUri: state.selectedUri.relativeUri,
+ source: importedLibrary.source,
+ library: importedLibrary,
+ );
+ } else {
+ uri = DirectiveUriWithSourceImpl(
+ relativeUriString: state.selectedUri.relativeUriStr,
+ relativeUri: state.selectedUri.relativeUri,
+ source: state.importedSource,
+ );
+ }
+ } else {
+ final selectedUri = state.selectedUri;
+ if (selectedUri is file_state.DirectiveUriWithUri) {
+ uri = DirectiveUriWithRelativeUriImpl(
+ relativeUriString: selectedUri.relativeUriStr,
+ relativeUri: selectedUri.relativeUri,
+ );
+ } else if (selectedUri is file_state.DirectiveUriWithString) {
+ uri = DirectiveUriWithRelativeUriStringImpl(
+ relativeUriString: selectedUri.relativeUriStr,
+ );
+ } else {
+ uri = DirectiveUriImpl();
+ }
+ }
+
+ return ImportElement2Impl(
+ importKeywordOffset: state.directive.importKeywordOffset,
+ uri: uri,
+ prefix: importPrefix,
+ )
+ ..combinators = combinators
+ ..isSynthetic = state.isSyntheticDartCore;
+ }
+
+ PrefixElementImpl _buildPrefix({
+ required String name,
+ required int nameOffset,
+ }) {
+ final reference = this.reference.getChild('@prefix').getChild(name);
+ final existing = reference.element;
+ if (existing is PrefixElementImpl) {
+ return existing;
+ } else {
+ final result = PrefixElementImpl(
+ name,
+ nameOffset,
+ reference: reference,
+ );
+ element.encloseElement(result);
+ return result;
+ }
+ }
+
/// These elements are implicitly declared in `dart:core`.
void _declareDartCoreDynamicNever() {
if (reference.name == 'dart:core') {
@@ -592,3 +709,10 @@
super.visitElement(element);
}
}
+
+extension<T> on T? {
+ R? mapOrNull<R>(R Function(T) mapper) {
+ final self = this;
+ return self != null ? mapper(self) : null;
+ }
+}
diff --git a/pkg/analyzer/lib/src/summary2/macro_application.dart b/pkg/analyzer/lib/src/summary2/macro_application.dart
index 8260593..8fcd68c 100644
--- a/pkg/analyzer/lib/src/summary2/macro_application.dart
+++ b/pkg/analyzer/lib/src/summary2/macro_application.dart
@@ -258,8 +258,8 @@
constructorName = annotation.constructorName?.name;
} else if (nameNode is PrefixedIdentifier) {
final importPrefixCandidate = nameNode.prefix.name;
- final hasImportPrefix = libraryBuilder.element.imports
- .any((import) => import.prefix?.name == importPrefixCandidate);
+ final hasImportPrefix = libraryBuilder.element.imports2.any(
+ (import) => import.prefix?.element.name == importPrefixCandidate);
if (hasImportPrefix) {
prefix = importPrefixCandidate;
name = nameNode.identifier.name;
@@ -273,8 +273,8 @@
throw StateError('${nameNode.runtimeType} $nameNode');
}
- for (final import in libraryBuilder.element.imports) {
- if (import.prefix?.name != prefix) {
+ for (final import in libraryBuilder.element.imports2) {
+ if (import.prefix?.element.name != prefix) {
continue;
}
diff --git a/pkg/analyzer/lib/src/test_utilities/find_element.dart b/pkg/analyzer/lib/src/test_utilities/find_element.dart
index d2923f5..3d7b0c3 100644
--- a/pkg/analyzer/lib/src/test_utilities/find_element.dart
+++ b/pkg/analyzer/lib/src/test_utilities/find_element.dart
@@ -50,10 +50,10 @@
throw StateError('Not found: $name');
}
- ImportElement import(String targetUri, {bool mustBeUnique = true}) {
- ImportElement? importElement;
+ ImportElement2 import(String targetUri, {bool mustBeUnique = true}) {
+ ImportElement2? importElement;
- for (var import in libraryElement.imports) {
+ for (var import in libraryElement.imports2) {
var importedUri = import.importedLibrary?.source.uri.toString();
if (importedUri == targetUri) {
if (importElement == null) {
@@ -243,10 +243,10 @@
}
PrefixElement prefix(String name) {
- for (var import_ in libraryElement.imports) {
- var prefix = import_.prefix;
- if (prefix?.name == name) {
- return prefix!;
+ for (var import_ in libraryElement.imports2) {
+ var prefix = import_.prefix?.element;
+ if (prefix != null && prefix.name == name) {
+ return prefix;
}
}
throw StateError('Not found: $name');
@@ -311,13 +311,13 @@
/// Helper for searching imported elements.
class ImportFindElement extends _FindElementBase {
- final ImportElement import;
+ final ImportElement2 import;
ImportFindElement(this.import);
LibraryElement get importedLibrary => import.importedLibrary!;
- PrefixElement? get prefix => import.prefix;
+ PrefixElement? get prefix => import.prefix?.element;
@override
CompilationUnitElement get unitElement {
diff --git a/pkg/analyzer/test/generated/element_resolver_test.dart b/pkg/analyzer/test/generated/element_resolver_test.dart
index 7cac99c..af43c44 100644
--- a/pkg/analyzer/test/generated/element_resolver_test.dart
+++ b/pkg/analyzer/test/generated/element_resolver_test.dart
@@ -422,7 +422,7 @@
''', [
error(HintCode.UNUSED_IMPORT, 7, 11),
]);
- expect(findNode.import('dart:math').element!.importedLibrary!.name,
+ expect(findNode.import('dart:math').element2!.importedLibrary!.name,
'dart.math');
}
@@ -432,7 +432,7 @@
''', [
error(HintCode.UNUSED_IMPORT, 7, 11),
]);
- expect(findNode.import('dart:math').element!.importedLibrary!.name,
+ expect(findNode.import('dart:math').element2!.importedLibrary!.name,
'dart.math');
}
@@ -448,7 +448,7 @@
]);
var importedVariables = findNode
.import('lib1.dart')
- .element!
+ .element2!
.importedLibrary!
.definingCompilationUnit
.topLevelVariables;
diff --git a/pkg/analyzer/test/generated/resolver_test_case.dart b/pkg/analyzer/test/generated/resolver_test_case.dart
index 704b831..d0f7199 100644
--- a/pkg/analyzer/test/generated/resolver_test_case.dart
+++ b/pkg/analyzer/test/generated/resolver_test_case.dart
@@ -110,7 +110,7 @@
void visitImportDirective(ImportDirective node) {
// Not sure how to test the combinators given that it isn't an error if the
// names are not defined.
- _checkResolved(node, node.element, (node) => node is ImportElement);
+ _checkResolved(node, node.element2, (node) => node is ImportElement2);
var prefix = node.prefix;
if (prefix == null) {
return;
diff --git a/pkg/analyzer/test/id_tests/assigned_variables_test.dart b/pkg/analyzer/test/id_tests/assigned_variables_test.dart
index 5107df9..309c55e 100644
--- a/pkg/analyzer/test/id_tests/assigned_variables_test.dart
+++ b/pkg/analyzer/test/id_tests/assigned_variables_test.dart
@@ -97,8 +97,8 @@
node, () => super.visitVariableDeclaration(node));
}
- Set<String> _convertVars(Iterable<PromotableElement> x) =>
- x.map((e) => e.name).toSet();
+ Set<String> _convertVars(Iterable<int> x) =>
+ x.map((e) => _currentAssignedVariables!.variableForKey(e).name).toSet();
void _handlePossibleTopLevelDeclaration(
AstNode node, void Function() callback) {
diff --git a/pkg/analyzer/test/src/dart/analysis/analyzer_state_printer.dart b/pkg/analyzer/test/src/dart/analysis/analyzer_state_printer.dart
index f55b678..89af3ef 100644
--- a/pkg/analyzer/test/src/dart/analysis/analyzer_state_printer.dart
+++ b/pkg/analyzer/test/src/dart/analysis/analyzer_state_printer.dart
@@ -235,7 +235,7 @@
sink.write(' ${file.uri}');
}
- if (import.isSyntheticDartCoreImport) {
+ if (import.isSyntheticDartCore) {
sink.write(' synthetic');
}
sink.writeln();
@@ -250,7 +250,7 @@
sink.write(' notLibrary');
}
- if (import.isSyntheticDartCoreImport) {
+ if (import.isSyntheticDartCore) {
sink.write(' synthetic');
}
sink.writeln();
@@ -258,7 +258,7 @@
final uriStr = _stringOfUriStr(import.selectedUri.relativeUriStr);
sink.write(_indent);
sink.write('uri: $uriStr');
- if (import.isSyntheticDartCoreImport) {
+ if (import.isSyntheticDartCore) {
sink.write(' synthetic');
}
sink.writeln();
diff --git a/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart b/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart
index 1901bb3..b2fac8c 100644
--- a/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/driver_resolution_test.dart
@@ -412,8 +412,8 @@
await resolveTestFile();
CompilationUnit unit = result.unit;
- ImportElement aImport = unit.declaredElement!.library.imports[0];
- PrefixElement aPrefix = aImport.prefix!;
+ final aImport = unit.declaredElement!.library.imports2[0];
+ PrefixElement aPrefix = aImport.prefix!.element;
LibraryElement aLibrary = aImport.importedLibrary!;
CompilationUnitElement aUnitElement = aLibrary.definingCompilationUnit;
@@ -451,8 +451,8 @@
await resolveTestFile();
CompilationUnit unit = result.unit;
- ImportElement aImport = unit.declaredElement!.library.imports[0];
- PrefixElement aPrefix = aImport.prefix!;
+ final aImport = unit.declaredElement!.library.imports2[0];
+ PrefixElement aPrefix = aImport.prefix!.element;
LibraryElement aLibrary = aImport.importedLibrary!;
CompilationUnitElement aUnitElement = aLibrary.definingCompilationUnit;
@@ -492,8 +492,8 @@
await resolveTestFile();
CompilationUnit unit = result.unit;
- ImportElement aImport = unit.declaredElement!.library.imports[0];
- PrefixElement aPrefix = aImport.prefix!;
+ final aImport = unit.declaredElement!.library.imports2[0];
+ PrefixElement aPrefix = aImport.prefix!.element;
LibraryElement aLibrary = aImport.importedLibrary!;
CompilationUnitElement aUnitElement = aLibrary.definingCompilationUnit;
@@ -533,8 +533,8 @@
await resolveTestFile();
CompilationUnit unit = result.unit;
- ImportElement aImport = unit.declaredElement!.library.imports[0];
- PrefixElement aPrefix = aImport.prefix!;
+ final aImport = unit.declaredElement!.library.imports2[0];
+ PrefixElement aPrefix = aImport.prefix!.element;
LibraryElement aLibrary = aImport.importedLibrary!;
CompilationUnitElement aUnitElement = aLibrary.definingCompilationUnit;
@@ -1443,7 +1443,7 @@
assertInvokeType(invocation, 'Future<dynamic> Function()');
var target = invocation.target as SimpleIdentifier;
- assertElement(target, import.prefix);
+ assertElement(target, import.prefix?.element);
assertType(target, null);
var name = invocation.methodName;
@@ -1469,7 +1469,7 @@
assertInvokeType(invocation, 'Future<dynamic> Function()');
var target = invocation.target as SimpleIdentifier;
- assertElement(target, import.prefix);
+ assertElement(target, import.prefix?.element);
assertType(target, null);
var name = invocation.methodName;
@@ -1500,7 +1500,7 @@
assertType(prefixed, 'Future<dynamic> Function()');
var prefix = prefixed.prefix;
- assertElement(prefix, import.prefix);
+ assertElement(prefix, import.prefix?.element);
assertType(prefix, null);
var identifier = prefixed.identifier;
@@ -1528,7 +1528,7 @@
assertElement(prefixed, v.getter);
assertType(prefixed, 'int');
- assertElement(prefixed.prefix, import.prefix);
+ assertElement(prefixed.prefix, import.prefix?.element);
assertType(prefixed.prefix, null);
assertElement(prefixed.identifier, v.getter);
@@ -1540,7 +1540,7 @@
assertElementNull(prefixed);
assertTypeNull(prefixed);
- assertElement(prefixed.prefix, import.prefix);
+ assertElement(prefixed.prefix, import.prefix?.element);
assertType(prefixed.prefix, null);
assertUnresolvedSimpleIdentifier(prefixed.identifier);
@@ -2210,7 +2210,7 @@
await resolveTestFile();
CompilationUnit unit = result.unit;
- ImportElement aImport = unit.declaredElement!.library.imports[0];
+ final aImport = unit.declaredElement!.library.imports2[0];
LibraryElement aLibrary = aImport.importedLibrary!;
ClassElement cElement = aLibrary.getType('C')!;
@@ -2241,7 +2241,7 @@
SimpleIdentifier typePrefix = typeIdentifier.prefix;
expect(typePrefix.name, 'p');
- expect(typePrefix.staticElement, same(aImport.prefix));
+ expect(typePrefix.staticElement, same(aImport.prefix?.element));
expect(typePrefix.staticType, isNull);
expect(typeIdentifier.identifier.staticElement, same(cElement));
@@ -2271,7 +2271,7 @@
SimpleIdentifier typePrefix = typeIdentifier.prefix;
expect(typePrefix.name, 'p');
- expect(typePrefix.staticElement, same(aImport.prefix));
+ expect(typePrefix.staticElement, same(aImport.prefix?.element));
expect(typePrefix.staticType, isNull);
expect(typeIdentifier.identifier.staticElement, same(cElement));
@@ -2303,7 +2303,7 @@
SimpleIdentifier typePrefix = typeIdentifier.prefix;
expect(typePrefix.name, 'p');
- expect(typePrefix.staticElement, same(aImport.prefix));
+ expect(typePrefix.staticElement, same(aImport.prefix?.element));
expect(typePrefix.staticType, isNull);
expect(typeIdentifier.identifier.staticElement, same(cElement));
@@ -2898,7 +2898,7 @@
findNode.namedType('a.Future'),
futureElement,
'Future<int>',
- expectedPrefix: findElement.import('dart:async').prefix,
+ expectedPrefix: findElement.import('dart:async').prefix?.element,
);
assertNamedType(findNode.namedType('int>'), intElement, 'int');
}
@@ -3231,7 +3231,7 @@
await resolveTestFile();
expect(result.errors, isNotEmpty);
- ImportElement import = findNode.import('dart:math').element!;
+ final import = findNode.import('dart:math').element2!;
var pRef = findNode.simple('p(a)');
assertElement(pRef, import.prefix);
@@ -3440,14 +3440,14 @@
await resolveTestFile();
expect(result.errors, isNotEmpty);
- ImportElement import = findNode.import('dart:math').element!;
+ final import = findNode.import('dart:math').element2!;
var invocation = findNode.methodInvocation('p(a)');
expect(invocation.staticType, isDynamicType);
assertUnresolvedInvokeType(invocation.staticInvokeType!);
var pRef = invocation.methodName;
- assertElement(pRef, import.prefix);
+ assertElement(pRef, import.prefix?.element);
assertTypeDynamic(pRef);
var aRef = findNode.simple('a);');
@@ -3613,7 +3613,7 @@
await resolveTestFile();
expect(result.errors, isNotEmpty);
- ImportElement import = findNode.import('a.dart').element!;
+ final import = findNode.import('a.dart').element2!;
var tElement = import.importedLibrary!.publicNamespace.get('T');
var prefixedName = findNode.prefixed('p.T');
@@ -3681,7 +3681,7 @@
await resolveTestFile();
expect(result.errors, isNotEmpty);
- ImportElement import = findNode.import('a.dart').element!;
+ final import = findNode.import('a.dart').element2!;
var tElement = import.importedLibrary!.publicNamespace.get('T');
var prefixedName = findNode.prefixed('p.T');
@@ -5646,7 +5646,7 @@
assertType(creation, 'C');
assertNamedType(creation.constructorName.type, c, 'C',
- expectedPrefix: import.prefix);
+ expectedPrefix: import.prefix?.element);
}
{
@@ -5656,7 +5656,7 @@
assertType(creation, 'C');
assertNamedType(creation.constructorName.type, c, 'C',
- expectedPrefix: import.prefix);
+ expectedPrefix: import.prefix?.element);
assertElement(creation.constructorName.name, namedConstructor);
}
}
@@ -5907,14 +5907,14 @@
my.Future<int> a;
''');
await resolveTestFile();
- ImportElement myImport = result.libraryElement.imports[0];
+ final myImport = result.libraryElement.imports2[0];
var intRef = findNode.namedType('int> a');
assertNamedType(intRef, intElement, 'int');
var futureRef = findNode.namedType('my.Future<int> a');
assertNamedType(futureRef, futureElement, 'Future<int>',
- expectedPrefix: myImport.prefix);
+ expectedPrefix: myImport.prefix?.element);
}
test_postfix_increment_of_non_generator() async {
@@ -6163,8 +6163,8 @@
// expect(result.errors, isEmpty);
var unitElement = result.unit.declaredElement!;
- ImportElement myImport = unitElement.library.imports[0];
- PrefixElement myPrefix = myImport.prefix!;
+ final myImport = unitElement.library.imports2[0];
+ PrefixElement myPrefix = myImport.prefix!.element;
var myLibrary = myImport.importedLibrary!;
var myUnit = myLibrary.definingCompilationUnit;
@@ -7751,8 +7751,8 @@
await resolveTestFile();
CompilationUnit unit = result.unit;
- ImportElement bImport = unit.declaredElement!.library.imports[0];
- ImportElement cImport = unit.declaredElement!.library.imports[1];
+ final bImport = unit.declaredElement!.library.imports2[0];
+ final cImport = unit.declaredElement!.library.imports2[1];
LibraryElement bLibrary = bImport.importedLibrary!;
LibraryElement aLibrary = bLibrary.exports[0].exportedLibrary!;
@@ -7766,7 +7766,10 @@
expect(typeIdentifier.staticElement, aClass);
expect(typeIdentifier.prefix.name, 'b');
- expect(typeIdentifier.prefix.staticElement, same(bImport.prefix));
+ expect(
+ typeIdentifier.prefix.staticElement,
+ same(bImport.prefix?.element),
+ );
expect(typeIdentifier.identifier.staticElement, aClass);
}
@@ -7779,7 +7782,10 @@
expect(typeIdentifier.staticElement, aClass);
expect(typeIdentifier.prefix.name, 'c');
- expect(typeIdentifier.prefix.staticElement, same(cImport.prefix));
+ expect(
+ typeIdentifier.prefix.staticElement,
+ same(cImport.prefix?.element),
+ );
expect(typeIdentifier.identifier.staticElement, aClass);
}
@@ -7913,7 +7919,7 @@
expect(result.errors, isNotEmpty);
var unitElement = result.unit.declaredElement!;
- var foo = unitElement.library.imports[0].prefix;
+ var foo = unitElement.library.imports2[0].prefix?.element;
List<Statement> statements = _getMainStatements(result);
var statement = statements[0] as ExpressionStatement;
@@ -7997,8 +8003,8 @@
expect(result.errors, isNotEmpty);
var unitElement = result.unit.declaredElement!;
- var mathImport = unitElement.library.imports[0];
- var foo = mathImport.prefix;
+ var mathImport = unitElement.library.imports2[0];
+ var foo = mathImport.prefix?.element;
List<Statement> statements = _getMainStatements(result);
var statement = statements[0] as ExpressionStatement;
@@ -8043,8 +8049,8 @@
expect(result.errors, isNotEmpty);
var unitElement = result.unit.declaredElement!;
- var mathImport = unitElement.library.imports[0];
- var foo = mathImport.prefix;
+ var mathImport = unitElement.library.imports2[0];
+ var foo = mathImport.prefix?.element;
var randomElement = mathImport.importedLibrary!.getType('Random')!;
List<Statement> statements = _getMainStatements(result);
diff --git a/pkg/analyzer/test/src/dart/analysis/driver_test.dart b/pkg/analyzer/test/src/dart/analysis/driver_test.dart
index 0149bed..5226986 100644
--- a/pkg/analyzer/test/src/dart/analysis/driver_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/driver_test.dart
@@ -2107,7 +2107,7 @@
ResolvedUnitResult result = await driver.getResultValid(testFile);
expect(result.path, testFile);
// Has only imports for valid URIs.
- List<ImportElement> imports = result.libraryElement.imports;
+ final imports = result.libraryElement.imports2;
expect(imports.map((import) {
return import.importedLibrary?.source.uri.toString();
}), ['dart:async', null, 'dart:math', 'dart:core']);
@@ -3568,9 +3568,9 @@
'$unit');
}
- ImportElement _getImportElement(CompilationUnit unit, int directiveIndex) {
+ ImportElement2 _getImportElement(CompilationUnit unit, int directiveIndex) {
var import = unit.directives[directiveIndex] as ImportDirective;
- return import.element!;
+ return import.element2!;
}
Source _getImportSource(CompilationUnit unit, int directiveIndex) {
diff --git a/pkg/analyzer/test/src/dart/analysis/file_state_test.dart b/pkg/analyzer/test/src/dart/analysis/file_state_test.dart
index 1336d79..29bb1a8 100644
--- a/pkg/analyzer/test/src/dart/analysis/file_state_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/file_state_test.dart
@@ -1562,7 +1562,7 @@
final coreKind = core.t1!.kind as LibraryFileStateKind;
for (final import in coreKind.imports) {
- if (import.isSyntheticDartCoreImport) {
+ if (import.isSyntheticDartCore) {
fail('dart:core should not import itself');
}
}
diff --git a/pkg/analyzer/test/src/dart/analysis/search_test.dart b/pkg/analyzer/test/src/dart/analysis/search_test.dart
index c59203e..c95f1a0 100644
--- a/pkg/analyzer/test/src/dart/analysis/search_test.dart
+++ b/pkg/analyzer/test/src/dart/analysis/search_test.dart
@@ -1131,7 +1131,7 @@
Random bar() => null;
''');
- ImportElement element = findElement.import('dart:math');
+ final element = findElement.import('dart:math');
var main = findElement.function('main');
var bar = findElement.function('bar');
var kind = SearchResultKind.REFERENCE;
@@ -1163,7 +1163,7 @@
N4 = 0;
}
''');
- ImportElement element = findElement.import('package:test/a.dart');
+ final element = findElement.import('package:test/a.dart');
var main = findElement.function('main');
var kind = SearchResultKind.REFERENCE;
var expected = [
@@ -1213,14 +1213,14 @@
var kind = SearchResultKind.REFERENCE;
var length = 'p.'.length;
{
- ImportElement element = findElement.import('dart:async');
+ final element = findElement.import('dart:async');
var expected = [
_expectId(main, kind, 'p.Future;', length: length),
];
await _verifyReferences(element, expected);
}
{
- ImportElement element = findElement.import('dart:math');
+ final element = findElement.import('dart:math');
var expected = [
_expectId(main, kind, 'p.Random', length: length),
];
@@ -1247,7 +1247,7 @@
a.N4 = 0;
}
''');
- ImportElement element = findElement.import('package:test/a.dart');
+ final element = findElement.import('package:test/a.dart');
var main = findElement.function('main');
var kind = SearchResultKind.REFERENCE;
var length = 'a.'.length;
@@ -2125,7 +2125,7 @@
V(); // nq
}
''');
- ImportElement importElement = findNode.import('show V').element!;
+ final importElement = findNode.import('show V').element2!;
CompilationUnitElement impUnit =
importElement.importedLibrary!.definingCompilationUnit;
TopLevelVariableElement variable = impUnit.topLevelVariables[0];
diff --git a/pkg/analyzer/test/src/dart/element/element_test.dart b/pkg/analyzer/test/src/dart/element/element_test.dart
index b69f6c9..3fa8eab 100644
--- a/pkg/analyzer/test/src/dart/element/element_test.dart
+++ b/pkg/analyzer/test/src/dart/element/element_test.dart
@@ -2,21 +2,17 @@
// 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/analysis/features.dart';
import 'package:analyzer/dart/ast/ast.dart';
import 'package:analyzer/dart/constant/value.dart';
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/dart/element/nullability_suffix.dart';
import 'package:analyzer/dart/element/type.dart';
-import 'package:analyzer/src/dart/analysis/session.dart';
import 'package:analyzer/src/dart/element/element.dart';
import 'package:analyzer/src/dart/element/type.dart';
-import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
import 'package:analyzer/src/generated/testing/element_factory.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
-import '../../../generated/test_analysis_context.dart';
import '../../../generated/test_support.dart';
import '../../../generated/type_system_test.dart';
import '../resolution/context_collection_resolution.dart';
@@ -33,7 +29,6 @@
defineReflectiveTests(CompilationUnitElementImplTest);
defineReflectiveTests(ElementLocationImplTest);
defineReflectiveTests(ElementImplTest);
- defineReflectiveTests(LibraryElementImplTest);
defineReflectiveTests(TopLevelVariableElementImplTest);
defineReflectiveTests(UniqueLocationTest);
});
@@ -1246,75 +1241,6 @@
}
@reflectiveTest
-class LibraryElementImplTest {
- void test_getImportedLibraries() {
- AnalysisContext context = TestAnalysisContext();
- LibraryElementImpl library1 = ElementFactory.library(context, "l1");
- LibraryElementImpl library2 = ElementFactory.library(context, "l2");
- LibraryElementImpl library3 = ElementFactory.library(context, "l3");
- LibraryElementImpl library4 = ElementFactory.library(context, "l4");
- PrefixElement prefixA = PrefixElementImpl('a', -1);
- PrefixElement prefixB = PrefixElementImpl('b', -1);
- List<ImportElementImpl> imports = [
- ElementFactory.importFor(library2, null),
- ElementFactory.importFor(library2, prefixB),
- ElementFactory.importFor(library3, null),
- ElementFactory.importFor(library3, prefixA),
- ElementFactory.importFor(library3, prefixB),
- ElementFactory.importFor(library4, prefixA)
- ];
- library1.imports = imports;
- List<LibraryElement> libraries = library1.importedLibraries;
- expect(libraries,
- unorderedEquals(<LibraryElement>[library2, library3, library4]));
- }
-
- void test_getPrefixes() {
- AnalysisContext context = TestAnalysisContext();
- LibraryElementImpl library = ElementFactory.library(context, "l1");
- PrefixElement prefixA = PrefixElementImpl('a', -1);
- PrefixElement prefixB = PrefixElementImpl('b', -1);
- List<ImportElementImpl> imports = [
- ElementFactory.importFor(ElementFactory.library(context, "l2"), null),
- ElementFactory.importFor(ElementFactory.library(context, "l3"), null),
- ElementFactory.importFor(ElementFactory.library(context, "l4"), prefixA),
- ElementFactory.importFor(ElementFactory.library(context, "l5"), prefixA),
- ElementFactory.importFor(ElementFactory.library(context, "l6"), prefixB)
- ];
- library.imports = imports;
- List<PrefixElement> prefixes = library.prefixes;
- expect(prefixes, hasLength(2));
- if (identical(prefixA, prefixes[0])) {
- expect(prefixes[1], same(prefixB));
- } else {
- expect(prefixes[0], same(prefixB));
- expect(prefixes[1], same(prefixA));
- }
- }
-
- void test_setImports() {
- AnalysisContext context = TestAnalysisContext();
- LibraryElementImpl library = LibraryElementImpl(
- context,
- _AnalysisSessionMock(),
- 'l1',
- -1,
- 0,
- FeatureSet.latestLanguageVersion());
- List<ImportElementImpl> expectedImports = [
- ElementFactory.importFor(ElementFactory.library(context, "l2"), null),
- ElementFactory.importFor(ElementFactory.library(context, "l3"), null)
- ];
- library.imports = expectedImports;
- List<ImportElement> actualImports = library.imports;
- expect(actualImports, hasLength(expectedImports.length));
- for (int i = 0; i < actualImports.length; i++) {
- expect(actualImports[i], same(expectedImports[i]));
- }
- }
-}
-
-@reflectiveTest
class TopLevelVariableElementImplTest extends PubPackageResolutionTest {
test_computeConstantValue() async {
newFile('$testPackageLibPath/a.dart', r'''
@@ -1600,8 +1526,3 @@
expect(_voidType.resolveToBound(objectNone), same(_voidType));
}
}
-
-class _AnalysisSessionMock implements AnalysisSessionImpl {
- @override
- noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
-}
diff --git a/pkg/analyzer/test/src/dart/resolution/type_literal_test.dart b/pkg/analyzer/test/src/dart/resolution/type_literal_test.dart
index 5f4fe3c..c43750d 100644
--- a/pkg/analyzer/test/src/dart/resolution/type_literal_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/type_literal_test.dart
@@ -41,7 +41,7 @@
typeLiteral,
findElement.importFind('package:test/a.dart').class_('C'),
'C<int>',
- expectedPrefix: findElement.import('package:test/a.dart').prefix,
+ expectedPrefix: findElement.import('package:test/a.dart').prefix?.element,
);
}
@@ -133,7 +133,7 @@
typeLiteral,
findElement.importFind('package:test/a.dart').typeAlias('CA'),
'C<int>',
- expectedPrefix: findElement.import('package:test/a.dart').prefix,
+ expectedPrefix: findElement.import('package:test/a.dart').prefix?.element,
);
}
diff --git a/pkg/analyzer/test/src/dart/resolution/type_name_test.dart b/pkg/analyzer/test/src/dart/resolution/type_name_test.dart
index 33d81f0..5c3ff04 100644
--- a/pkg/analyzer/test/src/dart/resolution/type_name_test.dart
+++ b/pkg/analyzer/test/src/dart/resolution/type_name_test.dart
@@ -666,7 +666,7 @@
findNode.namedType('mycore.dynamic a;'),
dynamicElement,
'dynamic',
- expectedPrefix: findElement.import('dart:core').prefix,
+ expectedPrefix: findElement.import('dart:core').prefix?.element,
);
}
diff --git a/pkg/analyzer/test/src/diagnostics/implements_deferred_class_test.dart b/pkg/analyzer/test/src/diagnostics/implements_deferred_class_test.dart
index d9e36f7..ac8fe41 100644
--- a/pkg/analyzer/test/src/diagnostics/implements_deferred_class_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/implements_deferred_class_test.dart
@@ -75,6 +75,6 @@
var typeRef = findNode.namedType('Random {}');
assertNamedType(typeRef, randomElement, 'Random',
- expectedPrefix: mathImport.prefix);
+ expectedPrefix: mathImport.prefix?.element);
}
}
diff --git a/pkg/analyzer/test/src/diagnostics/mixin_super_class_constraint_deferred_class_test.dart b/pkg/analyzer/test/src/diagnostics/mixin_super_class_constraint_deferred_class_test.dart
index 4985163..21d8902 100644
--- a/pkg/analyzer/test/src/diagnostics/mixin_super_class_constraint_deferred_class_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/mixin_super_class_constraint_deferred_class_test.dart
@@ -32,6 +32,6 @@
var typeRef = findNode.namedType('Random {}');
assertNamedType(typeRef, randomElement, 'Random',
- expectedPrefix: mathImport.prefix);
+ expectedPrefix: mathImport.prefix?.element);
}
}
diff --git a/pkg/analyzer/test/src/diagnostics/use_of_nullable_value_test.dart b/pkg/analyzer/test/src/diagnostics/use_of_nullable_value_test.dart
index b6cbd94..b4cce46 100644
--- a/pkg/analyzer/test/src/diagnostics/use_of_nullable_value_test.dart
+++ b/pkg/analyzer/test/src/diagnostics/use_of_nullable_value_test.dart
@@ -407,8 +407,7 @@
}
''', [
error(CompileTimeErrorCode.UNCHECKED_PROPERTY_ACCESS_OF_NULLABLE_VALUE,
- 104, 1,
- contextMessages: [message('/home/test/lib/test.dart', 56, 1)]),
+ 104, 1),
]);
if (isNullSafetyEnabled) {
@@ -660,8 +659,7 @@
}
''', [
error(CompileTimeErrorCode.UNCHECKED_PROPERTY_ACCESS_OF_NULLABLE_VALUE,
- 105, 1,
- contextMessages: [message('/home/test/lib/test.dart', 56, 1)]),
+ 105, 1),
]);
assertResolvedNodeText(findNode.assignment('x += 1'), r'''
@@ -1594,8 +1592,7 @@
}
''', [
error(CompileTimeErrorCode.UNCHECKED_PROPERTY_ACCESS_OF_NULLABLE_VALUE,
- 105, 1,
- contextMessages: [message('/home/test/lib/test.dart', 56, 1)]),
+ 105, 1),
]);
var propertyAccess1 = findNode.propertyAccess('b.a?.x; // 1');
var propertyAccess2 = findNode.propertyAccess('b.a.x; // 2');
@@ -1664,8 +1661,7 @@
}
''', [
error(CompileTimeErrorCode.UNCHECKED_PROPERTY_ACCESS_OF_NULLABLE_VALUE,
- 148, 1,
- contextMessages: [message('/home/test/lib/test.dart', 56, 1)]),
+ 148, 1),
]);
var propertyAccess1 = findNode.propertyAccess('x; // 1');
var propertyAccess2 = findNode.propertyAccess('x; // 2');
@@ -1702,8 +1698,7 @@
}
''', [
error(CompileTimeErrorCode.UNCHECKED_PROPERTY_ACCESS_OF_NULLABLE_VALUE,
- 152, 1,
- contextMessages: [message('/home/test/lib/test.dart', 101, 1)]),
+ 152, 1),
]);
var propertyAccess1 = findNode.propertyAccess('x; // 1');
var propertyAccess2 = findNode.propertyAccess('x; // 2');
diff --git a/pkg/analyzer/test/src/summary/element_text.dart b/pkg/analyzer/test/src/summary/element_text.dart
index 2c955c4..1177e37 100644
--- a/pkg/analyzer/test/src/summary/element_text.dart
+++ b/pkg/analyzer/test/src/summary/element_text.dart
@@ -52,6 +52,7 @@
bool withDisplayName = false,
bool withExportScope = false,
bool withNonSynthetic = false,
+ bool withSyntheticDartCoreImport = false,
}) {
var writer = _ElementWriter(
selfUriStr: '${library.source.uri}',
@@ -59,6 +60,7 @@
withDisplayName: withDisplayName,
withExportScope: withExportScope,
withNonSynthetic: withNonSynthetic,
+ withSyntheticDartCoreImport: withSyntheticDartCoreImport,
);
writer.writeLibraryElement(library);
@@ -124,6 +126,7 @@
final bool withDisplayName;
final bool withExportScope;
final bool withNonSynthetic;
+ final bool withSyntheticDartCoreImport;
final StringBuffer buffer = StringBuffer();
String indent = '';
@@ -134,6 +137,7 @@
required this.withDisplayName,
required this.withExportScope,
required this.withNonSynthetic,
+ required this.withSyntheticDartCoreImport,
});
void writeLibraryElement(LibraryElement e) {
@@ -154,7 +158,9 @@
_writeDocumentation(e);
_writeMetadata(e);
- var imports = e.imports.where((import) => !import.isSynthetic).toList();
+ var imports = e.imports2
+ .where((import) => withSyntheticDartCoreImport || !import.isSynthetic)
+ .toList();
_writeElements('imports', imports, _writeImportElement);
_writeElements('exports', e.exports, _writeExportElement);
@@ -426,16 +432,18 @@
}
void _writeDirectiveUri(DirectiveUri uri) {
- if (uri is DirectiveUriWithUnit) {
- _writelnWithIndent('${uri.unit.source.uri}');
+ if (uri is DirectiveUriWithLibraryImpl) {
+ buffer.write('${uri.library.source.uri}');
+ } else if (uri is DirectiveUriWithUnit) {
+ buffer.write('${uri.unit.source.uri}');
} else if (uri is DirectiveUriWithSource) {
- _writelnWithIndent("source '${uri.source.uri}'");
+ buffer.write("source '${uri.source.uri}'");
} else if (uri is DirectiveUriWithRelativeUri) {
- _writelnWithIndent("relativeUri '${uri.relativeUri}'");
+ buffer.write("relativeUri '${uri.relativeUri}'");
} else if (uri is DirectiveUriWithRelativeUriString) {
- _writelnWithIndent("relativeUriString '${uri.relativeUriString}'");
+ buffer.write("relativeUriString '${uri.relativeUriString}'");
} else {
- _writelnWithIndent('noRelativeUriString');
+ buffer.write('noRelativeUriString');
}
}
@@ -571,24 +579,25 @@
}
}
- void _writeImportElement(ImportElement e) {
+ void _writeImportElement(ImportElement2 e) {
_writeIndentedLine(() {
- _writeUri(e.importedLibrary?.source);
- _writeIf(e.isDeferred, ' deferred');
-
- var prefix = e.prefix;
- if (prefix != null) {
- buffer.write(' as ');
- _writeName(prefix);
- }
+ _writeDirectiveUri(e.uri);
+ _writeIf(e.isSynthetic, ' synthetic');
+ _writeImportElementPrefix(e.prefix);
});
_withIndent(() {
_writeMetadata(e);
_writeNamespaceCombinators(e.combinators);
});
+ }
- _assertNonSyntheticElementSelf(e);
+ void _writeImportElementPrefix(ImportElementPrefix? prefix) {
+ if (prefix != null) {
+ _writeIf(prefix is DeferredImportElementPrefix, ' deferred');
+ buffer.write(' as ');
+ _writeName(prefix.element);
+ }
}
void _writeIndentedLine(void Function() f) {
@@ -727,7 +736,9 @@
void _writePartElement(PartElement e) {
final uri = e.uri;
- _writeDirectiveUri(uri);
+ _writeIndentedLine(() {
+ _writeDirectiveUri(e.uri);
+ });
_withIndent(() {
_writeMetadata(e);
diff --git a/pkg/analyzer/test/src/summary/elements_test.dart b/pkg/analyzer/test/src/summary/elements_test.dart
index 0f4a224..91fbd41 100644
--- a/pkg/analyzer/test/src/summary/elements_test.dart
+++ b/pkg/analyzer/test/src/summary/elements_test.dart
@@ -22788,7 +22788,7 @@
staticType: null
element: <null>
imports
- <unresolved>
+ relativeUri 'ht:'
metadata
Annotation
atSign: @ @0
@@ -22832,8 +22832,16 @@
addSource('$testPackageLibPath/a.dart', 'library a; class C {}');
var library = await buildLibrary('import "a.dart" as a; a.C c;');
- expect(library.imports[0].prefix!.nameOffset, 19);
- expect(library.imports[0].prefix!.nameLength, 1);
+ // TODO(scheglov) Remove when removing `imports`.
+ {
+ // ignore: deprecated_member_use_from_same_package
+ final prefixElement = library.imports[0].prefix!;
+ expect(prefixElement.nameOffset, 19);
+ expect(prefixElement.nameLength, 1);
+ }
+
+ final prefixElement = library.imports2[0].prefix!.element;
+ expect(prefixElement.nameOffset, 19);
checkElementText(library, r'''
library
@@ -22860,9 +22868,9 @@
class C {}
class D extends p.C {} // Prevent "unused import" warning
''');
- expect(library.imports, hasLength(2));
- expect(library.imports[0].importedLibrary!.location, library.location);
- expect(library.imports[1].importedLibrary!.isDartCore, true);
+ expect(library.imports2, hasLength(2));
+ expect(library.imports2[0].importedLibrary!.location, library.location);
+ expect(library.imports2[1].importedLibrary!.isDartCore, true);
checkElementText(library, r'''
library
imports
@@ -22920,7 +22928,7 @@
var library = await buildLibrary('''
import "dart:math" show e, pi;
''');
- var import = library.imports[0];
+ var import = library.imports2[0];
var combinator = import.combinators[0] as ShowElementCombinator;
expect(combinator.offset, 19);
expect(combinator.end, 29);
@@ -22930,7 +22938,9 @@
var library = await buildLibrary('''
import 'foo.dart';
''');
- expect(library.imports[0].uri, 'foo.dart');
+
+ final uri = library.imports2[0].uri as DirectiveUriWithLibrary;
+ expect(uri.relativeUriString, 'foo.dart');
}
test_imports() async {
@@ -25366,11 +25376,11 @@
checkElementText(library, r'''
library
imports
- <unresolved>
- <unresolved>
+ relativeUriString ':[invaliduri]'
+ relativeUriString ':[invaliduri]:foo.dart'
package:test/a1.dart
- <unresolved>
- <unresolved>
+ relativeUriString ':[invaliduri]'
+ relativeUriString ':[invaliduri]:foo.dart'
exports
<unresolved>
<unresolved>
@@ -25424,6 +25434,121 @@
''');
}
+ test_library_imports_noRelativeUriStr() async {
+ final library = await buildLibrary(r'''
+import '${'foo'}.dart';
+''');
+ checkElementText(library, r'''
+library
+ imports
+ noRelativeUriString
+ definingUnit
+''');
+ }
+
+ test_library_imports_prefix_importedLibraries() async {
+ final library = await buildLibrary(r'''
+import 'dart:async' as p1;
+import 'dart:collection' as p2;
+import 'dart:math' as p1;
+''');
+ final p1 = library.prefixes.singleWhere((prefix) => prefix.name == 'p1');
+ final import_async = library.imports2[0];
+ final import_math = library.imports2[2];
+ expect(p1.imports2, unorderedEquals([import_async, import_math]));
+ }
+
+ test_library_imports_syntheticDartCore() async {
+ final library = await buildLibrary('');
+ checkElementText(
+ library,
+ r'''
+library
+ imports
+ dart:core synthetic
+ definingUnit
+''',
+ withSyntheticDartCoreImport: true);
+ }
+
+ test_library_imports_withRelativeUri_emptyUriSelf() async {
+ final library = await buildLibrary(r'''
+import '';
+''');
+ checkElementText(library, r'''
+library
+ imports
+ package:test/test.dart
+ definingUnit
+''');
+ }
+
+ test_library_imports_withRelativeUri_noSource() async {
+ final library = await buildLibrary(r'''
+import 'foo:bar';
+''');
+ checkElementText(library, r'''
+library
+ imports
+ relativeUri 'foo:bar'
+ definingUnit
+''');
+ }
+
+ test_library_imports_withRelativeUri_notExists() async {
+ final library = await buildLibrary(r'''
+import 'a.dart';
+''');
+ checkElementText(library, r'''
+library
+ imports
+ package:test/a.dart
+ definingUnit
+''');
+ }
+
+ test_library_imports_withRelativeUri_notLibrary_augmentation() async {
+ newFile('$testPackageLibPath/a.dart', r'''
+library augment 'test.dart';
+''');
+ final library = await buildLibrary(r'''
+import 'a.dart';
+''');
+ checkElementText(library, r'''
+library
+ imports
+ source 'package:test/a.dart'
+ definingUnit
+''');
+ }
+
+ test_library_imports_withRelativeUri_notLibrary_part() async {
+ newFile('$testPackageLibPath/a.dart', r'''
+part of other.lib;
+''');
+ final library = await buildLibrary(r'''
+import 'a.dart';
+''');
+ checkElementText(library, r'''
+library
+ imports
+ source 'package:test/a.dart'
+ definingUnit
+''');
+ }
+
+ test_library_imports_withRelativeUriString() async {
+ final library = await buildLibrary(r'''
+import ':';
+''');
+ checkElementText(library, r'''
+library
+ imports
+ relativeUriString ':'
+ definingUnit
+''');
+ }
+
test_library_name_with_spaces() async {
var library = await buildLibrary('library foo . bar ;');
checkElementText(library, r'''
@@ -25526,7 +25651,6 @@
}
test_library_parts_withRelativeUri_noSource() async {
- newFile('$testPackageLibPath/a.dart', '');
final library = await buildLibrary(r'''
part 'foo:bar';
''');
@@ -25587,6 +25711,16 @@
''');
}
+ test_library_prefixes() async {
+ final library = await buildLibrary(r'''
+import 'dart:async' as p1;
+import 'dart:collection' as p2;
+import 'dart:math' as p1;
+''');
+ final prefixNames = library.prefixes.map((e) => e.name).toList();
+ expect(prefixNames, unorderedEquals(['p1', 'p2']));
+ }
+
test_localFunctions() async {
var library = await buildLibrary(r'''
f() {
@@ -37947,7 +38081,7 @@
test_unresolved_import() async {
var library = await buildLibrary("import 'foo.dart';", allowErrors: true);
- var importedLibrary = library.imports[0].importedLibrary!;
+ var importedLibrary = library.imports2[0].importedLibrary!;
expect(importedLibrary.loadLibraryFunction, isNotNull);
expect(importedLibrary.publicNamespace, isNotNull);
expect(importedLibrary.exportNamespace, isNotNull);
diff --git a/pkg/analyzer/test/src/summary/resolved_ast_printer.dart b/pkg/analyzer/test/src/summary/resolved_ast_printer.dart
index 44ad036..c88cc6a 100644
--- a/pkg/analyzer/test/src/summary/resolved_ast_printer.dart
+++ b/pkg/analyzer/test/src/summary/resolved_ast_printer.dart
@@ -667,7 +667,7 @@
_writeln('ImportDirective');
_withIndent(() {
_writeNamedChildEntities(node);
- _writeElement('element', node.element);
+ _writeElement('element', node.element2);
_writeSource('selectedSource', node.selectedSource);
_writeRaw('selectedUriContent', node.selectedUriContent);
_writeRaw('uriContent', node.uriContent);
diff --git a/pkg/analyzer/test/util/element_type_matchers.dart b/pkg/analyzer/test/util/element_type_matchers.dart
index f286b3f..f05ab87 100644
--- a/pkg/analyzer/test/util/element_type_matchers.dart
+++ b/pkg/analyzer/test/util/element_type_matchers.dart
@@ -30,7 +30,7 @@
const isHideElementCombinator = TypeMatcher<HideElementCombinator>();
-const isImportElement = TypeMatcher<ImportElement>();
+const isImportElement = TypeMatcher<ImportElement2>();
const isLabelElement = TypeMatcher<LabelElement>();
diff --git a/pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart b/pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart
index 9ad3e64..b7bb1be 100644
--- a/pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart
+++ b/pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart
@@ -286,7 +286,7 @@
@override
void writeImportedName(List<Uri> uris, String name) {
assert(uris.isNotEmpty);
- var imports = <ImportElement>[];
+ var imports = <ImportElement2>[];
for (var uri in uris) {
imports.addAll(dartFileEditBuilder._getImportsForUri(uri));
}
@@ -301,7 +301,7 @@
} else {
var prefix = import.prefix;
if (prefix != null) {
- write(prefix.displayName);
+ write(prefix.element.displayName);
write('.');
}
}
@@ -1005,8 +1005,8 @@
/// Given a list of [imports] that do, or can, make the [name] visible in
/// scope, return the one that will lead to the cleanest code.
- ImportElement? _getBestImportForName(
- List<ImportElement> imports, String name) {
+ ImportElement2? _getBestImportForName(
+ List<ImportElement2> imports, String name) {
if (imports.isEmpty) {
return null;
} else if (imports.length == 1) {
@@ -1160,7 +1160,7 @@
if (import != null) {
var prefix = import.prefix;
if (prefix != null) {
- write(prefix.displayName);
+ write(prefix.element.displayName);
write('.');
}
} else {
@@ -1464,10 +1464,10 @@
return ImportLibraryElementResultImpl(null);
}
- for (var import in resolvedUnit.libraryElement.imports) {
+ for (var import in resolvedUnit.libraryElement.imports2) {
var importedLibrary = import.importedLibrary;
if (importedLibrary != null && importedLibrary.source.uri == uri) {
- return ImportLibraryElementResultImpl(import.prefix?.name);
+ return ImportLibraryElementResultImpl(import.prefix?.element.name);
}
}
@@ -1489,7 +1489,7 @@
if (resolvedUnit.libraryElement.source.uri == uri) return false;
// Existing import.
- for (var import in resolvedUnit.libraryElement.imports) {
+ for (var import in resolvedUnit.libraryElement.imports2) {
var importedLibrary = import.importedLibrary;
if (importedLibrary != null && importedLibrary.source.uri == uri) {
return true;
@@ -1752,8 +1752,8 @@
/// Return the import element used to import the given [element] into the
/// target library, or `null` if the element was not imported, such as when
/// the element is declared in the same library.
- ImportElement? _getImportElement(Element element) {
- for (var import in resolvedUnit.libraryElement.imports) {
+ ImportElement2? _getImportElement(Element element) {
+ for (var import in resolvedUnit.libraryElement.imports2) {
var definedNames = import.namespace.definedNames;
if (definedNames.containsValue(element)) {
return import;
@@ -1762,8 +1762,8 @@
return null;
}
- Iterable<ImportElement> _getImportsForUri(Uri uri) sync* {
- for (var import in resolvedUnit.libraryElement.imports) {
+ Iterable<ImportElement2> _getImportsForUri(Uri uri) sync* {
+ for (var import in resolvedUnit.libraryElement.imports2) {
var importUri = import.importedLibrary?.source.uri;
if (importUri == uri) {
yield import;
diff --git a/pkg/analyzer_plugin/lib/utilities/navigation/navigation_dart.dart b/pkg/analyzer_plugin/lib/utilities/navigation/navigation_dart.dart
index dada67b..23df1dd 100644
--- a/pkg/analyzer_plugin/lib/utilities/navigation/navigation_dart.dart
+++ b/pkg/analyzer_plugin/lib/utilities/navigation/navigation_dart.dart
@@ -26,17 +26,39 @@
unit.accept(visitor);
} else {
var node = _getNodeForRange(unit, offset, length);
- // Take the outer-most node that shares this offset/length so that we get
- // things like ConstructorName instead of SimpleIdentifier.
- // https://github.com/dart-lang/sdk/issues/46725
if (node != null) {
- node = _getOutermostNode(node);
+ node = _getNavigationTargetNode(node);
}
node?.accept(visitor);
}
return collector;
}
+/// Gets the nearest node that should be used for navigation.
+///
+/// This is usually the outermost node with the same offset as node but in some
+/// cases may be a different ancestor where required to produce the correct
+/// result.
+AstNode _getNavigationTargetNode(AstNode node) {
+ AstNode? current = node;
+ while (current != null &&
+ current.parent != null &&
+ current.offset == current.parent!.offset) {
+ current = current.parent;
+ }
+ current ??= node;
+
+ // To navigate to formal params, we need to visit the parameter and not just
+ // the identifier but they don't start at the same offset as they have a
+ // prefix.
+ final parent = current.parent;
+ if (parent is FormalParameter) {
+ current = parent;
+ }
+
+ return current;
+}
+
AstNode? _getNodeForRange(CompilationUnit unit, int offset, int length) {
var node = NodeLocator(offset, offset + length).searchWithin(unit);
for (var n = node; n != null; n = n.parent) {
@@ -47,21 +69,6 @@
return node;
}
-/// Gets the outer-most node with the same offset as node.
-///
-/// This reduces the number of nodes the visitor needs to walk when collecting
-/// navigation for a specific location in the file.
-AstNode _getOutermostNode(AstNode node) {
- AstNode? current = node;
- while (current != null &&
- current.parent != null &&
- current != current.parent &&
- current.offset == current.parent!.offset) {
- current = current.parent;
- }
- return current ?? node;
-}
-
/// A Dart specific wrapper around [NavigationCollector].
class _DartNavigationCollector {
final NavigationCollector collector;
@@ -360,7 +367,7 @@
@override
void visitImportDirective(ImportDirective node) {
- var importElement = node.element;
+ var importElement = node.element2;
if (importElement != null) {
Element? libraryElement = importElement.importedLibrary;
_addUriDirectiveRegion(node, libraryElement);
diff --git a/pkg/compiler/lib/src/compiler.dart b/pkg/compiler/lib/src/compiler.dart
index 5fdd14b..2c08f76 100644
--- a/pkg/compiler/lib/src/compiler.dart
+++ b/pkg/compiler/lib/src/compiler.dart
@@ -685,11 +685,12 @@
// Dump Info.
if (options.dumpInfo) {
- runDumpInfo(codegenResults, programSize);
+ await runDumpInfo(codegenResults, programSize);
}
}
- void runDumpInfo(CodegenResults codegenResults, int programSize) {
+ Future<void> runDumpInfo(
+ CodegenResults codegenResults, int programSize) async {
GlobalTypeInferenceResults globalTypeInferenceResults =
codegenResults.globalTypeInferenceResults;
JClosedWorld closedWorld = globalTypeInferenceResults.closedWorld;
@@ -698,11 +699,13 @@
dumpInfoTask.reportSize(programSize);
if (options.features.newDumpInfo.isEnabled) {
assert(untrimmedComponentForDumpInfo != null);
- dumpInfoState = dumpInfoTask.dumpInfoNew(untrimmedComponentForDumpInfo,
- closedWorld, globalTypeInferenceResults);
+ dumpInfoState = await dumpInfoTask.dumpInfoNew(
+ untrimmedComponentForDumpInfo,
+ closedWorld,
+ globalTypeInferenceResults);
} else {
dumpInfoState =
- dumpInfoTask.dumpInfo(closedWorld, globalTypeInferenceResults);
+ await dumpInfoTask.dumpInfo(closedWorld, globalTypeInferenceResults);
}
if (retainDataForTesting) {
dumpInfoStateForTesting = dumpInfoState;
diff --git a/pkg/compiler/lib/src/dump_info.dart b/pkg/compiler/lib/src/dump_info.dart
index 18cba93..e5d7229 100644
--- a/pkg/compiler/lib/src/dump_info.dart
+++ b/pkg/compiler/lib/src/dump_info.dart
@@ -20,6 +20,7 @@
import 'common/elements.dart' show JElementEnvironment;
import 'common/names.dart';
import 'common/tasks.dart' show CompilerTask;
+import 'common/ram_usage.dart';
import 'compiler.dart' show Compiler;
import 'constants/values.dart' show ConstantValue, InterceptorConstantValue;
import 'deferred_load/output_unit.dart' show OutputUnit, deferredPartFileName;
@@ -1234,30 +1235,32 @@
return code.map((ast) => _nodeData[ast]).toList();
}
- DumpInfoStateData dumpInfo(JClosedWorld closedWorld,
- GlobalTypeInferenceResults globalInferenceResults) {
+ Future<DumpInfoStateData> dumpInfo(JClosedWorld closedWorld,
+ GlobalTypeInferenceResults globalInferenceResults) async {
DumpInfoStateData dumpInfoState;
- measure(() {
+ await measure(() async {
ElementInfoCollector elementInfoCollector = ElementInfoCollector(
compiler, this, closedWorld, globalInferenceResults)
..run();
- dumpInfoState = buildDumpInfoData(closedWorld, elementInfoCollector);
+ dumpInfoState =
+ await buildDumpInfoData(closedWorld, elementInfoCollector);
if (useBinaryFormat) {
dumpInfoBinary(dumpInfoState.info);
} else {
dumpInfoJson(dumpInfoState.info);
}
+ return;
});
return dumpInfoState;
}
- DumpInfoStateData dumpInfoNew(
+ Future<DumpInfoStateData> dumpInfoNew(
ir.Component component,
JClosedWorld closedWorld,
- GlobalTypeInferenceResults globalInferenceResults) {
+ GlobalTypeInferenceResults globalInferenceResults) async {
DumpInfoStateData dumpInfoState;
- measure(() {
+ await measure(() async {
KernelInfoCollector kernelInfoCollector =
KernelInfoCollector(component, compiler, this, closedWorld)..run();
@@ -1265,7 +1268,8 @@
globalInferenceResults)
..run();
- dumpInfoState = buildDumpInfoDataNew(closedWorld, kernelInfoCollector);
+ dumpInfoState =
+ await buildDumpInfoDataNew(closedWorld, kernelInfoCollector);
TreeShakingInfoVisitor().filter(dumpInfoState.info);
if (useBinaryFormat) {
@@ -1308,8 +1312,8 @@
});
}
- DumpInfoStateData buildDumpInfoData(
- JClosedWorld closedWorld, ElementInfoCollector infoCollector) {
+ Future<DumpInfoStateData> buildDumpInfoData(
+ JClosedWorld closedWorld, ElementInfoCollector infoCollector) async {
Stopwatch stopwatch = Stopwatch();
stopwatch.start();
@@ -1371,6 +1375,7 @@
entrypoint: infoCollector
.state.entityToInfo[closedWorld.elementEnvironment.mainFunction],
size: _programSize,
+ ramUsage: await currentHeapCapacityInMb(),
dart2jsVersion:
compiler.options.hasBuildId ? compiler.options.buildId : null,
compilationMoment: DateTime.now(),
@@ -1387,8 +1392,8 @@
return result;
}
- DumpInfoStateData buildDumpInfoDataNew(
- JClosedWorld closedWorld, KernelInfoCollector infoCollector) {
+ Future<DumpInfoStateData> buildDumpInfoDataNew(
+ JClosedWorld closedWorld, KernelInfoCollector infoCollector) async {
Stopwatch stopwatch = Stopwatch();
stopwatch.start();
@@ -1453,6 +1458,7 @@
entrypoint: infoCollector
.state.entityToInfo[closedWorld.elementEnvironment.mainFunction],
size: _programSize,
+ ramUsage: await currentHeapCapacityInMb(),
dart2jsVersion:
compiler.options.hasBuildId ? compiler.options.buildId : null,
compilationMoment: DateTime.now(),
diff --git a/pkg/compiler/lib/src/inferrer/builder.dart b/pkg/compiler/lib/src/inferrer/builder.dart
index 6eb60d8..6a4a5f2 100644
--- a/pkg/compiler/lib/src/inferrer/builder.dart
+++ b/pkg/compiler/lib/src/inferrer/builder.dart
@@ -434,10 +434,6 @@
case ir.AsyncMarker.AsyncStar:
recordReturnType(_types.asyncStarStreamType);
break;
- case ir.AsyncMarker.SyncYielding:
- failedAt(
- _analyzedMember, "Unexpected async marker: ${node.asyncMarker}");
- break;
}
assert(_breaksFor.isEmpty);
assert(_continuesFor.isEmpty);
diff --git a/pkg/compiler/lib/src/inferrer/engine.dart b/pkg/compiler/lib/src/inferrer/engine.dart
index 6cae1c6..f088516 100644
--- a/pkg/compiler/lib/src/inferrer/engine.dart
+++ b/pkg/compiler/lib/src/inferrer/engine.dart
@@ -65,6 +65,7 @@
@override
final JsClosedWorld closedWorld;
+ @override
final TypeSystem types;
final Map<ir.TreeNode, TypeInformation> concreteTypes = {};
final GlobalLocalsMap globalLocalsMap;
@@ -174,6 +175,7 @@
/// Returns the type for [nativeBehavior]. See documentation on
/// [NativeBehavior].
+ @override
TypeInformation typeOfNativeBehavior(NativeBehavior nativeBehavior) {
if (nativeBehavior == null) return types.dynamicType;
List<Object> typesReturned = nativeBehavior.typesReturned;
@@ -214,6 +216,7 @@
return returnType;
}
+ @override
void updateSelectorInMember(MemberEntity owner, CallType callType,
ir.Node node, Selector selector, AbstractValue mask) {
KernelGlobalTypeInferenceElementData data = dataOfMember(owner);
@@ -755,6 +758,7 @@
/// Update the inputs to parameters in the graph. [remove] tells whether
/// inputs must be added or removed. If [init] is false, parameters are
/// added to the work queue.
+ @override
void updateParameterInputs(TypeInformation caller, MemberEntity callee,
ArgumentsTypes arguments, Selector selector,
{bool remove, bool addToQueue = true}) {
@@ -846,6 +850,7 @@
///
/// Invariant: After graph construction, no [PlaceholderTypeInformation] nodes
/// should be present and a default type for each parameter should exist.
+ @override
TypeInformation getDefaultTypeOfParameter(Local parameter) {
return _defaultTypeOfParameter.putIfAbsent(parameter, () {
return PlaceholderTypeInformation(
@@ -1093,6 +1098,7 @@
}
/// Returns the type of [element] when being called with [selector].
+ @override
TypeInformation typeOfMemberWithSelector(
MemberEntity element, Selector selector) {
if (element.name == Identifiers.noSuchMethod_ &&
@@ -1176,6 +1182,7 @@
///
/// One category of elements that do not apply is runtime helpers that the
/// backend calls, but the optimizations don't see those calls.
+ @override
bool canFieldBeUsedForGlobalOptimizations(FieldEntity element) {
if (closedWorld.backendUsage.isFieldUsedByBackend(element)) {
return false;
@@ -1191,12 +1198,14 @@
///
/// One category of elements that do not apply is runtime helpers that the
/// backend calls, but the optimizations don't see those calls.
+ @override
bool canFunctionParametersBeUsedForGlobalOptimizations(
FunctionEntity function) {
return !closedWorld.backendUsage.isFunctionUsedByBackend(function);
}
/// Returns `true` if inference of parameter types is disabled for [member].
+ @override
bool assumeDynamic(MemberEntity member) {
return closedWorld.annotationsData.hasAssumeDynamic(member);
}
diff --git a/pkg/compiler/lib/src/inferrer/engine_interfaces.dart b/pkg/compiler/lib/src/inferrer/engine_interfaces.dart
index 80c7d3e..ce45629 100644
--- a/pkg/compiler/lib/src/inferrer/engine_interfaces.dart
+++ b/pkg/compiler/lib/src/inferrer/engine_interfaces.dart
@@ -2,22 +2,42 @@
// 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:kernel/ast.dart' as ir;
+
import '../common/elements.dart';
import '../elements/entities.dart';
import '../js_backend/inferred_data.dart';
import '../js_backend/no_such_method_registry_interfaces.dart';
+import '../native/behavior.dart';
import '../universe/selector.dart';
import '../world_interfaces.dart';
import 'abstract_value_domain.dart';
+import 'locals_handler.dart';
+import 'type_graph_nodes.dart';
+import 'type_system.dart';
abstract class InferrerEngine {
AbstractValueDomain get abstractValueDomain;
+ TypeSystem get types;
JClosedWorld get closedWorld;
CommonElements get commonElements;
InferredDataBuilder get inferredDataBuilder;
FunctionEntity get mainElement;
NoSuchMethodData get noSuchMethodData;
+ TypeInformation typeOfNativeBehavior(NativeBehavior nativeBehavior);
+ bool canFieldBeUsedForGlobalOptimizations(FieldEntity element);
+ bool assumeDynamic(MemberEntity member);
+ TypeInformation getDefaultTypeOfParameter(Local parameter);
+ bool canFunctionParametersBeUsedForGlobalOptimizations(
+ FunctionEntity function);
+ TypeInformation typeOfMemberWithSelector(
+ MemberEntity element, Selector? selector);
+ void updateSelectorInMember(MemberEntity owner, CallType callType,
+ ir.Node? node, Selector? selector, AbstractValue? mask);
+ void updateParameterInputs(TypeInformation caller, MemberEntity callee,
+ ArgumentsTypes? arguments, Selector? selector,
+ {required bool remove, bool addToQueue = true});
bool returnsListElementType(Selector selector, AbstractValue mask);
bool returnsMapValueType(Selector selector, AbstractValue mask);
}
diff --git a/pkg/compiler/lib/src/inferrer/locals_handler.dart b/pkg/compiler/lib/src/inferrer/locals_handler.dart
index 69f77f5..a9c0265 100644
--- a/pkg/compiler/lib/src/inferrer/locals_handler.dart
+++ b/pkg/compiler/lib/src/inferrer/locals_handler.dart
@@ -2,8 +2,6 @@
// 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.
-// @dart = 2.10
-
library locals_handler;
import 'dart:collection' show IterableMixin;
@@ -11,7 +9,7 @@
import '../elements/entities.dart';
import '../ir/util.dart';
import '../util/util.dart';
-import 'engine.dart';
+import 'engine_interfaces.dart';
import 'type_graph_nodes.dart';
/// A variable scope holds types for variables. It has a link to a
@@ -25,15 +23,15 @@
/// This is used for computing common parents efficiently.
final int _level;
- Map<Local, TypeInformation> variables;
+ Map<Local, TypeInformation>? variables;
/// The parent of this scope. Null for the root scope.
- final VariableScope parent;
+ final VariableScope? parent;
/// The [ir.Node] that created this scope.
- final ir.Node tryBlock;
+ final ir.Node? tryBlock;
- final VariableScope copyOf;
+ final VariableScope? copyOf;
VariableScope({this.parent})
: this.variables = null,
@@ -52,13 +50,13 @@
VariableScope.deepCopyOf(VariableScope other)
: variables = other.variables == null
? null
- : Map<Local, TypeInformation>.from(other.variables),
+ : Map<Local, TypeInformation>.from(other.variables!),
tryBlock = other.tryBlock,
copyOf = other.copyOf ?? other,
_level = other._level,
parent = other.parent == null
? null
- : VariableScope.deepCopyOf(other.parent);
+ : VariableScope.deepCopyOf(other.parent!);
/// `true` if this scope is for a try block.
bool get isTry => tryBlock != null;
@@ -70,50 +68,47 @@
VariableScope get identity => copyOf ?? this;
/// Returns the common parent between this and [other] based on [identity].
- VariableScope commonParent(VariableScope other) {
+ VariableScope? commonParent(VariableScope other) {
if (identity == other.identity) {
return identity;
} else if (_level > other._level) {
- return parent.commonParent(other);
+ return parent!.commonParent(other);
} else if (_level < other._level) {
- return commonParent(other.parent);
+ return commonParent(other.parent!);
} else if (_level > 0) {
- return parent.commonParent(other.parent);
+ return parent!.commonParent(other.parent!);
} else {
return null;
}
}
- TypeInformation operator [](Local variable) {
- TypeInformation result;
- if (variables == null || (result = variables[variable]) == null) {
- return parent == null ? null : parent[variable];
+ TypeInformation? operator [](Local variable) {
+ TypeInformation? result;
+ if (variables == null || (result = variables![variable]) == null) {
+ return parent == null ? null : parent![variable];
}
return result;
}
void operator []=(Local variable, TypeInformation mask) {
- assert(mask != null);
- if (variables == null) {
- variables = Map<Local, TypeInformation>();
- }
- variables[variable] = mask;
+ assert((mask as dynamic) != null); // TODO(48820): Remove when sound.
+ (variables ??= <Local, TypeInformation>{})[variable] = mask;
}
/// Calls [f] for all variables in this and parent scopes until and including
/// [scope]. [f] is called at most once for each variable.
void forEachLocalUntilScope(
- VariableScope scope, void f(Local variable, TypeInformation type)) {
+ VariableScope? scope, void f(Local variable, TypeInformation type)) {
_forEachLocalUntilScope(scope, f, Setlet<Local>(), this);
}
void _forEachLocalUntilScope(
- VariableScope scope,
+ VariableScope? scope,
void f(Local variable, TypeInformation type),
Setlet<Local> seenLocals,
VariableScope origin) {
if (variables != null) {
- variables.forEach((variable, type) {
+ variables!.forEach((variable, type) {
if (seenLocals.contains(variable)) return;
seenLocals.add(variable);
f(variable, type);
@@ -123,7 +118,7 @@
return;
}
if (parent != null) {
- parent._forEachLocalUntilScope(scope, f, seenLocals, origin);
+ parent!._forEachLocalUntilScope(scope, f, seenLocals, origin);
} else {
assert(
scope == null,
@@ -139,7 +134,7 @@
bool updates(Local variable) {
if (variables == null) return false;
- return variables.containsKey(variable);
+ return variables!.containsKey(variable);
}
String toStructuredText(String indent) {
@@ -155,18 +150,18 @@
sb.write('\n${indent} copyOf:VariableScope(${copyOf.hashCode})');
}
if (tryBlock != null) {
- sb.write('\n${indent} tryBlock: ${nodeToDebugString(tryBlock)}');
+ sb.write('\n${indent} tryBlock: ${nodeToDebugString(tryBlock!)}');
}
if (variables != null) {
sb.write('\n${indent} variables:');
- variables.forEach((Local local, TypeInformation type) {
+ variables!.forEach((Local local, TypeInformation type) {
sb.write('\n${indent} $local: ');
sb.write(type.toStructuredText('${indent} '));
});
}
if (parent != null) {
sb.write('\n${indent} parent:');
- parent._toStructuredText(sb, '${indent} ');
+ parent!._toStructuredText(sb, '${indent} ');
}
sb.write(']');
}
@@ -180,7 +175,7 @@
/// Tracks initializers via initializations and assignments.
class FieldInitializationScope {
- Map<FieldEntity, TypeInformation> fields;
+ Map<FieldEntity, TypeInformation>? fields;
bool isThisExposed;
/// `true` when control flow prevents accumulating definite assignments,
@@ -195,7 +190,7 @@
: isThisExposed = other.isThisExposed,
isIndefinite = other.isIndefinite;
- factory FieldInitializationScope.from(FieldInitializationScope other) {
+ static FieldInitializationScope? from(FieldInitializationScope? other) {
if (other == null) return null;
return FieldInitializationScope.internalFrom(other);
}
@@ -203,12 +198,11 @@
void updateField(FieldEntity field, TypeInformation type) {
if (isThisExposed) return;
if (isIndefinite) return;
- fields ??= Map<FieldEntity, TypeInformation>();
- fields[field] = type;
+ (fields ??= <FieldEntity, TypeInformation>{})[field] = type;
}
- TypeInformation readField(FieldEntity field) {
- return fields == null ? null : fields[field];
+ TypeInformation? readField(FieldEntity field) {
+ return fields == null ? null : fields![field];
}
void forEach(void f(FieldEntity element, TypeInformation type)) {
@@ -219,7 +213,7 @@
/// flow through either [thenScope] or [elseScope].
FieldInitializationScope mergeDiamondFlow(InferrerEngine inferrer,
FieldInitializationScope thenScope, FieldInitializationScope elseScope) {
- assert(elseScope != null);
+ assert((elseScope as dynamic) != null); // TODO(48820): Remove when sound.
// Quick bailout check. If [isThisExposed] or [isIndefinite] is true, we
// know the code following won't do anything.
@@ -230,7 +224,7 @@
elseScope.fields == null ? this : elseScope;
thenScope.forEach((FieldEntity field, TypeInformation type) {
- TypeInformation otherType = otherScope.readField(field);
+ final otherType = otherScope.readField(field);
if (otherType == null) return;
updateField(field, inferrer.types.allocateDiamondPhi(type, otherType));
});
@@ -246,10 +240,10 @@
final List<TypeInformation> positional;
final Map<String, TypeInformation> named;
- ArgumentsTypes(this.positional, Map<String, TypeInformation> named)
+ ArgumentsTypes(this.positional, Map<String, TypeInformation>? named)
: this.named = (named == null || named.isEmpty) ? const {} : named {
- assert(this.positional.every((TypeInformation type) => type != null));
- assert(this.named.values.every((TypeInformation type) => type != null));
+ assert(this.positional.every((TypeInformation? type) => type != null));
+ assert(this.named.values.every((TypeInformation? type) => type != null));
}
ArgumentsTypes.empty()
@@ -266,7 +260,8 @@
String toString() => "{ positional = $positional, named = $named }";
@override
- bool operator ==(other) {
+ bool operator ==(Object? other) {
+ if (other is! ArgumentsTypes) return false;
if (positional.length != other.positional.length) return false;
if (named.length != other.named.length) return false;
for (int i = 0; i < positional.length; i++) {
@@ -296,7 +291,7 @@
}
@override
- bool contains(Object type) {
+ bool contains(Object? type) {
return positional.contains(type) || named.containsValue(type);
}
}
@@ -341,26 +336,25 @@
LocalsHandler.deepCopyOf(LocalsHandler other)
: _locals = VariableScope.deepCopyOf(other._locals);
- TypeInformation use(Local local) {
+ TypeInformation? use(Local local) {
return _locals[local];
}
void update(InferrerEngine inferrer, Local local, TypeInformation type,
- LocalsHandler tryBlock) {
+ LocalsHandler? tryBlock) {
if (tryBlock != null) {
// We don't know if an assignment in a try block
// will be executed, so all assignments in that block are
// potential types after we have left it. We update the parent
// of the try block so that, at exit of the try block, we get
// the right phi for it.
- TypeInformation existing = tryBlock._locals.parent[local];
+ final existing = tryBlock._locals.parent![local];
if (existing != null) {
- TypeInformation phiType = inferrer.types.allocatePhi(
+ final phiType = inferrer.types.allocatePhi(
tryBlock._locals.tryBlock, local, existing,
isTry: tryBlock._locals.isTry);
- TypeInformation inputType =
- inferrer.types.addPhiInput(local, phiType, type);
- tryBlock._locals.parent[local] = inputType;
+ final inputType = inferrer.types.addPhiInput(local, phiType, type);
+ tryBlock._locals.parent![local] = inputType;
}
// Update the current handler unconditionally with the new
// type.
@@ -378,7 +372,7 @@
/// from both are merged with a phi type.
LocalsHandler mergeFlow(InferrerEngine inferrer, LocalsHandler other,
{bool inPlace = false}) {
- VariableScope common = _locals.commonParent(other._locals);
+ final common = _locals.commonParent(other._locals);
assert(
common != null,
"No common parent for\n"
@@ -387,11 +381,11 @@
assert(
common == _locals || _locals.variables == null,
"Non-empty common parent for\n"
- "1:${common.toStructuredText(' ')}\n"
+ "1:${common?.toStructuredText(' ')}\n"
"2:${_locals.toStructuredText(' ')}");
other._locals.forEachLocalUntilScope(common,
(Local local, TypeInformation type) {
- TypeInformation myType = _locals[local];
+ final myType = _locals[local];
if (myType == null) return; // Variable is only defined in [other].
if (type == myType) return;
_locals[local] =
@@ -404,13 +398,13 @@
/// flow through either [thenBranch] or [elseBranch].
LocalsHandler mergeDiamondFlow(InferrerEngine inferrer,
LocalsHandler thenBranch, LocalsHandler elseBranch) {
- assert(elseBranch != null);
+ assert((elseBranch as dynamic) != null); // TODO(48820): Remove when sound.
void mergeLocal(Local local) {
- TypeInformation myType = _locals[local];
+ final myType = _locals[local];
if (myType == null) return;
- TypeInformation elseType = elseBranch._locals[local];
- TypeInformation thenType = thenBranch._locals[local];
+ final elseType = elseBranch._locals[local]!;
+ final thenType = thenBranch._locals[local]!;
if (thenType == elseType) {
_locals[local] = thenType;
} else {
@@ -418,7 +412,7 @@
}
}
- VariableScope common = _locals.commonParent(thenBranch._locals);
+ final common = _locals.commonParent(thenBranch._locals);
assert(
common != null,
"No common parent for\n"
@@ -427,12 +421,12 @@
assert(
_locals.commonParent(elseBranch._locals) == common,
"Diff common parent for\n"
- "1:${common.toStructuredText(' ')}\n2:"
+ "1:${common?.toStructuredText(' ')}\n2:"
"${_locals.commonParent(elseBranch._locals)?.toStructuredText(' ')}");
assert(
common == _locals || _locals.variables == null,
"Non-empty common parent for\n"
- "common:${common.toStructuredText(' ')}\n"
+ "common:${common?.toStructuredText(' ')}\n"
"1:${_locals.toStructuredText(' ')}\n"
"2:${thenBranch._locals.toStructuredText(' ')}");
thenBranch._locals.forEachLocalUntilScope(common, (Local local, _) {
@@ -477,7 +471,7 @@
LocalsHandler mergeAfterBreaks(
InferrerEngine inferrer, Iterable<LocalsHandler> handlers,
{bool keepOwnLocals = true}) {
- ir.Node tryBlock = _locals.tryBlock;
+ final tryBlock = _locals.tryBlock;
// Use a separate locals handler to perform the merge in, so that Phi
// creation does not invalidate previous type knowledge while we might
// still look it up.
@@ -487,7 +481,7 @@
Set<Local> seenLocals = Setlet<Local>();
// Merge all other handlers.
for (LocalsHandler handler in handlers) {
- VariableScope common = _locals.commonParent(handler._locals);
+ final common = _locals.commonParent(handler._locals);
assert(
common != null,
"No common parent for\n"
@@ -496,11 +490,11 @@
assert(
common == _locals || _locals.variables == null,
"Non-empty common parent for\n"
- "common:${common.toStructuredText(' ')}\n"
+ "common:${common?.toStructuredText(' ')}\n"
"1:${_locals.toStructuredText(' ')}\n"
"2:${handler._locals.toStructuredText(' ')}");
handler._locals.forEachLocalUntilScope(common, (local, otherType) {
- TypeInformation myType = merged[local];
+ final myType = merged[local];
if (myType == null) return;
TypeInformation newType;
if (!seenLocals.contains(local)) {
@@ -509,7 +503,8 @@
isTry: merged.isTry);
seenLocals.add(local);
} else {
- newType = inferrer.types.addPhiInput(local, myType, otherType);
+ newType = inferrer.types.addPhiInput(
+ local, myType as PhiElementTypeInformation, otherType);
}
if (newType != myType) {
merged[local] = newType;
@@ -520,10 +515,10 @@
// [merged] to update the Phi nodes with original values.
if (keepOwnLocals) {
for (Local variable in seenLocals) {
- TypeInformation originalType = _locals[variable];
+ final originalType = _locals[variable];
if (originalType != null) {
- merged[variable] = inferrer.types
- .addPhiInput(variable, merged[variable], originalType);
+ merged[variable] = inferrer.types.addPhiInput(variable,
+ merged[variable] as PhiElementTypeInformation, originalType);
}
}
}
@@ -531,7 +526,8 @@
// actual locals handler.
merged.forEachLocalUntilScope(merged,
(Local variable, TypeInformation type) {
- _locals[variable] = inferrer.types.simplifyPhi(tryBlock, variable, type);
+ _locals[variable] = inferrer.types
+ .simplifyPhi(tryBlock, variable, type as PhiElementTypeInformation);
});
return this;
}
@@ -541,7 +537,7 @@
bool mergeAll(InferrerEngine inferrer, Iterable<LocalsHandler> handlers) {
bool changed = false;
handlers.forEach((LocalsHandler other) {
- VariableScope common = _locals.commonParent(other._locals);
+ final common = _locals.commonParent(other._locals);
assert(
common != null,
"No common parent for\n"
@@ -550,14 +546,14 @@
assert(
common == _locals || _locals.variables == null,
"Non-empty common parent for\n"
- "common:${common.toStructuredText(' ')}\n"
+ "common:${common?.toStructuredText(' ')}\n"
"1:${_locals.toStructuredText(' ')}\n"
"2:${other._locals.toStructuredText(' ')}");
other._locals.forEachLocalUntilScope(common, (local, otherType) {
- TypeInformation myType = _locals[local];
+ final myType = _locals[local];
if (myType == null) return;
- TypeInformation newType =
- inferrer.types.addPhiInput(local, myType, otherType);
+ TypeInformation newType = inferrer.types
+ .addPhiInput(local, myType as PhiElementTypeInformation, otherType);
if (newType != myType) {
changed = true;
_locals[local] = newType;
@@ -579,8 +575,8 @@
void endLoop(InferrerEngine inferrer, ir.Node loop) {
_locals.forEachLocal((Local variable, TypeInformation type) {
- TypeInformation newType =
- inferrer.types.simplifyPhi(loop, variable, type);
+ final newType = inferrer.types
+ .simplifyPhi(loop, variable, type as PhiElementTypeInformation);
if (newType != type) {
_locals[variable] = newType;
}
diff --git a/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart b/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
index 8f28c04..6a698dc 100644
--- a/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
+++ b/pkg/compiler/lib/src/inferrer/type_graph_nodes.dart
@@ -2,8 +2,6 @@
// 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.
-// @dart = 2.10
-
library compiler.src.inferrer.type_graph_nodes;
import 'dart:collection' show IterableBase;
@@ -16,11 +14,11 @@
import '../elements/types.dart';
import '../universe/selector.dart' show Selector;
import '../util/util.dart' show Setlet;
-import '../world.dart' show JClosedWorld;
+import '../world_interfaces.dart' show JClosedWorld;
import 'abstract_value_domain.dart';
import 'debug.dart' as debug;
import 'locals_handler.dart' show ArgumentsTypes;
-import 'engine.dart';
+import 'engine_interfaces.dart';
import 'type_system.dart';
/// Common class for all nodes in the graph. The current nodes are:
@@ -46,10 +44,10 @@
AbstractValue type;
/// The graph node of the member this [TypeInformation] node belongs to.
- final MemberTypeInformation context;
+ final MemberTypeInformation? context;
/// The element this [TypeInformation] node belongs to.
- MemberEntity get contextMember => context?.member;
+ MemberEntity? get contextMember => context?.member;
ParameterInputs get inputs => _inputs;
@@ -189,7 +187,7 @@
/// The [Element] where this [TypeInformation] was created. May be `null`
/// for some [TypeInformation] nodes, where we do not need to store
/// the information.
- MemberEntity get owner => (context != null) ? context.member : null;
+ MemberEntity? get owner => (context != null) ? context?.member : null;
/// Returns whether the type cannot change after it has been
/// inferred.
@@ -341,10 +339,11 @@
@override
Iterator<TypeInformation> get iterator => _inputs.keys.iterator;
@override
- Iterable<TypeInformation> where(Function f) => _inputs.keys.where(f);
+ Iterable<TypeInformation> where(bool Function(TypeInformation) f) =>
+ _inputs.keys.where(f);
@override
- bool contains(Object info) => _inputs.containsKey(info);
+ bool contains(Object? info) => _inputs.containsKey(info);
@override
String toString() => _inputs.keys.toList().toString();
@@ -380,10 +379,10 @@
bool disableInferenceForClosures = true;
ElementTypeInformation._internal(
- AbstractValueDomain abstractValueDomain, MemberTypeInformation context)
+ AbstractValueDomain abstractValueDomain, MemberTypeInformation? context)
: super(abstractValueDomain.emptyType, context);
ElementTypeInformation._withInputs(AbstractValueDomain abstractValueDomain,
- MemberTypeInformation context, ParameterInputs inputs)
+ MemberTypeInformation? context, ParameterInputs inputs)
: super.withInputs(abstractValueDomain.emptyType, context, inputs);
String getInferredSignature(TypeSystem types);
@@ -410,7 +409,7 @@
// Strict `bool` value is computed in cleanup(). Also used as a flag to see if
// cleanup has been called.
- bool _isCalledOnce = null;
+ bool? _isCalledOnce = null;
/// Whether this member is invoked via indirect dynamic calls. In that case
/// the exact number of call sites cannot be computed precisely.
@@ -423,7 +422,7 @@
///
/// The global information is summarized in [cleanup], after which [_callers]
/// is set to `null`.
- Map<MemberEntity, Setlet<ir.Node /*?*/ >> _callers;
+ Map<MemberEntity, Setlet<ir.Node?>>? _callers;
MemberTypeInformation._internal(
AbstractValueDomain abstractValueDomain, this._member)
@@ -434,22 +433,24 @@
@override
String get debugName => '$member';
- void addCall(MemberEntity caller, ir.Node /*?*/ node) {
- _callers ??= <MemberEntity, Setlet<ir.Node /*?*/ >>{};
- _callers.putIfAbsent(caller, () => Setlet()).add(node);
+ void addCall(MemberEntity caller, ir.Node? node) {
+ (_callers ??= <MemberEntity, Setlet<ir.Node?>>{})
+ .putIfAbsent(caller, () => Setlet())
+ .add(node);
}
- void removeCall(MemberEntity caller, ir.Node /*?*/ node) {
- if (_callers == null) return;
- Setlet calls = _callers[caller];
+ void removeCall(MemberEntity caller, Object node) {
+ final callers = _callers;
+ if (callers == null) return;
+ final calls = callers[caller];
if (calls == null) return;
calls.remove(node);
if (calls.isEmpty) {
- _callers.remove(caller);
+ callers.remove(caller);
}
}
- Iterable<MemberEntity> get callersForTesting {
+ Iterable<MemberEntity>? get callersForTesting {
return _callers?.keys;
}
@@ -464,10 +465,11 @@
}
bool _computeIsCalledOnce() {
+ final callers = _callers;
if (_calledIndirectly) return false;
- if (_callers == null) return false;
+ if (callers == null) return false;
int count = 0;
- for (var set in _callers.values) {
+ for (var set in callers.values) {
count += set.length;
if (count > 1) return false;
}
@@ -488,9 +490,9 @@
@override
bool get isStable => super.isStable && !isClosurized;
- AbstractValue handleSpecialCases(InferrerEngine inferrer);
+ AbstractValue? handleSpecialCases(InferrerEngine inferrer);
- AbstractValue _handleFunctionCase(
+ AbstractValue? _handleFunctionCase(
FunctionEntity function, InferrerEngine inferrer) {
if (inferrer.closedWorld.nativeData.isNativeMember(function)) {
// Use the type annotation as the type for native elements. We
@@ -527,7 +529,7 @@
@override
AbstractValue computeType(InferrerEngine inferrer) {
- AbstractValue special = handleSpecialCases(inferrer);
+ final special = handleSpecialCases(inferrer);
if (special != null) return potentiallyNarrowType(special, inferrer);
return potentiallyNarrowType(
inferrer.types.computeTypeMask(inputs), inferrer);
@@ -554,36 +556,37 @@
@override
String getInferredSignature(TypeSystem types) {
- return types.getInferredSignatureOfMethod(_member);
+ return types.getInferredSignatureOfMethod(_member as FunctionEntity);
}
}
class FieldTypeInformation extends MemberTypeInformation {
- FieldEntity get _field => _member;
+ @override
+ final FieldEntity _member;
final DartType _type;
FieldTypeInformation(
- AbstractValueDomain abstractValueDomain, FieldEntity element, this._type)
- : super._internal(abstractValueDomain, element);
+ AbstractValueDomain abstractValueDomain, this._member, this._type)
+ : super._internal(abstractValueDomain, _member);
@override
- AbstractValue handleSpecialCases(InferrerEngine inferrer) {
- if (!inferrer.canFieldBeUsedForGlobalOptimizations(_field) ||
- inferrer.assumeDynamic(_field)) {
+ AbstractValue? handleSpecialCases(InferrerEngine inferrer) {
+ if (!inferrer.canFieldBeUsedForGlobalOptimizations(_member) ||
+ inferrer.assumeDynamic(_member)) {
// Do not infer types for fields that have a corresponding annotation or
// are assigned by synthesized calls
giveUp(inferrer);
return safeType(inferrer);
}
- if (inferrer.closedWorld.nativeData.isNativeMember(_field)) {
+ if (inferrer.closedWorld.nativeData.isNativeMember(_member)) {
// Use the type annotation as the type for native elements. We
// also give up on inferring to make sure this element never
// goes in the work queue.
giveUp(inferrer);
return inferrer
.typeOfNativeBehavior(inferrer.closedWorld.nativeData
- .getNativeFieldLoadBehavior(_field))
+ .getNativeFieldLoadBehavior(_member))
.type;
}
return null;
@@ -599,7 +602,7 @@
bool hasStableType(InferrerEngine inferrer) {
// The number of inputs of non-final fields is
// not stable. Therefore such a field cannot be stable.
- if (!_field.isAssignable) {
+ if (!_member.isAssignable) {
return false;
}
return super.hasStableType(inferrer);
@@ -607,16 +610,17 @@
}
class GetterTypeInformation extends MemberTypeInformation {
- FunctionEntity get _getter => _member;
+ @override
+ final FunctionEntity _member;
final FunctionType _type;
- GetterTypeInformation(AbstractValueDomain abstractValueDomain,
- FunctionEntity element, this._type)
- : super._internal(abstractValueDomain, element);
+ GetterTypeInformation(
+ AbstractValueDomain abstractValueDomain, this._member, this._type)
+ : super._internal(abstractValueDomain, _member);
@override
- AbstractValue handleSpecialCases(InferrerEngine inferrer) {
- return _handleFunctionCase(_getter, inferrer);
+ AbstractValue? handleSpecialCases(InferrerEngine inferrer) {
+ return _handleFunctionCase(_member, inferrer);
}
@override
@@ -627,15 +631,15 @@
}
class SetterTypeInformation extends MemberTypeInformation {
- FunctionEntity get _setter => _member;
+ @override
+ final FunctionEntity _member;
- SetterTypeInformation(
- AbstractValueDomain abstractValueDomain, FunctionEntity element)
- : super._internal(abstractValueDomain, element);
+ SetterTypeInformation(AbstractValueDomain abstractValueDomain, this._member)
+ : super._internal(abstractValueDomain, _member);
@override
- AbstractValue handleSpecialCases(InferrerEngine inferrer) {
- return _handleFunctionCase(_setter, inferrer);
+ AbstractValue? handleSpecialCases(InferrerEngine inferrer) {
+ return _handleFunctionCase(_member, inferrer);
}
@override
@@ -646,22 +650,23 @@
}
class MethodTypeInformation extends MemberTypeInformation {
- FunctionEntity get _method => _member;
+ @override
+ final FunctionEntity _member;
final FunctionType _type;
- MethodTypeInformation(AbstractValueDomain abstractValueDomain,
- FunctionEntity element, this._type)
- : super._internal(abstractValueDomain, element);
+ MethodTypeInformation(
+ AbstractValueDomain abstractValueDomain, this._member, this._type)
+ : super._internal(abstractValueDomain, _member);
@override
- AbstractValue handleSpecialCases(InferrerEngine inferrer) {
- return _handleFunctionCase(_method, inferrer);
+ AbstractValue? handleSpecialCases(InferrerEngine inferrer) {
+ return _handleFunctionCase(_member, inferrer);
}
@override
AbstractValue _potentiallyNarrowType(
AbstractValue mask, InferrerEngine inferrer) {
- if (inferrer.commonElements.isLateReadCheck(_method)) {
+ if (inferrer.commonElements.isLateReadCheck(_member)) {
mask = inferrer.abstractValueDomain.excludeLateSentinel(mask);
}
return _narrowType(inferrer.closedWorld, mask, _type.returnType);
@@ -672,31 +677,31 @@
}
class FactoryConstructorTypeInformation extends MemberTypeInformation {
- ConstructorEntity get _constructor => _member;
+ @override
+ final ConstructorEntity _member;
final FunctionType _type;
- FactoryConstructorTypeInformation(AbstractValueDomain abstractValueDomain,
- ConstructorEntity element, this._type)
- : super._internal(abstractValueDomain, element);
+ FactoryConstructorTypeInformation(
+ AbstractValueDomain abstractValueDomain, this._member, this._type)
+ : super._internal(abstractValueDomain, _member);
@override
- AbstractValue handleSpecialCases(InferrerEngine inferrer) {
+ AbstractValue? handleSpecialCases(InferrerEngine inferrer) {
AbstractValueDomain abstractValueDomain = inferrer.abstractValueDomain;
- if (_constructor.isFromEnvironmentConstructor) {
- if (_constructor.enclosingClass == inferrer.commonElements.intClass) {
+ if (_member.isFromEnvironmentConstructor) {
+ if (_member.enclosingClass == inferrer.commonElements.intClass) {
giveUp(inferrer);
return abstractValueDomain.includeNull(abstractValueDomain.intType);
- } else if (_constructor.enclosingClass ==
- inferrer.commonElements.boolClass) {
+ } else if (_member.enclosingClass == inferrer.commonElements.boolClass) {
giveUp(inferrer);
return abstractValueDomain.includeNull(abstractValueDomain.boolType);
- } else if (_constructor.enclosingClass ==
+ } else if (_member.enclosingClass ==
inferrer.commonElements.stringClass) {
giveUp(inferrer);
return abstractValueDomain.includeNull(abstractValueDomain.stringType);
}
}
- return _handleFunctionCase(_constructor, inferrer);
+ return _handleFunctionCase(_member, inferrer);
}
@override
@@ -712,15 +717,16 @@
}
class GenerativeConstructorTypeInformation extends MemberTypeInformation {
- ConstructorEntity get _constructor => _member;
+ @override
+ final FunctionEntity _member;
GenerativeConstructorTypeInformation(
- AbstractValueDomain abstractValueDomain, ConstructorEntity element)
- : super._internal(abstractValueDomain, element);
+ AbstractValueDomain abstractValueDomain, this._member)
+ : super._internal(abstractValueDomain, _member);
@override
- AbstractValue handleSpecialCases(InferrerEngine inferrer) {
- return _handleFunctionCase(_constructor, inferrer);
+ AbstractValue? handleSpecialCases(InferrerEngine inferrer) {
+ return _handleFunctionCase(_member, inferrer);
}
@override
@@ -796,13 +802,12 @@
_isTearOffClosureParameter = true;
// We have to add a flow-edge for the default value (if it exists), as we
// might not see all call-sites and thus miss the use of it.
- TypeInformation defaultType =
- inferrer.getDefaultTypeOfParameter(_parameter);
- if (defaultType != null) defaultType.addUser(this);
+ final defaultType = inferrer.getDefaultTypeOfParameter(_parameter);
+ defaultType.addUser(this);
}
// TODO(herhut): Cleanup into one conditional.
- AbstractValue handleSpecialCases(InferrerEngine inferrer) {
+ AbstractValue? handleSpecialCases(InferrerEngine inferrer) {
if (!inferrer.canFunctionParametersBeUsedForGlobalOptimizations(_method) ||
inferrer.assumeDynamic(_method)) {
// Do not infer types for parameters that have a corresponding annotation
@@ -890,7 +895,7 @@
@override
AbstractValue computeType(InferrerEngine inferrer) {
- AbstractValue special = handleSpecialCases(inferrer);
+ final special = handleSpecialCases(inferrer);
if (special != null) return special;
return potentiallyNarrowType(
inferrer.types.computeTypeMask(inputs), inferrer);
@@ -953,7 +958,7 @@
forIn,
}
-bool validCallType(CallType callType, ir.Node /*?*/ call, Selector selector) {
+bool validCallType(CallType callType, ir.Node? call, Selector selector) {
switch (callType) {
case CallType.access:
return call is ir.Node;
@@ -962,7 +967,6 @@
case CallType.forIn:
return call is ir.ForInStatement;
}
- throw StateError('Unexpected call type $callType.');
}
/// A [CallSiteTypeInformation] is a call found in the AST, or a
@@ -975,10 +979,10 @@
/// and [selector] and [receiver] fields for dynamic calls.
abstract class CallSiteTypeInformation extends TypeInformation
with ApplyableTypeInformation {
- final ir.Node /*?*/ _call;
+ final ir.Node? _call;
final MemberEntity caller;
- final Selector selector;
- final ArgumentsTypes arguments;
+ final Selector? selector;
+ final ArgumentsTypes? arguments;
final bool inLoop;
CallSiteTypeInformation(
@@ -990,7 +994,7 @@
this.arguments,
this.inLoop)
: super.noInputs(abstractValueDomain.emptyType, context) {
- assert(_call is ir.Node || (_call == null && selector.name == '=='));
+ assert(_call is ir.Node || (_call == null && selector?.name == '=='));
}
@override
@@ -1011,7 +1015,7 @@
StaticCallSiteTypeInformation(
AbstractValueDomain abstractValueDomain,
MemberTypeInformation context,
- ir.Node /*?*/ call,
+ ir.Node? call,
MemberEntity enclosing,
this.calledElement,
Selector selector,
@@ -1029,10 +1033,10 @@
@override
void addToGraph(InferrerEngine inferrer) {
MemberTypeInformation callee = _getCalledTypeInfo(inferrer);
- callee.addCall(caller, _call);
+ callee.addCall(caller, _call!);
callee.addUser(this);
if (arguments != null) {
- arguments.forEach((info) => info.addUser(this));
+ arguments!.forEach((info) => info.addUser(this));
}
inferrer.updateParameterInputs(this, calledElement, arguments, selector,
remove: false, addToQueue: false);
@@ -1072,7 +1076,7 @@
bool hasStableType(InferrerEngine inferrer) {
bool isStable = _getCalledTypeInfo(inferrer).isStable;
return isStable &&
- (arguments == null || arguments.every((info) => info.isStable)) &&
+ (arguments == null || arguments!.every((info) => info.isStable)) &&
super.hasStableType(inferrer);
}
@@ -1081,7 +1085,7 @@
ElementTypeInformation callee = _getCalledTypeInfo(inferrer);
callee.removeUser(this);
if (arguments != null) {
- arguments.forEach((info) => info.removeUser(this));
+ arguments!.forEach((info) => info.removeUser(this));
}
super.removeAndClearReferences(inferrer);
}
@@ -1107,7 +1111,7 @@
IndirectDynamicCallSiteTypeInformation(
AbstractValueDomain abstractValueDomain,
MemberTypeInformation context,
- ir.Node /*?*/ call,
+ ir.Node? call,
this.dynamicCall,
MemberEntity enclosing,
Selector selector,
@@ -1123,20 +1127,22 @@
void addToGraph(InferrerEngine inferrer) {
receiver.addUser(this);
dynamicCall.receiver.addInput(receiver);
- List<TypeInformation> positional = arguments.positional;
+ final args = arguments!;
+ List<TypeInformation> positional = args.positional;
+ final dynamicCallArgs = dynamicCall.arguments!;
for (int i = 0; i < positional.length; i++) {
positional[i].addUser(this);
- dynamicCall.arguments.positional[i].addInput(positional[i]);
+ dynamicCallArgs.positional[i].addInput(positional[i]);
}
- arguments.named.forEach((name, namedInfo) {
- dynamicCall.arguments.named[name].addInput(namedInfo);
+ args.named.forEach((name, namedInfo) {
+ dynamicCallArgs.named[name]!.addInput(namedInfo);
});
dynamicCall.addUser(this);
}
@override
AbstractValue computeType(InferrerEngine inferrer) {
- AbstractValue typeMask = _computeTypedSelector(inferrer);
+ final typeMask = _computeTypedSelector(inferrer);
inferrer.updateSelectorInMember(
caller, CallType.access, _call, selector, typeMask);
@@ -1151,7 +1157,7 @@
return result;
}
- AbstractValue _computeTypedSelector(InferrerEngine inferrer) {
+ AbstractValue? _computeTypedSelector(InferrerEngine inferrer) {
AbstractValue receiverType = receiver.type;
if (mask == receiverType) return mask;
return receiverType == inferrer.abstractValueDomain.dynamicType
@@ -1185,7 +1191,7 @@
dynamicCall.removeUser(this);
receiver.removeUser(this);
if (arguments != null) {
- arguments.forEach((info) => info.removeUser(this));
+ arguments!.forEach((info) => info.removeUser(this));
}
super.removeAndClearReferences(inferrer);
}
@@ -1197,16 +1203,16 @@
final TypeInformation receiver;
final AbstractValue mask;
final bool isConditional;
- bool _hasClosureCallTargets;
+ bool? _hasClosureCallTargets;
/// Cached concrete targets of this call.
- Iterable<MemberEntity> _concreteTargets;
+ Iterable<MemberEntity>? _concreteTargets;
DynamicCallSiteTypeInformation(
AbstractValueDomain abstractValueDomain,
MemberTypeInformation context,
this._callType,
- T call,
+ T? call,
MemberEntity enclosing,
Selector selector,
this.mask,
@@ -1223,28 +1229,29 @@
if (_callType == CallType.indirectAccess) {
callee._calledIndirectly = true;
} else {
- callee.addCall(caller, _call);
+ callee.addCall(caller, _call!);
}
}
void _removeCall(MemberTypeInformation callee) {
if (_callType != CallType.indirectAccess) {
- callee.removeCall(caller, _call);
+ callee.removeCall(caller, _call!);
}
}
@override
void addToGraph(InferrerEngine inferrer) {
- assert(receiver != null);
- AbstractValue typeMask = computeTypedSelector(inferrer);
+ assert((receiver as dynamic) != null); // TODO(48820): Remove when sound.
+ final typeMask = computeTypedSelector(inferrer);
_hasClosureCallTargets =
- inferrer.closedWorld.includesClosureCall(selector, typeMask);
- _concreteTargets = inferrer.closedWorld.locateMembers(selector, typeMask);
+ inferrer.closedWorld.includesClosureCall(selector!, typeMask);
+ final concreteTargets = _concreteTargets =
+ inferrer.closedWorld.locateMembers(selector!, typeMask);
receiver.addUser(this);
if (arguments != null) {
- arguments.forEach((info) => info.addUser(this));
+ arguments!.forEach((info) => info.addUser(this));
}
- for (MemberEntity element in _concreteTargets) {
+ for (MemberEntity element in concreteTargets) {
MemberTypeInformation callee =
inferrer.types.getInferredTypeOfMember(element);
_addCall(callee);
@@ -1255,17 +1262,17 @@
}
/// `true` if this invocation can hit a 'call' method on a closure.
- bool get hasClosureCallTargets => _hasClosureCallTargets;
+ bool get hasClosureCallTargets => _hasClosureCallTargets!;
/// All concrete targets of this invocation. If [hasClosureCallTargets] is
/// `true` the invocation can additional target an unknown set of 'call'
/// methods on closures.
- Iterable<MemberEntity> get concreteTargets => _concreteTargets;
+ Iterable<MemberEntity> get concreteTargets => _concreteTargets!;
@override
- Iterable<MemberEntity> get callees => _concreteTargets;
+ Iterable<MemberEntity> get callees => _concreteTargets!;
- AbstractValue computeTypedSelector(InferrerEngine inferrer) {
+ AbstractValue? computeTypedSelector(InferrerEngine inferrer) {
AbstractValue receiverType = receiver.type;
if (mask != receiverType) {
return receiverType == inferrer.abstractValueDomain.dynamicType
@@ -1277,11 +1284,11 @@
}
bool targetsIncludeComplexNoSuchMethod(InferrerEngine inferrer) {
- return _concreteTargets.any((MemberEntity e) {
+ return _concreteTargets!.any((MemberEntity e) {
return e.isFunction &&
e.isInstanceMember &&
e.name == Identifiers.noSuchMethod_ &&
- inferrer.noSuchMethodData.isComplex(e);
+ inferrer.noSuchMethodData.isComplex(e as FunctionEntity);
});
}
@@ -1292,31 +1299,31 @@
///
/// Returns the more precise TypeInformation, or `null` to defer to the
/// library code.
- TypeInformation handleIntrisifiedSelector(
- Selector selector, AbstractValue mask, InferrerEngine inferrer) {
+ TypeInformation? handleIntrisifiedSelector(
+ Selector selector, AbstractValue? mask, InferrerEngine inferrer) {
AbstractValueDomain abstractValueDomain = inferrer.abstractValueDomain;
if (mask == null) return null;
if (abstractValueDomain.isIntegerOrNull(mask).isPotentiallyFalse) {
return null;
}
if (!selector.isCall && !selector.isOperator) return null;
- if (!arguments.named.isEmpty) return null;
- if (arguments.positional.length > 1) return null;
+ final args = arguments!;
+ if (!args.named.isEmpty) return null;
+ if (args.positional.length > 1) return null;
- bool isInt(info) =>
+ bool isInt(TypeInformation info) =>
abstractValueDomain.isIntegerOrNull(info.type).isDefinitelyTrue;
- bool isEmpty(info) =>
+ bool isEmpty(TypeInformation info) =>
abstractValueDomain.isEmpty(info.type).isDefinitelyTrue;
- bool isUInt31(info) => abstractValueDomain
+ bool isUInt31(TypeInformation info) => abstractValueDomain
.isUInt31(abstractValueDomain.excludeNull(info.type))
.isDefinitelyTrue;
- bool isPositiveInt(info) =>
+ bool isPositiveInt(TypeInformation info) =>
abstractValueDomain.isPositiveIntegerOrNull(info.type).isDefinitelyTrue;
TypeInformation tryLater() => inferrer.types.nonNullEmptyType;
- TypeInformation argument =
- arguments.isEmpty ? null : arguments.positional.first;
+ final argument = args.isEmpty ? null : args.positional.first;
String name = selector.name;
// These are type inference rules only for useful cases that are not
@@ -1331,7 +1338,7 @@
case '%':
case 'remainder':
case '~/':
- if (isEmpty(argument)) return tryLater();
+ if (isEmpty(argument!)) return tryLater();
if (isPositiveInt(receiver) && isPositiveInt(argument)) {
// uint31 + uint31 -> uint32
if (name == '+' && isUInt31(receiver) && isUInt31(argument)) {
@@ -1346,35 +1353,35 @@
case '|':
case '^':
- if (isEmpty(argument)) return tryLater();
+ if (isEmpty(argument!)) return tryLater();
if (isUInt31(receiver) && isUInt31(argument)) {
return inferrer.types.uint31Type;
}
return null;
case '>>':
- if (isEmpty(argument)) return tryLater();
+ if (isEmpty(argument!)) return tryLater();
if (isUInt31(receiver)) {
return inferrer.types.uint31Type;
}
return null;
case '>>>':
- if (isEmpty(argument)) return tryLater();
+ if (isEmpty(argument!)) return tryLater();
if (isUInt31(receiver)) {
return inferrer.types.uint31Type;
}
return null;
case '&':
- if (isEmpty(argument)) return tryLater();
+ if (isEmpty(argument!)) return tryLater();
if (isUInt31(receiver) || isUInt31(argument)) {
return inferrer.types.uint31Type;
}
return null;
case '-':
- if (isEmpty(argument)) return tryLater();
+ if (isEmpty(argument!)) return tryLater();
if (isInt(argument)) {
return inferrer.types.intType;
}
@@ -1385,9 +1392,7 @@
return inferrer.types.intType;
case 'abs':
- return arguments.hasNoArguments()
- ? inferrer.types.positiveIntType
- : null;
+ return args.hasNoArguments() ? inferrer.types.positiveIntType : null;
default:
return null;
@@ -1398,19 +1403,21 @@
AbstractValue computeType(InferrerEngine inferrer) {
JClosedWorld closedWorld = inferrer.closedWorld;
AbstractValueDomain abstractValueDomain = closedWorld.abstractValueDomain;
- Iterable<MemberEntity> oldTargets = _concreteTargets;
- AbstractValue typeMask = computeTypedSelector(inferrer);
+ final oldTargets = _concreteTargets!;
+ final typeMask = computeTypedSelector(inferrer);
+ final localSelector = selector!;
inferrer.updateSelectorInMember(
- caller, _callType, _call, selector, typeMask);
+ caller, _callType, _call, localSelector, typeMask);
_hasClosureCallTargets =
- closedWorld.includesClosureCall(selector, typeMask);
- _concreteTargets = closedWorld.locateMembers(selector, typeMask);
+ closedWorld.includesClosureCall(localSelector, typeMask);
+ final concreteTargets =
+ _concreteTargets = closedWorld.locateMembers(localSelector, typeMask);
// Update the call graph if the targets could have changed.
- if (!identical(_concreteTargets, oldTargets)) {
+ if (!identical(concreteTargets, oldTargets)) {
// Add calls to new targets to the graph.
- _concreteTargets
+ concreteTargets
.where((target) => !oldTargets.contains(target))
.forEach((MemberEntity element) {
MemberTypeInformation callee =
@@ -1423,7 +1430,7 @@
// Walk over the old targets, and remove calls that cannot happen anymore.
oldTargets
- .where((target) => !_concreteTargets.contains(target))
+ .where((target) => !concreteTargets.contains(target))
.forEach((MemberEntity element) {
MemberTypeInformation callee =
inferrer.types.getInferredTypeOfMember(element);
@@ -1437,18 +1444,18 @@
// Walk over the found targets, and compute the joined union type mask
// for all these targets.
AbstractValue result;
- if (_hasClosureCallTargets) {
+ if (_hasClosureCallTargets!) {
result = abstractValueDomain.dynamicType;
} else {
result = inferrer.types
- .joinTypeMasks(_concreteTargets.map((MemberEntity element) {
+ .joinTypeMasks(concreteTargets.map((MemberEntity element) {
if (typeMask != null &&
- inferrer.returnsListElementType(selector, typeMask)) {
+ inferrer.returnsListElementType(localSelector, typeMask)) {
return abstractValueDomain.getContainerElementType(receiver.type);
} else if (typeMask != null &&
- inferrer.returnsMapValueType(selector, typeMask)) {
+ inferrer.returnsMapValueType(localSelector, typeMask)) {
if (abstractValueDomain.isDictionary(typeMask)) {
- AbstractValue arg = arguments.positional[0].type;
+ AbstractValue arg = arguments!.positional[0].type;
ConstantValue value = abstractValueDomain.getPrimitiveValue(arg);
if (value is StringConstantValue) {
String key = value.stringValue;
@@ -1476,8 +1483,8 @@
}
return abstractValueDomain.getMapValueType(typeMask);
} else {
- TypeInformation info =
- handleIntrisifiedSelector(selector, typeMask, inferrer);
+ final info =
+ handleIntrisifiedSelector(localSelector, typeMask, inferrer);
if (info != null) return info.type;
return inferrer.typeOfMemberWithSelector(element, selector).type;
}
@@ -1495,16 +1502,19 @@
@override
void giveUp(InferrerEngine inferrer, {bool clearInputs = true}) {
if (!abandonInferencing) {
- inferrer.updateSelectorInMember(caller, _callType, _call, selector, mask);
- Iterable<MemberEntity> oldTargets = _concreteTargets;
+ final call = _call!;
+ inferrer.updateSelectorInMember(caller, _callType, call, selector, mask);
+ final oldTargets = concreteTargets;
+ final localSelector = selector!;
_hasClosureCallTargets =
- inferrer.closedWorld.includesClosureCall(selector, mask);
- _concreteTargets = inferrer.closedWorld.locateMembers(selector, mask);
- for (MemberEntity element in _concreteTargets) {
+ inferrer.closedWorld.includesClosureCall(localSelector, mask);
+ final newConcreteTargets = _concreteTargets =
+ inferrer.closedWorld.locateMembers(localSelector, mask);
+ for (MemberEntity element in newConcreteTargets) {
if (!oldTargets.contains(element)) {
MemberTypeInformation callee =
inferrer.types.getInferredTypeOfMember(element);
- callee.addCall(caller, _call);
+ callee.addCall(caller, call);
inferrer.updateParameterInputs(this, element, arguments, selector,
remove: false, addToQueue: true);
}
@@ -1515,13 +1525,13 @@
@override
void removeAndClearReferences(InferrerEngine inferrer) {
- for (MemberEntity element in _concreteTargets) {
+ for (MemberEntity element in concreteTargets) {
MemberTypeInformation callee =
inferrer.types.getInferredTypeOfMember(element);
callee.removeUser(this);
}
if (arguments != null) {
- arguments.forEach((info) => info.removeUser(this));
+ arguments!.forEach((info) => info.removeUser(this));
}
super.removeAndClearReferences(inferrer);
}
@@ -1537,9 +1547,9 @@
@override
bool hasStableType(InferrerEngine inferrer) {
return receiver.isStable &&
- _concreteTargets.every((MemberEntity element) =>
+ concreteTargets.every((MemberEntity element) =>
inferrer.types.getInferredTypeOfMember(element).isStable) &&
- (arguments == null || arguments.every((info) => info.isStable)) &&
+ (arguments == null || arguments!.every((info) => info.isStable)) &&
super.hasStableType(inferrer);
}
}
@@ -1550,7 +1560,7 @@
ClosureCallSiteTypeInformation(
AbstractValueDomain abstractValueDomain,
MemberTypeInformation context,
- ir.Node /*?*/ call,
+ ir.Node? call,
MemberEntity enclosing,
Selector selector,
this.closure,
@@ -1561,7 +1571,7 @@
@override
void addToGraph(InferrerEngine inferrer) {
- arguments.forEach((info) => info.addUser(this));
+ arguments!.forEach((info) => info.addUser(this));
closure.addUser(this);
}
@@ -1763,7 +1773,7 @@
bool inferred = false;
InferredTypeInformation(AbstractValueDomain abstractValueDomain,
- MemberTypeInformation context, TypeInformation parentType)
+ MemberTypeInformation? context, TypeInformation? parentType)
: super(abstractValueDomain.emptyType, context) {
if (parentType != null) addInput(parentType);
}
@@ -1789,14 +1799,14 @@
final AbstractValue originalType;
/// The length at the allocation site.
- final int originalLength;
+ final int? originalLength;
/// The length after the container has been traced.
- int inferredLength;
+ late int inferredLength;
ListTypeInformation(
AbstractValueDomain abstractValueDomain,
- MemberTypeInformation context,
+ MemberTypeInformation? context,
this.originalType,
this.elementType,
this.originalLength)
@@ -1850,7 +1860,7 @@
/// elements in a [ListTypeInformation].
class ElementInContainerTypeInformation extends InferredTypeInformation {
ElementInContainerTypeInformation(AbstractValueDomain abstractValueDomain,
- MemberTypeInformation context, elementType)
+ MemberTypeInformation? context, elementType)
: super(abstractValueDomain, context, elementType);
@override
@@ -1869,7 +1879,7 @@
final AbstractValue originalType;
SetTypeInformation(
- MemberTypeInformation context, this.originalType, this.elementType)
+ MemberTypeInformation? context, this.originalType, this.elementType)
: super(originalType, context) {
elementType.addUser(this);
}
@@ -1917,7 +1927,7 @@
/// [SetTypeInformation].
class ElementInSetTypeInformation extends InferredTypeInformation {
ElementInSetTypeInformation(AbstractValueDomain abstractValueDomain,
- MemberTypeInformation context, elementType)
+ MemberTypeInformation? context, elementType)
: super(abstractValueDomain, context, elementType);
@override
@@ -1945,32 +1955,32 @@
bool get inDictionaryMode => !bailedOut && _allKeysAreStrings;
- MapTypeInformation(MemberTypeInformation context, this.originalType,
+ MapTypeInformation(MemberTypeInformation? context, this.originalType,
this.keyType, this.valueType)
: super(originalType, context) {
keyType.addUser(this);
valueType.addUser(this);
}
- TypeInformation addEntryInput(AbstractValueDomain abstractValueDomain,
+ TypeInformation? addEntryInput(AbstractValueDomain abstractValueDomain,
TypeInformation key, TypeInformation value,
[bool nonNull = false]) {
- TypeInformation newInfo = null;
+ ValueInMapTypeInformation? newInfo = null;
if (_allKeysAreStrings && key is StringLiteralTypeInformation) {
String keyString = key.asString();
typeInfoMap.putIfAbsent(keyString, () {
newInfo = ValueInMapTypeInformation(
abstractValueDomain, context, null, nonNull);
- return newInfo;
+ return newInfo!;
});
- typeInfoMap[keyString].addInput(value);
+ typeInfoMap[keyString]!.addInput(value);
} else {
_allKeysAreStrings = false;
typeInfoMap.clear();
}
keyType.addInput(key);
valueType.addInput(value);
- if (newInfo != null) newInfo.addUser(this);
+ newInfo?.addUser(this);
return newInfo;
}
@@ -1981,12 +1991,12 @@
if (_allKeysAreStrings && other.inDictionaryMode) {
other.typeInfoMap.forEach((keyString, value) {
typeInfoMap.putIfAbsent(keyString, () {
- TypeInformation newInfo = ValueInMapTypeInformation(
+ final newInfo = ValueInMapTypeInformation(
abstractValueDomain, context, null, false);
newInfos.add(newInfo);
return newInfo;
});
- typeInfoMap[keyString].addInput(value);
+ typeInfoMap[keyString]!.addInput(value);
});
} else {
_allKeysAreStrings = false;
@@ -2018,7 +2028,7 @@
if (inDictionaryMode) {
Map<String, AbstractValue> mappings = Map<String, AbstractValue>();
for (var key in typeInfoMap.keys) {
- mappings[key] = typeInfoMap[key].type;
+ mappings[key] = typeInfoMap[key]!.type;
}
return inferrer.abstractValueDomain.createDictionaryValue(
abstractValueDomain.getGeneralization(originalType),
@@ -2045,14 +2055,14 @@
} else if (abstractValueDomain.isDictionary(type)) {
assert(inDictionaryMode);
for (String key in typeInfoMap.keys) {
- TypeInformation value = typeInfoMap[key];
+ final value = typeInfoMap[key]!;
if (!abstractValueDomain.containsDictionaryKey(type, key) &&
abstractValueDomain.containsAll(value.type).isDefinitelyFalse &&
abstractValueDomain.isNull(value.type).isDefinitelyFalse) {
return toTypeMask(inferrer);
}
if (abstractValueDomain.getDictionaryValueForKey(type, key) !=
- typeInfoMap[key].type) {
+ typeInfoMap[key]!.type) {
return toTypeMask(inferrer);
}
}
@@ -2099,7 +2109,7 @@
/// for the keys in a [MapTypeInformation]
class KeyInMapTypeInformation extends InferredTypeInformation {
KeyInMapTypeInformation(AbstractValueDomain abstractValueDomain,
- MemberTypeInformation context, TypeInformation keyType)
+ MemberTypeInformation? context, TypeInformation keyType)
: super(abstractValueDomain, context, keyType);
@override
@@ -2120,7 +2130,7 @@
final bool nonNull;
ValueInMapTypeInformation(AbstractValueDomain abstractValueDomain,
- MemberTypeInformation context, TypeInformation valueType,
+ MemberTypeInformation? context, TypeInformation? valueType,
[this.nonNull = false])
: super(abstractValueDomain, context, valueType);
@@ -2143,13 +2153,13 @@
/// A [PhiElementTypeInformation] is an union of
/// [ElementTypeInformation], that is local to a method.
class PhiElementTypeInformation extends TypeInformation {
- final ir.Node branchNode;
- final Local variable;
+ final ir.Node? branchNode;
+ final Local? variable;
final bool isTry;
PhiElementTypeInformation(AbstractValueDomain abstractValueDomain,
- MemberTypeInformation context, this.branchNode, this.variable,
- {this.isTry})
+ MemberTypeInformation? context, this.branchNode, this.variable,
+ {required this.isTry})
: super(abstractValueDomain.emptyType, context);
@override
@@ -2186,7 +2196,7 @@
final FunctionEntity _element;
ClosureTypeInformation(AbstractValueDomain abstractValueDomain,
- MemberTypeInformation context, this._element)
+ MemberTypeInformation? context, this._element)
: super(abstractValueDomain.emptyType, context);
FunctionEntity get closure => _element;
@@ -2227,7 +2237,7 @@
/// Set to true once analysis is completed.
bool analyzed = false;
- Set<TypeInformation> _flowsInto;
+ Set<TypeInformation>? _flowsInto;
/// The set of [TypeInformation] nodes where values from the traced node could
/// flow in.
@@ -2241,7 +2251,7 @@
if (_flowsInto == null) {
_flowsInto = nodes.toSet();
} else {
- _flowsInto.addAll(nodes);
+ _flowsInto!.addAll(nodes);
}
}
}
@@ -2326,7 +2336,7 @@
if (isNullable) {
otherType = abstractValueDomain.includeNull(otherType);
}
- if (type == null) return otherType;
+ assert((type as dynamic) != null); // TODO(48820): Remove when sound.
AbstractValue newType = abstractValueDomain.intersection(type, otherType);
return abstractValueDomain.isLateSentinel(type).isPotentiallyTrue
? abstractValueDomain.includeLateSentinel(newType)
diff --git a/pkg/compiler/lib/src/inferrer/type_system.dart b/pkg/compiler/lib/src/inferrer/type_system.dart
index 9a90a88..34abce3 100644
--- a/pkg/compiler/lib/src/inferrer/type_system.dart
+++ b/pkg/compiler/lib/src/inferrer/type_system.dart
@@ -2,14 +2,12 @@
// 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.
-// @dart = 2.10
-
import 'package:kernel/ast.dart' as ir;
import '../common.dart';
import '../constants/values.dart' show BoolConstantValue;
import '../elements/entities.dart';
import '../elements/types.dart';
-import '../world.dart';
+import '../world_interfaces.dart';
import 'abstract_value_domain.dart';
import 'type_graph_nodes.dart';
@@ -30,7 +28,7 @@
void forEachParameter(FunctionEntity function, void f(Local parameter));
/// Returns whether [node] is valid as a general phi node.
- bool checkPhiNode(ir.Node node);
+ bool checkPhiNode(ir.Node? node);
/// Returns whether [node] is valid as a loop phi node.
bool checkLoopPhiNode(ir.Node node);
@@ -81,8 +79,7 @@
final Set<TypeInformation> allocatedClosures = Set<TypeInformation>();
/// Cache of [ConcreteTypeInformation].
- final Map<AbstractValue, TypeInformation> concreteTypes =
- Map<AbstractValue, TypeInformation>();
+ final Map<AbstractValue, ConcreteTypeInformation> concreteTypes = {};
/// Cache of some primitive constant types.
final Map<Object, TypeInformation> primitiveConstantTypes = {};
@@ -113,17 +110,15 @@
allocatedTypes,
].expand((x) => x);
- TypeSystem(this._closedWorld, this.strategy) {
- nonNullEmptyType = getConcreteTypeFor(_abstractValueDomain.emptyType);
- }
+ TypeSystem(this._closedWorld, this.strategy);
AbstractValueDomain get _abstractValueDomain =>
_closedWorld.abstractValueDomain;
/// Used to group [TypeInformation] nodes by the element that triggered their
/// creation.
- MemberTypeInformation _currentMember = null;
- MemberTypeInformation get currentMember => _currentMember;
+ MemberTypeInformation? _currentMember = null;
+ MemberTypeInformation? get currentMember => _currentMember;
void withMember(MemberEntity element, void action()) {
assert(_currentMember == null,
@@ -133,157 +128,81 @@
_currentMember = null;
}
- TypeInformation nullTypeCache;
- TypeInformation get nullType {
- if (nullTypeCache != null) return nullTypeCache;
- return nullTypeCache = getConcreteTypeFor(_abstractValueDomain.nullType);
- }
+ late final TypeInformation nullType =
+ getConcreteTypeFor(_abstractValueDomain.nullType);
- TypeInformation intTypeCache;
- TypeInformation get intType {
- if (intTypeCache != null) return intTypeCache;
- return intTypeCache = getConcreteTypeFor(_abstractValueDomain.intType);
- }
+ late final TypeInformation intType =
+ getConcreteTypeFor(_abstractValueDomain.intType);
- TypeInformation uint32TypeCache;
- TypeInformation get uint32Type {
- if (uint32TypeCache != null) return uint32TypeCache;
- return uint32TypeCache =
- getConcreteTypeFor(_abstractValueDomain.uint32Type);
- }
+ late final TypeInformation uint32Type =
+ getConcreteTypeFor(_abstractValueDomain.uint32Type);
- TypeInformation uint31TypeCache;
- TypeInformation get uint31Type {
- if (uint31TypeCache != null) return uint31TypeCache;
- return uint31TypeCache =
- getConcreteTypeFor(_abstractValueDomain.uint31Type);
- }
+ late final TypeInformation uint31Type =
+ getConcreteTypeFor(_abstractValueDomain.uint31Type);
- TypeInformation positiveIntTypeCache;
- TypeInformation get positiveIntType {
- if (positiveIntTypeCache != null) return positiveIntTypeCache;
- return positiveIntTypeCache =
- getConcreteTypeFor(_abstractValueDomain.positiveIntType);
- }
+ late final TypeInformation positiveIntType =
+ getConcreteTypeFor(_abstractValueDomain.positiveIntType);
- TypeInformation numTypeCache;
- TypeInformation get numType {
- if (numTypeCache != null) return numTypeCache;
- return numTypeCache = getConcreteTypeFor(_abstractValueDomain.numType);
- }
+ late final TypeInformation numType =
+ getConcreteTypeFor(_abstractValueDomain.numType);
- TypeInformation boolTypeCache;
- TypeInformation get boolType {
- if (boolTypeCache != null) return boolTypeCache;
- return boolTypeCache = getConcreteTypeFor(_abstractValueDomain.boolType);
- }
+ late final TypeInformation boolType =
+ getConcreteTypeFor(_abstractValueDomain.boolType);
- TypeInformation functionTypeCache;
- TypeInformation get functionType {
- if (functionTypeCache != null) return functionTypeCache;
- return functionTypeCache =
- getConcreteTypeFor(_abstractValueDomain.functionType);
- }
+ late final TypeInformation functionType =
+ getConcreteTypeFor(_abstractValueDomain.functionType);
- TypeInformation listTypeCache;
- TypeInformation get listType {
- if (listTypeCache != null) return listTypeCache;
- return listTypeCache = getConcreteTypeFor(_abstractValueDomain.listType);
- }
+ late final TypeInformation listType =
+ getConcreteTypeFor(_abstractValueDomain.listType);
- TypeInformation constListTypeCache;
- TypeInformation get constListType {
- if (constListTypeCache != null) return constListTypeCache;
- return constListTypeCache =
- getConcreteTypeFor(_abstractValueDomain.constListType);
- }
+ late final TypeInformation constListType =
+ getConcreteTypeFor(_abstractValueDomain.constListType);
- TypeInformation fixedListTypeCache;
- TypeInformation get fixedListType {
- if (fixedListTypeCache != null) return fixedListTypeCache;
- return fixedListTypeCache =
- getConcreteTypeFor(_abstractValueDomain.fixedListType);
- }
+ late final TypeInformation fixedListType =
+ getConcreteTypeFor(_abstractValueDomain.fixedListType);
- TypeInformation growableListTypeCache;
- TypeInformation get growableListType {
- if (growableListTypeCache != null) return growableListTypeCache;
- return growableListTypeCache =
- getConcreteTypeFor(_abstractValueDomain.growableListType);
- }
+ late final TypeInformation growableListType =
+ getConcreteTypeFor(_abstractValueDomain.growableListType);
- TypeInformation _mutableArrayType;
- TypeInformation get mutableArrayType => _mutableArrayType ??=
+ late final TypeInformation mutableArrayType =
getConcreteTypeFor(_abstractValueDomain.mutableArrayType);
- TypeInformation setTypeCache;
- TypeInformation get setType =>
- setTypeCache ??= getConcreteTypeFor(_abstractValueDomain.setType);
+ late final TypeInformation setType =
+ getConcreteTypeFor(_abstractValueDomain.setType);
- TypeInformation constSetTypeCache;
- TypeInformation get constSetType => constSetTypeCache ??=
+ late final TypeInformation constSetType =
getConcreteTypeFor(_abstractValueDomain.constSetType);
- TypeInformation mapTypeCache;
- TypeInformation get mapType {
- if (mapTypeCache != null) return mapTypeCache;
- return mapTypeCache = getConcreteTypeFor(_abstractValueDomain.mapType);
- }
+ late final TypeInformation mapType =
+ getConcreteTypeFor(_abstractValueDomain.mapType);
- TypeInformation constMapTypeCache;
- TypeInformation get constMapType {
- if (constMapTypeCache != null) return constMapTypeCache;
- return constMapTypeCache =
- getConcreteTypeFor(_abstractValueDomain.constMapType);
- }
+ late final TypeInformation constMapType =
+ getConcreteTypeFor(_abstractValueDomain.constMapType);
- TypeInformation stringTypeCache;
- TypeInformation get stringType {
- if (stringTypeCache != null) return stringTypeCache;
- return stringTypeCache =
- getConcreteTypeFor(_abstractValueDomain.stringType);
- }
+ late final TypeInformation stringType =
+ getConcreteTypeFor(_abstractValueDomain.stringType);
- TypeInformation typeTypeCache;
- TypeInformation get typeType {
- if (typeTypeCache != null) return typeTypeCache;
- return typeTypeCache = getConcreteTypeFor(_abstractValueDomain.typeType);
- }
+ late final TypeInformation typeType =
+ getConcreteTypeFor(_abstractValueDomain.typeType);
- TypeInformation dynamicTypeCache;
- TypeInformation get dynamicType {
- if (dynamicTypeCache != null) return dynamicTypeCache;
- return dynamicTypeCache =
- getConcreteTypeFor(_abstractValueDomain.dynamicType);
- }
+ late final TypeInformation dynamicType =
+ getConcreteTypeFor(_abstractValueDomain.dynamicType);
- TypeInformation asyncFutureTypeCache;
// Subtype of Future returned by async methods.
- TypeInformation get asyncFutureType {
- if (asyncFutureTypeCache != null) return asyncFutureTypeCache;
- return asyncFutureTypeCache =
- getConcreteTypeFor(_abstractValueDomain.asyncFutureType);
- }
+ late final TypeInformation asyncFutureType =
+ getConcreteTypeFor(_abstractValueDomain.asyncFutureType);
- TypeInformation syncStarIterableTypeCache;
- TypeInformation get syncStarIterableType {
- if (syncStarIterableTypeCache != null) return syncStarIterableTypeCache;
- return syncStarIterableTypeCache =
- getConcreteTypeFor(_abstractValueDomain.syncStarIterableType);
- }
+ late final TypeInformation syncStarIterableType =
+ getConcreteTypeFor(_abstractValueDomain.syncStarIterableType);
- TypeInformation asyncStarStreamTypeCache;
- TypeInformation get asyncStarStreamType {
- if (asyncStarStreamTypeCache != null) return asyncStarStreamTypeCache;
- return asyncStarStreamTypeCache =
- getConcreteTypeFor(_abstractValueDomain.asyncStarStreamType);
- }
+ late final TypeInformation asyncStarStreamType =
+ getConcreteTypeFor(_abstractValueDomain.asyncStarStreamType);
- TypeInformation _lateSentinelType;
- TypeInformation get lateSentinelType => _lateSentinelType ??=
+ late final TypeInformation lateSentinelType =
getConcreteTypeFor(_abstractValueDomain.lateSentinelType);
- TypeInformation nonNullEmptyType;
+ late final TypeInformation nonNullEmptyType =
+ getConcreteTypeFor(_abstractValueDomain.emptyType);
TypeInformation stringLiteralType(String value) {
return StringLiteralTypeInformation(
@@ -312,7 +231,7 @@
/// Returns the least upper bound between [firstType] and
/// [secondType].
TypeInformation computeLUB(
- TypeInformation firstType, TypeInformation secondType) {
+ TypeInformation? firstType, TypeInformation secondType) {
if (firstType == null) return secondType;
if (firstType == secondType) return firstType;
if (firstType == nonNullEmptyType) return secondType;
@@ -431,7 +350,7 @@
/// Returns the internal inferrer representation for [mask].
ConcreteTypeInformation getConcreteTypeFor(AbstractValue mask) {
- assert(mask != null);
+ assert((mask as dynamic) != null); // TODO(48820): Remove when sound.
return concreteTypes.putIfAbsent(mask, () {
return ConcreteTypeInformation(mask);
});
@@ -471,24 +390,24 @@
return type == nullType;
}
- TypeInformation allocateList(
- TypeInformation type, ir.TreeNode node, MemberEntity enclosing,
- [TypeInformation elementType, int length]) {
+ TypeInformation allocateList(TypeInformation type, ir.TreeNode node,
+ MemberEntity enclosing, TypeInformation elementType,
+ [int? length]) {
assert(strategy.checkListNode(node));
- ClassEntity typedDataClass = _closedWorld.commonElements.typedDataClass;
- bool isTypedArray = typedDataClass != null &&
+ final typedDataClass = _closedWorld.commonElements.typedDataClass;
+ bool isTypedArray =
_closedWorld.classHierarchy.isInstantiated(typedDataClass) &&
- _abstractValueDomain
- .isInstanceOfOrNull(type.type, typedDataClass)
- .isDefinitelyTrue;
+ _abstractValueDomain
+ .isInstanceOfOrNull(type.type, typedDataClass)
+ .isDefinitelyTrue;
bool isConst = (type.type == _abstractValueDomain.constListType);
bool isFixed = (type.type == _abstractValueDomain.fixedListType) ||
isConst ||
isTypedArray;
bool isElementInferred = isConst || isTypedArray;
- int inferredLength = isFixed ? length : null;
- AbstractValue elementTypeMask =
+ final inferredLength = isFixed ? length : null;
+ final elementTypeMask =
isElementInferred ? elementType.type : dynamicType.type;
AbstractValue mask = _abstractValueDomain.createContainerValue(
type.type, node, enclosing, elementTypeMask, inferredLength);
@@ -512,9 +431,8 @@
return result;
}
- TypeInformation allocateSet(
- TypeInformation type, ir.TreeNode node, MemberEntity enclosing,
- [TypeInformation elementType]) {
+ TypeInformation allocateSet(TypeInformation type, ir.TreeNode node,
+ MemberEntity enclosing, TypeInformation elementType) {
assert(strategy.checkSetNode(node));
bool isConst = type.type == _abstractValueDomain.constSetType;
@@ -532,44 +450,47 @@
}
TypeInformation allocateMap(
- ConcreteTypeInformation type, ir.TreeNode node, MemberEntity element,
- [List<TypeInformation> keyTypes, List<TypeInformation> valueTypes]) {
+ ConcreteTypeInformation type,
+ ir.TreeNode node,
+ MemberEntity element,
+ List<TypeInformation> keyTypes,
+ List<TypeInformation> valueTypes) {
assert(strategy.checkMapNode(node));
assert(keyTypes.length == valueTypes.length);
bool isFixed = (type.type == _abstractValueDomain.constMapType);
- TypeInformation keyType, valueType;
+ PhiElementTypeInformation? keyType, valueType;
for (int i = 0; i < keyTypes.length; ++i) {
- TypeInformation type = keyTypes[i];
+ final typeForKey = keyTypes[i];
keyType = keyType == null
- ? allocatePhi(null, null, type, isTry: false)
- : addPhiInput(null, keyType, type);
+ ? allocatePhi(null, null, typeForKey, isTry: false)
+ : addPhiInput(null, keyType, typeForKey);
- type = valueTypes[i];
+ final typeForValue = valueTypes[i];
valueType = valueType == null
- ? allocatePhi(null, null, type, isTry: false)
- : addPhiInput(null, valueType, type);
+ ? allocatePhi(null, null, typeForValue, isTry: false)
+ : addPhiInput(null, valueType, typeForValue);
}
- keyType =
+ final simplifiedKeyType =
keyType == null ? nonNullEmpty() : simplifyPhi(null, null, keyType);
- valueType =
+ final simplifiedValueType =
valueType == null ? nonNullEmpty() : simplifyPhi(null, null, valueType);
AbstractValue keyTypeMask, valueTypeMask;
if (isFixed) {
- keyTypeMask = keyType.type;
- valueTypeMask = valueType.type;
+ keyTypeMask = simplifiedKeyType.type;
+ valueTypeMask = simplifiedValueType.type;
} else {
keyTypeMask = valueTypeMask = dynamicType.type;
}
AbstractValue mask = _abstractValueDomain.createMapValue(
type.type, node, element, keyTypeMask, valueTypeMask);
- TypeInformation keyTypeInfo =
- KeyInMapTypeInformation(_abstractValueDomain, currentMember, keyType);
- TypeInformation valueTypeInfo = ValueInMapTypeInformation(
- _abstractValueDomain, currentMember, valueType);
+ final keyTypeInfo = KeyInMapTypeInformation(
+ _abstractValueDomain, currentMember, simplifiedKeyType);
+ final valueTypeInfo = ValueInMapTypeInformation(
+ _abstractValueDomain, currentMember, simplifiedValueType);
allocatedTypes.add(keyTypeInfo);
allocatedTypes.add(valueTypeInfo);
@@ -577,7 +498,7 @@
MapTypeInformation(currentMember, mask, keyTypeInfo, valueTypeInfo);
for (int i = 0; i < keyTypes.length; ++i) {
- TypeInformation newType = map.addEntryInput(
+ final newType = map.addEntryInput(
_abstractValueDomain, keyTypes[i], valueTypes[i], true);
if (newType != null) allocatedTypes.add(newType);
}
@@ -610,7 +531,7 @@
}
PhiElementTypeInformation _addPhi(
- ir.Node node, Local variable, TypeInformation inputType, bool isTry) {
+ ir.Node? node, Local? variable, TypeInformation inputType, bool isTry) {
PhiElementTypeInformation result = PhiElementTypeInformation(
_abstractValueDomain, currentMember, node, variable,
isTry: isTry);
@@ -622,8 +543,8 @@
/// Returns a new type for holding the potential types of [element].
/// [inputType] is the first incoming type of the phi.
PhiElementTypeInformation allocatePhi(
- ir.Node node, Local variable, TypeInformation inputType,
- {bool isTry}) {
+ ir.Node? node, Local? variable, TypeInformation inputType,
+ {required bool isTry}) {
assert(strategy.checkPhiNode(node));
// Check if [inputType] is a phi for a local updated in
// the try/catch block [node]. If it is, no need to allocate a new
@@ -643,7 +564,7 @@
/// from other merging uses.
PhiElementTypeInformation allocateLoopPhi(
ir.Node node, Local variable, TypeInformation inputType,
- {bool isTry}) {
+ {required bool isTry}) {
assert(strategy.checkLoopPhiNode(node));
return _addPhi(node, variable, inputType, isTry);
}
@@ -653,14 +574,14 @@
/// implementation of this method could just return that incoming
/// input type.
TypeInformation simplifyPhi(
- ir.Node node, Local variable, PhiElementTypeInformation phiType) {
+ ir.Node? node, Local? variable, PhiElementTypeInformation phiType) {
assert(phiType.branchNode == node);
if (phiType.inputs.length == 1) return phiType.inputs.first;
return phiType;
}
/// Adds [newType] as an input of [phiType].
- PhiElementTypeInformation addPhiInput(Local variable,
+ PhiElementTypeInformation addPhiInput(Local? variable,
PhiElementTypeInformation phiType, TypeInformation newType) {
phiType.addInput(newType);
return phiType;
@@ -697,7 +618,7 @@
list.add(mask);
}
- AbstractValue newType = null;
+ AbstractValue? newType;
for (AbstractValue mask in list) {
newType =
newType == null ? mask : _abstractValueDomain.union(newType, mask);
diff --git a/pkg/compiler/lib/src/ir/impact_data.dart b/pkg/compiler/lib/src/ir/impact_data.dart
index fb1f3b2..2a65114 100644
--- a/pkg/compiler/lib/src/ir/impact_data.dart
+++ b/pkg/compiler/lib/src/ir/impact_data.dart
@@ -192,10 +192,6 @@
}
registerAsyncStar(elementType);
break;
-
- case ir.AsyncMarker.SyncYielding:
- failedAt(CURRENT_ELEMENT_SPANNABLE,
- "Unexpected async marker: ${asyncMarker}");
}
}
diff --git a/pkg/compiler/lib/src/ir/util.dart b/pkg/compiler/lib/src/ir/util.dart
index c9fa392..d96ad3d 100644
--- a/pkg/compiler/lib/src/ir/util.dart
+++ b/pkg/compiler/lib/src/ir/util.dart
@@ -58,7 +58,6 @@
return AsyncMarker.SYNC;
case ir.AsyncMarker.SyncStar:
return AsyncMarker.SYNC_STAR;
- case ir.AsyncMarker.SyncYielding:
default:
throw UnsupportedError(
"Async marker ${node.asyncMarker} is not supported.");
diff --git a/pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart b/pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart
index a542b6c..a5a1606 100644
--- a/pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart
+++ b/pkg/compiler/lib/src/js_backend/custom_elements_analysis.dart
@@ -2,8 +2,6 @@
// 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.
-// @dart = 2.10
-
import '../common/elements.dart';
import '../constants/constant_system.dart' as constant_system;
import '../constants/values.dart';
@@ -71,7 +69,7 @@
}
void registerStaticUse(MemberEntity element) {
- assert(element != null);
+ assert((element as dynamic) != null); // TODO(48820): Remove.
if (_commonElements.isFindIndexForNativeSubclassType(element)) {
join.demanded = true;
}
@@ -151,9 +149,7 @@
final ElementEnvironment _elementEnvironment;
final CommonElements _commonElements;
final NativeBasicData _nativeData;
- final BackendUsageBuilder _backendUsageBuilder;
-
- final bool forResolution;
+ final BackendUsageBuilder? _backendUsageBuilder;
// Classes that are candidates for needing constructors. Classes are moved to
// [activeClasses] when we know they need constructors.
@@ -173,9 +169,8 @@
CustomElementsAnalysisJoin(
this._elementEnvironment, this._commonElements, this._nativeData,
- {BackendUsageBuilder backendUsageBuilder})
- : this._backendUsageBuilder = backendUsageBuilder,
- this.forResolution = backendUsageBuilder != null;
+ {BackendUsageBuilder? backendUsageBuilder})
+ : this._backendUsageBuilder = backendUsageBuilder;
WorldImpact flush() {
if (!demanded) return const WorldImpact();
@@ -196,13 +191,13 @@
impactBuilder.registerStaticUse(
StaticUse.constructorInvoke(constructor, CallStructure.NO_ARGS));
}
- if (forResolution) {
+ if (_backendUsageBuilder != null) {
escapingConstructors
- .forEach(_backendUsageBuilder.registerGlobalFunctionDependency);
+ .forEach(_backendUsageBuilder!.registerGlobalFunctionDependency);
}
// Force the generation of the type constant that is the key to an entry
// in the generated table.
- ConstantValue constant = _makeTypeConstant(cls);
+ final constant = _makeTypeConstant(cls);
impactBuilder.registerConstantUse(ConstantUse.customElements(constant));
}
}
diff --git a/pkg/compiler/lib/src/js_emitter/native_generator.dart b/pkg/compiler/lib/src/js_emitter/native_generator.dart
index a47b6be..ab7d73a 100644
--- a/pkg/compiler/lib/src/js_emitter/native_generator.dart
+++ b/pkg/compiler/lib/src/js_emitter/native_generator.dart
@@ -2,8 +2,6 @@
// 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.
-// @dart = 2.10
-
library dart2js.js_emitter.native_generator;
import 'package:js_runtime/synced/embedded_names.dart' as embeddedNames;
diff --git a/pkg/compiler/lib/src/source_file_provider.dart b/pkg/compiler/lib/src/source_file_provider.dart
index df9763b..ee9dea5 100644
--- a/pkg/compiler/lib/src/source_file_provider.dart
+++ b/pkg/compiler/lib/src/source_file_provider.dart
@@ -559,13 +559,18 @@
}
api.Input<List<int>> result =
await readBytesFromUri(resolvedUri, inputKind);
- switch (inputKind) {
- case api.InputKind.UTF8:
- utf8SourceFiles[uri] = utf8SourceFiles[resolvedUri];
- break;
- case api.InputKind.binary:
- binarySourceFiles[uri] = binarySourceFiles[resolvedUri];
- break;
+ if (uri != resolvedUri) {
+ if (!resolvedUri.isAbsolute) {
+ resolvedUri = cwd.resolveUri(resolvedUri);
+ }
+ switch (inputKind) {
+ case api.InputKind.UTF8:
+ utf8SourceFiles[uri] = utf8SourceFiles[resolvedUri];
+ break;
+ case api.InputKind.binary:
+ binarySourceFiles[uri] = binarySourceFiles[resolvedUri];
+ break;
+ }
}
return result;
}
diff --git a/pkg/compiler/test/analyses/dart2js_allowed.json b/pkg/compiler/test/analyses/dart2js_allowed.json
index 107ef15..746d0ef 100644
--- a/pkg/compiler/test/analyses/dart2js_allowed.json
+++ b/pkg/compiler/test/analyses/dart2js_allowed.json
@@ -27,15 +27,6 @@
"Dynamic access of 'memberContext'.": 1,
"Dynamic access of 'name'.": 1
},
- "pkg/compiler/lib/src/inferrer/locals_handler.dart": {
- "Dynamic access of 'length'.": 2,
- "Dynamic access of 'named'.": 2,
- "Dynamic access of 'positional'.": 2,
- "Dynamic invocation of '[]'.": 2
- },
- "pkg/compiler/lib/src/inferrer/type_graph_nodes.dart": {
- "Dynamic access of 'type'.": 4
- },
"pkg/compiler/lib/src/inferrer/typemasks/type_mask.dart": {
"Dynamic access of 'forwardTo'.": 1,
"Dynamic access of 'isForwarding'.": 1
diff --git a/pkg/compiler/test/serialization/serialization_test_helper.dart b/pkg/compiler/test/serialization/serialization_test_helper.dart
index f50d65b..aa3474c 100644
--- a/pkg/compiler/test/serialization/serialization_test_helper.dart
+++ b/pkg/compiler/test/serialization/serialization_test_helper.dart
@@ -24,17 +24,18 @@
const List<String> dumpInfoExceptions = [
'"compilationMoment":',
'"compilationDuration":',
- '"toJsonDuration":'
+ '"toJsonDuration":',
+ '"ramUsage":'
];
-void generateJavaScriptCode(
- Compiler compiler, GlobalTypeInferenceResults globalTypeInferenceResults) {
+void generateJavaScriptCode(Compiler compiler,
+ GlobalTypeInferenceResults globalTypeInferenceResults) async {
final codegenInputs = compiler.initializeCodegen(globalTypeInferenceResults);
final codegenResults = OnDemandCodegenResults(globalTypeInferenceResults,
codegenInputs, compiler.backendStrategy.functionCompiler);
final programSize = compiler.runCodegenEnqueuer(codegenResults);
if (compiler.options.dumpInfo) {
- compiler.runDumpInfo(codegenResults, programSize);
+ await compiler.runDumpInfo(codegenResults, programSize);
}
}
@@ -44,7 +45,7 @@
Compiler compiler,
SerializationStrategy strategy,
{bool stoppedAfterClosedWorld = false,
- bool stoppedAfterTypeInference = false}) {
+ bool stoppedAfterTypeInference = false}) async {
if (stoppedAfterClosedWorld) {
JsClosedWorld closedWorld = compiler.backendClosedWorldForTesting;
var newClosedWorldAndIndices =
@@ -59,7 +60,7 @@
GlobalTypeInferenceResults newGlobalInferenceResults =
cloneInferenceResults(
indices, compiler, globalInferenceResults, strategy);
- generateJavaScriptCode(compiler, newGlobalInferenceResults);
+ await generateJavaScriptCode(compiler, newGlobalInferenceResults);
}
var actualOutput = actualOutputCollector.clear();
Expect.setEquals(
@@ -181,10 +182,10 @@
});
Expect.isTrue(result3b.isSuccess);
- finishCompileAndCompare(
+ await finishCompileAndCompare(
expectedOutput, collector2, result2.compiler, strategy,
stoppedAfterClosedWorld: true);
- finishCompileAndCompare(
+ await finishCompileAndCompare(
expectedOutput, collector3b, result3b.compiler, strategy,
stoppedAfterTypeInference: true);
await dir.delete(recursive: true);
diff --git a/pkg/dart2js_info/lib/binary_serialization.dart b/pkg/dart2js_info/lib/binary_serialization.dart
index 8f788b2..0d707ce 100644
--- a/pkg/dart2js_info/lib/binary_serialization.dart
+++ b/pkg/dart2js_info/lib/binary_serialization.dart
@@ -75,6 +75,7 @@
void visitProgram(ProgramInfo info) {
visitFunction(info.entrypoint);
sink.writeInt(info.size);
+ sink.writeString(info.ramUsage);
sink.writeStringOrNull(info.dart2jsVersion);
writeDate(info.compilationMoment);
writeDuration(info.compilationDuration);
@@ -324,6 +325,7 @@
ProgramInfo readProgram() {
final entrypoint = readFunction();
final size = source.readInt();
+ final ramUsage = source.readString();
final dart2jsVersion = source.readStringOrNull();
final compilationMoment = readDate();
final compilationDuration = readDuration();
@@ -338,6 +340,7 @@
return ProgramInfo(
entrypoint: entrypoint,
size: size,
+ ramUsage: ramUsage,
dart2jsVersion: dart2jsVersion,
compilationMoment: compilationMoment,
compilationDuration: compilationDuration,
diff --git a/pkg/dart2js_info/lib/info.dart b/pkg/dart2js_info/lib/info.dart
index 1462964..509edb0 100644
--- a/pkg/dart2js_info/lib/info.dart
+++ b/pkg/dart2js_info/lib/info.dart
@@ -141,6 +141,7 @@
class ProgramInfo {
final FunctionInfo entrypoint;
+ final String ramUsage;
final int size;
final String? dart2jsVersion;
final DateTime compilationMoment;
@@ -167,6 +168,7 @@
ProgramInfo(
{required this.entrypoint,
+ required this.ramUsage,
required this.size,
required this.dart2jsVersion,
required this.compilationMoment,
diff --git a/pkg/dart2js_info/lib/json_info_codec.dart b/pkg/dart2js_info/lib/json_info_codec.dart
index 639776a..937ea4d 100644
--- a/pkg/dart2js_info/lib/json_info_codec.dart
+++ b/pkg/dart2js_info/lib/json_info_codec.dart
@@ -206,6 +206,7 @@
final programInfo = ProgramInfo(
entrypoint: parseId(json['entrypoint']) as FunctionInfo,
size: json['size'],
+ ramUsage: json['ramUsage'],
compilationMoment: DateTime.parse(json['compilationMoment']),
dart2jsVersion: json['dart2jsVersion'],
noSuchMethodEnabled: json['noSuchMethodEnabled'],
@@ -455,6 +456,7 @@
return {
'entrypoint': idFor(info.entrypoint).serializedId,
'size': info.size,
+ 'ramUsage': info.ramUsage,
'dart2jsVersion': info.dart2jsVersion,
'compilationMoment': '${info.compilationMoment}',
'compilationDuration': info.compilationDuration.inMicroseconds,
diff --git a/pkg/dart2js_info/test/hello_world/hello_world.js.info.json b/pkg/dart2js_info/test/hello_world/hello_world.js.info.json
index 9006151..c0bf81b 100644
--- a/pkg/dart2js_info/test/hello_world/hello_world.js.info.json
+++ b/pkg/dart2js_info/test/hello_world/hello_world.js.info.json
@@ -47,7 +47,7 @@
"id": "library/dart:_js_helper::",
"kind": "library",
"name": "_js_helper",
- "size": 12952,
+ "size": 12859,
"children": [
"class/dart:_js_helper::BoundClosure",
"class/dart:_js_helper::Closure",
@@ -262,7 +262,7 @@
"children": [
"function/hello_world.dart::main"
],
- "canonicalUri": "file:///usr/local/google/home/natebiggs/dart-sdk/sdk/pkg/dart2js_info/test/hello_world/hello_world.dart"
+ "canonicalUri": "file:///Users/markzipan/Projects/dart-sdk/sdk/pkg/dart2js_info/test/hello_world/hello_world.dart"
}
},
"class": {
@@ -2303,7 +2303,7 @@
"id": "function/dart:_js_helper::Primitives._objectTypeNameNewRti",
"kind": "function",
"name": "_objectTypeNameNewRti",
- "size": 959,
+ "size": 866,
"outputUnit": "outputUnit/main",
"parent": "class/dart:_js_helper::Primitives",
"children": [],
@@ -2324,7 +2324,7 @@
],
"sideEffects": "SideEffects(reads anything; writes anything)",
"inlinedCount": 0,
- "code": "Primitives__objectTypeNameNewRti(object) {\n var interceptor, dispatchName, t1, $constructor, constructorName;\n if (object instanceof A.Object)\n return A._rtiToString(A.instanceType(object), null);\n interceptor = J.getInterceptor$(object);\n if (interceptor === B.Interceptor_methods || interceptor === B.JavaScriptObject_methods || false) {\n dispatchName = B.C_JS_CONST(object);\n t1 = dispatchName !== \"Object\" && dispatchName !== \"\";\n if (t1)\n return dispatchName;\n $constructor = object.constructor;\n if (typeof $constructor == \"function\") {\n constructorName = $constructor.name;\n if (typeof constructorName == \"string\")\n t1 = constructorName !== \"Object\" && constructorName !== \"\";\n else\n t1 = false;\n if (t1)\n return constructorName;\n }\n }\n return A._rtiToString(A.instanceType(object), null);\n }",
+ "code": "Primitives__objectTypeNameNewRti(object) {\n var interceptor, dispatchName, $constructor, constructorName;\n if (object instanceof A.Object)\n return A._rtiToString(A.instanceType(object), null);\n interceptor = J.getInterceptor$(object);\n if (interceptor === B.Interceptor_methods || interceptor === B.JavaScriptObject_methods || false) {\n dispatchName = B.C_JS_CONST(object);\n if (dispatchName !== \"Object\" && dispatchName !== \"\")\n return dispatchName;\n $constructor = object.constructor;\n if (typeof $constructor == \"function\") {\n constructorName = $constructor.name;\n if (typeof constructorName == \"string\" && constructorName !== \"Object\" && constructorName !== \"\")\n return constructorName;\n }\n }\n return A._rtiToString(A.instanceType(object), null);\n }",
"type": "String Function(Object?)",
"functionKind": 0
},
@@ -28711,7 +28711,7 @@
"id": "outputUnit/main",
"kind": "outputUnit",
"name": "main",
- "size": 90362,
+ "size": 90269,
"filename": "hello_world.js",
"imports": []
}
@@ -28721,11 +28721,12 @@
"dump_minor_version": 1,
"program": {
"entrypoint": "function/hello_world.dart::main",
- "size": 90362,
+ "size": 90269,
+ "ramUsage": "194.188 MB",
"dart2jsVersion": null,
- "compilationMoment": "2022-05-26 21:08:43.608041",
- "compilationDuration": 3177312,
- "toJsonDuration": 3000,
+ "compilationMoment": "2022-07-08 12:57:36.142141",
+ "compilationDuration": 1321045,
+ "toJsonDuration": 1000,
"dumpInfoDuration": 0,
"noSuchMethodEnabled": false,
"isRuntimeTypeUsed": false,
diff --git a/pkg/dart2js_info/test/hello_world_deferred/hello_world_deferred.js.info.json b/pkg/dart2js_info/test/hello_world_deferred/hello_world_deferred.js.info.json
index cc4f282..f583ac5 100644
--- a/pkg/dart2js_info/test/hello_world_deferred/hello_world_deferred.js.info.json
+++ b/pkg/dart2js_info/test/hello_world_deferred/hello_world_deferred.js.info.json
@@ -54,7 +54,7 @@
"id": "library/dart:_js_helper::",
"kind": "library",
"name": "_js_helper",
- "size": 47353,
+ "size": 47260,
"children": [
"class/dart:_js_helper::BoundClosure",
"class/dart:_js_helper::Closure",
@@ -274,7 +274,7 @@
"id": "library/dart:async::",
"kind": "library",
"name": "dart.async",
- "size": 41039,
+ "size": 41197,
"children": [
"class/dart:async::AsyncError",
"class/dart:async::Completer",
@@ -397,7 +397,7 @@
"children": [
"function/hello_world_deferred.dart::main"
],
- "canonicalUri": "file:///usr/local/google/home/natebiggs/dart-sdk/sdk/pkg/dart2js_info/test/hello_world_deferred/hello_world_deferred.dart"
+ "canonicalUri": "file:///Users/markzipan/Projects/dart-sdk/sdk/pkg/dart2js_info/test/hello_world_deferred/hello_world_deferred.dart"
}
},
"class": {
@@ -5410,7 +5410,7 @@
"id": "function/dart:_js_helper::Primitives._objectTypeNameNewRti",
"kind": "function",
"name": "_objectTypeNameNewRti",
- "size": 995,
+ "size": 902,
"outputUnit": "outputUnit/main",
"parent": "class/dart:_js_helper::Primitives",
"children": [],
@@ -5431,7 +5431,7 @@
],
"sideEffects": "SideEffects(reads anything; writes anything)",
"inlinedCount": 0,
- "code": "Primitives__objectTypeNameNewRti(object) {\n var interceptor, dispatchName, t1, $constructor, constructorName;\n if (object instanceof A.Object)\n return A._rtiToString(A.instanceType(object), null);\n interceptor = J.getInterceptor$(object);\n if (interceptor === B.Interceptor_methods || interceptor === B.JavaScriptObject_methods || type$.UnknownJavaScriptObject._is(object)) {\n dispatchName = B.C_JS_CONST(object);\n t1 = dispatchName !== \"Object\" && dispatchName !== \"\";\n if (t1)\n return dispatchName;\n $constructor = object.constructor;\n if (typeof $constructor == \"function\") {\n constructorName = $constructor.name;\n if (typeof constructorName == \"string\")\n t1 = constructorName !== \"Object\" && constructorName !== \"\";\n else\n t1 = false;\n if (t1)\n return constructorName;\n }\n }\n return A._rtiToString(A.instanceType(object), null);\n }",
+ "code": "Primitives__objectTypeNameNewRti(object) {\n var interceptor, dispatchName, $constructor, constructorName;\n if (object instanceof A.Object)\n return A._rtiToString(A.instanceType(object), null);\n interceptor = J.getInterceptor$(object);\n if (interceptor === B.Interceptor_methods || interceptor === B.JavaScriptObject_methods || type$.UnknownJavaScriptObject._is(object)) {\n dispatchName = B.C_JS_CONST(object);\n if (dispatchName !== \"Object\" && dispatchName !== \"\")\n return dispatchName;\n $constructor = object.constructor;\n if (typeof $constructor == \"function\") {\n constructorName = $constructor.name;\n if (typeof constructorName == \"string\" && constructorName !== \"Object\" && constructorName !== \"\")\n return constructorName;\n }\n }\n return A._rtiToString(A.instanceType(object), null);\n }",
"type": "String Function(Object?)",
"functionKind": 0
},
@@ -19721,7 +19721,7 @@
"id": "function/dart:async::scheduleMicrotask",
"kind": "function",
"name": "scheduleMicrotask",
- "size": 367,
+ "size": 525,
"outputUnit": "outputUnit/main",
"parent": "library/dart:async::",
"children": [],
@@ -19742,7 +19742,7 @@
],
"sideEffects": "SideEffects(reads anything; writes anything)",
"inlinedCount": 0,
- "code": "scheduleMicrotask(callback) {\n var _null = null,\n currentZone = $.Zone__current;\n if (B.C__RootZone === currentZone) {\n A._rootScheduleMicrotask(_null, _null, B.C__RootZone, callback);\n return;\n }\n A._rootScheduleMicrotask(_null, _null, currentZone, type$.void_Function._as(currentZone.bindCallbackGuarded$1(callback)));\n }",
+ "code": "scheduleMicrotask(callback) {\n var t1, _null = null,\n currentZone = $.Zone__current;\n if (B.C__RootZone === currentZone) {\n A._rootScheduleMicrotask(_null, _null, B.C__RootZone, callback);\n return;\n }\n t1 = false;\n if (t1) {\n A._rootScheduleMicrotask(_null, _null, currentZone, type$.void_Function._as(callback));\n return;\n }\n A._rootScheduleMicrotask(_null, _null, currentZone, type$.void_Function._as(currentZone.bindCallbackGuarded$1(callback)));\n }",
"type": "void Function(void Function())",
"functionKind": 0
},
@@ -67168,7 +67168,7 @@
"id": "outputUnit/main",
"kind": "outputUnit",
"name": "main",
- "size": 188050,
+ "size": 188115,
"filename": "hello_world_deferred.js",
"imports": []
}
@@ -67187,11 +67187,12 @@
"dump_minor_version": 1,
"program": {
"entrypoint": "function/hello_world_deferred.dart::main",
- "size": 188644,
+ "size": 188709,
+ "ramUsage": "218.516 MB",
"dart2jsVersion": null,
- "compilationMoment": "2022-05-26 21:07:11.259922",
- "compilationDuration": 4395336,
- "toJsonDuration": 9000,
+ "compilationMoment": "2022-07-08 12:58:35.955576",
+ "compilationDuration": 1806706,
+ "toJsonDuration": 3000,
"dumpInfoDuration": 0,
"noSuchMethodEnabled": false,
"isRuntimeTypeUsed": false,
diff --git a/pkg/dart2js_info/test/json_to_proto_test.dart b/pkg/dart2js_info/test/json_to_proto_test.dart
index 240f3c2..5b20745 100644
--- a/pkg/dart2js_info/test/json_to_proto_test.dart
+++ b/pkg/dart2js_info/test/json_to_proto_test.dart
@@ -20,11 +20,11 @@
final proto = AllInfoProtoCodec().encode(decoded);
expect(proto.program.entrypointId, isNotNull);
- expect(proto.program.size, 90362);
+ expect(proto.program.size, 90269);
expect(proto.program.compilationMoment.toInt(),
- DateTime.parse("2022-05-26 21:08:43.608041").microsecondsSinceEpoch);
+ DateTime.parse("2022-07-08 12:57:36.142141").microsecondsSinceEpoch);
expect(proto.program.toProtoDuration.toInt(),
- Duration(milliseconds: 3).inMicroseconds);
+ Duration(milliseconds: 1).inMicroseconds);
expect(proto.program.dumpInfoDuration.toInt(),
Duration(milliseconds: 0).inMicroseconds);
expect(proto.program.noSuchMethodEnabled, isFalse);
diff --git a/pkg/dart2js_info/test/parse_test.dart b/pkg/dart2js_info/test/parse_test.dart
index 92c34d0..be06468 100644
--- a/pkg/dart2js_info/test/parse_test.dart
+++ b/pkg/dart2js_info/test/parse_test.dart
@@ -20,11 +20,11 @@
expect(program, isNotNull);
expect(program!.entrypoint, isNotNull);
- expect(program.size, 90362);
+ expect(program.size, 90269);
expect(program.compilationMoment,
- DateTime.parse("2022-05-26 21:08:43.608041"));
- expect(program.compilationDuration, Duration(microseconds: 3177312));
- expect(program.toJsonDuration, Duration(milliseconds: 3));
+ DateTime.parse("2022-07-08 12:57:36.142141"));
+ expect(program.compilationDuration, Duration(microseconds: 1321045));
+ expect(program.toJsonDuration, Duration(milliseconds: 1));
expect(program.dumpInfoDuration, Duration(seconds: 0));
expect(program.noSuchMethodEnabled, false);
expect(program.minified, false);
diff --git a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
index 94bac69..5d15880 100644
--- a/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/body_builder.dart
@@ -76,8 +76,7 @@
import '../modifier.dart'
show Modifier, constMask, covariantMask, finalMask, lateMask, requiredMask;
import '../names.dart' show emptyName, minusName, plusName;
-import '../problems.dart'
- show internalProblem, unexpected, unhandled, unsupported;
+import '../problems.dart' show internalProblem, unhandled, unsupported;
import '../scope.dart';
import '../source/diet_parser.dart';
import '../source/source_class_builder.dart';
@@ -1415,9 +1414,6 @@
case AsyncMarker.Sync:
break; // skip
- case AsyncMarker.SyncYielding:
- unexpected("async, async*, sync, or sync*", "$asyncModifier",
- member.charOffset, uri);
}
if (problem != null) {
@@ -3284,8 +3280,8 @@
@override
void endIfStatement(Token ifToken, Token? elseToken) {
Statement? elsePart = popStatementIfNotNull(elseToken);
- AssignedVariablesNodeInfo<VariableDeclaration> assignedVariablesInfo =
- pop() as AssignedVariablesNodeInfo<VariableDeclaration>;
+ AssignedVariablesNodeInfo assignedVariablesInfo =
+ pop() as AssignedVariablesNodeInfo;
Statement thenPart = popStatement();
Expression condition = pop() as Expression;
Statement node = forest.createIfStatement(
@@ -3308,7 +3304,7 @@
void endVariableInitializer(Token assignmentOperator) {
debugEvent("VariableInitializer");
assert(assignmentOperator.stringValue == "=");
- AssignedVariablesNodeInfo<VariableDeclaration>? assignedVariablesInfo;
+ AssignedVariablesNodeInfo? assignedVariablesInfo;
bool isLate = (currentLocalVariableModifiers & lateMask) != 0;
Expression initializer = popForValue();
if (isLate) {
@@ -3535,8 +3531,8 @@
/// ends. Since these need to be associated with the try statement created in
/// in [endTryStatement] we store them the stack until the try statement is
/// created.
- Link<AssignedVariablesNodeInfo<VariableDeclaration>> tryStatementInfoStack =
- const Link<AssignedVariablesNodeInfo<VariableDeclaration>>();
+ Link<AssignedVariablesNodeInfo> tryStatementInfoStack =
+ const Link<AssignedVariablesNodeInfo>();
@override
void beginBlock(Token token, BlockKind blockKind) {
@@ -3728,7 +3724,7 @@
// [handleForInitializerEmptyStatement],
// [handleForInitializerExpressionStatement], and
// [handleForInitializerLocalVariableDeclaration].
- AssignedVariablesNodeInfo<VariableDeclaration> assignedVariablesNodeInfo =
+ AssignedVariablesNodeInfo assignedVariablesNodeInfo =
typeInferrer.assignedVariables.popNode();
Object? variableOrExpression = pop();
@@ -3795,7 +3791,7 @@
// [handleForInitializerEmptyStatement],
// [handleForInitializerExpressionStatement], and
// [handleForInitializerLocalVariableDeclaration].
- AssignedVariablesNodeInfo<VariableDeclaration> assignedVariablesNodeInfo =
+ AssignedVariablesNodeInfo assignedVariablesNodeInfo =
typeInferrer.assignedVariables.deferNode();
Object? variableOrExpression = pop();
@@ -4383,8 +4379,8 @@
debugEvent("ConditionalExpression");
Expression elseExpression = popForValue();
Expression thenExpression = pop() as Expression;
- AssignedVariablesNodeInfo<VariableDeclaration> assignedVariablesInfo =
- pop() as AssignedVariablesNodeInfo<VariableDeclaration>;
+ AssignedVariablesNodeInfo assignedVariablesInfo =
+ pop() as AssignedVariablesNodeInfo;
Expression condition = pop() as Expression;
Expression node = forest.createConditionalExpression(
offsetForToken(question), condition, thenExpression, elseExpression);
@@ -5757,8 +5753,8 @@
debugEvent("endIfElseControlFlow");
Object? elseEntry = pop(); // else entry
Object? thenEntry = pop(); // then entry
- AssignedVariablesNodeInfo<VariableDeclaration> assignedVariablesInfo =
- pop() as AssignedVariablesNodeInfo<VariableDeclaration>;
+ AssignedVariablesNodeInfo assignedVariablesInfo =
+ pop() as AssignedVariablesNodeInfo;
Object? condition = pop(); // parenthesized expression
Token ifToken = pop() as Token;
@@ -6232,7 +6228,7 @@
}
// This is matched by the call to [beginNode] in [handleForInLoopParts].
- AssignedVariablesNodeInfo<VariableDeclaration> assignedVariablesNodeInfo =
+ AssignedVariablesNodeInfo assignedVariablesNodeInfo =
typeInferrer.assignedVariables.popNode();
Expression iterable = popForValue();
@@ -6348,7 +6344,7 @@
Token? awaitToken = pop(NullValue.AwaitToken) as Token?;
// This is matched by the call to [beginNode] in [handleForInLoopParts].
- AssignedVariablesNodeInfo<VariableDeclaration> assignedVariablesNodeInfo =
+ AssignedVariablesNodeInfo assignedVariablesNodeInfo =
typeInferrer.assignedVariables.deferNode();
Expression expression = popForValue();
diff --git a/pkg/front_end/lib/src/fasta/source/source_loader.dart b/pkg/front_end/lib/src/fasta/source/source_loader.dart
index 4f62e70..c039e08 100644
--- a/pkg/front_end/lib/src/fasta/source/source_loader.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_loader.dart
@@ -2730,45 +2730,14 @@
class num {}
-class _SyncIterable {}
-
-class _SyncIterator {
- var _current;
- var _yieldEachIterable;
-}
-
class Function {}
""";
/// A minimal implementation of dart:async that is sufficient to create an
/// instance of [CoreTypes] and compile program.
const String defaultDartAsyncSource = """
-_asyncErrorWrapperHelper(continuation) {}
-
void _asyncStarMoveNextHelper(var stream) {}
-_asyncThenWrapperHelper(continuation) {}
-
-_awaitHelper(object, thenCallback, errorCallback) {}
-
-_completeOnAsyncReturn(_future, value, async_jump_var) {}
-
-_completeWithNoFutureOnAsyncReturn(_future, value, async_jump_var) {}
-
-_completeOnAsyncError(_future, e, st, async_jump_var) {}
-
-class _AsyncStarStreamController {
- add(event) {}
-
- addError(error, stackTrace) {}
-
- addStream(stream) {}
-
- close() {}
-
- get stream => null;
-}
-
abstract class Completer {
factory Completer.sync() => null;
diff --git a/pkg/front_end/lib/src/fasta/type_inference/inference_visitor.dart b/pkg/front_end/lib/src/fasta/type_inference/inference_visitor.dart
index 8b82433..5926dff 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/inference_visitor.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/inference_visitor.dart
@@ -4218,7 +4218,7 @@
{required bool isNot}) {
// ignore: unnecessary_null_comparison
assert(isNot != null);
- EqualityInfo<VariableDeclaration, DartType>? equalityInfo =
+ EqualityInfo<DartType>? equalityInfo =
flowAnalysis.equalityOperand_end(left, leftType);
bool typeNeeded = !isTopLevel;
diff --git a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
index bb686bf..85db894 100644
--- a/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
+++ b/pkg/front_end/lib/src/fasta/type_inference/type_inferrer.dart
@@ -2456,7 +2456,7 @@
typeChecksNeeded);
}
- List<EqualityInfo<VariableDeclaration, DartType>?>? identicalInfo =
+ List<EqualityInfo<DartType>?>? identicalInfo =
isIdentical && arguments.positional.length == 2 ? [] : null;
int positionalIndex = 0;
int namedIndex = 0;
diff --git a/pkg/front_end/test/id_tests/assigned_variables_test.dart b/pkg/front_end/test/id_tests/assigned_variables_test.dart
index 23a5b09..53af2eb 100644
--- a/pkg/front_end/test/id_tests/assigned_variables_test.dart
+++ b/pkg/front_end/test/id_tests/assigned_variables_test.dart
@@ -74,8 +74,8 @@
_convertVars(_assignedVariables.capturedAnywhere));
}
- Set<String> _convertVars(Iterable<VariableDeclaration> x) =>
- x.map((e) => e.name!).toSet();
+ Set<String> _convertVars(Iterable<int> x) =>
+ x.map((e) => _assignedVariables.variableForKey(e).name!).toSet();
@override
_Data? computeNodeValue(Id id, TreeNode node) {
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index e401254..7105235e 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -1081,6 +1081,7 @@
reexports
ref
refactoring
+reference's
refined
reflect
reflectee
@@ -1496,6 +1497,7 @@
url
urls
usages
+user's
usr
usual
usually
diff --git a/pkg/front_end/testcases/general/issue38253c.dart.strong.transformed.expect b/pkg/front_end/testcases/general/issue38253c.dart.strong.transformed.expect
deleted file mode 100644
index eb54dc9..0000000
--- a/pkg/front_end/testcases/general/issue38253c.dart.strong.transformed.expect
+++ /dev/null
@@ -1,69 +0,0 @@
-library;
-//
-// Problems in library:
-//
-// pkg/front_end/testcases/general/issue38253c.dart:6:3: Error: 'g' isn't a type.
-// g f1() {}
-// ^
-//
-// pkg/front_end/testcases/general/issue38253c.dart:7:3: Error: 'g' isn't a type.
-// g f2() async {}
-// ^
-//
-import self as self;
-import "dart:async" as asy;
-import "dart:core" as core;
-
-static field () →* Null a = () → Null {
- function f1() → invalid-type {}
- function f2() → invalid-type /* originally async */ {
- final asy::_Future<dynamic>* :async_future = new asy::_Future::•<dynamic>();
- core::bool* :is_sync = false;
- FutureOr<dynamic>* :return_value;
- (dynamic) →* dynamic :async_op_then;
- (core::Object*, core::StackTrace*) →* dynamic :async_op_error;
- core::int* :await_jump_var = 0;
- dynamic :await_ctx_var;
- function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
- try {
- #L1:
- {}
- asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
- return;
- }
- on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
- asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
- }
- :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
- :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
- :async_op.call();
- :is_sync = true;
- return :async_future;
- }
- function f3() → core::int* {}
- function f4() → asy::Future<core::int*>* /* originally async */ {
- final asy::_Future<core::int*>* :async_future = new asy::_Future::•<core::int*>();
- core::bool* :is_sync = false;
- FutureOr<core::int*>* :return_value;
- (dynamic) →* dynamic :async_op_then;
- (core::Object*, core::StackTrace*) →* dynamic :async_op_error;
- core::int* :await_jump_var = 0;
- dynamic :await_ctx_var;
- function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding
- try {
- #L2:
- {}
- asy::_completeOnAsyncReturn(:async_future, :return_value, :is_sync);
- return;
- }
- on dynamic catch(dynamic exception, core::StackTrace* stack_trace) {
- asy::_completeOnAsyncError(:async_future, exception, stack_trace, :is_sync);
- }
- :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
- :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
- :async_op.call();
- :is_sync = true;
- return :async_future;
- }
-};
-static method main() → dynamic {}
diff --git a/pkg/frontend_server/lib/frontend_server.dart b/pkg/frontend_server/lib/frontend_server.dart
index 5d7088c..9065163 100644
--- a/pkg/frontend_server/lib/frontend_server.dart
+++ b/pkg/frontend_server/lib/frontend_server.dart
@@ -58,8 +58,7 @@
help: 'Whether dart:mirrors is supported. By default dart:mirrors is '
'supported when --aot and --minimal-kernel are not used.',
defaultsTo: null)
- ..addFlag('compact-async',
- help: 'Enable new compact async/await implementation.', defaultsTo: true)
+ ..addFlag('compact-async', help: 'Obsolete, ignored.', hide: true)
..addFlag('tfa',
help:
'Enable global type flow analysis and related transformations in AOT mode.',
@@ -543,7 +542,6 @@
nullSafety: compilerOptions.nnbdMode == NnbdMode.Strong,
supportMirrors: options['support-mirrors'] ??
!(options['aot'] || options['minimal-kernel']),
- compactAsync: options['compact-async'],
);
if (compilerOptions.target == null) {
print('Failed to create front-end target ${options['target']}.');
diff --git a/pkg/kernel/binary.md b/pkg/kernel/binary.md
index 46ecd90..db46616 100644
--- a/pkg/kernel/binary.md
+++ b/pkg/kernel/binary.md
@@ -147,7 +147,7 @@
type ComponentFile {
UInt32 magic = 0x90ABCDEF;
- UInt32 formatVersion = 82;
+ UInt32 formatVersion = 83;
Byte[10] shortSdkHash;
List<String> problemsAsJson; // Described in problems.md.
Library[] libraries;
@@ -510,8 +510,7 @@
Sync,
SyncStar,
Async,
- AsyncStar,
- SyncYielding
+ AsyncStar
}
*/
@@ -1398,7 +1397,7 @@
type YieldStatement extends Statement {
Byte tag = 77;
FileOffset fileOffset;
- Byte flags (isYieldStar, isNative);
+ Byte flags (isYieldStar);
Expression expression;
}
diff --git a/pkg/kernel/lib/ast.dart b/pkg/kernel/lib/ast.dart
index e8a0d0e..74fe943 100644
--- a/pkg/kernel/lib/ast.dart
+++ b/pkg/kernel/lib/ast.dart
@@ -3956,43 +3956,6 @@
SyncStar,
Async,
AsyncStar,
-
- // `SyncYielding` is a marker that tells Dart VM that this function is an
- // artificial closure introduced by an async transformer which desugared all
- // async syntax into a combination of native yields and helper method calls.
- //
- // Native yields (formatted as `[yield]`) are semantically close to
- // `yield x` statement: they denote a yield/resume point within a function
- // but are completely decoupled from the notion of iterators. When
- // execution of the closure reaches `[yield] x` it stops and return the
- // value of `x` to the caller. If closure is called again it continues
- // to the next statement after this yield as if it was suspended and resumed.
- //
- // Consider this example:
- //
- // g() {
- // var :await_jump_var = 0;
- // var :await_ctx_var;
- //
- // f(x) yielding {
- // [yield] '${x}:0';
- // [yield] '${x}:1';
- // [yield] '${x}:2';
- // }
- //
- // return f;
- // }
- //
- // print(f('a')); /* prints 'a:0', :await_jump_var = 1 */
- // print(f('b')); /* prints 'b:1', :await_jump_var = 2 */
- // print(f('c')); /* prints 'c:2', :await_jump_var = 3 */
- //
- // Note: currently Dart VM implicitly relies on async transformer to
- // inject certain artificial variables into g (like `:await_jump_var`).
- // As such SyncYielding and native yield are not intended to be used on their
- // own, but are rather an implementation artifact of the async transformer
- // itself.
- SyncYielding,
}
// ------------------------------------------------------------------------
@@ -10523,33 +10486,23 @@
}
/// Statement of form `yield x` or `yield* x`.
-///
-/// For native yield semantics see `AsyncMarker.SyncYielding`.
class YieldStatement extends Statement {
Expression expression;
int flags = 0;
- YieldStatement(this.expression,
- {bool isYieldStar: false, bool isNative: false}) {
+ YieldStatement(this.expression, {bool isYieldStar: false}) {
expression.parent = this;
this.isYieldStar = isYieldStar;
- this.isNative = isNative;
}
static const int FlagYieldStar = 1 << 0;
- static const int FlagNative = 1 << 1;
bool get isYieldStar => flags & FlagYieldStar != 0;
- bool get isNative => flags & FlagNative != 0;
void set isYieldStar(bool value) {
flags = value ? (flags | FlagYieldStar) : (flags & ~FlagYieldStar);
}
- void set isNative(bool value) {
- flags = value ? (flags | FlagNative) : (flags & ~FlagNative);
- }
-
@override
R accept<R>(StatementVisitor<R> v) => v.visitYieldStatement(this);
diff --git a/pkg/kernel/lib/binary/ast_from_binary.dart b/pkg/kernel/lib/binary/ast_from_binary.dart
index a4fd2ba..f37d04d 100644
--- a/pkg/kernel/lib/binary/ast_from_binary.dart
+++ b/pkg/kernel/lib/binary/ast_from_binary.dart
@@ -2895,8 +2895,7 @@
int offset = readOffset();
int flags = readByte();
return new YieldStatement(readExpression(),
- isYieldStar: flags & YieldStatement.FlagYieldStar != 0,
- isNative: flags & YieldStatement.FlagNative != 0)
+ isYieldStar: flags & YieldStatement.FlagYieldStar != 0)
..fileOffset = offset;
}
diff --git a/pkg/kernel/lib/binary/tag.dart b/pkg/kernel/lib/binary/tag.dart
index 754bbd6..2e861b6 100644
--- a/pkg/kernel/lib/binary/tag.dart
+++ b/pkg/kernel/lib/binary/tag.dart
@@ -179,7 +179,7 @@
/// Internal version of kernel binary format.
/// Bump it when making incompatible changes in kernel binaries.
/// Keep in sync with runtime/vm/kernel_binary.h, pkg/kernel/binary.md.
- static const int BinaryFormatVersion = 82;
+ static const int BinaryFormatVersion = 83;
}
abstract class ConstantTag {
diff --git a/pkg/kernel/lib/core_types.dart b/pkg/kernel/lib/core_types.dart
index 70edb2c..1734950 100644
--- a/pkg/kernel/lib/core_types.dart
+++ b/pkg/kernel/lib/core_types.dart
@@ -119,57 +119,15 @@
CoreTypes(Component component)
: index = new LibraryIndex.coreLibraries(component);
- late final Procedure asyncErrorWrapperHelperProcedure =
- index.getTopLevelProcedure('dart:async', '_asyncErrorWrapperHelper');
-
late final Library asyncLibrary = index.getLibrary('dart:async');
- late final Procedure asyncStarStreamControllerAdd =
- index.getProcedure('dart:async', '_AsyncStarStreamController', 'add');
-
- late final Procedure asyncStarStreamControllerAddError = index.getProcedure(
- 'dart:async', '_AsyncStarStreamController', 'addError');
-
- late final Procedure asyncStarStreamControllerAddStream = index.getProcedure(
- 'dart:async', '_AsyncStarStreamController', 'addStream');
-
- late final Class asyncStarStreamControllerClass =
- index.getClass('dart:async', '_AsyncStarStreamController');
-
- late final Procedure asyncStarStreamControllerClose =
- index.getProcedure('dart:async', '_AsyncStarStreamController', 'close');
-
- late final Constructor asyncStarStreamControllerDefaultConstructor =
- index.getConstructor('dart:async', '_AsyncStarStreamController', '');
-
- late final Member asyncStarStreamControllerStream =
- index.getMember('dart:async', '_AsyncStarStreamController', 'get:stream');
-
late final Procedure asyncStarMoveNextHelper =
index.getTopLevelProcedure('dart:async', '_asyncStarMoveNextHelper');
- late final Procedure asyncThenWrapperHelperProcedure =
- index.getTopLevelProcedure('dart:async', '_asyncThenWrapperHelper');
-
- late final Procedure awaitHelperProcedure =
- index.getTopLevelProcedure('dart:async', '_awaitHelper');
-
late final Class boolClass = index.getClass('dart:core', 'bool');
late final Class futureImplClass = index.getClass('dart:async', '_Future');
- late final Constructor futureImplConstructor =
- index.getConstructor('dart:async', '_Future', '');
-
- late final Procedure completeOnAsyncReturn =
- index.getTopLevelProcedure('dart:async', '_completeOnAsyncReturn');
-
- late final Procedure completeWithNoFutureOnAsyncReturn = index
- .getTopLevelProcedure('dart:async', '_completeWithNoFutureOnAsyncReturn');
-
- late final Procedure completeOnAsyncError =
- index.getTopLevelProcedure('dart:async', '_completeOnAsyncError');
-
late final Library coreLibrary = index.getLibrary('dart:core');
late final Class doubleClass = index.getClass('dart:core', 'double');
@@ -287,18 +245,6 @@
late final Class symbolClass = index.getClass('dart:core', 'Symbol');
- late final Constructor syncIterableDefaultConstructor =
- index.getConstructor('dart:core', '_SyncIterable', '');
-
- late final Class syncIteratorClass =
- index.getClass('dart:core', '_SyncIterator');
-
- late final Member syncIteratorCurrent =
- index.getMember('dart:core', '_SyncIterator', '_current');
-
- late final Member syncIteratorYieldEachIterable =
- index.getMember('dart:core', '_SyncIterator', '_yieldEachIterable');
-
late final Class typeClass = index.getClass('dart:core', 'Type');
late final Constructor fallThroughErrorUrlAndLineConstructor =
diff --git a/pkg/kernel/lib/target/targets.dart b/pkg/kernel/lib/target/targets.dart
index c466238..477f255 100644
--- a/pkg/kernel/lib/target/targets.dart
+++ b/pkg/kernel/lib/target/targets.dart
@@ -16,13 +16,11 @@
final bool trackWidgetCreation;
final bool enableNullSafety;
final bool supportMirrors;
- final bool compactAsync;
const TargetFlags(
{this.trackWidgetCreation = false,
this.enableNullSafety = false,
- this.supportMirrors = true,
- this.compactAsync = true});
+ this.supportMirrors = true});
@override
bool operator ==(other) {
@@ -30,8 +28,7 @@
return other is TargetFlags &&
trackWidgetCreation == other.trackWidgetCreation &&
enableNullSafety == other.enableNullSafety &&
- supportMirrors == other.supportMirrors &&
- compactAsync == other.compactAsync;
+ supportMirrors == other.supportMirrors;
}
@override
@@ -40,7 +37,6 @@
hash = 0x3fffffff & (hash * 31 + (hash ^ trackWidgetCreation.hashCode));
hash = 0x3fffffff & (hash * 31 + (hash ^ enableNullSafety.hashCode));
hash = 0x3fffffff & (hash * 31 + (hash ^ supportMirrors.hashCode));
- hash = 0x3fffffff & (hash * 31 + (hash ^ compactAsync.hashCode));
return hash;
}
}
diff --git a/pkg/kernel/lib/text/ast_to_text.dart b/pkg/kernel/lib/text/ast_to_text.dart
index d7946d2..9b97a47 100644
--- a/pkg/kernel/lib/text/ast_to_text.dart
+++ b/pkg/kernel/lib/text/ast_to_text.dart
@@ -818,8 +818,6 @@
return 'async';
case AsyncMarker.AsyncStar:
return 'async*';
- case AsyncMarker.SyncYielding:
- return 'yielding';
default:
return '<Invalid async marker: $marker>';
}
@@ -2414,8 +2412,6 @@
writeIndentation();
if (node.isYieldStar) {
writeWord('yield*');
- } else if (node.isNative) {
- writeWord('[yield]');
} else {
writeWord('yield');
}
diff --git a/pkg/kernel/lib/type_checker.dart b/pkg/kernel/lib/type_checker.dart
index 38dec89..6f2a341 100644
--- a/pkg/kernel/lib/type_checker.dart
+++ b/pkg/kernel/lib/type_checker.dart
@@ -363,26 +363,6 @@
case AsyncMarker.AsyncStar:
return null;
- case AsyncMarker.SyncYielding:
- // The SyncStar transform wraps the original function body twice,
- // where the inner most function returns bool.
- TreeNode? parent = function.parent;
- while (parent is! FunctionNode) {
- parent = parent!.parent;
- }
- FunctionNode enclosingFunction = parent;
- if (enclosingFunction.dartAsyncMarker == AsyncMarker.Sync) {
- parent = enclosingFunction.parent;
- while (parent is! FunctionNode) {
- parent = parent!.parent;
- }
- enclosingFunction = parent;
- if (enclosingFunction.dartAsyncMarker == AsyncMarker.SyncStar) {
- return coreTypes.boolLegacyRawType;
- }
- }
- return null;
-
default:
throw 'Unexpected async marker: ${function.asyncMarker}';
}
@@ -405,9 +385,6 @@
}
return const DynamicType();
- case AsyncMarker.SyncYielding:
- return function.returnType;
-
default:
throw 'Unexpected async marker: ${function.asyncMarker}';
}
diff --git a/pkg/kernel/lib/verifier.dart b/pkg/kernel/lib/verifier.dart
index 20c670e..9202afa 100644
--- a/pkg/kernel/lib/verifier.dart
+++ b/pkg/kernel/lib/verifier.dart
@@ -528,7 +528,6 @@
switch (currentAsyncMarker) {
case AsyncMarker.Sync:
case AsyncMarker.Async:
- case AsyncMarker.SyncYielding:
// ok
break;
case AsyncMarker.SyncStar:
@@ -556,7 +555,6 @@
break;
case AsyncMarker.SyncStar:
case AsyncMarker.AsyncStar:
- case AsyncMarker.SyncYielding:
// ok
break;
}
diff --git a/pkg/nnbd_migration/lib/src/edge_builder.dart b/pkg/nnbd_migration/lib/src/edge_builder.dart
index d6bfd32..ba12bca 100644
--- a/pkg/nnbd_migration/lib/src/edge_builder.dart
+++ b/pkg/nnbd_migration/lib/src/edge_builder.dart
@@ -1595,7 +1595,7 @@
@override
DecoratedType? visitPrefixedIdentifier(PrefixedIdentifier node) {
- if (node.prefix.staticElement is ImportElement) {
+ if (node.prefix.staticElement is ImportElement2) {
// TODO(paulberry)
_unimplemented(node, 'PrefixedIdentifier with a prefix');
} else {
diff --git a/pkg/nnbd_migration/lib/src/fix_aggregator.dart b/pkg/nnbd_migration/lib/src/fix_aggregator.dart
index ddb14d6..1f1a071 100644
--- a/pkg/nnbd_migration/lib/src/fix_aggregator.dart
+++ b/pkg/nnbd_migration/lib/src/fix_aggregator.dart
@@ -60,11 +60,11 @@
FixAggregator._(this.planner, this._changes, this._warnOnWeakCode,
CompilationUnitElement compilationUnitElement) {
- for (var importElement in compilationUnitElement.library.imports) {
+ for (var importElement in compilationUnitElement.library.imports2) {
// TODO(paulberry): the `??=` should ensure that if there are two imports,
// one prefixed and one not, we prefer the prefix. Test this.
_importPrefixes[importElement.importedLibrary] ??=
- importElement.prefix?.name;
+ importElement.prefix?.element.name;
}
}
diff --git a/pkg/vm/lib/kernel_front_end.dart b/pkg/vm/lib/kernel_front_end.dart
index 6e70384..7ffdc7f 100644
--- a/pkg/vm/lib/kernel_front_end.dart
+++ b/pkg/vm/lib/kernel_front_end.dart
@@ -81,8 +81,7 @@
help: 'Whether dart:mirrors is supported. By default dart:mirrors is '
'supported when --aot and --minimal-kernel are not used.',
defaultsTo: null);
- args.addFlag('compact-async',
- help: 'Enable new compact async/await implementation.', defaultsTo: true);
+ args.addFlag('compact-async', help: 'Obsolete, ignored.', hide: true);
args.addOption('depfile', help: 'Path to output Ninja depfile');
args.addOption('from-dill',
help: 'Read existing dill file instead of compiling from sources',
@@ -203,7 +202,6 @@
final String? manifestFilename = options['manifest'];
final String? dataDir = options['component-name'] ?? options['data-dir'];
final bool? supportMirrors = options['support-mirrors'];
- final bool compactAsync = options['compact-async'];
final bool minimalKernel = options['minimal-kernel'];
final bool treeShakeWriteOnlyFields = options['tree-shake-write-only-fields'];
@@ -287,8 +285,7 @@
compilerOptions.target = createFrontEndTarget(targetName,
trackWidgetCreation: options['track-widget-creation'],
nullSafety: compilerOptions.nnbdMode == NnbdMode.Strong,
- supportMirrors: supportMirrors ?? !(aot || minimalKernel),
- compactAsync: compactAsync);
+ supportMirrors: supportMirrors ?? !(aot || minimalKernel));
if (compilerOptions.target == null) {
print('Failed to create front-end target $targetName.');
return badUsageExitCode;
@@ -617,16 +614,14 @@
Target? createFrontEndTarget(String targetName,
{bool trackWidgetCreation = false,
bool nullSafety = false,
- bool supportMirrors = true,
- bool compactAsync = true}) {
+ bool supportMirrors = true}) {
// Make sure VM-specific targets are available.
installAdditionalTargets();
final TargetFlags targetFlags = new TargetFlags(
trackWidgetCreation: trackWidgetCreation,
enableNullSafety: nullSafety,
- supportMirrors: supportMirrors,
- compactAsync: compactAsync);
+ supportMirrors: supportMirrors);
return getTarget(targetName, targetFlags);
}
diff --git a/pkg/vm/lib/target/vm.dart b/pkg/vm/lib/target/vm.dart
index b706bd5..74c4842 100644
--- a/pkg/vm/lib/target/vm.dart
+++ b/pkg/vm/lib/target/vm.dart
@@ -9,11 +9,8 @@
import 'package:kernel/reference_from_index.dart';
import 'package:kernel/target/changed_structure_notifier.dart';
import 'package:kernel/target/targets.dart';
-import 'package:kernel/type_environment.dart';
import '../transformations/call_site_annotator.dart' as callSiteAnnotator;
-import '../transformations/continuation.dart' as transformAsync
- show transformLibraries, transformProcedure;
import '../transformations/lowering.dart' as lowering
show transformLibraries, transformProcedure;
import '../transformations/mixin_full_resolution.dart' as transformMixins
@@ -183,15 +180,9 @@
logger?.call("Transformed ffi annotations");
}
- // TODO(kmillikin): Make this run on a per-method basis.
bool productMode = environmentDefines!["dart.vm.product"] == "true";
- transformAsync.transformLibraries(
- new TypeEnvironment(coreTypes, hierarchy), libraries,
- productMode: productMode, desugarAsync: !flags.compactAsync);
- logger?.call("Transformed async methods");
-
- lowering.transformLibraries(
- libraries, coreTypes, hierarchy, flags.enableNullSafety);
+ lowering.transformLibraries(libraries, coreTypes, hierarchy,
+ nullSafety: flags.enableNullSafety, productMode: productMode);
logger?.call("Lowering transformations performed");
callSiteAnnotator.transformLibraries(
@@ -207,13 +198,8 @@
Map<String, String>? environmentDefines,
{void Function(String msg)? logger}) {
bool productMode = environmentDefines!["dart.vm.product"] == "true";
- transformAsync.transformProcedure(
- new TypeEnvironment(coreTypes, hierarchy), procedure,
- productMode: productMode, desugarAsync: !flags.compactAsync);
- logger?.call("Transformed async functions");
-
- lowering.transformProcedure(
- procedure, coreTypes, hierarchy, flags.enableNullSafety);
+ lowering.transformProcedure(procedure, coreTypes, hierarchy,
+ nullSafety: flags.enableNullSafety, productMode: productMode);
logger?.call("Lowering transformations performed");
}
diff --git a/pkg/vm/lib/transformations/async.dart b/pkg/vm/lib/transformations/async.dart
deleted file mode 100644
index 6a6628b..0000000
--- a/pkg/vm/lib/transformations/async.dart
+++ /dev/null
@@ -1,672 +0,0 @@
-// Copyright (c) 2016, 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:kernel/kernel.dart';
-import 'package:kernel/type_environment.dart';
-import 'continuation.dart';
-
-/// A transformer that introduces temporary variables for all subexpressions
-/// that are alive across yield points (AwaitExpression).
-///
-/// The transformer is invoked by passing [rewrite] a top-level expression.
-///
-/// All intermediate values that are possible live across an await are named in
-/// local variables.
-///
-/// Await expressions are translated into a call to a helper function and a
-/// native yield.
-class ExpressionLifter extends Transformer {
- final AsyncRewriterBase continuationRewriter;
-
- /// Have we seen an await to the right in the expression tree.
- ///
- /// Subexpressions are visited right-to-left in the reverse of evaluation
- /// order.
- ///
- /// On entry to an expression's visit method, [seenAwait] indicates whether a
- /// sibling to the right contains an await. If so the expression will be
- /// named in a temporary variable because it is potentially live across an
- /// await.
- ///
- /// On exit from an expression's visit method, [seenAwait] indicates whether
- /// the expression itself or a sibling to the right contains an await.
- bool seenAwait = false;
-
- /// The (reverse order) sequence of statements that have been emitted.
- ///
- /// Transformation of an expression produces a transformed expression and a
- /// sequence of statements which are assignments to local variables, calls to
- /// helper functions, and yield points. Only the yield points need to be a
- /// statements, and they are statements so an implementation does not have to
- /// handle unnamed expression intermediate live across yield points.
- ///
- /// The visit methods return the transformed expression and build a sequence
- /// of statements by emitting statements into this list. This list is built
- /// in reverse because children are visited right-to-left.
- ///
- /// If an expression should be named it is named before visiting its children
- /// so the naming assignment appears in the list before all statements
- /// implementing the translation of the children.
- ///
- /// Children that are conditionally evaluated, such as some parts of logical
- /// and conditional expressions, must be delimited so that they do not emit
- /// unguarded statements into [statements]. This is implemented by setting
- /// [statements] to a fresh empty list before transforming those children.
- List<Statement> statements = <Statement>[];
-
- /// The number of currently live named intermediate values.
- ///
- /// This index is used to allocate names to temporary values. Because
- /// children are visited right-to-left, names are assigned in reverse order of
- /// index.
- ///
- /// When an assignment is emitted into [statements] to name an expression
- /// before visiting its children, the index is not immediately reserved
- /// because a child can freely use the same name as its parent. In practice,
- /// this will be the rightmost named child.
- ///
- /// After visiting the children of a named expression, [nameIndex] is set to
- /// indicate one more live value (the value of the expression) than before
- /// visiting the expression.
- ///
- /// After visiting the children of an expression that is not named,
- /// [nameIndex] may still account for names of subexpressions.
- int nameIndex = 0;
-
- final VariableDeclaration asyncResult =
- new VariableDeclaration(':result_or_exception');
- final List<VariableDeclaration> variables = <VariableDeclaration>[];
-
- ExpressionLifter(this.continuationRewriter);
-
- StatefulStaticTypeContext get _staticTypeContext =>
- continuationRewriter.staticTypeContext;
-
- Block blockOf(List<Statement> statements) {
- return new Block(statements.reversed.toList());
- }
-
- /// Rewrite a toplevel expression (toplevel wrt. a statement).
- ///
- /// Rewriting an expression produces a sequence of statements and an
- /// expression. The sequence of statements are added to the given list. Pass
- /// an empty list if the rewritten expression should be delimited from the
- /// surrounding context.
- Expression rewrite(Expression expression, List<Statement> outer) {
- assert(statements.isEmpty);
- var saved = seenAwait;
- seenAwait = false;
- Expression result = transform(expression);
- outer.addAll(statements.reversed);
- statements.clear();
- seenAwait = seenAwait || saved;
- return result;
- }
-
- // Perform an action with a given list of statements so that it cannot emit
- // statements into the 'outer' list.
- Expression delimit(Expression action(), List<Statement> inner) {
- var outer = statements;
- statements = inner;
- Expression result = action();
- statements = outer;
- return result;
- }
-
- // Wraps VariableGet in an unsafeCast if `type` isn't dynamic.
- Expression unsafeCastVariableGet(
- VariableDeclaration variable, DartType type) {
- if (type != const DynamicType()) {
- return StaticInvocation(
- continuationRewriter.helper.unsafeCast,
- Arguments(<Expression>[VariableGet(variable)],
- types: <DartType>[type]));
- }
- return VariableGet(variable);
- }
-
- // Name an expression by emitting an assignment to a temporary variable.
- Expression name(Expression expr) {
- DartType type = expr.getStaticType(_staticTypeContext);
- VariableDeclaration temp = allocateTemporary(nameIndex, type);
- statements.add(ExpressionStatement(VariableSet(temp, expr)));
- // Wrap in unsafeCast to make sure we pass type information even if we later
- // have to re-type the temporary variable to dynamic.
- return unsafeCastVariableGet(temp, type);
- }
-
- VariableDeclaration allocateTemporary(int index,
- [DartType type = const DynamicType()]) {
- if (variables.length > index) {
- // Re-type temporary to dynamic if we detect reuse with different type.
- // Note: We should make sure all uses use `unsafeCast(...)` to pass their
- // type information on, as that is lost otherwise.
- if (variables[index].type != const DynamicType() &&
- variables[index].type != type) {
- variables[index].type = const DynamicType();
- }
- return variables[index];
- }
- for (var i = variables.length; i <= index; i++) {
- variables.add(VariableDeclaration(":async_temporary_${i}", type: type));
- }
- return variables[index];
- }
-
- // Simple literals. These are pure expressions so they can be evaluated after
- // an await to their right.
- @override
- TreeNode visitSymbolLiteral(SymbolLiteral expr) => expr;
- @override
- TreeNode visitTypeLiteral(TypeLiteral expr) => expr;
- @override
- TreeNode visitThisExpression(ThisExpression expr) => expr;
- @override
- TreeNode visitStringLiteral(StringLiteral expr) => expr;
- @override
- TreeNode visitIntLiteral(IntLiteral expr) => expr;
- @override
- TreeNode visitDoubleLiteral(DoubleLiteral expr) => expr;
- @override
- TreeNode visitBoolLiteral(BoolLiteral expr) => expr;
- @override
- TreeNode visitNullLiteral(NullLiteral expr) => expr;
-
- // Nullary expressions with effects.
- Expression nullary(Expression expr) {
- if (seenAwait) {
- expr = name(expr);
- ++nameIndex;
- }
- return expr;
- }
-
- @override
- TreeNode visitSuperPropertyGet(SuperPropertyGet expr) => nullary(expr);
- @override
- TreeNode visitStaticGet(StaticGet expr) => nullary(expr);
- @override
- TreeNode visitStaticTearOff(StaticTearOff expr) => nullary(expr);
- @override
- TreeNode visitRethrow(Rethrow expr) => nullary(expr);
-
- // Getting a final or const variable is not an effect so it can be evaluated
- // after an await to its right.
- @override
- TreeNode visitVariableGet(VariableGet expr) {
- Expression result = expr;
- if (seenAwait && !expr.variable.isFinal && !expr.variable.isConst) {
- result = name(expr);
- ++nameIndex;
- }
- return result;
- }
-
- // Transform an expression given an action to transform the children. For
- // this purposes of the await transformer the children should generally be
- // translated from right to left, in the reverse of evaluation order.
- Expression transformTreeNode(Expression expr, void action()) {
- var shouldName = seenAwait;
-
- // 1. If there is an await in a sibling to the right, emit an assignment to
- // a temporary variable before transforming the children.
- var result = shouldName ? name(expr) : expr;
-
- // 2. Remember the number of live temporaries before transforming the
- // children.
- var index = nameIndex;
-
- // 3. Transform the children. Initially they do not have an await in a
- // sibling to their right.
- seenAwait = false;
- action();
-
- // 4. If the expression was named then the variables used for children are
- // no longer live but the variable used for the expression is.
- // On the other hand, a sibling to the left (yet to be processed) cannot
- // reuse any of the variables used here, as the assignments in the children
- // (here) would overwrite assignments in the siblings to the left,
- // possibly before the use of the overwritten values.
- if (shouldName) {
- if (index + 1 > nameIndex) nameIndex = index + 1;
- seenAwait = true;
- }
- return result;
- }
-
- // Unary expressions.
- Expression unary(Expression expr) {
- return transformTreeNode(expr, () {
- expr.transformChildren(this);
- });
- }
-
- @override
- TreeNode visitInvalidExpression(InvalidExpression expr) => unary(expr);
- @override
- TreeNode visitVariableSet(VariableSet expr) => unary(expr);
- @override
- TreeNode visitInstanceGet(InstanceGet expr) => unary(expr);
- @override
- TreeNode visitDynamicGet(DynamicGet expr) => unary(expr);
- @override
- TreeNode visitInstanceTearOff(InstanceTearOff expr) => unary(expr);
- @override
- TreeNode visitFunctionTearOff(FunctionTearOff expr) => unary(expr);
- @override
- TreeNode visitSuperPropertySet(SuperPropertySet expr) => unary(expr);
- @override
- TreeNode visitStaticSet(StaticSet expr) => unary(expr);
- @override
- TreeNode visitNot(Not expr) => unary(expr);
- @override
- TreeNode visitIsExpression(IsExpression expr) => unary(expr);
- @override
- TreeNode visitAsExpression(AsExpression expr) => unary(expr);
- @override
- TreeNode visitThrow(Throw expr) => unary(expr);
-
- @override
- TreeNode visitInstanceSet(InstanceSet expr) {
- return transformTreeNode(expr, () {
- expr.value = transform(expr.value)..parent = expr;
- expr.receiver = transform(expr.receiver)..parent = expr;
- });
- }
-
- @override
- TreeNode visitDynamicSet(DynamicSet expr) {
- return transformTreeNode(expr, () {
- expr.value = transform(expr.value)..parent = expr;
- expr.receiver = transform(expr.receiver)..parent = expr;
- });
- }
-
- @override
- TreeNode visitArguments(Arguments args) {
- for (var named in args.named.reversed) {
- named.value = transform(named.value)..parent = named;
- }
- var positional = args.positional;
- for (var i = positional.length - 1; i >= 0; --i) {
- positional[i] = transform(positional[i])..parent = args;
- }
- // Returns the arguments, which is assumed at the call sites because they do
- // not replace the arguments or set parent pointers.
- return args;
- }
-
- @override
- TreeNode visitInstanceInvocation(InstanceInvocation expr) {
- return transformTreeNode(expr, () {
- visitArguments(expr.arguments);
- expr.receiver = transform(expr.receiver)..parent = expr;
- });
- }
-
- @override
- TreeNode visitLocalFunctionInvocation(LocalFunctionInvocation expr) {
- return transformTreeNode(expr, () {
- visitArguments(expr.arguments);
- });
- }
-
- @override
- TreeNode visitDynamicInvocation(DynamicInvocation expr) {
- return transformTreeNode(expr, () {
- visitArguments(expr.arguments);
- expr.receiver = transform(expr.receiver)..parent = expr;
- });
- }
-
- @override
- TreeNode visitFunctionInvocation(FunctionInvocation expr) {
- return transformTreeNode(expr, () {
- visitArguments(expr.arguments);
- expr.receiver = transform(expr.receiver)..parent = expr;
- });
- }
-
- @override
- TreeNode visitEqualsNull(EqualsNull expr) => unary(expr);
-
- @override
- TreeNode visitEqualsCall(EqualsCall expr) {
- return transformTreeNode(expr, () {
- expr.right = transform(expr.right)..parent = expr;
- expr.left = transform(expr.left)..parent = expr;
- });
- }
-
- @override
- TreeNode visitSuperMethodInvocation(SuperMethodInvocation expr) {
- return transformTreeNode(expr, () {
- visitArguments(expr.arguments);
- });
- }
-
- @override
- TreeNode visitStaticInvocation(StaticInvocation expr) {
- return transformTreeNode(expr, () {
- visitArguments(expr.arguments);
- });
- }
-
- @override
- TreeNode visitConstructorInvocation(ConstructorInvocation expr) {
- return transformTreeNode(expr, () {
- visitArguments(expr.arguments);
- });
- }
-
- @override
- TreeNode visitStringConcatenation(StringConcatenation expr) {
- return transformTreeNode(expr, () {
- var expressions = expr.expressions;
- for (var i = expressions.length - 1; i >= 0; --i) {
- expressions[i] = transform(expressions[i])..parent = expr;
- }
- });
- }
-
- @override
- TreeNode visitListLiteral(ListLiteral expr) {
- return transformTreeNode(expr, () {
- var expressions = expr.expressions;
- for (var i = expressions.length - 1; i >= 0; --i) {
- expressions[i] = transform(expr.expressions[i])..parent = expr;
- }
- });
- }
-
- @override
- TreeNode visitMapLiteral(MapLiteral expr) {
- return transformTreeNode(expr, () {
- for (var entry in expr.entries.reversed) {
- entry.value = transform(entry.value)..parent = entry;
- entry.key = transform(entry.key)..parent = entry;
- }
- });
- }
-
- // Control flow.
- @override
- TreeNode visitLogicalExpression(LogicalExpression expr) {
- var shouldName = seenAwait;
-
- // Right is delimited because it is conditionally evaluated.
- var rightStatements = <Statement>[];
- seenAwait = false;
- expr.right = delimit(() => transform(expr.right), rightStatements)
- ..parent = expr;
- var rightAwait = seenAwait;
-
- if (rightStatements.isEmpty) {
- // Easy case: right did not emit any statements.
- seenAwait = shouldName;
- return transformTreeNode(expr, () {
- expr.left = transform(expr.left)..parent = expr;
- seenAwait = seenAwait || rightAwait;
- });
- }
-
- // If right has emitted statements we will produce a temporary t and emit
- // for && (there is an analogous case for ||):
- //
- // t = [left] == true;
- // if (t) {
- // t = [right] == true;
- // }
-
- // Recall that statements are emitted in reverse order, so first emit the if
- // statement, then the assignment of [left] == true, and then translate left
- // so any statements it emits occur after in the accumulated list (that is,
- // so they occur before in the corresponding block).
- var rightBody = blockOf(rightStatements);
- final type = _staticTypeContext.typeEnvironment.coreTypes
- .boolRawType(_staticTypeContext.nonNullable);
- final result = allocateTemporary(nameIndex, type);
- final objectEquals = continuationRewriter.helper.coreTypes.objectEquals;
- rightBody.addStatement(new ExpressionStatement(new VariableSet(
- result,
- new EqualsCall(expr.right, new BoolLiteral(true),
- interfaceTarget: objectEquals,
- functionType: objectEquals.getterType as FunctionType))));
- Statement then;
- Statement? otherwise;
- if (expr.operatorEnum == LogicalExpressionOperator.AND) {
- then = rightBody;
- otherwise = null;
- } else {
- then = new EmptyStatement();
- otherwise = rightBody;
- }
- statements.add(
- new IfStatement(unsafeCastVariableGet(result, type), then, otherwise));
-
- final test = new EqualsCall(expr.left, new BoolLiteral(true),
- interfaceTarget: objectEquals,
- functionType: objectEquals.getterType as FunctionType);
- statements.add(new ExpressionStatement(new VariableSet(result, test)));
-
- seenAwait = false;
- test.left = transform(test.left)..parent = test;
-
- ++nameIndex;
- seenAwait = seenAwait || rightAwait;
- return unsafeCastVariableGet(result, type);
- }
-
- @override
- TreeNode visitConditionalExpression(ConditionalExpression expr) {
- // Then and otherwise are delimited because they are conditionally
- // evaluated.
- var shouldName = seenAwait;
-
- final savedNameIndex = nameIndex;
-
- var thenStatements = <Statement>[];
- seenAwait = false;
- expr.then = delimit(() => transform(expr.then), thenStatements)
- ..parent = expr;
- var thenAwait = seenAwait;
-
- final thenNameIndex = nameIndex;
- nameIndex = savedNameIndex;
-
- var otherwiseStatements = <Statement>[];
- seenAwait = false;
- expr.otherwise =
- delimit(() => transform(expr.otherwise), otherwiseStatements)
- ..parent = expr;
- var otherwiseAwait = seenAwait;
-
- // Only one side of this branch will get executed at a time, so just make
- // sure we have enough temps for either, not both at the same time.
- if (thenNameIndex > nameIndex) {
- nameIndex = thenNameIndex;
- }
-
- if (thenStatements.isEmpty && otherwiseStatements.isEmpty) {
- // Easy case: neither then nor otherwise emitted any statements.
- seenAwait = shouldName;
- return transformTreeNode(expr, () {
- expr.condition = transform(expr.condition)..parent = expr;
- seenAwait = seenAwait || thenAwait || otherwiseAwait;
- });
- }
-
- // If `then` or `otherwise` has emitted statements we will produce a
- // temporary t and emit:
- //
- // if ([condition]) {
- // t = [left];
- // } else {
- // t = [right];
- // }
- final result = allocateTemporary(nameIndex, expr.staticType);
- var thenBody = blockOf(thenStatements);
- var otherwiseBody = blockOf(otherwiseStatements);
- thenBody.addStatement(
- new ExpressionStatement(new VariableSet(result, expr.then)));
- otherwiseBody.addStatement(
- new ExpressionStatement(new VariableSet(result, expr.otherwise)));
- var branch = new IfStatement(expr.condition, thenBody, otherwiseBody);
- statements.add(branch);
-
- seenAwait = false;
- branch.condition = transform(branch.condition)..parent = branch;
-
- ++nameIndex;
- seenAwait = seenAwait || thenAwait || otherwiseAwait;
- return unsafeCastVariableGet(result, expr.staticType);
- }
-
- // Others.
- @override
- TreeNode visitAwaitExpression(AwaitExpression expr) {
- final R = continuationRewriter;
- var shouldName = seenAwait;
- var type = expr.getStaticType(_staticTypeContext);
- Expression result = unsafeCastVariableGet(asyncResult, type);
-
- // The statements are in reverse order, so name the result first if
- // necessary and then add the two other statements in reverse.
- if (shouldName) result = name(result);
- Arguments arguments = new Arguments(<Expression>[
- expr.operand,
- new VariableGet(R.thenContinuationVariable),
- new VariableGet(R.catchErrorContinuationVariable),
- ]);
-
- // We are building
- //
- // [yield] (let _ = _awaitHelper(...) in null)
- //
- // to ensure that :await_jump_var and :await_jump_ctx are updated
- // before _awaitHelper is invoked (see BuildYieldStatement in
- // StreamingFlowGraphBuilder for details of how [yield] is translated to
- // IL). This guarantees that recursive invocation of the current function
- // would continue from the correct "jump" position. Recursive invocations
- // arise if future we are awaiting completes synchronously. Builtin Future
- // implementation don't complete synchronously, but Flutter's
- // SynchronousFuture do (see bug http://dartbug.com/32098 for more details).
- statements.add(R.createContinuationPoint(new Let(
- new VariableDeclaration(null,
- initializer: new StaticInvocation(R.helper.awaitHelper, arguments)
- ..fileOffset = expr.fileOffset),
- new NullLiteral()))
- ..fileOffset = expr.fileOffset);
-
- seenAwait = false;
- var index = nameIndex;
- arguments.positional[0] = transform(expr.operand)..parent = arguments;
-
- if (shouldName && index + 1 > nameIndex) nameIndex = index + 1;
- seenAwait = true;
- return result;
- }
-
- @override
- TreeNode visitFunctionExpression(FunctionExpression expr) {
- expr.transformChildren(this);
- return expr;
- }
-
- @override
- TreeNode visitLet(Let expr) {
- var body = transform(expr.body);
-
- VariableDeclaration variable = expr.variable;
- if (seenAwait) {
- // There is an await in the body of `let var x = initializer in body` or
- // to its right. We will produce the sequence of statements:
- //
- // <initializer's statements>
- // var x = <initializer's value>
- // <body's statements>
- //
- // and return the body's value.
- //
- // So x is in scope for all the body's statements and the body's value.
- // This has the unpleasant consequence that all let-bound variables with
- // await in the let's body will end up hoisted out of the expression and
- // allocated to the context in the VM, even if they have no uses
- // (`let _ = e0 in e1` can be used for sequencing of `e0` and `e1`).
- statements.add(variable);
- var index = nameIndex;
- seenAwait = false;
- variable.initializer = transform(variable.initializer!)
- ..parent = variable;
- // Temporaries used in the initializer or the body are not live but the
- // temporary used for the body is.
- if (index + 1 > nameIndex) nameIndex = index + 1;
- seenAwait = true;
- return body;
- } else {
- // The body in `let x = initializer in body` did not contain an await. We
- // can leave a let expression.
- return transformTreeNode(expr, () {
- // The body has already been translated.
- expr.body = body..parent = expr;
- variable.initializer = transform(variable.initializer!)
- ..parent = variable;
- });
- }
- }
-
- @override
- TreeNode visitFunctionNode(FunctionNode node) {
- var nestedRewriter = new RecursiveContinuationRewriter(
- continuationRewriter.helper,
- _staticTypeContext,
- continuationRewriter.desugarAsync);
- return nestedRewriter.transform(node);
- }
-
- @override
- TreeNode visitBlockExpression(BlockExpression expr) {
- return transformTreeNode(expr, () {
- expr.value = transform(expr.value)..parent = expr;
- List<Statement> body = <Statement>[];
- for (Statement stmt in expr.body.statements.reversed) {
- Statement? translation = _rewriteStatement(stmt);
- if (translation != null) body.add(translation);
- }
- expr.body = new Block(body.reversed.toList())..parent = expr;
- });
- }
-
- Statement? _rewriteStatement(Statement stmt) {
- // This method translates a statement nested in an expression (e.g., in a
- // block expression). It produces a translated statement, a list of
- // statements which are side effects necessary for any await, and a flag
- // indicating whether there was an await in the statement or to its right.
- // The translated statement can be null in the case where there was already
- // an await to the right.
-
- // The translation is accumulating two lists of statements, an inner list
- // which is a reversed list of effects needed for the current expression and
- // an outer list which represents the block containing the current
- // statement. We need to preserve both of those from side effects.
- List<Statement> savedInner = statements;
- List<Statement> savedOuter = continuationRewriter.statements;
- statements = <Statement>[];
- continuationRewriter.statements = <Statement>[];
- continuationRewriter.transform(stmt);
-
- List<Statement> results = continuationRewriter.statements;
- statements = savedInner;
- continuationRewriter.statements = savedOuter;
- if (!seenAwait && results.length == 1) return results.first;
- statements.addAll(results.reversed);
- return null;
- }
-
- @override
- TreeNode defaultStatement(Statement stmt) {
- throw new UnsupportedError(
- "Use _rewriteStatement to transform statement: ${stmt}");
- }
-}
diff --git a/pkg/vm/lib/transformations/continuation.dart b/pkg/vm/lib/transformations/continuation.dart
deleted file mode 100644
index d23954f..0000000
--- a/pkg/vm/lib/transformations/continuation.dart
+++ /dev/null
@@ -1,1667 +0,0 @@
-// Copyright (c) 2016, 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 'dart:math' as math;
-
-import 'package:kernel/ast.dart';
-import 'package:kernel/core_types.dart';
-import 'package:kernel/type_algebra.dart' show Substitution;
-import 'package:kernel/type_environment.dart';
-
-import 'async.dart';
-
-class ContinuationVariables {
- static const awaitJumpVar = ':await_jump_var';
- static const asyncFuture = ':async_future';
- static const isSync = ":is_sync";
- static const awaitContextVar = ':await_ctx_var';
- static const asyncCompleter = ':async_completer';
- static const asyncOp = ':async_op';
- static const asyncOpThen = ':async_op_then';
- static const asyncOpError = ':async_op_error';
- static const controller = ':controller';
- static const controllerStreamVar = ':controller_stream';
- static const forIterator = ':for-iterator';
- static const returnValue = ':return_value';
- static const stream = ':stream';
- static const syncForIterator = ':sync-for-iterator';
- static const syncOpGen = ':sync_op_gen';
- static const syncOp = ':sync_op';
- // sync_op(..) parameter.
- static const iteratorParam = ':iterator';
- // (a)sync_op(..) parameters.
- static const exceptionParam = ':exception';
- static const stackTraceParam = ':stack_trace';
-
- static const savedTryContextVarPrefix = ':saved_try_context_var';
- static const exceptionVarPrefix = ':exception';
- static const stackTraceVarPrefix = ':stack_trace';
-
- static String savedTryContextVar(int depth) =>
- '$savedTryContextVarPrefix$depth';
- static String exceptionVar(int depth) => '$exceptionVarPrefix$depth';
- static String stackTraceVar(int depth) => '$stackTraceVarPrefix$depth';
-}
-
-void transformLibraries(
- TypeEnvironment typeEnvironment, List<Library> libraries,
- {required bool productMode, required bool desugarAsync}) {
- var helper =
- new HelperNodes.fromCoreTypes(typeEnvironment.coreTypes, productMode);
- var rewriter = new RecursiveContinuationRewriter(helper,
- new StatefulStaticTypeContext.stacked(typeEnvironment), desugarAsync);
- for (var library in libraries) {
- rewriter.rewriteLibrary(library);
- }
-}
-
-Component transformComponent(
- TypeEnvironment typeEnvironment, Component component,
- {required bool productMode, required bool desugarAsync}) {
- var helper =
- new HelperNodes.fromCoreTypes(typeEnvironment.coreTypes, productMode);
- var rewriter = new RecursiveContinuationRewriter(helper,
- new StatefulStaticTypeContext.stacked(typeEnvironment), desugarAsync);
- return rewriter.rewriteComponent(component);
-}
-
-Procedure transformProcedure(
- TypeEnvironment typeEnvironment, Procedure procedure,
- {required bool productMode, required bool desugarAsync}) {
- var helper =
- new HelperNodes.fromCoreTypes(typeEnvironment.coreTypes, productMode);
- var rewriter = new RecursiveContinuationRewriter(helper,
- new StatefulStaticTypeContext.stacked(typeEnvironment), desugarAsync);
- return rewriter.transform(procedure);
-}
-
-class RecursiveContinuationRewriter extends RemovingTransformer {
- final HelperNodes helper;
-
- final VariableDeclaration awaitJumpVariable = new VariableDeclaration(
- ContinuationVariables.awaitJumpVar,
- initializer: new IntLiteral(0));
- final VariableDeclaration awaitContextVariable =
- new VariableDeclaration(ContinuationVariables.awaitContextVar);
-
- StatefulStaticTypeContext staticTypeContext;
- final bool desugarAsync;
- final bool desugarAwaitFor;
-
- RecursiveContinuationRewriter(
- this.helper, this.staticTypeContext, this.desugarAsync,
- {this.desugarAwaitFor = false});
-
- Component rewriteComponent(Component node) {
- return transform(node);
- }
-
- Library rewriteLibrary(Library node) {
- return transform(node);
- }
-
- @override
- TreeNode visitField(Field node, TreeNode? removalSentinel) {
- staticTypeContext.enterMember(node);
- final result = super.visitField(node, removalSentinel);
- staticTypeContext.leaveMember(node);
- return result;
- }
-
- @override
- TreeNode visitConstructor(Constructor node, TreeNode? removalSentinel) {
- staticTypeContext.enterMember(node);
- final result = super.visitConstructor(node, removalSentinel);
- staticTypeContext.leaveMember(node);
- return result;
- }
-
- @override
- TreeNode visitProcedure(Procedure node, TreeNode? removalSentinel) {
- staticTypeContext.enterMember(node);
- final result =
- node.isAbstract ? node : super.visitProcedure(node, removalSentinel);
- staticTypeContext.leaveMember(node);
- return result;
- }
-
- @override
- TreeNode visitLibrary(Library node, TreeNode? removalSentinel) {
- staticTypeContext.enterLibrary(node);
- Library result = super.visitLibrary(node, removalSentinel) as Library;
- staticTypeContext.leaveLibrary(node);
- return result;
- }
-
- @override
- TreeNode visitFunctionNode(FunctionNode node, TreeNode? removalSentinel) {
- switch (node.asyncMarker) {
- case AsyncMarker.Sync:
- case AsyncMarker.SyncYielding:
- node.transformOrRemoveChildren(new RecursiveContinuationRewriter(
- helper, staticTypeContext, desugarAsync));
- return node;
- case AsyncMarker.SyncStar:
- if (desugarAsync) {
- return new SyncStarFunctionRewriter(
- helper, node, staticTypeContext, desugarAsync)
- .rewrite();
- } else {
- node.transformOrRemoveChildren(new RecursiveContinuationRewriter(
- helper, staticTypeContext, desugarAsync));
- return node;
- }
- case AsyncMarker.Async:
- if (desugarAsync) {
- return new AsyncFunctionRewriter(
- helper, node, staticTypeContext, desugarAsync)
- .rewrite();
- } else {
- node.transformOrRemoveChildren(new RecursiveContinuationRewriter(
- helper, staticTypeContext, desugarAsync,
- desugarAwaitFor: true));
- return node;
- }
- case AsyncMarker.AsyncStar:
- if (desugarAsync) {
- return new AsyncStarFunctionRewriter(
- helper, node, staticTypeContext, desugarAsync)
- .rewrite();
- } else {
- node.transformOrRemoveChildren(new RecursiveContinuationRewriter(
- helper, staticTypeContext, desugarAsync,
- desugarAwaitFor: true));
- return node;
- }
- }
- }
-
- @override
- TreeNode visitForInStatement(ForInStatement stmt, TreeNode? removalSentinel) {
- if (stmt.isAsync) {
- if (!desugarAwaitFor) {
- return super.visitForInStatement(stmt, removalSentinel);
- }
- // Transform
- //
- // await for (T variable in <stream-expression>) { ... }
- //
- // To (in product mode):
- //
- // {
- // :stream = <stream-expression>;
- // _StreamIterator<T> :for-iterator = new _StreamIterator<T>(:stream);
- // try {
- // while (await :for-iterator.moveNext()) {
- // T <variable> = :for-iterator.current;
- // ...
- // }
- // } finally {
- // if (:for-iterator._subscription != null)
- // await :for-iterator.cancel();
- // }
- // }
- //
- // Or (in non-product mode):
- //
- // {
- // :stream = <stream-expression>;
- // _StreamIterator<T> :for-iterator = new _StreamIterator<T>(:stream);
- // try {
- // while (let _ = _asyncStarMoveNextHelper(:stream) in
- // await :for-iterator.moveNext()) {
- // T <variable> = :for-iterator.current;
- // ...
- // }
- // } finally {
- // if (:for-iterator._subscription != null)
- // await :for-iterator.cancel();
- // }
- // }
- var valueVariable = stmt.variable;
-
- var streamVariable = new VariableDeclaration(ContinuationVariables.stream,
- initializer: stmt.iterable,
- type: stmt.iterable.getStaticType(staticTypeContext));
-
- final streamIteratorType = new InterfaceType(helper.streamIteratorClass,
- staticTypeContext.nullable, [valueVariable.type]);
- var forIteratorVariable = VariableDeclaration(
- ContinuationVariables.forIterator,
- initializer: new ConstructorInvocation(
- helper.streamIteratorConstructor,
- new Arguments(<Expression>[new VariableGet(streamVariable)],
- types: [valueVariable.type])),
- type: streamIteratorType);
-
- // await :for-iterator.moveNext()
- var condition = new AwaitExpression(new InstanceInvocation(
- InstanceAccessKind.Instance,
- VariableGet(forIteratorVariable),
- helper.streamIteratorMoveNext.name,
- new Arguments([]),
- interfaceTarget: helper.streamIteratorMoveNext,
- functionType:
- helper.streamIteratorMoveNext.getterType as FunctionType))
- ..fileOffset = stmt.fileOffset;
-
- Expression whileCondition;
- if (helper.productMode) {
- whileCondition = condition;
- } else {
- // _asyncStarMoveNextHelper(:stream)
- var asyncStarMoveNextCall = new StaticInvocation(
- helper.asyncStarMoveNextHelper,
- new Arguments([new VariableGet(streamVariable)]))
- ..fileOffset = stmt.fileOffset;
-
- // let _ = asyncStarMoveNextCall in (condition)
- whileCondition = new Let(
- new VariableDeclaration(null, initializer: asyncStarMoveNextCall),
- condition);
- }
-
- // T <variable> = :for-iterator.current;
- valueVariable.initializer = new InstanceGet(InstanceAccessKind.Instance,
- VariableGet(forIteratorVariable), helper.streamIteratorCurrent.name,
- interfaceTarget: helper.streamIteratorCurrent,
- resultType: valueVariable.type)
- ..fileOffset = stmt.bodyOffset;
- valueVariable.initializer!.parent = valueVariable;
-
- var whileBody = new Block(<Statement>[valueVariable, stmt.body]);
- var tryBody = new WhileStatement(whileCondition, whileBody);
-
- // if (:for-iterator._subscription != null) await :for-iterator.cancel();
- final DartType subscriptionType =
- Substitution.fromInterfaceType(streamIteratorType).substituteType(
- helper.coreTypes.streamIteratorSubscription.getterType);
- var tryFinalizer = new IfStatement(
- new Not(new EqualsNull(new InstanceGet(
- InstanceAccessKind.Instance,
- VariableGet(forIteratorVariable),
- helper.coreTypes.streamIteratorSubscription.name,
- interfaceTarget: helper.coreTypes.streamIteratorSubscription,
- resultType: subscriptionType))),
- new ExpressionStatement(new AwaitExpression(new InstanceInvocation(
- InstanceAccessKind.Instance,
- VariableGet(forIteratorVariable),
- helper.streamIteratorCancel.name,
- new Arguments(<Expression>[]),
- interfaceTarget: helper.streamIteratorCancel,
- functionType:
- helper.streamIteratorCancel.getterType as FunctionType))),
- null);
-
- var tryFinally = new TryFinally(tryBody, tryFinalizer);
-
- var block = new Block(
- <Statement>[streamVariable, forIteratorVariable, tryFinally]);
- return transform(block);
- }
-
- // Transform
- //
- // for ({var/final} T <variable> in <iterable>) { ... }
- //
- // Into
- //
- // {
- // final Iterator<T> :sync-for-iterator = <iterable>.iterator;
- // for (; :sync-for-iterator.moveNext() ;) {
- // {var/final} T variable = :sync-for-iterator.current;
- // ...
- // }
- // }
- // }
- final CoreTypes coreTypes = staticTypeContext.typeEnvironment.coreTypes;
-
- // The CFE might invoke this transformation despite the program having
- // compile-time errors. So we will not transform this [stmt] if the
- // `stmt.iterable` is an invalid expression or has an invalid type and
- // instead eliminate the entire for-in and replace it with a invalid
- // expression statement.
- final iterable = stmt.iterable;
- final iterableType = iterable.getStaticType(staticTypeContext);
- if (iterableType is InvalidType) {
- return ExpressionStatement(
- InvalidExpression('Invalid iterable type in for-in'));
- }
-
- // The NNBD sdk declares that Iterable.get:iterator returns a non-nullable
- // `Iterator<E>`.
- assert(const [
- Nullability.nonNullable,
- Nullability.legacy
- ].contains(coreTypes.iterableGetIterator.function.returnType.nullability));
-
- final DartType elementType = stmt.getElementType(staticTypeContext);
- final iteratorType = InterfaceType(
- coreTypes.iteratorClass, staticTypeContext.nonNullable, [elementType]);
-
- final syncForIterator = VariableDeclaration(
- ContinuationVariables.syncForIterator,
- initializer: InstanceGet(InstanceAccessKind.Instance, iterable,
- coreTypes.iterableGetIterator.name,
- interfaceTarget: coreTypes.iterableGetIterator,
- resultType: iteratorType)
- ..fileOffset = iterable.fileOffset,
- type: iteratorType)
- ..fileOffset = iterable.fileOffset;
-
- final condition = InstanceInvocation(
- InstanceAccessKind.Instance,
- VariableGet(syncForIterator),
- coreTypes.iteratorMoveNext.name,
- Arguments([]),
- interfaceTarget: coreTypes.iteratorMoveNext,
- functionType: coreTypes.iteratorMoveNext.getterType as FunctionType)
- ..fileOffset = iterable.fileOffset;
-
- final variable = stmt.variable
- ..initializer = (InstanceGet(InstanceAccessKind.Instance,
- VariableGet(syncForIterator), coreTypes.iteratorGetCurrent.name,
- interfaceTarget: coreTypes.iteratorGetCurrent,
- resultType: elementType)
- ..fileOffset = stmt.bodyOffset);
-
- final Block body = Block([variable, stmt.body])
- ..fileOffset = stmt.bodyOffset;
-
- return transform(
- Block([syncForIterator, ForStatement([], condition, [], body)]));
- }
-}
-
-abstract class ContinuationRewriterBase extends RecursiveContinuationRewriter {
- final FunctionNode enclosingFunction;
-
- int currentTryDepth = 0; // Nesting depth for try-blocks.
- int currentCatchDepth = 0; // Nesting depth for catch-blocks.
- int capturedTryDepth = 0; // Deepest yield point within a try-block.
- int capturedCatchDepth = 0; // Deepest yield point within a catch-block.
-
- ContinuationRewriterBase(HelperNodes helper, this.enclosingFunction,
- StatefulStaticTypeContext staticTypeContext, bool desugarAsync,
- {bool desugarAwaitFor = false})
- : super(helper, staticTypeContext, desugarAsync,
- desugarAwaitFor: desugarAwaitFor);
-
- /// Given a container [type], which is an instantiation of the given
- /// [containerClass] extract its element type.
- ///
- /// This is used to extract element type from Future<T>, Iterable<T> and
- /// Stream<T> instantiations.
- ///
- /// If instantiation is not valid (has more than 1 type argument) then
- /// this function returns [InvalidType].
- static DartType elementTypeFrom(Class containerClass, DartType type) {
- if (type is InterfaceType) {
- if (type.classNode == containerClass) {
- if (type.typeArguments.isEmpty) {
- return const DynamicType();
- } else if (type.typeArguments.length == 1) {
- return type.typeArguments[0];
- } else {
- return const InvalidType();
- }
- }
- }
- return const DynamicType();
- }
-
- static DartType elementTypeFromFutureOr(DartType type) {
- if (type is FutureOrType) {
- return type.typeArgument;
- }
- return const DynamicType();
- }
-
- DartType elementTypeFromReturnType(Class expected) =>
- elementTypeFrom(expected, enclosingFunction.returnType);
-
- DartType elementTypeFromAsyncReturnType() =>
- elementTypeFromFutureOr(enclosingFunction.returnType);
-
- Statement createContinuationPoint([Expression? value]) {
- if (value == null) value = new NullLiteral();
- capturedTryDepth = math.max(capturedTryDepth, currentTryDepth);
- capturedCatchDepth = math.max(capturedCatchDepth, currentCatchDepth);
- return new YieldStatement(value, isNative: true);
- }
-
- @override
- TreeNode visitTryCatch(TryCatch node, TreeNode? removalSentinel) {
- // ignore: unnecessary_null_comparison
- if (node.body != null) {
- ++currentTryDepth;
- node.body = transform(node.body);
- node.body.parent = node;
- --currentTryDepth;
- }
-
- ++currentCatchDepth;
- transformCatchList(node.catches, node);
- --currentCatchDepth;
- return node;
- }
-
- @override
- TreeNode visitTryFinally(TryFinally node, TreeNode? removalSentinel) {
- // ignore: unnecessary_null_comparison
- if (node.body != null) {
- ++currentTryDepth;
- node.body = transform(node.body);
- node.body.parent = node;
- --currentTryDepth;
- }
- // ignore: unnecessary_null_comparison
- if (node.finalizer != null) {
- ++currentCatchDepth;
- node.finalizer = transform(node.finalizer);
- node.finalizer.parent = node;
- --currentCatchDepth;
- }
- return node;
- }
-
- Iterable<VariableDeclaration> createCapturedTryVariables() =>
- new Iterable.generate(
- capturedTryDepth,
- (depth) => new VariableDeclaration(
- ContinuationVariables.savedTryContextVar(depth)));
-
- Iterable<VariableDeclaration> createCapturedCatchVariables() =>
- new Iterable.generate(capturedCatchDepth).expand((depth) => [
- new VariableDeclaration(ContinuationVariables.exceptionVar(depth)),
- new VariableDeclaration(ContinuationVariables.stackTraceVar(depth)),
- ]);
-
- List<VariableDeclaration> variableDeclarations() {
- awaitJumpVariable.type = staticTypeContext.typeEnvironment.coreTypes
- .intRawType(staticTypeContext.nonNullable);
- return [awaitJumpVariable, awaitContextVariable]
- ..addAll(createCapturedTryVariables())
- ..addAll(createCapturedCatchVariables());
- }
-}
-
-// Transformer that rewrites all variable references to a given function's
-// parameters.
-// This allows us to e.g. "shadow" the original parameter variables with copies
-// unique to given sub-closure to prevent shared variables being overwritten.
-class ShadowRewriter extends Transformer {
- final FunctionNode enclosingFunction;
- Map<VariableDeclaration, VariableDeclaration?> _shadowedParameters = {};
-
- ShadowRewriter(this.enclosingFunction) {
- for (final parameter in enclosingFunction.positionalParameters
- .followedBy(enclosingFunction.namedParameters)) {
- // Put in placeholders so we can allocate new variables lazily- i.e. only
- // if they're later referenced.
- _shadowedParameters[parameter] = null;
- }
- }
-
- // Return all used parameters.
- Iterable<VariableDeclaration> get shadowedParameters =>
- _shadowedParameters.values.whereType<VariableDeclaration>();
-
- VariableDeclaration _rewrite(VariableDeclaration variable) {
- if (_shadowedParameters.containsKey(variable)) {
- // Fill in placeholder.
- VariableDeclaration? placeholder = _shadowedParameters[variable];
- if (placeholder == null) {
- placeholder = _shadowedParameters[variable] = VariableDeclaration(
- variable.name,
- type: variable.type,
- initializer: VariableGet(variable),
- );
- }
- variable = placeholder;
- }
- return variable;
- }
-
- @override
- TreeNode visitVariableGet(VariableGet node) {
- node = super.visitVariableGet(node) as VariableGet;
- return node..variable = _rewrite(node.variable);
- }
-
- @override
- TreeNode visitVariableSet(VariableSet node) {
- node = super.visitVariableSet(node) as VariableSet;
- return node..variable = _rewrite(node.variable);
- }
-}
-
-class SyncStarFunctionRewriter extends ContinuationRewriterBase {
- final VariableDeclaration iteratorParameter;
-
- SyncStarFunctionRewriter(HelperNodes helper, FunctionNode enclosingFunction,
- StatefulStaticTypeContext staticTypeContext, bool desugarAsync)
- : iteratorParameter =
- VariableDeclaration(ContinuationVariables.iteratorParam)
- ..type = InterfaceType(
- helper.syncIteratorClass, staticTypeContext.nullable, [
- // Note: This is dynamic since nested iterators (of potentially
- // different type) are handled by shared internal synthetic
- // code.
- const DynamicType(),
- ]),
- super(helper, enclosingFunction, staticTypeContext, desugarAsync,
- desugarAwaitFor: false);
-
- FunctionNode rewrite() {
- // We need to preserve the original parameters passed to the sync* function
- // because each iteration should start from those parameters. To achieve
- // this we shadow the original parameters with new variables (which are
- // initialised to the original parameter values) and rewrite
- // the body to use these variables instead.
- final shadowRewriter = ShadowRewriter(enclosingFunction);
- enclosingFunction.body = shadowRewriter.transform(enclosingFunction.body!)
- ..parent = enclosingFunction;
-
- // TODO(cskau): Figure out why inlining this below causes segfaults.
- // Maybe related to http://dartbug.com/41596 ?
- final syncOpFN = FunctionNode(buildClosureBody(),
- positionalParameters: [
- iteratorParameter,
- new VariableDeclaration(ContinuationVariables.exceptionParam),
- new VariableDeclaration(ContinuationVariables.stackTraceParam),
- ],
- requiredParameterCount: 3,
- // Note: SyncYielding functions have no Dart equivalent. Since they are
- // synchronous, we use Sync. (Note also that the Dart VM backend uses
- // the Dart async marker to decide if functions are debuggable.)
- asyncMarker: AsyncMarker.SyncYielding,
- dartAsyncMarker: AsyncMarker.Sync,
- returnType: helper.coreTypes.boolLegacyRawType)
- ..fileOffset = enclosingFunction.fileOffset
- ..fileEndOffset = enclosingFunction.fileEndOffset;
- final syncOpType =
- syncOpFN.computeThisFunctionType(staticTypeContext.nonNullable);
-
- final syncOpGenVariable = VariableDeclaration(
- ContinuationVariables.syncOpGen,
- type: FunctionType([], syncOpType, staticTypeContext.nonNullable));
-
- final syncOpVariable = VariableDeclaration(ContinuationVariables.syncOp);
- final syncOpDecl = FunctionDeclaration(syncOpVariable, syncOpFN)
- ..fileOffset = enclosingFunction.fileOffset;
-
- enclosingFunction.body = Block([
- // :sync_op_gen() {
- // :await_jump_var;
- // :await_ctx_var;
- // bool sync_op(:iterator, e, st) yielding {
- // modified <node.body> ...
- // };
- // return sync_op;
- // }
- FunctionDeclaration(
- syncOpGenVariable,
- FunctionNode(
- Block([
- // :await_jump_var, :await_ctx_var.
- ...variableDeclarations(),
- // Shadow any used function parameters with local copies.
- ...shadowRewriter.shadowedParameters,
- // :sync_op(..) { .. }
- syncOpDecl,
- // return sync_op;
- ReturnStatement(VariableGet(syncOpVariable)),
- ]),
- returnType: syncOpType))
- ..fileOffset = enclosingFunction.fileOffset,
-
- // return _SyncIterable<T>(:sync_op_gen);
- ReturnStatement(ConstructorInvocation(
- helper.syncIterableConstructor,
- Arguments([
- VariableGet(syncOpGenVariable)
- ], types: [
- ContinuationRewriterBase.elementTypeFrom(
- helper.iterableClass, enclosingFunction.returnType)
- ]))),
- ])
- ..parent = enclosingFunction;
- enclosingFunction.asyncMarker = AsyncMarker.Sync;
-
- return enclosingFunction;
- }
-
- Statement buildClosureBody() {
- // The body will insert calls to
- // :iterator.current_=
- // :iterator.isYieldEach=
- // and return `true` as long as it did something and `false` when it's done.
- return new Block(<Statement>[
- transform(enclosingFunction.body!),
- new ReturnStatement(new BoolLiteral(false))
- ..fileOffset = enclosingFunction.fileEndOffset
- ]);
- }
-
- @override
- TreeNode visitYieldStatement(YieldStatement node, TreeNode? removalSentinel) {
- Expression transformedExpression = transform(node.expression);
-
- var statements = <Statement>[];
- if (node.isYieldStar) {
- statements.add(new ExpressionStatement(new InstanceSet(
- InstanceAccessKind.Instance,
- VariableGet(iteratorParameter),
- helper.syncIteratorYieldEachIterable.name,
- transformedExpression,
- interfaceTarget: helper.syncIteratorYieldEachIterable)));
- } else {
- statements.add(new ExpressionStatement(new InstanceSet(
- InstanceAccessKind.Instance,
- VariableGet(iteratorParameter),
- helper.syncIteratorCurrent.name,
- transformedExpression,
- interfaceTarget: helper.syncIteratorCurrent)));
- }
-
- statements.add(createContinuationPoint(new BoolLiteral(true))
- ..fileOffset = node.fileOffset);
- return new Block(statements);
- }
-
- @override
- TreeNode visitReturnStatement(
- ReturnStatement node, TreeNode? removalSentinel) {
- // sync* functions cannot return a value.
- assert(node.expression == null || node.expression is NullLiteral);
- node.expression = new BoolLiteral(false)..parent = node;
- return node;
- }
-}
-
-abstract class AsyncRewriterBase extends ContinuationRewriterBase {
- // :async_op has type (dynamic result_or_exception, StackTrace? s) -> dynamic
- final VariableDeclaration nestedClosureVariable;
-
- // :async_op_then has type (dynamic result) -> dynamic
- final VariableDeclaration thenContinuationVariable;
-
- // :async_op_error has type (Object e, StackTrace s) -> dynamic
- final VariableDeclaration catchErrorContinuationVariable;
-
- LabeledStatement? labeledBody;
-
- ExpressionLifter? expressionRewriter;
-
- AsyncRewriterBase(HelperNodes helper, FunctionNode enclosingFunction,
- StatefulStaticTypeContext staticTypeContext, bool desugarAsync)
- : nestedClosureVariable =
- VariableDeclaration(ContinuationVariables.asyncOp,
- type: FunctionType([
- const DynamicType(),
- helper.coreTypes
- .stackTraceRawType(staticTypeContext.nullable),
- ], const DynamicType(), staticTypeContext.nonNullable)),
- thenContinuationVariable = VariableDeclaration(
- ContinuationVariables.asyncOpThen,
- type: FunctionType(const [const DynamicType()], const DynamicType(),
- staticTypeContext.nonNullable)),
- catchErrorContinuationVariable =
- VariableDeclaration(ContinuationVariables.asyncOpError,
- type: FunctionType([
- helper.coreTypes.objectRawType(staticTypeContext.nonNullable),
- helper.coreTypes
- .stackTraceRawType(staticTypeContext.nonNullable),
- ], const DynamicType(), staticTypeContext.nonNullable)),
- super(helper, enclosingFunction, staticTypeContext, desugarAsync,
- desugarAwaitFor: true) {}
-
- void setupAsyncContinuations(List<Statement> statements) {
- expressionRewriter = new ExpressionLifter(this);
-
- // var :async_op_then;
- statements.add(thenContinuationVariable);
-
- // var :async_op_error;
- statements.add(catchErrorContinuationVariable);
-
- // :async_op(:result_or_exception, :stack_trace) {
- // modified <node.body>;
- // }
- final parameters = <VariableDeclaration>[
- expressionRewriter!.asyncResult,
- new VariableDeclaration(ContinuationVariables.stackTraceParam),
- ];
-
- // Note: SyncYielding functions have no Dart equivalent. Since they are
- // synchronous, we use Sync. (Note also that the Dart VM backend uses the
- // Dart async marker to decide if functions are debuggable.)
- final function = new FunctionNode(buildWrappedBody(),
- positionalParameters: parameters,
- asyncMarker: AsyncMarker.SyncYielding,
- dartAsyncMarker: AsyncMarker.Sync)
- ..fileOffset = enclosingFunction.fileOffset
- ..fileEndOffset = enclosingFunction.fileEndOffset;
-
- // The await expression lifter might have created a number of
- // [VariableDeclarations].
- // TODO(kustermann): If we didn't need any variables we should not emit
- // these.
- statements.addAll(variableDeclarations());
- statements.addAll(expressionRewriter!.variables);
-
- // Now add the closure function itself.
- final closureFunction =
- new FunctionDeclaration(nestedClosureVariable, function)
- ..fileOffset = enclosingFunction.parent!.fileOffset;
- statements.add(closureFunction);
-
- // :async_op_then = _asyncThenWrapperHelper(asyncBody);
- final boundThenClosure = new StaticInvocation(helper.asyncThenWrapper,
- new Arguments(<Expression>[new VariableGet(nestedClosureVariable)]));
- final thenClosureVariableAssign = new ExpressionStatement(
- new VariableSet(thenContinuationVariable, boundThenClosure));
- statements.add(thenClosureVariableAssign);
-
- // :async_op_error = _asyncErrorWrapperHelper(asyncBody);
- final boundCatchErrorClosure = new StaticInvocation(
- helper.asyncErrorWrapper,
- new Arguments(<Expression>[new VariableGet(nestedClosureVariable)]));
- final catchErrorClosureVariableAssign = new ExpressionStatement(
- new VariableSet(
- catchErrorContinuationVariable, boundCatchErrorClosure));
- statements.add(catchErrorClosureVariableAssign);
- }
-
- Statement buildWrappedBody() {
- ++currentTryDepth;
- labeledBody = new LabeledStatement(null);
- labeledBody!.body = visitDelimited(enclosingFunction.body!)
- ..parent = labeledBody;
- --currentTryDepth;
-
- var exceptionVariable = VariableDeclaration('exception');
- var stackTraceVariable = VariableDeclaration('stack_trace',
- type:
- helper.coreTypes.stackTraceRawType(staticTypeContext.nonNullable));
-
- return new TryCatch(
- buildReturn(labeledBody!),
- <Catch>[
- new Catch(
- exceptionVariable,
- new Block(<Statement>[
- buildCatchBody(exceptionVariable, stackTraceVariable)
- ]),
- stackTrace: stackTraceVariable)
- ],
- isSynthetic: true,
- );
- }
-
- Statement buildCatchBody(VariableDeclaration exceptionVariable,
- VariableDeclaration stackTraceVariable);
-
- Statement buildReturn(Statement body);
-
- List<Statement> statements = <Statement>[];
-
- @override
- TreeNode visitExpressionStatement(
- ExpressionStatement stmt, TreeNode? removalSentinel) {
- stmt.expression = expressionRewriter!.rewrite(stmt.expression, statements)
- ..parent = stmt;
- statements.add(stmt);
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitBlock(Block stmt, TreeNode? removalSentinel) {
- var saved = statements;
- statements = <Statement>[];
- for (var statement in stmt.statements) {
- transform(statement);
- }
- saved.add(new Block(statements));
- statements = saved;
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitEmptyStatement(EmptyStatement stmt, TreeNode? removalSentinel) {
- statements.add(stmt);
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitAssertBlock(AssertBlock stmt, TreeNode? removalSentinel) {
- var saved = statements;
- statements = <Statement>[];
- for (var statement in stmt.statements) {
- transform(statement);
- }
- saved.add(new Block(statements));
- statements = saved;
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitAssertStatement(
- AssertStatement stmt, TreeNode? removalSentinel) {
- var condEffects = <Statement>[];
- var cond = expressionRewriter!.rewrite(stmt.condition, condEffects);
- if (stmt.message == null) {
- stmt.condition = cond..parent = stmt;
- // If the translation of the condition produced a non-empty list of
- // statements, ensure they are guarded by whether asserts are enabled.
- statements.add(
- condEffects.isEmpty ? stmt : new AssertBlock(condEffects..add(stmt)));
- return removalSentinel ?? EmptyStatement();
- }
-
- // The translation depends on the translation of the message, by cases.
- Statement result;
- var msgEffects = <Statement>[];
- stmt.message = expressionRewriter!.rewrite(stmt.message!, msgEffects)
- ..parent = stmt;
- if (condEffects.isEmpty) {
- if (msgEffects.isEmpty) {
- // The condition rewrote to ([], C) and the message rewrote to ([], M).
- // The result is
- //
- // assert(C, M)
- stmt.condition = cond..parent = stmt;
- result = stmt;
- } else {
- // The condition rewrote to ([], C) and the message rewrote to (S*, M)
- // where S* is non-empty. The result is
- //
- // assert { if (C) {} else { S*; assert(false, M); }}
- stmt.condition = new BoolLiteral(false)..parent = stmt;
- result = new AssertBlock([
- new IfStatement(
- cond, new EmptyStatement(), new Block(msgEffects..add(stmt)))
- ]);
- }
- } else {
- if (msgEffects.isEmpty) {
- // The condition rewrote to (S*, C) where S* is non-empty and the
- // message rewrote to ([], M). The result is
- //
- // assert { S*; assert(C, M); }
- stmt.condition = cond..parent = stmt;
- condEffects.add(stmt);
- } else {
- // The condition rewrote to (S0*, C) and the message rewrote to (S1*, M)
- // where both S0* and S1* are non-empty. The result is
- //
- // assert { S0*; if (C) {} else { S1*; assert(false, M); }}
- stmt.condition = new BoolLiteral(false)..parent = stmt;
- condEffects.add(new IfStatement(
- cond, new EmptyStatement(), new Block(msgEffects..add(stmt))));
- }
- result = new AssertBlock(condEffects);
- }
- statements.add(result);
- return removalSentinel ?? EmptyStatement();
- }
-
- Statement visitDelimited(Statement stmt) {
- var saved = statements;
- statements = <Statement>[];
- transform(stmt);
- Statement result =
- statements.length == 1 ? statements.first : new Block(statements);
- statements = saved;
- return result;
- }
-
- @override
- TreeNode visitLabeledStatement(
- LabeledStatement stmt, TreeNode? removalSentinel) {
- stmt.body = visitDelimited(stmt.body)..parent = stmt;
- statements.add(stmt);
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitBreakStatement(BreakStatement stmt, TreeNode? removalSentinel) {
- statements.add(stmt);
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitWhileStatement(WhileStatement stmt, TreeNode? removalSentinel) {
- Statement body = visitDelimited(stmt.body);
- List<Statement> effects = <Statement>[];
- Expression cond = expressionRewriter!.rewrite(stmt.condition, effects);
- if (effects.isEmpty) {
- stmt.condition = cond..parent = stmt;
- stmt.body = body..parent = stmt;
- statements.add(stmt);
- } else {
- // The condition rewrote to a non-empty sequence of statements S* and
- // value V. Rewrite the loop to:
- //
- // L: while (true) {
- // S*
- // if (V) {
- // [body]
- // else {
- // break L;
- // }
- // }
- LabeledStatement labeled = new LabeledStatement(stmt);
- stmt.condition = new BoolLiteral(true)..parent = stmt;
- effects.add(new IfStatement(cond, body, new BreakStatement(labeled)));
- stmt.body = new Block(effects)..parent = stmt;
- statements.add(labeled);
- }
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitDoStatement(DoStatement stmt, TreeNode? removalSentinel) {
- Statement body = visitDelimited(stmt.body);
- List<Statement> effects = <Statement>[];
- stmt.condition = expressionRewriter!.rewrite(stmt.condition, effects)
- ..parent = stmt;
- if (effects.isNotEmpty) {
- // The condition rewrote to a non-empty sequence of statements S* and
- // value V. Add the statements to the end of the loop body.
- Block block = body is Block ? body : body = new Block(<Statement>[body]);
- for (var effect in effects) {
- block.statements.add(effect);
- effect.parent = body;
- }
- }
- stmt.body = body..parent = stmt;
- statements.add(stmt);
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitForStatement(ForStatement stmt, TreeNode? removalSentinel) {
- // Because of for-loop scoping and variable capture, it is tricky to deal
- // with await in the loop's variable initializers or update expressions.
- bool isSimple = true;
- int length = stmt.variables.length;
- List<List<Statement>> initEffects =
- new List<List<Statement>>.generate(length, (int i) {
- VariableDeclaration decl = stmt.variables[i];
- List<Statement> statements = <Statement>[];
- if (decl.initializer != null) {
- decl.initializer = expressionRewriter!
- .rewrite(decl.initializer!, statements)
- ..parent = decl;
- }
- isSimple = isSimple && statements.isEmpty;
- return statements;
- });
-
- length = stmt.updates.length;
- List<List<Statement>> updateEffects =
- new List<List<Statement>>.generate(length, (int i) {
- List<Statement> statements = <Statement>[];
- stmt.updates[i] = expressionRewriter!.rewrite(stmt.updates[i], statements)
- ..parent = stmt;
- isSimple = isSimple && statements.isEmpty;
- return statements;
- });
-
- Statement body = visitDelimited(stmt.body);
- Expression? cond = stmt.condition;
- List<Statement>? condEffects;
- if (cond != null) {
- condEffects = <Statement>[];
- cond = expressionRewriter!.rewrite(stmt.condition!, condEffects);
- }
-
- if (isSimple) {
- // If the condition contains await, we use a translation like the one for
- // while loops, but leaving the variable declarations and the update
- // expressions in place.
- if (condEffects == null || condEffects.isEmpty) {
- if (cond != null) stmt.condition = cond..parent = stmt;
- stmt.body = body..parent = stmt;
- statements.add(stmt);
- } else {
- LabeledStatement labeled = new LabeledStatement(stmt);
- // No condition in a for loop is the same as true.
- stmt.condition = null;
- condEffects
- .add(new IfStatement(cond!, body, new BreakStatement(labeled)));
- stmt.body = new Block(condEffects)..parent = stmt;
- statements.add(labeled);
- }
- return removalSentinel ?? EmptyStatement();
- }
-
- // If the rewrite of the initializer or update expressions produces a
- // non-empty sequence of statements then the loop is desugared. If the loop
- // has the form:
- //
- // label: for (Type x = init; cond; update) body
- //
- // it is translated as if it were:
- //
- // {
- // bool first = true;
- // Type temp;
- // label: while (true) {
- // Type x;
- // if (first) {
- // first = false;
- // x = init;
- // } else {
- // x = temp;
- // update;
- // }
- // if (cond) {
- // body;
- // temp = x;
- // } else {
- // break;
- // }
- // }
- // }
-
- // Place the loop variable declarations at the beginning of the body
- // statements and move their initializers to a guarded list of statements.
- // Add assignments to the loop variables from the previous iterations temp
- // variables before the updates.
- //
- // temps.first is the flag 'first'.
- // TODO(kmillikin) bool type for first.
- List<VariableDeclaration> temps = <VariableDeclaration>[
- new VariableDeclaration.forValue(new BoolLiteral(true), isFinal: false)
- ];
- List<Statement> loopBody = <Statement>[];
- List<Statement> initializers = <Statement>[
- new ExpressionStatement(
- new VariableSet(temps.first, new BoolLiteral(false)))
- ];
- List<Statement> updates = <Statement>[];
- List<Statement> newBody = <Statement>[body];
- for (int i = 0; i < stmt.variables.length; ++i) {
- VariableDeclaration decl = stmt.variables[i];
- temps.add(new VariableDeclaration(null, type: decl.type));
- loopBody.add(decl);
- if (decl.initializer != null) {
- initializers.addAll(initEffects[i]);
- initializers.add(
- new ExpressionStatement(new VariableSet(decl, decl.initializer!)));
- decl.initializer = null;
- }
- updates.add(new ExpressionStatement(
- new VariableSet(decl, new VariableGet(temps.last))));
- newBody.add(new ExpressionStatement(
- new VariableSet(temps.last, new VariableGet(decl))));
- }
- // Add the updates to their guarded list of statements.
- for (int i = 0; i < stmt.updates.length; ++i) {
- updates.addAll(updateEffects[i]);
- updates.add(new ExpressionStatement(stmt.updates[i]));
- }
- // Initializers or updates could be empty.
- loopBody.add(new IfStatement(new VariableGet(temps.first),
- new Block(initializers), new Block(updates)));
-
- LabeledStatement labeled = new LabeledStatement(null);
- if (cond != null) {
- loopBody.addAll(condEffects!);
- } else {
- cond = new BoolLiteral(true);
- }
- loopBody.add(
- new IfStatement(cond, new Block(newBody), new BreakStatement(labeled)));
- labeled.body =
- new WhileStatement(new BoolLiteral(true), new Block(loopBody))
- ..parent = labeled;
- statements.add(new Block(<Statement>[]
- ..addAll(temps)
- ..add(labeled)));
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitSwitchStatement(
- SwitchStatement stmt, TreeNode? removalSentinel) {
- stmt.expression = expressionRewriter!.rewrite(stmt.expression, statements)
- ..parent = stmt;
- for (var switchCase in stmt.cases) {
- // Expressions in switch cases cannot contain await so they do not need to
- // be translated.
- switchCase.body = visitDelimited(switchCase.body)..parent = switchCase;
- }
- statements.add(stmt);
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitContinueSwitchStatement(
- ContinueSwitchStatement stmt, TreeNode? removalSentinel) {
- statements.add(stmt);
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitIfStatement(IfStatement stmt, TreeNode? removalSentinel) {
- stmt.condition = expressionRewriter!.rewrite(stmt.condition, statements)
- ..parent = stmt;
- stmt.then = visitDelimited(stmt.then)..parent = stmt;
- if (stmt.otherwise != null) {
- stmt.otherwise = visitDelimited(stmt.otherwise!)..parent = stmt;
- }
- statements.add(stmt);
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitTryCatch(TryCatch stmt, TreeNode? removalSentinel) {
- ++currentTryDepth;
- stmt.body = visitDelimited(stmt.body)..parent = stmt;
- --currentTryDepth;
-
- ++currentCatchDepth;
- for (var clause in stmt.catches) {
- clause.body = visitDelimited(clause.body)..parent = clause;
- }
- --currentCatchDepth;
- statements.add(stmt);
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitTryFinally(TryFinally stmt, TreeNode? removalSentinel) {
- ++currentTryDepth;
- stmt.body = visitDelimited(stmt.body)..parent = stmt;
- --currentTryDepth;
- ++currentCatchDepth;
- stmt.finalizer = visitDelimited(stmt.finalizer)..parent = stmt;
- --currentCatchDepth;
- statements.add(stmt);
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitYieldStatement(YieldStatement stmt, TreeNode? removalSentinel) {
- stmt.expression = expressionRewriter!.rewrite(stmt.expression, statements)
- ..parent = stmt;
- statements.add(stmt);
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitVariableDeclaration(
- VariableDeclaration stmt, TreeNode? removalSentinel) {
- if (stmt.initializer != null) {
- stmt.initializer = expressionRewriter!
- .rewrite(stmt.initializer!, statements)
- ..parent = stmt;
- }
- statements.add(stmt);
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitFunctionDeclaration(
- FunctionDeclaration stmt, TreeNode? removalSentinel) {
- stmt.function = transform(stmt.function)..parent = stmt;
- statements.add(stmt);
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode defaultExpression(TreeNode node, TreeNode? removalSentinel) =>
- throw 'unreachable $node';
-}
-
-class AsyncStarFunctionRewriter extends AsyncRewriterBase {
- VariableDeclaration? controllerVariable;
-
- AsyncStarFunctionRewriter(HelperNodes helper, FunctionNode enclosingFunction,
- StatefulStaticTypeContext staticTypeContext, bool desugarAsync)
- : super(helper, enclosingFunction, staticTypeContext, desugarAsync);
-
- FunctionNode rewrite() {
- var statements = <Statement>[];
-
- final elementType = elementTypeFromReturnType(helper.streamClass);
-
- // _AsyncStarStreamController<T> :controller;
- controllerVariable = new VariableDeclaration(
- ContinuationVariables.controller,
- type: new InterfaceType(helper.asyncStarStreamControllerClass,
- staticTypeContext.nullable, [elementType]));
- statements.add(controllerVariable!);
-
- // dynamic :controller_stream;
- VariableDeclaration controllerStreamVariable =
- new VariableDeclaration(ContinuationVariables.controllerStreamVar);
- statements.add(controllerStreamVariable);
-
- setupAsyncContinuations(statements);
-
- // :controller = new _AsyncStarStreamController<T>(:async_op);
- var arguments = new Arguments(
- <Expression>[new VariableGet(nestedClosureVariable)],
- types: [elementType]);
- var buildController = new ConstructorInvocation(
- helper.asyncStarStreamControllerConstructor, arguments)
- ..fileOffset = enclosingFunction.fileOffset;
- var setController = new ExpressionStatement(
- new VariableSet(controllerVariable!, buildController));
- statements.add(setController);
-
- // :controller_stream = :controller.stream;
- var completerGet = new VariableGet(controllerVariable!);
- statements.add(new ExpressionStatement(new VariableSet(
- controllerStreamVariable,
- new InstanceGet(InstanceAccessKind.Instance, completerGet,
- helper.asyncStarStreamControllerStream.name,
- interfaceTarget: helper.asyncStarStreamControllerStream,
- resultType: Substitution.fromInterfaceType(
- controllerVariable!.type as InterfaceType)
- .substituteType(
- helper.asyncStarStreamControllerStream.getterType)))));
-
- // return :controller_stream;
- var returnStatement =
- new ReturnStatement(new VariableGet(controllerStreamVariable));
- statements.add(returnStatement);
-
- enclosingFunction.body = new Block(statements)..parent = enclosingFunction;
- enclosingFunction.asyncMarker = AsyncMarker.Sync;
- return enclosingFunction;
- }
-
- @override
- Statement buildWrappedBody() {
- ++currentTryDepth;
- Statement body = super.buildWrappedBody();
- --currentTryDepth;
-
- var finallyBody = new ExpressionStatement(new InstanceInvocation(
- InstanceAccessKind.Instance,
- new VariableGet(controllerVariable!),
- helper.asyncStarStreamControllerClose.name,
- new Arguments([]),
- interfaceTarget: helper.asyncStarStreamControllerClose,
- functionType:
- helper.asyncStarStreamControllerClose.getterType as FunctionType));
-
- var tryFinally = new TryFinally(body, new Block(<Statement>[finallyBody]));
- return tryFinally;
- }
-
- @override
- Statement buildCatchBody(VariableDeclaration exceptionVariable,
- VariableDeclaration stackTraceVariable) {
- return new ExpressionStatement(new InstanceInvocation(
- InstanceAccessKind.Instance,
- new VariableGet(controllerVariable!),
- helper.asyncStarStreamControllerAddError.name,
- new Arguments(<Expression>[
- new VariableGet(exceptionVariable),
- new VariableGet(stackTraceVariable)
- ]),
- interfaceTarget: helper.asyncStarStreamControllerAddError,
- functionType: helper.asyncStarStreamControllerAddError.getterType
- as FunctionType));
- }
-
- @override
- Statement buildReturn(Statement body) {
- // Async* functions cannot return a value. The returns from the function
- // have been translated into breaks from the labeled body.
- return new Block(<Statement>[
- body,
- new ReturnStatement()..fileOffset = enclosingFunction.fileEndOffset,
- ]);
- }
-
- @override
- TreeNode visitYieldStatement(YieldStatement stmt, TreeNode? removalSentinel) {
- Expression expr = expressionRewriter!.rewrite(stmt.expression, statements);
-
- final Procedure addMethod = stmt.isYieldStar
- ? helper.asyncStarStreamControllerAddStream
- : helper.asyncStarStreamControllerAdd;
- final FunctionType addMethodFunctionType = Substitution.fromInterfaceType(
- controllerVariable!.type as InterfaceType)
- .substituteType(addMethod.getterType) as FunctionType;
- var addExpression = new InstanceInvocation(
- InstanceAccessKind.Instance,
- new VariableGet(controllerVariable!),
- addMethod.name,
- new Arguments(<Expression>[expr]),
- interfaceTarget: addMethod,
- functionType: addMethodFunctionType)
- ..fileOffset = stmt.fileOffset;
-
- if (stmt.isYieldStar) {
- statements.add(ExpressionStatement(addExpression));
- statements.add(createContinuationPoint()..fileOffset = stmt.fileOffset);
- final wasCancelled = StaticInvocation(
- helper.unsafeCast,
- Arguments(<Expression>[VariableGet(expressionRewriter!.asyncResult)],
- types: <DartType>[helper.coreTypes.boolNonNullableRawType]));
- statements
- .add(IfStatement(wasCancelled, ReturnStatement(NullLiteral()), null));
- } else {
- statements.add(new IfStatement(
- addExpression,
- new ReturnStatement(new NullLiteral()),
- createContinuationPoint()..fileOffset = stmt.fileOffset));
- }
- return removalSentinel ?? EmptyStatement();
- }
-
- @override
- TreeNode visitReturnStatement(
- ReturnStatement node, TreeNode? removalSentinel) {
- // Async* functions cannot return a value.
- assert(node.expression == null || node.expression is NullLiteral);
- statements
- .add(new BreakStatement(labeledBody!)..fileOffset = node.fileOffset);
- return removalSentinel ?? EmptyStatement();
- }
-}
-
-class AsyncFunctionRewriter extends AsyncRewriterBase {
- VariableDeclaration? returnVariable;
- VariableDeclaration? asyncFutureVariable;
- VariableDeclaration? isSyncVariable;
-
- // In general an async functions such as
- //
- // Future<X> foo() async { return <expr>; }
- //
- // can return as `<expr>` either X or Future<X>, i.e. it can return
- // FutureOr<X>
- //
- // If we know it doesn't return any object of type `Future`, we can optimize
- // the future completion process by avoiding some expensive `is Future<T>`
- // type checks on the returned value.
- late bool canReturnFuture;
-
- AsyncFunctionRewriter(HelperNodes helper, FunctionNode enclosingFunction,
- StatefulStaticTypeContext staticTypeContext, bool desugarAsync)
- : super(helper, enclosingFunction, staticTypeContext, desugarAsync);
-
- FunctionNode rewrite() {
- var statements = <Statement>[];
-
- // The original function return type should be Future<T> or FutureOr<T>
- // because the function is async. If it was, we make a Completer<T>,
- // otherwise we make a malformed type. In a "Future<T> foo() async {}"
- // function the body can either return a "T" or a "Future<T>" => a
- // "FutureOr<T>".
- DartType valueType = elementTypeFromReturnType(helper.futureClass);
- if (valueType == const DynamicType()) {
- valueType = elementTypeFromAsyncReturnType();
- }
- final DartType returnType =
- FutureOrType(valueType, staticTypeContext.nullable);
- final futureTypeArguments = <DartType>[valueType];
-
- final futureType = InterfaceType(helper.futureImplClass,
- staticTypeContext.nonNullable, futureTypeArguments);
-
- // final _Future<T> :async_future = _Future<T>();
- asyncFutureVariable = VariableDeclaration(ContinuationVariables.asyncFuture,
- initializer: ConstructorInvocation(helper.futureImplConstructor,
- Arguments([], types: futureTypeArguments))
- ..fileOffset = enclosingFunction.body?.fileOffset ?? -1,
- isFinal: true,
- type: futureType);
- statements.add(asyncFutureVariable!);
-
- // bool :is_sync = false;
- isSyncVariable = VariableDeclaration(ContinuationVariables.isSync,
- initializer: BoolLiteral(false),
- type: helper.coreTypes.boolLegacyRawType);
- statements.add(isSyncVariable!);
-
- // asy::FutureOr<T>* :return_value;
- returnVariable = VariableDeclaration(ContinuationVariables.returnValue,
- type: returnType);
- statements.add(returnVariable!);
-
- canReturnFuture = false;
-
- setupAsyncContinuations(statements);
-
- // If we could prove the function doesn't return a `Future` we change the
- // type of `:return_value`.
- if (!canReturnFuture) {
- returnVariable!.type =
- valueType.withDeclaredNullability(Nullability.nullable);
- }
-
- // :async_op(null, null);
- final startStatement = ExpressionStatement(LocalFunctionInvocation(
- nestedClosureVariable, Arguments([NullLiteral(), NullLiteral()]),
- functionType: FunctionType(
- [], const DynamicType(), staticTypeContext.nonNullable))
- ..fileOffset = enclosingFunction.fileOffset);
- statements.add(startStatement);
-
- // :is_sync = true;
- final setIsSync =
- ExpressionStatement(VariableSet(isSyncVariable!, BoolLiteral(true)));
- statements.add(setIsSync);
-
- // return :async_future;
- statements.add(ReturnStatement(VariableGet(asyncFutureVariable!)));
-
- enclosingFunction.body = Block(statements)..parent = enclosingFunction;
- enclosingFunction.asyncMarker = AsyncMarker.Sync;
- return enclosingFunction;
- }
-
- // :async_op's try-catch catch body:
- @override
- Statement buildCatchBody(exceptionVariable, stackTraceVariable) {
- // _completeOnAsyncError(_future, e, st, :is_sync)
- return ExpressionStatement(StaticInvocation(
- helper.completeOnAsyncError,
- Arguments([
- VariableGet(asyncFutureVariable!),
- VariableGet(exceptionVariable),
- VariableGet(stackTraceVariable),
- VariableGet(isSyncVariable!)
- ])));
- }
-
- // :async_op's try-catch try body:
- @override
- Statement buildReturn(Statement body) {
- // Returns from the body have all been translated into assignments to the
- // return value variable followed by a break from the labeled body.
-
- // .. body ..
- // _completeOnAsyncReturn(_future, returnVariable, :is_sync)
- // return;
- return Block(<Statement>[
- body,
- ExpressionStatement(StaticInvocation(
- canReturnFuture
- ? helper.completeOnAsyncReturn
- : helper.completeWithNoFutureOnAsyncReturn,
- Arguments([
- VariableGet(asyncFutureVariable!),
- VariableGet(returnVariable!),
- VariableGet(isSyncVariable!)
- ]))),
- ReturnStatement()..fileOffset = enclosingFunction.fileEndOffset
- ]);
- }
-
- @override
- TreeNode visitReturnStatement(
- ReturnStatement node, TreeNode? removalSentinel) {
- final expression = node.expression;
- if (expression != null && !canReturnFuture) {
- final returnedType = staticTypeContext.getExpressionType(expression);
- canReturnFuture = _canHoldFutureObject(returnedType);
- }
-
- final transformedExpression = node.expression == null
- ? NullLiteral()
- : expressionRewriter!.rewrite(node.expression!, statements);
- statements.add(ExpressionStatement(
- VariableSet(returnVariable!, transformedExpression)
- ..fileOffset = node.fileOffset));
- statements.add(BreakStatement(labeledBody!));
- return removalSentinel ?? EmptyStatement();
- }
-
- bool _canHoldFutureObject(DartType type) {
- // Any supertype or subtype of `FutureOr` may hold a `Future` object.
- final env = staticTypeContext.typeEnvironment;
-
- if (type is TypeParameterType) {
- type = type.parameter.defaultType;
- }
-
- if (type is FutureOrType) return true;
-
- // Any supertype of Future (which includes Future/Object/dynamic) can hold
- // Future objects.
- if (env.isSubtypeOf(
- helper.futureType, type, SubtypeCheckMode.ignoringNullabilities)) {
- return true;
- }
-
- // Any subtype of Future (which includes Future/_Future and any user-defined
- // implementations) can hold Future objects.
- if (env.isSubtypeOf(
- type, helper.futureType, SubtypeCheckMode.ignoringNullabilities)) {
- return true;
- }
- return false;
- }
-}
-
-class HelperNodes {
- final Procedure asyncErrorWrapper;
- final Library asyncLibrary;
- final Procedure asyncStarStreamControllerAdd;
- final Procedure asyncStarStreamControllerAddError;
- final Procedure asyncStarStreamControllerAddStream;
- final Class asyncStarStreamControllerClass;
- final Procedure asyncStarStreamControllerClose;
- final Constructor asyncStarStreamControllerConstructor;
- final Member asyncStarStreamControllerStream;
- final Procedure asyncStarMoveNextHelper;
- final Procedure asyncThenWrapper;
- final Procedure awaitHelper;
- final Procedure completeOnAsyncReturn;
- final Procedure completeWithNoFutureOnAsyncReturn;
- final Procedure completeOnAsyncError;
- final Library coreLibrary;
- final CoreTypes coreTypes;
- final Class futureClass;
- final Class futureOrClass;
- final Class futureImplClass;
- final Constructor futureImplConstructor;
- final Class iterableClass;
- final Class streamClass;
- final Procedure streamIteratorCancel;
- final Class streamIteratorClass;
- final Constructor streamIteratorConstructor;
- final Member streamIteratorCurrent;
- final Procedure streamIteratorMoveNext;
- final Constructor syncIterableConstructor;
- final Class syncIteratorClass;
- final Member syncIteratorCurrent;
- final Member syncIteratorYieldEachIterable;
- final Class boolClass;
- final Procedure unsafeCast;
- final DartType futureType;
-
- bool productMode;
-
- HelperNodes._(
- this.asyncErrorWrapper,
- this.asyncLibrary,
- this.asyncStarStreamControllerAdd,
- this.asyncStarStreamControllerAddError,
- this.asyncStarStreamControllerAddStream,
- this.asyncStarStreamControllerClass,
- this.asyncStarStreamControllerClose,
- this.asyncStarStreamControllerConstructor,
- this.asyncStarStreamControllerStream,
- this.asyncStarMoveNextHelper,
- this.asyncThenWrapper,
- this.awaitHelper,
- this.completeOnAsyncReturn,
- this.completeWithNoFutureOnAsyncReturn,
- this.completeOnAsyncError,
- this.coreLibrary,
- this.coreTypes,
- this.futureClass,
- this.futureOrClass,
- this.futureImplClass,
- this.futureImplConstructor,
- this.iterableClass,
- this.streamClass,
- this.streamIteratorCancel,
- this.streamIteratorClass,
- this.streamIteratorConstructor,
- this.streamIteratorCurrent,
- this.streamIteratorMoveNext,
- this.syncIterableConstructor,
- this.syncIteratorClass,
- this.syncIteratorCurrent,
- this.syncIteratorYieldEachIterable,
- this.boolClass,
- this.productMode,
- this.unsafeCast)
- : futureType = InterfaceType(
- futureClass, Nullability.nonNullable, [DynamicType()]);
-
- factory HelperNodes.fromCoreTypes(CoreTypes coreTypes, bool productMode) {
- return new HelperNodes._(
- coreTypes.asyncErrorWrapperHelperProcedure,
- coreTypes.asyncLibrary,
- coreTypes.asyncStarStreamControllerAdd,
- coreTypes.asyncStarStreamControllerAddError,
- coreTypes.asyncStarStreamControllerAddStream,
- coreTypes.asyncStarStreamControllerClass,
- coreTypes.asyncStarStreamControllerClose,
- coreTypes.asyncStarStreamControllerDefaultConstructor,
- coreTypes.asyncStarStreamControllerStream,
- coreTypes.asyncStarMoveNextHelper,
- coreTypes.asyncThenWrapperHelperProcedure,
- coreTypes.awaitHelperProcedure,
- coreTypes.completeOnAsyncReturn,
- coreTypes.completeWithNoFutureOnAsyncReturn,
- coreTypes.completeOnAsyncError,
- coreTypes.coreLibrary,
- coreTypes,
- coreTypes.futureClass,
- coreTypes.deprecatedFutureOrClass,
- coreTypes.futureImplClass,
- coreTypes.futureImplConstructor,
- coreTypes.iterableClass,
- coreTypes.streamClass,
- coreTypes.streamIteratorCancel,
- coreTypes.streamIteratorClass,
- coreTypes.streamIteratorDefaultConstructor,
- coreTypes.streamIteratorCurrent,
- coreTypes.streamIteratorMoveNext,
- coreTypes.syncIterableDefaultConstructor,
- coreTypes.syncIteratorClass,
- coreTypes.syncIteratorCurrent,
- coreTypes.syncIteratorYieldEachIterable,
- coreTypes.boolClass,
- productMode,
- coreTypes.index.getTopLevelMember('dart:_internal', 'unsafeCast')
- as Procedure);
- }
-}
diff --git a/pkg/vm/lib/transformations/for_in_lowering.dart b/pkg/vm/lib/transformations/for_in_lowering.dart
new file mode 100644
index 0000000..f9576ed
--- /dev/null
+++ b/pkg/vm/lib/transformations/for_in_lowering.dart
@@ -0,0 +1,222 @@
+// Copyright (c) 2022, 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:kernel/ast.dart';
+import 'package:kernel/core_types.dart' show CoreTypes;
+import 'package:kernel/type_algebra.dart' show Substitution;
+import 'package:kernel/type_environment.dart' show StaticTypeContext;
+
+class ForInVariables {
+ static const stream = ':stream';
+ static const forIterator = ':for-iterator';
+ static const syncForIterator = ':sync-for-iterator';
+}
+
+/// VM-specific desugaring of for-in loops.
+class ForInLowering {
+ final CoreTypes coreTypes;
+ final bool productMode;
+
+ ForInLowering(this.coreTypes, {required this.productMode});
+
+ Statement transformForInStatement(ForInStatement stmt,
+ FunctionNode? enclosingFunction, StaticTypeContext staticTypeContext) {
+ if (stmt.isAsync) {
+ if (enclosingFunction == null ||
+ (enclosingFunction.asyncMarker != AsyncMarker.Async &&
+ enclosingFunction.asyncMarker != AsyncMarker.AsyncStar)) {
+ return stmt;
+ }
+ // Transform
+ //
+ // await for (T variable in <stream-expression>) { ... }
+ //
+ // To (in product mode):
+ //
+ // {
+ // :stream = <stream-expression>;
+ // _StreamIterator<T> :for-iterator = new _StreamIterator<T>(:stream);
+ // try {
+ // while (await :for-iterator.moveNext()) {
+ // T <variable> = :for-iterator.current;
+ // ...
+ // }
+ // } finally {
+ // if (:for-iterator._subscription != null)
+ // await :for-iterator.cancel();
+ // }
+ // }
+ //
+ // Or (in non-product mode):
+ //
+ // {
+ // :stream = <stream-expression>;
+ // _StreamIterator<T> :for-iterator = new _StreamIterator<T>(:stream);
+ // try {
+ // while (let _ = _asyncStarMoveNextHelper(:stream) in
+ // await :for-iterator.moveNext()) {
+ // T <variable> = :for-iterator.current;
+ // ...
+ // }
+ // } finally {
+ // if (:for-iterator._subscription != null)
+ // await :for-iterator.cancel();
+ // }
+ // }
+ final valueVariable = stmt.variable;
+
+ final streamVariable = new VariableDeclaration(ForInVariables.stream,
+ initializer: stmt.iterable,
+ type: stmt.iterable.getStaticType(staticTypeContext));
+
+ final streamIteratorType = new InterfaceType(
+ coreTypes.streamIteratorClass,
+ staticTypeContext.nullable,
+ [valueVariable.type]);
+ final forIteratorVariable = VariableDeclaration(
+ ForInVariables.forIterator,
+ initializer: new ConstructorInvocation(
+ coreTypes.streamIteratorDefaultConstructor,
+ new Arguments(<Expression>[new VariableGet(streamVariable)],
+ types: [valueVariable.type])),
+ type: streamIteratorType);
+
+ // await :for-iterator.moveNext()
+ final condition = new AwaitExpression(new InstanceInvocation(
+ InstanceAccessKind.Instance,
+ VariableGet(forIteratorVariable),
+ coreTypes.streamIteratorMoveNext.name,
+ new Arguments([]),
+ interfaceTarget: coreTypes.streamIteratorMoveNext,
+ functionType:
+ coreTypes.streamIteratorMoveNext.getterType as FunctionType))
+ ..fileOffset = stmt.fileOffset;
+
+ Expression whileCondition;
+ if (productMode) {
+ whileCondition = condition;
+ } else {
+ // _asyncStarMoveNextHelper(:stream)
+ final asyncStarMoveNextCall = new StaticInvocation(
+ coreTypes.asyncStarMoveNextHelper,
+ new Arguments([new VariableGet(streamVariable)]))
+ ..fileOffset = stmt.fileOffset;
+
+ // let _ = asyncStarMoveNextCall in (condition)
+ whileCondition = new Let(
+ new VariableDeclaration(null, initializer: asyncStarMoveNextCall),
+ condition);
+ }
+
+ // T <variable> = :for-iterator.current;
+ valueVariable.initializer = new InstanceGet(
+ InstanceAccessKind.Instance,
+ VariableGet(forIteratorVariable),
+ coreTypes.streamIteratorCurrent.name,
+ interfaceTarget: coreTypes.streamIteratorCurrent,
+ resultType: valueVariable.type)
+ ..fileOffset = stmt.bodyOffset;
+ valueVariable.initializer!.parent = valueVariable;
+
+ final whileBody = new Block(<Statement>[valueVariable, stmt.body]);
+ final tryBody = new WhileStatement(whileCondition, whileBody);
+
+ // if (:for-iterator._subscription != null) await :for-iterator.cancel();
+ final DartType subscriptionType =
+ Substitution.fromInterfaceType(streamIteratorType)
+ .substituteType(coreTypes.streamIteratorSubscription.getterType);
+ final tryFinalizer = new IfStatement(
+ new Not(new EqualsNull(new InstanceGet(
+ InstanceAccessKind.Instance,
+ VariableGet(forIteratorVariable),
+ coreTypes.streamIteratorSubscription.name,
+ interfaceTarget: coreTypes.streamIteratorSubscription,
+ resultType: subscriptionType))),
+ new ExpressionStatement(new AwaitExpression(new InstanceInvocation(
+ InstanceAccessKind.Instance,
+ VariableGet(forIteratorVariable),
+ coreTypes.streamIteratorCancel.name,
+ new Arguments(<Expression>[]),
+ interfaceTarget: coreTypes.streamIteratorCancel,
+ functionType:
+ coreTypes.streamIteratorCancel.getterType as FunctionType))),
+ null);
+
+ final tryFinally = new TryFinally(tryBody, tryFinalizer);
+
+ final block = new Block(
+ <Statement>[streamVariable, forIteratorVariable, tryFinally]);
+ return block;
+ }
+
+ // Transform
+ //
+ // for ({var/final} T <variable> in <iterable>) { ... }
+ //
+ // Into
+ //
+ // {
+ // final Iterator<T> :sync-for-iterator = <iterable>.iterator;
+ // for (; :sync-for-iterator.moveNext() ;) {
+ // {var/final} T variable = :sync-for-iterator.current;
+ // ...
+ // }
+ // }
+ // }
+
+ // The CFE might invoke this transformation despite the program having
+ // compile-time errors. So we will not transform this [stmt] if the
+ // `stmt.iterable` is an invalid expression or has an invalid type and
+ // instead eliminate the entire for-in and replace it with a invalid
+ // expression statement.
+ final iterable = stmt.iterable;
+ final iterableType = iterable.getStaticType(staticTypeContext);
+ if (iterableType is InvalidType) {
+ return ExpressionStatement(
+ InvalidExpression('Invalid iterable type in for-in'));
+ }
+
+ // The NNBD sdk declares that Iterable.get:iterator returns a non-nullable
+ // `Iterator<E>`.
+ assert(const [
+ Nullability.nonNullable,
+ Nullability.legacy
+ ].contains(coreTypes.iterableGetIterator.function.returnType.nullability));
+
+ final DartType elementType = stmt.getElementType(staticTypeContext);
+ final iteratorType = InterfaceType(
+ coreTypes.iteratorClass, staticTypeContext.nonNullable, [elementType]);
+
+ final syncForIterator = VariableDeclaration(ForInVariables.syncForIterator,
+ initializer: InstanceGet(InstanceAccessKind.Instance, iterable,
+ coreTypes.iterableGetIterator.name,
+ interfaceTarget: coreTypes.iterableGetIterator,
+ resultType: iteratorType)
+ ..fileOffset = iterable.fileOffset,
+ type: iteratorType)
+ ..fileOffset = iterable.fileOffset;
+
+ final condition = InstanceInvocation(
+ InstanceAccessKind.Instance,
+ VariableGet(syncForIterator),
+ coreTypes.iteratorMoveNext.name,
+ Arguments([]),
+ interfaceTarget: coreTypes.iteratorMoveNext,
+ functionType: coreTypes.iteratorMoveNext.getterType as FunctionType)
+ ..fileOffset = iterable.fileOffset;
+
+ final variable = stmt.variable
+ ..initializer = (InstanceGet(InstanceAccessKind.Instance,
+ VariableGet(syncForIterator), coreTypes.iteratorGetCurrent.name,
+ interfaceTarget: coreTypes.iteratorGetCurrent,
+ resultType: elementType)
+ ..fileOffset = stmt.bodyOffset);
+ variable.initializer!.parent = variable;
+
+ final Block body = Block([variable, stmt.body])
+ ..fileOffset = stmt.bodyOffset;
+
+ return Block([syncForIterator, ForStatement([], condition, [], body)]);
+ }
+}
diff --git a/pkg/vm/lib/transformations/lowering.dart b/pkg/vm/lib/transformations/lowering.dart
index 4242ff4..f86ff95 100644
--- a/pkg/vm/lib/transformations/lowering.dart
+++ b/pkg/vm/lib/transformations/lowering.dart
@@ -10,6 +10,7 @@
import 'package:vm/transformations/specializer/factory_specializer.dart';
+import 'for_in_lowering.dart' show ForInLowering;
import 'late_var_init_transformer.dart' show LateVarInitTransformer;
import 'list_literals_lowering.dart' show ListLiteralsLowering;
import 'type_casts_optimizer.dart' as typeCastsOptimizer
@@ -20,15 +21,19 @@
///
/// Each transformation is applied locally to AST nodes of certain types
/// after transforming children nodes.
-void transformLibraries(List<Library> libraries, CoreTypes coreTypes,
- ClassHierarchy hierarchy, bool nullSafety) {
- final transformer = _Lowering(coreTypes, hierarchy, nullSafety);
+void transformLibraries(
+ List<Library> libraries, CoreTypes coreTypes, ClassHierarchy hierarchy,
+ {required bool nullSafety, required bool productMode}) {
+ final transformer = _Lowering(coreTypes, hierarchy,
+ nullSafety: nullSafety, productMode: productMode);
libraries.forEach(transformer.visitLibrary);
}
-void transformProcedure(Procedure procedure, CoreTypes coreTypes,
- ClassHierarchy hierarchy, bool nullSafety) {
- final transformer = _Lowering(coreTypes, hierarchy, nullSafety);
+void transformProcedure(
+ Procedure procedure, CoreTypes coreTypes, ClassHierarchy hierarchy,
+ {required bool nullSafety, required bool productMode}) {
+ final transformer = _Lowering(coreTypes, hierarchy,
+ nullSafety: nullSafety, productMode: productMode);
procedure.accept(transformer);
}
@@ -38,15 +43,19 @@
final LateVarInitTransformer lateVarInitTransformer;
final FactorySpecializer factorySpecializer;
final ListLiteralsLowering listLiteralsLowering;
+ final ForInLowering forInLowering;
Member? _currentMember;
+ FunctionNode? _currentFunctionNode;
StaticTypeContext? _cachedStaticTypeContext;
- _Lowering(CoreTypes coreTypes, ClassHierarchy hierarchy, this.nullSafety)
+ _Lowering(CoreTypes coreTypes, ClassHierarchy hierarchy,
+ {required this.nullSafety, required bool productMode})
: env = TypeEnvironment(coreTypes, hierarchy),
lateVarInitTransformer = LateVarInitTransformer(),
factorySpecializer = FactorySpecializer(coreTypes),
- listLiteralsLowering = ListLiteralsLowering(coreTypes);
+ listLiteralsLowering = ListLiteralsLowering(coreTypes),
+ forInLowering = ForInLowering(coreTypes, productMode: productMode);
StaticTypeContext get _staticTypeContext =>
_cachedStaticTypeContext ??= StaticTypeContext(_currentMember!, env);
@@ -70,6 +79,17 @@
}
@override
+ visitFunctionNode(FunctionNode node) {
+ final savedFunctionNode = _currentFunctionNode;
+ _currentFunctionNode = node;
+
+ final result = super.visitFunctionNode(node);
+
+ _currentFunctionNode = savedFunctionNode;
+ return result;
+ }
+
+ @override
visitStaticInvocation(StaticInvocation node) {
node.transformChildren(this);
return factorySpecializer.transformStaticInvocation(node);
@@ -99,4 +119,11 @@
node.transformChildren(this);
return listLiteralsLowering.transformListLiteral(node);
}
+
+ @override
+ visitForInStatement(ForInStatement node) {
+ node.transformChildren(this);
+ return forInLowering.transformForInStatement(
+ node, _currentFunctionNode, _staticTypeContext);
+ }
}
diff --git a/pkg/vm/lib/transformations/type_flow/summary_collector.dart b/pkg/vm/lib/transformations/type_flow/summary_collector.dart
index 6bd2768..b89c8a7 100644
--- a/pkg/vm/lib/transformations/type_flow/summary_collector.dart
+++ b/pkg/vm/lib/transformations/type_flow/summary_collector.dart
@@ -363,17 +363,6 @@
final function = node.function;
function.accept(this);
- if (function.asyncMarker == AsyncMarker.SyncYielding) {
- // Mark parameters of synthetic async_op closures as captured
- // to make sure their updates at yield points are taken into account.
- for (var v in function.positionalParameters) {
- _captureVariable(v);
- }
- for (var v in function.namedParameters) {
- _captureVariable(v);
- }
- }
-
activeStatements = savedActiveStatements;
numVariablesAtActiveStatements = savedNumVariablesAtActiveStatements;
numVariablesAtFunctionEntry = savedNumVariablesAtFunctionEntry;
diff --git a/runtime/docs/index.md b/runtime/docs/index.md
index 8e261b0..23a1a14 100644
--- a/runtime/docs/index.md
+++ b/runtime/docs/index.md
@@ -98,7 +98,7 @@
At this point enough information is loaded from Kernel binary for runtime to successfully resolve and invoke methods. For example, it could resolve and invoke `main` function from a library.
!!! sourcecode "Source to read"
- @{package:kernel/ast.dart} defines classes describing the Kernel AST. @{package:front_end} handles parsing Dart source and building Kernel AST from it. @{dart::kernel::KernelLoader::LoadEntireProgram} is an entry point for deserialization of Kernel AST into corresponding VM objects. @{pkg/vm/bin/kernel_service.dart} implements the Kernel Service isolate, @{runtime/vm/kernel_isolate.cc} glues Dart implementation to the rest of the VM. @{package:vm} hosts most of the Kernel based VM specific functionality, e.g various Kernel-to-Kernel transformations. However some VM specific transformations still live in @{package:kernel} for historical reasons. A good example of a complicated transformation is @{package:kernel/transformations/continuation.dart}, which desugars `async`,`async*` and `sync*` functions.
+ @{package:kernel/ast.dart} defines classes describing the Kernel AST. @{package:front_end} handles parsing Dart source and building Kernel AST from it. @{dart::kernel::KernelLoader::LoadEntireProgram} is an entry point for deserialization of Kernel AST into corresponding VM objects. @{pkg/vm/bin/kernel_service.dart} implements the Kernel Service isolate, @{runtime/vm/kernel_isolate.cc} glues Dart implementation to the rest of the VM. @{package:vm} hosts most of the Kernel based VM specific functionality, e.g various Kernel-to-Kernel transformations.
!!! tryit "Trying it"
diff --git a/runtime/tests/vm/dart/splay_test.dart b/runtime/tests/vm/dart/splay_test.dart
index e508561..ef51ede 100644
--- a/runtime/tests/vm/dart/splay_test.dart
+++ b/runtime/tests/vm/dart/splay_test.dart
@@ -28,6 +28,9 @@
// VMOptions=--stress_write_barrier_elimination
// VMOptions=--old_gen_heap_size=100
// VMOptions=--mark_when_idle
+// VMOptions=--no_load_cse
+// VMOptions=--no_dead_store_elimination
+// VMOptions=--no_load_cse --no_dead_store_elimination
import "dart:math";
import 'package:benchmark_harness/benchmark_harness.dart';
diff --git a/runtime/tests/vm/dart_2/splay_test.dart b/runtime/tests/vm/dart_2/splay_test.dart
index f0474f6..6cd3050 100644
--- a/runtime/tests/vm/dart_2/splay_test.dart
+++ b/runtime/tests/vm/dart_2/splay_test.dart
@@ -32,6 +32,9 @@
// VMOptions=--stress_write_barrier_elimination
// VMOptions=--old_gen_heap_size=100
// VMOptions=--mark_when_idle
+// VMOptions=--no_load_cse
+// VMOptions=--no_dead_store_elimination
+// VMOptions=--no_load_cse --no_dead_store_elimination
import "dart:math";
import 'package:benchmark_harness/benchmark_harness.dart';
diff --git a/runtime/vm/compiler/backend/il.h b/runtime/vm/compiler/backend/il.h
index c7626f7..ad51a54 100644
--- a/runtime/vm/compiler/backend/il.h
+++ b/runtime/vm/compiler/backend/il.h
@@ -9412,7 +9412,7 @@
SIMD_BINARY_FLOAT_OP_LIST(M, BINARY_OP, Float32x4) \
SIMD_BINARY_FLOAT_OP_LIST(M, BINARY_OP, Float64x2) \
SIMD_BINARY_INTEGER_OP_LIST(M, BINARY_OP, Int32x4) \
- SIMD_PER_COMPONENT_XYZW(M, 1, Float32x4Shuffle, (Float32x4), Double) \
+ SIMD_PER_COMPONENT_XYZW(M, 1, Float32x4Get, (Float32x4), Double) \
SIMD_PER_COMPONENT_XYZW(M, 2, Float32x4With, (Double, Float32x4), Float32x4) \
SIMD_PER_COMPONENT_XYZW(M, 1, Int32x4GetFlag, (Int32x4), Bool) \
SIMD_PER_COMPONENT_XYZW(M, 2, Int32x4WithFlag, (Int32x4, Bool), Int32x4) \
diff --git a/runtime/vm/compiler/backend/il_arm.cc b/runtime/vm/compiler/backend/il_arm.cc
index d42f1c2..2775dde 100644
--- a/runtime/vm/compiler/backend/il_arm.cc
+++ b/runtime/vm/compiler/backend/il_arm.cc
@@ -5154,16 +5154,16 @@
// instructions. For arbitrary shuffles, use vtbl.
switch (instr->kind()) {
- case SimdOpInstr::kFloat32x4ShuffleX:
+ case SimdOpInstr::kFloat32x4GetX:
__ vcvtds(result.d(0), value.s(0));
break;
- case SimdOpInstr::kFloat32x4ShuffleY:
+ case SimdOpInstr::kFloat32x4GetY:
__ vcvtds(result.d(0), value.s(1));
break;
- case SimdOpInstr::kFloat32x4ShuffleZ:
+ case SimdOpInstr::kFloat32x4GetZ:
__ vcvtds(result.d(0), value.s(2));
break;
- case SimdOpInstr::kFloat32x4ShuffleW:
+ case SimdOpInstr::kFloat32x4GetW:
__ vcvtds(result.d(0), value.s(3));
break;
case SimdOpInstr::kInt32x4Shuffle:
@@ -5597,10 +5597,10 @@
CASE(Float64x2Mul) \
CASE(Float64x2Div) \
____(Float64x2BinaryOp) \
- CASE(Float32x4ShuffleX) \
- CASE(Float32x4ShuffleY) \
- CASE(Float32x4ShuffleZ) \
- CASE(Float32x4ShuffleW) \
+ CASE(Float32x4GetX) \
+ CASE(Float32x4GetY) \
+ CASE(Float32x4GetZ) \
+ CASE(Float32x4GetW) \
CASE(Int32x4Shuffle) \
CASE(Float32x4Shuffle) \
____(Simd32x4Shuffle) \
diff --git a/runtime/vm/compiler/backend/il_arm64.cc b/runtime/vm/compiler/backend/il_arm64.cc
index 2dfcd42..f0b8f86 100644
--- a/runtime/vm/compiler/backend/il_arm64.cc
+++ b/runtime/vm/compiler/backend/il_arm64.cc
@@ -4414,19 +4414,19 @@
break;
SIMD_OP_SIMPLE_UNARY(EMIT)
#undef EMIT
- case SimdOpInstr::kFloat32x4ShuffleX:
+ case SimdOpInstr::kFloat32x4GetX:
__ vinss(result, 0, value, 0);
__ fcvtds(result, result);
break;
- case SimdOpInstr::kFloat32x4ShuffleY:
+ case SimdOpInstr::kFloat32x4GetY:
__ vinss(result, 0, value, 1);
__ fcvtds(result, result);
break;
- case SimdOpInstr::kFloat32x4ShuffleZ:
+ case SimdOpInstr::kFloat32x4GetZ:
__ vinss(result, 0, value, 2);
__ fcvtds(result, result);
break;
- case SimdOpInstr::kFloat32x4ShuffleW:
+ case SimdOpInstr::kFloat32x4GetW:
__ vinss(result, 0, value, 3);
__ fcvtds(result, result);
break;
@@ -4705,10 +4705,10 @@
CASE(Float64x2Scale) \
____(SimdBinaryOp) \
SIMD_OP_SIMPLE_UNARY(CASE) \
- CASE(Float32x4ShuffleX) \
- CASE(Float32x4ShuffleY) \
- CASE(Float32x4ShuffleZ) \
- CASE(Float32x4ShuffleW) \
+ CASE(Float32x4GetX) \
+ CASE(Float32x4GetY) \
+ CASE(Float32x4GetZ) \
+ CASE(Float32x4GetW) \
CASE(Int32x4Shuffle) \
CASE(Float32x4Shuffle) \
CASE(Float32x4Splat) \
diff --git a/runtime/vm/compiler/backend/il_ia32.cc b/runtime/vm/compiler/backend/il_ia32.cc
index 9d1ffa4..355c0c0 100644
--- a/runtime/vm/compiler/backend/il_ia32.cc
+++ b/runtime/vm/compiler/backend/il_ia32.cc
@@ -4507,19 +4507,19 @@
break;
SIMD_OP_SIMPLE_UNARY(EMIT)
#undef EMIT
- case SimdOpInstr::kFloat32x4ShuffleX:
+ case SimdOpInstr::kFloat32x4GetX:
// Shuffle not necessary.
__ cvtss2sd(value, value);
break;
- case SimdOpInstr::kFloat32x4ShuffleY:
+ case SimdOpInstr::kFloat32x4GetY:
__ shufps(value, value, compiler::Immediate(0x55));
__ cvtss2sd(value, value);
break;
- case SimdOpInstr::kFloat32x4ShuffleZ:
+ case SimdOpInstr::kFloat32x4GetZ:
__ shufps(value, value, compiler::Immediate(0xAA));
__ cvtss2sd(value, value);
break;
- case SimdOpInstr::kFloat32x4ShuffleW:
+ case SimdOpInstr::kFloat32x4GetW:
__ shufps(value, value, compiler::Immediate(0xFF));
__ cvtss2sd(value, value);
break;
@@ -4739,10 +4739,10 @@
CASE(Float32x4WithW) \
____(SimdBinaryOp) \
SIMD_OP_SIMPLE_UNARY(CASE) \
- CASE(Float32x4ShuffleX) \
- CASE(Float32x4ShuffleY) \
- CASE(Float32x4ShuffleZ) \
- CASE(Float32x4ShuffleW) \
+ CASE(Float32x4GetX) \
+ CASE(Float32x4GetY) \
+ CASE(Float32x4GetZ) \
+ CASE(Float32x4GetW) \
CASE(Float32x4Shuffle) \
CASE(Int32x4Shuffle) \
CASE(Float32x4Splat) \
diff --git a/runtime/vm/compiler/backend/il_riscv.cc b/runtime/vm/compiler/backend/il_riscv.cc
index ba8d560..140c21d 100644
--- a/runtime/vm/compiler/backend/il_riscv.cc
+++ b/runtime/vm/compiler/backend/il_riscv.cc
@@ -4990,10 +4990,10 @@
CASE(Float64x2Scale) \
____(SimdBinaryOp) \
SIMD_OP_SIMPLE_UNARY(CASE) \
- CASE(Float32x4ShuffleX) \
- CASE(Float32x4ShuffleY) \
- CASE(Float32x4ShuffleZ) \
- CASE(Float32x4ShuffleW) \
+ CASE(Float32x4GetX) \
+ CASE(Float32x4GetY) \
+ CASE(Float32x4GetZ) \
+ CASE(Float32x4GetW) \
CASE(Int32x4Shuffle) \
CASE(Float32x4Shuffle) \
CASE(Float32x4Splat) \
diff --git a/runtime/vm/compiler/backend/il_x64.cc b/runtime/vm/compiler/backend/il_x64.cc
index 55fc995..8364d7a 100644
--- a/runtime/vm/compiler/backend/il_x64.cc
+++ b/runtime/vm/compiler/backend/il_x64.cc
@@ -4734,19 +4734,19 @@
break;
SIMD_OP_SIMPLE_UNARY(EMIT)
#undef EMIT
- case SimdOpInstr::kFloat32x4ShuffleX:
+ case SimdOpInstr::kFloat32x4GetX:
// Shuffle not necessary.
__ cvtss2sd(value, value);
break;
- case SimdOpInstr::kFloat32x4ShuffleY:
+ case SimdOpInstr::kFloat32x4GetY:
__ shufps(value, value, compiler::Immediate(0x55));
__ cvtss2sd(value, value);
break;
- case SimdOpInstr::kFloat32x4ShuffleZ:
+ case SimdOpInstr::kFloat32x4GetZ:
__ shufps(value, value, compiler::Immediate(0xAA));
__ cvtss2sd(value, value);
break;
- case SimdOpInstr::kFloat32x4ShuffleW:
+ case SimdOpInstr::kFloat32x4GetW:
__ shufps(value, value, compiler::Immediate(0xFF));
__ cvtss2sd(value, value);
break;
@@ -4965,10 +4965,10 @@
CASE(Float32x4WithW) \
____(SimdBinaryOp) \
SIMD_OP_SIMPLE_UNARY(CASE) \
- CASE(Float32x4ShuffleX) \
- CASE(Float32x4ShuffleY) \
- CASE(Float32x4ShuffleZ) \
- CASE(Float32x4ShuffleW) \
+ CASE(Float32x4GetX) \
+ CASE(Float32x4GetY) \
+ CASE(Float32x4GetZ) \
+ CASE(Float32x4GetW) \
CASE(Float32x4Shuffle) \
CASE(Int32x4Shuffle) \
CASE(Float32x4Splat) \
diff --git a/runtime/vm/compiler/backend/inliner.cc b/runtime/vm/compiler/backend/inliner.cc
index 575121f..4c8e06f 100644
--- a/runtime/vm/compiler/backend/inliner.cc
+++ b/runtime/vm/compiler/backend/inliner.cc
@@ -4058,10 +4058,10 @@
case MethodRecognizer::kFloat32x4Reciprocal:
case MethodRecognizer::kFloat32x4ReciprocalSqrt:
case MethodRecognizer::kFloat32x4Scale:
- case MethodRecognizer::kFloat32x4ShuffleW:
- case MethodRecognizer::kFloat32x4ShuffleX:
- case MethodRecognizer::kFloat32x4ShuffleY:
- case MethodRecognizer::kFloat32x4ShuffleZ:
+ case MethodRecognizer::kFloat32x4GetW:
+ case MethodRecognizer::kFloat32x4GetX:
+ case MethodRecognizer::kFloat32x4GetY:
+ case MethodRecognizer::kFloat32x4GetZ:
case MethodRecognizer::kFloat32x4Splat:
case MethodRecognizer::kFloat32x4Sqrt:
case MethodRecognizer::kFloat32x4ToFloat64x2:
diff --git a/runtime/vm/compiler/backend/redundancy_elimination.cc b/runtime/vm/compiler/backend/redundancy_elimination.cc
index 7d37d1f..5edf25f 100644
--- a/runtime/vm/compiler/backend/redundancy_elimination.cc
+++ b/runtime/vm/compiler/backend/redundancy_elimination.cc
@@ -3197,7 +3197,7 @@
};
void DeadStoreElimination::Optimize(FlowGraph* graph) {
- if (FLAG_dead_store_elimination) {
+ if (FLAG_dead_store_elimination && FLAG_load_cse) {
StoreOptimizer::OptimizeGraph(graph);
}
}
@@ -3599,6 +3599,12 @@
}
void AllocationSinking::Optimize() {
+ // Allocation sinking depends on load forwarding, so give up early if load
+ // forwarding is disabled.
+ if (!FLAG_load_cse || flow_graph_->is_huge_method()) {
+ return;
+ }
+
CollectCandidates();
// Insert MaterializeObject instructions that will describe the state of the
diff --git a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
index ff0c9bc..db660b5 100644
--- a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
+++ b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
@@ -5303,188 +5303,108 @@
const uint8_t flags = ReadByte(); // read flags.
- if ((flags & kYieldStatementFlagNative) == 0) {
- Fragment instructions;
- const bool is_yield_star = (flags & kYieldStatementFlagYieldStar) != 0;
+ Fragment instructions;
+ const bool is_yield_star = (flags & kYieldStatementFlagYieldStar) != 0;
- // Load :suspend_state variable using low-level FP-relative load
- // in order to avoid confusing SSA construction (which cannot
- // track its value as it is modified implicitly by stubs).
- LocalVariable* suspend_state = parsed_function()->suspend_state_var();
- ASSERT(suspend_state != nullptr);
- instructions += IntConstant(0);
- instructions += B->LoadFpRelativeSlot(
- compiler::target::frame_layout.FrameSlotForVariable(suspend_state) *
- compiler::target::kWordSize,
- CompileType::Dynamic(), kTagged);
- instructions += LoadNativeField(Slot::SuspendState_function_data());
+ // Load :suspend_state variable using low-level FP-relative load
+ // in order to avoid confusing SSA construction (which cannot
+ // track its value as it is modified implicitly by stubs).
+ LocalVariable* suspend_state = parsed_function()->suspend_state_var();
+ ASSERT(suspend_state != nullptr);
+ instructions += IntConstant(0);
+ instructions += B->LoadFpRelativeSlot(
+ compiler::target::frame_layout.FrameSlotForVariable(suspend_state) *
+ compiler::target::kWordSize,
+ CompileType::Dynamic(), kTagged);
+ instructions += LoadNativeField(Slot::SuspendState_function_data());
- instructions += BuildExpression(); // read expression.
- if (NeedsDebugStepCheck(parsed_function()->function(), pos)) {
- instructions += DebugStepCheck(pos);
- }
-
- if (parsed_function()->function().IsCompactAsyncStarFunction()) {
- // In the async* functions, generate the following code for yield <expr>:
- //
- // _AsyncStarStreamController controller = :suspend_state._functionData;
- // if (controller.add(<expr>)) {
- // return;
- // }
- // suspend();
- //
- // Generate the following code for yield* <expr>:
- //
- // _AsyncStarStreamController controller = :suspend_state._functionData;
- // controller.addStream(<expr>);
- // if (suspend()) {
- // return;
- // }
- //
-
- auto& add_method = Function::ZoneHandle(Z);
- if (is_yield_star) {
- add_method =
- IG->object_store()->async_star_stream_controller_add_stream();
- } else {
- add_method = IG->object_store()->async_star_stream_controller_add();
- }
- instructions += StaticCall(TokenPosition::kNoSource, add_method, 2,
- ICData::kNoRebind);
-
- if (is_yield_star) {
- // Discard result of _AsyncStarStreamController.addStream().
- instructions += Drop();
- // Suspend and test value passed to the resumed async* body.
- instructions += NullConstant();
- instructions += B->Suspend(pos, SuspendInstr::StubId::kYieldAsyncStar);
- } else {
- // Test value returned by _AsyncStarStreamController.add().
- }
-
- TargetEntryInstr* exit;
- TargetEntryInstr* continue_execution;
- instructions += BranchIfTrue(&exit, &continue_execution, false);
-
- Fragment do_exit(exit);
- do_exit += TranslateFinallyFinalizers(nullptr, -1);
- do_exit += NullConstant();
- do_exit += Return(TokenPosition::kNoSource);
-
- instructions = Fragment(instructions.entry, continue_execution);
- if (!is_yield_star) {
- instructions += NullConstant();
- instructions += B->Suspend(pos, SuspendInstr::StubId::kYieldAsyncStar);
- instructions += Drop();
- }
-
- } else if (parsed_function()->function().IsCompactSyncStarFunction()) {
- // In the sync* functions, generate the following code for yield <expr>:
- //
- // _SyncStarIterator iterator = :suspend_state._functionData;
- // iterator._current = <expr>;
- // suspend();
- //
- // Generate the following code for yield* <expr>:
- //
- // _SyncStarIterator iterator = :suspend_state._functionData;
- // iterator._yieldStarIterable = <expr>;
- // suspend();
- //
- auto& field = Field::ZoneHandle(Z);
- if (is_yield_star) {
- field = IG->object_store()->sync_star_iterator_yield_star_iterable();
- } else {
- field = IG->object_store()->sync_star_iterator_current();
- }
- instructions += B->StoreInstanceFieldGuarded(field);
- instructions += NullConstant();
- instructions += B->Suspend(pos, SuspendInstr::StubId::kYieldSyncStar);
- instructions += Drop();
- } else {
- UNREACHABLE();
- }
-
- return instructions;
- }
-
- ASSERT(flags == kYieldStatementFlagNative); // Must have been desugared.
-
- // Setup yield/continue point:
- //
- // ...
- // :await_jump_var = index;
- // :await_ctx_var = :current_context_var
- // return <expr>
- //
- // Continuation<index>:
- // Drop(1)
- // ...
- //
- // BuildGraphOfFunction will create a dispatch that jumps to
- // Continuation<:await_jump_var> upon entry to the function.
- //
- const intptr_t new_yield_pos = yield_continuations().length() + 1;
- Fragment instructions = IntConstant(new_yield_pos);
- instructions +=
- StoreLocal(TokenPosition::kNoSource, scopes()->yield_jump_variable);
- instructions += Drop();
- instructions += LoadLocal(parsed_function()->current_context_var());
- instructions +=
- StoreLocal(TokenPosition::kNoSource, scopes()->yield_context_variable);
- instructions += Drop();
instructions += BuildExpression(); // read expression.
- instructions += Return(pos, new_yield_pos);
-
- // Note: DropTempsInstr serves as an anchor instruction. It will not
- // be linked into the resulting graph.
- DropTempsInstr* anchor = new (Z) DropTempsInstr(0, nullptr);
- yield_continuations().Add(YieldContinuation(anchor, CurrentTryIndex()));
-
- Fragment continuation(instructions.entry, anchor);
- RELEASE_ASSERT(parsed_function()->function().IsAsyncClosure() ||
- parsed_function()->function().IsAsyncGenClosure() ||
- parsed_function()->function().IsSyncGenClosure());
-
- // TODO(43900): Only emit this when needed.
- {
- // Our sync-yielding functions can be invoked with either a yield result or
- // with an non-null exception & stacktrace.
- //
- // We detect the case we're in based on the nullability of stacktrace in
- //
- // :sync_op(:iterator, [:exception, :stack_trace]) { }
- //
- // or:
- //
- // :async_op(:result_or_exception, :stack_trace) { }
- //
- const auto& fun = parsed_function()->function();
- LocalVariable* exception_var =
- parsed_function()->ParameterVariable(fun.IsSyncGenClosure() ? 2 : 1);
- LocalVariable* stack_trace_var =
- parsed_function()->ParameterVariable(fun.IsSyncGenClosure() ? 3 : 2);
- ASSERT(stack_trace_var->name().ptr() ==
- Symbols::StackTraceParameter().ptr());
-
- TargetEntryInstr* no_error;
- TargetEntryInstr* error;
-
- continuation += LoadLocal(stack_trace_var);
- continuation += BranchIfNull(&no_error, &error);
-
- Fragment rethrow(/*instruction=*/error);
- rethrow += LoadLocal(exception_var);
- rethrow += LoadLocal(stack_trace_var);
-
- rethrow += RethrowException(pos, kInvalidTryIndex);
- Drop();
-
- // Set current to the end of the no_error branch.
- continuation = Fragment(/*entry=*/continuation.entry, /*current=*/no_error);
+ if (NeedsDebugStepCheck(parsed_function()->function(), pos)) {
+ instructions += DebugStepCheck(pos);
}
- return continuation;
+ if (parsed_function()->function().IsCompactAsyncStarFunction()) {
+ // In the async* functions, generate the following code for yield <expr>:
+ //
+ // _AsyncStarStreamController controller = :suspend_state._functionData;
+ // if (controller.add(<expr>)) {
+ // return;
+ // }
+ // suspend();
+ //
+ // Generate the following code for yield* <expr>:
+ //
+ // _AsyncStarStreamController controller = :suspend_state._functionData;
+ // controller.addStream(<expr>);
+ // if (suspend()) {
+ // return;
+ // }
+ //
+
+ auto& add_method = Function::ZoneHandle(Z);
+ if (is_yield_star) {
+ add_method =
+ IG->object_store()->async_star_stream_controller_add_stream();
+ } else {
+ add_method = IG->object_store()->async_star_stream_controller_add();
+ }
+ instructions +=
+ StaticCall(TokenPosition::kNoSource, add_method, 2, ICData::kNoRebind);
+
+ if (is_yield_star) {
+ // Discard result of _AsyncStarStreamController.addStream().
+ instructions += Drop();
+ // Suspend and test value passed to the resumed async* body.
+ instructions += NullConstant();
+ instructions += B->Suspend(pos, SuspendInstr::StubId::kYieldAsyncStar);
+ } else {
+ // Test value returned by _AsyncStarStreamController.add().
+ }
+
+ TargetEntryInstr* exit;
+ TargetEntryInstr* continue_execution;
+ instructions += BranchIfTrue(&exit, &continue_execution, false);
+
+ Fragment do_exit(exit);
+ do_exit += TranslateFinallyFinalizers(nullptr, -1);
+ do_exit += NullConstant();
+ do_exit += Return(TokenPosition::kNoSource);
+
+ instructions = Fragment(instructions.entry, continue_execution);
+ if (!is_yield_star) {
+ instructions += NullConstant();
+ instructions += B->Suspend(pos, SuspendInstr::StubId::kYieldAsyncStar);
+ instructions += Drop();
+ }
+
+ } else if (parsed_function()->function().IsCompactSyncStarFunction()) {
+ // In the sync* functions, generate the following code for yield <expr>:
+ //
+ // _SyncStarIterator iterator = :suspend_state._functionData;
+ // iterator._current = <expr>;
+ // suspend();
+ //
+ // Generate the following code for yield* <expr>:
+ //
+ // _SyncStarIterator iterator = :suspend_state._functionData;
+ // iterator._yieldStarIterable = <expr>;
+ // suspend();
+ //
+ auto& field = Field::ZoneHandle(Z);
+ if (is_yield_star) {
+ field = IG->object_store()->sync_star_iterator_yield_star_iterable();
+ } else {
+ field = IG->object_store()->sync_star_iterator_current();
+ }
+ instructions += B->StoreInstanceFieldGuarded(field);
+ instructions += NullConstant();
+ instructions += B->Suspend(pos, SuspendInstr::StubId::kYieldSyncStar);
+ instructions += Drop();
+ } else {
+ UNREACHABLE();
+ }
+
+ return instructions;
}
Fragment StreamingFlowGraphBuilder::BuildVariableDeclaration(
@@ -5667,10 +5587,8 @@
function.set_is_visible(true);
ASSERT(function.IsCompactSyncStarFunction());
} else {
- ASSERT((function_node_helper.async_marker_ ==
- FunctionNodeHelper::kSync) ||
- (function_node_helper.async_marker_ ==
- FunctionNodeHelper::kSyncYielding));
+ ASSERT(function_node_helper.async_marker_ ==
+ FunctionNodeHelper::kSync);
function.set_is_debuggable(function_node_helper.dart_async_marker_ ==
FunctionNodeHelper::kSync);
switch (function_node_helper.dart_async_marker_) {
@@ -5687,8 +5605,7 @@
// no special modifier
break;
}
- function.set_is_generated_body(function_node_helper.async_marker_ ==
- FunctionNodeHelper::kSyncYielding);
+ function.set_is_generated_body(false);
// sync* functions contain two nested synthetic functions,
// the first of which (sync_op_gen) is a regular sync function so we
// need to manually label it generated:
diff --git a/runtime/vm/compiler/frontend/kernel_translation_helper.h b/runtime/vm/compiler/frontend/kernel_translation_helper.h
index e8067f4..314cab9 100644
--- a/runtime/vm/compiler/frontend/kernel_translation_helper.h
+++ b/runtime/vm/compiler/frontend/kernel_translation_helper.h
@@ -307,7 +307,6 @@
kSyncStar = 1,
kAsync = 2,
kAsyncStar = 3,
- kSyncYielding = 4,
};
explicit FunctionNodeHelper(KernelReaderHelper* helper) {
diff --git a/runtime/vm/compiler/frontend/scope_builder.cc b/runtime/vm/compiler/frontend/scope_builder.cc
index 2db5f8f..3e7f2f8 100644
--- a/runtime/vm/compiler/frontend/scope_builder.cc
+++ b/runtime/vm/compiler/frontend/scope_builder.cc
@@ -570,50 +570,6 @@
first_body_token_position_ = helper_.reader_.min_position();
}
- // Ensure that :await_jump_var, :await_ctx_var, :async_op, :is_sync and
- // :async_future are captured.
- if (function_node_helper.async_marker_ == FunctionNodeHelper::kSyncYielding) {
- {
- LocalVariable* temp = nullptr;
- LookupCapturedVariableByName(
- (depth_.function_ == 0) ? &result_->yield_jump_variable : &temp,
- Symbols::AwaitJumpVar());
- }
- {
- LocalVariable* temp = nullptr;
- LookupCapturedVariableByName(
- (depth_.function_ == 0) ? &result_->yield_context_variable : &temp,
- Symbols::AwaitContextVar());
- }
- {
- LocalVariable* temp =
- scope_->LookupVariable(Symbols::AsyncOperation(), true);
- if (temp != nullptr) {
- scope_->CaptureVariable(temp);
- }
- }
- {
- LocalVariable* temp =
- scope_->LookupVariable(Symbols::AsyncFuture(), true);
- if (temp != nullptr) {
- scope_->CaptureVariable(temp);
- }
- }
- {
- LocalVariable* temp = scope_->LookupVariable(Symbols::is_sync(), true);
- if (temp != nullptr) {
- scope_->CaptureVariable(temp);
- }
- }
- {
- LocalVariable* temp =
- scope_->LookupVariable(Symbols::ControllerStream(), true);
- if (temp != nullptr) {
- scope_->CaptureVariable(temp);
- }
- }
- }
-
// Mark known chained futures such as _Future::timeout()'s _future.
if (function.recognized_kind() == MethodRecognizer::kFutureTimeout &&
depth_.function_ == 1) {
@@ -1289,20 +1245,8 @@
}
case kYieldStatement: {
helper_.ReadPosition(); // read position.
- word flags = helper_.ReadByte(); // read flags.
+ helper_.ReadByte(); // read flags.
VisitExpression(); // read expression.
-
- if ((flags & kYieldStatementFlagNative) != 0) {
- if (depth_.function_ == 0) {
- AddSwitchVariable();
- // Promote all currently visible local variables into the context.
- // TODO(27590) CaptureLocalVariables promotes to many variables into
- // the scope. Mark those variables as stack_local.
- // TODO(27590) we don't need to promote those variables that are
- // not used across yields.
- scope_->CaptureLocalVariables(current_function_scope_);
- }
- }
return;
}
case kVariableDeclaration:
@@ -1635,13 +1579,6 @@
variable->set_is_explicit_covariant_parameter();
}
- // The :sync_op and :async_op continuations are called multiple times. So we
- // don't want the parameters from the first invocation to get stored in the
- // context and reused on later invocations with different parameters.
- if (current_function_async_marker_ == FunctionNodeHelper::kSyncYielding) {
- variable->set_is_forced_stack();
- }
-
const bool needs_covariant_check_in_method =
helper.IsCovariant() ||
(helper.IsGenericCovariantImpl() &&
@@ -1730,23 +1667,6 @@
intptr_t nesting_depth) {
LocalVariable* v = NULL;
- // If we are inside a function with yield points then Kernel transformer
- // could have lifted some of the auxiliary exception variables into the
- // context to preserve them across yield points because they might
- // be needed for rethrow.
- // Check if it did and capture such variables instead of introducing
- // new local ones.
- // Note: function that wrap kSyncYielding function does not contain
- // its own try/catches.
- if (current_function_async_marker_ == FunctionNodeHelper::kSyncYielding) {
- ASSERT(current_function_scope_->parent() != NULL);
- v = current_function_scope_->parent()->LocalLookupVariable(
- GenerateName(prefix, nesting_depth - 1));
- if (v != NULL) {
- scope_->CaptureVariable(v);
- }
- }
-
// No need to create variables for try/catch-statements inside
// nested functions.
if (depth_.function_ > 0) return;
diff --git a/runtime/vm/compiler/graph_intrinsifier.cc b/runtime/vm/compiler/graph_intrinsifier.cc
index 148a752..9765e4e 100644
--- a/runtime/vm/compiler/graph_intrinsifier.cc
+++ b/runtime/vm/compiler/graph_intrinsifier.cc
@@ -673,8 +673,8 @@
return BuildSimdOp(flow_graph, kFloat64x2Cid, Token::kADD);
}
-static bool BuildFloat32x4Shuffle(FlowGraph* flow_graph,
- MethodRecognizer::Kind kind) {
+static bool BuildFloat32x4Get(FlowGraph* flow_graph,
+ MethodRecognizer::Kind kind) {
if (!FlowGraphCompiler::SupportsUnboxedDoubles() ||
!FlowGraphCompiler::SupportsUnboxedSimd128()) {
return false;
@@ -702,24 +702,20 @@
return true;
}
-bool GraphIntrinsifier::Build_Float32x4ShuffleX(FlowGraph* flow_graph) {
- return BuildFloat32x4Shuffle(flow_graph,
- MethodRecognizer::kFloat32x4ShuffleX);
+bool GraphIntrinsifier::Build_Float32x4GetX(FlowGraph* flow_graph) {
+ return BuildFloat32x4Get(flow_graph, MethodRecognizer::kFloat32x4GetX);
}
-bool GraphIntrinsifier::Build_Float32x4ShuffleY(FlowGraph* flow_graph) {
- return BuildFloat32x4Shuffle(flow_graph,
- MethodRecognizer::kFloat32x4ShuffleY);
+bool GraphIntrinsifier::Build_Float32x4GetY(FlowGraph* flow_graph) {
+ return BuildFloat32x4Get(flow_graph, MethodRecognizer::kFloat32x4GetY);
}
-bool GraphIntrinsifier::Build_Float32x4ShuffleZ(FlowGraph* flow_graph) {
- return BuildFloat32x4Shuffle(flow_graph,
- MethodRecognizer::kFloat32x4ShuffleZ);
+bool GraphIntrinsifier::Build_Float32x4GetZ(FlowGraph* flow_graph) {
+ return BuildFloat32x4Get(flow_graph, MethodRecognizer::kFloat32x4GetZ);
}
-bool GraphIntrinsifier::Build_Float32x4ShuffleW(FlowGraph* flow_graph) {
- return BuildFloat32x4Shuffle(flow_graph,
- MethodRecognizer::kFloat32x4ShuffleW);
+bool GraphIntrinsifier::Build_Float32x4GetW(FlowGraph* flow_graph) {
+ return BuildFloat32x4Get(flow_graph, MethodRecognizer::kFloat32x4GetW);
}
static bool BuildLoadField(FlowGraph* flow_graph, const Slot& field) {
diff --git a/runtime/vm/compiler/recognized_methods_list.h b/runtime/vm/compiler/recognized_methods_list.h
index 010e653..726488f 100644
--- a/runtime/vm/compiler/recognized_methods_list.h
+++ b/runtime/vm/compiler/recognized_methods_list.h
@@ -386,10 +386,10 @@
V(_Float64x2List, []=, Float64x2ArraySetIndexed, 0x8af8aa58) \
V(_TypedListBase, get:length, TypedListBaseLength, 0x5850f06b) \
V(_ByteDataView, get:length, ByteDataViewLength, 0x5850f06b) \
- V(_Float32x4, get:x, Float32x4ShuffleX, 0x3a398530) \
- V(_Float32x4, get:y, Float32x4ShuffleY, 0x27cae053) \
- V(_Float32x4, get:z, Float32x4ShuffleZ, 0x5d964be9) \
- V(_Float32x4, get:w, Float32x4ShuffleW, 0x3fd6906b) \
+ V(_Float32x4, get:x, Float32x4GetX, 0x3a398530) \
+ V(_Float32x4, get:y, Float32x4GetY, 0x27cae053) \
+ V(_Float32x4, get:z, Float32x4GetZ, 0x5d964be9) \
+ V(_Float32x4, get:w, Float32x4GetW, 0x3fd6906b) \
V(_Float32x4, *, Float32x4Mul, 0xe5507c87) \
V(_Float32x4, /, Float32x4Div, 0xc09f2f62) \
V(_Float32x4, -, Float32x4Sub, 0xdd326c4a) \
diff --git a/runtime/vm/kernel_binary.h b/runtime/vm/kernel_binary.h
index 3801578..b0658b3 100644
--- a/runtime/vm/kernel_binary.h
+++ b/runtime/vm/kernel_binary.h
@@ -20,8 +20,8 @@
static const uint32_t kMagicProgramFile = 0x90ABCDEFu;
// Both version numbers are inclusive.
-static const uint32_t kMinSupportedKernelFormatVersion = 82;
-static const uint32_t kMaxSupportedKernelFormatVersion = 82;
+static const uint32_t kMinSupportedKernelFormatVersion = 83;
+static const uint32_t kMaxSupportedKernelFormatVersion = 83;
// Keep in sync with package:kernel/lib/binary/tag.dart
#define KERNEL_TAG_LIST(V) \
@@ -218,7 +218,6 @@
// Keep in sync with package:kernel/lib/ast.dart
enum YieldStatementFlags {
kYieldStatementFlagYieldStar = 1 << 0,
- kYieldStatementFlagNative = 1 << 1,
};
// Keep in sync with package:kernel/lib/ast.dart
diff --git a/sdk/lib/_internal/js_dev_runtime/patch/developer_patch.dart b/sdk/lib/_internal/js_dev_runtime/patch/developer_patch.dart
index c451d7f..729dc22 100644
--- a/sdk/lib/_internal/js_dev_runtime/patch/developer_patch.dart
+++ b/sdk/lib/_internal/js_dev_runtime/patch/developer_patch.dart
@@ -213,9 +213,9 @@
return existingTag;
}
// Throw an exception if we've reached the maximum number of user tags.
- if (_instances.length == UserTag.MAX_USER_TAGS) {
+ if (_instances.length == UserTag.maxUserTags) {
throw UnsupportedError(
- 'UserTag instance limit (${UserTag.MAX_USER_TAGS}) reached.');
+ 'UserTag instance limit (${UserTag.maxUserTags}) reached.');
}
return _instances[label] = _FakeUserTag.real(label);
}
diff --git a/sdk/lib/_internal/js_runtime/lib/developer_patch.dart b/sdk/lib/_internal/js_runtime/lib/developer_patch.dart
index 54f7ca1..05db6d6 100644
--- a/sdk/lib/_internal/js_runtime/lib/developer_patch.dart
+++ b/sdk/lib/_internal/js_runtime/lib/developer_patch.dart
@@ -136,9 +136,9 @@
return existingTag;
}
// Throw an exception if we've reached the maximum number of user tags.
- if (_instances.length == UserTag.MAX_USER_TAGS) {
+ if (_instances.length == UserTag.maxUserTags) {
throw UnsupportedError(
- 'UserTag instance limit (${UserTag.MAX_USER_TAGS}) reached.');
+ 'UserTag instance limit (${UserTag.maxUserTags}) reached.');
}
return _instances[label] = _FakeUserTag.real(label);
}
diff --git a/sdk/lib/developer/profiler.dart b/sdk/lib/developer/profiler.dart
index 54bfd25..bf6ae6b 100644
--- a/sdk/lib/developer/profiler.dart
+++ b/sdk/lib/developer/profiler.dart
@@ -8,7 +8,12 @@
/// [DevTools CPU profiler](https://flutter.dev/docs/development/tools/devtools/cpu-profiler).
abstract class UserTag {
/// The maximum number of UserTag instances that can be created by a program.
- static const MAX_USER_TAGS = 64;
+ static const maxUserTags = 64;
+
+ @deprecated
+ // TODO: We shouldn't be using SCREAMING_CAPS for constants, so this should
+ // be removed for Dart 3.0.
+ static const MAX_USER_TAGS = maxUserTags;
external factory UserTag(String label);
@@ -112,7 +117,7 @@
/// The current set of registered [Metric]s.
static UnmodifiableMapView<String, Metric> get current =>
UnmodifiableMapView<String, Metric>(_metrics);
- static final Map<String, Metric> _metrics = new Map<String, Metric>();
+ static final _metrics = <String, Metric>{};
/// Register [Metric]s to make them visible to Observatory.
static void register(Metric metric) {
diff --git a/tests/lib/async/syncstar_mixed_iterators_test.dart b/tests/lib/async/syncstar_mixed_iterators_test.dart
index 2b2ecf1..338c52b 100644
--- a/tests/lib/async/syncstar_mixed_iterators_test.dart
+++ b/tests/lib/async/syncstar_mixed_iterators_test.dart
@@ -3,13 +3,13 @@
// BSD-style license that can be found in the LICENSE file.
//
// Test that sync* correctly iterates through nested iterators of both
-// the internal sync* transform _SyncIterable and generic Iterable types.
+// the internal sync* iterable and generic Iterable types.
import "package:expect/expect.dart";
Iterable<int> outerSyncStar() sync* {
yield 1;
- // _SyncIterable<int>:
+ // internal sync* iterable:
yield* innerSyncStar();
yield 4;
// Generic Iterable<int>:
diff --git a/tools/VERSION b/tools/VERSION
index 2c1d3fb..1ea2e37 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 18
PATCH 0
-PRERELEASE 274
+PRERELEASE 275
PRERELEASE_PATCH 0
\ No newline at end of file
