Suppress type constructors in java generic signatures

[scabug]

// compiles
interface J1 extends scala.collection.Traversable { }

interface J2<A> extends scala.collection.Traversable<A> { }
// J.java:4: types scala.collection.Traversable<A> and scala.collection.Traversable<A> are incompatible; both define newBuilder(), but with unrelated return types
// interface J2<A> extends scala.collection.Traversable<A> { }
// ^
interface J3 extends scala.collection.Traversable<Object> { }
//
// J.java:6: types scala.collection.Traversable<java.lang.Object> and scala.collection.Traversable<java.lang.Object> are incompatible; both define newBuilder(), but with unrelated return types
// interface J3 extends scala.collection.Traversable<Object> { }
// ^

The signatures of the inherited newBuilder() interface methods differ only in a type parameter.

const SI-14 = Asciz	()Lscala/collection/mutable/Builder;;
const SI-15 = Asciz	()Lscala/collection/mutable/Builder<TA;TRepr;>;;
const SI-16 = Asciz	()Lscala/collection/mutable/Builder;;
const SI-17 = Asciz	()Lscala/collection/mutable/Builder<TA;TCC;>;;

If one tries to do the same thing in java, it is disallowed:

import java.util.*;

interface J1<A, CC> { public Map<A, CC> foo(); }
interface J2<A, CC> { public Map<A, CC> foo(); }

abstract class J3 implements J1<String, List>, J2<String, Map> { }
// J1.java:6: types J2<java.lang.String,java.util.Map> and J1<java.lang.String,java.util.List> are incompatible; both define foo(), but with unrelated return types
// abstract class J3 implements J1<String, List>, J2<String, Map> { }
//          ^
// 1 error  

I thought perhaps overriding in Traversable would solve it by generating a signature there. It does generate a signature, but the failure remains.

trait Traversable[+A] extends TraversableLike[A, Traversable[A]] 
                         with GenericTraversableTemplate[A, Traversable] {
  def companion: GenericCompanion[Traversable] = Traversable
  override protected[this] def newBuilder: Builder[A, Traversable[A]] = companion.newBuilder[A]
  [...]  
}
// javap
//
// const SI-7 = Asciz newBuilder;
// const SI-8 = Asciz ()Lscala/collection/mutable/Builder;;
// const SI-9 = Asciz ()Lscala/collection/mutable/Builder<TA;Lscala/collection/Traversable<TA;>;>;;

% javac -cp /scala/trunk/build/quick/classes/library J.java 
// J.java:4: types scala.collection.Traversable<A> and scala.collection.Traversable<A> are incompatible; both define newBuilder(), but with unrelated return types
// interface J2<A> extends scala.collection.Traversable<A> { }
// ^
// J.java:8: types scala.collection.Traversable<java.lang.Object> and scala.collection.Traversable<java.lang.Object> are incompatible; both define newBuilder(), but with unrelated return types
// interface J3 extends scala.collection.Traversable<Object> { }
// ^
// 2 errors

Any thoughts? I don't know how big a deal this is, but it seems like a bad thing.

[scabug]

Imported From: https://issues.scala-lang.org/browse/SI-4337?orig=1
Reporter: @paulp

[scabug]

@paulp said:
This looks worse the longer I look at it. I have to find out exactly in what ways people are successfully using scala from java to have some change of making sense of this. Neither of these classes can be instantiated from java as-is.

abstract class BippyAbstract[+A] extends collection.Traversable[A] {
  def foreach[U](f: A => U): Unit = ()
}

class BippyConcrete[+A] extends collection.Traversable[A] {
  def foreach[U](f: A => U): Unit = ()
}  

The interestingly different errors are:

