Fix typos

Author: noti0na1

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

@@ -51,8 +51,8 @@ object NullOpsDecorator {
       }
 
       val self1 = self.widenDealias
-      val striped = strip(self1)
-      if (striped ne self1) striped else self
+      val stripped = strip(self1)
+      if (stripped ne self1) stripped else self
     }
 
     /** Like `stripNull`, but removes only the `JavaNull`s. */
@@ -73,14 +73,14 @@ object NullOpsDecorator {
 
     /** Is self (after widening and dealiasing) a type of the form `T | Null`? */
     def isNullableUnion(implicit ctx: Context): Boolean = {
-      val striped = self.stripNull()
-      striped ne self
+      val stripped = self.stripNull()
+      stripped ne self
     }
 
     /** Is self (after widening and dealiasing) a type of the form `T | JavaNull`? */
     def isJavaNullableUnion(implicit ctx: Context): Boolean = {
-      val striped = self.stripNull(true)
-      striped ne self
+      val stripped = self.stripNull(true)
+      stripped ne self
     }
   }
 }

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

@@ -224,17 +224,17 @@ object Nullables with
       val refSym = ref.symbol
       val refOwner = refSym.owner
 
-      @tailrec def usedWithinClosure(s: Symbol): Boolean =
+      @tailrec def recur(s: Symbol): Boolean =
         s != NoSymbol
         && s != refOwner
         && (s.isOneOf(Lazy | Method) // not at the rhs of lazy ValDef or in a method (or lambda)
           || s.isClass // not in a class
           // TODO: need to check by-name paramter
-          || usedWithinClosure(s.owner))
+          || recur(s.owner))
 
       refSym.is(Mutable) // if it is immutable, we don't need to check the rest conditions
       && refOwner.isTerm
-      && usedWithinClosure(curCtx.owner)
+      && recur(curCtx.owner)
 
   given treeOps: extension (tree: Tree) with
 
@@ -335,9 +335,11 @@ object Nullables with
           // lhs variable is no longer trackable. We don't need to check whether the type `T`
           // is correct here, as typer will check it.
           tree.withNotNullInfo(NotNullInfo(Set(), Set(ref)))
-        else
-          // otherwise, we know the variable will have a non-null value
+        else if (curCtx.explicitNulls && ref.isNullableUnion)
+          // If the initial type is nullable and the assigned value is non-null,
+          // we add it to the NotNull
           tree.withNotNullInfo(NotNullInfo(Set(ref), Set()))
+        else tree
       case _ => tree
 
   private val analyzedOps = Set(nme.EQ, nme.NE, nme.eq, nme.ne, nme.ZAND, nme.ZOR, nme.UNARY_!)

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

@@ -2289,7 +2289,7 @@ class Typer extends Namer
   }
 
   /** Tries to adapt NotNullInfos from creation context to the DefTree,
-   *  returns whether the adaption is successed. The adaption only success if the
+   *  returns whether the adaption took place. An adaption only takes place if the
    *  DefTree has a symbol and it has not been completed (is not forward referenced).
    */
   def adaptCreationContext(mdef: untpd.DefTree)(implicit ctx: Context): Boolean =