refactor to simplify JavaNullMap

Author: olhotak

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

@@ -72,20 +72,17 @@ object JavaNullInterop {
   private def hasNotNullAnnot(sym: Symbol)(using Context): Boolean =
     ctx.definitions.NotNullAnnots.exists(nna => sym.unforcedAnnotation(nna).isDefined)
 
-  private def javaNullMap(outermostLevelAlreadyNullable: Boolean)(using Context): TypeMap =
-    if ctx.flexibleTypes then new JavaFlexibleMap(outermostLevelAlreadyNullable) else new JavaNullMap(outermostLevelAlreadyNullable)
-
   /** If tp is a MethodType, the parameters and the inside of return type are nullified,
    *  but the result return type is not nullable.
    *  If tp is a type of a field, the inside of the type is nullified,
    *  but the result type is not nullable.
    */
   private def nullifyExceptReturnType(tp: Type)(using Context): Type =
-    javaNullMap(outermostLevelAlreadyNullable = true)(tp)
+    new JavaNullMap(outermostLevelAlreadyNullable = true)(tp)
 
   /** Nullifies a Java type by adding `| Null` in the relevant places. */
   private def nullifyType(tp: Type)(using Context): Type =
-    javaNullMap(outermostLevelAlreadyNullable = false)(tp)
+    new JavaNullMap(outermostLevelAlreadyNullable = false)(tp)
 
   /** A type map that implements the nullification function on types. Given a Java-sourced type, this adds `| Null`
    *  in the right places to make the nulls explicit in Scala.
@@ -99,6 +96,8 @@ object JavaNullInterop {
    *                                       to `(A & B) | Null`, instead of `(A | Null & B | Null) | Null`.
    */
   private class JavaNullMap(var outermostLevelAlreadyNullable: Boolean)(using Context) extends TypeMap {
+    def nullify(tp: Type): Type = if ctx.flexibleTypes then FlexibleType(tp) else OrNull(tp)
+
     /** Should we nullify `tp` at the outermost level? */
     def needsNull(tp: Type): Boolean =
       !outermostLevelAlreadyNullable && (tp match {
@@ -117,7 +116,7 @@ object JavaNullInterop {
       })
 
     override def apply(tp: Type): Type = tp match {
-      case tp: TypeRef if needsNull(tp) => OrNull(tp)
+      case tp: TypeRef if needsNull(tp) => nullify(tp)
       case appTp @ AppliedType(tycon, targs) =>
         val oldOutermostNullable = outermostLevelAlreadyNullable
         // We don't make the outmost levels of type arguments nullable if tycon is Java-defined.
@@ -127,7 +126,7 @@ object JavaNullInterop {
         val targs2 = targs map this
         outermostLevelAlreadyNullable = oldOutermostNullable
         val appTp2 = derivedAppliedType(appTp, tycon, targs2)
-        if needsNull(tycon) then OrNull(appTp2) else appTp2
+        if needsNull(tycon) then nullify(appTp2) else appTp2
       case ptp: PolyType =>
         derivedLambdaType(ptp)(ptp.paramInfos, this(ptp.resType))
       case mtp: MethodType =>
@@ -141,71 +140,12 @@ object JavaNullInterop {
         // nullify(A & B) = (nullify(A) & nullify(B)) | Null, but take care not to add
         // duplicate `Null`s at the outermost level inside `A` and `B`.
         outermostLevelAlreadyNullable = true
-        OrNull(derivedAndType(tp, this(tp.tp1), this(tp.tp2)))
-      case tp: TypeParamRef if needsNull(tp) => OrNull(tp)
-      // In all other cases, return the type unchanged.
-      // In particular, if the type is a ConstantType, then we don't nullify it because it is the
-      // type of a final non-nullable field.
-      case _ => tp
-    }
-  }
-
-  /**
-   *  Flexible types
-   */
-
-  private class JavaFlexibleMap(var outermostLevelAlreadyNullable: Boolean)(using Context) extends TypeMap {
-    /** Should we nullify `tp` at the outermost level? */
-    def needsFlexible(tp: Type): Boolean =
-      !outermostLevelAlreadyNullable && (tp match {
-        case tp: TypeRef =>
-          // We don't modify value types because they're non-nullable even in Java.
-          !tp.symbol.isValueClass &&
-          // We don't modify `Any` because it's already nullable.
-          !tp.isRef(defn.AnyClass) &&
-          // We don't nullify Java varargs at the top level.
-          // Example: if `setNames` is a Java method with signature `void setNames(String... names)`,
-          // then its Scala signature will be `def setNames(names: (String|Null)*): Unit`.
-          // This is because `setNames(null)` passes as argument a single-element array containing the value `null`,
-          // and not a `null` array.
-          !tp.isRef(defn.RepeatedParamClass)
-        case _ => true
-      })
-
-    override def apply(tp: Type): Type = tp match {
-      case tp: TypeRef if needsFlexible(tp) =>
-        //println(Thread.currentThread().getStackTrace()(3).getMethodName())
-        FlexibleType(tp)
-      case appTp @ AppliedType(tycon, targs) =>
-        val oldOutermostNullable = outermostLevelAlreadyNullable
-        // We don't make the outmost levels of type arguments nullable if tycon is Java-defined.
-        // This is because Java classes are _all_ nullified, so both `java.util.List[String]` and
-        // `java.util.List[String|Null]` contain nullable elements.
-        outermostLevelAlreadyNullable = tp.classSymbol.is(JavaDefined)
-        val targs2 = targs map this
-        outermostLevelAlreadyNullable = oldOutermostNullable
-        val appTp2 = derivedAppliedType(appTp, tycon, targs2)
-        if needsFlexible(tycon) then FlexibleType(appTp2) else appTp2
-      case ptp: PolyType =>
-        derivedLambdaType(ptp)(ptp.paramInfos, this(ptp.resType))
-      case mtp: MethodType =>
-        val oldOutermostNullable = outermostLevelAlreadyNullable
-        outermostLevelAlreadyNullable = false
-        val paramInfos2 = mtp.paramInfos map this /*new JavaNullMap(outermostLevelAlreadyNullable)*/ // FLEX PARAMS
-        outermostLevelAlreadyNullable = oldOutermostNullable
-        derivedLambdaType(mtp)(paramInfos2, this(mtp.resType))
-      case tp: TypeAlias => mapOver(tp)
-      case tp: AndType =>
-        // nullify(A & B) = (nullify(A) & nullify(B)) | Null, but take care not to add
-        // duplicate `Null`s at the outermost level inside `A` and `B`.
-        outermostLevelAlreadyNullable = true
-        FlexibleType(derivedAndType(tp, this(tp.tp1), this(tp.tp2)))
-      case tp: TypeParamRef if needsFlexible(tp) =>
-        FlexibleType(tp)
+        nullify(derivedAndType(tp, this(tp.tp1), this(tp.tp2)))
+      case tp: TypeParamRef if needsNull(tp) => nullify(tp)
       // In all other cases, return the type unchanged.
       // In particular, if the type is a ConstantType, then we don't nullify it because it is the
       // type of a final non-nullable field.
       case _ => tp
     }
   }
-}
+}