Dotty gets confused by raw types in bytecode signatures

[allanrenucci]

Consider the following file Test.scala:

import org.testng.IAnnotationTransformer
import org.testng.annotations.ITestAnnotation
import java.lang.reflect.Method
import java.lang.reflect.Constructor

class SingleTestAnnotationTransformer(testName: String) extends IAnnotationTransformer {
  override def transform( annotation: ITestAnnotation, testClass: java.lang.Class[_], testConstructor: Constructor[_], testMethod: Method): Unit = {}
}

Running

./bin/dotc -classpath "$(coursier fetch -p org.testng:testng:6.8.7)" Test.scala 

produces the following error:

-- [E036] Reference Error: Test.scala:9:15 -------------------------
9 |  override def transform( annotation: ITestAnnotation, testClass: java.lang.Class[_], testConstructor: Constructor[_], testMethod: Method): Unit = {
  |               ^
  |               method transform overrides nothing

[smarter]

We can see what signature Dotty expects by removing the override def:

6 |class SingleTestAnnotationTransformer(testName: String) extends IAnnotationTransformer {
  |      ^
  |class SingleTestAnnotationTransformer needs to be abstract, since def transform: 
  |  (x$0: org.testng.annotations.ITestAnnotation, x$1: Class, x$2: 
  |    java.lang.reflect.Constructor
  |  , x$3: java.lang.reflect.Method): Unit is not defined 

Notice the missing type parameters for Class and Constructor, my guess is that Dotty gets confused by the raw types used in https://github.com/cbeust/testng/blob/master/src/main/java/org/testng/IAnnotationTransformer.java.

[allanrenucci]

Can be reproduced by compiling Foo.java with javac:

interface Foo {
  void foo(java.util.List list);
}

and then Test.scala with the previous result on the classpath:

class Test extends Foo {
  override def foo(list: java.util.List[_]): Unit = ???
}

[smarter]

I'm on it but it won't be trivial: we need to check for raw types in ClassfileParser which is hard to do without forcing too much things and getting into cycles.

[adriaanm]

Would be nice to have a lazier LazyType PolyType, where you can query just the type params without forcing the rest of the type.

[smarter]

@adriaanm Behold! https://github.com/lampepfl/dotty/blob/c50c16420b037268fe8e62bdd659e60ee2ceabfc/compiler/src/dotty/tools/dotc/core/SymDenotations.scala#L1897-L1903

My plan is in fact to see if I can use this for classfile loading too ;)

[odersky]

Sigh. It's 14 years after Java generics came out and we still have to deal with raw types. 😢

This was one of the most messy aspects of nsc, basically impossibly to get right without forcing too much.

[odersky]

It took me a while to realize: it's because of the change to native applied types. Before, it was convenient that the raw type Class was both a higher-kinded type and an existential. Now, we don't have it so easy anymore. But I have an idea what to do by adapting (and hopefully improving) the concept of cooking in nsc.

[odersky]

It turned out to be a lot easier than for nsc because member types are completers anyway. This avoids the problem of forcing too much by accident.