SAM Overloading and existential bounds

In some cases existential bounds can be simplified without losing precision.

For example:
trait Blargle[T] { def compare(a: T, b: T): Int }

trait Test {
  def foo(a: Blargle[_ >: String]): Int
}

can be simplified to:

trait Test {
  def foo(a: Blargle[String]): Int
}

see: scala/scala#4101
#SCL8956 Fixed

Author: ilinum

src/org/jetbrains/plugins/scala/lang/psi/ScalaPsiUtil.scala

@@ -2341,7 +2341,7 @@ object ScalaPsiUtil {
    * @see SCL-6140
    * @see https://github.com/scala/scala/pull/3018/
    */
-  def toSAMType(expected: ScType, scope: GlobalSearchScope): Option[ScType] = {
+  def toSAMType(expected: ScType, scalaScope: GlobalSearchScope): Option[ScType] = {
 
     def constructorValidForSAM(constructors: Array[PsiMethod]): Boolean = {
       //primary constructor (if any) must be public, no-args, not overloaded
@@ -2371,8 +2371,14 @@ object ScalaPsiUtil {
                 !abst.head.hasTypeParameters
 
             if (valid) {
-              abst.head.getType() match {
-                case Success(tp, _) => Some(sub.subst(tp))
+              val fun = abst.head
+              fun.getType() match {
+                case Success(tp, _) =>
+                  val subbed = sub.subst(tp)
+                  extrapolateWildcardBounds(subbed, expected, fun.getProject, scalaScope) match {
+                    case s@Some(_) => s
+                    case _ => Some(subbed)
+                  }
                 case _ => None
               }
             } else None
@@ -2384,15 +2390,63 @@ object ScalaPsiUtil {
               //need to generate ScType for Java method
               val method = abst.head
               val project = method.getProject
-              val returnType: ScType = ScType.create(method.getReturnType, project, scope)
+              val returnType: ScType = ScType.create(method.getReturnType, project, scalaScope)
               val params: Array[ScType] = method.getParameterList.getParameters.map {
-                param: PsiParameter => ScType.create(param.getTypeElement.getType, project, scope)
+                param: PsiParameter => ScType.create(param.getTypeElement.getType, project, scalaScope)
+              }
+              val fun = ScFunctionType(returnType, params)(project, scalaScope)
+              val subbed = sub.subst(fun)
+              extrapolateWildcardBounds(subbed, expected, project, scalaScope) match {
+                case s@Some(_) => s
+                case _ => Some(subbed)
               }
-              val result = ScFunctionType(returnType, params)(project, scope)
-              Some(sub.subst(result))
             } else None
         }
       case None => None
     }
   }
+
+  /**
+   * In some cases existential bounds can be simplified without losing precision
+   *
+   * trait Comparinator[T] { def compare(a: T, b: T): Int }
+   *
+   * trait Test {
+   *   def foo(a: Comparinator[_ >: String]): Int
+   * }
+   *
+   * can be simplified to:
+   *
+   * trait Test {
+   *   def foo(a: Comparinator[String]): Int
+   * }
+   *
+   * @see https://github.com/scala/scala/pull/4101
+   * @see SCL-8956
+   */
+  private def extrapolateWildcardBounds(tp: ScType, expected: ScType, proj: Project, scope: GlobalSearchScope): Option[ScType] = {
+    expected match {
+      case ScExistentialType(ScParameterizedType(expectedDesignator, _), wildcards) =>
+        tp match {
+          case ScFunctionType(retTp, params) =>
+            def convertParameter(tpArg: ScType, variance: Int): ScType = {
+              wildcards.find(_.name == tpArg.canonicalText) match {
+                case Some(wildcard) =>
+                  (wildcard.lowerBound, wildcard.upperBound) match {
+                    case (lo, Any) if variance == ScTypeParam.Contravariant => lo
+                    case (Nothing, hi) if variance == ScTypeParam.Covariant => hi
+                    case _ => tpArg
+                  }
+                case _ => tpArg
+              }
+            }
+            //parameter clauses are contravariant positions, return types are covariant positions
+            val newParams = params.map(convertParameter(_, ScTypeParam.Contravariant))
+            val newRetTp = convertParameter(retTp, ScTypeParam.Covariant)
+            Some(ScFunctionType(newRetTp, newParams)(proj, scope))
+          case _ => None
+        }
+      case _ => None
+    }
+  }
 }

test/org/jetbrains/plugins/scala/annotator/SingleAbstractMethodTest.scala

@@ -293,17 +293,83 @@ class SingleAbstractMethodTest extends ScalaLightPlatformCodeInsightTestCaseAdap
     checkCodeHasNoErrors(code)
   }
 
-  def checkCodeHasNoErrors(code: String) {
-    assertMatches(messages(code)) {
+  def testExistentialBounds(): Unit = {
+    val code =
+      """
+        |trait Blargle[T] {
+        |  def foo(a: T): String
+        |}
+        |
+        |def f(b: Blargle[_ >: Int]) = -1
+        |f(s => s.toString)
+        |
+        |def g[T](b: Blargle[_ >: T]) = -1
+        |g((s: String) => s)
+        |
+        |trait Blergh[T] {
+        |  def foo(): T
+        |}
+        |
+        |def h[T](b: Blergh[_ <: T]) = -1
+        |h(() => "")
+        |def i(b: Blergh[_ <: String]) = -1
+        |i(() => "")
+        |
+      """.stripMargin
+    checkCodeHasNoErrors(code)
+  }
+
+  def testOverload(): Unit = {
+    val code =
+      """
+        |trait SAMOverload[A] {
+        |  def foo(s: A): Int = ???
+        |}
+        |
+        |def f[T](s: T): Unit = ()
+        |def f[T](s: T, a: SAMOverload[_ >: T]) = ()
+        |f("", (s: String) => 2)
+        |
+      """.stripMargin
+    checkCodeHasNoErrors(code)
+  }
+
+  def testJavaSAM(): Unit = {
+    val scalaCode = "new ObservableCopy(1).mapFunc(x => x + 1)"
+    val javaCode =
+      """
+        |public interface Func1<T, R> {
+        |    R call(T t);
+        |}
+        |
+        |public class ObservableCopy<T> {
+        |    public ObservableCopy(T t) {}
+        |
+        |    public final <R> ObservableCopy<R> mapFunc(Func1<? super T, ? extends R> func) {
+        |        return null;
+        |    }
+        |}
+        |
+      """.stripMargin
+    checkCodeHasNoErrors(scalaCode, Some(javaCode))
+  }
+
+  def checkCodeHasNoErrors(scalaCode: String, javaCode: Option[String] = None) {
+    assertMatches(messages(scalaCode, javaCode)) {
       case Nil =>
     }
   }
 
-  def messages(code: String): List[Message] = {
+  def messages(@Language("Scala") scalaCode: String, javaCode: Option[String] = None): List[Message] = {
+    javaCode match {
+      case Some(s) => configureFromFileTextAdapter("dummy.java", s)
+      case _ =>
+    }
+
     val annotator = new ScalaAnnotator() {}
     val mock = new AnnotatorHolderMock
 
-    val parse: ScalaFile = parseText(code)
+    val parse: ScalaFile = parseText(scalaCode)
 
     parse.depthFirst.foreach(annotator.annotate(_, mock))