From c0e27ce1b15b884876ab06677fdd22d483090c95 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Wed, 17 Oct 2012 19:38:02 +0400 Subject: [PATCH] Move descriptors cache from NamedMembers to JavaBaseScope 2 tests failing --- .../resolve/java/JavaDescriptorResolver.java | 10 --- .../jet/lang/resolve/java/NamedMembers.java | 32 +------- .../java/resolver/JavaFunctionResolver.java | 46 +++-------- .../java/resolver/JavaPropertiesResolver.java | 32 ++------ .../resolve/java/scope/JavaBaseScope.java | 80 +++++++++++++++++-- .../lang/resolve/java/scope/ScopeUtils.java | 29 ------- 6 files changed, 94 insertions(+), 135 deletions(-) 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 7fa1cebfbb4..6aeb78f65fd 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 @@ -131,11 +131,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes return propertiesResolver.resolveFieldGroupByName(name, data); } - @NotNull - public Set resolveFieldGroup(ResolverScopeData data) { - return propertiesResolver.resolveFieldGroup(data); - } - @Nullable public ClassDescriptor resolveClass(@NotNull FqName name, @NotNull DescriptorSearchRule searchRule, @NotNull PostponedTasks tasks) { return classResolver.resolveClass(name, searchRule, tasks); @@ -166,11 +161,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes return functionResolver.resolveFunctionGroup(methodName, scopeData); } - @NotNull - public List resolveMethods(@NotNull ResolverScopeData scopeData) { - return functionResolver.resolveMethods(scopeData); - } - @NotNull public List resolveInnerClasses(DeclarationDescriptor owner, PsiClass psiClass, boolean staticMembers) { return innerClassResolver.resolveInnerClasses(owner, psiClass, staticMembers); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/NamedMembers.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/NamedMembers.java index 9daaf24cbbf..e1afc92e536 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/NamedMembers.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/NamedMembers.java @@ -18,19 +18,12 @@ package org.jetbrains.jet.lang.resolve.java; import com.google.common.collect.Lists; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.FunctionDescriptor; -import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper; import org.jetbrains.jet.lang.resolve.name.Name; import java.util.List; -import java.util.Set; -/** -* @author Stepan Koltsov -*/ -public class NamedMembers { +public final class NamedMembers { public NamedMembers(@NotNull Name name) { this.name = name; @@ -45,11 +38,6 @@ public class NamedMembers { @NotNull private final List propertyAccessors = Lists.newArrayList(); - private Set propertyDescriptors; - - /** Including from supertypes */ - private Set functionDescriptors; - void addMethod(@NotNull PsiMethodWrapper method) { methods.add(method); } @@ -72,22 +60,4 @@ public class NamedMembers { public List getPropertyAccessors() { return propertyAccessors; } - - @Nullable - public Set getPropertyDescriptors() { - return propertyDescriptors; - } - - public void setPropertyDescriptors(@NotNull Set propertyDescriptors) { - this.propertyDescriptors = propertyDescriptors; - } - - @Nullable - public Set getFunctionDescriptors() { - return functionDescriptors; - } - - public void setFunctionDescriptors(@NotNull Set functionDescriptors) { - this.functionDescriptors = functionDescriptors; - } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java index 4a30e0570cb..70c340e5b27 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java @@ -37,7 +37,10 @@ import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import javax.inject.Inject; -import java.util.*; +import java.util.Collections; +import java.util.HashSet; +import java.util.List; +import java.util.Set; public final class JavaFunctionResolver { @@ -165,14 +168,11 @@ public final class JavaFunctionResolver { return functionDescriptorImpl; } - private void resolveNamedGroupFunctions( + @NotNull + private Set resolveNamedGroupFunctions( @NotNull ClassOrNamespaceDescriptor owner, @NotNull PsiClass psiClass, NamedMembers namedMembers, Name methodName, ResolverScopeData scopeData ) { - if (namedMembers.getFunctionDescriptors() != null) { - return; - } - final Set functions = new HashSet(); Set functionsFromCurrent = Sets.newHashSet(); @@ -216,7 +216,7 @@ public final class JavaFunctionResolver { } } - namedMembers.setFunctionDescriptors(functions); + return functions; } @NotNull @@ -224,22 +224,15 @@ public final class JavaFunctionResolver { MembersByNameCache namedMembersMap = scopeData.getMembersCache(); NamedMembers namedMembers = namedMembersMap.get(methodName); - if (namedMembers != null) { - - PsiClass psiClass = scopeData.getPsiClass(); - assert psiClass != null; - resolveNamedGroupFunctions(scopeData.getClassOrNamespaceDescriptor(), psiClass, namedMembers, - methodName, scopeData); - - Set result = namedMembers.getFunctionDescriptors(); - assert result != null; - return result; - } - else { + if (namedMembers == null) { return Collections.emptySet(); } + PsiClass psiClass = scopeData.getPsiClass(); + assert psiClass != null; + return resolveNamedGroupFunctions(scopeData.getClassOrNamespaceDescriptor(), psiClass, namedMembers, methodName, scopeData); } + @NotNull private JetType makeReturnType( PsiType returnType, PsiMethodWrapper method, @NotNull TypeVariableResolver typeVariableResolver @@ -265,6 +258,7 @@ public final class JavaFunctionResolver { } } + @NotNull private static Set getFunctionsFromSupertypes( ResolverScopeData scopeData, Name methodName @@ -278,20 +272,6 @@ public final class JavaFunctionResolver { return r; } - public List resolveMethods(@NotNull ResolverScopeData scopeData) { - List functions = new ArrayList(); - - for (NamedMembers member : scopeData.getMembersCache().allMembers()) { - PsiClass psiClass = scopeData.getPsiClass(); - assert psiClass != null; - resolveNamedGroupFunctions(scopeData.getClassOrNamespaceDescriptor(), psiClass, - member, member.getName(), scopeData); - functions.addAll(member.getFunctionDescriptors()); - } - - return functions; - } - private static boolean isEnumSpecialMethod(@NotNull FunctionDescriptor functionDescriptor) { List methodTypeParameters = functionDescriptor.getValueParameters(); String methodName = functionDescriptor.getName().getName(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertiesResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertiesResolver.java index 37a2fb49391..3f930d99ab7 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertiesResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertiesResolver.java @@ -79,6 +79,7 @@ public final class JavaPropertiesResolver { this.classResolver = classResolver; } + @NotNull public Set resolveFieldGroupByName( @NotNull Name fieldName, @NotNull ResolverScopeData scopeData @@ -93,30 +94,10 @@ public final class JavaPropertiesResolver { //noinspection ConstantConditions String qualifiedName = psiClass == null ? scopeData.getPsiPackage().getQualifiedName() : psiClass.getQualifiedName(); - resolveNamedGroupProperties(scopeData.getClassOrNamespaceDescriptor(), scopeData, namedMembers, fieldName, + return resolveNamedGroupProperties(scopeData.getClassOrNamespaceDescriptor(), scopeData, namedMembers, fieldName, "class or namespace " + qualifiedName); - - Set result = namedMembers.getPropertyDescriptors(); - assert result != null; - return result; } - @NotNull - public Set resolveFieldGroup(@NotNull ResolverScopeData scopeData) { - final PsiClass psiClass = scopeData.getPsiClass(); - assert psiClass != null; - - Set descriptors = Sets.newHashSet(); - MembersByNameCache membersForProperties = scopeData.getMembersCache(); - for (NamedMembers members : membersForProperties.allMembers()) { - resolveNamedGroupProperties( - scopeData.getClassOrNamespaceDescriptor(), scopeData, members, members.getName(), - "class or namespace " + psiClass.getQualifiedName()); - descriptors.addAll(members.getPropertyDescriptors()); - } - - return descriptors; - } private static class GroupingValue { PropertyAccessorData getter; PropertyAccessorData setter; @@ -124,17 +105,14 @@ public final class JavaPropertiesResolver { boolean ext; } - private void resolveNamedGroupProperties( + @NotNull + private Set resolveNamedGroupProperties( @NotNull ClassOrNamespaceDescriptor owner, @NotNull ResolverScopeData scopeData, @NotNull NamedMembers namedMembers, @NotNull Name propertyName, @NotNull String context ) { - if (namedMembers.getPropertyDescriptors() != null) { - return; - } - Map map = collectGroupingValuesFromAccessors(namedMembers.getPropertyAccessors()); Set propertiesFromCurrent = new HashSet(1); @@ -315,7 +293,7 @@ public final class JavaPropertiesResolver { OverrideResolver.resolveUnknownVisibilities(properties, trace); properties.addAll(propertiesFromCurrent); - namedMembers.setPropertyDescriptors(Sets.newHashSet(properties)); + return Sets.newHashSet(properties); } private List resolvePropertyTypeParameters( 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 738d5fde7b5..6a50bbf1527 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 @@ -16,20 +16,28 @@ package org.jetbrains.jet.lang.resolve.java.scope; +import com.google.common.collect.Maps; import com.google.common.collect.Sets; +import com.intellij.openapi.progress.ProgressIndicatorProvider; 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.descriptors.*; -import org.jetbrains.jet.lang.resolve.java.*; +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.java.JavaSemanticServices; +import org.jetbrains.jet.lang.resolve.java.NamedMembers; import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData; +import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl; import java.util.Collection; +import java.util.Collections; +import java.util.Map; +import java.util.Set; -import static org.jetbrains.jet.lang.resolve.java.scope.ScopeUtils.computeAllClassDeclarations; import static org.jetbrains.jet.lang.resolve.java.scope.ScopeUtils.computeAllPackageDeclarations; public abstract class JavaBaseScope extends JetScopeImpl { @@ -39,6 +47,12 @@ public abstract class JavaBaseScope extends JetScopeImpl { @NotNull protected final ResolverScopeData resolverScopeData; + @NotNull + private final Map> functionDescriptors = Maps.newHashMap(); + @NotNull + private final Map> propertyDescriptors = Maps.newHashMap(); + + @Nullable private Collection allDescriptors = null; @@ -59,19 +73,47 @@ public abstract class JavaBaseScope extends JetScopeImpl { @NotNull @Override public Collection getProperties(@NotNull Name name) { + Set cached = propertyDescriptors.get(name); + if (cached != null) return cached; + + if (allDescriptorsComputed()) { + return Collections.emptySet(); + } + + Set computedDescriptors = computePropertyDescriptors(name); + propertyDescriptors.put(name, computedDescriptors); + return computedDescriptors; + } + + @NotNull + private Set computePropertyDescriptors(@NotNull Name name) { return semanticServices.getDescriptorResolver().resolveFieldGroupByName(name, resolverScopeData); } @NotNull @Override public Collection getFunctions(@NotNull Name name) { + Set cached = functionDescriptors.get(name); + if (cached != null) return cached; + + if (allDescriptorsComputed()) { + return Collections.emptySet(); + } + + Set computedDescriptors = computeFunctionDescriptor(name); + functionDescriptors.put(name, computedDescriptors); + return computedDescriptors; + } + + @NotNull + private Set computeFunctionDescriptor(@NotNull Name name) { return semanticServices.getDescriptorResolver().resolveFunctionGroup(name, resolverScopeData); } @NotNull @Override public Collection getAllDescriptors() { - if (allDescriptors != null) { + if (allDescriptorsComputed()) { return allDescriptors; } @@ -80,12 +122,17 @@ public abstract class JavaBaseScope extends JetScopeImpl { return allDescriptors; } + private boolean allDescriptorsComputed() { + return allDescriptors != null; + } + @NotNull private Collection computeAllDescriptors() { Collection result = Sets.newHashSet(); PsiClass psiClass = resolverScopeData.getPsiClass(); if (psiClass != null) { - result.addAll(computeAllClassDeclarations(psiClass, semanticServices, resolverScopeData, getContainingDeclaration())); + computeFieldAndFunctionDescriptors(result); + computeInnerClasses(psiClass, result); } PsiPackage psiPackage = resolverScopeData.getPsiPackage(); @@ -94,4 +141,27 @@ public abstract class JavaBaseScope extends JetScopeImpl { } return result; } + + private void computeFieldAndFunctionDescriptors(Collection result) { + for (NamedMembers members : resolverScopeData.getMembersCache().allMembers()) { + Name name = members.getName(); + ProgressIndicatorProvider.checkCanceled(); + result.addAll(getFunctions(name)); + ProgressIndicatorProvider.checkCanceled(); + result.addAll(getProperties(name)); + } + } + + private void computeInnerClasses(@NotNull PsiClass psiClass, @NotNull Collection result) { + // TODO: Trying to hack the situation when we produce namespace descriptor for java class and still want to see inner classes + if (getContainingDeclaration() instanceof JavaNamespaceDescriptor) { + result.addAll(semanticServices.getDescriptorResolver().resolveInnerClasses( + resolverScopeData.getClassOrNamespaceDescriptor(), psiClass, false)); + } + else { + result.addAll(semanticServices.getDescriptorResolver().resolveInnerClasses( + resolverScopeData.getClassOrNamespaceDescriptor(), psiClass, + resolverScopeData.isStaticMembers())); + } + } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/ScopeUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/ScopeUtils.java index 6d4cd7c44bb..d3da0f625f0 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/ScopeUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/scope/ScopeUtils.java @@ -26,8 +26,6 @@ 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.*; -import org.jetbrains.jet.lang.resolve.java.data.ResolverScopeData; -import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor; import org.jetbrains.jet.lang.resolve.name.FqName; import java.util.Collection; @@ -79,31 +77,4 @@ public final class ScopeUtils { } return result; } - - @NotNull - public static Collection computeAllClassDeclarations( - @NotNull PsiClass psiClass, - @NotNull JavaSemanticServices javaSemanticServices, - @NotNull ResolverScopeData scopeData, - @NotNull DeclarationDescriptor containingDeclaration - ) { - Collection result = Sets.newHashSet(); - ProgressIndicatorProvider.checkCanceled(); - result.addAll(javaSemanticServices.getDescriptorResolver().resolveMethods(scopeData)); - - ProgressIndicatorProvider.checkCanceled(); - result.addAll(javaSemanticServices.getDescriptorResolver().resolveFieldGroup(scopeData)); - - // TODO: Trying to hack the situation when we produce namespace descriptor for java class and still want to see inner classes - if (containingDeclaration instanceof JavaNamespaceDescriptor) { - result.addAll(javaSemanticServices.getDescriptorResolver().resolveInnerClasses( - scopeData.getClassOrNamespaceDescriptor(), psiClass, false)); - } - else { - result.addAll(javaSemanticServices.getDescriptorResolver().resolveInnerClasses( - scopeData.getClassOrNamespaceDescriptor(), psiClass, - scopeData.isStaticMembers())); - } - return result; - } }