Make initialization checker see through synthetic applys

compiler/src/dotty/tools/dotc/transform/init/Semantic.scala

@@ -590,11 +590,20 @@ object Semantic {
     def call(meth: Symbol, args: List[ArgInfo], superType: Type, source: Tree, needResolve: Boolean = true): Contextual[Result] = log("call " + meth.show + ", args = " + args, printer, (_: Result).show) {
       def checkArgs = args.flatMap(_.promote)
 
+      def isSyntheticApply(meth: Symbol) =
+        meth.is(Flags.Synthetic)
+        && meth.owner.is(Flags.Module)
+        && meth.owner.companionClass.is(Flags.Case)
+
       // fast track if the current object is already initialized
       if promoted.isCurrentObjectPromoted then Result(Hot, Nil)
       else value match {
         case Hot  =>
-          Result(Hot, checkArgs)
+          if isSyntheticApply(meth) then
+            val klass = meth.owner.companionClass.asClass
+            instantiate(klass, klass.primaryConstructor, args, source)
+          else
+            Result(Hot, checkArgs)
 
         case Cold =>
           val error = CallCold(meth, source, trace.toVector)
@@ -616,11 +625,14 @@ object Semantic {
               given Trace = trace1
               val cls = target.owner.enclosingClass.asClass
               val ddef = target.defTree.asInstanceOf[DefDef]
-              val env2 = Env(ddef, args.map(_.value).widenArgs)
               // normal method call
-              withEnv(if isLocal then env else Env.empty) {
-                eval(ddef.rhs, ref, cls, cacheResult = true) ++ checkArgs
-              }
+              if isSyntheticApply(meth) then
+                val klass = meth.owner.companionClass.asClass
+                instantiate(klass, klass.primaryConstructor, args, source)
+              else
+                withEnv(if isLocal then env else Env.empty) {
+                  eval(ddef.rhs, ref, cls, cacheResult = true) ++ checkArgs
+                }
             else if ref.canIgnoreMethodCall(target) then
               Result(Hot, Nil)
             else

docs/docs/reference/other-new-features/safe-initialization.md

@@ -194,14 +194,6 @@ With the established principles and design goals, following rules are imposed:
    non-initialized object is not used, i.e. calling methods or accessing fields
    on the escaped object is not allowed.
 
-3. Local definitions may only refer to transitively initialized objects.
-
-   It means that in a local definition `val x: T = e`, the expression `e` may
-   only evaluate to transitively initialized objects. The same goes for local
-   lazy variables and methods. This rule is again motivated for simplicity in
-   reasoning about initialization: programmers may safely assume that all local
-   definitions only point to transitively initialized objects.
-
 ## Modularity
 
 The analysis takes the primary constructor of concrete classes as entry points.

tests/init/neg/apply.scala

@@ -0,0 +1,47 @@
+case class A(b: B)
+
+object A:
+  def foo(b: B) = new A(b)
+  inline def bar(b: B) = new A(b)
+
+class B:
+  val a = A(this)
+  val a2 = A.foo(this)   // error
+  val a3 = A.bar(this)
+
+// test receiver is ThisRef
+
+object O:
+  case class A(b: B)
+
+  object A:
+    def foo(b: B) = new A(b)
+    inline def bar(b: B) = new A(b)
+
+  class B:
+    val a = A(this)
+    val a2 = A.foo(this)   // error
+    val a3 = A.bar(this)
+
+  val b = new B
+end O
+
+
+// test receiver is Warm
+
+class M(n: N):
+  case class A(b: B)
+
+  object A:
+    def foo(b: B) = new A(b)
+    inline def bar(b: B) = new A(b)
+
+  class B:
+    val a = A(this)
+    val a2 = A.foo(this)   // error
+    val a3 = A.bar(this)
+end M
+
+class N:
+  val m = new M(this)
+  val b = new m.B