From de54f7d732ddc6811b841e628d3198a91b09dc71 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Mon, 29 Jul 2013 21:44:43 +0400 Subject: [PATCH] JavaClass, JavaPackage, JavaAnnotation Create dumb wrappers over PSI elements, will be used for loading descriptors from JVM reflection later (instead of PSI) --- .../di/InjectorForJavaDescriptorResolver.java | 9 ++- .../di/InjectorForTopDownAnalyzerForJvm.java | 9 ++- .../resolve/java/DescriptorResolverUtils.java | 44 +++++------ .../lang/resolve/java/JavaClassFinder.java | 32 ++++++++ .../resolve/java/JavaClassFinderImpl.java | 50 ++++++++++++ .../resolve/java/JavaDescriptorResolver.java | 6 +- .../resolve/java/provider/MembersCache.java | 35 +++++---- .../java/resolver/JavaClassResolver.java | 42 +++++----- .../resolver/JavaConstructorResolver.java | 5 +- .../java/resolver/JavaNamespaceResolver.java | 41 +++++----- .../scope/JavaClassNonStaticMembersScope.java | 26 +++---- .../scope/JavaClassStaticMembersScope.java | 12 +-- .../resolve/java/scope/JavaPackageScope.java | 30 ++++---- .../resolve/java/scope/MembersProvider.java | 24 +++--- .../java/structure/JavaAnnotation.java | 28 +++++++ .../resolve/java/structure/JavaClass.java | 76 +++++++++++++++++++ .../resolve/java/structure/JavaPackage.java | 67 ++++++++++++++++ .../injectors/GenerateInjectors.java | 3 + .../caches/JetFromJavaDescriptorHelper.java | 3 +- .../completion/DescriptorLookupConverter.java | 5 +- .../completion/JetTypesCompletionHelper.java | 3 +- .../importOptimizer/JetImportOptimizer.java | 3 +- 22 files changed, 417 insertions(+), 136 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinder.java create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderImpl.java create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaAnnotation.java create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaPackage.java diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java index 4f678616848..8dbb485fb88 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -18,6 +18,7 @@ package org.jetbrains.jet.di; import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder; @@ -42,6 +43,7 @@ public class InjectorForJavaDescriptorResolver { private final Project project; private final BindingTrace bindingTrace; + private final JavaClassFinderImpl javaClassFinder; private final JavaDescriptorResolver javaDescriptorResolver; private final PsiClassFinderImpl psiClassFinder; private final VirtualFileFinder virtualFileFinder; @@ -65,6 +67,7 @@ public class InjectorForJavaDescriptorResolver { ) { this.project = project; this.bindingTrace = bindingTrace; + this.javaClassFinder = new JavaClassFinderImpl(); this.javaDescriptorResolver = new JavaDescriptorResolver(); this.psiClassFinder = new PsiClassFinderImpl(); this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class); @@ -82,6 +85,8 @@ public class InjectorForJavaDescriptorResolver { this.javaConstructorResolver = new JavaConstructorResolver(); this.javaPropertyResolver = new JavaPropertyResolver(); + javaClassFinder.setPsiClassFinder(psiClassFinder); + this.javaDescriptorResolver.setClassResolver(javaClassResolver); this.javaDescriptorResolver.setConstructorResolver(javaConstructorResolver); this.javaDescriptorResolver.setFunctionResolver(javaFunctionResolver); @@ -92,10 +97,10 @@ public class InjectorForJavaDescriptorResolver { javaClassResolver.setAnnotationResolver(javaAnnotationResolver); javaClassResolver.setFunctionResolver(javaFunctionResolver); + javaClassResolver.setJavaClassFinder(javaClassFinder); javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver); javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver); javaClassResolver.setNamespaceResolver(javaNamespaceResolver); - javaClassResolver.setPsiClassFinder(psiClassFinder); javaClassResolver.setSignatureResolver(javaSignatureResolver); javaClassResolver.setSupertypesResolver(javaSupertypeResolver); javaClassResolver.setTrace(bindingTrace); @@ -128,8 +133,8 @@ public class InjectorForJavaDescriptorResolver { annotationDescriptorDeserializer.setVirtualFileFinder(virtualFileFinder); javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver); + javaNamespaceResolver.setJavaClassFinder(javaClassFinder); javaNamespaceResolver.setJavaDescriptorResolver(javaDescriptorResolver); - javaNamespaceResolver.setPsiClassFinder(psiClassFinder); javaNamespaceResolver.setTrace(bindingTrace); javaNamespaceResolver.setVirtualFileFinder(virtualFileFinder); 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 545dcc503af..cba8e3cc7cf 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl; +import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl; import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder; import org.jetbrains.jet.lang.resolve.DeclarationResolver; @@ -81,6 +82,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final JavaBridgeConfiguration javaBridgeConfiguration; private final JavaDescriptorResolver javaDescriptorResolver; private final PsiClassFinderImpl psiClassFinder; + private final JavaClassFinderImpl javaClassFinder; private final NamespaceFactoryImpl namespaceFactory; private final VirtualFileFinder virtualFileFinder; private final DeclarationResolver declarationResolver; @@ -133,6 +135,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.javaBridgeConfiguration = new JavaBridgeConfiguration(); this.javaDescriptorResolver = new JavaDescriptorResolver(); this.psiClassFinder = new PsiClassFinderImpl(); + this.javaClassFinder = new JavaClassFinderImpl(); this.namespaceFactory = new NamespaceFactoryImpl(); this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class); this.declarationResolver = new DeclarationResolver(); @@ -208,6 +211,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly psiClassFinder.setProject(project); + javaClassFinder.setPsiClassFinder(psiClassFinder); + this.namespaceFactory.setModuleDescriptor(moduleDescriptor); this.namespaceFactory.setTrace(bindingTrace); @@ -279,10 +284,10 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaClassResolver.setAnnotationResolver(javaAnnotationResolver); javaClassResolver.setFunctionResolver(javaFunctionResolver); + javaClassResolver.setJavaClassFinder(javaClassFinder); javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver); javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver); javaClassResolver.setNamespaceResolver(javaNamespaceResolver); - javaClassResolver.setPsiClassFinder(psiClassFinder); javaClassResolver.setSignatureResolver(javaSignatureResolver); javaClassResolver.setSupertypesResolver(javaSupertypeResolver); javaClassResolver.setTrace(bindingTrace); @@ -315,8 +320,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly annotationDescriptorDeserializer.setVirtualFileFinder(virtualFileFinder); javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver); + javaNamespaceResolver.setJavaClassFinder(javaClassFinder); javaNamespaceResolver.setJavaDescriptorResolver(javaDescriptorResolver); - javaNamespaceResolver.setPsiClassFinder(psiClassFinder); javaNamespaceResolver.setTrace(bindingTrace); javaNamespaceResolver.setVirtualFileFinder(virtualFileFinder); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java index b87831b7958..d7da4fb4381 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java @@ -23,6 +23,7 @@ import com.intellij.psi.util.PsiFormatUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; @@ -38,33 +39,29 @@ public final class DescriptorResolverUtils { private DescriptorResolverUtils() { } - public static boolean isCompiledKotlinPackageClass(@NotNull PsiClass psiClass) { - if (psiClass instanceof ClsClassImpl) { - String qualifiedName = psiClass.getQualifiedName(); - if (qualifiedName != null && PackageClassUtils.isPackageClassFqName(new FqName(qualifiedName))) { - return hasAnnotation(psiClass, JvmAnnotationNames.KOTLIN_PACKAGE.getFqName()); + public static boolean isCompiledKotlinPackageClass(@NotNull JavaClass javaClass) { + if (javaClass.getPsiClass() instanceof ClsClassImpl) { + String fqName = javaClass.getFqName(); + if (fqName != null && PackageClassUtils.isPackageClassFqName(new FqName(fqName))) { + return hasAnnotation(javaClass, JvmAnnotationNames.KOTLIN_PACKAGE.getFqName()); } } return false; } - public static boolean isCompiledKotlinClass(@NotNull PsiClass psiClass) { - if (psiClass instanceof ClsClassImpl) { - return hasAnnotation(psiClass, JvmAnnotationNames.KOTLIN_CLASS.getFqName()); + public static boolean isCompiledKotlinClass(@NotNull JavaClass javaClass) { + if (javaClass.getPsiClass() instanceof ClsClassImpl) { + return hasAnnotation(javaClass, JvmAnnotationNames.KOTLIN_CLASS.getFqName()); } return false; } - public static boolean hasAnnotation(@NotNull PsiClass psiClass, @NotNull FqName annotationFqName) { - PsiModifierList list = psiClass.getModifierList(); - if (list != null) { - return list.findAnnotation(annotationFqName.asString()) != null; - } - return false; + public static boolean hasAnnotation(@NotNull JavaClass javaClass, @NotNull FqName annotationFqName) { + return javaClass.findAnnotation(annotationFqName.asString()) != null; } - public static boolean isCompiledKotlinClassOrPackageClass(@NotNull PsiClass psiClass) { - return isCompiledKotlinClass(psiClass) || isCompiledKotlinPackageClass(psiClass); + public static boolean isCompiledKotlinClassOrPackageClass(@NotNull JavaClass javaClass) { + return isCompiledKotlinClass(javaClass) || isCompiledKotlinPackageClass(javaClass); } @NotNull @@ -155,15 +152,14 @@ public final class DescriptorResolverUtils { } @NotNull - public static Collection filterDuplicateClasses(@NotNull PsiClass[] classes) { - Set addedQualifiedNames = new HashSet(classes.length); - List result = new ArrayList(classes.length); + public static Collection filterDuplicateClasses(@NotNull Collection classes) { + Set addedQualifiedNames = new HashSet(classes.size()); + List result = new ArrayList(classes.size()); - for (PsiClass psiClass : classes) { - String qualifiedName = psiClass.getQualifiedName(); - - if (qualifiedName != null && addedQualifiedNames.add(qualifiedName)) { - result.add(psiClass); + for (JavaClass javaClass : classes) { + String fqName = javaClass.getFqName(); + if (fqName != null && addedQualifiedNames.add(fqName)) { + result.add(javaClass); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinder.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinder.java new file mode 100644 index 00000000000..a41707dab3f --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinder.java @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2013 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 org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; +import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage; +import org.jetbrains.jet.lang.resolve.name.FqName; + +public interface JavaClassFinder { + // TODO: scope + @Nullable + JavaClass findClass(@NotNull FqName fqName); + + @Nullable + JavaPackage findPackage(@NotNull FqName fqName); +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderImpl.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderImpl.java new file mode 100644 index 00000000000..9a5b7076c9a --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassFinderImpl.java @@ -0,0 +1,50 @@ +/* + * Copyright 2010-2013 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.java.structure.JavaClass; +import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage; +import org.jetbrains.jet.lang.resolve.name.FqName; + +import javax.inject.Inject; + +public class JavaClassFinderImpl implements JavaClassFinder { + private PsiClassFinder psiClassFinder; + + @Inject + public void setPsiClassFinder(@NotNull PsiClassFinder psiClassFinder) { + this.psiClassFinder = psiClassFinder; + } + + @Nullable + @Override + public JavaClass findClass(@NotNull FqName fqName) { + PsiClass psiClass = psiClassFinder.findPsiClass(fqName); + return psiClass == null ? null : new JavaClass(psiClass); + } + + @Nullable + @Override + public JavaPackage findPackage(@NotNull FqName fqName) { + PsiPackage psiPackage = psiClassFinder.findPsiPackage(fqName); + return psiPackage == null ? null : new JavaPackage(psiPackage); + } +} 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 e91ead2b64f..d3e42412aaa 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 @@ -16,12 +16,12 @@ package org.jetbrains.jet.lang.resolve.java; -import com.intellij.psi.PsiClass; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers; import org.jetbrains.jet.lang.resolve.java.resolver.*; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -81,8 +81,8 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes } @NotNull - public Collection resolveConstructors(@NotNull PsiClass psiClass, @NotNull ClassDescriptor classDescriptor) { - return constructorResolver.resolveConstructors(psiClass, classDescriptor); + public Collection resolveConstructors(@NotNull JavaClass javaClass, @NotNull ClassDescriptor classDescriptor) { + return constructorResolver.resolveConstructors(javaClass, classDescriptor); } @Nullable diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java index 00e181d2885..d1cbeadb38c 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/provider/MembersCache.java @@ -18,12 +18,17 @@ package org.jetbrains.jet.lang.resolve.java.provider; import com.google.common.collect.HashMultimap; import com.google.common.collect.Multimap; -import com.intellij.psi.*; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiField; +import com.intellij.psi.PsiMember; +import com.intellij.psi.PsiMethod; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker; import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; +import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiFieldWrapper; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMemberWrapper; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; @@ -89,19 +94,19 @@ public final class MembersCache { @NotNull public static MembersCache buildMembersByNameCache( - @Nullable PsiClass psiClass, - @Nullable PsiPackage psiPackage, + @Nullable JavaClass javaClass, + @Nullable JavaPackage javaPackage, boolean staticMembers ) { MembersCache membersCache = new MembersCache(); - if (psiClass != null) { - membersCache.new ClassMemberProcessor(psiClass, staticMembers).process(); - Collection innerClasses = DescriptorResolverUtils.filterDuplicateClasses(psiClass.getInnerClasses()); + if (javaClass != null) { + membersCache.new ClassMemberProcessor(javaClass, staticMembers).process(); + Collection innerClasses = javaClass.getInnerClasses(); membersCache.new ExtraPackageMembersProcessor(innerClasses).process(); } - else if (psiPackage != null) { - Collection classes = DescriptorResolverUtils.filterDuplicateClasses(psiPackage.getClasses()); + else if (javaPackage != null) { + Collection classes = DescriptorResolverUtils.filterDuplicateClasses(javaPackage.getClasses()); membersCache.new ExtraPackageMembersProcessor(classes).process(); } @@ -110,14 +115,16 @@ public final class MembersCache { private class ExtraPackageMembersProcessor { // 'extra' means that PSI elements for these members are not just top-level classes @NotNull - private final Collection psiClasses; + private final Collection javaClasses; - private ExtraPackageMembersProcessor(@NotNull Collection psiClasses) { - this.psiClasses = psiClasses; + private ExtraPackageMembersProcessor(@NotNull Collection javaClasses) { + this.javaClasses = javaClasses; } private void process() { - for (PsiClass psiClass : psiClasses) { + for (JavaClass javaClass : javaClasses) { + PsiClass psiClass = javaClass.getPsiClass(); + if (!(psiClass instanceof JetJavaMirrorMarker)) { // to filter out JetLightClasses if (SingleAbstractMethodUtils.isSamInterface(psiClass)) { processSamInterface(psiClass); @@ -137,8 +144,8 @@ public final class MembersCache { private final PsiClass psiClass; private final boolean staticMembers; - private ClassMemberProcessor(@NotNull PsiClass psiClass, boolean staticMembers) { - this.psiClass = psiClass; + private ClassMemberProcessor(@NotNull JavaClass javaClass, boolean staticMembers) { + this.psiClass = javaClass.getPsiClass(); this.staticMembers = staticMembers; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java index 2453f10138e..4c8715d9506 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java @@ -22,7 +22,6 @@ import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.psi.PsiAnnotation; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiModifier; @@ -39,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode; import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils; import org.jetbrains.jet.lang.resolve.java.scope.JavaClassNonStaticMembersScope; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -91,7 +91,7 @@ public final class JavaClassResolver { private JavaSignatureResolver signatureResolver; private JavaDescriptorResolver javaDescriptorResolver; private JavaAnnotationResolver annotationResolver; - private PsiClassFinder psiClassFinder; + private JavaClassFinder javaClassFinder; private JavaNamespaceResolver namespaceResolver; private JavaSupertypeResolver supertypesResolver; private JavaFunctionResolver functionResolver; @@ -132,8 +132,8 @@ public final class JavaClassResolver { } @Inject - public void setPsiClassFinder(PsiClassFinder psiClassFinder) { - this.psiClassFinder = psiClassFinder; + public void setJavaClassFinder(JavaClassFinder javaClassFinder) { + this.javaClassFinder = javaClassFinder; } @Inject @@ -237,17 +237,14 @@ public final class JavaClassResolver { } } - PsiClass psiClass = psiClassFinder.findPsiClass(qualifiedName); - if (psiClass == null) { + JavaClass javaClass = javaClassFinder.findClass(qualifiedName); + if (javaClass == null) { cacheNegativeValue(javaClassToKotlinFqName(qualifiedName)); return null; } if (KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(qualifiedName.parent())) { - PsiAnnotation assertInvisibleAnnotation = JavaAnnotationResolver.findOwnAnnotation( - psiClass, JvmAnnotationNames.ASSERT_INVISIBLE_IN_RESOLVER.getFqName().asString()); - - if (assertInvisibleAnnotation != null) { + if (javaClass.findAnnotation(JvmAnnotationNames.ASSERT_INVISIBLE_IN_RESOLVER.getFqName().asString()) != null) { if (ApplicationManager.getApplication().isInternal()) { LOG.error("classpath is configured incorrectly:" + " class " + qualifiedName + " from runtime must not be loaded by compiler"); @@ -257,10 +254,12 @@ public final class JavaClassResolver { } // Class may have been resolved previously by different Java resolver instance, and we are reusing its trace - ClassDescriptor alreadyResolved = trace.get(BindingContext.CLASS, psiClass); + ClassDescriptor alreadyResolved = trace.get(BindingContext.CLASS, javaClass.getPsiClass()); if (alreadyResolved != null) { return alreadyResolved; } + + PsiClass psiClass = javaClass.getPsiClass(); //TODO: code duplication ClassOrNamespaceDescriptor containingDeclaration = resolveParentDescriptor(qualifiedName, isContainedInClass(psiClass)); // class may be resolved during resolution of parent @@ -275,7 +274,7 @@ public final class JavaClassResolver { checkPsiClassIsNotJet(psiClass); - return doCreateClassDescriptor(qualifiedName, psiClass, tasks, containingDeclaration); + return doCreateClassDescriptor(qualifiedName, javaClass, tasks, containingDeclaration); } private void cacheNegativeValue(@NotNull FqNameBase qualifiedName) { @@ -293,10 +292,12 @@ public final class JavaClassResolver { @NotNull private ClassDescriptorFromJvmBytecode doCreateClassDescriptor( @NotNull FqName fqName, - @NotNull PsiClass psiClass, + @NotNull JavaClass javaClass, @NotNull PostponedTasks taskList, @NotNull ClassOrNamespaceDescriptor containingDeclaration ) { + PsiClass psiClass = javaClass.getPsiClass(); + ClassDescriptorFromJvmBytecode classDescriptor = new ClassDescriptorFromJvmBytecode(containingDeclaration, getClassKind(psiClass), isInnerClass(psiClass)); @@ -314,7 +315,7 @@ public final class JavaClassResolver { classDescriptor.setModality(resolveModality(psiClass, classDescriptor)); classDescriptor.createTypeConstructor(); - JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classDescriptor, psiClass, false, javaDescriptorResolver); + JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classDescriptor, javaClass, false, javaDescriptorResolver); classDescriptor.setScopeForMemberLookup(scope); classDescriptor.setScopeForConstructorResolve(scope); @@ -326,7 +327,7 @@ public final class JavaClassResolver { supertypes.addAll(supertypesResolver.getSupertypes(classDescriptor, psiClass, classTypeParameters)); if (psiClass.isEnum()) { - ClassDescriptorFromJvmBytecode classObjectDescriptor = createClassObjectDescriptorForEnum(classDescriptor, psiClass); + ClassDescriptorFromJvmBytecode classObjectDescriptor = createClassObjectDescriptorForEnum(classDescriptor, javaClass); cache(getFqNameForClassObject(psiClass), classObjectDescriptor); classDescriptor.getBuilder().setClassObjectDescriptor(classObjectDescriptor); } @@ -497,11 +498,8 @@ public final class JavaClassResolver { } @NotNull - private ClassDescriptorFromJvmBytecode createClassObjectDescriptorForEnum( - @NotNull ClassDescriptor containing, - @NotNull PsiClass psiClass - ) { - ClassDescriptorFromJvmBytecode classObjectDescriptor = createSyntheticClassObject(containing, psiClass); + private ClassDescriptorFromJvmBytecode createClassObjectDescriptorForEnum(@NotNull ClassDescriptor containing, @NotNull JavaClass javaClass) { + ClassDescriptorFromJvmBytecode classObjectDescriptor = createSyntheticClassObject(containing, javaClass); classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValuesMethod(classObjectDescriptor, trace)); classObjectDescriptor.getBuilder().addFunctionDescriptor(createEnumClassObjectValueOfMethod(classObjectDescriptor, trace)); @@ -510,7 +508,7 @@ public final class JavaClassResolver { } @NotNull - private ClassDescriptorFromJvmBytecode createSyntheticClassObject(@NotNull ClassDescriptor containing, @NotNull PsiClass psiClass) { + private ClassDescriptorFromJvmBytecode createSyntheticClassObject(@NotNull ClassDescriptor containing, @NotNull JavaClass javaClass) { ClassDescriptorFromJvmBytecode classObjectDescriptor = new ClassDescriptorFromJvmBytecode(containing, ClassKind.CLASS_OBJECT, false); @@ -520,7 +518,7 @@ public final class JavaClassResolver { classObjectDescriptor.setTypeParameterDescriptors(Collections.emptyList()); classObjectDescriptor.createTypeConstructor(); - JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classObjectDescriptor, psiClass, true, + JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classObjectDescriptor, javaClass, true, javaDescriptorResolver); WritableScopeImpl writableScope = new WritableScopeImpl(scope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, "Member lookup scope"); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java index 451b7570dd9..7f5be926aea 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java @@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; @@ -67,7 +68,9 @@ public final class JavaConstructorResolver { } @NotNull - public Collection resolveConstructors(@NotNull PsiClass psiClass, @NotNull ClassDescriptor containingClass) { + public Collection resolveConstructors(@NotNull JavaClass javaClass, @NotNull ClassDescriptor containingClass) { + PsiClass psiClass = javaClass.getPsiClass(); + Collection constructors = Lists.newArrayList(); List typeParameters = containingClass.getTypeConstructor().getParameters(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java index d4b8afb0bd7..f29a9ee7726 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java @@ -22,7 +22,6 @@ import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiMember; import com.intellij.psi.PsiModifier; -import com.intellij.psi.PsiPackage; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -40,6 +39,8 @@ import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils; import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope; import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; +import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage; import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -61,7 +62,7 @@ public final class JavaNamespaceResolver { @NotNull private final Set unresolvedCache = Sets.newHashSet(); - private PsiClassFinder psiClassFinder; + private JavaClassFinder javaClassFinder; private BindingTrace trace; private JavaDescriptorResolver javaDescriptorResolver; @@ -77,8 +78,8 @@ public final class JavaNamespaceResolver { } @Inject - public void setPsiClassFinder(PsiClassFinder psiClassFinder) { - this.psiClassFinder = psiClassFinder; + public void setJavaClassFinder(JavaClassFinder javaClassFinder) { + this.javaClassFinder = javaClassFinder; } @Inject @@ -156,8 +157,8 @@ public final class JavaNamespaceResolver { @NotNull NamespaceDescriptor namespaceDescriptor, boolean record ) { - PsiPackage psiPackage = psiClassFinder.findPsiPackage(fqName); - if (psiPackage != null) { + JavaPackage javaPackage = javaClassFinder.findPackage(fqName); + if (javaPackage != null) { FqName packageClassFqName = PackageClassUtils.getPackageClassFqName(fqName); VirtualFile virtualFile = virtualFileFinder.find(packageClassFqName); @@ -175,19 +176,21 @@ public final class JavaNamespaceResolver { // Otherwise (if psiClass is null or doesn't have a supported Kotlin annotation), it's a Java class and the package is empty if (record) { - trace.record(BindingContext.NAMESPACE, psiPackage, namespaceDescriptor); + trace.record(BindingContext.NAMESPACE, javaPackage.getPsiPackage(), namespaceDescriptor); } - return new JavaPackageScope(namespaceDescriptor, psiPackage, fqName, javaDescriptorResolver); + return new JavaPackageScope(namespaceDescriptor, javaPackage, fqName, javaDescriptorResolver); } - PsiClass psiClass = psiClassFinder.findPsiClass(fqName); - if (psiClass == null) { + JavaClass javaClass = javaClassFinder.findClass(fqName); + if (javaClass == null) { return null; } - if (DescriptorResolverUtils.isCompiledKotlinClassOrPackageClass(psiClass)) { + + if (DescriptorResolverUtils.isCompiledKotlinClassOrPackageClass(javaClass)) { return null; } + PsiClass psiClass = javaClass.getPsiClass(); if (!hasStaticMembers(psiClass)) { return null; } @@ -198,7 +201,7 @@ public final class JavaNamespaceResolver { trace.record(BindingContext.NAMESPACE, psiClass, namespaceDescriptor); } - return new JavaClassStaticMembersScope(namespaceDescriptor, fqName, psiClass, javaDescriptorResolver); + return new JavaClassStaticMembersScope(namespaceDescriptor, fqName, javaClass, javaDescriptorResolver); } private void cache(@NotNull FqName fqName, @Nullable JetScope packageScope) { @@ -248,14 +251,14 @@ public final class JavaNamespaceResolver { @NotNull public Collection getClassNamesInPackage(@NotNull FqName packageName) { - PsiPackage psiPackage = psiClassFinder.findPsiPackage(packageName); - if (psiPackage == null) return Collections.emptyList(); + JavaPackage javaPackage = javaClassFinder.findPackage(packageName); + if (javaPackage == null) return Collections.emptyList(); - PsiClass[] classes = psiPackage.getClasses(); - List result = new ArrayList(classes.length); - for (PsiClass psiClass : classes) { - if (DescriptorResolverUtils.isCompiledKotlinClass(psiClass)) { - result.add(Name.identifier(psiClass.getName())); + Collection classes = DescriptorResolverUtils.filterDuplicateClasses(javaPackage.getClasses()); + List result = new ArrayList(classes.size()); + for (JavaClass javaClass : classes) { + if (DescriptorResolverUtils.isCompiledKotlinClass(javaClass)) { + result.add(Name.identifier(javaClass.getName())); } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java index 679ef8541be..051b2850ab3 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassNonStaticMembersScope.java @@ -16,12 +16,12 @@ package org.jetbrains.jet.lang.resolve.java.scope; -import com.intellij.psi.PsiClass; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.name.FqName; import java.util.ArrayList; @@ -37,18 +37,18 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope @NotNull private final ClassDescriptor descriptor; @NotNull - private final PsiClass psiClass; + private final JavaClass javaClass; private final boolean staticMembersOfPsiClass; public JavaClassNonStaticMembersScope( @NotNull ClassDescriptor descriptor, - @NotNull PsiClass psiClass, + @NotNull JavaClass javaClass, boolean staticMembersOfPsiClass, @NotNull JavaDescriptorResolver javaDescriptorResolver ) { - super(descriptor, MembersProvider.forClass(psiClass, staticMembersOfPsiClass), javaDescriptorResolver); + super(descriptor, MembersProvider.forClass(javaClass, staticMembersOfPsiClass), javaDescriptorResolver); this.descriptor = descriptor; - this.psiClass = psiClass; + this.javaClass = javaClass; this.staticMembersOfPsiClass = staticMembersOfPsiClass; } @@ -67,7 +67,7 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope private void initConstructorsIfNeeded() { if (constructors == null) { - constructors = javaDescriptorResolver.resolveConstructors(psiClass, descriptor); + constructors = javaDescriptorResolver.resolveConstructors(javaClass, descriptor); for (ConstructorDescriptor constructor : constructors) { if (constructor.isPrimary()) { @@ -88,18 +88,18 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope return Collections.emptyList(); } - PsiClass[] innerPsiClasses = psiClass.getInnerClasses(); - List result = new ArrayList(innerPsiClasses.length); - for (PsiClass innerPsiClass : innerPsiClasses) { - result.add(resolveInnerClass(innerPsiClass)); + Collection innerClasses = javaClass.getInnerClasses(); + List result = new ArrayList(innerClasses.size()); + for (JavaClass innerClass : innerClasses) { + result.add(resolveInnerClass(innerClass)); } return result; } @NotNull - private ClassDescriptor resolveInnerClass(@NotNull PsiClass innerPsiClass) { - String name = innerPsiClass.getQualifiedName(); - assert name != null : "Inner class has no qualified name: " + innerPsiClass; + private ClassDescriptor resolveInnerClass(@NotNull JavaClass innerClass) { + String name = innerClass.getFqName(); + assert name != null : "Inner class has no qualified name: " + innerClass; ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(new FqName(name), IGNORE_KOTLIN_SOURCES); assert classDescriptor != null : "Couldn't resolve inner class " + name; return classDescriptor; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java index f5d6d5ebc4c..20fae02dc16 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java @@ -16,13 +16,13 @@ package org.jetbrains.jet.lang.resolve.java.scope; -import com.intellij.psi.PsiClass; import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -35,17 +35,17 @@ public final class JavaClassStaticMembersScope extends JavaClassMembersScope { @NotNull private final FqName packageFQN; @NotNull - private final PsiClass psiClass; + private final JavaClass javaClass; public JavaClassStaticMembersScope( @NotNull NamespaceDescriptor descriptor, @NotNull FqName packageFQN, - @NotNull PsiClass psiClass, + @NotNull JavaClass javaClass, @NotNull JavaDescriptorResolver javaDescriptorResolver ) { - super(descriptor, MembersProvider.forClass(psiClass, true), javaDescriptorResolver); + super(descriptor, MembersProvider.forClass(javaClass, true), javaDescriptorResolver); this.packageFQN = packageFQN; - this.psiClass = psiClass; + this.javaClass = javaClass; } @Override @@ -57,7 +57,7 @@ public final class JavaClassStaticMembersScope extends JavaClassMembersScope { @Override protected Collection computeAllDescriptors() { Collection result = super.computeAllDescriptors(); - for (PsiClass nested : psiClass.getInnerClasses()) { + for (JavaClass nested : javaClass.getInnerClasses()) { ContainerUtil.addIfNotNull(result, getNamespace(Name.identifier(nested.getName()))); } return result; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java index 11a899acff5..5d2cb24a9bc 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java @@ -18,15 +18,15 @@ package org.jetbrains.jet.lang.resolve.java.scope; import com.google.common.collect.Sets; import com.intellij.openapi.progress.ProgressIndicatorProvider; -import com.intellij.psi.PsiClass; import com.intellij.psi.PsiModifier; -import com.intellij.psi.PsiPackage; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker; import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; +import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -39,18 +39,18 @@ import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_K public final class JavaPackageScope extends JavaBaseScope { @NotNull - private final PsiPackage psiPackage; + private final JavaPackage javaPackage; @NotNull private final FqName packageFQN; public JavaPackageScope( @NotNull NamespaceDescriptor descriptor, - @NotNull PsiPackage psiPackage, + @NotNull JavaPackage javaPackage, @NotNull FqName packageFQN, @NotNull JavaDescriptorResolver javaDescriptorResolver ) { - super(descriptor, javaDescriptorResolver, MembersProvider.forPackage(psiPackage)); - this.psiPackage = psiPackage; + super(descriptor, javaDescriptorResolver, MembersProvider.forPackage(javaPackage)); + this.javaPackage = javaPackage; this.packageFQN = packageFQN; } @@ -89,24 +89,24 @@ public final class JavaPackageScope extends JavaBaseScope { private Collection computeAllPackageDeclarations() { Collection result = Sets.newHashSet(); - for (PsiPackage psiSubPackage : psiPackage.getSubPackages()) { - FqName fqName = new FqName(psiSubPackage.getQualifiedName()); + for (JavaPackage subPackage : javaPackage.getSubPackages()) { + FqName fqName = new FqName(subPackage.getFqName()); NamespaceDescriptor childNs = javaDescriptorResolver.resolveNamespace(fqName, IGNORE_KOTLIN_SOURCES); if (childNs != null) { result.add(childNs); } } - for (PsiClass psiClass : DescriptorResolverUtils.filterDuplicateClasses(psiPackage.getClasses())) { - if (DescriptorResolverUtils.isCompiledKotlinPackageClass(psiClass)) continue; + for (JavaClass javaClass : DescriptorResolverUtils.filterDuplicateClasses(javaPackage.getClasses())) { + if (DescriptorResolverUtils.isCompiledKotlinPackageClass(javaClass)) continue; - if (psiClass instanceof JetJavaMirrorMarker) continue; + if (isKotlinLightClass(javaClass)) continue; - if (!psiClass.hasModifierProperty(PsiModifier.PUBLIC)) continue; + if (!javaClass.getPsiClass().hasModifierProperty(PsiModifier.PUBLIC)) continue; ProgressIndicatorProvider.checkCanceled(); - String qualifiedName = psiClass.getQualifiedName(); + String qualifiedName = javaClass.getFqName(); if (qualifiedName == null) continue; FqName fqName = new FqName(qualifiedName); @@ -124,6 +124,10 @@ public final class JavaPackageScope extends JavaBaseScope { return result; } + private static boolean isKotlinLightClass(@NotNull JavaClass javaClass) { + return javaClass.getPsiClass() instanceof JetJavaMirrorMarker; + } + @Override @NotNull protected Set computeFunctionDescriptor(@NotNull Name name) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/MembersProvider.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/MembersProvider.java index 16d063e0467..ef291961796 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/MembersProvider.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/MembersProvider.java @@ -16,37 +16,37 @@ package org.jetbrains.jet.lang.resolve.java.scope; -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.java.provider.MembersCache; import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; +import org.jetbrains.jet.lang.resolve.java.structure.JavaPackage; import org.jetbrains.jet.lang.resolve.name.Name; import java.util.Collection; /* package */ class MembersProvider { @Nullable - private final PsiClass psiClass; + private final JavaClass javaClass; @Nullable - private final PsiPackage psiPackage; + private final JavaPackage javaPackage; private final boolean staticMembers; - private MembersProvider(@Nullable PsiClass psiClass, @Nullable PsiPackage psiPackage, boolean staticMembers) { - this.psiClass = psiClass; - this.psiPackage = psiPackage; + private MembersProvider(@Nullable JavaClass javaClass, @Nullable JavaPackage javaPackage, boolean staticMembers) { + this.javaClass = javaClass; + this.javaPackage = javaPackage; this.staticMembers = staticMembers; } @NotNull - public static MembersProvider forPackage(@NotNull PsiPackage psiPackage) { - return new MembersProvider(null, psiPackage, true); + public static MembersProvider forPackage(@NotNull JavaPackage javaPackage) { + return new MembersProvider(null, javaPackage, true); } @NotNull - public static MembersProvider forClass(@NotNull PsiClass psiClass, boolean staticMembers) { - return new MembersProvider(psiClass, null, staticMembers); + public static MembersProvider forClass(@NotNull JavaClass javaClass, boolean staticMembers) { + return new MembersProvider(javaClass, null, staticMembers); } @Nullable @@ -63,7 +63,7 @@ import java.util.Collection; @NotNull private MembersCache getMembersCache() { if (membersCache == null) { - membersCache = MembersCache.buildMembersByNameCache(psiClass, psiPackage, staticMembers); + membersCache = MembersCache.buildMembersByNameCache(javaClass, javaPackage, staticMembers); } return membersCache; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaAnnotation.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaAnnotation.java new file mode 100644 index 00000000000..ed9dbd9cafa --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaAnnotation.java @@ -0,0 +1,28 @@ +/* + * Copyright 2010-2013 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.structure; + +import com.intellij.psi.PsiAnnotation; +import org.jetbrains.annotations.NotNull; + +public class JavaAnnotation { + private final PsiAnnotation psiAnnotation; + + public JavaAnnotation(@NotNull PsiAnnotation psiAnnotation) { + this.psiAnnotation = psiAnnotation; + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java new file mode 100644 index 00000000000..925bf31b41d --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaClass.java @@ -0,0 +1,76 @@ +/* + * Copyright 2010-2013 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.structure; + +import com.intellij.psi.PsiAnnotation; +import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiModifierList; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +public class JavaClass { + private final PsiClass psiClass; + + public JavaClass(@NotNull PsiClass psiClass) { + this.psiClass = psiClass; + } + + @NotNull + public PsiClass getPsiClass() { + return psiClass; + } + + @NotNull + /* package */ static Collection javaClassesFromPsi(@NotNull PsiClass[] classes) { + List result = new ArrayList(classes.length); + for (PsiClass psiClass : classes) { + result.add(new JavaClass(psiClass)); + } + return result; + } + + @NotNull + public Collection getInnerClasses() { + return javaClassesFromPsi(psiClass.getInnerClasses()); + } + + @Nullable + public String getFqName() { + return psiClass.getQualifiedName(); + } + + @Nullable + public JavaAnnotation findAnnotation(@NotNull String fqName) { + PsiModifierList modifierList = psiClass.getModifierList(); + if (modifierList != null) { + PsiAnnotation annotation = modifierList.findAnnotation(fqName); + if (annotation != null) { + return new JavaAnnotation(annotation); + } + } + return null; + } + + @NotNull + public String getName() { + return psiClass.getName(); + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaPackage.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaPackage.java new file mode 100644 index 00000000000..51192e243a9 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/structure/JavaPackage.java @@ -0,0 +1,67 @@ +/* + * Copyright 2010-2013 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.structure; + +import com.intellij.psi.PsiPackage; +import org.jetbrains.annotations.NotNull; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; + +public class JavaPackage { + private final PsiPackage psiPackage; + + public JavaPackage(@NotNull PsiPackage psiPackage) { + this.psiPackage = psiPackage; + } + + @NotNull + public PsiPackage getPsiPackage() { + return psiPackage; + } + + @NotNull + private static Collection javaPackagesFromPsi(@NotNull PsiPackage[] packages) { + List result = new ArrayList(packages.length); + for (PsiPackage psiPackage : packages) { + result.add(new JavaPackage(psiPackage)); + } + return result; + } + + @NotNull + public Collection getClasses() { + return JavaClass.javaClassesFromPsi(psiPackage.getClasses()); + } + + @NotNull + public Collection getSubPackages() { + return javaPackagesFromPsi(psiPackage.getSubPackages()); + } + + @NotNull + public String getFqName() { + return psiPackage.getQualifiedName(); + } + + @NotNull + public String getName() { + String name = psiPackage.getName(); + return name == null ? "" : name; + } +} diff --git a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java b/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java index cf66bfc6538..9a799c62210 100644 --- a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java +++ b/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java @@ -34,6 +34,7 @@ import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.calls.CallResolver; import org.jetbrains.jet.lang.resolve.calls.NeedSyntheticCallResolverExtension; import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; +import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder; @@ -103,6 +104,7 @@ public class GenerateInjectors { generator.addPublicField(JavaBridgeConfiguration.class); generator.addField(JavaDescriptorResolver.class); generator.addField(PsiClassFinderImpl.class); + generator.addField(JavaClassFinderImpl.class); generator.addPublicField(NamespaceFactoryImpl.class); generator.addField(false, VirtualFileFinder.class, "virtualFileFinder", new GivenExpression( @@ -119,6 +121,7 @@ public class GenerateInjectors { generator.addParameter(BindingTrace.class); // Fields + generator.addField(JavaClassFinderImpl.class); generator.addPublicField(JavaDescriptorResolver.class); generator.addPublicField(PsiClassFinderImpl.class); generator.addField(false, VirtualFileFinder.class, "virtualFileFinder", diff --git a/idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java b/idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java index 59cb0c1e830..92b4831a0a3 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/JetFromJavaDescriptorHelper.java @@ -30,6 +30,7 @@ import org.jetbrains.jet.descriptors.serialization.*; import org.jetbrains.jet.lang.descriptors.ClassKind; import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; import org.jetbrains.jet.lang.resolve.java.resolver.KotlinClassFileHeader; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.util.QualifiedNamesUtil; @@ -138,7 +139,7 @@ public class JetFromJavaDescriptorHelper { FqName classFQN = new FqName(qualifiedName); - if (DescriptorResolverUtils.isCompiledKotlinPackageClass(containingClass)) { + if (DescriptorResolverUtils.isCompiledKotlinPackageClass(new JavaClass(containingClass))) { FqName classParentFQN = QualifiedNamesUtil.withoutLastSegment(classFQN); return QualifiedNamesUtil.combine(classParentFQN, Name.identifier(method.getName())); } diff --git a/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java b/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java index 5c051a6dd4f..d9b34800bed 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java +++ b/idea/src/org/jetbrains/jet/plugin/completion/DescriptorLookupConverter.java @@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -129,14 +130,14 @@ public final class DescriptorLookupConverter { private static LookupElement createJavaLookupElementIfPossible(@NotNull PsiElement declaration, @NotNull DeclarationDescriptor descriptor) { if (declaration instanceof PsiClass) { PsiClass psiClass = (PsiClass) declaration; - if (!DescriptorResolverUtils.isCompiledKotlinClassOrPackageClass(psiClass)) { + if (!DescriptorResolverUtils.isCompiledKotlinClassOrPackageClass(new JavaClass(psiClass))) { return setCustomInsertHandler(new JavaPsiClassReferenceElement(psiClass)); } } if (declaration instanceof PsiMember) { PsiClass containingClass = ((PsiMember) declaration).getContainingClass(); - if (containingClass != null && !DescriptorResolverUtils.isCompiledKotlinClassOrPackageClass(containingClass)) { + if (containingClass != null && !DescriptorResolverUtils.isCompiledKotlinClassOrPackageClass(new JavaClass(containingClass))) { if (declaration instanceof PsiMethod) { InsertHandler handler = getInsertHandler(descriptor); assert handler != null: "Special kotlin handler is expected for function: " + declaration.getText() + " and descriptor" + DescriptorRenderer.TEXT.render(descriptor); diff --git a/idea/src/org/jetbrains/jet/plugin/completion/JetTypesCompletionHelper.java b/idea/src/org/jetbrains/jet/plugin/completion/JetTypesCompletionHelper.java index c6e5867491d..f1f4ec69b31 100644 --- a/idea/src/org/jetbrains/jet/plugin/completion/JetTypesCompletionHelper.java +++ b/idea/src/org/jetbrains/jet/plugin/completion/JetTypesCompletionHelper.java @@ -27,6 +27,7 @@ import org.jetbrains.jet.asJava.KotlinLightClass; import org.jetbrains.jet.lang.descriptors.ClassKind; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -92,7 +93,7 @@ public class JetTypesCompletionHelper { return true; } - if (DescriptorResolverUtils.isCompiledKotlinClass(aClass)) { + if (DescriptorResolverUtils.isCompiledKotlinClass(new JavaClass(aClass))) { if (JetFromJavaDescriptorHelper.getCompiledClassKind(aClass) != ClassKind.CLASS_OBJECT) { String qualifiedName = aClass.getQualifiedName(); if (qualifiedName != null) { diff --git a/idea/src/org/jetbrains/jet/plugin/editor/importOptimizer/JetImportOptimizer.java b/idea/src/org/jetbrains/jet/plugin/editor/importOptimizer/JetImportOptimizer.java index 5976d749118..a0e06e63333 100644 --- a/idea/src/org/jetbrains/jet/plugin/editor/importOptimizer/JetImportOptimizer.java +++ b/idea/src/org/jetbrains/jet/plugin/editor/importOptimizer/JetImportOptimizer.java @@ -32,6 +32,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; +import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; @@ -283,7 +284,7 @@ public class JetImportOptimizer implements ImportOptimizer { if (memberName == null) { return null; } - if (DescriptorResolverUtils.isCompiledKotlinPackageClass(containingClass)) { + if (DescriptorResolverUtils.isCompiledKotlinPackageClass(new JavaClass(containingClass))) { return QualifiedNamesUtil.combine(classFQN.parent(), Name.identifier(memberName)); } else {