Typechecking regression in v3.1.2

[tnielens]

Compiler version

Works with v3.1.1, fails with v3.1.2 and v3.1.3-RC3.

First bad commit 3ab18a9

Minimized code

//> using scala "3.1.1"
//> using lib "org.scalacheck::scalacheck:1.16.0"
import scala.reflect.ClassTag
import org.scalacheck.Arbitrary
import org.scalacheck.Gen

trait E[F[_]] {
  type T
  val value: F[T]
  override def toString(): String = s"E($value)"
}

object E {
  def apply[F[_], T1](value1: F[T1]) = new E[F] {
    type T = T1
    val value = value1
  }
}

trait TaggedGen[T] {
  val tag: ClassTag[T]
  val gen: Gen[T]
  override def toString(): String = s"TaggedGen($tag, $gen)"
}
type ETaggedGen = E[TaggedGen]

object TaggedGen {
  def apply[T: ClassTag: Arbitrary] = new TaggedGen[T] {
    val tag = implicitly
    val gen = implicitly[Arbitrary[T]].arbitrary
  }

  def apply[T](tag1: ClassTag[T], gen1: Gen[T]) = new TaggedGen[T] {
    val tag = tag1
    val gen = gen1
  }

  val gen: Gen[ETaggedGen] =
    Gen.oneOf(
      E(apply[Boolean]),
      E(apply[Byte]),
      E(apply[String])
    )

  val gen2: Gen[ETaggedGen] =
    gen.map { etg =>
      implicit val tag = etg.value.tag
      E(TaggedGen(tag, etg.value.gen.filter(_ => true))) // <-- failure here
    }
}

Output

[error] ./test.sc:54:19: Found:    (tag : reflect.ClassTag[etg.T])
[error] Required: reflect.ClassTag[Any]
[error]       E(TaggedGen(tag, etg.value.gen.filter(_ => true)))
[error]                   ^^^
Error compiling project (Scala 3.1.2, JVM)

Expectation

This snippet should continue compiling with scala v3.1.2.

[bishabosha]

still fails with 3.2.0-RC1-bin-20220511-7c446ce-NIGHTLY

[odersky]

Can we find out where this regressed first? For the moment I am not even sure this is an error. I

[bishabosha]

can you reproduce this without scalacheck?

[tnielens]

I'll try to minimize the example and remove scalacheck.
As a short note, adding explicit type args to the failing expression makes it compile:
E[TaggedGen, etg.T](TaggedGen(tag, etg.value.gen.filter(_ => true))) // <-- failure here. With explicit type, compiles fine.

[tnielens]

Here is a short repro:

trait E[F[_]] {
  type T
  val value: F[T]
}

object E {
  def apply[F[_], T1](value1: F[T1]) = new E[F] {
    type T = T1
    val value = value1
  }
}

val a: Option[E[Ordering]] = Option(E(Ordering[Int]))
a.map(it => E(it.value))

[griggt]

Regressed in 3ab18a9.

[smarter]

Workaround: give an explicit result type to E.apply:

object E {
  def apply[F[_], T1](value1: F[T1]): E[F] = new E[F] {
    type T = T1
    val value = value1
  }
}

Otherwise the inferred type is E[F] { type T = T1 } which complicates inference since the type E[F] { type T = it.T } is not valid outside the lambda where it is defined.

[odersky]

So, can we close this?