Check throwable and String. I am unable to verify those with test som…

…ehow.
kozaxinan · Sep 26, 2024 · 378c87e · 378c87e
1 parent 8548aaf
commit 378c87e
Show file tree

Hide file tree

Showing 3 changed files with 33 additions and 6 deletions.
diff --git a/checks/src/main/java/com/kozaxinan/android/checks/ImmutableDataClassDetector.kt b/checks/src/main/java/com/kozaxinan/android/checks/ImmutableDataClassDetector.kt
@@ -10,10 +10,12 @@ import com.android.tools.lint.detector.api.Issue
 import com.android.tools.lint.detector.api.JavaContext
 import com.android.tools.lint.detector.api.Scope
 import com.android.tools.lint.detector.api.Severity
+import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiField
 import com.intellij.psi.PsiModifier
 import org.jetbrains.uast.UClass
 import org.jetbrains.uast.UField
+import org.jetbrains.uast.getContainingUClass
 import org.jetbrains.uast.toUElementOfType
 
 /**
@@ -50,10 +52,15 @@ internal class ImmutableDataClassDetector : Detector(), UastScanner {
             fields: List<UField>,
             evaluator: JavaEvaluator,
         ) {
-            val problematicFields = fields.filter { field: UField ->
-                !field.hasModifierProperty(PsiModifier.FINAL) ||
-                        field.isTypeMutable(evaluator)
-            }
+            val problematicFields = fields
+                .filterNot { field: UField ->
+                    hasThrowableSuperClass(field.getContainingUClass())
+                }
+                .filter { field: UField ->
+                    !field
+                        .hasModifierProperty(PsiModifier.FINAL) ||
+                            field.isTypeMutable(evaluator)
+                }
 
             if (problematicFields.isNotEmpty()) {
                 val message = problematicFields.joinToString(separator = "\n") { field ->

diff --git a/checks/src/main/java/com/kozaxinan/android/checks/KtDeclarationKt.kt b/checks/src/main/java/com/kozaxinan/android/checks/KtDeclarationKt.kt
@@ -1,6 +1,7 @@
 package com.kozaxinan.android.checks
 
 import com.android.tools.lint.client.api.JavaEvaluator
+import com.intellij.psi.PsiClass
 import com.intellij.psi.PsiMember
 import org.jetbrains.kotlin.asJava.LightClassGenerationSupport
 import org.jetbrains.kotlin.asJava.elements.KtLightMember
@@ -115,3 +116,18 @@ fun String?.matchesAnyOf(patterns: Sequence<Regex>): Boolean {
     }
     return false
 }
+
+fun hasThrowableSuperClass(uClass: UClass?): Boolean {
+    var superClass: PsiClass? = uClass?.javaPsi?.superClass
+    while (superClass != null) {
+        if (superClass.qualifiedName == "java.lang.Throwable") {
+            return true
+        }
+        superClass = superClass.superClass
+    }
+    return false
+}
+
+fun isStringClass(uClass: UClass): Boolean {
+    return uClass.qualifiedName == "java.lang.String"
+}
diff --git a/checks/src/main/java/com/kozaxinan/android/checks/RetrofitReturnTypeDetector.kt b/checks/src/main/java/com/kozaxinan/android/checks/RetrofitReturnTypeDetector.kt
@@ -116,14 +116,17 @@ internal abstract class RetrofitReturnTypeDetector : Detector(), UastScanner {
 
         internal fun findAllInnerFields(
             typeRef: PsiClassType,
-            visitedTypes: MutableSet<PsiClassType> = mutableSetOf()
+            visitedTypes: MutableSet<PsiClassType> = mutableSetOf(),
         ): Set<UField> {
             val actualReturnType = findGenericClassType(typeRef)
-            val typeClass = actualReturnType
+            val typeClass: UClass = actualReturnType
                 .resolve()
                 .toUElement() as? UClass
                 ?: return emptySet()
 
+            if (hasThrowableSuperClass(typeClass) || isStringClass(typeClass)) {
+                return setOf()
+            }
 
             if (visitedTypes.contains(actualReturnType)) {
                 return setOf()
@@ -137,6 +140,7 @@ internal abstract class RetrofitReturnTypeDetector : Detector(), UastScanner {
 
             return innerFields +
                     innerFields
+                        .asSequence()
                         .filterNot { it.isStatic }
                         .map { it.type }
                         .filterIsInstance<PsiClassType>()