Analyzer strong mode inconsistent implicit cast warnings

[bergwerf]

The analyzer in strong mode gives me inconsistent implicit cast warnings.
For example, for this snippet I get a warning:

List<String> c;
if (b is List<String>) {
  c = b; // Unsound implicit cast from dynamic to List<String>
}

While this does not give me a warning:

String c;
if (b is String) {
  c = b;
}

(Dart 1.15.0)

[jmesserly]

Hi, this is intended behavior. Casts to types like List<String> are more likely to fail at runtime in Strong Mode, while these casts were accepted in original Dart. For example:

var x = <dynamic>[1, 'hello'];
List<String> y = x; // WARNING

Here the cast will always fail on the second line, so we provide that information statically.

CC @leafpetersen

[leafpetersen]

What's the declared type of b? I can't reproduce this on any of the version of 1.15 or 1.16 that I have (using dynamic b as the static declaration of b).

Without the is check, this is working as intended, per John's comment above.

[jmesserly]

See also #24565 for further discussion. We're open to changing this behavior in the long term, it was intended to make it easier to find potential runtime cast failures as we upgrade code to Strong Mode.

(I think we can dupe it against that bug unless it turns out there's a type-promotion issue.)

[bergwerf]

The idea is that you don't know what b is. I have a class with a constructor that uses a Map<String, dynamic> as input type. All class fields are read from this data (could be JSON data) but to make it more safe I added a check like this:

factory fromData(Map<String, dynamic> data) {
  List<int> field;

  if(data.containsKey('field') && data['field'] is List<int>) {
    field = data['field'] as List<int>;
  } else {
    throw new ArgumentError.value(data, 'data', "no valid data field for 'field'");
  }

  return new MyClass(field);
}

(I use a factory because the fields in MyClass are final).

[bergwerf]

Anyway, as pointed out in #24565, this is intended behavior since generics type parameters are not considered by the analyzer (for this warning at least). I think that especially for List it would be useful if the strong mode only allows explicit types and also uses these for checking (you could even get around this by defining an IntList extends List<int> or something). For Maps this is a little more difficult since you often have to deal with key/value lists with many types (union types could offer a solution here).

[jmesserly]

ah, thanks for the clarification. this is a dupe so I'll consolidate the discussion into that bug