Omit more prefixes in non-package module printing

When we pretty-print a type in a module class, we end up printing the
module class's symbol.  For instance in a reduction failure of
Tuple.Union, we end up printing Tuple.Fold, with Tuple being an internal
(ThisType) reference to the Tuple module class.  I tweaked the logic in
fullNameString so that we omit more prefixes, if the module is
non-package (and make it consistent across -Ytest-pickler).  The package
part is important, because we want to continue to get "import
scala.concurrent.duration..." instead of "import concurrent.duration..".

[Cherry-picked fbb08f7]

Author: dwijnand

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -92,7 +92,10 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     nameString(if (ctx.property(XprintMode).isEmpty) sym.initial.name else sym.name)
 
   override def fullNameString(sym: Symbol): String =
-    if !sym.exists || isEmptyPrefix(sym.effectiveOwner) then nameString(sym)
+    if !sym.exists
+      || isEmptyPrefix(sym.effectiveOwner)
+      || !homogenizedView && !sym.is(Package) && isOmittablePrefix(sym.effectiveOwner)
+    then nameString(sym)
     else super.fullNameString(sym)
 
   override protected def fullNameOwner(sym: Symbol): Symbol = {

language-server/test/dotty/tools/languageserver/CompletionTest.scala

@@ -32,13 +32,13 @@ class CompletionTest {
 
   @Test def completionFromScalaPackage: Unit = {
     code"class Foo { val foo: Conv${m1} }"
-      .completion(("Conversion", Class, "scala.Conversion"))
+      .completion(("Conversion", Class, "Conversion"))
   }
 
   @Test def completionFromScalaPackageObject: Unit = {
     code"class Foo { val foo: BigD${m1} }"
       .completion(
-        ("BigDecimal", Field, "scala.BigDecimal"),
+        ("BigDecimal", Field, "BigDecimal"),
         ("BigDecimal", Method, "=> math.BigDecimal.type"),
       )
   }
@@ -47,14 +47,14 @@ class CompletionTest {
     code"class Foo { val foo: IArr${m1} }"
       .completion(
         ("IArray", Module, "IArray"),
-        ("IArray", Field, "scala.IArray"),
+        ("IArray", Field, "IArray"),
       )
   }
 
   @Test def completionFromJavaDefaults: Unit = {
     code"class Foo { val foo: Runn${m1} }"
       .completion(
-        ("Runnable", Class, "java.lang.Runnable"),
+        ("Runnable", Class, "Runnable"),
         ("Runnable", Module, "Runnable"),
       )
   }
@@ -971,7 +971,7 @@ class CompletionTest {
           ("implicitNotFound", Module, "scala.annotation.implicitNotFound"),
       )
       .completion(m2,
-          ("main", Class, "scala.main"),
+          ("main", Class, "main"),
           ("main", Module, "main"),
       )
 

tests/neg-custom-args/captures/cc-this2.check

@@ -2,5 +2,5 @@
 -- Error: tests/neg-custom-args/captures/cc-this2/D_2.scala:2:6 --------------------------------------------------------
 2 |class D extends C: // error
   |^
-  |reference (scala.caps.cap : Any) is not included in allowed capture set {} of pure base class class C
+  |reference (caps.cap : Any) is not included in allowed capture set {} of pure base class class C
 3 |  this: D^ =>

tests/neg-custom-args/captures/exception-definitions.check

@@ -1,7 +1,7 @@
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:2:6 -----------------------------------------------
 2 |class Err extends Exception: // error
   |^
-  |reference (scala.caps.cap : Any) is not included in allowed capture set {} of pure base class class Throwable
+  |reference (caps.cap : Any) is not included in allowed capture set {} of pure base class class Throwable
 3 |  self: Err^ =>
 -- Error: tests/neg-custom-args/captures/exception-definitions.scala:10:6 ----------------------------------------------
 10 |class Err4(c: Any^) extends AnyVal // error

tests/neg/print-tuple-union.check

@@ -0,0 +1,18 @@
+-- [E007] Type Mismatch Error: tests/neg/print-tuple-union.scala:3:23 --------------------------------------------------
+3 |  def bar[B]: Int = foo[B] // error
+  |                    ^^^^^^
+  |                    Found:    Tuple.Union[B]
+  |                    Required: Int
+  |
+  |                    Note: a match type could not be fully reduced:
+  |
+  |                      trying to reduce  Tuple.Union[B]
+  |                      trying to reduce  Tuple.Fold[B, Nothing, [x, y] =>> x | y]
+  |                      failed since selector B
+  |                      does not match  case EmptyTuple => Nothing
+  |                      and cannot be shown to be disjoint from it either.
+  |                      Therefore, reduction cannot advance to the remaining case
+  |
+  |                        case h *: t => h | Tuple.Fold[t, Nothing, [x, y] =>> x | y]
+  |
+  | longer explanation available when compiling with `-explain`

tests/neg/print-tuple-union.scala

@@ -0,0 +1,3 @@
+trait Test:
+  def foo[A]: Tuple.Union[A]
+  def bar[B]: Int = foo[B] // error

tests/printing/transformed/lazy-vals-new.check

@@ -23,9 +23,9 @@ package <empty> {
     lazy def x(): Int =
       {
         val result: Object = A.x$lzy1
-        if result.isInstanceOf[Int] then scala.Int.unbox(result) else
-          if result.eq(scala.runtime.LazyVals.NullValue) then
-            scala.Int.unbox(null) else scala.Int.unbox(A.x$lzyINIT1())
+        if result.isInstanceOf[Int] then Int.unbox(result) else
+          if result.eq(scala.runtime.LazyVals.NullValue) then Int.unbox(null)
+             else Int.unbox(A.x$lzyINIT1())
       }
     private def x$lzyINIT1(): Object =
       while <empty> do
@@ -41,7 +41,7 @@ package <empty> {
                 var resultNullable: Object = null
                 try
                   {
-                    resultNullable = scala.Int.box(2)
+                    resultNullable = Int.box(2)
                     if resultNullable.eq(null) then
                       result = scala.runtime.LazyVals.NullValue else
                       result = resultNullable