Fix cyclic complete and inference

Author: noti0na1

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -14,6 +14,7 @@ import collection.{immutable, mutable}
 import util.{Property, SourceFile, NoSource}
 import NameKinds.{TempResultName, OuterSelectName}
 import typer.ConstFold
+import typer.Nullables
 
 import scala.annotation.tailrec
 import scala.io.Codec
@@ -932,7 +933,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     /** The current tree applied to given type argument list: `tree[targs(0), ..., targs(targs.length - 1)]` */
     def appliedToTypeTrees(targs: List[Tree])(using Context): Tree =
-      if (targs.isEmpty) tree else TypeApply(tree, targs)
+      if targs.isEmpty then tree else
+        val app = TypeApply(tree, targs)
+        app.putAttachment(Nullables.UnsafeNullsKey, config.Feature.unsafeNullsEnabled)
+        app
 
     /** Apply to `()` unless tree's widened type is parameterless */
     def ensureApplied(using Context): Tree =

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

@@ -214,6 +214,13 @@ object Types {
     def isAnyRef(using Context): Boolean  = isRef(defn.ObjectClass, skipRefined = false)
     def isAnyKind(using Context): Boolean = isRef(defn.AnyKindClass, skipRefined = false)
 
+    /** Is this type exactly Null (no vars, aliases, refinements etc allowed)? */
+    def isExactlyNull(using Context): Boolean = this match {
+      case tp: TypeRef =>
+        tp.name == tpnme.Null && (tp.symbol eq defn.NullClass)
+      case _ => false
+    }
+
     /** Is this type exactly Nothing (no vars, aliases, refinements etc allowed)? */
     def isExactlyNothing(using Context): Boolean = this match {
       case tp: TypeRef =>

compiler/src/dotty/tools/dotc/transform/PostTyper.scala

@@ -7,6 +7,7 @@ import core._
 import dotty.tools.dotc.typer.Checking
 import dotty.tools.dotc.typer.Inliner
 import dotty.tools.dotc.typer.VarianceChecker
+import dotty.tools.dotc.typer.Nullables
 import Types._, Contexts._, Names._, Flags._, DenotTransformers._, Phases._
 import SymDenotations._, StdNames._, Annotations._, Trees._, Scopes._
 import Decorators._
@@ -299,7 +300,11 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           args.foreach(checkInferredWellFormed)
           if (fn.symbol != defn.ChildAnnot.primaryConstructor)
             // Make an exception for ChildAnnot, which should really have AnyKind bounds
-            Checking.checkBounds(args, fn.tpe.widen.asInstanceOf[PolyType])
+            val checkCtx = if tree.attachmentOrElse(Nullables.UnsafeNullsKey, false) then
+              ctx.addMode(Mode.UnsafeNullsSubType)
+            else
+              ctx
+            Checking.checkBounds(args, fn.tpe.widen.asInstanceOf[PolyType])(using checkCtx)
           fn match {
             case sel: Select =>
               val args1 = transform(args)
@@ -359,7 +364,11 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
           else if (tree.tpt.symbol == defn.orType)
             () // nothing to do
           else
-            Checking.checkAppliedType(tree)
+            val checkCtx = if tree.attachmentOrElse(Nullables.UnsafeNullsKey, false) then
+              ctx.addMode(Mode.UnsafeNullsSubType)
+            else
+              ctx
+            Checking.checkAppliedType(tree)(using checkCtx)
           super.transform(tree)
         case SingletonTypeTree(ref) =>
           Checking.checkRealizable(ref.tpe, ref.srcPos)

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

@@ -1075,7 +1075,7 @@ trait Applications extends Compatibility {
     val isNamed = hasNamedArg(tree.args)
     val typedArgs = if (isNamed) typedNamedArgs(tree.args) else tree.args.mapconserve(typedType(_))
     record("typedTypeApply")
-    typedFunPart(tree.fun, PolyProto(typedArgs, pt)) match {
+    val app = typedFunPart(tree.fun, PolyProto(typedArgs, pt)) match {
       case IntegratedTypeArgs(app) =>
         app
       case _: TypeApply if !ctx.isAfterTyper =>
@@ -1098,6 +1098,8 @@ trait Applications extends Compatibility {
         if (typedFn.tpe eq TryDynamicCallType) tryDynamicTypeApply()
         else assignType(cpy.TypeApply(tree)(typedFn, typedArgs), typedFn, typedArgs)
     }
+    app.putAttachment(Nullables.UnsafeNullsKey, config.Feature.unsafeNullsEnabled)
+    app
   }
 
   /** Rewrite `new Array[T](....)` if T is an unbounded generic to calls to newGenericArray.

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

@@ -22,29 +22,24 @@ object Nullables:
 
   private def needNullifyHi(lo: Type, hi: Type)(using Context): Boolean =
     ctx.explicitNulls
-    && lo.isBottomTypeAfterErasure
-    && !hi.isAny
-    && !hi.isBottomTypeAfterErasure
+    && lo.isExactlyNull
     && hi.isValueType
-    && hi.isNullableAfterErasure
 
   def createNullableTypeBounds(lo: Type, hi: Type)(using Context): TypeBounds =
-    TypeBounds(lo,
-      if needNullifyHi(lo, hi)
-      then OrNull(hi)
-      else hi)
+    val newHi = if needNullifyHi(lo, hi) then OrType(hi, defn.NullType, soft = false) else hi
+    TypeBounds(lo, newHi)
 
   def createNullableTypeBoundsTree(lo: Tree, hi: Tree, alias: Tree = EmptyTree)(using Context): TypeBoundsTree =
     val hiTpe = hi.typeOpt
-    TypeBoundsTree(lo,
-      if needNullifyHi(lo.typeOpt, hiTpe)
-      then TypeTree(OrNull(hiTpe))
-      else hi, alias)
+    val newHi = if needNullifyHi(lo.typeOpt, hiTpe) then TypeTree(OrType(hiTpe, defn.NullType, soft = false)) else hi
+    TypeBoundsTree(lo, newHi, alias)
 
   inline def useUnsafeNullsSubTypeIf[T](cond: Boolean)(inline op: Context ?=> T)(using Context): T =
     val c = if cond then ctx.addMode(Mode.UnsafeNullsSubType) else ctx
     op(using c)
 
+  val UnsafeNullsKey = Property.StickyKey[Boolean]
+
   /** A set of val or var references that are known to be not null, plus a set of
    *  variable references that are not known (anymore) to be not null
    */

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

@@ -1785,7 +1785,9 @@ class Typer extends Namer
                 checkedArgs = List(TypeTree(elemtp).withSpan(arg.span))
             case _ =>
           }
-      assignType(cpy.AppliedTypeTree(tree)(tpt1, checkedArgs), tpt1, checkedArgs)
+      val appTpTree =assignType(cpy.AppliedTypeTree(tree)(tpt1, checkedArgs), tpt1, checkedArgs)
+      appTpTree.putAttachment(Nullables.UnsafeNullsKey, config.Feature.unsafeNullsEnabled)
+      appTpTree
     }
   }