Claudio/recursionbug

[crusso]

class Foo(f1:Int -> Int, f2:Int -> Int) { };
class Bar () {
  private g(n:Int) : Int = n + 1;
  let Bar = Foo(g, g)  ;
};

used to crash with unbound id Foo.
It can fail more elegantly if we presume term Foo has type T.Pre and report that the type of let Bar can't be inferred..
We can only make it type-check successfully if we assume a skeletal constructor type ()->Foo while inferring the type of sibling classes like Bar.

But the solution feels like a hack...(we assume that for class C<T1<:U1,...TN<:Un>(pat1...,patn) {...}, C has type <T1:T.Pre,...T:T.Pre>(Any,...,Any) -> C(Ts),
for C abstract and Ti bounded at T.Pre. That's good enough to check application of C.

But I think this will go wrong if we just rebind C because then we'd be inferring the wrong type! Bugger.

[crusso]

As I suspected, approximating the type of the constructor is unsound, but declaring it correctly requires yet another pass in the already complicated type checker.

For now, I've gone for the simpler solution of assuming a constructor has type T.Pre, so that recursive references may require a type annotation to satisfy the type inferencer. Niote that the problem is guessing the domain of the class term constructor, not its codomain (which is obvious).

[crusso]

With the current fix:

The following fails to type check, reporting that the type of Foo is unknown (the compiler used to complain Foo was undeclared)

class Foo(f1:Int -> Int, f2:Int -> Int) { };
class Bar () {
  private g(n:Int) : Int = n + 1;
  let Bar = Foo(g, g)  ;
};

and this:

class Foo(f1:Int -> Int, f2:Int -> Int) { };
class Bar () {
  private g(n:Int) : Int = n + 1;
  let Bar = Foo(g, g) : Foo ;
};

is accepted, thanks to the extra annotation.

[nomeata]

So this is no longer WIP?

[crusso]

No longer WIP, but only an interim fix. We might want to do better later, but I think the work I did with modules might help there.

[rossberg]

Hm, this seems to be another fallout of removing nominal class types, which used to break this recursion. I'm a bit worried that there are more lingering.