Merge pull request #29 from csense-oss/2.1.2

2.1.2

Author: Tvede-dk

build.gradle.kts

@@ -1,16 +1,16 @@
 plugins {
     //https://github.com/JetBrains/gradle-intellij-plugin
-    id("org.jetbrains.intellij") version "1.17.2"
+    id("org.jetbrains.intellij") version "1.17.3"
     //https://github.com/JetBrains/kotlin
     kotlin("jvm") version "1.9.23"
     //https://jeremylong.github.io/DependencyCheck/
-    id("org.owasp.dependencycheck") version "9.0.10"
+    id("org.owasp.dependencycheck") version "9.1.0"
 }
 
 val javaVersion = "11"
 
 group = "csense-idea"
-version = "2.1.1"
+version = "2.1.2"
 
 intellij {
     updateSinceUntilBuild.set(false)
@@ -35,7 +35,7 @@ dependencies {
     //https://github.com/csense-oss/csense-kotlin-annotations
     implementation("csense.kotlin:csense-kotlin-annotations-jvm:0.0.63")
     //https://github.com/csense-oss/idea-kotlin-shared-base
-    implementation("csense.idea.base:csense-idea-base:0.1.62")
+    implementation("csense.idea.base:csense-idea-base:0.1.63")
     //https://github.com/Kotlin/kotlinx.serialization
     implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")
     //https://github.com/Kotlin/kotlinx.coroutines
@@ -49,9 +49,11 @@ dependencies {
 tasks.getByName<org.jetbrains.intellij.tasks.PatchPluginXmlTask>("patchPluginXml") {
     changeNotes.set(
         """
+            Fixes
         <ul>
-          <li>Fixed https://github.com/csense-oss/idea-kotlin-checked-exceptions/issues/18</li>
-          <li>Fixed https://github.com/csense-oss/idea-kotlin-checked-exceptions/issues/25</li>
+          <li> Fixes a lot of issues with respect to throw expressions (also causes a thrown exception to be interpreted as Exception https://github.com/csense-oss/idea-kotlin-checked-exceptions/issues/26 )</li>
+          <li> QuickFixes (CSense detects Throws annotation only if lambda provides callsInPlace contract https://github.com/csense-oss/idea-kotlin-checked-exceptions/issues/27) </li>
+          <li> Method references are now resolved (method references are not marked https://github.com/csense-oss/idea-kotlin-checked-exceptions/issues/28) </li>
         </ul>
       """
     )

changelog.md

@@ -1,3 +1,8 @@
+# 2.1.2
+- Fixes a lot of issues with respect to throw expressions (also causes a thrown exception to be interpreted as Exception https://github.com/csense-oss/idea-kotlin-checked-exceptions/issues/26 )
+- QuickFixes (CSense detects Throws annotation only if lambda provides callsInPlace contract https://github.com/csense-oss/idea-kotlin-checked-exceptions/issues/27)
+- Method references are now resolved (method references are not marked https://github.com/csense-oss/idea-kotlin-checked-exceptions/issues/28)
+
 # 2.1.1
 - Fixed https://github.com/csense-oss/idea-kotlin-checked-exceptions/issues/18
 - Fixed https://github.com/csense-oss/idea-kotlin-checked-exceptions/issues/25

src/main/kotlin/csense/idea/kotlin/checked/exceptions/bll/KtCallExpression.kt

@@ -0,0 +1,24 @@
+package csense.idea.kotlin.checked.exceptions.bll
+
+import csense.idea.base.bll.psiWrapper.`class`.*
+import csense.idea.base.bll.psiWrapper.function.operations.*
+import org.jetbrains.kotlin.psi.*
+
+fun KtCallExpression.throwsTypesForSettings(): List<KtPsiClass> {
+    val forFunction: List<KtPsiClass> = resolveMainReferenceAsFunction()
+        ?.throwsTypesForSettings()
+        ?: listOf()
+
+    return forFunction + resolveAllThrowingValueArguments()
+}
+
+fun KtCallExpression.resolveAllThrowingValueArguments(): List<KtPsiClass> {
+    return valueArguments.flatMap { it: KtValueArgument? ->
+        val argExpression: KtExpression = it?.getArgumentExpression() ?: return@flatMap emptyList()
+        when (argExpression) {
+            is KtCallableReferenceExpression -> argExpression.throwsTypesForSettings()
+            is KtCallExpression -> argExpression.throwsTypesForSettings()
+            else -> emptyList()
+        }
+    }
+}

src/main/kotlin/csense/idea/kotlin/checked/exceptions/bll/KtCallableReferenceExpression.kt

@@ -0,0 +1,9 @@
+package csense.idea.kotlin.checked.exceptions.bll
+
+import csense.idea.base.bll.psiWrapper.`class`.*
+import csense.idea.base.bll.psiWrapper.function.operations.*
+import org.jetbrains.kotlin.psi.*
+
+fun KtCallableReferenceExpression.throwsTypesForSettings(): List<KtPsiClass> {
+    return resolveKtPsiFunctionOrNull()?.throwsTypesForSettings() ?: emptyList()
+}

src/main/kotlin/csense/idea/kotlin/checked/exceptions/csense/Collection.kt

@@ -0,0 +1,13 @@
+package csense.idea.kotlin.checked.exceptions.csense
+
+import csense.kotlin.extensions.collections.*
+
+
+public inline fun <Item, U> Collection<Item>.selectLastOrNull(mappingPredicate: (Item) -> U?): U? {
+    forEachBackwards { item: Item ->
+        mappingPredicate(item)?.let { mapped: U ->
+            return@selectLastOrNull mapped
+        }
+    }
+    return null
+}

src/main/kotlin/csense/idea/kotlin/checked/exceptions/lineMarkers/CheckedExceptionLineMarkerProvider.kt

@@ -5,21 +5,15 @@ import com.intellij.codeInsight.navigation.*
 import com.intellij.openapi.util.*
 import com.intellij.psi.*
 import com.intellij.psi.impl.source.tree.*
-import com.intellij.psi.tree.*
 import csense.idea.base.bll.ast.*
 import csense.idea.base.bll.kotlin.*
 import csense.idea.base.bll.linemarkers.*
 import csense.idea.base.bll.psiWrapper.`class`.*
 import csense.idea.base.bll.psiWrapper.`class`.operations.*
-import csense.idea.base.bll.psiWrapper.function.operations.*
 import csense.idea.kotlin.checked.exceptions.bll.*
-import csense.idea.kotlin.checked.exceptions.builtin.operations.*
-import csense.idea.kotlin.checked.exceptions.inspections.*
-import csense.idea.kotlin.checked.exceptions.settings.*
 import csense.kotlin.extensions.*
 import csense.kotlin.extensions.collections.*
 import org.intellij.lang.annotations.*
-import org.jetbrains.kotlin.lexer.*
 import org.jetbrains.kotlin.psi.*
 import javax.swing.*
 
@@ -76,17 +70,14 @@ class CheckedExceptionLineMarkerProvider : SafeRelatedItemLineMarkerProvider() {
         leaf.parent.parent.invokeIsInstance { call: KtCallExpression ->
             onCallExpression(element = call, leafPsiElement = leaf, result = result)
         }
-
     }
 
-
     private fun onCallExpression(
         element: KtCallExpression,
         leafPsiElement: LeafPsiElement,
         result: MutableCollection<in RelatedItemLineMarkerInfo<*>>
     ) {
-        val throwsNonEmpty: List<KtPsiClass> = element.resolveMainReferenceAsFunction()
-            ?.throwsTypesForSettings()
+        val throwsNonEmpty: List<KtPsiClass> = element.throwsTypesForSettings()
             .nullOnEmpty()
             ?: return
 
@@ -100,6 +91,7 @@ class CheckedExceptionLineMarkerProvider : SafeRelatedItemLineMarkerProvider() {
         leafPsiElement: LeafPsiElement,
         typesOfExceptions: List<KtPsiClass>
     ): RelatedItemLineMarkerInfo<PsiElement> {
+        val exceptionIcon: Icon by lazy { IconLoader.getIcon("/icons/throws.svg", Companion::class.java) }
 
         val typesString: String = typesOfExceptions.coloredFqNameString(
             cssColor = IconThemeColor,
@@ -120,9 +112,7 @@ class CheckedExceptionLineMarkerProvider : SafeRelatedItemLineMarkerProvider() {
     }
 
 
-
     companion object {
-        val exceptionIcon: Icon by lazy { IconLoader.getIcon("/icons/throws.svg", Companion::class.java) }
         const val IconThemeColor = "#DB5860"
     }
-}
+}

src/main/kotlin/csense/idea/kotlin/checked/exceptions/lineMarkers/ThrowsExceptionLineMarkerProvider.kt

@@ -5,7 +5,6 @@ import com.intellij.codeInsight.navigation.*
 import com.intellij.openapi.util.*
 import com.intellij.psi.*
 import com.intellij.psi.impl.source.tree.*
-import csense.idea.base.bll.annotator.*
 import csense.idea.base.bll.kotlin.*
 import csense.idea.base.bll.linemarkers.*
 import csense.idea.base.bll.psiWrapper.`class`.*
@@ -52,6 +51,10 @@ class ThrowsExceptionLineMarkerProvider : AbstractSafeRelatedItemLineMarkerProvi
         type: String,
         isRuntimeException: Boolean
     ): RelatedItemLineMarkerInfo<PsiElement> {
+
+        val exceptionIcon: Icon = IconLoader.getIcon("/icons/exception.svg", Companion::class.java)
+
+
         @Language("html")
         val runtimeExceptionText: String = when (isRuntimeException) {
             true -> "(subtype of <i style=\"color:$iconColorTheme\">RuntimeException</i>)"
@@ -69,8 +72,7 @@ class ThrowsExceptionLineMarkerProvider : AbstractSafeRelatedItemLineMarkerProvi
     }
 
     companion object {
-        val exceptionIcon: Icon = IconLoader.getIcon("/icons/exception.svg", Companion::class.java)
-        const val iconColorTheme = "#EDA200"
+        const val iconColorTheme: String = "#EDA200"
     }
 
-}
+}

src/main/kotlin/csense/idea/kotlin/checked/exceptions/quickfixes/selectors/KtCallExpressionQuickFixSelector.kt

@@ -3,10 +3,12 @@ package csense.idea.kotlin.checked.exceptions.quickfixes.selectors
 import com.intellij.codeInspection.*
 import csense.idea.base.bll.kotlin.*
 import csense.idea.base.bll.psiWrapper.`class`.*
+import csense.idea.kotlin.checked.exceptions.csense.*
 import csense.idea.kotlin.checked.exceptions.quickfixes.add.*
 import csense.idea.kotlin.checked.exceptions.quickfixes.wrap.*
 import csense.idea.kotlin.checked.exceptions.repo.*
 import csense.idea.kotlin.checked.exceptions.visitors.*
+import csense.kotlin.extensions.*
 import org.jetbrains.kotlin.psi.*
 
 class KtCallExpressionQuickFixSelector(
@@ -30,38 +32,38 @@ class KtCallExpressionQuickFixSelector(
         result: MutableList<LocalQuickFix>
     ) {
         appendQuickFixesForExpression(state, result)
-        if (state.containingLambdas.isNotEmpty()) {
-            appendQuickFixesForContainingLambdas(state, result)
-        } else {
-            AddThrowsTypeToSelector.tryAddThrowsTypesAnnotations(
-                parent = state.parentScope,
-                result = result, uncaughtExceptions = uncaughtExceptions,
-                kotlinThrowable = kotlinThrowable
-            )
+
+        val firstBlockingLambda: LambdaArgumentLookup? = state.containingLambdas.selectLastOrNull { it: KtLambdaExpression ->
+            val lookup: LambdaArgumentLookup = it.toLamdaArgumentLookup() ?: return@selectLastOrNull null
+            val isBlocking: Boolean = !callThoughRepo.isLambdaCallThough(lookup)
+            return@selectLastOrNull isBlocking.map(ifTrue = lookup, ifFalse = null)
+        }
+
+        if (firstBlockingLambda != null) {
+            appendQuickFixesForContainingLambdas(result, firstBlockingLambda)
+            return
         }
+
+        AddThrowsTypeToSelector.tryAddThrowsTypesAnnotations(
+            parent = state.parentScope,
+            result = result, uncaughtExceptions = uncaughtExceptions,
+            kotlinThrowable = kotlinThrowable
+        )
     }
 
     private fun appendQuickFixesForContainingLambdas(
-        state: IncrementalExceptionCheckerState,
-        result: MutableList<LocalQuickFix>
+        result: MutableList<LocalQuickFix>,
+        blockingLambda: LambdaArgumentLookup
     ) {
-        val lambda: LambdaArgumentLookup = getLambdaFromStateOrNull(state) ?: return
-
-        if (!ignoreRepo.isLambdaIgnoreExceptions(lambda)) {
-            result += AddLambdaToIgnoreQuickFix(lambda)
+        if (!ignoreRepo.isLambdaIgnoreExceptions(blockingLambda)) {
+            result += AddLambdaToIgnoreQuickFix(blockingLambda)
         }
-        if (!callThoughRepo.isLambdaCallThough(lambda)) {
-            result += AddLambdaToCallthoughQuickFix(lambda)
+        if(!callThoughRepo.isLambdaCallThough(blockingLambda)) {
+            result += AddLambdaToCallthoughQuickFix(blockingLambda)
         }
     }
 
-    private fun getLambdaFromStateOrNull(
-        state: IncrementalExceptionCheckerState
-    ): LambdaArgumentLookup? {
-        return state.containingLambdas.lastOrNull()?.toLamdaArgumentLookup()
-    }
-
-    private fun appendQuickFixesForExpression(
+        private fun appendQuickFixesForExpression(
         state: IncrementalExceptionCheckerState,
         result: MutableList<LocalQuickFix>
     ) {

src/main/kotlin/csense/idea/kotlin/checked/exceptions/visitors/IncrementalExceptionCheckerVisitor.kt

@@ -262,6 +262,24 @@ class IncrementalExceptionCheckerVisitor(
         }
     }
 
+    override fun visitCallableReferenceExpression(
+        expression: KtCallableReferenceExpression,
+        state: IncrementalExceptionCheckerState?
+    ): Void? {
+        val currentState: IncrementalExceptionCheckerState = state.newStateByAppending()
+
+        val thrownExceptions: List<KtPsiClass> = expression
+            .resolveKtPsiFunctionOrNull()
+            ?.throwsTypesForCallBySettingsOrEmpty() ?: listOf()
+
+        findIssuesAndReport(
+            expression = expression,
+            currentState = currentState,
+            potentialExceptions = thrownExceptions
+        )
+        return super.visitCallableReferenceExpression(expression, state)
+    }
+
     private fun IncrementalExceptionCheckerState?.newStateByAppending(
         newCaptures: List<KtPsiClass> = listOf(),
         newThrows: List<KtPsiClass> = listOf(),
@@ -290,7 +308,7 @@ data class IncrementalExceptionCheckerState(
     val parentScope: KtElement? = null
 ) {
     companion object {
-        val empty = IncrementalExceptionCheckerState(
+        val empty: IncrementalExceptionCheckerState = IncrementalExceptionCheckerState(
             captures = emptyList(),
             throwsTypes = emptyList(),
             containingLambdas = emptyList(),

todo.md

@@ -5,7 +5,6 @@
 - handle "*arrayOf(exception::class, exception2::class)" ....
 - come up with something for init that can throw...
 - SAM function(s) might not be working
-- if (ignore, callthough) does not exists?
 - improve documentation parsing / handling
 - improve the "source" target when finding e.g.
 - settings for the colors etc. of the hints.