Improve error message

Author: odersky

compiler/src/dotty/tools/dotc/cc/CaptureOps.scala

@@ -422,6 +422,10 @@ extension (tp: Type)
           mapOver(t)
     tm(tp)
 
+  def hasUseAnnot(using Context): Boolean = tp match
+    case AnnotatedType(_, ann) => ann.symbol == defn.UseAnnot
+    case _ => false
+
   /** If `x` is a capture ref, its maybe capability `x?`, represented internally
    *  as `x @maybeCapability`. `x?` stands for a capability `x` that might or might
    *  not be part of a capture set. We have `{} <: {x?} <: {x}`. Maybe capabilities

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -245,6 +245,13 @@ object CheckCaptures:
        *  a separation check?
        */
       def needsSepCheck: Boolean
+
+      /** If a tree is an argument for which needsSepCheck is true,
+       *  the actual type of the argument before it was widened to formal.
+       *  The nuType of this argument is the formal parameter type in this case,
+       *  but for error diagnosis it's important to know what the actual type was.
+       */
+      def actualType: Type
   end CheckerAPI
 
 class CheckCaptures extends Recheck, SymTransformer:
@@ -285,11 +292,14 @@ class CheckCaptures extends Recheck, SymTransformer:
      */
     private val todoAtPostCheck = new mutable.ListBuffer[() => Unit]
 
-    /** Trees that will need a separation check because they contain cap */
-    private val sepCheckable = util.EqHashSet[Tree]()
+    /** Maps trees that will need a separation check because they contain cap
+     *  to the actual, non-widened type.
+     */
+    private val sepCheckable = util.EqHashMap[Tree, Type]()
 
     extension [T <: Tree](tree: T)
       def needsSepCheck: Boolean = sepCheckable.contains(tree)
