From 22b6e0f9c7484fd9420fa7fcfbcb69052510f7a8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Tue, 15 Apr 2025 18:52:32 +0200
Subject: [PATCH 01/14] add ImplicitValueClasses rule to enforce extending
 AnyVal for implicit classes

---
 .../commons/analyzer/AnalyzerPlugin.scala     |  1 +
 .../analyzer/ImplicitValueClasses.scala       | 24 ++++++++++++
 .../analyzer/ImplicitValueClassesTest.scala   | 38 +++++++++++++++++++
 3 files changed, 63 insertions(+)
 create mode 100644 analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala
 create mode 100644 analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala

diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
index eacfa6ef5..7e749211c 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
@@ -59,6 +59,7 @@ final class AnalyzerPlugin(val global: Global) extends Plugin { plugin =>
     new BadSingletonComponent(global),
     new ConstantDeclarations(global),
     new BasePackage(global),
+    new ImplicitValueClasses(global),
   )
 
   private lazy val rulesByName = rules.map(r => (r.name, r)).toMap
diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala
new file mode 100644
index 000000000..f322a0291
--- /dev/null
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala
@@ -0,0 +1,24 @@
+package com.avsystem.commons
+package analyzer
+
+import scala.tools.nsc.Global
+
+class ImplicitValueClasses(g: Global) extends AnalyzerRule(g, "implicitValueClasses", Level.Warn) {
+
+  import global.*
+
+  private lazy val anyValTpe = typeOf[AnyVal]
+
+  def analyze(unit: CompilationUnit): Unit = unit.body.foreach {
+    case cd: ClassDef if cd.mods.hasFlag(Flag.IMPLICIT) =>
+      val tpe = cd.symbol.typeSignature
+      val primaryCtor = tpe.member(termNames.CONSTRUCTOR).alternatives.find(_.asMethod.isPrimaryConstructor)
+      val paramLists = primaryCtor.map(_.asMethod.paramLists)
+      val hasExactlyOneParam = paramLists.forall(lists => lists.size == 1 && lists.head.size == 1)
+
+      if (!tpe.baseClasses.contains(anyValTpe.typeSymbol) && hasExactlyOneParam) {
+        report(cd.pos, "Implicit classes should always extend AnyVal to become value classes")
+      }
+    case _ =>
+  }
+}
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala
new file mode 100644
index 000000000..76214bb37
--- /dev/null
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala
@@ -0,0 +1,38 @@
+package com.avsystem.commons
+package analyzer
+
+import org.scalatest.funsuite.AnyFunSuite
+
+class ImplicitValueClassesTest extends AnyFunSuite with AnalyzerTest {
+  test("implicit classes should extend AnyVal") {
+    assertErrors(2,
+      """
+        |object whatever {
+        |  // This should pass - implicit class extending AnyVal
+        |  implicit class GoodImplicitClass(val x: Int) extends AnyVal {
+        |    def double: Int = x * 2
+        |  }
+        |
+        |  // This should fail - implicit class not extending AnyVal
+        |  implicit class BadImplicitClass1(val x: Int) {
+        |    def double: Int = x * 2
+        |  }
+        |
+        |  // This should fail - another implicit class not extending AnyVal
+        |  implicit class BadImplicitClass2[T <: Int](val x: T) {
+        |    def double: Int = x * 2
+        |  }
+        |
+        |  // Regular class - should not be affected
+        |  class RegularClass(val x: Int) {
+        |    def double: Int = x * 2
+        |  }
+        |
+        |  // implicit class with implicit parameter - should not be affected
+        |  implicit class ImplicitClassWithImplicitParameter(val x: Int)(implicit dummy: DummyImplicit) {
+        |    def double: Int = x * 2
+        |  }
+        |}
+      """.stripMargin)
+  }
+}
\ No newline at end of file

From e3c37cc9262359492bcc0169c0d1d0aa8e68fd93 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Tue, 15 Apr 2025 19:04:59 +0200
Subject: [PATCH 02/14] add FinalValueClasses rule to enforce marking value
 classes as final

---
 .../commons/analyzer/AnalyzerPlugin.scala     |  1 +
 .../commons/analyzer/FinalValueClasses.scala  | 21 ++++++++++
 .../analyzer/FinalValueClassesTest.scala      | 39 +++++++++++++++++++
 3 files changed, 61 insertions(+)
 create mode 100644 analyzer/src/main/scala/com/avsystem/commons/analyzer/FinalValueClasses.scala
 create mode 100644 analyzer/src/test/scala/com/avsystem/commons/analyzer/FinalValueClassesTest.scala

diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
index 7e749211c..8483df1fd 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
@@ -60,6 +60,7 @@ final class AnalyzerPlugin(val global: Global) extends Plugin { plugin =>
     new ConstantDeclarations(global),
     new BasePackage(global),
     new ImplicitValueClasses(global),
+    new FinalValueClasses(global),
   )
 
   private lazy val rulesByName = rules.map(r => (r.name, r)).toMap
diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/FinalValueClasses.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/FinalValueClasses.scala
new file mode 100644
index 000000000..d6054e242
--- /dev/null
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/FinalValueClasses.scala
@@ -0,0 +1,21 @@
+package com.avsystem.commons
+package analyzer
+
+import scala.tools.nsc.Global
+
+class FinalValueClasses(g: Global) extends AnalyzerRule(g, "finalValueClasses", Level.Warn) {
+
+  import global.*
+
+  private lazy val anyValTpe = typeOf[AnyVal]
+
+  def analyze(unit: CompilationUnit): Unit = unit.body.foreach {
+    case cd: ClassDef if !cd.mods.hasFlag(Flag.FINAL) =>
+      val tpe = cd.symbol.typeSignature
+
+      if (tpe.baseClasses.contains(anyValTpe.typeSymbol) ) {
+        report(cd.pos, "Value classes should be marked as final")
+      }
+    case _ =>
+  }
+}
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/FinalValueClassesTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/FinalValueClassesTest.scala
new file mode 100644
index 000000000..47cbdfb4b
--- /dev/null
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/FinalValueClassesTest.scala
@@ -0,0 +1,39 @@
+package com.avsystem.commons
+package analyzer
+
+import org.scalatest.funsuite.AnyFunSuite
+
+class FinalValueClassesTest extends AnyFunSuite with AnalyzerTest {
+  test("value classes should be marked as final") {
+    assertErrors(2,
+      """
+        |object whatever {
+        |  // This should pass - final value class
+        |  final class GoodValueClass(val x: Int) extends AnyVal {
+        |    def double: Int = x * 2
+        |  }
+        |
+        |  // This should fail - value class not marked as final
+        |  class BadValueClass1(val x: Int) extends AnyVal {
+        |    def double: Int = x * 2
+        |  }
+        |
+        |  // This should fail - another value class not marked as final
+        |  class BadValueClass2[T <: Int](val x: T) extends AnyVal {
+        |    def double: Int = x * 2
+        |  }
+        |
+        |  // Regular class extending AnyVal but not marked as final - should not be affected
+        |  // because it has multiple parameters
+        |  class RegularClass(val x: Int, val y: Int) {
+        |    def double: Int = x * 2
+        |  }
+        |
+        |  // Regular class not extending AnyVal - should not be affected
+        |  class RegularClass2(val x: Int) {
+        |    def double: Int = x * 2
+        |  }
+        |}
+      """.stripMargin)
+  }
+}
\ No newline at end of file

