MDS/openide
1
0
Fork 0
mirror of https://gitflic.ru/project/openide/openide.git synced 2026-09-27 10:03:11 +07:00
Code Issues Packages Projects Releases Wiki Activity

gradle: replace usages of deprecated method GroovyPsiManager.findClassWithCache

Browse Source
This commit is contained in:
Vladislav.Soroka
2017-01-18 13:11:26 +03:00
parent 8913e40ed1
commit 6038dcbab2
13 changed files with 48 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files
plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleArtifactsContributor.kt
+5 -5
View File
@@ -17,6 +17,7 @@ package org.jetbrains.plugins.gradle.service.resolve
import com.intellij.patterns.PsiJavaPatterns.psiElement
import com.intellij.psi.CommonClassNames.JAVA_LANG_OBJECT
import com.intellij.psi.JavaPsiFacade
import com.intellij.psi.PsiElement
import com.intellij.psi.PsiType
import com.intellij.psi.ResolveState
@@ -51,7 +52,6 @@ class GradleArtifactsContributor : GradleMethodContextContributor {
processor: PsiScopeProcessor,
state: ResolveState,
place: PsiElement): Boolean {
val psiManager = GroovyPsiManager.getInstance(place.project)
val methodName = if (methodCallInfo.isNotEmpty()) methodCallInfo[0] else null
if (methodName != null && place is GrReferenceExpression && psiElement().inside(artifactsClosure).accepts(place)) {
val text = place.text
@@ -61,7 +61,7 @@ class GradleArtifactsContributor : GradleMethodContextContributor {
return false
}
if (!GradleResolverUtil.processDeclarations(psiManager, processor, state, place, GRADLE_API_ARTIFACT_HANDLER)) return false
if (!GradleResolverUtil.processDeclarations(processor, state, place, GRADLE_API_ARTIFACT_HANDLER)) return false
// assuming that the method call is addition of an artifact to the given configuration.
if (!processArtifactAddition(processor, state, place)) return false
}
@@ -78,11 +78,11 @@ class GradleArtifactsContributor : GradleMethodContextContributor {
private fun processArtifactAddition(processor: PsiScopeProcessor,
state: ResolveState,
place: PsiElement): Boolean {
val psiManager = GroovyPsiManager.getInstance(place.project)
val artifactHandlerClass = psiManager.findClassWithCache(GRADLE_API_ARTIFACT_HANDLER, place.resolveScope) ?: return true
val groovyPsiManager = GroovyPsiManager.getInstance(place.project)
val artifactHandlerClass = JavaPsiFacade.getInstance(place.project).findClass(GRADLE_API_ARTIFACT_HANDLER, place.resolveScope) ?: return true
val call = PsiTreeUtil.getParentOfType(place, GrMethodCall::class.java) ?: return true
val returnClass = psiManager.createTypeByFQClassName(GRADLE_API_PUBLISH_ARTIFACT, place.resolveScope) ?: return true
val returnClass = groovyPsiManager.createTypeByFQClassName(GRADLE_API_PUBLISH_ARTIFACT, place.resolveScope) ?: return true
val type = PsiType.getJavaLangObject(place.manager, place.resolveScope).createArrayType()
val builder = GrLightMethodBuilder(place.manager, "add").apply {
containingClass = artifactHandlerClass
plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleDependenciesContributor.kt
+5 -4
View File
@@ -17,6 +17,7 @@ package org.jetbrains.plugins.gradle.service.resolve
import com.intellij.patterns.PsiJavaPatterns.psiElement
import com.intellij.patterns.StandardPatterns.or
import com.intellij.psi.JavaPsiFacade
import com.intellij.psi.PsiElement
import com.intellij.psi.ResolveState
import com.intellij.psi.scope.ElementClassHint
@@ -72,7 +73,7 @@ class GradleDependenciesContributor : GradleMethodContextContributor {
}
override fun process(methodCallInfo: List<String>, processor: PsiScopeProcessor, state: ResolveState, place: PsiElement): Boolean {
val psiManager = GroovyPsiManager.getInstance(place.project)
val groovyPsiManager = GroovyPsiManager.getInstance(place.project)
val methodName = methodCallInfo.firstOrNull() ?: return true
val classHint = processor.getHint(ElementClassHint.KEY)
@@ -80,12 +81,12 @@ class GradleDependenciesContributor : GradleMethodContextContributor {
if (shouldProcessMethods && place is GrReferenceExpression && psiElement().inside(dependenciesClosure).accepts(place)) {
if (methodCallInfo.size == 2) {
val resolveScope = place.getResolveScope()
val psiClass = psiManager.findClassWithCache(GRADLE_API_DEPENDENCY_HANDLER, resolveScope) ?: return true
val psiClass = JavaPsiFacade.getInstance(place.project).findClass(GRADLE_API_DEPENDENCY_HANDLER, resolveScope) ?: return true
if (canBeMethodOf(methodName, psiClass)) {
return true
}
val returnClass = psiManager.createTypeByFQClassName(GRADLE_API_ARTIFACTS_DEPENDENCY, resolveScope) ?: return true
val returnClass = groovyPsiManager.createTypeByFQClassName(GRADLE_API_ARTIFACTS_DEPENDENCY, resolveScope) ?: return true
val wrappedBase = GrLightMethodBuilder(place.manager, "add").apply {
returnType = returnClass
containingClass = psiClass
@@ -95,7 +96,7 @@ class GradleDependenciesContributor : GradleMethodContextContributor {
}
}
if (psiElement().inside(dependencyConfigurationClosure).accepts(place)) {
if (GradleResolverUtil.processDeclarations(psiManager, processor, state, place,
if (GradleResolverUtil.processDeclarations(processor, state, place,
GRADLE_API_ARTIFACTS_MODULE_DEPENDENCY,
GRADLE_API_ARTIFACTS_CLIENT_MODULE_DEPENDENCY)) return false
}
plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleExtensionsContributor.kt
+15 -14
View File
@@ -22,6 +22,7 @@ import com.intellij.patterns.ElementPattern
import com.intellij.patterns.PatternCondition
import com.intellij.patterns.PsiJavaPatterns.psiElement
import com.intellij.psi.CommonClassNames.*
import com.intellij.psi.JavaPsiFacade
import com.intellij.psi.PsiElement
import com.intellij.psi.ResolveState
import com.intellij.psi.scope.ElementClassHint
@@ -95,21 +96,21 @@ class GradleExtensionsContributor : GradleMethodContextContributor {
val classHint = processor.getHint(ElementClassHint.KEY)
val shouldProcessMethods = ResolveUtil.shouldProcessMethods(classHint)
val shouldProcessProperties = ResolveUtil.shouldProcessProperties(classHint)
val psiManager = GroovyPsiManager.getInstance(place.project)
val groovyPsiManager = GroovyPsiManager.getInstance(place.project)
val resolveScope = place.resolveScope
val projectClass = psiManager.findClassWithCache(GRADLE_API_PROJECT, resolveScope) ?: return true
val projectClass = JavaPsiFacade.getInstance(place.project).findClass(GRADLE_API_PROJECT, resolveScope) ?: return true
val name = processor.getHint(NameHint.KEY)?.getName(state)
if (psiElement().inside(closureInLeftShiftMethod).accepts(place)) {
if (!GradleResolverUtil.processDeclarations(psiManager, processor, state, place, GRADLE_API_DEFAULT_TASK)) {
if (!GradleResolverUtil.processDeclarations(processor, state, place, GRADLE_API_DEFAULT_TASK)) {
return false
}
}
if (place.text == "task" && place is GrReferenceExpression && place.parent is GrApplicationStatement) {
if (GradleResolverUtil.isLShiftElement(place.parent?.children?.getOrNull(1)?.firstChild)) {
val taskContainerClass = psiManager.findClassWithCache(GRADLE_API_TASK_CONTAINER, resolveScope) ?: return true
val returnClass = psiManager.createTypeByFQClassName(GRADLE_API_TASK, resolveScope) ?: return true
val taskContainerClass = JavaPsiFacade.getInstance(place.project).findClass(GRADLE_API_TASK_CONTAINER, resolveScope) ?: return true
val returnClass = groovyPsiManager.createTypeByFQClassName(GRADLE_API_TASK, resolveScope) ?: return true
val methodBuilder = GrLightMethodBuilder(place.manager, "create").apply {
containingClass = taskContainerClass
returnType = returnClass
@@ -143,7 +144,7 @@ class GradleExtensionsContributor : GradleMethodContextContributor {
for (gradleTask in extensionsData.tasks) {
if (shouldProcessMethods && name == gradleTask.name) {
val returnClass = psiManager.createTypeByFQClassName(
val returnClass = groovyPsiManager.createTypeByFQClassName(
if (isTaskDeclaration) JAVA_LANG_STRING else gradleTask.typeFqn, resolveScope) ?: continue
val methodBuilder = GrLightMethodBuilder(place.manager, gradleTask.name).apply {
@@ -163,7 +164,7 @@ class GradleExtensionsContributor : GradleMethodContextContributor {
val taskClosure = groovyClosure().inMethod(psiMethod(GRADLE_API_PROJECT, gradleTask.name))
val psiElement = psiElement()
if (psiElement.inside(taskClosure).accepts(place)) {
if (shouldProcessMethods && !GradleResolverUtil.processDeclarations(psiManager, processor, state, place, gradleTask.typeFqn)) {
if (shouldProcessMethods && !GradleResolverUtil.processDeclarations(processor, state, place, gradleTask.typeFqn)) {
place.putUserData(RESOLVED_CODE, null)
return false
}
@@ -210,7 +211,7 @@ class GradleExtensionsContributor : GradleMethodContextContributor {
return processor.execute(variable, state)
}
else if (shouldProcessMethods && it.typeFqn == GROOVY_LANG_CLOSURE) {
val returnClass = psiManager.createTypeByFQClassName(GROOVY_LANG_CLOSURE, resolveScope) ?: return true
val returnClass = groovyPsiManager.createTypeByFQClassName(GROOVY_LANG_CLOSURE, resolveScope) ?: return true
val methodBuilder = GrLightMethodBuilder(place.manager, name).apply {
returnType = returnClass
addParameter("args", JAVA_LANG_OBJECT, true)
@@ -262,7 +263,7 @@ class GradleExtensionsContributor : GradleMethodContextContributor {
buffer.append(" " + gradleProp.name)
val hasInitializer = !gradleProp.value.isNullOrBlank()
if (hasInitializer) {
buffer.append(" = ");
buffer.append(" = ")
val longString = gradleProp.value!!.toString().length > 100
if (longString) {
buffer.append("<blockquote>")
@@ -300,14 +301,14 @@ fun processExtension(processor: PsiScopeProcessor,
extension: GradleExtensionsSettings.GradleExtension): Boolean {
val classHint = processor.getHint(ElementClassHint.KEY)
val shouldProcessMethods = ResolveUtil.shouldProcessMethods(classHint)
val psiManager = GroovyPsiManager.getInstance(place.project)
val groovyPsiManager = GroovyPsiManager.getInstance(place.project)
val resolveScope = place.resolveScope
val projectClass = psiManager.findClassWithCache(GRADLE_API_PROJECT, resolveScope) ?: return true
val projectClass = JavaPsiFacade.getInstance(place.project).findClass(GRADLE_API_PROJECT, resolveScope) ?: return true
val name = processor.getHint(NameHint.KEY)?.getName(state)
if (name == extension.name) {
val returnClass = psiManager.createTypeByFQClassName(extension.rootTypeFqn, resolveScope) ?: return true
val returnClass = groovyPsiManager.createTypeByFQClassName(extension.rootTypeFqn, resolveScope) ?: return true
val methodName = if (shouldProcessMethods) extension.name else "get" + extension.name.capitalize()
val methodBuilder = GrLightMethodBuilder(place.manager, methodName).apply {
containingClass = projectClass
@@ -324,13 +325,13 @@ fun processExtension(processor: PsiScopeProcessor,
val placeText = place.text
val psiElement = psiElement()
if (psiElement.inside(extensionClosure).accepts(place)) {
if (shouldProcessMethods && !GradleResolverUtil.processDeclarations(psiManager, processor, state, place, extension.rootTypeFqn)) {
if (shouldProcessMethods && !GradleResolverUtil.processDeclarations(processor, state, place, extension.rootTypeFqn)) {
return false
}
val objectTypeFqn = extension.namedObjectTypeFqn?.let { if (it.isNotBlank()) it else null } ?: return true
if (place.parent is GrMethodCallExpression) {
val methodBuilder = GradleResolverUtil.createMethodWithClosure(placeText, objectTypeFqn, null, place, psiManager)
val methodBuilder = GradleResolverUtil.createMethodWithClosure(placeText, objectTypeFqn, null, place)
if (methodBuilder != null) {
place.putUserData(RESOLVED_CODE, true)
if (!processor.execute(methodBuilder, state)) return false
plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleIdeaPluginScriptContributor.kt
+1 -1
View File
@@ -80,7 +80,7 @@ class GradleIdeaPluginScriptContributor : GradleMethodContextContributor {
val psiManager = GroovyPsiManager.getInstance(place.project)
if (psiElement().inside(ideaIprClosure).inside(ideaProjectClosure).accepts(place)) {
if (GradleResolverUtil.processDeclarations(psiManager, processor, state, place, IDE_XML_MERGER_FQN)) return false
if (GradleResolverUtil.processDeclarations(processor, state, place, IDE_XML_MERGER_FQN)) return false
}
return true
}
plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleJavaContributor.kt
+1 -3
View File
@@ -26,7 +26,6 @@ import groovy.lang.Closure
import org.jetbrains.plugins.gradle.service.resolve.GradleCommonClassNames.*
import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression
import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager
import org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.TypesUtil
import org.jetbrains.plugins.groovy.lang.psi.patterns.groovyClosure
import org.jetbrains.plugins.groovy.lang.psi.patterns.psiMethod
@@ -67,8 +66,7 @@ class GradleJavaContributor : GradleMethodContextContributor {
}
override fun process(methodCallInfo: List<String>, processor: PsiScopeProcessor, state: ResolveState, place: PsiElement): Boolean {
val psiManager = GroovyPsiManager.getInstance(place.project)
if (!GradleResolverUtil.processDeclarations(psiManager, processor, state, place,
if (!GradleResolverUtil.processDeclarations(processor, state, place,
GRADLE_API_BASE_PLUGIN_CONVENTION,
GRADLE_API_JAVA_PLUGIN_CONVENTION,
GRADLE_API_APPLICATION_PLUGIN_CONVENTION,
plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleMavenArtifactRepositoryContributor.kt
+1 -4
View File
@@ -23,7 +23,6 @@ import com.intellij.psi.scope.PsiScopeProcessor
import groovy.lang.Closure
import org.jetbrains.plugins.gradle.service.resolve.GradleCommonClassNames.*
import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock
import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager
import org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.TypesUtil
import org.jetbrains.plugins.groovy.lang.psi.patterns.groovyClosure
import org.jetbrains.plugins.groovy.lang.psi.patterns.psiMethod
@@ -55,11 +54,9 @@ class GradleMavenArtifactRepositoryContributor : GradleMethodContextContributor
processor: PsiScopeProcessor,
state: ResolveState,
place: PsiElement): Boolean {
val psiManager = GroovyPsiManager.getInstance(place.project)
if (methodCallInfo.isNotEmpty() && psiElement().inside(repositoryClosure).accepts(place)) {
if (!GradleResolverUtil.processDeclarations(
psiManager, processor, state, place, GRADLE_API_ARTIFACTS_REPOSITORIES_MAVEN_ARTIFACT_REPOSITORY)) return false
processor, state, place, GRADLE_API_ARTIFACTS_REPOSITORIES_MAVEN_ARTIFACT_REPOSITORY)) return false
}
return true
}
plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleMiscContributor.kt
+4 -7
View File
@@ -16,10 +16,7 @@
package org.jetbrains.plugins.gradle.service.resolve
import com.intellij.patterns.PsiJavaPatterns.psiElement
import com.intellij.psi.PsiClass
import com.intellij.psi.PsiElement
import com.intellij.psi.PsiType
import com.intellij.psi.ResolveState
import com.intellij.psi.*
import com.intellij.psi.scope.PsiScopeProcessor
import groovy.lang.Closure
import org.jetbrains.plugins.gradle.service.resolve.GradleCommonClassNames.*
@@ -92,12 +89,12 @@ class GradleMiscContributor : GradleMethodContextContributor {
val classHint = processor.getHint(com.intellij.psi.scope.ElementClassHint.KEY)
val shouldProcessMethods = ResolveUtil.shouldProcessMethods(classHint)
val psiManager = GroovyPsiManager.getInstance(place.project)
val groovyPsiManager = GroovyPsiManager.getInstance(place.project)
val resolveScope = place.resolveScope
if (shouldProcessMethods && place.parent?.parent is GroovyFile && place.text == "plugins") {
val pluginsDependenciesClass = psiManager.findClassWithCache(pluginDependenciesSpecFqn, resolveScope) ?: return true
val returnClass = psiManager.createTypeByFQClassName(pluginDependenciesSpecFqn, resolveScope) ?: return true
val pluginsDependenciesClass = JavaPsiFacade.getInstance(place.project).findClass(pluginDependenciesSpecFqn, resolveScope) ?: return true
val returnClass = groovyPsiManager.createTypeByFQClassName(pluginDependenciesSpecFqn, resolveScope) ?: return true
val methodBuilder = GrLightMethodBuilder(place.manager, "plugins").apply {
containingClass = pluginsDependenciesClass
returnType = returnClass
plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleNonCodeMembersContributor.kt
+3 -4
View File
@@ -35,7 +35,6 @@ import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrApplic
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.path.GrMethodCallExpression
import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager
import org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.TypesUtil
import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightField
import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightMethodBuilder
@@ -121,8 +120,8 @@ class GradleNonCodeMembersContributor : NonCodeMembersContributor() {
if (GradleResolverUtil.canBeMethodOf(propCandidate, aClass)) return
val domainObjectFqn = TypesUtil.getQualifiedName(domainObjectType) ?: return
val psiManager = GroovyPsiManager.getInstance(place.project)
val domainObjectPsiClass = psiManager.findClassWithCache(domainObjectFqn, place.resolveScope) ?: return
val javaPsiFacade = JavaPsiFacade.getInstance(place.project)
val domainObjectPsiClass = javaPsiFacade.findClass(domainObjectFqn, place.resolveScope) ?: return
if (GradleResolverUtil.canBeMethodOf(propCandidate, domainObjectPsiClass)) return
if (GradleResolverUtil.canBeMethodOf("get" + propCandidate.capitalize(), domainObjectPsiClass)) return
if (GradleResolverUtil.canBeMethodOf("set" + propCandidate.capitalize(), domainObjectPsiClass)) return
@@ -131,7 +130,7 @@ class GradleNonCodeMembersContributor : NonCodeMembersContributor() {
val typeToDelegate = closure?.let { getDelegatesToInfo(it)?.typeToDelegate }
if (typeToDelegate != null) {
val fqNameToDelegate = TypesUtil.getQualifiedName(typeToDelegate) ?: return
val classToDelegate = psiManager.findClassWithCache(fqNameToDelegate, place.resolveScope) ?: return
val classToDelegate = javaPsiFacade.findClass(fqNameToDelegate, place.resolveScope) ?: return
if (classToDelegate !== aClass) {
val parent = place.parent
if (parent is GrMethodCall) {
plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleProjectContributor.kt
+1 -3
View File
@@ -21,7 +21,6 @@ import com.intellij.psi.scope.PsiScopeProcessor
import groovy.lang.Closure
import org.jetbrains.plugins.gradle.service.resolve.GradleCommonClassNames.*
import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock
import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager
import org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.TypesUtil
import org.jetbrains.plugins.groovy.lang.psi.patterns.groovyClosure
import org.jetbrains.plugins.groovy.lang.psi.patterns.psiMethod
@@ -54,7 +53,6 @@ class GradleProjectContributor : GradleMethodContextContributor {
}
override fun process(methodCallInfo: List<String>, processor: PsiScopeProcessor, state: ResolveState, place: PsiElement): Boolean {
val psiManager = GroovyPsiManager.getInstance(place.project)
return GradleResolverUtil.processDeclarations(psiManager, processor, state, place, GRADLE_API_PROJECT)
return GradleResolverUtil.processDeclarations(processor, state, place, GRADLE_API_PROJECT)
}
}
plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleResolverUtil.java
+5 -7
View File
@@ -28,7 +28,6 @@ import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrArgument
import org.jetbrains.plugins.groovy.lang.psi.api.statements.arguments.GrNamedArgument;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrBinaryExpression;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager;
import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightMethodBuilder;
import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GrLightParameter;
import org.jetbrains.plugins.groovy.lang.psi.util.GroovyCommonClassNames;
@@ -62,11 +61,10 @@ public class GradleResolverUtil {
public static GrLightMethodBuilder createMethodWithClosure(@NotNull String name,
@Nullable String returnType,
@Nullable String closureTypeParameter,
@NotNull PsiElement place,
@NotNull GroovyPsiManager psiManager) {
@NotNull PsiElement place) {
PsiClassType closureType;
PsiClass closureClass =
psiManager.findClassWithCache(GroovyCommonClassNames.GROOVY_LANG_CLOSURE, place.getResolveScope());
JavaPsiFacade.getInstance(place.getProject()).findClass(GroovyCommonClassNames.GROOVY_LANG_CLOSURE, place.getResolveScope());
if (closureClass == null) return null;
if (closureClass.getTypeParameters().length != 1) {
@@ -98,14 +96,14 @@ public class GradleResolverUtil {
return methodWithClosure;
}
public static boolean processDeclarations(@NotNull GroovyPsiManager psiManager,
@NotNull PsiScopeProcessor processor,
public static boolean processDeclarations(@NotNull PsiScopeProcessor processor,
@NotNull ResolveState state,
@NotNull PsiElement place,
@NotNull String... fqNames) {
JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(place.getProject());
for (String fqName : fqNames) {
if(fqName == null) continue;
PsiClass psiClass = psiManager.findClassWithCache(fqName, place.getResolveScope());
PsiClass psiClass = javaPsiFacade.findClass(fqName, place.getResolveScope());
if (psiClass != null) {
if (!UtilKt.processDeclarations(psiClass, processor, state, place)) return false;
}
plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/GradleSettingsScriptContributor.java
+1 -3
View File
@@ -19,7 +19,6 @@ import com.intellij.psi.*;
import com.intellij.psi.scope.PsiScopeProcessor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.plugins.gradle.util.GradleConstants;
import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager;
import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GroovyScriptClass;
import org.jetbrains.plugins.groovy.lang.resolve.NonCodeMembersContributor;
@@ -44,7 +43,6 @@ public class GradleSettingsScriptContributor extends NonCodeMembersContributor {
return;
}
GroovyPsiManager psiManager = GroovyPsiManager.getInstance(place.getProject());
GradleResolverUtil.processDeclarations(psiManager, processor, state, place, GradleCommonClassNames.GRADLE_API_INITIALIZATION_SETTINGS);
GradleResolverUtil.processDeclarations(processor, state, place, GradleCommonClassNames.GRADLE_API_INITIALIZATION_SETTINGS);
}
}
plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/dsl/GradleDslAnnotator.java
+4 -4
View File
@@ -17,6 +17,7 @@ package org.jetbrains.plugins.gradle.service.resolve.dsl;
import com.intellij.lang.annotation.AnnotationHolder;
import com.intellij.lang.annotation.Annotator;
import com.intellij.psi.JavaPsiFacade;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiType;
@@ -26,7 +27,6 @@ import org.jetbrains.plugins.gradle.service.resolve.GradleCommonClassNames;
import org.jetbrains.plugins.gradle.service.resolve.GradleResolverUtil;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager;
import org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.TypesUtil;
import org.jetbrains.plugins.groovy.lang.psi.util.GroovyCommonClassNames;
import org.jetbrains.plugins.groovy.lang.resolve.ResolveUtil;
@@ -50,14 +50,14 @@ public class GradleDslAnnotator implements Annotator {
PsiType psiType = GradleResolverUtil.getTypeOf(qualifier);
if (psiType == null) return;
if (InheritanceUtil.isInheritor(psiType, GradleCommonClassNames.GRADLE_API_NAMED_DOMAIN_OBJECT_COLLECTION)) {
final GroovyPsiManager psiManager = GroovyPsiManager.getInstance(element.getProject());
JavaPsiFacade javaPsiFacade = JavaPsiFacade.getInstance(element.getProject());
PsiClass defaultGroovyMethodsClass =
psiManager.findClassWithCache(GroovyCommonClassNames.DEFAULT_GROOVY_METHODS, element.getResolveScope());
javaPsiFacade.findClass(GroovyCommonClassNames.DEFAULT_GROOVY_METHODS, element.getResolveScope());
if (canBeMethodOf(referenceExpression.getReferenceName(), defaultGroovyMethodsClass)) return;
final String qualifiedName = TypesUtil.getQualifiedName(psiType);
final PsiClass containerClass =
qualifiedName != null ? psiManager.findClassWithCache(qualifiedName, element.getResolveScope()) : null;
qualifiedName != null ? javaPsiFacade.findClass(qualifiedName, element.getResolveScope()) : null;
if (canBeMethodOf(referenceExpression.getReferenceName(), containerClass)) return;
PsiElement nameElement = referenceExpression.getReferenceNameElement();
plugins/gradle/src/org/jetbrains/plugins/gradle/service/resolve/util.kt
+2 -4
View File
@@ -24,7 +24,6 @@ import org.jetbrains.plugins.groovy.codeInspection.assignment.GrMethodCallInfo
import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrMethodCall
import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression
import org.jetbrains.plugins.groovy.lang.psi.impl.GroovyPsiManager
import org.jetbrains.plugins.groovy.lang.psi.impl.statements.expressions.TypesUtil
import org.jetbrains.plugins.groovy.lang.psi.impl.synthetic.GroovyScriptClass
import org.jetbrains.plugins.groovy.lang.psi.util.GroovyPropertyUtils
@@ -62,8 +61,7 @@ fun processDeclarations(aClass: PsiClass,
val typeToDelegate = closure?.let { getDelegatesToInfo(it)?.typeToDelegate }
if (typeToDelegate != null) {
val fqNameToDelegate = TypesUtil.getQualifiedName(typeToDelegate) ?: return true
val classToDelegate = GroovyPsiManager.getInstance(place.project).findClassWithCache(fqNameToDelegate,
place.resolveScope) ?: return true
val classToDelegate = JavaPsiFacade.getInstance(place.project).findClass(fqNameToDelegate, place.resolveScope) ?: return true
if (classToDelegate !== aClass) {
val parent = place.parent
if (parent is GrMethodCall) {
@@ -73,7 +71,7 @@ fun processDeclarations(aClass: PsiClass,
}
}
val lValue: Boolean = place is GrReferenceExpression && PsiUtil.isLValue(place);
val lValue: Boolean = place is GrReferenceExpression && PsiUtil.isLValue(place)
if (!lValue) {
val isSetterCandidate = name.startsWith("set")
val isGetterCandidate = name.startsWith("get")