TypeErasure#apply: use WildcardType instead of null

As requested in the review, this is slightly shorter but means we have to be
very careful to not accidentally forget to propagate a WildcardType to the
top-level when computing signatures.

Author: smarter

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

@@ -596,10 +596,10 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
    *
    *   If computing the erasure of T requires erasing a WildcardType or an
    *   uninstantiated type variable, then an exception signaling an internal
-   *   error will be thrown, unless `inSigName` is set in which case `null`
+   *   error will be thrown, unless `inSigName` is set in which case WildcardType
    *   will be returned.
    *
-   *  In all other situations, |T| will be non-null and computed as follow:
+   *  In all other situations, |T| will be computed as follow:
    *   - For a refined type scala.Array+[T]:
    *      - if T is Nothing or Null, []Object
    *      - otherwise, if T <: Object, []|T|
@@ -631,7 +631,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
    *   - For NoType or NoPrefix, the type itself.
    *   - For any other type, exception.
    */
-  private def apply(tp: Type)(using Context): Type | Null =
+  private def apply(tp: Type)(using Context): Type =
     val etp = tp match
       case _: ErasedValueType =>
         tp
@@ -655,7 +655,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
       case SuperType(thistpe, supertpe) =>
         val eThis = this(thistpe)
         val eSuper = this(supertpe)
-        if eThis == null || eSuper == null then null
+        if eThis.isInstanceOf[WildcardType] || eSuper.isInstanceOf[WildcardType] then WildcardType
         else SuperType(eThis, eSuper)
       case ExprType(rt) =>
         defn.FunctionType(0)
@@ -665,7 +665,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
         eraseErasedFunctionApply(refinedInfo)
       case tp: TypeVar if !tp.isInstantiated =>
         assert(inSigName, i"Cannot erase uninstantiated type variable $tp")
-        null
+        WildcardType
       case tp: TypeProxy =>
         this(tp.underlying)
       case tp @ AndType(tp1, tp2) =>
@@ -676,7 +676,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
         else
           val e1 = this(tp1)
           val e2 = this(tp2)
-          if e1 == null || e2 == null then null
+          if e1.isInstanceOf[WildcardType] || e2.isInstanceOf[WildcardType] then WildcardType
           else erasedGlb(e1, e2)
       case OrType(tp1, tp2) =>
         if isSymbol && sourceLanguage.isScala2 && ctx.settings.scalajs.value then
@@ -693,7 +693,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
         else
           val e1 = this(tp1)
           val e2 = this(tp2)
-          if e1 == null || e2 == null then null
+          if e1.isInstanceOf[WildcardType] || e2.isInstanceOf[WildcardType] then WildcardType
           else TypeComparer.orType(e1, e2, isErased = true)
       case tp: MethodType =>
         def paramErasure(tpToErase: Type) =
@@ -751,10 +751,10 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
         tp
       case tp: WildcardType =>
         assert(inSigName, i"Cannot erase wildcard type $tp")
-        null
+        WildcardType
       case tp if (tp `eq` NoType) || (tp `eq` NoPrefix) =>
         tp
-    assert(etp != null || inSigName, i"Unexpected null erasure for $tp")
+    assert(!etp.isInstanceOf[WildcardType] || inSigName, i"Unexpected WildcardType erasure for $tp")
     etp
 
   /** Like translucentSuperType, but issue a fatal error if it does not exist. */
@@ -788,15 +788,15 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
     else
       try
         val eElem = erasureFn(sourceLanguage, semiEraseVCs = false, isConstructor, isSymbol, inSigName)(elemtp)
-        if eElem == null then null
+        if eElem.isInstanceOf[WildcardType] then WildcardType
         else JavaArrayType(eElem)
       catch case ex: Throwable =>
         handleRecursive("erase array type", tp.show, ex)
   }
 
-  private def erasePair(tp: Type)(using Context): Type | Null = {
+  private def erasePair(tp: Type)(using Context): Type = {
     val arity = tupleArity(tp)
-    if arity == -2 then null // erasure depends on an uninstantiated type variable or WildcardType
+    if arity == -2 then WildcardType // erasure depends on an uninstantiated type variable or WildcardType
     else if arity == -1 then defn.ProductClass.typeRef
     else if arity <= Definitions.MaxTupleArity then defn.TupleType(arity).nn
     else defn.TupleXXLClass.typeRef
@@ -827,7 +827,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
           case rt => MethodType(Nil, Nil, rt)
       case tp1 => this(tp1).nn
 
-  private def eraseDerivedValueClass(tp: Type)(using Context): Type | Null = {
+  private def eraseDerivedValueClass(tp: Type)(using Context): Type = {
     val cls = tp.classSymbol.asClass
     val unbox = valueClassUnbox(cls)
     if unbox.exists then
@@ -837,7 +837,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
       // The underlying part of an ErasedValueType cannot be an ErasedValueType itself
       val erase = erasureFn(sourceLanguage, semiEraseVCs = false, isConstructor, isSymbol, inSigName)
       val erasedUnderlying = erase(underlying)
-      if erasedUnderlying == null then return null
+      if erasedUnderlying.isInstanceOf[WildcardType] then return WildcardType
 
       // Ideally, we would just use `erasedUnderlying` as the erasure of `tp`, but to
       // be binary-compatible with Scala 2 we need two special cases for polymorphic
@@ -891,15 +891,14 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
 
   /** The name of the type as it is used in `Signature`s.
    *
-   *  If `tp` is null, or if computing its erasure requires erasing a
+   *  If `tp` is WildcardType, or if computing its erasure requires erasing a
    *  WildcardType or an uninstantiated type variable, then the special name
    *  `tpnme.Uninstantiated` which is used to signal an underdefined signature
    *  is used.
    *
    *  Note: Need to ensure correspondence with erasure!
    */
-  private def sigName(tp: Type | Null)(using Context): TypeName = try
-    if tp == null then return tpnme.Uninstantiated
+  private def sigName(tp: Type)(using Context): TypeName = try
     tp match {
       case tp: TypeRef =>
         if (!tp.denot.exists)
@@ -913,7 +912,6 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
         }
         if (semiEraseVCs && isDerivedValueClass(sym)) {
           val erasedVCRef = eraseDerivedValueClass(tp)
-          if erasedVCRef == null then return tpnme.Uninstantiated
           if (erasedVCRef.exists) return sigName(erasedVCRef)
         }
         if (defn.isSyntheticFunctionClass(sym))
@@ -960,7 +958,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
         tpnme.Uninstantiated
       case tp: ErrorType =>
         tpnme.ERROR
-      case _ if tp eq NoType => // Can't write `case NoType` because of #18083.
+      case NoType =>
         tpnme.ERROR
       case _ =>
         val erasedTp = this(tp)