renovate[bot]
commented
10 months ago âš Artifact update problem
Renovate failed to update an artifact related to this branch. You probably do not want to merge this PR as-is.
â™» Renovate will retry this branch, including artifacts, only when one of the following happens:
- any of the package files in this branch needs updating, or
- the branch becomes conflicted, or
- you click the rebase/retry checkbox if found above, or
- you rename this PR's title to start with "rebase!" to trigger it manually
The artifact failure details are included below:
File name: pubspec.lock
Command failed: flutter pub get --no-precompile
pubspec.yaml has no lower-bound SDK constraint.
You should edit pubspec.yaml to contain an SDK constraint:
environment:
sdk: '^3.2.0'
See https://dart.dev/go/sdk-constraint
This PR contains the following updates:
>=2.12.0 <3.0.0-><4.0.0Release Notes
dart-lang/sdk (dart)
### [`v3.3.0`](https://togithub.com/dart-lang/sdk/blob/HEAD/CHANGELOG.md#330) [Compare Source](https://togithub.com/dart-lang/sdk/compare/3.2.6...3.3.0) ##### Language Dart 3.3 adds [extension types] to the language. To use them, set your package's \[SDK constraint]\[language version] lower bound to 3.3 or greater (`sdk: '^3.3.0'`). ##### Extension types [extension types]: https://togithub.com/dart-lang/language/issues/2727 An *extension type* wraps an existing type with a different, static-only interface. It works in a way which is in many ways similar to a class that contains a single final instance variable holding the wrapped object, but without the space and time overhead of an actual wrapper object. Extension types are introduced by *extension type declarations*. Each such declaration declares a new named type (not just a new name for the same type). It declares a *representation variable* whose type is the *representation type*. The effect of using an extension type is that the *representation* (that is, the value of the representation variable) has the members declared by the extension type rather than the members declared by its "own" type (the representation type). Example: ```dart extension type Meters(int value) { String get label => '${value}m'; Meters operator +(Meters other) => Meters(value + other.value); } void main() { var m = Meters(42); // Has type `Meters`. var m2 = m + m; // OK, type `Meters`. // int i = m; // Compile-time error, wrong type. // m.isEven; // Compile-time error, no such member. assert(identical(m, m.value)); // Succeeds. } ``` The declaration `Meters` is an extension type that has representation type `int`. It introduces an implicit constructor `Meters(int value);` and a getter `int get value`. `m` and `m.value` is the very same object, but `m` has type `Meters` and `m.value` has type `int`. The point is that `m` has the members of `Meters` and `m.value` has the members of `int`. Extension types are entirely static, they do not exist at run time. If `o` is the value of an expression whose static type is an extension type `E` with representation type `R`, then `o` is just a normal object whose run-time type is a subtype of `R`, exactly like the value of an expression of type `R`. Also the run-time value of `E` is `R` (for example, `E == R` is true). In short: At run time, an extension type is erased to the corresponding representation type. A method call on an expression of an extension type is resolved at compile-time, based on the static type of the receiver, similar to how extension method calls work. There is no virtual or dynamic dispatch. This, combined with no memory overhead, means that extension types are zero-cost wrappers around their representation value. While there is thus no performance cost to using extension types, there is a safety cost. Since extension types are erased at compile time, run-time type tests on values that are statically typed as an extension type will check the type of the representation object instead, and if the type check looks like it tests for an extension type, like `is Meters`, it actually checks for the representation type, that is, it works exactly like `is int` at run time. Moreover, as mentioned above, if an extension type is used as a type argument to a generic class or function, the type variable will be bound to the representation type at run time. For example: ```dart void main() { var meters = Meters(3); // At run time, `Meters` is just `int`. print(meters is int); // Prints "true". print(Configuration
📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).
🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.
â™» Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.
🔕 Ignore: Close this PR and you won't be reminded about this update again.
This PR has been generated by Mend Renovate. View repository job log here.