[Java. Logging] Rename JvmLoggerSymbolReferenceProvider to LoggingArgumentSymbolReferenceProvider

IDEA-342484

GitOrigin-RevId: 60c6c1efbdd4f29bad036f79ce62f8759d2e7fd2

jvm/jvm-analysis-impl/resources/META-INF/JvmAnalysisPlugin.xml

@@ -185,10 +185,10 @@
       hostElementClass="com.intellij.model.psi.PsiExternalReferenceHost"
       hostLanguage="UAST"
       implementationClass="com.intellij.analysis.logging.resolve.JvmLoggerSymbolReferenceProvider"
-      targetClass="com.intellij.analysis.logging.resolve.JvmLoggerArgumentSymbol"/>
+      targetClass="com.intellij.analysis.logging.resolve.LoggingArgumentSymbol"/>
 
     <searcher forClass="com.intellij.find.usages.api.UsageSearchParameters"
-              implementationClass="com.intellij.analysis.logging.resolve.JvmLoggerUsageSearcher"/>
+              implementationClass="com.intellij.analysis.logging.resolve.LoggingArgumentUsageSearcher"/>
 
     <!--console filter-->
     <colorSettingsPage implementation="com.intellij.analysis.customization.console.ClassFinderConsoleColorsPage"/>

jvm/jvm-analysis-impl/src/com/intellij/analysis/logging/resolve/LoggingArgumentSymbol.kt

@@ -21,7 +21,7 @@ import org.jetbrains.uast.UExpression
 import org.jetbrains.uast.getParentOfType
 import org.jetbrains.uast.toUElementOfType
 
