No Java generic signatures generated for static forwarders in companions of objects for vals and paramless defs

[DieBauer]

Minimized code

package modes

import java.util.{List => JList}
import scala.jdk.CollectionConverters._

object Mode {
  val AllowedModes: List[Mode] = List(
    On,
    Off,
  )
}

sealed trait Mode {
  def name: String
}

case object On extends Mode {
  override val name: String = "on"
}

case object Off extends Mode {
  override val name: String = "off"
}

/** object for Java compatibility */
object Modes {
  val AllowedModes: JList[Mode] = Mode.AllowedModes.asJava
}

package mode;

import modes.Modes;
import modes.Mode;
import java.util.stream.Collectors;

class Converter {
    private final String modes = Modes.AllowedModes()
        .stream()
        .map(Mode::name)
        .collect(Collectors.joining(", "));
}

Output

> compile
[info] compiling 1 Scala source and 1 Java source to /Users/jens/Developer/dotty/java-interop/library/target/scala-3.0.0-M2/classes ...
[error] /Users/jens/Developer/dotty/java-interop/library/src/main/java/mode/Modes.java:10:1: incompatible types: invalid method reference
[error]     method name in interface modes.Mode cannot be applied to given types
[error]       required: no arguments
[error]       found: java.lang.Object
[error]       reason: actual and formal argument lists differ in length
[info] Some messages have been simplified; recompile with -Xdiags:verbose to get full output
[error] (lib / Compile / compileIncremental) javac returned non-zero exit code

Expectation

Fails with latest 3.0.0-M2-bin-20201115-3c04f9b-NIGHTLY and 3.0.0-M1. While this succeeds with scala 2.13.3.

java -version
openjdk version "11.0.8" 2020-07-14
OpenJDK Runtime Environment GraalVM CE 20.2.0 (build 11.0.8+10-jvmci-20.2-b03)
OpenJDK 64-Bit Server VM GraalVM CE 20.2.0

[smarter]

It's because we don't generate Java generic signatures on the static forwarders we create in a class for each method in the corresponding companion object, minimized:

object A {
  def foo: List[String] = Nil
}

Compiled with Scala 2:

# javap -p -v 'A$.class'
...
public scala.collection.immutable.List<java.lang.String> foo();

# javap -p -v 'A.class'
...
public static scala.collection.immutable.List<java.lang.String> foo();

Compiled with Dotty:

# javap -p -v 'A$.class'
...
public scala.collection.immutable.List<java.lang.String> foo();

# javap -p -v 'A.class'
...
public static scala.collection.immutable.List foo(); // <-- no type parameter info

[smarter]

Workaround: add parens to the method, then the correct signature gets generated:

object A {
  def foo(): List[String] = Nil
}

[griggt]

Is this related to #8631?

[smarter]

Yep same issue

[lrytz]

@smarter the issue here is that is that the nullary method has an ExprType(List[String]), which seems to be used for both nullary methods and by-name params, and erasure turns it into a Function0 favoring the latter interpretation.

Then this test fails (Function0 vs (): List): https://github.com/lampepfl/dotty/blob/0f0d6ad4b663fe9d7a8d73afaa2e0f72bdcff647/compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala#L928-L930

Do you have a suggestion how to fix this?

[smarter]

seems like we should use TypeErasure.transformInfo (or directly TypeErasure#eraseInfo) instead of fullErasure.

[lrytz]

👍 thanks!