Version 2.18.0-165.1.beta
Merge '2.18.0-165.0.dev' into beta
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2a5483d..3b2dffa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -300,6 +300,139 @@
[named args everywhere]: https://github.com/dart-lang/language/blob/master/accepted/future-releases/named-arguments-anywhere/feature-specification.md
[test package]: https://pub.dev/packages/test
+### Language
+
+The following features are new in the Dart 2.17 [language version][]. To use
+them, you must set the lower bound on the SDK constraint for your package to
+2.17 or greater (`sdk: '>=2.17.0 <3.0.0'`).
+
+[language version]: https://dart.dev/guides/language/evolution
+
+- **[Enhanced enums with members][]**: Enum declarations can now define
+ members including fields, constructors, methods, getters, etc. For example:
+
+ ```dart
+ enum Water {
+ frozen(32),
+ lukewarm(100),
+ boiling(212);
+
+ final int tempInFahrenheit;
+ const Water(this.tempInFahrenheit);
+
+ @override
+ String toString() => "The $name water is $tempInFahrenheit F.";
+ }
+ ```
+
+ Constructors must be `const` since enum values are always constants. If the
+ constructor takes arguments, they are passed when the enum value is
+ declared.
+
+ The above enum can be used like so:
+
+ ```dart
+ void main() {
+ print(Water.frozen); // prints "The frozen water is 32 F."
+ }
+ ```
+
+[enhanced enums with members]: https://github.com/dart-lang/language/blob/master/accepted/future-releases/enhanced-enums/feature-specification.md
+
+- **[Super parameters][]**: When extending a class whose constructor takes
+ parameters, the subclass constructor needs to provide arguments for them.
+ Often, these are passed as parameters to the subclass constructor, which
+ then forwards them to the superclass constructor. This is verbose because
+ the subclass constructor must list the name and type of each parameter in
+ its parameter list, and then explicitly forward each one as an argument to
+ the superclass constructor.
+
+ [@roy-sianez][] suggested [allowing `super.`][super dot] before a subclass
+ constructor parameter to implicitly forward it to the corresponding
+ superclass constructor parameter. Applying this feature to Flutter
+ eliminated [nearly 2,000 lines of code][flutter super]. For example, before:
+
+ ```dart
+ class CupertinoPage<T> extends Page<T> {
+ const CupertinoPage({
+ required this.child,
+ this.maintainState = true,
+ this.title,
+ this.fullscreenDialog = false,
+ LocalKey? key,
+ String? name,
+ Object? arguments,
+ String? restorationId,
+ }) : super(
+ key: key,
+ name: name,
+ arguments: arguments,
+ restorationId: restorationId,
+ );
+
+ // ...
+ }
+ ```
+
+ And using super parameters:
+
+ ```dart
+ class CupertinoPage<T> extends Page<T> {
+ const CupertinoPage({
+ required this.child,
+ this.maintainState = true,
+ this.title,
+ this.fullscreenDialog = false,
+ super.key,
+ super.name,
+ super.arguments,
+ super.restorationId,
+ });
+
+ // ...
+ }
+ ```
+
+ From our analysis, over 90% of explicit superclass constructor calls can be
+ completely eliminated, using `super.` parameters instead.
+
+[super parameters]: https://github.com/dart-lang/language/blob/master/working/1855%20-%20super%20parameters/proposal.md
+[@roy-sianez]: https://github.com/roy-sianez
+[super dot]: https://github.com/dart-lang/language/issues/1855
+[flutter super]: https://github.com/flutter/flutter/pull/100905/files
+
+- **[Named args everywhere][]**: In a function call, Dart requires positional
+ arguments to appear before named arguments. This can be frustrating for
+ arguments like collection literals and function expressions that look best
+ as the last argument in the argument list but are positional, like the
+ `test()` function in the [test package][]:
+
+ ```dart
+ main() {
+ test('A test description', () {
+ // Very long function body here...
+ }, skip: true);
+ }
+ ```
+
+ It would be better if the `skip` argument appeared at the top of the call
+ to `test()` so that it wasn't easily overlooked, but since it's named and
+ the test body argument is positional, `skip` must be placed at the end.
+
+ Dart 2.17 removes this restriction. Named arguments can be freely
+ interleaved with positional arguments, allowing code like:
+
+ ```dart
+ main() {
+ test(skip: true, 'A test description', () {
+ // Very long function body here...
+ });
+ }
+ ```
+
+[named args everywhere]: https://github.com/dart-lang/language/blob/master/accepted/future-releases/named-arguments-anywhere/feature-specification.md
+[test package]: https://pub.dev/packages/test
+
### Core libraries
#### `dart:core`
@@ -511,6 +644,11 @@
in 2018, as it doesn't work with any Dart 2.x release.
- Add optional `sourcePort` parameter to `Socket.connect`, `Socket.startConnect`, `RawSocket.connect` and `RawSocket.startConnect`
+- **Breaking Change** [#45410](https://github.com/dart-lang/sdk/issues/45410):
+ `HttpClient` no longer transmits some headers (i.e. `authorization`,
+ `www-authenticate`, `cookie`, `cookie2`) when processing redirects to
+ a different domain.
+
#### `dart:isolate`
- **Breaking change** [#47769](https://github.com/dart-lang/sdk/issues/47769):
diff --git a/tools/VERSION b/tools/VERSION
index 9d216f3..ab563e8 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -23,9 +23,9 @@
# * Making cherry-picks to stable channel
# - increase PATCH by 1
#
-CHANNEL dev
+CHANNEL beta
MAJOR 2
MINOR 18
PATCH 0
PRERELEASE 165
-PRERELEASE_PATCH 0
\ No newline at end of file
+PRERELEASE_PATCH 1
\ No newline at end of file
