Analyzer: null.foo reports no warning

[xvrh]

The dart analyzer reports no warnings with this code:

main() {
  null.foo;
}

I would expect: "The getter 'foo' is not defined for the class 'Null'."

[zoechi]

I guess you want to enable strong mode https://www.dartlang.org/guides/language/analysis-options

[zoechi]

See also #27276

[lrhn]

I'm guessing this is what triggered #27276
The problem is that the specification special-cases null to the synthetic bottom type at the type level, so the type Null isn't even part of the analysis here. There is no definition of the capabilities of the bottom type because it doesn't really exist - it's a type, not a class, it doesn't have a superclass to inherit things from, and it's specially designed to be allowed to not implement the superclass methods.

We need to fix this somehow, likely by special casing again to say that calling members of bottom is only allowed if they are also members on Object.

[leafpetersen]

cc @lrhn @eernstg @munificent @floitschG

Should Null allow all methods, or should we forbid this?

[lrhn]

The Null class is a class, it has the same methods as Object.
If this is about the null expression, we have changed that, and it's type is now Null, not bottom.

That doesn't completely avoid the problem because (throw 42).method() tries to call method on the bottom type, but it's unlikely to happen much in practice.

[leafpetersen]

Currently both strong and non-strong mode allow this code with no errors:

import 'dart:async';

main() {
  Future<Null> f;
  f.then((x) => x.length);
}

Do we view this as an implementation bug? WAI? Or something we need to sort out?

[lrhn]

Non-strong-mode is unsurprising, the static type of (x) => x.length is dynamic->dynamic, so it can't trigger any warnings.

Strong mode is wrong. Inference should make x have type Null and Null doesn't have a length getter. The behavior is not even matching original Dart 1 + inference, because in Dart 1, Null was not bottom. The null literal had static type bottom, but the Null type itself was just a class. If you write:

import 'dart:async';

main() {
  Future<Null> f;
  f.then((Null x) => x.length);
}

you should get a warning in non-strong mode (and probably an error in strong mode).

A quick check in dartpad shows that there is no warning, not even in non-strong mode, so yes, I think we do have an analyzer bug here.

[leafpetersen]

The new front end implements the correct behavior for this. Re-assigning this as an analyzer bug.

[leafpetersen]

This seems to be fixed.

[leafpetersen]

Correction, the original issue still reproduces on recent bleeding edge. Calling a method on something of type Null seems to have been fixed, but in at least some cases, calling a method on the null literal succeeds.

[srawlins]

This was fixed at some point recently; Dart analyzer 2.5.0 reports:

The getter 'foo' isn't defined for the class 'Null'.