Type alias with type param becomes type alias applied to Nothing

[Katrix]

minimized code

type Foo[A <: Int with Singleton] = AnyRef
def bar[A <: Int with Singleton](foo: Foo[A])(implicit v: ValueOf[A]): Int = v.value

val res = bar((???): Foo[10])

If the type parameter is used in some way on the right of the alias, then it won't be replaced with Nothing.

expectation

Compiles, like it does with Scala 2

The type is handed to the compiler on a silver plater. While I understand type aliases can be unstable, I'd assume they wouldn't be this unstable.

[odersky]

The problem is something else. scalac has a built-in fear of Nothing. It will infer A = Int with Singleton even if the function argument is ???, so the presence of the alias type Foo looks like a read herring to me here. scalac's technique is effective but unsystematic, since type
inference changes drastically once variables do have lower bounds. It also means that you can't rely on type inference to do the right thing if you do intend Nothing to be inferred.

dotc is more selective where it infers Nothing or not. But it seems it's still too eager to infer Nothing in this case.

[odersky]

#7845 fixes the problem of instantiating too eagerly to Nothing, but the present issue remains. I would argue scalac is wrong here. In fact type inference works by deriving and solving constraints from code. A constraint is a condition on type variables that is necessary to hold so that a subtype test can succeed. In the present example, the only relevant subtype test is Foo[10] <: Foo[A]. But since
Foo[A] = AnyRef, this is vacuously true. No constraint is generated, and that's how it should be. You need to write bar[10](???) to make your intention clear.