From a87f3e2a451fb816c71a75776155c8a69a4e5558 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Sat, 16 Jun 2012 06:44:16 +0400 Subject: [PATCH] jdr: merge resolveMethod* methods, use DescriptorPredicate --- .../resolve/java/JavaClassOrPackageScope.java | 9 +- .../resolve/java/JavaDescriptorResolver.java | 92 +++++++++---------- .../jet/lang/resolve/name/NamePredicate.java | 89 ++++++++++++++++++ .../lang/resolve/name/NamePredicateUtils.java | 40 ++++++++ 4 files changed, 179 insertions(+), 51 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/name/NamePredicate.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/name/NamePredicateUtils.java 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 index c3091460f2e..1653b88aea6 100644 --- 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 @@ -24,6 +24,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; +import org.jetbrains.jet.lang.resolve.name.NamePredicate; import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicate; import org.jetbrains.jet.lang.resolve.scopes.DescriptorPredicateUtils; import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl; @@ -60,13 +61,13 @@ public abstract class JavaClassOrPackageScope extends JetScopeImpl { @NotNull @Override public Collection getProperties(@NotNull Name name) { - return semanticServices.getDescriptorResolver().resolveFieldGroupByName(name, resolverScopeData); + return semanticServices.getDescriptorResolver().resolveFieldGroup(resolverScopeData, NamePredicate.exact(name)); } @NotNull @Override public Collection getFunctions(@NotNull Name name) { - return semanticServices.getDescriptorResolver().resolveFunctionGroup(name, resolverScopeData); + return semanticServices.getDescriptorResolver().resolveMethods(resolverScopeData, NamePredicate.exact(name)); } @NotNull @@ -76,9 +77,9 @@ public abstract class JavaClassOrPackageScope extends JetScopeImpl { allDescriptors = Sets.newHashSet(); if (resolverScopeData.psiClass != null) { - allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(resolverScopeData)); + allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveMethods(resolverScopeData, NamePredicate.all())); - allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(resolverScopeData)); + allDescriptors.addAll(semanticServices.getDescriptorResolver().resolveFieldGroup(resolverScopeData, NamePredicate.all())); // 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) { 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 1a593e8a35f..e01158c9484 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 @@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; +import org.jetbrains.jet.lang.resolve.name.NamePredicate; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; @@ -1143,33 +1144,12 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes } } - public Set resolveFieldGroupByName(@NotNull Name fieldName, @NotNull ResolverScopeData scopeData) { - - if (scopeData.psiClass == null) { - return Collections.emptySet(); - } - - getResolverScopeData(scopeData); - - NamedMembers namedMembers = scopeData.namedMembersMap.get(fieldName); - if (namedMembers == null) { - return Collections.emptySet(); - } - - resolveNamedGroupProperties(scopeData.classOrNamespaceDescriptor, scopeData, namedMembers, fieldName, - "class or namespace " + scopeData.psiClass.getQualifiedName()); - - return namedMembers.propertyDescriptors; - } - @NotNull - public Set resolveFieldGroup(@NotNull ResolverScopeData scopeData) { - - getResolverScopeData(scopeData); + public Set resolveFieldGroup(@NotNull ResolverScopeData scopeData, @NotNull NamePredicate predicate) { Set descriptors = Sets.newHashSet(); - Map membersForProperties = scopeData.namedMembersMap; - for (Map.Entry entry : membersForProperties.entrySet()) { + + for (Map.Entry entry : getNamedMemberss(scopeData, predicate)) { NamedMembers namedMembers = entry.getValue(); Name propertyName = entry.getKey(); @@ -1510,26 +1490,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes } } - @NotNull - public Set resolveFunctionGroup(@NotNull Name methodName, @NotNull ResolverScopeData scopeData) { - - getResolverScopeData(scopeData); - - Map namedMembersMap = scopeData.namedMembersMap; - - NamedMembers namedMembers = namedMembersMap.get(methodName); - if (namedMembers != null && namedMembers.methods != null) { - TypeSubstitutor typeSubstitutor = typeSubstitutorForGenericSupertypes(scopeData); - - resolveNamedGroupFunctions(scopeData.classOrNamespaceDescriptor, scopeData.psiClass, typeSubstitutor, namedMembers, methodName, scopeData); - - return namedMembers.functionDescriptors; - } - else { - return Collections.emptySet(); - } - } - private TypeSubstitutor createSubstitutorForGenericSupertypes(@Nullable ClassDescriptor classDescriptor) { TypeSubstitutor typeSubstitutor; if (classDescriptor != null) { @@ -1729,18 +1689,56 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes return annotation; } - public List resolveMethods(@NotNull ResolverScopeData scopeData) { + private Collection> getNamedMemberss(@NotNull ResolverScopeData scopeData, @NotNull NamePredicate predicate) { getResolverScopeData(scopeData); + Name exact = predicate.getExact(); + + if (predicate.isAll()) { + return scopeData.namedMembersMap.entrySet(); + } + else if (exact != null) { + NamedMembers namedMembers = scopeData.namedMembersMap.get(exact); + if (namedMembers != null) { + return Collections.>singletonList( + new AbstractMap.SimpleEntry(exact, namedMembers)); + } + else { + return null; + } + } + else { + Collection> r = Lists.newArrayList(); + for (Map.Entry e : scopeData.namedMembersMap.entrySet()) { + Name methodName = e.getKey(); + NamedMembers namedMembers = e.getValue(); + if (predicate.matches(methodName)) { + r.add(new AbstractMap.SimpleEntry(exact, namedMembers)); + } + } + return r; + } + } + + + @NotNull + public List resolveMethods(@NotNull ResolverScopeData scopeData, @NotNull NamePredicate predicate) { + TypeSubstitutor substitutorForGenericSupertypes = typeSubstitutorForGenericSupertypes(scopeData); List functions = new ArrayList(); - for (Map.Entry entry : scopeData.namedMembersMap.entrySet()) { + for (Map.Entry entry : getNamedMemberss(scopeData, predicate)) { Name methodName = entry.getKey(); NamedMembers namedMembers = entry.getValue(); - resolveNamedGroupFunctions(scopeData.classOrNamespaceDescriptor, scopeData.psiClass, substitutorForGenericSupertypes, namedMembers, methodName, scopeData); + resolveNamedGroupFunctions( + scopeData.classOrNamespaceDescriptor, + scopeData.psiClass, + substitutorForGenericSupertypes, + namedMembers, + methodName, + scopeData); functions.addAll(namedMembers.functionDescriptors); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/name/NamePredicate.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/name/NamePredicate.java new file mode 100644 index 00000000000..02c411ec71f --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/name/NamePredicate.java @@ -0,0 +1,89 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.name; + +import com.google.common.base.Predicate; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; + +/** + * @author Stepan Koltsov + */ +public abstract class NamePredicate { + + public boolean isAll() { + return this instanceof All; + } + + @Nullable + public Name getExact() { + if (this instanceof Exact) { + return ((Exact) this).required; + } + else { + return null; + } + } + + + public abstract boolean matches(@NotNull Name name); + + + private static class All extends NamePredicate { + public static final All instance = new All(); + + @Override + public boolean matches(@NotNull Name name) { + return true; + } + } + + public static All all() { + return new All(); + } + + + private static class Exact extends NamePredicate { + @NotNull + private final Name required; + + private Exact(@NotNull Name required) { + this.required = required; + } + + @Override + public boolean matches(@NotNull Name name) { + return name.equals(required); + } + } + + public static Exact exact(@NotNull Name required) { + return new Exact(required); + } + + + public Predicate asGuavaDescriptorPredicate() { + return new Predicate() { + @Override + public boolean apply(@NotNull DeclarationDescriptor descriptor) { + return matches(descriptor.getName()); + } + }; + } + +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/name/NamePredicateUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/name/NamePredicateUtils.java new file mode 100644 index 00000000000..8e9fea0a516 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/name/NamePredicateUtils.java @@ -0,0 +1,40 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.name; + +import com.google.common.collect.Collections2; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; + +import java.util.Collection; + +/** + * @author Stepan Koltsov + */ +public class NamePredicateUtils { + + public static Collection filter( + @NotNull Collection descriptors, + @NotNull NamePredicate predicate) { + if (predicate.isAll()) { + return descriptors; + } + else { + return Collections2.filter(descriptors, predicate.asGuavaDescriptorPredicate()); + } + } +}