Jens Johansen
37d14ad2ce
We're deprecating kernels Library.isExternal as it wasn't used for
what it was originally intended. It will hopefully go away entirely
soon.
This reverts commit 689447d0fb and fixes
the reason for the revert.
Change-Id: I122b5b777a2bf7316fde48e034fa3c566458a0cc
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/124133
Reviewed-by: Johnni Winther <johnniwinther@google.com>
Commit-Queue: Jens Johansen <jensj@google.com>
647 lines
20 KiB
Dart
647 lines
20 KiB
Dart
// Copyright (c) 2018, 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 'dart:io';
|
|
import 'package:front_end/src/api_unstable/ddc.dart' as fe;
|
|
import 'package:kernel/core_types.dart';
|
|
import 'package:kernel/kernel.dart';
|
|
import 'package:kernel/class_hierarchy.dart';
|
|
import 'package:kernel/target/targets.dart';
|
|
import 'package:test/test.dart';
|
|
|
|
import 'package:dev_compiler/src/kernel/command.dart';
|
|
import 'package:dev_compiler/src/kernel/nullable_inference.dart';
|
|
import 'package:dev_compiler/src/kernel/js_typerep.dart';
|
|
import 'package:dev_compiler/src/kernel/target.dart';
|
|
|
|
void main() {
|
|
test('empty main', () async {
|
|
await expectNotNull('main() {}', '');
|
|
});
|
|
|
|
group('literal', () {
|
|
test('null', () async {
|
|
await expectNotNull('main() { print(null); }', '');
|
|
});
|
|
test('bool', () async {
|
|
await expectNotNull('main() { print(false); }', 'false');
|
|
});
|
|
test('int', () async {
|
|
await expectNotNull('main() { print(42); }', '42');
|
|
});
|
|
test('double', () async {
|
|
await expectNotNull('main() { print(123.0); }', '123.0');
|
|
});
|
|
test('String', () async {
|
|
await expectNotNull('main() { print("hi"); }', '"hi"');
|
|
});
|
|
test('List', () async {
|
|
await expectNotNull(
|
|
'main() { print([42, null]); }', '<dart.core::int*>[42, null], 42');
|
|
});
|
|
test('Map', () async {
|
|
await expectNotNull('main() { print({"x": null}); }',
|
|
'<dart.core::String*, dart.core::Null?>{"x": null}, "x"');
|
|
});
|
|
|
|
test('Symbol', () async {
|
|
await expectNotNull('main() { print(#hi); }', '#hi');
|
|
});
|
|
|
|
test('Type', () async {
|
|
await expectNotNull('main() { print(Object); }', 'dart.core::Object*');
|
|
});
|
|
});
|
|
|
|
test('this', () async {
|
|
await expectNotNull('class C { m() { return this; } }', 'this');
|
|
});
|
|
|
|
test('is', () async {
|
|
await expectNotNull('main() { 42 is int; null is int; }',
|
|
'42 is dart.core::int*, 42, null is dart.core::int*');
|
|
});
|
|
|
|
test('as', () async {
|
|
await expectNotNull(
|
|
'main() { 42 as int; null as int; }', '42 as dart.core::int*, 42');
|
|
});
|
|
|
|
test('constructor', () async {
|
|
await expectNotNull(
|
|
'library a; class C {} main() { new C(); }', 'new a::C::•()');
|
|
});
|
|
|
|
group('operator', () {
|
|
test('==', () async {
|
|
// This is not a correct non-null assumption when user-defined operators,
|
|
// are present, see: https://github.com/dart-lang/sdk/issues/31854
|
|
await expectAllNotNull('main() { 1 == 1; }');
|
|
});
|
|
test('!', () async {
|
|
await expectAllNotNull('main() { !false; }');
|
|
});
|
|
test('!=', () async {
|
|
await expectAllNotNull('main() { 1 != 2; }');
|
|
});
|
|
test('&&', () async {
|
|
await expectAllNotNull('main() { true && true; }');
|
|
});
|
|
test('||', () async {
|
|
await expectAllNotNull('main() { true || true; }');
|
|
});
|
|
test('? :', () async {
|
|
await expectAllNotNull('main() { true ? true : false; }');
|
|
});
|
|
});
|
|
|
|
test('bool', () async {
|
|
await expectAllNotNull('main() { true.toString(); false.hashCode; }');
|
|
});
|
|
|
|
group('int', () {
|
|
test('arithmetic', () async {
|
|
await expectAllNotNull(
|
|
'main() { -0; 1 + 2; 3 - 4; 5 * 6; 7 / 8; 9 % 10; 11 ~/ 12; }');
|
|
});
|
|
test('bitwise', () async {
|
|
await expectAllNotNull(
|
|
'main() { 1 & 2; 3 | 4; 5 ^ 6; ~7; 8 << 9; 10 >> 11; }');
|
|
});
|
|
test('comparison', () async {
|
|
await expectAllNotNull('main() { 1 < 2; 3 > 4; 5 <= 6; 7 >= 8; }');
|
|
});
|
|
test('getters', () async {
|
|
await expectAllNotNull(
|
|
'main() { 1.isOdd; 1.isEven; 1.isNegative; 1.isNaN; 1.isInfinite; '
|
|
'1.isFinite; 1.sign; 1.bitLength; 1.hashCode; }');
|
|
});
|
|
test('methods', () async {
|
|
await expectAllNotNull(
|
|
'main() { 1.compareTo(2); 1.remainder(2); 1.abs(); 1.toInt(); '
|
|
'1.ceil(); 1.floor(); 1.truncate(); 1.round(); 1.ceilToDouble(); '
|
|
'1.floorToDouble(); 1.truncateToDouble(); 1.roundToDouble(); '
|
|
'1.toDouble(); 1.clamp(2, 2); 1.toStringAsFixed(2); '
|
|
'1.toStringAsExponential(); 1.toStringAsPrecision(2); 1.toString(); '
|
|
'1.toRadixString(2); 1.toUnsigned(2); 1.toSigned(2); 1.modPow(2, 2); '
|
|
'1.modInverse(2); 1.gcd(2); }');
|
|
});
|
|
});
|
|
|
|
group('double', () {
|
|
test('arithmetic', () async {
|
|
await expectAllNotNull(
|
|
'main() { -0.0; 1.0 + 2.0; 3.0 - 4.0; 5.0 * 6.0; 7.0 / 8.0; '
|
|
'9.0 % 10.0; 11.0 ~/ 12.0; }');
|
|
});
|
|
test('comparison', () async {
|
|
await expectAllNotNull(
|
|
'main() { 1.0 < 2.0; 3.0 > 4.0; 5.0 <= 6.0; 7.0 >= 8.0; }');
|
|
});
|
|
test('getters', () async {
|
|
await expectAllNotNull(
|
|
'main() { (1.0).isNegative; (1.0).isNaN; (1.0).isInfinite; '
|
|
'(1.0).isFinite; (1.0).sign; (1.0).hashCode; }');
|
|
});
|
|
test('methods', () async {
|
|
await expectAllNotNull(
|
|
'main() { (1.0).compareTo(2.0); (1.0).remainder(2.0); (1.0).abs(); '
|
|
'(1.0).toInt(); (1.0).ceil(); (1.0).floor(); (1.0).truncate(); '
|
|
'(1.0).round(); (1.0).ceilToDouble(); (1.0).floorToDouble(); '
|
|
'(1.0).truncateToDouble(); (1.0).roundToDouble(); (1.0).toDouble(); '
|
|
'(1.0).clamp(2.0, 2.0); (1.0).toStringAsFixed(2); (1.0).toString(); '
|
|
'(1.0).toStringAsExponential(); (1.0).toStringAsPrecision(2); }');
|
|
});
|
|
});
|
|
|
|
group('num', () {
|
|
test('arithmetic', () async {
|
|
await expectAllNotNull(
|
|
'main() { num n = 1; -n; n + n; n - n; n * n; n / n; n % n; n % n; '
|
|
'n ~/ n; }');
|
|
});
|
|
test('comparison', () async {
|
|
await expectAllNotNull(
|
|
'main() { num n = 1; n < n; n > n; n <= n; n >= n; }');
|
|
});
|
|
test('getters', () async {
|
|
await expectAllNotNull(
|
|
'main() { num n = 1; n.isNegative; n.isNaN; n.isInfinite; '
|
|
'n.isFinite; n.sign; n.hashCode; }');
|
|
});
|
|
test('methods', () async {
|
|
await expectAllNotNull(
|
|
'main() { num n = 1; n.compareTo(n); n.remainder(n); n.abs(); '
|
|
'n.toInt(); n.ceil(); n.floor(); n.truncate(); '
|
|
'n.round(); n.ceilToDouble(); n.floorToDouble(); '
|
|
'n.truncateToDouble(); n.roundToDouble(); n.toDouble(); '
|
|
'n.clamp(n, n); n.toStringAsFixed(n); n.toString(); '
|
|
'n.toStringAsExponential(); n.toStringAsPrecision(n); }');
|
|
});
|
|
});
|
|
|
|
group('String', () {
|
|
test('concatenation', () async {
|
|
await expectAllNotNull('main() { "1" "2"; }');
|
|
});
|
|
test('interpolation', () async {
|
|
await expectAllNotNull('main() { "1${2}"; }');
|
|
});
|
|
test('getters', () async {
|
|
await expectAllNotNull(
|
|
'main() { "".codeUnits; "".hashCode; "".isEmpty; "".isNotEmpty; '
|
|
'"".length; "".runes; }');
|
|
});
|
|
test('operators', () async {
|
|
await expectAllNotNull('main() { "" + ""; "" * 2; "" == ""; "x"[0]; }');
|
|
});
|
|
test('methods', () async {
|
|
await expectAllNotNull('''main() {
|
|
String s = '';
|
|
s.codeUnitAt(0);
|
|
s.contains(s);
|
|
s.endsWith(s);
|
|
s.indexOf(s);
|
|
s.lastIndexOf(s);
|
|
s.padLeft(1);
|
|
s.padRight(1);
|
|
s.replaceAll(s, s);
|
|
s.replaceAllMapped(s, (_) => s);
|
|
s.replaceFirst(s, s);
|
|
s.replaceFirstMapped(s, (_) => s);
|
|
s.replaceRange(1, 2, s);
|
|
s.split(s);
|
|
s.splitMapJoin(s, onMatch: (_) => s, onNonMatch: (_) => s);
|
|
s.startsWith(s);
|
|
s.substring(1);
|
|
s.toLowerCase();
|
|
s.toUpperCase();
|
|
s.trim();
|
|
s.trimLeft();
|
|
s.trimRight();
|
|
|
|
// compareTo relies on the interface target being String.compareTo
|
|
// except that method does not exist unless we insert too many
|
|
// forwarding stubs.
|
|
//
|
|
// s.compareTo(s);
|
|
|
|
s.toString();
|
|
// Pattern methods (allMatches, matchAsPrefix) are not recognized.
|
|
}''');
|
|
});
|
|
});
|
|
|
|
test('identical', () async {
|
|
await expectNotNull('main() { identical(null, null); }',
|
|
'dart.core::identical(null, null)');
|
|
});
|
|
|
|
test('throw', () async {
|
|
await expectNotNull('main() { print(throw null); }', 'throw null');
|
|
});
|
|
|
|
test('rethrow', () async {
|
|
await expectNotNull('main() { try {} catch (e) { rethrow; } }', 'rethrow');
|
|
});
|
|
|
|
test('function expression', () async {
|
|
await expectNotNull('main() { () => null; f() {}; f; }',
|
|
'() → dart.core::Null? => null, f');
|
|
});
|
|
|
|
test('cascades (kernel let)', () async {
|
|
// `null..toString()` evaluates to `null` so it is nullable.
|
|
await expectNotNull('main() { null..toString(); }', '');
|
|
await expectAllNotNull('main() { 1..toString(); }');
|
|
});
|
|
|
|
group('variable', () {
|
|
test('declaration not-null', () async {
|
|
await expectNotNull('main() { var x = 42; print(x); }', '42, x');
|
|
});
|
|
test('declaration null', () async {
|
|
await expectNotNull('main() { var x = null; print(x); }', '');
|
|
});
|
|
test('declaration without initializer', () async {
|
|
await expectNotNull('main() { var x; x = 1; print(x); }', 'x = 1, 1');
|
|
});
|
|
test('assignment non-null', () async {
|
|
await expectNotNull(
|
|
'main() { var x = 42; x = 1; print(x); }', '42, x = 1, 1, x');
|
|
});
|
|
test('assignment null', () async {
|
|
await expectNotNull('main() { var x = 42; x = null; print(x); }', '42');
|
|
});
|
|
test('flow insensitive', () async {
|
|
await expectNotNull('''main() {
|
|
var x = 1;
|
|
if (true) {
|
|
print(x);
|
|
} else {
|
|
x = null;
|
|
print(x);
|
|
}
|
|
}''', '1, true');
|
|
});
|
|
|
|
test('declaration from variable', () async {
|
|
await expectNotNull('''main() {
|
|
var x = 1;
|
|
var y = x;
|
|
print(y);
|
|
x = null;
|
|
}''', '1');
|
|
});
|
|
test('declaration from variable nested', () async {
|
|
await expectNotNull('''main() {
|
|
var x = 1;
|
|
var y = (x = null) == null;
|
|
print(x);
|
|
print(y);
|
|
}''', '1, (x = null).{dart.core::Object::==}(null), y');
|
|
});
|
|
test('declaration from variable transitive', () async {
|
|
await expectNotNull('''main() {
|
|
var x = 1;
|
|
var y = x;
|
|
var z = y;
|
|
print(z);
|
|
x = null;
|
|
}''', '1');
|
|
});
|
|
test('declaration between variable transitive nested', () async {
|
|
await expectNotNull('''main() {
|
|
var x = 1;
|
|
var y = 1;
|
|
var z = y = x;
|
|
print(z);
|
|
x = null;
|
|
}''', '1, 1');
|
|
});
|
|
|
|
test('for not-null', () async {
|
|
await expectAllNotNull('''main() {
|
|
for (var i = 0; i < 10; i++) {
|
|
i;
|
|
}
|
|
}''');
|
|
});
|
|
test('for nullable', () async {
|
|
await expectNotNull(
|
|
'''main() {
|
|
for (var i = 0; i < 10; i++) {
|
|
if (i >= 10) i = null;
|
|
}
|
|
}''',
|
|
// arithmetic operation results on `i` are themselves not null, even
|
|
// though `i` is nullable.
|
|
'0, i.{dart.core::num::<}(10), 10, i = i.{dart.core::num::+}(1), '
|
|
'i.{dart.core::num::+}(1), 1, i.{dart.core::num::>=}(10), 10');
|
|
});
|
|
test('for-in', () async {
|
|
await expectNotNull('''main() {
|
|
for (var i in []) {
|
|
print(i);
|
|
}
|
|
}''', '<dynamic>[]');
|
|
});
|
|
|
|
test('inner functions', () async {
|
|
await expectNotNull('''main() {
|
|
var y = 0;
|
|
f(x) {
|
|
var g = () => print('g');
|
|
g();
|
|
print(x);
|
|
print(y);
|
|
var z = 1;
|
|
print(z);
|
|
}
|
|
f(42);
|
|
}''', '0, () → void => dart.core::print("g"), "g", g, y, 1, z, f, 42');
|
|
});
|
|
test('assignment to closure variable', () async {
|
|
await expectNotNull('''main() {
|
|
var y = 0;
|
|
f(x) {
|
|
y = x;
|
|
}
|
|
f(42);
|
|
print(y);
|
|
}''', '0, f, 42');
|
|
});
|
|
|
|
test('declaration visits initializer', () async {
|
|
await expectAllNotNull('''main() {
|
|
var x = () { var y = 1; return y; };
|
|
x;
|
|
}''');
|
|
});
|
|
test('assignment visits value', () async {
|
|
await expectAllNotNull('''main() {
|
|
var x = () => 42;
|
|
x = () { var y = 1; return y; };
|
|
}''');
|
|
});
|
|
test('assignment visits value with closure variable set', () async {
|
|
await expectNotNull('''main() {
|
|
var x = () => 42;
|
|
var y = (() => x = null);
|
|
}''',
|
|
'() → dart.core::int* => 42, 42, () → dart.core::Null? => x = null');
|
|
});
|
|
test('do not depend on unrelated variables', () async {
|
|
await expectNotNull('''main() {
|
|
var x;
|
|
var y = identical(x, null);
|
|
y; // this is still non-null even though `x` is nullable
|
|
}''', 'dart.core::identical(x, null), y');
|
|
});
|
|
test('do not depend on unrelated variables updated later', () async {
|
|
await expectNotNull('''main() {
|
|
var x = 1;
|
|
var y = identical(x, 1);
|
|
x = null;
|
|
y; // this is still non-null even though `x` is nullable
|
|
}''', '1, dart.core::identical(x, 1), 1, y');
|
|
});
|
|
});
|
|
group('functions parameters in SDK', () {
|
|
setUp(() {
|
|
// Using annotations here to test how the parameter is detected when
|
|
// compiling functions from the SDK.
|
|
// A regression test for: https://github.com/dart-lang/sdk/issues/37700
|
|
useAnnotations = true;
|
|
});
|
|
tearDown(() {
|
|
useAnnotations = false;
|
|
});
|
|
test('optional with default value', () async {
|
|
await expectNotNull('''
|
|
f(x, [y = 1]) { x; y; }
|
|
''', '1');
|
|
});
|
|
test('named with default value', () async {
|
|
await expectNotNull('''
|
|
f(x, {y = 1}) { x; y; }
|
|
''', '1');
|
|
});
|
|
});
|
|
|
|
group('notNull', () {
|
|
setUp(() {
|
|
useAnnotations = true;
|
|
});
|
|
tearDown(() {
|
|
useAnnotations = false;
|
|
});
|
|
var imports = "import 'package:meta/meta.dart';";
|
|
group('(previously known kernel annotation bug)', () {
|
|
test('variable without initializer', () async {
|
|
await expectNotNull(
|
|
'$imports main() { @notNull var x; print(x); }', 'x');
|
|
});
|
|
test('variable with initializer', () async {
|
|
// TODO(jmesserly): this does not work in the Analyzer backend.
|
|
await expectNotNull(
|
|
'$imports main() { @notNull var x = null; print(x); }', 'x');
|
|
});
|
|
test('parameters', () async {
|
|
await expectNotNull(
|
|
'$imports f(@notNull x, [@notNull y, @notNull z = 42]) '
|
|
'{ x; y; z; }',
|
|
'42, x, y, z');
|
|
});
|
|
test('named parameters', () async {
|
|
await expectNotNull(
|
|
'$imports f({@notNull x, @notNull y: 42}) { x; y; }', '42, x, y');
|
|
});
|
|
});
|
|
|
|
test('top-level field', () async {
|
|
await expectNotNull(
|
|
'library a; $imports @notNull int x; main() { x; }', 'a::x');
|
|
});
|
|
|
|
test('getter', () async {
|
|
await expectNotNull(
|
|
'library b; $imports @notNull get x => null; main() { x; }', 'b::x');
|
|
});
|
|
|
|
test('function', () async {
|
|
await expectNotNull(
|
|
'library a; $imports @notNull f() {} main() { f(); }', 'a::f()');
|
|
});
|
|
|
|
test('method', () async {
|
|
await expectNotNull(
|
|
'library b; $imports class C { @notNull m() {} } '
|
|
'main() { var c = new C(); c.m(); }',
|
|
'new b::C::•(), c.{b::C::m}(), c');
|
|
});
|
|
});
|
|
}
|
|
|
|
/// Given the Dart [code], expects the [expectedNotNull] kernel expression list
|
|
/// to be produced in the set of expressions that cannot be null by DDC's null
|
|
/// inference.
|
|
Future expectNotNull(String code, String expectedNotNull) async {
|
|
var result = await kernelCompile(code);
|
|
var collector = NotNullCollector(result.librariesFromDill);
|
|
result.component.accept(collector);
|
|
var actualNotNull = collector.notNullExpressions
|
|
// ConstantExpressions print the table offset - we want to compare
|
|
// against the underlying constant value instead.
|
|
.map((e) {
|
|
if (e is ConstantExpression) {
|
|
Constant c = e.constant;
|
|
if (c is DoubleConstant &&
|
|
c.value.isFinite &&
|
|
c.value.truncateToDouble() == c.value) {
|
|
// Print integer values as integers
|
|
return BigInt.from(c.value).toString();
|
|
}
|
|
return c.toString();
|
|
}
|
|
return e.toString();
|
|
})
|
|
// Filter out our own NotNull annotations. The library prefix changes
|
|
// per test, so just filter on the suffix.
|
|
.where((s) => !s.endsWith('::_NotNull {}'))
|
|
.join(', ');
|
|
expect(actualNotNull, equals(expectedNotNull));
|
|
}
|
|
|
|
/// Given the Dart [code], expects all the expressions inferred to be not-null.
|
|
Future expectAllNotNull(String code) async {
|
|
var result = (await kernelCompile(code));
|
|
result.component.accept(ExpectAllNotNull(result.librariesFromDill));
|
|
}
|
|
|
|
bool useAnnotations = false;
|
|
NullableInference inference;
|
|
|
|
class _TestRecursiveVisitor extends RecursiveVisitor<void> {
|
|
final Set<Library> librariesFromDill;
|
|
int _functionNesting = 0;
|
|
|
|
_TestRecursiveVisitor(this.librariesFromDill);
|
|
|
|
@override
|
|
visitComponent(Component node) {
|
|
var hierarchy = ClassHierarchy(node);
|
|
inference ??= NullableInference(JSTypeRep(
|
|
fe.TypeSchemaEnvironment(CoreTypes(node), hierarchy),
|
|
hierarchy,
|
|
));
|
|
|
|
if (useAnnotations) {
|
|
inference.allowNotNullDeclarations = useAnnotations;
|
|
inference.allowPackageMetaAnnotations = useAnnotations;
|
|
}
|
|
super.visitComponent(node);
|
|
}
|
|
|
|
@override
|
|
visitLibrary(Library node) {
|
|
if (librariesFromDill.contains(node) ||
|
|
node.importUri.scheme == 'package' &&
|
|
node.importUri.pathSegments[0] == 'meta') {
|
|
return;
|
|
}
|
|
super.visitLibrary(node);
|
|
}
|
|
|
|
@override
|
|
visitFunctionNode(FunctionNode node) {
|
|
_functionNesting++;
|
|
if (_functionNesting == 1) inference.enterFunction(node);
|
|
super.visitFunctionNode(node);
|
|
if (_functionNesting == 1) inference.exitFunction(node);
|
|
_functionNesting--;
|
|
}
|
|
}
|
|
|
|
class NotNullCollector extends _TestRecursiveVisitor {
|
|
final notNullExpressions = <Expression>[];
|
|
|
|
NotNullCollector(Set<Library> librariesFromDill) : super(librariesFromDill);
|
|
|
|
@override
|
|
defaultExpression(Expression node) {
|
|
if (!inference.isNullable(node)) {
|
|
notNullExpressions.add(node);
|
|
}
|
|
super.defaultExpression(node);
|
|
}
|
|
}
|
|
|
|
class ExpectAllNotNull extends _TestRecursiveVisitor {
|
|
ExpectAllNotNull(Set<Library> librariesFromDill) : super(librariesFromDill);
|
|
|
|
@override
|
|
defaultExpression(Expression node) {
|
|
expect(inference.isNullable(node), false,
|
|
reason: 'expression `$node` should be inferred as not-null');
|
|
super.defaultExpression(node);
|
|
}
|
|
}
|
|
|
|
fe.InitializedCompilerState _compilerState;
|
|
final _fileSystem = fe.MemoryFileSystem(Uri.file('/memory/'));
|
|
|
|
class CompileResult {
|
|
final Component component;
|
|
final Set<Library> librariesFromDill;
|
|
|
|
CompileResult(this.component, this.librariesFromDill);
|
|
}
|
|
|
|
Future<CompileResult> kernelCompile(String code) async {
|
|
var succeeded = true;
|
|
void diagnosticMessageHandler(fe.DiagnosticMessage message) {
|
|
if (message.severity == fe.Severity.error) {
|
|
succeeded = false;
|
|
}
|
|
fe.printDiagnosticMessage(message, print);
|
|
}
|
|
|
|
var sdkUri = Uri.file('/memory/dart_sdk.dill');
|
|
var sdkFile = _fileSystem.entityForUri(sdkUri);
|
|
if (!await sdkFile.exists()) {
|
|
sdkFile.writeAsBytesSync(File(defaultSdkSummaryPath).readAsBytesSync());
|
|
}
|
|
var packagesUri = Uri.file('/memory/.packages');
|
|
var packagesFile = _fileSystem.entityForUri(packagesUri);
|
|
if (!await packagesFile.exists()) {
|
|
packagesFile.writeAsStringSync('meta:/memory/meta/lib');
|
|
_fileSystem
|
|
.entityForUri(Uri.file('/memory/meta/lib/meta.dart'))
|
|
.writeAsStringSync('''
|
|
class _NotNull { const _NotNull(); }
|
|
const notNull = const _NotNull();
|
|
class _NullCheck { const _NullCheck(); }
|
|
const nullCheck = const _NullCheck();
|
|
''');
|
|
}
|
|
|
|
var mainUri = Uri.file('/memory/test.dart');
|
|
_fileSystem.entityForUri(mainUri).writeAsStringSync(code);
|
|
var oldCompilerState = _compilerState;
|
|
_compilerState = await fe.initializeCompiler(oldCompilerState, false, null,
|
|
sdkUri, packagesUri, null, [], DevCompilerTarget(TargetFlags()),
|
|
fileSystem: _fileSystem,
|
|
experiments: const {},
|
|
environmentDefines: const {});
|
|
if (!identical(oldCompilerState, _compilerState)) inference = null;
|
|
fe.DdcResult result =
|
|
await fe.compile(_compilerState, [mainUri], diagnosticMessageHandler);
|
|
expect(succeeded, true);
|
|
|
|
Set<Library> librariesFromDill = result.computeLibrariesFromDill();
|
|
return CompileResult(result.component, librariesFromDill);
|
|
}
|