[analyzer] Analyzer reports misleading type when type-promotion

[AlexV525]

This tracker is for issues related to Analyzer.

Summary

Consider the code:

Object? _testVariable;

void main() {
  final Object? testVariable = _testVariable;
  if (testVariable is A?) {
    Usage<A>(testVariable);
  } else if (testVariable is B?) {
    Usage<B>(testVariable); // <-- Reports error here.
  }
}

class A {}

class B {}

class Usage<T> {
  const Usage(this.field);
  
  final T? field;
}

The analyzer gives the error: The argument type 'Object' can't be assigned to the parameter type 'B?'. (argument_type_not_assignable)

is A? judges A and Null, but the after flow only promotes non-nullable without the type context. As I can imagine it should be types that is! A?.

Changing is B? to is B solves the issue, though it seems to be lost nullability here, the is A? has already judged the nullability.

Version Information

Dart SDK: 2.17.3

[bwilkerson]

@stereotype441 How difficult would it be to add a context message here explaining why promotion didn't work as expected?

[AlexV525]

Hi guys, do we have any thoughts or progress here?

[eernstg]

Just a random drive-by comment: At else, flow analysis knows that testVariable is Object? and also that testVariable is! A? (note: that's "is not"). In particular, testVariable is not null. So the type of testVariable at that point becomes Object. And we can't promote from Object to B? because B? isn't a subtype of Object.

Any explanation that shows the promoted type at else would probably be quite helpful.

Pragmatically, @AlexV525, you might want to use a different construct where the flow analysis doesn't promote as aggressively from one case to the next:

Object? _testVariable;

void main() {
  final Object? testVariable = _testVariable;
  switch (testVariable) {
    case A? _:
      Usage<A>(testVariable);
    case B? _: // At this point `testVariable` has type `Object?` and is promoted to `B?`.
      Usage<B>(testVariable);
    /* default: no-op */
  }
}

class A {}

class B {}

class Usage<T> {
  const Usage(this.field);
  final T? field;
}

The reason why a switch statement or expression doesn't promote (much) based on the knowledge that a certain sequence of pattern matching steps failed is discussed here and here.

@stereotype441, you might have some further comments, is this working as expected?

[AlexV525]

@eernstg That makes more sense if is! A? equals to is! A and is! Null as you said. Here I'd just thinking that it's is! A or is! Null because A? means A || Null.

[eernstg]

That makes more sense if is! A? equals to is! A and is! Null as you said. Here I'd just thinking that it's is! A or is! Null because A? means A || Null.

It's 'and' rather than 'or' because of pure logic (De Morgan's laws). So you could say that we have e is! A? which means ! (e is A?), that is ! (e is A || e is Null), that is e is! A && e is! Null.