Singleton constrain should infer literal type

[mwisnicki]

Compiler version

3.7.2

Minimized code

https://scastie.scala-lang.org/hSVqiYRGQEOtddYD6PAYzQ

//> using scala 3.7.2
//> using options -Wall -Werror

//def singleton[T <: Singleton](v: T): T = v
// transparent does not help either
inline def singleton[T <: Singleton](inline v: T): T = v

enum Foo:
  case A
  case B

val e = singleton(Foo.A)
val e1: Foo.A.type = e // fail

// does not work for literal types

val s = singleton("a")
val s1: "a" = s // fail

Output

Found:    (Playground.e : Playground.Foo)
Required: (Playground.Foo.A : Playground.Foo)

Found:    (Playground.s : String)
Required: ("a" : String)

Expectation

1. transparent inline should preserve singleton type, especially with Singleton contraint
2. it would be useful if this worked even without inline, i.e. in presence of Singleton should infer actual singleton type

[mwisnicki]

Also inferred type of s seems to be a String, which does not satisfy <: Singleton

[mwisnicki]

Dependent types don't work either:

def singleton[T <: Singleton](v: T): v.type = v

[hamzaremmal]

This works exactly as designed. Type inference will infer Foo.A.type and ("a") for T and will respect the constraint of <: Singleton. What is missing here is when we assign something to a val or a var, we widen the type of the rhs when inferring its type; which means that Foo.A.type will become Foo and "a" will become String. To not have the widening happening, there is an experimental feature (still under design) that will allow to have more precise type inference. Here is a snippet:

import scala.language.experimental.modularity

def foo: 1 = 1
tracked val e = foo

Here, because e is a tracked val, widening of the inferred type will not happen and e will have the type 1.

[Gedochao]

//> using options -Wall -Werror

this part of the original reproduction seems unnecessary.