Make reporting nicer

Allow use of `result` instead of having to pass a lambda.

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -766,7 +766,7 @@ object desugar {
     }
 
     flatTree(cdef1 :: companions ::: implicitWrappers)
-  }.reporting(res => i"desugared: $res", Printers.desugar)
+  }.reporting(i"desugared: $result", Printers.desugar)
 
   /** Expand
    *

compiler/src/dotty/tools/dotc/core/Decorators.scala

@@ -1,4 +1,5 @@
-package dotty.tools.dotc
+package dotty.tools
+package dotc
 package core
 
 import annotation.tailrec
@@ -168,11 +169,16 @@ object Decorators {
       }
   }
 
-  implicit class genericDeco[T](val x: T) extends AnyVal {
-    def reporting(op: T => String, printer: config.Printers.Printer = config.Printers.default): T = {
-      printer.println(op(x))
+  implicit object reportDeco {
+    def (x: T) reporting[T](
+        op: given WrappedResult[T] => String,
+        printer: config.Printers.Printer = config.Printers.default): T = {
+      printer.println(op given WrappedResult(x))
       x
     }
+  }
+
+  implicit class genericDeco[T](val x: T) extends AnyVal {
     def assertingErrorsReported(implicit ctx: Context): T = {
       assert(ctx.reporter.errorsReported)
       x

compiler/src/dotty/tools/dotc/core/GadtConstraint.scala

@@ -123,9 +123,8 @@ final class ProperGadtConstraint private(
     }
 
     // The replaced symbols are picked up here.
-    addToConstraint(poly1, tvars).reporting({ _ =>
-      i"added to constraint: $params%, %\n$debugBoundsDescription"
-    }, gadts)
+    addToConstraint(poly1, tvars)
+      .reporting(i"added to constraint: $params%, %\n$debugBoundsDescription", gadts)
   }
 
   override def addBound(sym: Symbol, bound: Type, isUpper: Boolean)(implicit ctx: Context): Boolean = {
@@ -159,7 +158,7 @@ final class ProperGadtConstraint private(
           val oldUpperBound = bounds(symTvar.origin)
           // If we have bounds:
           //     F >: [t] => List[t] <: [t] => Any
-          // and we want to record that: 
+          // and we want to record that:
           //     F <: [+A] => List[A]
           // we need to adapt the variance and instead record that:
           //     F <: [A] => List[A]
@@ -177,10 +176,10 @@ final class ProperGadtConstraint private(
           if (isUpper) addUpperBound(symTvar.origin, bound1)
           else addLowerBound(symTvar.origin, bound1)
       }
-    ).reporting({ res =>
+    ).reporting({
       val descr = if (isUpper) "upper" else "lower"
       val op = if (isUpper) "<:" else ">:"
-      i"adding $descr bound $sym $op $bound = $res"
+      i"adding $descr bound $sym $op $bound = $result"
     }, gadts)
   }
 
@@ -206,7 +205,7 @@ final class ProperGadtConstraint private(
             case tb => tb
           }
         retrieveBounds
-          //.reporting({ res => i"gadt bounds $sym: $res" }, gadts)
+          //.reporting(i"gadt bounds $sym: $result", gadts)
           //.ensuring(containsNoInternalTypes(_))
     }
   }

compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala

@@ -548,7 +548,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
         merge(this.boundsMap, that.boundsMap, mergeEntries),
         merge(this.lowerMap, that.lowerMap, mergeParams),
         merge(this.upperMap, that.upperMap, mergeParams))
-  }.reporting(res => i"constraint merge $this with $other = $res", constr)
+  }.reporting(i"constraint merge $this with $other = $result", constr)
 
   def rename(tl: TypeLambda)(implicit ctx: Context): OrderingConstraint = {
     assert(contains(tl))

compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -782,7 +782,7 @@ object Symbols {
               }
             sourceFromTopLevel(ctx.withPhaseNoLater(ctx.flattenPhase))
           }
-        }//.reporting(res => i"source of $this # $id in ${denot.owner} = $res")
+        }//.reporting(i"source of $this # $id in ${denot.owner} = $result")
       mySource
     }
 

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

@@ -628,7 +628,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
           if (idx >= 0 && idx < args.length) {
             def finish(arg: Tree) =
               new TreeTypeMap().transform(arg) // make sure local bindings in argument have fresh symbols
-                .reporting(res => i"projecting $tree -> $res", inlining)
+                .reporting(i"projecting $tree -> $result", inlining)
             val arg = args(idx)
             if (precomputed)
               if (isPureExpr(arg)) finish(arg)

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

@@ -401,7 +401,7 @@ object ProtoTypes {
         resType match {
           case SelectionProto(name: TermName, mbrType, _, _) =>
             ctx.typer.hasExtensionMethod(tp, name, argType, mbrType)
-              //.reporting(res => i"has ext $tp $name $argType $mbrType: $res")
+              //.reporting(i"has ext $tp $name $argType $mbrType: $result")
           case _ =>
             false
         }

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

@@ -2565,7 +2565,7 @@ class Typer extends Namer
               typed(untpd.Select(untpd.New(untpd.TypedSplice(tpt)), nme.CONSTRUCTOR), pt)
           }
           recur(tycon, pt)
-            .reporting(res => i"try new $tree -> $res", typr)
+            .reporting(i"try new $tree -> $result", typr)
         }
       } { (nu, nuState) =>
         if (nu.isEmpty) fallBack

compiler/src/dotty/tools/package.scala

@@ -23,4 +23,12 @@ package object tools {
   /** Throws an `UnsupportedOperationException` with the given method name. */
   def unsupported(methodName: String): Nothing =
     throw new UnsupportedOperationException(methodName)
+
+  object WrappedResult {
+    opaque type Type[T] = T
+    def unwrap[T](x: Type[T]): T = x
+    def apply[T](x: T): Type[T] = x
+  }
+  type WrappedResult[T] = WrappedResult.Type[T]
+  def result[T] given (x: WrappedResult[T]): T = WrappedResult.unwrap(x)
 }