Show level errors before type mismatches

Author: odersky

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

@@ -899,7 +899,7 @@ object Capabilities:
           case _ => c1
 
     def showAsCapability(using Context) =
-      i"capability ${ctx.printer.toTextCapability(this).show}"
+      i"${ctx.printer.toTextCapability(this).show}"
 
     def toText(printer: Printer): Text = printer.toTextCapability(this)
   end Capability

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

@@ -15,6 +15,7 @@ import CaptureSet.VarState
 import Capabilities.*
 import StdNames.nme
 import config.Feature
+import dotty.tools.dotc.core.NameKinds.TryOwnerName
 
 /** Attachment key for capturing type trees */
 private val Captures: Key[CaptureSet] = Key()
@@ -624,9 +625,13 @@ extension (sym: Symbol)
     || sym.info.hasAnnotation(defn.ConsumeAnnot)
 
   def qualString(prefix: String)(using Context): String =
+    if !sym.exists then "" else i" $prefix ${sym.ownerString}"
+
+  def ownerString(using Context): String =
     if !sym.exists then ""
-    else if sym.isAnonymousFunction then i" $prefix enclosing function"
-    else i" $prefix $sym"
+    else if sym.isAnonymousFunction then i"an enclosing function"
+    else if sym.name.is(TryOwnerName) then i"an enclosing try expression"
+    else sym.show
 
 extension (tp: AnnotatedType)
   /** Is this a boxed capturing type? */

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

@@ -1324,12 +1324,25 @@ object CaptureSet:
       res.myTrace = cs1 :: this.myTrace
       res
 
-    def render(using Context) =
+    override def prefix(using Context) = cs match
+      case cs: Var =>
+        !cs.levelOK(elem)
+        || cs.isBadRoot(elem) && elem.isInstanceOf[FreshCap]
+      case _ =>
+        false
+
+    def trailing(msg: String)(using Context): String =
       i"""
          |
-         |Note that $description."""
+         |Note that $msg."""
 
-    private def description(using Context): String =
+    def leading(msg: String)(using Context): String =
+      i"""$msg.
+         |The leakage occurred when trying to match the following types:
+         |
+         |"""
+
+    def render(using Context): String =
       def why =
         val reasons = cs.elems.toList.collect:
           case c: FreshCap if !c.acceptsLevelOf(elem) =>
@@ -1340,27 +1353,33 @@ object CaptureSet:
         else reasons.mkString("\nbecause ", "\nand ", "")
       cs match
         case cs: Var =>
+          def ownerStr =
+            if !cs.description.isEmpty then "" else cs.owner.qualString("which is owned by")
           if !cs.levelOK(elem) then
-            val levelStr = elem match
-              case ref: TermRef => i", defined in ${ref.symbol.maybeOwner}\n"
-              case _ => " "
-            val ownerStr =
-              if cs.owner.exists then s" which is owned by ${cs.owner}" else ""
-            i"""${elem.showAsCapability}${levelStr}cannot be included in outer capture set $cs$ownerStr"""
+            val outlivesStr = elem match
+              case ref: TermRef => i"${ref.symbol.maybeOwner.qualString("defined in")} outlives its scope:\n"
+              case _ => " outlives its scope: "
+            leading:
+              i"""Capability ${elem.showAsCapability}${outlivesStr}it leaks into outer capture set $cs$ownerStr"""
           else if !elem.tryClassifyAs(cs.classifier) then
-            i"""${elem.showAsCapability} is not classified as ${cs.classifier}, therefore it
+            trailing:
+              i"""capability ${elem.showAsCapability} is not classified as ${cs.classifier}, therefore it
                 |cannot be included in capture set $cs of ${cs.classifier.name} elements"""
           else if cs.isBadRoot(elem) then
             elem match
               case elem: FreshCap =>
-                i"""local ${elem.showAsCapability} created in ${elem.ccOwner}
-                  |cannot be included in outer capture set $cs"""
+                leading:
+                  i"""Local capability ${elem.showAsCapability} created in ${elem.ccOwner} outlives its scope:
+                     |It leaks into outer capture set $cs$ownerStr"""
               case _ =>
