Version 2.17.0-256.0.dev
Merge commit 'b55dc762fa8858d747759bba29900891cb2ecc68' into 'dev'
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 9280fed..3e7b432 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -233,8 +233,16 @@
tracker.
`dart --verbose pub [command]` will also cause the log file to be written.
+- `dart pub global activate --source=git` now takes arguments `--git-path` to
+ specify the path of the activated package in the pubspec and `--git-ref` to
+ specify the branch or revision to check out.
- `dart pub add` can now add multiple packages in one command.
-
+- `dart pub token add` can now add a token for [pub.dev](https://pub.dev).
+- `dart pub uploader` has been removed. To manage uploaders for a package use
+ the `https://pub.dev/<packagename>/admin` web-interface.
+- Pub now supports a separate `pubspec_overrides.yaml` file that can contain
+ `dependency_overrides`. This makes it easier to avoid checking the local
+ overrides into version control.
#### Linter
Updated the Linter to `1.18.0`, which includes changes that
diff --git a/DEPS b/DEPS
index 3dce774..9d89269 100644
--- a/DEPS
+++ b/DEPS
@@ -141,7 +141,7 @@
"pool_rev": "7abe634002a1ba8a0928eded086062f1307ccfae",
"process_rev": "56ece43b53b64c63ae51ec184b76bd5360c28d0b",
"protobuf_rev": "c1eb6cb51af39ccbaa1a8e19349546586a5c8e31",
- "pub_rev": "8f5ab7b1aba3b9f66b56246d77e167990339d317",
+ "pub_rev": "a3a102a549388a6dbfecc9252fabb618f9a2f5f7",
"pub_semver_rev": "ea6c54019948dc03042c595ce9413e17aaf7aa38",
"root_certificates_rev": "692f6d6488af68e0121317a9c2c9eb393eb0ee50",
"rust_revision": "b7856f695d65a8ebc846754f97d15814bcb1c244",
diff --git a/benchmarks/AsyncLiveVars/dart/AsyncLiveVars.dart b/benchmarks/AsyncLiveVars/dart/AsyncLiveVars.dart
new file mode 100644
index 0000000..7969da6
--- /dev/null
+++ b/benchmarks/AsyncLiveVars/dart/AsyncLiveVars.dart
@@ -0,0 +1,305 @@
+// 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.
+
+// Micro-benchmark for testing async/await performance in presence of
+// different number of live values across await.
+
+import 'dart:async';
+
+import 'async_benchmark_base.dart' show AsyncBenchmarkBase;
+
+class MockClass {
+ static final String str = "${int.parse('42')}";
+ static final List<int> list =
+ List<int>.filled(int.parse('3'), int.parse('42'));
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ String get1() => str;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ List<int> get2() => list;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use1(String a0) => a0.length;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use2(String a0, List<int> a1) => a0.length + a1.length;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use4(String a0, List<int> a1, String a2, List<int> a3) =>
+ a0.length + a1.length + a2.length + a3.length;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use8(String a0, List<int> a1, String a2, List<int> a3, String a4,
+ List<int> a5, String a6, List<int> a7) =>
+ a0.length +
+ a1.length +
+ a2.length +
+ a3.length +
+ a4.length +
+ a5.length +
+ a6.length +
+ a7.length;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ Future<void> asyncMethod() async {}
+}
+
+class MockClass2 {
+ static int val1 = int.parse('42');
+ static int val2 = int.parse('43');
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ int get1() => val1;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ int get2() => val2;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use1(int a0) => a0;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use2(int a0, int a1) => a0 + a1;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use4(int a0, int a1, int a2, int a3) => a0 + a1 + a2 + a3;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ Future<void> asyncMethod() async {}
+}
+
+class LiveVarsBench extends AsyncBenchmarkBase {
+ LiveVarsBench(String name) : super(name);
+ @override
+ Future<void> exercise() async {
+ // These micro-benchmarks are too small, so
+ // make a larger number of iterations per measurement.
+ for (var i = 0; i < 10000; i++) {
+ await run();
+ }
+ }
+}
+
+class LiveObj1 extends LiveVarsBench {
+ LiveObj1() : super('AsyncLiveVars.LiveObj1');
+ final field1 = MockClass();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ }
+}
+
+class LiveObj2 extends LiveVarsBench {
+ LiveObj2() : super('AsyncLiveVars.LiveObj2');
+ final field1 = MockClass();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ final obj2 = field1.get2();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field1.asyncMethod();
+ field1.use2(obj1, obj2);
+ }
+}
+
+class LiveObj4 extends LiveVarsBench {
+ LiveObj4() : super('AsyncLiveVars.LiveObj4');
+ final field1 = MockClass();
+ final field2 = MockClass();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ final obj2 = field1.get2();
+ final obj3 = field2.get1();
+ final obj4 = field2.get2();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field1.asyncMethod();
+ field2.use1(obj3);
+ await field2.asyncMethod();
+ field1.use4(obj1, obj2, obj3, obj4);
+ }
+}
+
+class LiveObj8 extends LiveVarsBench {
+ LiveObj8() : super('AsyncLiveVars.LiveObj8');
+ final field1 = MockClass();
+ final field2 = MockClass();
+ final field3 = MockClass();
+ final field4 = MockClass();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ final obj2 = field1.get2();
+ final obj3 = field2.get1();
+ final obj4 = field2.get2();
+ final obj5 = field3.get1();
+ final obj6 = field3.get2();
+ final obj7 = field4.get1();
+ final obj8 = field4.get2();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field2.asyncMethod();
+ field3.use2(obj5, obj6);
+ await field4.asyncMethod();
+ field2.use8(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8);
+ }
+}
+
+class LiveObj16 extends LiveVarsBench {
+ LiveObj16() : super('AsyncLiveVars.LiveObj16');
+ final field1 = MockClass();
+ final field2 = MockClass();
+ final field3 = MockClass();
+ final field4 = MockClass();
+ final field5 = MockClass();
+ final field6 = MockClass();
+ final field7 = MockClass();
+ final field8 = MockClass();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ final obj2 = field1.get2();
+ final obj3 = field2.get1();
+ final obj4 = field2.get2();
+ final obj5 = field3.get1();
+ final obj6 = field3.get2();
+ final obj7 = field4.get1();
+ final obj8 = field4.get2();
+ final obj9 = field5.get1();
+ final obj10 = field5.get2();
+ final obj11 = field6.get1();
+ final obj12 = field6.get2();
+ final obj13 = field7.get1();
+ final obj14 = field7.get2();
+ final obj15 = field8.get1();
+ final obj16 = field8.get2();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field2.asyncMethod();
+ field5.use2(obj11, obj12);
+ await field4.asyncMethod();
+ field2.use8(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8);
+ field3.use8(obj9, obj10, obj11, obj12, obj13, obj14, obj15, obj16);
+ }
+}
+
+class LiveInt1 extends LiveVarsBench {
+ LiveInt1() : super('AsyncLiveVars.LiveInt1');
+ final field1 = MockClass2();
+ @override
+ Future<void> run() async {
+ final int1 = field1.get1();
+ await field1.asyncMethod();
+ field1.use1(int1);
+ await field1.asyncMethod();
+ field1.use1(int1);
+ await field1.asyncMethod();
+ field1.use1(int1);
+ }
+}
+
+class LiveInt4 extends LiveVarsBench {
+ LiveInt4() : super('AsyncLiveVars.LiveInt4');
+ final field1 = MockClass2();
+ final field2 = MockClass2();
+ @override
+ Future<void> run() async {
+ final int1 = field1.get1();
+ final int2 = field1.get2();
+ final int3 = field2.get1();
+ final int4 = field2.get2();
+ await field1.asyncMethod();
+ field1.use1(int1);
+ await field1.asyncMethod();
+ field2.use1(int3);
+ await field2.asyncMethod();
+ field1.use4(int1, int2, int3, int4);
+ }
+}
+
+class LiveObj2Int2 extends LiveVarsBench {
+ LiveObj2Int2() : super('AsyncLiveVars.LiveObj2Int2');
+ final field1 = MockClass();
+ final field2 = MockClass2();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ final obj2 = field1.get2();
+ final int1 = field2.get1();
+ final int2 = field2.get2();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field1.asyncMethod();
+ field2.use1(int1);
+ await field2.asyncMethod();
+ field1.use2(obj1, obj2);
+ field2.use2(int1, int2);
+ }
+}
+
+class LiveObj4Int4 extends LiveVarsBench {
+ LiveObj4Int4() : super('AsyncLiveVars.LiveObj4Int4');
+ final field1 = MockClass();
+ final field2 = MockClass();
+ final field3 = MockClass2();
+ final field4 = MockClass2();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ final obj2 = field1.get2();
+ final obj3 = field2.get1();
+ final obj4 = field2.get2();
+ final int1 = field3.get1();
+ final int2 = field3.get2();
+ final int3 = field4.get1();
+ final int4 = field4.get2();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field2.asyncMethod();
+ field3.use2(int2, int4);
+ await field4.asyncMethod();
+ field2.use4(obj1, obj2, obj3, obj4);
+ field4.use4(int1, int2, int3, int4);
+ }
+}
+
+Future<void> main() async {
+ final benchmarks = [
+ LiveObj1(),
+ LiveObj2(),
+ LiveObj4(),
+ LiveObj8(),
+ LiveObj16(),
+ LiveInt1(),
+ LiveInt4(),
+ LiveObj2Int2(),
+ LiveObj4Int4()
+ ];
+ for (final bench in benchmarks) {
+ await bench.report();
+ }
+}
diff --git a/benchmarks/AsyncLiveVars/dart/async_benchmark_base.dart b/benchmarks/AsyncLiveVars/dart/async_benchmark_base.dart
new file mode 100644
index 0000000..9a415b9
--- /dev/null
+++ b/benchmarks/AsyncLiveVars/dart/async_benchmark_base.dart
@@ -0,0 +1,68 @@
+// 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:benchmark_harness/benchmark_harness.dart'
+ show PrintEmitter, ScoreEmitter;
+
+// Similar to BenchmarkBase from package:benchmark_harness.
+class AsyncBenchmarkBase {
+ final String name;
+ final ScoreEmitter emitter;
+
+ // Empty constructor.
+ const AsyncBenchmarkBase(this.name, {this.emitter = const PrintEmitter()});
+
+ // The benchmark code.
+ // This function is not used, if both [warmup] and [exercise] are overwritten.
+ Future<void> run() async {}
+
+ // Runs a short version of the benchmark. By default invokes [run] once.
+ Future<void> warmup() async {
+ await run();
+ }
+
+ // Exercises the benchmark. By default invokes [run] 10 times.
+ Future<void> exercise() async {
+ for (var i = 0; i < 10; i++) {
+ await run();
+ }
+ }
+
+ // Not measured setup code executed prior to the benchmark runs.
+ Future<void> setup() async {}
+
+ // Not measures teardown code executed after the benchark runs.
+ Future<void> teardown() async {}
+
+ // Measures the score for this benchmark by executing it repeatedly until
+ // time minimum has been reached.
+ static Future<double> measureFor(Function f, int minimumMillis) async {
+ final int minimumMicros = minimumMillis * 1000;
+ int iter = 0;
+ final watch = Stopwatch();
+ watch.start();
+ int elapsed = 0;
+ while (elapsed < minimumMicros) {
+ await f();
+ elapsed = watch.elapsedMicroseconds;
+ iter++;
+ }
+ return elapsed / iter;
+ }
+
+ // Measures the score for the benchmark and returns it.
+ Future<double> measure() async {
+ await setup();
+ // Warmup for at least 100ms. Discard result.
+ await measureFor(warmup, 100);
+ // Run the benchmark for at least 2000ms.
+ final result = await measureFor(exercise, 2000);
+ await teardown();
+ return result;
+ }
+
+ Future<void> report() async {
+ emitter.emit(name, await measure());
+ }
+}
diff --git a/benchmarks/AsyncLiveVars/dart2/AsyncLiveVars.dart b/benchmarks/AsyncLiveVars/dart2/AsyncLiveVars.dart
new file mode 100644
index 0000000..9176274
--- /dev/null
+++ b/benchmarks/AsyncLiveVars/dart2/AsyncLiveVars.dart
@@ -0,0 +1,307 @@
+// 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.
+
+// Micro-benchmark for testing async/await performance in presence of
+// different number of live values across await.
+
+// @dart=2.9
+
+import 'dart:async';
+
+import 'async_benchmark_base.dart' show AsyncBenchmarkBase;
+
+class MockClass {
+ static final String str = "${int.parse('42')}";
+ static final List<int> list =
+ List<int>.filled(int.parse('3'), int.parse('42'));
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ String get1() => str;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ List<int> get2() => list;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use1(String a0) => a0.length;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use2(String a0, List<int> a1) => a0.length + a1.length;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use4(String a0, List<int> a1, String a2, List<int> a3) =>
+ a0.length + a1.length + a2.length + a3.length;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use8(String a0, List<int> a1, String a2, List<int> a3, String a4,
+ List<int> a5, String a6, List<int> a7) =>
+ a0.length +
+ a1.length +
+ a2.length +
+ a3.length +
+ a4.length +
+ a5.length +
+ a6.length +
+ a7.length;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ Future<void> asyncMethod() async {}
+}
+
+class MockClass2 {
+ static int val1 = int.parse('42');
+ static int val2 = int.parse('43');
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ int get1() => val1;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ int get2() => val2;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use1(int a0) => a0;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use2(int a0, int a1) => a0 + a1;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ void use4(int a0, int a1, int a2, int a3) => a0 + a1 + a2 + a3;
+
+ @pragma('vm:never-inline')
+ @pragma('dart2js:noInline')
+ Future<void> asyncMethod() async {}
+}
+
+class LiveVarsBench extends AsyncBenchmarkBase {
+ LiveVarsBench(String name) : super(name);
+ @override
+ Future<void> exercise() async {
+ // These micro-benchmarks are too small, so
+ // make a larger number of iterations per measurement.
+ for (var i = 0; i < 10000; i++) {
+ await run();
+ }
+ }
+}
+
+class LiveObj1 extends LiveVarsBench {
+ LiveObj1() : super('AsyncLiveVars.LiveObj1');
+ final field1 = MockClass();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ }
+}
+
+class LiveObj2 extends LiveVarsBench {
+ LiveObj2() : super('AsyncLiveVars.LiveObj2');
+ final field1 = MockClass();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ final obj2 = field1.get2();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field1.asyncMethod();
+ field1.use2(obj1, obj2);
+ }
+}
+
+class LiveObj4 extends LiveVarsBench {
+ LiveObj4() : super('AsyncLiveVars.LiveObj4');
+ final field1 = MockClass();
+ final field2 = MockClass();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ final obj2 = field1.get2();
+ final obj3 = field2.get1();
+ final obj4 = field2.get2();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field1.asyncMethod();
+ field2.use1(obj3);
+ await field2.asyncMethod();
+ field1.use4(obj1, obj2, obj3, obj4);
+ }
+}
+
+class LiveObj8 extends LiveVarsBench {
+ LiveObj8() : super('AsyncLiveVars.LiveObj8');
+ final field1 = MockClass();
+ final field2 = MockClass();
+ final field3 = MockClass();
+ final field4 = MockClass();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ final obj2 = field1.get2();
+ final obj3 = field2.get1();
+ final obj4 = field2.get2();
+ final obj5 = field3.get1();
+ final obj6 = field3.get2();
+ final obj7 = field4.get1();
+ final obj8 = field4.get2();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field2.asyncMethod();
+ field3.use2(obj5, obj6);
+ await field4.asyncMethod();
+ field2.use8(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8);
+ }
+}
+
+class LiveObj16 extends LiveVarsBench {
+ LiveObj16() : super('AsyncLiveVars.LiveObj16');
+ final field1 = MockClass();
+ final field2 = MockClass();
+ final field3 = MockClass();
+ final field4 = MockClass();
+ final field5 = MockClass();
+ final field6 = MockClass();
+ final field7 = MockClass();
+ final field8 = MockClass();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ final obj2 = field1.get2();
+ final obj3 = field2.get1();
+ final obj4 = field2.get2();
+ final obj5 = field3.get1();
+ final obj6 = field3.get2();
+ final obj7 = field4.get1();
+ final obj8 = field4.get2();
+ final obj9 = field5.get1();
+ final obj10 = field5.get2();
+ final obj11 = field6.get1();
+ final obj12 = field6.get2();
+ final obj13 = field7.get1();
+ final obj14 = field7.get2();
+ final obj15 = field8.get1();
+ final obj16 = field8.get2();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field2.asyncMethod();
+ field5.use2(obj11, obj12);
+ await field4.asyncMethod();
+ field2.use8(obj1, obj2, obj3, obj4, obj5, obj6, obj7, obj8);
+ field3.use8(obj9, obj10, obj11, obj12, obj13, obj14, obj15, obj16);
+ }
+}
+
+class LiveInt1 extends LiveVarsBench {
+ LiveInt1() : super('AsyncLiveVars.LiveInt1');
+ final field1 = MockClass2();
+ @override
+ Future<void> run() async {
+ final int1 = field1.get1();
+ await field1.asyncMethod();
+ field1.use1(int1);
+ await field1.asyncMethod();
+ field1.use1(int1);
+ await field1.asyncMethod();
+ field1.use1(int1);
+ }
+}
+
+class LiveInt4 extends LiveVarsBench {
+ LiveInt4() : super('AsyncLiveVars.LiveInt4');
+ final field1 = MockClass2();
+ final field2 = MockClass2();
+ @override
+ Future<void> run() async {
+ final int1 = field1.get1();
+ final int2 = field1.get2();
+ final int3 = field2.get1();
+ final int4 = field2.get2();
+ await field1.asyncMethod();
+ field1.use1(int1);
+ await field1.asyncMethod();
+ field2.use1(int3);
+ await field2.asyncMethod();
+ field1.use4(int1, int2, int3, int4);
+ }
+}
+
+class LiveObj2Int2 extends LiveVarsBench {
+ LiveObj2Int2() : super('AsyncLiveVars.LiveObj2Int2');
+ final field1 = MockClass();
+ final field2 = MockClass2();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ final obj2 = field1.get2();
+ final int1 = field2.get1();
+ final int2 = field2.get2();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field1.asyncMethod();
+ field2.use1(int1);
+ await field2.asyncMethod();
+ field1.use2(obj1, obj2);
+ field2.use2(int1, int2);
+ }
+}
+
+class LiveObj4Int4 extends LiveVarsBench {
+ LiveObj4Int4() : super('AsyncLiveVars.LiveObj4Int4');
+ final field1 = MockClass();
+ final field2 = MockClass();
+ final field3 = MockClass2();
+ final field4 = MockClass2();
+ @override
+ Future<void> run() async {
+ final obj1 = field1.get1();
+ final obj2 = field1.get2();
+ final obj3 = field2.get1();
+ final obj4 = field2.get2();
+ final int1 = field3.get1();
+ final int2 = field3.get2();
+ final int3 = field4.get1();
+ final int4 = field4.get2();
+ await field1.asyncMethod();
+ field1.use1(obj1);
+ await field2.asyncMethod();
+ field3.use2(int2, int4);
+ await field4.asyncMethod();
+ field2.use4(obj1, obj2, obj3, obj4);
+ field4.use4(int1, int2, int3, int4);
+ }
+}
+
+Future<void> main() async {
+ final benchmarks = [
+ LiveObj1(),
+ LiveObj2(),
+ LiveObj4(),
+ LiveObj8(),
+ LiveObj16(),
+ LiveInt1(),
+ LiveInt4(),
+ LiveObj2Int2(),
+ LiveObj4Int4()
+ ];
+ for (final bench in benchmarks) {
+ await bench.report();
+ }
+}
diff --git a/benchmarks/AsyncLiveVars/dart2/async_benchmark_base.dart b/benchmarks/AsyncLiveVars/dart2/async_benchmark_base.dart
new file mode 100644
index 0000000..9a415b9
--- /dev/null
+++ b/benchmarks/AsyncLiveVars/dart2/async_benchmark_base.dart
@@ -0,0 +1,68 @@
+// 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:benchmark_harness/benchmark_harness.dart'
+ show PrintEmitter, ScoreEmitter;
+
+// Similar to BenchmarkBase from package:benchmark_harness.
+class AsyncBenchmarkBase {
+ final String name;
+ final ScoreEmitter emitter;
+
+ // Empty constructor.
+ const AsyncBenchmarkBase(this.name, {this.emitter = const PrintEmitter()});
+
+ // The benchmark code.
+ // This function is not used, if both [warmup] and [exercise] are overwritten.
+ Future<void> run() async {}
+
+ // Runs a short version of the benchmark. By default invokes [run] once.
+ Future<void> warmup() async {
+ await run();
+ }
+
+ // Exercises the benchmark. By default invokes [run] 10 times.
+ Future<void> exercise() async {
+ for (var i = 0; i < 10; i++) {
+ await run();
+ }
+ }
+
+ // Not measured setup code executed prior to the benchmark runs.
+ Future<void> setup() async {}
+
+ // Not measures teardown code executed after the benchark runs.
+ Future<void> teardown() async {}
+
+ // Measures the score for this benchmark by executing it repeatedly until
+ // time minimum has been reached.
+ static Future<double> measureFor(Function f, int minimumMillis) async {
+ final int minimumMicros = minimumMillis * 1000;
+ int iter = 0;
+ final watch = Stopwatch();
+ watch.start();
+ int elapsed = 0;
+ while (elapsed < minimumMicros) {
+ await f();
+ elapsed = watch.elapsedMicroseconds;
+ iter++;
+ }
+ return elapsed / iter;
+ }
+
+ // Measures the score for the benchmark and returns it.
+ Future<double> measure() async {
+ await setup();
+ // Warmup for at least 100ms. Discard result.
+ await measureFor(warmup, 100);
+ // Run the benchmark for at least 2000ms.
+ final result = await measureFor(exercise, 2000);
+ await teardown();
+ return result;
+ }
+
+ Future<void> report() async {
+ emitter.emit(name, await measure());
+ }
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/deferred_closure_heuristic.dart b/pkg/_fe_analyzer_shared/lib/src/deferred_closure_heuristic.dart
new file mode 100644
index 0000000..d5f823a
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/deferred_closure_heuristic.dart
@@ -0,0 +1,139 @@
+// 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:_fe_analyzer_shared/src/util/dependency_walker.dart';
+
+/// Data structure tracking the type inference dependencies between closures
+/// passed as invocation parameters.
+///
+/// [planClosureReconciliationStages] is used as part of support for
+/// https://github.com/dart-lang/language/issues/731 (improved inference for
+/// fold etc.) to choose the proper order in which to recursively analyze
+/// closures passed as invocation arguments.
+abstract class ClosureDependencies<TypeVariable, Closure> {
+ final List<_ClosureNode<Closure>> _closureNodes = [];
+
+ /// Construct a [ClosureDependencies] object that's prepared to determine the
+ /// order to resolve [closures] for a generic invocation involving the given
+ /// [typeVariables].
+ ClosureDependencies(
+ Iterable<Closure> closures, Iterable<TypeVariable> typeVariables) {
+ Map<TypeVariable, Set<_ClosureNode<Closure>>> closuresDependingOnTypeVar =
+ {};
+ Map<TypeVariable, Set<_ClosureNode<Closure>>> closuresConstrainingTypeVar =
+ {};
+ for (Closure closure in closures) {
+ _ClosureNode<Closure> closureNode = new _ClosureNode<Closure>(closure);
+ _closureNodes.add(closureNode);
+ for (TypeVariable v in typeVarsFreeInClosureArguments(closure)) {
+ (closuresDependingOnTypeVar[v] ??= {}).add(closureNode);
+ }
+ for (TypeVariable v in typeVarsFreeInClosureReturns(closure)) {
+ (closuresConstrainingTypeVar[v] ??= {}).add(closureNode);
+ }
+ }
+ for (TypeVariable typeVariable in typeVariables) {
+ for (_ClosureNode<Closure> closureNode
+ in closuresDependingOnTypeVar[typeVariable] ?? const {}) {
+ closureNode.dependencies
+ .addAll(closuresConstrainingTypeVar[typeVariable] ?? const {});
+ }
+ }
+ }
+
+ /// Computes the order in which to resolve the closures passed to the
+ /// constructor.
+ ///
+ /// Each entry in the returned list represents the set of closures that should
+ /// be visited during a single stage of resolution; after each stage, the
+ /// assignment of actual types to type variables should be refined.
+ ///
+ /// So, for example, if the closures in question are A, B, and C, and the
+ /// returned list is `[{A, B}, {C}]`, then first closures A and B should be
+ /// resolved, then the assignment of actual types to type variables should be
+ /// refined, and then C should be resolved, and then the final assignment of
+ /// actual types to type variables should be computed.
+ List<Set<Closure>> planClosureReconciliationStages() {
+ _DependencyWalker<Closure> walker = new _DependencyWalker<Closure>();
+ for (_ClosureNode<Closure> closureNode in _closureNodes) {
+ walker.walk(closureNode);
+ }
+ return walker.closureReconciliationStages;
+ }
+
+ /// If the type of the parameter corresponding to [closure] is a function
+ /// type, the set of type parameters referred to by the parameter types of
+ /// that parameter. If the type of the parameter is not a function type, an
+ /// empty iterable should be returned.
+ ///
+ /// Should be overridden by the client.
+ Iterable<TypeVariable> typeVarsFreeInClosureArguments(Closure closure);
+
+ /// If the type of the parameter corresponding to [closure] is a function
+ /// type, the set of type parameters referred to by the return type of that
+ /// parameter. If the type of the parameter is not a function type, the set
+ /// type parameters referred to by the type of the parameter should be
+ /// returned.
+ ///
+ /// Should be overridden by the client.
+ Iterable<TypeVariable> typeVarsFreeInClosureReturns(Closure closure);
+}
+
+/// Node type representing a single [Closure] for purposes of walking the
+/// graph of type inference dependencies among closures.
+class _ClosureNode<Closure> extends Node<_ClosureNode<Closure>> {
+ /// The [Closure] being represented by this node.
+ final Closure closure;
+
+ /// If not `null`, the index of the reconciliation stage to which this closure
+ /// has been assigned.
+ int? stageNum;
+
+ /// The nodes for the closures depended on by this closure.
+ final List<_ClosureNode<Closure>> dependencies = [];
+
+ _ClosureNode(this.closure);
+
+ @override
+ bool get isEvaluated => stageNum != null;
+
+ @override
+ List<_ClosureNode<Closure>> computeDependencies() => dependencies;
+}
+
+/// Derived class of [DependencyWalker] capable of walking the graph of type
+/// inference dependencies among closures.
+class _DependencyWalker<Closure>
+ extends DependencyWalker<_ClosureNode<Closure>> {
+ /// The set of closure reconciliation stages accumulated so far.
+ final List<Set<Closure>> closureReconciliationStages = [];
+
+ @override
+ void evaluate(_ClosureNode v) => evaluateScc([v]);
+
+ @override
+ void evaluateScc(List<_ClosureNode> nodes) {
+ int stageNum = 0;
+ for (_ClosureNode node in nodes) {
+ for (_ClosureNode dependency in node.dependencies) {
+ int? dependencyStageNum = dependency.stageNum;
+ if (dependencyStageNum != null && dependencyStageNum >= stageNum) {
+ stageNum = dependencyStageNum + 1;
+ }
+ }
+ }
+ if (closureReconciliationStages.length <= stageNum) {
+ closureReconciliationStages.add({});
+ // `stageNum` can't grow by more than 1 each time `evaluateScc` is called,
+ // so adding one stage is sufficient to make sure the list is now long
+ // enough.
+ assert(stageNum < closureReconciliationStages.length);
+ }
+ Set<Closure> stage = closureReconciliationStages[stageNum];
+ for (_ClosureNode node in nodes) {
+ node.stageNum = stageNum;
+ stage.add(node.closure);
+ }
+ }
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor/message_grouper.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor/message_grouper.dart
index 7e2d390..382dd81 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/executor/message_grouper.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor/message_grouper.dart
@@ -3,7 +3,6 @@
// BSD-style license that can be found in the LICENSE file.
import 'dart:async';
-import 'dart:math';
import 'dart:typed_data';
/// Collects messages from an input stream of bytes.
@@ -14,18 +13,11 @@
/// The input bytes stream subscription.
late final StreamSubscription _inputStreamSubscription;
- /// The length of the current message to read, or `-1` if we are currently
- /// reading the length.
- int _length = -1;
-
/// The buffer to store the length bytes in.
- BytesBuilder _lengthBuffer = new BytesBuilder();
+ final _FixedBuffer _lengthBuffer = new _FixedBuffer(4);
/// If reading raw data, buffer for the data.
- Uint8List _messageBuffer = new Uint8List(0);
-
- /// The position to write the next byte in [_messageBuffer].
- int _messagePos = 0;
+ _FixedBuffer? _messageBuffer;
late StreamController<Uint8List> _messageStreamController =
new StreamController<Uint8List>(onCancel: () {
@@ -38,45 +30,36 @@
}
void _handleBytes(List<int> bytes, [int offset = 0]) {
- if (_length == -1) {
- while (_lengthBuffer.length < 4 && offset < bytes.length) {
+ final _FixedBuffer? messageBuffer = _messageBuffer;
+ if (messageBuffer == null) {
+ while (offset < bytes.length && !_lengthBuffer.isReady) {
_lengthBuffer.addByte(bytes[offset++]);
}
- if (_lengthBuffer.length >= 4) {
- Uint8List lengthBytes = _lengthBuffer.takeBytes();
- _length = lengthBytes[0] << 24 |
- lengthBytes[1] << 16 |
- lengthBytes[2] << 8 |
- lengthBytes[3];
+ if (_lengthBuffer.isReady) {
+ int length = _lengthBuffer[0] << 24 |
+ _lengthBuffer[1] << 16 |
+ _lengthBuffer[2] << 8 |
+ _lengthBuffer[3];
+ // Reset the length reading state.
+ _lengthBuffer.reset();
+ // Switch to the message payload reading state.
+ _messageBuffer = new _FixedBuffer(length);
+ _handleBytes(bytes, offset);
+ } else {
+ // Continue reading the length.
+ return;
}
- }
+ } else {
+ // Read the data from `bytes`.
+ while (offset < bytes.length && !messageBuffer.isReady) {
+ messageBuffer.addByte(bytes[offset++]);
+ }
- // Just pass along `bytes` without a copy if we can, and reset our state
- if (offset == 0 && bytes.length == _length && bytes is Uint8List) {
- _length = -1;
- _messageStreamController.add(bytes);
- return;
- }
-
- // Initialize a new buffer.
- if (_messagePos == 0) {
- _messageBuffer = new Uint8List(_length);
- }
-
- // Read the data from `bytes`.
- int lenToRead = min(_length - _messagePos, bytes.length - offset);
- while (lenToRead-- > 0) {
- _messageBuffer[_messagePos++] = bytes[offset++];
- }
-
- // If we completed a message, add it to the output stream, reset our state,
- // and call ourselves again if we have more data to read.
- if (_messagePos >= _length) {
- _messageStreamController.add(_messageBuffer);
- _length = -1;
- _messagePos = 0;
-
- if (offset < bytes.length) {
+ // If we completed a message, add it to the output stream.
+ if (messageBuffer.isReady) {
+ _messageStreamController.add(messageBuffer.bytes);
+ // Switch to the length reading state.
+ _messageBuffer = null;
_handleBytes(bytes, offset);
}
}
@@ -89,3 +72,27 @@
_messageStreamController.close();
}
}
+
+/// A buffer of fixed length.
+class _FixedBuffer {
+ final Uint8List bytes;
+
+ /// The offset in [bytes].
+ int _offset = 0;
+
+ _FixedBuffer(int length) : bytes = new Uint8List(length);
+
+ /// Return `true` when the required number of bytes added.
+ bool get isReady => _offset == bytes.length;
+
+ int operator [](int index) => bytes[index];
+
+ void addByte(int byte) {
+ bytes[_offset++] = byte;
+ }
+
+ /// Reset the number of added bytes to zero.
+ void reset() {
+ _offset = 0;
+ }
+}
diff --git a/pkg/_fe_analyzer_shared/test/deferred_closure_heuristic_test.dart b/pkg/_fe_analyzer_shared/test/deferred_closure_heuristic_test.dart
new file mode 100644
index 0000000..ab4b8f9
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/deferred_closure_heuristic_test.dart
@@ -0,0 +1,138 @@
+// 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:_fe_analyzer_shared/src/deferred_closure_heuristic.dart';
+import 'package:test/test.dart';
+
+main() {
+ test('single', () {
+ // If there is just a single closure and no type variables, it is selected.
+ var f = Closure('f');
+ expect(
+ _TestClosureDeps(typeVars: [], closures: [f])
+ .planClosureReconciliationStages(),
+ [
+ {f}
+ ]);
+ });
+
+ test('simple dependency', () {
+ // If f depends on g, then g is selected first, and then f.
+ var f = Closure('f', argTypes: ['T']);
+ var g = Closure('g', retTypes: ['T']);
+ expect(
+ _TestClosureDeps(typeVars: ['T'], closures: [f, g])
+ .planClosureReconciliationStages(),
+ [
+ {g},
+ {f}
+ ]);
+ });
+
+ test('long chain', () {
+ // If f depends on g and g depends on h, then we do three separate stages:
+ // h, then g, then f.
+ var f = Closure('f', argTypes: ['T']);
+ var g = Closure('g', argTypes: ['U'], retTypes: ['T']);
+ var h = Closure('h', retTypes: ['U']);
+ expect(
+ _TestClosureDeps(typeVars: ['T', 'U'], closures: [f, g, h])
+ .planClosureReconciliationStages(),
+ [
+ {h},
+ {g},
+ {f}
+ ]);
+ });
+
+ test('unrelated closure', () {
+ // Closures that are independent of all the others are inferred during the
+ // first stage.
+ var f = Closure('f', argTypes: ['T']);
+ var g = Closure('g', retTypes: ['T']);
+ var h = Closure('h');
+ expect(
+ _TestClosureDeps(typeVars: ['T', 'U'], closures: [f, g, h])
+ .planClosureReconciliationStages(),
+ [
+ {g, h},
+ {f}
+ ]);
+ });
+
+ test('independent chains', () {
+ // If f depends on g, and h depends on i, then g and i are selected first,
+ // and then f and h.
+ var f = Closure('f', argTypes: ['T']);
+ var g = Closure('g', retTypes: ['T']);
+ var h = Closure('h', argTypes: ['U']);
+ var i = Closure('i', retTypes: ['U']);
+ expect(
+ _TestClosureDeps(typeVars: ['T', 'U'], closures: [f, g, h, i])
+ .planClosureReconciliationStages(),
+ [
+ {g, i},
+ {f, h}
+ ]);
+ });
+
+ test('diamond', () {
+ // Test a diamond dependency shape: f depends on g and h; g and h both
+ // depend on i.
+ var f = Closure('f', argTypes: ['T', 'U']);
+ var g = Closure('g', argTypes: ['V'], retTypes: ['T']);
+ var h = Closure('h', argTypes: ['V'], retTypes: ['U']);
+ var i = Closure('i', retTypes: ['V']);
+ expect(
+ _TestClosureDeps(typeVars: ['T', 'U', 'V'], closures: [f, g, h, i])
+ .planClosureReconciliationStages(),
+ [
+ {i},
+ {g, h},
+ {f}
+ ]);
+ });
+
+ test('cycle', () {
+ // A dependency cycle is inferred all at once.
+ var f = Closure('f', argTypes: ['T']);
+ var g = Closure('g', argTypes: ['U']);
+ var h = Closure('h', argTypes: ['U'], retTypes: ['T']);
+ var i = Closure('i', argTypes: ['T'], retTypes: ['U']);
+ expect(
+ _TestClosureDeps(typeVars: ['T', 'U'], closures: [f, g, h, i])
+ .planClosureReconciliationStages(),
+ [
+ {h, i},
+ {f, g}
+ ]);
+ });
+}
+
+class Closure {
+ final String name;
+ final List<String> argTypes;
+ final List<String> retTypes;
+
+ Closure(this.name, {this.argTypes = const [], this.retTypes = const []});
+
+ @override
+ String toString() => name;
+}
+
+class _TestClosureDeps extends ClosureDependencies<String, Closure> {
+ final List<String> typeVars;
+ final List<Closure> closures;
+
+ _TestClosureDeps({required this.typeVars, required this.closures})
+ : super(closures, typeVars);
+
+ @override
+ Set<String> typeVarsFreeInClosureArguments(Closure closure) =>
+ closure.argTypes.toSet();
+
+ @override
+ Set<String> typeVarsFreeInClosureReturns(Closure closure) =>
+ closure.retTypes.toSet();
+}
diff --git a/pkg/analysis_server/lib/src/edit/edit_domain.dart b/pkg/analysis_server/lib/src/edit/edit_domain.dart
index be22f29..3b7e4a3 100644
--- a/pkg/analysis_server/lib/src/edit/edit_domain.dart
+++ b/pkg/analysis_server/lib/src/edit/edit_domain.dart
@@ -9,6 +9,7 @@
import 'package:analysis_server/src/collections.dart';
import 'package:analysis_server/src/domain_abstract.dart';
import 'package:analysis_server/src/handler/legacy/edit_bulk_fixes.dart';
+import 'package:analysis_server/src/handler/legacy/edit_format.dart';
import 'package:analysis_server/src/handler/legacy/edit_format_if_enabled.dart';
import 'package:analysis_server/src/handler/legacy/edit_get_assists.dart';
import 'package:analysis_server/src/handler/legacy/edit_get_fixes.dart';
@@ -16,11 +17,11 @@
import 'package:analysis_server/src/handler/legacy/edit_get_statement_completion.dart';
import 'package:analysis_server/src/handler/legacy/edit_import_elements.dart';
import 'package:analysis_server/src/handler/legacy/edit_is_postfix_completion_applicable.dart';
+import 'package:analysis_server/src/handler/legacy/edit_list_postfix_completion_templates.dart';
import 'package:analysis_server/src/handler/legacy/edit_organize_directives.dart';
import 'package:analysis_server/src/handler/legacy/edit_sort_members.dart';
import 'package:analysis_server/src/protocol_server.dart'
hide AnalysisError, Element;
-import 'package:analysis_server/src/services/completion/postfix/postfix_completion.dart';
import 'package:analysis_server/src/services/correction/status.dart';
import 'package:analysis_server/src/services/refactoring/refactoring.dart';
import 'package:analysis_server/src/services/search/search_engine.dart';
@@ -28,7 +29,6 @@
import 'package:analyzer/dart/analysis/session.dart';
import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/src/dart/ast/utilities.dart';
-import 'package:dart_style/dart_style.dart';
int test_resetCount = 0;
@@ -57,69 +57,14 @@
_newRefactoringManager();
}
- Response format(Request request) {
- server.options.analytics?.sendEvent('edit', 'format');
-
- var params = EditFormatParams.fromRequest(request);
- var file = params.file;
-
- String unformattedCode;
- try {
- var resource = server.resourceProvider.getFile(file);
- unformattedCode = resource.readAsStringSync();
- } catch (e) {
- return Response.formatInvalidFile(request);
- }
-
- int? start = params.selectionOffset;
- int? length = params.selectionLength;
-
- // No need to preserve 0,0 selection
- if (start == 0 && length == 0) {
- start = null;
- length = null;
- }
-
- var code = SourceCode(unformattedCode,
- uri: null,
- isCompilationUnit: true,
- selectionStart: start,
- selectionLength: length);
- var formatter = DartFormatter(pageWidth: params.lineLength);
- SourceCode formattedResult;
- try {
- formattedResult = formatter.formatSource(code);
- } on FormatterException {
- return Response.formatWithErrors(request);
- }
- var formattedSource = formattedResult.text;
-
- var edits = <SourceEdit>[];
-
- if (formattedSource != unformattedCode) {
- //TODO: replace full replacements with smaller, more targeted edits
- var edit = SourceEdit(0, unformattedCode.length, formattedSource);
- edits.add(edit);
- }
-
- var newStart = formattedResult.selectionStart;
- var newLength = formattedResult.selectionLength;
-
- // Sending null start/length values would violate protocol, so convert back
- // to 0.
- newStart ??= 0;
- newLength ??= 0;
-
- return EditFormatResult(edits, newStart, newLength).toResponse(request.id);
- }
-
@override
Response? handleRequest(
Request request, CancellationToken cancellationToken) {
try {
var requestName = request.method;
if (requestName == EDIT_REQUEST_FORMAT) {
- return format(request);
+ EditFormatHandler(server, request, cancellationToken).handle();
+ return Response.DELAYED_RESPONSE;
} else if (requestName == EDIT_REQUEST_FORMAT_IF_ENABLED) {
EditFormatIfEnabledHandler(server, request, cancellationToken).handle();
return Response.DELAYED_RESPONSE;
@@ -162,7 +107,10 @@
return Response.DELAYED_RESPONSE;
} else if (requestName ==
EDIT_REQUEST_LIST_POSTFIX_COMPLETION_TEMPLATES) {
- return listPostfixCompletionTemplates(request);
+ EditListPostfixCompletionTemplatesHandler(
+ server, request, cancellationToken)
+ .handle();
+ return Response.DELAYED_RESPONSE;
}
} on RequestFailure catch (exception) {
return exception.response;
@@ -170,16 +118,6 @@
return null;
}
- Response listPostfixCompletionTemplates(Request request) {
- var templates = DartPostfixCompletion.ALL_TEMPLATES
- .map((PostfixCompletionKind kind) =>
- PostfixTemplateDescriptor(kind.name, kind.key, kind.example))
- .toList();
-
- return EditListPostfixCompletionTemplatesResult(templates)
- .toResponse(request.id);
- }
-
Future<void> _getAvailableRefactorings(Request request) async {
var params = EditGetAvailableRefactoringsParams.fromRequest(request);
var file = params.file;
diff --git a/pkg/analysis_server/lib/src/handler/legacy/edit_format.dart b/pkg/analysis_server/lib/src/handler/legacy/edit_format.dart
new file mode 100644
index 0000000..ca6d691
--- /dev/null
+++ b/pkg/analysis_server/lib/src/handler/legacy/edit_format.dart
@@ -0,0 +1,83 @@
+// 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 'dart:async';
+
+import 'package:analysis_server/protocol/protocol.dart';
+import 'package:analysis_server/protocol/protocol_generated.dart';
+import 'package:analysis_server/src/analysis_server.dart';
+import 'package:analysis_server/src/handler/legacy/legacy_handler.dart';
+import 'package:analysis_server/src/utilities/progress.dart';
+import 'package:analyzer_plugin/protocol/protocol_common.dart';
+import 'package:dart_style/src/dart_formatter.dart';
+import 'package:dart_style/src/exceptions.dart';
+import 'package:dart_style/src/source_code.dart';
+
+/// The handler for the `edit.format` request.
+class EditFormatHandler extends LegacyHandler {
+ /// Initialize a newly created handler to be able to service requests for the
+ /// [server].
+ EditFormatHandler(AnalysisServer server, Request request,
+ CancellationToken cancellationToken)
+ : super(server, request, cancellationToken);
+
+ @override
+ Future<void> handle() async {
+ server.options.analytics?.sendEvent('edit', 'format');
+
+ var params = EditFormatParams.fromRequest(request);
+ var file = params.file;
+//
+ String unformattedCode;
+ try {
+ var resource = server.resourceProvider.getFile(file);
+ unformattedCode = resource.readAsStringSync();
+ } catch (e) {
+ sendResponse(Response.formatInvalidFile(request));
+ return;
+ }
+
+ int? start = params.selectionOffset;
+ int? length = params.selectionLength;
+
+ // No need to preserve 0,0 selection
+ if (start == 0 && length == 0) {
+ start = null;
+ length = null;
+ }
+
+ var code = SourceCode(unformattedCode,
+ uri: null,
+ isCompilationUnit: true,
+ selectionStart: start,
+ selectionLength: length);
+ var formatter = DartFormatter(pageWidth: params.lineLength);
+ SourceCode formattedResult;
+ try {
+ formattedResult = formatter.formatSource(code);
+ } on FormatterException {
+ sendResponse(Response.formatWithErrors(request));
+ return;
+ }
+ var formattedSource = formattedResult.text;
+
+ var edits = <SourceEdit>[];
+
+ if (formattedSource != unformattedCode) {
+ //TODO: replace full replacements with smaller, more targeted edits
+ var edit = SourceEdit(0, unformattedCode.length, formattedSource);
+ edits.add(edit);
+ }
+
+ var newStart = formattedResult.selectionStart;
+ var newLength = formattedResult.selectionLength;
+
+ // Sending null start/length values would violate protocol, so convert back
+ // to 0.
+ newStart ??= 0;
+ newLength ??= 0;
+
+ sendResult(EditFormatResult(edits, newStart, newLength));
+ }
+}
diff --git a/pkg/analysis_server/lib/src/handler/legacy/edit_list_postfix_completion_templates.dart b/pkg/analysis_server/lib/src/handler/legacy/edit_list_postfix_completion_templates.dart
new file mode 100644
index 0000000..b990eea
--- /dev/null
+++ b/pkg/analysis_server/lib/src/handler/legacy/edit_list_postfix_completion_templates.dart
@@ -0,0 +1,30 @@
+// 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 'dart:async';
+
+import 'package:analysis_server/protocol/protocol.dart';
+import 'package:analysis_server/protocol/protocol_generated.dart';
+import 'package:analysis_server/src/analysis_server.dart';
+import 'package:analysis_server/src/handler/legacy/legacy_handler.dart';
+import 'package:analysis_server/src/services/completion/postfix/postfix_completion.dart';
+import 'package:analysis_server/src/utilities/progress.dart';
+
+/// The handler for the `edit.listPostfixCompletionTemplates` request.
+class EditListPostfixCompletionTemplatesHandler extends LegacyHandler {
+ /// Initialize a newly created handler to be able to service requests for the
+ /// [server].
+ EditListPostfixCompletionTemplatesHandler(AnalysisServer server,
+ Request request, CancellationToken cancellationToken)
+ : super(server, request, cancellationToken);
+
+ @override
+ Future<void> handle() async {
+ var templates = DartPostfixCompletion.ALL_TEMPLATES
+ .map((PostfixCompletionKind kind) =>
+ PostfixTemplateDescriptor(kind.name, kind.key, kind.example))
+ .toList();
+ sendResult(EditListPostfixCompletionTemplatesResult(templates));
+ }
+}
diff --git a/pkg/analysis_server/lib/src/services/correction/dart/create_constructor_for_final_fields.dart b/pkg/analysis_server/lib/src/services/correction/dart/create_constructor_for_final_fields.dart
index 94e26f2..e125e84 100644
--- a/pkg/analysis_server/lib/src/services/correction/dart/create_constructor_for_final_fields.dart
+++ b/pkg/analysis_server/lib/src/services/correction/dart/create_constructor_for_final_fields.dart
@@ -4,18 +4,19 @@
import 'package:analysis_server/src/services/correction/dart/abstract_producer.dart';
import 'package:analysis_server/src/services/correction/fix.dart';
+import 'package:analysis_server/src/services/correction/util.dart';
import 'package:analyzer/dart/analysis/features.dart';
import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/element/element.dart';
import 'package:analyzer/dart/element/nullability_suffix.dart';
import 'package:analyzer_plugin/utilities/change_builder/change_builder_core.dart';
+import 'package:analyzer_plugin/utilities/change_builder/change_builder_dart.dart';
import 'package:analyzer_plugin/utilities/fixes/fixes.dart';
class CreateConstructorForFinalFields extends CorrectionProducer {
@override
FixKind get fixKind => DartFixKind.CREATE_CONSTRUCTOR_FOR_FINAL_FIELDS;
- bool get _isNonNullable => unit.featureSet.isEnabled(Feature.non_nullable);
-
@override
Future<void> compute(ChangeBuilder builder) async {
if (node is! SimpleIdentifier || node.parent is! VariableDeclaration) {
@@ -33,15 +34,12 @@
return;
}
- // prepare names of uninitialized final fields
- var fieldNames = <String>[];
+ var variableLists = <VariableDeclarationList>[];
for (var member in classDeclaration.members) {
if (member is FieldDeclaration) {
var variableList = member.fields;
if (variableList.isFinal && !variableList.isLate) {
- fieldNames.addAll(variableList.variables
- .where((v) => v.initializer == null)
- .map((v) => v.name.name));
+ variableLists.add(variableList);
}
}
}
@@ -59,41 +57,22 @@
if (keyClass == null) {
return;
}
- await builder.addDartFileEdit(file, (builder) {
- builder.addInsertion(targetLocation.offset, (builder) {
- builder.write(targetLocation.prefix);
- builder.write('const ');
- builder.write(className);
- builder.write('({');
- builder.writeType(
- keyClass.instantiate(
- typeArguments: const [],
- nullabilitySuffix: _isNonNullable
- ? NullabilitySuffix.question
- : NullabilitySuffix.star,
- ),
- );
- builder.write(' key');
- var childrenFields = <String>[];
- for (var fieldName in fieldNames) {
- if (fieldName == 'child' || fieldName == 'children') {
- childrenFields.add(fieldName);
- continue;
- }
- builder.write(', this.');
- builder.write(fieldName);
- }
- for (var fieldName in childrenFields) {
- builder.write(', this.');
- builder.write(fieldName);
- }
-
- builder.write('}) : super(key: key);');
- builder.write(targetLocation.suffix);
- });
- });
+ if (unit.featureSet.isEnabled(Feature.super_parameters)) {
+ await _withSuperParameters(
+ builder, targetLocation, className, variableLists);
+ } else {
+ await _withoutSuperParameters(
+ builder, targetLocation, className, keyClass, variableLists);
+ }
} else {
+ var fieldNames = <String>[];
+ for (var variableList in variableLists) {
+ fieldNames.addAll(variableList.variables
+ .where((v) => v.initializer == null)
+ .map((v) => v.name.name));
+ }
+
await builder.addDartFileEdit(file, (builder) {
builder.addInsertion(targetLocation.offset, (builder) {
builder.write(targetLocation.prefix);
@@ -105,6 +84,96 @@
}
}
+ Future<void> _withoutSuperParameters(
+ ChangeBuilder builder,
+ ClassMemberLocation targetLocation,
+ String className,
+ ClassElement keyClass,
+ List<VariableDeclarationList> variableLists) async {
+ var isNonNullable = unit.featureSet.isEnabled(Feature.non_nullable);
+ await builder.addDartFileEdit(file, (builder) {
+ builder.addInsertion(targetLocation.offset, (builder) {
+ builder.write(targetLocation.prefix);
+ builder.write('const ');
+ builder.write(className);
+ builder.write('({');
+ builder.writeType(
+ keyClass.instantiate(
+ typeArguments: const [],
+ nullabilitySuffix: isNonNullable
+ ? NullabilitySuffix.question
+ : NullabilitySuffix.star,
+ ),
+ );
+ builder.write(' key');
+
+ _writeParameters(builder, variableLists, isNonNullable);
+
+ builder.write('}) : super(key: key);');
+ builder.write(targetLocation.suffix);
+ });
+ });
+ }
+
+ Future<void> _withSuperParameters(
+ ChangeBuilder builder,
+ ClassMemberLocation targetLocation,
+ String className,
+ List<VariableDeclarationList> variableLists) async {
+ await builder.addDartFileEdit(file, (builder) {
+ builder.addInsertion(targetLocation.offset, (builder) {
+ builder.write(targetLocation.prefix);
+ builder.write('const ');
+ builder.write(className);
+ builder.write('({');
+ builder.write('super.key');
+
+ _writeParameters(builder, variableLists, true);
+
+ builder.write('});');
+ builder.write(targetLocation.suffix);
+ });
+ });
+ }
+
+ void _writeParameters(DartEditBuilder builder,
+ List<VariableDeclarationList> variableLists, bool isNonNullable) {
+ var childrenFields = <String>[];
+ var childrenNullables = <bool>[];
+ for (var variableList in variableLists) {
+ var fieldNames = variableList.variables
+ .where((v) => v.initializer == null)
+ .map((v) => v.name.name);
+
+ for (var fieldName in fieldNames) {
+ if (fieldName == 'child' || fieldName == 'children') {
+ childrenFields.add(fieldName);
+ childrenNullables.add(variableList.type?.type?.nullabilitySuffix ==
+ NullabilitySuffix.question);
+ continue;
+ }
+ builder.write(', ');
+ if (isNonNullable &&
+ variableList.type?.type?.nullabilitySuffix !=
+ NullabilitySuffix.question) {
+ builder.write('required ');
+ }
+ builder.write('this.');
+ builder.write(fieldName);
+ }
+ }
+ for (var i = 0; i < childrenFields.length; i++) {
+ var fieldName = childrenFields[i];
+ var nullableField = childrenNullables[i];
+ builder.write(', ');
+ if (isNonNullable && !nullableField) {
+ builder.write('required ');
+ }
+ builder.write('this.');
+ builder.write(fieldName);
+ }
+ }
+
/// Return an instance of this class. Used as a tear-off in `FixProcessor`.
static CreateConstructorForFinalFields newInstance() =>
CreateConstructorForFinalFields();
diff --git a/pkg/analysis_server/test/analysis/get_errors_test.dart b/pkg/analysis_server/test/analysis/get_errors_test.dart
index 1ce1f0a..e3f0c6e 100644
--- a/pkg/analysis_server/test/analysis/get_errors_test.dart
+++ b/pkg/analysis_server/test/analysis/get_errors_test.dart
@@ -33,7 +33,7 @@
}
''');
- await server.onAnalysisComplete;
+ await waitForTasksFinished();
var errors = await _getErrors(testFile.path);
expect(errors, hasLength(1));
diff --git a/pkg/analysis_server/test/analysis/get_hover_test.dart b/pkg/analysis_server/test/analysis/get_hover_test.dart
index 9120539..bb65e9a 100644
--- a/pkg/analysis_server/test/analysis/get_hover_test.dart
+++ b/pkg/analysis_server/test/analysis/get_hover_test.dart
@@ -48,7 +48,7 @@
}
Future<HoverInformation?> prepareHoverAt(int offset) async {
- await server.onAnalysisComplete;
+ await waitForTasksFinished();
var request = AnalysisGetHoverParams(testFile.path, offset).toRequest('0');
var response = await handleSuccessfulRequest(request);
var result = AnalysisGetHoverResult.fromResponse(response);
diff --git a/pkg/analysis_server/test/analysis/notification_analysis_options_test.dart b/pkg/analysis_server/test/analysis/notification_analysis_options_test.dart
index b82f567..f783d03 100644
--- a/pkg/analysis_server/test/analysis/notification_analysis_options_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_analysis_options_test.dart
@@ -6,13 +6,13 @@
import 'package:analysis_server/protocol/protocol_constants.dart';
import 'package:analysis_server/protocol/protocol_generated.dart'
hide AnalysisOptions;
-import 'package:analysis_server/src/domain_analysis.dart';
+import 'package:analyzer/file_system/file_system.dart';
import 'package:analyzer_plugin/protocol/protocol_common.dart';
import 'package:linter/src/rules.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
-import '../analysis_abstract.dart';
+import '../analysis_server_base.dart';
void main() {
defineReflectiveSuite(() {
@@ -21,8 +21,9 @@
}
@reflectiveTest
-class AnalysisOptionsFileNotificationTest extends AbstractAnalysisTest {
- Map<String, List<AnalysisError>> filesErrors = {};
+class AnalysisOptionsFileNotificationTest extends PubPackageAnalysisServerTest {
+ late File optionsFile;
+ Map<File, List<AnalysisError>> filesErrors = {};
final testSource = '''
main() {
@@ -33,40 +34,27 @@
List<AnalysisError> get errors => filesErrors[testFile]!;
- List<AnalysisError> get optionsFileErrors => filesErrors[optionsFilePath]!;
-
- String get optionsFilePath => '$projectPath/analysis_options.yaml';
+ List<AnalysisError> get optionsFileErrors => filesErrors[optionsFile]!;
List<AnalysisError> get testFileErrors => filesErrors[testFile]!;
void addOptionsFile(String contents) {
- newFile2(optionsFilePath, contents);
+ optionsFile = newAnalysisOptionsYamlFile2(testPackageRootPath, contents);
}
@override
void processNotification(Notification notification) {
if (notification.event == ANALYSIS_NOTIFICATION_ERRORS) {
var decoded = AnalysisErrorsParams.fromNotification(notification);
- filesErrors[decoded.file] = decoded.errors;
+ filesErrors[getFile(decoded.file)] = decoded.errors;
}
}
- Future<void> setAnalysisRoot() async {
- await setRoots(included: [projectPath], excluded: []);
- }
-
@override
- void setUp() {
+ Future<void> setUp() async {
registerLintRules();
super.setUp();
- server.handlers = [AnalysisDomainHandler(server)];
- }
-
- @override
- void tearDown() {
- filesErrors[optionsFilePath] = [];
- filesErrors[testFile] = [];
- super.tearDown();
+ await setRoots(included: [workspaceRootPath], excluded: []);
}
Future<void> test_error_filter() async {
@@ -82,8 +70,6 @@
}
''');
- await setAnalysisRoot();
-
await waitForTasksFinished();
// Verify options file.
@@ -109,8 +95,6 @@
}
''');
- await setAnalysisRoot();
-
await waitForTasksFinished();
// Verify options file.
@@ -148,7 +132,6 @@
''');
addTestFile(testSource);
- await setAnalysisRoot();
await waitForTasksFinished();
@@ -174,7 +157,6 @@
''');
addTestFile(testSource);
- await setAnalysisRoot();
await waitForTasksFinished();
@@ -186,15 +168,11 @@
Future<void> test_options_file_added() async {
addTestFile(testSource);
- await setAnalysisRoot();
await waitForTasksFinished();
// Verify that lints are disabled.
- expect(analysisOptions.lint, false);
-
- // Clear errors.
- filesErrors[testFile] = [];
+ expect(testFileAnalysisOptions.lint, false);
// Add options file with a lint enabled.
addOptionsFile('''
@@ -213,7 +191,6 @@
addOptionsFile('''
; #bang
''');
- await setAnalysisRoot();
await waitForTasksFinished();
@@ -231,25 +208,21 @@
''');
addTestFile(testSource);
- await setAnalysisRoot();
await waitForTasksFinished();
verifyLintsEnabled(['camel_case_types']);
- // Clear errors.
- filesErrors[testFile] = [];
-
- deleteFile(optionsFilePath);
+ deleteFile(optionsFile.path);
await pumpEventQueue();
await waitForTasksFinished();
- expect(analysisOptions.lint, false);
+ expect(testFileAnalysisOptions.lint, false);
}
void verifyLintsEnabled(List<String> lints) {
- var options = analysisOptions;
+ var options = testFileAnalysisOptions;
expect(options.lint, true);
var rules = options.lintRules.map((rule) => rule.name);
expect(rules, unorderedEquals(lints));
diff --git a/pkg/analysis_server/test/analysis/notification_analyzed_files_test.dart b/pkg/analysis_server/test/analysis/notification_analyzed_files_test.dart
index e2fce2f..31ae228 100644
--- a/pkg/analysis_server/test/analysis/notification_analyzed_files_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_analyzed_files_test.dart
@@ -5,10 +5,11 @@
import 'package:analysis_server/protocol/protocol.dart';
import 'package:analysis_server/protocol/protocol_constants.dart';
import 'package:analysis_server/protocol/protocol_generated.dart';
+import 'package:analyzer/file_system/file_system.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
-import '../analysis_abstract.dart';
+import '../analysis_server_base.dart';
void main() {
defineReflectiveSuite(() {
@@ -17,13 +18,14 @@
}
@reflectiveTest
-class AnalysisNotificationAnalyzedFilesTest extends AbstractAnalysisTest {
+class AnalysisNotificationAnalyzedFilesTest
+ extends PubPackageAnalysisServerTest {
late List<String> analyzedFiles;
bool analyzedFilesReceived = false;
- void assertHasFile(String filePath) {
+ void assertHasFile(File file) {
expect(analyzedFilesReceived, isTrue);
- expect(analyzedFiles, contains(filePath));
+ expect(analyzedFiles, contains(file.path));
}
void assertHasNoFile(String filePath) {
@@ -32,7 +34,9 @@
}
Future<void> prepareAnalyzedFiles() async {
- addGeneralAnalysisSubscription(GeneralAnalysisService.ANALYZED_FILES);
+ await addGeneralAnalysisSubscription(
+ GeneralAnalysisService.ANALYZED_FILES,
+ );
await pumpEventQueue(times: 5000);
}
@@ -48,7 +52,7 @@
@override
Future<void> setUp() async {
super.setUp();
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
}
Future<void> test_afterAnalysis() async {
@@ -69,8 +73,7 @@
}
Future<void> test_beforeAnalysis_excludeYamlFiles() async {
- var yamlFile = getFolder(projectPath).getChildAssumingFile('sample.yaml');
- yamlFile.writeAsStringSync('');
+ var yamlFile = newFile2('$testPackageRootPath/sample.yaml', '');
addTestFile('''
class A {}
''');
@@ -111,17 +114,19 @@
// Making a change that *does* affect the set of reachable files should
// trigger the notification to be re-sent.
addTestFile('class A {}');
- newFile2('/foo.dart', 'library foo;');
+ var foo = newFile2('/foo.dart', 'library foo;');
await prepareAnalyzedFiles();
expect(analyzedFilesReceived, isTrue);
analyzedFilesReceived = false;
modifyTestFile('import "${toUriStr('/foo.dart')}";');
await prepareAnalyzedFiles();
- assertHasFile(convertPath('/foo.dart'));
+ assertHasFile(foo);
}
void unsubscribeAnalyzedFiles() {
- removeGeneralAnalysisSubscription(GeneralAnalysisService.ANALYZED_FILES);
+ removeGeneralAnalysisSubscription(
+ GeneralAnalysisService.ANALYZED_FILES,
+ );
}
}
diff --git a/pkg/analysis_server/test/analysis/notification_closing_labels_test.dart b/pkg/analysis_server/test/analysis/notification_closing_labels_test.dart
index 42537b1..df55415 100644
--- a/pkg/analysis_server/test/analysis/notification_closing_labels_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_closing_labels_test.dart
@@ -10,7 +10,7 @@
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
-import '../analysis_abstract.dart';
+import '../analysis_server_base.dart';
void main() {
defineReflectiveSuite(() {
@@ -19,7 +19,8 @@
}
@reflectiveTest
-class AnalysisNotificationClosingLabelsTest extends AbstractAnalysisTest {
+class AnalysisNotificationClosingLabelsTest
+ extends PubPackageAnalysisServerTest {
static const sampleCode = '''
Widget build(BuildContext context) {
return /*1*/new Row(
@@ -44,7 +45,7 @@
void processNotification(Notification notification) {
if (notification.event == ANALYSIS_NOTIFICATION_CLOSING_LABELS) {
var params = AnalysisClosingLabelsParams.fromNotification(notification);
- if (params.file == testFile) {
+ if (params.file == testFile.path) {
lastLabels = params.labels;
_labelsReceived.complete(null);
}
@@ -57,7 +58,7 @@
@override
Future<void> setUp() async {
super.setUp();
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
}
Future<void> subscribeForLabels() async {
diff --git a/pkg/analysis_server/test/analysis/notification_errors_test.dart b/pkg/analysis_server/test/analysis/notification_errors_test.dart
index ab0e04d..ba24eaa 100644
--- a/pkg/analysis_server/test/analysis/notification_errors_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_errors_test.dart
@@ -5,16 +5,16 @@
import 'package:analysis_server/protocol/protocol.dart';
import 'package:analysis_server/protocol/protocol_constants.dart';
import 'package:analysis_server/protocol/protocol_generated.dart';
-import 'package:analysis_server/src/domain_analysis.dart';
import 'package:analyzer/file_system/file_system.dart';
import 'package:analyzer/src/lint/linter.dart';
import 'package:analyzer/src/test_utilities/package_config_file_builder.dart';
import 'package:analyzer_plugin/protocol/protocol_common.dart';
import 'package:linter/src/rules.dart';
+import 'package:path/path.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
-import '../analysis_abstract.dart';
+import '../analysis_server_base.dart';
import '../src/utilities/mock_packages.dart';
void main() {
@@ -24,19 +24,19 @@
}
@reflectiveTest
-class NotificationErrorsTest extends AbstractAnalysisTest {
+class NotificationErrorsTest extends PubPackageAnalysisServerTest {
late Folder pedanticFolder;
- Map<String, List<AnalysisError>?> filesErrors = {};
+ Map<File, List<AnalysisError>?> filesErrors = {};
@override
void processNotification(Notification notification) {
if (notification.event == ANALYSIS_NOTIFICATION_ERRORS) {
var decoded = AnalysisErrorsParams.fromNotification(notification);
- filesErrors[decoded.file] = decoded.errors;
+ filesErrors[getFile(decoded.file)] = decoded.errors;
} else if (notification.event == ANALYSIS_NOTIFICATION_FLUSH_RESULTS) {
var decoded = AnalysisFlushResultsParams.fromNotification(notification);
for (var file in decoded.files) {
- filesErrors[file] = null;
+ filesErrors[getFile(file)] = null;
}
}
}
@@ -46,55 +46,50 @@
registerLintRules();
super.setUp();
server.pendingFilesRemoveOverlayDelay = const Duration(milliseconds: 10);
- server.handlers = [
- AnalysisDomainHandler(server),
- ];
pedanticFolder = MockPackages.instance.addPedantic(resourceProvider);
}
Future<void> test_analysisOptionsFile() async {
- var filePath = join(projectPath, 'analysis_options.yaml');
- var analysisOptionsFile = newFile2(filePath, '''
+ var analysisOptions = newAnalysisOptionsYamlFile2(testPackageRootPath, '''
linter:
rules:
- invalid_lint_rule_name
-''').path;
+''');
- await setRoots(included: [projectPath], excluded: []);
+ await setRoots(included: [workspaceRootPath], excluded: []);
await waitForTasksFinished();
await pumpEventQueue();
//
// Verify the error result.
//
- var errors = filesErrors[analysisOptionsFile]!;
+ var errors = filesErrors[analysisOptions]!;
expect(errors, hasLength(1));
var error = errors[0];
- expect(error.location.file, filePath);
+ expect(error.location.file, analysisOptions.path);
expect(error.severity, AnalysisErrorSeverity.WARNING);
expect(error.type, AnalysisErrorType.STATIC_WARNING);
}
Future<void> test_analysisOptionsFile_packageInclude() async {
- var filePath = join(projectPath, 'analysis_options.yaml');
- var analysisOptionsFile = newFile2(filePath, '''
+ var analysisOptions = newAnalysisOptionsYamlFile2(testPackageRootPath, '''
include: package:pedantic/analysis_options.yaml
-''').path;
+''');
- await setRoots(included: [projectPath], excluded: []);
+ await setRoots(included: [workspaceRootPath], excluded: []);
await waitForTasksFinished();
await pumpEventQueue();
// Verify there's an error for the import.
- var errors = filesErrors[analysisOptionsFile]!;
+ var errors = filesErrors[analysisOptions]!;
expect(errors, hasLength(1));
var error = errors[0];
- expect(error.location.file, filePath);
+ expect(error.location.file, analysisOptions.path);
expect(error.severity, AnalysisErrorSeverity.WARNING);
expect(error.type, AnalysisErrorType.STATIC_WARNING);
// Write a package file that allows resolving the include.
newPackageConfigJsonFile(
- projectPath,
+ testPackageRootPath,
(PackageConfigFileBuilder()
..add(name: 'pedantic', rootPath: pedanticFolder.parent.path))
.toContent(toUriStr: toUriStr),
@@ -103,26 +98,27 @@
// Ensure the errors disappear.
await waitForTasksFinished();
await pumpEventQueue();
- errors = filesErrors[analysisOptionsFile]!;
+ errors = filesErrors[analysisOptions]!;
expect(errors, hasLength(0));
}
Future<void> test_androidManifestFile() async {
- var filePath = join(projectPath, 'android', 'AndroidManifest.xml');
- var manifestFile = newFile2(filePath, '''
+ var manifestPath =
+ join(testPackageRootPath, 'android', 'AndroidManifest.xml');
+ var manifestFile = newFile2(manifestPath, '''
<manifest
xmlns:android="http://schemas.android.com/apk/res/android">
<uses-feature android:name="android.hardware.touchscreen" android:required="false" />
<uses-feature android:name="android.software.home_screen" />
</manifest>
-''').path;
- newAnalysisOptionsYamlFile2(projectPath, '''
+''');
+ newAnalysisOptionsYamlFile2(testPackageRootPath, '''
analyzer:
optional-checks:
chrome-os-manifest-checks: true
''');
- await setRoots(included: [projectPath], excluded: []);
+ await setRoots(included: [workspaceRootPath], excluded: []);
await waitForTasksFinished();
await pumpEventQueue();
//
@@ -131,27 +127,28 @@
var errors = filesErrors[manifestFile]!;
expect(errors, hasLength(1));
var error = errors[0];
- expect(error.location.file, filePath);
+ expect(error.location.file, manifestFile.path);
expect(error.severity, AnalysisErrorSeverity.WARNING);
expect(error.type, AnalysisErrorType.STATIC_WARNING);
}
Future<void> test_androidManifestFile_dotDirectoryIgnored() async {
- var filePath = join(projectPath, 'ios', '.symlinks', 'AndroidManifest.xml');
- var manifestFile = newFile2(filePath, '''
+ var manifestPath =
+ join(testPackageRootPath, 'ios', '.symlinks', 'AndroidManifest.xml');
+ var manifestFile = newFile2(manifestPath, '''
<manifest
xmlns:android="http://schemas.android.com/apk/res/android">
<uses-feature android:name="android.hardware.touchscreen" android:required="false" />
<uses-feature android:name="android.software.home_screen" />
</manifest>
''').path;
- newAnalysisOptionsYamlFile2(projectPath, '''
+ newAnalysisOptionsYamlFile2(testPackageRootPath, '''
analyzer:
optional-checks:
chrome-os-manifest-checks: true
''');
- await setRoots(included: [projectPath], excluded: []);
+ await setRoots(included: [workspaceRootPath], excluded: []);
await waitForTasksFinished();
await pumpEventQueue();
//
@@ -165,8 +162,9 @@
// Although errors are not generated for dotfolders, their contents should
// still be analyzed so that code that references them (for example
// flutter_gen) should still be updated.
- final configPath = join(projectPath, '.dart_tool/package_config.json');
- final generatedProject = join(projectPath, '.dart_tool/foo');
+ final configPath =
+ join(testPackageRootPath, '.dart_tool/package_config.json');
+ final generatedProject = join(testPackageRootPath, '.dart_tool/foo');
final generatedFile = join(generatedProject, 'lib', 'foo.dart');
// Add the generated project into package_config.json.
@@ -181,7 +179,7 @@
A? a;
''');
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
await waitForTasksFinished();
await pumpEventQueue(times: 5000);
expect(filesErrors[testFile], isEmpty);
@@ -196,13 +194,12 @@
}
Future<void> test_dataFile() async {
- var filePath = join(projectPath, 'lib', 'fix_data.yaml');
- var dataFile = newFile2(filePath, '''
+ var dataFile = newFile2('$testPackageLibPath/fix_data.yaml', '''
version: 1
transforms:
-''').path;
+''');
- await setRoots(included: [projectPath], excluded: []);
+ await setRoots(included: [workspaceRootPath], excluded: []);
await waitForTasksFinished();
await pumpEventQueue();
//
@@ -211,7 +208,7 @@
var errors = filesErrors[dataFile]!;
expect(errors, hasLength(1));
var error = errors[0];
- expect(error.location.file, filePath);
+ expect(error.location.file, dataFile.path);
expect(error.severity, AnalysisErrorSeverity.ERROR);
expect(error.type, AnalysisErrorType.COMPILE_TIME_ERROR);
}
@@ -220,10 +217,10 @@
// Files inside dotFolders should not generate error notifications even
// if they are added to priority (priority affects only priority, not what
// is analyzed).
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
addTestFile('');
var brokenFile =
- newFile2(join(projectPath, '.dart_tool/broken.dart'), 'err').path;
+ newFile2(join(testPackageRootPath, '.dart_tool/broken.dart'), 'err');
await waitForTasksFinished();
await pumpEventQueue(times: 5000);
@@ -244,17 +241,19 @@
// them to be opened (such as hovers) should not result in error notifications
// because there is no event that would flush them and they'd remain in the
// editor forever.
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
addTestFile('');
var brokenFile =
- newFile2(join(projectPath, '.dart_tool/broken.dart'), 'err').path;
+ newFile2('$testPackageRootPath/.dart_tool/broken.dart', 'err');
await waitForTasksFinished();
await pumpEventQueue(times: 5000);
expect(filesErrors[brokenFile], isNull);
// Send a getHover request for the file that will cause it to be read from disk.
- await waitResponse(AnalysisGetHoverParams(brokenFile, 0).toRequest('0'));
+ await handleSuccessfulRequest(
+ AnalysisGetHoverParams(brokenFile.path, 0).toRequest('0'),
+ );
await waitForTasksFinished();
await pumpEventQueue(times: 5000);
@@ -263,14 +262,14 @@
}
Future<void> test_excludedFolder() async {
- newAnalysisOptionsYamlFile2(projectPath, '''
+ newAnalysisOptionsYamlFile2(testPackageRootPath, '''
analyzer:
exclude:
- excluded/**
''');
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
var excludedFile =
- newFile2(join(projectPath, 'excluded/broken.dart'), 'err').path;
+ newFile2('$testPackageRootPath/excluded/broken.dart', 'err');
// There should be no errors initially.
await waitForTasksFinished();
@@ -278,21 +277,24 @@
expect(filesErrors[excludedFile], isNull);
// Triggering the file to be processed should still generate no errors.
- await waitResponse(AnalysisGetHoverParams(excludedFile, 0).toRequest('0'));
+ await handleSuccessfulRequest(
+ AnalysisGetHoverParams(excludedFile.path, 0).toRequest('0'),
+ );
await waitForTasksFinished();
await pumpEventQueue(times: 5000);
expect(filesErrors[excludedFile], isNull);
// Opening the file should still generate no errors.
- await waitResponse(
- AnalysisSetPriorityFilesParams([excludedFile]).toRequest('0'));
+ await handleSuccessfulRequest(
+ AnalysisSetPriorityFilesParams([excludedFile.path]).toRequest('0'),
+ );
await waitForTasksFinished();
await pumpEventQueue(times: 5000);
expect(filesErrors[excludedFile], isNull);
}
Future<void> test_importError() async {
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
addTestFile('''
import 'does_not_exist.dart';
@@ -312,7 +314,7 @@
Future<void> test_lintError() async {
var camelCaseTypesLintName = 'camel_case_types';
- newAnalysisOptionsYamlFile2(projectPath, '''
+ newAnalysisOptionsYamlFile2(testPackageRootPath, '''
linter:
rules:
- $camelCaseTypesLintName
@@ -320,11 +322,10 @@
addTestFile('class a { }');
- await setRoots(included: [projectPath], excluded: []);
+ await setRoots(included: [workspaceRootPath], excluded: []);
await waitForTasksFinished();
- var testDriver = server.getAnalysisDriver(testFile)!;
- var lints = testDriver.analysisOptions.lintRules;
+ var lints = testFileAnalysisOptions.lintRules;
// Registry should only contain single lint rule.
expect(lints, hasLength(1));
@@ -335,15 +336,15 @@
var errors = filesErrors[testFile]!;
expect(errors, hasLength(1));
var error = errors[0];
- expect(error.location.file, join(projectPath, 'bin', 'test.dart'));
+ 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 {
- await createProject();
- var otherFile = newFile2('/other.dart', 'UnknownType V;').path;
+ await setRoots(included: [workspaceRootPath], excluded: []);
+ var otherFile = newFile2('/other.dart', 'UnknownType V;');
addTestFile('''
import '/other.dart';
main() {
@@ -357,10 +358,10 @@
Future<void> test_overlay_dotFolder() async {
// Files inside dotFolders should not generate error notifications even
// if they have overlays added.
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
addTestFile('');
var brokenFile =
- newFile2(join(projectPath, '.dart_tool/broken.dart'), 'err').path;
+ newFile2('$testPackageRootPath/.dart_tool/broken.dart', 'err');
await waitForTasksFinished();
await pumpEventQueue(times: 5000);
@@ -368,9 +369,9 @@
// Add and overlay and give chance for the file to be analyzed (if
// it would).
- await waitResponse(
+ await handleSuccessfulRequest(
AnalysisUpdateContentParams({
- brokenFile: AddContentOverlay('err'),
+ brokenFile.path: AddContentOverlay('err'),
}).toRequest('1'),
);
await waitForTasksFinished();
@@ -384,14 +385,14 @@
// Overlays added for files that don't exist on disk should still generate
// error notifications. Removing the overlay if the file is not on disk
// should clear the errors.
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
addTestFile('');
- var brokenFile = convertPath(join(projectPath, 'broken.dart'));
+ var brokenFile = getFile('$testPackageRootPath/broken.dart');
// Add and overlay and give chance for the file to be analyzed.
- await waitResponse(
+ await handleSuccessfulRequest(
AnalysisUpdateContentParams({
- brokenFile: AddContentOverlay('err'),
+ brokenFile.path: AddContentOverlay('err'),
}).toRequest('0'),
);
await waitForTasksFinished();
@@ -401,9 +402,9 @@
expect(filesErrors[brokenFile], hasLength(greaterThan(0)));
// Remove the overlay (this file no longer exists anywhere).
- await waitResponse(
+ await handleSuccessfulRequest(
AnalysisUpdateContentParams({
- brokenFile: RemoveContentOverlay(),
+ brokenFile.path: RemoveContentOverlay(),
}).toRequest('1'),
);
@@ -424,14 +425,14 @@
// error notifications. If the file is subsequently saved to disk before the
// overlay is removed, the errors should not be flushed when the overlay is
// removed.
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
addTestFile('');
- var brokenFile = convertPath(join(projectPath, 'broken.dart'));
+ var brokenFile = getFile('$testPackageRootPath/broken.dart');
// Add and overlay and give chance for the file to be analyzed.
- await waitResponse(
+ await handleSuccessfulRequest(
AnalysisUpdateContentParams({
- brokenFile: AddContentOverlay('err'),
+ brokenFile.path: AddContentOverlay('err'),
}).toRequest('0'),
);
await waitForTasksFinished();
@@ -441,14 +442,14 @@
expect(filesErrors[brokenFile], hasLength(greaterThan(0)));
// Write the file to disk.
- newFile2(brokenFile, 'err');
+ brokenFile.writeAsStringSync('err');
await waitForTasksFinished();
await pumpEventQueue(times: 5000);
// Remove the overlay.
- await waitResponse(
+ await handleSuccessfulRequest(
AnalysisUpdateContentParams({
- brokenFile: RemoveContentOverlay(),
+ brokenFile.path: RemoveContentOverlay(),
}).toRequest('1'),
);
await waitForTasksFinished();
@@ -460,14 +461,14 @@
}
Future<void> test_ParserError() async {
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
addTestFile('library lib');
await waitForTasksFinished();
await pumpEventQueue(times: 5000);
var errors = filesErrors[testFile]!;
expect(errors, hasLength(1));
var error = errors[0];
- expect(error.location.file, join(projectPath, 'bin', 'test.dart'));
+ expect(error.location.file, testFile.path);
expect(error.location.offset, isPositive);
expect(error.location.length, isNonNegative);
expect(error.severity, AnalysisErrorSeverity.ERROR);
@@ -476,11 +477,11 @@
}
Future<void> test_pubspecFile() async {
- var pubspecFile = newPubspecYamlFile(projectPath, '''
+ var pubspecFile = newPubspecYamlFile(testPackageRootPath, '''
version: 1.3.2
-''').path;
+''');
- await setRoots(included: [projectPath], excluded: []);
+ await setRoots(included: [workspaceRootPath], excluded: []);
await waitForTasksFinished();
await pumpEventQueue();
//
@@ -489,13 +490,13 @@
var errors = filesErrors[pubspecFile]!;
expect(errors, hasLength(1));
var error = errors[0];
- expect(error.location.file, pubspecFile);
+ expect(error.location.file, pubspecFile.path);
expect(error.severity, AnalysisErrorSeverity.WARNING);
expect(error.type, AnalysisErrorType.STATIC_WARNING);
//
// Fix the error and verify the new results.
//
- modifyFile(pubspecFile, '''
+ pubspecFile.writeAsStringSync('''
name: sample
version: 1.3.2
''');
@@ -507,21 +508,21 @@
}
Future<void> test_pubspecFile_lint() async {
- newAnalysisOptionsYamlFile2(projectPath, '''
+ newAnalysisOptionsYamlFile2(testPackageRootPath, '''
linter:
rules:
- sort_pub_dependencies
''');
- var pubspecFile = newPubspecYamlFile(projectPath, '''
+ var pubspecFile = newPubspecYamlFile(testPackageRootPath, '''
name: sample
dependencies:
b: any
a: any
-''').path;
+''');
- await setRoots(included: [projectPath], excluded: []);
+ await setRoots(included: [workspaceRootPath], excluded: []);
await waitForTasksFinished();
await pumpEventQueue();
//
@@ -530,13 +531,13 @@
var errors = filesErrors[pubspecFile]!;
expect(errors, hasLength(1));
var error = errors[0];
- expect(error.location.file, pubspecFile);
+ expect(error.location.file, pubspecFile.path);
expect(error.severity, AnalysisErrorSeverity.INFO);
expect(error.type, AnalysisErrorType.LINT);
//
// Fix the error and verify the new results.
//
- modifyFile(pubspecFile, '''
+ pubspecFile.writeAsStringSync('''
name: sample
dependencies:
@@ -551,7 +552,7 @@
}
Future<void> test_StaticWarning() async {
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
addTestFile('''
enum E {e1, e2}
diff --git a/pkg/analysis_server/test/analysis/notification_folding_test.dart b/pkg/analysis_server/test/analysis/notification_folding_test.dart
index add62cf..7cbda58 100644
--- a/pkg/analysis_server/test/analysis/notification_folding_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_folding_test.dart
@@ -9,7 +9,7 @@
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
-import '../analysis_abstract.dart';
+import '../analysis_server_base.dart';
void main() {
defineReflectiveSuite(() {
@@ -18,7 +18,7 @@
}
@reflectiveTest
-class AnalysisNotificationFoldingTest extends AbstractAnalysisTest {
+class AnalysisNotificationFoldingTest extends PubPackageAnalysisServerTest {
static const sampleCode = '''
import 'dart:async';
import 'dart:core';
@@ -40,7 +40,7 @@
void processNotification(Notification notification) {
if (notification.event == ANALYSIS_NOTIFICATION_FOLDING) {
var params = AnalysisFoldingParams.fromNotification(notification);
- if (params.file == testFile) {
+ if (params.file == testFile.path) {
lastRegions = params.regions;
_regionsReceived.complete(null);
}
@@ -53,7 +53,7 @@
@override
Future<void> setUp() async {
super.setUp();
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
}
Future<void> subscribeForFolding() async {
diff --git a/pkg/analysis_server/test/analysis/notification_highlights2_test.dart b/pkg/analysis_server/test/analysis/notification_highlights2_test.dart
index 6b6ebd6..2e70411 100644
--- a/pkg/analysis_server/test/analysis/notification_highlights2_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_highlights2_test.dart
@@ -11,7 +11,7 @@
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
-import '../analysis_abstract.dart';
+import '../analysis_server_base.dart';
void main() {
defineReflectiveSuite(() {
@@ -1593,7 +1593,7 @@
}
}
-class HighlightsTestSupport extends AbstractAnalysisTest {
+class HighlightsTestSupport extends PubPackageAnalysisServerTest {
late List<HighlightRegion> regions;
final Completer<void> _resultsAvailable = Completer();
@@ -1676,7 +1676,7 @@
}
if (notification.event == ANALYSIS_NOTIFICATION_HIGHLIGHTS) {
var params = AnalysisHighlightsParams.fromNotification(notification);
- if (params.file == testFile) {
+ if (params.file == testFile.path) {
regions = params.regions;
_resultsAvailable.complete();
}
@@ -1686,11 +1686,11 @@
@override
Future<void> setUp() async {
super.setUp();
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
}
void _addLibraryForTestPart() {
- newFile2(join(testFolder, 'my_lib.dart'), '''
+ newFile2('$testPackageLibPath/my_lib.dart', '''
library lib;
part 'test.dart';
''');
diff --git a/pkg/analysis_server/test/analysis/notification_implemented_test.dart b/pkg/analysis_server/test/analysis/notification_implemented_test.dart
index 0544f28..1b978de 100644
--- a/pkg/analysis_server/test/analysis/notification_implemented_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_implemented_test.dart
@@ -5,11 +5,11 @@
import 'package:analysis_server/protocol/protocol.dart';
import 'package:analysis_server/protocol/protocol_constants.dart';
import 'package:analysis_server/protocol/protocol_generated.dart';
-import 'package:analyzer_plugin/protocol/protocol_common.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
import '../analysis_abstract.dart';
+import '../analysis_server_base.dart';
void main() {
defineReflectiveSuite(() {
@@ -18,7 +18,7 @@
}
@reflectiveTest
-class AnalysisNotificationImplementedTest extends AbstractAnalysisTest {
+class AnalysisNotificationImplementedTest extends PubPackageAnalysisServerTest {
List<ImplementedClass>? implementedClasses;
List<ImplementedMember>? implementedMembers;
@@ -94,7 +94,7 @@
void processNotification(Notification notification) {
if (notification.event == ANALYSIS_NOTIFICATION_IMPLEMENTED) {
var params = AnalysisImplementedParams.fromNotification(notification);
- if (params.file == testFile) {
+ if (params.file == testFile.path) {
implementedClasses = params.classes;
implementedMembers = params.members;
}
@@ -104,7 +104,7 @@
@override
Future<void> setUp() async {
super.setUp();
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
}
Future<void> subscribeForImplemented() async {
@@ -122,25 +122,6 @@
assertHasImplementedClass('A {');
}
- Future<void> test_afterIncrementalResolution() async {
- await subscribeForImplemented();
- addTestFile('''
-class A {}
-class B extends A {}
-''');
- await prepareImplementedElements();
- assertHasImplementedClass('A {');
- // add a space
- implementedClasses = null;
- testCode = '''
-class A {}
-class B extends A {}
-''';
- server.updateContent('1', {testFile: AddContentOverlay(testCode)});
- await waitForImplementedElements();
- assertHasImplementedClass('A {');
- }
-
Future<void> test_class_extended() async {
addTestFile('''
class A {}
@@ -365,7 +346,7 @@
}
Future<void> test_method_withMethod_private_differentLib() async {
- newFile2(join(testFolder, 'lib.dart'), r'''
+ newFile2('$testPackageLibPath/lib.dart', r'''
import 'test.dart';
class B extends A {
void _m() {}
diff --git a/pkg/analysis_server/test/analysis/notification_navigation_test.dart b/pkg/analysis_server/test/analysis/notification_navigation_test.dart
index e869127..b657168 100644
--- a/pkg/analysis_server/test/analysis/notification_navigation_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_navigation_test.dart
@@ -214,7 +214,7 @@
class AAA {}
AAA aaa;
''');
- await server.onAnalysisComplete;
+ await waitForTasksFinished();
await prepareNavigation();
assertHasRegionTarget('AAA aaa;', 'AAA {}');
}
diff --git a/pkg/analysis_server/test/analysis/notification_occurrences_test.dart b/pkg/analysis_server/test/analysis/notification_occurrences_test.dart
index ca7d1e2..8880291 100644
--- a/pkg/analysis_server/test/analysis/notification_occurrences_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_occurrences_test.dart
@@ -12,6 +12,7 @@
import 'package:test_reflective_loader/test_reflective_loader.dart';
import '../analysis_abstract.dart';
+import '../analysis_server_base.dart';
void main() {
defineReflectiveSuite(() {
@@ -20,7 +21,7 @@
}
@reflectiveTest
-class AnalysisNotificationOccurrencesTest extends AbstractAnalysisTest {
+class AnalysisNotificationOccurrencesTest extends PubPackageAnalysisServerTest {
late List<Occurrences> occurrencesList;
late Occurrences testOccurrences;
@@ -80,7 +81,7 @@
void processNotification(Notification notification) {
if (notification.event == ANALYSIS_NOTIFICATION_OCCURRENCES) {
var params = AnalysisOccurrencesParams.fromNotification(notification);
- if (params.file == testFile) {
+ if (params.file == testFile.path) {
occurrencesList = params.occurrences;
_resultsAvailable.complete();
}
@@ -90,7 +91,7 @@
@override
Future<void> setUp() async {
super.setUp();
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
}
Future<void> test_afterAnalysis() async {
diff --git a/pkg/analysis_server/test/analysis/notification_outline_test.dart b/pkg/analysis_server/test/analysis/notification_outline_test.dart
index 14dc697..262673b 100644
--- a/pkg/analysis_server/test/analysis/notification_outline_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_outline_test.dart
@@ -11,7 +11,7 @@
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
-import '../analysis_abstract.dart';
+import '../analysis_server_base.dart';
void main() {
defineReflectiveSuite(() {
@@ -20,7 +20,7 @@
}
@reflectiveTest
-class AnalysisNotificationOutlineTest extends AbstractAnalysisTest {
+class AnalysisNotificationOutlineTest extends PubPackageAnalysisServerTest {
late FileKind fileKind;
String? libraryName;
Outline? outline;
@@ -37,7 +37,7 @@
void processNotification(Notification notification) {
if (notification.event == ANALYSIS_NOTIFICATION_OUTLINE) {
var params = AnalysisOutlineParams.fromNotification(notification);
- if (params.file == testFile) {
+ if (params.file == testFile.path) {
fileKind = params.kind;
libraryName = params.libraryName;
outline = params.outline;
@@ -46,7 +46,7 @@
}
if (notification.event == ANALYSIS_NOTIFICATION_HIGHLIGHTS) {
var params = AnalysisHighlightsParams.fromNotification(notification);
- if (params.file == testFile) {
+ if (params.file == testFile.path) {
_highlightsReceived?.complete(null);
_highlightsReceived = null;
}
@@ -56,7 +56,7 @@
@override
Future<void> setUp() async {
super.setUp();
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
}
Future<void> test_afterAnalysis() async {
diff --git a/pkg/analysis_server/test/analysis/notification_overrides_test.dart b/pkg/analysis_server/test/analysis/notification_overrides_test.dart
index 77b9230..ac0e7c8 100644
--- a/pkg/analysis_server/test/analysis/notification_overrides_test.dart
+++ b/pkg/analysis_server/test/analysis/notification_overrides_test.dart
@@ -11,6 +11,7 @@
import 'package:test_reflective_loader/test_reflective_loader.dart';
import '../analysis_abstract.dart';
+import '../analysis_server_base.dart';
void main() {
defineReflectiveSuite(() {
@@ -19,7 +20,7 @@
}
@reflectiveTest
-class AnalysisNotificationOverridesTest extends AbstractAnalysisTest {
+class AnalysisNotificationOverridesTest extends PubPackageAnalysisServerTest {
late List<Override> overridesList;
late Override overrideObject;
@@ -113,7 +114,7 @@
void processNotification(Notification notification) {
if (notification.event == ANALYSIS_NOTIFICATION_OVERRIDES) {
var params = AnalysisOverridesParams.fromNotification(notification);
- if (params.file == testFile) {
+ if (params.file == testFile.path) {
overridesList = params.overrides;
_resultsAvailable.complete();
}
@@ -123,7 +124,7 @@
@override
Future<void> setUp() async {
super.setUp();
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
}
Future<void> test_afterAnalysis() async {
@@ -221,7 +222,7 @@
}
Future<void> test_class_BAD_privateByPrivate_inDifferentLib() async {
- newFile2(join(testFolder, 'lib.dart'), r'''
+ newFile2('$testPackageLibPath/lib.dart', r'''
class A {
void _m() {}
}
diff --git a/pkg/analysis_server/test/analysis/reanalyze_test.dart b/pkg/analysis_server/test/analysis/reanalyze_test.dart
index 84aea11..d460e3e 100644
--- a/pkg/analysis_server/test/analysis/reanalyze_test.dart
+++ b/pkg/analysis_server/test/analysis/reanalyze_test.dart
@@ -5,11 +5,12 @@
import 'package:analysis_server/protocol/protocol.dart';
import 'package:analysis_server/protocol/protocol_constants.dart';
import 'package:analysis_server/protocol/protocol_generated.dart';
+import 'package:analyzer/file_system/file_system.dart';
import 'package:analyzer_plugin/protocol/protocol_common.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
-import '../analysis_abstract.dart';
+import '../analysis_server_base.dart';
void main() {
defineReflectiveSuite(() {
@@ -18,42 +19,45 @@
}
@reflectiveTest
-class ReanalyzeTest extends AbstractAnalysisTest {
- Map<String, List<AnalysisError>> filesErrors = {};
+class ReanalyzeTest extends PubPackageAnalysisServerTest {
+ Map<File, List<AnalysisError>> filesErrors = {};
@override
void processNotification(Notification notification) {
if (notification.event == ANALYSIS_NOTIFICATION_ERRORS) {
var decoded = AnalysisErrorsParams.fromNotification(notification);
- filesErrors[decoded.file] = decoded.errors;
+ filesErrors[getFile(decoded.file)] = decoded.errors;
}
}
Future<void> test_reanalyze() async {
- var b = convertPath('/other/b.dart');
+ var b = getFolder(testPackageLibPath).parent.getChildAssumingFile('b.dart');
- newFile2(testFile, r'''
-import '../../other/b.dart';
+ var file = newFile2('$testPackageTestPath/a.dart', r'''
+import '../b.dart';
var b = B();
''');
- await createProject();
+
+ await setRoots(included: [testPackageTestPath], excluded: []);
// b.dart does not exist, and `B` is unresolved.
await waitForTasksFinished();
- expect(filesErrors[testFile], hasLength(2));
+ expect(filesErrors[file], hasLength(2));
// Clear errors, so that we'll notice new results.
filesErrors.clear();
// Create b.dart, reanalyzing should fix the error.
- newFile2(b, 'class B {}');
+ b.writeAsStringSync('class B {}');
// Reanalyze.
- await server.reanalyze();
+ await handleSuccessfulRequest(
+ AnalysisReanalyzeParams().toRequest('0'),
+ );
await waitForTasksFinished();
// No errors.
- expect(filesErrors[testFile], isEmpty);
+ expect(filesErrors[file], isEmpty);
}
}
diff --git a/pkg/analysis_server/test/analysis/set_priority_files_test.dart b/pkg/analysis_server/test/analysis/set_priority_files_test.dart
index 16b93d0..47b2f68 100644
--- a/pkg/analysis_server/test/analysis/set_priority_files_test.dart
+++ b/pkg/analysis_server/test/analysis/set_priority_files_test.dart
@@ -4,12 +4,11 @@
import 'package:analysis_server/protocol/protocol.dart';
import 'package:analysis_server/protocol/protocol_generated.dart';
-import 'package:analysis_server/src/domain_analysis.dart';
-import 'package:analyzer/src/util/file_paths.dart' as file_paths;
+import 'package:analyzer/file_system/file_system.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
-import '../analysis_abstract.dart';
+import '../analysis_server_base.dart';
import '../mocks.dart';
void main() {
@@ -19,18 +18,15 @@
}
@reflectiveTest
-class SetPriorityFilesTest extends AbstractAnalysisTest {
+class SetPriorityFilesTest extends PubPackageAnalysisServerTest {
@override
Future<void> setUp() async {
super.setUp();
- server.handlers = [
- AnalysisDomainHandler(server),
- ];
- await createProject();
+ await setRoots(included: [workspaceRootPath], excluded: []);
}
Future<void> test_fileDoesNotExist() async {
- var file = convertPath('$projectPath/doesNotExist.dart');
+ var file = getFile('$testPackageLibPath/doesNotExist.dart');
var response = await _setPriorityFile(file);
expect(response, isResponseSuccess('0'));
}
@@ -45,90 +41,98 @@
}
Future<void> test_fileInAnalysisRootAddedLater() async {
- var path = convertPath('/other/file.dart');
- newFile2(path, '');
- await _setPriorityFile(path);
- await _setAnalysisRoots('/other');
- _verifyPriorityFiles(path);
+ var file = newFile2('/other/file.dart', '');
+ await _setPriorityFile(file);
+ await setRoots(included: [file.parent.path], excluded: []);
+ _verifyPriorityFiles(file);
}
Future<void> test_fileInSdk() async {
addTestFile('');
// set priority files
- var filePath = convertPath('/lib/convert/convert.dart');
- var response = await _setPriorityFile(filePath);
+ var file = sdkRoot
+ .getChildAssumingFolder('lib')
+ .getChildAssumingFolder('convert')
+ .getChildAssumingFile('convert.dart');
+ var response = await _setPriorityFile(file);
expect(response, isResponseSuccess('0'));
// verify
- _verifyPriorityFiles(filePath);
+ _verifyPriorityFiles(file);
}
Future<void> test_fileNotInAnalysisRoot() async {
- var path = convertPath('/other/file.dart');
- newFile2(path, '');
- await _setPriorityFile(path);
- _verifyPriorityFiles(path);
+ var file = newFile2('/other/file.dart', '');
+ await _setPriorityFile(file);
+ _verifyPriorityFiles(file);
}
Future<void> test_ignoredInAnalysisOptions() async {
- var sampleFile = convertPath('$projectPath/samples/sample.dart');
- newFile2('$projectPath/${file_paths.analysisOptionsYaml}', r'''
+ newAnalysisOptionsYamlFile2(testPackageRootPath, r'''
analyzer:
exclude:
- 'samples/**'
''');
- newFile2(sampleFile, '');
+ var file = newFile2('$testPackageRootPath/samples/sample.dart', '');
// attempt to set priority file
- await _setPriorityFile(sampleFile);
- _verifyPriorityFiles(sampleFile);
+ await _setPriorityFile(file);
+ _verifyPriorityFiles(file);
}
Future<void> test_ignoredInAnalysisOptions_inChildContext() async {
- newPackageConfigJsonFile(projectPath, '');
- newPackageConfigJsonFile('$projectPath/child', '');
- var sampleFile = convertPath('$projectPath/child/samples/sample.dart');
- newFile2('$projectPath/child/${file_paths.analysisOptionsYaml}', r'''
+ newPackageConfigJsonFile(testPackageRootPath, '');
+ newPackageConfigJsonFile('$testPackageRootPath/child', '');
+ var sampleFile = newFile2(
+ '$testPackageRootPath/child/samples/sample.dart',
+ '',
+ );
+ newAnalysisOptionsYamlFile2(testPackageRootPath, r'''
analyzer:
exclude:
- 'samples/**'
''');
- newFile2(sampleFile, '');
// attempt to set priority file
await _setPriorityFile(sampleFile);
_verifyPriorityFiles(sampleFile);
}
Future<void> test_ignoredInAnalysisOptions_inRootContext() async {
- newPackageConfigJsonFile(projectPath, '');
- newPackageConfigJsonFile('$projectPath/child', '');
- var sampleFile = convertPath('$projectPath/child/samples/sample.dart');
- newFile2('$projectPath/${file_paths.analysisOptionsYaml}', r'''
+ newPackageConfigJsonFile(testPackageRootPath, '');
+ newPackageConfigJsonFile('$testPackageRootPath/child', '');
+ var sampleFile = newFile2(
+ '$testPackageRootPath/child/samples/sample.dart',
+ '',
+ );
+ newAnalysisOptionsYamlFile2(testPackageRootPath, r'''
analyzer:
exclude:
- 'child/samples/**'
''');
- newFile2(sampleFile, '');
// attempt to set priority file
await _setPriorityFile(sampleFile);
_verifyPriorityFiles(sampleFile);
}
Future<void> test_invalidFilePathFormat_notAbsolute() async {
- var request = AnalysisSetPriorityFilesParams(['test.dart']).toRequest('0');
- var response = await waitResponse(request);
- expect(
+ var response = await handleRequest(
+ AnalysisSetPriorityFilesParams([
+ 'test.dart',
+ ]).toRequest('0'),
+ );
+ assertResponseFailure(
response,
- isResponseFailure('0', RequestErrorCode.INVALID_FILE_PATH_FORMAT),
+ requestId: '0',
+ errorCode: RequestErrorCode.INVALID_FILE_PATH_FORMAT,
);
}
Future<void> test_invalidFilePathFormat_notNormalized() async {
- var request =
- AnalysisSetPriorityFilesParams([convertPath('/foo/../bar/test.dart')])
- .toRequest('0');
- var response = await waitResponse(request);
- expect(
+ var response = await handleRequest(AnalysisSetPriorityFilesParams([
+ convertPath('/foo/../bar/test.dart'),
+ ]).toRequest('0'));
+ assertResponseFailure(
response,
- isResponseFailure('0', RequestErrorCode.INVALID_FILE_PATH_FORMAT),
+ requestId: '0',
+ errorCode: RequestErrorCode.INVALID_FILE_PATH_FORMAT,
);
}
@@ -139,22 +143,20 @@
expect(response, isResponseSuccess('0'));
// verify
var params = pluginManager.analysisSetPriorityFilesParams!;
- expect(params.files, <String>[testFile]);
+ expect(params.files, [testFile.path]);
}
- Future<Response> _setAnalysisRoots(String folder) async {
- var request = AnalysisSetAnalysisRootsParams([folder], []).toRequest('1');
- return await serverChannel.sendRequest(request);
+ Future<Response> _setPriorityFile(File file) async {
+ return await handleSuccessfulRequest(
+ AnalysisSetPriorityFilesParams(<String>[
+ file.path,
+ ]).toRequest('0'),
+ );
}
- Future<Response> _setPriorityFile(String file) async {
- var request = AnalysisSetPriorityFilesParams(<String>[file]).toRequest('0');
- return await serverChannel.sendRequest(request);
- }
-
- void _verifyPriorityFiles(String path) {
- var driver = server.getAnalysisDriver(path)!;
+ void _verifyPriorityFiles(File file) {
+ var driver = server.getAnalysisDriver(file.path)!;
var prioritySources = driver.priorityFiles;
- expect(prioritySources, [path]);
+ expect(prioritySources, [file.path]);
}
}
diff --git a/pkg/analysis_server/test/analysis/update_content_test.dart b/pkg/analysis_server/test/analysis/update_content_test.dart
index b5213d9..853eebb 100644
--- a/pkg/analysis_server/test/analysis/update_content_test.dart
+++ b/pkg/analysis_server/test/analysis/update_content_test.dart
@@ -5,13 +5,14 @@
import 'package:analysis_server/protocol/protocol.dart';
import 'package:analysis_server/protocol/protocol_constants.dart';
import 'package:analysis_server/protocol/protocol_generated.dart';
-import 'package:analyzer/src/dart/analysis/driver.dart';
+import 'package:analyzer/file_system/file_system.dart';
import 'package:analyzer_plugin/protocol/protocol_common.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
-import '../analysis_abstract.dart';
+import '../analysis_server_base.dart';
import '../mocks.dart';
+import '../services/refactoring/abstract_rename.dart';
void main() {
defineReflectiveSuite(() {
@@ -20,8 +21,8 @@
}
@reflectiveTest
-class UpdateContentTest extends AbstractAnalysisTest {
- Map<String, List<String>> filesErrors = {};
+class UpdateContentTest extends PubPackageAnalysisServerTest {
+ Map<File, List<String>> filesErrors = {};
int serverErrorCount = 0;
int navigationCount = 0;
@@ -31,7 +32,7 @@
var decoded = AnalysisErrorsParams.fromNotification(notification);
String _format(AnalysisError e) =>
'${e.location.startLine}: ${e.message}';
- filesErrors[decoded.file] = decoded.errors.map(_format).toList();
+ filesErrors[getFile(decoded.file)] = decoded.errors.map(_format).toList();
}
if (notification.event == ANALYSIS_NOTIFICATION_NAVIGATION) {
navigationCount++;
@@ -44,25 +45,28 @@
void test_illegal_ChangeContentOverlay() async {
// It should be illegal to send a ChangeContentOverlay for a file that
// doesn't have an overlay yet.
- await createProject();
- addTestFile('library foo;');
- var id = 'myId';
- try {
- server.updateContent(id, {
- testFile: ChangeContentOverlay([SourceEdit(8, 3, 'bar')])
- });
- fail('Expected an exception to be thrown');
- } on RequestFailure catch (e) {
- expect(e.response.id, id);
- expect(e.response.error!.code, RequestErrorCode.INVALID_OVERLAY_CHANGE);
- }
+ addTestFile('');
+ await setRoots(included: [workspaceRootPath], excluded: []);
+ var response = await handleRequest(
+ AnalysisUpdateContentParams({
+ testFile.path: ChangeContentOverlay([
+ SourceEdit(0, 0, ''),
+ ]),
+ }).toRequest('0'),
+ );
+ assertResponseFailure(
+ response,
+ requestId: '0',
+ errorCode: RequestErrorCode.INVALID_OVERLAY_CHANGE,
+ );
}
Future<void> test_invalidFilePathFormat_notAbsolute() async {
- var request = AnalysisUpdateContentParams(
- {'test.dart': AddContentOverlay('')},
- ).toRequest('0');
- var response = await waitResponse(request);
+ var response = await handleRequest(
+ AnalysisUpdateContentParams({
+ 'test.dart': AddContentOverlay(''),
+ }).toRequest('0'),
+ );
expect(
response,
isResponseFailure('0', RequestErrorCode.INVALID_FILE_PATH_FORMAT),
@@ -70,10 +74,11 @@
}
Future<void> test_invalidFilePathFormat_notNormalized() async {
- var request = AnalysisUpdateContentParams(
- {convertPath('/foo/../bar/test.dart'): AddContentOverlay('')},
- ).toRequest('0');
- var response = await waitResponse(request);
+ var response = await handleRequest(
+ AnalysisUpdateContentParams({
+ convertPath('/foo/../bar/test.dart'): AddContentOverlay(''),
+ }).toRequest('0'),
+ );
expect(
response,
isResponseFailure('0', RequestErrorCode.INVALID_FILE_PATH_FORMAT),
@@ -81,41 +86,54 @@
}
Future<void> test_multiple_contexts() async {
- var project1path = convertPath('/project1');
- var project2path = convertPath('/project2');
- var fooPath = newFile2('/project1/foo.dart', '''
-library foo;
-import '../project2/baz.dart';
-main() { f(); }''').path;
- var barPath = newFile2('/project2/bar.dart', '''
-library bar;
-import 'baz.dart';
-main() { f(); }''').path;
- var bazPath = newFile2('/project2/baz.dart', '''
-library baz;
-f(int i) {}
-''').path;
- await setRoots(included: [project1path, project2path], excluded: []);
+ writePackageConfig(
+ getFolder(workspaceRootPath),
+ PackageConfigFileBuilder()
+ ..add(name: 'aaa', rootPath: '$workspaceRootPath/aaa'),
+ );
+
+ var aaa = newFile2('$workspaceRootPath/aaa/lib/aaa.dart', r'''
+void f(int _) {}
+''');
+
+ var foo = newFile2('$workspaceRootPath/foo/lib/foo.dart', r'''
+import 'package:aaa/aaa.dart';
+void main() {
+ f();
+}
+''');
+
+ var bar = newFile2('$workspaceRootPath/bar/lib/bar.dart', r'''
+import 'package:aaa/aaa.dart';
+void main() {
+ f();
+}
+''');
+
+ await setRoots(included: [
+ foo.parent.path,
+ bar.parent.path,
+ ], excluded: []);
+
{
- await server.onAnalysisComplete;
+ await waitForTasksFinished();
// Files foo.dart and bar.dart should both have errors, since they both
// call f() with the wrong number of arguments.
- expect(filesErrors[fooPath], hasLength(1));
- expect(filesErrors[barPath], hasLength(1));
+ expect(filesErrors[foo], hasLength(1));
+ expect(filesErrors[bar], hasLength(1));
// Overlay the content of baz.dart to eliminate the errors.
- server.updateContent('1', {
- bazPath: AddContentOverlay('''
-library baz;
-f() {}
-''')
- });
+ await handleSuccessfulRequest(
+ AnalysisUpdateContentParams(
+ {aaa.path: AddContentOverlay('void f() {}')}).toRequest('0'),
+ );
}
+
{
- await server.onAnalysisComplete;
+ await waitForTasksFinished();
// The overlay should have been propagated to both contexts, causing both
// foo.dart and bar.dart to be reanalyzed and found to be free of errors.
- expect(filesErrors[fooPath], isEmpty);
- expect(filesErrors[barPath], isEmpty);
+ expect(filesErrors[foo], isEmpty);
+ expect(filesErrors[bar], isEmpty);
}
}
@@ -125,17 +143,23 @@
var project = newFolder('/project');
await setRoots(included: [project.path], excluded: []);
- server.updateContent('1',
- {'/project/main.dart': AddContentOverlay('import "target.dart";')});
- await server.onAnalysisComplete;
+ await handleSuccessfulRequest(
+ AnalysisUpdateContentParams({
+ '/project/main.dart': AddContentOverlay('import "target.dart";'),
+ }).toRequest('0'),
+ );
+ await waitForTasksFinished();
expect(filesErrors, {
'/project/main.dart': ["1: Target of URI doesn't exist: 'target.dart'."],
'/project/target.dart': []
});
- server.updateContent('1',
- {'/project/target.dart': AddContentOverlay('import "none.dart";')});
- await server.onAnalysisComplete;
+ await handleSuccessfulRequest(
+ AnalysisUpdateContentParams({
+ '/project/target.dart': AddContentOverlay('import "none.dart";')
+ }).toRequest('0'),
+ );
+ await waitForTasksFinished();
expect(filesErrors, {
'/project/main.dart': ['1: Unused import.'],
'/project/target.dart': ["1: Target of URI doesn't exist: 'none.dart'."],
@@ -144,51 +168,59 @@
}
Future<void> test_overlayOnly() async {
- var filePath1 = convertPath('/User/project1/test.dart');
- var filePath2 = convertPath('/User/project2/test.dart');
- var folderPath1 = newFolder('/User/project1').path;
- var folderPath2 = newFolder('/User/project2').path;
+ var a = newFile2('$testPackageLibPath/a.dart', '');
+ var b = getFile('$testPackageLibPath/b.dart');
- await setRoots(included: [folderPath1, folderPath2], excluded: []);
+ await setRoots(included: [workspaceRootPath], excluded: []);
+ await waitForTasksFinished();
+ expect(filesErrors[a], isEmpty);
+ expect(filesErrors[b], isNull);
- // exactly 2 contexts
- expect(server.driverMap, hasLength(2));
- var driver1 = server.getAnalysisDriver(filePath1)!;
- var driver2 = server.getAnalysisDriver(filePath2)!;
+ // Add `b.dart` overlay, analyzed.
+ await handleSuccessfulRequest(
+ AnalysisUpdateContentParams({
+ b.path: AddContentOverlay(''),
+ }).toRequest('0'),
+ );
+ await waitForTasksFinished();
+ expect(filesErrors[a], isEmpty);
+ expect(filesErrors[b], isEmpty);
- // no sources
- expect(await _getUserSources(driver1), isEmpty);
- expect(await _getUserSources(driver2), isEmpty);
-
- // add an overlay - new Source in context1
- server.updateContent('1', {filePath1: AddContentOverlay('')});
- expect(await _getUserSources(driver1), [filePath1]);
- expect(await _getUserSources(driver2), isEmpty);
-
- // remove the overlay - no sources
- server.updateContent('2', {filePath1: RemoveContentOverlay()});
-
- // The file isn't removed from the list of added sources.
-// expect(_getUserSources(driver1), isEmpty);
- expect(await _getUserSources(driver2), isEmpty);
+ // Add `b.dart` overlay, analyzed.
+ await handleSuccessfulRequest(
+ AnalysisUpdateContentParams({
+ b.path: RemoveContentOverlay(),
+ }).toRequest('0'),
+ );
+ await waitForTasksFinished();
+ expect(filesErrors[a], isEmpty);
+ // TODO(scheglov) We should get "flush" notification.
+ // expect(filesErrors[b], isNull);
}
@failingTest
Future<void> test_sendNoticesAfterNopChange() async {
// The errors are empty on the last line.
addTestFile('');
- await createProject();
- await server.onAnalysisComplete;
+ await setRoots(included: [workspaceRootPath], excluded: []);
+ await waitForTasksFinished();
// add an overlay
- server.updateContent(
- '1', {testFile: AddContentOverlay('main() {} main() {}')});
- await server.onAnalysisComplete;
+ await handleSuccessfulRequest(
+ AnalysisUpdateContentParams({
+ testFile.path: AddContentOverlay('main() {} main() {}'),
+ }).toRequest('0'),
+ );
+ await waitForTasksFinished();
// clear errors and make a no-op change
filesErrors.clear();
- server.updateContent('2', {
- testFile: ChangeContentOverlay([SourceEdit(0, 4, 'main')])
- });
- await server.onAnalysisComplete;
+ await handleSuccessfulRequest(
+ AnalysisUpdateContentParams({
+ testFile.path: ChangeContentOverlay([
+ SourceEdit(0, 4, 'main'),
+ ]),
+ }).toRequest('0'),
+ );
+ await waitForTasksFinished();
// errors should have been resent
expect(filesErrors, isNotEmpty);
}
@@ -197,31 +229,40 @@
Future<void> test_sendNoticesAfterNopChange_flushedUnit() async {
// The list of errors is empty on the last line.
addTestFile('');
- await createProject();
- await server.onAnalysisComplete;
+ await setRoots(included: [workspaceRootPath], excluded: []);
+ await waitForTasksFinished();
// add an overlay
- server.updateContent(
- '1', {testFile: AddContentOverlay('main() {} main() {}')});
- await server.onAnalysisComplete;
+ await handleSuccessfulRequest(
+ AnalysisUpdateContentParams({
+ testFile.path: AddContentOverlay('main() {} main() {}'),
+ }).toRequest('0'),
+ );
+ await waitForTasksFinished();
// clear errors and make a no-op change
filesErrors.clear();
- server.updateContent('2', {
- testFile: ChangeContentOverlay([SourceEdit(0, 4, 'main')])
- });
- await server.onAnalysisComplete;
+ await handleSuccessfulRequest(
+ AnalysisUpdateContentParams({
+ testFile.path: ChangeContentOverlay([
+ SourceEdit(0, 4, 'main'),
+ ]),
+ }).toRequest('0'),
+ );
+ await waitForTasksFinished();
// errors should have been resent
expect(filesErrors, isNotEmpty);
}
- void test_sentToPlugins() {
- var filePath = convertPath('/project/target.dart');
+ Future<void> test_sentToPlugins() async {
+ var filePath = convertPath('$testPackageLibPath/a.dart');
var fileContent = 'import "none.dart";';
//
// Add
//
- handleSuccessfulRequest(AnalysisUpdateContentParams(
- <String, Object>{filePath: AddContentOverlay(fileContent)})
- .toRequest('0'));
+ await handleSuccessfulRequest(
+ AnalysisUpdateContentParams(<String, Object>{
+ filePath: AddContentOverlay(fileContent),
+ }).toRequest('0'),
+ );
var params = pluginManager.analysisUpdateContentParams!;
var files = params.files;
expect(files, hasLength(1));
@@ -233,10 +274,14 @@
// Change
//
pluginManager.analysisUpdateContentParams = null;
- handleSuccessfulRequest(AnalysisUpdateContentParams(<String, Object>{
- filePath: ChangeContentOverlay(
- <SourceEdit>[SourceEdit(8, 1, "'"), SourceEdit(18, 1, "'")])
- }).toRequest('1'));
+ await handleSuccessfulRequest(
+ AnalysisUpdateContentParams(<String, Object>{
+ filePath: ChangeContentOverlay(<SourceEdit>[
+ SourceEdit(8, 1, "'"),
+ SourceEdit(18, 1, "'"),
+ ]),
+ }).toRequest('1'),
+ );
params = pluginManager.analysisUpdateContentParams!;
expect(params, isNotNull);
files = params.files;
@@ -249,8 +294,11 @@
// Remove
//
pluginManager.analysisUpdateContentParams = null;
- handleSuccessfulRequest(AnalysisUpdateContentParams(
- <String, Object>{filePath: RemoveContentOverlay()}).toRequest('2'));
+ await handleSuccessfulRequest(
+ AnalysisUpdateContentParams(<String, Object>{
+ filePath: RemoveContentOverlay(),
+ }).toRequest('2'),
+ );
params = pluginManager.analysisUpdateContentParams!;
expect(params, isNotNull);
files = params.files;
@@ -258,15 +306,4 @@
overlay = files[filePath];
expect(overlay, const TypeMatcher<RemoveContentOverlay>());
}
-
- Future<List<String>> _getUserSources(AnalysisDriver driver) async {
- var sources = <String>[];
- await driver.applyPendingFileChanges();
- driver.addedFiles.forEach((path) {
- if (path.startsWith(convertPath('/User/'))) {
- sources.add(path);
- }
- });
- return sources;
- }
}
diff --git a/pkg/analysis_server/test/analysis_server_base.dart b/pkg/analysis_server/test/analysis_server_base.dart
index a6d5579..804f079 100644
--- a/pkg/analysis_server/test/analysis_server_base.dart
+++ b/pkg/analysis_server/test/analysis_server_base.dart
@@ -10,6 +10,7 @@
import 'package:analysis_server/src/protocol_server.dart';
import 'package:analysis_server/src/server/crash_reporting_attachments.dart';
import 'package:analysis_server/src/utilities/mocks.dart';
+import 'package:analyzer/dart/analysis/analysis_options.dart' as analysis;
import 'package:analyzer/file_system/file_system.dart';
import 'package:analyzer/instrumentation/service.dart';
import 'package:analyzer/src/dart/analysis/experiments.dart';
@@ -69,9 +70,13 @@
}
class PubPackageAnalysisServerTest with ResourceProviderMixin {
+ final TestPluginManager pluginManager = TestPluginManager();
late final MockServerChannel serverChannel;
late final AnalysisServer server;
+ final List<GeneralAnalysisService> _analysisGeneralServices = [];
+ final Map<AnalysisService, List<String>> _analysisFileSubscriptions = {};
+
AnalysisDomainHandler get analysisDomain {
return server.handlers.whereType<AnalysisDomainHandler>().single;
}
@@ -86,8 +91,15 @@
EnableString.super_parameters,
];
+ Folder get sdkRoot => newFolder('/sdk');
+
File get testFile => getFile(testFilePath);
+ analysis.AnalysisOptions get testFileAnalysisOptions {
+ var analysisDriver = server.getAnalysisDriver(testFile.path)!;
+ return analysisDriver.analysisOptions;
+ }
+
String get testFileContent => testFile.readAsStringSync();
String get testFilePath => '$testPackageLibPath/test.dart';
@@ -102,6 +114,25 @@
String get workspaceRootPath => '/home';
+ Future<void> addAnalysisSubscription(
+ AnalysisService service,
+ File file,
+ ) async {
+ (_analysisFileSubscriptions[service] ??= []).add(file.path);
+ await handleSuccessfulRequest(
+ AnalysisSetSubscriptionsParams(
+ _analysisFileSubscriptions,
+ ).toRequest('0'),
+ );
+ }
+
+ Future<void> addGeneralAnalysisSubscription(
+ GeneralAnalysisService service,
+ ) async {
+ _analysisGeneralServices.add(service);
+ await _setGeneralAnalysisSubscriptions();
+ }
+
/// TODO(scheglov) rename
void addTestFile(String content) {
newFile2(testFilePath, content);
@@ -144,6 +175,10 @@
return response;
}
+ void modifyTestFile(String content) {
+ modifyFile(testFilePath, content);
+ }
+
/// Returns the offset of [search] in [file].
/// Fails if not found.
int offsetInFile(File file, String search) {
@@ -155,6 +190,21 @@
void processNotification(Notification notification) {}
+ Future<void> removeGeneralAnalysisSubscription(
+ GeneralAnalysisService service,
+ ) async {
+ _analysisGeneralServices.remove(service);
+ await _setGeneralAnalysisSubscriptions();
+ }
+
+ void setPriorityFiles(List<File> files) {
+ handleSuccessfulRequest(
+ AnalysisSetPriorityFilesParams(
+ files.map((e) => e.path).toList(),
+ ).toRequest('0'),
+ );
+ }
+
Future<void> setRoots({
required List<String> included,
required List<String> excluded,
@@ -174,7 +224,6 @@
void setUp() {
serverChannel = MockServerChannel();
- var sdkRoot = newFolder('/sdk');
createMockSdk(
resourceProvider: resourceProvider,
root: sdkRoot,
@@ -200,6 +249,7 @@
);
server.pendingFilesRemoveOverlayDelay = const Duration(milliseconds: 10);
+ server.pluginManager = pluginManager;
completionDomain.budgetDuration = const Duration(seconds: 30);
}
@@ -249,4 +299,12 @@
void writeTestPackagePubspecYamlFile(String content) {
newPubspecYamlFile(testPackageRootPath, content);
}
+
+ Future<void> _setGeneralAnalysisSubscriptions() async {
+ await handleSuccessfulRequest(
+ AnalysisSetGeneralSubscriptionsParams(
+ _analysisGeneralServices,
+ ).toRequest('0'),
+ );
+ }
}
diff --git a/pkg/analysis_server/test/edit/format_test.dart b/pkg/analysis_server/test/edit/format_test.dart
index d62a67e..742ae2a 100644
--- a/pkg/analysis_server/test/edit/format_test.dart
+++ b/pkg/analysis_server/test/edit/format_test.dart
@@ -4,7 +4,6 @@
import 'package:analysis_server/protocol/protocol_generated.dart';
import 'package:analysis_server/src/edit/edit_domain.dart';
-import 'package:analysis_server/src/utilities/progress.dart';
import 'package:test/test.dart';
import 'package:test_reflective_loader/test_reflective_loader.dart';
@@ -26,44 +25,42 @@
handler = EditDomainHandler(server);
}
- Future test_format_longLine() {
+ Future<void> test_format_longLine() async {
var content = '''
fun(firstParam, secondParam, thirdParam, fourthParam) {
if (firstParam.noNull && secondParam.noNull && thirdParam.noNull && fourthParam.noNull) {}
}
''';
addTestFile(content);
- return waitForTasksFinished().then((_) {
- var formatResult = _formatAt(0, 3, lineLength: 100);
+ await waitForTasksFinished();
+ var formatResult = await _formatAt(0, 3, lineLength: 100);
- expect(formatResult.edits, isNotNull);
- expect(formatResult.edits, hasLength(0));
+ expect(formatResult.edits, isNotNull);
+ expect(formatResult.edits, hasLength(0));
- expect(formatResult.selectionOffset, equals(0));
- expect(formatResult.selectionLength, equals(3));
- });
+ expect(formatResult.selectionOffset, equals(0));
+ expect(formatResult.selectionLength, equals(3));
}
- Future test_format_noOp() {
+ Future<void> test_format_noOp() async {
// Already formatted source
addTestFile('''
main() {
int x = 3;
}
''');
- return waitForTasksFinished().then((_) {
- var formatResult = _formatAt(0, 3);
- expect(formatResult.edits, isNotNull);
- expect(formatResult.edits, hasLength(0));
- });
+ await waitForTasksFinished();
+ var formatResult = await _formatAt(0, 3);
+ expect(formatResult.edits, isNotNull);
+ expect(formatResult.edits, hasLength(0));
}
- Future test_format_noSelection() async {
+ Future<void> test_format_noSelection() async {
addTestFile('''
main() { int x = 3; }
''');
await waitForTasksFinished();
- var formatResult = _formatAt(0, 0);
+ var formatResult = await _formatAt(0, 0);
expect(formatResult.edits, isNotNull);
expect(formatResult.edits, hasLength(1));
@@ -78,44 +75,42 @@
expect(formatResult.selectionLength, equals(0));
}
- Future test_format_simple() {
+ Future<void> test_format_simple() async {
addTestFile('''
main() { int x = 3; }
''');
- return waitForTasksFinished().then((_) {
- var formatResult = _formatAt(0, 3);
+ await waitForTasksFinished();
+ var formatResult = await _formatAt(0, 3);
- expect(formatResult.edits, isNotNull);
- expect(formatResult.edits, hasLength(1));
+ expect(formatResult.edits, isNotNull);
+ expect(formatResult.edits, hasLength(1));
- var edit = formatResult.edits[0];
- expect(edit.replacement, equals('''
+ var edit = formatResult.edits[0];
+ expect(edit.replacement, equals('''
main() {
int x = 3;
}
'''));
- expect(formatResult.selectionOffset, equals(0));
- expect(formatResult.selectionLength, equals(3));
- });
+ expect(formatResult.selectionOffset, equals(0));
+ expect(formatResult.selectionLength, equals(3));
}
- Future test_format_withErrors() {
+ Future<void> test_format_withErrors() async {
addTestFile('''
main() { int x =
''');
- return waitForTasksFinished().then((_) {
- var request = EditFormatParams(testFile, 0, 3).toRequest('0');
- var response = handler.handleRequest(request, NotCancelableToken());
- expect(response, isResponseFailure('0'));
- });
+ await waitForTasksFinished();
+ var request = EditFormatParams(testFile, 0, 3).toRequest('0');
+ var response = await waitResponse(request);
+ expect(response, isResponseFailure('0'));
}
- EditFormatResult _formatAt(int selectionOffset, int selectionLength,
- {int? lineLength}) {
+ Future<EditFormatResult> _formatAt(int selectionOffset, int selectionLength,
+ {int? lineLength}) async {
var request = EditFormatParams(testFile, selectionOffset, selectionLength,
lineLength: lineLength)
.toRequest('0');
- var response = handleSuccessfulRequest(request);
+ var response = await waitResponse(request);
return EditFormatResult.fromResponse(response);
}
}
diff --git a/pkg/analysis_server/test/lsp/type_definition_test.dart b/pkg/analysis_server/test/lsp/type_definition_test.dart
index 9f003e8..b7c92ea 100644
--- a/pkg/analysis_server/test/lsp/type_definition_test.dart
+++ b/pkg/analysis_server/test/lsp/type_definition_test.dart
@@ -16,6 +16,11 @@
@reflectiveTest
class TypeDefinitionTest extends AbstractLspAnalysisServerTest {
+ Uri get sdkCoreUri {
+ final sdkCorePath = convertPath('/sdk/lib/core/core.dart');
+ return Uri.file(sdkCorePath);
+ }
+
Future<void> test_currentFile() async {
final contents = '''
class [[A]] {}
@@ -78,7 +83,7 @@
''';
final result = await _getLocationResult(contents);
- expect(result.uri, 'file:///sdk/lib/core/core.dart');
+ expect(result.uri, '$sdkCoreUri');
_expectNameRange(result.range, 'String');
}
@@ -264,7 +269,7 @@
/// This is used for SDK sources where the exact location is not known to the
/// test.
void _expectSdkCoreType(LocationLink result, String typeName) {
- expect(result.targetUri, 'file:///sdk/lib/core/core.dart');
+ expect(result.targetUri, '$sdkCoreUri');
_expectNameRange(result.targetSelectionRange, typeName);
_expectCodeRange(result.targetRange);
}
diff --git a/pkg/analysis_server/test/src/services/correction/fix/create_constructor_for_final_fields_test.dart b/pkg/analysis_server/test/src/services/correction/fix/create_constructor_for_final_fields_test.dart
index 92c5799..783000a 100644
--- a/pkg/analysis_server/test/src/services/correction/fix/create_constructor_for_final_fields_test.dart
+++ b/pkg/analysis_server/test/src/services/correction/fix/create_constructor_for_final_fields_test.dart
@@ -12,6 +12,9 @@
void main() {
defineReflectiveSuite(() {
defineReflectiveTests(CreateConstructorForFinalFieldsTest);
+ defineReflectiveTests(CreateConstructorForFinalFieldsWithoutNullSafetyTest);
+ defineReflectiveTests(
+ CreateConstructorForFinalFieldsWithoutSuperParametersTest);
});
}
@@ -45,7 +48,7 @@
class MyWidget extends StatelessWidget {
final int a;
final int b = 2;
- final int c;
+ final int? c;
}
''');
await assertHasFix('''
@@ -54,9 +57,9 @@
class MyWidget extends StatelessWidget {
final int a;
final int b = 2;
- final int c;
+ final int? c;
- const MyWidget({Key? key, this.a, this.c}) : super(key: key);
+ const MyWidget({super.key, required this.a, this.c});
}
''', errorFilter: (error) {
return error.message.contains("'a'");
@@ -71,7 +74,7 @@
class MyWidget extends StatelessWidget {
final int a;
final Widget child;
- final int b;
+ final int? b;
}
''');
await assertHasFix('''
@@ -80,9 +83,9 @@
class MyWidget extends StatelessWidget {
final int a;
final Widget child;
- final int b;
+ final int? b;
- const MyWidget({Key? key, this.a, this.b, this.child}) : super(key: key);
+ const MyWidget({super.key, required this.a, this.b, required this.child});
}
''', errorFilter: (error) {
return error.message.contains("'a'");
@@ -97,7 +100,7 @@
class MyWidget extends StatelessWidget {
final int a;
final List<Widget> children;
- final int b;
+ final int? b;
}
''');
await assertHasFix('''
@@ -106,9 +109,9 @@
class MyWidget extends StatelessWidget {
final int a;
final List<Widget> children;
- final int b;
+ final int? b;
- const MyWidget({Key? key, this.a, this.b, this.children}) : super(key: key);
+ const MyWidget({super.key, required this.a, this.b, required this.children});
}
''', errorFilter: (error) {
return error.message.contains("'a'");
@@ -175,3 +178,179 @@
await assertNoFix();
}
}
+
+@reflectiveTest
+class CreateConstructorForFinalFieldsWithoutNullSafetyTest
+ extends FixProcessorTest {
+ @override
+ FixKind get kind => DartFixKind.CREATE_CONSTRUCTOR_FOR_FINAL_FIELDS;
+
+ @override
+ String get testPackageLanguageVersion => '2.9';
+
+ Future<void> test_flutter() async {
+ writeTestPackageConfig(flutter: true);
+ await resolveTestCode('''
+import 'package:flutter/widgets.dart';
+
+class MyWidget extends StatelessWidget {
+ final int a;
+ final int b = 2;
+ final int c;
+}
+''');
+ await assertHasFix('''
+import 'package:flutter/widgets.dart';
+
+class MyWidget extends StatelessWidget {
+ final int a;
+ final int b = 2;
+ final int c;
+
+ const MyWidget({Key key, this.a, this.c}) : super(key: key);
+}
+''', errorFilter: (error) {
+ return error.message.contains("'a'");
+ });
+ }
+
+ Future<void> test_flutter_childLast() async {
+ writeTestPackageConfig(flutter: true);
+ await resolveTestCode('''
+import 'package:flutter/widgets.dart';
+
+class MyWidget extends StatelessWidget {
+ final int a;
+ final Widget child;
+ final int b;
+}
+''');
+ await assertHasFix('''
+import 'package:flutter/widgets.dart';
+
+class MyWidget extends StatelessWidget {
+ final int a;
+ final Widget child;
+ final int b;
+
+ const MyWidget({Key key, this.a, this.b, this.child}) : super(key: key);
+}
+''', errorFilter: (error) {
+ return error.message.contains("'a'");
+ });
+ }
+
+ Future<void> test_flutter_childrenLast() async {
+ writeTestPackageConfig(flutter: true);
+ await resolveTestCode('''
+import 'package:flutter/widgets.dart';
+
+class MyWidget extends StatelessWidget {
+ final int a;
+ final List<Widget> children;
+ final int b;
+}
+''');
+ await assertHasFix('''
+import 'package:flutter/widgets.dart';
+
+class MyWidget extends StatelessWidget {
+ final int a;
+ final List<Widget> children;
+ final int b;
+
+ const MyWidget({Key key, this.a, this.b, this.children}) : super(key: key);
+}
+''', errorFilter: (error) {
+ return error.message.contains("'a'");
+ });
+ }
+}
+
+@reflectiveTest
+class CreateConstructorForFinalFieldsWithoutSuperParametersTest
+ extends FixProcessorTest {
+ @override
+ FixKind get kind => DartFixKind.CREATE_CONSTRUCTOR_FOR_FINAL_FIELDS;
+
+ @override
+ String get testPackageLanguageVersion => '2.16';
+
+ Future<void> test_flutter() async {
+ writeTestPackageConfig(flutter: true);
+ await resolveTestCode('''
+import 'package:flutter/widgets.dart';
+
+class MyWidget extends StatelessWidget {
+ final int a;
+ final int b = 2;
+ final int? c;
+}
+''');
+ await assertHasFix('''
+import 'package:flutter/widgets.dart';
+
+class MyWidget extends StatelessWidget {
+ final int a;
+ final int b = 2;
+ final int? c;
+
+ const MyWidget({Key? key, required this.a, this.c}) : super(key: key);
+}
+''', errorFilter: (error) {
+ return error.message.contains("'a'");
+ });
+ }
+
+ Future<void> test_flutter_childLast() async {
+ writeTestPackageConfig(flutter: true);
+ await resolveTestCode('''
+import 'package:flutter/widgets.dart';
+
+class MyWidget extends StatelessWidget {
+ final int a;
+ final Widget child;
+ final int? b;
+}
+''');
+ await assertHasFix('''
+import 'package:flutter/widgets.dart';
+
+class MyWidget extends StatelessWidget {
+ final int a;
+ final Widget child;
+ final int? b;
+
+ const MyWidget({Key? key, required this.a, this.b, required this.child}) : super(key: key);
+}
+''', errorFilter: (error) {
+ return error.message.contains("'a'");
+ });
+ }
+
+ Future<void> test_flutter_childrenLast() async {
+ writeTestPackageConfig(flutter: true);
+ await resolveTestCode('''
+import 'package:flutter/widgets.dart';
+
+class MyWidget extends StatelessWidget {
+ final int a;
+ final List<Widget>? children;
+ final int? b;
+}
+''');
+ await assertHasFix('''
+import 'package:flutter/widgets.dart';
+
+class MyWidget extends StatelessWidget {
+ final int a;
+ final List<Widget>? children;
+ final int? b;
+
+ const MyWidget({Key? key, required this.a, this.b, this.children}) : super(key: key);
+}
+''', errorFilter: (error) {
+ return error.message.contains("'a'");
+ });
+ }
+}
diff --git a/pkg/analyzer/lib/src/summary2/top_level_inference.dart b/pkg/analyzer/lib/src/summary2/top_level_inference.dart
index 9708fbb..50db402 100644
--- a/pkg/analyzer/lib/src/summary2/top_level_inference.dart
+++ b/pkg/analyzer/lib/src/summary2/top_level_inference.dart
@@ -203,7 +203,7 @@
if (_superParameters.isNotEmpty) {
dependencies.addIfNotNull(
- _walker.getNode(_constructor.superConstructor),
+ _walker.getNode(_constructor.superConstructor?.declaration),
);
}
diff --git a/pkg/analyzer/test/src/summary/elements_test.dart b/pkg/analyzer/test/src/summary/elements_test.dart
index 1a23546..b5bc665 100644
--- a/pkg/analyzer/test/src/summary/elements_test.dart
+++ b/pkg/analyzer/test/src/summary/elements_test.dart
@@ -1761,19 +1761,19 @@
}
test_class_constructor_parameters_super_requiredPositional_inferenceOrder() async {
- // It is important that `C` is declared after `B`, so that we check that
- // inference happens in order - first `C`, then `B`.
+ // It is important that `B` is declared after `C`, so that we check that
+ // inference happens in order - first `B`, then `C`.
var library = await buildLibrary('''
abstract class A {
A(int a);
}
-class B extends C {
- B(super.a);
+class C extends B {
+ C(super.a);
}
-class C extends A {
- C(super.a);
+class B extends A {
+ B(super.a);
}
''');
checkElementText(library, r'''
@@ -1786,16 +1786,16 @@
parameters
requiredPositional a @27
type: int
- class B @40
- supertype: C
+ class C @40
+ supertype: B
constructors
@56
parameters
requiredPositional final super.a @64
type: int
superConstructorParameter: a@101
- superConstructor: self::@class::C::@constructor::•
- class C @77
+ superConstructor: self::@class::B::@constructor::•
+ class B @77
supertype: A
constructors
@93
@@ -1807,6 +1807,60 @@
''');
}
+ test_class_constructor_parameters_super_requiredPositional_inferenceOrder_generic() async {
+ // It is important that `C` is declared before `B`, so that we check that
+ // inference happens in order - first `B`, then `C`.
+ var library = await buildLibrary('''
+class A {
+ A(int a);
+}
+
+class C extends B<String> {
+ C(super.a);
+}
+
+class B<T> extends A {
+ B(super.a);
+}
+''');
+ checkElementText(library, r'''
+library
+ definingUnit
+ classes
+ class A @6
+ constructors
+ @12
+ parameters
+ requiredPositional a @18
+ type: int
+ class C @31
+ supertype: B<String>
+ constructors
+ @55
+ parameters
+ requiredPositional final super.a @63
+ type: int
+ superConstructorParameter: ParameterMember
+ base: a@103
+ substitution: {T: String}
+ superConstructor: ConstructorMember
+ base: self::@class::B::@constructor::•
+ substitution: {T: String}
+ class B @76
+ typeParameters
+ covariant T @78
+ defaultType: dynamic
+ supertype: A
+ constructors
+ @95
+ parameters
+ requiredPositional final super.a @103
+ type: int
+ superConstructorParameter: a@18
+ superConstructor: self::@class::A::@constructor::•
+''');
+ }
+
test_class_constructor_parameters_super_requiredPositional_unresolved() async {
var library = await buildLibrary('''
class A {}
diff --git a/pkg/compiler/lib/src/compiler.dart b/pkg/compiler/lib/src/compiler.dart
index fcdf267..029efeb 100644
--- a/pkg/compiler/lib/src/compiler.dart
+++ b/pkg/compiler/lib/src/compiler.dart
@@ -304,13 +304,9 @@
programSplitConstraintsData = constraintParser.read(programSplitJson);
}
- if (options.cfeOnly) {
- await runLoadKernel();
- } else if (options.modularMode) {
- await runModularAnalysis();
- } else {
+ await selfTask.measureSubtask("compileFromKernel", () async {
await runSequentialPhases();
- }
+ });
}
/// Clear the internal compiler state to prevent memory leaks when invoking
@@ -329,7 +325,13 @@
}
}
- JClosedWorld computeClosedWorld(Uri rootLibraryUri, Iterable<Uri> libraries) {
+ JClosedWorld computeClosedWorld(
+ ir.Component component,
+ List<ModuleData> moduleData,
+ Uri rootLibraryUri,
+ Iterable<Uri> libraries) {
+ frontendStrategy.registerLoadedLibraries(component, libraries);
+ frontendStrategy.registerModuleData(moduleData);
ResolutionEnqueuer resolutionEnqueuer = frontendStrategy
.createResolutionEnqueuer(enqueueTask, this)
..onEmptyForTesting = onResolutionQueueEmptyForTesting;
@@ -379,59 +381,83 @@
return closedWorld;
}
- Future<load_kernel.Output> runLoadKernel() async {
+ Future<load_kernel.Output> loadKernel() async {
final input = load_kernel.Input(options, provider, reporter,
initializedCompilerState, forceSerializationForTesting);
load_kernel.Output output =
await loadKernelTask.measure(() async => load_kernel.run(input));
- if (output == null || compilationFailed) return null;
reporter.log("Kernel load complete");
- if (retainDataForTesting) {
- componentForTesting = output.component;
- }
- if (options.features.newDumpInfo.isEnabled && options.dumpInfo) {
- untrimmedComponentForDumpInfo = output.component;
- }
-
- if (options.cfeOnly) {
- ir.Component component = output.component;
- dumpUnusedLibrariesAndTrimComponent(component, output.libraries);
- await serializationTask.serializeComponent(component);
- }
return output;
}
- void dumpUnusedLibrariesAndTrimComponent(
- ir.Component component, List<Uri> libraries) {
- if (options.fromDill) {
- if (options.dumpUnusedLibraries) {
- dumpUnusedLibraries(component, libraries);
+ Future<load_kernel.Output> produceKernel() async {
+ if (options.readClosedWorldUri == null) {
+ load_kernel.Output output = await loadKernel();
+ if (output == null || compilationFailed) return null;
+ ir.Component component = output.component;
+ if (retainDataForTesting) {
+ componentForTesting = component;
}
- if (options.entryUri != null) {
- component = trimComponent(component, libraries);
+ if (options.features.newDumpInfo.isEnabled && options.dumpInfo) {
+ untrimmedComponentForDumpInfo = component;
}
+ if (options.cfeOnly) {
+ if (options.fromDill) {
+ List<Uri> libraries = output.libraries;
+ if (options.dumpUnusedLibraries) {
+ dumpUnusedLibraries(component, libraries);
+ }
+ if (options.entryUri != null) {
+ component = trimComponent(component, libraries);
+ }
+ }
+ await serializationTask.serializeComponent(component);
+ }
+ // We currently do not return the trimmed component from [produceKernel]
+ // because downstream phases, in particular modular analysis, currently
+ // depend on the untrimmed dill.
+ return output;
+ } else {
+ ir.Component component =
+ await serializationTask.deserializeComponentAndUpdateOptions();
+ return load_kernel.Output(component, null, null, null, null);
}
}
- void runModularAnalysis() async {
- load_kernel.Output output = await runLoadKernel();
- if (output == null || compilationFailed) return;
+ bool shouldStopAfterLoadKernel(load_kernel.Output output) =>
+ output == null || compilationFailed || options.cfeOnly;
+ Future<ModuleData> runModularAnalysis(
+ load_kernel.Output output, Set<Uri> moduleLibraries) async {
ir.Component component = output.component;
List<Uri> libraries = output.libraries;
- Set<Uri> moduleLibraries = output.moduleLibraries.toSet();
_userCodeLocations
.addAll(moduleLibraries.map((module) => CodeLocation(module)));
final input = modular_analysis.Input(
options, reporter, environment, component, libraries, moduleLibraries);
- ModuleData moduleData = await selfTask.measureSubtask(
+ return await selfTask.measureSubtask(
'runModularAnalysis', () async => modular_analysis.run(input));
- if (compilationFailed) return;
- serializationTask.testModuleSerialization(moduleData, component);
- serializationTask.serializeModuleData(
- moduleData, component, moduleLibraries);
}
+ Future<List<ModuleData>> produceModuleData(load_kernel.Output output) async {
+ ir.Component component = output.component;
+ if (options.modularMode) {
+ Set<Uri> moduleLibraries = output.moduleLibraries.toSet();
+ ModuleData moduleData = await runModularAnalysis(output, moduleLibraries);
+ if (options.writeModularAnalysisUri != null && !compilationFailed) {
+ serializationTask.testModuleSerialization(moduleData, component);
+ serializationTask.serializeModuleData(
+ moduleData, component, moduleLibraries);
+ }
+ return [moduleData];
+ } else {
+ return await serializationTask.deserializeModuleData(component);
+ }
+ }
+
+ bool get shouldStopAfterModularAnalysis =>
+ compilationFailed || options.writeModularAnalysisUri != null;
+
GlobalTypeInferenceResults performGlobalTypeInference(
JClosedWorld closedWorld) {
FunctionEntity mainFunction = closedWorld.elementEnvironment.mainFunction;
@@ -508,48 +534,23 @@
globalTypeInferenceResultsData);
}
- Future<load_kernel.Output> loadComponent() async {
- load_kernel.Output output = await runLoadKernel();
- if (output == null || compilationFailed) return null;
-
+ Future<ClosedWorldAndIndices> produceClosedWorld(
+ load_kernel.Output output, List<ModuleData> moduleData) async {
ir.Component component = output.component;
- List<Uri> libraries = output.libraries;
- frontendStrategy.registerLoadedLibraries(component, libraries);
- List<ModuleData> data;
- if (options.hasModularAnalysisInputs) {
- data = await serializationTask.deserializeModuleData(component);
- }
- frontendStrategy.registerModuleData(data);
-
- // After we've deserialized modular data, we trim the component of any
- // unnecessary dependencies.
- // Note: It is critical we wait to trim the dill until after we've
- // deserialized modular data because some of this data may reference
- // 'trimmed' elements.
- dumpUnusedLibrariesAndTrimComponent(component, libraries);
- return output;
- }
-
- Future<ClosedWorldAndIndices> produceClosedWorld() async {
ClosedWorldAndIndices closedWorldAndIndices;
if (options.readClosedWorldUri == null) {
- load_kernel.Output loadKernelOutput = await loadComponent();
- if (loadKernelOutput != null) {
- Uri rootLibraryUri = loadKernelOutput.rootLibraryUri;
- Iterable<Uri> libraries = loadKernelOutput.libraries;
- _userCodeLocations.add(CodeLocation(rootLibraryUri));
- JsClosedWorld closedWorld =
- computeClosedWorld(rootLibraryUri, libraries);
- closedWorldAndIndices = ClosedWorldAndIndices(closedWorld, null);
- if (options.writeClosedWorldUri != null) {
- serializationTask.serializeComponent(
- closedWorld.elementMap.programEnv.mainComponent);
- serializationTask.serializeClosedWorld(closedWorld);
- }
+ Uri rootLibraryUri = output.rootLibraryUri;
+ Iterable<Uri> libraries = output.libraries;
+ _userCodeLocations.add(CodeLocation(rootLibraryUri));
+ JsClosedWorld closedWorld =
+ computeClosedWorld(component, moduleData, rootLibraryUri, libraries);
+ closedWorldAndIndices = ClosedWorldAndIndices(closedWorld, null);
+ if (options.writeClosedWorldUri != null) {
+ serializationTask.serializeComponent(
+ closedWorld.elementMap.programEnv.mainComponent);
+ serializationTask.serializeClosedWorld(closedWorld);
}
} else {
- ir.Component component =
- await serializationTask.deserializeComponentAndUpdateOptions();
closedWorldAndIndices = await serializationTask.deserializeClosedWorld(
environment, abstractValueStrategy, component);
}
@@ -625,29 +626,40 @@
bool get shouldStopAfterCodegen => options.writeCodegenUri != null;
void runSequentialPhases() async {
- await selfTask.measureSubtask("compileFromKernel", () async {
- // Load kernel and compute closed world.
- ClosedWorldAndIndices closedWorldAndIndices = await produceClosedWorld();
- if (shouldStopAfterClosedWorld(closedWorldAndIndices)) return;
+ // Load kernel.
+ load_kernel.Output output = await produceKernel();
+ if (shouldStopAfterLoadKernel(output)) return;
- // Run global analysis.
- GlobalTypeInferenceResults globalTypeInferenceResults =
- await produceGlobalTypeInferenceResults(closedWorldAndIndices);
- if (shouldStopAfterGlobalTypeInference) return;
+ // Run modular analysis. This may be null if modular analysis was not
+ // requested for this pipeline.
+ List<ModuleData> moduleData;
+ if (options.modularMode || options.hasModularAnalysisInputs) {
+ moduleData = await produceModuleData(output);
+ }
+ if (shouldStopAfterModularAnalysis) return;
- // Run codegen.
- CodegenResults codegenResults = await produceCodegenResults(
- globalTypeInferenceResults, closedWorldAndIndices.indices);
- if (shouldStopAfterCodegen) return;
+ // Compute closed world.
+ ClosedWorldAndIndices closedWorldAndIndices =
+ await produceClosedWorld(output, moduleData);
+ if (shouldStopAfterClosedWorld(closedWorldAndIndices)) return;
- // Link.
- int programSize = runCodegenEnqueuer(codegenResults);
+ // Run global analysis.
+ GlobalTypeInferenceResults globalTypeInferenceResults =
+ await produceGlobalTypeInferenceResults(closedWorldAndIndices);
+ if (shouldStopAfterGlobalTypeInference) return;
- // Dump Info.
- if (options.dumpInfo) {
- runDumpInfo(codegenResults, programSize);
- }
- });
+ // Run codegen.
+ CodegenResults codegenResults = await produceCodegenResults(
+ globalTypeInferenceResults, closedWorldAndIndices.indices);
+ if (shouldStopAfterCodegen) return;
+
+ // Link.
+ int programSize = runCodegenEnqueuer(codegenResults);
+
+ // Dump Info.
+ if (options.dumpInfo) {
+ runDumpInfo(codegenResults, programSize);
+ }
}
void runDumpInfo(CodegenResults codegenResults, int programSize) {
diff --git a/pkg/dart2wasm/bin/run_wasm.js b/pkg/dart2wasm/bin/run_wasm.js
index b5034ea..593f159 100644
--- a/pkg/dart2wasm/bin/run_wasm.js
+++ b/pkg/dart2wasm/bin/run_wasm.js
@@ -42,6 +42,39 @@
}
}
+// Converts a JS array to a Dart List, and also recursively converts the items
+// in the array.
+function arrayToDartList(array, allocator, adder) {
+ var length = array.length;
+ var dartList = dartInstance.exports.$listAllocate();
+ for (var i = 0; i < length; i++) {
+ dartInstance.exports.$listAdd(dartList, array[i]);
+ }
+ return dartList;
+}
+
+// Converts a Dart List to a JS array. Any Dart objects will be converted, but
+// this will be cheap for JSValues.
+function arrayFromDartList(list, reader) {
+ var length = dartInstance.exports.$listLength(list);
+ var array = new Array(length);
+ for (var i = 0; i < length; i++) {
+ array[i] = dartInstance.exports.$listRead(list, i);
+ }
+ return array;
+}
+
+// Recursively converts a JS object into a Dart object.
+function dartify(object) {
+ if (typeof object === "string") {
+ return stringToDartString(object);
+ } else if (object instanceof Array) {
+ return arrayToDartList(object);
+ } else {
+ return object;
+ }
+}
+
// Imports for printing and event loop
var dart2wasm = {
printToConsole: function(string) {
@@ -64,6 +97,41 @@
// stack trace.
let userStackString = stackString.split('\n').slice(3).join('\n');
return stringToDartString(userStackString);
+ },
+ arrayFromDartList: arrayFromDartList,
+ arrayToDartList: arrayToDartList,
+ stringFromDartString: stringFromDartString,
+ stringToDartString: stringToDartString,
+ dartify: dartify,
+ newObject: function() {
+ return {};
+ },
+ globalThis: function() {
+ return globalThis;
+ },
+ getProperty: function(object, name) {
+ return object[name];
+ },
+ hasProperty: function(object, name) {
+ return name in object;
+ },
+ setProperty: function(object, name, value) {
+ return object[name] = value;
+ },
+ callMethodVarArgs: function(object, name, args) {
+ return object[name].apply(object, args);
+ },
+ callConstructorVarArgs: function(object, name, args) {
+ // Gets a constructor property at object[name], and apply bind to the
+ // constructor. We pass `null` as the first argument to `bind.apply`
+ // because this is `bind`'s unused context argument(`new` will
+ // explicitly create a new context).
+ var constructor = object[name];
+ var factoryFunction = constructor.bind.apply(constructor, [null, ...args]);
+ return new factoryFunction();
+ },
+ eval: function(string) {
+ eval(string);
}
};
diff --git a/pkg/dart2wasm/lib/code_generator.dart b/pkg/dart2wasm/lib/code_generator.dart
index 658a618..6631460 100644
--- a/pkg/dart2wasm/lib/code_generator.dart
+++ b/pkg/dart2wasm/lib/code_generator.dart
@@ -1181,7 +1181,7 @@
@override
w.ValueType visitEqualsNull(EqualsNull node, w.ValueType expectedType) {
- wrap(node.expression, translator.topInfo.nullableType);
+ wrap(node.expression, const w.RefType.any());
b.ref_is_null();
return w.NumType.i32;
}
diff --git a/pkg/dart2wasm/lib/target.dart b/pkg/dart2wasm/lib/target.dart
index 15e6651..cb5310be 100644
--- a/pkg/dart2wasm/lib/target.dart
+++ b/pkg/dart2wasm/lib/target.dart
@@ -46,6 +46,7 @@
'dart:_internal',
'dart:typed_data',
'dart:nativewrappers',
+ 'dart:js_util_wasm',
];
@override
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
index 4bb0a08..2f58bb1 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
@@ -479,9 +479,6 @@
constantEvaluator.withNewEnvironment(() {
transformAnnotations(node.annotations, node);
transformTypeParameterList(node.typeParameters, node);
- transformTypeParameterList(node.typeParametersOfFunctionType, node);
- transformVariableDeclarationList(node.positionalParameters, node);
- transformVariableDeclarationList(node.namedParameters, node);
});
return node;
}
diff --git a/pkg/front_end/lib/src/fasta/source/diet_listener.dart b/pkg/front_end/lib/src/fasta/source/diet_listener.dart
index 86e5832..5bbfd4a 100644
--- a/pkg/front_end/lib/src/fasta/source/diet_listener.dart
+++ b/pkg/front_end/lib/src/fasta/source/diet_listener.dart
@@ -299,24 +299,7 @@
// hood, so we only need the offset of the first annotation.
Token metadataToken = tokenForOffset(
typedefKeyword, endToken, metadata[0].charOffset)!;
- List<Expression> annotations =
- parseMetadata(typedefBuilder, metadataToken, null)!;
- if (formal.isPositional) {
- VariableDeclaration parameter =
- typedefBuilder.typedef.positionalParameters[i];
- for (Expression annotation in annotations) {
- parameter.addAnnotation(annotation);
- }
- } else {
- for (VariableDeclaration named
- in typedefBuilder.typedef.namedParameters) {
- if (named.name == formal.name) {
- for (Expression annotation in annotations) {
- named.addAnnotation(annotation);
- }
- }
- }
- }
+ parseMetadata(typedefBuilder, metadataToken, null)!;
}
}
}
diff --git a/pkg/front_end/lib/src/fasta/source/source_type_alias_builder.dart b/pkg/front_end/lib/src/fasta/source/source_type_alias_builder.dart
index 638253e..f6fd8b7 100644
--- a/pkg/front_end/lib/src/fasta/source/source_type_alias_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_type_alias_builder.dart
@@ -7,37 +7,27 @@
import 'package:front_end/src/fasta/kernel/expression_generator_helper.dart';
import 'package:kernel/ast.dart';
import 'package:kernel/class_hierarchy.dart';
-
-import 'package:kernel/type_algebra.dart'
- show FreshTypeParameters, getFreshTypeParameters;
-
import 'package:kernel/type_environment.dart';
-import '../fasta_codes.dart'
- show noLength, templateCyclicTypedef, templateTypeArgumentMismatch;
-
-import '../problems.dart' show unhandled;
-import '../scope.dart';
-
import '../builder/builder.dart';
import '../builder/class_builder.dart';
import '../builder/fixed_type_builder.dart';
-import '../builder/formal_parameter_builder.dart';
import '../builder/function_type_builder.dart';
import '../builder/library_builder.dart';
import '../builder/member_builder.dart';
import '../builder/metadata_builder.dart';
import '../builder/named_type_builder.dart';
-import '../builder/type_builder.dart';
import '../builder/type_alias_builder.dart';
+import '../builder/type_builder.dart';
import '../builder/type_declaration_builder.dart';
import '../builder/type_variable_builder.dart';
-
+import '../fasta_codes.dart'
+ show noLength, templateCyclicTypedef, templateTypeArgumentMismatch;
import '../kernel/constructor_tearoff_lowering.dart';
import '../kernel/kernel_helper.dart';
-
+import '../problems.dart' show unhandled;
+import '../scope.dart';
import '../util/helpers.dart';
-
import 'source_library_builder.dart' show SourceLibraryBuilder;
class SourceTypeAliasBuilder extends TypeAliasBuilderImpl {
@@ -101,33 +91,9 @@
typedef.type ??= buildThisType();
TypeBuilder? type = this.type;
- if (type is FunctionTypeBuilder) {
- List<TypeParameter> typeParameters = new List<TypeParameter>.generate(
- type.typeVariables?.length ?? 0,
- (int i) => type.typeVariables![i].parameter,
- growable: false);
- FreshTypeParameters freshTypeParameters =
- getFreshTypeParameters(typeParameters);
- for (int i = 0; i < freshTypeParameters.freshTypeParameters.length; i++) {
- TypeParameter typeParameter =
- freshTypeParameters.freshTypeParameters[i];
- typedef.typeParametersOfFunctionType
- .add(typeParameter..parent = typedef);
- }
-
- if (type.formals != null) {
- for (FormalParameterBuilder formal in type.formals!) {
- VariableDeclaration parameter = formal.build(libraryBuilder, 0);
- parameter.type = freshTypeParameters.substitute(parameter.type);
- if (formal.isNamed) {
- typedef.namedParameters.add(parameter);
- } else {
- typedef.positionalParameters.add(parameter);
- }
- parameter.parent = typedef;
- }
- }
- } else if (type is NamedTypeBuilder || type is FixedTypeBuilder) {
+ if (type is FunctionTypeBuilder ||
+ type is NamedTypeBuilder ||
+ type is FixedTypeBuilder) {
// No error, but also no additional setup work.
// ignore: unnecessary_null_comparison
} else if (type != null) {
diff --git a/pkg/front_end/test/fasta/expression_suite.dart b/pkg/front_end/test/fasta/expression_suite.dart
index e8871b6..2e0a4a9 100644
--- a/pkg/front_end/test/fasta/expression_suite.dart
+++ b/pkg/front_end/test/fasta/expression_suite.dart
@@ -73,6 +73,7 @@
class Context extends ChainContext {
final CompilerContext compilerContext;
+ final CompilerContext compilerContextNoNNBD;
final List<DiagnosticMessage> errors;
@override
@@ -82,7 +83,8 @@
final Set<Uri> fuzzedLibraries = {};
int fuzzCompiles = 0;
- Context(this.compilerContext, this.errors, bool updateExpectations, this.fuzz)
+ Context(this.compilerContext, this.compilerContextNoNNBD, this.errors,
+ bool updateExpectations, this.fuzz)
: steps = <Step>[
const ReadTest(),
const CompileExpression(),
@@ -362,8 +364,12 @@
// Compile [test.expression], update [test.errors] with results.
// As a side effect - verify that generated procedure can be serialized.
- Future<void> compileExpression(TestCase test, IncrementalCompiler compiler,
- IncrementalCompilerResult compilerResult, Context context) async {
+ Future<void> compileExpression(
+ TestCase test,
+ IncrementalCompiler compiler,
+ IncrementalCompiler? compilerNoNNBD,
+ IncrementalCompilerResult compilerResult,
+ Context context) async {
Map<String, DartType>? definitions = createDefinitionsWithTypes(
compilerResult.classHierarchy?.knownLibraries,
test.definitionTypes,
@@ -408,29 +414,36 @@
}
if (context.fuzz) {
- await fuzz(compiler, compilerResult, context);
+ await fuzz(compiler, compilerNoNNBD!, compilerResult, context);
}
}
- Future<void> fuzz(IncrementalCompiler compiler,
- IncrementalCompilerResult compilerResult, Context context) async {
+ Future<void> fuzz(
+ IncrementalCompiler compiler,
+ IncrementalCompiler compilerNoNNBD,
+ IncrementalCompilerResult compilerResult,
+ Context context) async {
for (Library lib in compilerResult.classHierarchy!.knownLibraries) {
if (!context.fuzzedLibraries.add(lib.importUri)) continue;
for (Member m in lib.members) {
- await fuzzMember(m, compiler, lib.importUri, context);
+ await fuzzMember(m, compiler, compilerNoNNBD, lib.importUri, context);
}
for (Class c in lib.classes) {
for (Member m in c.members) {
- await fuzzMember(m, compiler, lib.importUri, context);
+ await fuzzMember(m, compiler, compilerNoNNBD, lib.importUri, context);
}
}
}
}
- Future<void> fuzzMember(Member m, IncrementalCompiler compiler,
- Uri libraryUri, Context context) async {
+ Future<void> fuzzMember(
+ Member m,
+ IncrementalCompiler compiler,
+ IncrementalCompiler compilerNoNNBD,
+ Uri libraryUri,
+ Context context) async {
String expression = m.name.text;
if (m is Field || (m is Procedure && m.isGetter)) {
// fields and getters are fine as-is
@@ -447,8 +460,7 @@
expression = "${parent.name}()";
}
} else {
- print("Ignoring $m (${m.runtimeType})");
- return;
+ throw "Didn't know ${m.runtimeType}";
}
String? className;
@@ -457,23 +469,36 @@
className = parent.name;
}
- await fuzzTryCompile(compiler, "$expression", libraryUri, className,
- !m.isInstanceMember, context);
- if (className != null && !m.isInstanceMember) {
- await fuzzTryCompile(compiler, "$className.$expression", libraryUri, null,
- !m.isInstanceMember, context);
- }
- await fuzzTryCompile(compiler, "$expression.toString()", libraryUri,
+ await fuzzTryCompile(compiler, compilerNoNNBD, "$expression", libraryUri,
className, !m.isInstanceMember, context);
if (className != null && !m.isInstanceMember) {
- await fuzzTryCompile(compiler, "$className.$expression.toString()",
+ await fuzzTryCompile(compiler, compilerNoNNBD, "$className.$expression",
libraryUri, null, !m.isInstanceMember, context);
}
- await fuzzTryCompile(compiler, "$expression.toString() == '42'", libraryUri,
- className, !m.isInstanceMember, context);
+ await fuzzTryCompile(compiler, compilerNoNNBD, "$expression.toString()",
+ libraryUri, className, !m.isInstanceMember, context);
if (className != null && !m.isInstanceMember) {
await fuzzTryCompile(
compiler,
+ compilerNoNNBD,
+ "$className.$expression.toString()",
+ libraryUri,
+ null,
+ !m.isInstanceMember,
+ context);
+ }
+ await fuzzTryCompile(
+ compiler,
+ compilerNoNNBD,
+ "$expression.toString() == '42'",
+ libraryUri,
+ className,
+ !m.isInstanceMember,
+ context);
+ if (className != null && !m.isInstanceMember) {
+ await fuzzTryCompile(
+ compiler,
+ compilerNoNNBD,
"$className.$expression.toString() == '42'",
libraryUri,
null,
@@ -482,6 +507,7 @@
}
await fuzzTryCompile(
compiler,
+ compilerNoNNBD,
"() { var x = $expression.toString(); x == '42'; }()",
libraryUri,
className,
@@ -490,6 +516,7 @@
if (className != null && !m.isInstanceMember) {
await fuzzTryCompile(
compiler,
+ compilerNoNNBD,
"() { var x = $className.$expression.toString(); x == '42'; }()",
libraryUri,
null,
@@ -498,25 +525,50 @@
}
}
- Future<void> fuzzTryCompile(IncrementalCompiler compiler, String expression,
- Uri libraryUri, String? className, bool isStatic, Context context) async {
+ Future<void> fuzzTryCompile(
+ IncrementalCompiler compiler,
+ IncrementalCompiler compilerNoNNBD,
+ String expression,
+ Uri libraryUri,
+ String? className,
+ bool isStatic,
+ Context context) async {
context.fuzzCompiles++;
print("Fuzz compile #${context.fuzzCompiles} "
"('$expression' in $libraryUri $className)");
- Procedure? compiledProcedure = await compiler.compileExpression(
- expression,
- {},
- [],
- "debugExpr",
- libraryUri,
- className: className,
- isStatic: isStatic,
- );
- context.takeErrors();
- if (compiledProcedure != null) {
- // Confirm we can serialize generated procedure.
- List<int> list = serializeProcedure(compiledProcedure);
- assert(list.length > 0);
+ {
+ Procedure? compiledProcedure = await compiler.compileExpression(
+ expression,
+ {},
+ [],
+ "debugExpr",
+ libraryUri,
+ className: className,
+ isStatic: isStatic,
+ );
+ context.takeErrors();
+ if (compiledProcedure != null) {
+ // Confirm we can serialize generated procedure.
+ List<int> list = serializeProcedure(compiledProcedure);
+ assert(list.length > 0);
+ }
+ }
+ {
+ Procedure? compiledProcedure = await compilerNoNNBD.compileExpression(
+ expression,
+ {},
+ [],
+ "debugExpr",
+ libraryUri,
+ className: className,
+ isStatic: isStatic,
+ );
+ context.takeErrors();
+ if (compiledProcedure != null) {
+ // Confirm we can serialize generated procedure.
+ List<int> list = serializeProcedure(compiledProcedure);
+ assert(list.length > 0);
+ }
}
}
@@ -543,11 +595,27 @@
"${errors.map((e) => e.plainTextFormatted.first).toList()}");
}
Uri dillFileUri = toTestUri("${test.description.shortName}.dill");
+ Uri dillFileNoNNBDUri =
+ toTestUri("${test.description.shortName}.no.nnbd.dill");
Uint8List dillData = await serializeComponent(component);
context.fileSystem.entityForUri(dillFileUri).writeAsBytesSync(dillData);
Set<Uri> beforeFuzzedLibraries = context.fuzzedLibraries.toSet();
- await compileExpression(
- test, sourceCompiler, sourceCompilerResult, context);
+ IncrementalCompiler? sourceCompilerNoNNBD;
+ if (context.fuzz) {
+ sourceCompilerNoNNBD =
+ new IncrementalCompiler(context.compilerContextNoNNBD);
+ IncrementalCompilerResult sourceCompilerNoNNBDResult =
+ await sourceCompilerNoNNBD
+ .computeDelta(entryPoints: [test.entryPoint]);
+ Component componentNoNNBD = sourceCompilerNoNNBDResult.component;
+ Uint8List dillDataNoNNBD = await serializeComponent(componentNoNNBD);
+ context.fileSystem
+ .entityForUri(dillFileNoNNBDUri)
+ .writeAsBytesSync(dillDataNoNNBD);
+ context.takeErrors();
+ }
+ await compileExpression(test, sourceCompiler, sourceCompilerNoNNBD,
+ sourceCompilerResult, context);
IncrementalCompiler dillCompiler =
new IncrementalCompiler(context.compilerContext, dillFileUri);
@@ -560,9 +628,23 @@
// Since it compiled successfully from source, the bootstrap-from-Dill
// should also succeed without errors.
assert(errors.isEmpty);
+
+ IncrementalCompiler? dillCompilerNoNNBD;
+ if (context.fuzz) {
+ dillCompilerNoNNBD = new IncrementalCompiler(
+ context.compilerContextNoNNBD, dillFileNoNNBDUri);
+ IncrementalCompilerResult dillCompilerNoNNBDResult =
+ await dillCompilerNoNNBD
+ .computeDelta(entryPoints: [test.entryPoint]);
+ Component componentNoNNBD = dillCompilerNoNNBDResult.component;
+ componentNoNNBD.computeCanonicalNames();
+ context.takeErrors();
+ }
+
context.fuzzedLibraries.clear();
context.fuzzedLibraries.addAll(beforeFuzzedLibraries);
- await compileExpression(test, dillCompiler, dillCompilerResult, context);
+ await compileExpression(
+ test, dillCompiler, dillCompilerNoNNBD, dillCompilerResult, context);
}
return new Result.pass(tests);
}
@@ -614,17 +696,37 @@
final ProcessedOptions options =
new ProcessedOptions(options: optionBuilder, inputs: [entryPoint]);
+ final CompilerOptions optionBuilderNoNNBD = new CompilerOptions()
+ ..target = new VmTarget(new TargetFlags())
+ ..verbose = true
+ ..omitPlatform = true
+ ..fileSystem = fs
+ ..sdkSummary = sdkSummary
+ ..onDiagnostic = (DiagnosticMessage message) {
+ printDiagnosticMessage(message, print);
+ errors.add(message);
+ }
+ ..environmentDefines = const {}
+ ..explicitExperimentalFlags = {ExperimentalFlag.nonNullable: false}
+ ..allowedExperimentalFlagsForTesting = const AllowedExperimentalFlags();
+
+ final ProcessedOptions optionsNoNNBD =
+ new ProcessedOptions(options: optionBuilderNoNNBD, inputs: [entryPoint]);
+
final bool updateExpectations = environment["updateExpectations"] == "true";
final bool fuzz = environment["fuzz"] == "true";
final CompilerContext compilerContext = new CompilerContext(options);
+ final CompilerContext compilerContextNoNNBD =
+ new CompilerContext(optionsNoNNBD);
// Disable colors to ensure that expectation files are the same across
// platforms and independent of stdin/stderr.
colors.enableColors = false;
- return new Context(compilerContext, errors, updateExpectations, fuzz);
+ return new Context(
+ compilerContext, compilerContextNoNNBD, errors, updateExpectations, fuzz);
}
void main([List<String> arguments = const []]) =>
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index 5b21bf7..a85eeaf 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -245,6 +245,7 @@
connectivity
consideration
constness
+constraining
consult
consumers
container
@@ -320,6 +321,7 @@
demangle
demangled
dep
+depended
dependency's
deps
dereferencing
@@ -1024,6 +1026,7 @@
recompiling
recompute
recomputed
+reconciliation
reconstruct
recorder
recoveries
@@ -1038,6 +1041,7 @@
reexports
ref
refactoring
+refined
reflect
reflectee
reflective
@@ -1214,6 +1218,7 @@
stability
stacktrace
stacktraces
+stages
stale
stand
starter
diff --git a/pkg/front_end/testcases/general/annotation_typedef_formals.dart.weak.expect b/pkg/front_end/testcases/general/annotation_typedef_formals.dart.weak.expect
index 44bd339..3f168f4 100644
--- a/pkg/front_end/testcases/general/annotation_typedef_formals.dart.weak.expect
+++ b/pkg/front_end/testcases/general/annotation_typedef_formals.dart.weak.expect
@@ -2,8 +2,8 @@
import self as self;
import "dart:core" as core;
-typedef F = (@#C1 core::int x, core::num y, {@#C2 @#C3 core::String z, core::Object w}) → void;
-typedef G = (@#C1 core::int a, core::num b, [@#C2 @#C3 core::String c, core::Object d]) → void;
+typedef F = (core::int, core::num, {w: core::Object, z: core::String}) → void;
+typedef G = (core::int, core::num, [core::String, core::Object]) → void;
static const field core::int foo = #C1;
static const field core::int bar = #C2;
static const field core::int baz = #C3;
diff --git a/pkg/front_end/testcases/general/annotation_typedef_formals.dart.weak.modular.expect b/pkg/front_end/testcases/general/annotation_typedef_formals.dart.weak.modular.expect
index 44bd339..3f168f4 100644
--- a/pkg/front_end/testcases/general/annotation_typedef_formals.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/annotation_typedef_formals.dart.weak.modular.expect
@@ -2,8 +2,8 @@
import self as self;
import "dart:core" as core;
-typedef F = (@#C1 core::int x, core::num y, {@#C2 @#C3 core::String z, core::Object w}) → void;
-typedef G = (@#C1 core::int a, core::num b, [@#C2 @#C3 core::String c, core::Object d]) → void;
+typedef F = (core::int, core::num, {w: core::Object, z: core::String}) → void;
+typedef G = (core::int, core::num, [core::String, core::Object]) → void;
static const field core::int foo = #C1;
static const field core::int bar = #C2;
static const field core::int baz = #C3;
diff --git a/pkg/front_end/testcases/general/annotation_typedef_formals.dart.weak.transformed.expect b/pkg/front_end/testcases/general/annotation_typedef_formals.dart.weak.transformed.expect
index 44bd339..3f168f4 100644
--- a/pkg/front_end/testcases/general/annotation_typedef_formals.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/annotation_typedef_formals.dart.weak.transformed.expect
@@ -2,8 +2,8 @@
import self as self;
import "dart:core" as core;
-typedef F = (@#C1 core::int x, core::num y, {@#C2 @#C3 core::String z, core::Object w}) → void;
-typedef G = (@#C1 core::int a, core::num b, [@#C2 @#C3 core::String c, core::Object d]) → void;
+typedef F = (core::int, core::num, {w: core::Object, z: core::String}) → void;
+typedef G = (core::int, core::num, [core::String, core::Object]) → void;
static const field core::int foo = #C1;
static const field core::int bar = #C2;
static const field core::int baz = #C3;
diff --git a/pkg/front_end/testcases/general/annotation_typedef_formals_resolution.dart.weak.expect b/pkg/front_end/testcases/general/annotation_typedef_formals_resolution.dart.weak.expect
index 95d7ed5..707fc20 100644
--- a/pkg/front_end/testcases/general/annotation_typedef_formals_resolution.dart.weak.expect
+++ b/pkg/front_end/testcases/general/annotation_typedef_formals_resolution.dart.weak.expect
@@ -2,7 +2,7 @@
import self as self;
import "dart:core" as core;
-typedef F = (@#C1 core::int app) → core::int;
+typedef F = (core::int) → core::int;
static const field core::int app = #C1;
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/annotation_typedef_formals_resolution.dart.weak.modular.expect b/pkg/front_end/testcases/general/annotation_typedef_formals_resolution.dart.weak.modular.expect
index 95d7ed5..707fc20 100644
--- a/pkg/front_end/testcases/general/annotation_typedef_formals_resolution.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/annotation_typedef_formals_resolution.dart.weak.modular.expect
@@ -2,7 +2,7 @@
import self as self;
import "dart:core" as core;
-typedef F = (@#C1 core::int app) → core::int;
+typedef F = (core::int) → core::int;
static const field core::int app = #C1;
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/annotation_typedef_formals_resolution.dart.weak.transformed.expect b/pkg/front_end/testcases/general/annotation_typedef_formals_resolution.dart.weak.transformed.expect
index 95d7ed5..707fc20 100644
--- a/pkg/front_end/testcases/general/annotation_typedef_formals_resolution.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/annotation_typedef_formals_resolution.dart.weak.transformed.expect
@@ -2,7 +2,7 @@
import self as self;
import "dart:core" as core;
-typedef F = (@#C1 core::int app) → core::int;
+typedef F = (core::int) → core::int;
static const field core::int app = #C1;
static method main() → dynamic {}
diff --git a/pkg/front_end/testcases/general/annotation_variable_declaration.dart.weak.expect b/pkg/front_end/testcases/general/annotation_variable_declaration.dart.weak.expect
index d111b25..8329d57 100644
--- a/pkg/front_end/testcases/general/annotation_variable_declaration.dart.weak.expect
+++ b/pkg/front_end/testcases/general/annotation_variable_declaration.dart.weak.expect
@@ -2,7 +2,7 @@
import self as self;
import "dart:core" as core;
-typedef hest_t = ({@#C1 dynamic named}) → dynamic;
+typedef hest_t = ({named: dynamic}) → dynamic;
class Bar extends core::Object /*hasConstConstructor*/ {
const constructor •() → self::Bar
: super core::Object::•()
diff --git a/pkg/front_end/testcases/general/annotation_variable_declaration.dart.weak.modular.expect b/pkg/front_end/testcases/general/annotation_variable_declaration.dart.weak.modular.expect
index d111b25..8329d57 100644
--- a/pkg/front_end/testcases/general/annotation_variable_declaration.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/annotation_variable_declaration.dart.weak.modular.expect
@@ -2,7 +2,7 @@
import self as self;
import "dart:core" as core;
-typedef hest_t = ({@#C1 dynamic named}) → dynamic;
+typedef hest_t = ({named: dynamic}) → dynamic;
class Bar extends core::Object /*hasConstConstructor*/ {
const constructor •() → self::Bar
: super core::Object::•()
diff --git a/pkg/front_end/testcases/general/annotation_variable_declaration.dart.weak.transformed.expect b/pkg/front_end/testcases/general/annotation_variable_declaration.dart.weak.transformed.expect
index d111b25..8329d57 100644
--- a/pkg/front_end/testcases/general/annotation_variable_declaration.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/annotation_variable_declaration.dart.weak.transformed.expect
@@ -2,7 +2,7 @@
import self as self;
import "dart:core" as core;
-typedef hest_t = ({@#C1 dynamic named}) → dynamic;
+typedef hest_t = ({named: dynamic}) → dynamic;
class Bar extends core::Object /*hasConstConstructor*/ {
const constructor •() → self::Bar
: super core::Object::•()
diff --git a/pkg/front_end/testcases/general/redirecting_factory_invocation_metadata.dart.weak.expect b/pkg/front_end/testcases/general/redirecting_factory_invocation_metadata.dart.weak.expect
index 95a7fb9..41d3f4f 100644
--- a/pkg/front_end/testcases/general/redirecting_factory_invocation_metadata.dart.weak.expect
+++ b/pkg/front_end/testcases/general/redirecting_factory_invocation_metadata.dart.weak.expect
@@ -11,13 +11,13 @@
@#C1
part redirecting_factory_invocation_metadata_lib.dart;
@#C1
-typedef Typedef1<@#C1 unrelated T extends core::Object? = dynamic> = <T extends core::Object? = dynamic>(@#C1 self::Class<dynamic> #t1, [@#C1 self::Class<dynamic> #t2]) → dynamic;
+typedef Typedef1<@#C1 unrelated T extends core::Object? = dynamic> = <T extends core::Object? = dynamic>(self::Class<dynamic>, [self::Class<dynamic>]) → dynamic;
@#C1
-typedef Typedef2<@#C1 unrelated T extends core::Object? = dynamic> = <T extends core::Object? = dynamic>(@#C1 self::Class<dynamic> #t3, {@#C1 self::Class<dynamic> o2}) → dynamic;
+typedef Typedef2<@#C1 unrelated T extends core::Object? = dynamic> = <T extends core::Object? = dynamic>(self::Class<dynamic>, {o2: self::Class<dynamic>}) → dynamic;
@#C1
-typedef Typedef3<@#C1 unrelated T extends core::Object? = dynamic> = (@#C1 dynamic o1, [@#C1 dynamic o2]) → void;
+typedef Typedef3<@#C1 unrelated T extends core::Object? = dynamic> = (dynamic, [dynamic]) → void;
@#C1
-typedef Typedef4<@#C1 unrelated T extends core::Object? = dynamic> = (@#C1 dynamic o1, {@#C1 dynamic o2}) → void;
+typedef Typedef4<@#C1 unrelated T extends core::Object? = dynamic> = (dynamic, {o2: dynamic}) → void;
@#C1
class Const extends core::Object /*hasConstConstructor*/ {
static final field dynamic _redirecting# = <dynamic>[#C2]/*isLegacy*/;
diff --git a/pkg/front_end/testcases/general/redirecting_factory_invocation_metadata.dart.weak.modular.expect b/pkg/front_end/testcases/general/redirecting_factory_invocation_metadata.dart.weak.modular.expect
index 95a7fb9..41d3f4f 100644
--- a/pkg/front_end/testcases/general/redirecting_factory_invocation_metadata.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/general/redirecting_factory_invocation_metadata.dart.weak.modular.expect
@@ -11,13 +11,13 @@
@#C1
part redirecting_factory_invocation_metadata_lib.dart;
@#C1
-typedef Typedef1<@#C1 unrelated T extends core::Object? = dynamic> = <T extends core::Object? = dynamic>(@#C1 self::Class<dynamic> #t1, [@#C1 self::Class<dynamic> #t2]) → dynamic;
+typedef Typedef1<@#C1 unrelated T extends core::Object? = dynamic> = <T extends core::Object? = dynamic>(self::Class<dynamic>, [self::Class<dynamic>]) → dynamic;
@#C1
-typedef Typedef2<@#C1 unrelated T extends core::Object? = dynamic> = <T extends core::Object? = dynamic>(@#C1 self::Class<dynamic> #t3, {@#C1 self::Class<dynamic> o2}) → dynamic;
+typedef Typedef2<@#C1 unrelated T extends core::Object? = dynamic> = <T extends core::Object? = dynamic>(self::Class<dynamic>, {o2: self::Class<dynamic>}) → dynamic;
@#C1
-typedef Typedef3<@#C1 unrelated T extends core::Object? = dynamic> = (@#C1 dynamic o1, [@#C1 dynamic o2]) → void;
+typedef Typedef3<@#C1 unrelated T extends core::Object? = dynamic> = (dynamic, [dynamic]) → void;
@#C1
-typedef Typedef4<@#C1 unrelated T extends core::Object? = dynamic> = (@#C1 dynamic o1, {@#C1 dynamic o2}) → void;
+typedef Typedef4<@#C1 unrelated T extends core::Object? = dynamic> = (dynamic, {o2: dynamic}) → void;
@#C1
class Const extends core::Object /*hasConstConstructor*/ {
static final field dynamic _redirecting# = <dynamic>[#C2]/*isLegacy*/;
diff --git a/pkg/front_end/testcases/general/redirecting_factory_invocation_metadata.dart.weak.transformed.expect b/pkg/front_end/testcases/general/redirecting_factory_invocation_metadata.dart.weak.transformed.expect
index 95a7fb9..41d3f4f 100644
--- a/pkg/front_end/testcases/general/redirecting_factory_invocation_metadata.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/redirecting_factory_invocation_metadata.dart.weak.transformed.expect
@@ -11,13 +11,13 @@
@#C1
part redirecting_factory_invocation_metadata_lib.dart;
@#C1
-typedef Typedef1<@#C1 unrelated T extends core::Object? = dynamic> = <T extends core::Object? = dynamic>(@#C1 self::Class<dynamic> #t1, [@#C1 self::Class<dynamic> #t2]) → dynamic;
+typedef Typedef1<@#C1 unrelated T extends core::Object? = dynamic> = <T extends core::Object? = dynamic>(self::Class<dynamic>, [self::Class<dynamic>]) → dynamic;
@#C1
-typedef Typedef2<@#C1 unrelated T extends core::Object? = dynamic> = <T extends core::Object? = dynamic>(@#C1 self::Class<dynamic> #t3, {@#C1 self::Class<dynamic> o2}) → dynamic;
+typedef Typedef2<@#C1 unrelated T extends core::Object? = dynamic> = <T extends core::Object? = dynamic>(self::Class<dynamic>, {o2: self::Class<dynamic>}) → dynamic;
@#C1
-typedef Typedef3<@#C1 unrelated T extends core::Object? = dynamic> = (@#C1 dynamic o1, [@#C1 dynamic o2]) → void;
+typedef Typedef3<@#C1 unrelated T extends core::Object? = dynamic> = (dynamic, [dynamic]) → void;
@#C1
-typedef Typedef4<@#C1 unrelated T extends core::Object? = dynamic> = (@#C1 dynamic o1, {@#C1 dynamic o2}) → void;
+typedef Typedef4<@#C1 unrelated T extends core::Object? = dynamic> = (dynamic, {o2: dynamic}) → void;
@#C1
class Const extends core::Object /*hasConstConstructor*/ {
static final field dynamic _redirecting# = <dynamic>[#C2]/*isLegacy*/;
diff --git a/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.expect b/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.expect
index 50a886c..3444c42 100644
--- a/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.expect
+++ b/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.expect
@@ -7,7 +7,6 @@
// ^
//
import self as self;
-import "dart:core" as core;
typedef Handle = invalid-type;
static method main() → dynamic {
diff --git a/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.modular.expect b/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.modular.expect
index 50a886c..3444c42 100644
--- a/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.modular.expect
+++ b/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.modular.expect
@@ -7,7 +7,6 @@
// ^
//
import self as self;
-import "dart:core" as core;
typedef Handle = invalid-type;
static method main() → dynamic {
diff --git a/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.outline.expect b/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.outline.expect
index 74c6c6a..dc3f69b 100644
--- a/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.outline.expect
@@ -7,7 +7,6 @@
// ^
//
import self as self;
-import "dart:core" as core;
typedef Handle = invalid-type;
static method main() → dynamic
diff --git a/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.transformed.expect b/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.transformed.expect
index 50a886c..3444c42 100644
--- a/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/rasta/malformed_function_type.dart.weak.transformed.expect
@@ -7,7 +7,6 @@
// ^
//
import self as self;
-import "dart:core" as core;
typedef Handle = invalid-type;
static method main() → dynamic {
diff --git a/pkg/front_end/tool/ast_model.dart b/pkg/front_end/tool/ast_model.dart
index e06996a..9979dcb 100644
--- a/pkg/front_end/tool/ast_model.dart
+++ b/pkg/front_end/tool/ast_model.dart
@@ -128,9 +128,6 @@
},
'Typedef': {
'typeParameters': FieldRule(isDeclaration: true),
- 'typeParametersOfFunctionType': FieldRule(isDeclaration: false),
- 'positionalParameters': FieldRule(isDeclaration: false),
- 'namedParameters': FieldRule(isDeclaration: false),
},
'TypedefTearOff': {
'typeParameters': FieldRule(isDeclaration: true),
diff --git a/pkg/kernel/binary.md b/pkg/kernel/binary.md
index 3df728f..b3f1a41 100644
--- a/pkg/kernel/binary.md
+++ b/pkg/kernel/binary.md
@@ -147,7 +147,7 @@
type ComponentFile {
UInt32 magic = 0x90ABCDEF;
- UInt32 formatVersion = 76;
+ UInt32 formatVersion = 77;
Byte[10] shortSdkHash;
List<String> problemsAsJson; // Described in problems.md.
Library[] libraries;
@@ -288,9 +288,6 @@
List<Expression> annotations;
List<TypeParameter> typeParameters;
DartType type;
- List<TypeParameter> typeParametersOfFunctionType;
- List<VariableDeclarationPlain> positionalParameters;
- List<VariableDeclarationPlain> namedParameters;
}
type Combinator {
diff --git a/pkg/kernel/lib/ast.dart b/pkg/kernel/lib/ast.dart
index 17ac253..c98194e 100644
--- a/pkg/kernel/lib/ast.dart
+++ b/pkg/kernel/lib/ast.dart
@@ -840,14 +840,6 @@
// TODO(johnniwinther): Make this non-nullable.
DartType? type;
- // The following fields describe parameters of the underlying type when
- // that is a function type. They are needed to keep such attributes as names
- // and annotations. When the underlying type is not a function type, they are
- // empty.
- final List<TypeParameter> typeParametersOfFunctionType;
- final List<VariableDeclaration> positionalParameters;
- final List<VariableDeclaration> namedParameters;
-
Typedef(this.name, this.type,
{Reference? reference,
required this.fileUri,
@@ -858,16 +850,8 @@
// ignore: unnecessary_null_comparison
: assert(fileUri != null),
this.typeParameters = typeParameters ?? <TypeParameter>[],
- this.typeParametersOfFunctionType =
- typeParametersOfFunctionType ?? <TypeParameter>[],
- this.positionalParameters =
- positionalParameters ?? <VariableDeclaration>[],
- this.namedParameters = namedParameters ?? <VariableDeclaration>[],
super(reference) {
setParents(this.typeParameters, this);
- setParents(this.typeParametersOfFunctionType, this);
- setParents(this.positionalParameters, this);
- setParents(this.namedParameters, this);
}
Library get enclosingLibrary => parent as Library;
@@ -883,9 +867,6 @@
visitList(annotations, v);
visitList(typeParameters, v);
type?.accept(v);
- visitList(typeParametersOfFunctionType, v);
- visitList(positionalParameters, v);
- visitList(namedParameters, v);
}
@override
@@ -895,9 +876,6 @@
if (type != null) {
type = v.visitDartType(type!);
}
- v.transformList(typeParametersOfFunctionType, this);
- v.transformList(positionalParameters, this);
- v.transformList(namedParameters, this);
}
@override
@@ -912,9 +890,6 @@
type = newType;
}
}
- v.transformTypeParameterList(typeParametersOfFunctionType, this);
- v.transformVariableDeclarationList(positionalParameters, this);
- v.transformVariableDeclarationList(namedParameters, this);
}
@override
diff --git a/pkg/kernel/lib/binary/ast_from_binary.dart b/pkg/kernel/lib/binary/ast_from_binary.dart
index e067807..8952e40 100644
--- a/pkg/kernel/lib/binary/ast_from_binary.dart
+++ b/pkg/kernel/lib/binary/ast_from_binary.dart
@@ -1340,13 +1340,6 @@
node.annotations = readAnnotationList(node);
readAndPushTypeParameterList(node.typeParameters, node);
DartType type = readDartType();
- readAndPushTypeParameterList(node.typeParametersOfFunctionType, node);
- node.positionalParameters.clear();
- node.positionalParameters.addAll(readAndPushVariableDeclarationList());
- setParents(node.positionalParameters, node);
- node.namedParameters.clear();
- node.namedParameters.addAll(readAndPushVariableDeclarationList());
- setParents(node.namedParameters, node);
typeParameterStack.length = 0;
variableStack.length = 0;
node.fileOffset = fileOffset;
diff --git a/pkg/kernel/lib/binary/ast_to_binary.dart b/pkg/kernel/lib/binary/ast_to_binary.dart
index dc9ece8..c048177 100644
--- a/pkg/kernel/lib/binary/ast_to_binary.dart
+++ b/pkg/kernel/lib/binary/ast_to_binary.dart
@@ -1166,12 +1166,6 @@
writeNodeList(node.typeParameters);
writeNode(node.type!);
- enterScope(typeParameters: node.typeParametersOfFunctionType);
- writeNodeList(node.typeParametersOfFunctionType);
- writeVariableDeclarationList(node.positionalParameters);
- writeVariableDeclarationList(node.namedParameters);
-
- leaveScope(typeParameters: node.typeParametersOfFunctionType);
leaveScope(typeParameters: node.typeParameters, variableScope: true);
leaveScope(memberScope: true);
}
diff --git a/pkg/kernel/lib/binary/tag.dart b/pkg/kernel/lib/binary/tag.dart
index a8a29ff..39dbd8c 100644
--- a/pkg/kernel/lib/binary/tag.dart
+++ b/pkg/kernel/lib/binary/tag.dart
@@ -176,7 +176,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 = 76;
+ static const int BinaryFormatVersion = 77;
}
abstract class ConstantTag {
diff --git a/pkg/kernel/lib/src/equivalence.dart b/pkg/kernel/lib/src/equivalence.dart
index 9e8ae3f..3f11abc 100644
--- a/pkg/kernel/lib/src/equivalence.dart
+++ b/pkg/kernel/lib/src/equivalence.dart
@@ -1436,15 +1436,6 @@
if (!checkTypedef_type(visitor, node, other)) {
result = visitor.resultOnInequivalence;
}
- if (!checkTypedef_typeParametersOfFunctionType(visitor, node, other)) {
- result = visitor.resultOnInequivalence;
- }
- if (!checkTypedef_positionalParameters(visitor, node, other)) {
- result = visitor.resultOnInequivalence;
- }
- if (!checkTypedef_namedParameters(visitor, node, other)) {
- result = visitor.resultOnInequivalence;
- }
if (!checkTypedef_reference(visitor, node, other)) {
result = visitor.resultOnInequivalence;
}
@@ -4634,30 +4625,6 @@
return visitor.checkNodes(node.type, other.type, 'type');
}
- bool checkTypedef_typeParametersOfFunctionType(
- EquivalenceVisitor visitor, Typedef node, Typedef other) {
- return visitor.checkLists(
- node.typeParametersOfFunctionType,
- other.typeParametersOfFunctionType,
- visitor.checkDeclarations,
- 'typeParametersOfFunctionType');
- }
-
- bool checkTypedef_positionalParameters(
- EquivalenceVisitor visitor, Typedef node, Typedef other) {
- return visitor.checkLists(
- node.positionalParameters,
- other.positionalParameters,
- visitor.checkDeclarations,
- 'positionalParameters');
- }
-
- bool checkTypedef_namedParameters(
- EquivalenceVisitor visitor, Typedef node, Typedef other) {
- return visitor.checkLists(node.namedParameters, other.namedParameters,
- visitor.checkDeclarations, 'namedParameters');
- }
-
bool checkTypedef_reference(
EquivalenceVisitor visitor, Typedef node, Typedef other) {
return checkNamedNode_reference(visitor, node, other);
diff --git a/pkg/kernel/lib/text/ast_to_text.dart b/pkg/kernel/lib/text/ast_to_text.dart
index 94b7cf2..46969af 100644
--- a/pkg/kernel/lib/text/ast_to_text.dart
+++ b/pkg/kernel/lib/text/ast_to_text.dart
@@ -853,9 +853,7 @@
}
}
- void writeFunctionType(FunctionType node,
- {List<VariableDeclaration>? typedefPositional,
- List<VariableDeclaration>? typedefNamed}) {
+ void writeFunctionType(FunctionType node) {
if (state == WORD) {
ensureSpace();
}
@@ -863,38 +861,14 @@
writeSymbol('(');
List<DartType> positional = node.positionalParameters;
- bool parametersAnnotated = false;
- if (typedefPositional != null) {
- for (VariableDeclaration formal in typedefPositional) {
- parametersAnnotated =
- parametersAnnotated || formal.annotations.length > 0;
- }
- }
- if (typedefNamed != null) {
- for (VariableDeclaration formal in typedefNamed) {
- parametersAnnotated =
- parametersAnnotated || formal.annotations.length > 0;
- }
- }
-
- if (parametersAnnotated && typedefPositional != null) {
- writeList(typedefPositional.take(node.requiredParameterCount),
- writeVariableDeclaration);
- } else {
- writeList(positional.take(node.requiredParameterCount), writeType);
- }
+ writeList(positional.take(node.requiredParameterCount), writeType);
if (node.requiredParameterCount < positional.length) {
if (node.requiredParameterCount > 0) {
writeComma();
}
writeSymbol('[');
- if (parametersAnnotated && typedefPositional != null) {
- writeList(typedefPositional.skip(node.requiredParameterCount),
- writeVariableDeclaration);
- } else {
- writeList(positional.skip(node.requiredParameterCount), writeType);
- }
+ writeList(positional.skip(node.requiredParameterCount), writeType);
writeSymbol(']');
}
if (node.namedParameters.isNotEmpty) {
@@ -902,11 +876,7 @@
writeComma();
}
writeSymbol('{');
- if (parametersAnnotated && typedefNamed != null) {
- writeList(typedefNamed, writeVariableDeclaration);
- } else {
- writeList(node.namedParameters, visitNamedType);
- }
+ writeList(node.namedParameters, visitNamedType);
writeSymbol('}');
}
writeSymbol(')');
@@ -1483,9 +1453,7 @@
writeSpaced('=');
DartType? type = node.type;
if (type is FunctionType) {
- writeFunctionType(type,
- typedefPositional: node.positionalParameters,
- typedefNamed: node.namedParameters);
+ writeFunctionType(type);
} else {
writeNode(type);
}
diff --git a/pkg/kernel/lib/verifier.dart b/pkg/kernel/lib/verifier.dart
index 858e978..d9f95f6 100644
--- a/pkg/kernel/lib/verifier.dart
+++ b/pkg/kernel/lib/verifier.dart
@@ -282,8 +282,7 @@
assert(state == null);
typedefState[node] = TypedefState.BeingChecked;
Set<TypeParameter> savedTypeParameters = typeParametersInScope;
- typeParametersInScope = node.typeParameters.toSet()
- ..addAll(node.typeParametersOfFunctionType);
+ typeParametersInScope = node.typeParameters.toSet();
TreeNode? savedParent = currentParent;
currentParent = node;
// Visit children without checking the parent pointer on the typedef itself
diff --git a/pkg/vm/lib/transformations/type_flow/transformer.dart b/pkg/vm/lib/transformations/type_flow/transformer.dart
index 02cab5e..209910e 100644
--- a/pkg/vm/lib/transformations/type_flow/transformer.dart
+++ b/pkg/vm/lib/transformations/type_flow/transformer.dart
@@ -875,11 +875,6 @@
if (_usedTypedefs.add(typedef)) {
typedef.annotations = const <Expression>[];
_pass1.transformTypeParameterList(typedef.typeParameters, typedef);
- _pass1.transformTypeParameterList(
- typedef.typeParametersOfFunctionType, typedef);
- _pass1.transformVariableDeclarationList(
- typedef.positionalParameters, typedef);
- _pass1.transformVariableDeclarationList(typedef.namedParameters, typedef);
typedef.type?.accept(typeVisitor);
}
}
diff --git a/runtime/BUILD.gn b/runtime/BUILD.gn
index f30a460..3e6c317 100644
--- a/runtime/BUILD.gn
+++ b/runtime/BUILD.gn
@@ -203,11 +203,13 @@
"-ggdb3",
"-fno-rtti",
"-fno-exceptions",
- "-fno-strict-vtable-pointers", # Handle assignment updates vtable
- # pointers.
]
if (is_clang) {
- cflags += [ "-Wimplicit-fallthrough" ]
+ cflags += [
+ "-Wimplicit-fallthrough",
+ "-fno-strict-vtable-pointers", # Handle assignment updates vtable
+ # pointers.
+ ]
} else {
cflags += [ "-Wno-cast-function-type" ]
}
diff --git a/runtime/tests/vm/dart/flutter_regress_100441_test.dart b/runtime/tests/vm/dart/flutter_regress_100441_test.dart
new file mode 100644
index 0000000..d51cdff
--- /dev/null
+++ b/runtime/tests/vm/dart/flutter_regress_100441_test.dart
@@ -0,0 +1,29 @@
+// 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 'dart:async';
+
+import 'package:expect/expect.dart';
+
+StackTrace? stackTrace;
+
+main() async {
+ final values = [];
+ await for (final value in produce()) {
+ values.add(value);
+ }
+ Expect.equals('foo', values.single);
+ Expect.isNotNull(stackTrace!);
+}
+
+Stream<String> produce() async* {
+ await for (String response in produceInner()) {
+ yield response;
+ }
+}
+
+Stream<String> produceInner() async* {
+ yield 'foo';
+ stackTrace = StackTrace.current;
+}
diff --git a/runtime/tests/vm/dart_2/flutter_regress_100441_test.dart b/runtime/tests/vm/dart_2/flutter_regress_100441_test.dart
new file mode 100644
index 0000000..9250b6b
--- /dev/null
+++ b/runtime/tests/vm/dart_2/flutter_regress_100441_test.dart
@@ -0,0 +1,31 @@
+// 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.
+
+// @dart=2.9
+
+import 'dart:async';
+
+import 'package:expect/expect.dart';
+
+StackTrace stackTrace;
+
+main() async {
+ final values = [];
+ await for (final value in produce()) {
+ values.add(value);
+ }
+ Expect.equals('foo', values.single);
+ Expect.isNotNull(stackTrace);
+}
+
+Stream<String> produce() async* {
+ await for (String response in produceInner()) {
+ yield response;
+ }
+}
+
+Stream<String> produceInner() async* {
+ yield 'foo';
+ stackTrace = StackTrace.current;
+}
diff --git a/runtime/vm/compiler/assembler/assembler_ia32.cc b/runtime/vm/compiler/assembler/assembler_ia32.cc
index a6d5523..de73c0f 100644
--- a/runtime/vm/compiler/assembler/assembler_ia32.cc
+++ b/runtime/vm/compiler/assembler/assembler_ia32.cc
@@ -2180,7 +2180,7 @@
addl(dest, inc_imm);
}
-void Assembler::LoadDoubleConstant(XmmRegister dst, double value) {
+void Assembler::LoadDImmediate(XmmRegister dst, double value) {
// TODO(5410843): Need to have a code constants table.
int64_t constant = bit_cast<int64_t, double>(value);
pushl(Immediate(Utils::High32Bits(constant)));
diff --git a/runtime/vm/compiler/assembler/assembler_ia32.h b/runtime/vm/compiler/assembler/assembler_ia32.h
index f059fb2..8cee67d 100644
--- a/runtime/vm/compiler/assembler/assembler_ia32.h
+++ b/runtime/vm/compiler/assembler/assembler_ia32.h
@@ -713,6 +713,8 @@
}
}
+ void LoadDImmediate(XmmRegister dst, double value);
+
void Drop(intptr_t stack_elements);
void LoadIsolate(Register dst);
@@ -732,7 +734,6 @@
void PushObject(const Object& object);
void CompareObject(Register reg, const Object& object);
- void LoadDoubleConstant(XmmRegister dst, double value);
void LoadCompressed(Register dest, const Address& slot) { movl(dest, slot); }
diff --git a/runtime/vm/compiler/assembler/assembler_ia32_test.cc b/runtime/vm/compiler/assembler/assembler_ia32_test.cc
index 43c4818..e89073d 100644
--- a/runtime/vm/compiler/assembler/assembler_ia32_test.cc
+++ b/runtime/vm/compiler/assembler/assembler_ia32_test.cc
@@ -4558,8 +4558,8 @@
"ret\n");
}
-ASSEMBLER_TEST_GENERATE(TestLoadDoubleConstant, assembler) {
- __ LoadDoubleConstant(XMM3, -12.34);
+ASSEMBLER_TEST_GENERATE(TestLoadDImmediate, assembler) {
+ __ LoadDImmediate(XMM3, -12.34);
__ pushl(EAX);
__ pushl(EAX);
__ movsd(Address(ESP, 0), XMM3);
@@ -4569,9 +4569,9 @@
__ ret();
}
-ASSEMBLER_TEST_RUN(TestLoadDoubleConstant, test) {
- typedef double (*TestLoadDoubleConstantCode)();
- double res = reinterpret_cast<TestLoadDoubleConstantCode>(test->entry())();
+ASSEMBLER_TEST_RUN(TestLoadDImmediate, test) {
+ typedef double (*TestLoadDImmediateCode)();
+ double res = reinterpret_cast<TestLoadDImmediateCode>(test->entry())();
EXPECT_FLOAT_EQ(-12.34, res, 0.0001);
EXPECT_DISASSEMBLY(
"push 0xc028ae14\n"
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.cc b/runtime/vm/compiler/backend/flow_graph_compiler.cc
index 08da16e..3ec06a6 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.cc
@@ -1796,9 +1796,6 @@
result_location = Location::FpuRegisterLocation(
AllocateFreeFpuRegister(blocked_fpu_registers));
break;
- case Location::kRequiresStackSlot:
- UNREACHABLE();
- break;
}
locs->set_out(0, result_location);
}
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
index f9e6f0e..30f6bec 100644
--- a/runtime/vm/compiler/backend/il.cc
+++ b/runtime/vm/compiler/backend/il.cc
@@ -6494,26 +6494,21 @@
LocationSummary* FfiCallInstr::MakeLocationSummaryInternal(
Zone* zone,
bool is_optimizing,
- const Register temp) const {
- // The temporary register needs to be callee-saved and not an argument
- // register.
- ASSERT(((1 << CallingConventions::kFfiAnyNonAbiRegister) &
- CallingConventions::kArgumentRegisters) == 0);
+ const RegList temps) const {
+ auto contains_call =
+ is_leaf_ ? LocationSummary::kNativeLeafCall : LocationSummary::kCall;
- // TODO(dartbug.com/45468): Investigate whether we can avoid spilling
- // registers across ffi leaf calls by not using `kCall` here.
LocationSummary* summary = new (zone) LocationSummary(
zone, /*num_inputs=*/InputCount(),
- /*num_temps=*/temp == kNoRegister ? 2 : 3, LocationSummary::kCall);
+ /*num_temps=*/Utils::CountOneBitsWord(temps), contains_call);
- const Register temp0 = CallingConventions::kFfiAnyNonAbiRegister;
- const Register temp1 = CallingConventions::kSecondNonArgumentRegister;
- ASSERT(temp0 != temp1);
- summary->set_temp(0, Location::RegisterLocation(temp0));
- summary->set_temp(1, Location::RegisterLocation(temp1));
-
- if (temp != kNoRegister) {
- summary->set_temp(2, Location::RegisterLocation(temp));
+ intptr_t reg_i = 0;
+ for (intptr_t reg = 0; reg < kNumberOfCpuRegisters; reg++) {
+ if ((temps & (1 << reg)) != 0) {
+ summary->set_temp(reg_i,
+ Location::RegisterLocation(static_cast<Register>(reg)));
+ reg_i++;
+ }
}
summary->set_in(TargetAddressIndex(),
@@ -6524,10 +6519,7 @@
}
if (marshaller_.PassTypedData()) {
- // The register allocator already preserves this value across the call on
- // a stack slot, so we'll use the spilled value directly.
- summary->set_in(TypedDataIndex(), Location::RequiresStackSlot());
-
+ summary->set_in(TypedDataIndex(), Location::Any());
// We don't care about return location, but we need to pass a register.
summary->set_out(
0, Location::RegisterLocation(CallingConventions::kReturnReg));
@@ -6654,14 +6646,14 @@
void FfiCallInstr::EmitReturnMoves(FlowGraphCompiler* compiler,
const Register temp0,
const Register temp1) {
- __ Comment("EmitReturnMoves");
-
const auto& returnLocation =
marshaller_.Location(compiler::ffi::kResultIndex);
if (returnLocation.payload_type().IsVoid()) {
return;
}
+ __ Comment("EmitReturnMoves");
+
NoTemporaryAllocator no_temp;
if (returnLocation.IsRegisters() || returnLocation.IsFpuRegisters()) {
const auto& src = returnLocation;
@@ -6675,15 +6667,20 @@
// Get the typed data pointer which we have pinned to a stack slot.
const Location typed_data_loc = locs()->in(TypedDataIndex());
- ASSERT(typed_data_loc.IsStackSlot());
- ASSERT(typed_data_loc.base_reg() == FPREG);
- // If this is a leaf call there is no extra call frame to step through.
- if (is_leaf_) {
- __ LoadMemoryValue(temp0, FPREG, typed_data_loc.ToStackSlotOffset());
+ if (typed_data_loc.IsStackSlot()) {
+ ASSERT(typed_data_loc.base_reg() == FPREG);
+ // If this is a leaf call there is no extra call frame to step through.
+ if (is_leaf_) {
+ __ LoadMemoryValue(temp0, FPREG, typed_data_loc.ToStackSlotOffset());
+ } else {
+ __ LoadMemoryValue(
+ temp0, FPREG,
+ kSavedCallerFpSlotFromFp * compiler::target::kWordSize);
+ __ LoadMemoryValue(temp0, temp0, typed_data_loc.ToStackSlotOffset());
+ }
} else {
- __ LoadMemoryValue(
- temp0, FPREG, kSavedCallerFpSlotFromFp * compiler::target::kWordSize);
- __ LoadMemoryValue(temp0, temp0, typed_data_loc.ToStackSlotOffset());
+ compiler->EmitMove(Location::RegisterLocation(temp0), typed_data_loc,
+ &no_temp);
}
__ LoadField(temp0,
compiler::FieldAddress(
diff --git a/runtime/vm/compiler/backend/il.h b/runtime/vm/compiler/backend/il.h
index 65a9afb..a7dd7aa 100644
--- a/runtime/vm/compiler/backend/il.h
+++ b/runtime/vm/compiler/backend/il.h
@@ -5305,7 +5305,7 @@
LocationSummary* MakeLocationSummaryInternal(Zone* zone,
bool is_optimizing,
- const Register temp) const;
+ const RegList temps) const;
// Clobbers both given registers.
// `saved_fp` is used as the frame base to rebase off of.
diff --git a/runtime/vm/compiler/backend/il_arm.cc b/runtime/vm/compiler/backend/il_arm.cc
index 411d58b..3dab29a 100644
--- a/runtime/vm/compiler/backend/il_arm.cc
+++ b/runtime/vm/compiler/backend/il_arm.cc
@@ -1402,27 +1402,34 @@
__ Drop(ArgumentCount()); // Drop the arguments.
}
+#define R(r) (1 << r)
+
LocationSummary* FfiCallInstr::MakeLocationSummary(Zone* zone,
bool is_optimizing) const {
- return MakeLocationSummaryInternal(zone, is_optimizing, R0);
+ return MakeLocationSummaryInternal(
+ zone, is_optimizing,
+ (R(R0) | R(CallingConventions::kFfiAnyNonAbiRegister) |
+ R(CallingConventions::kSecondNonArgumentRegister)));
}
+#undef R
+
void FfiCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+ const Register branch = locs()->in(TargetAddressIndex()).reg();
+
+ // The temps are indexed according to their register number.
+ const Register temp2 = locs()->temp(0).reg();
// For regular calls, this holds the FP for rebasing the original locations
// during EmitParamMoves.
// For leaf calls, this holds the SP used to restore the pre-aligned SP after
// the call.
- const Register saved_fp_or_sp = locs()->temp(0).reg();
- RELEASE_ASSERT((CallingConventions::kCalleeSaveCpuRegisters &
- (1 << saved_fp_or_sp)) != 0);
- const Register temp1 = locs()->temp(1).reg();
- const Register temp2 = locs()->temp(2).reg();
- const Register branch = locs()->in(TargetAddressIndex()).reg();
+ const Register saved_fp_or_sp = locs()->temp(1).reg();
+ const Register temp1 = locs()->temp(2).reg();
// Ensure these are callee-saved register and are preserved across the call.
ASSERT((CallingConventions::kCalleeSaveCpuRegisters &
(1 << saved_fp_or_sp)) != 0);
- // temp doesn't need to be preserved.
+ // Other temps don't need to be preserved.
__ mov(saved_fp_or_sp,
is_leaf_ ? compiler::Operand(SPREG) : compiler::Operand(FPREG));
diff --git a/runtime/vm/compiler/backend/il_arm64.cc b/runtime/vm/compiler/backend/il_arm64.cc
index 410cb0e..7ba8603 100644
--- a/runtime/vm/compiler/backend/il_arm64.cc
+++ b/runtime/vm/compiler/backend/il_arm64.cc
@@ -1227,27 +1227,36 @@
__ Drop(ArgumentCount()); // Drop the arguments.
}
+#define R(r) (1 << r)
+
LocationSummary* FfiCallInstr::MakeLocationSummary(Zone* zone,
bool is_optimizing) const {
- return MakeLocationSummaryInternal(zone, is_optimizing, R11);
+ return MakeLocationSummaryInternal(
+ zone, is_optimizing,
+ (R(CallingConventions::kSecondNonArgumentRegister) | R(R11) |
+ R(CallingConventions::kFfiAnyNonAbiRegister) | R(R25)));
}
+#undef R
+
void FfiCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+ const Register branch = locs()->in(TargetAddressIndex()).reg();
+
+ // The temps are indexed according to their register number.
+ const Register temp1 = locs()->temp(0).reg();
+ const Register temp2 = locs()->temp(1).reg();
// For regular calls, this holds the FP for rebasing the original locations
// during EmitParamMoves.
// For leaf calls, this holds the SP used to restore the pre-aligned SP after
// the call.
- const Register saved_fp_or_sp = locs()->temp(0).reg();
- RELEASE_ASSERT((CallingConventions::kCalleeSaveCpuRegisters &
- (1 << saved_fp_or_sp)) != 0);
- const Register temp1 = locs()->temp(1).reg();
- const Register temp2 = locs()->temp(2).reg();
- const Register branch = locs()->in(TargetAddressIndex()).reg();
+ const Register saved_fp_or_sp = locs()->temp(2).reg();
+ const Register temp_csp = locs()->temp(3).reg();
// Ensure these are callee-saved register and are preserved across the call.
ASSERT((CallingConventions::kCalleeSaveCpuRegisters &
(1 << saved_fp_or_sp)) != 0);
- // temps don't need to be preserved.
+ ASSERT((CallingConventions::kCalleeSaveCpuRegisters & (1 << temp_csp)) != 0);
+ // Other temps don't need to be preserved.
__ mov(saved_fp_or_sp, is_leaf_ ? SPREG : FPREG);
@@ -1279,14 +1288,14 @@
// We are entering runtime code, so the C stack pointer must be restored
// from the stack limit to the top of the stack.
- __ mov(R25, CSP);
+ __ mov(temp_csp, CSP);
__ mov(CSP, SP);
__ blr(branch);
// Restore the Dart stack pointer.
__ mov(SP, CSP);
- __ mov(CSP, R25);
+ __ mov(CSP, temp_csp);
#if !defined(PRODUCT)
__ LoadImmediate(temp1, compiler::target::Thread::vm_tag_dart_id());
@@ -1315,14 +1324,14 @@
// We are entering runtime code, so the C stack pointer must be restored
// from the stack limit to the top of the stack.
- __ mov(R25, CSP);
+ __ mov(temp_csp, CSP);
__ mov(CSP, SP);
__ blr(branch);
// Restore the Dart stack pointer.
__ mov(SP, CSP);
- __ mov(CSP, R25);
+ __ mov(CSP, temp_csp);
// Update information in the thread object and leave the safepoint.
__ TransitionNativeToGenerated(temp1, /*leave_safepoint=*/true);
diff --git a/runtime/vm/compiler/backend/il_ia32.cc b/runtime/vm/compiler/backend/il_ia32.cc
index ce4c368..d608637 100644
--- a/runtime/vm/compiler/backend/il_ia32.cc
+++ b/runtime/vm/compiler/backend/il_ia32.cc
@@ -998,24 +998,33 @@
__ Drop(ArgumentCount()); // Drop the arguments.
}
+#define R(r) (1 << r)
+
LocationSummary* FfiCallInstr::MakeLocationSummary(Zone* zone,
bool is_optimizing) const {
- return MakeLocationSummaryInternal(zone, is_optimizing, kNoRegister);
+ return MakeLocationSummaryInternal(
+ zone, is_optimizing,
+ (R(CallingConventions::kSecondNonArgumentRegister) |
+ R(CallingConventions::kFfiAnyNonAbiRegister)));
}
+#undef R
+
void FfiCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+ const Register branch = locs()->in(TargetAddressIndex()).reg();
+
+ // The temps are indexed according to their register number.
+ const Register temp = locs()->temp(0).reg();
// For regular calls, this holds the FP for rebasing the original locations
// during EmitParamMoves.
// For leaf calls, this holds the SP used to restore the pre-aligned SP after
// the call.
- const Register saved_fp_or_sp = locs()->temp(0).reg();
- const Register temp = locs()->temp(1).reg();
- const Register branch = locs()->in(TargetAddressIndex()).reg();
+ const Register saved_fp_or_sp = locs()->temp(1).reg();
// Ensure these are callee-saved register and are preserved across the call.
ASSERT((CallingConventions::kCalleeSaveCpuRegisters &
(1 << saved_fp_or_sp)) != 0);
- // temp doesn't need to be preserved.
+ // Other temps don't need to be preserved.
__ movl(saved_fp_or_sp, is_leaf_ ? SPREG : FPREG);
diff --git a/runtime/vm/compiler/backend/il_riscv.cc b/runtime/vm/compiler/backend/il_riscv.cc
index 9068abb..9f576c9 100644
--- a/runtime/vm/compiler/backend/il_riscv.cc
+++ b/runtime/vm/compiler/backend/il_riscv.cc
@@ -1374,10 +1374,14 @@
__ Drop(ArgumentCount() + 1); // Drop the arguments and result.
}
+#define R(r) (1 << r)
+
LocationSummary* FfiCallInstr::MakeLocationSummary(Zone* zone,
bool is_optimizing) const {
- LocationSummary* summary =
- MakeLocationSummaryInternal(zone, is_optimizing, CALLEE_SAVED_TEMP2);
+ LocationSummary* summary = MakeLocationSummaryInternal(
+ zone, is_optimizing,
+ (R(CallingConventions::kSecondNonArgumentRegister) |
+ R(CallingConventions::kFfiAnyNonAbiRegister) | R(CALLEE_SAVED_TEMP2)));
// A3/A4/A5 are blocked during Dart register allocation because they are
// assigned to TMP/TMP2/PP. This assignment is important for reducing code
// size. To work around this for FFI calls, the FFI argument definitions are
@@ -1400,17 +1404,20 @@
return summary;
}
+#undef R
+
void FfiCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+ const Register target = locs()->in(TargetAddressIndex()).reg();
+
+ // The temps are indexed according to their register number.
+ const Register temp1 = locs()->temp(0).reg();
// For regular calls, this holds the FP for rebasing the original locations
// during EmitParamMoves.
// For leaf calls, this holds the SP used to restore the pre-aligned SP after
// the call.
- const Register saved_fp_or_sp = locs()->temp(0).reg();
- RELEASE_ASSERT((CallingConventions::kCalleeSaveCpuRegisters &
- (1 << saved_fp_or_sp)) != 0);
- const Register temp1 = locs()->temp(1).reg();
+ const Register saved_fp_or_sp = locs()->temp(1).reg();
const Register temp2 = locs()->temp(2).reg();
- const Register target = locs()->in(TargetAddressIndex()).reg();
+
ASSERT(temp1 != target);
ASSERT(temp2 != target);
ASSERT(temp1 != saved_fp_or_sp);
@@ -1420,7 +1427,7 @@
// Ensure these are callee-saved register and are preserved across the call.
ASSERT((CallingConventions::kCalleeSaveCpuRegisters &
(1 << saved_fp_or_sp)) != 0);
- // temps don't need to be preserved.
+ // Other temps don't need to be preserved.
__ mv(saved_fp_or_sp, is_leaf_ ? SPREG : FPREG);
diff --git a/runtime/vm/compiler/backend/il_test.cc b/runtime/vm/compiler/backend/il_test.cc
index a03d0e86..95f8ac0 100644
--- a/runtime/vm/compiler/backend/il_test.cc
+++ b/runtime/vm/compiler/backend/il_test.cc
@@ -952,6 +952,227 @@
EXPECT_EQ(reinterpret_cast<intptr_t>(thread), result_int);
}
+// Helper to set up an inlined FfiCall by replacing a StaticCall.
+FlowGraph* SetupFfiFlowgraph(TestPipeline* pipeline,
+ Zone* zone,
+ const compiler::ffi::CallMarshaller& marshaller,
+ uword native_entry,
+ bool is_leaf) {
+ FlowGraph* flow_graph = pipeline->RunPasses({CompilerPass::kComputeSSA});
+
+ // Make an FfiCall based on ffi_trampoline that calls our native function.
+ auto ffi_call = new FfiCallInstr(zone, DeoptId::kNone, marshaller, is_leaf);
+ RELEASE_ASSERT(ffi_call->InputCount() == 1);
+ // TargetAddress is the function pointer called.
+ const Representation address_repr =
+ compiler::target::kWordSize == 4 ? kUnboxedUint32 : kUnboxedInt64;
+ ffi_call->SetInputAt(
+ ffi_call->TargetAddressIndex(),
+ new Value(flow_graph->GetConstant(
+ Integer::Handle(Integer::NewCanonical(native_entry)), address_repr)));
+
+ // Replace the placeholder StaticCall with an FfiCall to our native function.
+ {
+ StaticCallInstr* static_call = nullptr;
+ {
+ ILMatcher cursor(flow_graph, flow_graph->graph_entry()->normal_entry(),
+ /*trace=*/false);
+ cursor.TryMatch({kMoveGlob, {kMatchStaticCall, &static_call}});
+ }
+ RELEASE_ASSERT(static_call != nullptr);
+
+ flow_graph->InsertBefore(static_call, ffi_call, /*env=*/nullptr,
+ FlowGraph::kEffect);
+ static_call->RemoveFromGraph(/*return_previous=*/false);
+ }
+
+ // Run remaining relevant compiler passes.
+ pipeline->RunAdditionalPasses({
+ CompilerPass::kApplyICData,
+ CompilerPass::kTryOptimizePatterns,
+ CompilerPass::kSetOuterInliningId,
+ CompilerPass::kTypePropagation,
+ // Skipping passes that don't seem to do anything for this test.
+ CompilerPass::kWidenSmiToInt32,
+ CompilerPass::kSelectRepresentations,
+ // Skipping passes that don't seem to do anything for this test.
+ CompilerPass::kTypePropagation,
+ CompilerPass::kRangeAnalysis,
+ // Skipping passes that don't seem to do anything for this test.
+ CompilerPass::kFinalizeGraph,
+ CompilerPass::kCanonicalize,
+ CompilerPass::kAllocateRegisters,
+ CompilerPass::kReorderBlocks,
+ });
+
+ return flow_graph;
+}
+
+// Test that FFI calls spill all live values to the stack, and that FFI leaf
+// calls are free to use available ABI callee-save registers to avoid spilling.
+// Additionally test that register allocation is done correctly by clobbering
+// all volatile registers in the native function being called.
+ISOLATE_UNIT_TEST_CASE(IRTest_FfiCallInstrLeafDoesntSpill) {
+ SetFlagScope<int> sfs(&FLAG_sound_null_safety, kNullSafetyOptionStrong);
+
+ const char* kScript = R"(
+ import 'dart:ffi';
+
+ // This is purely a placeholder and is never called.
+ void placeholder() {}
+
+ // Will call the "doFfiCall" and exercise its code.
+ bool invokeDoFfiCall() {
+ final double result = doFfiCall(1, 2, 3, 1.0, 2.0, 3.0);
+ if (result != (2 + 3 + 4 + 2.0 + 3.0 + 4.0)) {
+ throw 'Failed. Result was $result.';
+ }
+ return true;
+ }
+
+ // Will perform a "C" call while having live values in registers
+ // across the FfiCall.
+ double doFfiCall(int a, int b, int c, double x, double y, double z) {
+ // Ensure there is at least one live value in a register.
+ a += 1;
+ b += 1;
+ c += 1;
+ x += 1.0;
+ y += 1.0;
+ z += 1.0;
+ // We'll replace this StaticCall with an FfiCall.
+ placeholder();
+ // Use the live value.
+ return (a + b + c + x + y + z);
+ }
+
+ // FFI trampoline function.
+ typedef NT = Void Function();
+ typedef DT = void Function();
+ Pointer<NativeFunction<NT>> ptr = Pointer.fromAddress(0);
+ DT getFfiTrampolineClosure() => ptr.asFunction(isLeaf:true);
+ )";
+
+ const auto& root_library = Library::Handle(LoadTestScript(kScript));
+
+ // Build a "C" function that we can actually invoke.
+ auto& c_function = Instructions::Handle(
+ BuildInstructions([](compiler::Assembler* assembler) {
+ // Clobber all volatile registers to make sure caller doesn't rely on
+ // any non-callee-save register.
+ for (intptr_t reg = 0; reg < kNumberOfFpuRegisters; reg++) {
+ if ((kAbiVolatileFpuRegs & (1 << reg)) != 0) {
+#if defined(TARGET_ARCH_ARM)
+ // On ARM we need an extra scratch register for LoadDImmediate.
+ assembler->LoadDImmediate(static_cast<DRegister>(reg), 0.0, R3);
+#else
+ assembler->LoadDImmediate(static_cast<FpuRegister>(reg), 0.0);
+#endif
+ }
+ }
+ for (intptr_t reg = 0; reg < kNumberOfCpuRegisters; reg++) {
+ if ((kDartVolatileCpuRegs & (1 << reg)) != 0) {
+ assembler->LoadImmediate(static_cast<Register>(reg), 0xDEADBEEF);
+ }
+ }
+ assembler->Ret();
+ }));
+ uword native_entry = c_function.EntryPoint();
+
+ // Get initial compilation done.
+ Invoke(root_library, "invokeDoFfiCall");
+
+ const Function& do_ffi_call =
+ Function::Handle(GetFunction(root_library, "doFfiCall"));
+ RELEASE_ASSERT(!do_ffi_call.IsNull());
+
+ const auto& value = Closure::Handle(
+ Closure::RawCast(Invoke(root_library, "getFfiTrampolineClosure")));
+ RELEASE_ASSERT(value.IsClosure());
+ const auto& ffi_trampoline =
+ Function::ZoneHandle(Closure::Cast(value).function());
+ RELEASE_ASSERT(!ffi_trampoline.IsNull());
+
+ // Construct the FFICallInstr from the trampoline matching our native
+ // function.
+ const char* error = nullptr;
+ const auto marshaller_ptr = compiler::ffi::CallMarshaller::FromFunction(
+ thread->zone(), ffi_trampoline, &error);
+ RELEASE_ASSERT(error == nullptr);
+ RELEASE_ASSERT(marshaller_ptr != nullptr);
+ const auto& marshaller = *marshaller_ptr;
+
+ const auto& compile_and_run =
+ [&](bool is_leaf, std::function<void(ParallelMoveInstr*)> verify) {
+ // Build the SSA graph for "doFfiCall"
+ TestPipeline pipeline(do_ffi_call, CompilerPass::kJIT);
+ FlowGraph* flow_graph = SetupFfiFlowgraph(
+ &pipeline, thread->zone(), marshaller, native_entry, is_leaf);
+
+ {
+ ParallelMoveInstr* parallel_move = nullptr;
+ ILMatcher cursor(flow_graph,
+ flow_graph->graph_entry()->normal_entry(),
+ /*trace=*/false);
+ while (cursor.TryMatch(
+ {kMoveGlob, {kMatchAndMoveParallelMove, ¶llel_move}})) {
+ verify(parallel_move);
+ }
+ }
+
+ // Finish the compilation and attach code so we can run it.
+ pipeline.CompileGraphAndAttachFunction();
+
+ // Ensure we can successfully invoke the FFI call.
+ auto& result = Object::Handle(Invoke(root_library, "invokeDoFfiCall"));
+ RELEASE_ASSERT(result.IsBool());
+ EXPECT(Bool::Cast(result).value());
+ };
+
+ intptr_t num_cpu_reg_to_stack_nonleaf = 0;
+ intptr_t num_cpu_reg_to_stack_leaf = 0;
+ intptr_t num_fpu_reg_to_stack_nonleaf = 0;
+ intptr_t num_fpu_reg_to_stack_leaf = 0;
+
+ // Test non-leaf spills live values.
+ compile_and_run(/*is_leaf=*/false, [&](ParallelMoveInstr* parallel_move) {
+ // TargetAddress is passed in register, live values are all spilled.
+ for (int i = 0; i < parallel_move->NumMoves(); i++) {
+ auto move = parallel_move->moves()[i];
+ if (move->src_slot()->IsRegister() && move->dest_slot()->IsStackSlot()) {
+ num_cpu_reg_to_stack_nonleaf++;
+ } else if (move->src_slot()->IsFpuRegister() &&
+ move->dest_slot()->IsDoubleStackSlot()) {
+ num_fpu_reg_to_stack_nonleaf++;
+ }
+ }
+ });
+
+ // Test leaf calls do not cause spills of live values.
+ compile_and_run(/*is_leaf=*/true, [&](ParallelMoveInstr* parallel_move) {
+ // TargetAddress is passed in registers, live values are not spilled and
+ // remains in callee-save registers.
+ for (int i = 0; i < parallel_move->NumMoves(); i++) {
+ auto move = parallel_move->moves()[i];
+ if (move->src_slot()->IsRegister() && move->dest_slot()->IsStackSlot()) {
+ num_cpu_reg_to_stack_leaf++;
+ } else if (move->src_slot()->IsFpuRegister() &&
+ move->dest_slot()->IsDoubleStackSlot()) {
+ num_fpu_reg_to_stack_leaf++;
+ }
+ }
+ });
+
+ // We should have less moves to the stack (i.e. spilling) in leaf calls.
+ EXPECT_LT(num_cpu_reg_to_stack_leaf, num_cpu_reg_to_stack_nonleaf);
+ // We don't have volatile FPU registers on all platforms.
+ const bool has_callee_save_fpu_regs =
+ Utils::CountOneBitsWord(kAbiVolatileFpuRegs) <
+ Utils::CountOneBitsWord(kAllFpuRegistersList);
+ EXPECT(!has_callee_save_fpu_regs ||
+ num_fpu_reg_to_stack_leaf < num_fpu_reg_to_stack_nonleaf);
+}
+
static void TestConstantFoldToSmi(const Library& root_library,
const char* function_name,
CompilerPass::PipelineMode mode,
diff --git a/runtime/vm/compiler/backend/il_x64.cc b/runtime/vm/compiler/backend/il_x64.cc
index 33b66ee..9a12a65 100644
--- a/runtime/vm/compiler/backend/il_x64.cc
+++ b/runtime/vm/compiler/backend/il_x64.cc
@@ -1175,29 +1175,38 @@
__ Drop(ArgumentCount()); // Drop the arguments.
}
+#define R(r) (1 << r)
+
LocationSummary* FfiCallInstr::MakeLocationSummary(Zone* zone,
bool is_optimizing) const {
- // Use R10 as a temp register. We can't use RDI, RSI, RDX, R8, R9 as they are
- // arg registers, and R11 is TMP.
- return MakeLocationSummaryInternal(zone, is_optimizing, R10);
+ // Use R10 as a temp. register. We can't use RDI, RSI, RDX, R8, R9 as they are
+ // argument registers, and R11 is TMP.
+ return MakeLocationSummaryInternal(
+ zone, is_optimizing,
+ (R(CallingConventions::kSecondNonArgumentRegister) | R(R10) |
+ R(CallingConventions::kFfiAnyNonAbiRegister)));
}
+#undef R
+
void FfiCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
+ const Register target_address = locs()->in(TargetAddressIndex()).reg();
+
+ // The temps are indexed according to their register number.
+ // For regular calls, this holds the FP for rebasing the original locations
+ // during EmitParamMoves.
+ const Register saved_fp = locs()->temp(0).reg();
+ const Register temp = locs()->temp(1).reg();
// For leaf calls, this holds the SP used to restore the pre-aligned SP after
// the call.
// Note: R12 doubles as CODE_REG, which gets clobbered during frame setup in
// regular calls.
- const Register saved_sp = locs()->temp(0).reg();
- // For regular calls, this holds the FP for rebasing the original locations
- // during EmitParamMoves.
- const Register saved_fp = locs()->temp(1).reg();
- const Register temp = locs()->temp(2).reg();
- const Register target_address = locs()->in(TargetAddressIndex()).reg();
+ const Register saved_sp = locs()->temp(2).reg();
// Ensure these are callee-saved register and are preserved across the call.
ASSERT((CallingConventions::kCalleeSaveCpuRegisters & (1 << saved_sp)) != 0);
ASSERT((CallingConventions::kCalleeSaveCpuRegisters & (1 << saved_fp)) != 0);
- // temp doesn't need to be preserved.
+ // Other temps don't need to be preserved.
if (is_leaf_) {
__ movq(saved_sp, SPREG);
diff --git a/runtime/vm/compiler/backend/linearscan.cc b/runtime/vm/compiler/backend/linearscan.cc
index 19191d1..266b485 100644
--- a/runtime/vm/compiler/backend/linearscan.cc
+++ b/runtime/vm/compiler/backend/linearscan.cc
@@ -465,6 +465,28 @@
}
}
+void FlowGraphAllocator::BlockCpuRegisters(intptr_t registers,
+ intptr_t from,
+ intptr_t to) {
+ for (intptr_t r = 0; r < kNumberOfCpuRegisters; r++) {
+ if ((registers & (1 << r)) != 0) {
+ BlockLocation(Location::RegisterLocation(static_cast<Register>(r)), from,
+ to);
+ }
+ }
+}
+
+void FlowGraphAllocator::BlockFpuRegisters(intptr_t fpu_registers,
+ intptr_t from,
+ intptr_t to) {
+ for (intptr_t r = 0; r < kNumberOfFpuRegisters; r++) {
+ if ((fpu_registers & (1 << r)) != 0) {
+ BlockLocation(Location::FpuRegisterLocation(static_cast<FpuRegister>(r)),
+ from, to);
+ }
+ }
+}
+
void LiveRange::Print() {
if (first_use_interval() == NULL) {
return;
@@ -1389,6 +1411,21 @@
}
}
+ // Block all volatile (i.e. not native ABI callee-save) registers.
+ if (locs->native_leaf_call()) {
+ BlockCpuRegisters(kDartVolatileCpuRegs, pos, pos + 1);
+ BlockFpuRegisters(kAbiVolatileFpuRegs, pos, pos + 1);
+#if defined(TARGET_ARCH_ARM)
+ // We do not yet have a way to say that we only want FPU registers that
+ // overlap S registers.
+ // Block all Q/D FPU registers above the 8/16 that have S registers in
+ // VFPv3-D32.
+ // This way we avoid ending up trying to do single-word operations on
+ // registers that don't support it.
+ BlockFpuRegisters(kFpuRegistersWithoutSOverlap, pos, pos + 1);
+#endif
+ }
+
// Block all allocatable registers for calls.
if (locs->always_calls() && !locs->callee_safe_call()) {
// Expected shape of live range:
@@ -1397,16 +1434,9 @@
// [--)
//
// The stack bitmap describes the position i.
- for (intptr_t reg = 0; reg < kNumberOfCpuRegisters; reg++) {
- BlockLocation(Location::RegisterLocation(static_cast<Register>(reg)), pos,
- pos + 1);
- }
+ BlockCpuRegisters(kAllCpuRegistersList, pos, pos + 1);
- for (intptr_t reg = 0; reg < kNumberOfFpuRegisters; reg++) {
- BlockLocation(
- Location::FpuRegisterLocation(static_cast<FpuRegister>(reg)), pos,
- pos + 1);
- }
+ BlockFpuRegisters(kAllFpuRegistersList, pos, pos + 1);
#if defined(DEBUG)
// Verify that temps, inputs and output were specified as fixed
@@ -1426,8 +1456,7 @@
pair->At(1).policy() == Location::kAny);
} else {
ASSERT(!locs->in(j).IsUnallocated() ||
- locs->in(j).policy() == Location::kAny ||
- locs->in(j).policy() == Location::kRequiresStackSlot);
+ locs->in(j).policy() == Location::kAny);
}
}
@@ -1441,7 +1470,7 @@
#endif
}
- if (locs->can_call()) {
+ if (locs->can_call() && !locs->native_leaf_call()) {
safepoints_.Add(current);
}
diff --git a/runtime/vm/compiler/backend/linearscan.h b/runtime/vm/compiler/backend/linearscan.h
index 2d6e919..bc26c63 100644
--- a/runtime/vm/compiler/backend/linearscan.h
+++ b/runtime/vm/compiler/backend/linearscan.h
@@ -156,6 +156,10 @@
bool* blocked_registers,
LiveRange** blocking_ranges);
+ void BlockCpuRegisters(intptr_t registers, intptr_t from, intptr_t to);
+
+ void BlockFpuRegisters(intptr_t fpu_registers, intptr_t from, intptr_t to);
+
intptr_t NumberOfRegisters() const { return number_of_registers_; }
// Find all safepoints that are covered by this live range.
diff --git a/runtime/vm/compiler/backend/locations.cc b/runtime/vm/compiler/backend/locations.cc
index 56640f8..9b5b166 100644
--- a/runtime/vm/compiler/backend/locations.cc
+++ b/runtime/vm/compiler/backend/locations.cc
@@ -185,8 +185,7 @@
// restrictions.
if (always_calls()) {
if (loc.IsUnallocated()) {
- ASSERT(loc.policy() == Location::kAny ||
- loc.policy() == Location::kRequiresStackSlot);
+ ASSERT(loc.policy() == Location::kAny);
} else if (loc.IsPairLocation()) {
ASSERT(!loc.AsPairLocation()->At(0).IsUnallocated() ||
loc.AsPairLocation()->At(0).policy() == Location::kAny);
@@ -311,8 +310,6 @@
return "R";
case kRequiresFpuRegister:
return "DR";
- case kRequiresStackSlot:
- return "RS";
case kWritableRegister:
return "WR";
case kSameAsFirstInput:
diff --git a/runtime/vm/compiler/backend/locations.h b/runtime/vm/compiler/backend/locations.h
index b9988948..754852e 100644
--- a/runtime/vm/compiler/backend/locations.h
+++ b/runtime/vm/compiler/backend/locations.h
@@ -257,7 +257,6 @@
kPrefersRegister,
kRequiresRegister,
kRequiresFpuRegister,
- kRequiresStackSlot,
kWritableRegister,
kSameAsFirstInput,
};
@@ -285,10 +284,6 @@
return UnallocatedLocation(kRequiresFpuRegister);
}
- static Location RequiresStackSlot() {
- return UnallocatedLocation(kRequiresStackSlot);
- }
-
static Location WritableRegister() {
return UnallocatedLocation(kWritableRegister);
}
@@ -719,12 +714,19 @@
class LocationSummary : public ZoneAllocated {
public:
enum ContainsCall {
- kNoCall, // Used registers must be reserved as tmp.
- kCall, // Registers have been saved and can be used without reservation.
- kCallCalleeSafe, // Registers will be saved by the callee.
- kCallOnSlowPath, // Used registers must be reserved as tmp.
- kCallOnSharedSlowPath // Registers used to invoke shared stub must be
- // reserved as tmp.
+ // Used registers must be reserved as tmp.
+ kNoCall,
+ // Registers have been saved and can be used without reservation.
+ kCall,
+ // Registers will be saved by the callee.
+ kCallCalleeSafe,
+ // Used registers must be reserved as tmp.
+ kCallOnSlowPath,
+ // Registers used to invoke shared stub must be reserved as tmp.
+ kCallOnSharedSlowPath,
+ // Location is a native leaf call so any register not in the native ABI
+ // callee-save (or input/output/tmp) set might get clobbered.
+ kNativeLeafCall
};
LocationSummary(Zone* zone,
@@ -800,6 +802,8 @@
return contains_call_ == kCallOnSharedSlowPath;
}
+ bool native_leaf_call() const { return contains_call_ == kNativeLeafCall; }
+
void PrintTo(BaseTextBuffer* f) const;
static LocationSummary* Make(Zone* zone,
diff --git a/runtime/vm/compiler/frontend/kernel_translation_helper.cc b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
index 15f48ef..a94761c 100644
--- a/runtime/vm/compiler/frontend/kernel_translation_helper.cc
+++ b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
@@ -2832,19 +2832,6 @@
SkipStringReference(); // Read part URI index.
}
-void KernelReaderHelper::SkipLibraryTypedef() {
- SkipCanonicalNameReference(); // read canonical name.
- ReadUInt(); // read source_uri_index.
- ReadPosition(); // read position.
- SkipStringReference(); // read name index.
- SkipListOfExpressions(); // read annotations.
- SkipTypeParametersList(); // read type parameters.
- SkipDartType(); // read type.
- SkipTypeParametersList(); // read type parameters of function type.
- SkipListOfVariableDeclarations(); // read positional parameters.
- SkipListOfVariableDeclarations(); // read named parameters.
-}
-
TokenPosition KernelReaderHelper::ReadPosition() {
TokenPosition position = reader_.ReadPosition();
RecordTokenPosition(position);
diff --git a/runtime/vm/compiler/frontend/kernel_translation_helper.h b/runtime/vm/compiler/frontend/kernel_translation_helper.h
index 315e468..4016697 100644
--- a/runtime/vm/compiler/frontend/kernel_translation_helper.h
+++ b/runtime/vm/compiler/frontend/kernel_translation_helper.h
@@ -1279,7 +1279,6 @@
void SkipLibraryCombinator();
void SkipLibraryDependency();
void SkipLibraryPart();
- void SkipLibraryTypedef();
TokenPosition ReadPosition();
Tag ReadTag(uint8_t* payload = NULL);
uint8_t ReadFlags() { return reader_.ReadFlags(); }
diff --git a/runtime/vm/constants_arm.h b/runtime/vm/constants_arm.h
index 7b43812..7406b47 100644
--- a/runtime/vm/constants_arm.h
+++ b/runtime/vm/constants_arm.h
@@ -30,6 +30,8 @@
// to compare LR register code.
#define LR LR_DO_NOT_USE_DIRECTLY
+#define R(reg) (static_cast<RegList>(1) << (reg))
+
// We support both VFPv3-D16 and VFPv3-D32 profiles, but currently only one at
// a time.
#if defined(__ARM_ARCH_7A__)
@@ -209,6 +211,9 @@
D31 = 31,
kNumberOfDRegisters = 32,
#endif
+ // Number of D registers that overlap S registers.
+ // One D register overlaps two S registers, so regardless of the numbers of D
+ // registers, there are only 32 S registers that are overlapped.
kNumberOfOverlappingDRegisters = 16,
};
@@ -243,6 +248,10 @@
Q15 = 15,
kNumberOfQRegisters = 16,
#endif
+ // Number of Q registers that overlap S registers.
+ // One Q register overlaps four S registers, so regardless of the numbers of Q
+ // registers, there are only 32 S registers that are overlapped.
+ kNumberOfOverlappingQRegisters = 8,
};
static inline DRegister EvenDRegisterOf(QRegister q) {
@@ -256,7 +265,7 @@
static inline SRegister EvenSRegisterOf(DRegister d) {
#if defined(VFPv3_D32)
// When we have 32 D registers, the S registers only overlap the first 16.
- // That is, there are only 32 S registers.
+ // That is, there are only ever 32 S registers in any extension.
ASSERT(d < D16);
#endif
return static_cast<SRegister>(d * 2);
@@ -535,6 +544,7 @@
// List of registers used in load/store multiple.
typedef uint16_t RegList;
const RegList kAllCpuRegistersList = 0xFFFF;
+const RegList kAllFpuRegistersList = (1 << kNumberOfFpuRegisters) - 1;
// C++ ABI call registers.
const RegList kAbiArgumentCpuRegs =
@@ -572,7 +582,11 @@
const int kDartVolatileCpuRegCount = 5;
#endif
-#define R(reg) (static_cast<RegList>(1) << (reg))
+const RegList kAbiVolatileFpuRegs = R(Q0) | R(Q1) | R(Q2) | R(Q3);
+
+const RegList kFpuRegistersWithoutSOverlap =
+ kAllFpuRegistersList &
+ ~((1 << QRegister::kNumberOfOverlappingQRegisters) - 1);
class CallingConventions {
public:
diff --git a/runtime/vm/constants_arm64.h b/runtime/vm/constants_arm64.h
index a7f00d9..5be6e98 100644
--- a/runtime/vm/constants_arm64.h
+++ b/runtime/vm/constants_arm64.h
@@ -81,7 +81,9 @@
};
enum VRegister {
+ // v0 Volatile; Parameter/scratch register, result register.
V0 = 0,
+ // v1-v7 Volatile; Parameter/scratch register.
V1 = 1,
V2 = 2,
V3 = 3,
@@ -89,6 +91,8 @@
V5 = 5,
V6 = 6,
V7 = 7,
+ // v8-v15 Non-volatile; Scratch registers
+ // Only the bottom 64 bits are non-volatile! [ARM IHI 0055B, 5.1.2]
V8 = 8,
V9 = 9,
V10 = 10,
@@ -97,6 +101,7 @@
V13 = 13,
V14 = 14,
V15 = 15,
+ // v16-v31 Volatile; Scratch registers.
V16 = 16,
V17 = 17,
V18 = 18,
@@ -104,7 +109,7 @@
V20 = 20,
V21 = 21,
V22 = 22,
- V23 = 24,
+ V23 = 23,
V24 = 24,
V25 = 25,
V26 = 26,
@@ -430,6 +435,11 @@
const int kDartVolatileCpuRegCount = 15;
const int kDartVolatileFpuRegCount = 24;
+const RegList kAbiVolatileFpuRegs =
+ R(V0) | R(V1) | R(V2) | R(V3) | R(V4) | R(V5) | R(V6) | R(V7) | R(V16) |
+ R(V17) | R(V18) | R(V19) | R(V20) | R(V21) | R(V22) | R(V23) | R(V24) |
+ R(V25) | R(V26) | R(V27) | R(V28) | R(V29) | R(V30) | R(V31);
+
constexpr int kStoreBufferWrapperSize = 32;
class CallingConventions {
diff --git a/runtime/vm/constants_ia32.h b/runtime/vm/constants_ia32.h
index 061771d..733dd8c 100644
--- a/runtime/vm/constants_ia32.h
+++ b/runtime/vm/constants_ia32.h
@@ -16,6 +16,8 @@
namespace dart {
+#define R(reg) (1 << (reg))
+
enum Register {
EAX = 0,
ECX = 1,
@@ -29,6 +31,8 @@
kNoRegister = -1, // Signals an illegal register.
};
+// Low and high bytes registers of the the first four general purpose registers.
+// The other four general purpose registers do not have byte registers.
enum ByteRegister {
AL = 0,
CL = 1,
@@ -42,6 +46,10 @@
};
inline ByteRegister ByteRegisterOf(Register reg) {
+ // This only works for EAX, ECX, EDX, EBX.
+ // Remaining Register values map to high byte of the above registers.
+ RELEASE_ASSERT(reg == Register::EAX || reg == Register::ECX ||
+ reg == Register::EDX || reg == Register::EBX);
return static_cast<ByteRegister>(reg);
}
@@ -263,12 +271,23 @@
typedef uint32_t RegList;
const RegList kAllCpuRegistersList = 0xFF;
+const RegList kAllFpuRegistersList = (1 << kNumberOfFpuRegisters) - 1;
const intptr_t kReservedCpuRegisters = (1 << SPREG) | (1 << FPREG) | (1 << THR);
// CPU registers available to Dart allocator.
const RegList kDartAvailableCpuRegs =
kAllCpuRegistersList & ~kReservedCpuRegisters;
+const RegList kAbiPreservedCpuRegs = (1 << EDI) | (1 << ESI) | (1 << EBX);
+
+// Registers available to Dart that are not preserved by runtime calls.
+const RegList kDartVolatileCpuRegs =
+ kDartAvailableCpuRegs & ~kAbiPreservedCpuRegs;
+
+const RegList kAbiVolatileFpuRegs = kAllFpuRegistersList;
+
+#undef R
+
enum ScaleFactor {
TIMES_1 = 0,
TIMES_2 = 1,
@@ -332,8 +351,7 @@
static const intptr_t kXmmArgumentRegisters = 0;
static const intptr_t kNumFpuArgRegs = 0;
- static constexpr intptr_t kCalleeSaveCpuRegisters =
- (1 << EDI) | (1 << ESI) | (1 << EBX);
+ static constexpr intptr_t kCalleeSaveCpuRegisters = kAbiPreservedCpuRegs;
static const bool kArgumentIntRegXorFpuReg = false;
diff --git a/runtime/vm/constants_riscv.h b/runtime/vm/constants_riscv.h
index 30a720f..f8430df 100644
--- a/runtime/vm/constants_riscv.h
+++ b/runtime/vm/constants_riscv.h
@@ -387,6 +387,7 @@
typedef uint32_t RegList;
const RegList kAllCpuRegistersList = 0xFFFFFFFF;
+const RegList kAllFpuRegistersList = 0xFFFFFFFF;
#define R(reg) (static_cast<RegList>(1) << (reg))
diff --git a/runtime/vm/constants_x64.h b/runtime/vm/constants_x64.h
index b8bc0e7..930f588 100644
--- a/runtime/vm/constants_x64.h
+++ b/runtime/vm/constants_x64.h
@@ -16,6 +16,8 @@
namespace dart {
+#define R(reg) (static_cast<RegList>(1) << (reg))
+
enum Register {
RAX = 0,
RCX = 1,
@@ -345,7 +347,7 @@
const RegList kAllFpuRegistersList = 0xFFFF;
const RegList kReservedCpuRegisters =
- (1 << SPREG) | (1 << FPREG) | (1 << TMP) | (1 << PP) | (1 << THR);
+ R(SPREG) | R(FPREG) | R(TMP) | R(PP) | R(THR);
constexpr intptr_t kNumberOfReservedCpuRegisters = 5;
// CPU registers available to Dart allocator.
const RegList kDartAvailableCpuRegs =
@@ -354,6 +356,20 @@
kNumberOfCpuRegisters - kNumberOfReservedCpuRegisters;
constexpr int kStoreBufferWrapperSize = 13;
+#if defined(DART_TARGET_OS_WINDOWS)
+const RegList kAbiPreservedCpuRegs =
+ R(RBX) | R(RSI) | R(RDI) | R(R12) | R(R13) | R(R14) | R(R15);
+const RegList kAbiVolatileFpuRegs =
+ R(XMM0) | R(XMM1) | R(XMM2) | R(XMM3) | R(XMM4) | R(XMM5);
+#else
+const RegList kAbiPreservedCpuRegs = R(RBX) | R(R12) | R(R13) | R(R14) | R(R15);
+const RegList kAbiVolatileFpuRegs = kAllFpuRegistersList;
+#endif
+
+// Registers available to Dart that are not preserved by runtime calls.
+const RegList kDartVolatileCpuRegs =
+ kDartAvailableCpuRegs & ~kAbiPreservedCpuRegs;
+
enum ScaleFactor {
TIMES_1 = 0,
TIMES_2 = 1,
@@ -383,8 +399,6 @@
TIMES_COMPRESSED_HALF_WORD_SIZE = TIMES_COMPRESSED_WORD_SIZE - 1,
};
-#define R(reg) (static_cast<RegList>(1) << (reg))
-
class CallingConventions {
public:
#if defined(DART_TARGET_OS_WINDOWS)
@@ -422,11 +436,7 @@
static const intptr_t kVolatileCpuRegisters =
R(RAX) | R(RCX) | R(RDX) | R(R8) | R(R9) | R(R10) | R(R11);
- static const intptr_t kVolatileXmmRegisters =
- R(XMM0) | R(XMM1) | R(XMM2) | R(XMM3) | R(XMM4) | R(XMM5);
-
- static const intptr_t kCalleeSaveCpuRegisters =
- R(RBX) | R(RSI) | R(RDI) | R(R12) | R(R13) | R(R14) | R(R15);
+ static const RegList kVolatileXmmRegisters = kAbiVolatileFpuRegs;
static const intptr_t kCalleeSaveXmmRegisters =
R(XMM6) | R(XMM7) | R(XMM8) | R(XMM9) | R(XMM10) | R(XMM11) | R(XMM12) |
@@ -490,13 +500,7 @@
R(RSI) | R(RDI) | R(R8) |
R(R9) | R(R10) | R(R11);
- static const intptr_t kVolatileXmmRegisters =
- R(XMM0) | R(XMM1) | R(XMM2) | R(XMM3) | R(XMM4) | R(XMM5) | R(XMM6) |
- R(XMM7) | R(XMM8) | R(XMM9) | R(XMM10) | R(XMM11) | R(XMM12) | R(XMM13) |
- R(XMM14) | R(XMM15);
-
- static const intptr_t kCalleeSaveCpuRegisters =
- R(RBX) | R(R12) | R(R13) | R(R14) | R(R15);
+ static const RegList kVolatileXmmRegisters = kAbiVolatileFpuRegs;
static const intptr_t kCalleeSaveXmmRegisters = 0;
@@ -530,6 +534,8 @@
#endif
+ static const intptr_t kCalleeSaveCpuRegisters = kAbiPreservedCpuRegs;
+
COMPILE_ASSERT((kArgumentRegisters & kReservedCpuRegisters) == 0);
static constexpr Register kFfiAnyNonAbiRegister = R12;
@@ -544,9 +550,6 @@
(kArgumentRegisters | R(kPointerToReturnStructRegisterCall))) == 0);
};
-constexpr intptr_t kAbiPreservedCpuRegs =
- CallingConventions::kCalleeSaveCpuRegisters;
-
#undef R
class Instr {
diff --git a/runtime/vm/kernel_binary.h b/runtime/vm/kernel_binary.h
index ff0cfa2..0efa27f 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 = 76;
-static const uint32_t kMaxSupportedKernelFormatVersion = 76;
+static const uint32_t kMinSupportedKernelFormatVersion = 77;
+static const uint32_t kMaxSupportedKernelFormatVersion = 77;
// Keep in sync with package:kernel/lib/binary/tag.dart
#define KERNEL_TAG_LIST(V) \
diff --git a/runtime/vm/stack_trace.cc b/runtime/vm/stack_trace.cc
index 9b665c2..4c7cbcf 100644
--- a/runtime/vm/stack_trace.cc
+++ b/runtime/vm/stack_trace.cc
@@ -83,7 +83,8 @@
var_data_field(Field::Handle(zone)),
state_field(Field::Handle(zone)),
on_data_field(Field::Handle(zone)),
- state_data_field(Field::Handle(zone)) {
+ state_data_field(Field::Handle(zone)),
+ has_value_field(Field::Handle(zone)) {
const auto& async_lib = Library::Handle(zone, Library::AsyncLibrary());
// Look up classes:
// - async:
@@ -143,6 +144,9 @@
state_data_field =
stream_iterator_class.LookupFieldAllowPrivate(Symbols::_stateData());
ASSERT(!state_data_field.IsNull());
+ has_value_field =
+ stream_iterator_class.LookupFieldAllowPrivate(Symbols::_hasValue());
+ ASSERT(!has_value_field.IsNull());
}
ClosurePtr CallerClosureFinder::GetCallerInFutureImpl(const Object& future) {
@@ -201,9 +205,33 @@
// If the async* stream is await-for'd:
if (callback_instance_.GetClassId() == stream_iterator_class.id()) {
- // _StreamIterator._stateData
- future_ = Instance::Cast(callback_instance_).GetField(state_data_field);
- return GetCallerInFutureImpl(future_);
+ // If `_hasValue` is true then the `StreamIterator._stateData` field
+ // contains the iterator's value. In that case we cannot unwind anymore.
+ //
+ // Notice: With correct async* semantics this may never be true: The async*
+ // generator should only be invoked to produce a vaue if there's an
+ // in-progress `await streamIterator.moveNext()` call. Once such call has
+ // finished the async* generator should be paused/yielded until the next
+ // such call - and being paused/yielded means it should not appear in stack
+ // traces.
+ //
+ // See dartbug.com/48695.
+ const auto& stream_iterator = Instance::Cast(callback_instance_);
+ if (stream_iterator.GetField(has_value_field) ==
+ Object::bool_true().ptr()) {
+ return Closure::null();
+ }
+
+ // If we have an await'er for `await streamIterator.moveNext()` we continue
+ // unwinding there.
+ //
+ // Notice: With correct async* semantics this may always contain a Future
+ // See also comment above as well as dartbug.com/48695.
+ future_ = stream_iterator.GetField(state_data_field);
+ if (future_.GetClassId() == future_impl_class.id()) {
+ return GetCallerInFutureImpl(future_);
+ }
+ return Closure::null();
}
UNREACHABLE(); // If no onData is found we have a bug.
diff --git a/runtime/vm/stack_trace.h b/runtime/vm/stack_trace.h
index 566a0a8..0683cf7 100644
--- a/runtime/vm/stack_trace.h
+++ b/runtime/vm/stack_trace.h
@@ -92,6 +92,7 @@
Field& state_field;
Field& on_data_field;
Field& state_data_field;
+ Field& has_value_field;
DISALLOW_COPY_AND_ASSIGN(CallerClosureFinder);
};
diff --git a/runtime/vm/symbols.h b/runtime/vm/symbols.h
index ba78ad7..52ec048 100644
--- a/runtime/vm/symbols.h
+++ b/runtime/vm/symbols.h
@@ -414,6 +414,7 @@
V(_handleMessage, "_handleMessage") \
V(_handleFinalizerMessage, "_handleFinalizerMessage") \
V(_handleNativeFinalizerMessage, "_handleNativeFinalizerMessage") \
+ V(_hasValue, "_hasValue") \
V(_instanceOf, "_instanceOf") \
V(_listGetAt, "_listGetAt") \
V(_listLength, "_listLength") \
diff --git a/sdk/lib/_internal/wasm/lib/js_util_wasm_patch.dart b/sdk/lib/_internal/wasm/lib/js_util_wasm_patch.dart
new file mode 100644
index 0000000..f4e7512
--- /dev/null
+++ b/sdk/lib/_internal/wasm/lib/js_util_wasm_patch.dart
@@ -0,0 +1,31 @@
+// 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.
+
+library dart.js_util_wasm;
+
+import "dart:_internal";
+import "dart:js_util_wasm";
+import "dart:wasm";
+
+/// js_util_wasm methods used by the wasm runtime.
+@pragma("wasm:export", "\$listLength")
+double _listLength(List list) => list.length.toDouble();
+
+@pragma("wasm:export", "\$listRead")
+WasmAnyRef? _listRead(List<Object?> list, double index) =>
+ jsifyRaw(list[index.toInt()]);
+
+@pragma("wasm:export", "\$listAllocate")
+List<Object?> _listAllocate() => [];
+
+@pragma("wasm:export", "\$listAdd")
+void _listAdd(List<Object?> list, WasmAnyRef? item) =>
+ list.add(dartifyRaw(item));
+
+@patch
+Object _jsObjectToDartObject(WasmAnyRef ref) => unsafeCastOpaque<Object>(ref);
+
+@patch
+WasmAnyRef _jsObjectFromDartObject(Object object) =>
+ unsafeCastOpaque<WasmAnyRef>(object);
diff --git a/sdk/lib/async/stream_impl.dart b/sdk/lib/async/stream_impl.dart
index 3de0d58..42b6082 100644
--- a/sdk/lib/async/stream_impl.dart
+++ b/sdk/lib/async/stream_impl.dart
@@ -978,6 +978,7 @@
/// This will usually cause the [_subscription] to be paused, but as an
/// optimization, we only pause after the [moveNext] future has been
/// completed.
+ @pragma("vm:entry-point")
bool _hasValue = false;
_StreamIterator(final Stream<T> stream)
diff --git a/sdk/lib/js_util/js_util_sources.gni b/sdk/lib/js_util/js_util_sources.gni
index d3ac6d2..011df2e 100644
--- a/sdk/lib/js_util/js_util_sources.gni
+++ b/sdk/lib/js_util/js_util_sources.gni
@@ -2,4 +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.
-js_util_sdk_sources = [ "js_util.dart" ]
+js_util_sdk_sources = [
+ "js_util.dart",
+ "js_util_wasm.dart",
+]
diff --git a/sdk/lib/js_util/js_util_wasm.dart b/sdk/lib/js_util/js_util_wasm.dart
new file mode 100644
index 0000000..49b4a90
--- /dev/null
+++ b/sdk/lib/js_util/js_util_wasm.dart
@@ -0,0 +1,164 @@
+// 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.
+
+// Prototype js util library for wasm.
+library dart.js_util_wasm;
+
+import 'dart:wasm';
+
+/// [JSValue] is the root of the JS interop object hierarchy.
+class JSValue {
+ final WasmAnyRef _ref;
+
+ JSValue(this._ref);
+
+ static JSValue? box(WasmAnyRef? ref) => ref == null ? null : JSValue(ref);
+
+ WasmAnyRef toAnyRef() => _ref;
+ String toString() => _jsStringToDartString(_ref);
+ List<Object?> toObjectList() => _jsArrayToDartList(_ref);
+ Object toObject() => _jsObjectToDartObject(_ref);
+}
+
+/// Raw private JS functions.
+external WasmAnyRef _jsObjectFromDartObject(Object object);
+
+external Object _jsObjectToDartObject(WasmAnyRef ref);
+
+@pragma("wasm:import", "dart2wasm.arrayFromDartList")
+external WasmAnyRef _jsArrayFromDartList(List<Object?> list);
+
+@pragma("wasm:import", "dart2wasm.arrayToDartList")
+external List<Object?> _jsArrayToDartList(WasmAnyRef list);
+
+@pragma("wasm:import", "dart2wasm.stringFromDartString")
+external WasmAnyRef _jsStringFromDartString(String string);
+
+@pragma("wasm:import", "dart2wasm.stringToDartString")
+external String _jsStringToDartString(WasmAnyRef string);
+
+/// Raw public JS functions.
+/// These are public temporarily to give performance conscious users an escape
+/// hatch while we decide what this API will actually look like. They may
+/// become private in the future, or disappear entirely. For descriptions of the
+/// API, please see the corresponding non-raw functions.
+@pragma("wasm:import", "dart2wasm.eval")
+external void evalRaw(WasmAnyRef code);
+
+@pragma("wasm:import", "dart2wasm.dartify")
+external WasmAnyRef? dartifyRaw(WasmAnyRef? object);
+
+@pragma("wasm:import", "dart2wasm.newObject")
+external WasmAnyRef newObjectRaw();
+
+@pragma("wasm:import", "dart2wasm.globalThis")
+external WasmAnyRef globalThisRaw();
+
+@pragma("wasm:import", "dart2wasm.callConstructorVarArgs")
+external WasmAnyRef callConstructorVarArgsRaw(
+ WasmAnyRef o, WasmAnyRef name, WasmAnyRef args);
+
+@pragma("wasm:import", "dart2wasm.hasProperty")
+external bool hasPropertyRaw(WasmAnyRef o, WasmAnyRef name);
+
+@pragma("wasm:import", "dart2wasm.getProperty")
+external WasmAnyRef? getPropertyRaw(WasmAnyRef o, WasmAnyRef name);
+
+@pragma("wasm:import", "dart2wasm.setProperty")
+external WasmAnyRef? setPropertyRaw(
+ WasmAnyRef o, WasmAnyRef name, WasmAnyRef? value);
+
+@pragma("wasm:import", "dart2wasm.callMethodVarArgs")
+external WasmAnyRef? callMethodVarArgsRaw(
+ WasmAnyRef o, WasmAnyRef method, WasmAnyRef? args);
+
+WasmAnyRef? jsifyRaw(Object? object) {
+ if (object == null) {
+ return null;
+ } else if (object is JSValue) {
+ return object.toAnyRef();
+ } else if (object is String) {
+ return _jsStringFromDartString(object);
+ } else if (object is List<Object?>) {
+ return _jsArrayFromDartList(object);
+ } else {
+ return _jsObjectFromDartObject(object);
+ }
+}
+
+/// Conversion functions.
+/// TODO(joshualitt): Only a small set of types currently work:
+/// JS -> Dart:
+/// null
+/// strings
+/// arrays
+/// opaque Dart objects passed to JS
+/// Dart -> JS:
+/// null
+/// boolean
+/// doubles
+/// strings
+/// lists
+/// opaque JS objects passed to Dart
+/// In the future we would like to support more types, at least maps,
+/// and to fix some of the issues returning some types from JS.
+
+/// Extension methods for conversions.
+extension StringToJS on String {
+ JSValue toJS() => JSValue(_jsStringFromDartString(this));
+}
+
+extension ListOfObjectToJS on List<Object?> {
+ JSValue toJS() => JSValue(_jsArrayFromDartList(this));
+}
+
+extension ObjectToJS on Object {
+ JSValue toJS() => JSValue(_jsObjectFromDartObject(this));
+}
+
+/// Recursively converts objects from Dart to JS.
+JSValue? jsify(Object? object) => JSValue.box(jsifyRaw(object));
+
+/// Recursively converts objects from JS to Dart.
+Object? dartify(JSValue? object) => object == null
+ ? null
+ : _jsObjectToDartObject(dartifyRaw(object.toAnyRef())!);
+
+/// js util methods.
+/// These are low level calls into JS, and require care to use correctly.
+
+/// Evals a snippet of JS code in a Dart string.
+void eval(String code) => evalRaw(code.toJS().toAnyRef());
+
+/// Creates a new JS object literal and returns it.
+JSValue newObject() => JSValue(newObjectRaw());
+
+/// Returns a reference to `globalThis`.
+JSValue globalThis() => JSValue(globalThisRaw());
+
+/// Gets a [String] name property off of a JS object [o], invokes it as
+/// a constructor with a JS array of arguments [args], and returns the
+/// constructed JS object.
+JSValue callConstructorVarArgs(JSValue o, String name, List<JSValue?> args) =>
+ JSValue(callConstructorVarArgsRaw(
+ o.toAnyRef(), name.toJS().toAnyRef(), args.toJS().toAnyRef()));
+
+/// Checks for a [String] name on a JS object [o].
+bool hasProperty(JSValue o, String name) =>
+ hasPropertyRaw(o.toAnyRef(), name.toJS().toAnyRef());
+
+/// Gets a JS property with [String] name off of a JS object [o].
+JSValue? getProperty(JSValue o, String name) =>
+ JSValue.box(getPropertyRaw(o.toAnyRef(), name.toJS().toAnyRef()));
+
+/// Sets a JS property with [String] name on JS object [o] to the JS value
+/// [value], then returns [value].
+JSValue? setProperty(JSValue o, String name, JSValue? value) => JSValue.box(
+ setPropertyRaw(o.toAnyRef(), name.toJS().toAnyRef(), value?.toAnyRef()));
+
+/// Calls a JS method with a [String] name on JS object [o] with a JS array
+/// of arguments [args] and returns the resulting JS value.
+JSValue? callMethodVarArgs(JSValue o, String method, List<JSValue?> args) =>
+ JSValue.box(callMethodVarArgsRaw(
+ o.toAnyRef(), method.toJS().toAnyRef(), args.toJS().toAnyRef()));
diff --git a/sdk/lib/libraries.json b/sdk/lib/libraries.json
index dae53f7..212955e 100644
--- a/sdk/lib/libraries.json
+++ b/sdk/lib/libraries.json
@@ -232,6 +232,10 @@
"isolate": {
"uri": "isolate/isolate.dart"
},
+ "js_util_wasm": {
+ "uri": "js_util/js_util_wasm.dart",
+ "patches": "_internal/wasm/lib/js_util_wasm_patch.dart"
+ },
"math": {
"uri": "math/math.dart",
"patches": "_internal/wasm/lib/math_patch.dart"
diff --git a/sdk/lib/libraries.yaml b/sdk/lib/libraries.yaml
index ca10300..e0a8e42 100644
--- a/sdk/lib/libraries.yaml
+++ b/sdk/lib/libraries.yaml
@@ -216,6 +216,9 @@
uri: "html/dartium/nativewrappers.dart"
isolate:
uri: isolate/isolate.dart
+ js_util_wasm:
+ uri: js_util/js_util_wasm.dart
+ patches: _internal/wasm/lib/js_util_wasm_patch.dart
math:
uri: math/math.dart
patches: _internal/wasm/lib/math_patch.dart
diff --git a/tests/web/wasm/js_util_test.dart b/tests/web/wasm/js_util_test.dart
new file mode 100644
index 0000000..a5b31c1
--- /dev/null
+++ b/tests/web/wasm/js_util_test.dart
@@ -0,0 +1,85 @@
+// 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 'dart:js_util_wasm';
+
+import 'package:expect/expect.dart';
+
+void createObjectTest() {
+ JSValue o = newObject();
+ Expect.isFalse(hasProperty(o, 'foo'));
+ Expect.equals('bar', setProperty(o, 'foo', 'bar'.toJS()).toString());
+ Expect.isTrue(hasProperty(o, 'foo'));
+ Expect.equals('bar', getProperty(o, 'foo').toString());
+}
+
+// Unfortunately, lists do not currently compare identically.
+void _expectListEquals(List<Object?> l, List<Object?> r) {
+ Expect.equals(l.length, r.length);
+ for (int i = 0; i < l.length; i++) {
+ Expect.equals(l[i], r[i]);
+ }
+}
+
+void evalAndConstructTest() {
+ eval(r'''
+ function JSClass(c) {
+ this.c = c;
+ this.sum = (a, b) => {
+ return a + b + this.c;
+ }
+ this.list = ['a', 'b', 'c'];
+ }
+ globalThis.JSClass = JSClass;
+ ''');
+ JSValue gt = globalThis();
+ JSValue jsClass = callConstructorVarArgs(gt, 'JSClass', ['world!'.toJS()]);
+ Expect.equals(
+ 'hello world!',
+ callMethodVarArgs(jsClass, 'sum', ['hello'.toJS(), ' '.toJS()])
+ .toString());
+ _expectListEquals(
+ ['a', 'b', 'c'], getProperty(jsClass, 'list')!.toObjectList());
+}
+
+class Foo {
+ final int i;
+ Foo(this.i);
+}
+
+void dartObjectRoundTripTest() {
+ JSValue o = newObject();
+ setProperty(o, 'foo', Foo(4).toJS());
+ Object foo = getProperty(o, 'foo')!.toObject();
+ Expect.equals(4, (foo as Foo).i);
+}
+
+void deepConversionsTest() {
+ // Dart to JS.
+ Expect.isNull(dartify(jsify(null)));
+ Expect.equals(true, dartify(jsify(true)));
+ Expect.equals(2.0, dartify(jsify(2.0)));
+ Expect.equals('foo', dartify(jsify('foo')));
+ _expectListEquals(
+ ['a', 'b', 'c'], dartify(jsify(['a', 'b', 'c'])) as List<Object?>);
+
+ // JS to Dart.
+ eval(r'''
+ globalThis.a = null;
+ globalThis.b = 'foo';
+ globalThis.c = ['a', 'b', 'c'];
+ ''');
+ JSValue gt = globalThis();
+ Expect.isNull(dartify(getProperty(gt, 'a')));
+ Expect.equals('foo', dartify(getProperty(gt, 'b')));
+ _expectListEquals(
+ ['a', 'b', 'c'], dartify(getProperty(gt, 'c')) as List<Object?>);
+}
+
+void main() {
+ createObjectTest();
+ evalAndConstructTest();
+ dartObjectRoundTripTest();
+ deepConversionsTest();
+}
diff --git a/tests/web/web.status b/tests/web/web.status
index c54cd80..d20e136 100644
--- a/tests/web/web.status
+++ b/tests/web/web.status
@@ -5,6 +5,9 @@
[ $compiler != dart2js ]
dummy_compiler_test: SkipByDesign # Issue 30773. Test should be migrated as a unit test of dart2js, is only intended to test self-hosting.
+[ $compiler != dart2wasm ]
+wasm/*: SkipByDesign
+
[ $runtime == jsshell ]
deferred/load_in_correct_order_test: SkipByDesign # jsshell preamble does not support this test.
diff --git a/tools/VERSION b/tools/VERSION
index 3bced45..7b9e5d4 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 17
PATCH 0
-PRERELEASE 255
+PRERELEASE 256
PRERELEASE_PATCH 0
\ No newline at end of file
diff --git a/tools/bots/test_matrix.json b/tools/bots/test_matrix.json
index cf5a954..4f67da1 100644
--- a/tools/bots/test_matrix.json
+++ b/tools/bots/test_matrix.json
@@ -2969,7 +2969,8 @@
"arguments": [
"-ndart2wasm-hostasserts-linux-x64-d8",
"language",
- "corelib"
+ "corelib",
+ "web/wasm"
],
"shards": 30,
"fileset": "dart2wasm_hostasserts"
diff --git a/tools/manage_deps.dart b/tools/manage_deps.dart
index f954327..80b1b56 100755
--- a/tools/manage_deps.dart
+++ b/tools/manage_deps.dart
@@ -231,6 +231,7 @@
cmd[0],
cmd.skip(1).toList(),
workingDirectory: workingDirectory,
+ environment: {'DEPOT_TOOLS_UPDATE': '0'},
);
printSuccessTrailer(result, onFailure);
final output = (result.stdout as String);
