Runtime checks for qualified types

Co-Authored-By: Valentin Schneeberger <[email protected]>
Co-Authored-By: Quentin Bernet <[email protected]>

Author: 3 people

compiler/src/dotty/tools/dotc/qualified_types/QualifiedTypes.scala

@@ -19,17 +19,26 @@ import dotty.tools.dotc.ast.tpd.{
   Typed,
   given
 }
+import dotty.tools.dotc.config.Printers
 import dotty.tools.dotc.core.Atoms
 import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.core.Contexts.{ctx, Context}
-import dotty.tools.dotc.core.Decorators.{i, em, toTermName}
+import dotty.tools.dotc.core.Decorators.{em, i, toTermName}
 import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.Symbols.{defn, Symbol}
-import dotty.tools.dotc.core.Types.{AndType, ConstantType, SkolemType, ErrorType, MethodType, OrType, TermRef, Type, TypeProxy}
-
+import dotty.tools.dotc.core.Types.{
+  AndType,
+  ConstantType,
+  ErrorType,
+  MethodType,
+  OrType,
+  SkolemType,
+  TermRef,
+  Type,
+  TypeProxy
+}
 import dotty.tools.dotc.report
 import dotty.tools.dotc.reporting.trace
-import dotty.tools.dotc.config.Printers
 
 object QualifiedTypes:
   /** Does the type `tp1` imply the qualifier `qualifier2`?
@@ -66,9 +75,22 @@ object QualifiedTypes:
    */
   def adapt(tree: Tree, pt: Type)(using Context): Tree =
     trace(i"adapt $tree to $pt", Printers.qualifiedTypes):
-      if containsQualifier(pt) && isSimple(tree) then
-        val selfifiedTp = QualifiedType(tree.tpe, equalToPredicate(tree))
-        if selfifiedTp <:< pt then tree.cast(selfifiedTp) else EmptyTree
+      if containsQualifier(pt) then
+        if tree.tpe.hasAnnotation(defn.RuntimeCheckedAnnot) then
+          if checkContainsSkolem(pt) then
+            tpd.evalOnce(tree): e =>
+              If(
+                e.isInstance(pt),
+                e.asInstance(pt),
+                Throw(New(defn.IllegalArgumentExceptionType, List()))
+              )
+          else
+            tree.withType(ErrorType(em""))
+        else if isSimple(tree) then
+          val selfifiedTp = QualifiedType(tree.tpe, equalToPredicate(tree))
+          if selfifiedTp <:< pt then tree.cast(selfifiedTp) else EmptyTree
+        else
+          EmptyTree
       else
         EmptyTree
 
@@ -79,7 +101,7 @@ object QualifiedTypes:
       case SeqLiteral(elems, _) => elems.forall(isSimple)
       case Typed(expr, _)       => isSimple(expr)
       case Block(Nil, expr)     => isSimple(expr)
-      case _ => tpd.isIdempotentExpr(tree)
+      case _                    => tpd.isIdempotentExpr(tree)
 
   def containsQualifier(tp: Type)(using Context): Boolean =
     tp match
@@ -89,6 +111,18 @@ object QualifiedTypes:
       case OrType(tp1, tp2)    => containsQualifier(tp1) || containsQualifier(tp2)
       case _                   => false
 
