support k2 mode

Author: EmptyIrony

gradle.properties

@@ -1,6 +1,6 @@
 kotlin.stdlib.default.dependency=false
 pluginSinceBuild=232
-version=1.3-SNAPSHOT
+version=1.31-SNAPSHOT
 kotlin.code.style=official
 kotlin.experimental.tryK2=true
 kapt.use.k2=true

src/main/kotlin/org/tabooproject/development/Utils.kt

@@ -7,13 +7,9 @@ import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.util.PsiTreeUtil
 import okhttp3.OkHttpClient
 import okhttp3.Request
-import org.jetbrains.kotlin.descriptors.ClassDescriptor
-import org.jetbrains.kotlin.idea.caches.resolve.analyze
+import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.ImportPath
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 import java.io.IOException
 import java.net.InetSocketAddress
 import java.net.Proxy
@@ -121,12 +117,15 @@ private fun isPackageInProject(file: PsiFile, packageName: String): Boolean {
     return orderEnumerator.urls.any { it.contains(packageName.replace('.', '/')) }
 }
 
+
 fun KtFile.checkAndImportPackage(path: String) {
+    val fqName = FqName(path)
+
     // 检查和引入info包
     val import =
         PsiTreeUtil.findChildrenOfType(this, KtImportDirective::class.java)
     val hasImport =
-        import.any { it.importPath?.pathStr == path }
+        import.any { it.importedFqName == fqName }
     if (!hasImport) {
         val factory = KtPsiFactory(project)
         val importDirective =
@@ -137,11 +136,7 @@ fun KtFile.checkAndImportPackage(path: String) {
 
 val KtDotQualifiedExpression.fqName: String?
     get() {
-        val receiverExpression = receiverExpression
-        val bindingContext = receiverExpression.analyze(BodyResolveMode.PARTIAL)
-        val type = bindingContext.get(BindingContext.EXPRESSION_TYPE_INFO, receiverExpression)?.type
-        val classDescriptor = type?.constructor?.declarationDescriptor as? ClassDescriptor
-        return classDescriptor?.fqNameSafe?.asString() ?: return null
+        return text
     }
 
 fun KtDotQualifiedExpression.getPsiClass(): PsiClass? {

src/main/kotlin/org/tabooproject/development/suppressor/ExpansionUnusedSuppressor.kt

@@ -4,12 +4,9 @@ import com.intellij.codeInspection.InspectionSuppressor
 import com.intellij.codeInspection.SuppressQuickFix
 import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
-import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
+import org.jetbrains.kotlin.analysis.api.analyze
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtTypeReference
-import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
-import org.jetbrains.kotlin.resolve.lazy.BodyResolveMode
 
 private const val INSPECTION = "unused"
 
@@ -34,34 +31,38 @@ class ExpansionUnusedSuppressor: InspectionSuppressor {
 
     private fun checkIfClassImplementsOrExtends(element: PsiElement, className: String): Boolean {
         val ktClass = PsiTreeUtil.getParentOfType(element, KtClassOrObject::class.java) ?: return false
-        val context = ktClass.getResolutionFacade().analyze(ktClass, BodyResolveMode.FULL)
-        return ktClass.implementsInterface(className, context) || ktClass.isSubclassOf(className, context)
+        return analyze(ktClass) {
+            ktClass.implementsInterface(className) || ktClass.isSubclassOf(className)
+        }
     }
 
-    private fun KtClassOrObject.isSubclassOf(className: String, context: BindingContext): Boolean {
+    private fun KtClassOrObject.isSubclassOf(className: String): Boolean {
         if (fqName?.asString() == className) return true
 
         val superTypes = this.superTypeListEntries
         return superTypes.any { typeEntry ->
             val typeReference = typeEntry.typeReference
-            val typeFqName = typeReference?.getFqName(context)
+            val typeFqName = typeReference?.getFqName()
             typeFqName == className
         }
     }
 
-    private fun KtClassOrObject.implementsInterface(interfaceName: String, context: BindingContext): Boolean {
-        if (isSubclassOf(interfaceName, context)) return true
+    private fun KtClassOrObject.implementsInterface(interfaceName: String): Boolean {
+        if (isSubclassOf(interfaceName)) return true
 
         val superTypes = this.superTypeListEntries
         return superTypes.any { typeEntry ->
             val typeReference = typeEntry.typeReference
-            val typeFqName = typeReference?.getFqName(context)
+            val typeFqName = typeReference?.getFqName()
             typeFqName == interfaceName
         }
     }
 
-    private fun KtTypeReference.getFqName(context: BindingContext): String? {
-        val type = context[BindingContext.TYPE, this]
-        return type?.constructor?.declarationDescriptor?.fqNameSafe?.asString()
+    private fun KtTypeReference.getFqName(): String? {
+        return analyze(this) {
+            val type = type
+            val symbol = type.expandedSymbol
+            symbol?.classId?.asSingleFqName()?.asString()
+        }
     }
 }