Only nullify tasty files if flexible types are enabled

Author: HarrisL2

compiler/src/dotty/tools/dotc/core/JavaNullInterop.scala renamed to compiler/src/dotty/tools/dotc/core/ImplicitNullInterop.scala

@@ -35,7 +35,7 @@ import dotty.tools.dotc.core.Decorators.i
  *   to handle the full spectrum of Scala types. Additionally, some kinds of symbols like constructors and
  *   enum instances get special treatment.
  */
-object JavaNullInterop {
+object ImplicitNullInterop {
 
   /** Transforms the type `tp` of Java member `sym` to be explicitly nullable.
    *  `tp` is needed because the type inside `sym` might not be set when this method is called.
@@ -55,11 +55,11 @@ object JavaNullInterop {
    */
   def nullifyMember(sym: Symbol, tp: Type, isEnumValueDef: Boolean)(using Context): Type = trace(i"nullifyMember ${sym}, ${tp}"){
     assert(ctx.explicitNulls)
-    assert(sym.is(JavaDefined), "can only nullify java-defined members")
 
     // Some special cases when nullifying the type
-    if isEnumValueDef || sym.name == nme.TYPE_ then
-      // Don't nullify the `TYPE` field in every class and Java enum instances
+    if isEnumValueDef || sym.name == nme.TYPE_ // Don't nullify the `TYPE` field in every class and Java enum instances
+    || sym.is(Flags.ModuleVal) // Don't nullify Modules
+    then
       tp
     else if sym.name == nme.toString_ || sym.isConstructor || hasNotNullAnnot(sym) then
       // Don't nullify the return type of the `toString` method.
@@ -80,14 +80,14 @@ object JavaNullInterop {
    *  but the result type is not nullable.
    */
   private def nullifyExceptReturnType(tp: Type)(using Context): Type =
-    new JavaNullMap(outermostLevelAlreadyNullable = true)(tp)
+    new ImplicitNullMap(outermostLevelAlreadyNullable = true)(tp)
 
-  /** Nullifies a Java type by adding `| Null` in the relevant places. */
+  /** Nullifies a type by adding `| Null` in the relevant places. */
   private def nullifyType(tp: Type)(using Context): Type =
-    new JavaNullMap(outermostLevelAlreadyNullable = false)(tp)
+    new ImplicitNullMap(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.
+  /** A type map that implements the nullification function on types. Given a Java-sourced type or an
+   *  implicitly null type, this adds `| Null` in the right places to make the nulls explicit.
    *
    *  @param outermostLevelAlreadyNullable whether this type is already nullable at the outermost level.
    *                                       For example, `Array[String] | Null` is already nullable at the
@@ -97,17 +97,16 @@ object JavaNullInterop {
    *                                       This is useful for e.g. constructors, and also so that `A & B` is nullified
    *                                       to `(A & B) | Null`, instead of `(A | Null & B | Null) | Null`.
    */
-  private class JavaNullMap(var outermostLevelAlreadyNullable: Boolean)(using Context) extends TypeMap {
+  private class ImplicitNullMap(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 =
       if outermostLevelAlreadyNullable then false
       else tp match
-        case tp: TypeRef if !tp.hasSimpleKind => false
-        case tp: TypeRef if
+        case tp: TypeRef if !tp.hasSimpleKind
           // We don't modify value types because they're non-nullable even in Java.
-          tp.symbol.isValueClass
+          || tp.symbol.isValueClass
           // We don't modify unit types.
           || tp.isRef(defn.UnitClass)
           // We don't modify `Any` because it's already nullable.
@@ -147,6 +146,7 @@ object JavaNullInterop {
         outermostLevelAlreadyNullable = oldOutermostNullable
         derivedLambdaType(mtp)(paramInfos2, this(mtp.resType))
       case tp: TypeAlias => mapOver(tp)
+      case tp: TypeBounds => 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`.

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

@@ -3407,7 +3407,7 @@ object Types extends TypeUtils {
 
   object FlexibleType {
     def apply(tp: Type)(using Context): FlexibleType =
-      // assert(tp.isValueType, s"Should not flexify ${tp}")
+      assert(tp.isValueType, s"Should not flexify ${tp}")
       tp match {
       case ft: FlexibleType => ft
       case _ =>

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -519,7 +519,7 @@ class ClassfileParser(
       denot.info = translateTempPoly(attrCompleter.complete(denot.info, isVarargs))
       if (isConstructor) normalizeConstructorInfo()
 
-      if (ctx.explicitNulls) denot.info = JavaNullInterop.nullifyMember(denot.symbol, denot.info, isEnum)
+      if (ctx.explicitNulls) denot.info = ImplicitNullInterop.nullifyMember(denot.symbol, denot.info, isEnum)
 
       // seal java enums
       if (isEnum) {

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -921,7 +921,7 @@ class TreeUnpickler(reader: TastyReader,
       // If explicit nulls is enabled, and the source file did not have explicit
       // nulls enabled, nullify the member to allow for compatibility.
       def nullify(sym: Symbol) =
-        if (ctx.explicitNulls && !explicitNulls) then
+        if (ctx.explicitNulls && ctx.flexibleTypes && !explicitNulls) then
           sym.info = ImplicitNullInterop.nullifyMember(sym, sym.info, sym.is(Enum))
 
       val name = readName()
@@ -997,8 +997,6 @@ class TreeUnpickler(reader: TastyReader,
           nullify(sym)
           ValDef(tpt)
       }
-
-
       goto(end)
       setSpan(start, tree)
 

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

@@ -1907,7 +1907,7 @@ class Namer { typer: Typer =>
 
     val mbrTpe = paramFn(checkSimpleKinded(typedAheadType(mdef.tpt, tptProto)).tpe)
     if (ctx.explicitNulls && mdef.mods.is(JavaDefined))
-      JavaNullInterop.nullifyMember(sym, mbrTpe, mdef.mods.isAllOf(JavaEnumValue))
+      ImplicitNullInterop.nullifyMember(sym, mbrTpe, mdef.mods.isAllOf(JavaEnumValue))
     else mbrTpe
   }
 

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -217,8 +217,18 @@ class CompilationTests {
       compileFilesInDir("tests/explicit-nulls/pos", explicitNullsOptions),
       compileFilesInDir("tests/explicit-nulls/flexible-types-common", explicitNullsOptions),
       compileFilesInDir("tests/explicit-nulls/unsafe-common", explicitNullsOptions and "-language:unsafeNulls" and "-Yno-flexible-types"),
-    )
-  }.checkCompile()
+    ).checkCompile()
+
+    locally {
+      val tests = List(
+        compileFile("tests/explicit-nulls/flexible-unpickle/Unsafe_1.scala", explicitNullsOptions without "-Yexplicit-nulls"),
+        compileFile("tests/explicit-nulls/flexible-unpickle/Flexible_2.scala", explicitNullsOptions.withClasspath(
+          defaultOutputDir + testGroup + "/Unsafe_1/flexible-unpickle/Unsafe_1")),
+      ).map(_.keepOutput.checkCompile())
+
+      tests.foreach(_.delete())
+    }
+  }
 
   @Test def explicitNullsWarn: Unit = {
     implicit val testGroup: TestGroup = TestGroup("explicitNullsWarn")

tests/explicit-nulls/flexible-unpickle/Flexible_2.scala

@@ -5,12 +5,16 @@ class Inherit_1 extends Unsafe_1 {
   override def foo(s: String): String = s
   override def bar[T >: String](s: T): T = s
   override def bar2[T >: String | Null](s: T): T = s
+  override def bar3[T <: Function1[String,String]](g: T) = g
+  override def bar4[HK[_]](i: String | Null): HK[String | Null] = ???
 }
 
 class Inherit_2 extends Unsafe_1 {
   override def foo(s: String | Null): String | Null = null
   override def bar[T >: String](s: T | Null): T | Null = s
   override def bar2[T >: String](s: T): T = s
+  override def bar3[T <: Function1[(String|Null),(String|Null)]](g: T) = g
+  override def bar4[HK[_]](i: String): HK[String] = ???
 }
 
 class Inherit_3 extends Unsafe_1 {
@@ -23,6 +27,8 @@ class Inherit_4 extends Unsafe_1 {
   override def bar[T >: String](s: T | Null): T = "non-null string"
 }
 
+case class cc()
+
 @main
 def Flexible_2() =
   val s2: String | Null = "foo"

tests/explicit-nulls/flexible-unpickle/Unsafe_1.scala

@@ -11,9 +11,11 @@ class Unsafe_1 {
   def bar2[T >: String | Null](s: T): T = {
     ???
   }
-  def bar3[T <: Int => Int](g: T): T = g
+  def bar3[T <: Function1[String,String]](g: T): T = g
+  def bar4[HK[_]](i: String): HK[String] = ???
 }
 
 object Foo {
   def bar = "bar!"
+  def id[T](t: T): T = t
 }