Paul Berry
9a472930e5
The following shared getters are renamed so that their names are distinct from the corresponding getters in the analyzer: - `SharedFunctionTypeStructure.positionalParameterTypes` is renamed to `positionalParameterTypesShared` to be distinct from the analyzer's public getter `FunctionType.positionalParameterTypes`.* - `SharedFunctionTypeStructure.returnType` is renamed to `returnTypeShared` to be distinct from the analyzer's public getter `FunctionType.returnType`. - `SharedNamedFunctionParameterStructure.type` is renamed to `typeShared` to be distinct from the analyzer's public getter `FormalParameterElement.type`. - `SharedNamedTypeStructure.type` is renamed to `typeShared` to be distinct from the analyzer's public getter `RecordTypeNamedField.type`. - `SharedRecordTypeStructure.positionalTypes` is renamed to `positionalTypesShared` to be distinct from the analyzer's public getter `RecordType.positionalTypes`.* - `SharedRecordTypeStructure.sortedNamedTypes` is renamed to `sortedNamedTypesShared` to be distinct from the analyzer's public getter `RecordType.sortedNamedTypes`. - `SharedTypeParameterStructure.bound` is renamed to `boundShared` to be distinct from the analyzer's public getter `TypeParameterElement2.bound`. *Note that `FunctionType.positionalParameterTypes`, `RecordType.positionalTypes`, and `RecordType.sortedNamedTypes` were unintentionally exposed as part of the analyzer's public API. In a previous CL I marked them as deprecated. These renames pave the way for changing the analyzer's `DartType` class so that it implements `SharedTypeStructure<TypeImpl>` rather than `SharedTypeStructure<DartType>` (without the renames, the public getters mentioned above would all have to be changed to have type `TypeImpl`, and that in turn would expose `TypeImpl` through the analyzer public API, which we don't want to do). Once `DartType` implements `SharedTypeStructure<TypeImpl>`, that will allow all the other uses of `SharedTypeStructure<DartType>` in the analyzer to be gradually migrated to `SharedTypeStructure<TypeImpl>`. Once that is done, `DartType` can be changed so that it no longer implements `SharedTypeStructure<TypeImpl>` at all (`TypeImpl` will implement `SharedTypeStructure<TypeImpl> instead). This will free us up to make future changes to the `SharedTypeStructure` base class without inadvertently exposing those changes through the analyzer public API. This is part of a larger arc of work to change the analyzer's use of the shared code so that the type parameters it supplies are not part of the analyzer public API. See https://github.com/dart-lang/sdk/issues/59763. Change-Id: I0686fdeae304f8948484516f0249841b79e7da6c Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/403625 Reviewed-by: Chloe Stefantsova <cstefantsova@google.com> Reviewed-by: Konstantin Shcheglov <scheglov@google.com> Commit-Queue: Paul Berry <paulberry@google.com>
Dart Kernel
Dart Kernel is a small high-level language derived from Dart. It is designed for use as an intermediate format for whole-program analysis and transformations, and to be consumed by codegen and execution backends.
The kernel language has an in-memory representation in Dart and can be serialized as binary or text.
Both the kernel language and its implementations are unstable and are under development.
This package contains the Dart part of the implementation and contains:
- A transformable IR for the kernel language
- Serialization of kernel code
Note: The APIs in this package are in an early state; developers should be careful about depending on this package. In particular, there is no semver contract for release versions of this package. Please depend directly on individual versions.
See ast.dart for the in-memory IR, or binary.md for a description of the binary format. For now, the textual format is very ad-hoc and cannot be parsed back in.