636232628b
This reimplements dynamic call code generation to add support for type checking, named parameters (optional and required), and fixes a few related bugs on the way. Currently we do not try to be as efficient as possible. The goal with this patch is to implement it correctly. Summary of the changes: - For every dynamic access kind and member name, we generate a new "forwarder" function. Dynamic gets, sets, and invocations are compiled to calls to the forwarders with the right access kind (invocation, get, set) and member name. For example, if the program has dynamic invocation of a member "f", we create an "invocation forwarder for f". If it has a dynamic get of a member "x", we generate "getter forwarder for x". - Forwarder functions take 4 arguments: - Receiver of the invocation, get, or set. - A Dart list for type arguments in the invocation. For gets and sets the list is empty. - A Dart list for positional arguments in the invocation. For gets the list is empty. For sets, the list only has one element. - A Dart list for named arguments. For gets and sets the list is empty. The list has alternating elements of type `Symbol` and `Object?`, for the name and value of the named parameters. - A forwarder function compares receiver class ID with the potential targets of the call. When it finds a match, it compares the callee "shape" with the parameters passed in the call site. As it compares the shapes it adjusts argument lists: - Creates default values for missing optional positional and named arguments - Reorders the named argument list to match order expected by the callee If it can't find a matching class ID and a member with the right name and shape, it calls `noSuchMethod` on the receiver. If it finds a matching class ID and a member, it calls the "type checker" for the member, passing the original receiver and adjusted argument lists. - A "type checker" implements argument type checking for a member, and it's a member of the same class as the member it's checking types for. This is to allow accessing class-bound type parameters when generating type checking code. - Type checking is implemented using `_isSubtype` on arguments in the lists. - When type checking is successful a type checker calls the original member, passing the arguments as expected by the member. If type checking is unsuccessful it throws a type error. Most of the changes are for generating Wasm functions that compare shapes, adjusts argument lists, and checks types. Changes to members: - `Translator.dynamics` fields is renamed to `Translator.dynamicForwarders` - New field `Translator.dynamicForwarderFunctionType` added for the Wasm function type of forwarder and type checker functions. - Two new code gen utilities added: - `Translator.indexList`: generates code that indexes a Dart list - `Translator.getListLength`: generates code that gets length of a Dart list - New `Reference` extensions added to get type checker function references of members - New runtime library `named_parameters` implements two helper functions for dealing with named argument lists - The library `dynamic_dispatch` is replaced by `dynamic_forwarders`, which consists of two classes: - `DynamicForwarders`: maintains mapping from call kind (get, set, invocation) and member name to forwarder functions. - `Forwarder`: a single forwarder, implements code generation for forwarder functions. - `CodeGenerator` gets 3 new members: - `_callForwader` generates call to a forwarder - `_generateFieldSetterTypeCheckerMethod` generates code for a type checker of a setter function. - `_generateProcedureTypeCheckerMethod` generates code for a type checker of a method. Fixes #50367 Change-Id: I2b9d84237c8517bd217166d8acb67e025f0498fb Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/272261 Reviewed-by: Joshua Litt <joshualitt@google.com> Commit-Queue: Ömer Ağacan <omersa@google.com> Reviewed-by: Aske Simon Christensen <askesc@google.com> |
||
---|---|---|
.dart_tool | ||
.github | ||
benchmarks | ||
build | ||
docs | ||
pkg | ||
runtime | ||
samples | ||
sdk | ||
tests | ||
third_party | ||
tools | ||
utils | ||
.clang-format | ||
.gitattributes | ||
.gitconfig | ||
.gitignore | ||
.gn | ||
.mailmap | ||
.style.yapf | ||
.vpython | ||
AUTHORS | ||
BUILD.gn | ||
CHANGELOG.md | ||
codereview.settings | ||
CONTRIBUTING.md | ||
DEPS | ||
LICENSE | ||
OWNERS | ||
PATENT_GRANT | ||
PRESUBMIT.py | ||
README.dart-sdk | ||
README.md | ||
sdk_args.gni | ||
SECURITY.md | ||
WATCHLISTS |
Dart
A client-optimized language for fast apps on any platform
Dart is:
-
Optimized for UI: Develop with a programming language specialized around the needs of user interface creation.
-
Productive: Make changes iteratively: use hot reload to see the result instantly in your running app.
-
Fast on all platforms: Compile to ARM & x64 machine code for mobile, desktop, and backend. Or compile to JavaScript for the web.
Dart's flexible compiler technology lets you run Dart code in different ways, depending on your target platform and goals:
-
Dart Native: For programs targeting devices (mobile, desktop, server, and more), Dart Native includes both a Dart VM with JIT (just-in-time) compilation and an AOT (ahead-of-time) compiler for producing machine code.
-
Dart Web: For programs targeting the web, Dart Web includes both a development time compiler (dartdevc) and a production time compiler (dart2js).
License & patents
Dart is free and open source.
See LICENSE and PATENT_GRANT.
Using Dart
Visit dart.dev to learn more about the language, tools, and to find codelabs.
Browse pub.dev for more packages and libraries contributed by the community and the Dart team.
Our API reference documentation is published at api.dart.dev, based on the stable release. (We also publish docs from our beta and dev channels, as well as from the primary development branch).
Building Dart
If you want to build Dart yourself, here is a guide to getting the source, preparing your machine to build the SDK, and building.
There are more documents on our wiki.
Contributing to Dart
The easiest way to contribute to Dart is to file issues.
You can also contribute patches, as described in Contributing.