Abstract parameters of non-local constructor parameters as cold

This is a simple fix which should have no impact on expressiveness
and usability, as local classes inside secondary constructors are
extremely rare.

Author: liufengyun

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

@@ -74,7 +74,7 @@ object Errors {
 
   case class AccessCold(field: Symbol, source: Tree, trace: Seq[Tree]) extends Error {
     def show(using Context): String =
-      "Access field " + source.show + " on a value with an unknown initialization status" + "."
+      "Access field " + source.show + " on a value with an unknown initialization status."
   }
 
   case class CallCold(meth: Symbol, source: Tree, trace: Seq[Tree]) extends Error {

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

@@ -475,22 +475,14 @@ class Semantic {
 
         case addr: Addr =>
           given Trace = trace1
-
           // widen the outer to finitize addresses
           val outer = addr match
             case Warm(_, _: Warm, _, _) => Cold
             case _ => addr
 
           val value = Warm(klass, outer, ctor, args.map(_.value).widenArgs).ensureExists
           val res = value.call(ctor, args, superType = NoType, source)
-
-          def inSecondaryConstructor(sym: Symbol): Boolean =
-            !sym.isClass && (sym.isConstructor || inSecondaryConstructor(sym.owner))
-
-          // Approximate instances of local classes inside secondary constructor as Cold.
-          // This way, we avoid complicating the domain for Warm unnecessarily
-          if inSecondaryConstructor(klass.owner) then Result(Cold, res.errors)
-          else Result(value, res.errors)
+          Result(value, res.errors)
 
         case Fun(body, thisV, klass, env) =>
           report.error("unexpected tree in instantiating a function, fun = " + body.show, source)
@@ -901,7 +893,12 @@ class Semantic {
           // This enables us to simplify the domain without sacrificing
           // expressiveness nor soundess, as local classes inside secondary
           // constructors are uncommon.
-          Result(env.lookup(sym), Nil)
+          if sym.isContainedIn(klass) then
+            Result(env.lookup(sym), Nil)
+          else
+            // We don't know much about secondary constructor parameters in outer scope.
+            // It's always safe to approximate them with `Cold`.
+            Result(Cold, Nil)
         else
           default()
 

tests/init/neg/secondary-ctor2.scala

@@ -2,9 +2,9 @@ class A(b: B, x: Int) {
   def this(b: B) = {
     this(b, 5)
     class Inner() {
-      def foo() = println(b.n)
+      def foo() = println(b.n) // error: calling method on cold
     }
-    Inner().foo() // error: calling method on cold
+    Inner().foo()
 
     val f = () => new A(b, 3)
     f() // ok

tests/init/neg/secondary-ctor3.scala

@@ -7,9 +7,9 @@ def foo() =
     def this(b: B) = {
       this(b, 5)
       class Inner() {
-        def foo() = println(b.n)
+        def foo() = println(b.n) // error
       }
-      Inner().foo() // error: calling method on cold
+      Inner().foo()
 
       val l1 = new L1(3)
       println(l1.n)

tests/init/neg/secondary-ctor4.scala

@@ -0,0 +1,61 @@
+trait D {
+  val n: Int = 10
+}
+
+class M(x: Int) {
+
+  def this(d: D) = {
+    this(d.n)
+
+    class L1(x: Int) { val n: Int = 5 }
+
+    class A(b: B, x: Int) {
+      println(d.n)      // error
+
+      class L2(x: Int) { val n: Int = 5 }
+
+      def this(b: B) = {
+        this(b, 5)
+        println(d.n)  // error
+
+        class Inner() {
+          println(d.n)   // error
+          println(b.n)   // error
+          def foo() = println(b.n)  // error
+        }
+        Inner().foo()
+
+        val l1 = new L1(3)
+        println(l1.n)
+
+        val l2 = new L2(3)
+        println(l2.n)
+
+        (() => new A(b, 3))()  // ok
+      }
+    }
+
+    class B(val d: D) {
+      val n: Int = 10
+    }
+
+    new A(new B(new D))
+
+    trait T {
+      val m: Int = 10
+    }
+
+    class C(b: B) extends A(b) with T {
+      def this(b: B, x: Int) = this(b)
+    }
+
+    class D {
+      val b = new B(this)
+      val c = new C(b, 5)
+    }
+  }
+}
+
+class N(d: D) extends M(d) {
+  val msg = "Scala"
+}