Fix #6033: don't throw exception in case of NoDenotation

NoDenotation may result from a normal capture conversion.
Blindly throwing an error will cause unncessary compile crash.

Author: liufengyun

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

@@ -2076,15 +2076,14 @@ object TypeComparer {
   /** Show trace of comparison operations when performing `op` as result string */
   def explaining[T](say: String => Unit)(op: Context => T)(implicit ctx: Context): T = {
     val nestedCtx = ctx.fresh.setTypeComparerFn(new ExplainingTypeComparer(_))
-    val res = op(nestedCtx)
-    say(nestedCtx.typeComparer.lastTrace())
+    val res = try { op(nestedCtx) } finally { say(nestedCtx.typeComparer.lastTrace()) }
     res
   }
 
   /** Like [[explaining]], but returns the trace instead */
   def explained[T](op: Context => T)(implicit ctx: Context): String = {
     var trace: String = null
-    explaining(trace = _)(op)
+    try { explaining(trace = _)(op) } catch { case ex: Throwable => ex.printStackTrace }
     trace
   }
 }

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

@@ -1924,11 +1924,21 @@ object Types {
         param.derivedSingleDenotation(param, argInfo)
       }
       else {
-        if (!ctx.reporter.errorsReported)
-          throw new TypeError(
-            i"""bad parameter reference $this at ${ctx.phase}
-               |the parameter is ${param.showLocated} but the prefix $prefix
-               |does not define any corresponding arguments.""")
+        // Don't throw exception below, as capture conversion in
+        //
+        //    Array[_] | Null <: Array[Int]
+        //
+        // will result in the following check:
+        //
+        //    Int <: (Array[_] | Null) # T
+        //
+        //  See tests/pos/i6033.scala
+        //
+        // if (!ctx.reporter.errorsReported)
+        //   throw new TypeError(
+        //     i"""bad parameter reference $this at ${ctx.phase}
+        //        |the parameter is ${param.showLocated} but the prefix $prefix
+        //        |does not define any corresponding arguments.""")
         NoDenotation
       }
     }

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

@@ -405,8 +405,8 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
 
   /** Is `tp1` a subtype of `tp2`?  */
   def isSubType(tp1: Type, tp2: Type): Boolean = {
+    debug.println(TypeComparer.explained(implicit ctx => tp1 <:< tp2))
     val res = (tp1 != nullType || tp2 == nullType) && tp1 <:< tp2
-    debug.println(s"${tp1} <:< ${tp2} = $res")
     res
   }
 

tests/pos/i6033.scala

@@ -0,0 +1,5 @@
+class Test {
+  def f(a: Array[_]|Null): Unit  = a match {
+   case x: Array[Int] =>
+  }
+}