wip: groovy logger detector

Author: BFergerson

marker/jvm-marker/src/main/kotlin/spp/jetbrains/marker/jvm/psi/JVMLoggerDetector.kt

@@ -22,8 +22,12 @@ import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Computable
 import com.intellij.psi.PsiDocumentManager
 import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiRecursiveElementVisitor
 import com.intellij.refactoring.suggested.endOffset
 import com.intellij.refactoring.suggested.startOffset
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.literals.GrLiteral
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.path.GrMethodCallExpression
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod
 import org.jetbrains.uast.UCallExpression
 import org.jetbrains.uast.ULiteralExpression
 import org.jetbrains.uast.UMethod
@@ -58,11 +62,15 @@ class JVMLoggerDetector(val project: Project) : LoggerDetector {
     }
 
     override fun determineLoggerStatements(guideMark: MethodGuideMark): List<DetectedLogger> {
-        val uMethod = ApplicationManager.getApplication().runReadAction(Computable {
-            guideMark.getPsiMethod().toUElementOfType<UMethod>()
-        })
-        if (uMethod != null) {
-            determineLoggerStatements(uMethod, guideMark.sourceFileMarker)
+        if (guideMark.language.id == "Groovy") {
+            determineLoggerStatements(guideMark.getPsiMethod() as GrMethod, guideMark.sourceFileMarker)
+        } else {
+            val uMethod = ApplicationManager.getApplication().runReadAction(Computable {
+                guideMark.getPsiMethod().toUElementOfType<UMethod>()
+            })
+            if (uMethod != null) {
+                determineLoggerStatements(uMethod, guideMark.sourceFileMarker)
+            }
         }
         return guideMark.getChildren().mapNotNull { it.getUserData(DETECTED_LOGGER) }
     }
@@ -111,6 +119,54 @@ class JVMLoggerDetector(val project: Project) : LoggerDetector {
         return loggerStatements
     }
 
+    /**
+     * Unsure why, but Groovy UAST visitors don't work here. Have to use Groovy PSI.
+     */
+    fun determineLoggerStatements(grMethod: GrMethod, fileMarker: SourceFileMarker): List<DetectedLogger> {
+        val loggerStatements = mutableListOf<DetectedLogger>()
+        ApplicationManager.getApplication().runReadAction {
+            grMethod.acceptChildren(object : PsiRecursiveElementVisitor() {
+                override fun visitElement(element: PsiElement) {
+                    if (element is GrMethodCallExpression) {
+                        val loggerClass = element.resolveMethod()?.containingClass?.qualifiedName
+                        if (loggerClass != null && LOGGER_CLASSES.contains(loggerClass)) {
+                            val methodName = element.resolveMethod()?.name
+                            if (methodName != null && LOGGER_METHODS.contains(methodName)) {
+                                val logTemplate = element.argumentList.expressionArguments.firstOrNull()?.run {
+                                    (this as? GrLiteral)?.value as? String
+                                }
+
+                                if (logTemplate != null) {
+                                    log.debug("Found log statement: $logTemplate")
+                                    val detectedLogger = DetectedLogger(
+                                        logTemplate, methodName, getLineNumber(element) + 1
+                                    )
+                                    loggerStatements.add(detectedLogger)
+
+                                    //create expression guide mark for the log statement
+                                    val guideMark = fileMarker.createExpressionSourceMark(
+                                        element, SourceMark.Type.GUIDE
+                                    )
+                                    if (!fileMarker.containsSourceMark(guideMark)) {
+                                        guideMark.putUserData(DETECTED_LOGGER, detectedLogger)
+                                        guideMark.apply(true)
+                                    } else {
+                                        fileMarker.getSourceMark(guideMark.artifactQualifiedName, SourceMark.Type.GUIDE)
+                                            ?.putUserData(DETECTED_LOGGER, detectedLogger)
+                                    }
+                                } else {
+                                    log.warn("No log template argument available for expression: $element")
+                                }
+                            }
+                        }
+                    }
+                    super.visitElement(element)
+                }
+            })
+        }
+        return loggerStatements
+    }
+
     private fun getLineNumber(element: PsiElement, start: Boolean = true): Int {
         val document = element.containingFile.viewProvider.document
             ?: PsiDocumentManager.getInstance(element.project).getDocument(element.containingFile)

marker/jvm-marker/src/test/kotlin/spp/jetbrains/marker/jvm/psi/JVMLoggerDetectorTest.kt

@@ -33,6 +33,8 @@ import io.vertx.core.Vertx
 import org.intellij.lang.annotations.Language
 import org.jetbrains.kotlin.idea.core.util.toPsiFile
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.plugins.groovy.lang.psi.GroovyFile
+import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod
 import org.jetbrains.uast.UFile
 import org.jetbrains.uast.toUElement
 import spp.jetbrains.UserData
@@ -192,4 +194,40 @@ class JVMLoggerDetectorTest : LightJavaCodeInsightFixtureTestCase() {
             assertContainsOrdered(result, "trace {}", "debug {}", "info {}", "warn {}", "error {}")
         }
     }
+
+    fun testGroovyLogbackLogger() {
+        @Language("Groovy") val code = """
+                    import ch.qos.logback.classic.Logger
+                    class TestLogback {
+                        var log = new Logger()
+                        void loggers() {
+                            log.trace("trace {}", "trace")
+                            log.debug("debug {}", "debug")
+                            log.info("info {}", "info")
+                            log.warn("warn {}", "warn")
+                            log.error("error {}", "error")
+                        }
+                    }
+                """.trimIndent()
+
+        ApplicationManager.getApplication().runReadAction {
+            val sourceFile = myFixture.createFile("TestLogback.groovy", code).toPsiFile(project)
+            assertNotNull(sourceFile)
+
+            val uFile = sourceFile.toUElement() as UFile
+            assertEquals(1, uFile.classes.size)
+            assertEquals(1, uFile.classes[0].methods.size)
+
+            JVMMarker.setup()
+            SourceFileMarker.SUPPORTED_FILE_TYPES.add(GroovyFile::class.java)
+            val fileMarker = SourceMarker.getInstance(project).getSourceFileMarker(sourceFile!!)
+            assertNotNull(fileMarker)
+
+            val result = JVMLoggerDetector(project.apply { UserData.vertx(this, Vertx.vertx()) })
+                .determineLoggerStatements(uFile.classes[0].methods[0].sourcePsi as GrMethod, fileMarker!!)
+                .map { it.logPattern }
+            assertEquals(5, result.size)
+            assertContainsOrdered(result, "trace {}", "debug {}", "info {}", "warn {}", "error {}")
+        }
+    }
 }