+      def actualType: Type = sepCheckable.getOrElse(tree, NoType)
 
     /** Instantiate capture set variables appearing contra-variantly to their
      *  upper approximation.
@@ -666,15 +676,13 @@ class CheckCaptures extends Recheck, SymTransformer:
       val freshenedFormal = Fresh.fromCap(formal)
       val argType = recheck(arg, freshenedFormal)
         .showing(i"recheck arg $arg vs $freshenedFormal", capt)
-      formal match
-        case AnnotatedType(formal1, ann) if ann.symbol == defn.UseAnnot =>
-          // The UseAnnot is added to `formal` by `prepareFunction`
-          capt.println(i"charging deep capture set of $arg: ${argType} = ${argType.deepCaptureSet}")
-          markFree(argType.deepCaptureSet, arg.srcPos)
-        case _ =>
+      if formal.hasUseAnnot then
+        // The @use annotation is added to `formal` by `prepareFunction`
+        capt.println(i"charging deep capture set of $arg: ${argType} = ${argType.deepCaptureSet}")
+        markFree(argType.deepCaptureSet, arg.srcPos)
       if formal.containsCap then
         arg.updNuType(freshenedFormal)
-        sepCheckable += arg
+        sepCheckable(arg) = argType
       argType
 
     /** Map existential captures in result to `cap` and implement the following
@@ -704,9 +712,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       val qualCaptures = qualType.captureSet
       val argCaptures =
         for (argType, formal) <- argTypes.lazyZip(funType.paramInfos) yield
-          formal match
-            case AnnotatedType(_, ann) if ann.symbol == defn.UseAnnot => argType.deepCaptureSet
-            case _ => argType.captureSet
+          if formal.hasUseAnnot then argType.deepCaptureSet else argType.captureSet
       appType match
         case appType @ CapturingType(appType1, refs)
         if qualType.exists

compiler/src/dotty/tools/dotc/cc/SepCheck.scala

@@ -61,11 +61,7 @@ class SepChecker(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
 
     def captures(arg: Tree) =
       val argType = arg.nuType
-      argType match
-        case AnnotatedType(formal1, ann) if ann.symbol == defn.UseAnnot =>
-          argType.deepCaptureSet
-        case _ =>
-          argType.captureSet
+      if argType.hasUseAnnot then argType.deepCaptureSet else argType.captureSet
 
     val argCaptures = args.map(captures)
     capt.println(i"check separate $fn($args), fnCaptures = $fnCaptures, argCaptures = $argCaptures")
@@ -80,13 +76,14 @@ class SepChecker(checker: CheckCaptures.CheckerAPI) extends tpd.TreeTraverser:
         //println(i"check sep $arg / $footprint / $hiddenInArg")
         val overlap = hiddenInArg.footprint.overlapWith(footprint)
         if !overlap.isEmpty then
+          def formalName = if pname.toString.contains('$') then "" else i"$pname "
           def whatStr = if overlap.size == 1 then "this capability" else "these capabilities"
           def funStr =
             if fn.symbol.exists then i"${fn.symbol}"
             else "the function"
           report.error(
-            em"""Separation failure: argument to capture-polymorphic parameter $pname: ${arg.nuType}
-                |captures ${CaptureSet(overlap)} and also passes $whatStr separately to $funStr""",
+            em"""Separation failure: argument of type ${arg.actualType} to capture-polymorphic parameter
+                |${formalName}of type ${arg.nuType} captures ${CaptureSet(overlap)}, and $whatStr is also passed separately to $funStr.""",
             arg.srcPos)
         footprint ++= hiddenInArg
 

tests/neg-custom-args/captures/cc-dep-param.check

@@ -1,5 +1,5 @@
 -- Error: tests/neg-custom-args/captures/cc-dep-param.scala:8:6 --------------------------------------------------------
 8 |  foo(a, useA) // error: separation failure
   |      ^
-  |      Separation failure: argument to capture-polymorphic parameter x$0: Foo[Int]^
-  |      captures {a} and also passes this capability separately to method foo
+  |      Separation failure: argument of type (a : Foo[Int]^) to capture-polymorphic parameter
+  |      of type Foo[Int]^ captures {a}, and this capability is also passed separately to method foo.

tests/neg-custom-args/captures/filevar-expanded.check

@@ -1,8 +1,8 @@
 -- Error: tests/neg-custom-args/captures/filevar-expanded.scala:34:19 --------------------------------------------------
 34 |    withFile(io3): f => // error: separation failure
    |                   ^
-   |                Separation failure: argument to capture-polymorphic parameter x$1: (f: test2.File^{io3}) => Unit
-   |                captures {io3} and also passes this capability separately to method withFile
+   |Separation failure: argument of type (f: test2.File^{io3}) ->{io3} Unit to capture-polymorphic parameter
+   |of type (f: test2.File^{io3}) => Unit captures {io3}, and this capability is also passed separately to method withFile.
 35 |      val o = Service(io3)
 36 |      o.file = f  // this is a bit dubious. It's legal since we treat class refinements
 37 |                  // as capture set variables that can be made to include refs coming from outside.

tests/neg-custom-args/captures/function-combinators.check

@@ -1,5 +1,5 @@
 -- Error: tests/neg-custom-args/captures/function-combinators.scala:15:22 ----------------------------------------------
 15 |  val b2 = g1.andThen(g1); // error: separation failure
    |                      ^^
-   |                      Separation failure: argument to capture-polymorphic parameter x$0: Int => Int
-   |                      captures {ctx1} and also passes this capability separately to method andThen
+   |            Separation failure: argument of type (g1 : Int ->{ctx1} Int) to capture-polymorphic parameter
+   |            of type Int => Int captures {ctx1}, and this capability is also passed separately to method andThen.

tests/neg-custom-args/captures/lazyref.check

@@ -29,5 +29,5 @@
 -- Error: tests/neg-custom-args/captures/lazyref.scala:24:55 -----------------------------------------------------------
 24 |  val ref4 = (if cap1 == cap2 then ref1 else ref2).map(g) // error: separation failure
    |                                                       ^
-   |                                   Separation failure: argument to capture-polymorphic parameter x$0: Int => Int
-   |                                   captures {cap2} and also passes this capability separately to method map
+   |                Separation failure: argument of type (x: Int) ->{cap2} Int to capture-polymorphic parameter
+   |                of type Int => Int captures {cap2}, and this capability is also passed separately to method map.