WIP - Initial implementation of parameter overriding check

Author: liufengyun

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

@@ -37,6 +37,8 @@ class Checker extends Phase {
     val classes = traverser.getConcreteClasses()
 
     Semantic.checkClasses(classes)(using checkCtx)
+    ParamOverridingCheck.checkClasses(classes)(using checkCtx)
+
     units
 
   def run(using Context): Unit =

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

@@ -0,0 +1,336 @@
+package dotty.tools.dotc
+package transform
+package init
+
+import core.*
+import Contexts.*
+import Symbols.*
+import Types.*
+import StdNames.*
+import NameKinds.OuterSelectName
+
+import ast.tpd.*
+import config.Printers.init as printer
+import reporting.trace as log
+
+import Semantic.Arg
+import Semantic.NewExpr
+import Semantic.hasSource
+
+import scala.collection.mutable
+import scala.annotation.tailrec
+
+/**
+ * Check overriding of class parameters
+ *
+ * This check issues a warning if the use of a class pamameter in the primary
+ * constructor potentially has different semantics from its use in methods.
+ * The subtle semantic difference is demonstrated by the following exmpale:
+ *
+ *     class B(val y: Int):
+ *       println(y)                   // 10
+ *       foo()
+ *       def foo() = println(y)       // 20
+ *
+ *     class C(override val y: Int) extends B(10)
+ *
+ *     new C(20)
+ *
+ * A well-formed program should not depend on such subtle semantic differences.
+ * Therefore, we detect and warn such subtle semantic differences in code.
+ *
+ * This check depends on loading TASTY from libraries. It can be enabled with
+ * the compiler option `-Ysafe-init`.
+ */
+object ParamOverridingCheck:
+  type Contextual[T] = Context ?=> T
+
+  // ----------------------- Domain definitions --------------------------------
+
+  sealed abstract class Value:
+    val source: Tree
+
+  /** An unknown value */
+  class Unknown(val source: Tree) extends Value:
+    override def equals(other: Any): Boolean = false
+
+  /**
+   * A symbolic value
+   *
+   * Equality is defined as referential equality.
+   */
+  class Skolem(val source: Tree) extends Value
+
+  /** A reference to the object under initialization pointed by `this` */
+  class ThisRef(val klass: ClassSymbol, fields: mutable.Map[Symbol, Value]) extends Value:
+    val source = klass.defTree
+
+    def initField(sym: Symbol, value: Value) =
+      assert(!fields.contains(sym), "The " + sym + " is already initialized")
+      fields(sym) = value
+
+    def field(sym: Symbol) = fields(sym)
+
+    def fieldInitialized(sym: Symbol) = fields.contains(sym)
+
+  // ----------------------- Domain operations ---------------------------------
+
+  extension (value: Value)
+
+    def select(field: Symbol, receiver: Type, needResolve: Boolean = true, source: Tree): Contextual[Value] = log("select " + field.show + ", this = " + value, printer) {
+      value match
+        case ref: ThisRef =>
+          val target = if needResolve then Semantic.resolve(ref.klass, field) else field
+          if target.is(Flags.Lazy) then
+            val rhs = target.defTree.asInstanceOf[ValDef].rhs
+            eval(rhs, ref, target.owner.asClass)
+          else if target.exists then
+            if ref.fieldInitialized(target) then
+              ref.field(target)
+            else
+              Unknown(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)
+            else
+              // This is possible due to incorrect type cast.
+              // See tests/init/pos/Type.scala
+              Unknown(source)
+
+        case _ =>
+          Unknown(source)
+    }
+
+    def callConstructor(ctor: Symbol, args: List[Value]): Contextual[Unit] = log("call " + ctor.show + ", args = " + args, printer) {
+      // init "fake" param fields for parameters of primary and secondary constructors
+      def addParamsAsFields(args: List[Value], ref: ThisRef, ctorDef: DefDef) =
+        val params = ctorDef.termParamss.flatten.map(_.symbol)
+        assert(args.size == params.size, "arguments = " + args.size + ", params = " + params.size)
+        for (param, value) <- params.zip(args) do
+          ref.initField(param, value)
+          printer.println(param.show + " initialized with " + value)
+
+      value match
+        case ref: ThisRef =>
+          if ctor.hasSource then
+            val cls = ctor.owner.enclosingClass.asClass
+            val ddef = ctor.defTree.asInstanceOf[DefDef]
+            addParamsAsFields(args, ref, ddef)
+            if ctor.isPrimaryConstructor then
+              val tpl = cls.defTree.asInstanceOf[TypeDef].rhs.asInstanceOf[Template]
+              eval(tpl, ref, cls)
+            else
+              eval(ddef.rhs, ref, cls)
+
+        case _ =>
+    }
+  end extension
+
+  // --------------------------------- API -------------------------------------
+
+  /**
+   * Check the specified concrete classes
+   */
+  def checkClasses(concreteClasses: List[ClassSymbol])(using Context): Unit =
+    for classSym <- concreteClasses if overrideClassParams(classSym) 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
+        thisRef.initField(param.symbol, new Skolem(param))
+
+      init(tpl, thisRef, classSym)
+
+  // ---------------------- Semantic definition --------------------------------
+
+  /** Evaluate a list of expressions */
+  def eval(exprs: List[Tree], thisV: ThisRef, klass: ClassSymbol): Contextual[List[Value]] =
+    exprs.map { expr => eval(expr, thisV, klass) }
+
+  /** Evaluate arguments of methods */
+  def evalArgs(args: List[Arg], thisV: ThisRef, klass: ClassSymbol): Contextual[List[Value]] =
+    for arg <- args yield eval(arg.tree, thisV, klass)
+
+  /** Evaluate an expression with the given value for `this` in a given class `klass`
+   *
+   *  Note that `klass` might be a super class of the object referred by `thisV`.
+   *  The parameter `klass` is needed for `this` resolution. Consider the following code:
+   *
+   *  class A {
+   *    A.this
+   *    class B extends A { A.this }
+   *  }
+   *
+   *  As can be seen above, the meaning of the expression `A.this` depends on where
+   *  it is located.
+   *
+   */
+  def eval(expr: Tree, thisV: ThisRef, klass: ClassSymbol): Contextual[Value] =
+    expr match
+      case Ident(nme.WILDCARD) =>
+        Unknown(expr)
+
+      case id @ Ident(name) if !id.symbol.is(Flags.Method)  =>
+        assert(name.isTermName, "type trees should not reach here")
+        eval(expr.tpe, thisV, klass, expr)
+
+      case Select(qualifier, name) =>
+        val qual = eval(qualifier, thisV, klass)
+
+        name match
+          case OuterSelectName(_, _) =>
+            Skolem(expr)
+          case _ =>
+            qual.select(expr.symbol, receiver = qualifier.tpe, source = expr)
+
+      case _: This =>
+        eval(expr.tpe, thisV, klass, expr)
+
+      case Typed(expr, tpt) =>
+        eval(expr, thisV, klass)
+
+      case NamedArg(name, arg) =>
+        eval(arg, thisV, klass)
+
+      case Literal(_) =>
+        Skolem(expr)
+
+      case _ =>
+        Unknown(expr)
+
+  /** Handle semantics of leaf nodes */
+  def eval(tp: Type, thisV: ThisRef, klass: ClassSymbol, source: Tree): Contextual[Value] = log("evaluating " + tp.show, printer) {
+    tp match
+      case _: ConstantType =>
+        Skolem(source)
+
+      case tmref: TermRef if tmref.prefix == NoPrefix =>
+        Unknown(source)
+
+      case tmref: TermRef =>
+        val cls = tmref.widenSingleton.classSymbol
+        if cls.exists && cls.isStaticOwner then
+          if cls == klass || cls == thisV.klass then
+            thisV
+          else
+            Skolem(source)
+        else
+          eval(tmref.prefix, thisV, klass, source).select(tmref.symbol, receiver = tmref.prefix, source = source)
+
+      case tp @ ThisType(tref) =>
+        val cls = tref.classSymbol.asClass
+        if cls == klass then
+          thisV
+        else
+          Skolem(source)
+
+      case _ =>
+        report.error("[Internal error] unexpected type " + tp, source)
+        Unknown(source)
+  }
+
+  /** Initialize part of an abstract object in `klass` of the inheritance chain */
+  def init(tpl: Template, thisV: ThisRef, klass: ClassSymbol): Contextual[Value] = log("init " + klass.show, printer) {
+    val paramsMap = tpl.constr.termParamss.flatten.map { vdef =>
+      vdef.name -> thisV.field(vdef.symbol)
+    }.toMap
+
+    // init param fields from class parameters
+    klass.paramGetters.foreach { acc =>
+      val value = paramsMap(acc.name.toTermName)
+      thisV.initField(acc, value)
+      printer.println(acc.show + " initialized with " + value)
+    }
+
+    def superCall(tref: TypeRef, ctor: Symbol, args: List[Value]): Unit =
+      val cls = tref.classSymbol.asClass
+
+      // follow constructor
+      if ctor.hasSource then
+        printer.println("init super class " + cls.show)
+        thisV.callConstructor(ctor, args)
+
+    // parents
+    def initParent(parent: Tree) =
+      parent match
+      case tree @ Block(stats, NewExpr(tref, New(tpt), ctor, argss)) =>  // can happen
+        val args = evalArgs(argss.flatten, thisV, klass)
+        superCall(tref, ctor, args)
+
+      case tree @ NewExpr(tref, New(tpt), ctor, argss) =>       // extends A(args)
+        val args = evalArgs(argss.flatten, thisV, klass)
+        superCall(tref, ctor, args)
+
+      case _ =>   // extends A or extends A[T]
+        val tref = Semantic.typeRefOf(parent.tpe)
+        superCall(tref, tref.classSymbol.primaryConstructor, Nil)
+
+    // see spec 5.1 about "Template Evaluation".
+    // https://www.scala-lang.org/files/archive/spec/2.13/05-classes-and-objects.html
+    if !klass.is(Flags.Trait) then
+      // 1. first init parent class recursively
+      // 2. initialize traits according to linearization order
+      val superParent = tpl.parents.head
+      val superCls = superParent.tpe.classSymbol.asClass
+      initParent(superParent)
+
+      val parents = tpl.parents.tail
+      val mixins = klass.baseClasses.tail.takeWhile(_ != superCls)
+
+      // The interesting case is the outers for traits.  The compiler
+      // synthesizes proxy accessors for the outers in the class that extends
+      // the trait. As those outers must be stable values, they are initialized
+      // immediately following class parameters and before super constructor
+      // calls and user code in the class body.
+      mixins.reverse.foreach { mixin =>
+        parents.find(_.tpe.classSymbol == mixin) match
+        case Some(parent) =>
+          initParent(parent)
+
+        case None =>
+          // According to the language spec, if the mixin trait requires
+          // arguments, then the class must provide arguments to it explicitly
+          // in the parent list. That means we will encounter it in the Some
+          // branch.
+          //
+          // When a trait A extends a parameterized trait B, it cannot provide
+          // term arguments to B. That can only be done in a concrete class.
+          val tref = Semantic.typeRefOf(klass.typeRef.baseType(mixin).typeConstructor)
+          val ctor = tref.classSymbol.primaryConstructor
+          if ctor.exists then
+            superCall(tref, ctor, args = Nil)
+      }
+    end if
+
+    // skip class body
+
+    // check parameter access semantics
+    for
+      paramAcc <- klass.paramGetters
+      overridingSym = paramAcc.overridingSymbol(thisV.klass)
+      if overridingSym.exists
+    do
+      if !overridingSym.is(Flags.ParamAccessor) then
+        report.warning("Overriding class parameter " + paramAcc.name + " in " + klass + " with non-class-parameter in " + thisV.klass, overridingSym.defTree)
+      else
+        val overridingValue = thisV.field(overridingSym)
+        if thisV.field(paramAcc) != overridingValue then
+          report.warning("Incorrect overriding, " + paramAcc + " in " + klass + " have different value from " + overridingSym + " in " + thisV.klass, overridingValue.source)
+
+    thisV
+  }
+
+  // ------------------------- Helper methods ----------------------------------
+
+  /** Does the given class override a class parameter? */
+  def overrideClassParams(classSym: ClassSymbol)(using Context): Boolean =
+    classSym.info.baseClasses match
+      case _ :: inherited =>
+        inherited.exists(superCls => anyClassParameterOverridenBy(superCls, by = classSym))
+
+      case Nil =>
+        false
+
+  /** Does the given class override a class parameter? */
+  def anyClassParameterOverridenBy(classSym: ClassSymbol, by: ClassSymbol)(using Context): Boolean =
+    classSym.paramGetters.exists(_.overridingSymbol(classSym).exists)