Version 2.0.0-dev.24.0
Merge commit '23fe39e89fcaeda926fb0fef1378ef48cad6a558' into dev
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0fd7c1c..204f682 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,10 @@
* Added support for starting `async` functions synchronously. All tools (VM,
dart2js, DDC) have now a flag `--sync-async` to enable this behavior.
Currently this behavior is opt-in. It will become the default.
+* 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.
#### Strong Mode
diff --git a/DEPS b/DEPS
index 79b32bc..9b0a5cc 100644
--- a/DEPS
+++ b/DEPS
@@ -83,7 +83,7 @@
# For more details, see https://github.com/dart-lang/sdk/issues/30164
"dart_style_tag": "@1.0.9", # Please see the note above before updating.
- "dartdoc_tag" : "@v0.15.1",
+ "dartdoc_tag" : "@v0.16.0",
"fixnum_tag": "@0.10.5",
"func_rev": "@25eec48146a58967d75330075ab376b3838b18a8",
"glob_tag": "@1.1.5",
diff --git a/docs/language/Dart.g b/docs/language/Dart.g
index aa70500..827db76 100644
--- a/docs/language/Dart.g
+++ b/docs/language/Dart.g
@@ -802,9 +802,15 @@
postfixExpression
: (assignableExpression postfixOperator) =>
assignableExpression postfixOperator
+ | (typeName typeArguments '.') =>
+ constructorInvocation ((selector) => selector)*
| primary ((selector) => selector)*
;
+constructorInvocation
+ : typeName typeArguments '.' identifier arguments
+ ;
+
postfixOperator
: incrementOperator
;
@@ -834,8 +840,11 @@
: (SUPER unconditionalAssignableSelector
~('<' | '(' | '[' | '.' | '?.')) =>
SUPER unconditionalAssignableSelector
+ | (typeName typeArguments '.' identifier '(') =>
+ constructorInvocation
+ ((assignableSelectorPart) => assignableSelectorPart)+
| (identifier ~('<' | '(' | '[' | '.' | '?.')) => identifier
- | (primary argumentPart* assignableSelector) =>
+ | (primary assignableSelectorPart) =>
primary ((assignableSelectorPart) => assignableSelectorPart)+
| identifier
;
@@ -947,7 +956,8 @@
| breakStatement
| continueStatement
| returnStatement
- | (functionSignature functionBodyPrefix) => localFunctionDeclaration
+ | (metadata functionSignature functionBodyPrefix) =>
+ localFunctionDeclaration
| assertStatement
| (YIELD ~'*') => yieldStatement
| yieldEachStatement
@@ -967,7 +977,7 @@
;
localFunctionDeclaration
- : functionSignature functionBody
+ : metadata functionSignature functionBody
;
ifStatement
diff --git a/docs/language/informal/implicit-creation.md b/docs/language/informal/implicit-creation.md
new file mode 100644
index 0000000..af5069c
--- /dev/null
+++ b/docs/language/informal/implicit-creation.md
@@ -0,0 +1,310 @@
+# Implicit Creation
+
+Author: eernst@.
+
+Version: 0.5 (2018-01-04)
+
+Status: Under implementation.
+
+**This document** is an informal specification of the *implicit creation* feature.
+**The feature** adds support for omitting some occurrences of the reserved words
+`new` and `const` in instance creation expressions.
+
+This feature specification was written with a
+[combined proposal](https://github.com/dart-lang/sdk/blob/master/docs/language/informal/optional-new-const.md)
+as the starting point. That proposal presents optional new and optional const
+together with several other features.
+
+
+## Motivation
+
+In Dart without implicit creation, the reserved word `new` is present in
+almost all expressions whose evaluation invokes a constructor at run time,
+and `const` is present in the corresponding constant expressions. These
+expressions are known as *instance creation expressions*. If `new` or
+`const` is removed from such an instance creation expression, the remaining
+phrase is still syntactically correct in most cases. This feature
+specification updates the grammar to make them all syntactically correct.
+
+With that grammar update, all instance creation expressions can technically
+omit `new` or `const` because tools (compilers, analyzers) are able to
+parse these expressions. The tools are able to recognize that these
+expressions denote instance creations (rather than, say, static function
+invocations), because the part before the arguments is statically known to
+denote a constructor.
+
+For instance, `p.C.foo` may resolve statically to a constructor named `foo` in
+a class `C` imported with prefix `p`. Similarly, `D` may resolve to a class, in
+which case `D(42)` is statically known to be a constructor invocation because
+the other interpretation is statically known to be incorrect (that is, cf.
+section '16.14.3 Unqualified Invocation' in the language specification,
+evaluating `(D)(42)`: `(D)` is an instance of `Type` which is not a function
+type and does not have a method named `call`, so we cannot call `(D)`).
+
+In short, even without the keyword, we can still unambiguously recognize the
+expressions that create objects. In that sense, the keywords are superfluous.
+
+For human readers, however, it may be helpful to document that a particular
+expression will yield a fresh instance, and this is the most common argument why
+`new` should *not* be omitted: It can be good documentation. But Dart already
+allows instance creation expressions to invoke a factory constructor, which is
+not guaranteed to return a newly created object, so Dart developers never had
+any firm local guarantees that any particular expression would yield a fresh
+object. This means that it may very well be justified to have an explicit `new`,
+but it will never be a rigorous guarantee of freshness.
+
+Similarly, it may be important for developers to ensure that certain expressions
+are constant, because of the improved performance and the guaranteed
+canonicalization. This is a compelling argument in favor of making certain
+instance creation expressions constant: It is simply a bug for that same
+expression to have `new` because object identity is an observable
+characteristic, and it may be crucial for performance that the expression is
+constant.
+
+In summary, both `new` and `const` may always be omitted from an instance
+creation expression, but it is useful and reasonable to allow an explicit `new`,
+and it is necessary to allow an explicit `const`. Based on that line of
+reasoning, we've decided to make them optional. It will then be possible for
+developers to make many expressions considerably more concise, and they can
+still enforce the desired semantics as needed.
+
+Obviously, this underscores the importance of the default: When a given instance
+creation expression omits the keyword, should it be `const` or `new`?
+
+**For instance creation expressions we have chosen** to use `const` whenever
+possible, and otherwise `new`.
+
+This implies that `const` is the preferred choice for instance creation. There
+is a danger that `const` is chosen by default in some cases where this is not
+intended by the developer, and the affected software will have bugs which are
+hard to spot. In particular, `e1 == e2` may evaluate to true in cases where it
+would have yielded false with `new` objects.
+
+We consider that danger to be rather small, because `const` can only be chosen
+in cases where the denoted constructor is constant, and with a class with a
+constant constructor it is necessary for developers to treat all accesses to its
+instances in such a way that the software will still work correctly even when
+any given instance was obtained by evaluation of a constant expression. The
+point is that, for such a class, we can never know for sure that any given
+instance is _not_ a constant object.
+
+With composite literals such as lists and maps, a `const` modifier may be
+included in order to make it a constant expression (which will of course fail if
+it contains something which is not a constant expression). In this case the
+presence of `const` may again be crucial, for the same reasons as with an
+instance creation expression, but it may also be crucial that `const` is _not_
+present, because the list or map will be mutated.
+
+**For composite literals we have chosen** to implicitly introduce `const`
+whenever it is required by the context.
+
+The choice to include `const` only when required by context (rather than
+whenever possible) is strictly less aggressive than the approach with instance
+creations. This choice is necessary because there is no way for developers to
+ensure that a literal like `[1, 2]` is mutable, if permitted by the context,
+other than omitting `const`. Furthermore, we expect this choice to be
+convenient in practice, because mutable data structures are used frequently. So
+developers must expect to write an explicit `const` on composite literals now
+and then.
+
+In summary, the implicit creation feature allows for concise construction of
+objects, with a slight preference for constant expressions, and it still allows
+developers to explicitly specify `new` or `const`, whenever needed and whenever
+it is considered to be good documentation.
+
+
+## Syntax
+
+The syntax changes associated with this feature are the following:
+
+```
+postfixExpression ::=
+ assignableExpression postfixOperator |
+ constructorInvocation selector* | // NEW
+ primary selector*
+constructorInvocation ::= // NEW
+ typeName typeArguments '.' identifier arguments
+assignableExpression ::=
+ SUPER unconditionalAssignableSelector |
+ constructorInvocation assignableSelectorPart+ | // NEW
+ identifier |
+ primary assignableSelectorPart+
+assignableSelectorPart ::=
+ argumentPart* assignableSelector
+```
+
+
+## Static analysis
+
+We specify a type directed source code transformation which eliminates the
+feature by expressing the same semantics with different syntax. The static
+analysis proceeds to work on the transformed program.
+
+*This means that the feature is "static semantic sugar". We do not specify the
+dynamic semantics for this feature, because the feature is eliminated in this
+transformation step.*
+
+We need to treat expressions differently in different locations, hence the
+following definition: An expression _e_ is said to *occur in a constant
+context*,
+
+- if _e_ is an element of a constant list literal, or a key or value of
+ an entry of a constant map literal.
+- if _e_ is an actual argument of a constant object expression or of a
+ metadata annotation.
+- if _e_ is the initializing expression of a constant variable declaration.
+- if _e_ is a switch case expression.
+- if _e_ is an immediate subexpression of an expression _e1_ which occurs in
+ a constant context, unless _e1_ is a `throw` expression or a function
+ literal.
+
+*This roughly means that everything which is inside a syntactically
+constant expression is in a constant context. Note that a `const` modifier
+which is introduced by the source code transformation does not create a
+constant context, it is only the explicit occurrences of `const` in the
+program that create a constant context. Also note that a `throw` expression
+is currently not allowed in a constant expression, but extensions affecting
+that status may be considered. A similar situation arises for function
+literals.*
+
+The transformation consists of two steps. In the first step, every literal
+list and literal map _e_ which occurs in a constant context and does not
+have the modifier `const` is replaced by `const` _e_.
+
+We define *new/const insertion* as the following transformation, which will
+be applied to specific parts of the program as specified below:
+
+- if the expression _e_ occurs in a constant context, replace _e_ by
+ `const` _e_,
+- if the expression _e_ does not occur in a constant context, but `const`
+ _e_ is a correct constant expression, replace _e_ by `const` _e_,
+- otherwise replace _e_ by `new` _e_.
+
+*Note that this transformation is applied in a bottom-up order which implies
+that all relevant transformations have already been applied on subexpressions
+of _e_. Also note that this transformation is only applied to syntactic
+constructs where the outcome is a syntactically correct instance creation
+expression. On the other hand, the outcome may have static semantic errors,
+e.g., actual arguments to a constructor invocation may have wrong types
+because that's how the program was written.*
+
+We define *new insertion* as the following transformation, which will be
+applied as specified below:
+
+- replace _e_ by `new` _e_.
+
+*We specify the second step of the transformation as based on a depth-first
+traversal of an abstract syntax tree (AST). This means that the program is
+assumed to be free of syntax errors, and when the current AST is, e.g., a
+`postfixExpression`, the program as a whole has such a structure that the
+current location was parsed as a `postfixExpression`. This is different
+from the situation where we just require that a given subsequence of the
+tokens of the program allows for such a parsing in isolation. For instance,
+an identifier like `x` parses as an `assignableExpression` in isolation,
+but if it occurs in the context `var x = 42;` or `var y = x;` then it will
+not be parsed as an `assignableExpression`, it will be parsed as a plain
+`identifier` which is part of a `declaredIdentifier` in the first case, and
+as a `primary` which is a `postfixExpression`, which is a
+`unaryExpression`, etc., in the second case. In short, we are transforming
+the AST of the program as a whole, not isolated snippets of code.*
+
+*In scientific literature, this kind of transformation is commonly
+specified as an inductive transformation where `[[e1 e2]] = [[e1]] [[e2]]`
+when the language supports a construct of the form `e1 e2`, etc. The reader
+may prefer to view the transformation in that light, and we would then say
+that we have omitted all the congruence rules.*
+
+An expression of one of the following forms must be modified in bottom-up
+order to be or contain a `constantObjectExpression` or `newExpression`
+as described:
+
+With a `postfixExpression` _e_,
+
+- if _e_ is of the form `constructorInvocation selector*`, i.e.,
+ `typeName typeArguments '.' identifier arguments selector*` then perform
+ new/const insertion on the initial `constructorInvocation`.
+- if _e_ is of the form
+ `typeIdentifier arguments` where `typeIdentifier` denotes a class then
+ perform new/const insertion on _e_.
+- if _e_ is of the form
+ `identifier1 '.' identifier2 arguments` where `identifier1` denotes
+ a class and `identifier2` is the name of a named constructor in that class,
+ or `identifier1` denotes a prefix for a library _L_ and `identifier2` denotes
+ a class exported by _L_, perform new/const insertion on _e_.
+- if _e_ is of the form
+ `identifier1 '.' typeIdentifier '.' identifier2 arguments` where
+ `identifier1` denotes a library prefix for a library _L_, `typeIdentifier`
+ denotes a class _C_ exported by _L_, and `identifier2` is the name of a named
+ constructor in _C_, perform new/const insertion on _e_.
+
+For the purposes of describing the transformation on assignable expressions
+we need the following syntactic entity:
+
+```
+assignableExpressionTail ::=
+ arguments assignableSelector assignableSelectorPart*
+```
+
+With an `assignableExpression` _e_,
+
+- if _e_ is of the form
+ `constructorInvocation assignableSelectorPart+`
+ then perform new/const insertion on the initial
+ `constructorInvocation`.
+- if _e_ is of the form
+ `typeIdentifier assignableExpressionTail`
+ where `typeIdentifier` denotes a class then perform new/const insertion on
+ the initial `typeIdentifier arguments`.
+- if _e_ is of the form
+ `typeIdentifier '.' identifier assignableExpressionTail`
+ where `typeIdentifier` denotes a class and `identifier` is the name of
+ a named constructor in that class, or `typeIdentifier` denotes a prefix
+ for a library _L_ and `identifier` denotes a class exported by _L_
+ then perform new/const insertion on the initial
+ `typeIdentifier '.' identifier arguments`.
+- if _e_ is of the form
+ `typeIdentifier1 '.' typeIdentifier2 '.' identifier assignableExpressionTail`
+ Where `typeIdentifier1` denotes a library prefix for a library _L_,
+ `typeIdentifier2` denotes a class _C_ exported by _L_, and `identifier`
+ is the name of a named constructor in _C_ then perform new/const insertion
+ on the initial
+ `typeIdentifier1 '.' typeIdentifier2 '.' identifier arguments`.
+
+*In short, add `const` wherever possible on terms that invoke a
+constructor, and otherwise add `new`. It is easy to verify that each of the
+replacements can be derived from `postfixExpression` via `primary
+selector*` and similarly for `assignableExpression`. Hence, the
+transformation preserves syntactic correctness.*
+
+
+## Dynamic Semantics
+
+There is no dynamic semantics to specify for this feature because it is
+eliminated by code transformation.
+
+
+## Revisions
+
+- 0.5 (2018-01-04) Rewritten to use `const` whenever possible (aka "magic
+ const") and adjusted to specify optional const as well as optional new
+ together, because they are now very closely connected. This document was
+ renamed to 'implicit-creation.md', and the document 'optional-const.md'
+ was deleted.
+
+- 0.4 (2017-10-17) Reverted to use 'immediate subexpression' again, for
+ correctness. Adjusted terminology for consistency. Clarified the semantics
+ of the transformation.
+
+- 0.3 (2017-09-08) Included missing rule for transformation of composite
+ literals (lists and maps). Eliminated the notion of an immediate
+ subexpression, for improved precision.
+
+- 0.2 (2017-07-30) Updated the document to specify the previously missing
+ transformations for `assignableExpression`, and to specify a no-magic
+ approach (where no `const` is introduced except when forced by the
+ syntactic context).
+
+- 0.1 (2017-08-15) Stand-alone informal specification for optional new created,
+ using version 0.8 of the combined proposal
+ [optional-new-const.md](https://github.com/dart-lang/sdk/blob/master/docs/language/informal/optional-new-const.md)
+ as the starting point.
diff --git a/docs/language/informal/optional-const.md b/docs/language/informal/optional-const.md
deleted file mode 100644
index 9b79649..0000000
--- a/docs/language/informal/optional-const.md
+++ /dev/null
@@ -1,191 +0,0 @@
-# Optional const
-
-Author: eernst@.
-
-Version: 0.3 (2017-09-08)
-
-Status: Under implementation.
-
-**This document** is an informal specification of the *optional const* feature.
-**The feature** adds support for omitting the reserved word `const` in list and
-map literals and constant object expressions, in locations where `const` is
-currently required.
-
-This informal specification is built on a
-[combined proposal](https://github.com/dart-lang/sdk/blob/master/docs/language/informal/optional-new-const.md)
-which presents optional const and several other features.
-
-## Motivation
-
-In Dart without optional const, complex constant expressions often contain many
-occurrences of `const` on list and map literals, and on constant object
-expressions. Subexpressions of constant expressions are themselves required to
-be constant expressions, and this means that `const` on a nested list or map
-literal provides no extra information: It is a compile-time error if that
-`const` is omitted. Similarly, it is a compile-time error if a nested constant
-object expression is modified to use `new` rather than `const`. In that
-situation it carries no extra information whether `new` or `const` is used, and
-it is even possible to omit the reserved word entirely. It is also required for
-certain other expressions to be constant, e.g., initializing expressions for
-constant variables.
-
-In all these cases the presence of `const` is required, and hence such a
-`const` may be inferred by compilers and similar tools if it is omitted.
-
-Developers reading the source code are likely to find it easy to understand
-that a required `const` was omitted and is implied, because the reason for
-the requirement is visible in the enclosing syntax: The expression where
-`const` is inferred is a subexpression of an expression with `const` or it
-is used in another situation where a constant value is required, e.g., to
-initialize a constant variable.
-
-In summary, tools do not need the required occurrences of `const`, and they
-are also unimportant for developers. Conversely, omitting required occurrences
-of `const` will sometimes make large expressions substantially more concise
-and readable, and also more convenient to write. Here is an example:
-
-```dart
-const myMap = const {
- "a": const [const C("able"), const C("apple"), const C("axis")],
- "b": const [const C("banana"), const C("bold"), const C("burglary")],
-};
-```
-
-Removing the required occurrences of `const` yields the following:
-
-```dart
-const myMap = {
- "a": [C("able"), C("apple"), C("axis")],
- "b": [C("banana"), C("bold"), C("burglary")],
-};
-```
-
-This proposal specifies that these previously required occurrences of `const`
-can be omitted, and will then be inferred.
-
-For a more detailed discussion and motivation, please consult the
-[combined proposal](https://github.com/dart-lang/sdk/blob/master/docs/language/informal/optional-new-const.md)
-which covers optional const as well as several other proposals. That document
-was the starting point for this informal specification.
-
-## Syntax
-
-In order to support the optional const feature, the Dart grammar is modified as
-follows.
-
-```
-postfixExpression ::=
- assignableExpression postfixOperator |
- constructorInvocation | // NEW
- primary selector*
-constructorInvocation ::= // NEW
- typeName typeArguments '.' identifier arguments
-```
-
-*The grammar only needs to be adjusted for one case, namely invocations of named
-constructors for generic classes. In this case we can derive expressions like
-`const Foo<int>.bar()`, and the corresponding `Foo<int>.bar()` is not derivable
-in the same situations where the variant with `const` can be derived. In other
-words, we must add support for constructs like `Foo<int>.bar()` as part of a
-`postfixExpression`. For all other situations, the variant with `const` becomes
-a construct which is already syntactically correct Dart when the `const` is
-removed. For instance `const C(42)` becomes `C(42)` which is already allowed
-syntactically (it could be a function invocation).*
-
-## Static analysis
-
-We specify a type directed source code transformation which eliminates the
-feature. The static analysis proceeds to work on the transformed program.
-
-*This means that the feature is "sugar", but because of the need to refer
-to types it could be described as static semantic sugar rather than
-syntactic sugar. We do not specify the dynamic semantics for this feature,
-because the feature is eliminated in this transformation step.*
-
-We need to treat expressions differently in different locations, hence the
-following definition: An expression _e_ is said to *occur in a constant
-context*,
-
-- if _e_ is an element of a constant list literal, or a key or value of
- an entry of a constant map literal.
-- if _e_ is an actual argument of a constant object expression or of a
- metadata annotation.
-- if _e_ is the initializing expression of a constant variable declaration.
-- if _e_ is a switch case expression.
-- if _e_ is an immediate subexpression of an expression _e1_ which occurs in
- a constant context, unless _e1_ is a `throw` expression or a function
- literal.
-
-*This roughly means that everything which is inside a syntactically
-constant expression is in a constant context. A `throw` expression is
-currently not allowed in a constant expression, but extensions affecting
-that status may be considered. A similar situation arises for function
-literals.*
-
-*Note that the default value of an optional formal parameter is not a
-constant context. This choice reserves some freedom to modify the
-semantics of default values.*
-
-An expression on one of the following forms must be modified in top-down order
-to be or contain a `constantObjectExpression` as described:
-
-With a `postfixExpression` _e_ occurring in a constant context,
-
-- if _e_ is on the form `constructorInvocation` then replace _e_ by
- `const` _e_.
-- if _e_ is on the form
- `typeIdentifier arguments` where `typeIdentifier` denotes a class then
- replace _e_ by `const` _e_.
-- if _e_ is on the form
- `identifier1 '.' identifier2 arguments` where `identifier1` denotes
- a class and `identifier2` is the name of a named constructor in that
- class, or `identifier1` denotes a prefix for a library _L_ and
- `identifier2` denotes a class exported by _L_, replace _e_ by
- `const` _e_.
-- if _e_ is on the form
- `identifier1 '.' typeIdentifier '.' identifier2 arguments` where
- `identifier1` denotes a library prefix for a library _L_,
- `typeIdentifier` denotes a class _C_ exported by _L_, and `identifier2`
- is the name of a named constructor in _C_, replace _e_ by
- `const` _e_.
-
-For a list literal _e_ occurring in a constant context, replace _e_ by
-`const` _e_. For a map literal _e_ occurring in a constant context,
-replace _e_ by `const` _e_.
-
-*In short, in these specific situations: "just add `const`". It is easy to
-verify that each of the replacements can be derived from
-`constObjectExpression`, which can be derived from `postfixExpression` via
-`primary selector*`. Hence, the transformation preserves syntactic
-correctness.*
-
-The remaining static analysis proceeds to work on the transformed program.
-
-*It is possible that this transformation will create
-`constObjectExpressions` which violate the constraints on constant object
-expressions, e.g., when `const [[new A()]]` is transformed to
-`const [const [new A()]]` where the inner list is an error that was created
-by the transformation (so the error was moved from the outer to the inner
-list). It is recommended that the error messages emitted by tools in response
-to such violations include information about the transformation.*
-
-## Dynamic Semantics
-
-There is no dynamic semantics to specify for this feature because it is
-eliminated by code transformation.
-
-
-## Revisions
-
-- 0.3 (2017-09-08) Eliminated the notion of an immediate subexpression,
- for improved precision.
-
-- 0.2 (2017-08-30) Updated the document to specify the previously missing
- transformations for composite literals (lists and maps), and to specify a
- no-magic approach (where no `const` is introduced except when forced by
- the syntactic context).
-
-- 0.1 (2017-08-10) Stand-alone informal specification for optional const
- created, using version 0.8 of the combined proposal
- [optional-new-const.md](https://github.com/dart-lang/sdk/blob/master/docs/language/informal/optional-new-const.md)
- as the starting point.
diff --git a/docs/language/informal/optional-new.md b/docs/language/informal/optional-new.md
deleted file mode 100644
index 139f866..0000000
--- a/docs/language/informal/optional-new.md
+++ /dev/null
@@ -1,244 +0,0 @@
-# Optional new
-
-Author: eernst@.
-
-Version: 0.4 (2017-10-17)
-
-Status: Under implementation.
-
-**This document** is an informal specification of the *optional new* feature.
-**The feature** adds support for omitting the reserved word `new` in instance
-creation expressions.
-
-This feature extends and includes the
-[optional const feature](https://github.com/dart-lang/sdk/blob/master/docs/language/informal/optional-const.md),
-and it is assumed that the reader knows about optional const. Beyond
-that, this informal specification is derived from a
-[combined proposal](https://github.com/dart-lang/sdk/blob/master/docs/language/informal/optional-new-const.md)
-which presents optional new together with several other features.
-
-
-## Motivation
-
-In Dart without optional new, the reserved word `new` is present in every
-expression whose evaluation invokes a constructor (except constant
-expressions). These expressions are known as *instance creation expressions*. If
-`new` is removed from such an instance creation expression, the remaining phrase
-is still syntactically correct in almost all cases. The required grammar
-update that makes them all syntactically correct is a superset of the one that
-is specified for
-[optional const](https://github.com/dart-lang/sdk/blob/master/docs/language/informal/optional-const.md).
-
-With that grammar update, all instance creation expressions can technically
-omit the `new` because tools (compilers, analyzers) are able to parse these
-expressions, and they are able to recognize that they denote instance creations
-(rather than, say, static function invocations), because the part before the
-left parenthesis is statically known to denote a constructor.
-
-For instance, `p.C.foo` may resolve statically to a constructor named `foo` in
-a class `C` imported with prefix `p`. Similarly, `D` may resolve to a class, in
-which case `D(42)` is statically known to be a constructor invocation because
-the other interpretation is statically known to be incorrect (that is, cf.
-section '16.14.3 Unqualified Invocation' in the language specification,
-evaluating `(D)(42)`: `(D)` is an instance of `Type` which is not a function
-type and does not have a method named `call`).
-
-For human readers, it may be helpful to document that a particular expression
-is guaranteed to yield a fresh instance, and this is the most common argument
-why `new` should *not* be omitted. However, Dart already allows instance
-creation expressions to invoke a factory constructor, so Dart developers never
-had any firm local guarantees that any particular expression would yield a
-fresh object.
-
-Developers may thus prefer to omit `new` in order to obtain more concise code,
-and possibly also in order to achieve greater uniformity among invocations of
-constructors and other invocations, e.g., of static or global functions.
-
-With that in mind, this proposal allows instance creation expressions to omit
-the `new` in all cases, but also preserves the permission to include `new` in
-all cases. It is a matter of style to use `new` in a manner that developers
-find helpful.
-
-
-## Syntax
-
-The syntax changes associated with this feature are the following:
-
-```
-postfixExpression ::=
- assignableExpression postfixOperator |
- constructorInvocation | // NEW
- primary selector*
-constructorInvocation ::= // NEW
- typeName typeArguments '.' identifier arguments
-assignableExpression ::=
- SUPER unconditionalAssignableSelector |
- constructorInvocation (arguments* assignableSelector)+ | // NEW
- identifier |
- primary (arguments* assignableSelector)+
-```
-
-*As mentioned, this grammar update is a superset of the grammar update for
-[optional const](https://github.com/dart-lang/sdk/blob/master/docs/language/informal/optional-const.md).*
-
-
-## Static analysis
-
-We specify a type directed source code transformation which eliminates the
-feature by expressing the same semantics with different syntax. The static
-analysis proceeds to work on the transformed program.
-
-*Similarly to optional const, this means that the feature is "static semantic
-sugar". We do not specify the dynamic semantics for this feature, because the
-feature is eliminated in this transformation step.*
-
-We need to treat expressions differently in different locations, hence the
-following definition, which is identical to the one in
-[optional const](https://github.com/dart-lang/sdk/blob/master/docs/language/informal/optional-const.md):
-
-An expression _e_ is said to *occur in a constant context*,
-
-- if _e_ is an element of a constant list literal, or a key or value of
- an entry of a constant map literal.
-- if _e_ is an actual argument of a constant object expression or of a
- metadata annotation.
-- if _e_ is the initializing expression of a constant variable declaration.
-- if _e_ is a switch case expression.
-- if _e_ is an immediate subexpression of an expression _e1_ which occurs in
- a constant context, unless _e1_ is a `throw` expression or a function
- literal.
-
-*This roughly means that everything which is inside a syntactically
-constant expression is in a constant context. A `throw` expression is
-currently not allowed in a constant expression, but extensions affecting
-that status may be considered. A similar situation arises for function
-literals.*
-
-We define *new/const insertion* as the following transformation:
-
-- if the expression _e_ occurs in a constant context, replace _e_ by
- `const` _e_,
-- otherwise replace _e_ by `new` _e_.
-
-We define *new insertion* as the following transformation:
-
-- replace _e_ by `new` _e_.
-
-For the purposes of describing the main transformation we need the following
-syntactic entity:
-
-```
-assignableExpressionTail ::=
- arguments assignableSelector (arguments* assignableSelector)*
-```
-
-*We specify the transformation as based on a top-down traversal of an
-abstract syntax tree (AST). This means that the program is assumed to be
-free of syntax errors, and when the current AST is, e.g., a
-`postfixExpression`, the program as a whole has such a structure that
-the current location was parsed as a `postfixExpression`. This is
-different from the situation where we just require a given subsequence of the
-tokens of the program allows for such a parsing in isolation. For instance,
-an identifier like `x` parses as an `assignableExpression` in isolation,
-but if it occurs in the context `var x = 42;` or `var y = x;` then it
-will not be parsed as an `assignableExpression`, it will be parsed as a
-plain `identifier` which is part of a `declaredIdentifier` in the first
-case, and as a `primary` which is a `postfixExpression`, which is a
-`unaryExpression`, etc., in the second case. In short, we are
-transforming the AST of the program as a whole, not isolated snippets of
-code.*
-
-An expression of one of the following forms must be modified in top-down
-order to be or contain a `constantObjectExpression` or `newExpression`
-as described:
-
-With a `postfixExpression` _e_,
-
-- if _e_ is of the form `constructorInvocation`, i.e.,
- `typeName typeArguments '.' identifier arguments` then perform
- new/const insertion on _e_.
-- if _e_ is of the form
- `typeIdentifier arguments` where `typeIdentifier` denotes a class then
- perform new/const insertion on _e_.
-- if _e_ is of the form
- `identifier1 '.' identifier2 arguments` where `identifier1` denotes
- a class and `identifier2` is the name of a named constructor in that class,
- or `identifier1` denotes a prefix for a library _L_ and `identifier2` denotes
- a class exported by _L_, perform new/const insertion on _e_.
-- if _e_ is of the form
- `identifier1 '.' typeIdentifier '.' identifier2 arguments` where
- `identifier1` denotes a library prefix for a library _L_, `typeIdentifier`
- denotes a class _C_ exported by _L_, and `identifier2` is the name of a named
- constructor in _C_, perform new/const insertion on _e_.
-
-With an `assignableExpression` _e_,
-
-- if _e_ is of the form
- `constructorInvocation assignableExpressionTail`
- then perform new insertion on the initial
- `constructorInvocation arguments`.
-- if _e_ is of the form
- `typeIdentifier assignableExpressionTail`
- where `typeIdentifier` denotes a class then perform new insertion on the
- initial `typeIdentifier arguments`.
-- if _e_ is of the form
- `identifier1 '.' identifier2 assignableExpressionTail`
- where `identifier1` denotes a class and `identifier2` is the name of
- a named constructor in that class, or `identifier1` denotes a prefix
- for a library _L_ and `identifier2` denotes a class exported by _L_
- then perform new insertion on the initial
- `identifier1 '.' identifier2 arguments`.
-- if _e_ is of the form
- `identifier1 '.' typeIdentifier '.' identifier2 assignableExpressionTail`
- where `identifier1` denotes a library prefix for a library _L_,
- `typeIdentifier` denotes a class _C_ exported by _L_, and `identifier2`
- is the name of a named constructor in _C_ then perform new insertion
- on the initial
- `identifier1 '.' typeIdentifier '.' identifier2 arguments`.
-
-For a list literal _e_ occurring in a constant context, replace _e_ by
-`const` _e_. For a map literal _e_ occurring in a constant context,
-replace _e_ by `const` _e_.
-
-*In short, add `const` in const contexts and otherwise add `new`. With
-`assignableExpression` we always add `new`, because such an expression
-can never be a subexpression of a correct constant expression. It is easy
-to verify that each of the replacements can be derived from
-`postfixExpression` via `primary selector*` and similarly for
-`assignableExpression`. Hence, the transformation preserves syntactic
-correctness.*
-
-
-## Dynamic Semantics
-
-There is no dynamic semantics to specify for this feature because it is
-eliminated by code transformation.
-
-
-## Interplay with optional const
-
-This informal specification includes optional const as well as optional new,
-that is, if this specification is implemented then
-[optional const](https://github.com/dart-lang/sdk/blob/master/docs/language/informal/optional-const.md)
-may be considered as background material.
-
-
-## Revisions
-
-- 0.4 (2017-10-17) Reverted to use 'immediate subexpression' again, for
- correctness. Adjusted terminology for consistency. Clarified the semantics
- of the transformation.
-
-- 0.3 (2017-09-08) Included missing rule for transformation of composite
- literals (lists and maps). Eliminated the notion of an immediate
- subexpression, for improved precision.
-
-- 0.2 (2017-07-30) Updated the document to specify the previously missing
- transformations for `assignableExpression`, and to specify a no-magic
- approach (where no `const` is introduced except when forced by the
- syntactic context).
-
-- 0.1 (2017-08-15) Stand-alone informal specification for optional new created,
- using version 0.8 of the combined proposal
- [optional-new-const.md](https://github.com/dart-lang/sdk/blob/master/docs/language/informal/optional-new-const.md)
- as the starting point.
diff --git a/pkg/analysis_server/doc/api.html b/pkg/analysis_server/doc/api.html
index 40612c7..a459c82 100644
--- a/pkg/analysis_server/doc/api.html
+++ b/pkg/analysis_server/doc/api.html
@@ -2808,6 +2808,13 @@
additionally insert a template for the parameters. The information
required in order to do so is contained in other fields.
</p>
+ </dd><dt class="field"><b>displayText: String<span style="color:#999999"> (optional)</span></b></dt><dd>
+
+ <p>
+ Text to be displayed in, for example, a completion pop-up. This field
+ is only defined if the displayed text should be different than the
+ completion. Otherwise it is omitted.
+ </p>
</dd><dt class="field"><b>selectionOffset: int</b></dt><dd>
<p>
@@ -2834,7 +2841,7 @@
<p>
An abbreviated version of the Dartdoc associated with the element
- being suggested, This field is omitted if there is no Dartdoc
+ being suggested. This field is omitted if there is no Dartdoc
associated with the element.
</p>
</dd><dt class="field"><b>docComplete: String<span style="color:#999999"> (optional)</span></b></dt><dd>
@@ -2968,7 +2975,12 @@
suggestions of this kind, the completion is the named argument
identifier including a trailing ':' and a space.
</p>
- </dd><dt class="value">OPTIONAL_ARGUMENT</dt><dt class="value">PARAMETER</dt></dl></dd><dt class="typeDefinition"><a name="type_ContextData">ContextData: object</a></dt><dd>
+ </dd><dt class="value">OPTIONAL_ARGUMENT</dt><dt class="value">OVERRIDE</dt><dd>
+
+ <p>
+ An overriding implementation of a class member is being suggested.
+ </p>
+ </dd><dt class="value">PARAMETER</dt></dl></dd><dt class="typeDefinition"><a name="type_ContextData">ContextData: object</a></dt><dd>
<p>
Information about an analysis context.
</p>
diff --git a/pkg/analysis_server/lib/src/analysis_server.dart b/pkg/analysis_server/lib/src/analysis_server.dart
index de63821..43aab94 100644
--- a/pkg/analysis_server/lib/src/analysis_server.dart
+++ b/pkg/analysis_server/lib/src/analysis_server.dart
@@ -372,6 +372,7 @@
defaultContextOptions.generateImplicitErrors = false;
defaultContextOptions.useFastaParser = options.useCFE;
+ defaultContextOptions.previewDart2 = options.previewDart2;
{
String name = options.newAnalysisDriverLog;
diff --git a/pkg/analysis_server/lib/src/services/completion/dart/keyword_contributor.dart b/pkg/analysis_server/lib/src/services/completion/dart/keyword_contributor.dart
index 6e50eb5..5442592 100644
--- a/pkg/analysis_server/lib/src/services/completion/dart/keyword_contributor.dart
+++ b/pkg/analysis_server/lib/src/services/completion/dart/keyword_contributor.dart
@@ -14,8 +14,8 @@
import 'package:analyzer_plugin/src/utilities/completion/optype.dart';
const ASYNC_STAR = 'async*';
-const DEFERRED_AS = 'deferred as';
const DEFAULT_COLON = 'default:';
+const DEFERRED_AS = 'deferred as';
const EXPORT_STATEMENT = "export '';";
const IMPORT_STATEMENT = "import '';";
const PART_STATEMENT = "part '';";
@@ -31,6 +31,12 @@
Future<List<CompletionSuggestion>> computeSuggestions(
DartCompletionRequest request) async {
List<CompletionSuggestion> suggestions = <CompletionSuggestion>[];
+
+ // Don't suggest anything right after double or integer literals.
+ if (request.target.isDoubleOrIntLiteral()) {
+ return suggestions;
+ }
+
request.target.containingNode
.accept(new _KeywordVisitor(request, suggestions));
return suggestions;
@@ -220,8 +226,14 @@
@override
visitConstructorDeclaration(ConstructorDeclaration node) {
- if (node.initializers.isNotEmpty && node.initializers.last == entity) {
- _addSuggestion(Keyword.SUPER);
+ if (node.initializers.isNotEmpty) {
+ if (entity is ConstructorInitializer) {
+ _addSuggestion(Keyword.ASSERT);
+ }
+ if (node.initializers.last == entity) {
+ _addSuggestion(Keyword.SUPER);
+ _addSuggestion(Keyword.THIS);
+ }
}
}
@@ -347,23 +359,6 @@
}
@override
- visitParenthesizedExpression(ParenthesizedExpression node) {
- Expression expression = node.expression;
- if (expression is Identifier || expression is PropertyAccess) {
- if (entity == node.rightParenthesis) {
- var next = expression.endToken.next;
- if (next == entity || next == droppedToken) {
- // Fasta parses `if (x i^)` as `if (x ^) where the `i` is in the token
- // stream but not part of the ParenthesizedExpression.
- _addSuggestion(Keyword.IS, DART_RELEVANCE_HIGH);
- return;
- }
- }
- }
- _addExpressionKeywords(node);
- }
-
- @override
visitIfStatement(IfStatement node) {
if (_isPreviousTokenSynthetic(entity, TokenType.CLOSE_PAREN)) {
// Actual: if (x i^)
@@ -456,6 +451,23 @@
}
@override
+ visitParenthesizedExpression(ParenthesizedExpression node) {
+ Expression expression = node.expression;
+ if (expression is Identifier || expression is PropertyAccess) {
+ if (entity == node.rightParenthesis) {
+ var next = expression.endToken.next;
+ if (next == entity || next == droppedToken) {
+ // Fasta parses `if (x i^)` as `if (x ^) where the `i` is in the token
+ // stream but not part of the ParenthesizedExpression.
+ _addSuggestion(Keyword.IS, DART_RELEVANCE_HIGH);
+ return;
+ }
+ }
+ }
+ _addExpressionKeywords(node);
+ }
+
+ @override
visitPrefixedIdentifier(PrefixedIdentifier node) {
if (entity != node.identifier) {
_addExpressionKeywords(node);
diff --git a/pkg/analysis_server/lib/src/services/completion/dart/override_contributor.dart b/pkg/analysis_server/lib/src/services/completion/dart/override_contributor.dart
index bce108a..4f58799 100644
--- a/pkg/analysis_server/lib/src/services/completion/dart/override_contributor.dart
+++ b/pkg/analysis_server/lib/src/services/completion/dart/override_contributor.dart
@@ -63,13 +63,17 @@
* Return a template for an override of the given [element]. If selected, the
* template will replace [targetId].
*/
- Future<String> _buildReplacementText(AnalysisResult result,
- SimpleIdentifier targetId, ExecutableElement element) async {
+ Future<String> _buildReplacementText(
+ AnalysisResult result,
+ SimpleIdentifier targetId,
+ ExecutableElement element,
+ StringBuffer displayTextBuffer) async {
DartChangeBuilder builder =
new DartChangeBuilder(result.driver.currentSession);
await builder.addFileEdit(result.path, (DartFileEditBuilder builder) {
builder.addReplacement(range.node(targetId), (DartEditBuilder builder) {
- builder.writeOverrideOfInheritedMember(element);
+ builder.writeOverrideOfInheritedMember(element,
+ displayTextBuffer: displayTextBuffer);
});
});
return builder.sourceChange.edits[0].edits[0].replacement.trim();
@@ -81,11 +85,14 @@
*/
Future<CompletionSuggestion> _buildSuggestion(DartCompletionRequest request,
SimpleIdentifier targetId, ExecutableElement element) async {
- String completion =
- await _buildReplacementText(request.result, targetId, element);
+ StringBuffer displayTextBuffer = new StringBuffer();
+ String completion = await _buildReplacementText(
+ request.result, targetId, element, displayTextBuffer);
if (completion == null || completion.length == 0) {
return null;
}
+ String displayText =
+ displayTextBuffer.isNotEmpty ? displayTextBuffer.toString() : null;
CompletionSuggestion suggestion = new CompletionSuggestion(
CompletionSuggestionKind.OVERRIDE,
DART_RELEVANCE_HIGH,
@@ -93,7 +100,8 @@
targetId.offset,
0,
element.isDeprecated,
- false);
+ false,
+ displayText: displayText);
suggestion.element = protocol.convertElement(element);
return suggestion;
}
diff --git a/pkg/analysis_server/lib/src/services/correction/fix_internal.dart b/pkg/analysis_server/lib/src/services/correction/fix_internal.dart
index d983f08..b880b53 100644
--- a/pkg/analysis_server/lib/src/services/correction/fix_internal.dart
+++ b/pkg/analysis_server/lib/src/services/correction/fix_internal.dart
@@ -1466,7 +1466,9 @@
}
Future<Null> _addFix_createMissingOverrides() async {
- // prepare target
+ if (node.parent is! ClassDeclaration) {
+ return;
+ }
ClassDeclaration targetClass = node.parent as ClassDeclaration;
ClassElement targetClassElement = targetClass.element;
utils.targetClassElement = targetClassElement;
@@ -1613,6 +1615,9 @@
}
Future<Null> _addFix_createNoSuchMethod() async {
+ if (node.parent is! ClassDeclaration) {
+ return;
+ }
ClassDeclaration targetClass = node.parent as ClassDeclaration;
// prepare environment
String prefix = utils.getIndent(1);
diff --git a/pkg/analysis_server/test/integration/support/protocol_matchers.dart b/pkg/analysis_server/test/integration/support/protocol_matchers.dart
index 7173f6e..91b0f0d 100644
--- a/pkg/analysis_server/test/integration/support/protocol_matchers.dart
+++ b/pkg/analysis_server/test/integration/support/protocol_matchers.dart
@@ -201,6 +201,7 @@
* "kind": CompletionSuggestionKind
* "relevance": int
* "completion": String
+ * "displayText": optional String
* "selectionOffset": int
* "selectionLength": int
* "isDeprecated": bool
@@ -231,6 +232,7 @@
"isDeprecated": isBool,
"isPotential": isBool
}, optionalFields: {
+ "displayText": isString,
"docSummary": isString,
"docComplete": isString,
"declaringType": isString,
@@ -258,6 +260,7 @@
* KEYWORD
* NAMED_ARGUMENT
* OPTIONAL_ARGUMENT
+ * OVERRIDE
* PARAMETER
* }
*/
@@ -270,6 +273,7 @@
"KEYWORD",
"NAMED_ARGUMENT",
"OPTIONAL_ARGUMENT",
+ "OVERRIDE",
"PARAMETER"
]);
diff --git a/pkg/analysis_server/test/mocks.dart b/pkg/analysis_server/test/mocks.dart
index 3a8cfb8..bc58223 100644
--- a/pkg/analysis_server/test/mocks.dart
+++ b/pkg/analysis_server/test/mocks.dart
@@ -157,8 +157,8 @@
Future<Response> waitForResponse(Request request) {
String id = request.id;
- return new Future<Response>(() => responseController.stream
- .firstWhere((response) => response.id == id) as Future<Response>);
+ return responseController.stream
+ .firstWhere((response) => response.id == id);
}
}
diff --git a/pkg/analysis_server/test/services/completion/dart/keyword_contributor_test.dart b/pkg/analysis_server/test/services/completion/dart/keyword_contributor_test.dart
index 425178b..8568c03 100644
--- a/pkg/analysis_server/test/services/completion/dart/keyword_contributor_test.dart
+++ b/pkg/analysis_server/test/services/completion/dart/keyword_contributor_test.dart
@@ -837,6 +837,18 @@
assertSuggestKeywords([]);
}
+ test_constructor_initializers_first() async {
+ addTestSource('class A { int f; A() : ^, f = 1; }');
+ await computeSuggestions();
+ assertSuggestKeywords([Keyword.ASSERT]);
+ }
+
+ test_constructor_initializers_last() async {
+ addTestSource('class A { A() : ^; }');
+ await computeSuggestions();
+ assertSuggestKeywords([Keyword.ASSERT, Keyword.SUPER, Keyword.THIS]);
+ }
+
test_constructor_param() async {
addTestSource('class A { A(^) {});}');
await computeSuggestions();
@@ -1411,6 +1423,18 @@
relevance: DART_RELEVANCE_HIGH);
}
+ test_integerLiteral_inArgumentList() async {
+ addTestSource('main() { print(42^); }');
+ await computeSuggestions();
+ assertSuggestKeywords([]);
+ }
+
+ test_integerLiteral_inListLiteral() async {
+ addTestSource('main() { var items = [42^]; }');
+ await computeSuggestions();
+ assertSuggestKeywords([]);
+ }
+
test_is_expression() async {
addTestSource('main() {if (x is^)}');
await computeSuggestions();
diff --git a/pkg/analysis_server/test/services/correction/fix_test.dart b/pkg/analysis_server/test/services/correction/fix_test.dart
index 1fcab846..fd1701b 100644
--- a/pkg/analysis_server/test/services/correction/fix_test.dart
+++ b/pkg/analysis_server/test/services/correction/fix_test.dart
@@ -3113,7 +3113,20 @@
''');
}
- test_createNoSuchMethod() async {
+ test_createNoSuchMethod_BAD_classTypeAlias() async {
+ await resolveTestUnit('''
+abstract class A {
+ m();
+}
+
+class B = Object with A;
+''');
+ await assertNoFix(
+ DartFixKind.CREATE_NO_SUCH_METHOD,
+ );
+ }
+
+ test_createNoSuchMethod_OK() async {
await resolveTestUnit('''
abstract class A {
m1();
diff --git a/pkg/analysis_server/tool/spec/generated/java/types/CompletionSuggestion.java b/pkg/analysis_server/tool/spec/generated/java/types/CompletionSuggestion.java
index 7a8ebc3..582d655 100644
--- a/pkg/analysis_server/tool/spec/generated/java/types/CompletionSuggestion.java
+++ b/pkg/analysis_server/tool/spec/generated/java/types/CompletionSuggestion.java
@@ -54,6 +54,12 @@
private final String completion;
/**
+ * Text to be displayed in, for example, a completion pop-up. This field is only defined if the
+ * displayed text should be different than the completion. Otherwise it is omitted.
+ */
+ private final String displayText;
+
+ /**
* The offset, relative to the beginning of the completion, of where the selection should be placed
* after insertion.
*/
@@ -76,7 +82,7 @@
private final boolean isPotential;
/**
- * An abbreviated version of the Dartdoc associated with the element being suggested, This field is
+ * An abbreviated version of the Dartdoc associated with the element being suggested. This field is
* omitted if there is no Dartdoc associated with the element.
*/
private final String docSummary;
@@ -163,10 +169,11 @@
/**
* Constructor for {@link CompletionSuggestion}.
*/
- public CompletionSuggestion(String kind, int relevance, String completion, int selectionOffset, int selectionLength, boolean isDeprecated, boolean isPotential, String docSummary, String docComplete, String declaringType, String defaultArgumentListString, int[] defaultArgumentListTextRanges, Element element, String returnType, List<String> parameterNames, List<String> parameterTypes, Integer requiredParameterCount, Boolean hasNamedParameters, String parameterName, String parameterType, String importUri) {
+ public CompletionSuggestion(String kind, int relevance, String completion, String displayText, int selectionOffset, int selectionLength, boolean isDeprecated, boolean isPotential, String docSummary, String docComplete, String declaringType, String defaultArgumentListString, int[] defaultArgumentListTextRanges, Element element, String returnType, List<String> parameterNames, List<String> parameterTypes, Integer requiredParameterCount, Boolean hasNamedParameters, String parameterName, String parameterType, String importUri) {
this.kind = kind;
this.relevance = relevance;
this.completion = completion;
+ this.displayText = displayText;
this.selectionOffset = selectionOffset;
this.selectionLength = selectionLength;
this.isDeprecated = isDeprecated;
@@ -195,6 +202,7 @@
ObjectUtilities.equals(other.kind, kind) &&
other.relevance == relevance &&
ObjectUtilities.equals(other.completion, completion) &&
+ ObjectUtilities.equals(other.displayText, displayText) &&
other.selectionOffset == selectionOffset &&
other.selectionLength == selectionLength &&
other.isDeprecated == isDeprecated &&
@@ -221,6 +229,7 @@
String kind = jsonObject.get("kind").getAsString();
int relevance = jsonObject.get("relevance").getAsInt();
String completion = jsonObject.get("completion").getAsString();
+ String displayText = jsonObject.get("displayText") == null ? null : jsonObject.get("displayText").getAsString();
int selectionOffset = jsonObject.get("selectionOffset").getAsInt();
int selectionLength = jsonObject.get("selectionLength").getAsInt();
boolean isDeprecated = jsonObject.get("isDeprecated").getAsBoolean();
@@ -239,7 +248,7 @@
String parameterName = jsonObject.get("parameterName") == null ? null : jsonObject.get("parameterName").getAsString();
String parameterType = jsonObject.get("parameterType") == null ? null : jsonObject.get("parameterType").getAsString();
String importUri = jsonObject.get("importUri") == null ? null : jsonObject.get("importUri").getAsString();
- return new CompletionSuggestion(kind, relevance, completion, selectionOffset, selectionLength, isDeprecated, isPotential, docSummary, docComplete, declaringType, defaultArgumentListString, defaultArgumentListTextRanges, element, returnType, parameterNames, parameterTypes, requiredParameterCount, hasNamedParameters, parameterName, parameterType, importUri);
+ return new CompletionSuggestion(kind, relevance, completion, displayText, selectionOffset, selectionLength, isDeprecated, isPotential, docSummary, docComplete, declaringType, defaultArgumentListString, defaultArgumentListTextRanges, element, returnType, parameterNames, parameterTypes, requiredParameterCount, hasNamedParameters, parameterName, parameterType, importUri);
}
public static List<CompletionSuggestion> fromJsonArray(JsonArray jsonArray) {
@@ -290,6 +299,14 @@
}
/**
+ * Text to be displayed in, for example, a completion pop-up. This field is only defined if the
+ * displayed text should be different than the completion. Otherwise it is omitted.
+ */
+ public String getDisplayText() {
+ return displayText;
+ }
+
+ /**
* The Dartdoc associated with the element being suggested. This field is omitted if there is no
* Dartdoc associated with the element.
*/
@@ -298,7 +315,7 @@
}
/**
- * An abbreviated version of the Dartdoc associated with the element being suggested, This field is
+ * An abbreviated version of the Dartdoc associated with the element being suggested. This field is
* omitted if there is no Dartdoc associated with the element.
*/
public String getDocSummary() {
@@ -426,6 +443,7 @@
builder.append(kind);
builder.append(relevance);
builder.append(completion);
+ builder.append(displayText);
builder.append(selectionOffset);
builder.append(selectionLength);
builder.append(isDeprecated);
@@ -452,6 +470,9 @@
jsonObject.addProperty("kind", kind);
jsonObject.addProperty("relevance", relevance);
jsonObject.addProperty("completion", completion);
+ if (displayText != null) {
+ jsonObject.addProperty("displayText", displayText);
+ }
jsonObject.addProperty("selectionOffset", selectionOffset);
jsonObject.addProperty("selectionLength", selectionLength);
jsonObject.addProperty("isDeprecated", isDeprecated);
@@ -523,6 +544,8 @@
builder.append(relevance + ", ");
builder.append("completion=");
builder.append(completion + ", ");
+ builder.append("displayText=");
+ builder.append(displayText + ", ");
builder.append("selectionOffset=");
builder.append(selectionOffset + ", ");
builder.append("selectionLength=");
diff --git a/pkg/analysis_server/tool/spec/generated/java/types/CompletionSuggestionKind.java b/pkg/analysis_server/tool/spec/generated/java/types/CompletionSuggestionKind.java
index 32a42db..84048b8 100644
--- a/pkg/analysis_server/tool/spec/generated/java/types/CompletionSuggestionKind.java
+++ b/pkg/analysis_server/tool/spec/generated/java/types/CompletionSuggestionKind.java
@@ -51,6 +51,11 @@
public static final String OPTIONAL_ARGUMENT = "OPTIONAL_ARGUMENT";
+ /**
+ * An overriding implementation of a class member is being suggested.
+ */
+ public static final String OVERRIDE = "OVERRIDE";
+
public static final String PARAMETER = "PARAMETER";
}
diff --git a/pkg/analyzer/lib/src/error/codes.dart b/pkg/analyzer/lib/src/error/codes.dart
index dcfe176..29e93e1 100644
--- a/pkg/analyzer/lib/src/error/codes.dart
+++ b/pkg/analyzer/lib/src/error/codes.dart
@@ -5046,7 +5046,7 @@
/* TODO(leafp) Delete most of these.
*/
static const StrongModeCode TOP_LEVEL_CYCLE = const StrongModeCode(
- ErrorType.HINT,
+ ErrorType.COMPILE_TIME_ERROR,
'TOP_LEVEL_CYCLE',
"The type of '{0}' can't be inferred because it depends on itself through the cycle: {1}.",
"Try adding an explicit type to one or more of the variables in the cycle in order to break the cycle.");
diff --git a/pkg/analyzer/test/generated/parser_test.dart b/pkg/analyzer/test/generated/parser_test.dart
index dc832df..c0be389 100644
--- a/pkg/analyzer/test/generated/parser_test.dart
+++ b/pkg/analyzer/test/generated/parser_test.dart
@@ -10567,8 +10567,7 @@
ClassMember member = parser.parseClassMember('C');
expectNotNullIfNoErrors(member);
listener.assertErrors([
- expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER,
- usingFastaParser ? 6 : 11, 1)
+ expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 1)
]);
expect(member, new isInstanceOf<ConstructorDeclaration>());
NodeList<ConstructorInitializer> initializers =
@@ -10590,15 +10589,18 @@
createParser('C() : this {}');
ClassMember member = parser.parseClassMember('C');
expectNotNullIfNoErrors(member);
- listener.assertErrors([
- expectedError(ParserErrorCode.EXPECTED_TOKEN, 11, 1),
- expectedError(ParserErrorCode.MISSING_IDENTIFIER, 11, 1),
- usingFastaParser
- ? expectedError(
- ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 4)
- : expectedError(
- ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 11, 1)
- ]);
+ listener.assertErrors(usingFastaParser
+ ? [
+ expectedError(ParserErrorCode.EXPECTED_TOKEN, 11, 1),
+ expectedError(
+ ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 4)
+ ]
+ : [
+ expectedError(ParserErrorCode.EXPECTED_TOKEN, 11, 1),
+ expectedError(ParserErrorCode.MISSING_IDENTIFIER, 11, 1),
+ expectedError(
+ ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 11, 1)
+ ]);
}
void test_incomplete_constructorInitializers_thisField() {
@@ -10606,11 +10608,7 @@
ClassMember member = parser.parseClassMember('C');
expectNotNullIfNoErrors(member);
listener.assertErrors([
- usingFastaParser
- ? expectedError(
- ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 4)
- : expectedError(
- ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 8, 1)
+ expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 4)
]);
}
@@ -10620,11 +10618,7 @@
expectNotNullIfNoErrors(member);
listener.assertErrors([
expectedError(ParserErrorCode.MISSING_IDENTIFIER, 12, 1),
- usingFastaParser
- ? expectedError(
- ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 4)
- : expectedError(
- ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 11, 1)
+ expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 4)
]);
}
@@ -10633,8 +10627,7 @@
ClassMember member = parser.parseClassMember('C');
expectNotNullIfNoErrors(member);
listener.assertErrors([
- expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER,
- usingFastaParser ? 6 : 8, 1)
+ expectedError(ParserErrorCode.MISSING_ASSIGNMENT_IN_INITIALIZER, 6, 1)
]);
}
diff --git a/pkg/analyzer/test/src/fasta/recovery/partial_code/annotation_test.dart b/pkg/analyzer/test/src/fasta/recovery/partial_code/annotation_test.dart
index f8078ad..1b2fdee 100644
--- a/pkg/analyzer/test/src/fasta/recovery/partial_code/annotation_test.dart
+++ b/pkg/analyzer/test/src/fasta/recovery/partial_code/annotation_test.dart
@@ -14,19 +14,70 @@
buildAll() {
List<TestDescriptor> descriptors = <TestDescriptor>[
new TestDescriptor(
- 'ampersand', '@', [ParserErrorCode.MISSING_IDENTIFIER], '@_s_',
- allFailing: true),
+ 'ampersand',
+ '@',
+ [ParserErrorCode.MISSING_IDENTIFIER],
+ '@_s_',
+ allFailing: true,
+ ),
new TestDescriptor(
- 'leftParen', '@a(', [ParserErrorCode.EXPECTED_TOKEN], '@a()',
- allFailing: true),
+ 'leftParen',
+ '@a(',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ '@a()',
+ allFailing: true,
+ ),
];
- buildTests('annotation_topLevel', descriptors,
- PartialCodeTest.declarationSuffixes);
- buildTests('annotation_classMember', descriptors,
- PartialCodeTest.classMemberSuffixes,
- head: 'class C { ', tail: ' }');
buildTests(
- 'annotation_local', descriptors, PartialCodeTest.statementSuffixes,
- head: 'f() { ', tail: ' }');
+ 'annotation_topLevel',
+ expectErrors(descriptors, [ParserErrorCode.EXPECTED_EXECUTABLE]),
+ [],
+ );
+ buildTests(
+ 'annotation_topLevel',
+ descriptors,
+ PartialCodeTest.declarationSuffixes,
+ includeEof: false,
+ );
+ buildTests(
+ 'annotation_classMember',
+ descriptors,
+ PartialCodeTest.classMemberSuffixes,
+ head: 'class C { ',
+ tail: ' }',
+ );
+ buildTests(
+ 'annotation_local',
+ expectErrors(descriptors, [
+ ParserErrorCode.EXPECTED_TOKEN,
+ ParserErrorCode.EXPECTED_TYPE_NAME,
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ]),
+ [],
+ head: 'f() { ',
+ tail: ' }',
+ );
+ // TODO(brianwilkerson) Many of the combinations produced by the following
+ // produce "valid" code that is not valid. Even when we recover the
+ // annotation, the following statement is not allowed to have an annotation.
+ buildTests(
+ 'annotation_local',
+ descriptors,
+ PartialCodeTest.statementSuffixes,
+ head: 'f() { ',
+ includeEof: false,
+ tail: ' }',
+ );
}
+
+ /**
+ * Return a list of descriptors just like the given [descriptors] except that
+ * they have the given list of [errors] as the errors that are expected to be
+ * in the valid code.
+ */
+ List<TestDescriptor> expectErrors(
+ List<TestDescriptor> descriptors, List<ParserErrorCode> errors) =>
+ descriptors
+ .map((descriptor) => descriptor.withExpectedErrorsInValidCode(errors))
+ .toList();
}
diff --git a/pkg/analyzer/test/src/fasta/recovery/partial_code/field_declaration_test.dart b/pkg/analyzer/test/src/fasta/recovery/partial_code/field_declaration_test.dart
index d1f7a02..5c42722 100644
--- a/pkg/analyzer/test/src/fasta/recovery/partial_code/field_declaration_test.dart
+++ b/pkg/analyzer/test/src/fasta/recovery/partial_code/field_declaration_test.dart
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
import 'package:analyzer/src/dart/error/syntactic_errors.dart';
+import 'package:analyzer/src/error/codes.dart';
import 'partial_code_support.dart';
@@ -22,217 +23,268 @@
'setter'
];
buildTests(
- 'field_declaration',
- [
- //
- // Instance field, const.
- //
- new TestDescriptor(
- 'const_noName',
- 'const',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'const _s_;',
- allFailing: true),
- new TestDescriptor('const_name', 'const f',
- [ParserErrorCode.EXPECTED_TOKEN], 'const f;',
- allFailing: true),
- new TestDescriptor(
- 'const_equals',
- 'const f =',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'const f = _s_;',
- failing: allExceptEof),
- new TestDescriptor('const_initializer', 'const f = 0',
- [ParserErrorCode.EXPECTED_TOKEN], 'const f = 0;'),
- //
- // Instance field, final.
- //
- new TestDescriptor(
- 'final_noName',
- 'final',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'final _s_;',
- failing: allExceptEof),
- new TestDescriptor('final_name', 'final f',
- [ParserErrorCode.EXPECTED_TOKEN], 'final f;',
- failing: ['methodNonVoid', 'getter', 'setter']),
- new TestDescriptor(
- 'final_equals',
- 'final f =',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'final f = _s_;',
- failing: allExceptEof),
- new TestDescriptor('final_initializer', 'final f = 0',
- [ParserErrorCode.EXPECTED_TOKEN], 'final f = 0;'),
- //
- // Instance field, var.
- //
- new TestDescriptor(
- 'var_noName',
- 'var',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'var _s_;',
- failing: allExceptEof),
- new TestDescriptor(
- 'var_name', 'var f', [ParserErrorCode.EXPECTED_TOKEN], 'var f;',
- failing: ['methodNonVoid', 'getter', 'setter']),
- new TestDescriptor(
- 'var_equals',
- 'var f =',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'var f = _s_;',
- failing: allExceptEof),
- new TestDescriptor('var_initializer', 'var f = 0',
- [ParserErrorCode.EXPECTED_TOKEN], 'var f = 0;'),
- //
- // Instance field, type.
- //
- new TestDescriptor(
- 'type_noName',
- 'A',
- [
- ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'A _s_;',
- allFailing: true),
- new TestDescriptor(
- 'type_name', 'A f', [ParserErrorCode.EXPECTED_TOKEN], 'A f;'),
- new TestDescriptor(
- 'type_equals',
- 'A f =',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'A f = _s_;',
- failing: allExceptEof),
- new TestDescriptor('type_initializer', 'A f = 0',
- [ParserErrorCode.EXPECTED_TOKEN], 'A f = 0;'),
- //
- // Static field, const.
- //
- new TestDescriptor(
- 'static_const_noName',
- 'static const',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'static const _s_;',
- allFailing: true),
- new TestDescriptor('static_const_name', 'static const f',
- [ParserErrorCode.EXPECTED_TOKEN], 'static const f;',
- allFailing: true),
- new TestDescriptor(
- 'static_const_equals',
- 'static const f =',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'static const f = _s_;',
- failing: allExceptEof),
- new TestDescriptor('static_const_initializer', 'static const f = 0',
- [ParserErrorCode.EXPECTED_TOKEN], 'static const f = 0;'),
- //
- // Static field, final.
- //
- new TestDescriptor(
- 'static_final_noName',
- 'static final',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'static final _s_;',
- failing: allExceptEof),
- new TestDescriptor('static_final_name', 'static final f',
- [ParserErrorCode.EXPECTED_TOKEN], 'static final f;',
- failing: ['methodNonVoid', 'getter', 'setter']),
- new TestDescriptor(
- 'static_final_equals',
- 'static final f =',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'static final f = _s_;',
- failing: allExceptEof),
- new TestDescriptor('static_final_initializer', 'static final f = 0',
- [ParserErrorCode.EXPECTED_TOKEN], 'static final f = 0;'),
- //
- // Static field, var.
- //
- new TestDescriptor(
- 'static_var_noName',
- 'static var',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'static var _s_;',
- failing: allExceptEof),
- new TestDescriptor('static_var_name', 'static var f',
- [ParserErrorCode.EXPECTED_TOKEN], 'static var f;',
- failing: ['methodNonVoid', 'getter', 'setter']),
- new TestDescriptor(
- 'static_var_equals',
- 'static var f =',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'static var f = _s_;',
- failing: allExceptEof),
- new TestDescriptor('static_var_initializer', 'static var f = 0',
- [ParserErrorCode.EXPECTED_TOKEN], 'static var f = 0;'),
- //
- // Static field, type.
- //
- new TestDescriptor(
- 'static_type_noName',
- 'static A',
- [
- ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'static A _s_;',
- allFailing: true),
- new TestDescriptor('static_type_name', 'static A f',
- [ParserErrorCode.EXPECTED_TOKEN], 'static A f;'),
- new TestDescriptor(
- 'static_type_equals',
- 'static A f =',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'static A f = _s_;',
- failing: allExceptEof),
- new TestDescriptor('static_type_initializer', 'static A f = 0',
- [ParserErrorCode.EXPECTED_TOKEN], 'static A f = 0;'),
- ],
- PartialCodeTest.classMemberSuffixes,
- head: 'class C { ',
- tail: ' }');
+ 'field_declaration',
+ [
+ //
+ // Instance field, const.
+ //
+ new TestDescriptor(
+ 'const_noName',
+ 'const',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'const _s_;',
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED
+ ],
+ ),
+ new TestDescriptor(
+ 'const_name',
+ 'const f',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'const f;',
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED
+ ],
+ ),
+ new TestDescriptor(
+ 'const_equals',
+ 'const f =',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'const f = _s_;',
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'const_initializer',
+ 'const f = 0',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'const f = 0;',
+ ),
+ //
+ // Instance field, final.
+ //
+ new TestDescriptor(
+ 'final_noName',
+ 'final',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'final _s_;',
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'final_name',
+ 'final f',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'final f;',
+ failing: ['methodNonVoid', 'getter', 'setter'],
+ ),
+ new TestDescriptor(
+ 'final_equals',
+ 'final f =',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'final f = _s_;',
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'final_initializer',
+ 'final f = 0',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'final f = 0;',
+ ),
+ //
+ // Instance field, var.
+ //
+ new TestDescriptor(
+ 'var_noName',
+ 'var',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'var _s_;',
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'var_name',
+ 'var f',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'var f;',
+ failing: ['methodNonVoid', 'getter', 'setter'],
+ ),
+ new TestDescriptor(
+ 'var_equals',
+ 'var f =',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'var f = _s_;',
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'var_initializer',
+ 'var f = 0',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'var f = 0;',
+ ),
+ //
+ // Instance field, type.
+ //
+ new TestDescriptor(
+ 'type_noName',
+ 'A',
+ [
+ ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ 'A _s_;',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'type_name',
+ 'A f',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'A f;',
+ ),
+ new TestDescriptor(
+ 'type_equals',
+ 'A f =',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'A f = _s_;',
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'type_initializer',
+ 'A f = 0',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'A f = 0;',
+ ),
+ //
+ // Static field, const.
+ //
+ new TestDescriptor(
+ 'static_const_noName',
+ 'static const',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'static const _s_;',
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED
+ ],
+ ),
+ new TestDescriptor(
+ 'static_const_name',
+ 'static const f',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static const f;',
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED
+ ],
+ ),
+ new TestDescriptor(
+ 'static_const_equals',
+ 'static const f =',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'static const f = _s_;',
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'static_const_initializer',
+ 'static const f = 0',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static const f = 0;',
+ ),
+ //
+ // Static field, final.
+ //
+ new TestDescriptor(
+ 'static_final_noName',
+ 'static final',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'static final _s_;',
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'static_final_name',
+ 'static final f',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static final f;',
+ failing: ['methodNonVoid', 'getter', 'setter'],
+ ),
+ new TestDescriptor(
+ 'static_final_equals',
+ 'static final f =',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'static final f = _s_;',
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'static_final_initializer',
+ 'static final f = 0',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static final f = 0;',
+ ),
+ //
+ // Static field, var.
+ //
+ new TestDescriptor(
+ 'static_var_noName',
+ 'static var',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'static var _s_;',
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'static_var_name',
+ 'static var f',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static var f;',
+ failing: ['methodNonVoid', 'getter', 'setter'],
+ ),
+ new TestDescriptor(
+ 'static_var_equals',
+ 'static var f =',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'static var f = _s_;',
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'static_var_initializer',
+ 'static var f = 0',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static var f = 0;',
+ ),
+ //
+ // Static field, type.
+ //
+ new TestDescriptor(
+ 'static_type_noName',
+ 'static A',
+ [
+ ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ 'static A _s_;',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'static_type_name',
+ 'static A f',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static A f;',
+ ),
+ new TestDescriptor(
+ 'static_type_equals',
+ 'static A f =',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'static A f = _s_;',
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'static_type_initializer',
+ 'static A f = 0',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static A f = 0;',
+ ),
+ ],
+ PartialCodeTest.classMemberSuffixes,
+ head: 'class C { ',
+ tail: ' }',
+ );
}
}
diff --git a/pkg/analyzer/test/src/fasta/recovery/partial_code/if_statement_test.dart b/pkg/analyzer/test/src/fasta/recovery/partial_code/if_statement_test.dart
index 7f8ac54..6402a1c 100644
--- a/pkg/analyzer/test/src/fasta/recovery/partial_code/if_statement_test.dart
+++ b/pkg/analyzer/test/src/fasta/recovery/partial_code/if_statement_test.dart
@@ -13,33 +13,70 @@
class IfStatementTest extends PartialCodeTest {
buildAll() {
buildTests(
- 'if_statement',
- [
- new TestDescriptor(
- 'keyword',
- 'if',
- [
- ParserErrorCode.EXPECTED_TOKEN,
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- "if (_s_)",
- failing: ['eof']),
- new TestDescriptor(
- 'leftParen',
- 'if (',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- "if (_s_)",
- allFailing: true),
- new TestDescriptor(
- 'condition', 'if (a', [ParserErrorCode.EXPECTED_TOKEN], "if (a)",
- allFailing: true),
- ],
- PartialCodeTest.statementSuffixes,
- head: 'f() { ',
- tail: ' }');
+ 'if_statement',
+ [
+ new TestDescriptor(
+ 'keyword',
+ 'if',
+ [
+ ParserErrorCode.EXPECTED_TOKEN,
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ "if (_s_)",
+ ),
+ new TestDescriptor(
+ 'leftParen',
+ 'if (',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ "if (_s_)",
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'condition',
+ 'if (a',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ "if (a)",
+ allFailing: true,
+ ),
+ ],
+ PartialCodeTest.statementSuffixes,
+ head: 'f() { ',
+ includeEof: false,
+ tail: ' }',
+ );
+ buildTests(
+ 'if_statement',
+ [
+ new TestDescriptor(
+ 'keyword',
+ 'if',
+ [
+ ParserErrorCode.EXPECTED_TOKEN,
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ "if (_s_);",
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'leftParen',
+ 'if (',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ "if (_s_);",
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'condition',
+ 'if (a',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ "if (a);",
+ allFailing: true,
+ ),
+ ],
+ [],
+ head: 'f() { ',
+ tail: ' }',
+ );
}
}
diff --git a/pkg/analyzer/test/src/fasta/recovery/partial_code/method_declaration_test.dart b/pkg/analyzer/test/src/fasta/recovery/partial_code/method_declaration_test.dart
index 432d9d4..a2c8624 100644
--- a/pkg/analyzer/test/src/fasta/recovery/partial_code/method_declaration_test.dart
+++ b/pkg/analyzer/test/src/fasta/recovery/partial_code/method_declaration_test.dart
@@ -13,183 +13,276 @@
class MethodTest extends PartialCodeTest {
buildAll() {
buildTests(
- 'method_declaration',
- [
- //
- // Instance method, no return type.
- //
- new TestDescriptor('noType_leftParen', 'm(',
- [ParserErrorCode.EXPECTED_TOKEN], 'm();',
- allFailing: true),
- new TestDescriptor('noType_paramName', 'm(B',
- [ParserErrorCode.EXPECTED_TOKEN], 'm(B);',
- allFailing: true),
- new TestDescriptor('noType_paramTypeAndName', 'm(B b',
- [ParserErrorCode.EXPECTED_TOKEN], 'm(B b);',
- allFailing: true),
- new TestDescriptor(
- 'noType_paramAndComma',
- 'm(B b,',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'm(B b, _s_);',
- allFailing: true),
- new TestDescriptor('noType_noParams', 'm()',
- [ParserErrorCode.EXPECTED_TOKEN], 'm();',
- allFailing: true),
- new TestDescriptor('noType_params', 'm(b, c)',
- [ParserErrorCode.EXPECTED_TOKEN], 'm(b, c);',
- allFailing: true),
- new TestDescriptor(
- 'noType_emptyOptional',
- 'm(B b, [])',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.MISSING_FUNCTION_BODY
- ],
- 'm(B b, [_s_]){}'),
- new TestDescriptor(
- 'noType_emptyNamed',
- 'm(B b, {})',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.MISSING_FUNCTION_BODY
- ],
- 'm(B b, {_s_}){}'),
- //
- // Instance method, with simple return type.
- //
- new TestDescriptor('type_leftParen', 'A m(',
- [ParserErrorCode.EXPECTED_TOKEN], 'A m();',
- allFailing: true),
- new TestDescriptor('type_paramName', 'A m(B',
- [ParserErrorCode.EXPECTED_TOKEN], 'A m(B);',
- allFailing: true),
- new TestDescriptor('type_paramTypeAndName', 'A m(B b',
- [ParserErrorCode.EXPECTED_TOKEN], 'A m(B b);',
- allFailing: true),
- new TestDescriptor(
- 'type_paramAndComma',
- 'A m(B b,',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'A m(B b, _s_);',
- allFailing: true),
- new TestDescriptor('type_noParams', 'A m()',
- [ParserErrorCode.EXPECTED_TOKEN], 'A m();',
- allFailing: true),
- new TestDescriptor('type_params', 'A m(b, c)',
- [ParserErrorCode.EXPECTED_TOKEN], 'A m(b, c);',
- allFailing: true),
- new TestDescriptor(
- 'type_emptyOptional',
- 'A m(B b, [])',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.MISSING_FUNCTION_BODY
- ],
- 'A m(B b, [_s_]){}'),
- new TestDescriptor(
- 'type_emptyNamed',
- 'A m(B b, {})',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.MISSING_FUNCTION_BODY
- ],
- 'A m(B b, {_s_}){}'),
- //
- // Static method, no return type.
- //
- new TestDescriptor('static_noType_leftParen', 'static m(',
- [ParserErrorCode.EXPECTED_TOKEN], 'static m();',
- allFailing: true),
- new TestDescriptor('static_noType_paramName', 'static m(B',
- [ParserErrorCode.EXPECTED_TOKEN], 'static m(B);',
- allFailing: true),
- new TestDescriptor('static_noType_paramTypeAndName', 'static m(B b',
- [ParserErrorCode.EXPECTED_TOKEN], 'static m(B b);',
- allFailing: true),
- new TestDescriptor(
- 'static_noType_paramAndComma',
- 'static m(B b,',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'static m(B b, _s_);',
- allFailing: true),
- new TestDescriptor('static_noType_noParams', 'static m()',
- [ParserErrorCode.EXPECTED_TOKEN], 'static m();',
- allFailing: true),
- new TestDescriptor('static_noType_params', 'static m(b, c)',
- [ParserErrorCode.EXPECTED_TOKEN], 'static m(b, c);',
- allFailing: true),
- new TestDescriptor(
- 'static_noType_emptyOptional',
- 'static m(B b, [])',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.MISSING_FUNCTION_BODY
- ],
- 'static m(B b, [_s_]){}'),
- new TestDescriptor(
- 'static_noType_emptyNamed',
- 'static m(B b, {})',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.MISSING_FUNCTION_BODY
- ],
- 'static m(B b, {_s_}){}'),
- //
- // Static method, with simple return type.
- //
- new TestDescriptor('static_type_leftParen', 'static A m(',
- [ParserErrorCode.EXPECTED_TOKEN], 'static A m();',
- allFailing: true),
- new TestDescriptor('static_type_paramName', 'static A m(B',
- [ParserErrorCode.EXPECTED_TOKEN], 'static A m(B);',
- allFailing: true),
- new TestDescriptor('static_type_paramTypeAndName', 'static A m(B b',
- [ParserErrorCode.EXPECTED_TOKEN], 'static A m(B b);',
- allFailing: true),
- new TestDescriptor(
- 'static_type_paramAndComma',
- 'static A m(B b,',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- 'static A m(B b, _s_);',
- allFailing: true),
- new TestDescriptor('static_type_noParams', 'static A m()',
- [ParserErrorCode.EXPECTED_TOKEN], 'static A m();',
- allFailing: true),
- new TestDescriptor('static_type_params', 'static A m(b, c)',
- [ParserErrorCode.EXPECTED_TOKEN], 'static A m(b, c);',
- allFailing: true),
- new TestDescriptor(
- 'static_type_emptyOptional',
- 'static A m(B b, [])',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.MISSING_FUNCTION_BODY
- ],
- 'static A m(B b, [_s_]){}'),
- new TestDescriptor(
- 'static_type_emptyNamed',
- 'static A m(B b, {})',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.MISSING_FUNCTION_BODY
- ],
- 'static A m(B b, {_s_}){}'),
- ],
- PartialCodeTest.classMemberSuffixes,
- head: 'class C { ',
- tail: ' }');
+ 'method_declaration',
+ [
+ //
+ // Instance method, no return type.
+ //
+ new TestDescriptor(
+ 'noType_leftParen',
+ 'm(',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'm();',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'noType_paramName',
+ 'm(B',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'm(B);',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'noType_paramTypeAndName',
+ 'm(B b',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'm(B b);',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'noType_paramAndComma',
+ 'm(B b,',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'm(B b, _s_);',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'noType_noParams',
+ 'm()',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'm();',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'noType_params',
+ 'm(b, c)',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'm(b, c);',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'noType_emptyOptional',
+ 'm(B b, [])',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.MISSING_FUNCTION_BODY
+ ],
+ 'm(B b, [_s_]){}',
+ ),
+ new TestDescriptor(
+ 'noType_emptyNamed',
+ 'm(B b, {})',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.MISSING_FUNCTION_BODY
+ ],
+ 'm(B b, {_s_}){}',
+ ),
+ //
+ // Instance method, with simple return type.
+ //
+ new TestDescriptor(
+ 'type_leftParen',
+ 'A m(',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'A m();',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'type_paramName',
+ 'A m(B',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'A m(B);',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'type_paramTypeAndName',
+ 'A m(B b',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'A m(B b);',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'type_paramAndComma',
+ 'A m(B b,',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'A m(B b, _s_);',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'type_noParams',
+ 'A m()',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'A m();',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'type_params',
+ 'A m(b, c)',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'A m(b, c);',
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'type_emptyOptional',
+ 'A m(B b, [])',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.MISSING_FUNCTION_BODY
+ ],
+ 'A m(B b, [_s_]){}',
+ ),
+ new TestDescriptor(
+ 'type_emptyNamed',
+ 'A m(B b, {})',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.MISSING_FUNCTION_BODY
+ ],
+ 'A m(B b, {_s_}){}',
+ ),
+ //
+ // Static method, no return type.
+ //
+ new TestDescriptor(
+ 'static_noType_leftParen',
+ 'static m(',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static m();',
+ allFailing: true,
+ expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+ ),
+ new TestDescriptor(
+ 'static_noType_paramName',
+ 'static m(B',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static m(B);',
+ allFailing: true,
+ expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+ ),
+ new TestDescriptor(
+ 'static_noType_paramTypeAndName',
+ 'static m(B b',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static m(B b);',
+ allFailing: true,
+ expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+ ),
+ new TestDescriptor(
+ 'static_noType_paramAndComma',
+ 'static m(B b,',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'static m(B b, _s_);',
+ allFailing: true,
+ expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+ ),
+ new TestDescriptor(
+ 'static_noType_noParams',
+ 'static m()',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static m();',
+ allFailing: true,
+ expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+ ),
+ new TestDescriptor(
+ 'static_noType_params',
+ 'static m(b, c)',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static m(b, c);',
+ allFailing: true,
+ expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+ ),
+ new TestDescriptor(
+ 'static_noType_emptyOptional',
+ 'static m(B b, [])',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.MISSING_FUNCTION_BODY
+ ],
+ 'static m(B b, [_s_]){}',
+ ),
+ new TestDescriptor(
+ 'static_noType_emptyNamed',
+ 'static m(B b, {})',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.MISSING_FUNCTION_BODY
+ ],
+ 'static m(B b, {_s_}){}',
+ ),
+ //
+ // Static method, with simple return type.
+ //
+ new TestDescriptor(
+ 'static_type_leftParen',
+ 'static A m(',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static A m();',
+ allFailing: true,
+ expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+ ),
+ new TestDescriptor(
+ 'static_type_paramName',
+ 'static A m(B',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static A m(B);',
+ allFailing: true,
+ expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+ ),
+ new TestDescriptor(
+ 'static_type_paramTypeAndName',
+ 'static A m(B b',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static A m(B b);',
+ allFailing: true,
+ expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+ ),
+ new TestDescriptor(
+ 'static_type_paramAndComma',
+ 'static A m(B b,',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ 'static A m(B b, _s_);',
+ allFailing: true,
+ expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+ ),
+ new TestDescriptor(
+ 'static_type_noParams',
+ 'static A m()',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static A m();',
+ allFailing: true,
+ expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+ ),
+ new TestDescriptor(
+ 'static_type_params',
+ 'static A m(b, c)',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ 'static A m(b, c);',
+ allFailing: true,
+ expectedErrorsInValidCode: [ParserErrorCode.MISSING_FUNCTION_BODY],
+ ),
+ new TestDescriptor(
+ 'static_type_emptyOptional',
+ 'static A m(B b, [])',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.MISSING_FUNCTION_BODY
+ ],
+ 'static A m(B b, [_s_]){}',
+ ),
+ new TestDescriptor(
+ 'static_type_emptyNamed',
+ 'static A m(B b, {})',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.MISSING_FUNCTION_BODY
+ ],
+ 'static A m(B b, {_s_}){}',
+ ),
+ ],
+ PartialCodeTest.classMemberSuffixes,
+ head: 'class C { ',
+ tail: ' }',
+ );
}
}
diff --git a/pkg/analyzer/test/src/fasta/recovery/partial_code/partial_code_support.dart b/pkg/analyzer/test/src/fasta/recovery/partial_code/partial_code_support.dart
index ebb09d2..faaddf6 100644
--- a/pkg/analyzer/test/src/fasta/recovery/partial_code/partial_code_support.dart
+++ b/pkg/analyzer/test/src/fasta/recovery/partial_code/partial_code_support.dart
@@ -101,11 +101,13 @@
*/
buildTests(String groupName, List<TestDescriptor> descriptors,
List<TestSuffix> suffixes,
- {String head, String tail}) {
+ {String head, bool includeEof: true, String tail}) {
group(groupName, () {
for (TestDescriptor descriptor in descriptors) {
- _buildTestForDescriptorAndSuffix(
- descriptor, TestSuffix.eof, 0, head, tail);
+ if (includeEof) {
+ _buildTestForDescriptorAndSuffix(
+ descriptor, TestSuffix.eof, 0, head, tail);
+ }
for (int i = 0; i < suffixes.length; i++) {
_buildTestForDescriptorAndSuffix(
descriptor, suffixes[i], i + 1, head, tail);
@@ -113,9 +115,13 @@
if (descriptor.failing != null) {
test('${descriptor.name}_failingList', () {
Set<String> failing = new Set.from(descriptor.failing);
- failing.remove('eof');
+ if (includeEof) {
+ failing.remove('eof');
+ }
failing.removeAll(suffixes.map((TestSuffix suffix) => suffix.name));
- expect(failing, isEmpty);
+ expect(failing, isEmpty,
+ reason:
+ 'There are tests marked as failing that are not being run');
});
}
}
@@ -155,8 +161,8 @@
base.write(tail);
}
//
- // Determine the existing errors in the code
- // without either valid or invalid code.
+ // Determine the existing errors in the code without either valid or
+ // invalid code.
//
GatheringErrorListener listener =
new GatheringErrorListener(checkRanges: true);
@@ -181,7 +187,6 @@
if (descriptor.errorCodes != null) {
expectedInvalidCodeErrors.addAll(descriptor.errorCodes);
}
-
//
// Run the test.
//
@@ -255,6 +260,17 @@
*/
TestDescriptor(this.name, this.invalid, this.errorCodes, this.valid,
{this.allFailing: false, this.failing, this.expectedErrorsInValidCode});
+
+ /**
+ * Return a new description that is exactly like this descriptor except with
+ * the given [expectedErrorsInValidCode].
+ */
+ TestDescriptor withExpectedErrorsInValidCode(
+ List<ErrorCode> expectedErrorsInValidCode) =>
+ new TestDescriptor(name, invalid, errorCodes, valid,
+ allFailing: allFailing,
+ failing: failing,
+ expectedErrorsInValidCode: expectedErrorsInValidCode);
}
/**
diff --git a/pkg/analyzer/test/src/fasta/recovery/partial_code/top_level_variable_test.dart b/pkg/analyzer/test/src/fasta/recovery/partial_code/top_level_variable_test.dart
index 206cec2..17a1456 100644
--- a/pkg/analyzer/test/src/fasta/recovery/partial_code/top_level_variable_test.dart
+++ b/pkg/analyzer/test/src/fasta/recovery/partial_code/top_level_variable_test.dart
@@ -3,6 +3,7 @@
// BSD-style license that can be found in the LICENSE file.
import 'package:analyzer/src/dart/error/syntactic_errors.dart';
+import 'package:analyzer/src/error/codes.dart';
import 'partial_code_support.dart';
@@ -27,93 +28,170 @@
'top_level_variable',
[
new TestDescriptor(
- 'const',
- 'const',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- "const _s_;",
- allFailing: true),
- new TestDescriptor('constName', 'const a',
- [ParserErrorCode.EXPECTED_TOKEN], "const a;",
- allFailing: true),
- new TestDescriptor('constTypeName', 'const int a',
- [ParserErrorCode.EXPECTED_TOKEN], "const int a;",
- allFailing: true),
+ 'const',
+ 'const',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ "const _s_;",
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED
+ ],
+ ),
new TestDescriptor(
- 'constNameComma',
- 'const a,',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- "const a, _s_;",
- allFailing: true),
+ 'constName',
+ 'const a',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ "const a;",
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED
+ ],
+ ),
new TestDescriptor(
- 'constTypeNameComma',
- 'const int a,',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- "const int a, _s_;",
- allFailing: true),
- new TestDescriptor('constNameCommaName', 'const a, b',
- [ParserErrorCode.EXPECTED_TOKEN], "const a, b;",
- allFailing: true),
- new TestDescriptor('constTypeNameCommaName', 'const int a, b',
- [ParserErrorCode.EXPECTED_TOKEN], "const int a, b;",
- allFailing: true),
+ 'constTypeName',
+ 'const int a',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ "const int a;",
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED
+ ],
+ ),
new TestDescriptor(
- 'final',
- 'final',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- "final _s_;",
- allFailing: true),
- new TestDescriptor('finalName', 'final a',
- [ParserErrorCode.EXPECTED_TOKEN], "final a;",
- allFailing: true),
- new TestDescriptor('finalTypeName', 'final int a',
- [ParserErrorCode.EXPECTED_TOKEN], "final int a;",
- allFailing: true),
+ 'constNameComma',
+ 'const a,',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ "const a, _s_;",
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED,
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED
+ ],
+ ),
new TestDescriptor(
- 'type',
- 'int',
- [
- ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- "int _s_;",
- allFailing: true),
+ 'constTypeNameComma',
+ 'const int a,',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ "const int a, _s_;",
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED,
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED
+ ],
+ ),
new TestDescriptor(
- 'typeName', 'int a', [ParserErrorCode.EXPECTED_TOKEN], "int a;"),
+ 'constNameCommaName',
+ 'const a, b',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ "const a, b;",
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED,
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED
+ ],
+ ),
new TestDescriptor(
- 'var',
- 'var',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- "var _s_;",
- failing: allExceptEof),
+ 'constTypeNameCommaName',
+ 'const int a, b',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ "const int a, b;",
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED,
+ CompileTimeErrorCode.CONST_NOT_INITIALIZED
+ ],
+ ),
new TestDescriptor(
- 'varName', 'var a', [ParserErrorCode.EXPECTED_TOKEN], "var a;",
- failing: ['typedef', 'functionNonVoid', 'getter', 'setter']),
+ 'final',
+ 'final',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ "final _s_;",
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ StaticWarningCode.FINAL_NOT_INITIALIZED
+ ],
+ ),
new TestDescriptor(
- 'varNameEquals',
- 'var a =',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- "var a = _s_;",
- failing: allExceptEof),
- new TestDescriptor('varNameEqualsExpression', 'var a = b',
- [ParserErrorCode.EXPECTED_TOKEN], "var a = b;"),
+ 'finalName',
+ 'final a',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ "final a;",
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ StaticWarningCode.FINAL_NOT_INITIALIZED
+ ],
+ ),
+ new TestDescriptor(
+ 'finalTypeName',
+ 'final int a',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ "final int a;",
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ StaticWarningCode.FINAL_NOT_INITIALIZED
+ ],
+ ),
+ new TestDescriptor(
+ 'type',
+ 'int',
+ [
+ ParserErrorCode.MISSING_CONST_FINAL_VAR_OR_TYPE,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ "int _s_;",
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'typeName',
+ 'int a',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ "int a;",
+ ),
+ new TestDescriptor(
+ 'var',
+ 'var',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ "var _s_;",
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'varName',
+ 'var a',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ "var a;",
+ failing: ['typedef', 'functionNonVoid', 'getter', 'setter'],
+ ),
+ new TestDescriptor(
+ 'varNameEquals',
+ 'var a =',
+ [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ "var a = _s_;",
+ failing: allExceptEof,
+ ),
+ new TestDescriptor(
+ 'varNameEqualsExpression',
+ 'var a = b',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ "var a = b;",
+ ),
],
PartialCodeTest.declarationSuffixes);
}
diff --git a/pkg/analyzer/test/src/fasta/recovery/partial_code/while_statement_test.dart b/pkg/analyzer/test/src/fasta/recovery/partial_code/while_statement_test.dart
index c7aa796..29040d2 100644
--- a/pkg/analyzer/test/src/fasta/recovery/partial_code/while_statement_test.dart
+++ b/pkg/analyzer/test/src/fasta/recovery/partial_code/while_statement_test.dart
@@ -13,33 +13,83 @@
class WhileStatementTest extends PartialCodeTest {
buildAll() {
buildTests(
- 'while_statement',
- [
- new TestDescriptor(
- 'keyword',
- 'while',
- [
- ParserErrorCode.EXPECTED_TOKEN,
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- "while (_s_)",
- failing: ['eof', 'break', 'continue']),
- new TestDescriptor(
- 'leftParen',
- 'while (',
- [
- ParserErrorCode.MISSING_IDENTIFIER,
- ParserErrorCode.EXPECTED_TOKEN
- ],
- "while (_s_)",
- allFailing: true),
- new TestDescriptor('condition', 'while (a',
- [ParserErrorCode.EXPECTED_TOKEN], "while (a)",
- allFailing: true),
- ],
- PartialCodeTest.statementSuffixes,
- head: 'f() { ',
- tail: ' }');
+ 'while_statement',
+ <TestDescriptor>[
+ new TestDescriptor(
+ 'keyword',
+ 'while',
+ [
+ ParserErrorCode.EXPECTED_TOKEN,
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ "while (_s_)",
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ ),
+ new TestDescriptor(
+ 'leftParen',
+ 'while (',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ "while (_s_)",
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ ),
+ new TestDescriptor(
+ 'condition',
+ 'while (a',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ "while (a)",
+ allFailing: true,
+ expectedErrorsInValidCode: [
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ ),
+ ],
+ [],
+ head: 'f() { ',
+ tail: ' }',
+ );
+ buildTests(
+ 'while_statement',
+ <TestDescriptor>[
+ new TestDescriptor(
+ 'keyword',
+ 'while',
+ [
+ ParserErrorCode.EXPECTED_TOKEN,
+ ParserErrorCode.MISSING_IDENTIFIER,
+ ParserErrorCode.EXPECTED_TOKEN
+ ],
+ "while (_s_)",
+ failing: ['break', 'continue'],
+ ),
+ new TestDescriptor(
+ 'leftParen',
+ 'while (',
+ [ParserErrorCode.MISSING_IDENTIFIER, ParserErrorCode.EXPECTED_TOKEN],
+ "while (_s_)",
+ allFailing: true,
+ ),
+ new TestDescriptor(
+ 'condition',
+ 'while (a',
+ [ParserErrorCode.EXPECTED_TOKEN],
+ "while (a)",
+ allFailing: true,
+ ),
+ ],
+ PartialCodeTest.statementSuffixes,
+ head: 'f() { ',
+ includeEof: false,
+ tail: ' }',
+ );
}
}
diff --git a/pkg/analyzer/test/src/fasta/recovery/recovery_test_support.dart b/pkg/analyzer/test/src/fasta/recovery/recovery_test_support.dart
index 9a48970..af7574a 100644
--- a/pkg/analyzer/test/src/fasta/recovery/recovery_test_support.dart
+++ b/pkg/analyzer/test/src/fasta/recovery/recovery_test_support.dart
@@ -27,8 +27,11 @@
validUnit =
parseCompilationUnit(validCode, codes: expectedErrorsInValidCode);
} catch (e) {
- print('*** Valid code did not parse correctly');
- print(validCode);
+ print('');
+ print(' Errors in valid code.');
+ print(' Error: $e');
+ print(' Code: $validCode');
+ print('');
rethrow;
}
diff --git a/pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart b/pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart
index 60c028e..ebbb2f5 100644
--- a/pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart
+++ b/pkg/analyzer_plugin/lib/src/utilities/change_builder/change_builder_dart.dart
@@ -316,7 +316,7 @@
@override
void writeOverrideOfInheritedMember(ExecutableElement member,
- {String returnTypeGroupName}) {
+ {StringBuffer, displayTextBuffer, String returnTypeGroupName}) {
// prepare environment
String prefix = getIndent(1);
// may be property
diff --git a/pkg/analyzer_plugin/lib/src/utilities/completion/completion_target.dart b/pkg/analyzer_plugin/lib/src/utilities/completion/completion_target.dart
index b0dac1f..1ec6942 100644
--- a/pkg/analyzer_plugin/lib/src/utilities/completion/completion_target.dart
+++ b/pkg/analyzer_plugin/lib/src/utilities/completion/completion_target.dart
@@ -314,6 +314,19 @@
}
/**
+ * Return `true` if the target is a double or int literal.
+ */
+ bool isDoubleOrIntLiteral() {
+ var entity = this.entity;
+ if (entity is Token) {
+ TokenType previousTokenType = entity.previous?.type;
+ return previousTokenType == TokenType.DOUBLE ||
+ previousTokenType == TokenType.INT;
+ }
+ return false;
+ }
+
+ /**
* Return `true` if the target is a functional argument in an argument list.
* The target [AstNode] hierarchy *must* be resolved for this to work.
* See [maybeFunctionalArgument].
diff --git a/pkg/analyzer_plugin/lib/src/utilities/completion/optype.dart b/pkg/analyzer_plugin/lib/src/utilities/completion/optype.dart
index 49cc0ea..171f216 100644
--- a/pkg/analyzer_plugin/lib/src/utilities/completion/optype.dart
+++ b/pkg/analyzer_plugin/lib/src/utilities/completion/optype.dart
@@ -113,6 +113,12 @@
*/
factory OpType.forCompletion(CompletionTarget target, int offset) {
OpType optype = new OpType._();
+
+ // Don't suggest anything right after double or integer literals.
+ if (target.isDoubleOrIntLiteral()) {
+ return optype;
+ }
+
target.containingNode
.accept(new _OpTypeAstVisitor(optype, target.entity, offset));
var mthDecl =
@@ -280,6 +286,14 @@
}
@override
+ void visitAssertInitializer(AssertInitializer node) {
+ if (identical(entity, node.condition)) {
+ optype.includeReturnValueSuggestions = true;
+ optype.includeTypeNameSuggestions = true;
+ }
+ }
+
+ @override
void visitAssertStatement(AssertStatement node) {
if (identical(entity, node.condition)) {
optype.includeReturnValueSuggestions = true;
diff --git a/pkg/analyzer_plugin/lib/utilities/change_builder/change_builder_dart.dart b/pkg/analyzer_plugin/lib/utilities/change_builder/change_builder_dart.dart
index 79d3f3c..a14dffc 100644
--- a/pkg/analyzer_plugin/lib/utilities/change_builder/change_builder_dart.dart
+++ b/pkg/analyzer_plugin/lib/utilities/change_builder/change_builder_dart.dart
@@ -169,8 +169,11 @@
/**
* Append a placeholder for an override of the specified inherited [member].
+ * If provided, write a string value suitable for display (e.g., in a
+ * completion popup) in the given [displayTextBuffer].
*/
- void writeOverrideOfInheritedMember(ExecutableElement member);
+ void writeOverrideOfInheritedMember(ExecutableElement member,
+ {StringBuffer displayTextBuffer});
/**
* Write the code for a parameter that would match the given [argument]. The
diff --git a/pkg/analyzer_plugin/test/src/utilities/change_builder/change_builder_dart_test.dart b/pkg/analyzer_plugin/test/src/utilities/change_builder/change_builder_dart_test.dart
index e696ed4..4acdff3 100644
--- a/pkg/analyzer_plugin/test/src/utilities/change_builder/change_builder_dart_test.dart
+++ b/pkg/analyzer_plugin/test/src/utilities/change_builder/change_builder_dart_test.dart
@@ -985,20 +985,25 @@
}
test_writeOverrideOfInheritedMember_method_nullAsTypeArgument() async {
- await _assertWriteOverrideOfInheritedMethod('''
+ await _assertWriteOverrideOfInheritedMethod(
+ '''
abstract class A {
List<Null> foo();
}
class B extends A {
}
-''', '''
+''',
+ '''
@override
List<Null> foo() {
// TODO: implement foo
return null;
}
-''');
+''',
+ // TODO(pquitslund): Add tests once implemented.
+ //displayText: 'foo() { ... }'
+ );
}
test_writeOverrideOfInheritedMember_method_voidAsTypeArgument() async {
@@ -1440,20 +1445,26 @@
* an inherited method is to be added, assert that the text of the overridden
* member matches the [expected] text (modulo white space).
*/
- _assertWriteOverrideOfInheritedMethod(String content, String expected) async {
+ _assertWriteOverrideOfInheritedMethod(String content, String expected,
+ {String displayText}) async {
String path = provider.convertPath('/test.dart');
addSource(path, content);
ClassElement classA = await _getClassElement(path, 'A');
+ StringBuffer displayBuffer =
+ displayText != null ? new StringBuffer() : null;
+
DartChangeBuilderImpl builder = new DartChangeBuilder(session);
await builder.addFileEdit(path, (FileEditBuilder builder) {
builder.addInsertion(content.length - 2, (EditBuilder builder) {
- (builder as DartEditBuilder)
- .writeOverrideOfInheritedMember(classA.methods[0]);
+ (builder as DartEditBuilder).writeOverrideOfInheritedMember(
+ classA.methods[0],
+ displayTextBuffer: displayBuffer);
});
});
SourceEdit edit = getEdit(builder);
expect(edit.replacement, equalsIgnoringWhitespace(expected));
+ expect(displayBuffer?.toString(), displayText);
}
Future<ClassElement> _getClassElement(String path, String name) async {
diff --git a/pkg/analyzer_plugin/test/src/utilities/completion/optype_test.dart b/pkg/analyzer_plugin/test/src/utilities/completion/optype_test.dart
index ddc6cc8..fff6171 100644
--- a/pkg/analyzer_plugin/test/src/utilities/completion/optype_test.dart
+++ b/pkg/analyzer_plugin/test/src/utilities/completion/optype_test.dart
@@ -223,6 +223,11 @@
await assertOpType(returnValue: true, typeNames: true);
}
+ test_AssertInitializer() async {
+ addTestSource('class C { C() : assert(^); }');
+ await assertOpType(returnValue: true, typeNames: true);
+ }
+
test_AssignmentExpression_name() async {
// SimpleIdentifier VariableDeclaration VariableDeclarationList
// VariableDeclarationStatement Block
@@ -1173,6 +1178,21 @@
await assertOpType(returnValue: true, typeNames: true);
}
+ test_IntegerLiteral_inArgumentList() async {
+ addTestSource('main() { print(1^); }');
+ await assertOpType();
+ }
+
+ test_IntegerLiteral_inListLiteral() async {
+ addTestSource('main() { var items = [1^]; }');
+ await assertOpType();
+ }
+
+ test_DoubleLiteral() async {
+ addTestSource('main() { print(1.2^); }');
+ await assertOpType();
+ }
+
test_IsExpression_type_partial() async {
// SimpleIdentifier TypeName IsExpression IfStatement
addTestSource('main(){var a; if (a is Obj^)}');
diff --git a/pkg/compiler/lib/src/dart2js.dart b/pkg/compiler/lib/src/dart2js.dart
index 19d3b29..36ac2da 100644
--- a/pkg/compiler/lib/src/dart2js.dart
+++ b/pkg/compiler/lib/src/dart2js.dart
@@ -289,6 +289,8 @@
void setUseKernel(String argument) {
useKernel = true;
+ // TODO(sigmund): reenable hints (Issue #32111)
+ showHints = false;
passThrough(argument);
}
diff --git a/pkg/compiler/lib/src/elements/types.dart b/pkg/compiler/lib/src/elements/types.dart
index 5ea9202..4313798 100644
--- a/pkg/compiler/lib/src/elements/types.dart
+++ b/pkg/compiler/lib/src/elements/types.dart
@@ -1166,6 +1166,8 @@
InterfaceType getSupertype(ClassEntity cls);
/// Returns all supertypes of [cls].
+ // TODO(johnniwinther): This should include `Function` if [cls] declares
+ // a `call` method.
Iterable<InterfaceType> getSupertypes(ClassEntity cls);
/// Returns all types directly implemented by [cls].
diff --git a/pkg/compiler/lib/src/js_backend/backend.dart b/pkg/compiler/lib/src/js_backend/backend.dart
index 1131467..9a025ac 100644
--- a/pkg/compiler/lib/src/js_backend/backend.dart
+++ b/pkg/compiler/lib/src/js_backend/backend.dart
@@ -987,15 +987,11 @@
BackendImpacts impacts =
new BackendImpacts(compiler.options, closedWorld.commonElements);
if (compiler.options.disableRtiOptimization) {
- _rtiSubstitutions = new TrivialRuntimeTypesSubstitutions(
- closedWorld.elementEnvironment, closedWorld.dartTypes);
+ _rtiSubstitutions = new TrivialRuntimeTypesSubstitutions(closedWorld);
_rtiChecksBuilder =
new TrivialRuntimeTypesChecksBuilder(closedWorld, _rtiSubstitutions);
} else {
- RuntimeTypesImpl runtimeTypesImpl = new RuntimeTypesImpl(
- closedWorld.commonElements,
- closedWorld.elementEnvironment,
- closedWorld.dartTypes);
+ RuntimeTypesImpl runtimeTypesImpl = new RuntimeTypesImpl(closedWorld);
_rtiChecksBuilder = runtimeTypesImpl;
_rtiSubstitutions = runtimeTypesImpl;
}
diff --git a/pkg/compiler/lib/src/js_backend/runtime_types.dart b/pkg/compiler/lib/src/js_backend/runtime_types.dart
index 90cbe16..3a880dc 100644
--- a/pkg/compiler/lib/src/js_backend/runtime_types.dart
+++ b/pkg/compiler/lib/src/js_backend/runtime_types.dart
@@ -27,7 +27,7 @@
/// For each class, stores the possible class subtype tests that could succeed.
abstract class TypeChecks {
/// Get the set of checks required for class [element].
- Iterable<TypeCheck> operator [](ClassEntity element);
+ ClassChecks operator [](ClassEntity element);
/// Get the iterable for all classes that need type checks.
Iterable<ClassEntity> get classes;
@@ -167,8 +167,8 @@
/// in the return type or the argument types.
Iterable<ClassEntity> getReferencedClasses(FunctionType type);
- /// Return all classes that use type arguments.
- Iterable<ClassEntity> getRequiredArgumentClasses();
+ /// Return all classes needed for runtime type information.
+ Iterable<ClassEntity> get requiredClasses;
/// Return all classes immediately used in explicit or implicit is-tests.
///
@@ -202,7 +202,7 @@
TypeChecks get requiredChecks => _typeChecks;
@override
- Iterable<ClassEntity> getRequiredArgumentClasses() => _allClasses;
+ Iterable<ClassEntity> get requiredClasses => _allClasses;
@override
Iterable<ClassEntity> getReferencedClasses(FunctionType type) => _allClasses;
@@ -245,13 +245,20 @@
@override
RuntimeTypesChecks computeRequiredChecks(
CodegenWorldBuilder codegenWorldBuilder) {
- Set<ClassEntity> classes = _closedWorld
- .getClassSet(_closedWorld.commonElements.objectClass)
- .subtypes()
- .toSet();
rtiChecksBuilderClosed = true;
+ ClassUse classUse = new ClassUse()
+ ..instance = true
+ ..checkedInstance = true
+ ..typeArgument = true
+ ..checkedTypeArgument = true;
+ Map<ClassEntity, ClassUse> classUseMap = <ClassEntity, ClassUse>{};
+ for (ClassEntity cls in _closedWorld
+ .getClassSet(_closedWorld.commonElements.objectClass)
+ .subtypes()) {
+ classUseMap[cls] = classUse;
+ }
TypeChecks typeChecks = _substitutions._requiredChecks =
- _substitutions._computeChecks(classes, classes);
+ _substitutions._computeChecks(classUseMap);
return new TrivialTypesChecks(typeChecks);
}
@@ -285,31 +292,215 @@
abstract class RuntimeTypesSubstitutionsMixin
implements RuntimeTypesSubstitutions {
- ElementEnvironment get _elementEnvironment;
- DartTypes get _types;
+ ClosedWorld get _closedWorld;
TypeChecks get _requiredChecks;
- TypeChecks _computeChecks(
- Iterable<ClassEntity> instantiated, Iterable<ClassEntity> checked) {
+ ElementEnvironment get _elementEnvironment => _closedWorld.elementEnvironment;
+ DartTypes get _types => _closedWorld.dartTypes;
+ RuntimeTypesNeed get _rtiNeed => _closedWorld.rtiNeed;
+
+ /// Compute the required type checks and substitutions for the given
+ /// instantiated and checked classes.
+ TypeChecks _computeChecks(Map<ClassEntity, ClassUse> classUseMap) {
// Run through the combination of instantiated and checked
// arguments and record all combination where the element of a checked
// argument is a superclass of the element of an instantiated type.
TypeCheckMapping result = new TypeCheckMapping();
- for (ClassEntity element in instantiated) {
- if (checked.contains(element)) {
- result.add(element, element, null);
+ Set<ClassEntity> handled = new Set<ClassEntity>();
+
+ // Empty usage object for classes with no direct rti usage.
+ final ClassUse emptyUse = new ClassUse();
+
+ /// Compute the $isX and $asX functions need for [cls].
+ ClassChecks computeChecks(ClassEntity cls) {
+ if (!handled.add(cls)) return result[cls];
+
+ ClassChecks checks = new ClassChecks();
+ result[cls] = checks;
+ ClassUse classUse = classUseMap[cls] ?? emptyUse;
+
+ // Find the superclass from which [cls] inherits checks.
+ ClassEntity superClass = _elementEnvironment.getSuperClass(cls,
+ skipUnnamedMixinApplications: true);
+ ClassChecks superChecks;
+ bool extendsSuperClassTrivially = false;
+ if (superClass != null) {
+ // Compute the checks inherited from [superClass].
+ superChecks = computeChecks(superClass);
+
+ // Does [cls] extend [superClass] trivially?
+ //
+ // For instance:
+ //
+ // class A<T> {}
+ // class B<S> extends A<S> {}
+ // class C<U, V> extends A<U> {}
+ // class D extends A<int> {}
+ //
+ // here `B` extends `A` trivially, but `C` and `D` don't.
+ extendsSuperClassTrivially = isTrivialSubstitution(cls, superClass);
}
- // Find all supertypes of [element] in [checkedArguments] and add checks
- // and precompute the substitutions for them.
- for (InterfaceType supertype in _types.getSupertypes(element)) {
- ClassEntity superelement = supertype.element;
- if (checked.contains(superelement)) {
- Substitution substitution =
- computeSubstitution(element, superelement);
- result.add(element, superelement, substitution);
+
+ bool isNativeClass = _closedWorld.nativeData.isNativeClass(cls);
+ if (classUse.typeArgument ||
+ (isNativeClass && classUse.checkedInstance)) {
+ // We need [cls] at runtime - even if [cls] is not instantiated. Either
+ // as a type argument or for an is-test if [cls] is native.
+ checks.add(new TypeCheck(cls, null, needsIs: isNativeClass));
+ }
+
+ // Compute the set of classes that [cls] inherited properties from.
+ //
+ // This set reflects the emitted class hierarchy and therefore uses
+ // `getEffectiveMixinClass` to find the inherited mixins.
+ Set<ClassEntity> inheritedClasses = new Set<ClassEntity>();
+ ClassEntity other = cls;
+ while (other != null) {
+ inheritedClasses.add(other);
+ if (_elementEnvironment.isMixinApplication(other)) {
+ inheritedClasses
+ .add(_elementEnvironment.getEffectiveMixinClass(other));
+ }
+ other = _elementEnvironment.getSuperClass(other);
+ }
+
+ /// Compute the needed check for [cls] against the class of the super
+ /// [type].
+ void processSupertype(InterfaceType type) {
+ ClassEntity checkedClass = type.element;
+ ClassUse checkedClassUse = classUseMap[checkedClass] ?? emptyUse;
+
+ // Where [cls] inherits properties for [checkedClass].
+ bool inheritsFromCheckedClass = inheritedClasses.contains(checkedClass);
+
+ // If [cls] inherits properties from [checkedClass] and [checkedClass]
+ // needs type arguments, [cls] must provide a substitution for
+ // [checkedClass].
+ //
+ // For instance:
+ //
+ // class M<T> {
+ // m() => T;
+ // }
+ // class S {}
+ // class C extends S with M<int> {}
+ //
+ // Here `C` needs an `$asM` substitution function to provide the value
+ // of `T` in `M.m`.
+ bool needsTypeArgumentsForCheckedClass = inheritsFromCheckedClass &&
+ _rtiNeed.classNeedsTypeArguments(checkedClass);
+
+ // Whether [checkedClass] is used in an instance test or type argument
+ // test.
+ //
+ // For instance:
+ //
+ // class A {}
+ // class B {}
+ // test(o) => o is A || o is List<B>;
+ //
+ // Here `A` is used in an instance test and `B` is used in a type
+ // argument test.
+ bool isChecked = checkedClassUse.checkedTypeArgument ||
+ checkedClassUse.checkedInstance;
+
+ if (isChecked || needsTypeArgumentsForCheckedClass) {
+ // We need an $isX and/or $asX property on [cls] for [checkedClass].
+
+ // Whether `cls` implements `checkedClass` trivially.
+ //
+ // For instance:
+ //
+ // class A<T> {}
+ // class B<S> implements A<S> {}
+ // class C<U, V> implements A<U> {}
+ // class D implements A<int> {}
+ //
+ // here `B` implements `A` trivially, but `C` and `D` don't.
+ bool implementsCheckedTrivially =
+ isTrivialSubstitution(cls, checkedClass);
+
+ // Whether [checkedClass] is generic.
+ //
+ // Currently [isTrivialSubstitution] reports that [cls] implements
+ // [checkedClass] trivially if [checkedClass] is not generic. In this
+ // case the substitution is not only trivial it is also not needed.
+ bool isCheckedGeneric =
+ _elementEnvironment.isGenericClass(checkedClass);
+
+ // The checks for [checkedClass] inherited for [superClass].
+ TypeCheck checkFromSuperClass =
+ superChecks != null ? superChecks[checkedClass] : null;
+
+ // Whether [cls] need an explicit $isX property for [checkedClass].
+ //
+ // If [cls] inherits from [checkedClass] it also inherits the $isX
+ // property automatically generated on [checkedClass].
+ bool needsIs = !inheritsFromCheckedClass && isChecked;
+
+ if (checkFromSuperClass != null) {
+ // The superclass has a substitution function for [checkedClass].
+ // Check if we can reuse this it of need to override it.
+ //
+ // The inherited $isX property does _not_ need to be overriding.
+ if (extendsSuperClassTrivially) {
+ // [cls] implements [checkedClass] the same way as [superClass]
+ // so the inherited substitution function already works.
+ checks.add(new TypeCheck(checkedClass, null, needsIs: false));
+ } else {
+ // [cls] implements [checkedClass] differently from [superClass]
+ // so the inherited substitution function needs to be replaced.
+ if (implementsCheckedTrivially) {
+ // We need an explicit trivial substitution function for
+ // [checkedClass] that overrides the inherited function.
+ checks.add(new TypeCheck(checkedClass,
+ isCheckedGeneric ? const Substitution.trivial() : null,
+ needsIs: false));
+ } else {
+ // We need a non-trivial substitution function for
+ // [checkedClass].
+ checks.add(new TypeCheck(
+ checkedClass, computeSubstitution(cls, checkedClass),
+ needsIs: false));
+ }
+ }
+ } else {
+ // The superclass has no substitution function for [checkedClass].
+ if (implementsCheckedTrivially) {
+ // We don't add an explicit substitution function for
+ // [checkedClass] because the substitution is trivial and doesn't
+ // need to override an inherited function.
+ checks.add(new TypeCheck(checkedClass, null, needsIs: needsIs));
+ } else {
+ // We need a non-trivial substitution function for
+ // [checkedClass].
+ checks.add(new TypeCheck(
+ checkedClass, computeSubstitution(cls, checkedClass),
+ needsIs: needsIs));
+ }
+ }
}
}
+
+ for (InterfaceType type in _types.getSupertypes(cls)) {
+ processSupertype(type);
+ }
+ FunctionType callType = _types.getCallType(_types.getThisType(cls));
+ if (callType != null) {
+ processSupertype(_closedWorld.commonElements.functionType);
+ }
+ return checks;
}
+
+ for (ClassEntity cls in classUseMap.keys) {
+ ClassUse classUse = classUseMap[cls] ?? emptyUse;
+ if (classUse.instance || classUse.typeArgument) {
+ // Add checks only for classes that are live either as instantiated
+ // classes or type arguments passed at runtime.
+ computeChecks(cls);
+ }
+ }
+
return result;
}
@@ -318,11 +509,14 @@
Set<ClassEntity> instantiated = new Set<ClassEntity>();
ArgumentCollector collector = new ArgumentCollector();
for (ClassEntity target in checks.classes) {
- instantiated.add(target);
- for (TypeCheck check in checks[target]) {
- Substitution substitution = check.substitution;
- if (substitution != null) {
- collector.collectAll(substitution.arguments);
+ ClassChecks classChecks = checks[target];
+ if (classChecks.isNotEmpty) {
+ instantiated.add(target);
+ for (TypeCheck check in classChecks.checks) {
+ Substitution substitution = check.substitution;
+ if (substitution != null) {
+ collector.collectAll(substitution.arguments);
+ }
}
}
}
@@ -371,7 +565,7 @@
@override
Substitution getSubstitution(ClassEntity cls, ClassEntity other) {
// Look for a precomputed check.
- for (TypeCheck check in _requiredChecks[cls]) {
+ for (TypeCheck check in _requiredChecks[cls].checks) {
if (check.cls == other) {
return check.substitution;
}
@@ -400,17 +594,10 @@
}
class TrivialRuntimeTypesSubstitutions extends RuntimeTypesSubstitutionsMixin {
- final ElementEnvironment _elementEnvironment;
- final DartTypes _types;
+ final ClosedWorld _closedWorld;
TypeChecks _requiredChecks;
- TrivialRuntimeTypesSubstitutions(this._elementEnvironment, this._types);
-
- @override
- TypeChecks computeChecks(
- Iterable<ClassEntity> instantiated, Iterable<ClassEntity> checked) {
- return _requiredChecks;
- }
+ TrivialRuntimeTypesSubstitutions(this._closedWorld);
}
/// Interface for computing substitutions need for runtime type checks.
@@ -419,11 +606,6 @@
Substitution getSubstitution(ClassEntity cls, ClassEntity other);
- /// Compute the required type checks and substitutions for the given
- /// instantiated and checked classes.
- TypeChecks computeChecks(
- Iterable<ClassEntity> instantiated, Iterable<ClassEntity> checked);
-
Set<ClassEntity> getClassesUsedInSubstitutions(TypeChecks checks);
static bool hasTypeArguments(DartType type) {
@@ -1168,30 +1350,18 @@
}
class _RuntimeTypesChecks implements RuntimeTypesChecks {
- final RuntimeTypesSubstitutions substitutions;
+ final RuntimeTypesSubstitutions _substitutions;
final TypeChecks requiredChecks;
- final Iterable<ClassEntity> directlyInstantiatedArguments;
- final Iterable<ClassEntity> checkedArguments;
final Iterable<ClassEntity> checkedClasses;
final Iterable<FunctionType> checkedFunctionTypes;
- final TypeVariableTests typeVariableTests;
+ final TypeVariableTests _typeVariableTests;
- _RuntimeTypesChecks(
- this.substitutions,
- this.requiredChecks,
- this.directlyInstantiatedArguments,
- this.checkedArguments,
- this.checkedClasses,
- this.checkedFunctionTypes,
- this.typeVariableTests);
+ _RuntimeTypesChecks(this._substitutions, this.requiredChecks,
+ this.checkedClasses, this.checkedFunctionTypes, this._typeVariableTests);
@override
- Iterable<ClassEntity> getRequiredArgumentClasses() {
- Set<ClassEntity> requiredArgumentClasses = new Set<ClassEntity>.from(
- substitutions.getClassesUsedInSubstitutions(requiredChecks));
- return requiredArgumentClasses
- ..addAll(directlyInstantiatedArguments)
- ..addAll(checkedArguments);
+ Iterable<ClassEntity> get requiredClasses {
+ return _substitutions.getClassesUsedInSubstitutions(requiredChecks);
}
@override
@@ -1203,14 +1373,13 @@
@override
Iterable<ClassEntity> get classesUsingTypeVariableTests =>
- typeVariableTests.classTests;
+ _typeVariableTests.classTests;
}
class RuntimeTypesImpl extends _RuntimeTypesBase
with RuntimeTypesSubstitutionsMixin
implements RuntimeTypesChecksBuilder {
- final CommonElements _commentElements;
- final ElementEnvironment _elementEnvironment;
+ final ClosedWorld _closedWorld;
// The set of type arguments tested against type variable bounds.
final Set<DartType> checkedTypeArguments = new Set<DartType>();
@@ -1221,16 +1390,15 @@
bool rtiChecksBuilderClosed = false;
- RuntimeTypesImpl(
- this._commentElements, this._elementEnvironment, DartTypes types)
- : super(types);
+ RuntimeTypesImpl(this._closedWorld) : super(_closedWorld.dartTypes);
+
+ CommonElements get _commonElements => _closedWorld.commonElements;
+ ElementEnvironment get _elementEnvironment => _closedWorld.elementEnvironment;
+ RuntimeTypesNeed get _rtiNeed => _closedWorld.rtiNeed;
@override
TypeChecks get _requiredChecks => cachedRequiredChecks;
- Set<ClassEntity> directlyInstantiatedArguments;
- Set<ClassEntity> allInstantiatedArguments;
-
@override
void registerTypeVariableBoundsSubtypeCheck(
DartType typeArgument, DartType bound) {
@@ -1241,42 +1409,85 @@
RuntimeTypesChecks computeRequiredChecks(
CodegenWorldBuilder codegenWorldBuilder) {
TypeVariableTests typeVariableTests = new TypeVariableTests(
- _elementEnvironment, _commentElements, _types, codegenWorldBuilder);
+ _elementEnvironment, _commonElements, _types, codegenWorldBuilder);
Set<DartType> explicitIsChecks = typeVariableTests.explicitIsChecks;
Set<DartType> implicitIsChecks = typeVariableTests.implicitIsChecks;
+ Map<ClassEntity, ClassUse> classUseMap = <ClassEntity, ClassUse>{};
+
Set<ClassEntity> checkedClasses = new Set<ClassEntity>();
Set<FunctionType> checkedFunctionTypes = new Set<FunctionType>();
+ TypeVisitor liveTypeVisitor =
+ new TypeVisitor(onClass: (ClassEntity cls, {bool inTypeArgument}) {
+ ClassUse classUse = classUseMap.putIfAbsent(cls, () => new ClassUse());
+ if (inTypeArgument) {
+ classUse.typeArgument = true;
+ }
+ });
+
+ TypeVisitor testedTypeVisitor =
+ new TypeVisitor(onClass: (ClassEntity cls, {bool inTypeArgument}) {
+ ClassUse classUse = classUseMap.putIfAbsent(cls, () => new ClassUse());
+ if (inTypeArgument) {
+ classUse.typeArgument = true;
+ classUse.checkedTypeArgument = true;
+ } else {
+ classUse.checkedInstance = true;
+ }
+ });
+
void processType(DartType t) {
if (t is FunctionType) {
checkedFunctionTypes.add(t);
} else if (t is InterfaceType) {
checkedClasses.add(t.element);
}
+ testedTypeVisitor.visitType(t, false);
}
+ codegenWorldBuilder.instantiatedTypes.forEach((t) {
+ liveTypeVisitor.visitType(t, false);
+ ClassUse classUse =
+ classUseMap.putIfAbsent(t.element, () => new ClassUse());
+ classUse.instance = true;
+ });
+ Set<FunctionType> instantiatedClosureTypes =
+ computeInstantiatedClosureTypes(codegenWorldBuilder);
+ instantiatedClosureTypes.forEach((t) {
+ testedTypeVisitor.visitType(t, false);
+ });
+
explicitIsChecks.forEach(processType);
implicitIsChecks.forEach(processType);
- // These types are needed for is-checks against function types.
- Set<DartType> instantiatedTypesAndClosures =
- computeInstantiatedTypesAndClosures(codegenWorldBuilder);
- computeInstantiatedArguments(
- instantiatedTypesAndClosures, explicitIsChecks, implicitIsChecks);
- Set<ClassEntity> checkedArguments = computeCheckedArguments(
- instantiatedTypesAndClosures, explicitIsChecks, implicitIsChecks);
- cachedRequiredChecks =
- computeChecks(allInstantiatedArguments, checkedArguments);
+ cachedRequiredChecks = _computeChecks(classUseMap);
rtiChecksBuilderClosed = true;
- return new _RuntimeTypesChecks(
- this,
- cachedRequiredChecks,
- directlyInstantiatedArguments,
- checkedArguments,
- checkedClasses,
- checkedFunctionTypes,
- typeVariableTests);
+ return new _RuntimeTypesChecks(this, cachedRequiredChecks, checkedClasses,
+ checkedFunctionTypes, typeVariableTests);
+ }
+
+ Set<FunctionType> computeInstantiatedClosureTypes(
+ CodegenWorldBuilder codegenWorldBuilder) {
+ Set<FunctionType> instantiatedClosureTypes = new Set<FunctionType>();
+ for (InterfaceType instantiatedType
+ in codegenWorldBuilder.instantiatedTypes) {
+ FunctionType callType = _types.getCallType(instantiatedType);
+ if (callType != null) {
+ instantiatedClosureTypes.add(callType);
+ }
+ }
+ for (FunctionEntity element
+ in codegenWorldBuilder.staticFunctionsNeedingGetter) {
+ instantiatedClosureTypes
+ .add(_elementEnvironment.getFunctionType(element));
+ }
+
+ for (FunctionEntity element in codegenWorldBuilder.closurizedMembers) {
+ instantiatedClosureTypes
+ .add(_elementEnvironment.getFunctionType(element));
+ }
+ return instantiatedClosureTypes;
}
Set<DartType> computeInstantiatedTypesAndClosures(
@@ -1300,99 +1511,6 @@
}
return instantiatedTypes;
}
-
- /**
- * Collects all types used in type arguments of instantiated types.
- *
- * This includes type arguments used in supertype relations, because we may
- * have a type check against this supertype that includes a check against
- * the type arguments.
- */
- void computeInstantiatedArguments(Set<DartType> instantiatedTypes,
- Set<DartType> isChecks, Set<DartType> implicitIsChecks) {
- ArgumentCollector superCollector = new ArgumentCollector();
- ArgumentCollector directCollector = new ArgumentCollector();
- FunctionArgumentCollector functionArgumentCollector =
- new FunctionArgumentCollector();
-
- // We need to add classes occurring in function type arguments, like for
- // instance 'I' for [: o is C<f> :] where f is [: typedef I f(); :].
- void collectFunctionTypeArguments(Iterable<DartType> types) {
- for (DartType type in types) {
- functionArgumentCollector.collect(type);
- }
- }
-
- collectFunctionTypeArguments(isChecks);
- collectFunctionTypeArguments(implicitIsChecks);
- collectFunctionTypeArguments(checkedBounds);
-
- void collectTypeArguments(Iterable<DartType> types,
- {bool isTypeArgument: false}) {
- for (DartType type in types) {
- directCollector.collect(type, isTypeArgument: isTypeArgument);
- if (type is InterfaceType) {
- ClassEntity cls = type.element;
- for (InterfaceType supertype in _types.getSupertypes(cls)) {
- superCollector.collect(supertype, isTypeArgument: isTypeArgument);
- }
- }
- }
- }
-
- collectTypeArguments(instantiatedTypes);
- collectTypeArguments(checkedTypeArguments, isTypeArgument: true);
-
- for (ClassEntity cls in superCollector.classes.toList()) {
- for (InterfaceType supertype in _types.getSupertypes(cls)) {
- superCollector.collect(supertype);
- }
- }
-
- directlyInstantiatedArguments = directCollector.classes
- ..addAll(functionArgumentCollector.classes);
- allInstantiatedArguments = superCollector.classes
- ..addAll(directlyInstantiatedArguments);
- }
-
- /// Collects all type arguments used in is-checks.
- Set<ClassEntity> computeCheckedArguments(Set<DartType> instantiatedTypes,
- Set<DartType> isChecks, Set<DartType> implicitIsChecks) {
- ArgumentCollector collector = new ArgumentCollector();
- FunctionArgumentCollector functionArgumentCollector =
- new FunctionArgumentCollector();
-
- // We need to add types occurring in function type arguments, like for
- // instance 'J' for [: (J j) {} is f :] where f is
- // [: typedef void f(I i); :] and 'J' is a subtype of 'I'.
- void collectFunctionTypeArguments(Iterable<DartType> types) {
- for (DartType type in types) {
- functionArgumentCollector.collect(type);
- }
- }
-
- collectFunctionTypeArguments(instantiatedTypes);
- collectFunctionTypeArguments(checkedTypeArguments);
-
- void collectTypeArguments(Iterable<DartType> types,
- {bool isTypeArgument: false}) {
- for (DartType type in types) {
- collector.collect(type, isTypeArgument: isTypeArgument);
- }
- }
-
- collectTypeArguments(isChecks);
- collectTypeArguments(implicitIsChecks);
- collectTypeArguments(checkedBounds, isTypeArgument: true);
-
- return collector.classes..addAll(functionArgumentCollector.classes);
- }
-
- @override
- TypeChecks computeChecks(
- Iterable<ClassEntity> instantiated, Iterable<ClassEntity> checked) {
- return _computeChecks(instantiated, checked);
- }
}
class RuntimeTypesEncoderImpl implements RuntimeTypesEncoder {
@@ -1509,6 +1627,10 @@
@override
jsAst.Expression getSubstitutionCode(
Emitter emitter, Substitution substitution) {
+ if (substitution.isTrivial) {
+ return new jsAst.LiteralNull();
+ }
+
jsAst.Expression declaration(TypeVariableType variable) {
return new jsAst.Parameter(getVariableName(variable.element.name));
}
@@ -1799,17 +1921,15 @@
}
class TypeCheckMapping implements TypeChecks {
- final Map<ClassEntity, Set<TypeCheck>> map =
- new Map<ClassEntity, Set<TypeCheck>>();
+ final Map<ClassEntity, ClassChecks> map = new Map<ClassEntity, ClassChecks>();
- Iterable<TypeCheck> operator [](ClassEntity element) {
- Set<TypeCheck> result = map[element];
- return result != null ? result : const <TypeCheck>[];
+ ClassChecks operator [](ClassEntity element) {
+ ClassChecks result = map[element];
+ return result != null ? result : const ClassChecks.empty();
}
- void add(ClassEntity cls, ClassEntity check, Substitution substitution) {
- map.putIfAbsent(cls, () => new Set<TypeCheck>());
- map[cls].add(new TypeCheck(check, substitution));
+ void operator []=(ClassEntity element, ClassChecks checks) {
+ map[element] = checks;
}
Iterable<ClassEntity> get classes => map.keys;
@@ -1817,7 +1937,7 @@
String toString() {
StringBuffer sb = new StringBuffer();
for (ClassEntity holder in classes) {
- for (TypeCheck check in this[holder]) {
+ for (TypeCheck check in this[holder].checks) {
sb.write('${holder.name} <: ${check.cls.name}, ');
}
}
@@ -1904,18 +2024,28 @@
/// representation consult the documentation of [getSupertypeSubstitution].
//TODO(floitsch): Remove support for non-function substitutions.
class Substitution {
+ final bool isTrivial;
final bool isFunction;
final List<DartType> arguments;
final List<DartType> parameters;
- Substitution.list(this.arguments)
- : isFunction = false,
+ const Substitution.trivial()
+ : isTrivial = true,
+ isFunction = false,
+ arguments = const <DartType>[],
parameters = const <DartType>[];
- Substitution.function(this.arguments, this.parameters) : isFunction = true;
+ Substitution.list(this.arguments)
+ : isTrivial = false,
+ isFunction = false,
+ parameters = const <DartType>[];
- String toString() => 'Substitution(isFunction=$isFunction,'
- 'arguments=$arguments,parameters=$parameters)';
+ Substitution.function(this.arguments, this.parameters)
+ : isTrivial = false,
+ isFunction = true;
+
+ String toString() => 'Substitution(isTrivial=$isTrivial,'
+ 'isFunction=$isFunction,arguments=$arguments,parameters=$parameters)';
}
/**
@@ -1924,11 +2054,148 @@
*/
class TypeCheck {
final ClassEntity cls;
+ final bool needsIs;
final Substitution substitution;
final int hashCode = _nextHash = (_nextHash + 100003).toUnsigned(30);
static int _nextHash = 0;
- TypeCheck(this.cls, this.substitution);
+ TypeCheck(this.cls, this.substitution, {this.needsIs: true});
- String toString() => 'TypeCheck(cls=$cls,substitution=$substitution)';
+ String toString() =>
+ 'TypeCheck(cls=$cls,needsIs=$needsIs,substitution=$substitution)';
+}
+
+class TypeVisitor extends ResolutionDartTypeVisitor<void, bool> {
+ final void Function(ClassEntity entity, {bool inTypeArgument}) onClass;
+ final void Function(TypeVariableEntity entity, {bool inTypeArgument})
+ onTypeVariable;
+ final void Function(FunctionType type, {bool inTypeArgument}) onFunctionType;
+
+ TypeVisitor({this.onClass, this.onTypeVariable, this.onFunctionType});
+
+ visitType(DartType type, bool inTypeArgument) =>
+ type.accept(this, inTypeArgument);
+
+ visitTypes(List<DartType> types, bool inTypeArgument) {
+ for (DartType type in types) {
+ visitType(type, inTypeArgument);
+ }
+ }
+
+ @override
+ void visitTypeVariableType(TypeVariableType type, bool inTypeArgument) {
+ if (onTypeVariable != null) {
+ onTypeVariable(type.element, inTypeArgument: inTypeArgument);
+ }
+ }
+
+ @override
+ visitInterfaceType(InterfaceType type, bool inTypeArgument) {
+ if (onClass != null) {
+ onClass(type.element, inTypeArgument: inTypeArgument);
+ }
+ visitTypes(type.typeArguments, true);
+ }
+
+ @override
+ visitFunctionType(FunctionType type, bool inTypeArgument) {
+ if (onFunctionType != null) {
+ onFunctionType(type, inTypeArgument: inTypeArgument);
+ }
+ // Visit all nested types as type arguments; these types are not runtime
+ // instances but runtime type representations.
+ visitType(type.returnType, true);
+ visitTypes(type.parameterTypes, true);
+ visitTypes(type.optionalParameterTypes, true);
+ visitTypes(type.namedParameterTypes, true);
+ }
+
+ @override
+ visitTypedefType(TypedefType type, bool inTypeArgument) {
+ visitType(type.unaliased, inTypeArgument);
+ }
+
+ @override
+ visitFunctionTypeVariable(FunctionTypeVariable type, bool inTypeArgument) {
+ visitType(type.bound, inTypeArgument);
+ }
+}
+
+/// [TypeCheck]s need for a single class.
+class ClassChecks {
+ final Map<ClassEntity, TypeCheck> _map;
+
+ ClassChecks() : _map = <ClassEntity, TypeCheck>{};
+
+ const ClassChecks.empty() : _map = const <ClassEntity, TypeCheck>{};
+
+ void add(TypeCheck check) {
+ _map[check.cls] = check;
+ }
+
+ TypeCheck operator [](ClassEntity cls) => _map[cls];
+
+ Iterable<TypeCheck> get checks => _map.values;
+
+ bool get isNotEmpty => _map.isNotEmpty;
+
+ String toString() {
+ return 'ClassChecks($checks)';
+ }
+}
+
+/// Runtime type usage for a class.
+class ClassUse {
+ /// Whether the class is instantiated.
+ ///
+ /// For instance `A` in:
+ ///
+ /// class A {}
+ /// main() => new A();
+ ///
+ bool instance = false;
+
+ /// Whether objects are checked to be instances of the class.
+ ///
+ /// For instance `A` in:
+ ///
+ /// class A {}
+ /// main() => null is A;
+ ///
+ bool checkedInstance = false;
+
+ /// Whether the class is passed as a type argument at runtime.
+ ///
+ /// For instance `A` in:
+ ///
+ /// class A {}
+ /// main() => new List<A>() is List<String>();
+ ///
+ bool typeArgument = false;
+
+ /// Whether the class is checked as a type argument at runtime.
+ ///
+ /// For instance `A` in:
+ ///
+ /// class A {}
+ /// main() => new List<String>() is List<A>();
+ ///
+ bool checkedTypeArgument = false;
+
+ String toString() {
+ List<String> properties = <String>[];
+ if (instance) {
+ properties.add('instance');
+ }
+ if (checkedInstance) {
+ properties.add('checkedInstance');
+ }
+ if (typeArgument) {
+ properties.add('typeArgument');
+ }
+ if (checkedTypeArgument) {
+ properties.add('checkedTypeArgument');
+ }
+ return 'ClassUse(${properties.join(',')})';
+ }
}
diff --git a/pkg/compiler/lib/src/js_emitter/code_emitter_task.dart b/pkg/compiler/lib/src/js_emitter/code_emitter_task.dart
index d9cf761..cb3ae06 100644
--- a/pkg/compiler/lib/src/js_emitter/code_emitter_task.dart
+++ b/pkg/compiler/lib/src/js_emitter/code_emitter_task.dart
@@ -199,7 +199,6 @@
backend.superMemberData,
typeTestRegistry.rtiChecks,
backend.rtiEncoder,
- backend.rtiSubstitutions,
backend.jsInteropAnalysis,
backend.oneShotInterceptorData,
backend.customElementsCodegenAnalysis,
diff --git a/pkg/compiler/lib/src/js_emitter/native_emitter.dart b/pkg/compiler/lib/src/js_emitter/native_emitter.dart
index 70e3e35..12110ab 100644
--- a/pkg/compiler/lib/src/js_emitter/native_emitter.dart
+++ b/pkg/compiler/lib/src/js_emitter/native_emitter.dart
@@ -76,10 +76,8 @@
* [classesModifiedByEmitRTISupport] contains the list of classes that must
* exist, because runtime-type support adds information to the class.
*/
- Set<Class> prepareNativeClasses(
- List<Class> classes,
- Set<ClassEntity> interceptorClassesNeededByConstants,
- Set<ClassEntity> classesModifiedByEmitRTISupport) {
+ Set<Class> prepareNativeClasses(List<Class> classes,
+ Set<ClassEntity> interceptorClassesNeededByConstants) {
assert(classes.every((Class cls) => cls != null));
hasNativeClasses = classes.isNotEmpty;
@@ -136,10 +134,6 @@
needed = true;
} else if (interceptorClassesNeededByConstants.contains(classElement)) {
needed = true;
- } else if (classesModifiedByEmitRTISupport.contains(classElement)) {
- // TODO(9556): Remove this test when [emitRuntimeTypeSupport] no longer
- // adds information to a class prototype or constructor.
- needed = true;
} else if (extensionPoints.containsKey(cls)) {
needed = true;
}
diff --git a/pkg/compiler/lib/src/js_emitter/program_builder/collector.dart b/pkg/compiler/lib/src/js_emitter/program_builder/collector.dart
index 8b04d86..7877cdb 100644
--- a/pkg/compiler/lib/src/js_emitter/program_builder/collector.dart
+++ b/pkg/compiler/lib/src/js_emitter/program_builder/collector.dart
@@ -86,7 +86,7 @@
* Return a function that returns true if its argument is a class
* that needs to be emitted.
*/
- Function computeClassFilter() {
+ Function computeClassFilter(Iterable<ClassEntity> backendTypeHelpers) {
if (_mirrorsData.isTreeShakingDisabled) {
return (ClassEntity cls) => true;
}
@@ -117,16 +117,26 @@
}
// These classes are just helpers for the backend's type system.
- unneededClasses.add(_commonElements.jsMutableArrayClass);
- unneededClasses.add(_commonElements.jsFixedArrayClass);
- unneededClasses.add(_commonElements.jsExtendableArrayClass);
- unneededClasses.add(_commonElements.jsUInt32Class);
- unneededClasses.add(_commonElements.jsUInt31Class);
- unneededClasses.add(_commonElements.jsPositiveIntClass);
+ unneededClasses.addAll(backendTypeHelpers);
return (ClassEntity cls) => !unneededClasses.contains(cls);
}
+ // Return the classes that are just helpers for the backend's type system.
+ static Iterable<ClassEntity> getBackendTypeHelpers(
+ CommonElements commonElements) {
+ return <ClassEntity>[
+ commonElements.jsMutableArrayClass,
+ commonElements.jsFixedArrayClass,
+ commonElements.jsExtendableArrayClass,
+ // TODO(johnniwinther): Mark this as a backend type helper:
+ //commonElements.jsUnmodifiableArrayClass,
+ commonElements.jsUInt32Class,
+ commonElements.jsUInt31Class,
+ commonElements.jsPositiveIntClass
+ ];
+ }
+
/**
* Compute all the constants that must be emitted.
*/
@@ -193,6 +203,9 @@
/// Compute all the classes and typedefs that must be emitted.
void computeNeededDeclarations() {
+ Set<ClassEntity> backendTypeHelpers =
+ getBackendTypeHelpers(_commonElements).toSet();
+
// Compute needed typedefs.
typedefsNeededForReflection = _sorter.sortTypedefs(_closedWorld.allTypedefs
.where(_mirrorsData.isTypedefAccessibleByReflection)
@@ -203,7 +216,7 @@
// TODO(johnniwinther): This should be accessed from a codegen closed
// world.
_worldBuilder.directlyInstantiatedClasses
- .where(computeClassFilter())
+ .where(computeClassFilter(backendTypeHelpers))
.toSet();
void addClassWithSuperclasses(ClassEntity cls) {
@@ -240,6 +253,7 @@
// fields, etc.
classesOnlyNeededForRti = new Set<ClassEntity>();
for (ClassEntity cls in _rtiNeededClasses) {
+ if (backendTypeHelpers.contains(cls)) continue;
while (cls != null && !neededClasses.contains(cls)) {
if (!classesOnlyNeededForRti.add(cls)) break;
cls = _elementEnvironment.getSuperClass(cls);
diff --git a/pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart b/pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart
index a6eb6fa..3a68f98 100644
--- a/pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart
+++ b/pkg/compiler/lib/src/js_emitter/program_builder/program_builder.dart
@@ -32,11 +32,7 @@
import '../../js_backend/mirrors_data.dart';
import '../../js_backend/js_interop_analysis.dart';
import '../../js_backend/runtime_types.dart'
- show
- RuntimeTypesChecks,
- RuntimeTypesNeed,
- RuntimeTypesEncoder,
- RuntimeTypesSubstitutions;
+ show RuntimeTypesChecks, RuntimeTypesNeed, RuntimeTypesEncoder;
import '../../native/enqueue.dart' show NativeCodegenEnqueuer;
import '../../options.dart';
import '../../universe/selector.dart' show Selector;
@@ -82,7 +78,6 @@
final SuperMemberData _superMemberData;
final RuntimeTypesChecks _rtiChecks;
final RuntimeTypesEncoder _rtiEncoder;
- final RuntimeTypesSubstitutions _rtiSubstitutions;
final JsInteropAnalysis _jsInteropAnalysis;
final OneShotInterceptorData _oneShotInterceptorData;
final CustomElementsCodegenAnalysis _customElementsCodegenAnalysis;
@@ -130,7 +125,6 @@
this._superMemberData,
this._rtiChecks,
this._rtiEncoder,
- this._rtiSubstitutions,
this._jsInteropAnalysis,
this._oneShotInterceptorData,
this._customElementsCodegenAnalysis,
@@ -248,13 +242,9 @@
Set<ClassEntity> interceptorClassesNeededByConstants =
collector.computeInterceptorsReferencedFromConstants();
- Set<ClassEntity> classesModifiedByEmitRTISupport =
- _task.typeTestRegistry.computeClassesModifiedByEmitRuntimeTypeSupport();
_unneededNativeClasses = _task.nativeEmitter.prepareNativeClasses(
- nativeClasses,
- interceptorClassesNeededByConstants,
- classesModifiedByEmitRTISupport);
+ nativeClasses, interceptorClassesNeededByConstants);
_addJsInteropStubs(_registry.mainLibrariesMap);
@@ -688,17 +678,12 @@
RuntimeTypeGenerator runtimeTypeGenerator = new RuntimeTypeGenerator(
_elementEnvironment,
_commonElements,
- _types,
- _closedWorld,
_closureDataLookup,
_outputUnitData,
_task,
_namer,
- _nativeData,
_rtiChecks,
_rtiEncoder,
- _rtiNeed,
- _rtiSubstitutions,
_jsInteropAnalysis);
void visitMember(MemberEntity member) {
diff --git a/pkg/compiler/lib/src/js_emitter/runtime_type_generator.dart b/pkg/compiler/lib/src/js_emitter/runtime_type_generator.dart
index 751aa63..bb68ca8 100644
--- a/pkg/compiler/lib/src/js_emitter/runtime_type_generator.dart
+++ b/pkg/compiler/lib/src/js_emitter/runtime_type_generator.dart
@@ -20,21 +20,17 @@
import '../js/js.dart' as jsAst;
import '../js/js.dart' show js;
import '../js_backend/js_interop_analysis.dart';
-import '../js_backend/native_data.dart';
import '../js_backend/namer.dart' show Namer;
import '../js_backend/runtime_types.dart'
show
RuntimeTypesChecks,
- RuntimeTypesNeed,
RuntimeTypesEncoder,
- RuntimeTypesSubstitutions,
Substitution,
TypeCheck,
TypeChecks;
import '../js_emitter/sorter.dart';
import '../js_model/closure.dart' show JClosureField;
import '../util/util.dart' show Setlet;
-import '../world.dart';
import 'code_emitter_task.dart' show CodeEmitterTask;
import 'type_test_registry.dart' show TypeTestRegistry;
@@ -43,8 +39,6 @@
typedef void FunctionTypeSignatureEmitter(
FunctionEntity method, FunctionType methodType);
-typedef void SubstitutionEmitter(ClassEntity element, {bool emitNull});
-
class TypeTest {
final jsAst.Name name;
final jsAst.Node expression;
@@ -108,33 +102,23 @@
class RuntimeTypeGenerator {
final ElementEnvironment _elementEnvironment;
final CommonElements _commonElements;
- final DartTypes _types;
- final ClosedWorld _closedWorld;
final ClosureConversionTask _closureDataLookup;
final OutputUnitData _outputUnitData;
final CodeEmitterTask emitterTask;
final Namer _namer;
- final NativeData _nativeData;
final RuntimeTypesChecks _rtiChecks;
final RuntimeTypesEncoder _rtiEncoder;
- final RuntimeTypesNeed _rtiNeed;
- final RuntimeTypesSubstitutions _rtiSubstitutions;
final JsInteropAnalysis _jsInteropAnalysis;
RuntimeTypeGenerator(
this._elementEnvironment,
this._commonElements,
- this._types,
- this._closedWorld,
this._closureDataLookup,
this._outputUnitData,
this.emitterTask,
this._namer,
- this._nativeData,
this._rtiChecks,
this._rtiEncoder,
- this._rtiNeed,
- this._rtiSubstitutions,
this._jsInteropAnalysis);
TypeTestRegistry get _typeTestRegistry => emitterTask.typeTestRegistry;
@@ -165,18 +149,7 @@
assert(!(classElement is ClassElement && !classElement.isDeclaration),
failedAt(classElement));
- /// Generates an is-test if the test is not inherited from a superclass
- /// This assumes that for every class an is-tests is generated
- /// dynamically at runtime. We also always generate tests against
- /// native classes.
- /// TODO(herhut): Generate tests for native classes dynamically, as well.
- void generateIsTest(ClassEntity other) {
- if (_nativeData.isNativeClass(classElement) ||
- !_closedWorld.isSubclassOf(classElement, other)) {
- result.addIsTest(other, _namer.operatorIs(other), js('1'));
- }
- }
-
+ // TODO(johnniwinther): Include function signatures in [ClassChecks].
void generateFunctionTypeSignature(
FunctionEntity method, FunctionType type) {
assert(!(method is MethodElement && !method.isImplementation));
@@ -207,28 +180,12 @@
}
}
- void generateSubstitution(ClassEntity cls, {bool emitNull: false}) {
- if (!_elementEnvironment.isGenericClass(cls)) return;
- jsAst.Expression expression;
- bool needsNativeCheck =
- emitterTask.nativeEmitter.requiresNativeIsCheck(cls);
- Substitution substitution =
- _rtiSubstitutions.getSubstitution(classElement, cls);
- if (substitution != null) {
- expression =
- _rtiEncoder.getSubstitutionCode(emitterTask.emitter, substitution);
- }
- if (expression == null && (emitNull || needsNativeCheck)) {
- expression = new jsAst.LiteralNull();
- }
- if (expression != null) {
- result.addSubstitution(cls, _namer.substitutionName(cls), expression);
- }
- }
-
void generateTypeCheck(TypeCheck check) {
ClassEntity checkedClass = check.cls;
- generateIsTest(checkedClass);
+ if (check.needsIs) {
+ result.addIsTest(
+ checkedClass, _namer.operatorIs(checkedClass), js('1'));
+ }
Substitution substitution = check.substitution;
if (substitution != null) {
jsAst.Expression body =
@@ -239,12 +196,7 @@
}
_generateIsTestsOn(
- classElement,
- generateIsTest,
- generateFunctionTypeSignature,
- (ClassEntity e, {bool emitNull: false}) =>
- generateSubstitution(e, emitNull: emitNull),
- generateTypeCheck);
+ classElement, generateFunctionTypeSignature, generateTypeCheck);
if (classElement == _commonElements.jsJavaScriptFunctionClass) {
var type = _jsInteropAnalysis.buildJsFunctionType();
@@ -268,21 +220,13 @@
*/
void _generateIsTestsOn(
ClassEntity cls,
- void generateIsTest(ClassEntity element),
FunctionTypeSignatureEmitter generateFunctionTypeSignature,
- SubstitutionEmitter generateSubstitution,
void emitTypeCheck(TypeCheck check)) {
Setlet<ClassEntity> generated = new Setlet<ClassEntity>();
- if (checkedClasses.contains(cls)) {
- generateIsTest(cls);
- generateSubstitution(cls);
- generated.add(cls);
- }
-
// Precomputed is checks.
TypeChecks typeChecks = _rtiChecks.requiredChecks;
- Iterable<TypeCheck> classChecks = typeChecks[cls];
+ Iterable<TypeCheck> classChecks = typeChecks[cls].checks;
if (classChecks != null) {
for (TypeCheck check in classChecks) {
if (!generated.contains(check.cls)) {
@@ -292,59 +236,6 @@
}
}
- ClassEntity superclass = _elementEnvironment.getSuperClass(cls);
-
- bool haveSameTypeVariables(ClassEntity a, ClassEntity b) {
- if (a.isClosure) return true;
- return _rtiSubstitutions.isTrivialSubstitution(a, b);
- }
-
- bool supertypesNeedSubstitutions = false;
-
- if (superclass != null &&
- superclass != _commonElements.objectClass &&
- !haveSameTypeVariables(cls, superclass)) {
- // We cannot inherit the generated substitutions, because the type
- // variable layout for this class is different. Instead we generate
- // substitutions for all checks and make emitSubstitution a NOP for the
- // rest of this function.
-
- // TODO(karlklose): move the computation of these checks to
- // RuntimeTypeInformation.
- while (superclass != null) {
- if (_rtiNeed.classNeedsTypeArguments(superclass)) {
- generateSubstitution(superclass, emitNull: true);
- generated.add(superclass);
- }
- superclass = _elementEnvironment.getSuperClass(superclass);
- }
- supertypesNeedSubstitutions = true;
- }
-
- if (_elementEnvironment.isMixinApplication(cls)) {
- supertypesNeedSubstitutions = true;
- }
-
- if (supertypesNeedSubstitutions) {
- _elementEnvironment.forEachSupertype(cls, (InterfaceType supertype) {
- ClassEntity superclass = supertype.element;
- if (generated.contains(superclass)) return;
-
- if (classesUsingTypeVariableTests.contains(superclass) ||
- _rtiNeed.classUsesTypeVariableLiteral(superclass) ||
- checkedClasses.contains(superclass)) {
- // Generate substitution. If no substitution is necessary, emit
- // `null` to overwrite a (possibly) existing substitution from the
- // super classes.
- generateSubstitution(superclass, emitNull: true);
- }
- });
-
- void emitNothing(_, {emitNull}) {}
-
- generateSubstitution = emitNothing;
- }
-
// A class that defines a `call` method implicitly implements
// [Function] and needs checks for all typedefs that are used in is-checks.
if (checkedClasses.contains(_commonElements.functionClass) ||
@@ -353,57 +244,10 @@
_elementEnvironment.lookupLocalClassMember(cls, Identifiers.call);
if (call != null && call.isFunction) {
FunctionEntity callFunction = call;
- // A superclass might already implement the Function interface. In such
- // a case, we can avoid emitting the is test here.
- ClassEntity superclass = _elementEnvironment.getSuperClass(cls);
- if (!_closedWorld.isSubtypeOf(
- superclass, _commonElements.functionClass)) {
- _generateInterfacesIsTests(_commonElements.functionClass,
- generateIsTest, generateSubstitution, generated);
- }
FunctionType callType =
_elementEnvironment.getFunctionType(callFunction);
generateFunctionTypeSignature(callFunction, callType);
}
}
-
- for (InterfaceType interfaceType in _types.getInterfaces(cls)) {
- _generateInterfacesIsTests(interfaceType.element, generateIsTest,
- generateSubstitution, generated);
- }
- }
-
- /**
- * Generate "is tests" where [cls] is being implemented.
- */
- void _generateInterfacesIsTests(
- ClassEntity cls,
- void generateIsTest(ClassEntity element),
- SubstitutionEmitter generateSubstitution,
- Set<ClassEntity> alreadyGenerated) {
- void tryEmitTest(ClassEntity check) {
- if (!alreadyGenerated.contains(check) && checkedClasses.contains(check)) {
- alreadyGenerated.add(check);
- generateIsTest(check);
- generateSubstitution(check);
- }
- }
-
- tryEmitTest(cls);
-
- for (InterfaceType interfaceType in _types.getInterfaces(cls)) {
- ClassEntity element = interfaceType.element;
- tryEmitTest(element);
- _generateInterfacesIsTests(
- element, generateIsTest, generateSubstitution, alreadyGenerated);
- }
-
- // We need to also emit "is checks" for the superclass and its supertypes.
- ClassEntity superclass = _elementEnvironment.getSuperClass(cls);
- if (superclass != null) {
- tryEmitTest(superclass);
- _generateInterfacesIsTests(
- superclass, generateIsTest, generateSubstitution, alreadyGenerated);
- }
}
}
diff --git a/pkg/compiler/lib/src/js_emitter/type_test_registry.dart b/pkg/compiler/lib/src/js_emitter/type_test_registry.dart
index 0e31b7c..a740fb0 100644
--- a/pkg/compiler/lib/src/js_emitter/type_test_registry.dart
+++ b/pkg/compiler/lib/src/js_emitter/type_test_registry.dart
@@ -12,8 +12,7 @@
show
RuntimeTypesChecks,
RuntimeTypesChecksBuilder,
- RuntimeTypesSubstitutions,
- TypeChecks;
+ RuntimeTypesSubstitutions;
import '../js_backend/mirrors_data.dart';
import '../universe/world_builder.dart';
import '../world.dart' show ClosedWorld;
@@ -49,22 +48,6 @@
return _rtiNeededClasses;
}
- /**
- * Returns the classes with constructors used as a 'holder' in
- * [emitRuntimeTypeSupport].
- * TODO(9556): Some cases will go away when the class objects are created as
- * complete. Not all classes will go away while constructors are referenced
- * from type substitutions.
- */
- Set<ClassEntity> computeClassesModifiedByEmitRuntimeTypeSupport() {
- TypeChecks typeChecks = rtiChecks.requiredChecks;
- Set<ClassEntity> result = new Set<ClassEntity>();
- for (ClassEntity cls in typeChecks.classes) {
- if (typeChecks[cls].isNotEmpty) result.add(cls);
- }
- return result;
- }
-
void computeRtiNeededClasses(RuntimeTypesSubstitutions rtiSubstitutions,
MirrorsData mirrorsData, Iterable<MemberEntity> liveMembers) {
_rtiNeededClasses = new Set<ClassEntity>();
@@ -86,19 +69,9 @@
// 1. Add classes that are referenced by type arguments or substitutions in
// argument checks.
- // TODO(karlklose): merge this case with 2 when unifying argument and
- // object checks.
- rtiChecks
- .getRequiredArgumentClasses()
- .forEach((e) => addClassWithSuperclasses(e));
+ addClassesWithSuperclasses(rtiChecks.requiredClasses);
- // 2. Add classes that are referenced by substitutions in object checks and
- // their superclasses.
- Set<ClassEntity> classesUsedInSubstitutions = rtiSubstitutions
- .getClassesUsedInSubstitutions(rtiChecks.requiredChecks);
- addClassesWithSuperclasses(classesUsedInSubstitutions);
-
- // 3. Add classes that contain checked generic function types. These are
+ // 2. Add classes that contain checked generic function types. These are
// needed to store the signature encoding.
for (FunctionType type in rtiChecks.checkedFunctionTypes) {
ClassEntity contextClass = DartTypes.getClassContext(type);
diff --git a/pkg/compiler/lib/src/js_model/closure.dart b/pkg/compiler/lib/src/js_model/closure.dart
index 30d7a36..ab6b21e 100644
--- a/pkg/compiler/lib/src/js_model/closure.dart
+++ b/pkg/compiler/lib/src/js_model/closure.dart
@@ -260,6 +260,10 @@
_memberClosureRepresentationMap[closureClassInfo.signatureMethod] =
closureClassInfo;
_globalLocalsMap.setLocalsMap(closureClassInfo.callMethod, localsMap);
+ if (_strongMode) {
+ _globalLocalsMap.setLocalsMap(
+ closureClassInfo.signatureMethod, localsMap);
+ }
if (node.parent is ir.Member) {
assert(_elementMap.getMember(node.parent) == member);
_memberClosureRepresentationMap[member] = closureClassInfo;
diff --git a/pkg/compiler/lib/src/ssa/builder_kernel.dart b/pkg/compiler/lib/src/ssa/builder_kernel.dart
index 7c42e2c..9d4b34a 100644
--- a/pkg/compiler/lib/src/ssa/builder_kernel.dart
+++ b/pkg/compiler/lib/src/ssa/builder_kernel.dart
@@ -900,7 +900,7 @@
/// that no corresponding ir.Node actually exists for it. We just use the
/// targetElement.
void buildMethodSignature(ir.FunctionNode originalClosureNode) {
- openFunction(targetElement);
+ openFunction(targetElement, originalClosureNode);
List<HInstruction> typeArguments = <HInstruction>[];
// Add function type variables.
diff --git a/pkg/dev_compiler/tool/ddb b/pkg/dev_compiler/tool/ddb
new file mode 100755
index 0000000..4bead5f
--- /dev/null
+++ b/pkg/dev_compiler/tool/ddb
@@ -0,0 +1,209 @@
+#!/usr/bin/env dart
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+//
+// Compiles code with DDC and runs the resulting code with either node or
+// chrome.
+//
+// The first script supplied should be the one with `main()`.
+//
+// Saves the output in the same directory as the sources for convenient
+// inspection, modification or rerunning the code.
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:args/args.dart' show ArgParser;
+import 'package:path/path.dart' as path;
+
+void main(List<String> args) {
+ // Parse flags.
+ var parser = new ArgParser()
+ ..addFlag('kernel',
+ abbr: 'k', help: 'Compile with the new kernel-based front end.')
+ ..addFlag('debug',
+ abbr: 'd',
+ help: 'Use current source instead of built SDK.',
+ defaultsTo: false)
+ ..addOption('runtime',
+ abbr: 'r',
+ help: 'Platform to run on (node|d8|chrome). Default is node.',
+ allowed: ['node', 'd8', 'chrome'],
+ defaultsTo: 'node')
+ ..addOption('binary', abbr: 'b', help: 'Runtime binary path.');
+
+ var options = parser.parse(args);
+ if (options.rest.length != 1) {
+ throw 'Expected a single dart entrypoint.';
+ }
+ var entry = options.rest.first;
+ var libRoot = path.dirname(entry);
+ var basename = path.basenameWithoutExtension(entry);
+
+ var debug = options['debug'] as bool;
+ var kernel = options['kernel'] as bool;
+ var binary = options['binary'] as String;
+
+ var dartBinary = Platform.resolvedExecutable;
+ var dartPath = path.dirname(dartBinary);
+ var dartSdk = path.dirname(dartPath);
+ var toolPath = Platform.script.normalizePath().toFilePath();
+ var ddcPath = path.dirname(path.dirname(toolPath));
+
+ ProcessResult runDdc(String command, List<String> args) {
+ if (debug) {
+ // Use unbuilt script. This only works from a source checkout.
+ args.insertAll(0, ['-c', path.join(ddcPath, 'bin', '${command}.dart')]);
+ command = dartBinary;
+ } else {
+ // Use built snapshot.
+ command = path.join(dartPath, command);
+ }
+ return Process.runSync(command, args);
+ }
+
+ String mod;
+ bool chrome = false;
+ bool node = false;
+ bool d8 = false;
+ switch (options['runtime']) {
+ case 'node':
+ node = true;
+ mod = 'common';
+ break;
+ case 'd8':
+ d8 = true;
+ mod = 'es6';
+ break;
+ case 'chrome':
+ chrome = true;
+ mod = 'amd';
+ break;
+ }
+ var sdkJsPath = path.join(dartSdk, 'lib', 'dev_compiler', mod);
+
+ ProcessResult result;
+ if (kernel) {
+ var ddcSdk = path.join(dartSdk, 'lib', '_internal', 'ddc_sdk.dill');
+ result = runDdc('dartdevk', [
+ '--modules=$mod',
+ '--dart-sdk-summary=$ddcSdk',
+ '-o',
+ '$basename.js',
+ entry
+ ]);
+ } else {
+ result = runDdc('dartdevc', [
+ '--modules=$mod',
+ '--library-root=$libRoot',
+ '-o',
+ '$basename.js',
+ entry
+ ]);
+ }
+
+ print(result.stdout);
+ if (result.exitCode != 0) {
+ print(result.stderr);
+ exit(result.exitCode);
+ }
+
+ if (chrome) {
+ String chromeBinary;
+ if (binary != null) {
+ chromeBinary = binary;
+ } else if (Platform.isWindows) {
+ chromeBinary =
+ 'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe';
+ } else if (Platform.isMacOS) {
+ chromeBinary =
+ '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+ } else {
+ // Assume Linux
+ chromeBinary = 'google-chrome';
+ }
+
+ var html = """
+<script src='$sdkJsPath/require.js'></script>
+<script>
+ require.config({
+ baseUrl: '$libRoot',
+ paths: {
+ 'dart_sdk': '$sdkJsPath/dart_sdk'
+ },
+ waitSeconds: 15
+ });
+ require(['dart_sdk', '$basename'],
+ function(sdk, app) {
+ 'use strict';
+ sdk._debugger.registerDevtoolsFormatter();
+ sdk.dart.ignoreWhitelistedErrors(false);
+ sdk._isolate_helper.startRootIsolate(() => {}, []);
+ app.$basename.main();
+ });
+</script>
+""";
+ var htmlFile = '$libRoot/$basename.html';
+ new File(htmlFile).writeAsStringSync(html);
+ var tmp = path.join(Directory.systemTemp.path, 'ddc');
+
+ result = Process.runSync(chromeBinary,
+ ['--auto-open-devtools-for-tabs', '--user-data-dir=$tmp', htmlFile]);
+ } else if (node) {
+ var nodePath = '$sdkJsPath:$libRoot';
+ var runjs = '''
+ let source_maps;
+ try {
+ source_maps = require('source-map-support');
+ source_maps.install();
+ } catch(e) {
+ }
+ let sdk = require(\"dart_sdk\");
+ let main = require(\"./$basename\").$basename.main;
+ sdk.dart.ignoreWhitelistedErrors(false);
+ try {
+ sdk._isolate_helper.startRootIsolate(main, []);
+ } catch(e) {
+ if (!source_maps) {
+ console.log('For Dart source maps: npm install source-map-support');
+ }
+ console.error(e.toString(), sdk.dart.stackTrace(e).toString());
+ process.exit(1);
+ }
+ ''';
+ var nodeFile = '$libRoot/$basename.run.js';
+ new File(nodeFile).writeAsStringSync(runjs);
+ var nodeBinary = binary ?? 'node';
+ result = Process
+ .runSync(nodeBinary, [nodeFile], environment: {'NODE_PATH': nodePath});
+ stdout
+ ..write(result.stdout)
+ ..flush();
+ } else if (d8) {
+ var runjs = '''
+ import { dart, _isolate_helper } from '$sdkJsPath/dart_sdk.js';
+ import { $basename } from '$basename.js';
+ let main = $basename.main;
+ dart.ignoreWhitelistedErrors(false);
+ try {
+ _isolate_helper.startRootIsolate(() => {}, []);
+ main();
+ } catch(e) {
+ console.error(e.toString(), dart.stackTrace(e).toString());
+ }
+ ''';
+ var d8File = '$libRoot/$basename.d8.js';
+ new File(d8File).writeAsStringSync(runjs);
+ var d8Binary = binary ?? 'd8';
+ result = Process.runSync(binary, ['--module', d8File]);
+ stdout
+ ..write(result.stdout)
+ ..flush();
+ }
+ if (result.exitCode != 0) {
+ print(result.stderr);
+ exit(result.exitCode);
+ }
+}
diff --git a/pkg/front_end/lib/src/fasta/parser/parser.dart b/pkg/front_end/lib/src/fasta/parser/parser.dart
index 2c46b7b..9f07a92 100644
--- a/pkg/front_end/lib/src/fasta/parser/parser.dart
+++ b/pkg/front_end/lib/src/fasta/parser/parser.dart
@@ -3289,64 +3289,81 @@
Token parseInitializer(Token token) {
Token next = token.next;
listener.beginInitializer(next);
+ Token beforeExpression = token;
if (optional('assert', next)) {
token = parseAssert(token, Assert.Initializer);
+ listener.endInitializer(token.next);
+ return token;
} else if (optional('super', next)) {
- token = parseExpression(token);
+ return parseInitializerExpressionRest(token);
} else if (optional('this', next)) {
- if (!optional('(', next.next)) {
- if (!optional('.', next.next)) {
+ token = next;
+ next = token.next;
+ if (optional('.', next)) {
+ token = next;
+ next = token.next;
+ if (next.isIdentifier) {
+ token = next;
+ } else {
// Recovery
- reportRecoverableError(
- next.next, fasta.templateExpectedButGot.withArguments('.'));
- rewriter.insertTokenAfter(
- next, new SyntheticToken(TokenType.PERIOD, next.next.offset));
+ token = insertSyntheticIdentifier(
+ token, IdentifierContext.fieldInitializer);
}
- next = next.next;
- if (!next.next.isIdentifier) {
- // Recovery
- insertSyntheticIdentifier(next, IdentifierContext.fieldInitializer);
+ next = token.next;
+ if (optional('=', next)) {
+ return parseInitializerExpressionRest(beforeExpression);
}
- next = next.next;
}
- if (optional('(', next.next)) {
- token = parseExpression(token);
+ if (optional('(', next)) {
+ token = parseInitializerExpressionRest(beforeExpression);
next = token.next;
if (optional('{', next) || optional('=>', next)) {
reportRecoverableError(
next, fasta.messageRedirectingConstructorWithBody);
}
- } else {
- if (!optional('=', next.next)) {
- // Recovery
- reportRecoverableError(
- token.next, fasta.messageMissingAssignmentInInitializer);
- next = rewriter
- .insertTokenAfter(
- next, new SyntheticToken(TokenType.EQ, next.next.offset))
- .next;
- rewriter.insertTokenAfter(next,
- new SyntheticStringToken(TokenType.IDENTIFIER, '', next.offset));
- }
- token = parseExpression(token);
+ return token;
}
- } else if (next.isIdentifier) {
- if (!optional('=', next.next)) {
- // Recovery
- next = insertSyntheticIdentifier(
- token, IdentifierContext.fieldInitializer,
- message: fasta.messageMissingAssignmentInInitializer,
- messageOnToken: next);
+ // Recovery
+ if (optional('this', token)) {
+ // TODO(danrubel): Consider a better error message indicating that
+ // `this.<fieldname>=` is expected.
+ reportRecoverableError(
+ next, fasta.templateExpectedButGot.withArguments('.'));
rewriter.insertTokenAfter(
- next, new SyntheticToken(TokenType.EQ, next.offset));
+ token, new SyntheticToken(TokenType.PERIOD, next.offset));
+ token = token.next;
+ rewriter.insertTokenAfter(token,
+ new SyntheticStringToken(TokenType.IDENTIFIER, '', next.offset));
+ token = token.next;
+ next = token.next;
}
- token = parseExpression(token);
+ // Fall through to recovery
+ } else if (next.isIdentifier) {
+ if (optional('=', next.next)) {
+ return parseInitializerExpressionRest(token);
+ }
+ // Fall through to recovery
} else {
// Recovery
insertSyntheticIdentifier(token, IdentifierContext.fieldInitializer,
message: fasta.messageExpectedAnInitializer, messageOnToken: token);
- token = parseExpression(token);
+ return parseInitializerExpressionRest(beforeExpression);
}
+ // Recovery
+ // Insert a sythetic assignment to ensure that the expression is indeed
+ // an assignment. Failing to do so causes this test to fail:
+ // pkg/front_end/testcases/regress/issue_31192.dart
+ // TODO(danrubel): Investigate better recovery.
+ token = insertSyntheticIdentifier(
+ beforeExpression, IdentifierContext.fieldInitializer,
+ message: fasta.messageMissingAssignmentInInitializer);
+ rewriter.insertTokenAfter(
+ token, new SyntheticToken(TokenType.EQ, token.offset));
+ return parseInitializerExpressionRest(beforeExpression);
+ }
+
+ Token parseInitializerExpressionRest(Token token) {
+ token = parseExpression(token);
listener.endInitializer(token.next);
return token;
}
diff --git a/pkg/front_end/lib/src/fasta/parser/parser.md b/pkg/front_end/lib/src/fasta/parser/parser.md
index bf4999c..acbc13e 100644
--- a/pkg/front_end/lib/src/fasta/parser/parser.md
+++ b/pkg/front_end/lib/src/fasta/parser/parser.md
@@ -12,8 +12,6 @@
* In parseSwitchCase, the parser uses peekPastLabels to select between case
labels and statement labels.
- * The parser uses isGeneralizedFunctionType in parseType, and findMemberName.
-
- * The parser uses findMemberName in parseTopLevelMember, and parseMember.
+ * The parser uses isGeneralizedFunctionType in parseType.
* The parser uses isValidMethodTypeArguments in parseSend.
diff --git a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
index 375def5..ab381f5 100644
--- a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
@@ -216,10 +216,17 @@
if (!dottedName.startsWith(prefix)) return "";
dottedName = dottedName.substring(prefix.length);
- LibraryBuilder coreLibrary =
- loader.read(resolve(this.uri, "dart:core", -1), -1);
LibraryBuilder imported =
- coreLibrary.loader.builders[new Uri(scheme: 'dart', path: dottedName)];
+ loader.builders[new Uri(scheme: "dart", path: dottedName)];
+
+ if (imported == null) {
+ LibraryBuilder coreLibrary = loader.read(
+ resolve(
+ this.uri, new Uri(scheme: "dart", path: "core").toString(), -1),
+ -1);
+ imported = coreLibrary
+ .loader.builders[new Uri(scheme: 'dart', path: dottedName)];
+ }
return imported != null ? "true" : "";
}
diff --git a/pkg/kernel/lib/transformations/async.dart b/pkg/kernel/lib/transformations/async.dart
index 8f8133e..72a0d20 100644
--- a/pkg/kernel/lib/transformations/async.dart
+++ b/pkg/kernel/lib/transformations/async.dart
@@ -413,16 +413,31 @@
// The statements are in reverse order, so name the result first if
// necessary and then add the two other statements in reverse.
if (shouldName) result = name(result);
- statements.add(R.createContinuationPoint()..fileOffset = expr.fileOffset);
Arguments arguments = new Arguments(<Expression>[
expr.operand,
new VariableGet(R.thenContinuationVariable),
new VariableGet(R.catchErrorContinuationVariable),
new VariableGet(R.nestedClosureVariable),
]);
- statements.add(new ExpressionStatement(
- new StaticInvocation(R.helper.awaitHelper, arguments)
- ..fileOffset = expr.fileOffset));
+
+ // We are building
+ //
+ // [yield] (let _ = _awaitHelper(...) in null)
+ //
+ // to ensure that :await_jump_var and :await_jump_ctx are updated
+ // before _awaitHelper is invoked (see BuildYieldStatement in
+ // StreamingFlowGraphBuilder for details of how [yield] is translated to
+ // IL). This guarantees that recursive invocation of the current function
+ // would continue from the correct "jump" position. Recursive invocations
+ // arise if future we are awaiting completes synchronously. Builtin Future
+ // implementation don't complete synchronously, but Flutter's
+ // SynchronousFuture do (see bug http://dartbug.com/32098 for more details).
+ statements.add(R.createContinuationPoint(new Let(
+ new VariableDeclaration(null,
+ initializer: new StaticInvocation(R.helper.awaitHelper, arguments)
+ ..fileOffset = expr.fileOffset),
+ new NullLiteral()))
+ ..fileOffset = expr.fileOffset);
seenAwait = false;
var index = nameIndex;
diff --git a/pkg/kernel/lib/transformations/continuation.dart b/pkg/kernel/lib/transformations/continuation.dart
index 9d8e50e..d6ff80f 100644
--- a/pkg/kernel/lib/transformations/continuation.dart
+++ b/pkg/kernel/lib/transformations/continuation.dart
@@ -27,6 +27,13 @@
return rewriter.rewriteProgram(program);
}
+Procedure transformProcedure(
+ CoreTypes coreTypes, Procedure procedure, bool syncAsync) {
+ var helper = new HelperNodes.fromCoreTypes(coreTypes);
+ var rewriter = new RecursiveContinuationRewriter(helper, syncAsync);
+ return rewriter.visitProcedure(procedure);
+}
+
class RecursiveContinuationRewriter extends Transformer {
final HelperNodes helper;
diff --git a/runtime/bin/platform_fuchsia.cc b/runtime/bin/platform_fuchsia.cc
index d0277e0..24936b7 100644
--- a/runtime/bin/platform_fuchsia.cc
+++ b/runtime/bin/platform_fuchsia.cc
@@ -150,14 +150,12 @@
exit(exit_code);
}
-bool Platform::SaveConsoleConfiguration() {
+void Platform::SaveConsoleConfiguration() {
UNIMPLEMENTED();
- return false;
}
-bool Platform::RestoreConsoleConfiguration() {
+void Platform::RestoreConsoleConfiguration() {
UNIMPLEMENTED();
- return false;
}
} // namespace bin
diff --git a/runtime/vm/compiler/backend/il.h b/runtime/vm/compiler/backend/il.h
index 3b57ef0..3a95a1a 100644
--- a/runtime/vm/compiler/backend/il.h
+++ b/runtime/vm/compiler/backend/il.h
@@ -3019,16 +3019,12 @@
intptr_t type_args_len,
const Array& argument_names,
PushArgumentsArray* arguments,
- TokenPosition token_pos,
- intptr_t argument_check_bits = 0,
- intptr_t type_argument_check_bits = 0)
+ TokenPosition token_pos)
: TemplateDefinition<kInputCount, Throws>(deopt_id),
type_args_len_(type_args_len),
argument_names_(argument_names),
arguments_(arguments),
- token_pos_(token_pos),
- argument_check_bits_(argument_check_bits),
- type_argument_check_bits_(type_argument_check_bits) {
+ token_pos_(token_pos) {
ASSERT(argument_names.IsZoneHandle() || argument_names.InVMHeap());
}
@@ -3047,13 +3043,7 @@
virtual TokenPosition token_pos() const { return token_pos_; }
RawArray* GetArgumentsDescriptor() const {
return ArgumentsDescriptor::New(
- type_args_len(), ArgumentCountWithoutTypeArgs(), argument_names(),
- argument_check_bits(), type_argument_check_bits());
- }
-
- intptr_t argument_check_bits() const { return argument_check_bits_; }
- intptr_t type_argument_check_bits() const {
- return type_argument_check_bits_;
+ type_args_len(), ArgumentCountWithoutTypeArgs(), argument_names());
}
private:
@@ -3062,12 +3052,6 @@
PushArgumentsArray* arguments_;
TokenPosition token_pos_;
- // One bit per argument (up to word size) which helps the callee decide which
- // arguments it needs to check. See the comments in ArgumentsDescriptor for
- // more information on strong-mode checked calls.
- intptr_t argument_check_bits_;
- intptr_t type_argument_check_bits_;
-
DISALLOW_COPY_AND_ASSIGN(TemplateDartCall);
};
@@ -3128,16 +3112,12 @@
intptr_t checked_argument_count,
const ZoneGrowableArray<const ICData*>& ic_data_array,
intptr_t deopt_id,
- const Function& interface_target = Function::null_function(),
- intptr_t argument_check_bits = 0,
- intptr_t type_argument_check_bits = 0)
+ const Function& interface_target = Function::null_function())
: TemplateDartCall(deopt_id,
type_args_len,
argument_names,
arguments,
- token_pos,
- argument_check_bits,
- type_argument_check_bits),
+ token_pos),
ic_data_(NULL),
function_name_(function_name),
token_kind_(token_kind),
@@ -3168,16 +3148,12 @@
const Array& argument_names,
intptr_t checked_argument_count,
intptr_t deopt_id,
- const Function& interface_target = Function::null_function(),
- intptr_t argument_check_bits = 0,
- intptr_t type_argument_check_bits = 0)
+ const Function& interface_target = Function::null_function())
: TemplateDartCall(deopt_id,
type_args_len,
argument_names,
arguments,
- token_pos,
- argument_check_bits,
- type_argument_check_bits),
+ token_pos),
ic_data_(NULL),
function_name_(function_name),
token_kind_(token_kind),
@@ -3638,16 +3614,12 @@
PushArgumentsArray* arguments,
const ZoneGrowableArray<const ICData*>& ic_data_array,
intptr_t deopt_id,
- ICData::RebindRule rebind_rule,
- intptr_t argument_check_bits = 0,
- intptr_t type_argument_check_bits = 0)
+ ICData::RebindRule rebind_rule)
: TemplateDartCall(deopt_id,
type_args_len,
argument_names,
arguments,
- token_pos,
- argument_check_bits,
- type_argument_check_bits),
+ token_pos),
ic_data_(NULL),
call_count_(0),
function_(function),
@@ -3667,14 +3639,12 @@
PushArgumentsArray* arguments,
intptr_t deopt_id,
intptr_t call_count,
- ICData::RebindRule rebind_rule,
- intptr_t argument_check_bits = 0)
+ ICData::RebindRule rebind_rule)
: TemplateDartCall(deopt_id,
type_args_len,
argument_names,
arguments,
- token_pos,
- argument_check_bits),
+ token_pos),
ic_data_(NULL),
call_count_(call_count),
function_(function),
diff --git a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
index ec29c10e..dd4a560 100644
--- a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
+++ b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
@@ -1766,7 +1766,7 @@
case kYieldStatement: {
builder_->ReadPosition(); // read position.
word flags = builder_->ReadByte(); // read flags.
- builder_->SkipExpression(); // read expression.
+ VisitExpression(); // read expression.
ASSERT(flags == kNativeYieldFlags);
if (depth_.function_ == 0) {
@@ -5827,13 +5827,10 @@
const Array& argument_names,
ICData::RebindRule rebind_rule,
const InferredTypeMetadata* result_type,
- intptr_t type_args_count,
- intptr_t argument_check_bits,
- intptr_t type_argument_check_bits) {
+ intptr_t type_args_count) {
return flow_graph_builder_->StaticCall(
position, target, argument_count, argument_names, rebind_rule,
- result_type, type_args_count, argument_check_bits,
- type_argument_check_bits);
+ result_type, type_args_count);
}
Fragment StreamingFlowGraphBuilder::InstanceCall(
@@ -5857,13 +5854,10 @@
const Array& argument_names,
intptr_t checked_argument_count,
const Function& interface_target,
- const InferredTypeMetadata* result_type,
- intptr_t argument_check_bits,
- intptr_t type_argument_check_bits) {
+ const InferredTypeMetadata* result_type) {
return flow_graph_builder_->InstanceCall(
position, name, kind, type_args_len, argument_count, argument_names,
- checked_argument_count, interface_target, result_type,
- argument_check_bits, type_argument_check_bits);
+ checked_argument_count, interface_target, result_type);
}
Fragment StreamingFlowGraphBuilder::ThrowException(TokenPosition position) {
@@ -6291,7 +6285,7 @@
const TokenPosition position = ReadPosition(); // read position.
if (p != NULL) *p = position;
- uint8_t flags = ReadFlags(); // read flags
+ ReadFlags(); // skip flags
instructions += BuildExpression(); // read receiver.
@@ -6319,12 +6313,6 @@
ASSERT(setter_name.raw() == interface_target->name());
}
- intptr_t argument_check_bits = 0;
- if (I->strong()) {
- argument_check_bits = ArgumentCheckBitsForSetter(
- *interface_target, static_cast<DispatchCategory>(flags & 3));
- }
-
if (direct_call.check_receiver_for_null_) {
instructions += CheckNull(position, receiver);
}
@@ -6333,15 +6321,14 @@
ASSERT(FLAG_precompiled_mode);
instructions +=
StaticCall(position, direct_call.target_, 2, Array::null_array(),
- ICData::kNoRebind, /* result_type = */ NULL,
- /*type_args_len=*/0, argument_check_bits);
+ ICData::kNoRebind, /* result_type = */ NULL);
} else {
const intptr_t kTypeArgsLen = 0;
const intptr_t kNumArgsChecked = 1;
instructions +=
InstanceCall(position, setter_name, Token::kSET, kTypeArgsLen, 2,
Array::null_array(), kNumArgsChecked, *interface_target,
- /* result_type = */ NULL, argument_check_bits);
+ /* result_type = */ NULL);
}
instructions += Drop(); // Drop result of the setter invocation.
@@ -6624,7 +6611,7 @@
const TokenPosition position = ReadPosition(); // read position.
if (p != NULL) *p = position;
- uint8_t flags = ReadFlags(); // read flags.
+ ReadFlags(); // skip flags.
Fragment instructions(NullConstant());
LocalVariable* value = MakeTemporary();
@@ -6643,9 +6630,6 @@
instructions += StoreLocal(TokenPosition::kNoSource, value);
instructions += PushArgument();
- intptr_t argument_check_bits = ArgumentCheckBitsForSetter(
- target, static_cast<DispatchCategory>(flags & 3));
-
// Static calls are marked as "no-rebind", which is currently safe because
// DirectPropertyGet are only used in enums (index in toString) and enums
// can't change their structure during hot reload.
@@ -6653,9 +6637,7 @@
// have to be adjusted.
instructions +=
StaticCall(position, target, 2, Array::null_array(), ICData::kNoRebind,
- /* result_type = */ NULL,
- /*type_args_len=*/0, argument_check_bits,
- /*type_argument_check_bits=*/0);
+ /* result_type = */ NULL);
return instructions + Drop();
}
@@ -6752,177 +6734,6 @@
tag == kSpecialIntLiteral || tag == kDoubleLiteral;
}
-intptr_t StreamingFlowGraphBuilder::ArgumentCheckBitsForSetter(
- const Function& interface_target,
- DispatchCategory category) {
- intptr_t argument_check_bits = 0;
-
- switch (category) {
- case DynamicDispatch:
- argument_check_bits = 2; // 1 for value, 0 for receiver
- break;
- case Closure:
- // A property set cannot be a closure call.
- UNREACHABLE();
- case ViaThis:
- // All bits are 0.
- break;
- case Interface: {
- // TODO(sjindel): Revise checking interface target for null.
- if (interface_target.IsNull() ||
- !interface_target.IsImplicitGetterOrSetter()) {
- intptr_t type_argument_check_bits_unused;
- ArgumentCheckBitsForInvocation(
- 1, 0, 1, Array::null_array(), interface_target, category,
- &argument_check_bits, &type_argument_check_bits_unused);
- break;
- }
-
- const Field& target_field =
- Field::Handle(interface_target.LookupImplicitGetterSetterField());
- ASSERT(!target_field.IsNull());
- TypedData& kernel_data = TypedData::Handle(Z, target_field.KernelData());
- ASSERT(!kernel_data.IsNull());
- AlternativeReadingScope r(reader_, &kernel_data,
- target_field.kernel_offset());
- AlternativeScriptScope s(&translation_helper_,
- Script::Handle(target_field.Script()), script());
-
- FieldHelper helper(this);
- helper.ReadUntilIncluding(FieldHelper::kFlags);
-
- argument_check_bits = 1; // indicate dispatch category
- if (helper.IsGenericCovariantInterface()) {
- argument_check_bits |= 1 << 1;
- }
- }
- }
-
- return argument_check_bits;
-}
-
-void StreamingFlowGraphBuilder::ArgumentCheckBitsForInvocation(
- intptr_t argument_count, // excluding receiver
- intptr_t type_argument_count,
- intptr_t positional_argument_count,
- const Array& argument_names,
- const Function& interface_target,
- DispatchCategory category,
- intptr_t* argument_bits /*out*/,
- intptr_t* type_argument_bits /*out*/) {
- intptr_t argument_check_bits = 0;
- intptr_t type_argument_check_bits = 0;
-
- // If there are more than 'kBitsPerWord - 1' arguments, the rest will be
- // assumed to be marked as 1 (the '-1' is because of the receiver).
- int strong_checked_arguments =
- Utils::Minimum<intptr_t>(argument_count, kBitsPerWord - 1);
- int strong_checked_type_arguments =
- Utils::Minimum<intptr_t>(type_argument_count, kBitsPerWord);
-
- switch (category) {
- case DynamicDispatch:
- // All bits are 1 except the receiver which is 0.
- argument_check_bits = Utils::SignedNBitMask(strong_checked_arguments)
- << 1;
- type_argument_check_bits =
- Utils::SignedNBitMask(strong_checked_type_arguments);
- case ViaThis:
- // All bits are 0.
- break;
- case Closure:
- // All bits at 1.
- argument_check_bits = Utils::SignedNBitMask(strong_checked_arguments + 1);
- type_argument_check_bits =
- Utils::SignedNBitMask(strong_checked_type_arguments);
- break;
- case Interface: {
- ASSERT(!interface_target.IsNull() || !I->strong());
- if (interface_target.IsNull()) {
- argument_check_bits =
- Utils::SignedNBitMask(strong_checked_arguments + 1);
- type_argument_check_bits =
- Utils::SignedNBitMask(strong_checked_type_arguments);
- break;
- }
- argument_check_bits = 1;
- TypedData& kernel_data =
- TypedData::Handle(Z, interface_target.KernelData());
- ASSERT(!kernel_data.IsNull());
- AlternativeReadingScope _r(reader_, &kernel_data,
- interface_target.kernel_offset());
- AlternativeScriptScope _s(&translation_helper_,
- Script::Handle(interface_target.script()),
- script());
- ReadUntilFunctionNode();
-
- FunctionNodeHelper fn_helper(this);
- fn_helper.ReadUntilExcluding(FunctionNodeHelper::kTypeParameters);
- intptr_t num_interface_type_params = ReadListLength();
- // Maybe this can be ==?
- ASSERT(num_interface_type_params >= type_argument_count);
-
- for (intptr_t i = 0; i < num_interface_type_params; ++i) {
- uint8_t flags = ReadFlags();
- SkipListOfExpressions();
- SkipStringReference();
- SkipDartType();
- if (i >= strong_checked_type_arguments) continue;
- if (flags & TypeParameterHelper::kIsGenericCovariantInterface) {
- type_argument_check_bits |= Utils::Bit(i);
- }
- }
-
- fn_helper.SetJustRead(FunctionNodeHelper::kTypeParameters);
- fn_helper.ReadUntilExcluding(FunctionNodeHelper::kPositionalParameters);
- intptr_t num_interface_pos_params = ReadListLength();
- ASSERT(num_interface_pos_params >= positional_argument_count);
-
- intptr_t arg = 0;
- for (; arg < num_interface_pos_params; ++arg) {
- VariableDeclarationHelper var_helper(this);
- var_helper.ReadUntilExcluding(VariableDeclarationHelper::kEnd);
- if (arg >= strong_checked_arguments) continue;
- if (var_helper.IsGenericCovariantInterface()) {
- argument_check_bits |= Utils::Bit(arg + 1); // +1 for the receiver
- }
- }
-
- fn_helper.SetJustRead(FunctionNodeHelper::kPositionalParameters);
- if (argument_names.IsNull()) break;
-
- fn_helper.ReadUntilExcluding(FunctionNodeHelper::kNamedParameters);
- intptr_t num_interface_named_params = ReadListLength();
- for (intptr_t i = 0;
- i < argument_names.Length() && arg <= strong_checked_arguments;
- ++i, ++arg) {
- const String& arg_name =
- String::Handle(Z, String::RawCast(argument_names.At(i)));
-
- // Scan through the named parameters of the interface target to find
- // the right one.
- AlternativeReadingScope _(reader_);
- for (intptr_t j = 0; j < num_interface_named_params; ++j) {
- VariableDeclarationHelper var_helper(this);
- var_helper.ReadUntilExcluding(VariableDeclarationHelper::kEnd);
- const String& param_name = H.DartSymbol(var_helper.name_index_);
- if (!param_name.Equals(arg_name)) continue;
- if (var_helper.IsGenericCovariantInterface()) {
- argument_check_bits |= Utils::NBitMask(arg + 1);
- }
- break;
- }
- }
- break;
- }
- default:
- UNREACHABLE();
- }
-
- *argument_bits = argument_check_bits;
- *type_argument_bits = type_argument_check_bits;
-}
-
Fragment StreamingFlowGraphBuilder::BuildMethodInvocation(TokenPosition* p) {
const intptr_t offset = ReaderOffset() - 1; // Include the tag.
const TokenPosition position = ReadPosition(); // read position.
@@ -6933,7 +6744,7 @@
const InferredTypeMetadata result_type =
inferred_type_metadata_helper_.GetInferredType(offset);
- uint8_t flags = ReadFlags(); // read flags.
+ ReadFlags(); // skip flags.
const Tag receiver_tag = PeekTag(); // peek tag for receiver.
if (IsNumberLiteral(receiver_tag) &&
@@ -7068,27 +6879,15 @@
instructions += CheckNull(position, receiver_temp);
}
- intptr_t argument_check_bits = 0;
- intptr_t type_argument_check_bits = 0;
- if (I->strong()) {
- ArgumentCheckBitsForInvocation(
- argument_count - 1, type_args_len, positional_argument_count,
- argument_names, *interface_target,
- static_cast<DispatchCategory>(flags & 3), &argument_check_bits,
- &type_argument_check_bits);
- }
-
if (!direct_call.target_.IsNull()) {
ASSERT(FLAG_precompiled_mode);
instructions += StaticCall(position, direct_call.target_, argument_count,
argument_names, ICData::kNoRebind, &result_type,
- type_args_len, argument_check_bits,
- type_argument_check_bits);
+ type_args_len);
} else {
instructions += InstanceCall(
position, name, token_kind, type_args_len, argument_count,
- argument_names, checked_argument_count, *interface_target, &result_type,
- argument_check_bits, type_argument_check_bits);
+ argument_names, checked_argument_count, *interface_target, &result_type);
}
// Drop temporaries preserving result on the top of the stack.
@@ -7120,7 +6919,7 @@
const InferredTypeMetadata result_type =
inferred_type_metadata_helper_.GetInferredType(offset);
- uint8_t flags = ReadFlags(); // read flags.
+ ReadFlags(); // skip flags.
Tag receiver_tag = PeekTag(); // peek tag for receiver.
@@ -7177,16 +6976,9 @@
&positional_argument_count); // read arguments.
++argument_count;
- intptr_t argument_check_bits, type_argument_check_bits;
- ArgumentCheckBitsForInvocation(
- argument_count, type_args_len, positional_argument_count, argument_names,
- target, static_cast<DispatchCategory>(flags & 3), &argument_check_bits,
- &type_argument_check_bits);
-
return instructions +
StaticCall(position, target, argument_count, argument_names,
- ICData::kNoRebind, &result_type, type_args_len,
- argument_check_bits, type_argument_check_bits);
+ ICData::kNoRebind, &result_type, type_args_len);
}
Fragment StreamingFlowGraphBuilder::BuildSuperMethodInvocation(
diff --git a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.h b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.h
index b99111b..34df86f 100644
--- a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.h
+++ b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.h
@@ -1148,9 +1148,7 @@
const Array& argument_names,
ICData::RebindRule rebind_rule,
const InferredTypeMetadata* result_type = NULL,
- intptr_t type_args_len = 0,
- intptr_t argument_check_bits = 0,
- intptr_t type_argument_check_bits = 0);
+ intptr_t type_args_len = 0);
Fragment InstanceCall(TokenPosition position,
const String& name,
Token::Kind kind,
@@ -1164,9 +1162,7 @@
const Array& argument_names,
intptr_t checked_argument_count,
const Function& interface_target,
- const InferredTypeMetadata* result_type = NULL,
- intptr_t argument_check_bits = 0,
- intptr_t type_argument_check_bits = 0);
+ const InferredTypeMetadata* result_type = NULL);
enum TypeChecksToBuild {
kDefaultTypeChecks,
@@ -1332,19 +1328,6 @@
bool is_closure,
FunctionNodeHelper* function_node_helper);
- intptr_t ArgumentCheckBitsForSetter(const Function& interface_target,
- DispatchCategory category);
-
- void ArgumentCheckBitsForInvocation(
- intptr_t argument_count, // excluding receiver
- intptr_t type_argument_count,
- intptr_t positional_argument_count,
- const Array& argument_names,
- const Function& interface_target,
- DispatchCategory category,
- intptr_t* argument_bits,
- intptr_t* type_argument_bits);
-
const Script& script() { return script_; }
// Scan through metadata mappings section and cache offsets for recognized
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc
index f004628..ede8726 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.cc
+++ b/runtime/vm/compiler/frontend/kernel_to_il.cc
@@ -1235,15 +1235,13 @@
const Array& argument_names,
intptr_t checked_argument_count,
const Function& interface_target,
- const InferredTypeMetadata* result_type,
- intptr_t argument_bits,
- intptr_t type_argument_bits) {
+ const InferredTypeMetadata* result_type) {
const intptr_t total_count = argument_count + (type_args_len > 0 ? 1 : 0);
ArgumentArray arguments = GetArguments(total_count);
InstanceCallInstr* call = new (Z) InstanceCallInstr(
position, name, kind, arguments, type_args_len, argument_names,
checked_argument_count, ic_data_array_, GetNextDeoptId(),
- interface_target, argument_bits, type_argument_bits);
+ interface_target);
if (result_type != NULL) {
call->SetResultType(Z, CompileType::CreateNullable(result_type->nullable,
result_type->cid));
@@ -1512,15 +1510,12 @@
const Array& argument_names,
ICData::RebindRule rebind_rule,
const InferredTypeMetadata* result_type,
- intptr_t type_args_count,
- intptr_t argument_bits,
- intptr_t type_argument_check_bits) {
+ intptr_t type_args_count) {
const intptr_t total_count = argument_count + (type_args_count > 0 ? 1 : 0);
ArgumentArray arguments = GetArguments(total_count);
StaticCallInstr* call = new (Z)
StaticCallInstr(position, target, type_args_count, argument_names,
- arguments, ic_data_array_, GetNextDeoptId(), rebind_rule,
- argument_bits, type_argument_check_bits);
+ arguments, ic_data_array_, GetNextDeoptId(), rebind_rule);
const intptr_t list_cid =
GetResultCidOfListFactory(Z, target, argument_count);
if (list_cid != kDynamicCid) {
diff --git a/runtime/vm/compiler/frontend/kernel_to_il.h b/runtime/vm/compiler/frontend/kernel_to_il.h
index 6d9948d..13df421 100644
--- a/runtime/vm/compiler/frontend/kernel_to_il.h
+++ b/runtime/vm/compiler/frontend/kernel_to_il.h
@@ -700,9 +700,7 @@
const Array& argument_names,
intptr_t checked_argument_count,
const Function& interface_target,
- const InferredTypeMetadata* result_type = NULL,
- intptr_t argument_bits = 0,
- intptr_t type_argument_bits = 0);
+ const InferredTypeMetadata* result_type = NULL);
Fragment ClosureCall(intptr_t type_args_len,
intptr_t argument_count,
const Array& argument_names);
@@ -731,9 +729,7 @@
const Array& argument_names,
ICData::RebindRule rebind_rule,
const InferredTypeMetadata* result_type = NULL,
- intptr_t type_args_len = 0,
- intptr_t argument_bits = 0,
- intptr_t type_argument_check_bits = 0);
+ intptr_t type_args_len = 0);
Fragment StoreIndexed(intptr_t class_id);
Fragment StoreInstanceFieldGuarded(const Field& field,
bool is_initialization_store);
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 21580bd..840ca2f 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -22574,15 +22574,45 @@
}
}
}
+
+ // Workaround for http://dartbug.com/32087: currently Kernel front-end
+ // embeds absolute build-time paths to core library sources into Kernel
+ // binaries this introduces discrepancy between how stack traces were
+ // looked like in legacy pipeline and how they look in Dart 2 pipeline and
+ // breaks users' code that attempts to pattern match and filter various
+ // irrelevant frames (e.g. frames from dart:async).
+ // To work around this issue we reformat urls of scripts belonging to
+ // dart:-scheme libraries to look like they looked like in legacy pipeline:
+ //
+ // dart:libname/filename.dart
+ //
+ const char* url_string = url.ToCString();
+ if (script.kernel_program_info() != KernelProgramInfo::null()) {
+ const Class& owner = Class::Handle(function.Owner());
+ const Library& lib = Library::Handle(owner.library());
+ if (lib.is_dart_scheme()) {
+ // Search backwards until '/' is found. That gives us the filename.
+ intptr_t pos = strlen(url_string) - 1;
+ while (pos >= 0 && url_string[pos] != '/') {
+ pos--;
+ }
+ const char* filename = url_string + (pos + 1);
+
+ // Glue together canonic library url (e.g. dart:async) and filename.
+ url_string = zone->PrintToString(
+ "%s/%s", String::Handle(lib.url()).ToCString(), filename);
+ }
+ }
+
if (column >= 0) {
buffer->Printf("#%-6" Pd " %s (%s:%" Pd ":%" Pd ")\n", frame_index,
- function_name.ToCString(), url.ToCString(), line, column);
+ function_name.ToCString(), url_string, line, column);
} else if (line >= 0) {
buffer->Printf("#%-6" Pd " %s (%s:%" Pd ")\n", frame_index,
- function_name.ToCString(), url.ToCString(), line);
+ function_name.ToCString(), url_string, line);
} else {
buffer->Printf("#%-6" Pd " %s (%s)\n", frame_index,
- function_name.ToCString(), url.ToCString());
+ function_name.ToCString(), url_string);
}
}
diff --git a/sdk/lib/typed_data/typed_data.dart b/sdk/lib/typed_data/typed_data.dart
index c15a3f0..9c20289 100644
--- a/sdk/lib/typed_data/typed_data.dart
+++ b/sdk/lib/typed_data/typed_data.dart
@@ -10,6 +10,10 @@
/// import 'dart:typed_data';
library dart.typed_data;
+import "dart:_internal" show UnmodifiableListBase;
+
+part "unmodifiable_typed_data.dart";
+
/**
* A sequence of bytes underlying a typed data object.
*
diff --git a/sdk/lib/typed_data/typed_data_sources.gni b/sdk/lib/typed_data/typed_data_sources.gni
index daa50aa..23ba0f0 100644
--- a/sdk/lib/typed_data/typed_data_sources.gni
+++ b/sdk/lib/typed_data/typed_data_sources.gni
@@ -5,4 +5,5 @@
typed_data_sdk_sources = [
"typed_data.dart",
# The above file needs to be first if additional parts are added to the lib.
+ "unmodifiable_typed_data.dart",
]
diff --git a/sdk/lib/typed_data/unmodifiable_typed_data.dart b/sdk/lib/typed_data/unmodifiable_typed_data.dart
new file mode 100644
index 0000000..4cc5af7
--- /dev/null
+++ b/sdk/lib/typed_data/unmodifiable_typed_data.dart
@@ -0,0 +1,303 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+part of dart.typed_data;
+
+/**
+ * A read-only view of a [ByteBuffer].
+ */
+class UnmodifiableByteBufferView implements ByteBuffer {
+ final ByteBuffer _data;
+
+ UnmodifiableByteBufferView(ByteBuffer data) : _data = data;
+
+ int get lengthInBytes => _data.lengthInBytes;
+
+ Uint8List asUint8List([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableUint8ListView(_data.asUint8List(offsetInBytes, length));
+
+ Int8List asInt8List([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableInt8ListView(_data.asInt8List(offsetInBytes, length));
+
+ Uint8ClampedList asUint8ClampedList([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableUint8ClampedListView(
+ _data.asUint8ClampedList(offsetInBytes, length));
+
+ Uint16List asUint16List([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableUint16ListView(_data.asUint16List(offsetInBytes, length));
+
+ Int16List asInt16List([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableInt16ListView(_data.asInt16List(offsetInBytes, length));
+
+ Uint32List asUint32List([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableUint32ListView(_data.asUint32List(offsetInBytes, length));
+
+ Int32List asInt32List([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableInt32ListView(_data.asInt32List(offsetInBytes, length));
+
+ Uint64List asUint64List([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableUint64ListView(_data.asUint64List(offsetInBytes, length));
+
+ Int64List asInt64List([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableInt64ListView(_data.asInt64List(offsetInBytes, length));
+
+ Int32x4List asInt32x4List([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableInt32x4ListView(
+ _data.asInt32x4List(offsetInBytes, length));
+
+ Float32List asFloat32List([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableFloat32ListView(
+ _data.asFloat32List(offsetInBytes, length));
+
+ Float64List asFloat64List([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableFloat64ListView(
+ _data.asFloat64List(offsetInBytes, length));
+
+ Float32x4List asFloat32x4List([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableFloat32x4ListView(
+ _data.asFloat32x4List(offsetInBytes, length));
+
+ Float64x2List asFloat64x2List([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableFloat64x2ListView(
+ _data.asFloat64x2List(offsetInBytes, length));
+
+ ByteData asByteData([int offsetInBytes = 0, int length]) =>
+ new UnmodifiableByteDataView(_data.asByteData(offsetInBytes, length));
+}
+
+/**
+ * A read-only view of a [ByteData].
+ */
+class UnmodifiableByteDataView implements ByteData {
+ final ByteData _data;
+
+ UnmodifiableByteDataView(ByteData data) : _data = data;
+
+ int getInt8(int byteOffset) => _data.getInt8(byteOffset);
+
+ void setInt8(int byteOffset, int value) => _unsupported();
+
+ int getUint8(int byteOffset) => _data.getUint8(byteOffset);
+
+ void setUint8(int byteOffset, int value) => _unsupported();
+
+ int getInt16(int byteOffset, [Endian endian = Endian.big]) =>
+ _data.getInt16(byteOffset, endian);
+
+ void setInt16(int byteOffset, int value, [Endian endian = Endian.big]) =>
+ _unsupported();
+
+ int getUint16(int byteOffset, [Endian endian = Endian.big]) =>
+ _data.getUint16(byteOffset, endian);
+
+ void setUint16(int byteOffset, int value, [Endian endian = Endian.big]) =>
+ _unsupported();
+
+ int getInt32(int byteOffset, [Endian endian = Endian.big]) =>
+ _data.getInt32(byteOffset, endian);
+
+ void setInt32(int byteOffset, int value, [Endian endian = Endian.big]) =>
+ _unsupported();
+
+ int getUint32(int byteOffset, [Endian endian = Endian.big]) =>
+ _data.getUint32(byteOffset, endian);
+
+ void setUint32(int byteOffset, int value, [Endian endian = Endian.big]) =>
+ _unsupported();
+
+ int getInt64(int byteOffset, [Endian endian = Endian.big]) =>
+ _data.getInt64(byteOffset, endian);
+
+ void setInt64(int byteOffset, int value, [Endian endian = Endian.big]) =>
+ _unsupported();
+
+ int getUint64(int byteOffset, [Endian endian = Endian.big]) =>
+ _data.getUint64(byteOffset, endian);
+
+ void setUint64(int byteOffset, int value, [Endian endian = Endian.big]) =>
+ _unsupported();
+
+ double getFloat32(int byteOffset, [Endian endian = Endian.big]) =>
+ _data.getFloat32(byteOffset, endian);
+
+ void setFloat32(int byteOffset, double value, [Endian endian = Endian.big]) =>
+ _unsupported();
+
+ double getFloat64(int byteOffset, [Endian endian = Endian.big]) =>
+ _data.getFloat64(byteOffset, endian);
+
+ void setFloat64(int byteOffset, double value, [Endian endian = Endian.big]) =>
+ _unsupported();
+
+ int get elementSizeInBytes => _data.elementSizeInBytes;
+
+ int get offsetInBytes => _data.offsetInBytes;
+
+ int get lengthInBytes => _data.lengthInBytes;
+
+ ByteBuffer get buffer => new UnmodifiableByteBufferView(_data.buffer);
+
+ void _unsupported() {
+ throw new UnsupportedError(
+ "An UnmodifiableByteDataView may not be modified");
+ }
+}
+
+abstract class _UnmodifiableListMixin<N, L extends List<N>,
+ TD extends TypedData> {
+ L get _list;
+ TD get _data => (_list as TD);
+
+ int get length => _list.length;
+
+ N operator [](int index) => _list[index];
+
+ int get elementSizeInBytes => _data.elementSizeInBytes;
+
+ int get offsetInBytes => _data.offsetInBytes;
+
+ int get lengthInBytes => _data.lengthInBytes;
+
+ ByteBuffer get buffer => new UnmodifiableByteBufferView(_data.buffer);
+}
+
+/**
+ * View of a [Uint8List] that disallows modification.
+ */
+class UnmodifiableUint8ListView extends UnmodifiableListBase<int>
+ with _UnmodifiableListMixin<int, Uint8List, Uint8List>
+ implements Uint8List {
+ final Uint8List _list;
+ UnmodifiableUint8ListView(Uint8List list) : _list = list;
+}
+
+/**
+ * View of a [Int8List] that disallows modification.
+ */
+class UnmodifiableInt8ListView extends UnmodifiableListBase<int>
+ with _UnmodifiableListMixin<int, Int8List, Int8List>
+ implements Int8List {
+ final Int8List _list;
+ UnmodifiableInt8ListView(Int8List list) : _list = list;
+}
+
+/**
+ * View of a [Uint8ClampedList] that disallows modification.
+ */
+class UnmodifiableUint8ClampedListView extends UnmodifiableListBase<int>
+ with _UnmodifiableListMixin<int, Uint8ClampedList, Uint8ClampedList>
+ implements Uint8ClampedList {
+ final Uint8ClampedList _list;
+ UnmodifiableUint8ClampedListView(Uint8ClampedList list) : _list = list;
+}
+
+/**
+ * View of a [Uint16List] that disallows modification.
+ */
+class UnmodifiableUint16ListView extends UnmodifiableListBase<int>
+ with _UnmodifiableListMixin<int, Uint16List, Uint16List>
+ implements Uint16List {
+ final Uint16List _list;
+ UnmodifiableUint16ListView(Uint16List list) : _list = list;
+}
+
+/**
+ * View of a [Int16List] that disallows modification.
+ */
+class UnmodifiableInt16ListView extends UnmodifiableListBase<int>
+ with _UnmodifiableListMixin<int, Int16List, Int16List>
+ implements Int16List {
+ final Int16List _list;
+ UnmodifiableInt16ListView(Int16List list) : _list = list;
+}
+
+/**
+ * View of a [Uint32List] that disallows modification.
+ */
+class UnmodifiableUint32ListView extends UnmodifiableListBase<int>
+ with _UnmodifiableListMixin<int, Uint32List, Uint32List>
+ implements Uint32List {
+ final Uint32List _list;
+ UnmodifiableUint32ListView(Uint32List list) : _list = list;
+}
+
+/**
+ * View of a [Int32List] that disallows modification.
+ */
+class UnmodifiableInt32ListView extends UnmodifiableListBase<int>
+ with _UnmodifiableListMixin<int, Int32List, Int32List>
+ implements Int32List {
+ final Int32List _list;
+ UnmodifiableInt32ListView(Int32List list) : _list = list;
+}
+
+/**
+ * View of a [Uint64List] that disallows modification.
+ */
+class UnmodifiableUint64ListView extends UnmodifiableListBase<int>
+ with _UnmodifiableListMixin<int, Uint64List, Uint64List>
+ implements Uint64List {
+ final Uint64List _list;
+ UnmodifiableUint64ListView(Uint64List list) : _list = list;
+}
+
+/**
+ * View of a [Int64List] that disallows modification.
+ */
+class UnmodifiableInt64ListView extends UnmodifiableListBase<int>
+ with _UnmodifiableListMixin<int, Int64List, Int64List>
+ implements Int64List {
+ final Int64List _list;
+ UnmodifiableInt64ListView(Int64List list) : _list = list;
+}
+
+/**
+ * View of a [Int32x4List] that disallows modification.
+ */
+class UnmodifiableInt32x4ListView extends UnmodifiableListBase<Int32x4>
+ with _UnmodifiableListMixin<Int32x4, Int32x4List, Int32x4List>
+ implements Int32x4List {
+ final Int32x4List _list;
+ UnmodifiableInt32x4ListView(Int32x4List list) : _list = list;
+}
+
+/**
+ * View of a [Float32x4List] that disallows modification.
+ */
+class UnmodifiableFloat32x4ListView extends UnmodifiableListBase<Float32x4>
+ with _UnmodifiableListMixin<Float32x4, Float32x4List, Float32x4List>
+ implements Float32x4List {
+ final Float32x4List _list;
+ UnmodifiableFloat32x4ListView(Float32x4List list) : _list = list;
+}
+
+/**
+ * View of a [Float64x2List] that disallows modification.
+ */
+class UnmodifiableFloat64x2ListView extends UnmodifiableListBase<Float64x2>
+ with _UnmodifiableListMixin<Float64x2, Float64x2List, Float64x2List>
+ implements Float64x2List {
+ final Float64x2List _list;
+ UnmodifiableFloat64x2ListView(Float64x2List list) : _list = list;
+}
+
+/**
+ * View of a [Float32List] that disallows modification.
+ */
+class UnmodifiableFloat32ListView extends UnmodifiableListBase<double>
+ with _UnmodifiableListMixin<double, Float32List, Float32List>
+ implements Float32List {
+ final Float32List _list;
+ UnmodifiableFloat32ListView(Float32List list) : _list = list;
+}
+
+/**
+ * View of a [Float64List] that disallows modification.
+ */
+class UnmodifiableFloat64ListView extends UnmodifiableListBase<double>
+ with _UnmodifiableListMixin<double, Float64List, Float64List>
+ implements Float64List {
+ final Float64List _list;
+ UnmodifiableFloat64ListView(Float64List list) : _list = list;
+}
diff --git a/tests/compiler/dart2js/dart2js.status b/tests/compiler/dart2js/dart2js.status
index 0e0083a..c7649a6 100644
--- a/tests/compiler/dart2js/dart2js.status
+++ b/tests/compiler/dart2js/dart2js.status
@@ -37,7 +37,8 @@
old_frontend/resolver_test: RuntimeError # Test must be updated given new parser recovery
packages/*: Skip # Skip packages folder
quarantined/http_test: Pass, Slow
-rti/rti_need_test: Pass, Slow, Fail # Issue 32055
+rti/rti_emission_test: Pass, Slow
+rti/rti_need_test: Pass, Slow
serialization/analysis1_test: Skip # Skip most serialization tests. These are very slow and are no longer a priority.
serialization/analysis3_test: Skip # Skip most serialization tests. These are very slow and are no longer a priority.
serialization/analysis4_test: Skip # Skip most serialization tests. These are very slow and are no longer a priority.
diff --git a/tests/compiler/dart2js/equivalence/id_equivalence_helper.dart b/tests/compiler/dart2js/equivalence/id_equivalence_helper.dart
index b51545e..23dfb6f 100644
--- a/tests/compiler/dart2js/equivalence/id_equivalence_helper.dart
+++ b/tests/compiler/dart2js/equivalence/id_equivalence_helper.dart
@@ -855,10 +855,17 @@
/// Set of features used in annotations.
class Features {
- Map<String, String> _features = <String, String>{};
+ Map<String, Object> _features = <String, Object>{};
void add(String key, {var value: ''}) {
- _features[key] = value;
+ _features[key] = value.toString();
+ }
+
+ void addElement(String key, [var value]) {
+ List<String> list = _features.putIfAbsent(key, () => <String>[]);
+ if (value != null) {
+ list.add(value.toString());
+ }
}
bool containsKey(String key) {
@@ -879,12 +886,15 @@
StringBuffer sb = new StringBuffer();
bool needsComma = false;
for (String name in _features.keys.toList()..sort()) {
- String value = _features[name];
+ dynamic value = _features[name];
if (value != null) {
if (needsComma) {
sb.write(',');
}
sb.write(name);
+ if (value is List<String>) {
+ value = '[${(value..sort()).join(',')}]';
+ }
if (value != '') {
sb.write('=');
sb.write(value);
diff --git a/tests/compiler/dart2js/helpers/program_lookup.dart b/tests/compiler/dart2js/helpers/program_lookup.dart
index c3ef07a..5b1b8b1 100644
--- a/tests/compiler/dart2js/helpers/program_lookup.dart
+++ b/tests/compiler/dart2js/helpers/program_lookup.dart
@@ -36,7 +36,7 @@
}
Class getClass(ClassEntity element) {
- return getClassData(element).cls;
+ return getClassData(element)?.cls;
}
Method getMethod(FunctionEntity function) {
diff --git a/tests/compiler/dart2js/old_frontend/analyze_test_test.dart b/tests/compiler/dart2js/old_frontend/analyze_test_test.dart
index 3cf3f42..495ce73 100644
--- a/tests/compiler/dart2js/old_frontend/analyze_test_test.dart
+++ b/tests/compiler/dart2js/old_frontend/analyze_test_test.dart
@@ -28,6 +28,7 @@
const List<String> SKIP_LIST = const <String>[
// Helper files:
"/data/",
+ "/emission/",
"/side_effects/",
"quarantined/http_launch_data/",
"mirrors_helper.dart",
diff --git a/tests/compiler/dart2js/old_frontend/analyze_unused_dart2js_test.dart b/tests/compiler/dart2js/old_frontend/analyze_unused_dart2js_test.dart
index f0e1c8d..2de14d2 100644
--- a/tests/compiler/dart2js/old_frontend/analyze_unused_dart2js_test.dart
+++ b/tests/compiler/dart2js/old_frontend/analyze_unused_dart2js_test.dart
@@ -58,6 +58,10 @@
"pkg/kernel/lib/transformations/closure/": const [
"Duplicated library name 'kernel.transformations.closure.converter'",
],
+
+ "pkg/compiler/lib/src/js_backend/runtime_types.dart": const [
+ "'void' is not a subtype of bound 'Object' for type variable",
+ ],
};
void main() {
diff --git a/tests/compiler/dart2js/old_frontend/size_test.dart b/tests/compiler/dart2js/old_frontend/size_test.dart
index af9817a..95a1946 100644
--- a/tests/compiler/dart2js/old_frontend/size_test.dart
+++ b/tests/compiler/dart2js/old_frontend/size_test.dart
@@ -30,7 +30,7 @@
compileAll(TEST, coreSource: DEFAULT_CORELIB_WITH_LIST).then((generated) {
return MockCompiler.create((MockCompiler compiler) {
// Make sure no class is emitted.
- Expect.isFalse(generated.contains('finishClasses'));
+ Expect.isFalse(generated.contains('finishClasses'), generated);
});
}));
}
diff --git a/tests/compiler/dart2js/rti/backend_type_helper_test.dart b/tests/compiler/dart2js/rti/backend_type_helper_test.dart
new file mode 100644
index 0000000..6d47050
--- /dev/null
+++ b/tests/compiler/dart2js/rti/backend_type_helper_test.dart
@@ -0,0 +1,43 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:io';
+
+import 'package:async_helper/async_helper.dart';
+import 'package:compiler/src/commandline_options.dart';
+import 'package:compiler/src/compiler.dart';
+import 'package:compiler/src/elements/entities.dart';
+import 'package:compiler/src/js_emitter/program_builder/program_builder.dart';
+import 'package:compiler/src/world.dart';
+import 'package:expect/expect.dart';
+import '../helpers/program_lookup.dart';
+import '../memory_compiler.dart';
+
+main() {
+ runTest({bool useKernel}) async {
+ CompilationResult result = await runCompiler(
+ entryPoint: Platform.script.resolve('data/subtype_named_args.dart'),
+ options: useKernel ? [Flags.useKernel] : []);
+ Expect.isTrue(result.isSuccess);
+ Compiler compiler = result.compiler;
+ ClosedWorld closedWorld = compiler.backendClosedWorldForTesting;
+ ProgramLookup programLookup = new ProgramLookup(compiler);
+
+ List<ClassEntity> found = <ClassEntity>[];
+ for (ClassEntity element
+ in Collector.getBackendTypeHelpers(closedWorld.commonElements)) {
+ if (programLookup.getClass(element) != null) {
+ found.add(element);
+ }
+ }
+ Expect.isTrue(found.isEmpty, "Classes ${found} should not be emitted");
+ }
+
+ asyncTest(() async {
+ print('--test from ast---------------------------------------------------');
+ await runTest(useKernel: false);
+ print('--test from kernel------------------------------------------------');
+ await runTest(useKernel: true);
+ });
+}
diff --git a/tests/compiler/dart2js/rti/data/function_subtype_local5.dart b/tests/compiler/dart2js/rti/data/function_subtype_local5.dart
new file mode 100644
index 0000000..5acd91f
--- /dev/null
+++ b/tests/compiler/dart2js/rti/data/function_subtype_local5.dart
@@ -0,0 +1,44 @@
+// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+// Dart test program for constructors and initializers.
+
+// Check function subtyping for local functions on generic type against generic
+// typedefs.
+
+import 'package:expect/expect.dart';
+
+typedef int Foo<T>(T a, [String b]);
+typedef int Bar<T>(T a, [String b]);
+typedef int Baz<T>(T a, {String b});
+typedef int Boz<T>(T a);
+typedef int Biz<T>(T a, int b);
+
+/*class: C:explicit=[int Function(C.T),int Function(C.T,[String]),int Function(C.T,int),int Function(C.T,{,b:String})],needsArgs*/
+class C<T> {
+ void test(String nameOfT, bool expectedResult) {
+ int foo(bool a, [String b]) => null;
+ int baz(bool a, {String b}) => null;
+
+ Expect.equals(expectedResult, foo is Foo<T>, 'foo is Foo<$nameOfT>');
+ Expect.equals(expectedResult, foo is Bar<T>, 'foo is Bar<$nameOfT>');
+ Expect.isFalse(foo is Baz<T>, 'foo is Baz<$nameOfT>');
+ Expect.equals(expectedResult, foo is Boz<T>, 'foo is Boz<$nameOfT>');
+ Expect.isFalse(foo is Biz<T>, 'foo is Biz<$nameOfT>');
+
+ Expect.isFalse(baz is Foo<T>, 'baz is Foo<$nameOfT>');
+ Expect.isFalse(baz is Bar<T>, 'baz is Bar<$nameOfT>');
+ Expect.equals(expectedResult, baz is Baz<T>, 'baz is Baz<$nameOfT>');
+ Expect.equals(expectedResult, baz is Boz<T>, 'baz is Boz<$nameOfT>');
+ Expect.isFalse(baz is Biz<T>, 'bar is Biz<$nameOfT>');
+ }
+}
+
+/*class: D:needsArgs*/
+class D<S, T> extends C<T> {}
+
+main() {
+ new D<String, bool>().test('bool', true);
+ new D<bool, int>().test('int', false);
+ new D().test('dynamic', true);
+}
diff --git a/tests/compiler/dart2js/rti/data/generic_class_instantiate.dart b/tests/compiler/dart2js/rti/data/generic_class_instantiate.dart
index 8bf986a..65a7e4d 100644
--- a/tests/compiler/dart2js/rti/data/generic_class_instantiate.dart
+++ b/tests/compiler/dart2js/rti/data/generic_class_instantiate.dart
@@ -2,7 +2,7 @@
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
-/*class: A:arg,explicit=[B<A>]*/
+/*class: A:explicit=[B<A>]*/
class A {}
/*class: B:deps=[C],explicit=[B<A>],needsArgs*/
diff --git a/tests/compiler/dart2js/rti/data/generic_class_is.dart b/tests/compiler/dart2js/rti/data/generic_class_is.dart
index d82f758..acfcaac 100644
--- a/tests/compiler/dart2js/rti/data/generic_class_is.dart
+++ b/tests/compiler/dart2js/rti/data/generic_class_is.dart
@@ -4,7 +4,7 @@
import 'package:meta/dart2js.dart';
-/*class: A:arg,checked,implicit=[A]*/
+/*class: A:implicit=[A]*/
class A {}
/*class: B:direct,explicit=[B.T],needsArgs*/
diff --git a/tests/compiler/dart2js/rti/data/generic_class_is2.dart b/tests/compiler/dart2js/rti/data/generic_class_is2.dart
index 612fe1d..508466d 100644
--- a/tests/compiler/dart2js/rti/data/generic_class_is2.dart
+++ b/tests/compiler/dart2js/rti/data/generic_class_is2.dart
@@ -5,12 +5,9 @@
import 'package:expect/expect.dart';
import 'package:meta/dart2js.dart';
-// TODO(johnniwinther): A, C and C2 should be checked or A1, C1, and C2 should
-// have checks againts A, C and C, respectively.
-/*class: A:arg,checks=[A],implicit=[List<A<C2>>,List<A<C>>]*/
+/*class: A:implicit=[List<A<C2>>,List<A<C>>]*/
class A<T> {}
-/*class: A1:arg,checks=[A]*/
class A1 implements A<C1> {}
/*class: B:direct,explicit=[B.T],needsArgs*/
@@ -19,13 +16,12 @@
method(var t) => t is T;
}
-/*class: C:arg,checks=[C],implicit=[List<A<C>>]*/
+/*class: C:implicit=[List<A<C>>]*/
class C {}
-/*class: C1:arg*/
class C1 implements C {}
-/*class: C2:arg,checks=[C,C2],implicit=[List<A<C2>>]*/
+/*class: C2:implicit=[List<A<C2>>]*/
class C2 implements C {}
main() {
diff --git a/tests/compiler/dart2js/rti/data/generic_closure_instantiate.dart b/tests/compiler/dart2js/rti/data/generic_closure_instantiate.dart
index cc83ed0..635ac78 100644
--- a/tests/compiler/dart2js/rti/data/generic_closure_instantiate.dart
+++ b/tests/compiler/dart2js/rti/data/generic_closure_instantiate.dart
@@ -5,8 +5,7 @@
/*class: A:explicit=[B<A>]*/
class A {}
-/*ast.class: B:deps=[closure],explicit=[B<A>],needsArgs*/
-/*kernel.class: B:arg,checks=[B],deps=[closure],explicit=[B<A>],needsArgs*/
+/*class: B:deps=[closure],explicit=[B<A>],needsArgs*/
class B<T> {}
main() {
diff --git a/tests/compiler/dart2js/rti/data/generic_creation.dart b/tests/compiler/dart2js/rti/data/generic_creation.dart
new file mode 100644
index 0000000..56adaeb
--- /dev/null
+++ b/tests/compiler/dart2js/rti/data/generic_creation.dart
@@ -0,0 +1,56 @@
+// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import "package:expect/expect.dart";
+
+/*class: A:needsArgs*/
+/*element: A.:needsSignature*/
+class A<X, Y, Z> {
+ /*element: A.shift:needsSignature*/
+ shift() => new A<Z, X, Y>();
+ /*element: A.swap:needsSignature*/
+ swap() => new A<Z, Y, X>();
+ /*element: A.first:needsSignature*/
+ first() => new A<X, X, X>();
+ /*element: A.last:needsSignature*/
+ last() => new A<Z, Z, Z>();
+ /*element: A.wrap:needsSignature*/
+ wrap() => new A<A<X, X, X>, A<Y, Y, Y>, A<Z, Z, Z>>();
+}
+
+/*element: B.:needsSignature*/
+class B extends A<U, V, W> {}
+
+/*class: C:needsArgs*/
+/*element: C.:needsSignature*/
+class C<T> extends A<U, T, W> {}
+
+/*class: D:needsArgs*/
+/*element: D.:needsSignature*/
+class D<X, Y, Z> extends A<Y, Z, X> {}
+
+class U {}
+
+class V {}
+
+class W {}
+
+/*element: sameType:needsSignature*/
+sameType(a, b) => Expect.equals(a.runtimeType, b.runtimeType);
+
+/*element: main:needsSignature*/
+main() {
+ A a = new A<U, V, W>();
+ sameType(new A<W, U, V>(), a.shift());
+ sameType(new A<W, V, U>(), a.swap());
+ sameType(new A<U, U, U>(), a.first());
+ sameType(new A<W, W, W>(), a.last());
+ sameType(new A<A<U, U, U>, A<V, V, V>, A<W, W, W>>(), a.wrap());
+ B b = new B();
+ sameType(new A<A<U, U, U>, A<V, V, V>, A<W, W, W>>(), b.wrap());
+ C c = new C<V>();
+ sameType(new A<A<U, U, U>, A<V, V, V>, A<W, W, W>>(), c.wrap());
+ D d = new D<U, V, W>();
+ sameType(new A<A<V, V, V>, A<W, W, W>, A<U, U, U>>(), d.wrap());
+}
diff --git a/tests/compiler/dart2js/rti/data/generic_instanceof4.dart b/tests/compiler/dart2js/rti/data/generic_instanceof4.dart
index b035806..16b3327 100644
--- a/tests/compiler/dart2js/rti/data/generic_instanceof4.dart
+++ b/tests/compiler/dart2js/rti/data/generic_instanceof4.dart
@@ -12,7 +12,7 @@
}
}
-/*class: BB:arg,checked,implicit=[BB]*/
+/*class: BB:implicit=[BB]*/
class BB {}
/*class: B:implicit=[B.T],indirect,needsArgs*/
diff --git a/tests/compiler/dart2js/rti/data/generic_method1_strong.dart b/tests/compiler/dart2js/rti/data/generic_method1_strong.dart
index 376861d..651976b 100644
--- a/tests/compiler/dart2js/rti/data/generic_method1_strong.dart
+++ b/tests/compiler/dart2js/rti/data/generic_method1_strong.dart
@@ -13,9 +13,7 @@
}
}
-// TODO(johnniwinther): Should include 'arg'. Update the 'checkedArguments'
-// computation to take method type arguments into account.
-/*class: BB:checked,implicit=[BB]*/
+/*class: BB:implicit=[BB]*/
class BB {}
/*element: method2:deps=[B],implicit=[method2.T],indirect,needsArgs*/
diff --git a/tests/compiler/dart2js/rti/data/generic_method2_strong.dart b/tests/compiler/dart2js/rti/data/generic_method2_strong.dart
index 1235481..27a1d49 100644
--- a/tests/compiler/dart2js/rti/data/generic_method2_strong.dart
+++ b/tests/compiler/dart2js/rti/data/generic_method2_strong.dart
@@ -13,9 +13,7 @@
}
}
-// TODO(johnniwinther): Should include 'arg'. Update the 'checkedArguments'
-// computation to take method type arguments into account.
-/*class: BB:checked,implicit=[BB]*/
+/*class: BB:implicit=[BB]*/
class BB {}
/*class: B:deps=[method1],implicit=[B.T],indirect,needsArgs*/
diff --git a/tests/compiler/dart2js/rti/data/generic_method3_strong.dart b/tests/compiler/dart2js/rti/data/generic_method3_strong.dart
index dddc5f0..46ecef3c 100644
--- a/tests/compiler/dart2js/rti/data/generic_method3_strong.dart
+++ b/tests/compiler/dart2js/rti/data/generic_method3_strong.dart
@@ -13,7 +13,7 @@
}
}
-/*class: BB:arg,checked,implicit=[BB]*/
+/*class: BB:implicit=[BB]*/
class BB {}
/*element: method2:deps=[B],implicit=[method2.T],indirect,needsArgs*/
diff --git a/tests/compiler/dart2js/rti/data/generic_method_is_strong.dart b/tests/compiler/dart2js/rti/data/generic_method_is_strong.dart
index bcd1f4b..db9a3f7 100644
--- a/tests/compiler/dart2js/rti/data/generic_method_is_strong.dart
+++ b/tests/compiler/dart2js/rti/data/generic_method_is_strong.dart
@@ -12,30 +12,29 @@
class B2 {}
-/*class: C1:checked,implicit=[C1]*/
+/*class: C1:implicit=[C1]*/
class C1 {}
class C2 {}
-/*class: C3:checked*/
class C3 {}
-/*class: D1:checked,implicit=[D1]*/
+/*class: D1:implicit=[D1]*/
class D1 {}
class D2 {}
-/*class: E1:checked,implicit=[E1]*/
+/*class: E1:implicit=[E1]*/
class E1 {}
class E2 {}
-/*class: F1:checked,implicit=[F1]*/
+/*class: F1:implicit=[F1]*/
class F1 {}
class F2 {}
-/*class: F3:checked,implicit=[F3]*/
+/*class: F3:implicit=[F3]*/
class F3 {}
/*element: topLevelMethod1:direct,explicit=[topLevelMethod1.T],needsArgs*/
diff --git a/tests/compiler/dart2js/rti/data/list_to_set.dart b/tests/compiler/dart2js/rti/data/list_to_set.dart
index b8598de..f858a43 100644
--- a/tests/compiler/dart2js/rti/data/list_to_set.dart
+++ b/tests/compiler/dart2js/rti/data/list_to_set.dart
@@ -2,8 +2,10 @@
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
-/*class: global#List:deps=[Class,EmptyIterable,Iterable,JSArray,ListIterable,SetMixin,SubListIterable],explicit=[List],implicit=[List.E],indirect,needsArgs*/
-/*class: global#JSArray:checked,deps=[EmptyIterable,List,ListIterable,SetMixin,SubListIterable],explicit=[JSArray],implicit=[JSArray.E],indirect,needsArgs*/
+/*ast.class: global#List:deps=[Class,EmptyIterable,Iterable,JSArray,ListIterable,SetMixin,SubListIterable],explicit=[List],implicit=[List.E],indirect,needsArgs*/
+/*kernel.class: global#List:deps=[Class,EmptyIterable,Iterable,JSArray,ListIterable,SetMixin],explicit=[List],implicit=[List.E],indirect,needsArgs*/
+/*ast.class: global#JSArray:deps=[List],explicit=[JSArray],implicit=[JSArray.E],indirect,needsArgs*/
+/*kernel.class: global#JSArray:deps=[EmptyIterable,List,ListIterable,SetMixin,SubListIterable],explicit=[JSArray],implicit=[JSArray.E],indirect,needsArgs*/
main() {
var c = new Class<int>();
diff --git a/tests/compiler/dart2js/rti/data/map_literal.dart b/tests/compiler/dart2js/rti/data/map_literal.dart
index 409bb7d..1643414 100644
--- a/tests/compiler/dart2js/rti/data/map_literal.dart
+++ b/tests/compiler/dart2js/rti/data/map_literal.dart
@@ -5,7 +5,7 @@
/*class: global#Map:*/
/*class: global#LinkedHashMap:deps=[Map]*/
/*class: global#JsLinkedHashMap:deps=[LinkedHashMap]*/
-/*class: global#double:arg,explicit=[double]*/
+/*class: global#double:explicit=[double]*/
/*class: global#JSDouble:*/
main() {
diff --git a/tests/compiler/dart2js/rti/data/map_literal_checked.dart b/tests/compiler/dart2js/rti/data/map_literal_checked.dart
index d7534bf..9c6733f 100644
--- a/tests/compiler/dart2js/rti/data/map_literal_checked.dart
+++ b/tests/compiler/dart2js/rti/data/map_literal_checked.dart
@@ -2,10 +2,10 @@
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
-/*class: global#Map:checked,explicit=[Map],indirect,needsArgs*/
-/*class: global#LinkedHashMap:checked,deps=[Map],explicit=[LinkedHashMap<LinkedHashMap.K,LinkedHashMap.V>],implicit=[LinkedHashMap.K,LinkedHashMap.V],indirect,needsArgs*/
-/*class: global#JsLinkedHashMap:checked,deps=[LinkedHashMap],direct,explicit=[Iterable<JsLinkedHashMap.K>,JsLinkedHashMap.K,JsLinkedHashMap.V,JsLinkedHashMap<JsLinkedHashMap.K,JsLinkedHashMap.V>,void Function(JsLinkedHashMap.K,JsLinkedHashMap.V)],implicit=[JsLinkedHashMap.K,JsLinkedHashMap.V],needsArgs*/
-/*class: global#double:arg,checked,explicit=[double],implicit=[double]*/
+/*class: global#Map:explicit=[Map],indirect,needsArgs*/
+/*class: global#LinkedHashMap:deps=[Map],explicit=[LinkedHashMap<LinkedHashMap.K,LinkedHashMap.V>],implicit=[LinkedHashMap.K,LinkedHashMap.V],indirect,needsArgs*/
+/*class: global#JsLinkedHashMap:deps=[LinkedHashMap],direct,explicit=[Iterable<JsLinkedHashMap.K>,JsLinkedHashMap.K,JsLinkedHashMap.V,JsLinkedHashMap<JsLinkedHashMap.K,JsLinkedHashMap.V>,void Function(JsLinkedHashMap.K,JsLinkedHashMap.V)],implicit=[JsLinkedHashMap.K,JsLinkedHashMap.V],needsArgs*/
+/*class: global#double:explicit=[double],implicit=[double]*/
/*class: global#JSDouble:*/
main() {
diff --git a/tests/compiler/dart2js/rti/data/map_to_set.dart b/tests/compiler/dart2js/rti/data/map_to_set.dart
index 2d8037c..4cfda0e 100644
--- a/tests/compiler/dart2js/rti/data/map_to_set.dart
+++ b/tests/compiler/dart2js/rti/data/map_to_set.dart
@@ -5,7 +5,7 @@
/*class: global#Map:deps=[Class],needsArgs*/
/*class: global#LinkedHashMap:deps=[Map],needsArgs*/
/*class: global#JsLinkedHashMap:deps=[LinkedHashMap],implicit=[JsLinkedHashMap.K],needsArgs*/
-/*class: global#double:arg,explicit=[double]*/
+/*class: global#double:explicit=[double]*/
/*class: global#JSDouble:*/
main() {
diff --git a/tests/compiler/dart2js/rti/data/subtype_named_args.dart b/tests/compiler/dart2js/rti/data/subtype_named_args.dart
index 10e7145..d7014bf 100644
--- a/tests/compiler/dart2js/rti/data/subtype_named_args.dart
+++ b/tests/compiler/dart2js/rti/data/subtype_named_args.dart
@@ -6,30 +6,28 @@
import 'package:expect/expect.dart';
-/*ast.class: A:arg,checks=[A,Object],explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
-/*kernel.class: A:arg,checks=[A,Object],explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({f1:dynamic Function({a:A,b:B,c:C,d:D}),f2:dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>}),f3:dynamic Function({v:dynamic,x:dynamic,y:dynamic,z:dynamic})}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
+/*ast.class: A:explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
+/*kernel.class: A:explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({f1:dynamic Function({a:A,b:B,c:C,d:D}),f2:dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>}),f3:dynamic Function({v:dynamic,x:dynamic,y:dynamic,z:dynamic})}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
class A {}
-/*class: A1:arg,checks=[A1,Object]*/
class A1 {}
-/*class: A2:arg,checks=[A2,Object]*/
class A2 {}
-/*ast.class: B:arg,checks=[A,A1,A2,B,Object],explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
-/*kernel.class: B:arg,checks=[A,A1,A2,B,Object],explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({f1:dynamic Function({a:A,b:B,c:C,d:D}),f2:dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>}),f3:dynamic Function({v:dynamic,x:dynamic,y:dynamic,z:dynamic})}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
+/*ast.class: B:explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
+/*kernel.class: B:explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({f1:dynamic Function({a:A,b:B,c:C,d:D}),f2:dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>}),f3:dynamic Function({v:dynamic,x:dynamic,y:dynamic,z:dynamic})}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
class B implements A, A1, A2 {}
-/*ast.class: C:arg,checks=[A,A1,A2,B,C,Object],explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
-/*kernel.class: C:arg,checks=[A,A1,A2,B,C,Object],explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({f1:dynamic Function({a:A,b:B,c:C,d:D}),f2:dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>}),f3:dynamic Function({v:dynamic,x:dynamic,y:dynamic,z:dynamic})}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
+/*ast.class: C:explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
+/*kernel.class: C:explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({f1:dynamic Function({a:A,b:B,c:C,d:D}),f2:dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>}),f3:dynamic Function({v:dynamic,x:dynamic,y:dynamic,z:dynamic})}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
class C implements B {}
-/*ast.class: D:arg,checks=[A,A1,A2,B,C,D,Object],explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
-/*kernel.class: D:arg,checks=[A,A1,A2,B,C,D,Object],explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({f1:dynamic Function({a:A,b:B,c:C,d:D}),f2:dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>}),f3:dynamic Function({v:dynamic,x:dynamic,y:dynamic,z:dynamic})}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
+/*ast.class: D:explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
+/*kernel.class: D:explicit=[dynamic Function({a:A,b:B,c:C,d:D}),dynamic Function({f1:dynamic Function({a:A,b:B,c:C,d:D}),f2:dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>}),f3:dynamic Function({v:dynamic,x:dynamic,y:dynamic,z:dynamic})}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
class D implements C {}
-/*ast.class: G:arg,checks=[G,Object],explicit=[dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
-/*kernel.class: G:arg,checks=[G,Object],explicit=[dynamic Function({f1:dynamic Function({a:A,b:B,c:C,d:D}),f2:dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>}),f3:dynamic Function({v:dynamic,x:dynamic,y:dynamic,z:dynamic})}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
+/*ast.class: G:explicit=[dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
+/*kernel.class: G:explicit=[dynamic Function({f1:dynamic Function({a:A,b:B,c:C,d:D}),f2:dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>}),f3:dynamic Function({v:dynamic,x:dynamic,y:dynamic,z:dynamic})}),dynamic Function({g:G<A,B,C,D>,l:List<List<B>>,m:Map<num,int>})]*/
class G<T, S, U, W> {}
typedef classesFunc({A a, B b, C c, D d});
diff --git a/tests/compiler/dart2js/rti/data/subtype_named_args1.dart b/tests/compiler/dart2js/rti/data/subtype_named_args1.dart
new file mode 100644
index 0000000..0312132
--- /dev/null
+++ b/tests/compiler/dart2js/rti/data/subtype_named_args1.dart
@@ -0,0 +1,97 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// From co19/Language/Types/Function_Types/subtype_named_args_t01.
+
+import "package:expect/expect.dart";
+
+class A {}
+
+/*ast.class: B:explicit=[dynamic Function({a:B})]*/
+/*kernel.class: B:explicit=[dynamic Function({a:B}),dynamic Function({f:dynamic Function({a:B})})]*/
+class B implements A {}
+
+/*class: C:explicit=[dynamic Function({c:C})]*/
+class C implements B {}
+
+class D implements C {}
+
+typedef t1({B a});
+typedef t2({C c});
+typedef t3({int i});
+typedef t4({var v});
+typedef t5({Map m});
+typedef t6({Map<int, num> m});
+typedef t7({t1 f});
+typedef t8({Object a});
+
+typedef okWithT1_1({A a});
+typedef okWithT1_2({B a});
+typedef okWithT1_3({C a});
+typedef okWithT1_4({D a});
+
+main() {
+ Expect.isTrue(({A a}) {} is t1);
+ Expect.isTrue(({B a}) {} is t1);
+ Expect.isTrue(({C a}) {} is t1);
+ Expect.isTrue(({D a}) {} is t1);
+ Expect.isTrue(({Object a}) {} is t1);
+ Expect.isTrue(({var a}) {} is t1);
+
+ Expect.isTrue(({A c}) {} is t2);
+ Expect.isTrue(({B c}) {} is t2);
+ Expect.isTrue(({C c}) {} is t2);
+ Expect.isTrue(({D c}) {} is t2);
+ Expect.isTrue(({Object c}) {} is t2);
+ Expect.isTrue(({var c}) {} is t2);
+
+ Expect.isTrue(({num i}) {} is t3);
+ Expect.isTrue(({int i}) {} is t3);
+ Expect.isTrue(({Object i}) {} is t3);
+ Expect.isTrue(({var i}) {} is t3);
+
+ Expect.isTrue(({A v}) {} is t4);
+ Expect.isTrue(({B v}) {} is t4);
+ Expect.isTrue(({C v}) {} is t4);
+ Expect.isTrue(({D v}) {} is t4);
+ Expect.isTrue(({Object v}) {} is t4);
+ Expect.isTrue(({var v}) {} is t4);
+ Expect.isTrue(({num v}) {} is t4);
+ Expect.isTrue(({int v}) {} is t4);
+ Expect.isTrue(({Map v}) {} is t4);
+ Expect.isTrue(({Map<List<Map<List, List<int>>>, List> v}) {} is t4);
+ Expect.isTrue(({List v}) {} is t4);
+ Expect.isTrue(({t8 v}) {} is t4);
+ Expect.isTrue(({t7 v}) {} is t4);
+
+ Expect.isTrue(({Map m}) {} is t5);
+ Expect.isTrue(({Map<List, t8> m}) {} is t5);
+ Expect.isTrue(({Object m}) {} is t5);
+ Expect.isTrue(({var m}) {} is t5);
+ Expect.isTrue(({Map<List, List> m}) {} is t5);
+ Expect.isTrue(({Map<int, t8> m}) {} is t5);
+
+ Expect.isTrue(({Map<num, num> m}) {} is t6);
+ Expect.isTrue(({Map<int, int> m}) {} is t6);
+ Expect.isTrue(({Map m}) {} is t6);
+ Expect.isTrue(({Object m}) {} is t6);
+ Expect.isTrue(({var m}) {} is t6);
+
+ Expect.isTrue(({okWithT1_1 f}) {} is t7);
+ Expect.isTrue(({okWithT1_2 f}) {} is t7);
+ Expect.isTrue(({okWithT1_3 f}) {} is t7);
+ Expect.isTrue(({okWithT1_4 f}) {} is t7);
+
+ Expect.isTrue(({A a}) {} is t8);
+ Expect.isTrue(({B a}) {} is t8);
+ Expect.isTrue(({C a}) {} is t8);
+ Expect.isTrue(({D a}) {} is t8);
+ Expect.isTrue(({Object a}) {} is t8);
+ Expect.isTrue(({var a}) {} is t8);
+ Expect.isTrue(({num a}) {} is t8);
+ Expect.isTrue(({int a}) {} is t8);
+ Expect.isTrue(({Map a}) {} is t8);
+ Expect.isTrue(({Map<List<Map<List, List<int>>>, List> a}) {} is t8);
+ Expect.isTrue(({List a}) {} is t8);
+}
diff --git a/tests/compiler/dart2js/rti/data/type_argument_substitution.dart b/tests/compiler/dart2js/rti/data/type_argument_substitution.dart
index c1e227e..635ad13 100644
--- a/tests/compiler/dart2js/rti/data/type_argument_substitution.dart
+++ b/tests/compiler/dart2js/rti/data/type_argument_substitution.dart
@@ -7,16 +7,14 @@
import 'package:expect/expect.dart';
-/*class: K:arg*/
class K {}
-/*class: A:arg,checks=[A],explicit=[X<A<String>>]*/
+/*class: A:explicit=[X<A<String>>]*/
class A<T> {}
-/*class: B:arg,checks=[A]*/
class B extends A<K> {}
-/*class: X:checked,explicit=[X<A<String>>],needsArgs*/
+/*class: X:explicit=[X<A<String>>],needsArgs*/
class X<T> {}
main() {
diff --git a/tests/compiler/dart2js/rti/data/type_literal2.dart b/tests/compiler/dart2js/rti/data/type_literal2.dart
new file mode 100644
index 0000000..a1e3e6b
--- /dev/null
+++ b/tests/compiler/dart2js/rti/data/type_literal2.dart
@@ -0,0 +1,18 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/*class: A:deps=[B],exp,needsArgs*/
+class A<T> {
+ method1() => T;
+}
+
+/*class: B:needsArgs*/
+class B<S> {
+ method2() => new A<S>().method1();
+}
+
+main() {
+ var b = new B<int>();
+ b.method2();
+}
diff --git a/tests/compiler/dart2js/rti/emission/arguments.dart b/tests/compiler/dart2js/rti/emission/arguments.dart
new file mode 100644
index 0000000..328e684
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/arguments.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[]*/
+class A {}
+
+/*class: B:checks=[]*/
+class B {}
+
+/*class: C:checks=[]*/
+class C<T> {}
+
+@noInline
+test(o) => o is C<A>;
+
+main() {
+ test(new C<A>());
+ test(new C<B>());
+}
diff --git a/tests/compiler/dart2js/rti/emission/call.dart b/tests/compiler/dart2js/rti/emission/call.dart
new file mode 100644
index 0000000..d603eab
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/call.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:expect/expect.dart';
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[$isFunction]*/
+class A {
+ call() {}
+}
+
+@noInline
+test(o) => o is Function;
+
+main() {
+ Expect.isTrue(test(new A()));
+ Expect.isFalse(test(null));
+}
diff --git a/tests/compiler/dart2js/rti/emission/closure_function.dart b/tests/compiler/dart2js/rti/emission/closure_function.dart
new file mode 100644
index 0000000..82d8712
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/closure_function.dart
@@ -0,0 +1,13 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+@noInline
+test(o) => o is Function;
+
+main() {
+ test(/*checks=[]*/ () {});
+ test(null);
+}
diff --git a/tests/compiler/dart2js/rti/emission/closure_function_type.dart b/tests/compiler/dart2js/rti/emission/closure_function_type.dart
new file mode 100644
index 0000000..0c7e05b
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/closure_function_type.dart
@@ -0,0 +1,13 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+@noInline
+test(o) => o is Function();
+
+main() {
+ test(/*checks=[]*/ () {});
+ test(/*checks=[]*/ (a) {});
+}
diff --git a/tests/compiler/dart2js/rti/emission/generic_instanceof4.dart b/tests/compiler/dart2js/rti/emission/generic_instanceof4.dart
new file mode 100644
index 0000000..45ab17f
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/generic_instanceof4.dart
@@ -0,0 +1,28 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[]*/
+class A<T> {
+ @noInline
+ foo(x) {
+ return x is T;
+ }
+}
+
+/*class: BB:checks=[]*/
+class BB {}
+
+/*class: B:checks=[$isBB]*/
+class B<T> implements BB {
+ @noInline
+ foo() {
+ return new A<T>().foo(new B());
+ }
+}
+
+main() {
+ new B<BB>().foo();
+}
diff --git a/tests/compiler/dart2js/rti/emission/inherited_is.dart b/tests/compiler/dart2js/rti/emission/inherited_is.dart
new file mode 100644
index 0000000..618b16f
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/inherited_is.dart
@@ -0,0 +1,25 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:expect/expect.dart';
+import 'package:meta/dart2js.dart';
+
+class A {}
+
+/*class: B:checks=[]*/
+class B implements A {}
+
+/*class: C:checks=[$isA]*/
+class C = Object with B;
+
+/*class: D:checks=[]*/
+class D extends C {}
+
+@noInline
+test(o) => o is A;
+
+main() {
+ Expect.isTrue(test(new D()));
+ Expect.isFalse(test(null));
+}
diff --git a/tests/compiler/dart2js/rti/emission/inherited_is2.dart b/tests/compiler/dart2js/rti/emission/inherited_is2.dart
new file mode 100644
index 0000000..a703a2b
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/inherited_is2.dart
@@ -0,0 +1,25 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:expect/expect.dart';
+import 'package:meta/dart2js.dart';
+
+class A {}
+
+/*class: B:checks=[$isA]*/
+class B implements A {}
+
+/*class: C:checks=[]*/
+class C extends B {}
+
+/*class: D:checks=[]*/
+class D extends C {}
+
+@noInline
+test(o) => o is A;
+
+main() {
+ Expect.isTrue(test(new D()));
+ Expect.isFalse(test(null));
+}
diff --git a/tests/compiler/dart2js/rti/emission/list.dart b/tests/compiler/dart2js/rti/emission/list.dart
new file mode 100644
index 0000000..b5d777c
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/list.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: global#JSArray:checks=[$isIterable]*/
+/*class: global#Iterable:*/
+
+/*class: A:checks=[]*/
+class A {}
+
+/*class: B:checks=[]*/
+class B {}
+
+@noInline
+test(o) => o is Iterable<A>;
+
+main() {
+ test(<A>[]);
+ test(<B>[]);
+}
diff --git a/tests/compiler/dart2js/rti/emission/map_literal.dart b/tests/compiler/dart2js/rti/emission/map_literal.dart
new file mode 100644
index 0000000..1b86df4
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/map_literal.dart
@@ -0,0 +1,13 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/*class: global#Map:*/
+/*class: global#LinkedHashMap:*/
+/*class: global#JsLinkedHashMap:checks=[]*/
+/*class: global#double:checks=[]*/
+/*class: global#JSDouble:checks=[]*/
+
+main() {
+ <int, double>{}[0] = 0.5;
+}
diff --git a/tests/compiler/dart2js/rti/emission/map_literal_checked.dart b/tests/compiler/dart2js/rti/emission/map_literal_checked.dart
new file mode 100644
index 0000000..bda462b
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/map_literal_checked.dart
@@ -0,0 +1,13 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/*class: global#Map:checks=[]*/
+/*class: global#LinkedHashMap:*/
+/*class: global#JsLinkedHashMap:checks=[$isLinkedHashMap]*/
+/*class: global#double:checks=[]*/
+/*class: global#JSDouble:checks=[$isdouble]*/
+
+main() {
+ <int, double>{}[0] = 0.5;
+}
diff --git a/tests/compiler/dart2js/rti/emission/mixin_mixin2.dart b/tests/compiler/dart2js/rti/emission/mixin_mixin2.dart
new file mode 100644
index 0000000..747c430
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/mixin_mixin2.dart
@@ -0,0 +1,43 @@
+// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import "package:expect/expect.dart";
+
+/*class: M:checks=[]*/
+class M<T> {
+ t() {
+ return T;
+ }
+}
+
+/*class: A:checks=[]*/
+class A<U> = Object with M<U>;
+
+/*class: B:checks=[]*/
+class B<V> = Object with A<V>;
+
+/*class: C:checks=[$asM]*/
+class C<U> = Object with M<List<U>>;
+
+/*class: D:checks=[$asM]*/
+class D<V> = Object with C<Set<V>>;
+
+/*class: E:checks=[$asM]*/
+class E extends A<num> {}
+
+/*class: F:checks=[$asM]*/
+class F extends B<String> {}
+
+/*class: G:checks=[]*/
+class G<T> extends C<T> {}
+
+/*class: H:checks=[$asM]*/
+class H<T> extends D<Map<String, T>> {}
+
+main() {
+ Expect.equals("num", new E().t().toString());
+ Expect.equals("String", new F().t().toString());
+ Expect.equals("List<bool>", new G<bool>().t().toString());
+ Expect.equals("List<Set<Map<String, int>>>", new H<int>().t().toString());
+}
diff --git a/tests/compiler/dart2js/rti/emission/mixin_mixin4.dart b/tests/compiler/dart2js/rti/emission/mixin_mixin4.dart
new file mode 100644
index 0000000..7d42422
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/mixin_mixin4.dart
@@ -0,0 +1,38 @@
+// Copyright (c) 2013, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import "package:expect/expect.dart";
+
+class I<T> {}
+
+class J<T> {}
+
+/*class: S:checks=[]*/
+class S<T> {}
+
+/*class: M:checks=[]*/
+class M<T> {
+ t() {
+ return T;
+ }
+}
+
+class A<U, V> = Object with M<Map<U, V>> implements I<V>;
+
+/*class: C:checks=[$asA,$asI,$asJ,$asM,$asS,$isA,$isI,$isJ]*/
+class C<T, K> = S<T> with A<T, List<K>> implements J<K>;
+
+@NoInline()
+test(c) {
+ Expect.equals("Map<int, List<bool>>", c.t().toString());
+ Expect.isTrue(c is I<List<bool>>);
+ Expect.isTrue(c is J<bool>);
+ Expect.isTrue(c is S<int>);
+ Expect.isTrue(c is A<int, List<bool>>);
+ Expect.isTrue(c is M<Map<int, List<bool>>>);
+}
+
+main() {
+ test(new C<int, bool>());
+}
diff --git a/tests/compiler/dart2js/rti/emission/mixin_type_arguments.dart b/tests/compiler/dart2js/rti/emission/mixin_type_arguments.dart
new file mode 100644
index 0000000..6067cef
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/mixin_type_arguments.dart
@@ -0,0 +1,107 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:expect/expect.dart' show Expect;
+
+/*class: A:checks=[]*/
+class A {}
+
+/*class: B:checks=[]*/
+class B {}
+
+/*class: C:checks=[]*/
+class C {}
+
+/*class: D:checks=[]*/
+class D {}
+
+/*class: E:checks=[]*/
+class E {}
+
+/*class: F:checks=[]*/
+class F {}
+
+/*class: M1:checks=[]*/
+class M1<Tm1> {
+ m1() => "M1<$Tm1>";
+}
+
+/*class: M2:checks=[]*/
+class M2<Tm2> {
+ m2() => "M2<$Tm2>";
+}
+
+/*class: M3:checks=[]*/
+class M3<Tm3> {
+ m3() => "M3<$Tm3>";
+}
+
+/*class: M4:checks=[]*/
+class M4<Tm4> {
+ m4() => "M4<$Tm4>";
+}
+
+/*class: M5:checks=[]*/
+class M5<Tm5> {
+ m5() => "M5<$Tm5>";
+}
+
+/*class: C1:checks=[$asM1,$asM2,$asM3,$asM4,$asM5]*/
+class C1 = Object with M1, M2<A>, M3, M4<B>, M5<C>;
+
+/*class: C2:checks=[$asM1,$asM2,$asM3,$asM4,$asM5]*/
+class C2 = Object with M1<A>, M2<B>, M3<C>, M4<D>, M5<E>;
+
+/*class: C3:checks=[$asM1,$asM3,$asM4,$asM5]*/
+class C3<T> = Object with M1<A>, M2<T>, M3, M4, M5<B>;
+
+/*class: C4:checks=[$asM1,$asM2,$asM3,$asM4,$asM5]*/
+class C4 extends Object with M1, M2<A>, M3, M4<B>, M5<C> {}
+
+/*class: C5:checks=[$asM1,$asM2,$asM3,$asM4,$asM5]*/
+class C5 extends Object with M1<A>, M2<B>, M3<C>, M4<D>, M5<E> {}
+
+/*class: C6:checks=[$asM1,$asM3,$asM4,$asM5]*/
+class C6<T> extends Object with M1<A>, M2<T>, M3, M4, M5<B> {}
+
+/*class: C7:checks=[$asM1,$asM2,$asM3,$asM4,$asM5]*/
+class C7 = Object with M1<A>, M2<A>, M3<A>, M4<A>, M5<A>;
+
+/*class: C8:checks=[$asM1,$asM2,$asM3,$asM4,$asM5]*/
+class C8 extends Object with M1<A>, M2<A>, M3<A>, M4<A>, M5<A> {}
+
+/*class: C9:checks=[$asM1,$asM2,$asM3,$asM4,$asM5]*/
+class C9 = Object
+ with M1<List<A>>, M2<List<A>>, M3<List<A>>, M4<List<A>>, M5<List<A>>;
+
+/*class: CA:checks=[$asM1,$asM2,$asM3,$asM4,$asM5]*/
+class CA extends Object
+ with M1<List<A>>, M2<List<A>>, M3<List<A>>, M4<List<A>>, M5<List<A>> {}
+
+trace(x) => "${x.m1()}, ${x.m2()}, ${x.m3()}, ${x.m4()}, ${x.m5()}";
+
+main() {
+ Expect.stringEquals(
+ "M1<dynamic>, M2<A>, M3<dynamic>, M4<B>, M5<C>", trace(new C1()));
+ Expect.stringEquals("M1<A>, M2<B>, M3<C>, M4<D>, M5<E>", trace(new C2()));
+ Expect.stringEquals(
+ "M1<A>, M2<dynamic>, M3<dynamic>, M4<dynamic>, M5<B>", trace(new C3()));
+ Expect.stringEquals(
+ "M1<A>, M2<F>, M3<dynamic>, M4<dynamic>, M5<B>", trace(new C3<F>()));
+ Expect.stringEquals(
+ "M1<dynamic>, M2<A>, M3<dynamic>, M4<B>, M5<C>", trace(new C4()));
+ Expect.stringEquals("M1<A>, M2<B>, M3<C>, M4<D>, M5<E>", trace(new C5()));
+ Expect.stringEquals(
+ "M1<A>, M2<dynamic>, M3<dynamic>, M4<dynamic>, M5<B>", trace(new C6()));
+ Expect.stringEquals(
+ "M1<A>, M2<F>, M3<dynamic>, M4<dynamic>, M5<B>", trace(new C6<F>()));
+ Expect.stringEquals("M1<A>, M2<A>, M3<A>, M4<A>, M5<A>", trace(new C7()));
+ Expect.stringEquals("M1<A>, M2<A>, M3<A>, M4<A>, M5<A>", trace(new C8()));
+ Expect.stringEquals(
+ "M1<List<A>>, M2<List<A>>, M3<List<A>>, M4<List<A>>, M5<List<A>>",
+ trace(new C9()));
+ Expect.stringEquals(
+ "M1<List<A>>, M2<List<A>>, M3<List<A>>, M4<List<A>>, M5<List<A>>",
+ trace(new CA()));
+}
diff --git a/tests/compiler/dart2js/rti/emission/native.dart b/tests/compiler/dart2js/rti/emission/native.dart
new file mode 100644
index 0000000..c7bfb9f
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/native.dart
@@ -0,0 +1,34 @@
+// Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import "package:expect/expect.dart";
+// ignore: import_internal_library
+import 'dart:_js_helper' show Native;
+// ignore: import_internal_library
+import 'dart:_foreign_helper' show JS;
+
+/*class: Purple:checks=[$isPurple]*/
+@Native('PPPP')
+class Purple {}
+
+@Native('QQQQ')
+class Q {}
+
+@NoInline()
+makeP() => JS('returns:;creates:Purple', 'null');
+
+@NoInline()
+makeQ() => JS('Q', 'null');
+
+@NoInline()
+testNative() {
+ var x = makeP();
+ Expect.isTrue(x is Purple);
+ x = makeQ();
+ Expect.isFalse(x is Purple);
+}
+
+main() {
+ testNative();
+}
diff --git a/tests/compiler/dart2js/rti/emission/regress_18713.dart b/tests/compiler/dart2js/rti/emission/regress_18713.dart
new file mode 100644
index 0000000..8d0ff99
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/regress_18713.dart
@@ -0,0 +1,38 @@
+// Copyright (c) 2016, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import "package:expect/expect.dart";
+
+/*class: T:checks=[]*/
+class T<X> {
+ final Type tType = X;
+ Type get getTType => X;
+}
+
+/*class: S:checks=[]*/
+class S<Y> {
+ final Type sType = Y;
+ Type get getSType => Y;
+}
+
+/*class: TS:checks=[$asS0,$asT]*/
+class TS<A, B> = T<A> with S<B>;
+
+@NoInline()
+@AssumeDynamic()
+dyn(x) => x;
+
+main() {
+ var ts = new TS<int, String>();
+
+ Expect.equals("String", ts.sType.toString());
+ Expect.equals("int", ts.tType.toString());
+ Expect.equals("String", ts.getSType.toString());
+ Expect.equals("int", ts.getTType.toString());
+
+ Expect.equals("String", dyn(ts).sType.toString());
+ Expect.equals("int", dyn(ts).tType.toString());
+ Expect.equals("String", dyn(ts).getSType.toString());
+ Expect.equals("int", dyn(ts).getTType.toString());
+}
diff --git a/tests/compiler/dart2js/rti/emission/runtime_type.dart b/tests/compiler/dart2js/rti/emission/runtime_type.dart
new file mode 100644
index 0000000..c9973eb
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/runtime_type.dart
@@ -0,0 +1,13 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/*class: A:checks=[]*/
+class A<T> {}
+
+/*class: B:checks=[]*/
+class B<T> {}
+
+main() {
+ print("A<B<int>>" == new A<B<int>>().runtimeType.toString());
+}
diff --git a/tests/compiler/dart2js/rti/emission/self.dart b/tests/compiler/dart2js/rti/emission/self.dart
new file mode 100644
index 0000000..76c29c4
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/self.dart
@@ -0,0 +1,16 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: C:checks=[]*/
+class C {}
+
+@noInline
+test(o) => o is C;
+
+main() {
+ test(new C());
+ test(null);
+}
diff --git a/tests/compiler/dart2js/rti/emission/self_generic.dart b/tests/compiler/dart2js/rti/emission/self_generic.dart
new file mode 100644
index 0000000..793f276
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/self_generic.dart
@@ -0,0 +1,16 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: C:checks=[]*/
+class C<T> {}
+
+@noInline
+test(o) => o is C<String>;
+
+main() {
+ test(new C<String>());
+ test(new C<int>());
+}
diff --git a/tests/compiler/dart2js/rti/emission/subtype_named_args.dart b/tests/compiler/dart2js/rti/emission/subtype_named_args.dart
new file mode 100644
index 0000000..b2b1cc7
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/subtype_named_args.dart
@@ -0,0 +1,80 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// From co19/Language/Types/Function_Types/subtype_named_args_t02.
+
+import 'package:expect/expect.dart';
+
+/*class: A:checks=[]*/
+class A {}
+
+/*class: A1:checks=[]*/
+class A1 {}
+
+/*class: A2:checks=[]*/
+class A2 {}
+
+/*class: B:checks=[$isA,$isA1,$isA2]*/
+class B implements A, A1, A2 {}
+
+/*class: C:checks=[$isA,$isA1,$isA2,$isB]*/
+class C implements B {}
+
+/*class: D:checks=[$isA,$isA1,$isA2,$isB,$isC]*/
+class D implements C {}
+
+/*class: G:checks=[]*/
+class G<T, S, U, W> {}
+
+typedef classesFunc({A a, B b, C c, D d});
+typedef genericsFunc({Map<num, int> m, List<List<B>> l, G<A, B, C, D> g});
+typedef dynamicFunc({var x, var y, var z, var v});
+typedef funcFunc({classesFunc f1, genericsFunc f2, dynamicFunc f3});
+typedef mixFunc({var x, B b, G<A, B, C, D> g, funcFunc f});
+
+typedef okWithClassesFunc_1({A a, A1 b, A1 c, A1 d});
+typedef okWithClassesFunc_2({D a, D b, D c, D d});
+
+typedef okWithGenericsFunc_1(
+ {Map<num, num> m, List<List<A1>> l, G<A, A1, A1, A1> g});
+typedef okWithGenericsFunc_2(
+ {Map<int, int> m, List<List<D>> l, G<D, D, D, D> g});
+
+typedef okWithDynamicFunc_1({A x, G y, mixFunc z, var v});
+typedef okWithDynamicFunc_2({int x, bool y, List<Map> z, classesFunc v});
+
+main() {
+ Expect.isTrue(/*checks=[]*/ ({D a, B b, C c, A d}) {} is classesFunc);
+ Expect.isTrue(/*checks=[]*/ ({A a, A b, A c, A d}) {} is classesFunc);
+ Expect.isTrue(/*checks=[]*/ ({D a, A1 b, A1 c, A1 d}) {} is classesFunc);
+ Expect.isTrue(/*checks=[]*/ ({D a, A2 b, A2 c, A2 d}) {} is classesFunc);
+ Expect.isTrue(/*checks=[]*/ ({D a, D b, D c, D d}) {} is classesFunc);
+ Expect.isTrue(/*checks=[]*/ ({var a, var b, var c, var d}) {} is classesFunc);
+ Expect.isTrue(/*checks=[]*/ ({Object a, Object b, Object c, Object d}) {}
+ is classesFunc);
+
+ Expect.isTrue(/*checks=[]*/ (
+ {Map<num, num> m,
+ List<List<A1>> l,
+ G<A, A1, A1, A1> g}) {} is genericsFunc);
+ Expect.isTrue(
+ /*checks=[]*/ ({Map<int, int> m, List<List<D>> l, G<D, D, D, D> g}) {}
+ is genericsFunc);
+ Expect.isTrue(/*checks=[]*/ ({var m, var l, var g}) {} is genericsFunc);
+ Expect.isTrue(
+ /*checks=[]*/ ({Object m, Object l, Object g}) {} is genericsFunc);
+
+ Expect.isTrue(/*checks=[]*/ ({A x, G y, mixFunc z, var v}) {} is dynamicFunc);
+ Expect.isTrue(/*checks=[]*/ ({int x, bool y, List<Map> z, classesFunc v}) {}
+ is dynamicFunc);
+
+ Expect.isTrue(/*checks=[]*/ (
+ {okWithClassesFunc_1 f1,
+ okWithGenericsFunc_1 f2,
+ okWithDynamicFunc_1 f3}) {} is funcFunc);
+ Expect.isTrue(/*checks=[]*/ (
+ {okWithClassesFunc_2 f1,
+ okWithGenericsFunc_2 f2,
+ okWithDynamicFunc_2 f3}) {} is funcFunc);
+}
diff --git a/tests/compiler/dart2js/rti/emission/superclass.dart b/tests/compiler/dart2js/rti/emission/superclass.dart
new file mode 100644
index 0000000..4270537
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/superclass.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: B:checks=[]*/
+class B {}
+
+/*class: C:checks=[]*/
+class C extends B {}
+
+@noInline
+test(o) => o is B;
+
+main() {
+ test(new C());
+ test(null);
+}
diff --git a/tests/compiler/dart2js/rti/emission/superclass_as.dart b/tests/compiler/dart2js/rti/emission/superclass_as.dart
new file mode 100644
index 0000000..e780a0e
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/superclass_as.dart
@@ -0,0 +1,26 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:expect/expect.dart';
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[]*/
+class A<T> {}
+
+/*class: B:checks=[]*/
+class B<T, S> {
+ @noInline
+ method() => new A<S>();
+}
+
+/*class: C:checks=[$asB]*/
+class C<T> extends B<T, T> {}
+
+@noInline
+test(o) => o is A<int>;
+
+main() {
+ Expect.isTrue(test(new C<int>().method()));
+ Expect.isFalse(test(new C<String>().method()));
+}
diff --git a/tests/compiler/dart2js/rti/emission/superclass_complex.dart b/tests/compiler/dart2js/rti/emission/superclass_complex.dart
new file mode 100644
index 0000000..d2f9bb5
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/superclass_complex.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[]*/
+class A<T> {}
+
+/*class: B:checks=[]*/
+class B<T> {}
+
+/*class: C:checks=[$asB]*/
+class C<T> extends B<A<T>> {}
+
+@noInline
+test(o) => o is B<A<String>>;
+
+main() {
+ test(new C<String>());
+ test(new C<int>());
+}
diff --git a/tests/compiler/dart2js/rti/emission/superclass_fixed.dart b/tests/compiler/dart2js/rti/emission/superclass_fixed.dart
new file mode 100644
index 0000000..5c86698
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/superclass_fixed.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: B:checks=[]*/
+class B<T> {}
+
+/*class: C:checks=[$asB]*/
+class C extends B<String> {}
+
+@noInline
+test(o) => o is B<String>;
+
+main() {
+ test(new C());
+ test(null);
+}
diff --git a/tests/compiler/dart2js/rti/emission/superclass_supertype.dart b/tests/compiler/dart2js/rti/emission/superclass_supertype.dart
new file mode 100644
index 0000000..fa9bad0
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/superclass_supertype.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[]*/
+class A {}
+
+/*class: B:*/
+class B {}
+
+/*class: C:checks=[$isB]*/
+class C extends A implements B {}
+
+@noInline
+test(o) => o is B;
+
+main() {
+ test(new C());
+ test(null);
+}
diff --git a/tests/compiler/dart2js/rti/emission/superclass_supertype_complex.dart b/tests/compiler/dart2js/rti/emission/superclass_supertype_complex.dart
new file mode 100644
index 0000000..29bcaa7
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/superclass_supertype_complex.dart
@@ -0,0 +1,25 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[]*/
+class A<T> {}
+
+/*class: B:*/
+class B<T> {}
+
+/*class: C:checks=[]*/
+class C<T> {}
+
+/*class: D:checks=[$asB,$isB]*/
+class D<T> extends C<T> implements B<A<T>> {}
+
+@noInline
+test(o) => o is B<A<String>>;
+
+main() {
+ test(new D<String>());
+ test(new D<int>());
+}
diff --git a/tests/compiler/dart2js/rti/emission/superclass_supertype_fixed.dart b/tests/compiler/dart2js/rti/emission/superclass_supertype_fixed.dart
new file mode 100644
index 0000000..3c5a8d0
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/superclass_supertype_fixed.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[]*/
+class A {}
+
+/*class: B:*/
+class B<T> {}
+
+/*class: C:checks=[$asB,$isB]*/
+class C extends A implements B<String> {}
+
+@noInline
+test(o) => o is B<String>;
+
+main() {
+ test(new C());
+ test(null);
+}
diff --git a/tests/compiler/dart2js/rti/emission/superclass_supertype_trivial.dart b/tests/compiler/dart2js/rti/emission/superclass_supertype_trivial.dart
new file mode 100644
index 0000000..73f6b8b
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/superclass_supertype_trivial.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[]*/
+class A<T> {}
+
+/*class: B:*/
+class B<T> {}
+
+/*class: C:checks=[$isB]*/
+class C<T> extends A<T> implements B<T> {}
+
+@noInline
+test(o) => o is B<String>;
+
+main() {
+ test(new C<String>());
+ test(new C<int>());
+}
diff --git a/tests/compiler/dart2js/rti/emission/superclass_trivial.dart b/tests/compiler/dart2js/rti/emission/superclass_trivial.dart
new file mode 100644
index 0000000..b9d8ac1
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/superclass_trivial.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: B:checks=[]*/
+class B<T> {}
+
+/*class: C:checks=[]*/
+class C<T> extends B<T> {}
+
+@noInline
+test(o) => o is B<String>;
+
+main() {
+ test(new C<String>());
+ test(new C<int>());
+}
diff --git a/tests/compiler/dart2js/rti/emission/superclasses_non_trivial.dart b/tests/compiler/dart2js/rti/emission/superclasses_non_trivial.dart
new file mode 100644
index 0000000..c3ff5dd
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/superclasses_non_trivial.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[]*/
+class A<T> {}
+
+/*class: B:checks=[$asA]*/
+class B<S, T> extends A<T> {} // Non-trivial substitution of A.
+
+/*class: C:checks=[]*/
+class C<S, T> extends B<S, T> {} // Non-trivial substitution of A
+
+@noInline
+test(o) => o is A<String>;
+
+main() {
+ test(new C<int, String>());
+ test(new B<String, int>());
+}
diff --git a/tests/compiler/dart2js/rti/emission/superclasses_trivial.dart b/tests/compiler/dart2js/rti/emission/superclasses_trivial.dart
new file mode 100644
index 0000000..a552926
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/superclasses_trivial.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[]*/
+class A<T> {}
+
+/*class: B:checks=[$asA]*/
+class B<S, T> extends A<T> {} // Non-trivial substitution of A.
+
+/*class: C:checks=[$asA,$asB]*/
+class C<T> extends B<T, T> {} // Trivial substitution of A
+
+@noInline
+test(o) => o is A<String>;
+
+main() {
+ test(new C<String>());
+ test(new B<String, int>());
+}
diff --git a/tests/compiler/dart2js/rti/emission/supertype.dart b/tests/compiler/dart2js/rti/emission/supertype.dart
new file mode 100644
index 0000000..763d175
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/supertype.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: B:*/
+class B {}
+
+/*class: C:checks=[$isB]*/
+class C implements B {}
+
+@noInline
+test(o) => o is B;
+
+main() {
+ test(new C());
+ test(null);
+}
diff --git a/tests/compiler/dart2js/rti/emission/supertype_complex.dart b/tests/compiler/dart2js/rti/emission/supertype_complex.dart
new file mode 100644
index 0000000..8a70382
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/supertype_complex.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[]*/
+class A<T> {}
+
+/*class: B:*/
+class B<T> {}
+
+/*class: C:checks=[$asB,$isB]*/
+class C<T> implements B<A<T>> {}
+
+@noInline
+test(o) => o is B<A<String>>;
+
+main() {
+ test(new C<String>());
+ test(new C<int>());
+}
diff --git a/tests/compiler/dart2js/rti/emission/supertype_fixed.dart b/tests/compiler/dart2js/rti/emission/supertype_fixed.dart
new file mode 100644
index 0000000..ce5d6d7
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/supertype_fixed.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: B:*/
+class B<T> {}
+
+/*class: C:checks=[$asB,$isB]*/
+class C implements B<String> {}
+
+@noInline
+test(o) => o is B<String>;
+
+main() {
+ test(new C());
+ test(null);
+}
diff --git a/tests/compiler/dart2js/rti/emission/supertype_trivial.dart b/tests/compiler/dart2js/rti/emission/supertype_trivial.dart
new file mode 100644
index 0000000..4cc95f5
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/supertype_trivial.dart
@@ -0,0 +1,19 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: B:*/
+class B<T> {}
+
+/*class: C:checks=[$isB]*/
+class C<T> implements B<T> {}
+
+@noInline
+test(o) => o is B<String>;
+
+main() {
+ test(new C<String>());
+ test(new C<int>());
+}
diff --git a/tests/compiler/dart2js/rti/emission/supertypes_extends.dart b/tests/compiler/dart2js/rti/emission/supertypes_extends.dart
new file mode 100644
index 0000000..ab679a8
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/supertypes_extends.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:*/
+class A {}
+
+/*class: B:checks=[$isA]*/
+class B implements A {}
+
+/*class: C:checks=[]*/
+class C extends B {} // Implements A through `extends B`.
+
+@noInline
+test(o) => o is A;
+
+main() {
+ test(new C());
+ test(null);
+}
diff --git a/tests/compiler/dart2js/rti/emission/supertypes_extends2.dart b/tests/compiler/dart2js/rti/emission/supertypes_extends2.dart
new file mode 100644
index 0000000..772ef53
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/supertypes_extends2.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+class A {}
+
+/*class: B:checks=[$isA]*/
+class B implements A {}
+
+/*class: C:checks=[]*/
+class C extends B {} // Implements A through `extends B`.
+
+@noInline
+test(o) => o is A;
+
+main() {
+ test(new C());
+ test(new B());
+ test(null);
+}
diff --git a/tests/compiler/dart2js/rti/emission/supertypes_extends3.dart b/tests/compiler/dart2js/rti/emission/supertypes_extends3.dart
new file mode 100644
index 0000000..894e130
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/supertypes_extends3.dart
@@ -0,0 +1,25 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:*/
+class A {}
+
+/*class: B:checks=[$isA]*/
+class B implements A {}
+
+/*class: C:checks=[]*/
+class C extends B {} // Implements A through `extends B`.
+
+/*class: D:checks=[]*/
+class D extends C {} // Implements A through `extends C`.
+
+@noInline
+test(o) => o is A;
+
+main() {
+ test(new D());
+ test(null);
+}
diff --git a/tests/compiler/dart2js/rti/emission/supertypes_implements.dart b/tests/compiler/dart2js/rti/emission/supertypes_implements.dart
new file mode 100644
index 0000000..ac984b7
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/supertypes_implements.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:*/
+class A {}
+
+/*class: B:*/
+class B extends A {}
+
+/*class: C:checks=[$isA]*/
+class C implements B {} // Implements A through `implements B`.
+
+@noInline
+test(o) => o is A;
+
+main() {
+ test(new C());
+ test(null);
+}
diff --git a/tests/compiler/dart2js/rti/emission/supertypes_non_trivial.dart b/tests/compiler/dart2js/rti/emission/supertypes_non_trivial.dart
new file mode 100644
index 0000000..27fd588
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/supertypes_non_trivial.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[]*/
+class A<T> {}
+
+/*class: B:checks=[$asA]*/
+class B<S, T> extends A<T> {} // Non-trivial substitution of A.
+
+/*class: C:checks=[$asA,$isA]*/
+class C<S, T> implements B<S, T> {} // Non-trivial substitution of A
+
+@noInline
+test(o) => o is A<String>;
+
+main() {
+ test(new C<int, String>());
+ test(new B<String, int>());
+}
diff --git a/tests/compiler/dart2js/rti/emission/supertypes_trivial.dart b/tests/compiler/dart2js/rti/emission/supertypes_trivial.dart
new file mode 100644
index 0000000..340c2f4
--- /dev/null
+++ b/tests/compiler/dart2js/rti/emission/supertypes_trivial.dart
@@ -0,0 +1,22 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:meta/dart2js.dart';
+
+/*class: A:checks=[]*/
+class A<T> {}
+
+/*class: B:checks=[$asA]*/
+class B<S, T> extends A<T> {} // Non-trivial substitution of A.
+
+/*class: C:checks=[$isA]*/
+class C<T> implements B<T, T> {} // Trivial substitution of A
+
+@noInline
+test(o) => o is A<String>;
+
+main() {
+ test(new C<String>());
+ test(new B<String, int>());
+}
diff --git a/tests/compiler/dart2js/rti/rti_emission_test.dart b/tests/compiler/dart2js/rti/rti_emission_test.dart
new file mode 100644
index 0000000..2dcdc43
--- /dev/null
+++ b/tests/compiler/dart2js/rti/rti_emission_test.dart
@@ -0,0 +1,207 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:io';
+import 'package:async_helper/async_helper.dart';
+import 'package:compiler/src/closure.dart';
+import 'package:compiler/src/commandline_options.dart';
+import 'package:compiler/src/common.dart';
+import 'package:compiler/src/compiler.dart';
+import 'package:compiler/src/diagnostics/diagnostic_listener.dart';
+import 'package:compiler/src/elements/elements.dart';
+import 'package:compiler/src/elements/entities.dart';
+import 'package:compiler/src/js_emitter/model.dart';
+import 'package:compiler/src/tree/nodes.dart' as ast;
+import 'package:compiler/src/kernel/element_map.dart';
+import 'package:compiler/src/kernel/kernel_backend_strategy.dart';
+import 'package:compiler/src/ssa/builder.dart' as ast;
+import 'package:kernel/ast.dart' as ir;
+import '../equivalence/id_equivalence.dart';
+import '../equivalence/id_equivalence_helper.dart';
+import '../helpers/program_lookup.dart';
+
+main(List<String> args) {
+ asyncTest(() async {
+ Directory dataDir =
+ new Directory.fromUri(Platform.script.resolve('emission'));
+ await checkTests(
+ dataDir, computeAstRtiMemberEmission, computeKernelRtiMemberEmission,
+ computeClassDataFromAst: computeAstRtiClassEmission,
+ computeClassDataFromKernel: computeKernelRtiClassEmission,
+ args: args,
+ options: [
+ Flags.strongMode
+ ],
+ skipForKernel: [
+ // TODO(johnniwinther): Fix this. It triggers a crash in the ssa
+ // builder.
+ 'runtime_type.dart',
+ ]);
+ });
+}
+
+class Tags {
+ static const String isChecks = 'checks';
+}
+
+void computeAstRtiMemberEmission(
+ Compiler compiler, MemberEntity _member, Map<Id, ActualData> actualMap,
+ {bool verbose: false}) {
+ MemberElement member = _member;
+ ResolvedAst resolvedAst = member.resolvedAst;
+ compiler.reporter.withCurrentElement(member.implementation, () {
+ new RtiMemberEmissionAstComputer(
+ compiler.reporter, actualMap, resolvedAst, compiler)
+ .run();
+ });
+}
+
+void computeAstRtiClassEmission(
+ Compiler compiler, ClassEntity cls, Map<Id, ActualData> actualMap,
+ {bool verbose: false}) {
+ new RtiClassEmissionAstComputer(compiler, actualMap).computeClassValue(cls);
+}
+
+abstract class ComputeValueMixin<T> {
+ Compiler get compiler;
+ ProgramLookup lookup;
+
+ String getClassValue(ClassEntity element) {
+ lookup ??= new ProgramLookup(compiler);
+ Class cls = lookup.getClass(element);
+ Features features = new Features();
+ if (cls != null) {
+ features.addElement(Tags.isChecks);
+ for (StubMethod stub in cls.isChecks) {
+ features.addElement(Tags.isChecks, stub.name.key);
+ }
+ }
+ return features.getText();
+ }
+
+ String getMemberValue(MemberEntity member) {
+ if (member.enclosingClass != null && member.enclosingClass.isClosure) {
+ return getClassValue(member.enclosingClass);
+ }
+ return null;
+ }
+}
+
+class RtiClassEmissionAstComputer extends DataRegistry
+ with ComputeValueMixin<ast.Node> {
+ final Compiler compiler;
+ final Map<Id, ActualData> actualMap;
+
+ RtiClassEmissionAstComputer(this.compiler, this.actualMap);
+
+ DiagnosticReporter get reporter => compiler.reporter;
+
+ void computeClassValue(covariant ClassElement cls) {
+ Id id = new ClassId(cls.name);
+ registerValue(cls.sourcePosition, id, getClassValue(cls), cls);
+ }
+}
+
+class RtiMemberEmissionAstComputer extends AstDataExtractor
+ with ComputeValueMixin<ast.Node> {
+ final Compiler compiler;
+
+ RtiMemberEmissionAstComputer(DiagnosticReporter reporter,
+ Map<Id, ActualData> actualMap, ResolvedAst resolvedAst, this.compiler)
+ : super(reporter, actualMap, resolvedAst);
+
+ @override
+ String computeElementValue(Id id, AstElement element) {
+ if (element.isParameter) {
+ return null;
+ } else if (element.isLocal && element.isFunction) {
+ LocalFunctionElement localFunction = element;
+ return getMemberValue(localFunction.callMethod);
+ } else {
+ MemberElement member = element.declaration;
+ return getMemberValue(member);
+ }
+ }
+
+ @override
+ String computeNodeValue(Id id, ast.Node node, [AstElement element]) {
+ if (element != null && element.isLocal && element.isFunction) {
+ return computeElementValue(id, element);
+ }
+ return null;
+ }
+}
+
+void computeKernelRtiMemberEmission(
+ Compiler compiler, MemberEntity member, Map<Id, ActualData> actualMap,
+ {bool verbose: false}) {
+ KernelBackendStrategy backendStrategy = compiler.backendStrategy;
+ KernelToElementMapForBuilding elementMap = backendStrategy.elementMap;
+ MemberDefinition definition = elementMap.getMemberDefinition(member);
+ new RtiMemberEmissionIrComputer(
+ compiler.reporter,
+ actualMap,
+ elementMap,
+ member,
+ compiler,
+ backendStrategy.closureDataLookup as ClosureDataLookup<ir.Node>)
+ .run(definition.node);
+}
+
+void computeKernelRtiClassEmission(
+ Compiler compiler, ClassEntity cls, Map<Id, ActualData> actualMap,
+ {bool verbose: false}) {
+ KernelBackendStrategy backendStrategy = compiler.backendStrategy;
+ KernelToElementMapForBuilding elementMap = backendStrategy.elementMap;
+ new RtiClassEmissionIrComputer(compiler, elementMap, actualMap)
+ .computeClassValue(cls);
+}
+
+class RtiClassEmissionIrComputer extends DataRegistry
+ with ComputeValueMixin<ir.Node> {
+ final Compiler compiler;
+ final KernelToElementMapForBuilding _elementMap;
+ final Map<Id, ActualData> actualMap;
+
+ RtiClassEmissionIrComputer(this.compiler, this._elementMap, this.actualMap);
+
+ DiagnosticReporter get reporter => compiler.reporter;
+
+ void computeClassValue(ClassEntity cls) {
+ Id id = new ClassId(cls.name);
+ ir.TreeNode node = _elementMap.getClassDefinition(cls).node;
+ registerValue(
+ computeSourceSpanFromTreeNode(node), id, getClassValue(cls), cls);
+ }
+}
+
+class RtiMemberEmissionIrComputer extends IrDataExtractor
+ with ComputeValueMixin<ir.Node> {
+ final KernelToElementMapForBuilding _elementMap;
+ final ClosureDataLookup<ir.Node> _closureDataLookup;
+ final Compiler compiler;
+
+ RtiMemberEmissionIrComputer(
+ DiagnosticReporter reporter,
+ Map<Id, ActualData> actualMap,
+ this._elementMap,
+ MemberEntity member,
+ this.compiler,
+ this._closureDataLookup)
+ : super(reporter, actualMap);
+
+ @override
+ String computeMemberValue(Id id, ir.Member node) {
+ return getMemberValue(_elementMap.getMember(node));
+ }
+
+ @override
+ String computeNodeValue(Id id, ir.TreeNode node) {
+ if (node is ir.FunctionExpression || node is ir.FunctionDeclaration) {
+ ClosureRepresentationInfo info = _closureDataLookup.getClosureInfo(node);
+ return getMemberValue(info.callMethod);
+ }
+ return null;
+ }
+}
diff --git a/tests/compiler/dart2js/rti/rti_need_test.dart b/tests/compiler/dart2js/rti/rti_need_test.dart
index 75a94d4..1acbf8f 100644
--- a/tests/compiler/dart2js/rti/rti_need_test.dart
+++ b/tests/compiler/dart2js/rti/rti_need_test.dart
@@ -34,7 +34,14 @@
computeClassDataFromAst: computeAstRtiClassNeed,
computeClassDataFromKernel: computeKernelRtiClassNeed,
args: args,
- options: [Flags.strongMode]);
+ options: [
+ Flags.strongMode
+ ],
+ skipForKernel: [
+ // TODO(johnniwinther): Fix this. It triggers a crash in the ssa
+ // builder.
+ 'generic_creation.dart',
+ ]);
});
}
@@ -71,23 +78,6 @@
static const String directTypeArgumentTest = 'direct';
static const String indirectTypeArgumentTest = 'indirect';
static const String typeLiteral = 'exp';
- static const String typeChecks = 'checks';
-
- /// This class is needed as a checked type argument.
- ///
- /// For instance directly in `String` in `o is List<String>` or indirectly
- /// as `String` in
- ///
- /// class C<T> {
- /// method(o) => o is T;
- /// }
- /// main() => new C<String>().method('');
- static const String argumentClass = 'arg';
-
- // Objects are checked against this class.
- //
- // For instance `String` in `o is String`.
- static const String checkedClass = 'checked';
}
abstract class ComputeValueMixin<T> {
@@ -98,9 +88,6 @@
RuntimeTypesNeedBuilderImpl get rtiNeedBuilder =>
compiler.frontendStrategy.runtimeTypesNeedBuilderForTesting;
RuntimeTypesNeed get rtiNeed => compiler.backendClosedWorldForTesting.rtiNeed;
- RuntimeTypesChecks get rtiChecks =>
- compiler.backend.emitter.typeTestRegistry.rtiChecks;
- TypeChecks get requiredChecks => rtiChecks.requiredChecks;
ClassEntity getFrontendClass(ClassEntity cls);
MemberEntity getFrontendMember(MemberEntity member);
Local getFrontendClosure(MemberEntity member);
@@ -152,17 +139,6 @@
rtiNeedBuilder.typeVariableTests.explicitIsChecks);
findChecks(features, Tags.implicitTypeCheck, frontendClass,
rtiNeedBuilder.typeVariableTests.implicitIsChecks);
- if (rtiChecks.checkedClasses.contains(backendClass)) {
- features.add(Tags.checkedClass);
- }
- if (rtiChecks.getRequiredArgumentClasses().contains(backendClass)) {
- features.add(Tags.argumentClass);
- }
- Iterable<TypeCheck> checks = requiredChecks[backendClass];
- if (checks.isNotEmpty) {
- features[Tags.typeChecks] =
- '[${(checks.map((c) => c.cls.name).toList()..sort()).join(',')}]';
- }
return features.getText();
}
diff --git a/tests/corelib_2/corelib_2.status b/tests/corelib_2/corelib_2.status
index 4f5250d..5047aea 100644
--- a/tests/corelib_2/corelib_2.status
+++ b/tests/corelib_2/corelib_2.status
@@ -250,7 +250,6 @@
symbol_reserved_word_test/03: RuntimeError
type_hashcode_test: Crash # Assertion failure: Only 2 of 3 arguments have been read from: [HRef(HForeignCode("# ? Object.keys(#) : []")), literal: NullConstant, literal: NullConstant]
uri_base_test: RuntimeError
-uri_query_test: Crash # Assertion failure: Cannot find value local(testQueryParameters#normalizedQuery) in (BoxLocal(_box_0)) for j:signature(testQueryParameters_test.$signature).
[ $compiler == dart2js && $dart2js_with_kernel && $minified && $strong ]
apply3_test: CompileTimeError
@@ -293,7 +292,6 @@
symbol_operator_test/none: RuntimeError
symbol_reserved_word_test/03: RuntimeError
uri_base_test: RuntimeError
-uri_query_test: Crash # Assertion failure: Cannot find value local(testQueryParameters#normalizedQuery) in (BoxLocal(_box_0)) for j:signature(testQueryParameters_test.$signature).
[ $compiler == dart2js && $dart2js_with_kernel && !$strong ]
*: SkipByDesign
diff --git a/tests/language/language_dart2js.status b/tests/language/language_dart2js.status
index 368ba6a..f4ca4f4 100644
--- a/tests/language/language_dart2js.status
+++ b/tests/language/language_dart2js.status
@@ -277,8 +277,6 @@
mixin_illegal_superclass_test/29: MissingCompileTimeError
mixin_illegal_superclass_test/30: MissingCompileTimeError
mixin_issue10216_2_test: RuntimeError
-mixin_mixin2_test: RuntimeError
-mixin_mixin3_test: RuntimeError
mixin_mixin4_test: RuntimeError
mixin_mixin5_test: RuntimeError
mixin_mixin6_test: RuntimeError
@@ -286,7 +284,6 @@
mixin_mixin_bound2_test: RuntimeError
mixin_mixin_bound_test: RuntimeError
mixin_mixin_test: RuntimeError
-mixin_mixin_type_arguments_test: Crash # NoSuchMethodError: The method 'hasSubclass' was called on null.
mixin_of_mixin_test/01: CompileTimeError
mixin_of_mixin_test/02: CompileTimeError
mixin_of_mixin_test/03: CompileTimeError
@@ -642,8 +639,6 @@
mixin_illegal_superclass_test/29: MissingCompileTimeError
mixin_illegal_superclass_test/30: MissingCompileTimeError
mixin_issue10216_2_test: RuntimeError
-mixin_mixin2_test: RuntimeError
-mixin_mixin3_test: RuntimeError
mixin_mixin4_test: RuntimeError
mixin_mixin5_test: RuntimeError
mixin_mixin6_test: RuntimeError
@@ -651,7 +646,6 @@
mixin_mixin_bound2_test: RuntimeError
mixin_mixin_bound_test: RuntimeError
mixin_mixin_test: RuntimeError
-mixin_mixin_type_arguments_test: RuntimeError
mixin_of_mixin_test/01: CompileTimeError
mixin_of_mixin_test/02: CompileTimeError
mixin_of_mixin_test/03: CompileTimeError
@@ -949,9 +943,6 @@
mixin_illegal_superclass_test/28: MissingCompileTimeError
mixin_illegal_superclass_test/29: MissingCompileTimeError
mixin_illegal_superclass_test/30: MissingCompileTimeError
-mixin_mixin2_test: RuntimeError
-mixin_mixin3_test: RuntimeError
-mixin_mixin_type_arguments_test: RuntimeError
mixin_of_mixin_test/01: CompileTimeError
mixin_of_mixin_test/02: CompileTimeError
mixin_of_mixin_test/03: CompileTimeError
@@ -1259,7 +1250,6 @@
mixin_illegal_superclass_test/28: MissingCompileTimeError
mixin_illegal_superclass_test/29: MissingCompileTimeError
mixin_illegal_superclass_test/30: MissingCompileTimeError
-mixin_mixin_type_arguments_test: RuntimeError
mixin_of_mixin_test/01: CompileTimeError
mixin_of_mixin_test/02: CompileTimeError
mixin_of_mixin_test/03: CompileTimeError
@@ -1460,9 +1450,6 @@
mixin_forwarding_constructor4_test/01: MissingCompileTimeError # Issue 15101
mixin_forwarding_constructor4_test/02: MissingCompileTimeError # Issue 15101
mixin_forwarding_constructor4_test/03: MissingCompileTimeError # Issue 15101
-mixin_mixin2_test: RuntimeError # Issue 13109.
-mixin_mixin3_test: RuntimeError # Issue 13109.
-mixin_mixin_type_arguments_test: RuntimeError # Issue 29587
mixin_of_mixin_test: CompileTimeError # Issue 23773
mixin_super_2_test: CompileTimeError # Issue 23773
mixin_super_bound2_test: CompileTimeError # Issue 23773
@@ -1585,18 +1572,19 @@
symbol_conflict_test: RuntimeError # Issue 23857
[ $compiler == dart2js && $minified ]
-cyclic_type2_test: RuntimeError, OK # runtimeType.toString not preserved in minified code.
-cyclic_type_test/0*: RuntimeError, OK # runtimeType.toString not preserved in minified code.
-f_bounded_quantification4_test: RuntimeError, OK # runtimeType.toString not preserved in minified code.
-generic_closure_test: RuntimeError, OK # runtimeType.toString not preserved in minified code.
-mixin_generic_test: RuntimeError, OK # runtimeType.toString not preserved in minified code.
-mixin_mixin2_test: RuntimeError, OK # runtimeType.toString not preserved in minified code.
-mixin_mixin3_test: RuntimeError, OK # runtimeType.toString not preserved in minified code.
-mixin_mixin4_test: RuntimeError, OK # runtimeType.toString not preserved in minified code.
-mixin_mixin5_test: RuntimeError, OK # runtimeType.toString not preserved in minified code.
-mixin_mixin6_test: RuntimeError, OK # runtimeType.toString not preserved in minified code.
-mixin_mixin_bound2_test: RuntimeError, OK # runtimeType.toString not preserved in minified code.
-mixin_mixin_bound_test: RuntimeError, OK # runtimeType.toString not preserved in minified code.
-regress_21795_test: RuntimeError, OK # runtimeType.toString not preserved in minified code.
+cyclic_type2_test: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
+cyclic_type_test/0*: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
+f_bounded_quantification4_test: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
+generic_closure_test: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
+mixin_generic_test: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
+mixin_mixin2_test: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
+mixin_mixin3_test: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
+mixin_mixin4_test: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
+mixin_mixin5_test: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
+mixin_mixin6_test: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
+mixin_mixin_bound2_test: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
+mixin_mixin_bound_test: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
+mixin_mixin_type_arguments_test: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
+regress_21795_test: RuntimeError, OK # Issue 31054: runtimeType.toString not preserved in minified code.
stack_trace_test: RuntimeError, OK # Stack trace not preserved in minified code.
diff --git a/tests/language_2/language_2_analyzer.status b/tests/language_2/language_2_analyzer.status
index 2902b0f..f24119b 100644
--- a/tests/language_2/language_2_analyzer.status
+++ b/tests/language_2/language_2_analyzer.status
@@ -1205,7 +1205,6 @@
super_setter_test: StaticWarning # Issue 28823
switch_case_test/none: CompileTimeError
type_inference_accessor_ref_test/06: MissingCompileTimeError
-type_inference_circularity_test: MissingCompileTimeError
type_promotion_functions_test/01: Pass
type_promotion_functions_test/05: Pass
type_promotion_functions_test/06: Pass
diff --git a/tests/language_2/language_2_dart2js.status b/tests/language_2/language_2_dart2js.status
index 22eab3f..d7f5dbe 100644
--- a/tests/language_2/language_2_dart2js.status
+++ b/tests/language_2/language_2_dart2js.status
@@ -263,9 +263,6 @@
implicit_downcast_during_while_statement_test: RuntimeError
inferrer_synthesized_constructor_test: RuntimeError
malformed2_test/00: MissingCompileTimeError
-mixin_mixin2_test: RuntimeError
-mixin_mixin3_test: RuntimeError
-mixin_mixin_type_arguments_test: RuntimeError
mixin_type_parameters_super_test: RuntimeError
type_parameter_test/05: MissingCompileTimeError
typevariable_substitution2_test/02: RuntimeError
@@ -637,8 +634,6 @@
mixin_illegal_superclass_test/29: MissingCompileTimeError
mixin_illegal_superclass_test/30: MissingCompileTimeError
mixin_issue10216_2_test: RuntimeError
-mixin_mixin2_test: RuntimeError
-mixin_mixin3_test: RuntimeError
mixin_mixin4_test: RuntimeError
mixin_mixin5_test: RuntimeError
mixin_mixin6_test: RuntimeError
@@ -646,7 +641,6 @@
mixin_mixin_bound2_test: RuntimeError
mixin_mixin_bound_test: RuntimeError
mixin_mixin_test: RuntimeError
-mixin_mixin_type_arguments_test: RuntimeError
mixin_of_mixin_test/none: CompileTimeError
mixin_super_2_test/none: CompileTimeError
mixin_super_constructor_named_test/01: MissingCompileTimeError
@@ -1229,8 +1223,6 @@
mixin_illegal_superclass_test/29: MissingCompileTimeError
mixin_illegal_superclass_test/30: MissingCompileTimeError
mixin_issue10216_2_test: RuntimeError
-mixin_mixin2_test: RuntimeError
-mixin_mixin3_test: RuntimeError
mixin_mixin4_test: RuntimeError
mixin_mixin5_test: RuntimeError
mixin_mixin6_test: RuntimeError
@@ -1238,7 +1230,6 @@
mixin_mixin_bound2_test: RuntimeError
mixin_mixin_bound_test: RuntimeError
mixin_mixin_test: RuntimeError
-mixin_mixin_type_arguments_test: RuntimeError
mixin_of_mixin_test/none: CompileTimeError
mixin_super_2_test/none: CompileTimeError
mixin_super_constructor_named_test/01: MissingCompileTimeError
@@ -1798,9 +1789,6 @@
mixin_invalid_bound_test/08: MissingCompileTimeError
mixin_invalid_bound_test/09: MissingCompileTimeError
mixin_invalid_bound_test/10: MissingCompileTimeError
-mixin_mixin2_test: RuntimeError
-mixin_mixin3_test: RuntimeError
-mixin_mixin_type_arguments_test: RuntimeError
mixin_of_mixin_test/none: CompileTimeError
mixin_regress_13688_test: Crash # Assertion failure: Only 2 of 3 arguments have been read from: [HRef(HForeignCode("# ? Object.keys(#) : []")), literal: NullConstant, literal: NullConstant]
mixin_super_2_test/none: CompileTimeError
@@ -2567,7 +2555,6 @@
mixin_invalid_bound_test/08: MissingCompileTimeError
mixin_invalid_bound_test/09: MissingCompileTimeError
mixin_invalid_bound_test/10: MissingCompileTimeError
-mixin_mixin_type_arguments_test: RuntimeError
mixin_of_mixin_test/none: CompileTimeError
mixin_super_2_test/none: CompileTimeError
mixin_super_bound_test/01: MissingCompileTimeError
@@ -3437,9 +3424,6 @@
mixin_invalid_bound_test/08: MissingCompileTimeError
mixin_invalid_bound_test/09: MissingCompileTimeError
mixin_invalid_bound_test/10: MissingCompileTimeError
-mixin_mixin2_test: RuntimeError # Issue 13109.
-mixin_mixin3_test: RuntimeError # Issue 13109.
-mixin_mixin_type_arguments_test: RuntimeError # Issue 29587
mixin_of_mixin_test/none: CompileTimeError
mixin_super_2_test/none: CompileTimeError
mixin_super_bound2_test: CompileTimeError # Issue 23773
@@ -3873,6 +3857,7 @@
mixin_mixin6_test: RuntimeError # Issue 31054
mixin_mixin_bound2_test: RuntimeError # Issue 31054
mixin_mixin_bound_test: RuntimeError # Issue 31054
+mixin_mixin_type_arguments_test: RuntimeError # Issue 31054
[ $compiler == dart2js && !$strong ]
dynamic_test: RuntimeError
diff --git a/tests/language_2/vm/await_synchronous_future_test.dart b/tests/language_2/vm/await_synchronous_future_test.dart
new file mode 100644
index 0000000..9ccf5dc
--- /dev/null
+++ b/tests/language_2/vm/await_synchronous_future_test.dart
@@ -0,0 +1,48 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// Test that async/await syntax works for synchronously completed futures.
+// Such futures are used by Flutter (see http://dartbug.com/32098).
+
+import 'dart:async';
+
+import 'package:expect/expect.dart';
+import 'package:async_helper/async_helper.dart';
+
+class SynchronousFuture<T> implements Future<T> {
+ final T v;
+
+ SynchronousFuture(this.v);
+
+ Future<E> then<E>(FutureOr<E> f(T v), {Function onError}) {
+ final u = f(v);
+ return u is Future<dynamic>
+ ? (u as Future<dynamic>).then((v) => v as E)
+ : new SynchronousFuture<E>(u);
+ }
+
+ Stream<T> asStream() => throw 'unimplemented';
+ Future<T> catchError(Function onError, {bool test(dynamic error)}) =>
+ throw 'unimplemented';
+ Future<T> timeout(Duration timeLimit, {dynamic onTimeout()}) =>
+ throw 'unimplemented';
+ Future<T> whenComplete(dynamic action()) => throw 'unimplemented';
+}
+
+void main() {
+ var stage = 0;
+ asyncTest(() async {
+ int v;
+ Expect.equals(0, stage++);
+ v = await new SynchronousFuture<int>(stage);
+ Expect.equals(1, v);
+ Expect.equals(1, stage++);
+ v = await new SynchronousFuture<int>(stage);
+ Expect.equals(2, v);
+ Expect.equals(2, stage++);
+ v = await new SynchronousFuture<int>(stage);
+ Expect.equals(3, v);
+ Expect.equals(3, stage++);
+ });
+}
diff --git a/tests/lib_2/lib_2_dart2js.status b/tests/lib_2/lib_2_dart2js.status
index 21b3a73..87a6273 100644
--- a/tests/lib_2/lib_2_dart2js.status
+++ b/tests/lib_2/lib_2_dart2js.status
@@ -68,6 +68,7 @@
typed_data/int32x4_arithmetic_test/int64: RuntimeError # Issue 1533
typed_data/int64_list_load_store_test: RuntimeError # Issue 10275
typed_data/typed_data_hierarchy_int64_test: RuntimeError # Issue 10275
+typed_data/unmodifiable_typed_data_test: RuntimeError # Issue 10275
[ $compiler != dart2js ]
async/dart2js_uncaught_error_test: Skip # JS-integration only test
diff --git a/tests/lib_2/lib_2_dartdevc.status b/tests/lib_2/lib_2_dartdevc.status
index dd36b16..c90982c 100644
--- a/tests/lib_2/lib_2_dartdevc.status
+++ b/tests/lib_2/lib_2_dartdevc.status
@@ -130,4 +130,4 @@
typed_data/int32x4_arithmetic_test/int64: RuntimeError # Issue 29922
typed_data/int64_list_load_store_test: RuntimeError # Issue 29922
typed_data/typed_data_hierarchy_int64_test: RuntimeError # Issue 29922
-
+typed_data/unmodifiable_typed_data_test: RuntimeError # Issue 10275
diff --git a/tests/lib_2/typed_data/unmodifiable_typed_data_test.dart b/tests/lib_2/typed_data/unmodifiable_typed_data_test.dart
new file mode 100644
index 0000000..70708c5
--- /dev/null
+++ b/tests/lib_2/typed_data/unmodifiable_typed_data_test.dart
@@ -0,0 +1,165 @@
+// Copyright (c) 2018, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:typed_data';
+import 'package:expect/expect.dart';
+
+List<int> intList = <int>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+
+checkReadable(List<int> list) {
+ for (int i = 0; i < intList.length; i++) {
+ Expect.equals(list[i], intList[i]);
+ }
+}
+
+checkUnmodifiable(List<int> list) {
+ var zero = 0;
+ var one = 1;
+ var two = 2;
+ Expect.throwsUnsupportedError(() => list.add(zero));
+ Expect.throwsUnsupportedError(() => list.addAll([one, two]));
+ Expect.throwsUnsupportedError(() => list.clear());
+ Expect.throwsUnsupportedError(() => list.insert(0, zero));
+ Expect.throwsUnsupportedError(() => list.insertAll(0, [one, two]));
+ Expect.throwsUnsupportedError(() => list.remove(one));
+ Expect.throwsUnsupportedError(() => list.removeAt(0));
+ Expect.throwsUnsupportedError(() => list.removeLast());
+ Expect.throwsUnsupportedError(() => list.removeRange(0, 1));
+ Expect.throwsUnsupportedError(() => list.removeWhere((x) => true));
+ Expect.throwsUnsupportedError(() => list.replaceRange(0, 1, []));
+ Expect.throwsUnsupportedError(() => list.retainWhere((x) => false));
+ Expect.throwsUnsupportedError(() => list[0] = zero);
+ Expect.throwsUnsupportedError(() => list.setRange(0, 1, [one]));
+ Expect.throwsUnsupportedError(() => list.setAll(0, [one]));
+}
+
+int8ListTest() {
+ Int8List i8l = new Int8List.fromList(intList);
+ UnmodifiableInt8ListView list = new UnmodifiableInt8ListView(i8l);
+ checkReadable(list);
+ checkUnmodifiable(list);
+}
+
+uint8ListTest() {
+ Uint8List u8l = new Uint8List.fromList(intList);
+ UnmodifiableUint8ListView list = new UnmodifiableUint8ListView(u8l);
+ checkReadable(list);
+ checkUnmodifiable(list);
+}
+
+int16ListTest() {
+ Int16List i16l = new Int16List.fromList(intList);
+ UnmodifiableInt16ListView list = new UnmodifiableInt16ListView(i16l);
+ checkReadable(list);
+ checkUnmodifiable(list);
+}
+
+uint16ListTest() {
+ Uint16List u16l = new Uint16List.fromList(intList);
+ UnmodifiableUint16ListView list = new UnmodifiableUint16ListView(u16l);
+ checkReadable(list);
+ checkUnmodifiable(list);
+}
+
+int32ListTest() {
+ Int32List i32l = new Int32List.fromList(intList);
+ UnmodifiableInt32ListView list = new UnmodifiableInt32ListView(i32l);
+ checkReadable(list);
+ checkUnmodifiable(list);
+}
+
+uint32ListTest() {
+ Uint32List u32l = new Uint32List.fromList(intList);
+ UnmodifiableUint32ListView list = new UnmodifiableUint32ListView(u32l);
+ checkReadable(list);
+ checkUnmodifiable(list);
+}
+
+int64ListTest() {
+ Int64List i64l = new Int64List.fromList(intList);
+ UnmodifiableInt64ListView list = new UnmodifiableInt64ListView(i64l);
+ checkReadable(list);
+ checkUnmodifiable(list);
+}
+
+uint64ListTest() {
+ Uint64List u64l = new Uint64List.fromList(intList);
+ UnmodifiableUint64ListView list = new UnmodifiableUint64ListView(u64l);
+ checkReadable(list);
+ checkUnmodifiable(list);
+}
+
+List<double> doubleList = <double>[1.0, 2.0, 3.0, 4.0, 5.0];
+
+checkDoubleReadable(List<double> list) {
+ for (int i = 0; i < doubleList.length; i++) {
+ Expect.equals(list[i], doubleList[i]);
+ }
+}
+
+checkDoubleUnmodifiable(List<double> list) {
+ var zero = 0.0;
+ var one = 1.0;
+ var two = 2.0;
+ Expect.throwsUnsupportedError(() => list.add(zero));
+ Expect.throwsUnsupportedError(() => list.addAll([one, two]));
+ Expect.throwsUnsupportedError(() => list.clear());
+ Expect.throwsUnsupportedError(() => list.insert(0, zero));
+ Expect.throwsUnsupportedError(() => list.insertAll(0, [one, two]));
+ Expect.throwsUnsupportedError(() => list.remove(one));
+ Expect.throwsUnsupportedError(() => list.removeAt(0));
+ Expect.throwsUnsupportedError(() => list.removeLast());
+ Expect.throwsUnsupportedError(() => list.removeRange(0, 1));
+ Expect.throwsUnsupportedError(() => list.removeWhere((x) => true));
+ Expect.throwsUnsupportedError(() => list.replaceRange(0, 1, []));
+ Expect.throwsUnsupportedError(() => list.retainWhere((x) => false));
+ Expect.throwsUnsupportedError(() => list[0] = zero);
+ Expect.throwsUnsupportedError(() => list.setRange(0, 1, [one]));
+ Expect.throwsUnsupportedError(() => list.setAll(0, [one]));
+}
+
+float32ListTest() {
+ Float32List f32l = new Float32List.fromList(doubleList);
+ UnmodifiableFloat32ListView list = new UnmodifiableFloat32ListView(f32l);
+ checkDoubleReadable(list);
+ checkDoubleUnmodifiable(list);
+}
+
+float64ListTest() {
+ Float64List f64l = new Float64List.fromList(doubleList);
+ UnmodifiableFloat64ListView list = new UnmodifiableFloat64ListView(f64l);
+ checkDoubleReadable(list);
+ checkDoubleUnmodifiable(list);
+}
+
+byteDataTest() {
+ ByteBuffer buffer = new Uint8List.fromList(intList).buffer;
+ ByteData bd = new ByteData.view(buffer);
+ UnmodifiableByteDataView ubdv = new UnmodifiableByteDataView(bd);
+
+ Expect.throwsUnsupportedError(() => ubdv.setInt8(0, 0));
+ Expect.throwsUnsupportedError(() => ubdv.setUint8(0, 0));
+ Expect.throwsUnsupportedError(() => ubdv.setInt16(0, 0));
+ Expect.throwsUnsupportedError(() => ubdv.setUint16(0, 0));
+ Expect.throwsUnsupportedError(() => ubdv.setInt32(0, 0));
+ Expect.throwsUnsupportedError(() => ubdv.setUint32(0, 0));
+ Expect.throwsUnsupportedError(() => ubdv.setInt64(0, 0));
+ Expect.throwsUnsupportedError(() => ubdv.setUint64(0, 0));
+ Expect.throwsUnsupportedError(() => ubdv.setFloat32(0, 0.0));
+ Expect.throwsUnsupportedError(() => ubdv.setFloat64(0, 0.0));
+}
+
+main() {
+ int8ListTest();
+ uint8ListTest();
+ int16ListTest();
+ uint16ListTest();
+ int32ListTest();
+ uint32ListTest();
+ int64ListTest();
+ uint64ListTest();
+ float32ListTest();
+ float64ListTest();
+ byteDataTest();
+}
diff --git a/tools/VERSION b/tools/VERSION
index 1145d30..f6a0fd2 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
MAJOR 2
MINOR 0
PATCH 0
-PRERELEASE 23
+PRERELEASE 24
PRERELEASE_PATCH 0
diff --git a/tools/testing/dart/command.dart b/tools/testing/dart/command.dart
index 0a25554..b2680ca 100644
--- a/tools/testing/dart/command.dart
+++ b/tools/testing/dart/command.dart
@@ -115,6 +115,24 @@
return new MakeSymlinkCommand._(link, target);
}
+ static Command fasta(
+ Uri compilerLocation,
+ Uri outputFile,
+ List<Uri> bootstrapDependencies,
+ Uri executable,
+ List<String> arguments,
+ Map<String, String> environment,
+ Uri workingDirectory) {
+ return new FastaCompilationCommand._(
+ compilerLocation,
+ outputFile,
+ bootstrapDependencies,
+ executable,
+ arguments,
+ environment,
+ workingDirectory);
+ }
+
/// A descriptive name for this command.
final String displayName;
@@ -282,6 +300,73 @@
deepJsonCompare(_bootstrapDependencies, other._bootstrapDependencies);
}
+class FastaCompilationCommand extends CompilationCommand {
+ final Uri _compilerLocation;
+
+ FastaCompilationCommand._(
+ this._compilerLocation,
+ Uri outputFile,
+ List<Uri> bootstrapDependencies,
+ Uri executable,
+ List<String> arguments,
+ Map<String, String> environmentOverrides,
+ Uri workingDirectory)
+ : super._("fasta", outputFile.toFilePath(), true, bootstrapDependencies,
+ executable.toFilePath(), arguments, environmentOverrides,
+ workingDirectory: workingDirectory?.toFilePath());
+
+ @override
+ List<String> get batchArguments {
+ return <String>[
+ _compilerLocation.resolve("batch.dart").toFilePath(),
+ ];
+ }
+
+ @override
+ String get reproductionCommand {
+ String relativizeAndEscape(String argument) {
+ if (workingDirectory != null) {
+ argument = argument.replaceAll(
+ workingDirectory, new Uri.directory(".").toFilePath());
+ }
+ return escapeCommandLineArgument(argument);
+ }
+
+ StringBuffer buffer = new StringBuffer();
+ if (workingDirectory != null && !io.Platform.isWindows) {
+ buffer.write("(cd ");
+ buffer.write(escapeCommandLineArgument(workingDirectory));
+ buffer.write(" ; ");
+ }
+ environmentOverrides?.forEach((key, value) {
+ if (io.Platform.isWindows) {
+ buffer.write("set ");
+ }
+ buffer.write(key);
+ buffer.write("=");
+ buffer.write(relativizeAndEscape(value));
+ if (io.Platform.isWindows) {
+ buffer.write(" &");
+ }
+ buffer.write(" ");
+ });
+ buffer.writeAll(
+ (<String>[executable]
+ ..add(_compilerLocation.toFilePath())
+ ..addAll(arguments))
+ .map(relativizeAndEscape),
+ " ");
+ if (workingDirectory != null) {
+ if (io.Platform.isWindows) {
+ buffer.write(" (working directory: $workingDirectory)");
+ } else {
+ buffer.write(" )");
+ }
+ }
+ return "$buffer";
+ }
+}
+
class VMKernelCompilationCommand extends CompilationCommand {
VMKernelCompilationCommand._(
String outputFile,
diff --git a/tools/testing/dart/compiler_configuration.dart b/tools/testing/dart/compiler_configuration.dart
index 8cb66ae..ac20f0b 100644
--- a/tools/testing/dart/compiler_configuration.dart
+++ b/tools/testing/dart/compiler_configuration.dart
@@ -85,8 +85,10 @@
case Compiler.specParser:
return new SpecParserCompilerConfiguration(configuration);
+ case Compiler.fasta:
+ return new FastaCompilerConfiguration(configuration);
+
case Compiler.none:
- case Compiler.fasta: // TODO(ahe): Implement a real fasta compiler.
return new NoneCompilerConfiguration(configuration);
}
@@ -161,7 +163,6 @@
List<String> sharedOptions,
List<String> originalArguments,
CommandArtifact artifact) {
- var buildDir = _configuration.buildDirectory;
var args = <String>[];
if (useDfe) {
// DFE+strong configuration is a Dart 2.0 configuration which uses
@@ -1080,3 +1081,117 @@
genKernel, args, environmentOverrides);
}
}
+
+class FastaCompilerConfiguration extends CompilerConfiguration {
+ static const String mimeType = "application/x.dill";
+
+ final Uri _compilerLocation;
+
+ final Uri _plaformDill;
+
+ final Uri _vmExecutable;
+
+ final bool _isLegacy;
+
+ FastaCompilerConfiguration(Configuration configuration)
+ : this._(
+ Uri.base.resolve("pkg/front_end/tool/_fasta/compile.dart"),
+ Uri.base
+ .resolveUri(new Uri.directory(configuration.buildDirectory)),
+ !configuration.isStrong,
+ configuration.useSdk,
+ configuration);
+
+ FastaCompilerConfiguration._(this._compilerLocation, Uri buildDirectory,
+ this._isLegacy, bool useSdk, Configuration configuration)
+ : _plaformDill = (useSdk
+ ? buildDirectory.resolve("dart-sdk/lib/_internal/")
+ : buildDirectory)
+ .resolve(
+ _isLegacy ? "vm_platform.dill" : "vm_platform_strong.dill"),
+ _vmExecutable = useSdk
+ ? buildDirectory.resolve("dart-sdk/bin/dart")
+ : buildDirectory.resolve("dart"),
+ super._subclass(configuration);
+
+ @override
+ bool get useDfe => true;
+
+ @override
+ bool get runRuntimeDespiteMissingCompileTimeError => true;
+
+ @override
+ int get timeoutMultiplier => 1;
+
+ @override
+ bool get hasCompiler => true;
+
+ @override
+ List<Uri> bootstrapDependencies() => <Uri>[_plaformDill];
+
+ @override
+ Command createCommand(String inputFile, String outputFile,
+ List<String> sharedOptions, Map<String, String> environment) {
+ throw "not implemented yet";
+ }
+
+ @override
+ CommandArtifact computeCompilationArtifact(String tempDir,
+ List<String> arguments, Map<String, String> environmentOverrides) {
+ Uri output =
+ Uri.base.resolveUri(new Uri.directory(tempDir)).resolve("out.dill");
+ String outputFileName = output.toFilePath();
+ String vmPath = _vmExecutable.toFilePath();
+ if (Platform.isWindows) {
+ vmPath += ".exe";
+ }
+ List<String> compilerArguments = <String>[
+ "-o",
+ outputFileName,
+ "--platform",
+ _plaformDill.toFilePath(),
+ ]..addAll(arguments);
+
+ return new CommandArtifact(
+ [
+ Command.fasta(
+ _compilerLocation,
+ output,
+ bootstrapDependencies(),
+ _vmExecutable,
+ compilerArguments,
+ environmentOverrides,
+ Uri.base,
+ )
+ ],
+ outputFileName,
+ mimeType,
+ );
+ }
+
+ @override
+ List<String> computeCompilerArguments(
+ List<String> vmOptions,
+ List<String> sharedOptions,
+ List<String> dart2jsOptions,
+ List<String> args) {
+ List<String> arguments = <String>[];
+ for (String argument in args) {
+ if (argument != "--ignore-unrecognized-flags") {
+ arguments.add(argument);
+ }
+ }
+ return arguments;
+ }
+
+ @override
+ List<String> computeRuntimeArguments(
+ RuntimeConfiguration runtimeConfiguration,
+ TestInformation info,
+ List<String> vmOptions,
+ List<String> sharedOptions,
+ List<String> originalArguments,
+ CommandArtifact artifact) {
+ return <String>[];
+ }
+}
diff --git a/tools/testing/dart/test_runner.dart b/tools/testing/dart/test_runner.dart
index 2cb2950..5c743b3 100644
--- a/tools/testing/dart/test_runner.dart
+++ b/tools/testing/dart/test_runner.dart
@@ -572,6 +572,10 @@
}
class BatchRunnerProcess {
+ /// When true, the command line is passed to the test runner as a
+ /// JSON-encoded list of strings.
+ final bool _jsonCommandLine;
+
Completer<CommandOutput> _completer;
ProcessCommand _command;
List<String> _arguments;
@@ -593,6 +597,8 @@
Timer _timer;
int _testCount = 0;
+ BatchRunnerProcess(this._jsonCommandLine);
+
Future<CommandOutput> runCommand(String runnerType, ProcessCommand command,
int timeout, List<String> arguments) {
assert(_completer == null);
@@ -664,7 +670,11 @@
}
String _createArgumentsLine(List<String> arguments, int timeout) {
- return arguments.join(' ') + '\n';
+ if (_jsonCommandLine) {
+ return "${JSON.encode(arguments)}\n";
+ } else {
+ return arguments.join(' ') + '\n';
+ }
}
void _reportResult() {
@@ -1161,7 +1171,8 @@
.runCommand(command.displayName, command, timeout, command.arguments);
} else if (command is CompilationCommand &&
(command.displayName == 'dartdevc' ||
- command.displayName == 'dartdevk') &&
+ command.displayName == 'dartdevk' ||
+ command.displayName == 'fasta') &&
globalConfiguration.batch) {
return _getBatchRunner(command.displayName)
.runCommand(command.displayName, command, timeout, command.arguments);
@@ -1269,7 +1280,7 @@
if (runners == null) {
runners = new List<BatchRunnerProcess>(maxProcesses);
for (int i = 0; i < maxProcesses; i++) {
- runners[i] = new BatchRunnerProcess();
+ runners[i] = new BatchRunnerProcess(identifier == "fasta");
}
_batchProcesses[identifier] = runners;
}
