Check nesteded scrutinees for scrutability

Author: odersky

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -1158,6 +1158,7 @@ trait Applications extends Compatibility {
   def typedUnApply(tree: untpd.Apply, selType: Type)(using Context): Tree = {
     record("typedUnApply")
     val Apply(qual, args) = tree
+    checkScrutable(selType, tree.srcPos, pattern = true)
 
     def notAnExtractor(tree: Tree): Tree =
       // prefer inner errors

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -1246,6 +1246,11 @@ trait Checking {
         if preExisting.exists || seen.contains(tname) then
           report.error(em"@targetName annotation ${'"'}$tname${'"'} clashes with other definition in same scope", stat.srcPos)
         if stat.isDef then seen += tname
+
+  def checkScrutable(tp: Type, pos: SrcPos, pattern: Boolean)(using Context): Unit =
+    if !tp.derivesFrom(defn.ScrutableClass) && sourceVersion.isAtLeast(`3.1-migration`) then
+      val kind = if pattern then "pattern selector " else ""
+      report.warning(em"${kind}type $tp should not be scrutinized", pos)
 }
 
 trait ReChecking extends Checking {
@@ -1256,6 +1261,7 @@ trait ReChecking extends Checking {
   override def checkFullyAppliedType(tree: Tree)(using Context): Unit = ()
   override def checkEnumCaseRefsLegal(cdef: TypeDef, enumCtx: Context)(using Context): Unit = ()
   override def checkAnnotApplicable(annot: Tree, sym: Symbol)(using Context): Boolean = true
+  override def checkScrutable(tp: Type, pos: SrcPos, pattern: Boolean)(using Context): Unit = ()
 }
 
 trait NoChecking extends ReChecking {

compiler/src/dotty/tools/dotc/typer/ReTyper.scala

@@ -140,6 +140,5 @@ class ReTyper extends Typer with ReChecking {
 
   override protected def addAccessorDefs(cls: Symbol, body: List[Tree])(using Context): List[Tree] = body
   override protected def checkEqualityEvidence(tree: tpd.Tree, pt: Type)(using Context): Unit = ()
-  override protected def checkScrutable(sel: Tree)(using Context): Unit = ()
   override protected def matchingApply(methType: MethodOrPoly, pt: FunProto)(using Context): Boolean = true
 }

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -764,6 +764,7 @@ class Typer extends Namer
       def handlePattern: Tree = {
         val tpt1 = typedTpt
         if (!ctx.isAfterTyper && pt != defn.ImplicitScrutineeTypeRef)
+          checkScrutable(pt, tree.srcPos, pattern = true)
           withMode(Mode.GadtConstraintInference) {
             TypeComparer.constrainPatternType(tpt1.tpe, pt)
           }
@@ -1294,8 +1295,6 @@ class Typer extends Namer
     assignType(cpy.Closure(tree)(env1, meth1, target), meth1, target)
   }
 
-  protected def checkScrutable(sel: Tree)(using Context): Unit = adapt(sel, defn.ScrutableType)
-
   def typedMatch(tree: untpd.Match, pt: Type)(using Context): Tree =
     tree.selector match {
       case EmptyTree =>
@@ -1317,10 +1316,9 @@ class Typer extends Namer
           typed(desugar.makeCaseLambda(tree.cases, checkMode, protoFormals.length).withSpan(tree.span), pt)
         }
       case _ =>
+        if tree.isInline then checkInInlineContext("inline match", tree.srcPos)
         val sel1 = typedExpr(tree.selector)
         val selType = fullyDefinedType(sel1.tpe, "pattern selector", tree.span).widen
-        if tree.isInline then checkInInlineContext("inline match", tree.srcPos)
-        else checkScrutable(sel1)
 
         /** Extractor for match types hidden behind an AppliedType/MatchAlias */
         object MatchTypeInDisguise {
@@ -3531,6 +3529,7 @@ class Typer extends Namer
         case _ => pt.isScrutable
 
       if isScrutableTarget && !wtp.derivesFrom(defn.ScrutableClass) then
+        checkScrutable(wtp, tree.srcPos, pattern = false)
         val target = AndType(tree.tpe.widenExpr, defn.ScrutableType)
         if target <:< pt then
           return readapt(tree.cast(target))

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

@@ -164,6 +164,8 @@ class CompilationTests {
       compileFile("tests/neg-custom-args/typeclass-derivation2.scala", defaultOptions.and("-Yerased-terms")),
       compileFile("tests/neg-custom-args/i5498-postfixOps.scala", defaultOptions withoutLanguageFeature "postfixOps"),
       compileFile("tests/neg-custom-args/deptypes.scala", defaultOptions.and("-language:experimental.dependent")),
+      compileFile("tests/neg-custom-args/scrutable.scala", defaultOptions.and("-Xfatal-warnings", "-source", "3.1")),
+      compileFile("tests/neg-custom-args/i7314.scala", defaultOptions.and("-Xfatal-warnings", "-source", "3.1"))
     ).checkExpectedErrors()
   }
 

tests/neg-custom-args/i7314.scala

@@ -0,0 +1,9 @@
+@main def Test =
+  // conversion out of the opaque type:
+  val imm1 = IArray(1,2,3) // supposedly immutable
+  println(imm1(0)) // 1
+  imm1 match {
+    case a: Array[Int] =>  // error: should not be scrutinized
+      a(0) = 0
+  }
+  println(imm1(0)) // 0

tests/neg-custom-args/scrutable.scala

@@ -0,0 +1,27 @@
+def foo[T](x: T): Scrutable =
+  println(x.getClass())   // error: should not be scrutinized
+  println(x.isInstanceOf[Int]) // error: should not be scrutinized
+  x match
+    case x: Int =>   // error: should not be scrutinized
+      println("int")
+      x
+    case x: String =>  // error: should not be scrutinized
+      println("string")
+      x
+  List(x) match
+    case (x: Int) :: Nil =>  // error: should not be scrutinized
+      println("int")
+      x
+    case List(x: String) =>  // error: should not be scrutinized
+      println("string")
+      x
+    case List(y :: Nil) =>  // error: should not be scrutinized
+      y :: Nil
+    case _ =>
+      x   // error: should not be scrutinized
+
+@main def Test =
+  val x: Scrutable = foo(1)
+  val y: Scrutable = foo("hello")
+  assert(x != y)
+

tests/run/scrutable.check

@@ -1,4 +1,8 @@
 class java.lang.Integer
+true
+int
 int
 class java.lang.String
+false
+string
 string

tests/run/scrutable.scala

@@ -1,12 +1,24 @@
-def foo[T](x: Any): Scrutable =
+def foo[T](x: T): Scrutable =
   println(x.getClass())
+  println(x.isInstanceOf[Int])
   x match
     case x: Int =>
       println("int")
       x
     case x: String =>
       println("string")
       x
+  List(x) match
+    case (x: Int) :: Nil =>
+      println("int")
+      x
+    case List(x: String) =>
+      println("string")
+      x
+    case List(y :: Nil) =>
+      y :: Nil
+    case _ =>
+      x
 
 @main def Test =
   val x: Scrutable = foo(1)