enhance CatchThrowable rule to allow catching Throwable with custom extractors and update corresponding tests

Author: halotukozak

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

@@ -2,27 +2,19 @@ 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._
+  import global.*
 
   private lazy val throwableTpe = typeOf[Throwable]
 
-  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 nonFatalSymbols contains qualifier.symbol => true
+  private def isCustomExtractor(tree: Tree): Boolean = tree match {
+    case UnApply(Apply(Select(_, TermName("unapply")), _), _) => true
     case _ => false
   }
 
-  private def checkTree(pat: Tree): Unit = if (pat.tpe != null && pat.tpe =:= throwableTpe && !isNonFatalPattern(pat)) {
+  private def checkTree(pat: Tree): Unit = if (pat.tpe != null && pat.tpe =:= throwableTpe && !isCustomExtractor(pat)) {
     report(pat.pos, "Catching Throwable is discouraged, catch specific exceptions instead")
   }
 

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

@@ -73,15 +73,22 @@ class CatchThrowableTest extends AnyFunSuite with AnalyzerTest {
       """.stripMargin)
   }
 
-  test("catching Throwable using NonFatal should be allowed") {
+  test("catching Throwable using custom extractor should be allowed") {
     assertNoErrors(
       //language=Scala
       """
-        |object Test extends com.avsystem.commons.CommonAliases {
+        |object Test extends com.avsystem.commons.CommonAliases  {
+        |  object custom {
+        |    def unapply(t: Throwable): Option[IllegalArgumentException] = t match {
+        |      case e: IllegalArgumentException => Some(e)
+        |      case _ => None
+        |    }
+        |  }
         |  def test(): Unit = {
         |    try {
         |      println("test")
         |    } catch {
+        |      case custom(t) => println(t)
         |      case NonFatal(t) => println(t)
         |      case scala.util.control.NonFatal(t) => println(t)
         |    }