ignore `dynamic` when doing inference

ignore `dynamic` when doing inference

R=leafp@google.com

Committed: https://github.com/dart-lang/sdk/commit/8c25a41accf52265a89bcc2ffac3bdb7c271f9fb

[Jennifer Messerly, 2016-09-15 22:40:58]

jmesserly@google.com changed reviewers:
+ leafp@google.com

[Jennifer Messerly, 2016-09-15 22:40:59]

This fixes some issues that folks were seeing in when upgrading existing code to
the version that treats inference failures as errors.

[Leaf, 2016-09-16 00:12:25]

https://codereview.chromium.org/2343863004/diff/1/pkg/analyzer/test/src/task/...
File pkg/analyzer/test/src/task/strong/inferred_type_test.dart (right):

https://codereview.chromium.org/2343863004/diff/1/pkg/analyzer/test/src/task/...
pkg/analyzer/test/src/task/strong/inferred_type_test.dart:1871: var z =
o.fold(0, /*info:INFERRED_TYPE_CLOSURE,error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/(x,
y) => /*info:DYNAMIC_INVOKE*/x + y);
I don't understand this new error here.  Why does it show up?

[Jennifer Messerly, 2016-09-16 20:14:40]

https://codereview.chromium.org/2343863004/diff/1/pkg/analyzer/test/src/task/...
File pkg/analyzer/test/src/task/strong/inferred_type_test.dart (right):

https://codereview.chromium.org/2343863004/diff/1/pkg/analyzer/test/src/task/...
pkg/analyzer/test/src/task/strong/inferred_type_test.dart:1871: var z =
o.fold(0, /*info:INFERRED_TYPE_CLOSURE,error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/(x,
y) => /*info:DYNAMIC_INVOKE*/x + y);
On 2016/09/16 00:12:25, Leaf wrote:
> I don't understand this new error here.  Why does it show up?

So we can't infer "fold" properly due to lack of up+down. What happens:

1. we use return context first by itself to see if that infers any type args
2. we push the updated types down to the arguments. Often this pushes down a lot
of "dynamic" (which I'll write as *). In this example we had no return type, so
* is pushed down for fold<T>'s T.
3. as a result the closure infers as `(*, int) -> *`
4. however the first arg to fold is "0" which has type int, so we know int <: T
5. prior to this CL, we'd LUB(int, *) and get a lower bound of *
6. after this CL, we ignore * and conclude `int` is our lower bound, and by
heuristic instantiate with <int>
7. `(*, int) -> *` is not assignable to the `(int, int) -> int` parameter type.

[Leaf, 2016-09-20 16:44:48]

lgtm

https://codereview.chromium.org/2343863004/diff/1/pkg/analyzer/test/src/task/...
File pkg/analyzer/test/src/task/strong/inferred_type_test.dart (right):

https://codereview.chromium.org/2343863004/diff/1/pkg/analyzer/test/src/task/...
pkg/analyzer/test/src/task/strong/inferred_type_test.dart:1871: var z =
o.fold(0, /*info:INFERRED_TYPE_CLOSURE,error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/(x,
y) => /*info:DYNAMIC_INVOKE*/x + y);
On 2016/09/16 20:14:40, John Messerly wrote:
> On 2016/09/16 00:12:25, Leaf wrote:
> > I don't understand this new error here.  Why does it show up?
> 
> So we can't infer "fold" properly due to lack of up+down. What happens:
> 
> 1. we use return context first by itself to see if that infers any type args
> 2. we push the updated types down to the arguments. Often this pushes down a
lot
> of "dynamic" (which I'll write as *). In this example we had no return type,
so
> * is pushed down for fold<T>'s T.
> 3. as a result the closure infers as `(*, int) -> *`
> 4. however the first arg to fold is "0" which has type int, so we know int <:
T
> 5. prior to this CL, we'd LUB(int, *) and get a lower bound of *
> 6. after this CL, we ignore * and conclude `int` is our lower bound, and by
> heuristic instantiate with <int>
> 7. `(*, int) -> *` is not assignable to the `(int, int) -> int` parameter
type.
> 

ok.  Overall, I think this is probably a better outcome, at least from the DDC
standpoint.

[Jennifer Messerly, 2016-09-20 16:49:44]

On 2016/09/20 16:44:48, Leaf wrote:
> lgtm
> 
>
https://codereview.chromium.org/2343863004/diff/1/pkg/analyzer/test/src/task/...
> File pkg/analyzer/test/src/task/strong/inferred_type_test.dart (right):
> 
>
https://codereview.chromium.org/2343863004/diff/1/pkg/analyzer/test/src/task/...
> pkg/analyzer/test/src/task/strong/inferred_type_test.dart:1871: var z =
> o.fold(0, /*info:INFERRED_TYPE_CLOSURE,error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/(x,
> y) => /*info:DYNAMIC_INVOKE*/x + y);
> On 2016/09/16 20:14:40, John Messerly wrote:
> > On 2016/09/16 00:12:25, Leaf wrote:
> > > I don't understand this new error here.  Why does it show up?
> > 
> > So we can't infer "fold" properly due to lack of up+down. What happens:
> > 
> > 1. we use return context first by itself to see if that infers any type args
> > 2. we push the updated types down to the arguments. Often this pushes down a
> lot
> > of "dynamic" (which I'll write as *). In this example we had no return type,
> so
> > * is pushed down for fold<T>'s T.
> > 3. as a result the closure infers as `(*, int) -> *`
> > 4. however the first arg to fold is "0" which has type int, so we know int
<:
> T
> > 5. prior to this CL, we'd LUB(int, *) and get a lower bound of *
> > 6. after this CL, we ignore * and conclude `int` is our lower bound, and by
> > heuristic instantiate with <int>
> > 7. `(*, int) -> *` is not assignable to the `(int, int) -> int` parameter
> type.
> > 
> 
> ok.  Overall, I think this is probably a better outcome, at least from the DDC
> standpoint.

ah yeah, good point! I was thinking of it as an unfortunate downside but you're
right, it's actually better for DDC. Nice :)

[Jennifer Messerly, 2016-09-20 16:56:50]

I also added a short CHANGELOG note. Slowly getting better at remembering those
:)

[Jennifer Messerly, 2016-09-20 16:59:16]

Description was changed from

==========
ignore `dynamic` when doing inference
==========

to

==========
ignore `dynamic` when doing inference

R=leafp@google.com

Committed:
https://github.com/dart-lang/sdk/commit/8c25a41accf52265a89bcc2ffac3bdb7c271f9fb
==========

[Jennifer Messerly, 2016-09-20 16:59:17]

Committed patchset #2 (id:20001) manually as
8c25a41accf52265a89bcc2ffac3bdb7c271f9fb (presubmit successful).