Check abstract classes

Author: liufengyun

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

@@ -19,7 +19,7 @@ import scala.collection.mutable
 
 import Semantic._
 
-class Checker extends Phase {
+class Checker extends Phase:
 
   override def phaseName: String = Checker.name
 
@@ -34,7 +34,7 @@ class Checker extends Phase {
     val checkCtx = ctx.fresh.setPhase(this.start)
     val traverser = new InitTreeTraverser()
     units.foreach { unit => traverser.traverse(unit.tpdTree) }
-    val classes = traverser.getConcreteClasses()
+    val classes = traverser.getClasses()
 
     ParamOverridingCheck.checkClasses(classes)(using checkCtx)
     Semantic.checkClasses(classes)(using checkCtx)
@@ -45,10 +45,10 @@ class Checker extends Phase {
     // ignore, we already called `Semantic.check()` in `runOn`
     ()
 
-  class InitTreeTraverser extends TreeTraverser {
-    private val concreteClasses: mutable.ArrayBuffer[ClassSymbol] = new mutable.ArrayBuffer
+  class InitTreeTraverser extends TreeTraverser:
+    private val classes: mutable.ArrayBuffer[ClassSymbol] = new mutable.ArrayBuffer
 
-    def getConcreteClasses(): List[ClassSymbol] = concreteClasses.toList
+    def getClasses(): List[ClassSymbol] = classes.toList
 
     override def traverse(tree: Tree)(using Context): Unit =
       traverseChildren(tree)
@@ -61,28 +61,13 @@ class Checker extends Phase {
           mdef match
           case tdef: TypeDef if tdef.isClassDef =>
             val cls = tdef.symbol.asClass
-            if isConcreteClass(cls) then concreteClasses.append(cls)
+            classes.append(cls)
           case _ =>
 
         case _ =>
       }
-  }
-
-  private def isConcreteClass(cls: ClassSymbol)(using Context) = {
-    val instantiable: Boolean =
-      cls.is(Flags.Module) ||
-      !cls.isOneOf(Flags.AbstractOrTrait) && {
-        // see `Checking.checkInstantiable` in typer
-        val tp = cls.appliedRef
-        val stp = SkolemType(tp)
-        val selfType = cls.givenSelfType.asSeenFrom(stp, cls)
-        !selfType.exists || stp <:< selfType
-      }
+  end InitTreeTraverser
 
-    // A concrete class may not be instantiated if the self type is not satisfied
-    instantiable && cls.enclosingPackageClass != defn.StdLibPatchesPackage.moduleClass
-  }
-}
 
 object Checker:
   val name: String = "initChecker"

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

@@ -145,8 +145,8 @@ object ParamOverridingCheck:
   /**
    * Check the specified concrete classes
    */
-  def checkClasses(concreteClasses: List[ClassSymbol])(using Context): Unit =
-    for classSym <- concreteClasses do
+  def checkClasses(classes: List[ClassSymbol])(using Context): Unit =
+    for classSym <- classes if !classSym.is(Flags.Trait) do
       val thisRef = ThisRef(classSym, fields = mutable.Map.empty)
       val tpl = classSym.defTree.asInstanceOf[TypeDef].rhs.asInstanceOf[Template]
       for param <- tpl.constr.termParamss.flatten yield
@@ -331,8 +331,7 @@ object ParamOverridingCheck:
     // check parameter access semantics
     for
       paramSym <- klass.paramGetters
-      subClass <- thisV.klass.baseClasses if subClass.isSubClass(klass) && subClass != klass
-      overridingSym = paramSym.overridingSymbol(subClass) if overridingSym.exists
+      overridingSym = paramSym.overridingSymbol(thisV.klass) if overridingSym.exists
     do
       // println(paramSym.show + " is overridden in " + thisV.klass)
       if !overridingSym.is(Flags.ParamAccessor) then

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

@@ -1210,7 +1210,7 @@ object Semantic:
   class WorkList private[Semantic](tasks: List[ClassSymbol]):
     /** Process the worklist until done */
     final def work()(using Cache, Context): Unit =
-      for task <- tasks do doTask(task)
+      for task <- tasks if isConcreteClass(task) do doTask(task)
 
     /** Check an individual class
      *
@@ -1766,3 +1766,18 @@ object Semantic:
     if (sym.isEffectivelyFinal || sym.isConstructor) sym
     else sym.matchingMember(cls.appliedRef)
   }
+
+  private def isConcreteClass(cls: ClassSymbol)(using Context) = {
+    val instantiable: Boolean =
+      cls.is(Flags.Module) ||
+      !cls.isOneOf(Flags.AbstractOrTrait) && {
+        // see `Checking.checkInstantiable` in typer
+        val tp = cls.appliedRef
+        val stp = SkolemType(tp)
+        val selfType = cls.givenSelfType.asSeenFrom(stp, cls)
+        !selfType.exists || stp <:< selfType
+      }
+
+    // A concrete class may not be instantiated if the self type is not satisfied
+    instantiable && cls.enclosingPackageClass != defn.StdLibPatchesPackage.moduleClass
+  }

tests/init/neg/i15764d.scala

@@ -3,3 +3,7 @@ class A(val y: Int)
 abstract class B(override val y: Int) extends A(10) // error
 
 class C extends B(7)
+
+class X(val y: Int)
+
+abstract class Y(override val y: Int) extends A(10) // error

tests/init/pos/i15764e.scala

@@ -0,0 +1,7 @@
+trait X(val x: Int, y: Int, z: Int)
+trait Y(override val x: Int, y: Int, z: Int) extends X
+class Z(override val x: Int, y: Int, z: Int) extends Y(x, y, z) with X(x, y, z)
+
+trait A(val x: Int, y: Int, z: Int)
+trait B(override val x: Int, y: Int, z: Int) extends A
+class C extends B(1, 2, 3) with A(1, 2, 3)