[tests] Enum shorthands - FutureOr tests and some additional tests.

Added back the `FutureOr` tests now that we've decided what we want to do for `FutureOr`. "`FutureOr<S>` denotes the same namespace as `S` for enum shorthands."

There are a few tests for `X extends T` where the context type is `X`. It would be a compile-time error to find static members of `T` even if `T` did have the corresponding static member.

Bug: #57038
Change-Id: Ibb8054d66e024d93b71878ed49bc7866b785b02c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/397986
Commit-Queue: Kallen Tu <[email protected]>
Reviewed-by: Erik Ernst <[email protected]>

Author: kallentu

tests/language/enum_shorthands/simple/simple_identifier_extends_error_test.dart

@@ -0,0 +1,34 @@
+// Copyright (c) 2024, 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.
+
+// When we get a type `X` that extends a type `T`, we wouldn't be able to find
+// the static members of `T`. It is a compile-time error to use an enum
+// shorthand for type `X` in these cases.
+
+// SharedOptions=--enable-experiment=enum-shorthands
+
+import 'dart:async';
+
+import '../enum_shorthand_helper.dart';
+
+void extendsInteger<X extends Integer>() {
+  X x = .one;
+  // ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+}
+
+void extendsIntegerNullable<X extends Integer?>() {
+  X x = .one;
+  // ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+}
+
+void extendsFutureOrInteger<X extends FutureOr<Integer>>() {
+  X x = .one;
+  // ^
+  // [analyzer] unspecified
+  // [cfe] unspecified
+}

tests/language/enum_shorthands/simple/simple_identifier_future_or_test.dart

@@ -0,0 +1,106 @@
+// Copyright (c) 2024, 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.
+
+// `FutureOr<S>` denotes the same namespace as `S` for enum shorthands.
+
+// SharedOptions=--enable-experiment=enum-shorthands
+
+import 'dart:async';
+
+import '../enum_shorthand_helper.dart';
+
+class ColorFutureOrContext {
+  final FutureOr<Color> color;
+  final FutureOr<Color?> nullableColor;
+  ColorFutureOrContext(this.color, this.nullableColor);
+  ColorFutureOrContext.named({this.color = .blue, this.nullableColor});
+  ColorFutureOrContext.optional([this.color = .blue, this.nullableColor]);
+}
+
+class IntegerFutureOrContext {
+  final FutureOr<Integer> integer;
+  final FutureOr<Integer?> nullableInteger;
+  IntegerFutureOrContext(this.integer, this.nullableInteger);
+  IntegerFutureOrContext.named({this.integer = .constOne, this.nullableInteger});
+  IntegerFutureOrContext.optional([this.integer = .constOne, this.nullableInteger]);
+}
+
+class IntegerExtFutureOrContext {
+  final FutureOr<IntegerExt> integer;
+  final FutureOr<IntegerExt?> nullableInteger;
+  IntegerExtFutureOrContext(this.integer, this.nullableInteger);
+  IntegerExtFutureOrContext.named({this.integer = .constOne, this.nullableInteger});
+  IntegerExtFutureOrContext.optional([this.integer = .constOne, this.nullableInteger]);
+}
+
+class IntegerMixinFutureOrContext {
+  final FutureOr<IntegerMixin> integer;
+  final FutureOr<IntegerMixin?> nullableInteger;
+  IntegerMixinFutureOrContext(this.integer, this.nullableInteger);
+  IntegerMixinFutureOrContext.named({this.integer = .mixinConstOne, this.nullableInteger});
+  IntegerMixinFutureOrContext.optional([this.integer = .mixinConstOne, this.nullableInteger]);
+}
+
+void main() {
+  // Enum
+  FutureOr<Color> color = .blue;
+  FutureOr<Color?> nullableColor = .blue;
+  const FutureOr<Color> constColor = .blue;
+  const FutureOr<Color?> constNullableColor = .blue;
+  switch (color) {
+    case .blue:
+      print('blue');
+    case .red:
+      print('red');
+    case .green:
+      print('green');
+  }
+
+  var colorList = <FutureOr<Color>>[.blue, .green, .red];
+  var nullableColorList = <FutureOr<Color?>>[.blue, .green, .red];
+
+  var colorContextPositional = ColorFutureOrContext(.blue, .red);
+  var colorContextNamed = ColorFutureOrContext.named(color: .blue, nullableColor: .red);
+  var colorContextOptional = ColorFutureOrContext.optional(.blue, .red);
+
+  // Class
+  FutureOr<Integer> integer = .one;
+  FutureOr<Integer?> nullableInteger = .one;
+  const FutureOr<Integer> constInteger = .constOne;
+  const FutureOr<Integer?> constNullableInteger = .constOne;
+
+  var integerList = <FutureOr<Integer>>[.one, .two, .one];
+  var nullableIntegerList = <FutureOr<Integer?>>[.one, .two, .one];
+
+  var integerContextPositional = IntegerFutureOrContext(.one, .two);
+  var integerContextNamed = IntegerFutureOrContext.named(integer: .one, nullableInteger: .two);
+  var integerContextOptional = IntegerFutureOrContext.optional(.one, .two);
+
+  // Extension type
+  FutureOr<IntegerExt> integerExt = .one;
+  FutureOr<IntegerExt?> nullableIntegerExt = .one;
+  const FutureOr<IntegerExt> constIntegerExt = .constOne;
+  const FutureOr<IntegerExt?> constNullableIntegerExt = .constOne;
+
+  var integerExtList = <FutureOr<IntegerExt>>[.one, .two, .one];
+  var nullableIntegerExtList = <FutureOr<IntegerExt?>>[.one, .two, .one];
+
+  var integerExtContextPositional = IntegerExtFutureOrContext(.one, .two);
+  var integerExtContextNamed = IntegerExtFutureOrContext.named(integer: .one, nullableInteger: .two);
+  var integerExtContextOptional = IntegerExtFutureOrContext.optional(.one, .two);
+
+  // Mixin
+  FutureOr<IntegerMixin> integerMixin = .mixinOne;
+  FutureOr<IntegerMixin?> nullableIntegerMixin = .mixinOne;
+  const FutureOr<IntegerMixin> constIntegerMixin = .mixinConstOne;
+  const FutureOr<IntegerMixin?> constNullableIntegerMixin = .mixinConstOne;
+
+  var integerMixinList = <FutureOr<IntegerExt>>[.one, .two, .one];
+  var nullableIntegerMixinList = <FutureOr<IntegerExt?>>[.one, .two, .one];
+
+  var integerMixinContextPositional = IntegerMixinFutureOrContext(.mixinOne, .mixinTwo);
+  var integerMixinContextNamed = IntegerMixinFutureOrContext.named(integer: .mixinOne, nullableInteger: .mixinTwotwo);
+  var integerMixinContextOptional = IntegerMixinFutureOrContext.optional(.mixinOne, .mixinTwo);
+}
+

tests/language/enum_shorthands/simple/simple_identifier_nullable_test.dart

@@ -8,6 +8,13 @@
 
 import '../enum_shorthand_helper.dart';
 
+class NullableInteger {
+  static NullableInteger? get one => NullableInteger(1);
+  static NullableInteger? get two => NullableInteger(2);
+  final int integer;
+  NullableInteger(this.integer);
+}
+
 void main() {
   // Enum
   Color? color = .blue;
@@ -36,5 +43,10 @@ void main() {
   IntegerMixin? integerMixin = .mixinOne;
   const IntegerMixin? constIntegerMixin = .mixinConstOne;
   var integerMixinList = <IntegerMixin?>[.one, .two, .one];
+
+  // Null assertion on a nullable static member.
+  NullableInteger? nullableInteger = .one;
+  NullableInteger nullableIntegerAssert = .one!;
+  var nullableIntegerMixinList = <NullableInteger>[.one!, .two!, .one!];
 }