From 9b2e4c7d164d5dc77c5dbd3287264225906ed159 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Thu, 26 Jan 2012 14:37:25 +0400 Subject: [PATCH] refactoring JavaDescriptorResolver and Java*Scope --- .../resolve/java/JavaBridgeConfiguration.java | 11 ++- .../resolve/java/JavaClassMembersScope.java | 80 +++++-------------- .../resolve/java/JavaClassOrPackageScope.java | 65 +++++++++++++++ .../resolve/java/JavaDescriptorResolver.java | 32 ++++++-- .../lang/resolve/java/JavaPackageScope.java | 62 +++++--------- .../jet/types/JetTypeCheckerTest.java | 6 +- 6 files changed, 144 insertions(+), 112 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassOrPackageScope.java 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 77be1926646..7149ca0265e 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 @@ -5,11 +5,14 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.Configuration; import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.Importer; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; +import java.util.Collections; + /** * @author abreslav */ @@ -29,11 +32,15 @@ public class JavaBridgeConfiguration implements Configuration { @Override public void addDefaultImports(@NotNull BindingTrace trace, @NotNull WritableScope rootScope, @NotNull Importer importer) { - rootScope.importScope(new JavaPackageScope("", null, javaSemanticServices)); - importer.addScopeImport(new JavaPackageScope("java.lang", null, javaSemanticServices)); + rootScope.importScope(new JavaPackageScope("", createNamespaceDescriptor(JavaDescriptorResolver.JAVA_ROOT, ""), javaSemanticServices)); + importer.addScopeImport(new JavaPackageScope("java.lang", createNamespaceDescriptor("lang", "java.lang"), javaSemanticServices)); delegateConfiguration.addDefaultImports(trace, rootScope, importer); } + public static JavaNamespaceDescriptor createNamespaceDescriptor(String name, String qualifiedName) { + return new JavaNamespaceDescriptor(null, Collections.emptyList(), name, qualifiedName, true); + } + @Override public void extendNamespaceScope(@NotNull BindingTrace trace, @NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) { namespaceMemberScope.importScope(new JavaPackageScope(DescriptorUtils.getFQName(namespaceDescriptor), namespaceDescriptor, javaSemanticServices)); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java index 636682c0838..daa5c444429 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java @@ -2,9 +2,7 @@ package org.jetbrains.jet.lang.resolve.java; import com.google.common.collect.Maps; import com.google.common.collect.Sets; -import com.intellij.psi.HierarchicalMethodSignature; import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiMethod; import com.intellij.psi.PsiModifier; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; @@ -12,9 +10,6 @@ import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; -import org.jetbrains.jet.lang.descriptors.VariableDescriptor; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.TypeSubstitutor; @@ -26,25 +21,30 @@ import java.util.Set; /** * @author abreslav */ -public class JavaClassMembersScope implements JetScope { - private final PsiClass psiClass; - private final JavaSemanticServices semanticServices; +public class JavaClassMembersScope extends JavaClassOrPackageScope { + private final PsiClassWrapper psiClass; private final boolean staticMembers; - private final DeclarationDescriptor containingDeclaration; private final Map classifiers = Maps.newHashMap(); private Collection allDescriptors; - public JavaClassMembersScope(@NotNull DeclarationDescriptor classOrNamespaceDescriptor, PsiClass psiClass, JavaSemanticServices semanticServices, boolean staticMembers) { - this.containingDeclaration = classOrNamespaceDescriptor; - this.psiClass = psiClass; - this.semanticServices = semanticServices; + public JavaClassMembersScope( + @NotNull DeclarationDescriptor classOrNamespaceDescriptor, + @NotNull PsiClass psiClass, + @NotNull JavaSemanticServices semanticServices, + boolean staticMembers) { + super(classOrNamespaceDescriptor, semanticServices); + this.psiClass = new PsiClassWrapper(psiClass); this.staticMembers = staticMembers; } - @NotNull @Override - public DeclarationDescriptor getContainingDeclaration() { - return containingDeclaration; + protected PsiClassWrapper psiClass() { + return psiClass; + } + + @Override + protected boolean staticMembers() { + return staticMembers; } @NotNull @@ -53,11 +53,6 @@ public class JavaClassMembersScope implements JetScope { throw new UnsupportedOperationException(); // TODO } - @Override - public PropertyDescriptor getPropertyByFieldReference(@NotNull String fieldName) { - return null; - } - @Override public ClassifierDescriptor getClassifier(@NotNull String name) { ClassifierDescriptor classifierDescriptor = classifiers.get(name); @@ -80,28 +75,19 @@ public class JavaClassMembersScope implements JetScope { allDescriptors = Sets.newHashSet(); TypeSubstitutor substitutorForGenericSupertypes = getTypeSubstitutorForSupertypes(); - for (HierarchicalMethodSignature signature : psiClass.getVisibleSignatures()) { - PsiMethod method = signature.getMethod(); - if (method.hasModifierProperty(PsiModifier.STATIC) != staticMembers) { - continue; - } - FunctionDescriptor functionDescriptor = semanticServices.getDescriptorResolver().resolveMethodToFunctionDescriptor(containingDeclaration, psiClass, substitutorForGenericSupertypes, new PsiMethodWrapper(method)); - if (functionDescriptor != null) { - allDescriptors.add(functionDescriptor); - } - } + allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(psiClass.getPsiClass(), descriptor, staticMembers, substitutorForGenericSupertypes)); - allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(containingDeclaration, psiClass, staticMembers)); + allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(descriptor, psiClass.getPsiClass(), staticMembers)); - allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveInnerClasses(containingDeclaration, psiClass, staticMembers)); + allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveInnerClasses(descriptor, psiClass.getPsiClass(), staticMembers)); } return allDescriptors; } private TypeSubstitutor getTypeSubstitutorForSupertypes() { TypeSubstitutor substitutorForGenericSupertypes; - if (containingDeclaration instanceof ClassDescriptor) { - substitutorForGenericSupertypes = semanticServices.getDescriptorResolver().createSubstitutorForGenericSupertypes((ClassDescriptor) containingDeclaration); + if (descriptor instanceof ClassDescriptor) { + substitutorForGenericSupertypes = semanticServices.getDescriptorResolver().createSubstitutorForGenericSupertypes((ClassDescriptor) descriptor); } else { substitutorForGenericSupertypes = TypeSubstitutor.EMPTY; @@ -111,7 +97,7 @@ public class JavaClassMembersScope implements JetScope { private ClassifierDescriptor doGetClassifierDescriptor(String name) { // TODO : suboptimal, walk the list only once - for (PsiClass innerClass : psiClass.getAllInnerClasses()) { + for (PsiClass innerClass : psiClass.getPsiClass().getAllInnerClasses()) { if (name.equals(innerClass.getName())) { if (innerClass.hasModifierProperty(PsiModifier.STATIC) != staticMembers) return null; ClassDescriptor classDescriptor = semanticServices.getDescriptorResolver().resolveClass(innerClass); @@ -123,28 +109,6 @@ public class JavaClassMembersScope implements JetScope { return null; } - @NotNull - @Override - public Set getProperties(@NotNull String name) { - return semanticServices.getDescriptorResolver().resolveFieldGroupByName(containingDeclaration, psiClass, name, staticMembers); - } - - @Override - public VariableDescriptor getLocalVariable(@NotNull String name) { - return null; - } - - @NotNull - @Override - public Set getFunctions(@NotNull String name) { - return semanticServices.getDescriptorResolver().resolveFunctionGroup( - containingDeclaration, - psiClass, - staticMembers ? null : (ClassDescriptor) containingDeclaration, - name, - staticMembers); - } - @Override public NamespaceDescriptor getNamespace(@NotNull String name) { return null; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassOrPackageScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassOrPackageScope.java new file mode 100644 index 00000000000..f1ff0921913 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassOrPackageScope.java @@ -0,0 +1,65 @@ +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.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.VariableDescriptor; +import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl; + +import java.util.Collections; +import java.util.Set; + +/** + * @author Stepan Koltsov + */ +public abstract class JavaClassOrPackageScope extends JetScopeImpl { + + @NotNull + protected final DeclarationDescriptor descriptor; + protected final JavaSemanticServices semanticServices; + + protected JavaClassOrPackageScope(@NotNull DeclarationDescriptor descriptor, @NotNull JavaSemanticServices semanticServices) { + this.descriptor = descriptor; + this.semanticServices = semanticServices; + } + + @NotNull + @Override + public DeclarationDescriptor getContainingDeclaration() { + return descriptor; + } + + @Nullable + protected abstract PsiClassWrapper psiClass(); + + protected abstract boolean staticMembers(); + + @NotNull + @Override + public Set getProperties(@NotNull String name) { + PsiClassWrapper psiClass = psiClass(); + + if (psiClass == null) { + return Collections.emptySet(); + } + + // TODO: cache + return semanticServices.getDescriptorResolver().resolveFieldGroupByName( + descriptor, psiClass.getPsiClass(), name, staticMembers()); + } + + @NotNull + @Override + public Set getFunctions(@NotNull String name) { + PsiClassWrapper psiClassForPackage = psiClass(); + + if (psiClassForPackage == null) { + return Collections.emptySet(); + } + + return semanticServices.getDescriptorResolver().resolveFunctionGroup(descriptor, psiClassForPackage.getPsiClass(), name, staticMembers()); + } + +} 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 edabcbcf394..c8766ffb590 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 @@ -1056,9 +1056,9 @@ public class JavaDescriptorResolver { } @NotNull - public Set resolveFunctionGroup(@NotNull DeclarationDescriptor owner, @NotNull PsiClass psiClass, @Nullable ClassDescriptor classDescriptor, @NotNull String methodName, boolean staticMembers) { + public Set resolveFunctionGroup(@NotNull DeclarationDescriptor descriptor, @NotNull PsiClass psiClass, @NotNull String methodName, boolean staticMembers) { - ResolverScopeData resolverScopeData = getResolverScopeData(owner, new PsiClassWrapper(psiClass)); + ResolverScopeData resolverScopeData = getResolverScopeData(descriptor, new PsiClassWrapper(psiClass)); Map namedMembersMap = resolverScopeData.namedMembersMap; @@ -1067,13 +1067,18 @@ public class JavaDescriptorResolver { return Collections.emptySet(); } - TypeSubstitutor typeSubstitutor = createSubstitutorForGenericSupertypes(classDescriptor); - resolveNamedGroupFunctions(owner, psiClass, typeSubstitutor, staticMembers, namedMembers, methodName); + TypeSubstitutor typeSubstitutor; + if (descriptor instanceof ClassDescriptor && !staticMembers) { + typeSubstitutor = createSubstitutorForGenericSupertypes((ClassDescriptor) descriptor); + } else { + typeSubstitutor = TypeSubstitutor.EMPTY; + } + resolveNamedGroupFunctions(descriptor, psiClass, typeSubstitutor, staticMembers, namedMembers, methodName); return namedMembers.functionDescriptors; } - public TypeSubstitutor createSubstitutorForGenericSupertypes(ClassDescriptor classDescriptor) { + public TypeSubstitutor createSubstitutorForGenericSupertypes(@Nullable ClassDescriptor classDescriptor) { TypeSubstitutor typeSubstitutor; if (classDescriptor != null) { typeSubstitutor = TypeUtils.buildDeepSubstitutor(classDescriptor.getDefaultType()); @@ -1105,7 +1110,7 @@ public class JavaDescriptorResolver { } @Nullable - public FunctionDescriptor resolveMethodToFunctionDescriptor(DeclarationDescriptor owner, PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, PsiMethodWrapper method) { + private FunctionDescriptor resolveMethodToFunctionDescriptor(DeclarationDescriptor owner, PsiClass psiClass, TypeSubstitutor typeSubstitutorForGenericSuperclasses, PsiMethodWrapper method) { PsiType returnType = method.getReturnType(); if (returnType == null) { @@ -1224,6 +1229,21 @@ public class JavaDescriptorResolver { } return substitutedFunctionDescriptor; } + + public List resolveMethods(PsiClass psiClass, DeclarationDescriptor containingDeclaration, boolean staticMembers, TypeSubstitutor substitutorForGenericSupertypes) { + List functions = new ArrayList(); + for (HierarchicalMethodSignature signature : psiClass.getVisibleSignatures()) { + PsiMethod method = signature.getMethod(); + if (method.hasModifierProperty(PsiModifier.STATIC) != staticMembers) { + continue; + } + FunctionDescriptor functionDescriptor = semanticServices.getDescriptorResolver().resolveMethodToFunctionDescriptor(containingDeclaration, psiClass, substitutorForGenericSupertypes, new PsiMethodWrapper(method)); + if (functionDescriptor != null) { + functions.add(functionDescriptor); + } + } + return functions; + } private List resolveMethodTypeParameters( @NotNull PsiMethodWrapper method, diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java index cfd692ece93..884c26ad16f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java @@ -2,12 +2,14 @@ package org.jetbrains.jet.lang.resolve.java; import com.google.common.collect.Sets; import com.intellij.psi.PsiClass; -import com.intellij.psi.PsiField; 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.scopes.JetScopeImpl; +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.FunctionDescriptor; +import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import java.util.Collection; import java.util.Collections; @@ -16,17 +18,17 @@ import java.util.Set; /** * @author abreslav */ -public class JavaPackageScope extends JetScopeImpl { - private final JavaSemanticServices semanticServices; - private final DeclarationDescriptor containingDescriptor; +public class JavaPackageScope extends JavaClassOrPackageScope { private final String packageFQN; private Collection allDescriptors; - public JavaPackageScope(@NotNull String packageFQN, DeclarationDescriptor containingDescriptor, JavaSemanticServices semanticServices) { - this.semanticServices = semanticServices; + public JavaPackageScope( + @NotNull String packageFQN, + @NotNull DeclarationDescriptor containingDescriptor, + @NotNull JavaSemanticServices semanticServices) { + super(containingDescriptor, semanticServices); this.packageFQN = packageFQN; - this.containingDescriptor = containingDescriptor; } @Override @@ -36,6 +38,7 @@ public class JavaPackageScope extends JetScopeImpl { @Override public ClassDescriptor getObjectDescriptor(@NotNull String name) { + // TODO return null; } @@ -43,8 +46,9 @@ public class JavaPackageScope extends JetScopeImpl { public NamespaceDescriptor getNamespace(@NotNull String name) { return semanticServices.getDescriptorResolver().resolveNamespace(getQualifiedName(name)); } - - private PsiClass getPsiClassForPackage() { + + @Override + protected PsiClassWrapper psiClass() { // If this package is actually a Kotlin namespace, then we access it through a namespace descriptor, and // Kotlin functions are already there NamespaceDescriptor kotlinNamespaceDescriptor = semanticServices.getKotlinNamespaceDescriptor(packageFQN); @@ -58,42 +62,12 @@ public class JavaPackageScope extends JetScopeImpl { return null; } - if (containingDescriptor == null) { - return null; - } - - return psiClass; + return new PsiClassWrapper(psiClass); } - @NotNull @Override - public Set getFunctions(@NotNull String name) { - PsiClass psiClassForPackage = getPsiClassForPackage(); - - if (psiClassForPackage == null) { - return Collections.emptySet(); - } - - return semanticServices.getDescriptorResolver().resolveFunctionGroup(containingDescriptor, psiClassForPackage, null, name, true); - } - - @NotNull - @Override - public Set getProperties(@NotNull String name) { - PsiClass psiClassForPackage = getPsiClassForPackage(); - - if (psiClassForPackage == null) { - return Collections.emptySet(); - } - - // TODO: cache - return semanticServices.getDescriptorResolver().resolveFieldGroupByName(containingDescriptor, psiClassForPackage, name, true); - } - - @NotNull - @Override - public DeclarationDescriptor getContainingDeclaration() { - return containingDescriptor; + protected boolean staticMembers() { + return true; } @NotNull diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 14ad874837a..01ee7bc2912 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -12,6 +12,8 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.*; +import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaPackageScope; import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices; import org.jetbrains.jet.lang.resolve.scopes.*; @@ -543,8 +545,8 @@ public class JetTypeCheckerTest extends JetLiteFixture { WritableScopeImpl writableScope = new WritableScopeImpl(scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING); writableScope.importScope(library.getLibraryScope()); JavaSemanticServices javaSemanticServices = new JavaSemanticServices(getProject(), semanticServices, JetTestUtils.DUMMY_TRACE); - writableScope.importScope(new JavaPackageScope("", null, javaSemanticServices)); - writableScope.importScope(new JavaPackageScope("java.lang", null, javaSemanticServices)); + writableScope.importScope(new JavaPackageScope("", JavaBridgeConfiguration.createNamespaceDescriptor(JavaDescriptorResolver.JAVA_ROOT, ""), javaSemanticServices)); + writableScope.importScope(new JavaPackageScope("java.lang", JavaBridgeConfiguration.createNamespaceDescriptor("lang", "java.lang"), javaSemanticServices)); writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); return writableScope; }