Desugar using clauses for Singleton context bounds to be erased

Drop the previous convention that Singleton is an erased class under
x.modularity. That does not work anynmore if we change to the Erased trait
scheme.

Author: odersky

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -543,7 +543,7 @@ class Definitions {
     // needed as a synthetic class because Scala 2.x refers to it in classfiles
     // but does not define it as an explicit class.
     val cls = enterCompleteClassSymbol(
-      ScalaPackageClass, tpnme.Singleton, PureInterfaceCreationFlags | Final | Erased,
+      ScalaPackageClass, tpnme.Singleton, PureInterfaceCreationFlags | Final,
       List(AnyType))
     enterTypeField(cls, tpnme.Self, Deferred, cls.info.decls.openForMutations)
     cls

compiler/src/dotty/tools/dotc/core/TypeUtils.scala

@@ -26,8 +26,6 @@ class TypeUtils:
     def isErasedClass(using Context): Boolean =
       val cls = self.underlyingClassRef(refinementOK = true).typeSymbol
       cls.is(Flags.Erased)
-       && (cls != defn.SingletonClass || Feature.enabled(Feature.modularity))
-         // Singleton counts as an erased class only under x.modularity
 
 
     /** Is this type a checked exception? This is the case if the type

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -1908,6 +1908,11 @@ class Namer { typer: Typer =>
         case _ =>
 
     val mbrTpe = paramFn(checkSimpleKinded(typedAheadType(mdef.tpt, tptProto)).tpe)
+    // Add an erased to the using clause generated from a `: Singleton` context bound
+    mdef.tpt match
+      case tpt: untpd.ContextBoundTypeTree if mbrTpe.typeSymbol == defn.SingletonClass =>
+        sym.setFlag(Erased)
+      case _ =>
     if (ctx.explicitNulls && mdef.mods.is(JavaDefined))
       JavaNullInterop.nullifyMember(sym, mbrTpe, mdef.mods.isAllOf(JavaEnumValue))
     else mbrTpe

tests/new/test.scala

@@ -1,12 +1,3 @@
-import java.io.IOException
 
-class CanThrow[-E <: Exception]
 
-def foo[E <: Exception](e: E)(using erased CanThrow[E]): Nothing = throw e
-
-erased def magic[E]: E = magic // error
-inline def moreMagic[E]: E = moreMagic
-
-def Test =
-  foo(new IOException)(using magic)
-  foo(new IOException)(using moreMagic) // should be error
+def foo[T: Singleton](x: T) = x

tests/pos/singleton-ctx-bound.scala

@@ -1,4 +1,4 @@
-//> using options -language:experimental.modularity -source future
+//> using options -language:experimental.modularity -source future -language:experimental.erasedDefinitions
 object Test:
 
   class Wrap[T](x: T)
@@ -11,15 +11,15 @@ object Test:
   val x1 = f1(1)
   val _: Wrap[1] = x1
 
-  def f2[T](x: T)(using Singleton { type Self = T}): Wrap[T] = Wrap(x)
+  def f2[T](x: T)(using erased Singleton { type Self = T}): Wrap[T] = Wrap(x)
   val x2 = f2(1)
   val _: Wrap[1] = x2
 
   def f3[T: Singleton](x: T): Wrap[T] = Wrap(x)
   val x3 = f3(1)
   val _: Wrap[1] = x3
 
-  def f4[T](x: T)(using T is Singleton): Wrap[T] = Wrap(x)
+  def f4[T](x: T)(using erased T is Singleton): Wrap[T] = Wrap(x)
   val x4 = f4(1)
   val _: Wrap[1] = x4
 
@@ -33,7 +33,7 @@ object Test:
   val y1 = C1("hi")
   val _: "hi" = y1.fld
 
-  class C2[T](x: T)(using T is Singleton):
+  class C2[T](x: T)(using erased T is Singleton):
     def fld: T = x
   val y2 = C2("hi")
   val _: "hi" = y2.fld