Allow to suppress kotlin inspections with Suppress() annotation

idea/idea-analysis/src/org/jetbrains/kotlin/idea/caches/resolve/KotlinCacheService.kt

@@ -20,36 +20,44 @@ import com.intellij.openapi.components.ServiceManager
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.roots.ProjectRootModificationTracker
+import com.intellij.psi.util.CachedValue
 import com.intellij.psi.util.CachedValueProvider
 import com.intellij.psi.util.CachedValuesManager
 import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.util.containers.SLRUCache
 import org.jetbrains.kotlin.analyzer.EmptyResolverForProject
 import org.jetbrains.kotlin.container.getService
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
 import org.jetbrains.kotlin.idea.project.AnalyzerFacadeProvider
 import org.jetbrains.kotlin.idea.project.TargetPlatformDetector
 import org.jetbrains.kotlin.idea.resolve.ResolutionFacade
 import org.jetbrains.kotlin.idea.util.ProjectRootsUtil
 import org.jetbrains.kotlin.js.resolve.JsPlatform
+import org.jetbrains.kotlin.psi.KtAnnotated
 import org.jetbrains.kotlin.psi.KtCodeFragment
 import org.jetbrains.kotlin.psi.KtElement
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.TargetPlatform
+import org.jetbrains.kotlin.resolve.diagnostics.KotlinSuppressCache
 import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
+import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import org.jetbrains.kotlin.utils.keysToMap
 
-internal val LOG = Logger.getInstance(javaClass<KotlinCacheService>())
+internal val LOG = Logger.getInstance(KotlinCacheService::class.java)
 
 public class KotlinCacheService(val project: Project) {
     companion object {
         @JvmStatic
-        public fun getInstance(project: Project): KotlinCacheService = ServiceManager.getService(project, javaClass<KotlinCacheService>())!!
+        public fun getInstance(project: Project): KotlinCacheService = ServiceManager.getService(project, KotlinCacheService::class.java)!!
     }
 
     public fun getResolutionFacade(elements: List<KtElement>): ResolutionFacade {
         return getFacadeToAnalyzeFiles(elements.map { it.getContainingKtFile() })
     }
 
+    public fun getSuppressionCache(): KotlinSuppressCache = kotlinSuppressCache.value
+
     private val globalFacadesPerPlatform = listOf(JvmPlatform, JsPlatform).keysToMap { platform -> GlobalFacade(platform) }
 
     private inner class GlobalFacade(platform: TargetPlatform) {
@@ -147,6 +155,22 @@ public class KotlinCacheService(val project: Project) {
         }
     }
 
+    private val kotlinSuppressCache: CachedValue<KotlinSuppressCache> = CachedValuesManager.getManager(project).createCachedValue({
+        CachedValueProvider.Result<KotlinSuppressCache>(object : KotlinSuppressCache() {
+            override fun getSuppressionAnnotations(annotated: KtAnnotated): List<AnnotationDescriptor> {
+                val context = annotated.analyze(BodyResolveMode.PARTIAL)
+                val annotatedDescriptor = context.get(BindingContext.DECLARATION_TO_DESCRIPTOR, annotated)
+
+                if (annotatedDescriptor != null) {
+                    return annotatedDescriptor.annotations.toList()
+                }
+                else {
+                    return annotated.annotationEntries.map { context.get(BindingContext.ANNOTATION, it) }.filterNotNull()
+                }
+            }
+        }, LibraryModificationTracker.getInstance(project), PsiModificationTracker.MODIFICATION_COUNT)
+    }, false)
+
     private val syntheticFileCachesLock = Any()
 
     private val slruCacheProvider = CachedValueProvider {

idea/idea-analysis/src/org/jetbrains/kotlin/idea/inspections/AbstractKotlinInspection.kt

@@ -16,12 +16,15 @@
 
 package org.jetbrains.kotlin.idea.inspections
 
-import com.intellij.codeInspection.LocalInspectionTool
-import com.intellij.codeInspection.CustomSuppressableInspectionTool
-import com.intellij.psi.PsiElement
+import com.intellij.codeHighlighting.HighlightDisplayLevel
 import com.intellij.codeInsight.daemon.HighlightDisplayKey
+import com.intellij.codeInspection.CustomSuppressableInspectionTool
+import com.intellij.codeInspection.LocalInspectionTool
 import com.intellij.codeInspection.SuppressIntentionAction
 import com.intellij.codeInspection.SuppressManager
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.diagnostics.Severity
+import org.jetbrains.kotlin.idea.caches.resolve.KotlinCacheService
 
 public abstract class AbstractKotlinInspection: LocalInspectionTool(), CustomSuppressableInspectionTool {
     public override fun getSuppressActions(element: PsiElement?): Array<SuppressIntentionAction>? {
@@ -29,6 +32,30 @@ public abstract class AbstractKotlinInspection: LocalInspectionTool(), CustomSup
     }
 
     public override fun isSuppressedFor(element: PsiElement): Boolean {
-        return SuppressManager.getInstance()!!.isSuppressedFor(element, getID())
+        if (SuppressManager.getInstance()!!.isSuppressedFor(element, getID())) {
+            return true
+        }
+
+        val project = element.project
+        if (KotlinCacheService.getInstance(project).getSuppressionCache().isSuppressed(element, this.shortName, toSeverity(defaultLevel))) {
+            return true
+        }
+
+        return false
+    }
+
+    public fun toSeverity(highlightDisplayLevel: HighlightDisplayLevel): Severity  {
+        return when (highlightDisplayLevel) {
+            HighlightDisplayLevel.DO_NOT_SHOW -> Severity.INFO
+
+            HighlightDisplayLevel.WARNING,
+            HighlightDisplayLevel.WEAK_WARNING -> Severity.WARNING
+
+            HighlightDisplayLevel.ERROR,
+            HighlightDisplayLevel.GENERIC_SERVER_ERROR_OR_WARNING,
+            HighlightDisplayLevel.NON_SWITCHABLE_ERROR -> Severity.ERROR
+
+            else -> Severity.ERROR
+        }
     }
 }

idea/idea-analysis/src/org/jetbrains/kotlin/idea/intentions/SelfTargetingIntention.kt

@@ -91,7 +91,9 @@ public abstract class SelfTargetingIntention<TElement : KtElement>(
         val inspection = findInspection(javaClass) ?: return false
 
         val key = HighlightDisplayKey.find(inspection.shortName)
-        if (!InspectionProjectProfileManager.getInstance(project).getInspectionProfile(target).isToolEnabled(key)) return false
+        if (!InspectionProjectProfileManager.getInstance(project).getInspectionProfile(target).isToolEnabled(key)) {
+            return false
+        }
 
         return inspection.intentions.single { it.intention.javaClass == javaClass }.additionalChecker(target)
     }