chore(jvm): default to not include inner classes on getFunctions()

Author: BFergerson

core/src/main/kotlin/spp/jetbrains/artifact/service/ArtifactScopeService.kt

@@ -39,8 +39,8 @@ object ArtifactScopeService : AbstractSourceMarkerService<IArtifactScopeService>
         return getService(element.language).getLoops(element)
     }
 
-    override fun getFunctions(element: PsiElement): List<PsiNamedElement> {
-        return getService(element.language).getFunctions(element)
+    override fun getFunctions(element: PsiElement, includeInnerClasses: Boolean): List<PsiNamedElement> {
+        return getService(element.language).getFunctions(element, includeInnerClasses)
     }
 
     override fun getClasses(element: PsiElement): List<PsiNamedElement> {
@@ -118,8 +118,8 @@ object ArtifactScopeService : AbstractSourceMarkerService<IArtifactScopeService>
 
 // Extensions
 
-fun PsiElement.getFunctions(): List<PsiNamedElement> {
-    return ArtifactScopeService.getService(language).getFunctions(this)
+fun PsiElement.getFunctions(includeInnerClasses: Boolean = false): List<PsiNamedElement> {
+    return ArtifactScopeService.getService(language).getFunctions(this, includeInnerClasses)
 }
 
 fun PsiElement.getClasses(): List<PsiNamedElement> {

core/src/main/kotlin/spp/jetbrains/artifact/service/define/IArtifactScopeService.kt

@@ -32,7 +32,7 @@ import com.intellij.psi.PsiNamedElement
 interface IArtifactScopeService : ISourceMarkerService {
 
     fun getLoops(element: PsiElement): List<PsiElement>
-    fun getFunctions(element: PsiElement): List<PsiNamedElement>
+    fun getFunctions(element: PsiElement, includeInnerClasses: Boolean = false): List<PsiNamedElement>
     fun getClasses(element: PsiElement): List<PsiNamedElement>
     fun getChildIfs(element: PsiElement): List<PsiElement>
     fun getParentIf(element: PsiElement): PsiElement?

marker/js-marker/src/main/kotlin/spp/jetbrains/marker/js/service/JavascriptArtifactScopeService.kt

@@ -54,7 +54,7 @@ class JavascriptArtifactScopeService : IArtifactScopeService {
         return element.descendantsOfType<JSLoopStatement>().toList()
     }
 
-    override fun getFunctions(element: PsiElement): List<PsiNamedElement> {
+    override fun getFunctions(element: PsiElement, includeInnerClasses: Boolean): List<PsiNamedElement> {
         require(ArtifactTypeService.isJavaScript(element))
         return element.descendantsOfType<JSFunction>().toList()
     }

marker/jvm-marker/src/main/kotlin/spp/jetbrains/marker/jvm/service/JVMArtifactScopeService.kt

@@ -36,6 +36,7 @@ import com.siyeh.ig.psiutils.ControlFlowUtils
 import org.jetbrains.kotlin.backend.jvm.ir.psiElement
 import org.jetbrains.kotlin.idea.caches.resolve.resolveToCall
 import org.jetbrains.kotlin.psi.*
+import org.jetbrains.kotlin.psi.psiUtil.containingClass
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrCall
 import org.jetbrains.plugins.scala.lang.psi.api.statements.ScFunctionDefinition
 import org.joor.Reflect
@@ -64,11 +65,25 @@ class JVMArtifactScopeService : IArtifactScopeService {
         }
     }
 
-    override fun getFunctions(element: PsiElement): List<PsiNamedElement> {
+    override fun getFunctions(element: PsiElement, includeInnerClasses: Boolean): List<PsiNamedElement> {
         return when {
-            ArtifactTypeService.isKotlin(element) -> element.descendantsOfType<KtNamedFunction>().toList()
-            ArtifactTypeService.isScala(element) -> element.descendantsOfType<ScFunctionDefinition>().toList()
-            else -> element.descendantsOfType<PsiMethod>().toList()
+            ArtifactTypeService.isKotlin(element) -> element.descendantsOfType<KtNamedFunction>().filter {
+                if (element is KtClass && !includeInnerClasses) {
+                    element == it.containingClass()
+                } else true
+            }.toList()
+
+            ArtifactTypeService.isScala(element) -> element.descendantsOfType<ScFunctionDefinition>().filter {
+                if (element is PsiClass && !includeInnerClasses) {
+                    element == it.containingClass
+                } else true
+            }.toList()
+
+            else -> element.descendantsOfType<PsiMethod>().filter {
+                if (element is PsiClass && !includeInnerClasses) {
+                    element == it.containingClass
+                } else true
+            }.toList()
         }
     }
 

marker/jvm-marker/src/test/kotlin/spp/jetbrains/marker/jvm/service/JVMArtifactScopeServiceTest.kt

@@ -24,6 +24,8 @@ import com.intellij.testFramework.TestDataPath
 import com.intellij.testFramework.fixtures.BasePlatformTestCase
 import kotlinx.coroutines.runBlocking
 import spp.jetbrains.artifact.service.ArtifactScopeService
+import spp.jetbrains.artifact.service.getClasses
+import spp.jetbrains.artifact.service.getFunctions
 import spp.jetbrains.marker.SourceMarker
 import spp.jetbrains.marker.jvm.JVMLanguageProvider
 
@@ -104,4 +106,28 @@ class JVMArtifactScopeServiceTest : BasePlatformTestCase() {
 //        assertEquals("directCalledFunction", internalCallerFunctions.first().name)
 //        assertEquals("callerFunction", internalCallerFunctions.last().name)
     }
+
+    fun testGetFunctionsOnInnerClass() {
+        doGetFunctionsOnInnerClass("groovy")
+        doGetFunctionsOnInnerClass("java")
+        doGetFunctionsOnInnerClass("kt")
+    }
+
+    private fun doGetFunctionsOnInnerClass(extension: String) {
+        val psiFile = myFixture.configureByFile(getTestName(false) + ".$extension")
+        assertEquals(2, psiFile.getClasses().size)
+
+        val classFunctions = psiFile.getClasses().first().getFunctions()
+        assertEquals(1, classFunctions.size)
+        assertEquals("function1", classFunctions.first().name)
+
+        val innerClassFunctions = psiFile.getClasses().last().getFunctions()
+        assertEquals(1, innerClassFunctions.size)
+        assertEquals("function2", innerClassFunctions.first().name)
+
+        val allFunctions = psiFile.getClasses().first().getFunctions(true)
+        assertEquals(2, allFunctions.size)
+        assertEquals("function1", allFunctions.first().name)
+        assertEquals("function2", allFunctions.last().name)
+    }
 }

marker/jvm-marker/src/test/testData/scope/GetFunctionsOnInnerClass.groovy

@@ -0,0 +1,9 @@
+class GetFunctionsInnerClass {
+    private void function1() {
+    }
+
+    class InnerClass {
+        private void function2() {
+        }
+    }
+}

marker/jvm-marker/src/test/testData/scope/GetFunctionsOnInnerClass.java

@@ -0,0 +1,9 @@
+private class GetFunctionsInnerClass {
+    private void function1() {
+    }
+
+    class InnerClass {
+        private void function2() {
+        }
+    }
+}

marker/jvm-marker/src/test/testData/scope/GetFunctionsOnInnerClass.kt

@@ -0,0 +1,9 @@
+class GetFunctionsInnerClass {
+    fun function1() {
+    }
+
+    class InnerClass {
+        fun function2() {
+        }
+    }
+}

marker/py-marker/src/main/kotlin/spp/jetbrains/marker/py/service/PythonArtifactScopeService.kt

@@ -54,7 +54,7 @@ class PythonArtifactScopeService : IArtifactScopeService {
         return element.descendantsOfType<PyLoopStatement>().toList()
     }
 
-    override fun getFunctions(element: PsiElement): List<PsiNamedElement> {
+    override fun getFunctions(element: PsiElement, includeInnerClasses: Boolean): List<PsiNamedElement> {
         require(ArtifactTypeService.isPython(element))
         return element.descendantsOfType<PyFunction>().toList()
     }