Fix #8425: Avoid race between erasure and explicit outer

Author: odersky

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

@@ -710,7 +710,7 @@ object Erasure {
       if (sym.isEffectivelyErased) erasedDef(sym)
       else
         val restpe = if sym.isConstructor then defn.UnitType else sym.info.resultType
-        var vparams = outer.paramDefs(sym)
+        var vparams = outerParamDefs(sym)
             ::: ddef.vparamss.flatten.filterConserve(!_.symbol.is(Flags.Erased))
 
         def skipContextClosures(rhs: Tree, crCount: Int)(using Context): Tree =
@@ -746,6 +746,28 @@ object Erasure {
         super.typedDefDef(ddef1, sym)
     end typedDefDef
 
+    /** The outer parameter definition of a constructor if it needs one */
+    private def outerParamDefs(constr: Symbol)(using ctx: Context): List[ValDef] =
+      if constr.isConstructor && hasOuterParam(constr.owner.asClass) then
+        constr.info match
+          case MethodTpe(outerName :: _, outerType :: _, _) =>
+            val outerSym = ctx.newSymbol(constr, outerName, Flags.Param, outerType)
+            ValDef(outerSym) :: Nil
+          case _ =>
+            // There's a possible race condition that a constructor was looked at
+            // after erasure before we had a chance to run ExplicitOuter on its class
+            // If furthermore the enclosing class does not always have constructors,
+            // but needs constructors in this particular case, we miss the constructor
+            // accessor that's produced with an `enteredAfter` in ExplicitOuter, so
+            // `tranformInfo` of the constructor in erasure yields a method type without
+            // an outer parameter. We fix this problem by adding the missing outer
+            // parameter here. 
+            constr.copySymDenotation(
+              info = outer.addParam(constr.owner.asClass, constr.info)
+            ).installAfter(erasurePhase)
+            outerParamDefs(constr)
+      else Nil
+
     override def typedClosure(tree: untpd.Closure, pt: Type)(implicit ctx: Context): Tree = {
       val xxl = defn.isXXLFunctionClass(tree.typeOpt.typeSymbol)
       var implClosure @ Closure(_, meth, _) = super.typedClosure(tree, pt)

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

@@ -240,7 +240,7 @@ object ExplicitOuter {
     needsOuterIfReferenced(cls) && outerAccessor(cls).exists
 
   /** Class constructor takes an outer argument. Can be called only after phase ExplicitOuter. */
-  private def hasOuterParam(cls: ClassSymbol)(implicit ctx: Context): Boolean =
+  def hasOuterParam(cls: ClassSymbol)(implicit ctx: Context): Boolean =
     !cls.is(Trait) && needsOuterIfReferenced(cls) && outerAccessor(cls).exists
 
   /** Tree references an outer class of `cls` which is not a static owner.
@@ -412,14 +412,5 @@ object ExplicitOuter {
         loop(start, count)
       catch case ex: ClassCastException =>
         throw new ClassCastException(i"no path exists from ${ctx.owner.enclosingClass} to $toCls")
-
-    /** The outer parameter definition of a constructor if it needs one */
-    def paramDefs(constr: Symbol): List[ValDef] =
-      if (constr.isConstructor && hasOuterParam(constr.owner.asClass)) {
-        val MethodTpe(outerName :: _, outerType :: _, _) = constr.info
-        val outerSym = ctx.newSymbol(constr, outerName, Param, outerType)
-        ValDef(outerSym) :: Nil
-      }
-      else Nil
   }
 }