Merge branch 'emit-deferred-reachability-warnings' into check-ordinal-match

* emit-deferred-reachability-warnings:
  Restore adaptType, with expanded its docs & tests
  Avoid generating skolems just to return true
  Simplify adaptType by introducing unboxedType
  Update checkfiles is success & rm out file
  Redo & organise adaptType in SpaceEngine
  Emit deferred reachability warnings
  Fix typo
  Make trace typed, to avoid needless casting
  Revert "Bump tasty to 28.3-1"
  Dedupe ConsoleReporter & ReplConsoleReporter
  Implement ReplConsoleReporter in terms of the ReplDriver `out` PrintStream
  Fix and reinstate repl/errmsgs
  Fix printing refined self-types

Author: dwijnand

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

@@ -1731,6 +1731,20 @@ class Definitions {
     else sys.error(s"Not a primitive value type: $tp")
   }.typeRef
 
+  def unboxedType(tp: Type)(using Context): TypeRef = {
+    val cls = tp.classSymbol
+    if (cls eq BoxedByteClass)         ByteType
+    else if (cls eq BoxedShortClass)   ShortType
+    else if (cls eq BoxedCharClass)    CharType
+    else if (cls eq BoxedIntClass)     IntType
+    else if (cls eq BoxedLongClass)    LongType
+    else if (cls eq BoxedFloatClass)   FloatType
+    else if (cls eq BoxedDoubleClass)  DoubleType
+    else if (cls eq BoxedUnitClass)    UnitType
+    else if (cls eq BoxedBooleanClass) BooleanType
+    else sys.error(s"Not a boxed primitive value type: $tp")
+  }
+
   /** The JVM tag for `tp` if it's a primitive, `java.lang.Object` otherwise. */
   def typeTag(tp: Type)(using Context): Name = typeTags(scalaClassName(tp))
 

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

@@ -12,27 +12,30 @@ import Diagnostic.{ Error, ConditionalWarning }
 class ConsoleReporter(
   reader: BufferedReader = Console.in,
   writer: PrintWriter = new PrintWriter(Console.err, true)
-) extends AbstractReporter {
+) extends ConsoleReporter.AbstractConsoleReporter {
+  override def printMessage(msg: String): Unit = { writer.print(msg + "\n"); writer.flush() }
+  override def flush()(using Context): Unit    = writer.flush()
 
-  import Diagnostic._
-
-  /** Prints the message. */
-  def printMessage(msg: String): Unit = { writer.print(msg + "\n"); writer.flush() }
-
-  /** Prints the message with the given position indication. */
-  def doReport(dia: Diagnostic)(using Context): Unit = {
+  override def doReport(dia: Diagnostic)(using Context): Unit = {
+    super.doReport(dia)
     dia match
-      case dia: Error =>
-        printMessage(messageAndPos(dia))
-        if (ctx.settings.Xprompt.value) Reporter.displayPrompt(reader, writer)
-      case dia =>
-        printMessage(messageAndPos(dia))
-
-    if shouldExplain(dia) then
-      printMessage(explanation(dia.msg))
-    else if dia.msg.canExplain then
-      printMessage("\nlonger explanation available when compiling with `-explain`")
+      case dia: Error if ctx.settings.Xprompt.value => Reporter.displayPrompt(reader, writer)
+      case _                                        =>
   }
+}
+
+object ConsoleReporter {
+  abstract class AbstractConsoleReporter extends AbstractReporter {
+    /** Prints the message. */
+    def printMessage(msg: String): Unit
 
-  override def flush()(using Context): Unit = { writer.flush() }
+    /** Prints the message with the given position indication. */
+    def doReport(dia: Diagnostic)(using Context): Unit = {
+      printMessage(messageAndPos(dia))
+      if Diagnostic.shouldExplain(dia) then
+        printMessage(explanation(dia.msg))
+      else if dia.msg.canExplain then
+        printMessage("\nlonger explanation available when compiling with `-explain`")
+    }
+  }
 }

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

@@ -33,7 +33,7 @@ trait TraceSyntax:
       apply(question, if cond then Printers.default else Printers.noPrinter, show)(op)
     else op
 
-  inline def apply[T](inline question: String, inline printer: Printers.Printer, inline showOp: Any => String)(inline op: T)(using Context): T =
+  inline def apply[T, U >: T](inline question: String, inline printer: Printers.Printer, inline showOp: U => String)(inline op: T)(using Context): T =
     inline if isEnabled then
       doTrace[T](question, printer, showOp)(op)
     else op
@@ -60,15 +60,15 @@ trait TraceSyntax:
 
   private def doTrace[T](question: => String,
                          printer: Printers.Printer = Printers.default,
-                         showOp: Any => String = alwaysToString)
+                         showOp: T => String = alwaysToString)
                         (op: => T)(using Context): T =
     if ctx.mode.is(Mode.Printing) || !isForced && (printer eq Printers.noPrinter) then op
     else
       // Avoid evaluating question multiple time, since each evaluation
       // may cause some extra logging output.
       val q = question
       val leading = s"==> $q?"
