#2313. [Extension types] Add nullability tests (#2324)

Add nullability tests

Author: sgrekhov

LanguageFeatures/Extension-types/nullability_A01_t01.dart

@@ -0,0 +1,58 @@
+// Copyright (c) 2023, 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 Let V be an extension type of the form Name<T1, .. Ts>, and let R
+/// be the corresponding instantiated representation type. If R is non-nullable
+/// then V is a proper subtype of Object, and V is non-nullable. Otherwise, V is
+/// a proper subtype of Object?, and V is potentially nullable.
+///
+/// @description Checks that an extension type is not-nullable even if its
+/// representation type is nullable
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "dart:async" show FutureOr;
+
+extension type ET1(int? _) {}
+
+extension type ET2(Null _) {}
+
+extension type ET3(dynamic _) {}
+
+extension type ET4(void _) {}
+
+extension type ET5(FutureOr<Null> _) {}
+
+main() {
+  ET1 et11 = null;
+//           ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  ET1? et12 = null;
+
+  ET2 et21 = null;
+//           ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  ET2? et22 = null;
+
+  ET3 et31 = null;
+//           ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  ET3? et32 = null;
+
+  ET4 et41 = null;
+//           ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  ET4? et42 = null;
+
+  ET5 et51 = null;
+//           ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  ET5? et52 = null;
+}

LanguageFeatures/Extension-types/nullability_A01_t02.dart

@@ -0,0 +1,40 @@
+// Copyright (c) 2023, 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 Let V be an extension type of the form Name<T1, .. Ts>, and let R
+/// be the corresponding instantiated representation type. If R is non-nullable
+/// then V is a proper subtype of Object, and V is non-nullable. Otherwise, V is
+/// a proper subtype of Object?, and V is potentially nullable.
+///
+/// @description Checks that null can be assigned to an extension type at run
+/// time if its representation type is nullable
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "dart:async" show FutureOr;
+import "../../Utils/expect.dart";
+
+extension type ET1(int? _) {}
+
+extension type ET2(Null _) {}
+
+extension type ET3(dynamic _) {}
+
+extension type ET4(void _) {}
+
+extension type ET5(FutureOr<Null> _) {}
+
+main() {
+  ET1 et1 = null as dynamic;
+  Expect.isNull(et1);
+  ET2 et2 = null as dynamic;
+  Expect.isNull(et2);
+  ET3 et3 = null as dynamic;
+  Expect.isNull(et3);
+  ET4 et4 = null as dynamic;
+  Expect.isNull(et4);
+  ET5 et5 = null as dynamic;
+  Expect.isNull(et5);
+}

LanguageFeatures/Extension-types/nullability_A01_t03.dart

@@ -0,0 +1,42 @@
+// Copyright (c) 2023, 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 Let V be an extension type of the form Name<T1, .. Ts>, and let R
+/// be the corresponding instantiated representation type. If R is non-nullable
+/// then V is a proper subtype of Object, and V is non-nullable. Otherwise, V is
+/// a proper subtype of Object?, and V is potentially nullable.
+///
+/// @description Checks that null can be assigned to an extension type at run
+/// time if its representation type is nullable
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "dart:async" show FutureOr;
+import "../../Utils/expect.dart";
+
+typedef VoidAlias = void;
+
+extension type ET1<T extends int?>(T _) {}
+
+extension type ET2<T extends Null>(T _) {}
+
+extension type ET3<T extends dynamic>(T _) {}
+
+extension type ET4<T extends FutureOr<Null>>(T _) {}
+
+extension type ET5<T extends VoidAlias>(T _) {}
+
+main() {
+  ET1 et1 = null as dynamic;
+  Expect.isNull(et1);
+  ET2 et2 = null as dynamic;
+  Expect.isNull(et2);
+  ET3 et3 = null as dynamic;
+  Expect.isNull(et3);
+  ET4 et4 = null as dynamic;
+  Expect.isNull(et4);
+  ET5 et5 = null as dynamic;
+  Expect.isNull(et5);
+}

LanguageFeatures/Extension-types/nullability_A02_t01.dart

