Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1763)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: pkg/analyzer/test/src/summary/resynthesize_common.dart

Issue 2728883004: Verify resynthesized elements by comparing text presentations. (Closed)
Patch Set: Created 3 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« pkg/analyzer/test/src/summary/resynthesize_ast_test.dart ('K') | « pkg/analyzer/test/src/summary/resynthesize_ast_test.dart ('k') | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: pkg/analyzer/test/src/summary/resynthesize_common.dart
diff --git a/pkg/analyzer/test/src/summary/resynthesize_common.dart b/pkg/analyzer/test/src/summary/resynthesize_common.dart
index 51b77eda797836a473c0b9c629bb8e00ca19b1a3..199e827caaf8c4b5615605f7b8f67ecc7d0e1407 100644
--- a/pkg/analyzer/test/src/summary/resynthesize_common.dart
+++ b/pkg/analyzer/test/src/summary/resynthesize_common.dart
@@ -29,6 +29,7 @@ import 'package:test_reflective_loader/test_reflective_loader.dart';
import '../../generated/test_support.dart';
import '../abstract_single_unit.dart';
import '../context/abstract_context.dart';
+import 'element_text.dart';
/**
* Abstract base class for resynthesizing and comparing elements.
@@ -53,6 +54,11 @@ abstract class AbstractResynthesizeTest extends AbstractSingleUnitTest {
*/
bool allowMissingFiles = false;
+ /**
+ * Return `true` if resynthesizing should be done is strong mode.
+ */
+ bool get isStrongMode;
+
void addLibrary(String uri) {
otherLibrarySources.add(context.sourceFactory.forUri(uri));
}
@@ -1317,23 +1323,105 @@ abstract class ResynthesizeTest extends AbstractResynthesizeTest {
SummaryResynthesizer encodeDecodeLibrarySource(Source librarySource);
fail_library_hasExtUri() {
Brian Wilkerson 2017/03/03 16:09:33 We might want to break this file up into smaller p
- checkLibrary('import "dart-ext:doesNotExist.dart";');
+ var library = checkLibrary('import "dart-ext:doesNotExist.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+''');
+ }
}
test_class_abstract() {
- checkLibrary('abstract class C {}');
+ var library = checkLibrary('abstract class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+}
+''');
+ }
}
test_class_alias() {
- checkLibrary('class C = D with E, F; class D {} class E {} class F {}');
+ var library =
+ checkLibrary('class C = D with E, F; class D {} class E {} class F {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D with E, F {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+class F {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D with E, F {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+class F {
+}
+''');
+ }
}
test_class_alias_abstract() {
- checkLibrary('abstract class C = D with E; class D {} class E {}');
+ var library =
+ checkLibrary('abstract class C = D with E; class D {} class E {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class C extends D with E {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class C extends D with E {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+''');
+ }
}
test_class_alias_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
@@ -1342,6 +1430,31 @@ class C = D with E;
class D {}
class E {}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D with E {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D with E {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+''');
+ }
}
test_class_alias_with_forwarding_constructors() {
@@ -1359,35 +1472,122 @@ class Base {
factory Base.fact2() = Base.noArgs;
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import "a.dart";
class M {}
class MixinApp = Base with M;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class M {
+}
+class MixinApp extends Base with M {
+ synthetic MixinApp._priv();
+ synthetic MixinApp();
+ synthetic MixinApp.noArgs();
+ synthetic MixinApp.requiredArg(x);
+ synthetic MixinApp.fact();
+ synthetic MixinApp.fact2();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class M {
+}
+class MixinApp extends Base with M {
+ synthetic MixinApp._priv();
+ synthetic MixinApp();
+ synthetic MixinApp.noArgs();
+ synthetic MixinApp.requiredArg(x);
+ synthetic MixinApp.fact();
+ synthetic MixinApp.fact2();
+}
+''');
+ }
}
test_class_alias_with_forwarding_constructors_type_substitution() {
- checkLibrary('''
+ var library = checkLibrary('''
class Base<T> {
Base.ctor(T t, List<T> l);
}
class M {}
class MixinApp = Base with M;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class Base<T> {
+ Base.ctor(T t, List<T> l);
+}
+class M {
+}
+class MixinApp extends Base with M {
+ synthetic MixinApp.ctor(t, List l);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class Base<T> {
+ Base.ctor(T t, List<T> l);
+}
+class M {
+}
+class MixinApp extends Base with M {
+ synthetic MixinApp.ctor(t, List l);
+}
+''');
+ }
}
test_class_alias_with_forwarding_constructors_type_substitution_complex() {
- checkLibrary('''
+ var library = checkLibrary('''
class Base<T> {
Base.ctor(T t, List<T> l);
}
class M {}
class MixinApp<U> = Base<List<U>> with M;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class Base<T> {
+ Base.ctor(T t, List<T> l);
+}
+class M {
+}
+class MixinApp<U> extends Base<List<U>> with M {
+ synthetic MixinApp.ctor(List<U> t, List<List<U>> l);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class Base<T> {
+ Base.ctor(T t, List<T> l);
+}
+class M {
+}
+class MixinApp<U> extends Base<List<U>> with M {
+ synthetic MixinApp.ctor(List<U> t, List<List<U>> l);
+}
+''');
+ }
}
test_class_alias_with_mixin_members() {
- checkLibrary('''
+ var library = checkLibrary('''
class C = D with E;
class D {}
class E {
@@ -1396,133 +1596,668 @@ class E {
void f() {}
int x;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D with E {
+ synthetic C();
+}
+class D {
+}
+class E {
+ int x;
+ int get a {}
+ void set b(int i) {}
+ void f() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D with E {
+ synthetic C();
+}
+class D {
+}
+class E {
+ int x;
+ int get a {}
+ void set b(int i) {}
+ void f() {}
+}
+''');
+ }
}
test_class_constructor_const() {
- checkLibrary('class C { const C(); }');
+ var library = checkLibrary('class C { const C(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ }
}
test_class_constructor_const_external() {
- checkLibrary('class C { external const C(); }');
+ var library = checkLibrary('class C { external const C(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ }
}
test_class_constructor_explicit_named() {
- checkLibrary('class C { C.foo(); }');
+ var library = checkLibrary('class C { C.foo(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.foo();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.foo();
+}
+''');
+ }
}
test_class_constructor_explicit_type_params() {
- checkLibrary('class C<T, U> { C(); }');
+ var library = checkLibrary('class C<T, U> { C(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ C();
+}
+''');
+ }
}
test_class_constructor_explicit_unnamed() {
- checkLibrary('class C { C(); }');
+ var library = checkLibrary('class C { C(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ }
}
test_class_constructor_external() {
- checkLibrary('class C { external C(); }');
+ var library = checkLibrary('class C { external C(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ }
}
test_class_constructor_factory() {
- checkLibrary('class C { factory C() => null; }');
+ var library = checkLibrary('class C { factory C() => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ }
}
test_class_constructor_field_formal_dynamic_dynamic() {
- checkLibrary('class C { dynamic x; C(dynamic this.x); }');
+ var library = checkLibrary('class C { dynamic x; C(dynamic this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_dynamic_typed() {
- checkLibrary('class C { dynamic x; C(int this.x); }');
+ var library = checkLibrary('class C { dynamic x; C(int this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(int this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(int this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_dynamic_untyped() {
- checkLibrary('class C { dynamic x; C(this.x); }');
+ var library = checkLibrary('class C { dynamic x; C(this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_multiple_matching_fields() {
// This is a compile-time error but it should still analyze consistently.
- checkLibrary('class C { C(this.x); int x; String x; }', allowErrors: true);
+ var library = checkLibrary('class C { C(this.x); int x; String x; }',
+ allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ String x;
+ C(int this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ String x;
+ C(int this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_no_matching_field() {
// This is a compile-time error but it should still analyze consistently.
- checkLibrary('class C { C(this.x); }', allowErrors: true);
+ var library = checkLibrary('class C { C(this.x); }', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C(this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C(this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_typed_dynamic() {
- checkLibrary('class C { num x; C(dynamic this.x); }', allowErrors: true);
+ var library = checkLibrary('class C { num x; C(dynamic this.x); }',
+ allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num x;
+ C(this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num x;
+ C(this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_typed_typed() {
- checkLibrary('class C { num x; C(int this.x); }');
+ var library = checkLibrary('class C { num x; C(int this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num x;
+ C(int this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num x;
+ C(int this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_typed_untyped() {
- checkLibrary('class C { num x; C(this.x); }');
- }
-
+ var library = checkLibrary('class C { num x; C(this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num x;
+ C(num this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num x;
+ C(num this.x);
+}
+''');
+ }
+ }
+
test_class_constructor_field_formal_untyped_dynamic() {
- checkLibrary('class C { var x; C(dynamic this.x); }');
+ var library = checkLibrary('class C { var x; C(dynamic this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_untyped_typed() {
- checkLibrary('class C { var x; C(int this.x); }');
+ var library = checkLibrary('class C { var x; C(int this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(int this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(int this.x);
+}
+''');
+ }
}
test_class_constructor_field_formal_untyped_untyped() {
- checkLibrary('class C { var x; C(this.x); }');
+ var library = checkLibrary('class C { var x; C(this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(this.x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(this.x);
+}
+''');
+ }
}
test_class_constructor_fieldFormal_named_noDefault() {
- checkLibrary('class C { int x; C({this.x}); }');
+ var library = checkLibrary('class C { int x; C({this.x}); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C({int this.x});
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C({int this.x});
+}
+''');
+ }
}
test_class_constructor_fieldFormal_named_withDefault() {
- checkLibrary('class C { int x; C({this.x: 42}); }');
+ var library = checkLibrary('class C { int x; C({this.x: 42}); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C({int this.x});
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C({int this.x});
+}
+''');
+ }
}
test_class_constructor_fieldFormal_optional_noDefault() {
- checkLibrary('class C { int x; C([this.x]); }');
+ var library = checkLibrary('class C { int x; C([this.x]); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C([int this.x]);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C([int this.x]);
+}
+''');
+ }
}
test_class_constructor_fieldFormal_optional_withDefault() {
- checkLibrary('class C { int x; C([this.x = 42]); }');
+ var library = checkLibrary('class C { int x; C([this.x = 42]); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C([int this.x]);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+ C([int this.x]);
+}
+''');
+ }
}
test_class_constructor_implicit() {
- checkLibrary('class C {}');
+ var library = checkLibrary('class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_class_constructor_implicit_type_params() {
- checkLibrary('class C<T, U> {}');
+ var library = checkLibrary('class C<T, U> {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+''');
+ }
}
test_class_constructor_params() {
- checkLibrary('class C { C(x, y); }');
+ var library = checkLibrary('class C { C(x, int y); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C(x, int y);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C(x, int y);
+}
+''');
+ }
}
test_class_constructors() {
- checkLibrary('class C { C.foo(); C.bar(); }');
+ var library = checkLibrary('class C { C.foo(); C.bar(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.foo();
+ C.bar();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.foo();
+ C.bar();
+}
+''');
+ }
}
test_class_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
class C {}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_class_documented_tripleSlash() {
- checkLibrary('''
+ var library = checkLibrary('''
/// aaa
/// bbbb
/// cc
class C {}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_class_documented_with_references() {
- checkLibrary('''
+ var library = checkLibrary('''
/**
* Docs referring to [D] and [E]
*/
@@ -1530,174 +2265,885 @@ class C {}
class D {}
class E {}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+class D {
+}
+class E {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+class D {
+}
+class E {
+}
+''');
+ }
}
test_class_documented_with_windows_line_endings() {
- checkLibrary('/**\r\n * Docs\r\n */\r\nclass C {}');
+ var library = checkLibrary('/**\r\n * Docs\r\n */\r\nclass C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_class_field_const() {
- checkLibrary('class C { static const int i = 0; }');
+ var library = checkLibrary('class C { static const int i = 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const int i;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const int i;
+}
+''');
+ }
}
test_class_field_implicit_type() {
- checkLibrary('class C { var x; }');
+ var library = checkLibrary('class C { var x; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+}
+''');
+ }
}
test_class_field_static() {
- checkLibrary('class C { static int i; }');
+ var library = checkLibrary('class C { static int i; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int i;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int i;
+}
+''');
+ }
}
test_class_fields() {
- checkLibrary('class C { int i; int j; }');
+ var library = checkLibrary('class C { int i; int j; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int i;
+ int j;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int i;
+ int j;
+}
+''');
+ }
}
test_class_getter_abstract() {
- checkLibrary('abstract class C { int get x; }');
+ var library = checkLibrary('abstract class C { int get x; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+ int get x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+ int get x;
+}
+''');
+ }
}
test_class_getter_external() {
- checkLibrary('class C { external int get x; }');
+ var library = checkLibrary('class C { external int get x; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external int get x {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external int get x {}
+}
+''');
+ }
}
test_class_getter_implicit_return_type() {
- checkLibrary('class C { get x => null; }');
+ var library = checkLibrary('class C { get x => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ get x {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ get x {}
+}
+''');
+ }
}
test_class_getter_static() {
- checkLibrary('class C { static int get x => null; }');
+ var library = checkLibrary('class C { static int get x => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int get x {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int get x {}
+}
+''');
+ }
}
test_class_getters() {
- checkLibrary('class C { int get x => null; get y => null; }');
+ var library = checkLibrary('class C { int get x => null; get y => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int get x {}
+ get y {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int get x {}
+ get y {}
+}
+''');
+ }
}
test_class_implicitField_getterFirst() {
- checkLibrary('class C { int get x => 0; void set x(int value) {} }');
+ var library =
+ checkLibrary('class C { int get x => 0; void set x(int value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int get x {}
+ void set x(int value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int get x {}
+ void set x(int value) {}
+}
+''');
+ }
}
test_class_implicitField_setterFirst() {
- checkLibrary('class C { void set x(int value) {} int get x => 0; }');
+ var library =
+ checkLibrary('class C { void set x(int value) {} int get x => 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(int value) {}
+ int get x {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(int value) {}
+ int get x {}
+}
+''');
+ }
}
test_class_interfaces() {
- checkLibrary('class C implements D, E {} class D {} class E {}');
+ var library =
+ checkLibrary('class C implements D, E {} class D {} class E {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C implements D, E {
+}
+class D {
+}
+class E {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C implements D, E {
+}
+class D {
+}
+class E {
+}
+''');
+ }
}
test_class_interfaces_unresolved() {
- checkLibrary('class C implements X, Y, Z {} class X {} class Z {}',
+ var library = checkLibrary(
+ 'class C implements X, Y, Z {} class X {} class Z {}',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C implements X, Z {
+}
+class X {
+}
+class Z {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C implements X, Z {
+}
+class X {
+}
+class Z {
+}
+''');
+ }
}
test_class_method_abstract() {
- checkLibrary('abstract class C { f(); }');
+ var library = checkLibrary('abstract class C { f(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+ f();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+ f();
+}
+''');
+ }
}
test_class_method_external() {
- checkLibrary('class C { external f(); }');
+ var library = checkLibrary('class C { external f(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external f() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external f() {}
+}
+''');
+ }
}
test_class_method_params() {
- checkLibrary('class C { f(x, y) {} }');
+ var library = checkLibrary('class C { f(x, y) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ f(x, y) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ f(x, y) {}
+}
+''');
+ }
}
test_class_method_static() {
- checkLibrary('class C { static f() {} }');
+ var library = checkLibrary('class C { static f() {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static f() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static f() {}
+}
+''');
+ }
}
test_class_methods() {
- checkLibrary('class C { f() {} g() {} }');
+ var library = checkLibrary('class C { f() {} g() {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ f() {}
+ g() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ f() {}
+ g() {}
+}
+''');
+ }
}
test_class_mixins() {
- checkLibrary('class C extends Object with D, E {} class D {} class E {}');
+ var library = checkLibrary(
+ 'class C extends Object with D, E {} class D {} class E {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends Object with D, E {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends Object with D, E {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+''');
+ }
}
test_class_mixins_unresolved() {
- checkLibrary('class C extends Object with X, Y, Z; class X {} class Z {}',
+ var library = checkLibrary(
+ 'class C extends Object with X, Y, Z; class X {} class Z {}',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends Object with X, Z {
+ synthetic C();
+}
+class X {
+}
+class Z {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends Object with X, Z {
+ synthetic C();
+}
+class X {
+}
+class Z {
+}
+''');
+ }
}
test_class_setter_abstract() {
- checkLibrary('abstract class C { void set x(int value); }');
+ var library = checkLibrary('abstract class C { void set x(int value); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+ void set x(int value);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class C {
+ void set x(int value);
+}
+''');
+ }
}
test_class_setter_external() {
- checkLibrary('class C { external void set x(int value); }');
+ var library = checkLibrary('class C { external void set x(int value); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external void set x(int value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external void set x(int value) {}
+}
+''');
+ }
}
test_class_setter_implicit_param_type() {
- checkLibrary('class C { void set x(value) {} }');
+ var library = checkLibrary('class C { void set x(value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(value) {}
+}
+''');
+ }
}
test_class_setter_implicit_return_type() {
- checkLibrary('class C { set x(int value) {} }');
+ var library = checkLibrary('class C { set x(int value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(int value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ set x(int value) {}
+}
+''');
+ }
}
test_class_setter_invalid_no_parameter() {
- checkLibrary('class C { void set x() {} }');
+ var library = checkLibrary('class C { void set x() {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x() {}
+}
+''');
+ }
}
test_class_setter_static() {
- checkLibrary('class C { static void set x(int value) {} }');
+ var library = checkLibrary('class C { static void set x(int value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static void set x(int value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static void set x(int value) {}
+}
+''');
+ }
}
test_class_setters() {
- checkLibrary('class C { void set x(int value) {} set y(value) {} }');
+ var library =
+ checkLibrary('class C { void set x(int value) {} set y(value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(int value) {}
+ void set y(value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(int value) {}
+ set y(value) {}
+}
+''');
+ }
}
test_class_supertype() {
- checkLibrary('class C extends D {} class D {}');
+ var library = checkLibrary('class C extends D {} class D {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+}
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+}
+class D {
+}
+''');
+ }
}
test_class_supertype_unresolved() {
- checkLibrary('class C extends D {}', allowErrors: true);
+ var library = checkLibrary('class C extends D {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_class_type_parameters() {
- checkLibrary('class C<T, U> {}');
+ var library = checkLibrary('class C<T, U> {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+''');
+ }
}
test_class_type_parameters_bound() {
- checkLibrary('class C<T extends Object, U extends D> {} class D {}');
+ var library =
+ checkLibrary('class C<T extends Object, U extends D> {} class D {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T extends Object, U extends D> {
+}
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T extends Object, U extends D> {
+}
+class D {
+}
+''');
+ }
}
test_class_type_parameters_f_bound_complex() {
- checkLibrary('class C<T extends List<U>, U> {}');
+ var library = checkLibrary('class C<T extends List<U>, U> {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T extends List<U>, U> {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T extends List<U>, U> {
+}
+''');
+ }
}
test_class_type_parameters_f_bound_simple() {
- checkLibrary('class C<T extends U, U> {}');
+ var library = checkLibrary('class C<T extends U, U> {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T extends U, U> {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T extends U, U> {
+}
+''');
+ }
}
test_classes() {
- checkLibrary('class C {} class D {}');
+ var library = checkLibrary('class C {} class D {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+class D {
+}
+''');
+ }
}
test_closure_executable_with_return_type_from_closure() {
- checkLibrary('''
+ var library = checkLibrary('''
f() {
print(() {});
print(() => () => 0);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f() {}
+''');
+ }
}
test_closure_generic() {
- checkLibrary('final f = <U, V>(U x, V y) => y;');
+ var library = checkLibrary('final f = <U, V>(U x, V y) => y;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+final <U,V>(U, V) → V f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+final f;
+''');
+ }
}
test_closure_in_variable_declaration_in_part() {
addSource('/a.dart', 'part of lib; final f = (int i) => i.toDouble();');
- checkLibrary('''
+ var library = checkLibrary('''
library lib;
part "a.dart";
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library lib;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+final (int) → double f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library lib;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+final f;
+''');
+ }
}
test_const_invalid_field_const() {
variablesWithNotConstInitializers.add('f');
- checkLibrary(
+ var library = checkLibrary(
r'''
class C {
static const f = 1 + foo();
@@ -1705,11 +3151,30 @@ class C {
int foo() => 42;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const int f;
+}
+int foo() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const f;
+}
+int foo() {}
+''');
+ }
}
test_const_invalid_field_final() {
variablesWithNotConstInitializers.add('f');
- checkLibrary(
+ var library = checkLibrary(
r'''
class C {
final f = 1 + foo();
@@ -1717,25 +3182,78 @@ class C {
int foo() => 42;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final int f;
+}
+int foo() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final f;
+}
+int foo() {}
+''');
+ }
}
test_const_invalid_topLevel() {
variablesWithNotConstInitializers.add('v');
- checkLibrary(
+ var library = checkLibrary(
r'''
const v = 1 + foo();
int foo() => 42;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int v;
+int foo() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const v;
+int foo() {}
+''');
+ }
}
test_const_invokeConstructor_generic_named() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C<K, V> {
const C.named(K k, V v);
}
const V = const C<int, String>.named(1, '222');
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<K, V> {
+ C.named(K k, V v);
+}
+const C<int, String> V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<K, V> {
+ C.named(K k, V v);
+}
+const V;
+''');
+ }
}
test_const_invokeConstructor_generic_named_imported() {
@@ -1746,10 +3264,25 @@ class C<K, V> {
const C.named(K k, V v);
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = const C<int, String>.named(1, '222');
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const C<int, String> V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const V;
+''');
+ }
}
test_const_invokeConstructor_generic_named_imported_withPrefix() {
@@ -1760,28 +3293,81 @@ class C<K, V> {
const C.named(K k, V v);
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = const p.C<int, String>.named(1, '222');
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const C<int, String> V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const V;
+''');
+ }
}
test_const_invokeConstructor_generic_noTypeArguments() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
+class C<K, V> {
+ const C();
+}
+const V = const C();
+''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<K, V> {
+ C();
+}
+const C V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
class C<K, V> {
- const C();
+ C();
}
-const V = const C();
+const V;
''');
+ }
}
test_const_invokeConstructor_generic_unnamed() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C<K, V> {
const C();
}
const V = const C<int, String>();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<K, V> {
+ C();
+}
+const C<int, String> V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<K, V> {
+ C();
+}
+const V;
+''');
+ }
}
test_const_invokeConstructor_generic_unnamed_imported() {
@@ -1792,10 +3378,25 @@ class C<K, V> {
const C();
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = const C<int, String>();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const C<int, String> V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const V;
+''');
+ }
}
test_const_invokeConstructor_generic_unnamed_imported_withPrefix() {
@@ -1806,19 +3407,53 @@ class C<K, V> {
const C();
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = const p.C<int, String>();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const C<int, String> V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const V;
+''');
+ }
}
test_const_invokeConstructor_named() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
const C.named(bool a, int b, int c, {String d, double e});
}
const V = const C.named(true, 1, 2, d: 'ccc', e: 3.4);
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.named(bool a, int b, int c, {String d}, {double e});
+}
+const C V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.named(bool a, int b, int c, {String d}, {double e});
+}
+const V;
+''');
+ }
}
test_const_invokeConstructor_named_imported() {
@@ -1829,10 +3464,25 @@ class C {
const C.named();
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = const C.named();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const C V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const V;
+''');
+ }
}
test_const_invokeConstructor_named_imported_withPrefix() {
@@ -1843,27 +3493,72 @@ class C {
const C.named();
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = const p.C.named();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const C V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const V;
+''');
+ }
}
test_const_invokeConstructor_named_unresolved() {
- checkLibrary(
+ var library = checkLibrary(
r'''
class C {}
const V = const C.named();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+const C V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+const V;
+''');
+ }
}
test_const_invokeConstructor_named_unresolved2() {
- checkLibrary(
+ var library = checkLibrary(
r'''
const V = const C.named();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const V;
+''');
+ }
}
test_const_invokeConstructor_named_unresolved3() {
@@ -1873,39 +3568,101 @@ const V = const C.named();
class C {
}
''');
- checkLibrary(
+ var library = checkLibrary(
r'''
import 'a.dart' as p;
const V = const p.C.named();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const C V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const V;
+''');
+ }
}
test_const_invokeConstructor_named_unresolved4() {
addLibrarySource('/a.dart', '');
- checkLibrary(
+ var library = checkLibrary(
r'''
import 'a.dart' as p;
const V = const p.C.named();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const V;
+''');
+ }
}
test_const_invokeConstructor_named_unresolved5() {
- checkLibrary(
+ var library = checkLibrary(
r'''
const V = const p.C.named();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const V;
+''');
+ }
}
test_const_invokeConstructor_unnamed() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
const C();
}
const V = const C();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+const C V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+const V;
+''');
+ }
}
test_const_invokeConstructor_unnamed_imported() {
@@ -1916,10 +3673,25 @@ class C {
const C();
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = const C();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const C V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const V;
+''');
+ }
}
test_const_invokeConstructor_unnamed_imported_withPrefix() {
@@ -1930,45 +3702,120 @@ class C {
const C();
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = const p.C();
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const C V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const V;
+''');
+ }
}
test_const_invokeConstructor_unnamed_unresolved() {
- checkLibrary(
+ var library = checkLibrary(
r'''
const V = const C();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const V;
+''');
+ }
}
test_const_invokeConstructor_unnamed_unresolved2() {
addLibrarySource('/a.dart', '');
- checkLibrary(
+ var library = checkLibrary(
r'''
import 'a.dart' as p;
const V = const p.C();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const V;
+''');
+ }
}
test_const_invokeConstructor_unnamed_unresolved3() {
- checkLibrary(
+ var library = checkLibrary(
r'''
const V = const p.C();
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const V;
+''');
+ }
}
test_const_length_ofClassConstField() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
static const String F = '';
}
const int v = C.F.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const String F;
+}
+const int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const String F;
+}
+const int v;
+''');
+ }
}
test_const_length_ofClassConstField_imported() {
@@ -1979,10 +3826,25 @@ class C {
static const String F = '';
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const int v = C.F.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const int v;
+''');
+ }
}
test_const_length_ofClassConstField_imported_withPrefix() {
@@ -1993,23 +3855,66 @@ class C {
static const String F = '';
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const int v = p.C.F.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const int v;
+''');
+ }
}
test_const_length_ofStringLiteral() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const v = 'abc'.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const v;
+''');
+ }
}
test_const_length_ofTopLevelVariable() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const String S = 'abc';
const v = S.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const String S;
+const int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const String S;
+const v;
+''');
+ }
}
test_const_length_ofTopLevelVariable_imported() {
@@ -2018,10 +3923,25 @@ const v = S.length;
r'''
const String S = 'abc';
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const v = S.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const v;
+''');
+ }
}
test_const_length_ofTopLevelVariable_imported_withPrefix() {
@@ -2030,51 +3950,144 @@ const v = S.length;
r'''
const String S = 'abc';
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const v = p.S.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const v;
+''');
+ }
}
test_const_length_staticMethod() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
static int length() => 42;
}
const v = C.length;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int length() {}
+}
+const () → int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int length() {}
+}
+const v;
+''');
+ }
}
test_const_parameterDefaultValue_initializingFormal_functionTyped() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
final x;
const C({this.x: foo});
}
int foo() => 42;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C({this.x});
+}
+int foo() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C({this.x});
+}
+int foo() {}
+''');
+ }
}
test_const_parameterDefaultValue_initializingFormal_named() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
final x;
const C({this.x: 1 + 2});
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C({this.x});
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C({this.x});
+}
+''');
+ }
}
test_const_parameterDefaultValue_initializingFormal_positional() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
final x;
const C([this.x = 1 + 2]);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C([this.x]);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C([this.x]);
+}
+''');
+ }
}
test_const_parameterDefaultValue_normal() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
const C.positional([p = 1 + 2]);
const C.named({p: 1 + 2});
@@ -2084,15 +4097,61 @@ class C {
void methodNamedWithoutDefault({p}) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.positional([p]);
+ C.named({p});
+ void methodPositional([p]) {}
+ void methodPositionalWithoutDefault([p]) {}
+ void methodNamed({p}) {}
+ void methodNamedWithoutDefault({p}) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.positional([p]);
+ C.named({p});
+ void methodPositional([p]) {}
+ void methodPositionalWithoutDefault([p]) {}
+ void methodNamed({p}) {}
+ void methodNamedWithoutDefault({p}) {}
+}
+''');
+ }
}
test_const_reference_staticField() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
static const int F = 42;
}
const V = C.F;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const int F;
+}
+const int V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const int F;
+}
+const V;
+''');
+ }
}
test_const_reference_staticField_imported() {
@@ -2103,10 +4162,25 @@ class C {
static const int F = 42;
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = C.F;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const int V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const V;
+''');
+ }
}
test_const_reference_staticField_imported_withPrefix() {
@@ -2117,19 +4191,53 @@ class C {
static const int F = 42;
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = p.C.F;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const int V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const V;
+''');
+ }
}
test_const_reference_staticMethod() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
+class C {
+ static int m(int a, String b) => 42;
+}
+const V = C.m;
+''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int m(int a, String b) {}
+}
+const (int, String) → int V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
class C {
- static int m(int a, String b) => 42;
+ static int m(int a, String b) {}
}
-const V = C.m;
+const V;
''');
+ }
}
test_const_reference_staticMethod_imported() {
@@ -2140,10 +4248,25 @@ class C {
static int m(int a, String b) => 42;
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = C.m;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const (int, String) → int V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const V;
+''');
+ }
}
test_const_reference_staticMethod_imported_withPrefix() {
@@ -2154,17 +4277,47 @@ class C {
static int m(int a, String b) => 42;
}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = p.C.m;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const (int, String) → int V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const V;
+''');
+ }
}
test_const_reference_topLevelFunction() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
foo() {}
const V = foo;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const () → dynamic V;
+foo() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const V;
+foo() {}
+''');
+ }
}
test_const_reference_topLevelFunction_imported() {
@@ -2173,10 +4326,25 @@ const V = foo;
r'''
foo() {}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const V = foo;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const () → dynamic V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const V;
+''');
+ }
}
test_const_reference_topLevelFunction_imported_withPrefix() {
@@ -2185,17 +4353,47 @@ const V = foo;
r'''
foo() {}
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const V = p.foo;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const () → dynamic V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const V;
+''');
+ }
}
test_const_reference_topLevelVariable() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const A = 1;
const B = A + 2;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int A;
+const int B;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const A;
+const B;
+''');
+ }
}
test_const_reference_topLevelVariable_imported() {
@@ -2204,10 +4402,25 @@ const B = A + 2;
r'''
const A = 1;
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const B = A + 2;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const int B;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const B;
+''');
+ }
}
test_const_reference_topLevelVariable_imported_withPrefix() {
@@ -2216,14 +4429,29 @@ const B = A + 2;
r'''
const A = 1;
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const B = p.A + 2;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const int B;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const B;
+''');
+ }
}
test_const_reference_type() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {}
class D<T> {}
enum E {a, b, c}
@@ -2236,15 +4464,71 @@ const vGenericClass = D;
const vEnum = E;
const vFunctionTypeAlias = F;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F(int a, String b);
+enum E { a, b, c }
+class C {
+}
+class D<T> {
+}
+const Type vDynamic;
+const Type vNull;
+const Type vObject;
+const Type vClass;
+const Type vGenericClass;
+const Type vEnum;
+const Type vFunctionTypeAlias;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F(int a, String b);
+enum E { a, b, c }
+class C {
+}
+class D<T> {
+}
+const vDynamic;
+const vNull;
+const vObject;
+const vClass;
+const vGenericClass;
+const vEnum;
+const vFunctionTypeAlias;
+''');
+ }
}
test_const_reference_type_functionType() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
typedef F();
class C {
final f = <F>[];
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F();
+class C {
+ final List<F> f;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F();
+class C {
+ final f;
+}
+''');
+ }
}
test_const_reference_type_imported() {
@@ -2255,12 +4539,31 @@ class C {}
enum E {a, b, c}
typedef F(int a, String b);
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const vClass = C;
const vEnum = E;
const vFunctionTypeAlias = F;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const Type vClass;
+const Type vEnum;
+const Type vFunctionTypeAlias;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const vClass;
+const vEnum;
+const vFunctionTypeAlias;
+''');
+ }
}
test_const_reference_type_imported_withPrefix() {
@@ -2271,37 +4574,103 @@ class C {}
enum E {a, b, c}
typedef F(int a, String b);
''');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const vClass = p.C;
const vEnum = p.E;
const vFunctionTypeAlias = p.F;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const Type vClass;
+const Type vEnum;
+const Type vFunctionTypeAlias;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const vClass;
+const vEnum;
+const vFunctionTypeAlias;
+''');
+ }
}
test_const_reference_type_typeParameter() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C<T> {
final f = <T>[];
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ final List<T> f;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ final f;
+}
+''');
+ }
}
test_const_reference_unresolved_prefix0() {
- checkLibrary(
+ var library = checkLibrary(
r'''
const V = foo;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const V;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const V;
+''');
+ }
}
test_const_reference_unresolved_prefix1() {
- checkLibrary(
+ var library = checkLibrary(
r'''
class C {}
const v = C.foo;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+const v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+const v;
+''');
+ }
}
test_const_reference_unresolved_prefix2() {
@@ -2310,16 +4679,31 @@ const v = C.foo;
'''
class C {}
''');
- checkLibrary(
+ var library = checkLibrary(
r'''
import 'foo.dart' as p;
const v = p.C.foo;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as p;
+const v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as p;
+const v;
+''');
+ }
}
test_const_topLevel_binary() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vEqual = 1 == 2;
const vAnd = true && false;
const vOr = false || true;
@@ -2339,28 +4723,114 @@ const vGreaterEqual = 1 >= 2;
const vLess = 1 < 2;
const vLessEqual = 1 <= 2;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const bool vEqual;
+const bool vAnd;
+const bool vOr;
+const int vBitXor;
+const int vBitAnd;
+const int vBitOr;
+const int vBitShiftLeft;
+const int vBitShiftRight;
+const int vAdd;
+const int vSubtract;
+const int vMiltiply;
+const num vDivide;
+const int vFloorDivide;
+const int vModulo;
+const bool vGreater;
+const bool vGreaterEqual;
+const bool vLess;
+const bool vLessEqual;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const vEqual;
+const vAnd;
+const vOr;
+const vBitXor;
+const vBitAnd;
+const vBitOr;
+const vBitShiftLeft;
+const vBitShiftRight;
+const vAdd;
+const vSubtract;
+const vMiltiply;
+const vDivide;
+const vFloorDivide;
+const vModulo;
+const vGreater;
+const vGreaterEqual;
+const vLess;
+const vLessEqual;
+''');
+ }
}
test_const_topLevel_conditional() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vConditional = (1 == 2) ? 11 : 22;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int vConditional;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const vConditional;
+''');
+ }
}
test_const_topLevel_identical() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vIdentical = (1 == 2) ? 11 : 22;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int vIdentical;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const vIdentical;
+''');
+ }
}
test_const_topLevel_ifNull() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vIfNull = 1 ?? 2.0;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const num vIfNull;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const vIfNull;
+''');
+ }
}
test_const_topLevel_literal() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vNull = null;
const vBoolFalse = false;
const vBoolTrue = true;
@@ -2372,31 +4842,107 @@ const vStringConcat = 'aaa' 'bbb';
const vStringInterpolation = 'aaa ${true} ${42} bbb';
const vSymbol = #aaa.bbb.ccc;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const vNull;
+const bool vBoolFalse;
+const bool vBoolTrue;
+const int vInt;
+const int vIntLong;
+const double vDouble;
+const String vString;
+const String vStringConcat;
+const String vStringInterpolation;
+const Symbol vSymbol;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const vNull;
+const vBoolFalse;
+const vBoolTrue;
+const vInt;
+const vIntLong;
+const vDouble;
+const vString;
+const vStringConcat;
+const vStringInterpolation;
+const vSymbol;
+''');
+ }
}
test_const_topLevel_prefix() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vNotEqual = 1 != 2;
const vNot = !true;
const vNegate = -1;
const vComplement = ~1;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const bool vNotEqual;
+const bool vNot;
+const int vNegate;
+const int vComplement;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const vNotEqual;
+const vNot;
+const vNegate;
+const vComplement;
+''');
+ }
}
test_const_topLevel_super() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vSuper = super;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const vSuper;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const vSuper;
+''');
+ }
}
test_const_topLevel_this() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vThis = this;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const vThis;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const vThis;
+''');
+ }
}
test_const_topLevel_typedList() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vNull = const <Null>[];
const vDynamic = const <dynamic>[1, 2, 3];
const vInterfaceNoTypeParameters = const <int>[1, 2, 3];
@@ -2404,101 +4950,307 @@ const vInterfaceNoTypeArguments = const <List>[];
const vInterfaceWithTypeArguments = const <List<String>>[];
const vInterfaceWithTypeArguments2 = const <Map<int, List<String>>>[];
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const List<Null> vNull;
+const List vDynamic;
+const List<int> vInterfaceNoTypeParameters;
+const List<List> vInterfaceNoTypeArguments;
+const List<List<String>> vInterfaceWithTypeArguments;
+const List<Map<int, List<String>>> vInterfaceWithTypeArguments2;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const vNull;
+const vDynamic;
+const vInterfaceNoTypeParameters;
+const vInterfaceNoTypeArguments;
+const vInterfaceWithTypeArguments;
+const vInterfaceWithTypeArguments2;
+''');
+ }
}
test_const_topLevel_typedList_imported() {
addLibrarySource('/a.dart', 'class C {}');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart';
const v = const <C>[];
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const List<C> v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+const v;
+''');
+ }
}
test_const_topLevel_typedList_importedWithPrefix() {
addLibrarySource('/a.dart', 'class C {}');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'a.dart' as p;
const v = const <p.C>[];
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const List<C> v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as p;
+const v;
+''');
+ }
}
test_const_topLevel_typedMap() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const vDynamic1 = const <dynamic, int>{};
const vDynamic2 = const <int, dynamic>{};
const vInterface = const <int, String>{};
const vInterfaceWithTypeArguments = const <int, List<String>>{};
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const Map<dynamic, int> vDynamic1;
+const Map<int, dynamic> vDynamic2;
+const Map<int, String> vInterface;
+const Map<int, List<String>> vInterfaceWithTypeArguments;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const vDynamic1;
+const vDynamic2;
+const vInterface;
+const vInterfaceWithTypeArguments;
+''');
+ }
}
test_const_topLevel_untypedList() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const v = const [1, 2, 3];
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const List<int> v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const v;
+''');
+ }
}
test_const_topLevel_untypedMap() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
const v = const {0: 'aaa', 1: 'bbb', 2: 'ccc'};
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const Map<int, String> v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const v;
+''');
+ }
}
test_constExpr_pushReference_field_simpleIdentifier() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
static const a = b;
static const b = null;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const a;
+ static const b;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const a;
+ static const b;
+}
+''');
+ }
}
test_constExpr_pushReference_staticMethod_simpleIdentifier() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
static const a = m;
static m() {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const () → dynamic a;
+ static m() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const a;
+ static m() {}
+}
+''');
+ }
}
test_constructor_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
/**
* Docs
*/
C();
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ }
}
test_constructor_initializers_assertInvocation() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
const C(int x) : assert(x >= 42);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C(int x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C(int x);
+}
+''');
+ }
}
test_constructor_initializers_assertInvocation_message() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
const C(int x) : assert(x >= 42, 'foo');
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C(int x);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C(int x);
+}
+''');
+ }
}
test_constructor_initializers_field() {
- checkLibrary('''
+ var library = checkLibrary('''
+class C {
+ final x;
+ const C() : x = 42;
+}
+''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
class C {
final x;
- const C() : x = 42;
+ C();
}
''');
+ }
}
test_constructor_initializers_field_notConst() {
variablesWithNotConstInitializers.add('x');
- checkLibrary(
+ var library = checkLibrary(
'''
class C {
final x;
@@ -2507,19 +5259,59 @@ class C {
int foo() => 42;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C();
+}
+int foo() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C();
+}
+int foo() {}
+''');
+ }
}
test_constructor_initializers_field_withParameter() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
final x;
const C(int p) : x = 1 + p;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C(int p);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C(int p);
+}
+''');
+ }
}
test_constructor_initializers_superInvocation_named() {
- checkLibrary('''
+ var library = checkLibrary('''
class A {
const A.aaa(int p);
}
@@ -2527,10 +5319,33 @@ class C extends A {
const C() : super.aaa(42);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A.aaa(int p);
+}
+class C extends A {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A.aaa(int p);
+}
+class C extends A {
+ C();
+}
+''');
+ }
}
test_constructor_initializers_superInvocation_namedExpression() {
- checkLibrary('''
+ var library = checkLibrary('''
class A {
const A.aaa(a, {int b});
}
@@ -2538,10 +5353,33 @@ class C extends A {
const C() : super.aaa(1, b: 2);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A.aaa(a, {int b});
+}
+class C extends A {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A.aaa(a, {int b});
+}
+class C extends A {
+ C();
+}
+''');
+ }
}
test_constructor_initializers_superInvocation_unnamed() {
- checkLibrary('''
+ var library = checkLibrary('''
class A {
const A(int p);
}
@@ -2549,37 +5387,117 @@ class C extends A {
const C.ccc() : super(42);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A(int p);
+}
+class C extends A {
+ C.ccc();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A(int p);
+}
+class C extends A {
+ C.ccc();
+}
+''');
+ }
}
test_constructor_initializers_thisInvocation_named() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
const C() : this.named(1, 'bbb');
const C.named(int a, String b);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+ C.named(int a, String b);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+ C.named(int a, String b);
+}
+''');
+ }
}
test_constructor_initializers_thisInvocation_namedExpression() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
const C() : this.named(1, b: 2);
const C.named(a, {int b});
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+ C.named(a, {int b});
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+ C.named(a, {int b});
+}
+''');
+ }
}
test_constructor_initializers_thisInvocation_unnamed() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
const C.named() : this(1, 'bbb');
const C(int a, String b);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.named();
+ C(int a, String b);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.named();
+ C(int a, String b);
+}
+''');
+ }
}
test_constructor_redirected_factory_named() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
factory C() = D.named;
C._();
@@ -2588,10 +5506,35 @@ class D extends C {
D.named() : super._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+ C._();
+}
+class D extends C {
+ D.named();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+ C._();
+}
+class D extends C {
+ D.named();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_generic() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T, U> {
factory C() = D<U, T>.named;
C._();
@@ -2600,6 +5543,31 @@ class D<T, U> extends C<U, T> {
D.named() : super._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ C();
+ C._();
+}
+class D<T, U> extends C<U, T> {
+ D.named();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ C();
+ C._();
+}
+class D<T, U> extends C<U, T> {
+ D.named();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_imported() {
@@ -2611,13 +5579,34 @@ class D extends C {
D.named() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart';
class C {
factory C() = D.named;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C {
+ C();
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C {
+ C();
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_imported_generic() {
@@ -2629,13 +5618,34 @@ class D<T, U> extends C<U, T> {
D.named() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart';
class C<T, U> {
factory C() = D<U, T>.named;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C<T, U> {
+ C();
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C<T, U> {
+ C();
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_prefixed() {
@@ -2647,13 +5657,34 @@ class D extends C {
D.named() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart' as foo;
class C {
factory C() = foo.D.named;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C {
+ C();
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C {
+ C();
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_prefixed_generic() {
@@ -2665,27 +5696,65 @@ class D<T, U> extends C<U, T> {
D.named() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart' as foo;
class C<T, U> {
factory C() = foo.D<U, T>.named;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C<T, U> {
+ C();
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C<T, U> {
+ C();
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_unresolved_class() {
- checkLibrary(
+ var library = checkLibrary(
'''
class C<E> {
factory C() = D.named<E>;
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<E> {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<E> {
+ C();
+}
+''');
+ }
}
test_constructor_redirected_factory_named_unresolved_constructor() {
- checkLibrary(
+ var library = checkLibrary(
'''
class D {}
class C<E> {
@@ -2693,30 +5762,101 @@ class C<E> {
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class D {
+}
+class C<E> {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class D {
+}
+class C<E> {
+ C();
+}
+''');
+ }
}
test_constructor_redirected_factory_unnamed() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
factory C() = D;
C._();
}
-class D extends C {
- D() : super._();
+class D extends C {
+ D() : super._();
+}
+''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+ C._();
+}
+class D extends C {
+ D();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+ C._();
+}
+class D extends C {
+ D();
+}
+''');
+ }
+ }
+
+ test_constructor_redirected_factory_unnamed_generic() {
+ var library = checkLibrary('''
+class C<T, U> {
+ factory C() = D<U, T>;
+ C._();
+}
+class D<T, U> extends C<U, T> {
+ D() : super._();
+}
+''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ C();
+ C._();
+}
+class D<T, U> extends C<U, T> {
+ D();
}
''');
- }
-
- test_constructor_redirected_factory_unnamed_generic() {
- checkLibrary('''
+ } else {
+ checkElementText(
+ library,
+ r'''
class C<T, U> {
- factory C() = D<U, T>;
+ C();
C._();
}
class D<T, U> extends C<U, T> {
- D() : super._();
+ D();
}
''');
+ }
}
test_constructor_redirected_factory_unnamed_imported() {
@@ -2728,13 +5868,34 @@ class D extends C {
D() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart';
class C {
factory C() = D;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C {
+ C();
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C {
+ C();
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_unnamed_imported_generic() {
@@ -2746,13 +5907,34 @@ class D<T, U> extends C<U, T> {
D() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart';
class C<T, U> {
factory C() = D<U, T>;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C<T, U> {
+ C();
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class C<T, U> {
+ C();
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_unnamed_prefixed() {
@@ -2764,13 +5946,34 @@ class D extends C {
D() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart' as foo;
class C {
factory C() = foo.D;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C {
+ C();
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C {
+ C();
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_unnamed_prefixed_generic() {
@@ -2782,63 +5985,177 @@ class D<T, U> extends C<U, T> {
D() : super._();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'foo.dart' as foo;
class C<T, U> {
factory C() = foo.D<U, T>;
C._();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C<T, U> {
+ C();
+ C._();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C<T, U> {
+ C();
+ C._();
+}
+''');
+ }
}
test_constructor_redirected_factory_unnamed_unresolved() {
- checkLibrary(
+ var library = checkLibrary(
'''
class C<E> {
factory C() = D<E>;
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<E> {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<E> {
+ C();
+}
+''');
+ }
}
test_constructor_redirected_thisInvocation_named() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
C.named();
C() : this.named();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.named();
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.named();
+ C();
+}
+''');
+ }
}
test_constructor_redirected_thisInvocation_named_generic() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T> {
C.named();
C() : this.named();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ C.named();
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ C.named();
+ C();
+}
+''');
+ }
}
test_constructor_redirected_thisInvocation_unnamed() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
C();
C.named() : this();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+ C.named();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+ C.named();
+}
+''');
+ }
}
test_constructor_redirected_thisInvocation_unnamed_generic() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T> {
C();
C.named() : this();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ C();
+ C.named();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ C();
+ C.named();
+}
+''');
+ }
}
test_constructor_withCycles_const() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
final x;
const C() : x = const D();
@@ -2848,10 +6165,37 @@ class D {
const D() : x = const C();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C();
+}
+class D {
+ final x;
+ D();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C();
+}
+class D {
+ final x;
+ D();
+}
+''');
+ }
}
test_constructor_withCycles_nonConst() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
final x;
C() : x = new D();
@@ -2861,10 +6205,37 @@ class D {
D() : x = new C();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C();
+}
+class D {
+ final x;
+ D();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+ C();
+}
+class D {
+ final x;
+ D();
+}
+''');
+ }
}
test_defaultValue_refersToGenericClass_constructor() {
- checkLibrary('''
+ var library = checkLibrary('''
class B<T> {
const B();
}
@@ -2872,10 +6243,33 @@ class C<T> {
const C([B<T> b = const B()]);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ B();
+}
+class C<T> {
+ C([B<T> b]);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ B();
+}
+class C<T> {
+ C([B<T> b]);
+}
+''');
+ }
}
test_defaultValue_refersToGenericClass_constructor2() {
- checkLibrary('''
+ var library = checkLibrary('''
abstract class A<T> {}
class B<T> implements A<T> {
const B();
@@ -2884,19 +6278,65 @@ class C<T> implements A<Iterable<T>> {
const C([A<T> a = const B()]);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class A<T> {
+}
+class B<T> implements A<T> {
+ B();
+}
+class C<T> implements A<Iterable<T>> {
+ C([A<T> a]);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class A<T> {
+}
+class B<T> implements A<T> {
+ B();
+}
+class C<T> implements A<Iterable<T>> {
+ C([A<T> a]);
+}
+''');
+ }
}
test_defaultValue_refersToGenericClass_functionG() {
- checkLibrary('''
+ var library = checkLibrary('''
class B<T> {
const B();
}
void foo<T>([B<T> b = const B()]) {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ B();
+}
+void foo<T>([B<T> b]) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ B();
+}
+void foo<T>([B<T> b]) {}
+''');
+ }
}
test_defaultValue_refersToGenericClass_methodG() {
- checkLibrary('''
+ var library = checkLibrary('''
class B<T> {
const B();
}
@@ -2904,10 +6344,33 @@ class C {
void foo<T>([B<T> b = const B()]) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ B();
+}
+class C {
+ void foo<T>([B<T> b]) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ B();
+}
+class C {
+ void foo<T>([B<T> b]) {}
+}
+''');
+ }
}
test_defaultValue_refersToGenericClass_methodG_classG() {
- checkLibrary('''
+ var library = checkLibrary('''
class B<T1, T2> {
const B();
}
@@ -2915,10 +6378,33 @@ class C<E1> {
void foo<E2>([B<E1, E2> b = const B()]) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class B<T1, T2> {
+ B();
+}
+class C<E1> {
+ void foo<E2>([B<E1, E2> b]) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class B<T1, T2> {
+ B();
+}
+class C<E1> {
+ void foo<E2>([B<E1, E2> b]) {}
+}
+''');
+ }
}
test_defaultValue_refersToGenericClass_methodNG() {
- checkLibrary('''
+ var library = checkLibrary('''
class B<T> {
const B();
}
@@ -2926,37 +6412,114 @@ class C<T> {
void foo([B<T> b = const B()]) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ B();
+}
+class C<T> {
+ void foo([B<T> b]) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class B<T> {
+ B();
+}
+class C<T> {
+ void foo([B<T> b]) {}
+}
+''');
+ }
}
test_enum_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
enum E { v }''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+enum E { v }
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+enum E { v }
+''');
+ }
}
test_enum_value_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
enum E {
/**
* Docs
*/
v
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+enum E { v }
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+enum E { v }
+''');
+ }
}
test_enum_values() {
- checkLibrary('enum E { v1, v2 }');
+ var library = checkLibrary('enum E { v1, v2 }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+enum E { v1, v2 }
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+enum E { v1, v2 }
+''');
+ }
}
test_enums() {
- checkLibrary('enum E1 { v1 } enum E2 { v2 }');
+ var library = checkLibrary('enum E1 { v1 } enum E2 { v2 }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+enum E1 { v1 }
+enum E2 { v2 }
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+enum E1 { v1 }
+enum E2 { v2 }
+''');
+ }
}
test_error_extendsEnum() {
- checkLibrary('''
+ var library = checkLibrary('''
enum E {a, b, c}
class M {}
@@ -2975,24 +6538,108 @@ class C extends Object with E, M {
class D = Object with M, E;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+enum E { a, b, c }
+class M {
+}
+class A {
+ foo() {}
+}
+class B implements M {
+ foo() {}
+}
+class C extends Object with M {
+ synthetic C();
+ foo() {}
+}
+class D extends Object with M {
+ synthetic D();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+enum E { a, b, c }
+class M {
+}
+class A {
+ foo() {}
+}
+class B implements M {
+ foo() {}
+}
+class C extends Object with M {
+ synthetic C();
+ foo() {}
+}
+class D extends Object with M {
+ synthetic D();
+}
+''');
+ }
}
test_executable_parameter_type_typedef() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
+typedef F(int p);
+main(F f) {}
+''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F(int p);
+main(F f) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
typedef F(int p);
main(F f) {}
''');
+ }
}
test_export_class() {
addLibrarySource('/a.dart', 'class C {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_class_type_alias() {
addLibrarySource(
'/a.dart', 'class C {} exends _D with _E; class _D {} class _E {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_configurations_useDefault() {
@@ -3005,6 +6652,19 @@ export 'foo.dart'
if (dart.library.io) 'foo_io.dart'
if (dart.library.html) 'foo_html.dart';
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'foo.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'foo.dart';
+''');
+ }
expect(library.exports[0].uri, 'foo.dart');
expect(library.exports[0].exportedLibrary.source.shortName, 'foo.dart');
}
@@ -3020,6 +6680,19 @@ export 'foo.dart'
if (dart.library.io) 'foo_io.dart'
if (dart.library.html) 'foo_html.dart';
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'foo_io.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'foo_io.dart';
+''');
+ }
expect(library.exports[0].uri, 'foo_io.dart');
expect(library.exports[0].exportedLibrary.source.shortName, 'foo_io.dart');
}
@@ -3035,6 +6708,19 @@ export 'foo.dart'
if (dart.library.io) 'foo_io.dart'
if (dart.library.html) 'foo_html.dart';
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'foo_html.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'foo_html.dart';
+''');
+ }
ExportElement export = library.exports[0];
expect(export.uri, 'foo_html.dart');
expect(export.exportedLibrary.source.shortName, 'foo_html.dart');
@@ -3042,52 +6728,182 @@ export 'foo.dart'
test_export_function() {
addLibrarySource('/a.dart', 'f() {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_getter() {
addLibrarySource('/a.dart', 'get f() => null;');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_hide() {
addLibrary('dart:async');
- checkLibrary('export "dart:async" hide Stream, Future;');
+ var library = checkLibrary('export "dart:async" hide Stream, Future;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'dart:async' hide Stream, Future;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'dart:async' hide Stream, Future;
+''');
+ }
}
test_export_multiple_combinators() {
addLibrary('dart:async');
- checkLibrary('export "dart:async" hide Stream show Future;');
+ var library = checkLibrary('export "dart:async" hide Stream show Future;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'dart:async' hide Stream show Future;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'dart:async' hide Stream show Future;
+''');
+ }
}
test_export_setter() {
addLibrarySource('/a.dart', 'void set f(value) {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_show() {
addLibrary('dart:async');
- checkLibrary('export "dart:async" show Future, Stream;');
+ var library = checkLibrary('export "dart:async" show Future, Stream;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'dart:async' show Future, Stream;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'dart:async' show Future, Stream;
+''');
+ }
}
test_export_typedef() {
addLibrarySource('/a.dart', 'typedef F();');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_variable() {
addLibrarySource('/a.dart', 'var x;');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_variable_const() {
addLibrarySource('/a.dart', 'const x = 0;');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_export_variable_final() {
addLibrarySource('/a.dart', 'final x = 0;');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_exportImport_configurations_useDefault() {
@@ -3106,6 +6922,23 @@ export 'foo.dart'
import 'bar.dart';
class B extends A {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'bar.dart';
+class B extends A {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'bar.dart';
+class B extends A {
+}
+''');
+ }
var typeA = library.definingCompilationUnit.getType('B').supertype;
expect(typeA.element.source.shortName, 'foo.dart');
}
@@ -3127,6 +6960,23 @@ export 'foo.dart'
import 'bar.dart';
class B extends A {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'bar.dart';
+class B extends A {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'bar.dart';
+class B extends A {
+}
+''');
+ }
var typeA = library.definingCompilationUnit.getType('B').supertype;
expect(typeA.element.source.shortName, 'foo_io.dart');
}
@@ -3134,215 +6984,843 @@ class B extends A {}
test_exports() {
addLibrarySource('/a.dart', 'library a;');
addLibrarySource('/b.dart', 'library b;');
- checkLibrary('export "a.dart"; export "b.dart";');
+ var library = checkLibrary('export "a.dart"; export "b.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+export 'b.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+export 'b.dart';
+''');
+ }
}
test_expr_invalid_typeParameter_asPrefix() {
variablesWithNotConstInitializers.add('f');
- checkLibrary('''
+ var library = checkLibrary('''
class C<T> {
final f = T.k;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ final f;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ final f;
+}
+''');
+ }
}
test_field_covariant() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
covariant int x;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ convariant int x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ convariant int x;
+}
+''');
+ }
}
test_field_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
/**
* Docs
*/
var x;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+}
+''');
+ }
}
test_field_formal_param_inferred_type_implicit() {
- checkLibrary('class C extends D { var v; C(this.v); }'
+ var library = checkLibrary('class C extends D { var v; C(this.v); }'
' abstract class D { int get v; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ int v;
+ C(int this.v);
+}
+abstract class D {
+ int get v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ var v;
+ C(this.v);
+}
+abstract class D {
+ int get v;
+}
+''');
+ }
}
test_field_inferred_type_nonStatic_explicit_initialized() {
- checkLibrary('class C { num v = 0; }');
+ var library = checkLibrary('class C { num v = 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ num v;
+}
+''');
+ }
}
test_field_inferred_type_nonStatic_implicit_initialized() {
- checkLibrary('class C { var v = 0; }');
+ var library = checkLibrary('class C { var v = 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var v;
+}
+''');
+ }
}
test_field_inferred_type_nonStatic_implicit_uninitialized() {
- checkLibrary(
+ var library = checkLibrary(
'class C extends D { var v; } abstract class D { int get v; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ int v;
+}
+abstract class D {
+ int get v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ var v;
+}
+abstract class D {
+ int get v;
+}
+''');
+ }
}
test_field_inferred_type_static_implicit_initialized() {
- checkLibrary('class C { static var v = 0; }');
+ var library = checkLibrary('class C { static var v = 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static int v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static var v;
+}
+''');
+ }
}
test_field_propagatedType_const_noDep() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
static const x = 0;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const int x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static const x;
+}
+''');
+ }
}
test_field_propagatedType_final_dep_inLib() {
addLibrarySource('/a.dart', 'final a = 1;');
- checkLibrary('''
+ var library = checkLibrary('''
import "a.dart";
class C {
final b = a / 2;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class C {
+ final num b;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class C {
+ final b;
+}
+''');
+ }
}
test_field_propagatedType_final_dep_inPart() {
addSource('/a.dart', 'part of lib; final a = 1;');
- checkLibrary('''
+ var library = checkLibrary('''
library lib;
part "a.dart";
class C {
final b = a / 2;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library lib;
+part 'a.dart';
+class C {
+ final num b;
+}
+--------------------
+unit: a.dart
+
+final int a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library lib;
+part 'a.dart';
+class C {
+ final b;
+}
+--------------------
+unit: a.dart
+
+final a;
+''');
+ }
}
test_field_propagatedType_final_noDep_instance() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
final x = 0;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final int x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ final x;
+}
+''');
+ }
}
test_field_propagatedType_final_noDep_static() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
static final x = 0;
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static final int x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static final x;
+}
+''');
+ }
}
test_field_static_final_untyped() {
- checkLibrary('class C { static final x = 0; }');
+ var library = checkLibrary('class C { static final x = 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static final int x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static final x;
+}
+''');
+ }
}
test_field_untyped() {
- checkLibrary('class C { var x = 0; }');
+ var library = checkLibrary('class C { var x = 0; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+}
+''');
+ }
}
test_function_async() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
Future f() async {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+Future f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+Future f() {}
+''');
+ }
}
test_function_asyncStar() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
Stream f() async* {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+Stream f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+Stream f() {}
+''');
+ }
}
test_function_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
f() {}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f() {}
+''');
+ }
}
test_function_entry_point() {
- checkLibrary('main() {}');
+ var library = checkLibrary('main() {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+main() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+main() {}
+''');
+ }
}
test_function_entry_point_in_export() {
addLibrarySource('/a.dart', 'library a; main() {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_function_entry_point_in_export_hidden() {
addLibrarySource('/a.dart', 'library a; main() {}');
- checkLibrary('export "a.dart" hide main;');
+ var library = checkLibrary('export "a.dart" hide main;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart' hide main;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart' hide main;
+''');
+ }
}
test_function_entry_point_in_part() {
addSource('/a.dart', 'part of my.lib; main() {}');
- checkLibrary('library my.lib; part "a.dart";');
+ var library = checkLibrary('library my.lib; part "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+main() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+main() {}
+''');
+ }
}
test_function_external() {
- checkLibrary('external f();');
+ var library = checkLibrary('external f();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+external f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+external f() {}
+''');
+ }
}
test_function_parameter_final() {
- checkLibrary('f(final x) {}');
+ var library = checkLibrary('f(final x) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f(final x) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f(final x) {}
+''');
+ }
}
test_function_parameter_kind_named() {
- checkLibrary('f({x}) {}');
+ var library = checkLibrary('f({x}) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f({x}) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f({x}) {}
+''');
+ }
}
test_function_parameter_kind_positional() {
- checkLibrary('f([x]) {}');
+ var library = checkLibrary('f([x]) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f([x]) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f([x]) {}
+''');
+ }
}
test_function_parameter_kind_required() {
- checkLibrary('f(x) {}');
+ var library = checkLibrary('f(x) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f(x) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f(x) {}
+''');
+ }
}
test_function_parameter_parameters() {
- checkLibrary('f(g(x, y)) {}');
+ var library = checkLibrary('f(g(x, y)) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f((dynamic, dynamic) → dynamic g) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f((dynamic, dynamic) → dynamic g) {}
+''');
+ }
}
test_function_parameter_return_type() {
- checkLibrary('f(int g()) {}');
+ var library = checkLibrary('f(int g()) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f(() → int g) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f(() → int g) {}
+''');
+ }
}
test_function_parameter_return_type_void() {
- checkLibrary('f(void g()) {}');
+ var library = checkLibrary('f(void g()) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f(() → void g) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f(() → void g) {}
+''');
+ }
}
test_function_parameter_type() {
- checkLibrary('f(int i) {}');
+ var library = checkLibrary('f(int i) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f(int i) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f(int i) {}
+''');
+ }
}
test_function_parameters() {
- checkLibrary('f(x, y) {}');
+ var library = checkLibrary('f(x, y) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f(x, y) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f(x, y) {}
+''');
+ }
}
test_function_return_type() {
- checkLibrary('int f() => null;');
+ var library = checkLibrary('int f() => null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+int f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+int f() {}
+''');
+ }
}
test_function_return_type_implicit() {
- checkLibrary('f() => null;');
+ var library = checkLibrary('f() => null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f() {}
+''');
+ }
}
test_function_return_type_void() {
- checkLibrary('void f() {}');
+ var library = checkLibrary('void f() {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f() {}
+''');
+ }
}
test_function_type_parameter() {
prepareAnalysisContext(createOptions());
- checkLibrary('T f<T, U>(U u) => null;');
+ var library = checkLibrary('T f<T, U>(U u) => null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+T f<T, U>(U u) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+T f<T, U>(U u) {}
+''');
+ }
}
test_function_type_parameter_with_function_typed_parameter() {
prepareAnalysisContext(createOptions());
- checkLibrary('void f<T, U>(T x(U u)) {}');
+ var library = checkLibrary('void f<T, U>(T x(U u)) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>((U) → T x) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>((U) → T x) {}
+''');
+ }
}
test_functions() {
- checkLibrary('f() {} g() {}');
+ var library = checkLibrary('f() {} g() {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f() {}
+g() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f() {}
+g() {}
+''');
+ }
}
test_futureOr() {
var library = checkLibrary('import "dart:async"; FutureOr<int> x;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+FutureOr<int> x;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+var x;
+''');
+ }
var variables = library.definingCompilationUnit.topLevelVariables;
expect(variables, hasLength(1));
if (createOptions().strongMode) {
@@ -3354,6 +7832,21 @@ f() {}''');
test_futureOr_const() {
var library = checkLibrary('import "dart:async"; const x = FutureOr;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+const Type x;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+const x;
+''');
+ }
var variables = library.definingCompilationUnit.topLevelVariables;
expect(variables, hasLength(1));
var x = variables[0] as ConstTopLevelVariableElementImpl;
@@ -3372,6 +7865,25 @@ FutureOr<int> f() => null;
var x = f();
var y = x.then((z) => z.asDouble());
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+FutureOr<int> x;
+var y;
+FutureOr<int> f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+var x;
+var y;
+f() {}
+''');
+ }
var variables = library.definingCompilationUnit.topLevelVariables;
expect(variables, hasLength(2));
var x = variables[0];
@@ -3389,7 +7901,7 @@ var y = x.then((z) => z.asDouble());
test_generic_gClass_gMethodStatic() {
prepareAnalysisContext(createOptions());
- checkLibrary('''
+ var library = checkLibrary('''
class C<T, U> {
static void m<V, W>(V v, W w) {
void f<X, Y>(V v, W w, X x, Y y) {
@@ -3397,6 +7909,23 @@ class C<T, U> {
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ static void m<V, W>(V v, W w) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ static void m<V, W>(V v, W w) {}
+}
+''');
+ }
}
test_getElement_constructor_named() {
@@ -3482,33 +8011,127 @@ class C<T, U> {
}
test_getter_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
get x => null;''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+get x {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+get x {}
+''');
+ }
}
test_getter_external() {
- checkLibrary('external int get x;');
+ var library = checkLibrary('external int get x;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+external int get x {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+external int get x {}
+''');
+ }
}
test_getter_inferred_type_nonStatic_implicit_return() {
- checkLibrary(
+ var library = checkLibrary(
'class C extends D { get f => null; } abstract class D { int get f; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ int get f {}
+}
+abstract class D {
+ int get f;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ get f {}
+}
+abstract class D {
+ int get f;
+}
+''');
+ }
}
test_getters() {
- checkLibrary('int get x => null; get y => null;');
+ var library = checkLibrary('int get x => null; get y => null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+int get x {}
+get y {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+int get x {}
+get y {}
+''');
+ }
}
test_implicitTopLevelVariable_getterFirst() {
- checkLibrary('int get x => 0; void set x(int value) {}');
+ var library = checkLibrary('int get x => 0; void set x(int value) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+int get x {}
+void set x(int value) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+int get x {}
+void set x(int value) {}
+''');
+ }
}
test_implicitTopLevelVariable_setterFirst() {
- checkLibrary('void set x(int value) {} int get x => 0;');
+ var library = checkLibrary('void set x(int value) {} int get x => 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void set x(int value) {}
+int get x {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void set x(int value) {}
+int get x {}
+''');
+ }
}
test_import_configurations_useDefault() {
@@ -3523,6 +8146,23 @@ import 'foo.dart'
class B extends A {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class B extends A {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+class B extends A {
+}
+''');
+ }
var typeA = library.definingCompilationUnit.getType('B').supertype;
expect(typeA.element.source.shortName, 'foo.dart');
}
@@ -3540,28 +8180,108 @@ import 'foo.dart'
class B extends A {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo_io.dart';
+class B extends A {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo_io.dart';
+class B extends A {
+}
+''');
+ }
var typeA = library.definingCompilationUnit.getType('B').supertype;
expect(typeA.element.source.shortName, 'foo_io.dart');
}
test_import_deferred() {
addLibrarySource('/a.dart', 'f() {}');
- checkLibrary('import "a.dart" deferred as p; main() { p.f(); }');
+ var library =
+ checkLibrary('import "a.dart" deferred as p; main() { p.f(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' deferred as p;
+main() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' deferred as p;
+main() {}
+''');
+ }
}
test_import_hide() {
addLibrary('dart:async');
- checkLibrary('import "dart:async" hide Stream, Completer; Future f;');
+ var library =
+ checkLibrary('import "dart:async" hide Stream, Completer; Future f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' hide Stream, Completer;
+Future f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' hide Stream, Completer;
+Future f;
+''');
+ }
}
test_import_multiple_combinators() {
addLibrary('dart:async');
- checkLibrary('import "dart:async" hide Stream show Future; Future f;');
+ var library =
+ checkLibrary('import "dart:async" hide Stream show Future; Future f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' hide Stream show Future;
+Future f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' hide Stream show Future;
+Future f;
+''');
+ }
}
test_import_prefixed() {
addLibrarySource('/a.dart', 'library a; class C {}');
- checkLibrary('import "a.dart" as a; a.C c;');
+ var library = checkLibrary('import "a.dart" as a; a.C c;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as a;
+C c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as a;
+C c;
+''');
+ }
}
test_import_self() {
@@ -3574,6 +8294,27 @@ class D extends p.C {} // Prevent "unused import" warning
expect(resynthesized.imports[0].importedLibrary.location,
resynthesized.location);
expect(resynthesized.imports[1].importedLibrary.isDartCore, true);
+ if (isStrongMode) {
+ checkElementText(
+ resynthesized,
+ r'''
+import 'test.dart' as p;
+class C {
+}
+class D extends C {
+}
+''');
+ } else {
+ checkElementText(
+ resynthesized,
+ r'''
+import 'test.dart' as p;
+class C {
+}
+class D extends C {
+}
+''');
+ }
}
test_import_short_absolute() {
@@ -3582,78 +8323,212 @@ class D extends p.C {} // Prevent "unused import" warning
var destinationPath =
resourceProvider.pathContext.fromUri(Uri.parse('/a.dart'));
addLibrarySource(destinationPath, 'class C {}');
- checkLibrary('import "/a.dart"; C c;');
+ var library = checkLibrary('import "/a.dart"; C c;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import '/a.dart';
+C c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import '/a.dart';
+C c;
+''');
+ }
}
test_import_show() {
addLibrary('dart:async');
- checkLibrary('''
+ var library = checkLibrary('''
import "dart:async" show Future, Stream;
Future f;
Stream s;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' show Future, Stream;
+Future f;
+Stream s;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' show Future, Stream;
+Future f;
+Stream s;
+''');
+ }
}
test_imports() {
addLibrarySource('/a.dart', 'library a; class C {}');
addLibrarySource('/b.dart', 'library b; class D {}');
- checkLibrary('import "a.dart"; import "b.dart"; C c; D d;');
+ var library = checkLibrary('import "a.dart"; import "b.dart"; C c; D d;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+import 'b.dart';
+C c;
+D d;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+import 'b.dart';
+C c;
+D d;
+''');
+ }
}
test_inferred_function_type_for_variable_in_generic_function() {
// In the code below, `x` has an inferred type of `() => int`, with 2
// (unused) type parameters from the enclosing top level function.
- checkLibrary('''
+ var library = checkLibrary('''
f<U, V>() {
var x = () => 0;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f<U, V>() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f<U, V>() {}
+''');
+ }
}
test_inferred_function_type_in_generic_class_constructor() {
// In the code below, `() => () => 0` has an inferred return type of
// `() => int`, with 2 (unused) type parameters from the enclosing class.
- checkLibrary('''
+ var library = checkLibrary('''
class C<U, V> {
final x;
C() : x = (() => () => 0);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<U, V> {
+ final x;
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<U, V> {
+ final x;
+ C();
+}
+''');
+ }
}
test_inferred_function_type_in_generic_class_getter() {
// In the code below, `() => () => 0` has an inferred return type of
// `() => int`, with 2 (unused) type parameters from the enclosing class.
- checkLibrary('''
+ var library = checkLibrary('''
class C<U, V> {
get x => () => () => 0;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<U, V> {
+ get x {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<U, V> {
+ get x {}
+}
+''');
+ }
}
test_inferred_function_type_in_generic_class_in_generic_method() {
// In the code below, `() => () => 0` has an inferred return type of
// `() => int`, with 3 (unused) type parameters from the enclosing class
// and method.
- checkLibrary('''
+ var library = checkLibrary('''
class C<T> {
f<U, V>() {
print(() => () => 0);
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ f<U, V>() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ f<U, V>() {}
+}
+''');
+ }
}
test_inferred_function_type_in_generic_class_setter() {
// In the code below, `() => () => 0` has an inferred return type of
// `() => int`, with 2 (unused) type parameters from the enclosing class.
- checkLibrary('''
+ var library = checkLibrary('''
class C<U, V> {
void set x(value) {
print(() => () => 0);
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<U, V> {
+ void set x(value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<U, V> {
+ void set x(value) {}
+}
+''');
+ }
}
test_inferred_function_type_in_generic_closure() {
@@ -3668,11 +8543,23 @@ class C<U, V> {
}
// In the code below, `<U, V>() => () => 0` has an inferred return type of
// `() => int`, with 3 (unused) type parameters.
- checkLibrary('''
+ var library = checkLibrary('''
f<T>() {
print(/*<U, V>*/() => () => 0);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f<T>() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+''');
+ }
}
test_inferred_generic_function_type_in_generic_closure() {
@@ -3687,35 +8574,136 @@ f<T>() {
}
// In the code below, `<U, V>() => <W, X, Y, Z>() => 0` has an inferred
// return type of `() => int`, with 7 (unused) type parameters.
- checkLibrary('''
+ var library = checkLibrary('''
f<T>() {
print(/*<U, V>*/() => /*<W, X, Y, Z>*/() => 0);
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f<T>() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+''');
+ }
}
test_inferred_type_is_typedef() {
- checkLibrary('typedef int F(String s);'
+ var library = checkLibrary('typedef int F(String s);'
' class C extends D { var v; }'
' abstract class D { F get v; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef int F(String s);
+class C extends D {
+ F v;
+}
+abstract class D {
+ F get v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef int F(String s);
+class C extends D {
+ var v;
+}
+abstract class D {
+ F get v;
+}
+''');
+ }
}
test_inferred_type_refers_to_bound_type_param() {
- checkLibrary('class C<T> extends D<int, T> { var v; }'
+ var library = checkLibrary('class C<T> extends D<int, T> { var v; }'
' abstract class D<U, V> { Map<V, U> get v; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> extends D<int, T> {
+ Map<T, int> v;
+}
+abstract class D<U, V> {
+ Map<V, U> get v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> extends D<int, T> {
+ var v;
+}
+abstract class D<U, V> {
+ Map<V, U> get v;
+}
+''');
+ }
}
void test_inferred_type_refers_to_function_typed_param_of_typedef() {
- checkLibrary('''
+ var library = checkLibrary('''
typedef void F(int g(String s));
h(F f) => null;
var v = h(/*info:INFERRED_TYPE_CLOSURE*/(y) {});
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef void F((String) → int g);
+var v;
+h(F f) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef void F((String) → int g);
+var v;
+h(F f) {}
+''');
+ }
}
test_inferred_type_refers_to_function_typed_parameter_type_generic_class() {
- checkLibrary('class C<T, U> extends D<U, int> { void f(int x, g) {} }'
- ' abstract class D<V, W> { void f(int x, W g(V s)); }');
+ var library =
+ checkLibrary('class C<T, U> extends D<U, int> { void f(int x, g) {} }'
+ ' abstract class D<V, W> { void f(int x, W g(V s)); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> extends D<U, int> {
+ void f(int x, (U) → int g) {}
+}
+abstract class D<V, W> {
+ void f(int x, (V) → W g);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> extends D<U, int> {
+ void f(int x, g) {}
+}
+abstract class D<V, W> {
+ void f(int x, (V) → W g);
+}
+''');
+ }
}
test_inferred_type_refers_to_function_typed_parameter_type_other_lib() {
@@ -3723,31 +8711,127 @@ var v = h(/*info:INFERRED_TYPE_CLOSURE*/(y) {});
'/a.dart', 'import "b.dart"; abstract class D extends E {}');
addLibrarySource(
'/b.dart', 'abstract class E { void f(int x, int g(String s)); }');
- checkLibrary('import "a.dart"; class C extends D { void f(int x, g) {} }');
+ var library = checkLibrary(
+ 'import "a.dart"; class C extends D { void f(int x, g) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class C extends D {
+ void f(int x, (String) → int g) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class C extends D {
+ void f(int x, g) {}
+}
+''');
+ }
}
test_inferred_type_refers_to_method_function_typed_parameter_type() {
- checkLibrary('class C extends D { void f(int x, g) {} }'
+ var library = checkLibrary('class C extends D { void f(int x, g) {} }'
' abstract class D { void f(int x, int g(String s)); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void f(int x, (String) → int g) {}
+}
+abstract class D {
+ void f(int x, (String) → int g);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void f(int x, g) {}
+}
+abstract class D {
+ void f(int x, (String) → int g);
+}
+''');
+ }
}
test_inferred_type_refers_to_nested_function_typed_param() {
- checkLibrary('''
+ var library = checkLibrary('''
f(void g(int x, void h())) => null;
var v = f((x, y) {});
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+var v;
+f((int, () → void) → void g) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+var v;
+f((int, () → void) → void g) {}
+''');
+ }
}
test_inferred_type_refers_to_nested_function_typed_param_named() {
- checkLibrary('''
+ var library = checkLibrary('''
f({void g(int x, void h())}) => null;
var v = f(g: (x, y) {});
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+var v;
+f({(int, () → void) → void g}) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+var v;
+f({(int, () → void) → void g}) {}
+''');
+ }
}
test_inferred_type_refers_to_setter_function_typed_parameter_type() {
- checkLibrary('class C extends D { void set f(g) {} }'
+ var library = checkLibrary('class C extends D { void set f(g) {} }'
' abstract class D { void set f(int g(String s)); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void set f((String) → int g) {}
+}
+abstract class D {
+ void set f((String) → int g);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void set f(g) {}
+}
+abstract class D {
+ void set f((String) → int g);
+}
+''');
+ }
}
void test_inferredType_definedInSdkLibraryPart() {
@@ -3765,6 +8849,25 @@ class B extends A {
m(p) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class B extends A {
+ m(Stream p) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class B extends A {
+ m(p) {}
+}
+''');
+ }
ClassElement b = library.definingCompilationUnit.types[0];
ParameterElement p = b.methods[0].parameters[0];
// This test should verify that we correctly record inferred types,
@@ -3777,15 +8880,32 @@ class B extends A {
}
void test_inferredType_usesSyntheticFunctionType_functionTypedParam() {
- checkLibrary('''
+ var library = checkLibrary('''
int f(int x(String y)) => null;
String g(int x(String y)) => null;
var v = [f, g];
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+List<((String) → int) → Object> v;
+int f((String) → int x) {}
+String g((String) → int x) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+var v;
+int f((String) → int x) {}
+String g((String) → int x) {}
+''');
+ }
}
test_inheritance_errors() {
- checkLibrary('''
+ var library = checkLibrary('''
abstract class A {
int m();
}
@@ -3800,63 +8920,214 @@ abstract class D extends C {
var f;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+abstract class A {
+ int m();
+}
+abstract class B {
+ String m();
+}
+abstract class C implements A, B {
+}
+abstract class D extends C {
+ var f;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+abstract class A {
+ int m();
+}
+abstract class B {
+ String m();
+}
+abstract class C implements A, B {
+}
+abstract class D extends C {
+ var f;
+}
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure() {
- checkLibrary('var v = () => 0;');
+ var library = checkLibrary('var v = () => 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+() → int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+var v;
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure_await_dynamic() {
- checkLibrary('var v = (f) async => await f;');
+ var library = checkLibrary('var v = (f) async => await f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+(dynamic) → Future<dynamic> v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+var v;
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure_await_future3_int() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
var v = (Future<Future<Future<int>>> f) async => await f;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+(Future<Future<Future<int>>>) → Future<int> v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+var v;
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure_await_future_int() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
var v = (Future<int> f) async => await f;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+(Future<int>) → Future<int> v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+var v;
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure_await_future_noArg() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
var v = (Future f) async => await f;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+(Future<dynamic>) → Future<dynamic> v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+var v;
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure_field() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
var v = () => 0;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ () → int v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var v;
+}
+''');
+ }
}
test_initializer_executable_with_return_type_from_closure_local() {
- checkLibrary('''
+ var library = checkLibrary('''
void f() {
int u = 0;
var v = () => 0;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f() {}
+''');
+ }
}
test_instantiateToBounds_boundRefersToEarlierTypeArgument() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<S extends num, T extends C<S, T>> {}
C c;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<S extends num, T extends C<S, T>> {
+}
+C<num, C<num, dynamic>> c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<S extends num, T extends C<S, T>> {
+}
+C c;
+''');
+ }
}
test_instantiateToBounds_boundRefersToItself() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T extends C<T>> {}
C c;
var c2 = new C();
@@ -3864,27 +9135,101 @@ class B {
var c3 = new C();
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T extends C<T>> {
+}
+class B {
+ C<C> c3;
+}
+C<C> c;
+C<C> c2;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T extends C<T>> {
+}
+class B {
+ var c3;
+}
+C c;
+var c2;
+''');
+ }
}
test_instantiateToBounds_boundRefersToLaterTypeArgument() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T extends C<T, U>, U extends num> {}
C c;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T extends C<T, U>, U extends num> {
+}
+C<C<dynamic, num>, num> c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T extends C<T, U>, U extends num> {
+}
+C c;
+''');
+ }
}
test_instantiateToBounds_functionTypeAlias_simple() {
- checkLibrary('''
+ var library = checkLibrary('''
+typedef F<T extends num>(T p);
+F f;
+''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F<T extends num>(T p);
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
typedef F<T extends num>(T p);
F f;
''');
+ }
}
test_instantiateToBounds_simple() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T extends num> {}
C c;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T extends num> {
+}
+C<num> c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T extends num> {
+}
+C c;
+''');
+ }
}
test_invalid_annotation_prefixed_constructor() {
@@ -3895,11 +9240,28 @@ class C {
const C.named();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import "a.dart" as a;
@a.C.named
class D {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as a;
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as a;
+class D {
+}
+''');
+ }
}
test_invalid_annotation_unprefixed_constructor() {
@@ -3910,31 +9272,84 @@ class C {
const C.named();
}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import "a.dart";
@C.named
class D {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+class D {
+}
+''');
+ }
}
test_invalid_importPrefix_asTypeArgument() {
- checkLibrary('''
+ var library = checkLibrary('''
import 'dart:async' as ppp;
class C {
List<ppp> v;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as ppp;
+class C {
+ List v;
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as ppp;
+class C {
+ List v;
+}
+''');
+ }
}
test_invalid_nameConflict_imported() {
namesThatCannotBeResolved.add('V');
addLibrarySource('/a.dart', 'V() {}');
addLibrarySource('/b.dart', 'V() {}');
- checkLibrary('''
+ var library = checkLibrary('''
import 'a.dart';
import 'b.dart';
foo([p = V]) {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+import 'b.dart';
+foo([p]) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+import 'b.dart';
+foo([p]) {}
+''');
+ }
}
test_invalid_nameConflict_imported_exported() {
@@ -3947,41 +9362,109 @@ foo([p = V]) {}
export 'a.dart';
export 'b.dart';
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'c.dart';
foo([p = V]) {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'c.dart';
+foo([p]) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'c.dart';
+foo([p]) {}
+''');
+ }
}
test_invalid_nameConflict_local() {
namesThatCannotBeResolved.add('V');
- checkLibrary('''
+ var library = checkLibrary('''
foo([p = V]) {}
V() {}
var V;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+var V;
+foo([p]) {}
+V() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+var V;
+foo([p]) {}
+V() {}
+''');
+ }
}
test_invalid_setterParameter_fieldFormalParameter() {
- checkLibrary('''
+ var library = checkLibrary('''
+class C {
+ int foo;
+ void set bar(this.foo) {}
+}
+''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int foo;
+ void set bar(this.foo) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
class C {
int foo;
void set bar(this.foo) {}
}
''');
+ }
}
test_invalid_setterParameter_fieldFormalParameter_self() {
- checkLibrary('''
+ var library = checkLibrary('''
+class C {
+ set x(this.x) {}
+}
+''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(this.x) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
class C {
set x(this.x) {}
}
''');
+ }
}
test_invalidUris() {
allowMissingFiles = true;
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import '[invalid uri]';
import '[invalid uri]:foo.dart';
import 'a1.dart';
@@ -3998,31 +9481,104 @@ part '[invalid uri]';
part 'a3.dart';
part '[invalid uri]';
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a1.dart';
+export 'a2.dart';
+part 'a3.dart';
+--------------------
+unit: a3.dart
+
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a1.dart';
+export 'a2.dart';
+part 'a3.dart';
+--------------------
+unit: a3.dart
+
+''');
+ }
}
test_library() {
- checkLibrary('');
+ var library = checkLibrary('');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+''');
+ }
}
test_library_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
library foo;''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library foo;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library foo;
+''');
+ }
}
test_library_name_with_spaces() {
- checkLibrary('library foo . bar ;');
+ var library = checkLibrary('library foo . bar ;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library foo.bar;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library foo.bar;
+''');
+ }
}
test_library_named() {
- checkLibrary('library foo.bar;');
+ var library = checkLibrary('library foo.bar;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library foo.bar;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library foo.bar;
+''');
+ }
}
test_localFunctions() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
f() {
f1() {}
{
@@ -4030,38 +9586,98 @@ f() {
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f() {}
+''');
+ }
}
test_localFunctions_inConstructor() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
C() {
f() {}
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ }
}
test_localFunctions_inMethod() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
m() {
f() {}
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ m() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ m() {}
+}
+''');
+ }
}
test_localFunctions_inTopLevelGetter() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
get g {
f() {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+get g {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+get g {}
+''');
+ }
}
test_localLabels_inConstructor() {
- checkLibrary(
+ var library = checkLibrary(
r'''
class C {
C() {
@@ -4074,10 +9690,27 @@ class C {
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ }
}
test_localLabels_inMethod() {
- checkLibrary(
+ var library = checkLibrary(
r'''
class C {
m() {
@@ -4090,10 +9723,27 @@ class C {
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ m() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ m() {}
+}
+''');
+ }
}
test_localLabels_inTopLevelFunction() {
- checkLibrary(
+ var library = checkLibrary(
r'''
main() {
aaa: while (true) {}
@@ -4104,10 +9754,23 @@ main() {
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+main() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+main() {}
+''');
+ }
}
test_localVariables_inConstructor() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
C() {
int v;
@@ -4115,10 +9778,27 @@ class C {
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+''');
+ }
}
test_localVariables_inLocalFunction() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
f() {
f1() {
int v1 = 1;
@@ -4131,20 +9811,50 @@ f() {
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f() {}
+''');
+ }
}
test_localVariables_inMethod() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
class C {
m() {
int v;
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ m() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ m() {}
+}
+''');
+ }
}
test_localVariables_inTopLevelFunction() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
main() {
int v1 = 1;
{
@@ -4153,260 +9863,1212 @@ main() {
Map<int, List<double>> v3;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+main() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+main() {}
+''');
+ }
}
test_localVariables_inTopLevelGetter() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
get g {
int v;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+get g {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+get g {}
+''');
+ }
}
test_main_class() {
- checkLibrary('class main {}');
+ var library = checkLibrary('class main {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class main {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class main {
+}
+''');
+ }
}
test_main_class_alias() {
- checkLibrary('class main = C with D; class C {} class D {}');
+ var library = checkLibrary('class main = C with D; class C {} class D {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class main extends C with D {
+ synthetic main();
+}
+class C {
+}
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class main extends C with D {
+ synthetic main();
+}
+class C {
+}
+class D {
+}
+''');
+ }
}
test_main_class_alias_via_export() {
addLibrarySource('/a.dart', 'class main = C with D; class C {} class D {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_main_class_via_export() {
addLibrarySource('/a.dart', 'class main {}');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_main_getter() {
- checkLibrary('get main => null;');
+ var library = checkLibrary('get main => null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+get main {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+get main {}
+''');
+ }
}
test_main_getter_via_export() {
addLibrarySource('/a.dart', 'get main => null;');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_main_typedef() {
- checkLibrary('typedef main();');
+ var library = checkLibrary('typedef main();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef main();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef main();
+''');
+ }
}
test_main_typedef_via_export() {
addLibrarySource('/a.dart', 'typedef main();');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_main_variable() {
- checkLibrary('var main;');
+ var library = checkLibrary('var main;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+var main;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+var main;
+''');
+ }
}
test_main_variable_via_export() {
addLibrarySource('/a.dart', 'var main;');
- checkLibrary('export "a.dart";');
+ var library = checkLibrary('export "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'a.dart';
+''');
+ }
}
test_member_function_async() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
class C {
Future f() async {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+class C {
+ Future f() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+class C {
+ Future f() {}
+}
+''');
+ }
}
test_member_function_asyncStar() {
- checkLibrary(r'''
+ var library = checkLibrary(r'''
import 'dart:async';
class C {
Stream f() async* {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+class C {
+ Stream f() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async';
+class C {
+ Stream f() {}
+}
+''');
+ }
}
test_metadata_classDeclaration() {
- checkLibrary('const a = null; @a class C {}');
+ var library = checkLibrary('const a = null; @a class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+const a;
+''');
+ }
}
test_metadata_classTypeAlias() {
- checkLibrary(
+ var library = checkLibrary(
'const a = null; @a class C = D with E; class D {} class E {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D with E {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D with E {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+const a;
+''');
+ }
}
test_metadata_constructor_call_named() {
- checkLibrary('class A { const A.named(); } @A.named() class C {}');
+ var library =
+ checkLibrary('class A { const A.named(); } @A.named() class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A.named();
+}
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A.named();
+}
+class C {
+}
+''');
+ }
}
test_metadata_constructor_call_named_prefixed() {
addLibrarySource('/foo.dart', 'class A { const A.named(); }');
- checkLibrary('import "foo.dart" as foo; @foo.A.named() class C {}');
+ var library =
+ checkLibrary('import "foo.dart" as foo; @foo.A.named() class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C {
+}
+''');
+ }
}
test_metadata_constructor_call_unnamed() {
- checkLibrary('class A { const A(); } @A() class C {}');
+ var library = checkLibrary('class A { const A(); } @A() class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A();
+}
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A();
+}
+class C {
+}
+''');
+ }
}
test_metadata_constructor_call_unnamed_prefixed() {
addLibrarySource('/foo.dart', 'class A { const A(); }');
- checkLibrary('import "foo.dart" as foo; @foo.A() class C {}');
+ var library = checkLibrary('import "foo.dart" as foo; @foo.A() class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart' as foo;
+class C {
+}
+''');
+ }
}
test_metadata_constructor_call_with_args() {
- checkLibrary('class A { const A(x); } @A(null) class C {}');
+ var library = checkLibrary('class A { const A(x); } @A(null) class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A(x);
+}
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A(x);
+}
+class C {
+}
+''');
+ }
}
test_metadata_constructorDeclaration_named() {
- checkLibrary('const a = null; class C { @a C.named(); }');
+ var library = checkLibrary('const a = null; class C { @a C.named(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.named();
+}
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.named();
+}
+const a;
+''');
+ }
}
test_metadata_constructorDeclaration_unnamed() {
- checkLibrary('const a = null; class C { @a C(); }');
+ var library = checkLibrary('const a = null; class C { @a C(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C();
+}
+const a;
+''');
+ }
}
test_metadata_enumDeclaration() {
- checkLibrary('const a = null; @a enum E { v }');
+ var library = checkLibrary('const a = null; @a enum E { v }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+enum E { v }
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+enum E { v }
+const a;
+''');
+ }
}
test_metadata_exportDirective() {
addLibrarySource('/foo.dart', '');
- checkLibrary('@a export "foo.dart"; const a = null;');
+ var library = checkLibrary('@a export "foo.dart"; const a = null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'foo.dart';
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'foo.dart';
+const a;
+''');
+ }
}
test_metadata_fieldDeclaration() {
- checkLibrary('const a = null; class C { @a int x; }');
+ var library = checkLibrary('const a = null; class C { @a int x; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+}
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ int x;
+}
+const a;
+''');
+ }
}
test_metadata_fieldFormalParameter() {
- checkLibrary('const a = null; class C { var x; C(@a this.x); }');
+ var library =
+ checkLibrary('const a = null; class C { var x; C(@a this.x); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(this.x);
+}
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C(this.x);
+}
+const a;
+''');
+ }
}
test_metadata_fieldFormalParameter_withDefault() {
- checkLibrary('const a = null; class C { var x; C([@a this.x = null]); }');
+ var library = checkLibrary(
+ 'const a = null; class C { var x; C([@a this.x = null]); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C([this.x]);
+}
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C([this.x]);
+}
+const a;
+''');
+ }
}
test_metadata_functionDeclaration_function() {
- checkLibrary('const a = null; @a f() {}');
+ var library = checkLibrary('const a = null; @a f() {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const a;
+f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const a;
+f() {}
+''');
+ }
}
test_metadata_functionDeclaration_getter() {
- checkLibrary('const a = null; @a get f => null;');
+ var library = checkLibrary('const a = null; @a get f => null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const a;
+get f {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const a;
+get f {}
+''');
+ }
}
test_metadata_functionDeclaration_setter() {
- checkLibrary('const a = null; @a set f(value) {}');
+ var library = checkLibrary('const a = null; @a set f(value) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const a;
+void set f(value) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const a;
+set f(value) {}
+''');
+ }
}
test_metadata_functionTypeAlias() {
- checkLibrary('const a = null; @a typedef F();');
+ var library = checkLibrary('const a = null; @a typedef F();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F();
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F();
+const a;
+''');
+ }
}
test_metadata_functionTypedFormalParameter() {
- checkLibrary('const a = null; f(@a g()) {}');
+ var library = checkLibrary('const a = null; f(@a g()) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const a;
+f(() → dynamic g) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const a;
+f(() → dynamic g) {}
+''');
+ }
}
test_metadata_functionTypedFormalParameter_withDefault() {
- checkLibrary('const a = null; f([@a g() = null]) {}');
+ var library = checkLibrary('const a = null; f([@a g() = null]) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const a;
+f([() → dynamic g]) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const a;
+f([() → dynamic g]) {}
+''');
+ }
}
test_metadata_importDirective() {
addLibrarySource('/foo.dart', 'const b = null;');
- checkLibrary('@a import "foo.dart"; const a = b;');
+ var library = checkLibrary('@a import "foo.dart"; const a = b;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+const a;
+''');
+ }
}
test_metadata_invalid_classDeclaration() {
- checkLibrary('f(_) {} @f(42) class C {}');
+ var library = checkLibrary('f(_) {} @f(42) class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+f(_) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+f(_) {}
+''');
+ }
}
test_metadata_libraryDirective() {
- checkLibrary('@a library L; const a = null;');
+ var library = checkLibrary('@a library L; const a = null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library L;
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library L;
+const a;
+''');
+ }
}
test_metadata_methodDeclaration_getter() {
- checkLibrary('const a = null; class C { @a get m => null; }');
+ var library = checkLibrary('const a = null; class C { @a get m => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ get m {}
+}
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ get m {}
+}
+const a;
+''');
+ }
}
test_metadata_methodDeclaration_method() {
- checkLibrary('const a = null; class C { @a m() {} }');
+ var library = checkLibrary('const a = null; class C { @a m() {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ m() {}
+}
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ m() {}
+}
+const a;
+''');
+ }
}
test_metadata_methodDeclaration_setter() {
- checkLibrary('const a = null; class C { @a set m(value) {} }');
+ var library =
+ checkLibrary('const a = null; class C { @a set m(value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set m(value) {}
+}
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ set m(value) {}
+}
+const a;
+''');
+ }
}
test_metadata_partDirective() {
addSource('/foo.dart', 'part of L;');
- checkLibrary('library L; @a part "foo.dart"; const a = null;');
+ var library =
+ checkLibrary('library L; @a part "foo.dart"; const a = null;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library L;
+part 'foo.dart';
+const a;
+--------------------
+unit: foo.dart
+
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library L;
+part 'foo.dart';
+const a;
+--------------------
+unit: foo.dart
+
+''');
+ }
}
test_metadata_prefixed_variable() {
addLibrarySource('/a.dart', 'const b = null;');
- checkLibrary('import "a.dart" as a; @a.b class C {}');
+ var library = checkLibrary('import "a.dart" as a; @a.b class C {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as a;
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart' as a;
+class C {
+}
+''');
+ }
}
test_metadata_simpleFormalParameter() {
- checkLibrary('const a = null; f(@a x) {}');
+ var library = checkLibrary('const a = null; f(@a x) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const a;
+f(x) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const a;
+f(x) {}
+''');
+ }
}
test_metadata_simpleFormalParameter_withDefault() {
- checkLibrary('const a = null; f([@a x = null]) {}');
+ var library = checkLibrary('const a = null; f([@a x = null]) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const a;
+f([x]) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const a;
+f([x]) {}
+''');
+ }
}
test_metadata_topLevelVariableDeclaration() {
- checkLibrary('const a = null; @a int v;');
+ var library = checkLibrary('const a = null; @a int v;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const a;
+int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const a;
+int v;
+''');
+ }
}
test_metadata_typeParameter_ofClass() {
- checkLibrary('const a = null; class C<@a T> {}');
+ var library = checkLibrary('const a = null; class C<@a T> {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+}
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+}
+const a;
+''');
+ }
}
test_metadata_typeParameter_ofClassTypeAlias() {
- checkLibrary(
+ var library = checkLibrary(
'const a = null; class C<@a T> = D with E; class D {} class E {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> extends D with E {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> extends D with E {
+ synthetic C();
+}
+class D {
+}
+class E {
+}
+const a;
+''');
+ }
}
test_metadata_typeParameter_ofFunction() {
- checkLibrary('const a = null; f<@a T>() {}');
+ var library = checkLibrary('const a = null; f<@a T>() {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const a;
+f<T>() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const a;
+f<T>() {}
+''');
+ }
}
test_metadata_typeParameter_ofTypedef() {
- checkLibrary('const a = null; typedef F<@a T>();');
+ var library = checkLibrary('const a = null; typedef F<@a T>();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F<T>();
+const a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F<T>();
+const a;
+''');
+ }
}
test_method_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
class C {
/**
* Docs
*/
f() {}
}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ f() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ f() {}
+}
+''');
+ }
}
test_method_inferred_type_nonStatic_implicit_param() {
- checkLibrary('class C extends D { void f(value) {} }'
+ var library = checkLibrary('class C extends D { void f(value) {} }'
' abstract class D { void f(int value); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void f(int value) {}
+}
+abstract class D {
+ void f(int value);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void f(value) {}
+}
+abstract class D {
+ void f(int value);
+}
+''');
+ }
}
test_method_inferred_type_nonStatic_implicit_return() {
- checkLibrary(
+ var library = checkLibrary(
'class C extends D { f() => null; } abstract class D { int f(); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ int f() {}
+}
+abstract class D {
+ int f();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ f() {}
+}
+abstract class D {
+ int f();
+}
+''');
+ }
}
test_method_type_parameter() {
prepareAnalysisContext(createOptions());
- checkLibrary('class C { T f<T, U>(U u) => null; }');
+ var library = checkLibrary('class C { T f<T, U>(U u) => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ T f<T, U>(U u) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ T f<T, U>(U u) {}
+}
+''');
+ }
}
test_method_type_parameter_in_generic_class() {
prepareAnalysisContext(createOptions());
- checkLibrary('class C<T, U> { V f<V, W>(T t, U u, W w) => null; }');
+ var library =
+ checkLibrary('class C<T, U> { V f<V, W>(T t, U u, W w) => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ V f<V, W>(T t, U u, W w) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ V f<V, W>(T t, U u, W w) {}
+}
+''');
+ }
}
test_method_type_parameter_with_function_typed_parameter() {
prepareAnalysisContext(createOptions());
- checkLibrary('class C { void f<T, U>(T x(U u)) {} }');
+ var library = checkLibrary('class C { void f<T, U>(T x(U u)) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void f<T, U>((U) → T x) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void f<T, U>((U) → T x) {}
+}
+''');
+ }
}
test_nameConflict_exportedAndLocal() {
@@ -4418,10 +11080,25 @@ class C {
export 'a.dart';
class C {}
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'c.dart';
C v = null;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'c.dart';
+C v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'c.dart';
+C v;
+''');
+ }
}
test_nameConflict_exportedAndLocal_exported() {
@@ -4434,10 +11111,25 @@ export 'a.dart';
class C {}
''');
addLibrarySource('/d.dart', 'export "c.dart";');
- checkLibrary('''
+ var library = checkLibrary('''
import 'd.dart';
C v = null;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'd.dart';
+C v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'd.dart';
+C v;
+''');
+ }
}
test_nameConflict_exportedAndParted() {
@@ -4456,10 +11148,25 @@ library lib;
export 'a.dart';
part 'b.dart';
''');
- checkLibrary('''
+ var library = checkLibrary('''
import 'c.dart';
C v = null;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'c.dart';
+C v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'c.dart';
+C v;
+''');
+ }
}
test_nameConflict_importWithRelativeUri_exportWithAbsolute() {
@@ -4469,15 +11176,32 @@ C v = null;
addLibrarySource('/a.dart', 'class A {}');
addLibrarySource('/b.dart', 'export "/a.dart";');
- checkLibrary('''
+ var library = checkLibrary('''
import 'a.dart';
import 'b.dart';
A v = null;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+import 'b.dart';
+A v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+import 'b.dart';
+A v;
+''');
+ }
}
test_nested_generic_functions_in_generic_class_with_function_typed_params() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T, U> {
void g<V, W>() {
void h<X, Y>(void p(T t, U u, V v, W w, X x, Y y)) {
@@ -4485,10 +11209,27 @@ class C<T, U> {
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ void g<V, W>() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ void g<V, W>() {}
+}
+''');
+ }
}
test_nested_generic_functions_in_generic_class_with_local_variables() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T, U> {
void g<V, W>() {
void h<X, Y>() {
@@ -4502,10 +11243,27 @@ class C<T, U> {
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ void g<V, W>() {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ void g<V, W>() {}
+}
+''');
+ }
}
test_nested_generic_functions_with_function_typed_param() {
- checkLibrary('''
+ var library = checkLibrary('''
void f<T, U>() {
void g<V, W>() {
void h<X, Y>(void p(T t, U u, V v, W w, X x, Y y)) {
@@ -4513,10 +11271,23 @@ void f<T, U>() {
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>() {}
+''');
+ }
}
test_nested_generic_functions_with_local_variables() {
- checkLibrary('''
+ var library = checkLibrary('''
void f<T, U>() {
void g<V, W>() {
void h<X, Y>() {
@@ -4530,203 +11301,748 @@ void f<T, U>() {
}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>() {}
+''');
+ }
}
test_operator() {
- checkLibrary('class C { C operator+(C other) => null; }');
+ var library = checkLibrary('class C { C operator+(C other) => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C +(C other) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C +(C other) {}
+}
+''');
+ }
}
test_operator_equal() {
- checkLibrary('class C { bool operator==(Object other) => false; }');
+ var library =
+ checkLibrary('class C { bool operator==(Object other) => false; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool ==(Object other) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool ==(Object other) {}
+}
+''');
+ }
}
test_operator_external() {
- checkLibrary('class C { external C operator+(C other); }');
+ var library = checkLibrary('class C { external C operator+(C other); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external C +(C other) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ external C +(C other) {}
+}
+''');
+ }
}
test_operator_greater_equal() {
- checkLibrary('class C { bool operator>=(C other) => false; }');
+ var library =
+ checkLibrary('class C { bool operator>=(C other) => false; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool >=(C other) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool >=(C other) {}
+}
+''');
+ }
}
test_operator_index() {
- checkLibrary('class C { bool operator[](int i) => null; }');
+ var library = checkLibrary('class C { bool operator[](int i) => null; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool [](int i) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool [](int i) {}
+}
+''');
+ }
}
test_operator_index_set() {
- checkLibrary('class C { void operator[]=(int i, bool v) {} }');
+ var library =
+ checkLibrary('class C { void operator[]=(int i, bool v) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void []=(int i, bool v) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void []=(int i, bool v) {}
+}
+''');
+ }
}
test_operator_less_equal() {
- checkLibrary('class C { bool operator<=(C other) => false; }');
+ var library =
+ checkLibrary('class C { bool operator<=(C other) => false; }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool <=(C other) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ bool <=(C other) {}
+}
+''');
+ }
}
void test_parameter_checked() {
// Note: due to dartbug.com/27393, the keyword "checked" is identified by
// its presence in a library called "meta". If that bug is fixed, this test
// my need to be changed.
- checkLibrary(r'''
+ var library = checkLibrary(r'''
library meta;
const checked = null;
class A<T> {
void f(@checked T t) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library meta;
+class A<T> {
+ void f(convariant T t) {}
+}
+const checked;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library meta;
+class A<T> {
+ void f(convariant T t) {}
+}
+const checked;
+''');
+ }
}
void test_parameter_checked_inherited() {
// Note: due to dartbug.com/27393, the keyword "checked" is identified by
// its presence in a library called "meta". If that bug is fixed, this test
// my need to be changed.
- checkLibrary(r'''
+ var library = checkLibrary(r'''
library meta;
const checked = null;
class A<T> {
- void f(@checked T t) {}
+ void f(@checked T t) {}
+}
+class B<T> extends A<T> {
+ void f(T t) {}
+}
+''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library meta;
+class A<T> {
+ void f(convariant T t) {}
+}
+class B<T> extends A<T> {
+ void f(convariant T t) {}
+}
+const checked;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library meta;
+class A<T> {
+ void f(convariant T t) {}
+}
+class B<T> extends A<T> {
+ void f(T t) {}
+}
+const checked;
+''');
+ }
+ }
+
+ test_parameter_covariant() {
+ prepareAnalysisContext(createOptions());
+ var library = checkLibrary('class C { void m(covariant C c) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void m(convariant C c) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void m(convariant C c) {}
+}
+''');
+ }
+ }
+
+ void test_parameter_covariant_inherited() {
+ var library = checkLibrary(r'''
+class A<T> {
+ void f(covariant T t) {}
}
class B<T> extends A<T> {
void f(T t) {}
}
''');
- }
-
- test_parameter_covariant() {
- prepareAnalysisContext(createOptions());
- checkLibrary('class C { void m(covariant C c) {} }');
- }
-
- void test_parameter_covariant_inherited() {
- checkLibrary(r'''
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
class A<T> {
- void f(covariant T t) {}
+ void f(convariant T t) {}
+}
+class B<T> extends A<T> {
+ void f(convariant T t) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A<T> {
+ void f(convariant T t) {}
}
class B<T> extends A<T> {
void f(T t) {}
}
''');
+ }
}
test_parameter_parameters() {
- checkLibrary('class C { f(g(x, y)) {} }');
+ var library = checkLibrary('class C { f(g(x, y)) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ f((dynamic, dynamic) → dynamic g) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ f((dynamic, dynamic) → dynamic g) {}
+}
+''');
+ }
}
test_parameter_parameters_in_generic_class() {
- checkLibrary('class C<A, B> { f(A g(B x)) {} }');
+ var library = checkLibrary('class C<A, B> { f(A g(B x)) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<A, B> {
+ f((B) → A g) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<A, B> {
+ f((B) → A g) {}
+}
+''');
+ }
}
test_parameter_return_type() {
- checkLibrary('class C { f(int g()) {} }');
+ var library = checkLibrary('class C { f(int g()) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ f(() → int g) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ f(() → int g) {}
+}
+''');
+ }
}
test_parameter_return_type_void() {
- checkLibrary('class C { f(void g()) {} }');
+ var library = checkLibrary('class C { f(void g()) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ f(() → void g) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ f(() → void g) {}
+}
+''');
+ }
}
test_parameterTypeNotInferred_constructor() {
// Strong mode doesn't do type inference on constructor parameters, so it's
// ok that we don't store inferred type info for them in summaries.
- checkLibrary('''
+ var library = checkLibrary('''
class C {
C.positional([x = 1]);
C.named({x: 1});
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.positional([x]);
+ C.named({x});
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ C.positional([x]);
+ C.named({x});
+}
+''');
+ }
}
test_parameterTypeNotInferred_initializingFormal() {
// Strong mode doesn't do type inference on initializing formals, so it's
// ok that we don't store inferred type info for them in summaries.
- checkLibrary('''
+ var library = checkLibrary('''
class C {
var x;
C.positional([this.x = 1]);
C.named({this.x: 1});
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C.positional([this.x]);
+ C.named({this.x});
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ var x;
+ C.positional([this.x]);
+ C.named({this.x});
+}
+''');
+ }
}
test_parameterTypeNotInferred_staticMethod() {
// Strong mode doesn't do type inference on parameters of static methods,
// so it's ok that we don't store inferred type info for them in summaries.
- checkLibrary('''
+ var library = checkLibrary('''
class C {
static void positional([x = 1]) {}
static void named({x: 1}) {}
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static void positional([x]) {}
+ static void named({x}) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static void positional([x]) {}
+ static void named({x}) {}
+}
+''');
+ }
}
test_parameterTypeNotInferred_topLevelFunction() {
// Strong mode doesn't do type inference on parameters of top level
// functions, so it's ok that we don't store inferred type info for them in
// summaries.
- checkLibrary('''
+ var library = checkLibrary('''
void positional([x = 1]) {}
void named({x: 1}) {}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void positional([x]) {}
+void named({x}) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void positional([x]) {}
+void named({x}) {}
+''');
+ }
}
test_parts() {
addSource('/a.dart', 'part of my.lib;');
addSource('/b.dart', 'part of my.lib;');
- checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+ var library = checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+--------------------
+unit: b.dart
+
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+--------------------
+unit: b.dart
+
+''');
+ }
}
test_parts_invalidUri() {
allowMissingFiles = true;
addSource('/foo/bar.dart', 'part of my.lib;');
- checkLibrary('library my.lib; part "foo/";');
+ var library = checkLibrary('library my.lib; part "foo/";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+''');
+ }
}
test_parts_invalidUri_nullStringValue() {
allowMissingFiles = true;
addSource('/foo/bar.dart', 'part of my.lib;');
- checkLibrary(r'''
+ var library = checkLibrary(r'''
library my.lib;
part "${foo}/bar.dart";
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+''');
+ }
}
test_propagated_type_refers_to_closure() {
- checkLibrary('''
+ var library = checkLibrary('''
void f() {
var x = () => 0;
var y = x;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f() {}
+''');
+ }
}
test_setter_covariant() {
- checkLibrary('class C { void set x(covariant int value); }');
+ var library = checkLibrary('class C { void set x(covariant int value); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(convariant int value);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ void set x(convariant int value);
+}
+''');
+ }
}
test_setter_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
void set x(value) {}''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void set x(value) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void set x(value) {}
+''');
+ }
}
test_setter_external() {
- checkLibrary('external void set x(int value);');
+ var library = checkLibrary('external void set x(int value);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+external void set x(int value) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+external void set x(int value) {}
+''');
+ }
}
test_setter_inferred_type_nonStatic_implicit_param() {
- checkLibrary('class C extends D { void set f(value) {} }'
+ var library = checkLibrary('class C extends D { void set f(value) {} }'
' abstract class D { void set f(int value); }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void set f(int value) {}
+}
+abstract class D {
+ void set f(int value);
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C extends D {
+ void set f(value) {}
+}
+abstract class D {
+ void set f(int value);
+}
+''');
+ }
}
test_setter_inferred_type_static_implicit_return() {
- checkLibrary('class C { static set f(int value) {} }');
+ var library = checkLibrary('class C { static set f(int value) {} }');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static void set f(int value) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+ static set f(int value) {}
+}
+''');
+ }
}
test_setter_inferred_type_top_level_implicit_return() {
- checkLibrary('set f(int value) {}');
+ var library = checkLibrary('set f(int value) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void set f(int value) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+set f(int value) {}
+''');
+ }
}
test_setters() {
- checkLibrary('void set x(int value) {} set y(value) {}');
+ var library = checkLibrary('void set x(int value) {} set y(value) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void set x(int value) {}
+void set y(value) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void set x(int value) {}
+set y(value) {}
+''');
+ }
}
test_syntheticFunctionType_genericClosure() {
@@ -4739,10 +12055,21 @@ void set x(value) {}''');
// and remove this hack. See dartbug.com/25819
return;
}
- checkLibrary('''
+ var library = checkLibrary('''
final v = f() ? /*<T>*/(T t) => 0 : /*<T>*/(T t) => 1;
bool f() => true;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+''');
+ }
}
test_syntheticFunctionType_genericClosure_inGenericFunction() {
@@ -4755,70 +12082,217 @@ bool f() => true;
// and remove this hack. See dartbug.com/25819
return;
}
- checkLibrary('''
+ var library = checkLibrary('''
void f<T, U>(bool b) {
final v = b ? /*<V>*/(T t, U u, V v) => 0 : /*<V>*/(T t, U u, V v) => 1;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>(bool b) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+''');
+ }
}
test_syntheticFunctionType_inGenericClass() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T, U> {
var v = f() ? (T t, U u) => 0 : (T t, U u) => 1;
}
bool f() => false;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+ synthetic C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+ var v;
+}
+bool f() {}
+''');
+ }
}
test_syntheticFunctionType_inGenericFunction() {
- checkLibrary('''
+ var library = checkLibrary('''
void f<T, U>(bool b) {
var v = b ? (T t, U u) => 0 : (T t, U u) => 1;
}
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>(bool b) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+void f<T, U>(bool b) {}
+''');
+ }
}
test_syntheticFunctionType_noArguments() {
- checkLibrary('''
+ var library = checkLibrary('''
final v = f() ? () => 0 : () => 1;
bool f() => true;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+final v;
+bool f() {}
+''');
+ }
}
test_syntheticFunctionType_withArguments() {
- checkLibrary('''
+ var library = checkLibrary('''
final v = f() ? (int x, String y) => 0 : (int x, String y) => 1;
bool f() => true;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+final v;
+bool f() {}
+''');
+ }
}
test_type_arguments_explicit_dynamic_dynamic() {
- checkLibrary('Map<dynamic, dynamic> m;');
+ var library = checkLibrary('Map<dynamic, dynamic> m;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+Map m;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+Map m;
+''');
+ }
}
test_type_arguments_explicit_dynamic_int() {
- checkLibrary('Map<dynamic, int> m;');
+ var library = checkLibrary('Map<dynamic, int> m;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+Map<dynamic, int> m;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+Map<dynamic, int> m;
+''');
+ }
}
test_type_arguments_explicit_String_dynamic() {
- checkLibrary('Map<String, dynamic> m;');
+ var library = checkLibrary('Map<String, dynamic> m;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+Map<String, dynamic> m;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+Map<String, dynamic> m;
+''');
+ }
}
test_type_arguments_explicit_String_int() {
- checkLibrary('Map<String, int> m;');
+ var library = checkLibrary('Map<String, int> m;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+Map<String, int> m;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+Map<String, int> m;
+''');
+ }
}
test_type_arguments_implicit() {
- checkLibrary('Map m;');
+ var library = checkLibrary('Map m;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+Map m;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+Map m;
+''');
+ }
}
test_type_dynamic() {
- checkLibrary('dynamic d;');
+ var library = checkLibrary('dynamic d;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+var d;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+var d;
+''');
+ }
}
test_type_invalid_topLevelVariableElement_asType() {
- checkLibrary(
+ var library = checkLibrary(
'''
class C<T extends V> {}
typedef V F(V p);
@@ -4827,218 +12301,971 @@ V V2 = null;
int V = 0;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F(p);
+class C<T extends dynamic> {
+}
+var V2;
+int V;
+f(p) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F(p);
+class C<T extends dynamic> {
+}
+var V2;
+int V;
+f(p) {}
+''');
+ }
}
test_type_invalid_topLevelVariableElement_asTypeArgument() {
- checkLibrary(
+ var library = checkLibrary(
'''
var V;
static List<V> V2;
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+var V;
+List V2;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+var V;
+List V2;
+''');
+ }
}
test_type_invalid_typeParameter_asPrefix() {
- checkLibrary(
+ var library = checkLibrary(
'''
class C<T> {
m(T.K p) {}
}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ m(p) {}
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ m(p) {}
+}
+''');
+ }
}
test_type_reference_lib_to_lib() {
- checkLibrary('class C {} enum E { v } typedef F(); C c; E e; F f;');
+ var library =
+ checkLibrary('class C {} enum E { v } typedef F(); C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F();
+enum E { v }
+class C {
+}
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F();
+enum E { v }
+class C {
+}
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_lib_to_part() {
addSource('/a.dart', 'part of l; class C {} enum E { v } typedef F();');
- checkLibrary('library l; part "a.dart"; C c; E e; F f;');
+ var library = checkLibrary('library l; part "a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+C c;
+E e;
+F f;
+--------------------
+unit: a.dart
+
+typedef F();
+enum E { v }
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+C c;
+E e;
+F f;
+--------------------
+unit: a.dart
+
+typedef F();
+enum E { v }
+class C {
+}
+''');
+ }
}
test_type_reference_part_to_lib() {
addSource('/a.dart', 'part of l; C c; E e; F f;');
- checkLibrary(
+ var library = checkLibrary(
'library l; part "a.dart"; class C {} enum E { v } typedef F();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+typedef F();
+enum E { v }
+class C {
+}
+--------------------
+unit: a.dart
+
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+typedef F();
+enum E { v }
+class C {
+}
+--------------------
+unit: a.dart
+
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_part_to_other_part() {
addSource('/a.dart', 'part of l; class C {} enum E { v } typedef F();');
addSource('/b.dart', 'part of l; C c; E e; F f;');
- checkLibrary('library l; part "a.dart"; part "b.dart";');
+ var library = checkLibrary('library l; part "a.dart"; part "b.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+typedef F();
+enum E { v }
+class C {
+}
+--------------------
+unit: b.dart
+
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+typedef F();
+enum E { v }
+class C {
+}
+--------------------
+unit: b.dart
+
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_part_to_part() {
addSource('/a.dart',
'part of l; class C {} enum E { v } typedef F(); C c; E e; F f;');
- checkLibrary('library l; part "a.dart";');
+ var library = checkLibrary('library l; part "a.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+typedef F();
+enum E { v }
+class C {
+}
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library l;
+part 'a.dart';
+--------------------
+unit: a.dart
+
+typedef F();
+enum E { v }
+class C {
+}
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_class() {
- checkLibrary('class C {} C c;');
+ var library = checkLibrary('class C {} C c;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+C c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+C c;
+''');
+ }
}
test_type_reference_to_class_with_type_arguments() {
- checkLibrary('class C<T, U> {} C<int, String> c;');
+ var library = checkLibrary('class C<T, U> {} C<int, String> c;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+C<int, String> c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+C<int, String> c;
+''');
+ }
}
test_type_reference_to_class_with_type_arguments_implicit() {
- checkLibrary('class C<T, U> {} C c;');
+ var library = checkLibrary('class C<T, U> {} C c;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+C c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T, U> {
+}
+C c;
+''');
+ }
}
test_type_reference_to_enum() {
- checkLibrary('enum E { v } E e;');
+ var library = checkLibrary('enum E { v } E e;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+enum E { v }
+E e;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+enum E { v }
+E e;
+''');
+ }
}
test_type_reference_to_import() {
addLibrarySource('/a.dart', 'class C {} enum E { v }; typedef F();');
- checkLibrary('import "a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_export() {
addLibrarySource('/a.dart', 'export "b.dart";');
addLibrarySource('/b.dart', 'class C {} enum E { v } typedef F();');
- checkLibrary('import "a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_export_export() {
addLibrarySource('/a.dart', 'export "b.dart";');
addLibrarySource('/b.dart', 'export "c.dart";');
addLibrarySource('/c.dart', 'class C {} enum E { v } typedef F();');
- checkLibrary('import "a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_export_export_in_subdirs() {
addLibrarySource('/a/a.dart', 'export "b/b.dart";');
addLibrarySource('/a/b/b.dart', 'export "../c/c.dart";');
addLibrarySource('/a/c/c.dart', 'class C {} enum E { v } typedef F();');
- checkLibrary('import "a/a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a/a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a/a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a/a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_export_in_subdirs() {
addLibrarySource('/a/a.dart', 'export "b/b.dart";');
addLibrarySource('/a/b/b.dart', 'class C {} enum E { v } typedef F();');
- checkLibrary('import "a/a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a/a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a/a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a/a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_part() {
addLibrarySource('/a.dart', 'library l; part "b.dart";');
addSource('/b.dart', 'part of l; class C {} enum E { v } typedef F();');
- checkLibrary('import "a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_part2() {
addLibrarySource('/a.dart', 'library l; part "p1.dart"; part "p2.dart";');
addSource('/p1.dart', 'part of l; class C1 {}');
addSource('/p2.dart', 'part of l; class C2 {}');
- checkLibrary('import "a.dart"; C1 c1; C2 c2;');
+ var library = checkLibrary('import "a.dart"; C1 c1; C2 c2;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C1 c1;
+C2 c2;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C1 c1;
+C2 c2;
+''');
+ }
}
test_type_reference_to_import_part_in_subdir() {
addLibrarySource('/a/b.dart', 'library l; part "c.dart";');
addSource('/a/c.dart', 'part of l; class C {} enum E { v } typedef F();');
- checkLibrary('import "a/b.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a/b.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a/b.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a/b.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_import_relative() {
addLibrarySource('/a.dart', 'class C {} enum E { v } typedef F();');
- checkLibrary('import "a.dart"; C c; E e; F f;');
+ var library = checkLibrary('import "a.dart"; C c; E e; F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+C c;
+E e;
+F f;
+''');
+ }
}
test_type_reference_to_typedef() {
- checkLibrary('typedef F(); F f;');
+ var library = checkLibrary('typedef F(); F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F();
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F();
+F f;
+''');
+ }
}
test_type_reference_to_typedef_with_type_arguments() {
- checkLibrary('typedef U F<T, U>(T t); F<int, String> f;');
+ var library = checkLibrary('typedef U F<T, U>(T t); F<int, String> f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T, U>(T t);
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T, U>(T t);
+F f;
+''');
+ }
}
test_type_reference_to_typedef_with_type_arguments_implicit() {
- checkLibrary('typedef U F<T, U>(T t); F f;');
+ var library = checkLibrary('typedef U F<T, U>(T t); F f;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T, U>(T t);
+F f;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T, U>(T t);
+F f;
+''');
+ }
}
test_type_unresolved() {
- checkLibrary('C c;', allowErrors: true);
+ var library = checkLibrary('C c;', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+dynamic c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+dynamic c;
+''');
+ }
}
test_type_unresolved_prefixed() {
- checkLibrary('import "dart:core" as core; core.C c;', allowErrors: true);
+ var library = checkLibrary('import "dart:core" as core; core.C c;',
+ allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:core' as core;
+dynamic c;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:core' as core;
+dynamic c;
+''');
+ }
}
test_typedef_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
typedef F();''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F();
+''');
+ }
}
test_typedef_parameter_parameters() {
- checkLibrary('typedef F(g(x, y));');
+ var library = checkLibrary('typedef F(g(x, y));');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F((dynamic, dynamic) → dynamic g);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F((dynamic, dynamic) → dynamic g);
+''');
+ }
}
test_typedef_parameter_parameters_in_generic_class() {
- checkLibrary('typedef F<A, B>(A g(B x));');
+ var library = checkLibrary('typedef F<A, B>(A g(B x));');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F<A, B>((B) → A g);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F<A, B>((B) → A g);
+''');
+ }
}
test_typedef_parameter_return_type() {
- checkLibrary('typedef F(int g());');
+ var library = checkLibrary('typedef F(int g());');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F(() → int g);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F(() → int g);
+''');
+ }
}
test_typedef_parameter_type() {
- checkLibrary('typedef F(int i);');
+ var library = checkLibrary('typedef F(int i);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F(int i);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F(int i);
+''');
+ }
}
test_typedef_parameter_type_generic() {
- checkLibrary('typedef F<T>(T t);');
+ var library = checkLibrary('typedef F<T>(T t);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F<T>(T t);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F<T>(T t);
+''');
+ }
}
test_typedef_parameters() {
- checkLibrary('typedef F(x, y);');
+ var library = checkLibrary('typedef F(x, y);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F(x, y);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F(x, y);
+''');
+ }
}
test_typedef_return_type() {
- checkLibrary('typedef int F();');
+ var library = checkLibrary('typedef int F();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef int F();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef int F();
+''');
+ }
}
test_typedef_return_type_generic() {
- checkLibrary('typedef T F<T>();');
+ var library = checkLibrary('typedef T F<T>();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef T F<T>();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef T F<T>();
+''');
+ }
}
test_typedef_return_type_implicit() {
- checkLibrary('typedef F();');
+ var library = checkLibrary('typedef F();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef F();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef F();
+''');
+ }
}
test_typedef_return_type_void() {
- checkLibrary('typedef void F();');
+ var library = checkLibrary('typedef void F();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef void F();
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef void F();
+''');
+ }
}
test_typedef_type_parameters() {
- checkLibrary('typedef U F<T, U>(T t);');
+ var library = checkLibrary('typedef U F<T, U>(T t);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T, U>(T t);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T, U>(T t);
+''');
+ }
}
test_typedef_type_parameters_bound() {
- checkLibrary('typedef U F<T extends Object, U extends D>(T t); class D {}');
+ var library = checkLibrary(
+ 'typedef U F<T extends Object, U extends D>(T t); class D {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T extends Object, U extends D>(T t);
+class D {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T extends Object, U extends D>(T t);
+class D {
+}
+''');
+ }
}
test_typedef_type_parameters_f_bound_complex() {
- checkLibrary('typedef U F<T extends List<U>, U>(T t);');
+ var library = checkLibrary('typedef U F<T extends List<U>, U>(T t);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T extends List<U>, U>(T t);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T extends List<U>, U>(T t);
+''');
+ }
}
test_typedef_type_parameters_f_bound_simple() {
- checkLibrary('typedef U F<T extends U, U>(T t);');
+ var library = checkLibrary('typedef U F<T extends U, U>(T t);');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T extends U, U>(T t);
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+typedef U F<T extends U, U>(T t);
+''');
+ }
}
test_typedefs() {
- checkLibrary('f() {} g() {}');
+ var library = checkLibrary('f() {} g() {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+f() {}
+g() {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+f() {}
+g() {}
+''');
+ }
}
@failingTest
test_unresolved_annotation_instanceCreation_argument_super() {
// TODO(scheglov) fix https://github.com/dart-lang/sdk/issues/28553
- checkLibrary(
+ var library = checkLibrary(
'''
class A {
const A(_);
@@ -5048,10 +13275,35 @@ class A {
class C {}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A(_);
+}
+
+class C {
+ synthetic C();
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A(_);
+}
+
+class C {
+ synthetic C();
+}
+''');
+ }
}
test_unresolved_annotation_instanceCreation_argument_this() {
- checkLibrary(
+ var library = checkLibrary(
'''
class A {
const A(_);
@@ -5061,59 +13313,270 @@ class A {
class C {}
''',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A(_);
+}
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class A {
+ A(_);
+}
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_namedConstructorCall_noClass() {
- checkLibrary('@foo.bar() class C {}', allowErrors: true);
+ var library = checkLibrary('@foo.bar() class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_namedConstructorCall_noConstructor() {
- checkLibrary('@String.foo() class C {}', allowErrors: true);
+ var library = checkLibrary('@String.foo() class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedIdentifier_badPrefix() {
- checkLibrary('@foo.bar class C {}', allowErrors: true);
+ var library = checkLibrary('@foo.bar class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedIdentifier_noDeclaration() {
- checkLibrary('import "dart:async" as foo; @foo.bar class C {}',
+ var library = checkLibrary(
+ 'import "dart:async" as foo; @foo.bar class C {}',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedNamedConstructorCall_badPrefix() {
- checkLibrary('@foo.bar.baz() class C {}', allowErrors: true);
+ var library = checkLibrary('@foo.bar.baz() class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedNamedConstructorCall_noClass() {
- checkLibrary('import "dart:async" as foo; @foo.bar.baz() class C {}',
+ var library = checkLibrary(
+ 'import "dart:async" as foo; @foo.bar.baz() class C {}',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedNamedConstructorCall_noConstructor() {
- checkLibrary('import "dart:async" as foo; @foo.Future.bar() class C {}',
+ var library = checkLibrary(
+ 'import "dart:async" as foo; @foo.Future.bar() class C {}',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedUnnamedConstructorCall_badPrefix() {
- checkLibrary('@foo.bar() class C {}', allowErrors: true);
+ var library = checkLibrary('@foo.bar() class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_prefixedUnnamedConstructorCall_noClass() {
- checkLibrary('import "dart:async" as foo; @foo.bar() class C {}',
+ var library = checkLibrary(
+ 'import "dart:async" as foo; @foo.bar() class C {}',
allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'dart:async' as foo;
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_simpleIdentifier() {
- checkLibrary('@foo class C {}', allowErrors: true);
+ var library = checkLibrary('@foo class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_unresolved_annotation_unnamedConstructorCall_noClass() {
- checkLibrary('@foo() class C {}', allowErrors: true);
+ var library = checkLibrary('@foo() class C {}', allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C {
+}
+''');
+ }
}
test_unresolved_export() {
allowMissingFiles = true;
- checkLibrary("export 'foo.dart';", allowErrors: true);
+ var library = checkLibrary("export 'foo.dart';", allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+export 'foo.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+export 'foo.dart';
+''');
+ }
}
test_unresolved_import() {
@@ -5124,101 +13587,446 @@ class C {}
expect(importedLibrary.loadLibraryFunction, isNotNull);
expect(importedLibrary.publicNamespace, isNotNull);
expect(importedLibrary.exportNamespace, isNotNull);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'foo.dart';
+''');
+ }
}
test_unresolved_part() {
allowMissingFiles = true;
- checkLibrary("part 'foo.dart';", allowErrors: true);
+ var library = checkLibrary("part 'foo.dart';", allowErrors: true);
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+part 'foo.dart';
+--------------------
+unit: foo.dart
+
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+part 'foo.dart';
+--------------------
+unit: foo.dart
+
+''');
+ }
}
test_unused_type_parameter() {
- checkLibrary('''
+ var library = checkLibrary('''
class C<T> {
void f() {}
}
C<int> c;
var v = c.f;
''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ void f() {}
+}
+C<int> c;
+() → void v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+class C<T> {
+ void f() {}
+}
+C<int> c;
+var v;
+''');
+ }
}
test_variable_const() {
- checkLibrary('const int i = 0;');
+ var library = checkLibrary('const int i = 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int i;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const int i;
+''');
+ }
}
test_variable_documented() {
- checkLibrary('''
+ var library = checkLibrary('''
// Extra comment so doc comment offset != 0
/**
* Docs
*/
var x;''');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+var x;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+var x;
+''');
+ }
}
test_variable_final() {
- checkLibrary('final int x = 0;');
+ var library = checkLibrary('final int x = 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+final int x;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+final int x;
+''');
+ }
}
test_variable_final_top_level_untyped() {
- checkLibrary('final v = 0;');
+ var library = checkLibrary('final v = 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+final int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+final v;
+''');
+ }
}
test_variable_getterInLib_setterInPart() {
addSource('/a.dart', 'part of my.lib; void set x(int _) {}');
- checkLibrary('library my.lib; part "a.dart"; int get x => 42;');
+ var library =
+ checkLibrary('library my.lib; part "a.dart"; int get x => 42;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+int get x {}
+--------------------
+unit: a.dart
+
+void set x(int _) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+int get x {}
+--------------------
+unit: a.dart
+
+void set x(int _) {}
+''');
+ }
}
test_variable_getterInPart_setterInLib() {
addSource('/a.dart', 'part of my.lib; int get x => 42;');
- checkLibrary('library my.lib; part "a.dart"; void set x(int _) {}');
+ var library =
+ checkLibrary('library my.lib; part "a.dart"; void set x(int _) {}');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+void set x(int _) {}
+--------------------
+unit: a.dart
+
+int get x {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+void set x(int _) {}
+--------------------
+unit: a.dart
+
+int get x {}
+''');
+ }
}
test_variable_getterInPart_setterInPart() {
addSource('/a.dart', 'part of my.lib; int get x => 42;');
addSource('/b.dart', 'part of my.lib; void set x(int _) {}');
- checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+ var library = checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+int get x {}
+--------------------
+unit: b.dart
+
+void set x(int _) {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+int get x {}
+--------------------
+unit: b.dart
+
+void set x(int _) {}
+''');
+ }
}
test_variable_implicit_type() {
- checkLibrary('var x;');
+ var library = checkLibrary('var x;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+var x;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+var x;
+''');
+ }
}
test_variable_inferred_type_implicit_initialized() {
- checkLibrary('var v = 0;');
+ var library = checkLibrary('var v = 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+int v;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+var v;
+''');
+ }
}
test_variable_propagatedType_const_noDep() {
- checkLibrary('const i = 0;');
+ var library = checkLibrary('const i = 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+const int i;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+const i;
+''');
+ }
}
test_variable_propagatedType_final_dep_inLib() {
addLibrarySource('/a.dart', 'final a = 1;');
- checkLibrary('import "a.dart"; final b = a / 2;');
+ var library = checkLibrary('import "a.dart"; final b = a / 2;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+final num b;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'a.dart';
+final b;
+''');
+ }
}
test_variable_propagatedType_final_dep_inPart() {
addSource('/a.dart', 'part of lib; final a = 1;');
- checkLibrary('library lib; part "a.dart"; final b = a / 2;');
+ var library = checkLibrary('library lib; part "a.dart"; final b = a / 2;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library lib;
+part 'a.dart';
+final num b;
+--------------------
+unit: a.dart
+
+final int a;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library lib;
+part 'a.dart';
+final b;
+--------------------
+unit: a.dart
+
+final a;
+''');
+ }
}
test_variable_propagatedType_final_noDep() {
- checkLibrary('final i = 0;');
+ var library = checkLibrary('final i = 0;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+final int i;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+final i;
+''');
+ }
}
test_variable_propagatedType_implicit_dep() {
// The propagated type is defined in a library that is not imported.
addLibrarySource('/a.dart', 'class C {}');
addLibrarySource('/b.dart', 'import "a.dart"; C f() => null;');
- checkLibrary('import "b.dart"; final x = f();');
+ var library = checkLibrary('import "b.dart"; final x = f();');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+import 'b.dart';
+final C x;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+import 'b.dart';
+final x;
+''');
+ }
}
test_variable_setterInPart_getterInPart() {
addSource('/a.dart', 'part of my.lib; void set x(int _) {}');
addSource('/b.dart', 'part of my.lib; int get x => 42;');
- checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+ var library = checkLibrary('library my.lib; part "a.dart"; part "b.dart";');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+void set x(int _) {}
+--------------------
+unit: b.dart
+
+int get x {}
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+library my.lib;
+part 'a.dart';
+part 'b.dart';
+--------------------
+unit: a.dart
+
+void set x(int _) {}
+--------------------
+unit: b.dart
+
+int get x {}
+''');
+ }
}
test_variables() {
- checkLibrary('int i; int j;');
+ var library = checkLibrary('int i; int j;');
+ if (isStrongMode) {
+ checkElementText(
+ library,
+ r'''
+int i;
+int j;
+''');
+ } else {
+ checkElementText(
+ library,
+ r'''
+int i;
+int j;
+''');
+ }
}
/**
« pkg/analyzer/test/src/summary/resynthesize_ast_test.dart ('K') | « pkg/analyzer/test/src/summary/resynthesize_ast_test.dart ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698