From 302287eed2ec5b8bddfdd90c3af93175f9e87daa Mon Sep 17 00:00:00 2001 From: Kallen Tu Date: Wed, 8 Jan 2025 15:35:38 -0800 Subject: [PATCH] [tests] Enum shorthands - Selector chain tests for cascades, ??, collections and nested contexts. Tests for nested context types, such as a constructor with an argument that also uses an enum shorthand. Tests for selector chains. Multiple members and properties in one shorthand. Bug: https://github.com/dart-lang/sdk/issues/57038 Change-Id: Ie9609b7594ccbe4347a59026d9e758868015fe64 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/402442 Reviewed-by: Lasse Nielsen Commit-Queue: Kallen Tu --- .../enum_shorthand_helper.dart | 35 ++++++++ .../enum_shorthands/multiple/nested_test.dart | 53 +++++++++++ .../multiple/selector_chain_test.dart | 87 +++++++++++++++++++ 3 files changed, 175 insertions(+) create mode 100644 tests/language/enum_shorthands/multiple/nested_test.dart create mode 100644 tests/language/enum_shorthands/multiple/selector_chain_test.dart diff --git a/tests/language/enum_shorthands/enum_shorthand_helper.dart b/tests/language/enum_shorthands/enum_shorthand_helper.dart index 97f969f2575..69cbdcb49d3 100644 --- a/tests/language/enum_shorthands/enum_shorthand_helper.dart +++ b/tests/language/enum_shorthands/enum_shorthand_helper.dart @@ -45,16 +45,36 @@ class _IntegerWithMixin extends Integer with IntegerMixin { class ConstructorClass { final int? x; + ConstructorClass(this.x); ConstructorClass.regular(this.x); ConstructorClass.named({this.x}); ConstructorClass.optional([this.x]); + ConstructorClass.integer(Integer integer) : x = 1; + + ConstructorClass.staticMember(StaticMember member) : x = 1; + ConstructorClass.staticMemberExt(StaticMemberExt member) : x = 1; + + ConstructorClass.ctor(ConstructorClass ctor) : x = 1; + const ConstructorClass.constRegular(this.x); const ConstructorClass.constNamed({this.x}); const ConstructorClass.constOptional([this.x]); } +class ConstructorWithNonFinal { + final int x; + + ConstructorWithNonFinal field = ConstructorWithNonFinal(1); + + ConstructorWithNonFinal(this.x); + + ConstructorWithNonFinal method() => ConstructorWithNonFinal(1); + + ConstructorWithNonFinal? methodNullable() => null; +} + class UnnamedConstructor {} class UnnamedConstructorTypeParameters {} @@ -75,8 +95,18 @@ class StaticMember { static StaticMember memberType(U u) => StaticMember(u); static StaticMember? memberTypeNullable(U u) => null; + static StaticMember ctor(ConstructorClass c) => + StaticMember(c); + + static StaticMember property(Integer i) => StaticMember(i); + final T t; + StaticMember field = StaticMember.member(); + StaticMember(this.t); + + StaticMember method() => StaticMember.member(); + StaticMember? methodNullable() => null; } extension type StaticMemberExt(T x) { @@ -84,4 +114,9 @@ extension type StaticMemberExt(T x) { static StaticMemberExt? memberNullable() => null; static StaticMemberExt memberType(U u) => StaticMemberExt(u); static StaticMemberExt? memberTypeNullable(U u) => null; + + static StaticMemberExt ctor(ConstructorClass c) => + StaticMemberExt(c); + + static StaticMemberExt property(Integer i) => StaticMemberExt(i); } diff --git a/tests/language/enum_shorthands/multiple/nested_test.dart b/tests/language/enum_shorthands/multiple/nested_test.dart new file mode 100644 index 00000000000..8aeafd98310 --- /dev/null +++ b/tests/language/enum_shorthands/multiple/nested_test.dart @@ -0,0 +1,53 @@ +// Copyright (c) 2025, 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. + +// Nested enum shorthands. + +// SharedOptions=--enable-experiment=enum-shorthands + +import '../enum_shorthand_helper.dart'; + +void main() { + StaticMember memberMember = .memberType( + .memberType(.member()), + ); + + StaticMemberExt memberMemberExt = .memberType( + .memberType(.member()), + ); + + StaticMember memberCtor = .memberType(.new(.member())); + + StaticMemberExt memberCtorExt = .memberType( + .new(.member()), + ); + + StaticMember memberProperty = .property(.one); + + StaticMemberExt memberPropertyExt = .property(.one); + + StaticMember memberCtorMember = .ctor( + .staticMember(.member()), + ); + + StaticMemberExt memberCtorMemberExt = .ctor( + .staticMemberExt(.member()), + ); + + StaticMember memberCtorProperty = .ctor(.integer(.one)); + + ConstructorClass ctorMember = .staticMember(.member()); + + ConstructorClass ctorMemberExt = .staticMemberExt(.member()); + + ConstructorClass ctorProperty = .integer(.one); + + ConstructorClass ctorCtor = .ctor(.new(1)); + + ConstructorClass ctorCtorCtor = .ctor(.ctor(.new(1))); + + ConstructorClass ctorMemberCtor = .staticMember(.ctor(.named(x: 1))); + + ConstructorClass ctorMemberCtorExt = .staticMemberExt(.ctor(.named(x: 1))); +} diff --git a/tests/language/enum_shorthands/multiple/selector_chain_test.dart b/tests/language/enum_shorthands/multiple/selector_chain_test.dart new file mode 100644 index 00000000000..e8129cd2612 --- /dev/null +++ b/tests/language/enum_shorthands/multiple/selector_chain_test.dart @@ -0,0 +1,87 @@ +// Copyright (c) 2025, 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. + +// Enum shorthands selector chains in collections, cascades, `??` and other +// contexts. + +// SharedOptions=--enable-experiment=enum-shorthands + +import 'dart:async'; + +import '../enum_shorthand_helper.dart'; + +class Cascade { + late StaticMember member; + late ConstructorWithNonFinal ctor; +} + +void main() { + StaticMember memberField = .member().field; + StaticMember memberMethod = .member().method(); + StaticMember memberMixed = .member().method().field; + StaticMember memberMixed2 = .member().field.method(); + + ConstructorWithNonFinal ctorField = .new(1).field; + ConstructorWithNonFinal ctorMethod = .new(1).method(); + ConstructorWithNonFinal ctorMixed = + .new(1).method().field; + ConstructorWithNonFinal ctorMixed2 = + .new(1).field.method(); + + // FutureOr + FutureOr futureOrMember = .member().field.method(); + FutureOr futureOrCtor = + .new(1).field.method(); + + // Collection literals + var memberList = [ + .member().field, + .member().field.method(), + ]; + var memberSet = { + .member().field, + .member().field.method(), + }; + var memberMap = { + .member().field: .member().field, + .member().field.method(): .member().field.method(), + }; + + var ctorList = [ + .new(1).field, + .new(1).method().field, + ]; + var ctorSet = { + .new(1).field, + .new(1).method().field, + }; + var ctorMap = { + .new(1).field: .new(1).field, + .new(1).method().field: + .new(1).method().field, + }; + + // Cascades + Cascade() + ..member = .member().field.method() + ..ctor = .new(1).method().field; + + StaticMember memberCascade = .member().field.method()..toString(); + ConstructorWithNonFinal ctorCascade = + .new(1).method().field..toString(); + + // If-null + StaticMember? staticMemberNull = null as StaticMember?; + StaticMember ifNullMember = + staticMemberNull ?? .member().field.method(); + StaticMember ifNullMember2 = + .member().field.methodNullable() ?? .member(); + + ConstructorWithNonFinal? ctorNull = null as ConstructorWithNonFinal?; + ConstructorWithNonFinal ifNullCtor = + ctorNull ?? .new(1).method().field; + ConstructorWithNonFinal ifNullCtor2 = + .new(1).method().field.methodNullable() ?? + ConstructorWithNonFinal(1); +}