fix SAM type recognition in parameters to JavaDefined methods

Author: olhotak

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

@@ -122,7 +122,7 @@ object JavaNullInterop {
         // 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)
+        outermostLevelAlreadyNullable = tp.classSymbol.is(JavaDefined) && !ctx.flexibleTypes
         val targs2 = targs map this
         outermostLevelAlreadyNullable = oldOutermostNullable
         val appTp2 = derivedAppliedType(appTp, tycon, targs2)

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

@@ -976,6 +976,8 @@ object Types {
         if (keepOnly(pre, tp.refinedName)) ns + tp.refinedName else ns
       case tp: TypeProxy =>
         tp.superType.memberNames(keepOnly, pre)
+      case tp: FlexibleType =>
+        tp.underlying.memberNames(keepOnly, pre)
       case tp: AndType =>
         tp.tp1.memberNames(keepOnly, pre) | tp.tp2.memberNames(keepOnly, pre)
       case tp: OrType =>
@@ -3408,6 +3410,12 @@ object Types {
 
   // --- FlexibleType -----------------------------------------------------------------
 
+  object FlexibleType {
+    def apply(underlying: Type) = underlying match {
+      case ft: FlexibleType => ft
+      case _ => new FlexibleType(underlying)
+    }
+  }
   case class FlexibleType(underlying: Type) extends CachedGroundType with ValueType {
     def lo(using Context): Type = OrNull(underlying)
     override def show(using Context) = i"FlexibleType($underlying)"
@@ -5652,11 +5660,15 @@ object Types {
                   foldOver(vmap, t)
             val vmap = accu(VarianceMap.empty, samMeth.info)
             val tparams = tycon.typeParamSymbols
+            def boundFollowingVariance(lo: Type, hi: Type, tparam: TypeSymbol) =
+              val v = vmap.computedVariance(tparam)
+              if v.uncheckedNN < 0 then lo
+              else hi
             val args1 = args.zipWithConserve(tparams):
               case (arg @ TypeBounds(lo, hi), tparam) =>
-                val v = vmap.computedVariance(tparam)
-                if v.uncheckedNN < 0 then lo
-                else hi
+                boundFollowingVariance(lo, hi, tparam)
+              case (arg @ FlexibleType(lo, hi), tparam) =>
+                boundFollowingVariance(arg.lo, hi, tparam)
               case (arg, _) => arg
             tp.derivedAppliedType(tycon, args1)
           case tp: RefinedType =>
@@ -5692,6 +5704,8 @@ object Types {
         samClass(tp.underlying)
       case tp: AnnotatedType =>
         samClass(tp.underlying)
+      case tp: FlexibleType =>
+        samClass(tp.underlying)
       case _ =>
         NoSymbol
 

tests/flexible-types/pos/sam-parameter-javadefined/injava.java

@@ -0,0 +1,6 @@
+class injava {
+    static void overloaded(Runnable r) {}
+    static void overloaded(int i) {}
+
+    static void notoverloaded(Runnable r) {}
+}

tests/flexible-types/pos/sam-parameter-javadefined/sam-test.scala

@@ -0,0 +1,22 @@
+def foo = {
+  def unit: Unit = ()
+
+  injava.overloaded({ () => unit } : Runnable )
+  injava.overloaded({ () => unit } )
+
+  injava.notoverloaded({ () => unit } : Runnable )
+  injava.notoverloaded({ () => unit } )
+
+  val list = new java.util.Vector[Int]()
+  java.util.Collections.sort[Int](list, { (a,b) => a - b } : java.util.Comparator[Int] )
+  java.util.Collections.sort[Int](list, { (a,b) => a - b })
+
+  new Thread({ () => unit } : Runnable )
+  new Thread({ () => unit } )
+
+  val cf = new java.util.concurrent.CompletableFuture[String]
+  cf.handle[Unit]({
+      case (string, null) => unit
+      case (string, throwable) => unit
+    })
+}