% javac -cp /scala/inst/29/lib/scala-library.jar:. J.java 
J.java:5: <anonymous J$$1> is not abstract and does not override abstract method <A1,A2,A3>unzip3(scala.Function1<java.lang.String,scala.Tuple3<A1,A2,A3>>) in scala.collection.generic.GenericTraversableTemplate
  BippyAbstract<String> b1 = new BippyAbstract<String>() {
                                                         ^
J.java:11: scala.collection.generic.HasNewBuilder cannot be inherited with different arguments: <java.lang.String,scala.collection.Traversable<java.lang.String>> and <java.lang.String,scala.collection.Traversable>
  BippyConcrete<String> b2 = new BippyConcrete<String>() {
                                                         ^
2 errors  

These issues go back as far as I look, for instance here is 2.7:

  J.java:5: <anonymous J$$1> is not abstract and does not override abstract method <B>toArray() in scala.collection.Set
    BippyAbstract<String> b1 = new BippyAbstract<String>() {
                                                           ^
  J.java:11: toArray() in BippyConcrete cannot implement <B>toArray() in scala.collection.Set; attempting to use incompatible return type
  found   : scala.runtime.BoxedArray
  required: B[]
    BippyConcrete<String> b2 = new BippyConcrete<String>() {
                                                           ^ 

So what exactly is it that people do from java? Do they only call methods? What do we think ought to work, and what is beyond hope?

[scabug]

@paulp said:
More good times, seeing what happens if I start pulling on the thread regarding the supposed abstract methods javac doesn't believe I have implemented.

// try with Traversable types applied - we get "found A, required B"
BippyAbstract<String> b1 = new BippyAbstract<String>() {
  public <A1,A2,A3> scala.Tuple3<Traversable<A1>,Traversable<A2>,Traversable<A3>> 
    unzip3(scala.Function1<java.lang.String,scala.Tuple3<A1,A2,A3>> f) {
      return null;
    }
}
// J.java:11: <A1,A2,A3>unzip3(scala.Function1<java.lang.String,scala.Tuple3<A1,A2,A3>>) in  cannot override <A1,A2,A3>unzip3(scala.Function1<A,scala.Tuple3<A1,A2,A3>>) in BippyAbstract; attempting to use incompatible return type
// found   : scala.Tuple3<scala.collection.Traversable,scala.collection.Traversable,scala.collection.Traversable>
// required: scala.Tuple3<scala.collection.Traversable<A1>,scala.collection.Traversable<A2>,scala.collection.Traversable<A3>>
//       unzip3(scala.Function1<java.lang.String,scala.Tuple3<A1,A2,A3>> f) {
//       ^

// try as type constructors - and it's "found B, required A"
BippyAbstract<String> b1 = new BippyAbstract<String>() {
  public <A1,A2,A3> scala.Tuple3<Traversable, Traversable, Traversable>
    unzip3(scala.Function1<java.lang.String,scala.Tuple3<A1,A2,A3>> f) {
      return null;
    }
}         
// J.java:22: <A1,A2,A3>unzip3(scala.Function1<java.lang.String,scala.Tuple3<A1,A2,A3>>) in  cannot implement <A1,A2,A3>unzip3(scala.Function1<A,scala.Tuple3<A1,A2,A3>>) in scala.collection.generic.GenericTraversableTemplate; attempting to use incompatible return type
// found   : scala.Tuple3<scala.collection.Traversable<A1>,scala.collection.Traversable<A2>,scala.collection.Traversable<A3>>
// required: scala.Tuple3<scala.collection.Traversable,scala.collection.Traversable,scala.collection.Traversable>
//       unzip3(scala.Function1<java.lang.String,scala.Tuple3<A1,A2,A3>> f) {
//       ^

It's like a bad video game where you're not supposed to go that way yet.

[scabug]

@paulp said:
OK, I think I have a key piece of this identified.

// this declaration
trait GenericTraversableTemplate[+A, +CC[X] <: Traversable[X]] extends HasNewBuilder[A, CC[A] @uncheckedVariance]
// has the wrong class signature
<A:Ljava/lang/Object;CC::Lscala/collection/Traversable<Ljava/lang/Object;>;>Ljava/lang/Object;Lscala/collection/generic/HasNewBuilder<TA;TCC;>;Lscala/ScalaObject

HasNewBuilder<TA;TCC;> should be HasNewBuilder<TA;TCC<A>;>

[scabug]

@paulp said:
Replying to [comment:6 extempore]:

OK, I think I have a key piece of this identified.

Those following along at home should note that "should be" there is only conceptually true: that's not actually a legal signature, which is part of the problem.

[scabug]

@odersky said:
I think we need to suppress signatures altogether for files with higher-kinded types.
They are conflated with raw types, and scalac will get confused.

[scabug]

@odersky said:
I'd like to re-classify this as non-blocking for 2.9. Lowering priority to normal.

[scabug]

@adriaanm said:
Un-assigning to foster work stealing, as announced in https://groups.google.com/forum/?fromgroups=#!topic/scala-internals/o8WG4plpNkw

[scabug]

@adriaanm said:
Unassigning and rescheduling to M6 as previous deadline was missed.