From d708dc6ed41f3a97d152b92ee6a838d25d95417e Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 24 Jul 2013 19:28:27 +0400 Subject: [PATCH] Delete JavaSemanticServices Almost in all places only JavaDescriptorResolver was needed. The only exception is JavaPackageScope which needs PsiClassFinder, that is now passed as a constructor argument. Also merge JavaPackageScopeWithoutMembers into its superclass JavaPackageScope --- .../di/InjectorForJavaDescriptorResolver.java | 10 +--- .../di/InjectorForTopDownAnalyzerForJvm.java | 12 ++--- .../resolve/java/JavaBridgeConfiguration.java | 14 +++-- .../resolve/java/JavaSemanticServices.java | 48 ----------------- .../java/resolver/JavaClassResolver.java | 20 ++++--- .../java/resolver/JavaNamespaceResolver.java | 17 +++--- .../resolve/java/scope/JavaBaseScope.java | 15 ++---- .../java/scope/JavaClassMembersScope.java | 10 ++-- .../scope/JavaClassNonStaticMembersScope.java | 8 +-- .../scope/JavaClassStaticMembersScope.java | 8 +-- .../resolve/java/scope/JavaPackageScope.java | 46 ++++++++++------ .../scope/JavaPackageScopeWithoutMembers.java | 54 ------------------- 12 files changed, 81 insertions(+), 181 deletions(-) delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java delete mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScopeWithoutMembers.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 d295642fa5b..2ff76873078 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -30,7 +30,6 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaSignatureResolver; import org.jetbrains.jet.lang.resolve.java.resolver.DeserializedDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.AnnotationDescriptorDeserializer; import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.lang.resolve.java.resolver.JavaSupertypeResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaInnerClassResolver; @@ -55,7 +54,6 @@ public class InjectorForJavaDescriptorResolver { private final DeserializedDescriptorResolver deserializedDescriptorResolver; private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; private final JavaNamespaceResolver javaNamespaceResolver; - private final JavaSemanticServices javaSemanticServices; private final JavaSupertypeResolver javaSupertypeResolver; private final JavaConstructorResolver javaConstructorResolver; private final JavaInnerClassResolver javaInnerClassResolver; @@ -79,7 +77,6 @@ public class InjectorForJavaDescriptorResolver { this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(); this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); this.javaNamespaceResolver = new JavaNamespaceResolver(); - this.javaSemanticServices = new JavaSemanticServices(); this.javaSupertypeResolver = new JavaSupertypeResolver(); this.javaConstructorResolver = new JavaConstructorResolver(); this.javaInnerClassResolver = new JavaInnerClassResolver(); @@ -96,10 +93,10 @@ public class InjectorForJavaDescriptorResolver { javaClassResolver.setAnnotationResolver(javaAnnotationResolver); javaClassResolver.setFunctionResolver(javaFunctionResolver); + javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver); javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver); javaClassResolver.setNamespaceResolver(javaNamespaceResolver); javaClassResolver.setPsiClassFinder(psiClassFinder); - javaClassResolver.setSemanticServices(javaSemanticServices); javaClassResolver.setSignatureResolver(javaSignatureResolver); javaClassResolver.setSupertypesResolver(javaSupertypeResolver); javaClassResolver.setTrace(bindingTrace); @@ -130,13 +127,10 @@ public class InjectorForJavaDescriptorResolver { annotationDescriptorDeserializer.setPsiClassFinder(psiClassFinder); javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver); - javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices); + javaNamespaceResolver.setJavaDescriptorResolver(javaDescriptorResolver); javaNamespaceResolver.setPsiClassFinder(psiClassFinder); javaNamespaceResolver.setTrace(bindingTrace); - javaSemanticServices.setDescriptorResolver(javaDescriptorResolver); - javaSemanticServices.setPsiClassFinder(psiClassFinder); - javaSupertypeResolver.setClassResolver(javaClassResolver); javaSupertypeResolver.setTrace(bindingTrace); javaSupertypeResolver.setTypeTransformer(javaTypeTransformer); 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 62db53e4504..4c09526153e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -47,7 +47,6 @@ import org.jetbrains.jet.lang.resolve.OverloadResolver; import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver; import org.jetbrains.jet.lang.resolve.ScriptBodyResolver; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaCompileTimeConstResolver; @@ -99,7 +98,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final OverrideResolver overrideResolver; private final TypeHierarchyResolver typeHierarchyResolver; private final ScriptBodyResolver scriptBodyResolver; - private final JavaSemanticServices javaSemanticServices; private final JavaClassResolver javaClassResolver; private final JavaAnnotationResolver javaAnnotationResolver; private final JavaCompileTimeConstResolver javaCompileTimeConstResolver; @@ -152,7 +150,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.overrideResolver = new OverrideResolver(); this.typeHierarchyResolver = new TypeHierarchyResolver(); this.scriptBodyResolver = new ScriptBodyResolver(); - this.javaSemanticServices = new JavaSemanticServices(); this.javaClassResolver = new JavaClassResolver(); this.javaAnnotationResolver = new JavaAnnotationResolver(); this.javaCompileTimeConstResolver = new JavaCompileTimeConstResolver(); @@ -201,7 +198,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); this.descriptorResolver.setTypeResolver(typeResolver); - this.javaBridgeConfiguration.setJavaSemanticServices(javaSemanticServices); + this.javaBridgeConfiguration.setJavaDescriptorResolver(javaDescriptorResolver); javaDescriptorResolver.setClassResolver(javaClassResolver); javaDescriptorResolver.setConstructorResolver(javaConstructorResolver); @@ -281,15 +278,12 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly scriptBodyResolver.setExpressionTypingServices(expressionTypingServices); scriptBodyResolver.setTrace(bindingTrace); - javaSemanticServices.setDescriptorResolver(javaDescriptorResolver); - javaSemanticServices.setPsiClassFinder(psiClassFinder); - javaClassResolver.setAnnotationResolver(javaAnnotationResolver); javaClassResolver.setFunctionResolver(javaFunctionResolver); + javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver); javaClassResolver.setKotlinDescriptorResolver(deserializedDescriptorResolver); javaClassResolver.setNamespaceResolver(javaNamespaceResolver); javaClassResolver.setPsiClassFinder(psiClassFinder); - javaClassResolver.setSemanticServices(javaSemanticServices); javaClassResolver.setSignatureResolver(javaSignatureResolver); javaClassResolver.setSupertypesResolver(javaSupertypeResolver); javaClassResolver.setTrace(bindingTrace); @@ -320,7 +314,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly annotationDescriptorDeserializer.setPsiClassFinder(psiClassFinder); javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver); - javaNamespaceResolver.setJavaSemanticServices(javaSemanticServices); + javaNamespaceResolver.setJavaDescriptorResolver(javaDescriptorResolver); javaNamespaceResolver.setPsiClassFinder(psiClassFinder); javaNamespaceResolver.setTrace(bindingTrace); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java index 657a7fbd9dc..54e901b32c0 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java @@ -37,16 +37,20 @@ public class JavaBridgeConfiguration implements ModuleConfiguration { .addAll(DefaultModuleConfiguration.DEFAULT_JET_IMPORTS) .build(); - private JavaSemanticServices javaSemanticServices; + private JavaDescriptorResolver javaDescriptorResolver; @Inject - public void setJavaSemanticServices(@NotNull JavaSemanticServices javaSemanticServices) { - this.javaSemanticServices = javaSemanticServices; + public void setJavaDescriptorResolver(@NotNull JavaDescriptorResolver javaDescriptorResolver) { + this.javaDescriptorResolver = javaDescriptorResolver; } @Override - public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) { - JetScope javaPackageScope = javaSemanticServices.getDescriptorResolver().getJavaPackageScope(namespaceDescriptor); + public void extendNamespaceScope( + @NotNull BindingTrace trace, + @NotNull NamespaceDescriptor namespaceDescriptor, + @NotNull WritableScope namespaceMemberScope + ) { + JetScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(namespaceDescriptor); if (javaPackageScope != null) { namespaceMemberScope.importScope(javaPackageScope); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java deleted file mode 100644 index 64ce348fa99..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaSemanticServices.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * 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 javax.inject.Inject; - -public class JavaSemanticServices { - @NotNull - private JavaDescriptorResolver descriptorResolver; - @NotNull - private PsiClassFinder psiClassFinder; - - @Inject - public void setDescriptorResolver(@NotNull JavaDescriptorResolver descriptorResolver) { - this.descriptorResolver = descriptorResolver; - } - - @Inject - public void setPsiClassFinder(@NotNull PsiClassFinder psiClassFinder) { - this.psiClassFinder = psiClassFinder; - } - - @NotNull - public JavaDescriptorResolver getDescriptorResolver() { - return descriptorResolver; - } - - @NotNull - public PsiClassFinder getPsiClassFinder() { - return psiClassFinder; - } -} 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 0dc1f4ffc21..677f26a4d67 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 @@ -87,7 +87,7 @@ public final class JavaClassResolver { private BindingTrace trace; private JavaSignatureResolver signatureResolver; - private JavaSemanticServices semanticServices; + private JavaDescriptorResolver javaDescriptorResolver; private JavaAnnotationResolver annotationResolver; private PsiClassFinder psiClassFinder; private JavaNamespaceResolver namespaceResolver; @@ -114,8 +114,8 @@ public final class JavaClassResolver { } @Inject - public void setSemanticServices(JavaSemanticServices semanticServices) { - this.semanticServices = semanticServices; + public void setJavaDescriptorResolver(JavaDescriptorResolver javaDescriptorResolver) { + this.javaDescriptorResolver = javaDescriptorResolver; } @Inject @@ -292,9 +292,9 @@ public final class JavaClassResolver { classDescriptor.setVisibility(DescriptorResolverUtils.resolveVisibility(psiClass)); classDescriptor.setModality(resolveModality(psiClass, classDescriptor)); classDescriptor.createTypeConstructor(); - JavaClassNonStaticMembersScope membersScope = new JavaClassNonStaticMembersScope(classDescriptor, classData, semanticServices); - classDescriptor.setScopeForMemberLookup(membersScope); - classDescriptor.setScopeForConstructorResolve(membersScope); + JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classDescriptor, classData, javaDescriptorResolver); + classDescriptor.setScopeForMemberLookup(scope); + classDescriptor.setScopeForConstructorResolve(scope); String context = "class " + psiClass.getQualifiedName(); signatureResolver.initializeTypeParameters(typeParameterDescriptorInitializations, classDescriptor, context); @@ -521,13 +521,11 @@ public final class JavaClassResolver { classObjectDescriptor.setVisibility(containing.getVisibility()); classObjectDescriptor.setTypeParameterDescriptors(Collections.emptyList()); classObjectDescriptor.createTypeConstructor(); - JavaClassNonStaticMembersScope classMembersScope = - new JavaClassNonStaticMembersScope(classObjectDescriptor, data, semanticServices); + JavaClassNonStaticMembersScope scope = new JavaClassNonStaticMembersScope(classObjectDescriptor, data, javaDescriptorResolver); WritableScopeImpl writableScope = - new WritableScopeImpl(classMembersScope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, - "Member lookup scope"); + new WritableScopeImpl(scope, classObjectDescriptor, RedeclarationHandler.THROW_EXCEPTION, "Member lookup scope"); writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); classObjectDescriptor.setScopeForMemberLookup(writableScope); - classObjectDescriptor.setScopeForConstructorResolve(classMembersScope); + classObjectDescriptor.setScopeForConstructorResolve(scope); } } 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 a59a64160d8..0b311800fed 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 @@ -36,10 +36,13 @@ import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor; -import org.jetbrains.jet.lang.resolve.java.provider.*; +import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProviderImpl; +import org.jetbrains.jet.lang.resolve.java.provider.MembersCache; +import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider; +import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProviderImpl; import org.jetbrains.jet.lang.resolve.java.scope.JavaBaseScope; import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope; -import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScopeWithoutMembers; +import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -62,7 +65,7 @@ public final class JavaNamespaceResolver { private PsiClassFinder psiClassFinder; private BindingTrace trace; - private JavaSemanticServices javaSemanticServices; + private JavaDescriptorResolver javaDescriptorResolver; private DeserializedDescriptorResolver deserializedDescriptorResolver; @@ -80,8 +83,8 @@ public final class JavaNamespaceResolver { } @Inject - public void setJavaSemanticServices(JavaSemanticServices javaSemanticServices) { - this.javaSemanticServices = javaSemanticServices; + public void setJavaDescriptorResolver(@NotNull JavaDescriptorResolver javaDescriptorResolver) { + this.javaDescriptorResolver = javaDescriptorResolver; } @Inject @@ -188,7 +191,7 @@ 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 PackagePsiDeclarationProvider provider = new PackagePsiDeclarationProviderImpl(psiPackage, psiClassFinder); - return new JavaPackageScopeWithoutMembers(namespaceDescriptor, provider, fqName, javaSemanticServices); + return new JavaPackageScope(namespaceDescriptor, provider, fqName, javaDescriptorResolver, psiClassFinder); } PsiClass psiClass = psiClassFinder.findPsiClass(fqName, PsiClassFinder.RuntimeClassesHandleMode.IGNORE); @@ -205,7 +208,7 @@ public final class JavaNamespaceResolver { return new JavaClassStaticMembersScope( namespaceDescriptor, new ClassPsiDeclarationProviderImpl(psiClass, true, psiClassFinder), - fqName, javaSemanticServices); + fqName, javaDescriptorResolver); } private static boolean isOldKotlinPackageClass(@NotNull PsiClass psiClass) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaBaseScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaBaseScope.java index 6f1edf2f678..53f08b600d7 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaBaseScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaBaseScope.java @@ -27,7 +27,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider; import org.jetbrains.jet.lang.resolve.java.provider.NamedMembers; import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider; @@ -38,9 +37,8 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl; import java.util.*; public abstract class JavaBaseScope extends JetScopeImpl { - @NotNull - protected final JavaSemanticServices semanticServices; + protected final JavaDescriptorResolver javaDescriptorResolver; @NotNull protected final PsiDeclarationProvider declarationProvider; @NotNull @@ -59,10 +57,10 @@ public abstract class JavaBaseScope extends JetScopeImpl { protected JavaBaseScope( @NotNull ClassOrNamespaceDescriptor descriptor, - @NotNull JavaSemanticServices semanticServices, + @NotNull JavaDescriptorResolver javaDescriptorResolver, @NotNull PsiDeclarationProvider declarationProvider ) { - this.semanticServices = semanticServices; + this.javaDescriptorResolver = javaDescriptorResolver; this.declarationProvider = declarationProvider; this.descriptor = descriptor; } @@ -90,7 +88,7 @@ public abstract class JavaBaseScope extends JetScopeImpl { @NotNull private Set computePropertyDescriptors(@NotNull Name name) { - return getResolver().resolveFieldGroupByName(name, declarationProvider, descriptor); + return javaDescriptorResolver.resolveFieldGroupByName(name, declarationProvider, descriptor); } @NotNull @@ -160,11 +158,6 @@ public abstract class JavaBaseScope extends JetScopeImpl { return result; } - @NotNull - protected JavaDescriptorResolver getResolver() { - return semanticServices.getDescriptorResolver(); - } - //TODO: remove this method @NotNull public PsiElement getPsiElement() { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java index e008de8e09b..c751da3ffce 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassMembersScope.java @@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.resolve.java.scope; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider; import org.jetbrains.jet.lang.resolve.name.LabelName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -37,9 +37,9 @@ public abstract class JavaClassMembersScope extends JavaBaseScope { protected JavaClassMembersScope( @NotNull ClassOrNamespaceDescriptor descriptor, @NotNull ClassPsiDeclarationProvider declarationProvider, - @NotNull JavaSemanticServices semanticServices + @NotNull JavaDescriptorResolver javaDescriptorResolver ) { - super(descriptor, semanticServices, declarationProvider); + super(descriptor, javaDescriptorResolver, declarationProvider); this.declarationProvider = declarationProvider; } @@ -53,7 +53,7 @@ public abstract class JavaClassMembersScope extends JavaBaseScope { @NotNull @Override protected Set computeFunctionDescriptor(@NotNull Name name) { - return getResolver().resolveFunctionGroup(name, declarationProvider, descriptor); + return javaDescriptorResolver.resolveFunctionGroup(name, declarationProvider, descriptor); } @NotNull @@ -71,7 +71,7 @@ public abstract class JavaClassMembersScope extends JavaBaseScope { @NotNull @Override protected Collection computeInnerClasses() { - return getResolver().resolveInnerClasses(declarationProvider); + return javaDescriptorResolver.resolveInnerClasses(declarationProvider); } @Override 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 84656e66f1f..22341118eb0 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 @@ -20,7 +20,7 @@ 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.JavaSemanticServices; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider; import java.util.Collection; @@ -35,9 +35,9 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope public JavaClassNonStaticMembersScope( @NotNull ClassDescriptor descriptor, @NotNull ClassPsiDeclarationProvider psiDeclarationProvider, - @NotNull JavaSemanticServices semanticServices + @NotNull JavaDescriptorResolver javaDescriptorResolver ) { - super(descriptor, psiDeclarationProvider, semanticServices); + super(descriptor, psiDeclarationProvider, javaDescriptorResolver); this.descriptor = descriptor; } @@ -56,7 +56,7 @@ public final class JavaClassNonStaticMembersScope extends JavaClassMembersScope private void initConstructorsIfNeeded() { if (constructors == null) { - constructors = getResolver().resolveConstructors(declarationProvider, descriptor); + constructors = javaDescriptorResolver.resolveConstructors(declarationProvider, descriptor); for (ConstructorDescriptor constructor : constructors) { if (constructor.isPrimary()) { 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 93618c33b32..7f38cbef0c1 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 @@ -22,7 +22,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.provider.ClassPsiDeclarationProvider; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -37,15 +37,15 @@ public final class JavaClassStaticMembersScope extends JavaClassMembersScope { @NotNull NamespaceDescriptor descriptor, @NotNull ClassPsiDeclarationProvider declarationProvider, @NotNull FqName packageFQN, - @NotNull JavaSemanticServices semanticServices + @NotNull JavaDescriptorResolver javaDescriptorResolver ) { - super(descriptor, declarationProvider, semanticServices); + super(descriptor, declarationProvider, javaDescriptorResolver); this.packageFQN = packageFQN; } @Override public NamespaceDescriptor getNamespace(@NotNull Name name) { - return getResolver().resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN); + return javaDescriptorResolver.resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN); } @NotNull 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 27137260c63..fd8af5dc2a5 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 @@ -22,35 +22,38 @@ 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.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import java.util.Collection; +import java.util.Collections; +import java.util.Set; -public abstract class JavaPackageScope extends JavaBaseScope { +public final class JavaPackageScope extends JavaBaseScope { @NotNull private final FqName packageFQN; + @NotNull + private final PsiClassFinder psiClassFinder; - protected JavaPackageScope( + public JavaPackageScope( @NotNull NamespaceDescriptor descriptor, @NotNull PackagePsiDeclarationProvider declarationProvider, @NotNull FqName packageFQN, - @NotNull JavaSemanticServices semanticServices + @NotNull JavaDescriptorResolver javaDescriptorResolver, + @NotNull PsiClassFinder psiClassFinder ) { - super(descriptor, semanticServices, declarationProvider); + super(descriptor, javaDescriptorResolver, declarationProvider); this.packageFQN = packageFQN; + this.psiClassFinder = psiClassFinder; } @Override public ClassifierDescriptor getClassifier(@NotNull Name name) { ClassDescriptor classDescriptor = - getResolver().resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + javaDescriptorResolver.resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); if (classDescriptor == null || classDescriptor.getKind().isObject()) { return null; } @@ -60,7 +63,7 @@ public abstract class JavaPackageScope extends JavaBaseScope { @Override public ClassDescriptor getObjectDescriptor(@NotNull Name name) { ClassDescriptor classDescriptor = - getResolver().resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + javaDescriptorResolver.resolveClass(packageFQN.child(name), DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); if (classDescriptor != null && classDescriptor.getKind().isObject()) { return classDescriptor; } @@ -69,7 +72,7 @@ public abstract class JavaPackageScope extends JavaBaseScope { @Override public NamespaceDescriptor getNamespace(@NotNull Name name) { - return getResolver().resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN); + return javaDescriptorResolver.resolveNamespace(packageFQN.child(name), DescriptorSearchRule.INCLUDE_KOTLIN); } @NotNull @@ -88,13 +91,13 @@ public abstract class JavaPackageScope extends JavaBaseScope { for (PsiPackage psiSubPackage : psiPackage.getSubPackages()) { FqName fqName = new FqName(psiSubPackage.getQualifiedName()); - NamespaceDescriptor childNs = getResolver().resolveNamespace(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + NamespaceDescriptor childNs = javaDescriptorResolver.resolveNamespace(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); if (childNs != null) { result.add(childNs); } } - for (PsiClass psiClass : semanticServices.getPsiClassFinder().findPsiClasses(psiPackage)) { + for (PsiClass psiClass : psiClassFinder.findPsiClasses(psiPackage)) { if (DescriptorResolverUtils.isCompiledKotlinPackageClass(psiClass)) continue; if (psiClass instanceof JetJavaMirrorMarker) continue; @@ -107,12 +110,12 @@ public abstract class JavaPackageScope extends JavaBaseScope { if (qualifiedName == null) continue; FqName fqName = new FqName(qualifiedName); - ClassDescriptor classDescriptor = getResolver().resolveClass(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + ClassDescriptor classDescriptor = javaDescriptorResolver.resolveClass(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); if (classDescriptor != null) { result.add(classDescriptor); } - NamespaceDescriptor namespace = getResolver().resolveNamespace(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); + NamespaceDescriptor namespace = javaDescriptorResolver.resolveNamespace(fqName, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); if (namespace != null) { result.add(namespace); } @@ -120,4 +123,17 @@ public abstract class JavaPackageScope extends JavaBaseScope { return result; } + + @Override + @NotNull + protected Set computeFunctionDescriptor(@NotNull Name name) { + return javaDescriptorResolver.resolveFunctionGroup(name, (PackagePsiDeclarationProvider) declarationProvider, + (NamespaceDescriptor) descriptor); + } + + @NotNull + @Override + protected Collection computeInnerClasses() { + return Collections.emptyList(); + } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScopeWithoutMembers.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScopeWithoutMembers.java deleted file mode 100644 index 183cf6f9f2d..00000000000 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScopeWithoutMembers.java +++ /dev/null @@ -1,54 +0,0 @@ -/* - * 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.scope; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; -import org.jetbrains.jet.lang.resolve.java.provider.PackagePsiDeclarationProvider; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; - -import java.util.Collection; -import java.util.Collections; -import java.util.Set; - -public final class JavaPackageScopeWithoutMembers extends JavaPackageScope { - public JavaPackageScopeWithoutMembers( - @NotNull NamespaceDescriptor descriptor, - @NotNull PackagePsiDeclarationProvider declarationProvider, - @NotNull FqName packageFQN, - @NotNull JavaSemanticServices semanticServices - ) { - super(descriptor, declarationProvider, packageFQN, semanticServices); - } - - @Override - @NotNull - protected Set computeFunctionDescriptor(@NotNull Name name) { - return getResolver().resolveFunctionGroup( - name, (PackagePsiDeclarationProvider) declarationProvider, (NamespaceDescriptor) descriptor); - } - - @NotNull - @Override - protected Collection computeInnerClasses() { - return Collections.emptyList(); - } -}