解决kotlin代码重排的一个严重问题

Author: wuhao000

AegisCodeCheckPlugin.zip

@@ -13,6 +13,7 @@
       and it supports both java and kotlin.<br>
       Otherwise, it provided some additional features, such as:
       <ul>
+        <li>rearrange kotlin source code when reformatting like java</li>
         <li>rearrange tag attributes for .vue files when reformatting</li>
         <li>add gutters for mybatis mapper interfaces and mapping xml files,
          you can jump from the interface methods to the mapping file tag or the opposite,
@@ -39,7 +40,7 @@
   <extensions defaultExtensionNs="com.intellij">
     <postStartupActivity implementation="com.wuhao.code.check.PostStart"/>
     <lang.rearranger language="kotlin"
-                     implementationClass="com.wuhao.code.check.style.arrangement.KotlinCodeRearrangeProcessor"/>
+                     implementationClass="com.wuhao.code.check.style.arrangement.KotlinRearranger"/>
     <completion.contributor
         implementationClass="com.wuhao.code.check.completion.SpringBootConfigValueInjectCodeCompletion"
         language="JAVA" order="FIRST"/>

resources/META-INF/plugin.xml

@@ -60,7 +60,7 @@ fun getPsiElementFactory(element: PsiElement): PsiElementFactoryImpl {
 /**
  * 全局日志
  */
-val LOG = Logger.getLogger("plugin")
+val LOG: Logger = Logger.getLogger("plugin")
 
 /**
  * kotlin的修饰符

src/com/wuhao/code/check/CommonConstants.kt

@@ -50,7 +50,7 @@ class FixJavaBlankLineProcessor : PostFormatProcessor {
         if (element is PsiField) {
           val nextField = element.getNextSiblingIgnoringWhitespace()
           val prevField = element.getPrevSiblingIgnoringWhitespaceAndComments()
-          if(prevField !is PsiField) {
+          if (prevField !is PsiField) {
             fixBlankLineBefore(element, 2, factory)
           }
           if (nextField is PsiField) {

src/com/wuhao/code/check/processors/FixJavaBlankLineProcessor.kt

@@ -79,7 +79,6 @@ class FixJavaElementOrder : PostFormatProcessor {
 
   /**
    * 获取java修饰符的权重
-   * @param modifier 修饰符
    * @return 权重值
    */
   private fun JvmModifier.getWeight(): Int {

src/com/wuhao/code/check/processors/FixJavaElementOrder.kt

@@ -3,13 +3,6 @@
  */
 package com.wuhao.code.check.style.arrangement
 
-import com.intellij.openapi.util.Pair
-import com.intellij.psi.codeStyle.arrangement.ArrangementEntryDependencyInfo
-import com.intellij.util.containers.ContainerUtil
-import com.intellij.util.containers.ContainerUtilRt
-import com.intellij.util.containers.Stack
-import gnu.trove.TObjectIntHashMap
-import org.jetbrains.kotlin.psi.KtClass
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.psi.KtProperty
 import java.util.*
@@ -22,136 +15,22 @@ import kotlin.collections.LinkedHashMap
 class KotlinArrangementParseInfo {
 
   private val myEntries = ArrayList<KotlinElementArrangementEntry>()
-  private val myMethodDependencyRoots = ArrayList<KotlinArrangementEntryDependencyInfo>()
-  private val myMethodDependencies = HashMap<KtNamedFunction, MutableSet<KtNamedFunction /* dependencies */>>()
   private val myMethodEntriesMap = HashMap<KtNamedFunction, KotlinElementArrangementEntry>()
-  private val myOverriddenMethods = LinkedHashMap<KtClass, MutableList<Pair<KtNamedFunction/*overridden*/,
-      KtNamedFunction/*overriding*/>>>()
-  private val myTmpMethodDependencyRoots = LinkedHashSet<KtNamedFunction>()
-  private val myDependentMethods = HashSet<KtNamedFunction>()
   private val myFields = LinkedHashMap<KtProperty, KotlinElementArrangementEntry>()
-  private val myFieldDependencies = HashMap<KtProperty, Set<KtProperty>>()
-  private var myRebuildMethodDependencies: Boolean = false
 
   val entries: List<KotlinElementArrangementEntry>
     get() = myEntries
 
-  /**
-   * @return list of method dependency roots, i.e. there is a possible case that particular method
-   * [calls another method][ArrangementEntryDependencyInfo.getDependentEntriesInfos], it calls other methods
-   * and so forth
-   */
-  val methodDependencyRoots: List<KotlinArrangementEntryDependencyInfo>
-    get() {
-      if (myRebuildMethodDependencies) {
-        myMethodDependencyRoots.clear()
-        val cache = HashMap<KtNamedFunction, KotlinArrangementEntryDependencyInfo>()
-        for (method in myTmpMethodDependencyRoots) {
-          val info = buildMethodDependencyInfo(method, cache)
-          if (info != null) {
-            myMethodDependencyRoots.add(info)
-          }
-        }
-        myRebuildMethodDependencies = false
-      }
-      return myMethodDependencyRoots
-    }
-
-  val overriddenMethods: List<KotlinArrangementOverriddenMethodsInfo>
-    get() {
-      val result = ArrayList<KotlinArrangementOverriddenMethodsInfo>()
-      val weights = TObjectIntHashMap<KtNamedFunction>()
-      val comparator = Comparator<Pair<KtNamedFunction, KtNamedFunction>> { o1, o2 ->
-        weights.get(o1.first) - weights.get(o2
-            .first)
-      }
-      for ((key, value) in myOverriddenMethods) {
-        val info = KotlinArrangementOverriddenMethodsInfo(key.name!!)
-        weights.clear()
-        ContainerUtil.sort(value, comparator)
-        for (pair in value) {
-          val overridingMethodEntry = myMethodEntriesMap[pair.second]
-          if (overridingMethodEntry != null) {
-            info.addMethodEntry(overridingMethodEntry)
-          }
-        }
-        if (!info.methodEntries.isEmpty()) {
-          result.add(info)
-        }
-      }
-
-      return result
-    }
-
-  val fieldDependencyRoots: List<KotlinArrangementEntryDependencyInfo>
-    get() = KotlinFieldDependenciesManager(myFieldDependencies, myFields).roots
-
-  val fields: Collection<KotlinElementArrangementEntry>
-    get() = myFields.values
-
   fun addEntry(entry: KotlinElementArrangementEntry) {
     myEntries.add(entry)
   }
 
-
-  private fun buildMethodDependencyInfo(
-      method: KtNamedFunction,
-      cache: MutableMap<KtNamedFunction, KotlinArrangementEntryDependencyInfo>): KotlinArrangementEntryDependencyInfo? {
-    val entry = myMethodEntriesMap[method] ?: return null
-    val result = KotlinArrangementEntryDependencyInfo(entry)
-    val toProcess = Stack<Pair<KtNamedFunction, KotlinArrangementEntryDependencyInfo>>()
-    toProcess.push(Pair.create(method, result))
-    val usedMethods = ContainerUtilRt.newHashSet<KtNamedFunction>()
-    while (!toProcess.isEmpty()) {
-      val pair = toProcess.pop()
-      val dependentMethods = myMethodDependencies[pair.first] ?: continue
-      usedMethods.add(pair.first)
-      for (dependentMethod in dependentMethods) {
-        if (usedMethods.contains(dependentMethod)) {
-          // Prevent cyclic dependencies.
-          return null
-        }
-        val dependentEntry = myMethodEntriesMap[dependentMethod] ?: continue
-        val dependentMethodInfo: KotlinArrangementEntryDependencyInfo? = cache[dependentMethod]
-        if (dependentMethodInfo == null) {
-          cache[dependentMethod] = KotlinArrangementEntryDependencyInfo(dependentEntry)
-        }
-        val dependentPair = Pair.create<KtNamedFunction, KotlinArrangementEntryDependencyInfo>(dependentMethod,
-            dependentMethodInfo)
-        pair.second.addDependentEntryInfo(dependentPair.second)
-        toProcess.push(dependentPair)
-      }
-    }
-    return result
-  }
-
-
   fun onMethodEntryCreated(method: KtNamedFunction, entry: KotlinElementArrangementEntry) {
     myMethodEntriesMap[method] = entry
   }
 
   fun onFieldEntryCreated(field: KtProperty, entry: KotlinElementArrangementEntry) {
     myFields[field] = entry
   }
-
-  /**
-   * Is expected to be called when new method dependency is detected. Here given `'base method'` calls
-   * `'dependent method'`.
-   */
-  fun registerMethodCallDependency(caller: KtNamedFunction, callee: KtNamedFunction) {
-    myTmpMethodDependencyRoots.remove(callee)
-    if (!myDependentMethods.contains(caller)) {
-      myTmpMethodDependencyRoots.add(caller)
-    }
-    myDependentMethods.add(callee)
-    val methods: MutableSet<KtNamedFunction>? = myMethodDependencies[caller]
-    if (methods == null) {
-      myMethodDependencies[caller] = LinkedHashSet()
-    }
-    if (!methods!!.contains(callee)) {
-      methods.add(callee)
-    }
-    myRebuildMethodDependencies = true
-  }
 }
 

src/com/wuhao/code/check/style/arrangement/KotlinArrangementEntryDependencyInfo.kt

@@ -62,7 +62,7 @@ class KotlinArrangementVisitor(private val myInfo: KotlinArrangementParseInfo,
 
   init {
     myGroupingRules = getGroupingRules(settings)
-    myMethodBodyProcessor = MethodBodyProcessor(myInfo)
+    myMethodBodyProcessor = MethodBodyProcessor()
     mySectionDetector = ArrangementSectionDetector(myDocument, settings) { data ->
       val range = data.textRange
       val entry = KotlinSectionArrangementEntry(current, data.token, range, data.text, true)
@@ -87,19 +87,7 @@ class KotlinArrangementVisitor(private val myInfo: KotlinArrangementParseInfo,
     mySectionDetector.processComment(comment)
   }
 
-  private val visitCache = arrayListOf<PsiElement>()
-  override fun visitElement(element: PsiElement) {
-    if (visitCache.contains(element)) {
-      return
-    }
-    visitCache.add(element)
-    super.visitElement(element)
-    element.children.forEach { child ->
-      this.visitElement(child)
-    }
-  }
-
-  override fun visitClass(clazz: KtClass) {
+  override fun visitClass(clazz: KtClass,data:Any?) {
     val isSectionCommentsDetected = registerSectionComments(clazz)
     val range = if (isSectionCommentsDetected) getElementRangeWithoutComments(clazz) else clazz.textRange
     var type = CLASS
@@ -176,7 +164,10 @@ class KotlinArrangementVisitor(private val myInfo: KotlinArrangementParseInfo,
     }
   }
 
-  override fun visitProperty(property: KtProperty) {
+  override fun visitProperty(property: KtProperty, data: Any?) {
+    if (property.parent !is KtClassBody){
+      return
+    }
     val isSectionCommentsDetected = registerSectionComments(property)
     // There is a possible case that more than one field is declared for the same type like 'int i, j;'. We want to process only
     // the first one then.
@@ -261,18 +252,20 @@ class KotlinArrangementVisitor(private val myInfo: KotlinArrangementParseInfo,
     return element.textRange.endOffset
   }
 
-  override fun visitClassInitializer(initializer: KtClassInitializer) {
+  override fun visitClassInitializer(initializer: KtClassInitializer,data: Any?) {
     val entry = createNewEntry(initializer, initializer.textRange, INIT_BLOCK, null, true) ?: return
     parseModifiers(initializer.modifierList, entry)
   }
 
-  override fun visitFunction(function: KtNamedFunction) {
+  override fun visitNamedFunction(function: KtNamedFunction, data: Any?) {
+    if (function.parent !is KtClassBody){
+      return
+    }
     val isSectionCommentsDetected = registerSectionComments(function)
     val range = if (isSectionCommentsDetected)
       getElementRangeWithoutComments(function)
     else
       function.textRange
-
     val type = METHOD
     val entry = createNewEntry(function, range, type, function.name, true) ?: return
     processEntry(entry, function, function.bodyExpression)
@@ -292,40 +285,17 @@ class KotlinArrangementVisitor(private val myInfo: KotlinArrangementParseInfo,
    * @author 吴昊
    * @since 1.2.6
    */
-  private class MethodBodyProcessor internal constructor(private val myInfo: KotlinArrangementParseInfo) :
+  private class MethodBodyProcessor internal constructor() :
       JavaRecursiveElementVisitor() {
     private var myBaseMethod: KtNamedFunction? = null
 
-
-    override fun visitMethodCallExpression(psiMethodCallExpression: PsiMethodCallExpression) {
-      val reference = psiMethodCallExpression.methodExpression.reference ?: return
-      val e = reference.resolve()
-      if (e is KtNamedFunction) {
-        assert(myBaseMethod != null)
-        val m = e as KtNamedFunction?
-        if (m!!.parent === myBaseMethod!!.parent) {
-          myInfo.registerMethodCallDependency(myBaseMethod!!, m!!)
-        }
-      }
-
-      // We process all method call expression children because there is a possible case like below:
-      //   new Runnable() {
-      //     void test();
-      //   }.visit();
-      // Here we want to process that 'Runnable.visit()' implementation.
-      super.visitMethodCallExpression(psiMethodCallExpression)
-    }
-
-
     internal fun setBaseMethod(baseMethod: KtNamedFunction?): Boolean {
       if (baseMethod == null || myBaseMethod == null) {
         myBaseMethod = baseMethod
         return true
       }
       return false
     }
-
-
   }
 
   companion object {

src/com/wuhao/code/check/style/arrangement/KotlinArrangementOverriddenMethodsInfo.kt

@@ -33,8 +33,7 @@ open class KotlinElementArrangementEntry(parent: ArrangementEntry?,
               range: TextRange,
               type: ArrangementSettingsToken,
               name: String?,
-              canBeMatched: Boolean) : this(parent, range.startOffset, range.endOffset, type, name, canBeMatched) {
-  }
+              canBeMatched: Boolean) : this(parent, range.startOffset, range.endOffset, type, name, canBeMatched)
 
   init {
     myTypes.add(type)