SI-6440 Address regressions around MissingRequirementError

 Go back to using globalError to report when a stub's info is referenced,
 and only throw the MissingRequirementError when compilation really
 must abort due to having a StubTermSymbol in a place where a
 StubClassSymbol would have been a better choice.

 This situation arises when an entire package is missing from the
 classpath, as was the case in the reported bug.

 Adds `StoreReporterDirectTest`, which buffers messages issued
 during compilation for more structured interrogation. Use this
 in two test for manifests -- these tests were using a crude means
 of grepping compiler console output to focus on the relevant output,
 but this approach was insufficient with the new multi-line error
 message emitted as part of this change.

 Also used that base test class to add two new tests: one for
 the reported error (package missing), and another for a simpler
 error (class missing). The latter test shows how stub symbols
 allow code to compile if it doesn't the subset of signatures
 in some type that refer to a missing class.

 Gave the INFO/WARNING/ERROR members of Reporter sensible
 toString implementations; they inherit from Enumeration#Value
 in an unusual manner (why?) that means the built in toString of
 Enumeration printed `Severity@0`.

3 files changed, 17 insertions, 10 deletions

diff --git a/src/reflect/scala/reflect/internal/Symbols.scala b/src/reflect/scala/reflect/internal/Symbols.scala
index 67b2d05224..06bf54c1f8 100644
--- a/src/reflect/scala/reflect/internal/Symbols.scala
+++ b/src/reflect/scala/reflect/internal/Symbols.scala
@@ -3103,12 +3103,18 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     )
   }
   trait StubSymbol extends Symbol {
-    override final def failIfStub() = fail(())
     protected def missingMessage: String
+
+    /** Fail the stub by throwing a [[scala.reflect.internal.MissingRequirementError]]. */
+    override final def failIfStub() = {MissingRequirementError.signal(missingMessage)} //
+
+    /** Fail the stub by reporting an error to the reporter, setting the IS_ERROR flag
+      * on this symbol, and returning the dummy value `alt`.
+      */
     private def fail[T](alt: T): T = {
       // Avoid issuing lots of redundant errors
       if (!hasFlag(IS_ERROR)) {
-        MissingRequirementError.signal(missingMessage)
+        globalError(missingMessage)
         if (settings.debug.value)
           (new Throwable).printStackTrace
 
diff --git a/src/reflect/scala/reflect/internal/Types.scala b/src/reflect/scala/reflect/internal/Types.scala
index 57212bab55..d5347705a6 100644
--- a/src/reflect/scala/reflect/internal/Types.scala
+++ b/src/reflect/scala/reflect/internal/Types.scala
@@ -1385,10 +1385,11 @@ trait Types extends api.Types { self: SymbolTable =>
   /** A class for this-types of the form <sym>.this.type
    */
   abstract case class ThisType(sym: Symbol) extends SingletonType with ThisTypeApi {
-    // SI-6640 allow StubSymbols to reveal what's missing from the classpath
-    //         before we trip the assertion.
-    sym.failIfStub()
-    assert(sym.isClass, sym)
+    if (!sym.isClass) {
+      // SI-6640 allow StubSymbols to reveal what's missing from the classpath before we trip the assertion.
+      sym.failIfStub()
+      assert(false, sym)
+    }
 
     //assert(sym.isClass && !sym.isModuleClass || sym.isRoot, sym)
     override def isTrivial: Boolean = sym.isPackageClass
diff --git a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
index 5464a68205..f3a5053a91 100644
--- a/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
+++ b/src/reflect/scala/reflect/internal/pickling/UnPickler.scala
@@ -234,10 +234,10 @@ abstract class UnPickler {
               adjust(mirrorThatLoaded(owner).missingHook(owner, name)) orElse {
                 // (5) Create a stub symbol to defer hard failure a little longer.
                 val missingMessage =
-                  s"""|A signature in $filename refers to ${name.longString} in ${owner.fullLocationString}
-                      |which is not available. It may be completely missing from the current classpath,
-                      |or the version on the classpath might be incompatible with the version used when
-                      |compiling $filename.""".stripMargin
+                  s"""|bad symbolic reference. A signature in $filename refers to ${name.longString}
+                      |in ${owner.kindString} ${owner.fullName} which is not available.
+                      |It may be completely missing from the current classpath, or the version on
+                      |the classpath might be incompatible with the version used when compiling $filename.""".stripMargin
                 owner.newStubSymbol(name, missingMessage)
               }
             }