PsiClassFinder

2012-03-27 00:27:27 +04:00
parent 6ef2500494
commit 69c9d3ffad
9 changed files with 174 additions and 47 deletions
@@ -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;
    }
@@ -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);

@@ -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) {
@@ -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;
@@ -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.")) {
@@ -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);
+}
@@ -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());
+    }
+
+
+}