Type inference failure with dependent types and type classes (Nothing was inferred)

[epifab]

Compiler version

3.0.0

Minimized code

trait Type[T]:
  type Out

type varchar

given Type[varchar] with
  type Out = String

class Placeholder[T, U]

object Placeholder:
  def apply[T](using t: Type[T]): Placeholder[T, t.Out] = new Placeholder

trait Encoder[P, X]:
  def encode(x: X): String

object Encoder:
  def apply[P, X](placeholder: P)(using e: Encoder[P, X]): X => String = e.encode

  given [T, X]: Encoder[Placeholder[T, X], X] with
    def encode(x: X): String = ???

// the following compiles just fine
Encoder(new Placeholder[varchar, String])("hello")
// the following fails
Encoder(Placeholder[varchar])("hello")

Output

Found:    ("hello" : String)
Required: Nothing
  Encoder(Placeholder[varchar])("hello")

Expectation

It should have compiled just fine

[hoshikon]

It also compiles if I assign Placeholder[varchar] to a value and pass it in. (the last line)

val p = Placeholder[varchar]
Encoder(p)("hello")

[bishabosha]

minimised:

type Foo

trait Type[T]:
  type Out

given Type[Foo] with
  type Out = String

class TC[T, U]

object TC:
  def apply[T](using t: Type[T]): TC[T, t.Out] = new TC()

def foo[T](x: T): T = x

val x = foo(TC[Foo]) // : TC[Foo, Nothing] 

if we try to help it a bit by passing in given_Type_Foo explicitly this is what we get:

scala> foo(TC[Foo](using given_Type_Foo))                                               
val res6: 
  TC[Foo, ?
     >: (Type[Foo] & Singleton)#Out & given_Type_Foo.Out <: 
      (Type[Foo] & Singleton)#Out
     | given_Type_Foo.Out
  ] = TC@4e2860d3

[odersky]

This works for me on master