Update comments

Author: noti0na1

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

@@ -1287,7 +1287,7 @@ object desugar {
     val ts = tree.trees
     val arity = ts.length
     assert(arity <= Definitions.MaxTupleArity)
-    def tupleTypeRef = defn.TupleType(arity)
+    def tupleTypeRef = defn.TupleType(arity).nn
     if (arity == 0)
       if (ctx.mode is Mode.Type) TypeTree(defn.UnitType) else unitLiteral
     else if (ctx.mode is Mode.Type) AppliedTypeTree(ref(tupleTypeRef), ts)

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

@@ -1468,7 +1468,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def tupleTypeTree(elems: List[Tree])(using Context): Tree = {
     val arity = elems.length
     if arity <= Definitions.MaxTupleArity then
-      val tupleTp: TypeRef | Null = defn.TupleType(arity)
+      val tupleTp = defn.TupleType(arity)
       if tupleTp != null then
         AppliedTypeTree(TypeTree(tupleTp), elems)
       else nestedPairsTypeTree(elems)

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

@@ -164,7 +164,7 @@ object Annotations {
   object LazyBodyAnnotation {
     def apply(bodyFn: Context ?=> Tree): LazyBodyAnnotation =
       new LazyBodyAnnotation:
-        protected var myTree: Tree | (Context ?=> Tree) = ctx ?=> bodyFn(using ctx)
+        protected var myTree: Tree | (Context ?=> Tree) | Null = ctx ?=> bodyFn(using ctx)
   }
 
   object Annotation {
@@ -195,15 +195,15 @@ object Annotations {
     /** Create an annotation where the tree is computed lazily. */
     def deferred(sym: Symbol)(treeFn: Context ?=> Tree)(using Context): Annotation =
       new LazyAnnotation {
-        protected var myTree: Tree | (Context ?=> Tree) = ctx ?=> treeFn(using ctx)
-        protected var mySym: Symbol | (Context ?=> Symbol) = sym
+        protected var myTree: Tree | (Context ?=> Tree) | Null = ctx ?=> treeFn(using ctx)
+        protected var mySym: Symbol | (Context ?=> Symbol) | Null = sym
       }
 
     /** Create an annotation where the symbol and the tree are computed lazily. */
     def deferredSymAndTree(symFn: Context ?=> Symbol)(treeFn: Context ?=> Tree)(using Context): Annotation =
       new LazyAnnotation {
-        protected var mySym: Symbol | (Context ?=> Symbol) = ctx ?=> symFn(using ctx)
-        protected var myTree: Tree | (Context ?=> Tree) = ctx ?=> treeFn(using ctx)
+        protected var mySym: Symbol | (Context ?=> Symbol) | Null = ctx ?=> symFn(using ctx)
+        protected var myTree: Tree | (Context ?=> Tree) | Null = ctx ?=> treeFn(using ctx)
       }
 
     /** Extractor for child annotations */

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

@@ -604,7 +604,7 @@ trait ConstraintHandling {
     val e = constraint.entry(param)
     if (e.exists) e.bounds
     else {
-      // TODO
+      // TODO: should we change the type of paramInfos to nullable?
       val pinfos: List[param.binder.PInfo] | Null = param.binder.paramInfos
       if (pinfos != null) pinfos(param.paramNum) // pinfos == null happens in pos/i536.scala
       else TypeBounds.empty
@@ -679,7 +679,6 @@ trait ConstraintHandling {
           if (!fromBelow) variance = -1
           def apply(t: Type): Type = t match {
             case t @ TypeParamRef(tl: TypeLambda, n) if comparedTypeLambdas contains tl =>
-              // TODO: do we need to check null here?
               val bounds = tl.paramInfos(n)
               range(bounds.lo, bounds.hi)
             case _ =>

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

@@ -271,14 +271,14 @@ object Contexts {
     /** Either the current scope, or, if the current context owner is a class,
      *  the declarations of the current class.
      */
+    // TODO: Should we change its type to nullable?
+    // We can see its value can be null in nestingLevel below.
     def effectiveScope(using Context): Scope =
-      // TODO
       val co: Symbol | Null = owner
       if co != null && co.isClass then co.asClass.unforcedDecls
       else scope
 
     def nestingLevel: Int =
-      // TODO
       val sc: Scope | Null = effectiveScope
       if sc != null then sc.nestingLevel else 0
 

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

@@ -180,8 +180,8 @@ class Definitions {
   private def enterT1ParameterlessMethod(cls: ClassSymbol, name: TermName, resultTypeFn: PolyType => Type, flags: FlagSet) =
     enterPolyMethod(cls, name, 1, resultTypeFn, flags)
 
-  private def mkArityArray(name: String, arity: Int, countFrom: Int): Array[TypeRef] = {
-    val arr = new Array[TypeRef](arity + 1)
+  private def mkArityArray(name: String, arity: Int, countFrom: Int): Array[TypeRef | Null] = {
+    val arr = new Array[TypeRef | Null](arity + 1)
     for (i <- countFrom to arity) arr(i) = requiredClassRef(name + i)
     arr
   }
@@ -1260,7 +1260,7 @@ class Definitions {
 
   @tu lazy val untestableClasses: Set[Symbol] = Set(NothingClass, NullClass, SingletonClass)
 
-  @tu lazy val AbstractFunctionType: Array[TypeRef] = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0)
+  @tu lazy val AbstractFunctionType: Array[TypeRef] = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0).asInstanceOf[Array[TypeRef]]
   val AbstractFunctionClassPerRun: PerRun[Array[Symbol]] = new PerRun(AbstractFunctionType.map(_.symbol.asClass))
   def AbstractFunctionClass(n: Int)(using Context): Symbol = AbstractFunctionClassPerRun()(using ctx)(n)
 
@@ -1283,7 +1283,7 @@ class Definitions {
     .withDefaultValue(holderImpl("LazyRef"))
   })
 
-  @tu lazy val TupleType: Array[TypeRef] = mkArityArray("scala.Tuple", MaxTupleArity, 1)
+  @tu lazy val TupleType: Array[TypeRef | Null] = mkArityArray("scala.Tuple", MaxTupleArity, 1)
 
   private class FunType(prefix: String):
     private var classRefs: Array[TypeRef | Null] = new Array(22)
@@ -1497,15 +1497,15 @@ class Definitions {
   def isTupleNType(tp: Type)(using Context): Boolean = {
     val arity = tp.dealias.argInfos.length
     arity <= MaxTupleArity && {
-      val tupletp: TypeRef | Null = TupleType(arity)
+      val tupletp = TupleType(arity)
       tupletp != null && tp.isRef(tupletp.symbol)
     }
   }
 
   def tupleType(elems: List[Type]): Type = {
     val arity = elems.length
     if 0 < arity && arity <= MaxTupleArity then
-      val tupletp: TypeRef | Null = TupleType(arity)
+      val tupletp = TupleType(arity)
       if tupletp != null then tupletp.appliedTo(elems)
       else TypeOps.nestedPairs(elems)
     else TypeOps.nestedPairs(elems)

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

@@ -132,7 +132,7 @@ object TypeErasure {
    */
   abstract case class ErasedValueType(tycon: TypeRef, erasedUnderlying: Type)
   extends CachedGroundType with ValueType {
-    override def computeHash(bs: Hashable.Binders): Int = doHash(bs, tycon, erasedUnderlying)
+    override def computeHash(bs: Hashable.Binders | Null): Int = doHash(bs, tycon, erasedUnderlying)
   }
 
   final class CachedErasedValueType(tycon: TypeRef, erasedUnderlying: Type)
@@ -690,7 +690,7 @@ class TypeErasure(sourceLanguage: SourceLanguage, semiEraseVCs: Boolean, isConst
   private def erasePair(tp: Type)(using Context): Type = {
     val arity = tp.tupleArity
     if (arity < 0) defn.ProductClass.typeRef
-    else if (arity <= Definitions.MaxTupleArity) defn.TupleType(arity)
+    else if (arity <= Definitions.MaxTupleArity) defn.TupleType(arity).nn
     else defn.TupleXXLClass.typeRef
   }
 

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

@@ -3919,7 +3919,6 @@ object Types {
         && {
           val bs1 = new BinderPairs(this, that, bs)
           // `paramInfos` and `resType` might still be uninstantiated at this point
-          // TODO:
           (paramInfos: List[TypeBounds] | Null) != null && (resType: Type | Null) != null &&
           paramInfos.equalElements(that.paramInfos, bs1) &&
           resType.equals(that.resType, bs1)

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

@@ -46,12 +46,8 @@ class PatternMatcher extends MiniPhase {
         case rt => tree.tpe
       val translated = new Translator(matchType, this).translateMatch(tree)
 
-      val engineCtx =
-        if tree.hasAttachment(Nullables.UnsafeNullsMatch)
-        then ctx.retractMode(Mode.SafeNulls) else ctx
-
       // check exhaustivity and unreachability
-      val engine = new patmat.SpaceEngine()(using engineCtx)
+      val engine = new patmat.SpaceEngine
       engine.checkExhaustivity(tree)
       engine.checkRedundancy(tree)
 

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

@@ -195,7 +195,7 @@ class TupleOptimizations extends MiniPhase with IdentityDenotTransformer {
   private def knownTupleFromElements(tpes: List[Type], elements: List[Tree])(using Context) = {
     val size = elements.size
     assert(0 < size && size <= MaxTupleArity)
-    val tupleModule = defn.TupleType(size).classSymbol.companionModule
+    val tupleModule = defn.TupleType(size).nn.classSymbol.companionModule
     ref(tupleModule).select(nme.apply).appliedToTypes(tpes).appliedToTermArgs(elements)
   }