| ## 2.12.0 |
| |
| ### Language |
| |
| **Breaking Change** [Null |
| Safety](https://dart.dev/null-safety/understanding-null-safety) is now enabled |
| by default in all packages with a lower sdk constraint of 2.12.0 or greater. |
| Files that are not subject to language versioning (whether because they are not |
| contained in a pub package, or because the package that they are contained in |
| has no lower sdk constraint) are treated as opted into to null safety by default |
| and may report new errors. Pub packages may be opted out of null safety by |
| setting a min sdk constraint in pubspec.yaml of 2.9.0 or less. Files may be |
| opted out of null safety by adding `// @dart=2.9` to the beginning of the file. |
| |
| ### Core libraries |
| |
| #### `dart:collection` |
| |
| * Added `UnmodifiableSetView` class, which allows users to guarantee that |
| methods that could change underlying `Set` instance can not be invoked. |
| |
| #### `dart:core` |
| |
| * Added `unmodifiable` constructor to class `Set`, which allows users to create |
| unmodifiable `Set` instances. |
| |
| #### `dart:io` |
| |
| * `HttpRequest` will now correctly follow HTTP 308 redirects |
| (`HttpStatus.permanentRedirect`). |
| |
| #### `dart:isolate` |
| |
| * Added `debugName` positional parameter to `ReceivePort` and `RawReceivePort` |
| constructors, a name which can be associated with the port and displayed in |
| tooling. |
| |
| #### `dart:collection` |
| |
| * `LinkedList` made it explicit that elements are compared by identity, |
| and updated `contains` to take advantage of this. |
| |
| #### `dart:html` |
| |
| * `EventStreamSubscription.cancel` has been updated to retain its synchronous |
| timing when running in both sound and unsound null safety modes. See issue |
| [#44157][] for more details. |
| |
| [#44157]: https://github.com/dart-lang/sdk/issues/44157 |
| |
| ### Dart VM |
| |
| * **Breaking Change** [#42312][]: `Dart_WeakPersistentHandle`s will no longer |
| auto-delete themselves when the referenced object is garbage collected to |
| avoid race conditions, but they are still automatically deleted when the |
| isolate group shuts down. |
| * **Breaking Change** [#42312][]: `Dart_WeakPersistentHandleFinalizer` |
| is renamed to `Dart_HandleFinalizer` and had its `handle` argument removed. |
| All api functions using that type have been updated. |
| |
| [#42312]: https://github.com/dart-lang/sdk/issues/42312 |
| |
| ### Dart2JS |
| |
| * Removed `--no-defer-class-types` and `--no-new-deferred-split`. |
| |
| ### Tools |
| |
| #### Dartanalyzer |
| |
| * Removed the `--use-fasta-parser`, `--preview-dart-2`, and |
| `--enable-assert-initializers` command line options. These options haven't |
| been supported in a while and were no-ops. |
| |
| #### dartfmt |
| |
| * Don't duplicate comments on chained if elements. |
| * Preserve `?` in initializing formal function-typed parameters. |
| |
| #### Linter |
| |
| Updated the Linter to `0.1.127`, which includes: |
| |
| * fixed crash in `prefer_collection_literals` when there is no static parameter |
| element. |
| * fixed false negatives for `prefer_collection_literals` when a LinkedHashSet or |
| LinkedHashMap instantiation is passed as the argument to a function in any |
| position other than the first. |
| * fixed false negatives for `prefer_collection_literals` when a LinkedHashSet or |
| LinkedHashMap instantiation is used in a place with a static type other than |
| Set or Map. |
| * (Internal): test updates to the new `PhysicalResourceProvider` API. |
| * Fixed false positives in `prefer_constructors_over_static_methods`. |
| * Updates to `package_names` to allow leading underscores. |
| * Fixed NPEs in `unnecessary_null_checks`. |
| * A fixed NPE in `missing_whitespace_between_adjacent_strings`. |
| * Updates to `void_checks` for NNBD. |
| * A fixed range error in `unnecessary_string_escapes`. |
| * A fixed false positives in `unnecessary_null_types`. |
| * Fixes to `prefer_constructors_over_static_methods` to respect type parameters. |
| * Updates to `always_require_non_null_named_parameters` to be NNBD-aware. |
| * Updates tp `unnecessary_nullable_for_final_variable_declarations` to allow dynamic. |
| * Updates `overridden_fields` to not report on abstract parent fields. |
| * Fixes to `unrelated_type_equality_checks` for NNBD. |
| * Improvements to `type_init_formals`to allow types not equal to the field type. |
| * Performance improvements to `always_use_package_imports`, |
| `avoid_renaming_method_parameters`, `prefer_relative_imports` and |
| `public_member_api_docs`. |
| * (internal): updates to analyzer `0.40.4` APIs |
| * New lint: `cast_nullable_to_non_nullable`. |
| * New lint: `null_check_on_nullable_type_parameter`. |
| * New lint: `tighten_type_of_initializing_formals`. |
| * Updates to `public_member_apis` to check generic type aliases. |
| * (Internal): updates to adopt new analyzer APIs. |
| * Fixed `close_sinks` to handle `this`-prefixed property accesses. |
| * New lint: `unnecessary_null_checks`. |
| * Fixed `unawaited_futures` to handle `Future` subtypes. |
| * New lint: `avoid_type_to_string`. |
| |
| #### Pub |
| |
| * **Breaking**: The Dart SDK constraint is now **required** in `pubspec.yaml`. |
| |
| You now have to include a section like: |
| |
| ```yaml |
| environment: |
| sdk: '>=2.10.0 <3.0.0' |
| ``` |
| |
| See [#44072][]. |
| |
| For legacy dependencies without an sdk constraint pub will now assume a |
| default language version of 2.7. |
| * The top level `pub` executable has been deprecated. Use `dart pub` instead. |
| See [dart tool][]. |
| * New command `dart pub add` that adds new dependencies to your `pubspec.yaml`. |
| |
| And a corresponding `dart pub remove` that removes dependencies. |
| * New option `dart pub upgrade --major-versions` will update constraints in |
| your `pubspec.yaml` to match the the _resolvable_ column reported in |
| `dart pub outdated`. This allows users to easily upgrade to latest version for |
| all dependencies where this is possible, even if such upgrade requires an |
| update to the version constraint in `pubspec.yaml`. |
| |
| It is also possible to only upgrade the major version for a subset of your |
| dependencies using `dart pub upgrade --major-versions <dependencies...>`. |
| * New option `dart pub upgrade --null-safety` will attempt to update constraints |
| in your `pubspec.yaml`, such that only null-safety migrated versions of |
| dependencies are allowed. |
| * New option `dart pub outdated --mode=null-safety` that will analyze your |
| dependencies for null-safety. |
| * `dart pub publish` will now check your pubspec keys for likely typos. |
| * `dart pub upgrade package_foo` will fetch dependencies, but ignore the |
| `pubspec.lock` for `package_foo`, allowing users to only upgrade a subset of |
| dependencies. |
| * New command `dart pub login` that logs in to pub.dev. |
| * The `--server` option to `dart pub publish` and `dart pub uploader` have been |
| deprecated. Use `publish_to` in your `pubspec.yaml` or set the |
| `$PUB_HOSTED_URL` environment variable. |
| * `pub global activate no longer re-precompiles if current global installed was |
| same version. |
| * The Flutter SDK constraint upper bound is now ignored in pubspecs and |
| deprecated when publishing. |
| |
| See: [flutter-upper-bound-deprecation][]. |
| |
| [flutter-upper-bound-deprecation]: https://dart.dev/go/flutter-upper-bound-deprecation |
| [#44072]: https://github.com/dart-lang/sdk/issues/44072 |
| [dart tool]: https://dart.dev/tools/dart-tool |
| |
| ## 2.10.4 - 2020-11-12 |
| |
| This is a patch release that fixes a crash in the Dart VM (issues [#43941][], |
| [flutter/flutter#43620][], and [Dart-Code/Dart-Code#2814][]). |
| |
| [#43941]: https://github.com/dart-lang/sdk/issues/43941 |
| [flutter/flutter#43620]: https://github.com/flutter/flutter/issues/43620 |
| [Dart-Code/Dart-Code#2814]: https://github.com/Dart-Code/Dart-Code/issues/2814 |
| |
| ## 2.10.3 - 2020-10-29 |
| |
| This is a patch release that fixes the following issues: |
| * breaking changes in Chrome 86 that affect DDC (issues [#43750][] and |
| [#43193][]). |
| * compiler error causing incorrect use of positional parameters when named |
| parameters should be used instead (issues [flutter/flutter#65324][] and |
| [flutter/flutter#68092][]). |
| * crashes and/or undefined behavor in AOT compiled code (issues [#43770][] and |
| [#43786][]). |
| * AOT compilation of classes with more than 64 unboxed fields |
| (issue [flutter/flutter#67803][]). |
| |
| [#43750]: https://github.com/dart-lang/sdk/issues/43750 |
| [#43193]: https://github.com/dart-lang/sdk/issues/43193 |
| [flutter/flutter#65324]: https://github.com/flutter/flutter/issues/65324 |
| [flutter/flutter#68092]: https://github.com/flutter/flutter/issues/68092 |
| [#43770]: https://github.com/dart-lang/sdk/issues/43770 |
| [#43786]: https://github.com/dart-lang/sdk/issues/43786 |
| [flutter/flutter#67803]: https://github.com/flutter/flutter/issues/67803 |
| |
| ## 2.10.2 - 2020-10-15 |
| |
| This is a patch release that fixes a DDC compiler crash (issue [#43589]). |
| |
| [#43589]: https://github.com/dart-lang/sdk/issues/43589 |
| |
| ## 2.10.1 - 2020-10-06 |
| |
| This is a patch release that fixes the following issues: |
| * crashes when developing Flutter applications (issue [#43464][]). |
| * non-deterministic incorrect program behaviour and/or crashes (issue |
| [flutter/flutter#66672][]). |
| * uncaught TypeErrors in DDC (issue [#43661][]). |
| |
| [#43464]: https://github.com/dart-lang/sdk/issues/43464 |
| [flutter/flutter#66672]: https://github.com/flutter/flutter/issues/66672 |
| [#43661]: https://github.com/dart-lang/sdk/issues/43661 |
| |
| ## 2.10.0 - 2020-09-28 |
| |
| ### Core libraries |
| |
| #### `dart:io` |
| |
| * Adds `Abort` method to class `HttpClientRequest`, which allows users |
| to cancel outgoing HTTP requests and stop following IO operations. |
| * A validation check is added to `path` of class `Cookie`. Having characters |
| ranging from 0x00 to 0x1f and 0x3b (";") will lead to a `FormatException`. |
| * The `HttpClient` and `HttpServer` classes now have a 1 MiB limit for the |
| total size of the HTTP headers when parsing a request or response, instead |
| of the former 8 KiB limit for each header name and value. This limit cannot |
| be configured at this time. |
| |
| #### `dart:typed_data` |
| |
| * Class `BytesBuilder` is moved from `dart:io` to `dart:typed_data`. |
| It's temporarily being exported from `dart:io` as well. |
| |
| ### Dart VM |
| |
| * **Breaking Change** [#42982][]: `dart_api_dl.cc` is renamed to |
| `dart_api_dl.c` and changed to a pure C file. |
| * Introduces `Dart_FinalizableHandle`s. They do auto-delete, and the weakly |
| referred object cannot be accessed through them. |
| |
| ### Dart2JS |
| |
| * Adds support for deferred loading of types seperately from classes. This |
| enables dart2js to make better optimization choices when deferred loading. |
| This work is necessary to address unsoundness in the deferred loading |
| algorithm. Currently, fixing this unsoundness would result in code bloat, |
| but loading types seperately from classes will allow us to fix the |
| unsoundness with only a minimal regression. To explicitly disable |
| deferred loading of types, pass `--no-defer-class-types`. See the original |
| post on the [unsoundness in the deferred loading algorithm][]. |
| * Enables a new sound deferred splitting algorithm. To explicitly disable |
| the new deferred splitting algorithm, pass `--no-new-deferred-split`. |
| See the original post on the |
| [unsoundness in the deferred loading algorithm][]. |
| |
| |
| [#42982]: https://github.com/dart-lang/sdk/issues/42982 |
| [unsoundness in the deferred loading algorithm]: https://github.com/dart-lang/sdk/blob/302ad7ab2cd2de936254850550aad128ae76bbb7/CHANGELOG.md#dart2js-3 |
| |
| ### Tools |
| |
| #### dartfmt |
| |
| * Don't crash when non-ASCII whitespace is trimmed. |
| * Split all conditional expressions (`?:`) when they are nested. |
| * Handle `external` and `abstract` fields and variables. |
| |
| #### Linter |
| |
| Updated the Linter to `0.1.118`, which includes: |
| |
| * New lint: `unnecessary_nullable_for_final_variable_declarations`. |
| * Fixed NPE in `prefer_asserts_in_initializer_lists`. |
| * Fixed range error in `unnecessary_string_escapes`. |
| * `unsafe_html` updated to support unique error codes. |
| * Updates to `diagnostic_describe_all_properties` to check for `Diagnosticable`s (not `DiagnosticableMixin`s). |
| * New lint: `use_late`. |
| * Fixed `unnecessary_lambdas` to respect deferred imports. |
| * Updated `public_member_api_docs` to check mixins. |
| * Updated `unnecessary_statements` to skip `as` expressions. |
| * Fixed `prefer_relative_imports` to work with path dependencies. |
| |
| #### Pub |
| |
| * `pub run` and `pub global run` accepts a `--(no-)-sound-null-safety` flag, |
| that is passed to the VM. |
| * Fix: Avoid multiple recompilation of binaries in global packages. |
| * Fix: Avoid exponential behaviour of error reporting from the solver. |
| * Fix: Refresh binstubs after recompile in global run. |
| |
| ## 2.9.3 - 2020-09-08 |
| |
| This is a patch release that fixes DDC to handle a breaking change in Chrome |
| (issue [#43193][]). |
| |
| [#43193]: https://github.com/dart-lang/sdk/issues/43193 |
| |
| ## 2.9.2 - 2020-08-26 |
| |
| This is a patch release that fixes transient StackOverflow exceptions when |
| building Flutter applications (issue [flutter/flutter#63560][]). |
| |
| [flutter/flutter#63560]: https://github.com/flutter/flutter/issues/63560 |
| |
| ## 2.9.1 - 2020-08-12 |
| |
| This is a patch release that fixes unhandled exceptions in some Flutter |
| applications (issue [flutter/flutter#63038][]). |
| |
| [flutter/flutter#63038]: https://github.com/flutter/flutter/issues/63038 |
| |
| ## 2.9.0 - 2020-08-05 |
| |
| ### Language |
| |
| ### Core libraries |
| |
| #### `dart:async` |
| |
| * Adds `Stream.multi` constructor creating streams which can be |
| listened to more than once, and where each individual listener |
| can be controlled independently. |
| |
| #### `dart:convert` |
| |
| * **Breaking Change** [#41100][]: When encoding a string containing unpaired |
| surrogates as UTF-8, the unpaired surrogates will be encoded as replacement |
| characters (`U+FFFD`). When decoding UTF-8, encoded surrogates will be |
| treated as malformed input. When decoding UTF-8 with `allowMalformed: true`, |
| the number of replacement characters emitted for malformed input sequences |
| has been changed to match the [WHATWG encoding standard][]. |
| |
| [#41100]: https://github.com/dart-lang/sdk/issues/41100 |
| [WHATWG encoding standard]: https://encoding.spec.whatwg.org/#utf-8-decoder |
| |
| #### `dart:io` |
| |
| * [#42006][]: The signature of `exit` has been changed to return the |
| `Never`type instead of `void`. since no code will run after it, |
| * Class `OSError` now implements `Exception`. This change means `OSError` will |
| now be caught in catch clauses catching `Exception`s. |
| * Added `InternetAddress.tryParse`. |
| * [Abstract Unix Domain Socket][] is supported on Linux/Android now. Using an |
| `InternetAddress` with `address` starting with '@' and type being |
| `InternetAddressType.Unix` will create an abstract Unix Domain Socket. |
| * On Windows, file APIs can now handle files and directories identified by |
| long paths (greater than 260 characters). It complies with all restrictions |
| from [Long Path on Windows][]. Note that `Directory.current` does not work |
| with long path. |
| |
| [#42006]: https://github.com/dart-lang/sdk/issues/42006 |
| [Abstract Unix Domain Socket]: http://man7.org/linux/man-pages/man7/unix.7.html |
| [Long Path on Windows]: https://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file#maximum-path-length-limitation |
| |
| #### `dart:html` |
| |
| * **Breaking Change**: `CssClassSet.add()` previously returned `null` if the |
| `CssClassSet` corresponded to multiple elements. In order to align with the |
| null-safe changes in the `Set` interface, it will now return `false` |
| instead. The same applies for `CssClassSet.toggle`. |
| |
| * `EventStreamSubscription.cancel` method used to return `null`, but since |
| `StreamSubscription.cancel` has changed to be non-nullable, this method |
| returns an empty `Future` instead. Due to an optimization on `null` |
| `Future`s, this method used to complete synchronously, but now that the |
| `Future` is empty instead, it completes asynchronously, therefore |
| potentially invalidating code that relied on the synchronous side-effect. |
| This change will only affect code using sound null-safety. See issue |
| [#41653][] for more details. |
| |
| * Methods in `Console` have been updated to better reflect the modern Console |
| specification. Particularly of interest are `dir` and `table` which take in |
| extra optional arguments. |
| |
| [#41653]: https://github.com/dart-lang/sdk/issues/41653 |
| |
| #### `dart:mirrors` |
| |
| * **Breaking Change** [#42714][]: web compilers (dart2js and DDC) now produce |
| a compile-time error if `dart:mirrors` is imported. |
| |
| Most projects should not be affected. Since 2.0.0 this library was |
| unsupported and produced runtime errors on all its APIs. Since then several |
| tools already reject code that use `dart:mirrors` including webdev and |
| flutter tools, we expect few projects to run into this problem. |
| |
| [#42714]: https://github.com/dart-lang/sdk/issues/42714 |
| |
| ### Tools |
| |
| #### dartfmt |
| |
| * Add `--fix-single-cascade-statements`. |
| * Correctly handle `var` in `--fix-function-typedefs`. |
| * Preserve leading indentation in fixed doc comments. |
| * Split outer nested control flow elements. |
| * Always place a blank line after script tags. |
| * Don't add unneeded splits on if elements near comments. |
| * Indent blocks in initializers of multiple-variable declarations. |
| * Update the null-aware subscript syntax from `?.[]` to `?[]`. |
| |
| #### Linter |
| |
| Updated the Linter to `0.1.117`, which includes: |
| |
| * New lint: `do_not_use_environment`. |
| * New lint: `exhaustive_cases`. |
| * New lint: `no_default_cases` (experimental). |
| * New lint: `sized_box_for_whitespace`. |
| * New lint: `use_is_even_rather_than_modulo`. |
| * Updated `directives_ordering` to remove third party package special-casing. |
| * Updated `prefer_is_empty` to special-case assert initializers and const |
| contexts. |
| * Updated `prefer_mixin` to allow "legacy" SDK abstract class mixins. |
| * Updated `sized_box_for_whitespace` to address false-positives. |
| * Updated `type_annotate_public_apis` to allow inferred types in final field |
| assignments. |
| * Updated `unnecessary_lambdas` to check for tear-off assignability. |
| * Updated `unsafe_html` to use a `SecurityLintCode` (making it un-ignorable) and |
| to include `Window.open`, `Element.html` and `DocumentFragment.html` in unsafe |
| API checks. Also added checks for attributes and methods on extensions. |
| |
| ### Dart VM |
| |
| * **Breaking Change** [#41100][]: When printing a string using the `print` |
| function, the default implementation (used when not overridden by the |
| embedder or the current zone) will print any unpaired surrogates in the |
| string as replacement characters (`U+FFFD`). Similarly, the |
| `Dart_StringToUTF8` function in the Dart API will convert unpaired |
| surrogates into replacement characters. |
| |
| ### Pub |
| * `pub run` and `pub global run` accepts a `--enable-experiment` flag enabling |
| experiments in the Dart VM (and language). |
| * Warn when publishing the first null-safe version of a package. |
| * `pub outdated`: |
| * If the current version of a dependency is a prerelease |
| version, use prereleases for latest if there is no newer stable. |
| * Don't require a `pubspec.lock` file. When the lockfile is missing, the |
| **Current** column is empty. |
| * `pub upgrade`: Show summary count of outdated packages after running. |
| It will also only show newer packages if they are not prereleases or |
| the package is already a prerelease. |
| * Publishing Flutter plugins using the old plugin format is no longer allowed. |
| Plugins using the old plugin format can still be consumed. |
| * `pub run`: Fix precompilation with relative `PUB_CACHE` paths |
| ([#2486](https://github.com/dart-lang/pub/pull/2486)). |
| * Preserve Windows line endings in `pubspec.lock` if they are already there |
| ([#2489](https://github.com/dart-lang/pub/pull/2489)). |
| * Better terminal color-detection. Use colors in terminals on Windows. |
| * Fix git folder names in cache, allowing for ssh-style git |
| dependencies. |
| * Fix: Avoid precompilation of dependencies of global packages. |
| |
| ## 2.8.4 - 2020-06-04 |
| |
| This is a patch release that fixes potential memory leaks in the Dart front-end |
| (issues [#42111][] and [#42112][]). |
| |
| [#42111]: https://github.com/dart-lang/sdk/issues/42111 |
| [#42112]: https://github.com/dart-lang/sdk/issues/42112 |
| |
| ## 2.8.3 - 2020-05-28 |
| |
| This is a patch release that fixes the following issues: |
| * crashes in Flutter apps (issue [flutter/flutter#57318][]). |
| * a regression in stack traces (issue [#41907][]). |
| * re-canonicalization of constants with unboxed fields (issue |
| [flutter/flutter#57190][]). |
| |
| [flutter/flutter#57318]: https://github.com/flutter/flutter/issues/57318 |
| [#41907]: https://github.com/dart-lang/sdk/issues/41907 |
| [flutter/flutter#57190]: https://github.com/flutter/flutter/issues/57190 |
| |
| ## 2.8.2 - 2020-05-13 |
| |
| This is a patch release that fixes an AOT compilation bug in global |
| transformations which manifests as a NoSuchMethod exception |
| (issue [flutter/flutter#56479][]). |
| |
| [flutter/flutter#56479]: https://github.com/flutter/flutter/issues/56479 |
| |
| ## 2.8.1 - 2020-05-06 |
| |
| Much of the changes in this release are in preparation for non-nullable types, |
| which will arrive in a future version. In anticipation of that, we have made a |
| number of small but technically breaking changes to several core library APIs in |
| order to make them easier to use in a world with non-nullable types. Almost all |
| existing Dart code will be unaffected by these changes, but if you see |
| unexpected failures, note the breaking changes listed below. |
| |
| ### Language |
| |
| There are no new language features in this release. There are only two |
| minor breaking changes: |
| |
| * **Breaking change** [#40675][]: Fixed an implementation bug where local |
| variable inference would incorrectly use the promoted type of a type |
| variable. |
| |
| * **Breaking change** [#41362][]: Dart 2.0.0 made the clauses `implements |
| Function`, `extends Function`, or `with Function` have no effect (spec |
| section 19.6). We fixed an implementation bug that may be visible on some |
| rare scenarios. |
| |
| [#40675]: https://github.com/dart-lang/sdk/issues/40675 |
| [#41362]: https://github.com/dart-lang/sdk/issues/41362 |
| |
| ### Core libraries |
| |
| #### `dart:async` |
| |
| * **Breaking change** [#40676][]: Changed the return type of |
| `StreamSubscription.cancel()` to `Future<void>`. Previously, it was |
| declared to return `Future` and was allowed to return `null` at runtime. |
| |
| * **Breaking change** [#40681][]: The `runZoned()` function is split into two |
| functions: `runZoned()` and `runZonedGuarded()`, where the latter has a |
| required `onError` parameter, and the former has none. This prepares the |
| functions for Null Safety where the two functions will differ in the |
| nullability of their return types. |
| |
| * **Breaking change** [#40683][]: Errors passed to |
| `Completer.completeError()`, `Stream.addError()`, `Future.error()`, etc. can |
| no longer be `null`. These operations now *synchronously* throw an exception |
| if passed a `null` error. |
| |
| * Make stack traces non-null [#40130][]. Where methods like |
| `completer.completeError()` allow omitting a stack trace, the platform will |
| now insert a default stack trace rather than propagate a `null` value. |
| |
| Error handling functions need no longer be prepared for `null` stack traces. |
| |
| [#40676]: https://github.com/dart-lang/sdk/issues/40676 |
| [#40681]: https://github.com/dart-lang/sdk/issues/40681 |
| [#40683]: https://github.com/dart-lang/sdk/issues/40683 |
| [#40130]: https://github.com/dart-lang/sdk/issues/40130 |
| |
| #### `dart:core` |
| |
| * **Breaking change** [#40674][]: Three members on `RuneIterator` no longer |
| return `null` when accessed before the first call to `moveNext()`. Instead, |
| `current` and `rawIndex` return `-1` and `currentAsString` returns an empty |
| string. |
| |
| * **Breaking change** [#40678][]: The `String.fromEnvironment()` default value |
| for `defaultValue` is now an empty string instead of `null`. Likewise, the |
| default value for `int.fromEnvironment()`'s `defaultValue` parameter is |
| zero. Under null safety, a constructor cannot return `null`, so this |
| prepares these APIs for that. |
| |
| * The class `CastError` is deprecated, and all implementation specific classes |
| implementing `TypeError` or `CastError` now implement both. In a future |
| release, `CastError` will be removed. See issue [40763][] for details. |
| |
| * Adds `StackTrace.empty` constant which is the stack trace used as default |
| stack trace when no better alternative is available. |
| |
| * The class `TypeError` no longer extends `AssertionError`. This also means |
| that it no longer inherits the spurious `message` getter which was added to |
| `AssertionError` when the second operand to `assert` was allowed. The value |
| of that getter on a `TypeError` was the same string as returned by |
| `toString()`, so it is still available. |
| |
| * `ArgumentError.checkNotNull()` and the `RangeError` static methods |
| `checkValueInInterval()`, `checkValidIndex()` and `checkNotNegative()` all |
| return their first argument on success. This makes these functions more |
| convenient to use in-line in, for example, `=>` function bodies or |
| constructor initialization lists. |
| |
| [#40674]: https://github.com/dart-lang/sdk/issues/40674 |
| [#40678]: https://github.com/dart-lang/sdk/issues/40678 |
| [40763]: https://github.com/dart-lang/sdk/issues/40763 |
| |
| #### `dart:developer` |
| |
| * The constructors for `TimelineTask` now accept an optional `filterKey` |
| parameter. If provided, the arguments for all events associated with the |
| task will contain an entry named `filterKey`, set to the value of the |
| `filterKey` parameter provided in the constructor. This will be used by |
| tooling to allow for better filtering of timeline events. |
| |
| #### `dart:html` |
| |
| * **Breaking Change** [#39627][]: Changed the return type of several HTML |
| native methods involving futures. In return types that matched |
| `Future<List<T>>`, `T was` changed to `dynamic`. These methods would have |
| resulted in a runtime error if they were used. |
| |
| * **Breaking Change**: `Node.insertAllBefore()` erroneously had a return type |
| of `Node`, even though it was not returning anything. This has been |
| corrected to `void`. |
| |
| [#39627]: https://github.com/dart-lang/sdk/issues/39627 |
| |
| #### `dart:io` |
| |
| * Class `HttpParser` will no longer throw an exception when a HTTP response |
| status code is within [0, 999]. Customized status codes in this range are |
| now valid. |
| |
| * **Breaking change** [#33501][]: The signature of `HttpHeaders` methods |
| `add()` and `set` have been changed to: |
| |
| ```dart |
| void add(String name, Object value, {bool preserveHeaderCase: false}) |
| void set(String name, Object value, {bool preserveHeaderCase: false}) |
| ``` |
| |
| Setting `preserveHeaderCase` to `true` preserves the case of the `name` |
| parameter instead of converting it to lowercase. The `HttpHeader.forEach()` |
| method provides the current case of each header. |
| |
| This is breaking only for classes extending or implementing `HttpHeaders` |
| and having their own `add` or `set` methods without the `bool |
| preserveHeaderCase` named parameter. |
| |
| * **Breaking change** [#40702][]: The `Socket` class now throws a |
| `SocketException` if the socket has been explicitly destroyed or upgraded to |
| a secure socket upon setting or getting socket options. Previously, setting |
| a socket option would be ignored and getting a socket option would return |
| `null`. |
| |
| * **Breaking change** [#40483][]: The `Process` class now throws a |
| `StateError` if the process is detached (`ProcessStartMode.detached` and |
| `ProcessStartMode.detachedWithStdio`) upon accessing the `exitCode` getter. |
| It now also throws when not connected to the child process's stdio |
| (`ProcessStartMode.detached` and `ProcessStartMode.inheritStdio`) upon |
| accessing the `stdin`, `stdout`, and `stderr` getters. Previously, these |
| getters would all return `null`. |
| |
| * **Breaking change** [#40706][]: The dummy object returned if |
| `FileStat.stat()` or `FileStat.statSync()` fail now contains Unix epoch |
| timestamps instead of `null` for the `accessed`, `changed`, and `modified` |
| getters. |
| |
| * **Breaking change** [#40709][]: The `HeaderValue` class now parses more |
| strictly in two invalid edge cases. This is the class used to parse the |
| semicolon delimited parameters used in the `Accept`, `Authorization`, |
| `Content-Type`, and other such HTTP headers. |
| |
| The empty parameter value without double quotes (which is not allowed by the |
| standards) is now parsed as the empty string rather than `null`. E.g. |
| `HeaderValue.parse("v;a=").parameters` now gives `{"a": ""}` rather than |
| `{"a": null}`. |
| |
| Invalid inputs with unbalanced double quotes are now rejected. E.g. |
| `HeaderValue.parse('v;a="b').parameters` will now throw a `HttpException` |
| instead of giving `{"a": "b"}`. |
| |
| * The `HeaderValue.toString()` method now supports parameters with `null` |
| values by omitting the value. `HeaderValue("v", {"a": null, "b": |
| "c"}).toString()` now gives `v; a; b=c`. This behavior can be used to |
| implement some features in the `Accept` and `Sec-WebSocket-Extensions` |
| headers. |
| |
| Likewise the empty value and values using characters outside of [RFC 7230 |
| tokens][] are now correctly implemented by double quoting such values with |
| escape sequences. For example: |
| |
| ```dart |
| HeaderValue("v", |
| {"a": "A", "b": "(B)", "c": "", "d": "ø", "e": "\\\""}).toString() |
| ``` |
| |
| Gives: `v;a=A;b="(B)";c="";d="ø";e="\\\""`. |
| |
| * [Unix domain sockets][] are now supported on Linux, Android and MacOS, which |
| can be used by passing a `InternetAddress` of `InternetAddressType.Unix` |
| into the `connect()`, `startConnect()` and `bind()` methods. The `port` |
| argument in those methods will be ignored. The `port` getter always returns |
| 0 for Unix domain sockets. |
| |
| * Class `InternetAddressType` gains one more option `Unix`, which represents a |
| Unix domain address. |
| |
| * Class `InternetAddress`: |
| |
| * `InternetAddress` constructor gains an optional `type` parameter. To |
| create a Unix domain address, `type` is set to |
| `InternetAddressType.Unix` and `address` is a file path. |
| |
| * `InternetAddress` gains a new constructor `fromRawAddress()` that takes |
| an address in byte format for Internet addresses or raw file path for |
| Unix domain addresses. |
| |
| * **Breaking change** [#40681][]: The static methods `runZoned()` and |
| `runWithHttpOverrides()` on `HttpOverrides` no longer accept |
| `zoneSpecification` and `onError` parameters. Use the `runZoned()` or |
| `runZonedGuarded()` functions from `dart:async` directly if needing to |
| specify those. |
| |
| * Class `HttpClient` and `HttpServer`, when receiving `HttpRequest` or |
| `HttpClientResponse`, will now put a 8K size limit on its header fields and |
| values. |
| |
| [#33501]: https://github.com/dart-lang/sdk/issues/33501 |
| [#40702]: https://github.com/dart-lang/sdk/issues/40702 |
| [#40483]: https://github.com/dart-lang/sdk/issues/40483 |
| [#40706]: https://github.com/dart-lang/sdk/issues/40706 |
| [#40709]: https://github.com/dart-lang/sdk/issues/40709 |
| [RFC 7230 tokens]: https://tools.ietf.org/html/rfc7230#section-3.2.6 |
| [Unix domain sockets]: https://en.wikipedia.org/wiki/Unix_domain_socket |
| |
| #### `dart:mirrors` |
| |
| * Added `MirrorSystem.neverType`. |
| |
| ### Dart VM |
| |
| * Added `Dart_TypeDynamic`, `Dart_TypeVoid` and `Dart_TypeNever`. Type |
| `dynamic` can no longer by reached using `Dart_GetType(dart:core, dynamic)`. |
| |
| * Added the following methods to the VM embedding API: |
| |
| * `Dart_GetNonNullableType()` |
| * `Dart_GetNullableType()` |
| * `Dart_TypeToNonNullable()` |
| * `Dart_TypeToNullable()` |
| * `Dart_IsLegacyType()` |
| * `Dart_IsNonNullableType()` |
| * `Dart_IsNullableType()` |
| |
| ### Foreign Function Interface (`dart:ffi`) |
| |
| * **Breaking Change**: Changed `Pointer.asFunction()` and |
| `DynamicLibrary.lookupFunction()` to extension methods. Invoking them |
| dynamically previously already threw an exception, so the runtime behavior |
| stays the same. However, the extension methods are only visible if |
| `dart:ffi` is imported directly. This breaks code where `dart:ffi` is not |
| directly imported. To fix, add: |
| |
| ```dart |
| import 'dart:ffi'; |
| ``` |
| |
| ### Tools |
| |
| #### Dart Dev Compiler (DDC) |
| |
| We fixed several inconsistencies between DDC and Dart2JS so that users less |
| frequently encounter code that is accepted by one compiler but then fails in the |
| other. |
| |
| * **Breaking Change**: Deleted the legacy (analyzer based) version of DDC. For |
| additional details see the [announcement][ddc]. |
| |
| * The `--kernel` option is now ignored and defaults to true. There is no |
| longer any way to invoke the legacy (analyzer based) version of DDC. |
| |
| * Command line arguments that were only used for the legacy DDC have been |
| removed. |
| |
| * The pre-compiled `dart_sdk.js` artifacts generated by legacy DDC have |
| been deleted from `dart-sdk/lib/dev_compiler` in favor of the versions |
| located at `dart-sdk/lib/dev_compiler/kernel`. |
| |
| * **Breaking Change**: Functions passed to JavaScript using the recommended |
| `package:js` interop specification must now be wrapped with a call to |
| `allowInterop`. This behavior was always enforced by Dart2JS, but was not |
| enforced consistently by DDC. It is now enforced by both. |
| |
| * **Breaking Change**: Constructors in `@JS()` classes must be marked with |
| `external`. Previously the `external` could be omitted in some cases with |
| DDC but doing so would cause incorrect behavior with Dart2JS. |
| |
| * JS interop classes with an index operator are now static errors. |
| |
| * All remaining support from the `dart:mirrors` library has been removed. Use |
| of this library on the web has been unsupported and prevented by the Dart |
| build systems since Dart v2.0.0. All known exception cases have been cleaned |
| up. This change makes DDC and Dart2JS now behave consistently. |
| |
| The library can still be imported on web apps, but all APIs throw. In a |
| future breaking change release, imports to this library will likely become a |
| compile-time error. |
| |
| [ddc]: https://github.com/dart-lang/sdk/issues/38994 |
| |
| #### Dart2JS |
| |
| A new representation of runtime types is enabled by default. |
| |
| This change is part of a long term goal of making runtime checks cheaper and |
| more flexible for upcoming changes in the language. The new representation |
| disentangles how types and classes are represented and makes types first-class |
| to the compiler. This makes it possible to do certain kind of optimizations on |
| type checks that were not possible before and will enable us to model |
| non-nullable types in the near future. |
| |
| This change should not affect the semantics of your application, but it has some |
| relatively small visible effects that we want to highlight: |
| |
| * Types are now canonicalized, this fixes a long standing bug that Types could |
| not be used in switch cases (issue [17207][]). |
| |
| * Code-size changes may be visible, but the difference is small overall. It is |
| more visible on smaller apps because the new implementation includes more |
| helper methods. On large apps we have even seen an overall code-size |
| reduction. |
| |
| * Certain checks are a lot faster. This is less noticeable if you are |
| compiling apps with `-O3` where checks are omitted altogether. Even with |
| `-O3`, the performance of some `is` checks used by your app may improve. |
| |
| * When using `-O3` and `-O4` incorrect type annotations could surface as |
| errors. The old type representation was accidentally lenient on some invalid |
| type annotations. We have only encountered this issue on programs that were |
| not tested properly at the js-interop program boundary. |
| |
| * `Type.toString()` has a small change that is rarely visible. For a long |
| time, Dart2JS has had support to erase unused type variables. Today, when |
| Dart2JS is given `--lax-runtime-type-to-string` (currently included in |
| `-O2`, `-O3`, and `-O4`) and it decides to erase the type variable of a |
| class `Foo<T>`, then it compiles expressions like |
| `foo.runtimeType.toString()` to print `Foo`. With the new representation, |
| this will show `Foo<erased>` instead. This change may be visible in error |
| messages produced by type checks involving erased types. |
| |
| Because types and classes are represented separately, we will likely reevaluate |
| restrictions of deferred libraries in the near future. For example, we could |
| support referring to deferred types because types can be downloaded while |
| classes are not. |
| |
| In the unlikely case you run into any issues, please file a bug so we can |
| investigate. You can temporarily force the old type representation by passing |
| `--use-old-rti` to Dart2JS if necessary, but our goal is to delete the old type |
| representation soon. |
| |
| In addition, we fixed some inconsistencies between Dart2JS and DDC: |
| |
| * JS interop classes with an index operator are now static errors instead of |
| causing invalid code in Dart2JS. |
| |
| * **Breaking Change**: The subtyping rule for generic functions is now more |
| forgiving. Corresponding type parameter bounds now only need to be mutual |
| subtypes rather than structurally equal up to renaming of bound type |
| variables and equating all top types. |
| |
| * **Breaking Change**: Types are now normalized. See [normalization][] for the |
| full specification. Types will now be printed in their normal form, and |
| mutual subtypes with the same normal form will now be considered equal. |
| |
| * **Breaking Change**: Constructors in `@JS()` classes must be marked with |
| `external`. Previously, the external could be omitted for unused |
| constructors. Omitting `external` for a constructor which is used would |
| cause incorrect behavior at runtime, now omitting it on any constructor is a |
| static error. |
| |
| [17207]: https://github.com/dart-lang/sdk/issues/17207 |
| |
| [normalization]: https://github.com/dart-lang/language/blob/master/resources/type-system/normalization.md |
| |
| |
| Other dart2js changes: |
| |
| * **Breaking Change**: The `--package-root` flag, which was hidden and disabled |
| in Dart 2.0.0, has been completely removed. Passing this flag will now cause |
| `dart2js` to fail. |
| |
| #### Linter |
| |
| Updated the Linter to `0.1.114`, which includes: |
| |
| * Fixed `avoid_shadowing_type_parameters` to support extensions and mixins. |
| * Updated `non_constant_identifier_names` to allow named constructors made up of only underscores (`_`). |
| * Updated `avoid_unused_constructor_parameters` to ignore unused params named in all underscores (`_`). |
| |
| #### Analyzer |
| |
| * Removed support for the deprecated analysis options file name |
| `.analysis_options`. |
| |
| #### Pub |
| |
| * Added `pub outdated` command which lists outdated package dependencies, and |
| gives advice on how to upgrade. |
| |
| * `pub get` and `pub upgrade` now fetch version information about hosted |
| dependencies in parallel, improving the time package resolution performance. |
| |
| * `pub get` and `pub upgrade` no longer precompile executables from |
| dependencies by default. Instead they are precompiled on first `pub run`. |
| Use `pub get --precompile` to get the previous behavior. |
| |
| * Fixed missing retries of DNS failures during `pub get`. |
| |
| * If code contains imports for packages not listed in the package's |
| `pubspec.yaml` then `pub publish` will reject the package. |
| |
| * `pub publish` no longer requires the presence of a `homepage` field, if the |
| `repository` field is provided. |
| |
| * `pub publish` warns if non-pre-release packages depends on pre-release |
| packages or pre-release Dart SDKs. |
| |
| * Relative paths in `pubspec.lock` now use `/` also on Windows to make the |
| file sharable between machines. |
| |
| * Fixed language version in [`.dart_tool/package_config.json`][package config] |
| for packages without an explicit SDK constraint. Pub now writes an empty |
| language version where before the language version of the current SDK would |
| be used. |
| |
| * `%LOCALAPPDATA%` is now preferred over `%APPDATA%` when creating a pub cache |
| directory on Windows. `%LOCALAPPDATA%` is not copied when users roam between |
| devices. |
| |
| * `pub publish` warns if LICENSE and README.md files are not called those |
| exact names. |
| |
| * `pub repair cache` downloads hosted packages in parallel. |
| |
| [package config]: https://github.com/dart-lang/language/blob/master/accepted/future-releases/language-versioning/package-config-file-v2.md |
| |
| ## 2.7.2 - 2020-03-23 |
| |
| This is a patch release that addresses a vulnerability in `dart:html` |
| [NodeValidator][] related to DOM clobbering of `previousSibling`. See the |
| [vulnerability advisory][CVE-2020-8923] for more details. Thanks to **Vincenzo |
| di Cicco** for finding and reporting this issue. |
| |
| This release also improves compatibility with ARMv8 processors (issue [40001][]) |
| and dart:io stability (issue [40589][]). |
| |
| [NodeValidator]: https://api.dart.dev/stable/dart-html/NodeValidator-class.html |
| [CVE-2020-8923]: https://github.com/dart-lang/sdk/security/advisories/GHSA-hfq3-v9pv-p627 |
| [40001]: https://github.com/dart-lang/sdk/issues/40001 |
| [40589]: https://github.com/dart-lang/sdk/issues/40589 |
| |
| ## 2.7.1 - 2020-01-23 |
| |
| This is a patch release that improves dart2js compile-time (issue [40217][]). |
| |
| [40217]: https://github.com/dart-lang/sdk/issues/40217 |
| |
| **Breaking Change**: |
| The Dart SDK for macOS is now only available for x64 (issue [39810][]). |
| |
| [39810]: https://github.com/dart-lang/sdk/issues/39810 |
| |
| ## 2.7.0 - 2019-12-11 |
| |
| **Extension methods** -- which we shipped in preview in 2.6.0 -- are no longer |
| in preview, and are now officially supported as of 2.7.0. Learn more about them |
| here: |
| |
| https://medium.com/dartlang/extension-methods-2d466cd8b308 |
| |
| ### Language |
| |
| * **Breaking Change**: [Static extension members][] are accessible when |
| imported with a prefix (issue [671][]). In the extension method **preview** |
| launch, importing a library with a prefix hid all extension members in |
| addition to hiding the extension name, thereby making them inaccessible |
| in the importing library except via the explicit override syntax. Based |
| on user feedback, we have changed this to make extensions methods accessible |
| even when imported with a prefix. |
| |
| ```dart |
| // "thing.dart" |
| class Thing { |
| } |
| extension Show on Thing { |
| void show() { |
| print("This is a thing"); |
| } |
| } |
| // "client.dart" |
| import "thing.dart" as p; |
| void test() { |
| p.Thing().show(); // Previously an error, now resolves to Show.show |
| } |
| ``` |
| |
| [Static extension members]: https://github.com/dart-lang/language/blob/master/accepted/2.6/static-extension-members/feature-specification.md |
| [671]: https://github.com/dart-lang/language/issues/671 |
| |
| ### Core libraries |
| |
| #### `dart:io` |
| |
| * **Breaking change**: Added `IOOverrides.serverSocketBind` to aid in writing |
| tests that wish to mock `ServerSocket.bind`. |
| |
| #### `dart:typed_data` |
| |
| * Added new constructors, `.sublistView(TypedData, [start, end])` to all |
| `TypedData` classes. The constructor makes it easier, and less error-prone, |
| to create a view of (a slice of) another `TypedData` object. |
| |
| ### Dart VM |
| |
| * New fields added to existing instances by a reload will now be initialized |
| lazily, as if the field was a late field. This makes the initialization order |
| program-defined, whereas previously it was undefined. |
| |
| ### Tools |
| |
| #### Linter |
| |
| The Linter was updated to `0.1.104`, which includes: |
| |
| * updated `unnecessary_overrides` to allow overrides when annotations (besides `@override` are specified) |
| * updated `file_names` to allow names w/ leading `_`'s (and improved performance) |
| * new lint: `unnecessary_final` |
| |
| #### Pub |
| |
| * `pub get` generates [`.dart_tool/package_config.json`](https://github.com/dart-lang/language/blob/62c036cc41b10fb543102d2f73ee132d1e2b2a0e/accepted/future-releases/language-versioning/package-config-file-v2.md) |
| in addition to `.packages` to support language versioning. |
| |
| * `pub publish` now warns about the old flutter plugin registration format. |
| |
| * `pub publish` now warns about the `author` field in pubspec.yaml being. |
| obsolete. |
| |
| * Show a proper error message when `git` is not installed. |
| |
| ## 2.6.1 - 2019-11-11 |
| |
| This is a patch release that reduces dart2js memory usage (issue [27883][]), |
| improves stability on arm64 (issue [39090][]) and updates the Dart FFI |
| documentation. |
| |
| [27883]: https://github.com/dart-lang/sdk/issues/27883 |
| [39090]: https://github.com/dart-lang/sdk/issues/39090 |
| |
| ## 2.6.0 - 2019-11-05 |
| |
| ### Language |
| |
| * **[IN PREVIEW]** [Static extension members][]: A new language feature |
| allowing specially declared static functions to be invoked like instance |
| members on expressions of appropriate static types is available in preview. |
| |
| Static extension members are declared using a new `extension` declaration. |
| Example: |
| |
| ```dart |
| extension MyFancyList<T> on List<T> { |
| /// Whether this list has an even length. |
| bool get isLengthEven => this.length.isEven; |
| |
| /// Whether this list has an odd length. |
| bool get isLengthOdd => !isLengthEven; |
| |
| /// List of values computed for each pairs of adjacent elements. |
| /// |
| /// The result always has one element less than this list, |
| /// if this list has any elements. |
| List<R> combinePairs<R>(R Function(T, T) combine) => |
| [for (int i = 1; i < this.length; i++) |
| combine(this[i - 1], this[i])]; |
| } |
| ``` |
| |
| Extension declarations cannot declare instance fields or constructors. |
| Extension members can be invoked explicitly, |
| `MyFancyList(intList).isLengthEven)`, or implicitly, `intList.isLengthEven`, |
| where the latter is recognized by `intList` matching the `List<T>` "on" type |
| of the declaration. An extension member cannot be called implicitly on an |
| expression whose static type has a member with the same base-name. In that |
| case, the interface member takes precedence. If multiple extension members |
| apply to the same implicit invocation, the most specific one is used, if |
| there is one such. |
| |
| Extensions can be declared on any type, not just interface types. |
| |
| ```dart |
| extension IntCounter on int { |
| /// The numbers from this number to, but not including, [end]. |
| Iterable<int> to(int end) sync* { |
| int step = end < this ? -1 : 1; |
| for (int i = this; i != end; i += step) yield i; |
| } |
| } |
| |
| extension CurryFunction<R, S, T> on R Function(S, T) { |
| /// Curry a binary function with its first argument. |
| R Function(T) curry(S first) => (T second) => this(first, second); |
| } |
| ``` |
| |
| [Static extension members]: https://github.com/dart-lang/language/blob/master/accepted/2.6/static-extension-members/feature-specification.md |
| |
| * **Breaking change** [#37985](https://github.com/dart-lang/sdk/issues/37985): |
| Inference is changed when using `Null` values in a `FutureOr` context. |
| Namely, constraints of the forms similar to `Null` <: `FutureOr<T>` now |
| yield `Null` as the solution for `T`. For example, the following code will |
| now print "Null", and it was printing "dynamic" before (note that the |
| anonymous closure `() {}` in the example has `Null` as its return type): |
| |
| ```dart |
| import 'dart:async'; |
| |
| void foo<T>(FutureOr<T> Function() f) { print(T); } |
| |
| main() { foo(() {}); } |
| ``` |
| |
| |
| ### Core libraries |
| |
| * Default values of parameters of abstract methods are no longer available |
| via `dart:mirrors`. |
| |
| #### `dart:developer` |
| |
| * Added optional `parent` parameter to `TimelineTask` constructor to allow for |
| linking of asynchronous timeline events in the DevTools timeline view. |
| |
| #### `dart:io` |
| |
| * Added `enableTimelineLogging` property to `HttpClient` which, when enabled, |
| will post HTTP connection and request information to the developer timeline |
| for all `HttpClient` instances. |
| |
| ### Dart VM |
| |
| * Added a new tool for AOT compiling Dart programs to native, self-contained |
| executables. See https://dart.dev/tools/dart2native for additional details. |
| |
| ### Foreign Function Interface (`dart:ffi`) |
| |
| * **Breaking change**: The API now makes use of static extension members. |
| Static extension members enable the `dart:ffi` API to be more precise with |
| types, and provide convenient access to memory through extension getters and |
| setters. The extension members on `Pointer` provide `.value` and `.value =` |
| for accessing the value in native memory and `[]` and `[]=` for indexed access. |
| The method `asExternalTypedData` has been replaced with `asTypedList` extension |
| methods. And finally, `Structs` do no longer have a type argument and are |
| accessed using the extension member `.ref` on `Pointer`. |
| These changes makes the code using `dart:ffi` much more concise. |
| * **Breaking change**: The memory management has been removed (`Pointer.allocate` |
| and `Pointer.free`). Instead, memory management is available in |
| [package:ffi](https://pub.dev/packages/ffi). |
| * **Breaking change**: `Pointer.offsetBy` was removed, use `cast` and `elementAt` |
| instead. |
| * Faster memory load and stores. |
| * The dartanalyzer (commandline and IDEs) now reports `dart:ffi` static errors. |
| * Callbacks are now supported in AOT (ahead-of-time) compiled code. |
| |
| ### Dart for the Web |
| |
| #### Dart Dev Compiler (DDC) |
| |
| * Kernel DDC will no longer accept non-dill files as summary inputs. |
| * Removed support for the deprecated web extension. |
| |
| ### Tools |
| |
| #### Linter |
| |
| The Linter was updated to `0.1.101`, which includes: |
| |
| * fixed `diagnostic_describe_all_properties` to flag properties in `Diagnosticable`s with no debug methods defined |
| * fixed `noSuchMethod` exception in `camel_case_extensions` when analyzing unnamed extensions |
| * fixed `avoid_print` to catch tear-off usage |
| * new lint: `avoid_web_libraries_in_flutter` (experimental) |
| * (internal) prepare `unnecessary_lambdas` for coming `MethodInvocation` vs. `FunctionExpressionInvocation` changes |
| |
| ## 2.5.2 - 2019-10-08 |
| |
| This is a patch release with properly signed binaries required for macOS |
| Catalina (Issue [38765][]). |
| |
| [38765]: https://github.com/dart-lang/sdk/issues/38765 |
| |
| ## 2.5.1 - 2019-09-27 |
| |
| This is a patch release that prevents type inference failures in the analyzer |
| (Issue [38365][]). |
| |
| [38365]: https://github.com/dart-lang/sdk/issues/38365 |
| |
| ## 2.5.0 - 2019-09-10 |
| |
| ### Language |
| |
| The set of operations allowed in constant expressions has been expanded as |
| described in |
| the [constant update proposal](https://github.com/dart-lang/language/issues/61). |
| The control flow and spread collection features shipped in Dart 2.3 are now also |
| supported in constants |
| as |
| [described in the specification here](https://github.com/dart-lang/language/blob/master/accepted/2.3/unified-collections/feature-specification.md#constant-semantics). |
| |
| Specifically, it is now valid to use the following operations in constant |
| expressions under the appropriate conditions: |
| - Casts (`e as T`) and type tests (`e is T`). |
| - Comparisons to `null`, even for types which override the `==` operator. |
| - The `&`, `|`, and `^` binary operators on booleans. |
| - The spread operators (`...` and `...?`). |
| - An `if` element in a collection literal. |
| |
| ```dart |
| // Example: these are now valid constants. |
| const Object i = 3; |
| const list = [i as int]; |
| const set = {if (list is List<int>) ...list}; |
| const map = {if (i is int) i : "int"}; |
| ``` |
| |
| In addition, the semantics of constant evaluation has been changed as follows: |
| - The `&&` operator only evaluates its second operand if the first evaluates |
| to true. |
| - The `||` operator only evaluates its second operand if the first evaluates |
| to false. |
| - The `??` operator only evaluates its second operand if the first evaluates |
| to null. |
| - The conditional operator (`e ? e1 : e2`) only evaluates one of the two |
| branches, depending on the value of the first operand. |
| |
| ```dart |
| // Example: x is now a valid constant definition. |
| const String s = null; |
| const int x = (s == null) ? 0 : s.length; |
| ``` |
| |
| ### Core libraries |
| |
| * **Breaking change** [#36900](https://github.com/dart-lang/sdk/issues/36900): |
| The following methods and |
| properties across various core libraries, which used to declare a return type |
| of `List<int>`, were updated to declare a return type of `Uint8List`: |
| |
| * `BytesBuilder.takeBytes()` |
| * `BytesBuilder.toBytes()` |
| * `Datagram.data` |
| * `File.readAsBytes()` (`Future<Uint8List>`) |
| * `File.readAsBytesSync()` |
| * `InternetAddress.rawAddress` |
| * `RandomAccessFile.read()` (`Future<Uint8List>`) |
| * `RandomAccessFile.readSync()` |
| * `RawSocket.read()` |
| * `Utf8Codec.encode()` (and `Utf8Encoder.convert()`) |
| |
| In addition, the following classes were updated to implement |
| `Stream<Uint8List>` rather than `Stream<List<int>>`: |
| |
| * `HttpRequest` |
| * `Socket` |
| |
| **Possible errors and how to fix them** |
| |
| * > The argument type 'Utf8Decoder' can't be assigned to the parameter type 'StreamTransformer<Uint8List, dynamic>' |
| |
| > type 'Utf8Decoder' is not a subtype of type 'StreamTransformer' of 'streamTransformer'" |
| |
| You can fix these call sites by updating your code to use |
| `StreamTransformer.bind()` instead of `Stream.transform()`, like so: |
| |
| *Before:* `stream.transform(utf8.decoder)` |
| *After:* `utf8.decoder.bind(stream)` |
| |
| * > The argument type 'IOSink' can't be assigned to the parameter type 'StreamConsumer<Uint8List>' |
| |
| > type '_IOSinkImpl' is not a subtype of type 'StreamConsumer<Uint8List>' of 'streamConsumer' |
| |
| You can fix these call sites by casting your stream instance to a `Stream<List<int>>` before calling `.pipe()` on the stream, like so: |
| |
| *Before:* `stream.pipe(consumer)` |
| *After:* `stream.cast<List<int>>().pipe(consumer)` |
| |
| Finally, the following typed lists were updated to have their `sublist()` |
| methods declare a return type that is the same as the source list: |
| |
| * `Int8List.sublist()` → `Int8List` |
| * `Int16List.sublist()` → `Int16List` |
| * `Int32List.sublist()` → `Int32List` |
| * `Int64List.sublist()` → `Int64List` |
| * `Int32x4List.sublist()` → `Int32x4List` |
| * `Float32List.sublist()` → `Float32List` |
| * `Float64List.sublist()` → `Float64List` |
| * `Float32x4List.sublist()` → `Float32x4List` |
| * `Float64x2List.sublist()` → `Float64x2List` |
| * `Uint8List.sublist()` → `Uint8List` |
| * `Uint8ClampedList.sublist()` → `Uint8ClampedList` |
| * `Uint16List.sublist()` → `Uint16List` |
| * `Uint32List.sublist()` → `Uint32List` |
| * `Uint64List.sublist()` → `Uint64List` |
| |
| #### `dart:async` |
| |
| * Add `value` and `error` constructors on `Stream` |
| to allow easily creating single-value or single-error streams. |
| |
| #### `dart:core` |
| |
| * Update `Uri` class to support [RFC6874](https://tools.ietf.org/html/rfc6874): |
| "%25" or "%" can be appended to the end of a valid IPv6 representing a Zone |
| Identifier. A valid zone ID consists of unreversed character or Percent |
| encoded octet, which was defined in RFC3986. |
| IPv6addrz = IPv6address "%25" ZoneID |
| |
| [29456]: https://github.com/dart-lang/sdk/issues/29456 |
| |
| #### `dart:io` |
| |
| * **Breaking change** [#37192](https://github.com/dart-lang/sdk/issues/37192): |
| The `Cookie` class's constructor's `name` and `value` |
| optional positional parameters are now mandatory. The |
| signature changes from: |
| |
| Cookie([String name, String value]) |
| |
| to |
| |
| Cookie(String name, String value) |
| |
| However, it has not been possible to set `name` and `value` to null since Dart |
| 1.3.0 (2014) where a bug made it impossible. Any code not using both |
| parameters or setting any to null would necessarily get a noSuchMethod |
| exception at runtime. This change catches such erroneous uses at compile time. |
| Since code could not previously correctly omit the parameters, this is not |
| really a breaking change. |
| |
| * **Breaking change** [#37192](https://github.com/dart-lang/sdk/issues/37192): |
| The `Cookie` class's `name` and `value` setters now |
| validates that the strings are made from the allowed character set and are not |
| null. The constructor already made these checks and this |
| fixes the loophole where the setters didn't also validate. |
| |
| ### Dart VM |
| |
| ### Tools |
| |
| #### Pub |
| |
| * Clean-up invalid git repositories in cache when fetching from git. |
| * **Breaking change** [#36765](https://github.com/dart-lang/sdk/issues/36765): |
| Packages published to [pub.dev](https://pub.dev) can no longer contain git |
| dependencies. These packages will be rejected by the server. |
| |
| #### Linter |
| |
| The Linter was updated to `0.1.96`, which includes: |
| |
| * fixed false positives in `unnecessary_parens` |
| * various changes to migrate to preferred analyzer APIs |
| * rule test fixes |
| |
| #### Dartdoc |
| |
| Dartdoc was updated to `0.28.4`; this version includes several fixes and is based |
| on a newer version of the analyzer package. |
| |
| ## 2.4.1 - 2019-08-07 |
| |
| This is a patch release that fixes a performance regression in JIT mode, as |
| well as a potential crash of our AOT compiler. |
| |
| ### Dart VM |
| |
| * Fixed a performance regression where usage of `Int32List` could trigger |
| repeated deoptimizations in JIT mode (Issue [37551][]). |
| |
| * Fixed a bug where usage of a static getter with name `length` could cause a |
| crash in our AOT compiler (Issue [35121][]). |
| |
| [37551]: https://github.com/dart-lang/sdk/issues/37551 |
| [35121]: https://github.com/dart-lang/sdk/issues/35121 |
| |
| ### Dart Dev Compiler (DDC) |
| |
| Callbacks passed to JS and wrapped with `allowInterop` or |
| `allowInteropCaptureThis` are now strict about argument counts and argument |
| types. This may mean that tests which were previously passing and relying on |
| loose argument checking (too many or too few arguments, or arguments with too |
| specific types like `List<Something>` instead of `List<dynamic>`) may start |
| failing. This changes makes DDC behave more like dart2js with the default flags. |
| |
| ## 2.4.0 - 2019-06-27 |
| |
| ### Core libraries |
| |
| #### `dart:isolate` |
| |
| * `TransferableTypedData` class was added to facilitate faster cross-isolate |
| communication of `Uint8List` data. |
| |
| * **Breaking change**: `Isolate.resolvePackageUri` will always throw an |
| `UnsupportedError` when compiled with dart2js or DDC. This was the only |
| remaining API in `dart:isolate` that didn't automatically throw since we |
| dropped support for this library in [Dart 2.0.0][1]. Note that the API already |
| throws in dart2js if the API is used directly without manually setting up a |
| `defaultPackagesBase` hook. |
| |
| [1]: https://github.com/dart-lang/sdk/blob/master/CHANGELOG.md#200---2018-08-07 |
| |
| |
| #### `dart:developer` |
| * Exposed `result`, `errorCode` and `errorDetail` getters in |
| `ServiceExtensionResponse` to allow for better debugging of VM service |
| extension RPC results. |
| |
| #### `dart:io` |
| |
| * Fixed `Cookie` class interoperability with certain websites by allowing the |
| cookie values to be the empty string (Issue [35804][]) and not stripping |
| double quotes from the value (Issue [33327][]) in accordance with RFC 6265. |
| |
| [33327]: https://github.com/dart-lang/sdk/issues/33327 |
| [35804]: https://github.com/dart-lang/sdk/issues/35804 |
| |
| * [#36971](https://github.com/dart-lang/sdk/issues/36971): |
| The `HttpClientResponse` interface has been extended with the addition of a |
| new `compressionState` getter, which specifies whether the body of a |
| response was compressed when it was received and whether it has been |
| automatically uncompressed via `HttpClient.autoUncompress`. |
| |
| As part of this change, a corresponding new enum was added to `dart:io`: |
| `HttpClientResponseCompressionState`. |
| |
| This is a **breaking change** for those implementing the `HttpClientResponse` |
| interface as subclasses will need to implement the new getter. |
| |
| #### `dart:async` |
| |
| * **Breaking change** [#36382](https://github.com/dart-lang/sdk/issues/36382): |
| The `await for` allowed `null` as a stream due to a bug |
| in `StreamIterator` class. This bug has now been fixed. |
| |
| #### `dart:core` |
| |
| * [#36171](https://github.com/dart-lang/sdk/issues/36171): |
| The `RegExp` interface has been extended with two new |
| constructor named parameters: |
| |
| * `unicode:` (`bool`, default: `false`), for Unicode patterns |
| * `dotAll:` (`bool`, default: `false`), to change the matching behavior of |
| '.' to also match line terminating characters. |
| |
| Appropriate properties for these named parameters have also been added so |
| their use can be detected after construction. |
| |
| In addition, `RegExp` methods that originally returned `Match` objects |
| now return a more specific subtype, `RegExpMatch`, which adds two features: |
| |
| * `Iterable<String> groupNames`, a property that contains the names of all |
| named capture groups |
| * `String namedGroup(String name)`, a method that retrieves the match for |
| the given named capture group |
| |
| This is a **breaking change** for implementers of the `RegExp` interface. |
| Subclasses will need to add the new properties and may have to update the |
| return types on overridden methods. |
| |
| ### Language |
| |
| * **Breaking change** [#35097](https://github.com/dart-lang/sdk/issues/35097): |
| Covariance of type variables used in super-interfaces |
| is now enforced. For example, the following code was |
| previously accepted and will now be rejected: |
| |
| ```dart |
| class A<X> {}; |
| class B<X> extends A<void Function(X)> {}; |
| ``` |
| |
| * The identifier `async` can now be used in asynchronous and generator |
| functions. |
| |
| ### Dart for the Web |
| |
| #### Dart Dev Compiler (DDC) |
| |
| * Improve `NoSuchMethod` errors for failing dynamic calls. Now they include |
| specific information about the nature of the error such as: |
| * Attempting to call a null value. |
| * Calling an object instance with a null `call()` method. |
| * Passing too few or too many arguments. |
| * Passing incorrect named arguments. |
| * Passing too few or too many type arguments. |
| * Passing type arguments to a non-generic method. |
| |
| ### Tools |
| |
| #### Linter |
| |
| The Linter was updated to `0.1.91`, which includes the following changes: |
| |
| * Fixed missed cases in `prefer_const_constructors` |
| * Fixed `prefer_initializing_formals` to no longer suggest API breaking changes |
| * Updated `omit_local_variable_types` to allow explicit `dynamic`s |
| * Fixed null-reference in `unrelated_type_equality_checks` |
| * New lint: `unsafe_html` |
| * Broadened `prefer_null_aware_operators` to work beyond local variables. |
| * Added `prefer_if_null_operators`. |
| * Fixed `prefer_contains` false positives. |
| * Fixed `unnecessary_parenthesis` false positives. |
| * Fixed `prefer_asserts_in_initializer_lists` false positives |
| * Fixed `curly_braces_in_flow_control_structures` to handle more cases |
| * New lint: `prefer_double_quotes` |
| * New lint: `sort_child_properties_last` |
| * Fixed `type_annotate_public_apis` false positive for `static const` initializers |
| |
| #### Pub |
| |
| * `pub publish` will no longer warn about missing dependencies for import |
| statements in `example/`. |
| * OAuth2 authentication will explicitly ask for the `openid` scope. |
| |
| ## 2.3.2 - 2019-06-11 |
| |
| This is a patch version release with a security improvement. |
| |
| ### Security vulnerability |
| |
| * **Security improvement:** On Linux and Android, starting a process with |
| `Process.run`, `Process.runSync`, or `Process.start` would first search the |
| current directory before searching `PATH` (Issue [37101][]). This behavior |
| effectively put the current working directory in the front of `PATH`, even if |
| it wasn't in the `PATH`. This release changes that behavior to only searching |
| the directories in the `PATH` environment variable. Operating systems other |
| than Linux and Android didn't have this behavior and aren't affected by this |
| vulnerability. |
| |
| This vulnerability could result in execution of untrusted code if a command |
| without a slash in its name was run inside an untrusted directory containing |
| an executable file with that name: |
| |
| ```dart |
| Process.run("ls", workingDirectory: "/untrusted/directory") |
| ``` |
| |
| This would attempt to run `/untrusted/directory/ls` if it existed, even |
| though it is not in the `PATH`. It was always safe to instead use an absolute |
| path or a path containing a slash. |
| |
| This vulnerability was introduced in Dart 2.0.0. |
| |
| [37101]: https://github.com/dart-lang/sdk/issues/37101 |
| |
| ## 2.3.1 - 2019-05-21 |
| |
| This is a patch version release with bug fixes. |
| |
| ### Tools |
| |
| #### dart2js |
| |
| * Fixed a bug that caused the compiler to crash when it compiled UI-as-code |
| features within fields (Issue [36864][]). |
| |
| [36864]: https://github.com/dart-lang/sdk/issues/36864 |
| |
| ## 2.3.0 - 2019-05-08 |
| |
| The focus in this release is on the new "UI-as-code" language features which |
| make collections more expressive and declarative. |
| |
| ### Language |
| |
| Flutter is growing rapidly, which means many Dart users are building UI in code |
| out of big deeply-nested expressions. Our goal with 2.3.0 was to [make that kind |
| of code easier to write and maintain][ui-as-code]. Collection literals are a |
| large component, so we focused on three features to make collections more |
| powerful. We'll use list literals in the examples below, but these features also |
| work in map and set literals. |
| |
| [ui-as-code]: https://medium.com/dartlang/making-dart-a-better-language-for-ui-f1ccaf9f546c |
| |
| #### Spread |
| |
| Placing `...` before an expression inside a collection literal unpacks the |
| result of the expression and inserts its elements directly inside the new |
| collection. Where before you had to write something like this: |
| |
| ```dart |
| CupertinoPageScaffold( |
| child: ListView(children: [ |
| Tab2Header() |
| ]..addAll(buildTab2Conversation()) |
| ..add(buildFooter())), |
| ); |
| ``` |
| |
| Now you can write this: |
| |
| ```dart |
| CupertinoPageScaffold( |
| child: ListView(children: [ |
| Tab2Header(), |
| ...buildTab2Conversation(), |
| buildFooter() |
| ]), |
| ); |
| ``` |
| |
| If you know the expression might evaluate to null and you want to treat that as |
| equivalent to zero elements, you can use the null-aware spread `...?`. |
| |
| #### Collection if |
| |
| Sometimes you might want to include one or more elements in a collection only |
| under certain conditions. If you're lucky, you can use a `?:` operator to |
| selectively swap out a single element, but if you want to exchange more than one |
| or omit elements, you are forced to write imperative code like this: |
| |
| ```dart |
| Widget build(BuildContext context) { |
| var children = [ |
| IconButton(icon: Icon(Icons.menu)), |
| Expanded(child: title) |
| ]; |
| |
| if (isAndroid) { |
| children.add(IconButton(icon: Icon(Icons.search))); |
| } |
| |
| return Row(children: children); |
| } |
| ``` |
| |
| We now allow `if` inside collection literals to conditionally omit or (with |
| `else`) swap out an element: |
| |
| ```dart |
| Widget build(BuildContext context) { |
| return Row( |
| children: [ |
| IconButton(icon: Icon(Icons.menu)), |
| Expanded(child: title), |
| if (isAndroid) |
| IconButton(icon: Icon(Icons.search)), |
| ], |
| ); |
| } |
| ``` |
| |
| Unlike the existing `?:` operator, a collection `if` can be composed with |
| spreads to conditionally include or omit multiple items: |
| |
| ```dart |
| Widget build(BuildContext context) { |
| return Row( |
| children: [ |
| IconButton(icon: Icon(Icons.menu)), |
| if (isAndroid) ...[ |
| Expanded(child: title), |
| IconButton(icon: Icon(Icons.search)), |
| ] |
| ], |
| ); |
| } |
| ``` |
| |
| #### Collection for |
| |
| In many cases, the higher-order methods on Iterable give you a declarative way |
| to modify a collection in the context of a single expression. But some |
| operations, especially involving both transforming and filtering, can be |
| cumbersome to express in a functional style. |
| |
| To solve this problem, you can use `for` inside a collection literal. Each |
| iteration of the loop produces an element which is then inserted in the |
| resulting collection. Consider the following code: |
| |
| ```dart |
| var command = [ |
| engineDartPath, |
| frontendServer, |
| ...fileSystemRoots.map((root) => "--filesystem-root=$root"), |
| ...entryPoints |
| .where((entryPoint) => fileExists("lib/$entryPoint.json")) |
| .map((entryPoint) => "lib/$entryPoint"), |
| mainPath |
| ]; |
| ``` |
| |
| With a collection `for`, the code becomes simpler: |
| |
| ```dart |
| var command = [ |
| engineDartPath, |
| frontendServer, |
| for (var root in fileSystemRoots) "--filesystem-root=$root", |
| for (var entryPoint in entryPoints) |
| if (fileExists("lib/$entryPoint.json")) "lib/$entryPoint", |
| mainPath |
| ]; |
| ``` |
| |
| As you can see, all three of these features can be freely composed. For full |
| details of the changes, see [the official proposal][ui-as-code proposal]. |
| |
| [ui-as-code proposal]: https://github.com/dart-lang/language/blob/master/accepted/future-releases/unified-collections/feature-specification.md |
| |
| **Note: These features are not currently supported in *const* collection |
| literals. In a future release, we intend to relax this restriction and allow |
| spread and collection `if` inside const collections.** |
| |
| ### Core library changes |
| |
| #### `dart:isolate` |
| |
| * Added `debugName` property to `Isolate`. |
| * Added `debugName` optional parameter to `Isolate.spawn` and |
| `Isolate.spawnUri`. |
| |
| #### `dart:core` |
| |
| * RegExp patterns can now use lookbehind assertions. |
| * RegExp patterns can now use named capture groups and named backreferences. |
| Currently, named group matches can only be retrieved in Dart either by the |
| implicit index of the named group or by downcasting the returned Match |
| object to the type RegExpMatch. The RegExpMatch interface contains methods |
| for retrieving the available group names and retrieving a match by group |
| name. |
| |
| ### Dart VM |
| |
| * The VM service now requires an authentication code by default. This behavior |
| can be disabled by providing the `--disable-service-auth-codes` flag. |
| |
| * Support for deprecated flags '-c' and '--checked' has been removed. |
| |
| ### Dart for the Web |
| |
| #### dart2js |
| |
| A binary format was added to dump-info. The old JSON format is still available |
| and provided by default, but we are starting to deprecate it. The new binary |
| format is more compact and cheaper to generate. On some large apps we tested, it |
| was 4x faster to serialize and used 6x less memory. |
| |
| To use the binary format today, use `--dump-info=binary`, instead of |
| `--dump-info`. |
| |
| What to expect next? |
| |
| * The [visualizer tool][visualizer] will not be updated to support the new |
| binary format, but you can find several command-line tools at |
| `package:dart2js_info` that provide similar features to those in the |
| visualizer. |
| |
| * The command-line tools in `package:dart2js_info` also work with the old JSON |
| format, so you can start using them even before you enable the new format. |
| |
| * In a future release `--dump-info` will default to `--dump-info=binary`. At |
| that point, there will be an option to fallback to the JSON format, but the |
| visualizer tool will be deprecated. |
| |
| * A release after that, the JSON format will no longer be available from |
| dart2js, but may be available from a command-line tool in |
| `package:dart2js_info`. |
| |
| [visualizer]: https://dart-lang.github.io/dump-info-visualizer/ |
| |
| ### Tools |
| |
| #### dartfmt |
| |
| * Tweak set literal formatting to follow other collection literals. |
| * Add support for "UI as code" features. |
| * Properly format trailing commas in assertions. |
| * Improve indentation of adjacent strings in argument lists. |
| |
| #### Linter |
| |
| The Linter was updated to `0.1.86`, which includes the following changes: |
| |
| * Added the following lints: `prefer_inlined_adds`, |
| `prefer_for_elements_to_map_fromIterable`, |
| `prefer_if_elements_to_conditional_expressions`, |
| `diagnostic_describe_all_properties`. |
| * Updated `file_names` to skip prefixed-extension Dart files (`.css.dart`, |
| `.g.dart`, etc.). |
| * Fixed false positives in `unnecessary_parenthesis`. |
| |
| #### Pub |
| |
| * Added a CHANGELOG validator that complains if you `pub publish` without |
| mentioning the current version. |
| * Removed validation of library names when doing `pub publish`. |
| * Added support for `pub global activate`ing package from a custom pub URL. |
| * Added subcommand: `pub logout`. Logs you out of the current session. |
| |
| #### Dart native |
| |
| Initial support for compiling Dart apps to native machine code has been added. |
| Two new tools have been added to the `bin` folder of the Dart SDK: |
| |
| * `dart2aot`: AOT (ahead-of-time) compiles a Dart program to native |
| machine code. The tool is supported on Windows, macOS, and Linux. |
| |
| * `dartaotruntime`: A small runtime used for executing an AOT compiled program. |
| |
| ## 2.2.0 - 2019-02-26 |
| |
| ### Language |
| |
| Sets now have a literal syntax like lists and maps do: |
| |
| ```dart |
| var set = {1, 2, 3}; |
| ``` |
| |
| Using curly braces makes empty sets ambiguous with maps: |
| |
| ```dart |
| var collection = {}; // Empty set or map? |
| ``` |
| |
| To avoid breaking existing code, an ambiguous literal is treated as a map. |
| To create an empty set, you can rely on either a surrounding context type |
| or an explicit type argument: |
| |
| ```dart |
| // Variable type forces this to be a set: |
| Set<int> set = {}; |
| |
| // A single type argument means this must be a set: |
| var set2 = <int>{}; |
| ``` |
| |
| Set literals are released on all platforms. The `set-literals` experiment flag |
| has been disabled. |
| |
| ### Tools |
| |
| #### Analyzer |
| |
| * The `DEPRECATED_MEMBER_USE` hint was split into two hints: |
| |
| * `DEPRECATED_MEMBER_USE` reports on usage of `@deprecated` members |
| declared in a different package. |
| * `DEPRECATED_MEMBER_USE_FROM_SAME_PACKAGE` reports on usage of |
| `@deprecated` members declared in the same package. |
| |
| #### Linter |
| |
| Upgraded the linter to `0.1.82` which adds the following improvements: |
| |
| * Added `provide_deprecation_message`, and |
| `use_full_hex_values_for_flutter_colors`, `prefer_null_aware_operators`. |
| * Fixed `prefer_const_declarations` set literal false-positives. |
| * Updated `prefer_collection_literals` to support set literals. |
| * Updated `unnecessary_parenthesis` play nicer with cascades. |
| * Removed deprecated lints from the "all options" sample. |
| * Stopped registering "default lints". |
| * Fixed `hash_and_equals` to respect `hashCode` fields. |
| |
| ### Other libraries |
| |
| #### `package:kernel` |
| |
| * **Breaking change:** The `klass` getter on the `InstanceConstant` class in |
| the Kernel AST API has been renamed to `classNode` for consistency. |
| |
| * **Breaking change:** Updated `Link` implementation to utilize true symbolic |
| links instead of junctions on Windows. Existing junctions will continue to |
| work with the new `Link` implementation, but all new links will create |
| symbolic links. |
| |
| To create a symbolic link, Dart must be run with administrative privileges |
| or Developer Mode must be enabled, otherwise a `FileSystemException` will be |
| raised with errno set to `ERROR_PRIVILEGE_NOT_HELD` (Issue [33966]). |
| |
| [33966]: https://github.com/dart-lang/sdk/issues/33966 |
| |
| ## 2.1.1 - 2019-02-18 |
| |
| This is a patch version release. Again, the team's focus was mostly on improving |
| performance and stability after the large changes in Dart 2.0.0. In particular, |
| dart2js now always uses the "fast startup" emitter and the old emitter has been |
| removed. |
| |
| There are a couple of very minor **breaking changes:** |
| |
| * In `dart:io`, adding to a closed `IOSink` now throws a `StateError`. |
| |
| * On the Dart VM, a soundness hole when using `dart:mirrors` to reflectively |
| invoke a method in an incorrect way that violates its static types has |
| been fixed (Issue [35611][]). |
| |
| ### Language |
| |
| This release has no language changes. |
| |
| ### Core library |
| |
| #### `dart:core` |
| |
| * Made `DateTime.parse()` also recognize `,` as a valid decimal separator |
| when parsing from a string (Issue [35576][]). |
| |
| [35576]: https://github.com/dart-lang/sdk/issues/35576 |
| |
| #### `dart:html` |
| |
| * Added methods `Element.removeAttribute`, `Element.removeAttributeNS`, |
| `Element.hasAttribute` and `Element.hasAttributeNS`. (Issue [35655][]). |
| * Improved dart2js compilation of `element.attributes.remove(name)` to |
| generate `element.removeAttribute(name)`, so that there is no performance |
| reason to migrate to the above methods. |
| * Fixed a number of `dart:html` bugs: |
| |
| * Fixed HTML API's with callback typedef to correctly convert Dart |
| functions to JS functions (Issue [35484]). |
| * HttpStatus constants exposed in `dart:html` (Issue [34318]). |
| * Expose DomName `ondblclick` and `dblclickEvent` for Angular analyzer. |
| * Fixed `removeAll` on `classes`; `elements` parameter should be |
| `Iterable<Object>` to match Set's `removeAll` not `Iterable<E>` (Issue |
| [30278]). |
| * Fixed a number of methods on DataTransferItem, Entry, FileEntry and |
| DirectoryEntry which previously returned NativeJavaScriptObject. This |
| fixes handling drag/drop of files/directories (Issue [35510]). |
| * Added ability to allow local file access from Chrome browser in ddb. |
| |
| [35655]: https://github.com/dart-lang/sdk/issues/35655 |
| [30278]: https://github.com/dart-lang/sdk/issues/30278 |
| [34318]: https://github.com/dart-lang/sdk/issues/34318 |
| [35484]: https://github.com/dart-lang/sdk/issues/35484 |
| [35510]: https://github.com/dart-lang/sdk/issues/35510 |
| |
| #### `dart:io` |
| |
| * **Breaking Change:** Adding to a closed `IOSink` now throws a `StateError`. |
| * Added ability to get and set low level socket options. |
| |
| [29554]: https://github.com/dart-lang/sdk/issues/29554 |
| |
| ### Dart VM |
| |
| In previous releases it was possible to violate static types using |
| `dart:mirrors`. This code would run without any TypeErrors and print |
| "impossible" output: |
| |
| ```dart |
| import 'dart:mirrors'; |
| |
| class A { |
| void method(int v) { |
| if (v != null && v is! int) { |
| print("This should be impossible: expected null or int got ${v}"); |
| } |
| } |
| } |
| |
| void main() { |
| final obj = A(); |
| reflect(obj).invoke(#method, ['not-an-number']); |
| } |
| ``` |
| |
| This bug is fixed now. Only code that already violates static typing will break. |
| See Issue [35611][] for more details. |
| |
| [35611]: https://github.com/dart-lang/sdk/issues/35611 |
| |
| ### Dart for the Web |
| |
| #### dart2js |
| |
| * The old "full emitter" back-end is removed and dart2js always uses the "fast |
| startup" back-end. The generated fast startup code is optimized to load |
| faster, even though it can be slightly larger. The `--fast-startup` and |
| `--no-fast-startup` are allowed but ignored. They will be removed in a |
| future version. |
| |
| * We fixed a bug in how deferred constructor calls were incorrectly not marked |
| as deferred. The old behavior didn't cause breakages, but was imprecise and |
| pushed more code to the main output unit. |
| |
| * A new deferred split algorithm implementation was added. |
| |
| This implementation fixes a soundness bug and addresses performance issues |
| of the previous implementation, because of that it can have a visible impact |
| on apps. In particular: |
| |
| * We fixed a performance issue which was introduced when we migrated to |
| the common front-end. On large apps, the fix can cut 2/3 of the time |
| spent on this task. |
| |
| * We fixed a bug in how inferred types were categorized (Issue [35311][]). |
| The old behavior was unsound and could produce broken programs. The fix |
| may cause more code to be pulled into the main output unit. |
| |
| This shows up frequently when returning deferred values from closures |
| since the closure's inferred return type is the deferred type. For |
| example, if you have: |
| |
| ```dart |
| () async { |
| await deferred_prefix.loadLibrary(); |
| return new deferred_prefix.Foo(); |
| } |
| ``` |
| |
| The closure's return type is `Future<Foo>`. The old implementation |
| defers `Foo`, and incorrectly makes the return type `Future<dynamic>`. |
| This may break in places where the correct type is expected. |
| |
| The new implementation will not defer `Foo`, and will place it in the |
| main output unit. If your intent is to defer it, then you need to ensure |
| the return type is not inferred to be `Foo`. For example, you can do so |
| by changing the code to a named closure with a declared type, or by |
| ensuring that the return expression has the type you want, like: |
| |
| ```dart |
| () async { |
| await deferred_prefix.loadLibrary(); |
| return new deferred_prefix.Foo() as dynamic; |
| } |
| ``` |
| |
| Because the new implementation might require you to inspect and fix your |
| app, we exposed two temporary flags: |
| |
| * The `--report-invalid-deferred-types` causes dart2js to run both the |
| old and new algorithms and report any cases where an invalid type was |
| detected. |
| |
| * The `--new-deferred-split` flag enables this new algorithm. |
| |
| * The `--categories=*` flag is being replaced. `--categories=all` was only |
| used for testing and it is no longer supported. `--categories=Server` |
| continues to work at this time but it is deprecated, please use |
| `--server-mode` instead. |
| |
| * The `--library-root` flag was replaced by `--libraries-spec`. This flag is |
| rarely used by developers invoking dart2js directly. It's important for |
| integrating dart2js with build systems. See `--help` for more details on the |
| new flag. |
| |
| [35311]: https://github.com/dart-lang/sdk/issues/35311 |
| |
| ### Tools |
| |
| #### Analyzer |
| |
| * Support for `declarations-casts` has been removed and the `implicit-casts` |
| option now has the combined semantics of both options. This means that |
| users that disable `implicit-casts` might now see errors that were not |
| previously being reported. |
| |
| * New hints added: |
| |
| * `NON_CONST_CALL_TO_LITERAL_CONSTRUCTOR` and |
| `NON_CONST_CALL_TO_LITERAL_CONSTRUCTOR_USING_NEW` inform you when a |
| `@literal` const constructor is called in a non-const context (or with |
| `new`). |
| * `INVALID_LITERAL_ANNOTATION` reports when something other than a const |
| constructor is annotated with `@literal`. |
| * `SUBTYPE_OF_SEALED_CLASS` reports when any class or mixin subclasses |
| (extends, implements, mixes in, or constrains to) a `@sealed` class, and |
| the two are declared in different packages. |
| * `MIXIN_ON_SEALED_CLASS` reports when a `@sealed` class is used as a |
| superclass constraint of a mixin. |
| |
| #### dartdoc |
| |
| Default styles now work much better on mobile. Simple browsing and searching of |
| API docs now work in many cases. |
| |
| Upgraded the linter to `0.1.78` which adds the following improvements: |
| |
| * Added `prefer_final_in_for_each`, `unnecessary_await_in_return`, |
| `use_function_type_syntax_for_parameters`, |
| `avoid_returning_null_for_future`, and `avoid_shadowing_type_parameters`. |
| * Updated `invariant_booleans` status to experimental. |
| * Fixed `type_annotate_public_apis` false positives on local functions. |
| * Fixed `avoid_shadowing_type_parameters` to report shadowed type parameters |
| in generic typedefs. |
| * Fixed `use_setters_to_change_properties` to not wrongly lint overriding |
| methods. |
| * Fixed `cascade_invocations` to not lint awaited targets. |
| * Fixed `prefer_conditional_assignment` false positives. |
| * Fixed `join_return_with_assignment` false positives. |
| * Fixed `cascade_invocations` false positives. |
| * Deprecated `prefer_bool_in_asserts` as it is redundant in Dart 2. |
| |
| ## 2.1.0 - 2018-11-15 |
| |
| This is a minor version release. The team's focus was mostly on improving |
| performance and stability after the large changes in Dart 2.0.0. Notable |
| changes: |
| |
| * We've introduced a dedicated syntax for declaring a mixin. Instead of the |
| `class` keyword, it uses `mixin`: |
| |
| ```dart |
| mixin SetMixin<E> implements Set<E> { |
| ... |
| } |
| ``` |
| |
| The new syntax also enables `super` calls inside mixins. |
| |
| * Integer literals now work in double contexts. When passing a literal number |
| to a function that expects a `double`, you no longer need an explicit `.0` |
| at the end of the number. In releases before 2.1, you need code like this |
| when setting a double like `fontSize`: |
| |
| ```dart |
| TextStyle(fontSize: 18.0) |
| ``` |
| |
| Now you can remove the `.0`: |
| |
| ```dart |
| TextStyle(fontSize: 18) |
| ``` |
| |
| In releases before 2.1, `fontSize : 18` causes a static error. This was a |
| common mistake and source of friction. |
| |
| * **Breaking change:** A number of static errors that should have been |
| detected and reported were not supported in 2.0.0. These are reported now, |
| which means existing incorrect code may show new errors. |
| |
| * `dart:core` now exports `Future` and `Stream`. You no longer need to import |
| `dart:async` to use those very common types. |
| |
| ### Language |
| |
| * Introduced a new syntax for mixin declarations. |
| |
| ```dart |
| mixin SetMixin<E> implements Set<E> { |
| ... |
| } |
| ``` |
| |
| Most classes that are intended to be used as mixins are intended to *only* |
| be used as mixins. The library author doesn't want users to be able to |
| construct or subclass the class. The new syntax makes that intent clear and |
| enforces it in the type system. It is an error to extend or construct a type |
| declared using `mixin`. (You can implement it since mixins expose an |
| implicit interface.) |
| |
| Over time, we expect most mixin declarations to use the new syntax. However, |
| if you have a "mixin" class where users *are* extending or constructing it, |
| note that moving it to the new syntax is a breaking API change since it |
| prevents users from doing that. If you have a type like this that is a |
| mixin as well as being a concrete class and/or superclass, then the existing |
| syntax is what you want. |
| |
| If you need to use a `super` inside a mixin, the new syntax is required. |
| This was previously only allowed with the experimental `--supermixins` flag |
| because it has some complex interactions with the type system. The new |
| syntax addresses those issues and lets you use `super` calls by declaring |
| the superclass constraint your mixin requires: |
| |
| ```dart |
| class Superclass { |
| superclassMethod() { |
| print("in superclass"); |
| } |
| } |
| |
| mixin SomeMixin on Superclass { |
| mixinMethod() { |
| // This is OK: |
| super.superclassMethod(); |
| } |
| } |
| |
| class GoodSub extends Superclass with SomeMixin {} |
| |
| class BadSub extends Object with SomeMixin {} |
| // Error: Since the super() call in mixinMethod() can't find a |
| // superclassMethod() to call, this is prohibited. |
| ``` |
| |
| Even if you don't need to use `super` calls, the new mixin syntax is good |
| because it clearly expresses that you intend the type to be mixed in. |
| |
| * Allow integer literals to be used in double contexts. An integer literal |
| used in a place where a double is required is now interpreted as a double |
| value. The numerical value of the literal needs to be precisely |
| representable as a double value. |
| |
| * Integer literals compiled to JavaScript are now allowed to have any value |
| that can be exactly represented as a JavaScript `Number`. They were |
| previously limited to such numbers that were also representable as signed |
| 64-bit integers. |
| |
| **(Breaking)** A number of static errors that should have been detected and |
| reported were not supported in 2.0.0. These are reported now, which means |
| existing incorrect code may show new errors: |
| |
| * **Setters with the same name as the enclosing class aren't allowed.** (Issue |
| [34225][].) It is not allowed to have a class member with the same name as |
| the enclosing class: |
| |
| ```dart |
| class A { |
| set A(int x) {} |
| } |
| ``` |
| |
| Dart 2.0.0 incorrectly allows this for setters (only). Dart 2.1.0 rejects |
| it. |
| |
| *To fix:* This is unlikely to break anything, since it violates all style |
| guides anyway. |
| |
| * **Constant constructors cannot redirect to non-constant constructors.** |
| (Issue [34161][].) It is not allowed to have a constant constructor that |
| redirects to a non-constant constructor: |
| |
| ```dart |
| class A { |
| const A.foo() : this(); // Redirecting to A() |
| A() {} |
| } |
| ``` |
| |
| Dart 2.0.0 incorrectly allows this. Dart 2.1.0 rejects it. |
| |
| *To fix:* Make the target of the redirection a properly const constructor. |
| |
| * **Abstract methods may not unsoundly override a concrete method.** (Issue |
| [32014][].) Concrete methods must be valid implementations of their |
| interfaces: |
| |
| ```dart |
| class A { |
| num get thing => 2.0; |
| } |
| |
| abstract class B implements A { |
| int get thing; |
| } |
| |
| class C extends A with B {} |
| // 'thing' from 'A' is not a valid override of 'thing' from 'B'. |
| |
| main() { |
| print(new C().thing.isEven); // Expects an int but gets a double. |
| } |
| ``` |
| |
| Dart 2.0.0 allows unsound overrides like the above in some cases. Dart 2.1.0 |
| rejects them. |
| |
| *To fix:* Relax the type of the invalid override, or tighten the type of the |
| overridden method. |
| |
| * **Classes can't implement FutureOr.** (Issue [33744][].) Dart doesn't allow |
| classes to implement the FutureOr type: |
| |
| ```dart |
| class A implements FutureOr<Object> {} |
| ``` |
| |
| Dart 2.0.0 allows classes to implement FutureOr. Dart 2.1.0 does not. |
| |
| *To fix:* Don't do this. |
| |
| * **Type arguments to generic typedefs must satisfy their bounds.** (Issue |
| [33308][].) If a parameterized typedef specifies a bound, actual arguments |
| must be checked against it: |
| |
| ```dart |
| class A<X extends int> {} |
| |
| typedef F<Y extends int> = A<Y> Function(); |
| |
| F<num> f = null; |
| ``` |
| |
| Dart 2.0.0 allows bounds violations like `F<num>` above. Dart 2.1.0 rejects |
| them. |
| |
| *To fix:* Either remove the bound on the typedef parameter, or pass a valid |
| argument to the typedef. |
| |
| * **Constructor invocations must use valid syntax, even with optional `new`.** |
| (Issue [34403][].) Type arguments to generic named constructors go after the |
| class name, not the constructor name, even when used without an explicit |
| `new`: |
| |
| ```dart |
| class A<T> { |
| A.foo() {} |
| } |
| |
| main() { |
| A.foo<String>(); // Incorrect syntax, was accepted in 2.0.0. |
| A<String>.foo(); // Correct syntax. |
| } |
| ``` |
| |
| Dart 2.0.0 accepts the incorrect syntax when the `new` keyword is left out. |
| Dart 2.1.0 correctly rejects this code. |
| |
| *To fix:* Move the type argument to the correct position after the class |
| name. |
| |
| * **Instance members should shadow prefixes.** (Issue [34498][].) If the same |
| name is used as an import prefix and as a class member name, then the class |
| member name takes precedence in the class scope. |
| |
| ```dart |
| import 'dart:core'; |
| import 'dart:core' as core; |
| |
| class A { |
| core.List get core => null; // "core" refers to field, not prefix. |
| } |
| ``` |
| |
| Dart 2.0.0 incorrectly resolves the use of `core` in `core.List` to the |
| prefix name. Dart 2.1.0 correctly resolves this to the field name. |
| |
| *To fix:* Change the prefix name to something which does not clash with the |
| instance member. |
| |
| * **Implicit type arguments in extends clauses must satisfy the class |
| bounds.** (Issue [34532][].) Implicit type arguments for generic classes are |
| computed if not passed explicitly, but when used in an `extends` clause they |
| must be checked for validity: |
| |
| ```dart |
| class Foo<T> {} |
| |
| class Bar<T extends Foo<T>> {} |
| |
| class Baz extends Bar {} // Should error because Bar completes to Bar<Foo> |
| ``` |
| |
| Dart 2.0.0 accepts the broken code above. Dart 2.1.0 rejects it. |
| |
| *To fix:* Provide explicit type arguments to the superclass that satisfy the |
| bound for the superclass. |
| |
| * **Mixins must correctly override their superclasses.** (Issue [34235][].) In |
| some rare cases, combinations of uses of mixins could result in invalid |
| overrides not being caught: |
| |
| ```dart |
| class A { |
| num get thing => 2.0; |
| } |
| |
| class M1 { |
| int get thing => 2; |
| } |
| |
| class B = A with M1; |
| |
| class M2 { |
| num get thing => 2.0; |
| } |
| |
| class C extends B with M2 {} // 'thing' from 'M2' not a valid override. |
| |
| main() { |
| M1 a = new C(); |
| print(a.thing.isEven); // Expects an int but gets a double. |
| } |
| ``` |
| |
| Dart 2.0.0 accepts the above example. Dart 2.1.0 rejects it. |
| |
| *To fix:* Ensure that overriding methods are correct overrides of their |
| superclasses, either by relaxing the superclass type, or tightening the |
| subclass/mixin type. |
| |
| [32014]: https://github.com/dart-lang/sdk/issues/32014 |
| [33308]: https://github.com/dart-lang/sdk/issues/33308 |
| [33744]: https://github.com/dart-lang/sdk/issues/33744 |
| [34161]: https://github.com/dart-lang/sdk/issues/34161 |
| [34225]: https://github.com/dart-lang/sdk/issues/34225 |
| [34235]: https://github.com/dart-lang/sdk/issues/34235 |
| [34403]: https://github.com/dart-lang/sdk/issues/34403 |
| [34498]: https://github.com/dart-lang/sdk/issues/34498 |
| [34532]: https://github.com/dart-lang/sdk/issues/34532 |
| |
| ### Core libraries |
| |
| #### `dart:async` |
| |
| * Fixed a bug where calling `stream.take(0).drain(value)` would not correctly |
| forward the `value` through the returned `Future`. |
| * Added a `StreamTransformer.fromBind` constructor. |
| * Updated `Stream.fromIterable` to send a done event after the error when the |
| iterator's `moveNext` throws, and handle if the `current` getter throws |
| (issue [33431][]). |
| |
| [33431]: http://dartbug.com/33431 |
| |
| #### `dart:core` |
| |
| * Added `HashMap.fromEntries` and `LinkedHashmap.fromEntries` constructors. |
| * Added `ArgumentError.checkNotNull` utility method. |
| * Made `Uri` parsing more permissive about `[` and `]` occurring in the path, |
| query or fragment, and `#` occurring in fragment. |
| * Exported `Future` and `Stream` from `dart:core`. |
| * Added operators `&`, `|` and `^` to `bool`. |
| * Added missing methods to `UnmodifiableMapMixin`. Some maps intended to |
| be unmodifiable incorrectly allowed new methods added in Dart 2 to |
| succeed. |
| * Deprecated the `provisional` annotation and the `Provisional` |
| annotation class. These should have been removed before releasing Dart 2.0, |
| and they have no effect. |
| |
| #### `dart:html` |
| |
| Fixed Service Workers and any Promise/Future API with a Dictionary parameter. |
| |
| APIs in dart:html (that take a Dictionary) will receive a Dart Map parameter. |
| The Map parameter must be converted to a Dictionary before passing to the |
| browser's API. Before this change, any Promise/Future API with a |
| Map/Dictionary parameter never called the Promise and didn't return a Dart |
| Future - now it does. |
| |
| This caused a number of breaks especially in Service Workers (register, etc.). |
| Here is a complete list of the fixed APIs: |
| |
| * BackgroundFetchManager |
| * `Future<BackgroundFetchRegistration> fetch(String id, Object requests, |
| [Map options])` |
| * CacheStorage |
| * `Future match(/*RequestInfo*/ request, [Map options])` |
| * CanMakePayment |
| * `Future<List<Client>> matchAll([Map options])` |
| * CookieStore |
| * `Future getAll([Map options])` |
| * `Future set(String name, String value, [Map options])` |
| * CredentialsContainer |
| * `Future get([Map options])` |
| * `Future create([Map options])` |
| * ImageCapture |
| * `Future setOptions(Map photoSettings)` |
| * MediaCapabilities |
| * `Future<MediaCapabilitiesInfo> decodingInfo(Map configuration)` |
| * `Future<MediaCapabilitiesInfo> encodingInfo(Map configuration)` |
| * MediaStreamTrack |
| * `Future applyConstraints([Map constraints])` |
| * Navigator |
| * `Future requestKeyboardLock([List<String> keyCodes])` |
| * `Future requestMidiAccess([Map options])` |
| * `Future share([Map data])` |
| * OffscreenCanvas |
| * `Future<Blob> convertToBlob([Map options])` |
| * PaymentInstruments |
| * `Future set(String instrumentKey, Map details)` |
| * Permissions |
| * `Future<PermissionStatus> query(Map permission)` |
| * `Future<PermissionStatus> request(Map permissions)` |
| * `Future<PermissionStatus> revoke(Map permission)` |
| * PushManager |
| * `Future permissionState([Map options])` |
| * `Future<PushSubscription> subscribe([Map options])` |
| * RtcPeerConnection |
| * Changed: |
| |
| ```dart |
| Future createAnswer([options_OR_successCallback, |
| RtcPeerConnectionErrorCallback failureCallback, |
| Map mediaConstraints]) |
| ``` |
| |
| to: |
| |
| ```dart |
| Future<RtcSessionDescription> createAnswer([Map options]) |
| ``` |
| |
| * Changed: |
| |
| ```dart |
| Future createOffer([options_OR_successCallback, |
| RtcPeerConnectionErrorCallback failureCallback, |
| Map rtcOfferOptions]) |
| ``` |
| |
| to: |
| |
| ```dart |
| Future<RtcSessionDescription> createOffer([Map options]) |
| ``` |
| |
| * Changed: |
| |
| ```dart |
| Future setLocalDescription(Map description, |
| VoidCallback successCallback, |
| [RtcPeerConnectionErrorCallback failureCallback]) |
| ``` |
| |
| to: |
| |
| ```dart |
| Future setLocalDescription(Map description) |
| ``` |
| |
| * Changed: |
| |
| ```dart |
| Future setLocalDescription(Map description, |
| VoidCallback successCallback, |
| [RtcPeerConnectionErrorCallback failureCallback]) |
| ``` |
| |
| to: |
| |
| ```dart |
| Future setRemoteDescription(Map description) |
| ``` |
| |
| * ServiceWorkerContainer |
| * `Future<ServiceWorkerRegistration> register(String url, [Map options])` |
| * ServiceWorkerRegistration |
| * `Future<List<Notification>> getNotifications([Map filter])` |
| * `Future showNotification(String title, [Map options])` |
| * VRDevice |
| * `Future requestSession([Map options])` |
| * `Future supportsSession([Map options])` |
| * VRSession |
| * `Future requestFrameOfReference(String type, [Map options])` |
| * Window |
| * `Future fetch(/*RequestInfo*/ input, [Map init])` |
| * WorkerGlobalScope |
| * `Future fetch(/*RequestInfo*/ input, [Map init])` |
| |
| In addition, exposed Service Worker "self" as a static getter named "instance". |
| The instance is exposed on four different Service Worker classes and can throw |
| a InstanceTypeError if the instance isn't of the class expected |
| (WorkerGlobalScope.instance will always work and not throw): |
| |
| * `SharedWorkerGlobalScope.instance` |
| * `DedicatedWorkerGlobalScope.instance` |
| * `ServiceWorkerGlobalScope.instance` |
| * `WorkerGlobalScope.instance` |
| |
| #### `dart:io` |
| |
| * Added new HTTP status codes. |
| |
| ### Dart for the Web |
| |
| #### dart2js |
| |
| * **(Breaking)** Duplicate keys in a const map are not allowed and produce a |
| compile-time error. Dart2js used to report this as a warning before. This |
| was already an error in dartanalyzer and DDC and will be an error in other |
| tools in the future as well. |
| |
| * Added `-O` flag to tune optimization levels. For more details run `dart2js |
| -h -v`. |
| |
| We recommend to enable optimizations using the `-O` flag instead of |
| individual flags for each optimization. This is because the `-O` flag is |
| intended to be stable and continue to work in future versions of dart2js, |
| while individual flags may come and go. |
| |
| At this time we recommend to test and debug with `-O1` and to deploy with |
| `-O3`. |
| |
| ### Tool Changes |
| |
| #### dartfmt |
| |
| * Addressed several dartfmt issues when used with the new CFE parser. |
| |
| #### Linter |
| |
| Bumped the linter to `0.1.70` which includes the following new lints: |
| |
| * `avoid_returning_null_for_void` |
| * `sort_pub_dependencies` |
| * `prefer_mixin` |
| * `avoid_implementing_value_types` |
| * `flutter_style_todos` |
| * `avoid_void_async` |
| * `prefer_void_to_null` |
| |
| and improvements: |
| |
| * Fixed NPE in `prefer_iterable_whereType`. |
| * Improved message display for `await_only_futures` |
| * Performance improvements for `null_closures` |
| * Mixin support |
| * Updated `sort_constructors_first` to apply to all members. |
| * Updated `unnecessary_this` to work on field initializers. |
| * Updated `unawaited_futures` to ignore assignments within cascades. |
| * Improved handling of constant expressions with generic type params. |
| * NPE fix for `invariant_booleans`. |
| * Improved docs for `unawaited_futures`. |
| * Updated `unawaited_futures` to check cascades. |
| * Relaxed `void_checks` (allowing `T Function()` to be assigned to |
| `void Function()`). |
| * Fixed false positives in `lines_longer_than_80_chars`. |
| |
| #### Pub |
| |
| * Renamed the `--checked` flag to `pub run` to `--enable-asserts`. |
| * Pub will no longer delete directories named "packages". |
| * The `--packages-dir` flag is now ignored. |
| |
| ## 2.0.0 - 2018-08-07 |
| |
| This is the first major version release of Dart since 1.0.0, so it contains many |
| significant changes across all areas of the platform. Large changes include: |
| |
| * **(Breaking)** The unsound optional static type system has been replaced |
| with a sound static type system using type inference and runtime checks. |
| This was formerly called "[strong mode][]" and only used by the Dart for web |
| products. Now it is the one official static type system for the entire |
| platform and replaces the previous "checked" and "production" modes. |
| |
| * **(Breaking)** Functions marked `async` now run synchronously until the |
| first `await` statement. Previously, they would return to the event loop |
| once at the top of the function body before any code runs ([issue 30345][]). |
| |
| * **(Breaking)** Constants in the core libraries have been renamed from |
| `SCREAMING_CAPS` to `lowerCamelCase`. |
| |
| * **(Breaking)** Many new methods have been added to core library classes. If |
| you implement the interfaces of these classes, you will need to implement |
| the new methods. |
| |
| * **(Breaking)** "dart:isolate" and "dart:mirrors" are no longer supported |
| when using Dart for the web. They are still supported in the command-line |
| VM. |
| |
| * **(Breaking)** Pub's transformer-based build system has been [replaced by a |
| new build system][transformers]. |
| |
| * The `new` keyword is optional and can be omitted. Likewise, `const` can be |
| omitted inside a const context ([issue 30921][]). |
| |
| * Dartium is no longer maintained or supported. |
| |
| [issue 30345]: https://github.com/dart-lang/sdk/issues/30345 |
| [issue 30921]: https://github.com/dart-lang/sdk/issues/30921 |
| [strong mode]: https://www.dartlang.org/guides/language/sound-dart |
| [transformers]: https://www.dartlang.org/tools/pub/obsolete |
| |
| ### Language |
| |
| * "[Strong mode][]" is now the official type system of the language. |
| |
| * The `new` keyword is optional and can be omitted. Likewise, `const` can be |
| omitted inside a const context. |
| |
| * A string in a `part of` declaration may now be used to refer to the library |
| this file is part of. A library part can now declare its library as either: |
| |
| ```dart |
| part of name.of.library; |
| ``` |
| |
| Or: |
| |
| ```dart |
| part of "uriReferenceOfLibrary.dart"; |
| ``` |
| |
| This allows libraries with no library declarations (and therefore no name) |
| to have parts, and it allows tools to easily find the library of a part |
| file. The Dart 1.0 syntax is supported but deprecated. |
| |
| * Functions marked `async` now run synchronously until the first `await` |
| statement. Previously, they would return to the event loop once at the top |
| of the function body before any code runs ([issue 30345][]). |
| |
| * The type `void` is now a Top type like `dynamic`, and `Object`. It also now |
| has new errors for being used where not allowed (such as being assigned to |
| any non-`void`-typed parameter). Some libraries (importantly, mockito) may |
| need to be updated to accept void values to keep their APIs working. |
| |
| * Future flattening is now done only as specified in the Dart 2.0 spec, rather |
| than more broadly. This means that the following code has an error on the |
| assignment to `y`. |
| |
| ```dart |
| test() { |
| Future<int> f; |
| var x = f.then<Future<List<int>>>((x) => []); |
| Future<List<int>> y = x; |
| } |
| ``` |
| |
| * Invocations of `noSuchMethod()` receive default values for optional args. |
| The following program used to print "No arguments passed", and now prints |
| "First argument is 3". |
| |
| ```dart |
| abstract class B { |
| void m([int x = 3]); |
| } |
| |
| class A implements B { |
| noSuchMethod(Invocation i) { |
| if (i.positionalArguments.length == 0) { |
| print("No arguments passed"); |
| } else { |
| print("First argument is ${i.positionalArguments[0]}"); |
| } |
| } |
| } |
| |
| void main() { |
| A().m(); |
| } |
| ``` |
| |
| * Bounds on generic functions are invariant. The following program now issues |
| an invalid override error ([issue 29014][sdk#29014]): |
| |
| ```dart |
| class A { |
| void f<T extends int>() {} |
| } |
| |
| class B extends A { |
| @override |
| void f<T extends num>() {} |
| } |
| ``` |
| |
| * Numerous corner case bugs around return statements in synchronous and |
| asynchronous functions fixed. Specifically: |
| |
| * Issues [31887][issue 31887], [32881][issue 32881]. Future flattening |
| should not be recursive. |
| * Issues [30638][issue 30638], [32233][issue 32233]. Incorrect downcast |
| errors with `FutureOr`. |
| * Issue [32233][issue 32233]. Errors when returning `FutureOr`. |
| * Issue [33218][issue 33218]. Returns in functions with void related |
| types. |
| * Issue [31278][issue 31278]. Incorrect hint on empty returns in async. |
| functions. |
| |
| * An empty `return;` in an async function with return type `Future<Object>` |
| does not report an error. |
| |
| * `return exp;` where `exp` has type `void` in an async function is now an |
| error unless the return type of the function is `void` or `dynamic`. |
| |
| * Mixed return statements of the form `return;` and `return exp;` are now |
| allowed when `exp` has type `void`. |
| |
| * A compile time error is emitted for any literal which cannot be exactly |
| represented on the target platform. As a result, dart2js and DDC report |
| errors if an integer literal cannot be represented exactly in JavaScript |
| ([issue 33282][]). |
| |
| * New member conflict rules have been implemented. Most cases of conflicting |
| members with the same name are now static errors ([issue 33235][]). |
| |
| [sdk#29014]: https://github.com/dart-lang/sdk/issues/29014 |
| [issue 30638]: https://github.com/dart-lang/sdk/issues/30638 |
| [issue 31278]: https://github.com/dart-lang/sdk/issues/31278 |
| [issue 31887]: https://github.com/dart-lang/sdk/issues/31887 |
| [issue 32233]: https://github.com/dart-lang/sdk/issues/32233 |
| [issue 32881]: https://github.com/dart-lang/sdk/issues/32881 |
| [issue 33218]: https://github.com/dart-lang/sdk/issues/33218 |
| [issue 33235]: https://github.com/dart-lang/sdk/issues/33235 |
| [issue 33282]: https://github.com/dart-lang/sdk/issues/33282 |
| [issue 33341]: https://github.com/dart-lang/sdk/issues/33341 |
| |
| ### Core libraries |
| |
| * Replaced `UPPER_CASE` constant names with `lowerCamelCase`. For example, |
| `HTML_ESCAPE` is now `htmlEscape`. |
| |
| * The Web libraries were re-generated using Chrome 63 WebIDLs |
| ([details][idl]). |
| |
| [idl]: https://github.com/dart-lang/sdk/wiki/Chrome-63-Dart-Web-Libraries |
| |
| #### `dart:async` |
| |
| * `Stream`: |
| * Added `cast` and `castFrom`. |
| * Changed `firstWhere`, `lastWhere`, and `singleWhere` to return |
| `Future<T>` and added an optional `T orElse()` callback. |
| * `StreamTransformer`: added `cast` and `castFrom`. |
| * `StreamTransformerBase`: new class. |
| * `Timer`: added `tick` property. |
| * `Zone` |
| * changed to be strong-mode clean. This required some breaking API |
| changes. See https://goo.gl/y9mW2x for more information. |
| * Added `bindBinaryCallbackGuarded`, `bindCallbackGuarded`, and |
| `bindUnaryCallbackGuarded`. |
| * Renamed `Zone.ROOT` to `Zone.root`. |
| * Removed the deprecated `defaultValue` parameter on `Stream.firstWhere` and |
| `Stream.lastWhere`. |
| * Changed an internal lazily-allocated reusable "null future" to always belong |
| to the root zone. This avoids race conditions where the first access to the |
| future determined which zone it would belong to. The zone is only used for |
| *scheduling* the callback of listeners, the listeners themselves will run in |
| the correct zone in any case. Issue [#32556](http://dartbug.com/32556). |
| |
| #### `dart:cli` |
| |
| * *New* "provisional" library for CLI-specific features. |
| * `waitFor`: function that suspends a stack to wait for a `Future` to |
| complete. |
| |
| #### `dart:collection` |
| |
| * `MapBase`: added `mapToString`. |
| * `LinkedHashMap` no longer implements `HashMap` |
| * `LinkedHashSet` no longer implements `HashSet`. |
| * Added `of` constructor to `Queue`, `ListQueue`, `DoubleLinkedQueue`, |
| `HashSet`, `LinkedHashSet`, `SplayTreeSet`, `Map`, `HashMap`, |
| `LinkedHashMap`, `SplayTreeMap`. |
| * Removed `Maps` class. Extend `MapBase` or mix in `MapMixin` instead to |
| provide map method implementations for a class. |
| * Removed experimental `Document` method `getCSSCanvasContext` and property |
| `supportsCssCanvasContext`. |
| * Removed obsolete `Element` property `xtag` no longer supported in browsers. |
| * Exposed `ServiceWorker` class. |
| * Added constructor to `MessageChannel` and `MessagePort` `addEventListener` |
| automatically calls `start` method to receive queued messages. |
| |
| #### `dart:convert` |
| |
| * `Base64Codec.decode` return type is now `Uint8List`. |
| * `JsonUnsupportedObjectError`: added `partialResult` property |
| * `LineSplitter` now implements `StreamTransformer<String, String>` instead of |
| `Converter`. It retains `Converter` methods `convert` and |
| `startChunkedConversion`. |
| * `Utf8Decoder` when compiled with dart2js uses the browser's `TextDecoder` in |
| some common cases for faster decoding. |
| * Renamed `ASCII`, `BASE64`, `BASE64URI`, `JSON`, `LATIN1` and `UTF8` to |
| `ascii`, `base64`, `base64Uri`, `json`, `latin1` and `utf8`. |
| * Renamed the `HtmlEscapeMode` constants `UNKNOWN`, `ATTRIBUTE`, |
| `SQ_ATTRIBUTE` and `ELEMENT` to `unknown`, `attribute`, `sqAttribute` and |
| `elements`. |
| * Added `jsonEncode`, `jsonDecode`, `base64Encode`, `base64UrlEncode` and |
| `base64Decode` top-level functions. |
| * Changed return type of `encode` on `AsciiCodec` and `Latin1Codec`, and |
| `convert` on `AsciiEncoder`, `Latin1Encoder`, to `Uint8List`. |
| * Allow `utf8.decoder.fuse(json.decoder)` to ignore leading Unicode BOM. |
| |
| #### `dart:core` |
| |
| * `BigInt` class added to support integers greater than 64-bits. |
| * Deprecated the `proxy` annotation. |
| * Added `Provisional` class and `provisional` field. |
| * Added `pragma` annotation. |
| * `RegExp` added static `escape` function. |
| * The `Uri` class now correctly handles paths while running on Node.js on |
| Windows. |
| * Core collection changes: |
| * `Iterable` added members `cast`, `castFrom`, `followedBy` and |
| `whereType`. |
| * `Iterable.singleWhere` added `orElse` parameter. |
| * `List` added `+` operator, `first` and `last` setters, and `indexWhere` |
| and `lastIndexWhere` methods, and static `copyRange` and `writeIterable` |
| methods. |
| * `Map` added `fromEntries` constructor. |
| * `Map` added `addEntries`, `cast`, `entries`, `map`, `removeWhere`, |
| `update` and `updateAll` members. |
| * `MapEntry`: new class used by `Map.entries`. |
| * *Note*: if a class extends `IterableBase`, `ListBase`, `SetBase` or |
| `MapBase` (or uses the corresponding mixins) from `dart:collection`, the |
| new members are implemented automatically. |
| * Added `of` constructor to `List`, `Set`, `Map`. |
| * Renamed `double.INFINITY`, `double.NEGATIVE_INFINITY`, `double.NAN`, |
| `double.MAX_FINITE` and `double.MIN_POSITIVE` to `double.infinity`, |
| `double.negativeInfinity`, `double.nan`, `double.maxFinite` and |
| `double.minPositive`. |
| * Renamed the following constants in `DateTime` to lower case: `MONDAY` |
| through `SUNDAY`, `DAYS_PER_WEEK` (as `daysPerWeek`), `JANUARY` through |
| `DECEMBER` and `MONTHS_PER_YEAR` (as `monthsPerYear`). |
| * Renamed the following constants in `Duration` to lower case: |
| `MICROSECONDS_PER_MILLISECOND` to `microsecondsPerMillisecond`, |
| `MILLISECONDS_PER_SECOND` to `millisecondsPerSecond`, `SECONDS_PER_MINUTE` |
| to `secondsPerMinute`, `MINUTES_PER_HOUR` to `minutesPerHour`, |
| `HOURS_PER_DAY` to `hoursPerDay`, `MICROSECONDS_PER_SECOND` to |
| `microsecondsPerSecond`, `MICROSECONDS_PER_MINUTE` to |
| `microsecondsPerMinute`, `MICROSECONDS_PER_HOUR` to `microsecondsPerHour`, |
| `MICROSECONDS_PER_DAY` to `microsecondsPerDay`, `MILLISECONDS_PER_MINUTE` to |
| `millisecondsPerMinute`, `MILLISECONDS_PER_HOUR` to `millisecondsPerHour`, |
| `MILLISECONDS_PER_DAY` to `millisecondsPerDay`, `SECONDS_PER_HOUR` to |
| `secondsPerHour`, `SECONDS_PER_DAY` to `secondsPerDay`, `MINUTES_PER_DAY` to |
| `minutesPerDay`, and `ZERO` to `zero`. |
| * Added `typeArguments` to `Invocation` class. |
| * Added constructors to invocation class that allows creation of `Invocation` |
| objects directly, without going through `noSuchMethod`. |
| * Added `unaryMinus` and `empty` constant symbols on the `Symbol` class. |
| * Changed return type of `UriData.dataAsBytes` to `Uint8List`. |
| * Added `tryParse` static method to `int`, `double`, `num`, `BigInt`, `Uri` |
| and `DateTime`. |
| * Deprecated `onError` parameter on `int.parse`, `double.parse` and |
| `num.parse`. |
| * Deprecated the `NoSuchMethodError` constructor. |
| * `int.parse` on the VM no longer accepts unsigned hexadecimal numbers greater |
| than or equal to `2**63` when not prefixed by `0x`. (SDK issue |
| [32858](https://github.com/dart-lang/sdk/issues/32858)) |
| |
| #### `dart:developer` |
| |
| * `Flow` class added. |
| * `Timeline.startSync` and `Timeline.timeSync` now accepts an optional |
| parameter `flow` of type `Flow`. The `flow` parameter is used to generate |
| flow timeline events that are enclosed by the slice described by |
| `Timeline.{start,finish}Sync` and `Timeline.timeSync`. |
| |
| <!-- |
| Still need entries for all changes to dart:html since 1.x |
| --> |
| |
| #### `dart:html` |
| |
| * Removed deprecated `query` and `queryAll`. Use `querySelector` and |
| `querySelectorAll`. |
| |
| #### `dart:io` |
| |
| * `HttpStatus` added `UPGRADE_REQUIRED`. |
| * `IOOverrides` and `HttpOverrides` added to aid in writing tests that wish to |
| mock varios `dart:io` objects. |
| * `Platform.operatingSystemVersion` added that gives a platform-specific |
| String describing the version of the operating system. |
| * `ProcessStartMode.INHERIT_STDIO` added, which allows a child process to |
| inherit the parent's stdio handles. |
| * `RawZLibFilter` added for low-level access to compression and decompression |
| routines. |
| * Unified backends for `SecureSocket`, `SecurityContext`, and |
| `X509Certificate` to be consistent across all platforms. All `SecureSocket`, |
| `SecurityContext`, and `X509Certificate` properties and methods are now |
| supported on iOS and OSX. |
| * `SecurityContext.alpnSupported` deprecated as ALPN is now supported on all |
| platforms. |
| * `SecurityContext`: added `withTrustedRoots` named optional parameter |
| constructor, which defaults to false. |
| * Added a `timeout` parameter to `Socket.connect`, `RawSocket.connect`, |
| `SecureSocket.connect` and `RawSecureSocket.connect`. If a connection |
| attempt takes longer than the duration specified in `timeout`, a |
| `SocketException` will be thrown. Note: if the duration specified in |
| `timeout` is greater than the OS level timeout, a timeout may occur sooner |
| than specified in `timeout`. |
| * `Stdin.hasTerminal` added, which is true if stdin is attached to a terminal. |
| * `WebSocket` added static `userAgent` property. |
| * `RandomAccessFile.close` returns `Future<void>` |
| * Added `IOOverrides.socketConnect`. |
| * Added Dart-styled constants to `ZLibOptions`, `FileMode`, `FileLock`, |
| `FileSystemEntityType`, `FileSystemEvent`, `ProcessStartMode`, |
| `ProcessSignal`, `InternetAddressType`, `InternetAddress`, |
| `SocketDirection`, `SocketOption`, `RawSocketEvent`, and `StdioType`, and |
| deprecated the old `SCREAMING_CAPS` constants. |
| * Added the Dart-styled top-level constants `zlib`, `gzip`, and |
| `systemEncoding`, and deprecated the old `SCREAMING_CAPS` top-level |
| constants. |
| * Removed the top-level `FileMode` constants `READ`, `WRITE`, `APPEND`, |
| `WRITE_ONLY`, and `WRITE_ONLY_APPEND`. Please use e.g. `FileMode.read` |
| instead. |
| * Added `X509Certificate.der`, `X509Certificate.pem`, and |
| `X509Certificate.sha1`. |
| * Added `FileSystemEntity.fromRawPath` constructor to allow for the creation |
| of `FileSystemEntity` using `Uint8List` buffers. |
| * Dart-styled constants have been added for `HttpStatus`, `HttpHeaders`, |
| `ContentType`, `HttpClient`, `WebSocketStatus`, `CompressionOptions`, and |
| `WebSocket`. The `SCREAMING_CAPS` constants are marked deprecated. Note that |
| `HttpStatus.CONTINUE` is now `HttpStatus.continue_`, and that e.g. |
| `HttpHeaders.FIELD_NAME` is now `HttpHeaders.fieldNameHeader`. |
| * Deprecated `Platform.packageRoot`, which is only used for `packages/` |
| directory resolution which is no longer supported. It will now always return |
| null, which is a value that was always possible for it to return previously. |
| * Adds `HttpClient.connectionTimeout`. |
| * Adds `{Socket,RawSocket,SecureSocket}.startConnect`. These return a |
| `ConnectionTask`, which can be used to cancel an in-flight connection |
| attempt. |
| |
| #### `dart:isolate` |
| |
| * Make `Isolate.spawn` take a type parameter representing the argument type of |
| the provided function. This allows functions with arguments types other than |
| `Object` in strong mode. |
| * Rename `IMMEDIATE` and `BEFORE_NEXT_EVENT` on `Isolate` to `immediate` and |
| `beforeNextEvent`. |
| * Deprecated `Isolate.packageRoot`, which is only used for `packages/` |
| directory resolution which is no longer supported. It will now always return |
| null, which is a value that was always possible for it to return previously. |
| * Deprecated `packageRoot` parameter in `Isolate.spawnUri`, which is was |
| previously used only for `packages/` directory resolution. That style of |
| resolution is no longer supported in Dart 2. |
| |
| <!-- |
| Still need entries for all changes to dart:js since 1.x |
| --> |
| |
| #### `dart.math` |
| |
| * Renamed `E`, `LN10`, `LN`, `LOG2E`, `LOG10E`, `PI`, `SQRT1_2` and `SQRT2` to |
| `e`, `ln10`, `ln`, `log2e`, `log10e`, `pi`, `sqrt1_2` and `sqrt2`. |
| |
| #### `dart.mirrors` |
| |
| * Added `IsolateMirror.loadUri`, which allows dynamically loading additional |
| code. |
| * Marked `MirrorsUsed` as deprecated. The `MirrorsUsed` annotation was only |
| used to inform the dart2js compiler about how mirrors were used, but dart2js |
| no longer supports the mirrors library altogether. |
| |
| <!-- |
| Still need entries for all changes to dart:svg since 1.x |
| --> |
| |
| #### `dart:typed_data` |
| |
| * Added `Unmodifiable` view classes over all `List` types. |
| * Renamed `BYTES_PER_ELEMENT` to `bytesPerElement` on all typed data lists. |
| * Renamed constants `XXXX` through `WWWW` on `Float32x4` and `Int32x4` to |
| lower-case `xxxx` through `wwww`. |
| * Renamed `Endinanness` to `Endian` and its constants from `BIG_ENDIAN`, |
| `LITTLE_ENDIAN` and `HOST_ENDIAN` to `little`, `big` and `host`. |
| |
| <!-- |
| Still need entries for all changes to dart:web_audio,web_gl,web_sql since 1.x |
| --> |
| |
| ### Dart VM |
| |
| * Support for MIPS has been removed. |
| |
| * Dart `int` is now restricted to 64 bits. On overflow, arithmetic operations |
| wrap around, and integer literals larger than 64 bits are not allowed. See |
| https://github.com/dart-lang/sdk/blob/master/docs/language/informal/int64.md |
| for details. |
| |
| * The Dart VM no longer attempts to perform `packages/` directory resolution |
| (for loading scripts, and in `Isolate.resolveUri`). Users relying on |
| `packages/` directories should switch to `.packages` files. |
| |
| ### Dart for the Web |
| |
| * Expose JavaScript Promise APIs using Dart futures. For example, |
| `BackgroundFetchManager.get` is defined as: |
| |
| ```dart |
| Future<BackgroundFetchRegistration> get(String id) |
| ``` |
| |
| It can be used like: |
| |
| ```dart |
| BackgroundFetchRegistration result = await fetchMgr.get('abc'); |
| ``` |
| |
| The underlying JS Promise-to-Future mechanism will be exposed as a public |
| API in the future. |
| |
| #### Dart Dev Compiler (DDC) |
| |
| * dartdevc will no longer throw an error from `is` checks that return a |
| different result in weak mode (SDK [issue 28988][sdk#28988]). For example: |
| |
| ```dart |
| main() { |
| List l = []; |
| // Prints "false", does not throw. |
| print(l is List<String>); |
| } |
| ``` |
| |
| * Failed `as` casts on `Iterable<T>`, `Map<T>`, `Future<T>`, and `Stream<T>` |
| are no longer ignored. These failures were ignored to make it easier to |
| migrate Dart 1 code to strong mode, but ignoring them is a hole in the type |
| system. This closes part of that hole. (We still need to stop ignoring "as" |
| cast failures on function types, and implicit cast failures on the above |
| types and function types.) |
| |
| [sdk#28988]: https://github.com/dart-lang/sdk/issues/28988 |
| |
| #### dart2js |
| |
| * dart2js now compiles programs with Dart 2.0 semantics. Apps are expected to |
| be bigger than before, because Dart 2.0 has many more implicit checks |
| (similar to the `--checked` flag in Dart 1.0). |
| |
| We exposed a `--omit-implicit-checks` flag which removes most of the extra |
| implicit checks. Only use this if you have enough test coverage to know that |
| the app will work well without the checks. If a check would have failed and |
| it is omitted, your app may crash or behave in unexpected ways. This flag is |
| similar to `--trust-type-annotations` in Dart 1.0. |
| |
| * dart2js replaced its front-end with the common front-end (CFE). Thanks to |
| the CFE, dart2js errors are more consistent with all other Dart tools. |
| |
| * dart2js replaced its source-map implementation. There aren't any big |
| differences, but more data is emitted for synthetic code generated by the |
| compiler. |
| |
| * `dart:mirrors` support was removed. Frameworks are encouraged to use |
| code-generation instead. Conditional imports indicate that mirrors are not |
| supported, and any API in the mirrors library will throw at runtime. |
| |
| * The generated output of dart2js can now be run as a webworker. |
| |
| * `dart:isolate` support was removed. To launch background tasks, please |
| use webworkers instead. APIs for webworkers can be accessed from `dart:html` |
| or JS-interop. |
| |
| * dart2js no longer supports the `--package-root` flag. This flag was |
| deprecated in favor of `--packages` long ago. |
| |
| ### Tool Changes |
| |
| #### Analyzer |
| |
| * The analyzer will no longer issue a warning when a generic type parameter is |
| used as the type in an instance check. For example: |
| |
| ```dart |
| test<T>() { |
| print(3 is T); // No warning |
| } |
| ``` |
| |
| * New static checking of `@visibleForTesting` elements. Accessing a method, |
| function, class, etc. annotated with `@visibleForTesting` from a file _not_ |
| in a `test/` directory will result in a new hint ([issue 28273][]). |
| |
| * Static analysis now respects functions annotated with `@alwaysThrows` |
| ([issue 31384][]). |
| |
| * New hints added: |
| |
| * `NULL_AWARE_BEFORE_OPERATOR` when an operator is used after a null-aware |
| access. For example: |
| |
| ```dart |
| x?.a - ''; // HINT |
| ``` |
| |
| * `NULL_AWARE_IN_LOGICAL_OPERATOR` when an expression with null-aware |
| access is used as a condition in logical operators. For example: |
| |
| ```dart |
| x.a || x?.b; // HINT |
| ``` |
| |
| * The command line analyzer (dartanalyzer) and the analysis server no longer |
| treat directories named `packages` specially. Previously they had ignored |
| these directories - and their contents - from the point of view of analysis. |
| Now they'll be treated just as regular directories. This special-casing of |
| `packages` directories was to support using symlinks for package: |
| resolution; that functionality is now handled by `.packages` files. |
| |
| * New static checking of duplicate shown or hidden names in an export |
| directive ([issue 33182][]). |
| |
| * The analysis server will now only analyze code in Dart 2 mode ('strong |
| mode'). It will emit warnings for analysis options files that have |
| `strong-mode: false` set (and will emit a hint for `strong-mode: true`, |
| which is no longer necessary). |
| |
| * The dartanalyzer `--strong` flag is now deprecated and ignored. The |
| command-line analyzer now only analyzes code in strong mode. |
| |
| [issue 28273]: https://github.com/dart-lang/sdk/issues/28273 |
| [issue 31384]: https://github.com/dart-lang/sdk/issues/31384 |
| [issue 33182]: https://github.com/dart-lang/sdk/issues/33182 |
| |
| #### dartfmt |
| |
| * Support `assert()` in const constructor initializer lists. |
| |
| * Better formatting for multi-line strings in argument lists. |
| |
| * Force splitting an empty block as the then body of an if with an else. |
| |
| * Support metadata annotations on enum cases. |
| |
| * Add `--fix` to remove unneeded `new` and `const` keywords, and change `:` to |
| `=` before named parameter default values. |
| |
| * Change formatting rules around static methods to uniformly format code with |
| and without `new` and `const`. |
| |
| * Format expressions inside string interpolation. |
| |
| #### Pub |
| |
| * Pub has a brand new version solver! It supports all the same features as the |
| old version solver, but it's much less likely to stall out on difficult |
| package graphs, and it's much clearer about why a solution can't be found |
| when version solving fails. |
| |
| * Remove support for transformers, `pub build`, and `pub serve`. Use the |
| [new build system][transformers] instead. |
| |
| * There is now a default SDK constraint of `<2.0.0` for any package with no |
| existing upper bound. This allows us to move more safely to 2.0.0. All new |
| packages published on pub will now require an upper bound SDK constraint so |
| future major releases of Dart don't destabilize the package ecosystem. |
| |
| All SDK constraint exclusive upper bounds are now treated as though they |
| allow pre-release versions of that upper bound. For example, the SDK |
| constraint `>=1.8.0 <2.0.0` now allows pre-release SDK versions such as |
| `2.0.0-beta.3.0`. This allows early adopters to try out packages that don't |
| explicitly declare support for the new version yet. You can disable this |
| functionality by setting the `PUB_ALLOW_PRERELEASE_SDK` environment variable |
| to `false`. |
| |
| * Allow depending on a package in a subdirectory of a Git repository. Git |
| dependencies may now include a `path` parameter, indicating that the package |
| exists in a subdirectory of the Git repository. For example: |
| |
| ```yaml |
| dependencies: |
| foobar: |
| git: |
| url: git://github.com/dart-lang/multi_package_repo |
| path: pkg/foobar |
| ``` |
| |
| * Added an `--executables` option to `pub deps` command. This will list all |
| available executables that can be run with `pub run`. |
| |
| * The Flutter `sdk` source will now look for packages in |
| `flutter/bin/cache/pkg/` as well as `flutter/packages/`. In particular, this |
| means that packages can depend on the `sky_engine` package from the `sdk` |
| source ([issue 1775][pub#1775]). |
| |
| * Pub now caches compiled packages and snapshots in the `.dart_tool/pub` |
| directory, rather than the `.pub` directory ([issue 1795][pub#1795]). |
| |
| * Other bug fixes and improvements. |
| |
| [issue 30246]: https://github.com/dart-lang/sdk/issues/30246 |
| [pub#1679]: https://github.com/dart-lang/pub/issues/1679 |
| [pub#1684]: https://github.com/dart-lang/pub/issues/1684 |
| [pub#1775]: https://github.com/dart-lang/pub/issues/1775 |
| [pub#1795]: https://github.com/dart-lang/pub/issues/1795 |
| [pub#1823]: https://github.com/dart-lang/pub/issues/1823 |
| |
| ## 1.24.3 - 2017-12-14 |
| |
| * Fix for constructing a new SecurityContext that contains the built-in |
| certificate authority roots |
| ([issue 24693](https://github.com/dart-lang/sdk/issues/24693)). |
| |
| ### Core library changes |
| |
| * `dart:io` |
| * Unified backends for `SecureSocket`, `SecurityContext`, and |
| `X509Certificate` to be consistent across all platforms. All |
| `SecureSocket`, `SecurityContext`, and `X509Certificate` properties and |
| methods are now supported on iOS and OSX. |
| |
| ## 1.24.2 - 2017-06-22 |
| |
| * Fixes for debugging in Dartium. |
| * Fix DevConsole crash with JS |
| ([issue 29873](https://github.com/dart-lang/sdk/issues/29873)). |
| * Fix debugging in WebStorm, NULL returned for JS objects |
| ([issue 29854](https://github.com/dart-lang/sdk/issues/29854)). |
| |
| ## 1.24.1 - 2017-06-14 |
| |
| * Bug fixes for dartdevc support in `pub serve`. |
| * Fixed module config invalidation logic so modules are properly |
| recalculated when package layout changes. |
| * Fixed exception when handling require.js errors that aren't script load |
| errors. |
| * Fixed an issue where requesting the bootstrap.js file before the dart.js |
| file would result in a 404. |
| * Fixed a Safari issue during bootstrapping (note that Safari is still not |
| officially supported but does work for trivial examples). |
| * Fix for a Dartium issue where there was no sound in checked mode |
| ([issue 29810](https://github.com/dart-lang/sdk/issues/29810)). |
| |
| ## 1.24.0 - 2017-06-12 |
| |
| ### Language |
| * During a dynamic type check, `void` is not required to be `null` anymore. |
| In practice, this makes overriding `void` functions with non-`void` functions |
| safer. |
| |
| * During static analysis, a function or setter declared using `=>` with return |
| type `void` now allows the returned expression to have any type. For example, |
| assuming the declaration `int x;`, it is now type correct to have |
| `void f() => ++x;`. |
| |
| * A new function-type syntax has been added to the language. |
| **Warning**: *In Dart 1.24, this feature is incomplete, and not stable in the Analyzer.* |
| |
| Intuitively, the type of a function can be constructed by textually replacing |
| the function's name with `Function` in its declaration. For instance, the |
| type of `void foo() {}` would be `void Function()`. The new syntax may be used |
| wherever a type can be written. It is thus now possible to declare fields |
| containing functions without needing to write typedefs: `void Function() x;`. |
| The new function type has one restriction: it may not contain the old-style |
| function-type syntax for its parameters. The following is thus illegal: |
| `void Function(int f())`. |
| `typedefs` have been updated to support this new syntax. |
| |
| Examples: |
| |
| ```dart |
| typedef F = void Function(); // F is the name for a `void` callback. |
| int Function(int) f; // A field `f` that contains an int->int function. |
| |
| class A<T> { |
| // The parameter `callback` is a function that takes a `T` and returns |
| // `void`. |
| void forEach(void Function(T) callback); |
| } |
| |
| // The new function type supports generic arguments. |
| typedef Invoker = T Function<T>(T Function() callback); |
| ``` |
| |
| ### Core library changes |
| |
| * `dart:async`, `dart:core`, `dart:io` |
| * Adding to a closed sink, including `IOSink`, is no longer not allowed. In |
| 1.24, violations are only reported (on stdout or stderr), but a future |
| version of the Dart SDK will change this to throwing a `StateError`. |
| |
| * `dart:convert` |
| * **BREAKING** Removed the deprecated `ChunkedConverter` class. |
| * JSON maps are now typed as `Map<String, dynamic>` instead of |
| `Map<dynamic, dynamic>`. A JSON-map is not a `HashMap` or `LinkedHashMap` |
| anymore (but just a `Map`). |
| |
| * `dart:io` |
| * Added `Platform.localeName`, needed for accessing the locale on platforms |
| that don't store it in an environment variable. |
| * Added `ProcessInfo.currentRss` and `ProcessInfo.maxRss` for inspecting |
| the Dart VM process current and peak resident set size. |
| * Added `RawSynchronousSocket`, a basic synchronous socket implementation. |
| |
| * `dart:` web APIs have been updated to align with Chrome v50. |
| This change includes **a large number of changes**, many of which are |
| breaking. In some cases, new class names may conflict with names that exist |
| in existing code. |
| |
| * `dart:html` |
| |
| * **REMOVED** classes: `Bluetooth`, `BluetoothDevice`, |
| `BluetoothGattCharacteristic`, `BluetoothGattRemoteServer`, |
| `BluetoothGattService`, `BluetoothUuid`, `CrossOriginConnectEvent`, |
| `DefaultSessionStartEvent`, `DomSettableTokenList`, `MediaKeyError`, |
| `PeriodicSyncEvent`, `PluginPlaceholderElement`, `ReadableStream`, |
| `StashedMessagePort`, `SyncRegistration` |
| |
| * **REMOVED** members: |
| * `texImage2DCanvas` was removed from `RenderingContext`. |
| * `endClip` and `startClip` were removed from `Animation`. |
| * `after` and `before` were removed from `CharacterData`, `ChildNode` and |
| `Element`. |
| * `keyLocation` was removed from `KeyboardEvent`. Use `location` instead. |
| * `generateKeyRequest`, `keyAddedEvent`, `keyErrorEvent`, `keyMessageEvent`, |
| `mediaGroup`, `needKeyEvent`, `onKeyAdded`, `onKeyError`, `onKeyMessage`, |
| and `onNeedKey` were removed from `MediaElement`. |
| * `getStorageUpdates` was removed from `Navigator` |
| * `status` was removed from `PermissionStatus` |
| * `getAvailability` was removed from `PreElement` |
| |
| * Other behavior changes: |
| * URLs returned in CSS or html are formatted with quoted string. |
| Like `url("http://google.com")` instead of `url(http://google.com)`. |
| * Event timestamp property type changed from `int` to `num`. |
| * Chrome introduced slight layout changes of UI objects. |
| In addition many height/width dimensions are returned in subpixel values |
| (`num` instead of whole numbers). |
| * `setRangeText` with a `selectionMode` value of 'invalid' is no longer |
| valid. Only "select", "start", "end", "preserve" are allowed. |
| |
| * `dart:svg` |
| |
| * A large number of additions and removals. Review your use of `dart:svg` |
| carefully. |
| |
| * `dart:web_audio` |
| |
| * new method on `AudioContext` - `createIirFilter` returns a new class |
| `IirFilterNode`. |
| |
| * `dart:web_gl` |
| |
| * new classes: `CompressedTextureAstc`, `ExtColorBufferFloat`, |
| `ExtDisjointTimerQuery`, and `TimerQueryExt`. |
| |
| * `ExtFragDepth` added: `readPixels2` and `texImage2D2`. |
| |
| #### Strong Mode |
| |
| * Removed ad hoc `Future.then` inference in favor of using `FutureOr`. Prior to |
| adding `FutureOr` to the language, the analyzer implemented an ad hoc type |
| inference for `Future.then` (and overrides) treating it as if the onValue |
| callback was typed to return `FutureOr` for the purposes of inference. |
| This ad hoc inference has been removed now that `FutureOr` has been added. |
| |
| Packages that implement `Future` must either type the `onValue` parameter to |
| `.then` as returning `FutureOr<T>`, or else must leave the type of the parameter |
| entirely to allow inference to fill in the type. |
| |
| * During static analysis, a function or setter declared using `=>` with return |
| type `void` now allows the returned expression to have any type. |
| |
| ### Tool Changes |
| |
| * Dartium |
| |
| Dartium is now based on Chrome v50. See *Core library changes* above for |
| details on the changed APIs. |
| |
| * Pub |
| |
| * `pub build` and `pub serve` |
| |
| * Added support for the Dart Development Compiler. |
| |
| Unlike dart2js, this new compiler is modular, which allows pub to do |
| incremental re-builds for `pub serve`, and potentially `pub build` in the |
| future. |
| |
| In practice what that means is you can edit your Dart files, refresh in |
| Chrome (or other supported browsers), and see your edits almost |
| immediately. This is because pub is only recompiling your package, not all |
| packages that you depend on. |
| |
| There is one caveat with the new compiler, which is that your package and |
| your dependencies must all be strong mode clean. If you are getting an |
| error compiling one of your dependencies, you will need to file bugs or |
| send pull requests to get them strong mode clean. |
| |
| There are two ways of opting into the new compiler: |
| |
| * Use the new `--web-compiler` flag, which supports `dartdevc`, |
| `dart2js` or `none` as options. This is the easiest way to try things |
| out without changing the default. |
| |
| * Add config to your pubspec. There is a new `web` key which supports a |
| single key called `compiler`. This is a map from mode names to |
| compiler to use. For example, to default to dartdevc in debug mode you |
| can add the following to your pubspec: |
| |
| ```yaml |
| web: |
| compiler: |
| debug: dartdevc |
| ``` |
| |
| You can also use the new compiler to run your tests in Chrome much more |
| quickly than you can with dart2js. In order to do that, run |
| `pub serve test --web-compiler=dartdevc`, and then run |
| `pub run test -p chrome --pub-serve=8080`. |
| |
| * The `--no-dart2js` flag has been deprecated in favor of |
| `--web-compiler=none`. |
| |
| * `pub build` will use a failing exit code if there are errors in any |
| transformer. |
| |
| * `pub publish` |
| |
| * Added support for the UNLICENSE file. |
| |
| * Packages that depend on the Flutter SDK may be published. |
| |
| * `pub get` and `pub upgrade` |
| |
| * Don't dump a stack trace when a network error occurs while fetching |
| packages. |
| |
| * dartfmt |
| * Preserve type parameters in new generic function typedef syntax. |
| * Add self-test validation to ensure formatter bugs do not cause user code |
| to be lost. |
| |
| ### Infrastructure changes |
| |
| * As of this release, we'll show a warning when using the MIPS architecture. |
| Unless we learn about any critical use of Dart on MIPS in the meantime, we're |
| planning to deprecate support for MIPS starting with the next stable release. |
| |
| ## 1.23.0 - 2017-04-21 |
| |
| #### Strong Mode |
| |
| * Breaking change - it is now a strong mode error if a mixin causes a name |
| conflict between two private members (field/getter/setter/method) from a |
| different library. (SDK |
| issue [28809](https://github.com/dart-lang/sdk/issues/28809)). |
| |
| lib1.dart: |
| |
| |
| ```dart |
| class A { |
| int _x; |
| } |
| |
| class B { |
| int _x; |
| } |
| ``` |
| |
| lib2.dart: |
| |
| |
| ```dart |
| import 'lib1.dart'; |
| |
| class C extends A with B {} |
| ``` |
| |
| ``` |
| error • The private name _x, defined by B, conflicts with the same name defined by A at tmp/lib2.dart:3:24 • private_collision_in_mixin_application |
| ``` |
| |
| |
| * Breaking change - strong mode will prefer the expected type to infer generic |
| types, functions, and methods (SDK |
| issue [27586](https://github.com/dart-lang/sdk/issues/27586)). |
| |
| ```dart |
| main() { |
| List<Object> foo = /*infers: <Object>*/['hello', 'world']; |
| var bar = /*infers: <String>*/['hello', 'world']; |
| } |
| ``` |
| |
| * Strong mode inference error messages are improved |
| (SDK issue [29108](https://github.com/dart-lang/sdk/issues/29108)). |
| |
| ```dart |
| import 'dart:math'; |
| test(Iterable/* fix is to add <num> here */ values) { |
| num n = values.fold(values.first as num, max); |
| } |
| ``` |
| Now produces the error on the generic function "max": |
| ``` |
| Couldn't infer type parameter 'T'. |
| |
| Tried to infer 'dynamic' for 'T' which doesn't work: |
| Function type declared as '<T extends num>(T, T) → T' |
| used where '(num, dynamic) → num' is required. |
| |
| Consider passing explicit type argument(s) to the generic. |
| ``` |
| |
| * Strong mode supports overriding fields, `@virtual` is no longer required |
| (SDK issue [28120](https://github.com/dart-lang/sdk/issues/28120)). |
| |
| ```dart |
| class C { |
| int x = 42; |
| } |
| class D extends C { |
| get x { |
| print("x got called"); |
| return super.x; |
| } |
| } |
| main() { |
| print(new D().x); |
| } |
| ``` |
| |
| * Strong mode down cast composite warnings are no longer issued by default. |
| (SDK issue [28588](https://github.com/dart-lang/sdk/issues/28588)). |
| |
| ```dart |
| void test() { |
| List untyped = []; |
| List<int> typed = untyped; // No down cast composite warning |
| } |
| ``` |
| |
| To opt back into the warnings, add the following to |
| the |
| [.analysis_options](https://www.dartlang.org/guides/language/analysis-options) |
| file for your project. |
| |
| ``` |
| analyzer: |
| errors: |
| strong_mode_down_cast_composite: warning |
| ``` |
| |
| |
| ### Core library changes |
| |
| * `dart:core` |
| * Added `Uri.isScheme` function to check the scheme of a URI. |
| Example: `uri.isScheme("http")`. Ignores case when comparing. |
| * Make `UriData.parse` validate its input better. |
| If the data is base-64 encoded, the data is normalized wrt. |
| alphabet and padding, and it contains invalid base-64 data, |
| parsing fails. Also normalizes non-base-64 data. |
| * `dart:io` |
| * Added functions `File.lastAccessed`, `File.lastAccessedSync`, |
| `File.setLastModified`, `File.setLastModifiedSync`, `File.setLastAccessed`, |
| and `File.setLastAccessedSync`. |
| * Added `{Stdin,Stdout}.supportsAnsiEscapes`. |
| |
| ### Dart VM |
| |
| * Calls to `print()` and `Stdout.write*()` now correctly print unicode |
| characters to the console on Windows. Calls to `Stdout.add*()` behave as |
| before. |
| |
| ### Tool changes |
| |
| * Analysis |
| * `dartanalyzer` now follows the same rules as the analysis server to find |
| an analysis options file, stopping when an analysis options file is found: |
| * Search up the directory hierarchy looking for an analysis options file. |
| * If analyzing a project referencing the [Flutter](https://flutter.io/) |
| package, then use the |
| [default Flutter analysis options](https://github.com/flutter/flutter/blob/master/packages/flutter/lib/analysis_options_user.yaml) |
| found in `package:flutter`. |
| * If in a Bazel workspace, then use the analysis options in |
| `package:dart.analysis_options/default.yaml` if it exists. |
| * Use the default analysis options rules. |
| * In addition, specific to `dartanalyzer`: |
| * an analysis options file can be specified on the command line via |
| `--options` and that file will be used instead of searching for an |
| analysis options file. |
| * any analysis option specified on the command line |
| (e.g. `--strong` or `--no-strong`) takes precedence over any corresponding |
| value specified in the analysis options file. |
| |
| * Dartium, dart2js, and DDC |
| |
| * Imports to `dart:io` are allowed, but the imported library is not supported |
| and will likely fail on most APIs at runtime. This change was made as a |
| stopgap measure to make it easier to write libraries that share code between |
| platforms (like package `http`). This might change again when configuration |
| specific imports are supported. |
| |
| * Pub |
| * Now sends telemetry data to `pub.dartlang.org` to allow better understanding |
| of why a particular package is being accessed. |
| * `pub publish` |
| * Warns if a package imports a package that's not a dependency from within |
| `lib/` or `bin/`, or a package that's not a dev dependency from within |
| `benchmark/`, `example/`, `test/` or `tool/`. |
| * No longer produces "UID too large" errors on OS X. All packages are now |
| uploaded with the user and group names set to "pub". |
| * No longer fails with a stack overflow when uploading a package that uses |
| Git submodules. |
| * `pub get` and `pub upgrade` |
| * Produce more informative error messages if they're run directly in a |
| package that uses Flutter. |
| * Properly unlock SDK and path dependencies if they have a new version |
| that's also valid according to the user's pubspec. |
| |
| * dartfmt |
| * Support new generic function typedef syntax. |
| * Make the precedence of cascades more visible. |
| * Fix a couple of places where spurious newlines were inserted. |
| * Correctly report unchanged formatting when reading from stdin. |
| * Ensure space between `-` and `--`. Code that does this is pathological, but |
| it technically meant dartfmt could change the semantics of the code. |
| * Preserve a blank line between enum cases. |
| * Other small formatting tweaks. |
| |
| |
| ## 1.22.1 - 2017-02-22 |
| |
| Patch release, resolves two issues: |
| * Dart VM crash: [Issue 28072](https://github.com/dart-lang/sdk/issues/28757) |
| |
| * Dart VM bug combining types, await, and deferred loading: [Issue 28678](https://github.com/dart-lang/sdk/issues/28678) |
| |
| |
| ## 1.22.0 - 2017-02-14 |
| |
| ### Language |
| |
| * Breaking change: |
| ['Generalized tear-offs'](https://github.com/gbracha/generalizedTearOffs/blob/master/proposal.md) |
| are no longer supported, and will cause errors. We updated the language spec |
| and added warnings in 1.21, and are now taking the last step to fully |
| de-support them. They were previously only supported in the VM, and there |
| are almost no known uses of them in the wild. |
| |
| * The `assert()` statement has been expanded to support an optional second |
| `message` argument |
| (SDK issue [27342](https://github.com/dart-lang/sdk/issues/27342)). |
| |
| The message is displayed if the assert fails. It can be any object, and it |
| is accessible as `AssertionError.message`. It can be used to provide more |
| user friendly exception outputs. As an example, the following assert: |
| |
| ```dart |
| assert(configFile != null, "Tool config missing. Please see https://goo.gl/k8iAi for details."); |
| ``` |
| |
| would produce the following exception output: |
| |
| ``` |
| Unhandled exception: |
| 'file:///Users/mit/tmp/tool/bin/main.dart': Failed assertion: line 9 pos 10: |
| 'configFile != null': Tool config missing. Please see https://goo.gl/k8iAi for details. |
| #0 _AssertionError._doThrowNew (dart:core-patch/errors_patch.dart:33) |
| #1 _AssertionError._throwNew (dart:core-patch/errors_patch.dart:29) |
| #2 main (file:///Users/mit/tmp/tool/bin/main.dart:9:10) |
| ``` |
| |
| * The `Null` type has been moved to the bottom of the type hierarchy. As such, |
| it is considered a subtype of every other type. The `null` *literal* was |
| always treated as a bottom type. Now the named class `Null` is too: |
| |
| ```dart |
| const empty = <Null>[]; |
| |
| String concatenate(List<String> parts) => parts.join(); |
| int sum(List<int> numbers) => numbers.fold(0, (sum, n) => sum + n); |
| |
| concatenate(empty); // OK. |
| sum(empty); // OK. |
| ``` |
| |
| * Introduce `covariant` modifier on parameters. It indicates that the |
| parameter (and the corresponding parameter in any method that overrides it) |
| has looser override rules. In strong mode, these require a runtime type |
| check to maintain soundness, but enable an architectural pattern that is |
| useful in some code. |
| |
| It lets you specialize a family of classes together, like so: |
| |
| ```dart |
| abstract class Predator { |
| void chaseAndEat(covariant Prey p); |
| } |
| |
| abstract class Prey {} |
| |
| class Mouse extends Prey {} |
| |
| class Seal extends Prey {} |
| |
| class Cat extends Predator { |
| void chaseAndEat(Mouse m) => ... |
| } |
| |
| class Orca extends Predator { |
| void chaseAndEat(Seal s) => ... |
| } |
| ``` |
| |
| This isn't statically safe, because you could do: |
| |
| ```dart |
| Predator predator = new Cat(); // Upcast. |
| predator.chaseAndEat(new Seal()); // Cats can't eat seals! |
| ``` |
| |
| To preserve soundness in strong mode, in the body of a method that uses a |
| covariant override (here, `Cat.chaseAndEat()`), the compiler automatically |
| inserts a check that the parameter is of the expected type. So the compiler |
| gives you something like: |
| |
| ```dart |
| class Cat extends Predator { |
| void chaseAndEat(o) { |
| var m = o as Mouse; |
| ... |
| } |
| } |
| ``` |
| |
| Spec mode allows this unsound behavior on all parameters, even though users |
| rarely rely on it. Strong mode disallowed it initially. Now, strong mode |
| lets you opt into this behavior in the places where you do want it by using |
| this modifier. Outside of strong mode, the modifier is ignored. |
| |
| * Change instantiate-to-bounds rules for generic type parameters when running |
| in strong mode. If you leave off the type parameters from a generic type, we |
| need to decide what to fill them in with. Dart 1.0 says just use `dynamic`, |
| but that isn't sound: |
| |
| ```dart |
| class Abser<T extends num> { |
| void absThis(T n) { n.abs(); } |
| } |
| |
| var a = new Abser(); // Abser<dynamic>. |
| a.absThis("not a num"); |
| ``` |
| |
| We want the body of `absThis()` to be able to safely assume `n` is at |
| least a `num` -- that's why there's a constraint on T, after all. Implicitly |
| using `dynamic` as the type parameter in this example breaks that. |
| |
| Instead, strong mode uses the bound. In the above example, it fills it in |
| with `num`, and then the second line where a string is passed becomes a |
| static error. |
| |
| However, there are some cases where it is hard to figure out what that |
| default bound should be: |
| |
| ```dart |
| class RuhRoh<T extends Comparable<T>> {} |
| ``` |
| |
| Strong mode's initial behavior sometimes produced surprising, unintended |
| results. For 1.22, we take a simpler approach and then report an error if |
| a good default type argument can't be found. |
| |
| ### Core libraries |
| |
| * Define `FutureOr<T>` for code that works with either a future or an |
| immediate value of some type. For example, say you do a lot of text |
| manipulation, and you want a handy function to chain a bunch of them: |
| |
| ```dart |
| typedef String StringSwizzler(String input); |
| |
| String swizzle(String input, List<StringSwizzler> swizzlers) { |
| var result = input; |
| for (var swizzler in swizzlers) { |
| result = swizzler(result); |
| } |
| |
| return result; |
| } |
| ``` |
| |
| This works fine: |
| |
| ```dart |
| main() { |
| var result = swizzle("input", [ |
| (s) => s.toUpperCase(), |
| (s) => () => s * 2) |
| ]); |
| print(result); // "INPUTINPUT". |
| } |
| ``` |
| |
| Later, you realize you'd also like to support swizzlers that are |
| asynchronous (maybe they look up synonyms for words online). You could make |
| your API strictly asynchronous, but then users of simple synchronous |
| swizzlers have to manually wrap the return value in a `Future.value()`. |
| Ideally, your `swizzle()` function would be "polymorphic over asynchrony". |
| It would allow both synchronous and asynchronous swizzlers. Because `await` |
| accepts immediate values, it is easy to implement this dynamically: |
| |
| ```dart |
| Future<String> swizzle(String input, List<StringSwizzler> swizzlers) async { |
| var result = input; |
| for (var swizzler in swizzlers) { |
| result = await swizzler(result); |
| } |
| |
| return result; |
| } |
| |
| main() async { |
| var result = swizzle("input", [ |
| (s) => s.toUpperCase(), |
| (s) => new Future.delayed(new Duration(milliseconds: 40), () => s * 2) |
| ]); |
| print(await result); |
| } |
| ``` |
| |
| What should the declared return type on StringSwizzler be? In the past, you |
| had to use `dynamic` or `Object`, but that doesn't tell the user much. Now, |
| you can do: |
| |
| ```dart |
| typedef FutureOr<String> StringSwizzler(String input); |
| ``` |
| |
| Like the name implies, `FutureOr<String>` is a union type. It can be a |
| `String` or a `Future<String>`, but not anything else. In this case, that's |
| not super useful beyond just stating a more precise type for readers of the |
| code. It does give you a little better error checking in code that uses the |
| result of that. |
| |
| `FutureOr<T>` becomes really important in *generic* methods like |
| `Future.then()`. In those cases, having the type system understand this |
| magical union type helps type inference figure out the type argument of |
| `then()` based on the closure you pass it. |
| |
| Previously, strong mode had hard-coded rules for handling `Future.then()` |
| specifically. `FutureOr<T>` exposes that functionality so third-party APIs |
| can take advantage of it too. |
| |
| ### Tool changes |
| |
| * Dart2Js |
| |
| * Remove support for (long-time deprecated) mixin typedefs. |
| |
| * Pub |
| |
| * Avoid using a barback asset server for executables unless they actually use |
| transformers. This makes precompilation substantially faster, produces |
| better error messages when precompilation fails, and allows |
| globally-activated executables to consistently use the |
| `Isolate.resolvePackageUri()` API. |
| |
| * On Linux systems, always ignore packages' original file owners and |
| permissions when extracting those packages. This was already the default |
| under most circumstances. |
| |
| * Properly close the standard input stream of child processes started using |
| `pub run`. |
| |
| * Handle parse errors from the package cache more gracefully. A package whose |
| pubspec can't be parsed will now be ignored by `pub get --offline` and |
| deleted by `pub cache repair`. |
| |
| * Make `pub run` run executables in spawned isolates. This lets them handle |
| signals and use standard IO reliably. |
| |
| * Fix source-maps produced by dart2js when running in `pub serve`: URL |
| references to assets from packages match the location where `pub serve` |
| serves them (`packages/package_name/` instead of |
| `../packages/package_name/`). |
| |
| ### Infrastructure changes |
| |
| * The SDK now uses GN rather than gyp to generate its build files, which will |
| now be exclusively ninja flavored. Documentation can be found on our |
| [wiki](https://github.com/dart-lang/sdk/wiki/Building-with-GN). Also see the |
| help message of `tools/gn.py`. This change is in response to the deprecation |
| of gyp. Build file generation with gyp will continue to be available in this |
| release by setting the environment variable `DART_USE_GYP` before running |
| `gclient sync` or `gclient runhooks`, but this will be removed in a future |
| release. |
| |
| ## 1.21.1 - 2017-01-13 |
| |
| Patch release, resolves one issue: |
| |
| * Dart VM: Snapshots of generic functions fail. [Issue 28072](https://github.com/dart-lang/sdk/issues/28072) |
| |
| ## 1.21.0 - 2016-12-07 |
| |
| ### Language |
| |
| * Support generic method syntax. Type arguments are not available at |
| runtime. For details, check the |
| [informal specification](https://gist.github.com/eernstg/4353d7b4f669745bed3a5423e04a453c). |
| * Support access to initializing formals, e.g., the use of `x` to initialize |
| `y` in `class C { var x, y; C(this.x): y = x; }`. |
| Please check the |
| [informal specification](https://gist.github.com/eernstg/cff159be9e34d5ea295d8c24b1a3e594) |
| for details. |
| * Don't warn about switch case fallthrough if the case ends in a `rethrow` |
| statement. (SDK issue |
| [27650](https://github.com/dart-lang/sdk/issues/27650)) |
| * Also don't warn if the entire switch case is wrapped in braces - as long as |
| the block ends with a `break`, `continue`, `rethrow`, `return` or `throw`. |
| * Allow `=` as well as `:` as separator for named parameter default values. |
| |
| ```dart |
| enableFlags({bool hidden: false}) { … } |
| ``` |
| |
| can now be replaced by |
| |
| ```dart |
| enableFlags({bool hidden = false}) { … } |
| ``` |
| |
| (SDK issue [27559](https://github.com/dart-lang/sdk/issues/27559)) |
| |
| ### Core library changes |
| |
| * `dart:core`: `Set.difference` now takes a `Set<Object>` as argument. (SDK |
| issue [27573](https://github.com/dart-lang/sdk/issues/27573)) |
| |
| * `dart:developer` |
| |
| * Added `Service` class. |
| * Allows inspecting and controlling the VM service protocol HTTP server. |
| * Provides an API to access the ID of an `Isolate`. |
| |
| ### Tool changes |
| |
| * Dart Dev Compiler |
| |
| * Support calls to `loadLibrary()` on deferred libraries. Deferred libraries |
| are still loaded eagerly. (SDK issue |
| [27343](https://github.com/dart-lang/sdk/issues/27343)) |
| |
| ## 1.20.1 - 2016-10-13 |
| |
| Patch release, resolves one issue: |
| |
| * Dartium: Fixes a bug that caused crashes. No issue filed. |
| |
| ### Strong Mode |
| |
| * It is no longer a warning when casting from dynamic to a composite type |
| (SDK issue [27766](https://github.com/dart-lang/sdk/issues/27766)). |
| |
| ```dart |
| main() { |
| dynamic obj = <int>[1, 2, 3]; |
| // This is now allowed without a warning. |
| List<int> list = obj; |
| } |
| ``` |
| |
| ## 1.20.0 - 2016-10-11 |
| |
| ### Dart VM |
| |
| * We have improved the way that the VM locates the native code library for a |
| native extension (e.g. `dart-ext:` import). We have updated this |
| [article on native extensions](https://www.dartlang.org/articles/dart-vm/native-extensions) |
| to reflect the VM's improved behavior. |
| |
| * Linux builds of the VM will now use the `tcmalloc` library for memory |
| allocation. This has the advantages of better debugging and profiling support |
| and faster small allocations, with the cost of slightly larger initial memory |
| footprint, and slightly slower large allocations. |
| |
| * We have improved the way the VM searches for trusted root certificates for |
| secure socket connections on Linux. First, the VM will look for trusted root |
| certificates in standard locations on the file system |
| (`/etc/pki/tls/certs/ca-bundle.crt` followed by `/etc/ssl/certs`), and only if |
| these do not exist will it fall back on the builtin trusted root certificates. |
| This behavior can be overridden on Linux with the new flags |
| `--root-certs-file` and `--root-certs-cache`. The former is the path to a file |
| containing the trusted root certificates, and the latter is the path to a |
| directory containing root certificate files hashed using `c_rehash`. |
| |
| * The VM now throws a catchable `Error` when method compilation fails. This |
| allows easier debugging of syntax errors, especially when testing. (SDK issue |
| [23684](https://github.com/dart-lang/sdk/issues/23684)) |
| |
| ### Core library changes |
| |
| * `dart:core`: Remove deprecated `Resource` class. |
| Use the class in `package:resource` instead. |
| * `dart:async` |
| * `Future.wait` now catches synchronous errors and returns them in the |
| returned Future. (SDK issue |
| [27249](https://github.com/dart-lang/sdk/issues/27249)) |
| * More aggressively returns a `Future` on `Stream.cancel` operations. |
| Discourages to return `null` from `cancel`. (SDK issue |
| [26777](https://github.com/dart-lang/sdk/issues/26777)) |
| * Fixes a few bugs where the cancel future wasn't passed through |
| transformations. |
| * `dart:io` |
| * Added `WebSocket.addUtf8Text` to allow sending a pre-encoded text message |
| without a round-trip UTF-8 conversion. (SDK issue |
| [27129](https://github.com/dart-lang/sdk/issues/27129)) |
| |
| ### Strong Mode |
| |
| * Breaking change - it is an error if a generic type parameter cannot be |
| inferred (SDK issue [26992](https://github.com/dart-lang/sdk/issues/26992)). |
| |
| ```dart |
| class Cup<T> { |
| Cup(T t); |
| } |
| main() { |
| // Error because: |
| // - if we choose Cup<num> it is not assignable to `cOfInt`, |
| // - if we choose Cup<int> then `n` is not assignable to int. |
| num n; |
| C<int> cOfInt = new C(n); |
| } |
| ``` |
| |
| * New feature - use `@checked` to override a method and tighten a parameter |
| type (SDK issue [25578](https://github.com/dart-lang/sdk/issues/25578)). |
| |
| ```dart |
| import 'package:meta/meta.dart' show checked; |
| class View { |
| addChild(View v) {} |
| } |
| class MyView extends View { |
| // this override is legal, it will check at runtime if we actually |
| // got a MyView. |
| addChild(@checked MyView v) {} |
| } |
| main() { |
| dynamic mv = new MyView(); |
| mv.addChild(new View()); // runtime error |
| } |
| ``` |
| |
| * New feature - use `@virtual` to allow field overrides in strong mode |
| (SDK issue [27384](https://github.com/dart-lang/sdk/issues/27384)). |
| |
| ```dart |
| import 'package:meta/meta.dart' show virtual; |
| class Base { |
| @virtual int x; |
| } |
| class Derived extends Base { |
| int x; |
| |
| // Expose the hidden storage slot: |
| int get superX => super.x; |
| set superX(int v) { super.x = v; } |
| } |
| ``` |
| |
| * Breaking change - infer list and map literals from the context type as well as |
| their values, consistent with generic methods and instance creation |
| (SDK issue [27151](https://github.com/dart-lang/sdk/issues/27151)). |
| |
| ```dart |
| import 'dart:async'; |
| main() async { |
| var b = new Future<B>.value(new B()); |
| var c = new Future<C>.value(new C()); |
| var/*infer List<Future<A>>*/ list = [b, c]; |
| var/*infer List<A>*/ result = await Future.wait(list); |
| } |
| class A {} |
| class B extends A {} |
| class C extends A {} |
| ``` |
| |
| ### Tool changes |
| |
| * `dartfmt` - upgraded to v0.2.10 |
| * Don't crash on annotations before parameters with trailing commas. |
| * Always split enum declarations if they end in a trailing comma. |
| * Add `--set-exit-if-changed` to set the exit code on a change. |
| |
| * Pub |
| * Pub no longer generates a `packages/` directory by default. Instead, it |
| generates a `.packages` file, called a package spec. To generate |
| a `packages/` directory in addition to the package spec, use the |
| `--packages-dir` flag with `pub get`, `pub upgrade`, and `pub downgrade`. |
| See the [Good-bye |
| symlinks](http://news.dartlang.org/2016/10/good-bye-symlinks.html) article |
| for details. |
| |
| ## 1.19.1 - 2016-09-08 |
| |
| Patch release, resolves one issue: |
| |
| * Dartdoc: Fixes a bug that prevented generation of docs. |
| (Dartdoc issue [1233](https://github.com/dart-lang/dartdoc/issues/1233)) |
| |
| ## 1.19.0 - 2016-08-26 |
| |
| ### Language changes |
| |
| * The language now allows a trailing comma after the last argument of a call and |
| the last parameter of a function declaration. This can make long argument or |
| parameter lists easier to maintain, as commas can be left as-is when |
| reordering lines. For details, see SDK issue |
| [26644](https://github.com/dart-lang/sdk/issues/26644). |
| |
| ### Tool Changes |
| |
| * `dartfmt` - upgraded to v0.2.9+1 |
| * Support trailing commas in argument and parameter lists. |
| * Gracefully handle read-only files. |
| * About a dozen other bug fixes. |
| |
| * Pub |
| * Added a `--no-packages-dir` flag to `pub get`, `pub upgrade`, and `pub |
| downgrade`. When this flag is passed, pub will not generate a `packages/` |
| directory, and will remove that directory and any symlinks to it if they |
| exist. Note that this replaces the unsupported `--no-package-symlinks` flag. |
| |
| * Added the ability for packages to declare a constraint on the [Flutter][] |
| SDK: |
| |
| ```yaml |
| environment: |
| flutter: ^0.1.2 |
| sdk: >=1.19.0 <2.0.0 |
| ``` |
| |
| A Flutter constraint will only be satisfiable when pub is running in the |
| context of the `flutter` executable, and when the Flutter SDK version |
| matches the constraint. |
| |
| * Added `sdk` as a new package source that fetches packages from a hard-coded |
| SDK. Currently only the `flutter` SDK is supported: |
| |
| ```yaml |
| dependencies: |
| flutter_driver: |
| sdk: flutter |
| version: ^0.0.1 |
| ``` |
| |
| A Flutter `sdk` dependency will only be satisfiable when pub is running in |
| the context of the `flutter` executable, and when the Flutter SDK contains a |
| package with the given name whose version matches the constraint. |
| |
| * `tar` files on Linux are now created with `0` as the user and group IDs. |
| This fixes a crash when publishing packages while using Active Directory. |
| |
| * Fixed a bug where packages from a hosted HTTP URL were considered the same |
| as packages from an otherwise-identical HTTPS URL. |
| |
| * Fixed timer formatting for timers that lasted longer than a minute. |
| |
| * Eliminate some false negatives when determining whether global executables |
| are on the user's executable path. |
| |
| * `dart2js` |
| * `dart2dart` (aka `dart2js --output-type=dart`) has been removed (this was deprecated in Dart 1.11). |
| |
| [Flutter]: https://flutter.io/ |
| |
| ### Dart VM |
| |
| * The dependency on BoringSSL has been rolled forward. Going forward, builds |
| of the Dart VM including secure sockets will require a compiler with C++11 |
| support. For details, see the |
| [Building wiki page](https://github.com/dart-lang/sdk/wiki/Building). |
| |
| ### Strong Mode |
| |
| * New feature - an option to disable implicit casts |
| (SDK issue [26583](https://github.com/dart-lang/sdk/issues/26583)), |
| see the [documentation](https://github.com/dart-lang/dev_compiler/blob/master/doc/STATIC_SAFETY.md#disable-implicit-casts) |
| for usage instructions and examples. |
| |
| * New feature - an option to disable implicit dynamic |
| (SDK issue [25573](https://github.com/dart-lang/sdk/issues/25573)), |
| see the [documentation](https://github.com/dart-lang/dev_compiler/blob/master/doc/STATIC_SAFETY.md#disable-implicit-dynamic) |
| for usage instructions and examples. |
| |
| * Breaking change - infer generic type arguments from the |
| constructor invocation arguments |
| (SDK issue [25220](https://github.com/dart-lang/sdk/issues/25220)). |
| |
| ```dart |
| var map = new Map<String, String>(); |
| |
| // infer: Map<String, String> |
| var otherMap = new Map.from(map); |
| ``` |
| |
| * Breaking change - infer local function return type |
| (SDK issue [26414](https://github.com/dart-lang/sdk/issues/26414)). |
| |
| ```dart |
| void main() { |
| // infer: return type is int |
| f() { return 40; } |
| int y = f() + 2; // type checks |
| print(y); |
| } |
| ``` |
| |
| * Breaking change - allow type promotion from a generic type parameter |
| (SDK issue [26414](https://github.com/dart-lang/sdk/issues/26965)). |
| |
| ```dart |
| void fn/*<T>*/(/*=T*/ object) { |
| if (object is String) { |
| // Treat `object` as `String` inside this block. |
| // But it will require a cast to pass it to something that expects `T`. |
| print(object.substring(1)); |
|