#459. Late fields and variables tests added
diff --git a/LanguageFeatures/nnbd/late_A02_t03.dart b/LanguageFeatures/nnbd/late_A02_t03.dart
new file mode 100644
index 0000000..a3a18ff
--- /dev/null
+++ b/LanguageFeatures/nnbd/late_A02_t03.dart
@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion A read of a field or variable which is marked as late which has
+ * not yet been written to causes the initializer expression of the variable to
+ * be evaluated to a value, assigned to the variable or field, and returned as
+ * the value of the read.
+ *
+ * If there is no initializer expression, the read causes a runtime error.
+ *
+ * @description Check that it is a runtime error to read late variable without
+ * initializer expression
+ * @author sgrekhov@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+import "../../Utils/expect.dart";
+
+class A1 {
+ covariant late String v;
+ A1() : this.v = (this.v == "" ? "one": "two");
+}
+
+class A2 {
+ covariant late String? v;
+ A2() : this.v = (this.v == "" ? "one": "two");
+}
+
+class B1 {
+ late final String v;
+ B1() : this.v = (this.v == "" ? "one": "two");
+}
+
+class B2 {
+ late final String v;
+ B2() : this.v = (this.v == "" ? "one": "two");
+}
+
+class C1 {
+ late String v;
+ C1() : this.v = (this.v == "" ? "one": "two");
+}
+
+class C2 {
+ late String v;
+ C2() : this.v = (this.v == "" ? "one": "two");
+}
+
+main() {
+ Expect.throws(() {new A1();});
+ Expect.throws(() {new B1();});
+ Expect.throws(() {new C1();});
+ Expect.throws(() {new A2();});
+ Expect.throws(() {new B2();});
+ Expect.throws(() {new C2();});
+}
diff --git a/LanguageFeatures/nnbd/late_A03_t04.dart b/LanguageFeatures/nnbd/late_A03_t04.dart
new file mode 100644
index 0000000..5803d81
--- /dev/null
+++ b/LanguageFeatures/nnbd/late_A03_t04.dart
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion A read of a field or variable which is marked as late which has
+ * not yet been written to causes the initializer expression of the variable to
+ * be evaluated to a value, assigned to the variable or field, and returned as
+ * the value of the read.
+ * ...
+ * Evaluating the initializer expression may validly cause a write to the field
+ * or variable, assuming that the field or variable is not final. In this case,
+ * the variable assumes the written value. The final value of the initializer
+ * expression overwrites any intermediate written values.
+ *
+ * @description Check that evaluating the initializer expression may validly
+ * cause a write to the field or variable, assuming that the field or variable
+ * is not final. In this case, the variable assumes the written value. The final
+ * value of the initializer expression overwrites any intermediate written
+ * values.
+ * @author sgrekhov@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+import "../../Utils/expect.dart";
+
+class A1 {
+ covariant late String v;
+ A1() : this.v = ((this.v = "Lily") == "lily" ? "was": "here");
+}
+
+class A2 {
+ covariant late String v;
+ A2() : this.v = ((this.v = "Lily") == "lily" ? "was": "here");
+}
+
+class C1 {
+ late String v;
+ C1() : this.v = ((this.v = "Lily") == "lily" ? "was": "here");
+}
+
+class C2 {
+ late String v;
+ C2() : this.v = ((this.v = "Lily") == "lily" ? "was": "here");
+}
+
+main() {
+ Expect.equals("here", new A1().v);
+ Expect.equals("here", new A2().v);
+ Expect.equals("here", new C1().v);
+ Expect.equals("here", new C2().v);
+}
diff --git a/LanguageFeatures/nnbd/late_A05_t01.dart b/LanguageFeatures/nnbd/late_A05_t01.dart
new file mode 100644
index 0000000..b6eba69
--- /dev/null
+++ b/LanguageFeatures/nnbd/late_A05_t01.dart
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion A read of a field or variable which is marked as late which has
+ * not yet been written to causes the initializer expression of the variable to
+ * be evaluated to a value, assigned to the variable or field, and returned as
+ * the value of the read.
+ * ...
+ * If a variable or field is read from during the process of evaluating its own
+ * initializer expression, and no write to the variable has occurred, the read
+ * is treated as a first read and the initializer expression is evaluated again.
+ *
+ * @description Check that if a variable or field is read from during the
+ * process of evaluating its own initializer expression, and no write to the
+ * variable has occurred, the read is treated as a first read and the
+ * initializer expression is evaluated again
+ * @author sgrekhov@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+import "../../Utils/expect.dart";
+
+String _log = "";
+int _counter = 0;
+
+String init(String val, void readme()) {
+ _counter++;
+ _log = "init('$val'), counter: $_counter";
+ if (_counter == 1) {
+ readme();
+ throw new Exception();
+ }
+ return val;
+}
+
+void clear() {
+ _counter = 0;
+}
+
+class C {
+ static late final String s1 = init("When", (){C.s1;});
+ static late String s2 = init("I found", (){C.s2;});
+ covariant late String v1 = init("myself", (){this.v1;});
+ late final String v2 = init("in time", (){this.v2;});
+ late String v3 = init("of trouble", (){this.v3;});
+}
+
+late final String g1 = init("Mother Mary", (){g1;});
+late String g2 = init("comes to me", (){g2;});
+
+main() {
+ late final String l1 = init("Speaking words of wisdom", (){l1;);
+ late String l2 = init("let it be", (){l2;});
+
+ Expect.equals("", _log);
+ Expect.throws(() {C.s1;});
+ Expect.equals("When", C.s1);
+ Expect.equals("init('When'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {C.s2;});
+ Expect.equals("I found", C.s2);
+ Expect.equals("init('I found'), counter: 2", _log);
+ clear();
+
+ C c = new C();
+ Expect.equals("", _log);
+
+ Expect.throws(() {c.v1;});
+ Expect.equals("myself", c.v1);
+ Expect.equals("init('myself'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {c.v2;});
+ Expect.equals("in time", c.v2);
+ Expect.equals("init('in time'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {c.v3;});
+ Expect.equals("of trouble", c.v3);
+ Expect.equals("init('of trouble'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {g1;});
+ Expect.equals("Mother Mary", g1);
+ Expect.equals("init('Mother Mary'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {g2;});
+ Expect.equals("comes to me", g2);
+ Expect.equals("init('comes to me'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {l1;});
+ Expect.equals("Speaking words of wisdom", l1);
+ Expect.equals("init('Speaking words of wisdom'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {l2;});
+ Expect.equals("let it be", l2);
+ Expect.equals("init('let it be'), counter: 2", _log);
+ clear();
+}
diff --git a/LanguageFeatures/nnbd/late_A05_t02.dart b/LanguageFeatures/nnbd/late_A05_t02.dart
new file mode 100644
index 0000000..f6d83b0
--- /dev/null
+++ b/LanguageFeatures/nnbd/late_A05_t02.dart
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion A read of a field or variable which is marked as late which has
+ * not yet been written to causes the initializer expression of the variable to
+ * be evaluated to a value, assigned to the variable or field, and returned as
+ * the value of the read.
+ * ...
+ * If a variable or field is read from during the process of evaluating its own
+ * initializer expression, and no write to the variable has occurred, the read
+ * is treated as a first read and the initializer expression is evaluated again.
+ *
+ * @description Check that if a variable or field is read from during the
+ * process of evaluating its own initializer expression, and no write to the
+ * variable has occurred, the read is treated as a first read and the
+ * initializer expression is evaluated again
+ * @author sgrekhov@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+import "../../Utils/expect.dart";
+
+String _log = "";
+int _counter = 0;
+
+String init(String val, void readme()) {
+ _counter++;
+ _log = "init('$val'), counter: $_counter";
+ if (_counter == 1) {
+ readme();
+ throw new Exception();
+ }
+ return val;
+}
+
+void clear() {
+ _counter = 0;
+}
+
+class C {
+ static late final String? s1 = init("When", (){C.s1;});
+ static late String? s2 = init("I found", (){C.s2;});
+ covariant late String? v1 = init("myself", (){this.v1;});
+ late final String? v2 = init("in time", (){this.v2;});
+ late String? v3 = init("of trouble", (){this.v3;});
+}
+
+late final String? g1 = init("Mother Mary", (){g1;});
+late String? g2 = init("comes to me", (){g2;});
+
+main() {
+ late final String? l1 = init("Speaking words of wisdom", (){l1;);
+ late String? l2 = init("let it be", (){l2;});
+
+ Expect.equals("", _log);
+ Expect.throws(() {C.s1;});
+ Expect.equals("When", C.s1);
+ Expect.equals("init('When'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {C.s2;});
+ Expect.equals("I found", C.s2);
+ Expect.equals("init('I found'), counter: 2", _log);
+ clear();
+
+ C c = new C();
+ Expect.equals("", _log);
+
+ Expect.throws(() {c.v1;});
+ Expect.equals("myself", c.v1);
+ Expect.equals("init('myself'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {c.v2;});
+ Expect.equals("in time", c.v2);
+ Expect.equals("init('in time'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {c.v3;});
+ Expect.equals("of trouble", c.v3);
+ Expect.equals("init('of trouble'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {g1;});
+ Expect.equals("Mother Mary", g1);
+ Expect.equals("init('Mother Mary'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {g2;});
+ Expect.equals("comes to me", g2);
+ Expect.equals("init('comes to me'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {l1;});
+ Expect.equals("Speaking words of wisdom", l1);
+ Expect.equals("init('Speaking words of wisdom'), counter: 2", _log);
+ clear();
+
+ Expect.throws(() {l2;});
+ Expect.equals("let it be", l2);
+ Expect.equals("init('let it be'), counter: 2", _log);
+ clear();
+}
diff --git a/LanguageFeatures/nnbd/late_A05_t03.dart b/LanguageFeatures/nnbd/late_A05_t03.dart
new file mode 100644
index 0000000..91dd212
--- /dev/null
+++ b/LanguageFeatures/nnbd/late_A05_t03.dart
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion A read of a field or variable which is marked as late which has
+ * not yet been written to causes the initializer expression of the variable to
+ * be evaluated to a value, assigned to the variable or field, and returned as
+ * the value of the read.
+ * ...
+ * If a variable or field is read from during the process of evaluating its own
+ * initializer expression, and no write to the variable has occurred, the read
+ * is treated as a first read and the initializer expression is evaluated again.
+ *
+ * @description Check that if a variable or field is read from during the
+ * process of evaluating its own initializer expression but write to the
+ * variable occurred, then initializer expression is not evaluated again
+ * @author sgrekhov@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+import "../../Utils/expect.dart";
+
+String _log = "";
+int _counter = 0;
+
+String init(String val1, String val2, void writeAndReadme()) {
+ _counter++;
+ _log = "counter: $_counter";
+ if (_counter == 1) {
+ writeAndReadme();
+ return val2;
+ }
+ return val1;
+}
+
+void clear() {
+ _counter = 0;
+}
+
+class C {
+ static late final String s1 =
+ init("No woman", "no cry", (){C.s1 = "Lily was here"; C.s1;});
+ static late String s2 =
+ init("No woman", "no cry", (){C.s2 = "Lily was here"; C.s2;});
+ covariant late String v1 =
+ init("No woman", "no cry", (){this.v1 = "Lily was here"; this.v1;});
+ late final String v2 =
+ init("No woman", "no cry", (){this.v2 = "Lily was here"; this.v2;});
+ late String v3 =
+ init("No woman", "no cry", (){this.v3 = "Lily was here"; this.v3;});
+}
+
+late final String g1 =
+ init("No woman", "no cry", (){g1 = "Lily was here"; g1;});
+late String g2 =
+ init("No woman", "no cry", (){g2 = "Lily was here"; g2;});
+
+main() {
+ late final String l1 =
+ init("No woman", "no cry", (){l1 = "Lily was here"; l1;);
+ late String l2 = init("No woman", "no cry", (){l2 = "Lily was here"; l2;});
+
+ Expect.equals("", _log);
+ Expect.equals("no cry", C.s1);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", C.s2);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ C c = new C();
+ Expect.equals("", _log);
+
+ Expect.equals("no cry", c.v1);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", c.v2);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", c.v3);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", g1);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", g2);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", l1);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", l2);
+ Expect.equals("counter: 1", _log);
+ clear();
+}
diff --git a/LanguageFeatures/nnbd/late_A05_t04.dart b/LanguageFeatures/nnbd/late_A05_t04.dart
new file mode 100644
index 0000000..dfdac33
--- /dev/null
+++ b/LanguageFeatures/nnbd/late_A05_t04.dart
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion A read of a field or variable which is marked as late which has
+ * not yet been written to causes the initializer expression of the variable to
+ * be evaluated to a value, assigned to the variable or field, and returned as
+ * the value of the read.
+ * ...
+ * If a variable or field is read from during the process of evaluating its own
+ * initializer expression, and no write to the variable has occurred, the read
+ * is treated as a first read and the initializer expression is evaluated again.
+ *
+ * @description Check that if a variable or field is read from during the
+ * process of evaluating its own initializer expression but write to the
+ * variable occurred, then initializer expression is not evaluated again
+ * @author sgrekhov@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+import "../../Utils/expect.dart";
+
+String _log = "";
+int _counter = 0;
+
+String init(String val1, String val2, void writeAndReadme()) {
+ _counter++;
+ _log = "counter: $_counter";
+ if (_counter == 1) {
+ writeAndReadme();
+ return val2;
+ }
+ return val1;
+}
+
+void clear() {
+ _counter = 0;
+}
+
+class C {
+ static late final String? s1 =
+ init("No woman", "no cry", (){C.s1 = "Lily was here"; C.s1;});
+ static late String? s2 =
+ init("No woman", "no cry", (){C.s2 = "Lily was here"; C.s2;});
+ covariant late String? v1 =
+ init("No woman", "no cry", (){this.v1 = "Lily was here"; this.v1;});
+ late final String? v2 =
+ init("No woman", "no cry", (){this.v2 = "Lily was here"; this.v2;});
+ late String? v3 =
+ init("No woman", "no cry", (){this.v3 = "Lily was here"; this.v3;});
+}
+
+late final String? g1 =
+ init("No woman", "no cry", (){g1 = "Lily was here"; g1;});
+late String? g2 =
+ init("No woman", "no cry", (){g2 = "Lily was here"; g2;});
+
+main() {
+ late final String? l1 =
+ init("No woman", "no cry", (){l1 = "Lily was here"; l1;);
+ late String? l2 = init("No woman", "no cry", (){l2 = "Lily was here"; l2;});
+
+ Expect.equals("", _log);
+ Expect.equals("no cry", C.s1);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", C.s2);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ C c = new C();
+ Expect.equals("", _log);
+
+ Expect.equals("no cry", c.v1);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", c.v2);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", c.v3);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", g1);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", g2);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", l1);
+ Expect.equals("counter: 1", _log);
+ clear();
+
+ Expect.equals("no cry", l2);
+ Expect.equals("counter: 1", _log);
+ clear();
+}
diff --git a/LanguageFeatures/nnbd/late_A06_t01.dart b/LanguageFeatures/nnbd/late_A06_t01.dart
new file mode 100644
index 0000000..4e442f1
--- /dev/null
+++ b/LanguageFeatures/nnbd/late_A06_t01.dart
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion A write to a field or variable which is marked final and late is a
+ * runtime error unless the field or variable was declared with no initializer
+ * expression, and there have been no previous writes to the field or variable
+ * (including via an initializing formal or an initializer list entry).
+ *
+ * @description Check that if a final late variable is declared with no
+ * initializer expression, and there have been no previous writes to it, then
+ * write attempt to this field or variable is not an error
+ * @author sgrekhov@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+import "../../Utils/expect.dart";
+
+class C {
+ static late final String s;
+ late final String v;
+}
+
+late final String g;
+
+main() {
+ late final String l;
+
+ C.s = "No";
+ Expect.equals("No", C.s);
+
+ C c = new C();
+ c.v = "woman";
+ Expect.equals("woman", c.v);
+
+ g = "no";
+ Expect.equals("no", g);
+
+ l = "cry";
+ Expect.equals("cry", l);
+}
diff --git a/LanguageFeatures/nnbd/late_A06_t02.dart b/LanguageFeatures/nnbd/late_A06_t02.dart
new file mode 100644
index 0000000..637b4da
--- /dev/null
+++ b/LanguageFeatures/nnbd/late_A06_t02.dart
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion A write to a field or variable which is marked final and late is a
+ * runtime error unless the field or variable was declared with no initializer
+ * expression, and there have been no previous writes to the field or variable
+ * (including via an initializing formal or an initializer list entry).
+ *
+ * @description Check that if a final late variable is declared with no
+ * initializer expression, and there have been no previous writes to it, then
+ * write attempt to this field or variable is not an error
+ * @author sgrekhov@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+import "../../Utils/expect.dart";
+
+class C {
+ static late final String? s;
+ late final String? v;
+}
+
+late final String? g;
+
+main() {
+ late final String? l;
+
+ C.s = "No";
+ Expect.equals("No", C.s);
+
+ C c = new C();
+ c.v = "woman";
+ Expect.equals("woman", c.v);
+
+ g = "no";
+ Expect.equals("no", g);
+
+ l = "cry";
+ Expect.equals("cry", l);
+}
diff --git a/LanguageFeatures/nnbd/late_A06_t03.dart b/LanguageFeatures/nnbd/late_A06_t03.dart
new file mode 100644
index 0000000..361a0a8
--- /dev/null
+++ b/LanguageFeatures/nnbd/late_A06_t03.dart
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion A write to a field or variable which is marked final and late is a
+ * runtime error unless the field or variable was declared with no initializer
+ * expression, and there have been no previous writes to the field or variable
+ * (including via an initializing formal or an initializer list entry).
+ *
+ * @description Check that if a final late variable is declared with no
+ * initializer expression, and there have been no previous writes to it, then
+ * write attempt to this field or variable is not an error
+ * @author sgrekhov@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+import "../../Utils/expect.dart";
+
+class A {
+ late final String a1;
+ late final String? a2;
+
+ A(this.a1, this.a2);
+}
+
+class C {
+ late final String c1;
+ late final String? c2;
+
+ C(String v1, String v2) : this.c1 = v1, this.c2 = v2;
+}
+
+main() {
+ A a = new A("No woman", "no cry");
+ Expect.equals("No woman", a.a1);
+ Expect.equals("No cry", a.a2);
+
+ C c = new C("No woman", "no cry");
+ Expect.equals("No woman", c.c1);
+ Expect.equals("No cry", c.c2);
+}
diff --git a/LanguageFeatures/nnbd/late_A06_t04.dart b/LanguageFeatures/nnbd/late_A06_t04.dart
new file mode 100644
index 0000000..061e491
--- /dev/null
+++ b/LanguageFeatures/nnbd/late_A06_t04.dart
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion A write to a field or variable which is marked final and late is a
+ * runtime error unless the field or variable was declared with no initializer
+ * expression, and there have been no previous writes to the field or variable
+ * (including via an initializing formal or an initializer list entry).
+ *
+ * @description Check that if a final late variable is declared with no
+ * initializer expression, and there have been no previous writes to it, then
+ * write attempt to this field or variable is not an error, but the second
+ * attempt of write to it is a runtime error
+ * @author sgrekhov@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+import "../../Utils/expect.dart";
+
+class C {
+ static late final String s;
+ late final String v;
+}
+
+late final String g;
+
+main() {
+ late final String l;
+
+ C.s = "No";
+ Expect.equals("No", C.s);
+ Expect.throws(() {C.s = "Lily was here";});
+
+ C c = new C();
+ c.v = "woman";
+ Expect.equals("woman", c.v);
+ Expect.throws(() {c.v = "Lily was here";});
+
+ g = "no";
+ Expect.equals("no", g);
+ Expect.throws(() {g = "Lily was here";});
+
+ l = "cry";
+ Expect.equals("cry", l);
+ Expect.throws(() {l = "Lily was here";});
+}
diff --git a/LanguageFeatures/nnbd/late_A06_t05.dart b/LanguageFeatures/nnbd/late_A06_t05.dart
new file mode 100644
index 0000000..9b9b9ef
--- /dev/null
+++ b/LanguageFeatures/nnbd/late_A06_t05.dart
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion A write to a field or variable which is marked final and late is a
+ * runtime error unless the field or variable was declared with no initializer
+ * expression, and there have been no previous writes to the field or variable
+ * (including via an initializing formal or an initializer list entry).
+ *
+ * @description Check that if a final late variable is declared with no
+ * initializer expression, and there have been no previous writes to it, then
+ * write attempt to this field or variable is not an error, but the second
+ * attempt of write to it is a runtime error
+ * @author sgrekhov@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+import "../../Utils/expect.dart";
+
+class C {
+ static late final String? s;
+ late final String? v;
+}
+
+late final String? g;
+
+main() {
+ late final String? l;
+
+ C.s = "No";
+ Expect.throws(() {C.s = "Lily was here";});
+ Expect.equals("No", C.s);
+
+ C c = new C();
+ c.v = "woman";
+ Expect.throws(() {c.v = "Lily was here";});
+ Expect.equals("woman", c.v);
+
+ g = "no";
+ Expect.throws(() {g = "Lily was here";});
+ Expect.equals("no", g);
+
+ l = "cry";
+ Expect.throws(() {l = "Lily was here";});
+ Expect.equals("cry", l);
+}
diff --git a/LanguageFeatures/nnbd/late_A06_t06.dart b/LanguageFeatures/nnbd/late_A06_t06.dart
new file mode 100644
index 0000000..e069def
--- /dev/null
+++ b/LanguageFeatures/nnbd/late_A06_t06.dart
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion A write to a field or variable which is marked final and late is a
+ * runtime error unless the field or variable was declared with no initializer
+ * expression, and there have been no previous writes to the field or variable
+ * (including via an initializing formal or an initializer list entry).
+ *
+ * @description Check that if a final late variable is declared with no
+ * initializer expression, and there have been no previous writes to it, then
+ * write attempt to this field or variable is not an error, but the second
+ * attempt of write to it is a runtime error
+ * @author sgrekhov@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+import "../../Utils/expect.dart";
+
+class A {
+ late final String a1;
+ late final String? a2;
+
+ A(this.a1, this.a2);
+}
+
+class C {
+ late final String c1;
+ late final String? c2;
+
+ C(String v1, String v2) : this.c1 = v1, this.c2 = v2;
+}
+
+main() {
+ A a = new A("No woman", "no cry");
+ Expect.throws(() {a.a1 = "Lily was here";});
+ Expect.throws(() {a.a2 = "Lily was here";});
+ Expect.equals("No woman", a.a1);
+ Expect.equals("No cry", a.a2);
+
+ C c = new C("No woman", "no cry");
+ Expect.throws(() {c.c1 = "Lily was here";});
+ Expect.throws(() {c.c2 = "Lily was here";});
+ Expect.equals("No woman", c.c1);
+ Expect.equals("No cry", c.c2);
+}
diff --git a/LanguageFeatures/nnbd/late_A07_t01.dart b/LanguageFeatures/nnbd/late_A07_t01.dart
new file mode 100644
index 0000000..280006c
--- /dev/null
+++ b/LanguageFeatures/nnbd/late_A07_t01.dart
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ */
+/**
+ * @assertion Overriding a field which is marked both final and late with a
+ * member which does not otherwise introduce a setter introduces an implicit
+ * setter which throws.
+ *
+ * @description Check that overriding a field which is marked both final and late with a
+ * member which does not otherwise introduce a setter introduces an implicit
+ * setter which throws.
+ * @author sgrekhov@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+import "../../Utils/expect.dart";
+
+class A {
+ late final int x;
+}
+class B extends A {
+ int get x => 3;
+}
+class C extends A {
+ late final int x = 3;
+}
+void test() {
+ Expect.throws(() => new B().x = 3);
+ Expect.throws(() => new C().x = 3);
+}
\ No newline at end of file
