"implicit any" where circularity is trivially resolvable

Bug Report

🔎 Search Terms

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about Common “Bugs” That Aren’t Bugs and When and why are classes nominal?

⏯ Playground Link

Playground link with relevant code

💻 Code

class Foo {
  constructor(_provider: FooProvider) {}
}

interface FooProvider {
  getFoo(): Foo
}

class FooFactory {
  // 'getFoo' implicitly has return type 'any' because it does not have a
  // return type annotation and is referenced directly or indirectly in one of
  // its return expressions. (7023)
  getFoo() {
    // 'result' implicitly has type 'any' because it does not have a type
    // annotation and is referenced directly or indirectly in its own
    // initializer. (7022)
    const result = new Foo(this)
    return result
  }
}

🙁 Actual behavior

The type of the variable result, and thus the return type of FooFactory.getFoo, defaults to any. This is wrong, because result clearly has the type Foo regardless of the type of the argument to the Foo constructor.

Adding implements FooProvider to FooFactory does not help, which I also find a bit strange.

🙂 Expected behavior

The circularity should be resolved at the new Foo(this) expression, since calling this non-generic constructor can only result in one possible type, regardless of arguments.

[RyanCavanaugh]

If someone can make this work without making a bunch of other stuff (perf, maintainability, etc) worse they’re free to send a PR, but we don’t think that’s possible.

[MartinJohns]

That would require the compiler to perform type checks in two iterations (first inference, then the rest), which it currently not does. The issue exists for a long time already, and Ryan mentions the issue in this comment.

The best approach is really to just add a type annotation.