From 69c9d3ffad1806fecc586f2e5a8dce9eace9f37a Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Tue, 27 Mar 2012 00:27:27 +0400 Subject: [PATCH] PsiClassFinder --- .../di/InjectorForJavaSemanticServices.java | 11 +++ .../di/InjectorForTopDownAnalyzerForJvm.java | 6 ++ .../resolve/java/JavaDescriptorResolver.java | 53 ++--------- .../lang/resolve/java/JavaPackageScope.java | 4 +- .../resolve/java/JavaSemanticServices.java | 14 +++ .../jet/lang/resolve/java/PsiClassFinder.java | 33 +++++++ .../resolve/java/PsiClassFinderForJvm.java | 93 +++++++++++++++++++ .../jetbrains/jet/resolve/JetResolveTest.java | 4 +- .../jet/di/AllInjectorsGenerator.java | 3 + 9 files changed, 174 insertions(+), 47 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinder.java create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderForJvm.java diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java index 8e7e5bbaf01..58b15636f2b 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaSemanticServices.java @@ -21,6 +21,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; +import org.jetbrains.jet.lang.resolve.java.PsiClassFinderForJvm; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.java.JavaTypeTransformer; @@ -34,6 +35,7 @@ public class InjectorForJavaSemanticServices { private JavaSemanticServices javaSemanticServices; private JavaDescriptorResolver javaDescriptorResolver; private BindingTrace bindingTrace; + private PsiClassFinderForJvm psiClassFinderForJvm; private final Project project; public InjectorForJavaSemanticServices( @@ -43,23 +45,28 @@ public class InjectorForJavaSemanticServices { this.javaDescriptorResolver = new JavaDescriptorResolver(); this.bindingTrace = new org.jetbrains.jet.lang.resolve.BindingTraceContext(); JavaBridgeConfiguration javaBridgeConfiguration = new JavaBridgeConfiguration(); + this.psiClassFinderForJvm = new PsiClassFinderForJvm(); ModuleDescriptor moduleDescriptor = new org.jetbrains.jet.lang.descriptors.ModuleDescriptor(""); this.project = project; JavaTypeTransformer javaTypeTransformer = new JavaTypeTransformer(); NamespaceFactoryImpl namespaceFactoryImpl = new NamespaceFactoryImpl(); this.javaSemanticServices.setDescriptorResolver(javaDescriptorResolver); + this.javaSemanticServices.setPsiClassFinder(psiClassFinderForJvm); this.javaSemanticServices.setTrace(bindingTrace); this.javaSemanticServices.setTypeTransformer(javaTypeTransformer); this.javaDescriptorResolver.setNamespaceFactory(namespaceFactoryImpl); this.javaDescriptorResolver.setProject(project); + this.javaDescriptorResolver.setPsiClassFinder(psiClassFinderForJvm); this.javaDescriptorResolver.setSemanticServices(javaSemanticServices); this.javaDescriptorResolver.setTrace(bindingTrace); javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices); javaBridgeConfiguration.setProject(project); + this.psiClassFinderForJvm.setProject(project); + javaTypeTransformer.setJavaSemanticServices(javaSemanticServices); javaTypeTransformer.setResolver(javaDescriptorResolver); @@ -81,6 +88,10 @@ public class InjectorForJavaSemanticServices { return this.bindingTrace; } + public PsiClassFinderForJvm getPsiClassFinderForJvm() { + return this.psiClassFinderForJvm; + } + public Project getProject() { return this.project; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java index b51433013f8..e3dfc362f42 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -29,6 +29,7 @@ import org.jetbrains.jet.lang.resolve.ObservableBindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; +import org.jetbrains.jet.lang.resolve.java.PsiClassFinderForJvm; import org.jetbrains.jet.lang.resolve.DeclarationResolver; import org.jetbrains.jet.lang.resolve.AnnotationResolver; import org.jetbrains.jet.lang.resolve.calls.CallResolver; @@ -82,6 +83,7 @@ public class InjectorForTopDownAnalyzerForJvm { this.topDownAnalysisParameters = topDownAnalysisParameters; this.observableBindingTrace = observableBindingTrace; this.javaBridgeConfiguration = new JavaBridgeConfiguration(); + PsiClassFinderForJvm psiClassFinderForJvm = new PsiClassFinderForJvm(); DeclarationResolver declarationResolver = new DeclarationResolver(); AnnotationResolver annotationResolver = new AnnotationResolver(); CallResolver callResolver = new CallResolver(); @@ -136,6 +138,8 @@ public class InjectorForTopDownAnalyzerForJvm { this.javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices); this.javaBridgeConfiguration.setProject(project); + psiClassFinderForJvm.setProject(project); + declarationResolver.setAnnotationResolver(annotationResolver); declarationResolver.setContext(topDownAnalysisContext); declarationResolver.setDescriptorResolver(descriptorResolver); @@ -183,11 +187,13 @@ public class InjectorForTopDownAnalyzerForJvm { typeHierarchyResolver.setTrace(observableBindingTrace); javaSemanticServices.setDescriptorResolver(javaDescriptorResolver); + javaSemanticServices.setPsiClassFinder(psiClassFinderForJvm); javaSemanticServices.setTrace(observableBindingTrace); javaSemanticServices.setTypeTransformer(javaTypeTransformer); javaDescriptorResolver.setNamespaceFactory(namespaceFactoryImpl); javaDescriptorResolver.setProject(project); + javaDescriptorResolver.setPsiClassFinder(psiClassFinderForJvm); javaDescriptorResolver.setSemanticServices(javaSemanticServices); javaDescriptorResolver.setTrace(observableBindingTrace); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index 0f1aa136143..a77a3a9f4d1 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -191,25 +191,15 @@ public class JavaDescriptorResolver { protected final Map namespaceDescriptorCacheByFqn = Maps.newHashMap(); protected final Map namespaceDescriptorCache = Maps.newHashMap(); - protected JavaPsiFacade javaFacade; protected Project project; - protected GlobalSearchScope javaSearchScope ; protected JavaSemanticServices semanticServices; - private AltClassFinder altClassFinder; private NamespaceFactory namespaceFactory; private BindingTrace trace; + private PsiClassFinder psiClassFinder; @Inject public void setProject(Project project) { this.project = project; - this.altClassFinder = new AltClassFinder(project); - this.javaSearchScope = new DelegatingGlobalSearchScope(GlobalSearchScope.allScope(project)) { - @Override - public boolean contains(VirtualFile file) { - return myBaseScope.contains(file) && file.getFileType() != JetFileType.INSTANCE; - } - }; - this.javaFacade = JavaPsiFacade.getInstance(project); } @Inject @@ -227,7 +217,10 @@ public class JavaDescriptorResolver { this.trace = trace; } - + @Inject + public void setPsiClassFinder(PsiClassFinder psiClassFinder) { + this.psiClassFinder = psiClassFinder; + } @Nullable ResolverClassData resolveClassData(@NotNull PsiClass psiClass, @NotNull DescriptorSearchRule searchRule) { @@ -313,7 +306,7 @@ public class JavaDescriptorResolver { // Not let's take a descriptor of a Java class ResolverBinaryClassData classData = classDescriptorCache.get(qualifiedName); if (classData == null) { - PsiClass psiClass = findClass(qualifiedName); + PsiClass psiClass = psiClassFinder.findPsiClass(qualifiedName); if (psiClass == null) { return null; } @@ -752,7 +745,8 @@ public class JavaDescriptorResolver { List prevTypeParameters = new ArrayList(); for (TypeParameterDescriptorInitialization psiTypeParameter : typeParametersInitialization) { prevTypeParameters.add(psiTypeParameter.descriptor); - initializeTypeParameter(psiTypeParameter, TypeVariableResolvers.typeVariableResolverFromTypeParameters(prevTypeParameters, typeParametersOwner, context)); + initializeTypeParameter(psiTypeParameter, + TypeVariableResolvers.typeVariableResolverFromTypeParameters(prevTypeParameters, typeParametersOwner, context)); } } @@ -839,42 +833,15 @@ public class JavaDescriptorResolver { } } - PsiPackage psiPackage = findPackage(qualifiedName); + PsiPackage psiPackage = psiClassFinder.findPsiPackage(qualifiedName); if (psiPackage == null) { - PsiClass psiClass = findClass(qualifiedName); + PsiClass psiClass = psiClassFinder.findPsiClass(qualifiedName); if (psiClass == null) return null; return resolveNamespace(psiClass); } return resolveNamespace(psiPackage); } - @Nullable - public PsiClass findClass(@NotNull FqName qualifiedName) { - PsiClass original = javaFacade.findClass(qualifiedName.getFqName(), javaSearchScope); - PsiClass altClass = altClassFinder.findClass(qualifiedName); - PsiClass result = original; - if (altClass != null) { - if (altClass instanceof ClsClassImpl) { - altClass.putUserData(ClsClassImpl.DELEGATE_KEY, original); - } - - result = altClass; - } - - if (result != null) { - FqName actualQualifiedName = new FqName(result.getQualifiedName()); - if (!actualQualifiedName.equals(qualifiedName)) { -// throw new IllegalStateException("requested " + qualifiedName + ", got " + actualQualifiedName); - } - } - - return result; - } - - /*package*/ PsiPackage findPackage(@NotNull FqName qualifiedName) { - return javaFacade.findPackage(qualifiedName.getFqName()); - } - private NamespaceDescriptor resolveNamespace(@NotNull PsiPackage psiPackage) { ResolverNamespaceData namespaceData = namespaceDescriptorCache.get(psiPackage); if (namespaceData == null) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java index 1446f99968c..89910298097 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java @@ -60,7 +60,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope { return null; } else { // TODO: what is GlobalSearchScope - return semanticServices.getDescriptorResolver().javaFacade.findClass(getQualifiedName(packageFQN, JvmAbi.PACKAGE_CLASS).getFqName()); + return semanticServices.getPsiClassFinder().findPsiClass(getQualifiedName(packageFQN, JvmAbi.PACKAGE_CLASS)); } } @@ -107,7 +107,7 @@ public class JavaPackageScope extends JavaClassOrPackageScope { allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(descriptor, psiClass, staticMembers())); } - final PsiPackage javaPackage = semanticServices.getDescriptorResolver().findPackage(packageFQN); + final PsiPackage javaPackage = semanticServices.getPsiClassFinder().findPsiPackage(packageFQN); if (javaPackage != null) { boolean isKotlinNamespace = semanticServices.getKotlinNamespaceDescriptor(new FqName(javaPackage.getQualifiedName())) != null; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java index dd4fbfbad56..a8ad47c14b5 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java @@ -37,6 +37,8 @@ public class JavaSemanticServices { @NotNull private JavaDescriptorResolver descriptorResolver; @NotNull + private PsiClassFinder psiClassFinder; + @NotNull private BindingTrace trace; @@ -50,6 +52,11 @@ public class JavaSemanticServices { this.descriptorResolver = descriptorResolver; } + @Inject + public void setPsiClassFinder(@NotNull PsiClassFinder psiClassFinder) { + this.psiClassFinder = psiClassFinder; + } + @Inject public void setTrace(@NotNull BindingTrace trace) { this.trace = trace; @@ -72,6 +79,13 @@ public class JavaSemanticServices { return trace.get(BindingContext.FQNAME_TO_CLASS_DESCRIPTOR, qualifiedName); } + @NotNull + public PsiClassFinder getPsiClassFinder() { + return psiClassFinder; + } + + + @Nullable public ClassDescriptor getKotlinBuiltinClassDescriptor(@NotNull FqName qualifiedName) { if (qualifiedName.getFqName().startsWith("jet.")) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinder.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinder.java new file mode 100644 index 00000000000..d61d51024db --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinder.java @@ -0,0 +1,33 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.java; + +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiPackage; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.resolve.FqName; + +/** + * @author Stepan Koltsov + */ +public interface PsiClassFinder { + @Nullable + PsiClass findPsiClass(@NotNull FqName fqName); + @Nullable + PsiPackage findPsiPackage(@NotNull FqName fqName); +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderForJvm.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderForJvm.java new file mode 100644 index 00000000000..ed2409eeca9 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/PsiClassFinderForJvm.java @@ -0,0 +1,93 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.java; + +import com.intellij.openapi.project.Project; +import com.intellij.openapi.vfs.VirtualFile; +import com.intellij.psi.JavaPsiFacade; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiPackage; +import com.intellij.psi.impl.compiled.ClsClassImpl; +import com.intellij.psi.search.DelegatingGlobalSearchScope; +import com.intellij.psi.search.GlobalSearchScope; +import com.intellij.psi.search.SearchScope; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.resolve.FqName; +import org.jetbrains.jet.lang.resolve.java.alt.AltClassFinder; +import org.jetbrains.jet.plugin.JetFileType; + +import javax.inject.Inject; + +/** + * @author Stepan Koltsov + */ +public class PsiClassFinderForJvm implements PsiClassFinder { + + private Project project; + private AltClassFinder altClassFinder; + private GlobalSearchScope javaSearchScope; + private JavaPsiFacade javaFacade; + + @Inject + public void setProject(Project project) { + this.project = project; + this.altClassFinder = new AltClassFinder(project); + this.javaSearchScope = new DelegatingGlobalSearchScope(GlobalSearchScope.allScope(project)) { + @Override + public boolean contains(VirtualFile file) { + return myBaseScope.contains(file) && file.getFileType() != JetFileType.INSTANCE; + } + }; + this.javaFacade = JavaPsiFacade.getInstance(project); + } + + + + + @Override + @Nullable + public PsiClass findPsiClass(@NotNull FqName qualifiedName) { + PsiClass original = javaFacade.findClass(qualifiedName.getFqName(), javaSearchScope); + PsiClass altClass = altClassFinder.findClass(qualifiedName); + PsiClass result = original; + if (altClass != null) { + if (altClass instanceof ClsClassImpl) { + altClass.putUserData(ClsClassImpl.DELEGATE_KEY, original); + } + + result = altClass; + } + + if (result != null) { + FqName actualQualifiedName = new FqName(result.getQualifiedName()); + if (!actualQualifiedName.equals(qualifiedName)) { +// throw new IllegalStateException("requested " + qualifiedName + ", got " + actualQualifiedName); + } + } + + return result; + } + + @Override + @Nullable + public PsiPackage findPsiPackage(@NotNull FqName qualifiedName) { + return javaFacade.findPackage(qualifiedName.getFqName()); + } + + +} diff --git a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java index a68fb05871a..bd62dc67e58 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/JetResolveTest.java @@ -123,8 +123,8 @@ public class JetResolveTest extends ExtensibleResolveTestCase { @NotNull private PsiClass findClass(String qualifiedName) { Project project = getProject(); - JavaDescriptorResolver javaDescriptorResolver = new InjectorForJavaSemanticServices(project).getJavaDescriptorResolver(); - return javaDescriptorResolver.findClass(new FqName(qualifiedName)); + InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(project); + return injector.getPsiClassFinderForJvm().findPsiClass(new FqName(qualifiedName)); } @NotNull diff --git a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java index f82f8addb02..0117bfc8a08 100644 --- a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java +++ b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java @@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; +import org.jetbrains.jet.lang.resolve.java.PsiClassFinderForJvm; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; @@ -64,6 +65,7 @@ public class AllInjectorsGenerator { DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false); generateInjectorForTopDownAnalyzerCommon(generator); generator.addPublicField(JavaBridgeConfiguration.class); + generator.addField(PsiClassFinderForJvm.class); generator.generate("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJvm"); } @@ -121,6 +123,7 @@ public class AllInjectorsGenerator { generator.addField(true, BindingTrace.class, null, new GivenExpression("new org.jetbrains.jet.lang.resolve.BindingTraceContext()")); generator.addField(JavaBridgeConfiguration.class); + generator.addPublicField(PsiClassFinderForJvm.class); generator.addField(false, ModuleDescriptor.class, null, new GivenExpression("new org.jetbrains.jet.lang.descriptors.ModuleDescriptor(\"\")"));