Handle type literals correctly with deferred loading and await.

Handle type literals correctly with deferred loading and await.

When referring to constants via a deferred prefix in an await expression
the transformation must make sure that the generated code before and after
the deferred load agree on the number of captured variables. (i.e. the number
of await-temp variables introduced by the await-transformer is the same)

This CL uses a temporary in the case of compile-time constants, because before
the deferred load, a reference lib.C is translated into a static getter which
also requires a temporary.

Fixes #28678

R=hausner@google.com

Committed: https://github.com/dart-lang/sdk/commit/67a93da99eb11ada7d8267243c6824d5c67de91c

[Florian Schneider, 2017-02-08 04:12:10]

fschneider@google.com changed reviewers:
+ hausner@google.com

[hausner, 2017-02-08 06:28:31]

We can discuss offline tomorrow, but I don't see how the compiler knows whether
an expression with a deferred prefix is a compile-time constant before the
library is loaded.

Also, does this CL mean that an expression like this

await f(10)

will now be translated as

var temp1 = 10;
await f(temp1);
....

[Florian Schneider, 2017-02-08 18:17:47]

On 2017/02/08 06:28:31, hausner wrote:
> We can discuss offline tomorrow, but I don't see how the compiler knows
whether
> an expression with a deferred prefix is a compile-time constant before the
> library is loaded.
> 
> Also, does this CL mean that an expression like this
> 
> await f(10)
> 
> will now be translated as
> 
> var temp1 = 10;
> await f(temp1);
> ....

You're right that this can potentially be expensive. I'll try to narrow it to
constants that have a deferred prefix.

[Florian Schneider, 2017-02-08 20:28:03]

Description was changed from

==========
Handle compile-time constants correctly with deferred loading and await.

When referring to constants via a deferred prefix in an await expression
the transformation must make sure that the generated code before and after
the deferred load agree on the number of captured variables. (i.e. the number
of await-temp variables introduced by the await-transformer is the same)

This CL uses a temporary in the case of compile-time constants, because before
the deferred load, a reference lib.C is translated into a static getter which
also requires a temporary.

Fixes #28678
==========

to

==========
Handle type literals correctly with deferred loading and await.

When referring to constants via a deferred prefix in an await expression
the transformation must make sure that the generated code before and after
the deferred load agree on the number of captured variables. (i.e. the number
of await-temp variables introduced by the await-transformer is the same)

This CL uses a temporary in the case of compile-time constants, because before
the deferred load, a reference lib.C is translated into a static getter which
also requires a temporary.

Fixes #28678
==========

[Florian Schneider, 2017-02-08 20:29:13]

Ptal. The original patch set did not correcty fix the issue. It only affects
type literals now. Other compile-time constants were handled correctly.

[hausner, 2017-02-08 22:41:00]

LGTM.

https://codereview.chromium.org/2683973002/diff/60001/runtime/vm/ast_transfor...
File runtime/vm/ast_transformer.cc (right):

https://codereview.chromium.org/2683973002/diff/60001/runtime/vm/ast_transfor...
runtime/vm/ast_transformer.cc:122: if (node->is_deferred_reference()) {
Maybe a short comment and/or pointer to the issue as an explanation why this is
necessary.

[Florian Schneider, 2017-02-08 23:25:23]

https://codereview.chromium.org/2683973002/diff/60001/runtime/vm/ast_transfor...
File runtime/vm/ast_transformer.cc (right):

https://codereview.chromium.org/2683973002/diff/60001/runtime/vm/ast_transfor...
runtime/vm/ast_transformer.cc:122: if (node->is_deferred_reference()) {
On 2017/02/08 22:41:00, hausner wrote:
> Maybe a short comment and/or pointer to the issue as an explanation why this
is
> necessary.

Done.

[Florian Schneider, 2017-02-08 23:37:47]

Description was changed from

==========
Handle type literals correctly with deferred loading and await.

When referring to constants via a deferred prefix in an await expression
the transformation must make sure that the generated code before and after
the deferred load agree on the number of captured variables. (i.e. the number
of await-temp variables introduced by the await-transformer is the same)

This CL uses a temporary in the case of compile-time constants, because before
the deferred load, a reference lib.C is translated into a static getter which
also requires a temporary.

Fixes #28678
==========

to

==========
Handle type literals correctly with deferred loading and await.

When referring to constants via a deferred prefix in an await expression
the transformation must make sure that the generated code before and after
the deferred load agree on the number of captured variables. (i.e. the number
of await-temp variables introduced by the await-transformer is the same)

This CL uses a temporary in the case of compile-time constants, because before
the deferred load, a reference lib.C is translated into a static getter which
also requires a temporary.

Fixes #28678

R=hausner@google.com

Committed:
https://github.com/dart-lang/sdk/commit/67a93da99eb11ada7d8267243c6824d5c67de91c
==========

[Florian Schneider, 2017-02-08 23:37:49]

Committed patchset #5 (id:70001) manually as
67a93da99eb11ada7d8267243c6824d5c67de91c (presubmit successful).