Do not flexify higher-kinded types

Author: HarrisL2

community-build/community-projects/scalatest

@@ -104,19 +104,26 @@ object ImplicitNullInterop {
     def needsNull(tp: Type): Boolean =
       if outermostLevelAlreadyNullable then false
       else tp match
+        case tp: TypeRef if !tp.hasSimpleKind => false
         case tp: TypeRef if
           // We don't modify value types because they're non-nullable even in Java.
           tp.symbol.isValueClass
           // We don't modify unit types.
           || tp.isRef(defn.UnitClass)
           // 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.
-          || !ctx.flexibleTypes && tp.isRef(defn.RepeatedParamClass) => false
+          || tp.isRef(defn.AnyClass) => false
+        case _ => true
+
+    // 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.
+    def tyconNeedsNull(tp: Type): Boolean =
+      if outermostLevelAlreadyNullable then false
+      else tp match
+        case tp: TypeRef
+          if !ctx.flexibleTypes && tp.isRef(defn.RepeatedParamClass) => false
         case _ => true
 
     override def apply(tp: Type): Type = tp match {
@@ -130,7 +137,7 @@ object ImplicitNullInterop {
         val targs2 = targs map this
         outermostLevelAlreadyNullable = oldOutermostNullable
         val appTp2 = derivedAppliedType(appTp, tycon, targs2)
-        if needsNull(tycon) then nullify(appTp2) else appTp2
+        if tyconNeedsNull(tycon) then nullify(appTp2) else appTp2
       case ptp: PolyType =>
         derivedLambdaType(ptp)(ptp.paramInfos, this(ptp.resType))
       case mtp: MethodType =>

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

@@ -1830,6 +1830,8 @@ object Types extends TypeUtils {
         t
       case t @ SAMType(_, _) =>
         t
+      case ft: FlexibleType =>
+        ft.underlying.findFunctionType
       case _ =>
         NoType
 
@@ -3401,15 +3403,17 @@ object Types extends TypeUtils {
     override def underlying(using Context): Type = hi
 
     def derivedFlexibleType(hi: Type)(using Context): Type =
-      if hi eq this.hi then this else FlexibleType(hi)
+      if hi eq this.hi then this else FlexibleType.make(hi)
 
     override def computeHash(bs: Binders): Int = doHash(bs, hi)
 
     override final def baseClasses(using Context): List[ClassSymbol] = hi.baseClasses
   }
 
   object FlexibleType {
-    def apply(tp: Type)(using Context): FlexibleType = tp match {
+    def apply(tp: Type)(using Context): FlexibleType =
+      // assert(tp.isValueType, s"Should not flexify ${tp}")
+      tp match {
       case ft: FlexibleType => ft
       case _ =>
         // val tp1 = tp.stripNull()
@@ -3430,6 +3434,15 @@ object Types extends TypeUtils {
         assert(!tp.isInstanceOf[LazyType])
         FlexibleType(OrNull(tp), tp)
     }
+
+    def make(tp: Type)(using Context): Type =
+      tp match
+        case _: FlexibleType => tp
+        case TypeBounds(lo, hi) => TypeBounds(FlexibleType.make(lo), FlexibleType.make(hi))
+        case wt: WildcardType => wt.optBounds match
+          case tb: TypeBounds => WildcardType(FlexibleType.make(tb).asInstanceOf[TypeBounds])
+          case _ => wt
+        case other => FlexibleType(tp)
   }
 
   // --- AndType/OrType ---------------------------------------------------------------

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

@@ -1,6 +1,28 @@
 import unsafeNulls.Foo.*
 import unsafeNulls.Unsafe_1
 
+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
+}
+
+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
+}
+
+class Inherit_3 extends Unsafe_1 {
+  override def foo(s: String): String | Null = null
+  override def bar[T >: String](s: T): T | Null = s
+}
+
+class Inherit_4 extends Unsafe_1 {
+  override def foo(s: String | Null): String = "non-null string"
+  override def bar[T >: String](s: T | Null): T = "non-null string"
+}
+
 @main
 def Flexible_2() =
   val s2: String | Null = "foo"

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

@@ -5,6 +5,13 @@ class Unsafe_1 {
     if (s == null) then "nullString"
     else s
   }
+  def bar[T >: String](s: T): T = {
+    ???
+  }
+  def bar2[T >: String | Null](s: T): T = {
+    ???
+  }
+  def bar3[T <: Int => Int](g: T): T = g
 }
 
 object Foo {

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

@@ -7,10 +7,14 @@ def m = {
 
   j.g1(f1)
   j.g1((_: String | Null) => null)
+  j.g1(_ => null)
+  j.g1(x => if (x == "") null else null)
   j.g1(null)
 
   j.g2(f2)
   j.g2((_: Int) => ())
+  j.g2(_ => ())
+  j.g2(x => if (x == 1) () else ())
   j.g2(null)
 
   j.h1(f1)