Update comments

Author: noti0na1

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

@@ -269,7 +269,7 @@ class Definitions {
     @tu lazy val Any_asInstanceOf: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOf_, _.paramRefs(0), Final)
     @tu lazy val Any_typeTest: TermSymbol     = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOfPM, _ => BooleanType, Final | Synthetic | Artifact)
     @tu lazy val Any_typeCast: TermSymbol     = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOfPM, _.paramRefs(0), Final | Synthetic | Artifact | StableRealizable)
-      // generated by pattern matcher and exlicit nulls, eliminated by erasure
+      // generated by pattern matcher and explicit nulls, eliminated by erasure
 
     /** def getClass[A >: this.type](): Class[? <: A] */
     @tu lazy val Any_getClass: TermSymbol =
@@ -1144,7 +1144,7 @@ class Definitions {
 
   def isTupleType(tp: Type)(implicit ctx: Context): Boolean = {
     val arity = tp.dealias.argInfos.length
-    arity <= MaxTupleArity && TupleType(arity) != null && (tp isRef TupleType(arity).symbol)
+    arity <= MaxTupleArity && TupleType(arity) != null && tp.isRef(TupleType(arity).symbol)
   }
 
   def tupleType(elems: List[Type]): Type = {

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

@@ -2,7 +2,7 @@ package dotty.tools.dotc.core
 
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Symbols.defn
-import dotty.tools.dotc.core.Types.{AndType, ClassInfo, ConstantType, OrType, Type, TypeBounds, TypeMap, TypeProxy}
+import dotty.tools.dotc.core.Types._
 
 /** Defines operations on nullable types. */
 object NullOpsDecorator {
@@ -18,8 +18,8 @@ object NullOpsDecorator {
     }
 
     /** Syntactically strips the nullability from this type.
-     *  If the normalized form (as per `normNullableUnion`) of this type is `T1 | ... | Tn-1 | Tn`,
-     *  and `Tn` references to `Null` (or `JavaNull`), then return `T1 | ... | Tn-1`.
+     *  If the type is `T1 | ... | Tn`, and `Ti` references to `Null` (or `JavaNull`),
+     *  then return `T1 | ... | Ti-1 | Ti+1 | ... | Tn`.
      *  If this type isn't (syntactically) nullable, then returns the type unchanged.
      *
      *  @param onlyJavaNull whether we only remove `JavaNull`, the default value is false
@@ -40,7 +40,7 @@ object NullOpsDecorator {
           else tp.derivedOrType(llhs, rrhs)
         case tp @ AndType(tp1, tp2) =>
           // We cannot `tp.derivedAndType(strip(tp1), strip(tp2))` directly,
-          // since `normNullableUnion((A | Null) & B)` would produce the wrong
+          // since `stripNull((A | Null) & B)` would produce the wrong
           // result `(A & B) | Null`.
           val tp1s = strip(tp1)
           val tp2s = strip(tp2)
@@ -59,8 +59,8 @@ object NullOpsDecorator {
     def stripJavaNull(implicit ctx: Context): Type = self.stripNull(true)
 
     /** Collapses all `JavaNull` unions within this type, and not just the outermost ones (as `stripJavaNull` does).
-     *  e.g. (Array[String|Null]|Null).stripNull => Array[String|Null]
-     *       (Array[String|Null]|Null).stripInnerNulls => Array[String]
+     *  e.g. (Array[String|JavaNull]|JavaNull).stripJavaNull => Array[String|JavaNull]
+     *       (Array[String|JavaNull]|JavaNull).stripAllJavaNull => Array[String]
      *  If no `JavaNull` unions are found within the type, then returns the input type unchanged.
      */
     def stripAllJavaNull(implicit ctx: Context): Type = {