-      val trailing = (res: Any) => s"<== $q = ${showOp(res)}"
+      val trailing = (res: T) => s"<== $q = ${showOp(res)}"
       var finalized = false
       var logctx = ctx
       while logctx.reporter.isInstanceOf[StoreReporter] do logctx = logctx.outer

compiler/src/dotty/tools/dotc/transform/init/Semantic.scala

@@ -321,7 +321,7 @@ class Semantic {
     def widenArgs: List[Value] = values.map(_.widenArg).toList
 
   extension (value: Value)
-    def select(field: Symbol, source: Tree, needResolve: Boolean = true): Contextual[Result] = log("select " + field.show, printer, res => res.asInstanceOf[Result].show) {
+    def select(field: Symbol, source: Tree, needResolve: Boolean = true): Contextual[Result] = log("select " + field.show, printer, (_: Result).show) {
       if promoted.isCurrentObjectPromoted then Result(Hot, Nil)
       else value match {
         case Hot  =>
@@ -371,7 +371,7 @@ class Semantic {
       }
     }
 
-    def call(meth: Symbol, args: List[ArgInfo], superType: Type, source: Tree, needResolve: Boolean = true): Contextual[Result] = log("call " + meth.show + ", args = " + args, printer, res => res.asInstanceOf[Result].show) {
+    def call(meth: Symbol, args: List[ArgInfo], superType: Type, source: Tree, needResolve: Boolean = true): Contextual[Result] = log("call " + meth.show + ", args = " + args, printer, (_: Result).show) {
       def checkArgs = args.flatMap(_.promote)
 
       // fast track if the current object is already initialized
@@ -445,7 +445,7 @@ class Semantic {
     }
 
     /** Handle a new expression `new p.C` where `p` is abstracted by `value` */
-    def instantiate(klass: ClassSymbol, ctor: Symbol, args: List[ArgInfo], source: Tree): Contextual[Result] = log("instantiating " + klass.show + ", value = " + value + ", args = " + args, printer, res => res.asInstanceOf[Result].show) {
+    def instantiate(klass: ClassSymbol, ctor: Symbol, args: List[ArgInfo], source: Tree): Contextual[Result] = log("instantiating " + klass.show + ", value = " + value + ", args = " + args, printer, (_: Result).show) {
       val trace1 = trace.add(source)
       if promoted.isCurrentObjectPromoted then Result(Hot, Nil)
       else value match {
@@ -702,7 +702,7 @@ class Semantic {
    *
    *  This method only handles cache logic and delegates the work to `cases`.
    */
-  def eval(expr: Tree, thisV: Addr, klass: ClassSymbol, cacheResult: Boolean = false): Contextual[Result] = log("evaluating " + expr.show + ", this = " + thisV.show, printer, res => res.asInstanceOf[Result].show) {
+  def eval(expr: Tree, thisV: Addr, klass: ClassSymbol, cacheResult: Boolean = false): Contextual[Result] = log("evaluating " + expr.show + ", this = " + thisV.show, printer, (_: Result).show) {
     val innerMap = cache.getOrElseUpdate(thisV, new EqHashMap[Tree, Value])
     if (innerMap.contains(expr)) Result(innerMap(expr), Errors.empty)
     else {
@@ -911,7 +911,7 @@ class Semantic {
     }
 
   /** Handle semantics of leaf nodes */
-  def cases(tp: Type, thisV: Addr, klass: ClassSymbol, source: Tree): Contextual[Result] = log("evaluating " + tp.show, printer, res => res.asInstanceOf[Result].show) {
+  def cases(tp: Type, thisV: Addr, klass: ClassSymbol, source: Tree): Contextual[Result] = log("evaluating " + tp.show, printer, (_: Result).show) {
     tp match {
       case _: ConstantType =>
         Result(Hot, Errors.empty)
@@ -941,7 +941,7 @@ class Semantic {
   }
 
   /** Resolve C.this that appear in `klass` */
-  def resolveThis(target: ClassSymbol, thisV: Value, klass: ClassSymbol, source: Tree): Contextual[Value] = log("resolving " + target.show + ", this = " + thisV.show + " in " + klass.show, printer, res => res.asInstanceOf[Value].show) {
+  def resolveThis(target: ClassSymbol, thisV: Value, klass: ClassSymbol, source: Tree): Contextual[Value] = log("resolving " + target.show + ", this = " + thisV.show + " in " + klass.show, printer, (_: Value).show) {
     if target == klass then thisV
     else if target.is(Flags.Package) then Hot
     else
@@ -969,7 +969,7 @@ class Semantic {
    *
    *  See `tpd.outerSelect` and `ElimOuterSelect`.
    */
-  def resolveOuterSelect(target: ClassSymbol, thisV: Value, hops: Int, source: Tree): Contextual[Value] = log("resolving outer " + target.show + ", this = " + thisV.show + ", hops = " + hops, printer, res => res.asInstanceOf[Value].show) {
+  def resolveOuterSelect(target: ClassSymbol, thisV: Value, hops: Int, source: Tree): Contextual[Value] = log("resolving outer " + target.show + ", this = " + thisV.show + ", hops = " + hops, printer, (_: Value).show) {
     // Is `target` reachable from `cls` with the given `hops`?
     def reachable(cls: ClassSymbol, hops: Int): Boolean =
       if hops == 0 then cls == target
@@ -1011,7 +1011,7 @@ class Semantic {
       else cases(tref.prefix, thisV, klass, source)
 
   /** Initialize part of an abstract object in `klass` of the inheritance chain */
-  def init(tpl: Template, thisV: Addr, klass: ClassSymbol): Contextual[Result] = log("init " + klass.show, printer, res => res.asInstanceOf[Result].show) {
+  def init(tpl: Template, thisV: Addr, klass: ClassSymbol): Contextual[Result] = log("init " + klass.show, printer, (_: Result).show) {
     val errorBuffer = new mutable.ArrayBuffer[Error]
 
     val paramsMap = tpl.constr.termParamss.flatten.map { vdef =>

compiler/src/dotty/tools/dotc/transform/patmat/Space.scala

@@ -114,7 +114,7 @@ trait SpaceLogic {
   def show(sp: Space): String
 
   /** Simplify space such that a space equal to `Empty` becomes `Empty` */
-  def simplify(space: Space)(using Context): Space = trace(s"simplify ${show(space)} --> ", debug, x => show(x.asInstanceOf[Space]))(space match {
+  def simplify(space: Space)(using Context): Space = trace(s"simplify ${show(space)} --> ", debug, show)(space match {
     case Prod(tp, fun, spaces) =>
       val sps = spaces.map(simplify(_))
       if (sps.contains(Empty)) Empty
@@ -194,7 +194,7 @@ trait SpaceLogic {
   }
 
   /** Intersection of two spaces  */
-  def intersect(a: Space, b: Space)(using Context): Space = trace(s"${show(a)} & ${show(b)}", debug, x => show(x.asInstanceOf[Space])) {
+  def intersect(a: Space, b: Space)(using Context): Space = trace(s"${show(a)} & ${show(b)}", debug, show) {
     def tryDecompose1(tp: Type) = intersect(Or(decompose(tp)), b)
     def tryDecompose2(tp: Type) = intersect(a, Or(decompose(tp)))
 
@@ -226,7 +226,7 @@ trait SpaceLogic {
   }
 
   /** The space of a not covered by b */
-  def minus(a: Space, b: Space)(using Context): Space = trace(s"${show(a)} - ${show(b)}", debug, x => show(x.asInstanceOf[Space])) {
+  def minus(a: Space, b: Space)(using Context): Space = trace(s"${show(a)} - ${show(b)}", debug, show) {
     def tryDecompose1(tp: Type) = minus(Or(decompose(tp)), b)
     def tryDecompose2(tp: Type) = minus(a, Or(decompose(tp)))
 
@@ -512,23 +512,28 @@ class SpaceEngine(using Context) extends SpaceLogic {
       if converted == null then tp else ConstantType(converted)
     case _ => tp
 
-  /** Adapt types by performing primitive value boxing.  #12805 */
-  def maybeBox(tp1: Type, tp2: Type): Type =
-    if tp1.classSymbol.isPrimitiveValueClass && !tp2.classSymbol.isPrimitiveValueClass then
-      defn.boxedType(tp1).narrow
-    else tp1
+  def isPrimToBox(tp: Type, pt: Type) =
+    tp.classSymbol.isPrimitiveValueClass && (defn.boxedType(tp).classSymbol eq pt.classSymbol)
+
+  /** Adapt types by performing primitive value unboxing or boxing, or numeric constant conversion.  #12805
+   *
+   *  This makes these isSubType cases work like this:
+   *  {{{
+   *   1      <:< Integer  => (<skolem> : Integer) <:< Integer  = true
+   *  ONE     <:< Int      => (<skolem> : Int)     <:< Int      = true
+   *  Integer <:< (1: Int) => (<skolem> : Int)     <:< (1: Int) = false
+   *  }}}
+   */
+  def adaptType(tp1: Type, tp2: Type): Type = trace(i"adaptType($tp1, $tp2)", show = true) {
+    if      isPrimToBox(tp1, tp2) then defn.boxedType(tp1).narrow
+    else if isPrimToBox(tp2, tp1) then defn.unboxedType(tp1).narrow
+    else convertConstantType(tp1, tp2)
+  }
 
   /** Is `tp1` a subtype of `tp2`?  */
-  def isSubType(_tp1: Type, tp2: Type): Boolean = {
-    val tp1 = maybeBox(convertConstantType(_tp1, tp2), tp2)
-    //debug.println(TypeComparer.explained(_.isSubType(tp1, tp2)))
-    val res = if (ctx.explicitNulls) {
-      tp1 <:< tp2
-    } else {
-      (tp1 != constantNullType || tp2 == constantNullType) && tp1 <:< tp2
-    }
-    debug.println(i"$tp1 <:< $tp2 = $res")
-    res
+  def isSubType(tp1: Type, tp2: Type): Boolean = trace(i"$tp1 <:< $tp2", debug, show = true) {
+    if tp1 == constantNullType && !ctx.explicitNulls then tp2 == constantNullType
+    else adaptType(tp1, tp2) <:< tp2
   }
 
   def isSameUnapply(tp1: TermRef, tp2: TermRef): Boolean =
@@ -900,7 +905,9 @@ class SpaceEngine(using Context) extends SpaceLogic {
   def checkRedundancy(_match: Match): Unit = {
     debug.println(s"---------------checking redundant patterns ${_match.show}")
 
-    val Match(sel, cases) = _match
+    val Match(sel, _) = _match
+    val cases = _match.cases.toIndexedSeq
+
     val selTyp = sel.tpe.widen.dealias
 
     if (!redundancyCheckable(sel)) return
@@ -911,7 +918,14 @@ class SpaceEngine(using Context) extends SpaceLogic {
       else project(selTyp)
     debug.println(s"targetSpace: ${show(targetSpace)}")
 
-    cases.iterator.zipWithIndex.foldLeft(Nil: List[Space]) { case (prevs, (CaseDef(pat, guard, _), i)) =>
+    var i        = 0
+    val len      = cases.length
+    var prevs    = List.empty[Space]
+    var deferred = List.empty[Tree]
+
+    while (i < len) {
+      val CaseDef(pat, guard, _) = cases(i)
+
       debug.println(i"case pattern: $pat")
 
       val curr = project(pat)
@@ -923,18 +937,24 @@ class SpaceEngine(using Context) extends SpaceLogic {
       val covered = simplify(intersect(curr, targetSpace))
       debug.println(s"covered: ${show(covered)}")
 
-      if pat != EmptyTree // rethrow case of catch uses EmptyTree
-        && prev != Empty // avoid isSubspace(Empty, Empty) - one of the previous cases much be reachable
-        && isSubspace(covered, prev)
-      then {
-        if isNullable && i == cases.length - 1 && isWildcardArg(pat) then
-          report.warning(MatchCaseOnlyNullWarning(), pat.srcPos)
-        else
+      if prev == Empty && covered == Empty then // defer until a case is reachable
+        deferred ::= pat
+      else {
+        for (pat <- deferred.reverseIterator)
           report.warning(MatchCaseUnreachable(), pat.srcPos)
+        if pat != EmptyTree // rethrow case of catch uses EmptyTree
+            && isSubspace(covered, prev)
+        then {
+          val nullOnly = isNullable && i == len - 1 && isWildcardArg(pat)
+          val msg = if nullOnly then MatchCaseOnlyNullWarning() else MatchCaseUnreachable()
+          report.warning(msg, pat.srcPos)
+        }
+        deferred = Nil
       }
 
       // in redundancy check, take guard as false in order to soundly approximate
-      (if guard.isEmpty then covered else Empty) :: prevs
+      prevs ::= (if guard.isEmpty then covered else Empty)
+      i += 1
     }
   }
 }

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

@@ -80,7 +80,7 @@ object PrepareInlineable {
       def preTransform(tree: Tree)(using Context): Tree = tree match {
         case tree: RefTree if needsAccessor(tree.symbol) =>
           if (tree.symbol.isConstructor) {
-            report.error("Implementation restriction: cannot use private constructors in inlineinline methods", tree.srcPos)
+            report.error("Implementation restriction: cannot use private constructors in inline methods", tree.srcPos)
             tree // TODO: create a proper accessor for the private constructor
           }
           else useAccessor(tree)

compiler/src/dotty/tools/repl/ReplDriver.scala

@@ -1,6 +1,6 @@
 package dotty.tools.repl
 
-import java.io.{File => JFile, PrintStream, PrintWriter}
+import java.io.{File => JFile, PrintStream}
 import java.nio.charset.StandardCharsets
 
 import dotty.tools.dotc.ast.Trees._
@@ -425,12 +425,12 @@ class ReplDriver(settings: Array[String],
     state
   }
 
-  /** Like ConsoleReporter, but without file paths or real -Xprompt'ing */
-  private object ReplConsoleReporter extends ConsoleReporter(
-    reader = null, // this short-circuits the -Xprompt display from waiting for an input
-    writer = new PrintWriter(out, /* autoFlush = */ true), // write to out, not Console.err
-  ) {
+  /** Like ConsoleReporter, but without file paths, -Xprompt displaying,
+   *  and using a PrintStream rather than a PrintWriter so messages aren't re-encoded. */
+  private object ReplConsoleReporter extends ConsoleReporter.AbstractConsoleReporter {
     override def posFileStr(pos: SourcePosition) = "" // omit file paths
+    override def printMessage(msg: String): Unit = out.println(msg)
+    override def flush()(using Context): Unit    = out.flush()
   }
 
   /** Print warnings & errors using ReplConsoleReporter, and info straight to out */

compiler/test-resources/pending/repl/errmsgs renamed to compiler/test-resources/repl/errmsgs

@@ -51,19 +51,19 @@ scala> abstract class C { type T; val x: T; val s: Unit = { type T = String; var
 1 | abstract class C { type T; val x: T; val s: Unit = { type T = String; var y: T = x; locally { def f() = { type T = Int; val z: T = y }; f() } }; }
   |                                                                                  ^
   |Found:    (C.this.x : C.this.T)
-  |Required: T?
+  |Required: T²
   |
   |where:    T  is a type in class C
-  |          T? is a type in the initializer of value s which is an alias of String
+  |          T² is a type in the initializer of value s which is an alias of String
 longer explanation available when compiling with `-explain`
 -- [E007] Type Mismatch Error: -------------------------------------------------
 1 | abstract class C { type T; val x: T; val s: Unit = { type T = String; var y: T = x; locally { def f() = { type T = Int; val z: T = y }; f() } }; }
   |                                                                                                                                    ^
   |Found:    (y : T)
-  |Required: T?
+  |Required: T²
   |
   |where:    T  is a type in the initializer of value s which is an alias of String
-  |          T? is a type in method f which is an alias of Int
+  |          T² is a type in method f which is an alias of Int
 longer explanation available when compiling with `-explain`
 2 errors found
 scala> class Foo() { def bar: Int = 1 }; val foo = new Foo(); foo.barr

compiler/test/dotty/tools/dotc/transform/SpaceEngineTest.scala

@@ -0,0 +1,25 @@
+package dotty.tools
+package dotc
+package transform
+
+import org.junit.*, Assert.*
+
+import core.*, Constants.*, Contexts.*, Decorators.*, Symbols.*, Types.*
+
+class SpaceEngineTest extends DottyTest:
+  @Test def testAdaptTest(): Unit =
+    given Context = ctx
+    val defn = ctx.definitions
+    import defn._
+    val e = patmat.SpaceEngine()
+
+    val BoxedIntType = BoxedIntClass.typeRef
+    val ConstOneType = ConstantType(Constant(1))
+
+    assertTrue(e.isPrimToBox(IntType, BoxedIntType))
+    assertFalse(e.isPrimToBox(BoxedIntType, IntType))
+    assertTrue(e.isPrimToBox(ConstOneType, BoxedIntType))
+
+    assertEquals(BoxedIntType, e.adaptType(IntType, BoxedIntType).widenSingleton)
+    assertEquals(IntType,      e.adaptType(BoxedIntType, IntType).widenSingleton)
+    assertEquals(IntType,      e.adaptType(BoxedIntType, ConstOneType).widenSingleton)