+  def checkContainsSkolem(tp: Type)(using Context): Boolean =
+    var res = true
+    tp.foreachPart:
+      case QualifiedType(_, qualifier) =>
+        qualifier.foreachSubTree: subTree =>
+          subTree.tpe.foreachPart:
+            case tp: SkolemType =>
+              report.error(em"The qualified type $qualifier cannot be checked at runtime", qualifier.srcPos)
+              res = false
+            case _ => ()
+      case _ => ()
+    res
 
   private def equalToPredicate(tree: Tree)(using Context): Tree =
     Lambda(

compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala

@@ -18,6 +18,8 @@ import config.Printers.{ transforms => debug }
 import patmat.Typ
 import dotty.tools.dotc.util.SrcPos
 
+import qualified_types.QualifiedType
+
 /** This transform normalizes type tests and type casts,
  *  also replacing type tests with singleton argument type with reference equality check
  *  Any remaining type tests
@@ -323,7 +325,7 @@ object TypeTestsCasts {
          *  The transform happens before erasure of `testType`, thus cannot be merged
          *  with `transformIsInstanceOf`, which depends on erased type of `testType`.
          */
-        def transformTypeTest(expr: Tree, testType: Type, flagUnrelated: Boolean): Tree = testType.dealias match {
+        def transformTypeTest(expr: Tree, testType: Type, flagUnrelated: Boolean): Tree = testType.dealiasKeepRefiningAnnots match {
           case tref: TermRef if tref.symbol == defn.EmptyTupleModule =>
             ref(defn.RuntimeTuples_isInstanceOfEmptyTuple).appliedTo(expr)
           case _: SingletonType =>
@@ -352,6 +354,12 @@ object TypeTestsCasts {
             ref(defn.RuntimeTuples_isInstanceOfNonEmptyTuple).appliedTo(expr)
           case AppliedType(tref: TypeRef, _) if tref.symbol == defn.PairClass =>
             ref(defn.RuntimeTuples_isInstanceOfNonEmptyTuple).appliedTo(expr)
+          case QualifiedType(parent, closureDef(qualifierDef)) =>
+            evalOnce(expr): e =>
+              // e.isInstanceOf[baseType] && qualifier(e.asInstanceOf[baseType])
+              val arg = e.asInstance(parent)
+              val qualifierTest = BetaReduce.reduceApplication(qualifierDef, List(List(arg))).get
+              transformTypeTest(e, parent, flagUnrelated).and(qualifierTest)
           case _ =>
             val testWidened = testType.widen
             defn.untestableClasses.find(testWidened.isRef(_)) match

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -172,6 +172,7 @@ class CompilationTests {
       compileFilesInDir("tests/run", defaultOptions.and("-Wsafe-init")),
       compileFilesInDir("tests/run-deep-subtype", allowDeepSubtypes),
       compileFilesInDir("tests/run-custom-args/captures", allowDeepSubtypes.and("-language:experimental.captureChecking", "-source", "3.8")),
+      compileFilesInDir("tests/run-custom-args/qualified-types", defaultOptions.and("-language:experimental.qualifiedTypes")),
       // Run tests for legacy lazy vals.
       compileFilesInDir("tests/run", defaultOptions.and("-Wsafe-init", "-Ylegacy-lazy-vals", "-Ycheck-constraint-deps"), FileFilter.include(TestSources.runLazyValsAllowlist)),
     ).checkRuns()

tests/neg-custom-args/qualified-types/runtimeChecked_dependent_neg.scala

@@ -0,0 +1,8 @@
+def foo(x: Int, y: {v: Int with v > x}): y.type = y
+
+def getInt(): Int =
+  println("getInt called")
+  42
+
+@main def Test =
+  val res = foo(getInt(), 2.runtimeChecked) // error

tests/run-custom-args/qualified-types/evalOnce.check

@@ -0,0 +1,4 @@
+Hello
+succeed
+65
+Hello

tests/run-custom-args/qualified-types/evalOnce.scala

@@ -0,0 +1,15 @@
+@main def Test: Unit =
+
+  ({println ("Hello"); 4}).isInstanceOf[{ y : Int with y > 0}]
+
+  class Person(val name: String, var age: Int)
+    def incAge(p: Person): Int =
+        p.age += 1
+        p.age
+
+  val p = new Person("Alice", 64)
+
+  if incAge(p).isInstanceOf[{v:Int with v == 65}] then println("succeed")
+  println(p.age)
+
+  ({println ("Hello"); 4}).isInstanceOf[Int & { y : Int with y > 0}]