Compute overriding symbol correctly

Author: liufengyun

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

@@ -97,18 +97,18 @@ object ParamOverridingCheck:
             if ref.fieldInitialized(target) then
               ref.field(target)
             else
-              Unknown(source)
+              Skolem(source)
           else
             if ref.klass.isSubClass(receiver.widenSingleton.classSymbol) then
               report.error("[Internal error] Unexpected resolution failure: ThisRef.klass = " + ref.klass.show + ", field = " + field.show, source)
-              Unknown(source)
+              Skolem(source)
             else
               // This is possible due to incorrect type cast.
               // See tests/init/pos/Type.scala
-              Unknown(source)
+              Skolem(source)
 
         case _ =>
-          Unknown(source)
+          Skolem(source)
     }
 
   extension (thisV: ThisRef)
@@ -209,7 +209,7 @@ object ParamOverridingCheck:
         Skolem(expr)
 
       case _ =>
-        Unknown(expr)
+        Skolem(expr)
 
   /** Handle semantics of leaf nodes */
   def eval(tp: Type, thisV: ThisRef, klass: ClassSymbol, source: Tree): Contextual[Value] = log("evaluating " + tp.show, printer) {
@@ -225,9 +225,9 @@ object ParamOverridingCheck:
           if enclosingClass == klass then
             thisV.field(sym)
           else
-            Unknown(source)
+            Skolem(source)
         else
-          Unknown(source)
+          Skolem(source)
 
       case tmref: TermRef =>
         val cls = tmref.widenSingleton.classSymbol
@@ -248,7 +248,7 @@ object ParamOverridingCheck:
 
       case _ =>
         report.error("[Internal error] unexpected type " + tp, source)
-        Unknown(source)
+        Skolem(source)
   }
 
   /** Initialize part of an abstract object in `klass` of the inheritance chain */
@@ -331,17 +331,17 @@ object ParamOverridingCheck:
     // check parameter access semantics
     for
       paramSym <- klass.paramGetters
-      overridingSym = paramSym.matchingMember(thisV.klass.thisType)
-      if overridingSym.exists && overridingSym != paramSym && overridingSym.is(Flags.Override)
+      subClass <- thisV.klass.baseClasses if subClass.isSubClass(klass) && subClass != klass
+      overridingSym = paramSym.overridingSymbol(subClass) if overridingSym.exists
     do
       // println(paramSym.show + " is overridden in " + thisV.klass)
       if !overridingSym.is(Flags.ParamAccessor) then
         report.warning("Overriding parameter " + paramSym.show + " in " + klass.show + " as non-parameter in " + overridingSym.owner.show, overridingSym.defTree)
       else
         val overridingValue = thisV.field(overridingSym)
-        // println(overridingSym.show + " in " + thisV.klass + " = " + overridingValue)
-        // println(paramSym.show + " in " + klass + " = " + thisV.field(paramSym))
         if thisV.field(paramSym) != overridingValue then
+          // println(overridingSym.show + " in " + thisV.klass + " = " + overridingValue)
+          // println(paramSym.show + " in " + klass + " = " + thisV.field(paramSym))
           report.warning("Incorrect overriding: " + paramSym.show + " in " + klass.show + " has a different value from " + overridingSym.show + " in " + overridingSym.owner.show, overridingSym.defTree)
 
     thisV

tests/init/pos/i15764d.scala

@@ -0,0 +1,13 @@
+class A(val y: Int):
+  println(y)                   // should not issue a warning here
+  foo()
+  def foo() = println(y)
+
+class B(m: Int, n: Int) extends A(m):
+  def this(z: Int) = this(z, z)
+
+class C(override val y: Int) extends B(y)
+
+class D extends C(10)
+
+class E extends C(new A(20).y)