Keep constructor proxies after erasure

It's awkward to delete all references to them. We should treat them like other
symbols that are effectively erased.

Author: odersky

compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala

@@ -214,7 +214,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I) extends BTypes {
   private def definedClasses(sym: Symbol, phase: Phase) =
     if (sym.isDefinedInCurrentRun)
       atPhase(phase) {
-        toDenot(sym).info.decls.filter(_.isClass)
+        toDenot(sym).info.decls.filter(sym => sym.isClass && !sym.isEffectivelyErased)
       }
     else Nil
 

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

@@ -1180,11 +1180,13 @@ object SymDenotations {
      */
     final def companionModule(using Context): Symbol =
       if (is(Module)) sourceModule
+      else if registeredCompanion.isAbsent() then NoSymbol
       else registeredCompanion.sourceModule
 
     private def companionType(using Context): Symbol =
       if (is(Package)) NoSymbol
       else if (is(ModuleVal)) moduleClass.denot.companionType
+      else if registeredCompanion.isAbsent() then NoSymbol
       else registeredCompanion
 
     /** The class with the same (type-) name as this module or module class,

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

@@ -238,6 +238,7 @@ object TypeErasure {
 
     if (defn.isPolymorphicAfterErasure(sym)) eraseParamBounds(sym.info.asInstanceOf[PolyType])
     else if (sym.isAbstractType) TypeAlias(WildcardType)
+    else if sym.is(ConstructorProxy) then NoType
     else if (sym.isConstructor) outer.addParam(sym.owner.asClass, erase(tp)(using preErasureCtx))
     else if (sym.is(Label)) erase.eraseResult(sym.info)(using preErasureCtx)
     else erase.eraseInfo(tp, sym)(using preErasureCtx) match {

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -1038,24 +1038,9 @@ object Erasure {
     override def typedTypeDef(tdef: untpd.TypeDef, sym: Symbol)(using Context): Tree =
       EmptyTree
 
-    /** Drop all constructor proxies of members of class `cls`.
-     *  If `cls` is itself a constructor proxy, mark it as absent after erasure.
-     */
-    private def dropConstructorProxies(cls: ClassSymbol)(using Context) =
-      import Flags._
-      if cls.linkedClass.is(ConstructorProxy) then
-        if cls.owner.is(PackageClass) && cls.isDefinedInCurrentRun then
-          cls.linkedClass.copySymDenotation(initFlags = EmptyFlags, info = NoType)
-            .installAfter(erasurePhase)
-        cls.registeredCompanion = NoSymbol
-      for mbr <- cls.info.decls do
-        if mbr.is(ConstructorProxy) then mbr.dropAfter(erasurePhase)
-
     override def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(using Context): Tree =
       if cls.is(Flags.Erased) then erasedDef(cls)
-      else
-        try super.typedClassDef(cdef, cls)
-        finally dropConstructorProxies(cls)
+      else super.typedClassDef(cdef, cls)
 
     override def typedAnnotated(tree: untpd.Annotated, pt: Type)(using Context): Tree =
       typed(tree.arg, pt)

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -446,8 +446,7 @@ class TreeChecker extends Phase with SymTransformer {
       val decls   = cls.classInfo.decls.toList.toSet.filter(isNonMagicalMember)
       val defined = impl.body.map(_.symbol)
 
-      def isAllowed(sym: Symbol): Boolean =
-        sym.is(ConstructorProxy) && !ctx.phase.erasedTypes
+      def isAllowed(sym: Symbol): Boolean = sym.is(ConstructorProxy)
 
       val symbolsNotDefined = (decls -- defined - constr.symbol).filterNot(isAllowed)