remove support for SAM types in ImplicitFunctionParams rule and enhance tests for function type restrictions

Author: halotukozak

analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitFunctionParams.scala

@@ -13,7 +13,7 @@ class ImplicitFunctionParams(g: Global) extends AnalyzerRule(g, "implicitFunctio
         if (paramList.nonEmpty && paramList.head.mods.hasFlag(Flag.IMPLICIT)) {
           paramList.foreach { param =>
             val paramTpe = param.tpt.tpe
-            if (paramTpe != null && (definitions.isFunctionProto(paramTpe) || definitions.isPartialFunctionType(paramTpe))) {
+            if (paramTpe != null && (definitions.isFunctionType(paramTpe) || definitions.isPartialFunctionType(paramTpe))) {
               report(param.pos, "Implicit parameters should not have any function type")
             }
           }

analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitFunctionParamsTest.scala

@@ -53,4 +53,85 @@ class ImplicitFunctionParamsTest extends AnyFunSuite with AnalyzerTest {
         |}
       """.stripMargin)
   }
-}
+
+  test("implicit parameters with SAM types should pass") {
+    assertCompiles(
+      //language=Scala
+      """
+        |object whatever {
+        |  // Define a SAM type (Single Abstract Method)
+        |  trait IntToString {
+        |    def apply(i: Int): String
+        |  }
+        |
+        |  // This should pass - regular parameter with SAM type
+        |  def goodMethod1(f: IntToString): Unit = ???
+        |
+        |  // This should pass - implicit parameter with SAM type
+        |  def goodMethod2(implicit f: IntToString): Unit = ???
+        |
+        |  // This should pass - implicit parameter with SAM type in second parameter list
+        |  def goodMethod3(x: Int)(implicit f: IntToString): Unit = ???
+        |
+        |  // This should pass - regular class parameter with SAM type
+        |  class GoodClass1(f: IntToString)
+        |
+        |  // This should pass - implicit class parameter with SAM type
+        |  class GoodClass2(implicit f: IntToString)
+        |
+        |  // This should pass - implicit class parameter with SAM type in second parameter list
+        |  class GoodClass3(x: Int)(implicit f: IntToString)
+        |}
+      """.stripMargin)
+  }
+
+  test("implicit parameters should not be function types with multiple parameters") {
+    assertErrors(8,
+      //language=Scala
+      """
+        |object whatever {
+        |  // This should pass - regular parameter with Function2 type
+        |  def goodMethod1(f: (Int, String) => Boolean): Unit = ???
+        |
+        |  // This should pass - regular parameter with Function3 type
+        |  def goodMethod2(f: (Int, String, Double) => Boolean): Unit = ???
+        |
+        |  // This should pass - implicit parameter with non-function type
+        |  def goodMethod3(implicit s: String): Unit = ???
+        |
+        |  // This should fail - implicit parameter with Function2 type
+        |  def badMethod1(implicit f: (Int, String) => Boolean): Unit = ???
+        |
+        |  // This should fail - implicit parameter with Function2 type in second parameter list
+        |  def badMethod2(x: Int)(implicit f: (Int, String) => Boolean): Unit = ???
+        |
+        |  // This should fail - implicit parameter with Function3 type
+        |  def badMethod3(implicit f: (Int, String, Double) => Boolean): Unit = ???
+        |
+        |  // This should fail - implicit parameter with Function3 type in second parameter list
+        |  def badMethod4(x: Int)(implicit f: (Int, String, Double) => Boolean): Unit = ???
+        |
+        |  // This should pass - regular class parameter with Function2 type
+        |  class GoodClass1(f: (Int, String) => Boolean)
+        |
+        |  // This should pass - regular class parameter with Function3 type
+        |  class GoodClass2(f: (Int, String, Double) => Boolean)
+        |
+        |  // This should pass - implicit class parameter with non-function type
+        |  class GoodClass3(implicit s: String)
+        |
+        |  // This should fail - implicit class parameter with Function2 type
+        |  class BadClass1(implicit f: (Int, String) => Boolean)
+        |
+        |  // This should fail - implicit class parameter with Function2 type in second parameter list
+        |  class BadClass2(x: Int)(implicit f: (Int, String) => Boolean)
+        |
+        |  // This should fail - implicit class parameter with Function3 type
+        |  class BadClass3(implicit f: (Int, String, Double) => Boolean)
+        |
+        |  // This should fail - implicit class parameter with Function3 type in second parameter list
+        |  class BadClass4(x: Int)(implicit f: (Int, String, Double) => Boolean)
+        |}
+      """.stripMargin)
+  }
+}