Fix bootstrapping

Author: liufengyun

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

@@ -1287,7 +1287,7 @@ object Types {
      *  then the top-level union isn't widened. This is needed so that type inference can infer nullable types.
      */
     def widenUnion(using Context): Type = widen match
-      case tp @ OrNull(tp1): OrType =>
+      case tp @ OrNull(tp1) =>
         // Don't widen `T|Null`, since otherwise we wouldn't be able to infer nullable unions.
         val tp1Widen = tp1.widenUnionWithoutNull
         if (tp1Widen.isRef(defn.AnyClass)) tp1Widen
@@ -3497,10 +3497,31 @@ object Types {
    */
   object OrNull {
     def apply(tp: Type)(using Context) =
-      if tp.isNullType then tp else OrType(tp, defn.NullType, soft = false)
+      OrType(tp, defn.NullType, soft = false)
+    def unapply(tp: OrType)(using Context): Option[Type] =
+      if (ctx.explicitNulls) {
+        val tp1 = tp.stripNull()
+        if tp1 ne tp then Some(tp1) else None
+      }
+      else None
+  }
+
+  /** An extractor object to pattern match against a Java-nullable union.
+   *  e.g.
+   *
+   *  (tp: Type) match
+   *    case OrUncheckedNull(tp1) => // tp had the form `tp1 | UncheckedNull`
+   *    case _ => // tp was not a Java-nullable union
+   */
+  object OrUncheckedNull {
+    def apply(tp: Type)(using Context) =
+      OrType(tp, defn.UncheckedNullAliasType, soft = false)
     def unapply(tp: Type)(using Context): Option[Type] =
-      val tp1 = tp.stripNull
-      if tp1 ne tp then Some(tp1) else None
+      if (ctx.explicitNulls) {
+        val tp1 = tp.stripUncheckedNull
+        if tp1 ne tp then Some(tp1) else None
+      }
+      else None
   }
 
   // ----- ExprType and LambdaTypes -----------------------------------

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

@@ -476,13 +476,17 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
    *  (x: T | Null) => x.$asInstanceOf$[x.type & T]
    */
   def toNotNullTermRef(tree: Tree, pt: Type)(using Context): Tree = tree.tpe match
-    case ref @ OrNull(tpnn) : TermRef
+    case ref: TermRef
     if pt != AssignProto && // Ensure it is not the lhs of Assign
     ctx.notNullInfos.impliesNotNull(ref) &&
     // If a reference is in the context, it is already trackable at the point we add it.
     // Hence, we don't use isTracked in the next line, because checking use out of order is enough.
     !ref.usedOutOfOrder =>
-      tree.cast(AndType(ref, tpnn))
+      ref.widenDealias match
+      case OrNull(tpnn) =>
+        tree.cast(AndType(ref, tpnn))
+      case _ =>
+        tree
     case _ =>
       tree