-class JvmLoggerArgumentSymbol(val expression: PsiElement) : Symbol, NavigatableSymbol, SearchTarget {
+class LoggingArgumentSymbol(val expression: PsiElement) : Symbol, NavigatableSymbol, SearchTarget {
   override val usageHandler: UsageHandler = UsageHandler.createEmptyUsageHandler(expression.text)
 
   fun getPlaceholderString(): UExpression? {
@@ -33,8 +33,8 @@ class JvmLoggerArgumentSymbol(val expression: PsiElement) : Symbol, NavigatableS
     return getPlaceholderContext(logMethod, LOGGER_RESOLVE_TYPE_SEARCHERS, log4jHasImplementationForSlf4j)?.logStringArgument
   }
 
-  override fun createPointer(): Pointer<JvmLoggerArgumentSymbol> {
-    return Pointer.delegatingPointer(SmartPointerManager.createPointer(expression), ::JvmLoggerArgumentSymbol)
+  override fun createPointer(): Pointer<LoggingArgumentSymbol> {
+    return Pointer.delegatingPointer(SmartPointerManager.createPointer(expression), ::LoggingArgumentSymbol)
   }
 
   override fun presentation(): TargetPresentation = TargetPresentation.builder(expression.text).presentation()
@@ -42,7 +42,7 @@ class JvmLoggerArgumentSymbol(val expression: PsiElement) : Symbol, NavigatableS
   override fun getNavigationTargets(project: Project): Collection<NavigationTarget> = listOf(SymbolNavigationService.getInstance().psiElementNavigationTarget(expression))
 
   override fun equals(other: Any?): Boolean {
-    if (other !is JvmLoggerArgumentSymbol) return false
+    if (other !is LoggingArgumentSymbol) return false
     return other.expression == this.expression
   }
 

jvm/jvm-analysis-impl/src/com/intellij/analysis/logging/resolve/LoggingArgumentSymbolReference.kt

@@ -6,7 +6,7 @@ import com.intellij.model.psi.PsiSymbolReference
 import com.intellij.openapi.util.TextRange
 import com.intellij.psi.PsiElement
 
-class JvmLoggerArgumentSymbolReference(
+class LoggingArgumentSymbolReference(
   private val literalExpression: PsiElement,
   private val literalRange: TextRange,
   private val externalReference: PsiElement,
@@ -15,5 +15,5 @@ class JvmLoggerArgumentSymbolReference(
 
   override fun getRangeInElement(): TextRange = literalRange
 
-  override fun resolveReference(): Collection<Symbol> = listOf(JvmLoggerArgumentSymbol(externalReference))
+  override fun resolveReference(): Collection<Symbol> = listOf(LoggingArgumentSymbol(externalReference))
 }

jvm/jvm-analysis-impl/src/com/intellij/analysis/logging/resolve/LoggingArgumentSymbolReferenceProvider.kt

@@ -22,11 +22,11 @@ class JvmLoggerSymbolReferenceProvider : PsiSymbolReferenceProvider {
   }
 
   private fun hintsCheck(hints: PsiSymbolReferenceHints): Boolean {
-    if (!hints.referenceClass.isAssignableFrom(JvmLoggerArgumentSymbolReference::class.java)) return false
+    if (!hints.referenceClass.isAssignableFrom(LoggingArgumentSymbolReference::class.java)) return false
     val targetClass = hints.targetClass
-    if (targetClass != null && !targetClass.isAssignableFrom(JvmLoggerArgumentSymbol::class.java)) return false
+    if (targetClass != null && !targetClass.isAssignableFrom(LoggingArgumentSymbol::class.java)) return false
     val target = hints.target
-    return target == null || target is JvmLoggerArgumentSymbol
+    return target == null || target is LoggingArgumentSymbol
   }
 
   override fun getSearchRequests(project: Project, target: Symbol): Collection<SearchRequest> {
@@ -57,7 +57,7 @@ fun getLogArgumentReferences(literalExpression: UExpression): List<PsiSymbolRefe
     if (range == null) return null
     val alignedRange = range.shiftRight(offset)
     val parameterPsi = parameter.sourcePsi ?: return null
-    JvmLoggerArgumentSymbolReference(psiLiteralExpression, alignedRange, parameterPsi)
+    LoggingArgumentSymbolReference(psiLiteralExpression, alignedRange, parameterPsi)
   }
 
   return when (context.loggerType) {

jvm/jvm-analysis-impl/src/com/intellij/analysis/logging/resolve/LoggingArgumentUsageSearcher.kt

@@ -8,10 +8,10 @@ import com.intellij.find.usages.api.UsageSearcher
 import com.intellij.model.psi.PsiSymbolReference
 import com.siyeh.ig.format.DefUsage
 
-class JvmLoggerUsageSearcher : UsageSearcher {
+class LoggingArgumentUsageSearcher : UsageSearcher {
   override fun collectImmediateResults(parameters: UsageSearchParameters): Collection<Usage> {
     val target = parameters.target
-    if (target !is JvmLoggerArgumentSymbol) return emptyList()
+    if (target !is LoggingArgumentSymbol) return emptyList()
     val uLiteralExpression = target.getPlaceholderString() ?: return emptyList()
     return getLogArgumentReferences(uLiteralExpression)?.let {
       it.filter { ref: PsiSymbolReference -> ref.resolvesTo(target) }

jvm/jvm-analysis-java-tests/testSrc/com/intellij/logging/resolve/JavaLoggingArgumentSymbolReferenceProviderTest.kt

@@ -1,6 +1,6 @@
 package com.intellij.logging.resolve
 
-import com.intellij.analysis.logging.resolve.JvmLoggerArgumentSymbol
+import com.intellij.analysis.logging.resolve.LoggingArgumentSymbol
 import com.intellij.jvm.analysis.internal.testFramework.logging.LoggingArgumentSymbolReferenceProviderTestBase
 import com.intellij.model.psi.PsiSymbolReference
 import com.intellij.model.psi.PsiSymbolReferenceService
@@ -37,8 +37,8 @@ class JavaLoggingArgumentSymbolReferenceProviderTest : LoggingArgumentSymbolRefe
       val symbols = ref.resolveReference()
       assertEquals(bindings.size, symbols.size)
       val symbol = symbols.single()
-      assertTrue(symbol is JvmLoggerArgumentSymbol)
-      val formatSymbol = symbol as JvmLoggerArgumentSymbol
+      assertTrue(symbol is LoggingArgumentSymbol)
+      val formatSymbol = symbol as LoggingArgumentSymbol
       assertTrue(formatSymbol.getPlaceholderString() is ULiteralExpression)
       val expressionText = formatSymbol.expression.text
       assertEquals(bindings[ref.rangeInElement], expressionText)