add extractor for Null ops; remove useless imports; reduce side effects

Author: noti0na1

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

@@ -45,6 +45,8 @@ object NullOpsDecorator {
           if (rrhs.isNullType) llhs
           else if (llhs.isNullType) rrhs
           else tp.derivedOrType(llhs, rrhs)
+        case tp @ AndType(tp1, tp2) =>
+          tp.derivedAndType(strip(tp1), strip(tp2))
         case _ =>
           if (tp.isNullType) {
             if (tp.isJavaNullType) hasJavaNull = true
@@ -77,17 +79,6 @@ object NullOpsDecorator {
       }
     }
 
-    /** Is this type guaranteed not to have `null` as a value? */
-    final def isNotNull(implicit ctx: Context): Boolean = self match {
-      case tp: ConstantType => tp.value.value != null
-      case tp: ClassInfo => !tp.cls.isNullableClass && tp.cls != defn.NothingClass
-      case tp: TypeBounds => tp.lo.isNotNull
-      case tp: TypeProxy => tp.underlying.isNotNull
-      case AndType(tp1, tp2) => tp1.isNotNull || tp2.isNotNull
-      case OrType(tp1, tp2) => tp1.isNotNull && tp2.isNotNull
-      case _ => false
-    }
-
     def maybeNullable(implicit ctx: Context): Type =
       if (ctx.explicitNulls) OrType(self, defn.NullType) else self
 
@@ -120,18 +111,17 @@ object NullOpsDecorator {
      */
     def stripAllJavaNull(implicit ctx: Context): Type = {
       assert(ctx.explicitNulls)
-      var diff = false
       object RemoveNulls extends TypeMap {
         override def apply(tp: Type): Type =
           tp.normNullableUnion match {
             case OrType(lhs, rhs) if rhs.isJavaNullType =>
-              diff = true
               mapOver(lhs)
             case _ => mapOver(tp)
           }
       }
-      val rem = RemoveNulls(self.widenDealias)
-      if (diff) rem else self
+      val self1 = self.widenDealias
+      val rem = RemoveNulls(self1)
+      if (rem ne self1) rem else self
     }
 
     /** Injects this type into a union with `JavaNull`. */

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

@@ -386,8 +386,8 @@ trait Symbols { this: Context =>
   /** Get a List of ClassSymbols which are either defined in current compilation
    *  run or present on classpath.
    */
-  def getClassesIfDefined(pathes: List[PreName]): List[ClassSymbol] =
-    pathes.foldLeft(List.empty){ case (acc, path) => getClassIfDefined(path) match {
+  def getClassesIfDefined(paths: List[PreName]): List[ClassSymbol] =
+    paths.foldLeft(List.empty){ case (acc, path) => getClassIfDefined(path) match {
       case cls: ClassSymbol => cls :: acc
       case _ => acc
     }}

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

@@ -1610,12 +1610,18 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
             // The next two definitions handle the special case mentioned above, where
             // the Java argument has type 'Any', and the Scala argument has type 'Object' or
             // 'Object|Null', depending on whether explicit nulls are enabled.
-            lazy val formal2IsObject =
-              if (ctx.explicitNulls) formal2.isNullableUnion && formal2.stripNull(ctx).isRef(ObjectClass)
-              else formal2.isRef(ObjectClass)
-            lazy val formal1IsObject =
-              if (ctx.explicitNulls) formal1.isNullableUnion && formal1.stripNull(ctx).isRef(ObjectClass)
+            def formal1IsObject =
+              if (ctx.explicitNulls) formal1 match {
+                case OrNull(formal1b) => formal1b.isRef(ObjectClass)
+                case _ => false
+              }
               else formal1.isRef(ObjectClass)
+            def formal2IsObject =
+              if (ctx.explicitNulls) formal2 match {
+                case OrNull(formal2b) => formal2b.isRef(ObjectClass)
+                case _ => false
+              }
+              else formal2.isRef(ObjectClass)
             (isSameTypeWhenFrozen(formal1, formal2a)
             || tp1.isJavaMethod && formal2IsObject && (formal1 isRef AnyClass)
             || tp2.isJavaMethod && formal1IsObject && (formal2 isRef AnyClass)) &&

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

@@ -273,6 +273,17 @@ object Types {
       loop(this)
     }
 
+    /** Is this type guaranteed not to have `null` as a value? */
+    final def isNotNull(implicit ctx: Context): Boolean = this match {
+      case tp: ConstantType => tp.value.value != null
+      case tp: ClassInfo => !tp.cls.isNullableClass && tp.cls != defn.NothingClass
+      case tp: TypeBounds => tp.lo.isNotNull
+      case tp: TypeProxy => tp.underlying.isNotNull
+      case AndType(tp1, tp2) => tp1.isNotNull || tp2.isNotNull
+      case OrType(tp1, tp2) => tp1.isNotNull && tp2.isNotNull
+      case _ => false
+    }
+
     /** Is this type produced as a repair for an error? */
     final def isError(implicit ctx: Context): Boolean = stripTypeVar.isInstanceOf[ErrorType]
 
@@ -588,19 +599,19 @@ object Types {
         case AndType(l, r) =>
           goAnd(l, r)
         case tp: OrType =>
-          if (ctx.explicitNulls && tp.isJavaNullableUnion) {
-            // Selecting `name` from a type `T|JavaNull` is like selecting `name` from `T`.
-            // This can throw at runtime, but we trade soundness for usability.
-            // We need to strip `JavaNull` from both the type and the prefix so that
-            // `pre <: tp` continues to hold.
-            tp.stripJavaNull.findMember(name, pre.stripJavaNull, required, excluded)
-          }
-          else {
-            // we need to keep the invariant that `pre <: tp`. Branch `union-types-narrow-prefix`
-            // achieved that by narrowing `pre` to each alternative, but it led to merge errors in
-            // lots of places. The present strategy is instead of widen `tp` using `join` to be a
-            // supertype of `pre`.
-            go(tp.join)
+          tp match {
+            case OrJavaNull(tp1) =>
+              // Selecting `name` from a type `T|JavaNull` is like selecting `name` from `T`.
+              // This can throw at runtime, but we trade soundness for usability.
+              // We need to strip `JavaNull` from both the type and the prefix so that
+              // `pre <: tp` continues to hold.
+              tp1.findMember(name, pre.stripJavaNull, required, excluded)
+            case _ =>
+              // we need to keep the invariant that `pre <: tp`. Branch `union-types-narrow-prefix`
+              // achieved that by narrowing `pre` to each alternative, but it led to merge errors in
+              // lots of places. The present strategy is instead of widen `tp` using `join` to be a
+              // supertype of `pre`.
+              go(tp.join)
           }
         case tp: JavaArrayType =>
           defn.ObjectType.findMember(name, pre, required, excluded)
@@ -2924,6 +2935,25 @@ object Types {
       else apply(tp1, tp2)
   }
 
+  object OrNull {
+    def apply(tp: Type)(given Context) =
+      OrType(tp, defn.NullType)
+    def unapply(tp: Type)(given Context): Option[Type] =
+      val tp1 = tp.stripNull
+      if tp1 ne tp then Some(tp1) else None
+  }
+
+  object OrJavaNull {
+    def apply(tp: Type)(given Context) =
+      OrType(tp, defn.JavaNullAliasType)
+    def unapply(tp: Type)(given ctx: Context): Option[Type] =
+      if (ctx.explicitNulls) {
+        val tp1 = tp.stripJavaNull
+        if tp1 ne tp then Some(tp1) else None
+      }
+      else None
+  }
+
   // ----- ExprType and LambdaTypes -----------------------------------
 
   // Note: method types are cached whereas poly types are not. The reason

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

@@ -16,7 +16,6 @@ import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.core.{Names, StdNames}
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
 import dotty.tools.dotc.transform.SymUtils._
-import dotty.tools.dotc.core.NullOpsDecorator._
 import scala.collection.mutable
 
 class LazyVals extends MiniPhase with IdentityDenotTransformer {

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

@@ -17,7 +17,6 @@ import config.Printers.patmatch
 import reporting.diagnostic.messages._
 import dotty.tools.dotc.ast._
 import util.Property._
-import NullOpsDecorator._
 
 /** The pattern matching transform.
  *  After this phase, the only Match nodes remaining in the code are simple switches

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

@@ -14,7 +14,6 @@ import util.Spans._
 import reporting.diagnostic.messages.TypeTestAlwaysSucceeds
 import reporting.trace
 import config.Printers.{ transforms => debug }
-import NullOpsDecorator._
 
 /** This transform normalizes type tests and type casts,
  *  also replacing type tests with singleton argument type with reference equality check