-                i"universal ${elem.showAsCapability} cannot be included in capture set $cs"
+                trailing:
+                  i"universal capability ${elem.showAsCapability} cannot be included in capture set $cs"
           else
-            i"${elem.showAsCapability} cannot be included in capture set $cs"
+            trailing:
+              i"capability ${elem.showAsCapability} cannot be included in capture set $cs"
         case _ =>
-          i"${elem.showAsCapability} is not included in capture set $cs$why"
+          trailing:
+            i"capability ${elem.showAsCapability} is not included in capture set $cs$why"
 
     override def toText(printer: Printer): Text =
       inContext(printer.printerContext):

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

@@ -201,9 +201,6 @@ object CheckCaptures:
     && !sym.isOneOf(DeferredOrTermParamOrAccessor)
     && !sym.hasAnnotation(defn.UntrackedCapturesAnnot)
 
-  private def ownerStr(owner: Symbol)(using Context): String =
-    if owner.isAnonymousFunction then "enclosing function" else owner.show
-
   trait CheckerAPI:
     /** Complete symbol info of a val or a def */
     def completeDef(tree: ValOrDefDef, sym: Symbol, completer: LazyType)(using Context): Type

compiler/src/dotty/tools/dotc/reporting/Message.scala

@@ -42,11 +42,18 @@ object Message:
     else ""
 
   /** A note can produce an added string for an error message */
-  abstract class Note(val prefix: Boolean = false):
+  abstract class Note:
+  
+  	/** Should the note be shown before the actual message or after?
+  	 *  Default is after.
+  	 */
+    def prefix(using Context): Boolean = false
+
+    /** The note rendered as part of an error message */
     def render(using Context): String
 
   object Note:
