ClassTag inference fails with method call chain

[lrytz]

//> using scala 3.7.1

trait B[-A, +To] {
  def addOne(e: A): this.type = this
  def res(): To
}

class Col[A]

object Factory {
  def newB[A: reflect.ClassTag] = new B[A, Col[A]] { def res(): Col[A] = new Col[A] }
}


def t = Factory.newB.addOne(1).res()

gives

[error] ./A.scala:15:21
[error] No ClassTag available for A
[error]
[error] where:    A is a type variable
[error] def t = Factory.newB.addOne(1).res()
[error]                     ^

It works for a non-ClassTag evidence, e.g., when changing A: reflect.ClassTag to A: Numeric.

Example using collections: collection.immutable.ArraySeq.newBuilder.addOne(1).result().

[odersky]

This is an interesting bug.

If we replace ClassTag with Numeric the following happens:

• the original implicit search is ambiguous since the type variable A is not constrained but there are some instances of Numeric in the implicit type scope of Numeric[A].
• we get into a fallback where we constrain the result of the newB from what is known in the suffix.
• that adds the constraint A >: Int
• we try implicit search again and succeed.

But for ClassTag the following happens

• we get an implicit not found instead of an ambiguity, since all ClassTag[T] instances
  are in the companions of their types and A matches none of these.
• as fallback we try to synthesize the ClassTag, but since the type variable is unconstrained we fail again.
• the previous fallback where we constrain the result further is not available on this path.

I changed the test by adding two dummy instances of ClassTag in front of the failing line:

  given reflect.ClassTag[String] = ???
  given reflect.ClassTag[Exception] = ???

  def t = Factory.newB.addOne(1).res()

Then we do get an ambiguity and the whole thing works.

Why don't we always try the fallback of constraining the result further? That's because there might be an implicit conversion between the call to Factory.newB and .addOne(1). So constraining the result might lose solutions. That's why we are very careful to do this only as a last fallback. In this case constraining the result is a last fallback only if the search is ambiguous since otherwise we could also try a default value.

This is a great demonstration of the sanity and expressive power we can win by restricting implicit conversions, see SIP 71.

[odersky]

#23532 fixes the ClassTag problem. But note that for SIP 70 this is not enough. We need to be able to construct sequence literals even if there is no ClassTag available.

[lrytz]

for SIP 70 this is not enough. We need to be able to construct sequence literals even if there is no ClassTag available.

Right. For ArraySeq there's the "untagged" factory that could be used as a fallback.

scala> def sq[T](x: T) = collection.immutable.ArraySeq.untagged.newBuilder.addOne(x).result()
def sq[T](x: T): scala.collection.immutable.ArraySeq[T]