PsiClassFinder

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("<dummy>");
         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;
     }

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);
 

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java

@@ -191,25 +191,15 @@ public class JavaDescriptorResolver {
     protected final Map<FqName, ResolverNamespaceData> namespaceDescriptorCacheByFqn = Maps.newHashMap();
     protected final Map<PsiElement, ResolverNamespaceData> 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<TypeParameterDescriptor> prevTypeParameters = new ArrayList<TypeParameterDescriptor>();
         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) {

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;

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.")) {

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);
+}

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());
+    }
+
+
+}

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();
+        InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(project);
-        return javaDescriptorResolver.findClass(new FqName(qualifiedName));
+        return injector.getPsiClassFinderForJvm().findPsiClass(new FqName(qualifiedName));
     }
 
     @NotNull

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(\"<dummy>\")"));