From b189364ad211b135a8cc22a882f376bb3265f72a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Tue, 15 Apr 2025 19:16:08 +0200
Subject: [PATCH 03/14] add ImplicitParamDefaults rule to prevent default
 values for implicit parameters

---
 .../commons/analyzer/AnalyzerPlugin.scala     |  1 +
 .../analyzer/ImplicitParamDefaults.scala      | 23 +++++++++
 .../analyzer/ImplicitParamDefaultsTest.scala  | 49 +++++++++++++++++++
 3 files changed, 73 insertions(+)
 create mode 100644 analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitParamDefaults.scala
 create mode 100644 analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitParamDefaultsTest.scala

diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
index 8483df1fd..4e6614d25 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
@@ -61,6 +61,7 @@ final class AnalyzerPlugin(val global: Global) extends Plugin { plugin =>
     new BasePackage(global),
     new ImplicitValueClasses(global),
     new FinalValueClasses(global),
+    new ImplicitParamDefaults(global),
   )
 
   private lazy val rulesByName = rules.map(r => (r.name, r)).toMap
diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitParamDefaults.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitParamDefaults.scala
new file mode 100644
index 000000000..3a04cb933
--- /dev/null
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitParamDefaults.scala
@@ -0,0 +1,23 @@
+package com.avsystem.commons
+package analyzer
+
+import scala.tools.nsc.Global
+
+class ImplicitParamDefaults(g: Global) extends AnalyzerRule(g, "implicitParamDefaults", Level.Warn) {
+
+  import global.*
+
+  def analyze(unit: CompilationUnit): Unit = unit.body.foreach {
+    case dd: DefDef =>
+      dd.vparamss.foreach { paramList =>
+        if (paramList.nonEmpty && paramList.head.mods.hasFlag(Flag.IMPLICIT)) {
+          paramList.foreach { param =>
+            if (param.rhs != EmptyTree) {
+              report(param.pos, "Do not declare default values for implicit parameters")
+            }
+          }
+        }
+      }
+    case _ =>
+  }
+}
\ No newline at end of file
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitParamDefaultsTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitParamDefaultsTest.scala
new file mode 100644
index 000000000..9449219d9
--- /dev/null
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitParamDefaultsTest.scala
@@ -0,0 +1,49 @@
+package com.avsystem.commons
+package analyzer
+
+import org.scalatest.funsuite.AnyFunSuite
+
+class ImplicitParamDefaultsTest extends AnyFunSuite with AnalyzerTest {
+  test("implicit parameters should not have default values") {
+    assertErrors(6,
+      """
+        |object whatever {
+        |  // This should pass - implicit parameter without default value
+        |  def goodMethod1(implicit s: Scheduler): Unit = ???
+        |
+        |  // This should pass - regular parameter with default value
+        |  def goodMethod2(s: Scheduler = Scheduler.global): Unit = ???
+        |
+        |  // This should fail - implicit parameter with default value
+        |  def badMethod1(implicit s: Scheduler = Scheduler.global): Unit = ???
+        |
+        |  // This should fail - implicit parameter with default value
+        |  def badMethod(sth: Int)(implicit s: Scheduler = Scheduler.global): Unit = ???
+        |
+        |  // This should fail - another implicit parameter with default value
+        |  def badMethod2[T](x: T)(implicit s: Scheduler = Scheduler.global): T = ???
+        |
+        |  // This should pass - implicit parameter without default value
+        |  class GoodClass1(implicit s: Scheduler)
+        |
+        |  // This should pass - regular parameter with default value
+        |  class GoodClass2(s: Scheduler = Scheduler.global)
+        |
+        |  // This should fail - implicit parameter with default value
+        |  class BadClass1(implicit s: Scheduler = Scheduler.global)
+        |
+        |  // This should fail - implicit parameter with default value
+        |  class BadClass2(sth: Int)(implicit s: Scheduler = Scheduler.global)
+        |
+        |  // This should fail - another implicit parameter with default value
+        |  class BadClass3[T](x: T)(implicit s: Scheduler = Scheduler.global)
+        |
+        |  // Dummy classes for the test
+        |  class Scheduler
+        |  object Scheduler {
+        |    val global = new Scheduler
+        |  }
+        |}
+      """.stripMargin)
+  }
+}
\ No newline at end of file

From 7edce9a9ed0bbd5275c80942b92127609ef4ac17 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Thu, 17 Apr 2025 13:48:28 +0200
Subject: [PATCH 04/14] ImplicitValueClasses rule: divide test into several
 ones, add Universal Trait and inheriting classes support. If class is nested,
 only info. Add nested classes support

---
 .idea/codeStyles/Project.xml                  |  18 --
 .../commons/analyzer/AnalyzerRule.scala       |   3 +-
 .../analyzer/ImplicitValueClasses.scala       |  32 ++-
 .../commons/analyzer/ImplicitTypesTest.scala  |   2 +-
 .../analyzer/ImplicitValueClassesTest.scala   | 211 ++++++++++++++++--
 5 files changed, 226 insertions(+), 40 deletions(-)

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index cb14e62c6..095539431 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,23 +1,5 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
-    <JetCodeStyleSettings>
-      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
-        <value>
-          <package name="java.util" alias="false" withSubpackages="false" />
-          <package name="kotlinx.android.synthetic" alias="false" withSubpackages="true" />
-          <package name="io.ktor" alias="false" withSubpackages="true" />
-        </value>
-      </option>
-      <option name="PACKAGES_IMPORT_LAYOUT">
-        <value>
-          <package name="" alias="false" withSubpackages="true" />
-          <package name="java" alias="false" withSubpackages="true" />
-          <package name="javax" alias="false" withSubpackages="true" />
-          <package name="kotlin" alias="false" withSubpackages="true" />
-          <package name="" alias="true" withSubpackages="true" />
-        </value>
-      </option>
-    </JetCodeStyleSettings>
     <ScalaCodeStyleSettings>
       <option name="addImportsRelativeToBasePackage" value="false" />
       <option name="importsWithPrefix">
diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerRule.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerRule.scala
index d5b42f0f0..33a1b0a09 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerRule.scala
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerRule.scala
@@ -32,7 +32,8 @@ abstract class AnalyzerRule(val global: Global, val name: String, defaultLevel:
     pos: Position,
     message: String,
     category: WarningCategory = WarningCategory.Lint,
-    site: Symbol = NoSymbol
+    site: Symbol = NoSymbol,
+    level: Level = this.level
   ): Unit =
     level match {
       case Level.Off =>
diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala
index f322a0291..52dae558e 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala
@@ -6,18 +6,42 @@ import scala.tools.nsc.Global
 class ImplicitValueClasses(g: Global) extends AnalyzerRule(g, "implicitValueClasses", Level.Warn) {
 
   import global.*
+  import definitions.*
 
-  private lazy val anyValTpe = typeOf[AnyVal]
+  private lazy val defaultClasses = Set[Symbol](AnyClass, AnyValClass, ObjectClass)
+
+  private lazy val reportOnNestedClasses = argument match {
+    case null => false
+    case a => a.toBoolean
+  }
+
+  private lazy val message = "Implicit classes should always extend AnyVal to become value classes" +
+    (if (reportOnNestedClasses) ". Nested classes should be extracted to top-level objects" else "")
 
   def analyze(unit: CompilationUnit): Unit = unit.body.foreach {
     case cd: ClassDef if cd.mods.hasFlag(Flag.IMPLICIT) =>
       val tpe = cd.symbol.typeSignature
       val primaryCtor = tpe.member(termNames.CONSTRUCTOR).alternatives.find(_.asMethod.isPrimaryConstructor)
       val paramLists = primaryCtor.map(_.asMethod.paramLists)
-      val hasExactlyOneParam = paramLists.forall(lists => lists.size == 1 && lists.head.size == 1)
+      val inheritsAnyVal = tpe.baseClasses contains AnyValClass
+
+      def inheritsOtherClass = tpe.baseClasses.exists { cls =>
+        def isDefault = defaultClasses contains cls
+        def isUniversalTrait = cls.isTrait && cls.superClass == AnyClass
+
+        cls != cd.symbol && !isDefault && !isUniversalTrait
+      }
+      def hasExactlyOneParam = paramLists.forall(lists => lists.size == 1 && lists.head.size == 1)
+
+      if (!inheritsAnyVal && !inheritsOtherClass && hasExactlyOneParam) {
+        def isNestedClass =
+          //implicit classes are always nested classes, so we want to check if the outer class's an object
+          /*cd.symbol.isNestedClass &&*/ !cd.symbol.isStatic
 
-      if (!tpe.baseClasses.contains(anyValTpe.typeSymbol) && hasExactlyOneParam) {
-        report(cd.pos, "Implicit classes should always extend AnyVal to become value classes")
+        if (reportOnNestedClasses || !isNestedClass)
+          report(cd.pos, message)
+        else
+          report(cd.pos, message, level = Level.Info)
       }
     case _ =>
   }
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitTypesTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitTypesTest.scala
index f7d07a83f..d17c8601d 100644
--- a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitTypesTest.scala
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitTypesTest.scala
@@ -13,7 +13,7 @@ class ImplicitTypesTest extends AnyFunSuite with AnalyzerTest {
         |  implicit def conv(x: Int) = x.toString
         |  implicit def conv2(x: Int): String = x.toString
         |  implicit object objekt
-        |  implicit class wtf(x: Int)
+        |  implicit final class wtf(val x: Int) extends AnyVal
         |}
       """.stripMargin)
   }
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala
index 76214bb37..d8e9d118e 100644
--- a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala
@@ -1,38 +1,217 @@
 package com.avsystem.commons
 package analyzer
 
+import org.scalatest.Suites
 import org.scalatest.funsuite.AnyFunSuite
 
-class ImplicitValueClassesTest extends AnyFunSuite with AnalyzerTest {
-  test("implicit classes should extend AnyVal") {
-    assertErrors(2,
+class DefaultImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
+  test("implicit final class extending AnyVal should pass") {
+    assertNoErrors(
+      //language=Scala
       """
         |object whatever {
-        |  // This should pass - implicit class extending AnyVal
-        |  implicit class GoodImplicitClass(val x: Int) extends AnyVal {
+        |  implicit final class GoodImplicitClass(val x: Int) extends AnyVal {
         |    def double: Int = x * 2
         |  }
-        |
-        |  // This should fail - implicit class not extending AnyVal
-        |  implicit class BadImplicitClass1(val x: Int) {
+        |}
+      """.stripMargin)
+  }
+
+  test("implicit class not extending AnyVal should fail") {
+    assertErrors(1,
+      //language=Scala
+      """
+        |object whatever {
+        |  implicit final class BadImplicitClass(val x: Int) {
         |    def double: Int = x * 2
         |  }
-        |
-        |  // This should fail - another implicit class not extending AnyVal
-        |  implicit class BadImplicitClass2[T <: Int](val x: T) {
+        |}
+      """.stripMargin)
+  }
+
+  test("implicit class with type parameter not extending AnyVal should fail") {
+    assertErrors(1,
+      //language=Scala
+      """
+        |object whatever {
+        |  implicit final class BadImplicitClass[T <: Int](val x: T) {
         |    def double: Int = x * 2
         |  }
-        |
-        |  // Regular class - should not be affected
+        |}
+      """.stripMargin)
+  }
+
+  test("regular class should not be affected") {
+    assertNoErrors(
+      //language=Scala
+      """
+        |object whatever {
         |  class RegularClass(val x: Int) {
         |    def double: Int = x * 2
         |  }
+        |}
+      """.stripMargin)
+  }
+
+  test("implicit class with implicit parameter should not be affected") {
+    assertNoErrors(
+      //language=Scala
+      """
+        |object whatever {
+        |  implicit final class ImplicitClassWithImplicitParameter(val x: Int)(implicit dummy: DummyImplicit) {
+        |    def double: Int = x * 2
+        |  }
+        |}
+      """.stripMargin)
+  }
+
+  test("implicit class extending other classes should not be affected") {
+    assertNoErrors(
+      //language=Scala
+      """
+        |object whatever {
+        |  class SomeClass
+        |
+        |  implicit final class GoodImplicitClass1(val x: Int) extends SomeClass {
+        |    def double: Int = x * 2
+        |  }
         |
-        |  // implicit class with implicit parameter - should not be affected
-        |  implicit class ImplicitClassWithImplicitParameter(val x: Int)(implicit dummy: DummyImplicit) {
+        |  trait SomeTrait
+        |  implicit final class GoodImplicitClass2(val x: Int) extends SomeTrait {
         |    def double: Int = x * 2
         |  }
         |}
       """.stripMargin)
   }
-}
\ No newline at end of file
+
+  test("implicit class extending AnyVal with traits should be handled correctly") {
+    //language=Scala
+    assertErrors(1,
+      """
+        |object whatever {
+        |  trait AnyTrait extends Any
+        |  implicit final class GoodImplicitClass(val x: Int) extends AnyVal with AnyTrait {
+        |    def double: Int = x * 2
+        |  }
+        |  implicit final class BadImplicitClass(val x: Int) extends AnyTrait {
+        |    def double: Int = x * 2
+        |  }
+        |}
+      """.stripMargin)
+  }
+
+  test("nested implicit class not extending AnyVal should pass") {
+    assertNoErrors(
+      //language=Scala
+      """
+        |object whatever {
+        |  class Outer {
+        |    implicit final class NestedImplicitClass(val x: Int) {
+        |      def double: Int = x * 2
+        |    }
+        |  }
+        |}
+      """.stripMargin)
+  }
+}
+
+class NestedImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
+  settings.pluginOptions.value ++= List("AVSystemAnalyzer:+implicitValueClasses:true")
+
+  test("nested implicit class not extending AnyVal should fail") {
+    assertErrors(1,
+      """
+        |object whatever {
+        |  class Outer {
+        |    implicit final class GoodNestedImplicitClass(val x: Int) {
+        |      def double: Int = x * 2
+        |    }
+        |  }
+        |}
+      """.stripMargin)
+  }
+
+
+  test("nested implicit class with type parameter not extending AnyVal should fail") {
+    assertErrors(1,
+      """
+        |object whatever {
+        |  class Outer {
+        |    implicit final class BadNestedImplicitClass[T <: Int](val x: T) {
+        |      def double: Int = x * 2
+        |    }
+        |  }
+        |}
+      """.stripMargin)
+  }
+
+  test("deeply nested implicit class not extending AnyVal should fail") {
+    assertErrors(1,
+      """
+        |object whatever {
+        |  class Outer {
+        |    class Inner {
+        |      implicit final class BadDeeplyNestedImplicitClass(val x: Int) {
+        |        def double: Int = x * 2
+        |      }
+        |    }
+        |  }
+        |}
+      """.stripMargin)
+  }
+
+  test("regular class should not be affected") {
+    assertNoErrors(
+      """
+        |object whatever {
+        |  class Outer {
+        |    class RegularClass(val x: Int) {
+        |      def double: Int = x * 2
+        |    }
+        |  }
+        |}
+      """.stripMargin)
+  }
+
+  test("implicit class extending other classes should not be affected") {
+    assertNoErrors(
+      """
+        |object whatever {
+        |  class Outer {
+        |    class SomeClass
+        |
+        |    implicit final class GoodImplicitClass1(val x: Int) extends SomeClass {
+        |      def double: Int = x * 2
+        |    }
+        |
+        |    trait SomeTrait
+        |    implicit final class GoodImplicitClass2(val x: Int) extends SomeTrait {
+        |      def double: Int = x * 2
+        |    }
+        |  }
+        |}
+      """.stripMargin)
+  }
+
+  test("implicit class extending AnyVal with traits should be handled correctly") {
+    assertErrors(1,
+      """
+        |object whatever {
+        |  class Outer {
+        |    trait AnyTrait extends Any
+        |    implicit final class GoodImplicitClass(val x: Int) extends AnyVal with AnyTrait {
+        |      def double: Int = x * 2
+        |    }
+        |    implicit final class BadImplicitClass(val x: Int) extends AnyTrait {
+        |      def double: Int = x * 2
+        |    }
+        |  }
+        |}
+      """.stripMargin)
+  }
+}
+
+class ImplicitValueClassesTest extends Suites(
+  new DefaultImplicitValueClassesSuite,
+  new NestedImplicitValueClassesSuite
+)

From 9964dd434f0618ef6aac6d55386f56af456ab99b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Thu, 17 Apr 2025 13:59:46 +0200
Subject: [PATCH 05/14] do not run same tests twice

---
 .../commons/analyzer/ImplicitValueClassesTest.scala       | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala
index d8e9d118e..e701f3cc5 100644
--- a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala
@@ -1,10 +1,9 @@
 package com.avsystem.commons
 package analyzer
 
-import org.scalatest.Suites
 import org.scalatest.funsuite.AnyFunSuite
 
-class DefaultImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
+class ImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
   test("implicit final class extending AnyVal should pass") {
     assertNoErrors(
       //language=Scala
@@ -210,8 +209,3 @@ class NestedImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
       """.stripMargin)
   }
 }
-
-class ImplicitValueClassesTest extends Suites(
-  new DefaultImplicitValueClassesSuite,
-  new NestedImplicitValueClassesSuite
-)

From 746d402b1aaa8e3182ca660038aa77b7734690fd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Thu, 17 Apr 2025 14:10:54 +0200
Subject: [PATCH 06/14] refactor ImplicitValueClasses rule: move message
 construction inside analyze method

---
 .idea/codeStyles/Project.xml                   | 18 ++++++++++++++++++
 .../analyzer/ImplicitValueClasses.scala        |  8 ++++----
 2 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
index 095539431..cb14e62c6 100644
--- a/.idea/codeStyles/Project.xml
+++ b/.idea/codeStyles/Project.xml
@@ -1,5 +1,23 @@
 <component name="ProjectCodeStyleConfiguration">
   <code_scheme name="Project" version="173">
+    <JetCodeStyleSettings>
+      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
+        <value>
+          <package name="java.util" alias="false" withSubpackages="false" />
+          <package name="kotlinx.android.synthetic" alias="false" withSubpackages="true" />
+          <package name="io.ktor" alias="false" withSubpackages="true" />
+        </value>
+      </option>
+      <option name="PACKAGES_IMPORT_LAYOUT">
+        <value>
+          <package name="" alias="false" withSubpackages="true" />
+          <package name="java" alias="false" withSubpackages="true" />
+          <package name="javax" alias="false" withSubpackages="true" />
+          <package name="kotlin" alias="false" withSubpackages="true" />
+          <package name="" alias="true" withSubpackages="true" />
+        </value>
+      </option>
+    </JetCodeStyleSettings>
     <ScalaCodeStyleSettings>
       <option name="addImportsRelativeToBasePackage" value="false" />
       <option name="importsWithPrefix">
diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala
index 52dae558e..65c616ec8 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala
@@ -15,9 +15,6 @@ class ImplicitValueClasses(g: Global) extends AnalyzerRule(g, "implicitValueClas
     case a => a.toBoolean
   }
 
-  private lazy val message = "Implicit classes should always extend AnyVal to become value classes" +
-    (if (reportOnNestedClasses) ". Nested classes should be extracted to top-level objects" else "")
-
   def analyze(unit: CompilationUnit): Unit = unit.body.foreach {
     case cd: ClassDef if cd.mods.hasFlag(Flag.IMPLICIT) =>
       val tpe = cd.symbol.typeSignature
@@ -34,10 +31,13 @@ class ImplicitValueClasses(g: Global) extends AnalyzerRule(g, "implicitValueClas
       def hasExactlyOneParam = paramLists.forall(lists => lists.size == 1 && lists.head.size == 1)
 
       if (!inheritsAnyVal && !inheritsOtherClass && hasExactlyOneParam) {
-        def isNestedClass =
+        val isNestedClass =
           //implicit classes are always nested classes, so we want to check if the outer class's an object
           /*cd.symbol.isNestedClass &&*/ !cd.symbol.isStatic
 
+        val message = "Implicit classes should always extend AnyVal to become value classes" +
+          (if (isNestedClass) ". Nested classes should be extracted to top-level objects" else "")
+
         if (reportOnNestedClasses || !isNestedClass)
           report(cd.pos, message)
         else

From 1a234f92c6cb0087754ed457863b644b2708be2a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Thu, 17 Apr 2025 15:01:57 +0200
Subject: [PATCH 07/14] add CatchThrowable rule to discourage catching
 Throwable directly and edit README

---
 .../commons/analyzer/AnalyzerPlugin.scala     |  1 +
 .../commons/analyzer/CatchThrowable.scala     | 22 ++++++
 .../commons/analyzer/CatchThrowableTest.scala | 75 +++++++++++++++++++
 .../analyzer/ImplicitParamDefaultsTest.scala  |  1 +
 docs/Analyzer.md                              |  4 +
 5 files changed, 103 insertions(+)
 create mode 100644 analyzer/src/main/scala/com/avsystem/commons/analyzer/CatchThrowable.scala
 create mode 100644 analyzer/src/test/scala/com/avsystem/commons/analyzer/CatchThrowableTest.scala

diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
index 4e6614d25..0c7441171 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
@@ -62,6 +62,7 @@ final class AnalyzerPlugin(val global: Global) extends Plugin { plugin =>
     new ImplicitValueClasses(global),
     new FinalValueClasses(global),
     new ImplicitParamDefaults(global),
+    new CatchThrowable(global),
   )
 
   private lazy val rulesByName = rules.map(r => (r.name, r)).toMap
diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/CatchThrowable.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/CatchThrowable.scala
new file mode 100644
index 000000000..7f24d6a9f
--- /dev/null
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/CatchThrowable.scala
@@ -0,0 +1,22 @@
+package com.avsystem.commons
+package analyzer
+
+import scala.tools.nsc.Global
+
+class CatchThrowable(g: Global) extends AnalyzerRule(g, "catchThrowable", Level.Warn) {
+
+  import global._
+
+  private lazy val throwableTpe = typeOf[Throwable]
+
+  def analyze(unit: CompilationUnit): Unit =
+    unit.body.foreach {
+      case t: Try =>
+        t.catches.foreach { case cas@CaseDef(pat, _, _) =>
+          if (pat.tpe != null && pat.tpe =:= throwableTpe) {
+            report(cas.pos, "Catching Throwable is discouraged, catch specific exceptions instead")
+          }
+        }
+      case _ =>
+    }
+}
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/CatchThrowableTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/CatchThrowableTest.scala
new file mode 100644
index 000000000..e9ec57dbc
--- /dev/null
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/CatchThrowableTest.scala
@@ -0,0 +1,75 @@
+package com.avsystem.commons
+package analyzer
+
+import org.scalatest.funsuite.AnyFunSuite
+
+class CatchThrowableTest extends AnyFunSuite with AnalyzerTest {
+  test("catching Throwable should be rejected") {
+    assertErrors(1,
+      //language=Scala
+      """
+        |object Test {
+        |  def test(): Unit = {
+        |    try {
+        |      println("test")
+        |    } catch {
+        |      case t: Throwable => println(t)
+        |    }
+        |  }
+        |}
+      """.stripMargin)
+  }
+
+  test("catching specific exceptions should be allowed") {
+    assertNoErrors(
+      //language=Scala
+      """
+        |object Test {
+        |  def test(): Unit = {
+        |    try {
+        |      println("test")
+        |    } catch {
+        |      case e: Exception => println(e)
+        |      case e: RuntimeException => println(e)
+        |      case e: IllegalArgumentException => println(e)
+        |    }
+        |  }
+        |}
+      """.stripMargin)
+  }
+
+  test("catching Throwable with other exceptions should be rejected") {
+    assertErrors(1,
+      //language=Scala
+      """
+        |object Test {
+        |  def test(): Unit = {
+        |    try {
+        |      println("test")
+        |    } catch {
+        |      case e: IllegalArgumentException => println(e)
+        |      case t: Throwable => println(t)
+        |    }
+        |  }
+        |}
+      """.stripMargin)
+  }
+
+  test("catching Throwable in nested catch block should be rejected") {
+    assertErrors(1,
+      //language=Scala
+      """
+        |object Test {
+        |  def test(): Unit = {
+        |    try println("test")
+        |    catch {
+        |      case e: Exception => try println("test")
+        |      catch {
+        |        case e: Throwable => println(e)
+        |      }
+        |    }
+        |  }
+        |}
+      """.stripMargin)
+  }
+}
\ No newline at end of file
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitParamDefaultsTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitParamDefaultsTest.scala
index 9449219d9..05a153a17 100644
--- a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitParamDefaultsTest.scala
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitParamDefaultsTest.scala
@@ -6,6 +6,7 @@ import org.scalatest.funsuite.AnyFunSuite
 class ImplicitParamDefaultsTest extends AnyFunSuite with AnalyzerTest {
   test("implicit parameters should not have default values") {
     assertErrors(6,
+      //language=Scala
       """
         |object whatever {
         |  // This should pass - implicit parameter without default value
diff --git a/docs/Analyzer.md b/docs/Analyzer.md
index 5ef4d58fc..ad41bbf10 100644
--- a/docs/Analyzer.md
+++ b/docs/Analyzer.md
@@ -31,6 +31,10 @@ Here's a list of currently supported rules:
 | `throwableObjects`         | warning       | Makes sure that objects are never used as `Throwable`s (unless they have stack traces disabled)                                                                                                      |
 | `constantDeclarations`     | off           | Checks if constants are always declared as `final val`s with `UpperCamelCase` and no explicit type annotation for literal values                                                                     |
 | `basePackage`              | warning       | Checks if all sources are within the specified base package                                                                                                                                          |
+| `catchThrowable`           | warning       | Makes sure that code does not catch `Throwable` directly, which can hide critical errors like `OutOfMemoryError`                                                                                     |
+| `finalValueClasses`        | warning       | Makes sure that value classes are marked final.                                                                                                                                                      |
+| `implicitParamDefaults`    | warning       | Makes sure that default values are not defined for implicit parameters                                                                                                                               |
+| `implicitValueClasses`     | warning       | Makes sure that implicit classes extend `AnyVal` (when applicable). Nested classes check can be enabled by passing the `true` argument.                                                              |
 
 Rules may be enabled and disabled in `build.sbt` with Scala compiler options:
 

From fbafdfba53289661c40e907a844bea9dfeec85f4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Thu, 17 Apr 2025 15:33:16 +0200
Subject: [PATCH 08/14] add ImplicitFunctionParams rule to prevent implicit
 parameters from being function types or partial functions

---
 .../commons/analyzer/AnalyzerPlugin.scala     |  1 +
 .../analyzer/ImplicitFunctionParams.scala     | 24 ++++++++
 .../analyzer/ImplicitFunctionParamsTest.scala | 56 +++++++++++++++++++
 docs/Analyzer.md                              |  1 +
 4 files changed, 82 insertions(+)
 create mode 100644 analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitFunctionParams.scala
 create mode 100644 analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitFunctionParamsTest.scala

diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
index 0c7441171..89a02dbef 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
@@ -63,6 +63,7 @@ final class AnalyzerPlugin(val global: Global) extends Plugin { plugin =>
     new FinalValueClasses(global),
     new ImplicitParamDefaults(global),
     new CatchThrowable(global),
+    new ImplicitFunctionParams(global),
   )
 
   private lazy val rulesByName = rules.map(r => (r.name, r)).toMap
diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitFunctionParams.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitFunctionParams.scala
new file mode 100644
index 000000000..669b3a79d
--- /dev/null
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitFunctionParams.scala
@@ -0,0 +1,24 @@
+package com.avsystem.commons
+package analyzer
+
+import scala.tools.nsc.Global
+
+class ImplicitFunctionParams(g: Global) extends AnalyzerRule(g, "implicitFunctionParams", Level.Warn) {
+
+  import global.*
+
+  def analyze(unit: CompilationUnit): Unit = unit.body.foreach {
+    case dd: DefDef =>
+      dd.vparamss.foreach { paramList =>
+        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))) {
+              report(param.pos, "Implicit parameters should not have any function type")
+            }
+          }
+        }
+      }
+    case _ =>
+  }
+}
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitFunctionParamsTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitFunctionParamsTest.scala
new file mode 100644
index 000000000..683021514
--- /dev/null
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitFunctionParamsTest.scala
@@ -0,0 +1,56 @@
+package com.avsystem.commons
+package analyzer
+
+import org.scalatest.funsuite.AnyFunSuite
+
+class ImplicitFunctionParamsTest extends AnyFunSuite with AnalyzerTest {
+  test("implicit parameters should not be function types or partial functions") {
+    assertErrors(8,
+      //language=Scala
+      """
+        |object whatever {
+        |  // This should pass - regular parameter with function type
+        |  def goodMethod1(f: Int => String): Unit = ???
+        |
+        |  // This should pass - regular parameter with partial function type
+        |  def goodMethod2(pf: PartialFunction[Int, String]): Unit = ???
+        |
+        |  // This should pass - implicit parameter with non-function type
+        |  def goodMethod3(implicit s: String): Unit = ???
+        |
+        |  // This should fail - implicit parameter with function type
+        |  def badMethod1(implicit f: Int => String): Unit = ???
+        |
+        |  // This should fail - implicit parameter with function type in second parameter list
+        |  def badMethod2(x: Int)(implicit f: Int => String): Unit = ???
+        |
+        |  // This should fail - implicit parameter with partial function type
+        |  def badMethod3(implicit pf: PartialFunction[Int, String]): Unit = ???
+        |
+        |  // This should fail - implicit parameter with partial function type in second parameter list
+        |  def badMethod4(x: Int)(implicit pf: PartialFunction[Int, String]): Unit = ???
+        |
+        |  // This should pass - regular class parameter with function type
+        |  class GoodClass1(f: Int => String)
+        |
+        |  // This should pass - regular class parameter with partial function type
+        |  class GoodClass2(pf: PartialFunction[Int, String])
+        |
+        |  // This should pass - implicit class parameter with non-function type
+        |  class GoodClass3(implicit s: String)
+        |
+        |  // This should fail - implicit class parameter with function type
+        |  class BadClass1(implicit f: Int => String)
+        |
+        |  // This should fail - implicit class parameter with function type in second parameter list
+        |  class BadClass2(x: Int)(implicit f: Int => String)
+        |
+        |  // This should fail - implicit class parameter with partial function type
+        |  class BadClass3(implicit pf: PartialFunction[Int, String])
+        |
+        |  // This should fail - implicit class parameter with partial function type in second parameter list
+        |  class BadClass4(x: Int)(implicit pf: PartialFunction[Int, String])
+        |}
+      """.stripMargin)
+  }
+}
\ No newline at end of file
diff --git a/docs/Analyzer.md b/docs/Analyzer.md
index ad41bbf10..06e7f3b5d 100644
--- a/docs/Analyzer.md
+++ b/docs/Analyzer.md
@@ -35,6 +35,7 @@ Here's a list of currently supported rules:
 | `finalValueClasses`        | warning       | Makes sure that value classes are marked final.                                                                                                                                                      |
 | `implicitParamDefaults`    | warning       | Makes sure that default values are not defined for implicit parameters                                                                                                                               |
 | `implicitValueClasses`     | warning       | Makes sure that implicit classes extend `AnyVal` (when applicable). Nested classes check can be enabled by passing the `true` argument.                                                              |
+| `implicitFunctionParams`    | warning       | Makes sure that implicit parameters are not function types or partial functions                                                                                                                  |
 
 Rules may be enabled and disabled in `build.sbt` with Scala compiler options:
 

From 0f19b6756ecea72b32894fb261c63dc7ed407670 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Thu, 17 Apr 2025 15:59:47 +0200
Subject: [PATCH 09/14] remove support for SAM types in ImplicitFunctionParams
 rule and enhance tests for function type restrictions

---
 .../analyzer/ImplicitFunctionParams.scala     |  2 +-
 .../analyzer/ImplicitFunctionParamsTest.scala | 83 ++++++++++++++++++-
 2 files changed, 83 insertions(+), 2 deletions(-)

diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitFunctionParams.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitFunctionParams.scala
index 669b3a79d..073954653 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitFunctionParams.scala
+++ b/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")
             }
           }
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitFunctionParamsTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitFunctionParamsTest.scala
index 683021514..8d47cdc93 100644
--- a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitFunctionParamsTest.scala
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitFunctionParamsTest.scala
@@ -53,4 +53,85 @@ class ImplicitFunctionParamsTest extends AnyFunSuite with AnalyzerTest {
         |}
       """.stripMargin)
   }
-}
\ No newline at end of file
+
+  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)
+  }
+}

From 441f2f643d70f9dbccf7485659bf50bf6eadb509 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Thu, 17 Apr 2025 16:29:56 +0200
Subject: [PATCH 10/14] enhance CatchThrowable rule to allow catching NonFatal
 exceptions and add corresponding test

---
 .../commons/analyzer/CatchThrowable.scala     |  9 ++++++++-
 .../commons/analyzer/CatchThrowableTest.scala | 20 ++++++++++++++++++-
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/CatchThrowable.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/CatchThrowable.scala
index 7f24d6a9f..554c30eff 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/CatchThrowable.scala
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/CatchThrowable.scala
@@ -2,18 +2,25 @@ package com.avsystem.commons
 package analyzer
 
 import scala.tools.nsc.Global
+import scala.util.control.NonFatal
 
 class CatchThrowable(g: Global) extends AnalyzerRule(g, "catchThrowable", Level.Warn) {
 
   import global._
 
   private lazy val throwableTpe = typeOf[Throwable]
+  private lazy val nonFatalSym = typeOf[NonFatal.type].termSymbol
+
+  private def isNonFatalPattern(tree: Tree): Boolean = tree match {
+    case UnApply(Apply(Select(qualifier, TermName("unapply")), _), _) if qualifier.symbol == nonFatalSym => true
+    case _ => false
+  }
 
   def analyze(unit: CompilationUnit): Unit =
     unit.body.foreach {
       case t: Try =>
         t.catches.foreach { case cas@CaseDef(pat, _, _) =>
-          if (pat.tpe != null && pat.tpe =:= throwableTpe) {
+          if (pat.tpe != null && pat.tpe =:= throwableTpe && !isNonFatalPattern(pat)) {
             report(cas.pos, "Catching Throwable is discouraged, catch specific exceptions instead")
           }
         }
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/CatchThrowableTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/CatchThrowableTest.scala
index e9ec57dbc..b5c4f1d9a 100644
--- a/analyzer/src/test/scala/com/avsystem/commons/analyzer/CatchThrowableTest.scala
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/CatchThrowableTest.scala
@@ -72,4 +72,22 @@ class CatchThrowableTest extends AnyFunSuite with AnalyzerTest {
         |}
       """.stripMargin)
   }
-}
\ No newline at end of file
+
+  test("catching Throwable using NonFatal should be allowed") {
+    assertNoErrors(
+      //language=Scala
+      """
+        |import scala.util.control.NonFatal
+        |
+        |object Test {
+        |  def test(): Unit = {
+        |    try {
+        |      println("test")
+        |    } catch {
+        |      case NonFatal(t) => println(t)
+        |    }
+        |  }
+        |}
+      """.stripMargin)
+  }
+}

From 04ff725f6ad68be8817aa4ecc9eae94832d42204 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Thu, 17 Apr 2025 16:37:29 +0200
Subject: [PATCH 11/14] support NonFatal alias also

---
 .../com/avsystem/commons/analyzer/CatchThrowable.scala | 10 ++++++++--
 .../avsystem/commons/analyzer/CatchThrowableTest.scala |  5 ++---
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/CatchThrowable.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/CatchThrowable.scala
index 554c30eff..bc8a09cfb 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/CatchThrowable.scala
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/CatchThrowable.scala
@@ -9,10 +9,16 @@ class CatchThrowable(g: Global) extends AnalyzerRule(g, "catchThrowable", Level.
   import global._
 
   private lazy val throwableTpe = typeOf[Throwable]
-  private lazy val nonFatalSym = typeOf[NonFatal.type].termSymbol
+
+  private lazy val nonFatalSymbols = {
+    val nonFatal = typeOf[NonFatal.type].termSymbol
+    val nonFatalAlias = classType("com.avsystem.commons.CommonAliases").member(TermName("NonFatal"))
+
+    Set(nonFatal, nonFatalAlias)
+  }
 
   private def isNonFatalPattern(tree: Tree): Boolean = tree match {
-    case UnApply(Apply(Select(qualifier, TermName("unapply")), _), _) if qualifier.symbol == nonFatalSym => true
+    case UnApply(Apply(Select(qualifier, TermName("unapply")), _), _) if nonFatalSymbols contains qualifier.symbol => true
     case _ => false
   }
 
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/CatchThrowableTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/CatchThrowableTest.scala
index b5c4f1d9a..08c7cd003 100644
--- a/analyzer/src/test/scala/com/avsystem/commons/analyzer/CatchThrowableTest.scala
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/CatchThrowableTest.scala
@@ -77,14 +77,13 @@ class CatchThrowableTest extends AnyFunSuite with AnalyzerTest {
     assertNoErrors(
       //language=Scala
       """
-        |import scala.util.control.NonFatal
-        |
-        |object Test {
+        |object Test extends com.avsystem.commons.CommonAliases {
         |  def test(): Unit = {
         |    try {
         |      println("test")
         |    } catch {
         |      case NonFatal(t) => println(t)
+        |      case scala.util.control.NonFatal(t) => println(t)
         |    }
         |  }
         |}

From 1856639f4957d0aaaa2654d8522cbc8473e918fa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Fri, 18 Apr 2025 10:48:01 +0200
Subject: [PATCH 12/14] add FinalCaseClasses rule to enforce final modifier on
 case classes and include tests

---
 .../commons/analyzer/AnalyzerPlugin.scala     |  1 +
 .../commons/analyzer/FinalCaseClasses.scala   | 15 +++++++
 .../analyzer/FinalCaseClassesTest.scala       | 39 +++++++++++++++++++
 3 files changed, 55 insertions(+)
 create mode 100644 analyzer/src/main/scala/com/avsystem/commons/analyzer/FinalCaseClasses.scala
 create mode 100644 analyzer/src/test/scala/com/avsystem/commons/analyzer/FinalCaseClassesTest.scala

diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
index 89a02dbef..e02902508 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/AnalyzerPlugin.scala
@@ -61,6 +61,7 @@ final class AnalyzerPlugin(val global: Global) extends Plugin { plugin =>
     new BasePackage(global),
     new ImplicitValueClasses(global),
     new FinalValueClasses(global),
+    new FinalCaseClasses(global),
     new ImplicitParamDefaults(global),
     new CatchThrowable(global),
     new ImplicitFunctionParams(global),
diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/FinalCaseClasses.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/FinalCaseClasses.scala
new file mode 100644
index 000000000..8cae4288e
--- /dev/null
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/FinalCaseClasses.scala
@@ -0,0 +1,15 @@
+package com.avsystem.commons
+package analyzer
+
+import scala.tools.nsc.Global
+
+class FinalCaseClasses(g: Global) extends AnalyzerRule(g, "finalCaseClasses", Level.Warn) {
+
+  import global.*
+
+  def analyze(unit: CompilationUnit): Unit = unit.body.foreach {
+    case cd: ClassDef if !cd.mods.hasFlag(Flag.FINAL) && cd.mods.hasFlag(Flag.CASE) =>
+      report(cd.pos, "Case classes should be marked as final")
+    case _ =>
+  }
+}
\ No newline at end of file
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/FinalCaseClassesTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/FinalCaseClassesTest.scala
new file mode 100644
index 000000000..428672a98
--- /dev/null
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/FinalCaseClassesTest.scala
@@ -0,0 +1,39 @@
+package com.avsystem.commons
+package analyzer
+
+import org.scalatest.funsuite.AnyFunSuite
+
+class FinalCaseClassesTest extends AnyFunSuite with AnalyzerTest {
+  test("case classes should be marked as final") {
+    assertErrors(2,
+      //language=scala
+      """
+        |object whatever {
+        |  // This should pass - final case class
+        |  final case class GoodCaseClass(x: Int, y: String) {
+        |    def double: Int = x * 2
+        |  }
+        |
+        |  // This should fail - case class not marked as final
+        |  case class BadCaseClass1(x: Int, y: String) {
+        |    def double: Int = x * 2
+        |  }
+        |
+        |  // This should fail - another case class not marked as final
+        |  case class BadCaseClass2[T](x: T, y: String) {
+        |    def double: String = y * 2
+        |  }
+        |
+        |  // Regular class - should not be affected
+        |  class RegularClass(val x: Int, val y: String) {
+        |    def double: Int = x * 2
+        |  }
+        |
+        |  // Regular class with case-like constructor - should not be affected
+        |  class RegularClass2(x: Int, y: String) {
+        |    def double: Int = x * 2
+        |  }
+        |}
+      """.stripMargin)
+  }
+}
\ No newline at end of file

From 563f6b45fa837c2643a3f579f2068a91d23c17ea Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Fri, 18 Apr 2025 11:04:59 +0200
Subject: [PATCH 13/14] enhance ImplicitValueClasses rule to prevent implicit
 classes from being derived value classes and add corresponding tests

---
 .../analyzer/ImplicitValueClasses.scala       |  9 +++++++--
 .../analyzer/ImplicitValueClassesTest.scala   | 19 +++++++++++++++++++
 2 files changed, 26 insertions(+), 2 deletions(-)

diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala
index 65c616ec8..5e61e192f 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/ImplicitValueClasses.scala
@@ -28,9 +28,14 @@ class ImplicitValueClasses(g: Global) extends AnalyzerRule(g, "implicitValueClas
 
         cls != cd.symbol && !isDefault && !isUniversalTrait
       }
-      def hasExactlyOneParam = paramLists.forall(lists => lists.size == 1 && lists.head.size == 1)
+      def hasExactlyOneParam = paramLists.exists(lists => lists.size == 1 && lists.head.size == 1)
 
-      if (!inheritsAnyVal && !inheritsOtherClass && hasExactlyOneParam) {
+      def paramIsValueClass = paramLists.exists { lists =>
+        /* lists.nonEmpty && lists.head.nonEmpty && */
+        lists.head.head.typeSignature.typeSymbol.isDerivedValueClass
+      }
+
+      if (!inheritsAnyVal && !inheritsOtherClass && hasExactlyOneParam && !paramIsValueClass) {
         val isNestedClass =
           //implicit classes are always nested classes, so we want to check if the outer class's an object
           /*cd.symbol.isNestedClass &&*/ !cd.symbol.isStatic
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala
index e701f3cc5..3001128c0 100644
--- a/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/ImplicitValueClassesTest.scala
@@ -112,6 +112,18 @@ class ImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
         |}
       """.stripMargin)
   }
+
+  test("implicit class for value class should not be affected") {
+    assertNoErrors(
+      //language=Scala
+      """
+        |object whatever {
+        |  implicit final class ValueClass(x: com.avsystem.commons.misc.Timestamp) {
+        |    def sth: Long = x.millis
+        |  }
+        |}
+      """.stripMargin)
+  }
 }
 
 class NestedImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
@@ -119,6 +131,7 @@ class NestedImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
 
   test("nested implicit class not extending AnyVal should fail") {
     assertErrors(1,
+      //language=Scala
       """
         |object whatever {
         |  class Outer {
@@ -134,6 +147,8 @@ class NestedImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
   test("nested implicit class with type parameter not extending AnyVal should fail") {
     assertErrors(1,
       """
+        |      //language=Scala
+        |
         |object whatever {
         |  class Outer {
         |    implicit final class BadNestedImplicitClass[T <: Int](val x: T) {
@@ -146,6 +161,7 @@ class NestedImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
 
   test("deeply nested implicit class not extending AnyVal should fail") {
     assertErrors(1,
+      //language=Scala
       """
         |object whatever {
         |  class Outer {
@@ -161,6 +177,7 @@ class NestedImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
 
   test("regular class should not be affected") {
     assertNoErrors(
+      //language=Scala
       """
         |object whatever {
         |  class Outer {
@@ -174,6 +191,7 @@ class NestedImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
 
   test("implicit class extending other classes should not be affected") {
     assertNoErrors(
+      //language=Scala
       """
         |object whatever {
         |  class Outer {
@@ -194,6 +212,7 @@ class NestedImplicitValueClassesSuite extends AnyFunSuite with AnalyzerTest {
 
   test("implicit class extending AnyVal with traits should be handled correctly") {
     assertErrors(1,
+      //language=Scala
       """
         |object whatever {
         |  class Outer {

From f37a935885626d0bb6724fcd6a9696f0ee640f68 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bart=C5=82omiej=20Kozak?= <b.kozak@avsystem.com>
Date: Fri, 18 Apr 2025 11:44:45 +0200
Subject: [PATCH 14/14] enhance FinalCaseClasses rule to handle case classes
 defined inside traits and add corresponding test for SI-4440

---
 .../commons/analyzer/FinalCaseClasses.scala   | 14 +++++++++++--
 .../analyzer/FinalCaseClassesTest.scala       | 20 +++++++++++++++++++
 2 files changed, 32 insertions(+), 2 deletions(-)

diff --git a/analyzer/src/main/scala/com/avsystem/commons/analyzer/FinalCaseClasses.scala b/analyzer/src/main/scala/com/avsystem/commons/analyzer/FinalCaseClasses.scala
index 8cae4288e..013f282c7 100644
--- a/analyzer/src/main/scala/com/avsystem/commons/analyzer/FinalCaseClasses.scala
+++ b/analyzer/src/main/scala/com/avsystem/commons/analyzer/FinalCaseClasses.scala
@@ -1,6 +1,8 @@
 package com.avsystem.commons
 package analyzer
 
+import com.avsystem.commons.analyzer.Level.Info
+
 import scala.tools.nsc.Global
 
 class FinalCaseClasses(g: Global) extends AnalyzerRule(g, "finalCaseClasses", Level.Warn) {
@@ -9,7 +11,15 @@ class FinalCaseClasses(g: Global) extends AnalyzerRule(g, "finalCaseClasses", Le
 
   def analyze(unit: CompilationUnit): Unit = unit.body.foreach {
     case cd: ClassDef if !cd.mods.hasFlag(Flag.FINAL) && cd.mods.hasFlag(Flag.CASE) =>
-      report(cd.pos, "Case classes should be marked as final")
+      // Skip case classes defined inside traits (SI-4440)
+
+      val isInner = cd.symbol.isStatic
+
+      if (isInner) {
+        report(cd.pos, "Case classes should be marked as final")
+      } else {
+        report(cd.pos, "Case classes should be marked as final. Due to the SI-4440 bug, it cannot be done here. Consider moving the case class to the companion object", level = Info)
+      }
     case _ =>
   }
-}
\ No newline at end of file
+}
diff --git a/analyzer/src/test/scala/com/avsystem/commons/analyzer/FinalCaseClassesTest.scala b/analyzer/src/test/scala/com/avsystem/commons/analyzer/FinalCaseClassesTest.scala
index 428672a98..714c52d4a 100644
--- a/analyzer/src/test/scala/com/avsystem/commons/analyzer/FinalCaseClassesTest.scala
+++ b/analyzer/src/test/scala/com/avsystem/commons/analyzer/FinalCaseClassesTest.scala
@@ -36,4 +36,24 @@ class FinalCaseClassesTest extends AnyFunSuite with AnalyzerTest {
         |}
       """.stripMargin)
   }
+
+  // SI-4440 https://github.com/scala/bug/issues/4440
+  test("should not be affected due to SI-4440"){
+    assertNoErrors(
+      //language=scala
+      """
+        |trait Outer {
+        |  case class Inner(x: Int, y: String) {
+        |    def double: Int = x * 2
+        |  }
+        |}
+        |
+        |class Outer2 {
+        |  case class Inner(x: Int, y: String) {
+        |    def double: Int = x * 2
+        |  }
+        |}
+        """.stripMargin
+    )
+  }
 }
\ No newline at end of file