@@ -0,0 +1,37 @@
+// Copyright (c) 2023, 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 Let V be an extension type of the form Name<T1, .. Ts>, and let R
+/// be the corresponding instantiated representation type. If R is non-nullable
+/// then V is a proper subtype of Object, and V is non-nullable. Otherwise, V is
+/// a proper subtype of Object?, and V is potentially nullable.
+///
+/// @description Checks that a warning is produced depending of the
+/// representation type when an extension type is checked by `??` operator
+/// @author [email protected]
+/// @issue 53822
+
+// SharedOptions=--enable-experiment=inline-class
+
+extension type ET1<T>(T _) {
+  void test() {
+    this ?? print("No warning here!");
+  }
+}
+
+extension type ET2<T extends Object>(T _) {
+  void test() {
+    this ?? print("Expect a warning here!");
+//       ^^
+// [analyzer] unspecified
+// [cfe] unspecified
+  }
+}
+
+main() {
+  ET1(42).test();
+  ET1(null).test();
+  ET1<int?>(42).test();
+  ET2(42).test();
+}

LanguageFeatures/Extension-types/static_analysis_extension_types_A17_t06.dart

@@ -0,0 +1,37 @@
+// Copyright (c) 2023, 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 Let DV be an extension type declaration named Name with type
+/// parameters X1 extends B1, .. Xs extends Bs. Assume that the representation
+/// declaration of DV is (R id)
+///
+/// We then say that the declared representation type of Name is R, and the
+/// instantiated representation type corresponding to Name<T1,.. Ts> is
+/// [T1/X1, .. Ts/Xs]R.
+/// ...
+/// Let V be an extension type of the form Name<T1, .. Ts>, and let R be the
+/// corresponding instantiated representation type. If R is non-nullable then V
+/// is a proper subtype of Object, and V is non-nullable. Otherwise, V is a
+/// proper subtype of Object?, and V is potentially nullable.
+///
+/// @description Checks that it is not an error to call a member of an extension
+/// type with a nullable representation type
+/// @author [email protected]
+/// @issue 53822
+
+// SharedOptions=--enable-experiment=inline-class
+
+extension type ET1(int? _) {
+  foo() {}
+}
+
+extension type ET2<T>(T _) {
+  foo() {}
+}
+
+main() {
+  ET1(42).foo();
+  ET2<int?>(42).foo();
+  ET2<Null>(null).foo();
+}

LanguageFeatures/Extension-types/syntax_A03_t02.dart

@@ -0,0 +1,35 @@
+// Copyright (c) 2023, 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 rule for <extensionTypeDeclaration> is added to the grammar,
+/// along with some rules for elements used in extension type declarations:
+///
+/// <extensionTypeDeclaration> ::=
+///   'extension' 'type' 'const'? <typeIdentifier> <typeParameters>?
+///   <representationDeclaration> <interfaces>?
+///   '{'
+///     (<metadata> <extensionTypeMemberDeclaration>)*
+///   '}'
+///
+/// <representationDeclaration> ::=
+///   ('.' <identifierOrNew>)? '(' <metadata> <type> <identifier> ')'
+///
+/// <identifierOrNew> ::= <identifier> | 'new'
+///
+/// <extensionTypeMemberDeclaration> ::= <classMemberDefinition>
+///
+/// @description Checks that it is a compile-time error if an extension type
+/// declares a type parameter which extends type `void`
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+extension type ET1<T extends void>(T id) {}
+//                           ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+main() {
+  print(ET1);
+}

LanguageFeatures/Extension-types/syntax_A03_t03.dart

@@ -0,0 +1,38 @@
+// Copyright (c) 2023, 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 rule for <extensionTypeDeclaration> is added to the grammar,
+/// along with some rules for elements used in extension type declarations:
+///
+/// <extensionTypeDeclaration> ::=
+///   'extension' 'type' 'const'? <typeIdentifier> <typeParameters>?
+///   <representationDeclaration> <interfaces>?
+///   '{'
+///     (<metadata> <extensionTypeMemberDeclaration>)*
+///   '}'
+///
+/// <representationDeclaration> ::=
+///   ('.' <identifierOrNew>)? '(' <metadata> <type> <identifier> ')'
+///
+/// <identifierOrNew> ::= <identifier> | 'new'
+///
+/// <extensionTypeMemberDeclaration> ::= <classMemberDefinition>
+///
+/// @description Checks that it is not an error if an extension type declares a
+/// type parameter which extends an alias of the type `void`
+/// @author [email protected]
+
+// SharedOptions=--enable-experiment=inline-class
+
+import "../../Utils/expect.dart";
+
+typedef VoidAlias = void;
+
+extension type ET<T extends VoidAlias>(T id) {} // Ok, no error
+
+main() {
+  Expect.equals(42, ET(42).id);
+  Expect.equals(null, ET(null).id);
+  Expect.equals("42", ET<String>("42").id);
+}