Would like a way to see the analyzer's inferred type.

[eseidel]

I'm constantly fighting errors like:

message: 'Unsound implicit cast from dynamic to List<Foo>'
at: '28,22'
source: 'dart'

From things like:

 List<Foo> foos = yaml['foos'].map((YamlMap yamlFoo) {
      return fooFactory.fooByName(yamlFoo['name']);
    }).toList();

It would help if there was a key combination I could use to see what the inferred type was in each step of my call chain.

dynamic poisons your chained calls, as soon as you hit one, the rest of them end up dynamic, so figuring out which step in the chain ended up dynamic is what I'm trying to do. Maybe this is an analyzer issue?

[zoechi]

"Quick Documentation" in WebStorm/IDEA seems to provide that information

[eseidel]

So that works for variables, but not for methods/accessors. Example:

Map<String, String> foo;
var bar = foo.values;

If you highlight bar and hit f1 you see a static type of Iterator<String>, however if you highlight values you don't. When you have a long chain of calls, it could be useful to see the inferred types along the way. At least I think that would have helped me in fighting these strong_mode errors.

[raju-bitter]

+1 Would be very useful, especially when reading through code you haven't written yourself.

[devoncarew]

/cc @jwren and @leafpetersen, who've discussed something similar.

[leafpetersen]

This is something I'd really like us to support better in the IDE - I'm hoping we can spend some time on it next quarter.

@eseidel I'm surprised that you don't see a type for values in that example though. If I use Quick Documentation with the cursor on values for that example I see:

Signature: get Map.values() → Iterable<String>

which is using the inferred type. This doesn't work for general expressions, but it should be working for any method calls. This is especially useful for generic methods. With this example:

Map<String, String> foo;
var bar = foo.values.map((x) => x.length);

Quick Documentation on map will give me:

Signature: Iterable.map((String) → T f) → Iterable<T> 

Static type: ((String) → int) → Iterable<int>

which tells me that int is the inferred type argument that is being filled in for the generic parameter T to Iterable.map.

[pq]

@leafpetersen : what's the current thinking on support like this?

[leafpetersen]

I talked to @stevemessick about this a bit earlier this year. We're both keen to do something with this, but my guess is that there are a lot of higher priority things in the queue right now.

[pq]

Good deal. My thinking too. Thanks!