-    def apply(msg: Context ?=> String, prefix: Boolean = false) = new Note(prefix):
+    def apply(msg: Context ?=> String) = new Note:
       def render(using Context) = msg
 
   enum Disambiguation:

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -343,23 +343,23 @@ class TypeMismatch(val found: Type, expected: Type, val inTree: Option[untpd.Tre
           mapOver(tp)
         case _ =>
           mapOver(tp)
-
+    val preface = notes.filter(_.prefix).map(_.render).mkString
     val found1 = reported(found)
     reported.setVariance(-1)
     val expected1 = reported(expected)
     val (found2, expected2) =
       if (found1 frozen_<:< expected1) || reported.fbounded then (found, expected)
       else (found1, expected1)
     val (foundStr, expectedStr) = Formatting.typeDiff(found2.normalized, expected2.normalized)
-    i"""|Found:    $foundStr
+    i"""|${preface}Found:    $foundStr
         |Required: $expectedStr${reported.notes}"""
   end msg
 
   override def msgPostscript(using Context): String =
     def importSuggestions =
       if expected.isTopType || found.isBottomType then ""
       else ctx.typer.importSuggestionAddendum(ViewProto(found.widen, expected))
-    notes.map(_.render).mkString ++ super.msgPostscript ++ importSuggestions
+    notes.filter(!_.prefix).map(_.render).mkString ++ super.msgPostscript ++ importSuggestions
 
   override def explain(using Context) =
     val treeStr = inTree.map(x => s"\nTree:\n\n${x.show}\n").getOrElse("")

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

@@ -2,11 +2,12 @@
  4 |  boundary[AnyRef^]:
  5 |    l1 ?=> // error // error
    |  ^
+   |  Capability cap outlives its scope: it leaks into outer capture set 's1 which is owned by value local.
+   |  The leakage occurred when trying to match the following types:
+   |
    |  Found:    scala.util.boundary.Label[Object^'s1]
    |  Required: scala.util.boundary.Label[Object^]^²
    |
-   |  Note that capability cap cannot be included in outer capture set 's1 which is owned by val local.
-   |
    |  where:    ^ and cap refer to the universal root capability
    |            ^²        refers to a fresh root capability classified as Control in the type of value local
  6 |      boundary[Unit]: l2 ?=>

tests/neg-custom-args/captures/effect-swaps-explicit.check

@@ -19,10 +19,11 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/effect-swaps-explicit.scala:69:10 ------------------------
 69 |          Future: fut ?=> // error, type mismatch
    |          ^
-   |Found:    (contextual$9: boundary.Label[Result[Future[T^'s2]^'s3, E^'s4]^'s5]^'s6) ?->{fr, async} Future[T^'s7]^{fr, contextual$9}
-   |Required: (boundary.Label[Result[Future[T^'s8]^'s9, E^'s10]]^) ?=> Future[T^'s8]^'s9
+   |Capability contextual$9 outlives its scope: it leaks into outer capture set 's2 which is owned by method fail4.
+   |The leakage occurred when trying to match the following types:
    |
-   |Note that capability contextual$9 cannot be included in outer capture set 's9 which is owned by method fail4.
+   |Found:    (contextual$9: boundary.Label[Result[Future[T^'s3]^'s4, E^'s5]^'s6]^'s7) ?->{fr, async} Future[T^'s8]^{fr, contextual$9}
+   |Required: (boundary.Label[Result[Future[T^'s9]^'s2, E^'s10]]^) ?=> Future[T^'s9]^'s2
    |
    |where:    ?=> refers to a fresh root capability created in method fail4 when checking argument to parameter body of method make
    |          ^   refers to the universal root capability

tests/neg-custom-args/captures/effect-swaps.check

@@ -19,10 +19,11 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/effect-swaps.scala:69:10 ---------------------------------
 69 |          Future: fut ?=> // error, type mismatch
    |          ^
-   |Found:    (contextual$9: boundary.Label[Result[Future[T^'s2]^'s3, E^'s4]^'s5]^'s6) ?->{fr, async} Future[T^'s7]^{fr, contextual$9}
-   |Required: (boundary.Label[Result[Future[T^'s8]^'s9, E^'s10]]^) ?=> Future[T^'s8]^'s9
+   |Capability contextual$9 outlives its scope: it leaks into outer capture set 's2 which is owned by method fail4.
+   |The leakage occurred when trying to match the following types:
    |
-   |Note that capability contextual$9 cannot be included in outer capture set 's9 which is owned by method fail4.
+   |Found:    (contextual$9: boundary.Label[Result[Future[T^'s3]^'s4, E^'s5]^'s6]^'s7) ?->{fr, async} Future[T^'s8]^{fr, contextual$9}
+   |Required: (boundary.Label[Result[Future[T^'s9]^'s2, E^'s10]]^) ?=> Future[T^'s9]^'s2
    |
    |where:    ?=> refers to a fresh root capability created in method fail4 when checking argument to parameter body of method make
    |          ^   refers to the universal root capability

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

@@ -1,10 +1,11 @@
 -- [E007] Type Mismatch Error: tests/neg-custom-args/captures/filevar.scala:15:12 --------------------------------------
 15 |  withFile: f =>       // error with level checking, was OK under both schemes before
    |            ^
-   |Found:    (l: scala.caps.Capability^) ?->'s1 File^'s2 ->'s3 Unit
-   |Required: (l: scala.caps.Capability^) ?-> (f: File^{l}) => Unit
+   |Capability l outlives its scope: it leaks into outer capture set 's1 of parameter f.
+   |The leakage occurred when trying to match the following types:
    |
-   |Note that capability l cannot be included in outer capture set 's4 of parameter f which is owned by method $anonfun.
+   |Found:    (l: scala.caps.Capability^) ?->'s2 File^'s3 ->'s4 Unit
+   |Required: (l: scala.caps.Capability^) ?-> (f: File^{l}) => Unit
    |
    |where:    => refers to a root capability associated with the result type of (using l: scala.caps.Capability^): (f: File^{l}) => Unit
    |          ^  refers to the universal root capability