From 46f1873dc8b2875df7147283291a56d0a28bdd8b Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Mon, 18 Aug 2014 15:54:38 +0400 Subject: [PATCH] JDR: drop various code that is marked as temporary Remove additional logic for comparing files in JavaClassFinderImpl Drop redundant check for builtins in findClassInJava(FqName) Drop resolve cache query in LazyJavaClassMemberScope and LazyJavaPackageFragmentScope --- .../resolve/java/JavaClassFinderImpl.java | 19 ------------------- .../java/resolver/LazyResolveBasedCache.kt | 11 ----------- .../resolver/TraceBasedJavaResolverCache.java | 10 ---------- .../descriptors/LazyJavaClassMemberScope.kt | 12 +++--------- .../LazyJavaPackageFragmentScope.kt | 14 ++++---------- .../jet/lang/resolve/java/lazy/resolvers.kt | 6 ------ .../resolver/DescriptorResolverUtils.java | 18 ------------------ .../java/resolver/JavaResolverCache.java | 8 ++++---- 8 files changed, 11 insertions(+), 87 deletions(-) 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 index 436a1d63ec3..dece6ba614b 100644 --- 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 @@ -17,7 +17,6 @@ package org.jetbrains.jet.lang.resolve.java; import com.intellij.openapi.project.Project; -import com.intellij.openapi.util.Comparing; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiPackage; @@ -62,24 +61,6 @@ public class JavaClassFinderImpl implements JavaClassFinder { return myBaseScope.contains(file) && file.getFileType() != JetFileType.INSTANCE; } - @Override - public int compare(VirtualFile file1, VirtualFile file2) { - //TODO_r: delete this code? - // TODO: this is a hackish workaround for the following problem: - // since we are working with the allScope(), if the same class FqName - // to be on the class path twice, because it is included into different libraries - // (e.g. junit-4.0.jar is used as a separate library and as a part of idea_full) - // the two libraries are attached to different modules, the parent compare() - // can't tell which one comes first, so they can come in random order - // To fix this, we sort additionally by the full path, to make the ordering deterministic - // TODO: Delete this hack when proper scopes are used - int compare = super.compare(file1, file2); - if (compare == 0) { - return Comparing.compare(file1.getPath(), file2.getPath()); - } - return compare; - } - //NOTE: expected by class finder to be not null @NotNull @Override diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/LazyResolveBasedCache.kt b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/LazyResolveBasedCache.kt index 4a604886f2f..f971e69f7d4 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/LazyResolveBasedCache.kt +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/LazyResolveBasedCache.kt @@ -24,16 +24,9 @@ import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod import org.jetbrains.jet.lang.resolve.lazy.ResolveSession import org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils import org.jetbrains.jet.lang.resolve.name.FqName -import org.jetbrains.jet.lang.types.TypeProjection import javax.inject.Inject -import java.util.Collections import kotlin.properties.Delegates -import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns -import com.intellij.openapi.application.ApplicationManager import com.intellij.openapi.diagnostic.Logger -import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaClassImpl -import com.google.common.base.Predicates -import org.jetbrains.jet.lang.descriptors.impl.PackageViewDescriptorImpl import org.jetbrains.jet.lang.resolve.name.tail import org.jetbrains.jet.lang.resolve.name.each @@ -62,10 +55,6 @@ public class LazyResolveBasedCache() : JavaResolverCache { } } - override fun getClass(javaClass: JavaClass): ClassDescriptor? { - return traceBasedCache.getClass(javaClass) ?: null - } - override fun recordMethod(method: JavaMethod, descriptor: SimpleFunctionDescriptor) { traceBasedCache.recordMethod(method, descriptor) } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java index 95cab5f8d51..82aa36128e0 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java @@ -16,9 +16,7 @@ package org.jetbrains.jet.lang.resolve.java.resolver; -import com.intellij.psi.PsiExpression; import com.intellij.psi.PsiField; -import com.intellij.psi.impl.JavaConstantExpressionEvaluator; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; @@ -27,8 +25,6 @@ import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.CompileTimeConstantUtils; -import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.java.structure.JavaElement; import org.jetbrains.jet.lang.resolve.java.structure.JavaField; @@ -57,12 +53,6 @@ public class TraceBasedJavaResolverCache implements JavaResolverCache { return trace.get(FQNAME_TO_CLASS_DESCRIPTOR, fqName.toUnsafe()); } - @Nullable - @Override - public ClassDescriptor getClass(@NotNull JavaClass javaClass) { - return trace.get(CLASS, ((JavaClassImpl) javaClass).getPsi()); - } - @Override public void recordMethod(@NotNull JavaMethod method, @NotNull SimpleFunctionDescriptor descriptor) { BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, ((JavaMethodImpl) method).getPsi(), descriptor); diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt index 5de6bced1cf..d03b26c200d 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaClassMemberScope.kt @@ -231,15 +231,9 @@ public class LazyJavaClassMemberScope( else null } else { - // TODO: this caching is a temporary workaround, should be replaced with properly caching the whole LazyJavaPackageFragmentProvider - //TODO_R: remove this logic? - val alreadyResolved = c.javaResolverCache.getClass(jNestedClass) - if (alreadyResolved != null) - alreadyResolved - else LazyJavaClassDescriptor(c, - getContainingDeclaration(), - DescriptorUtils.getFqName(getContainingDeclaration()).child(name).toSafe(), - jNestedClass) + LazyJavaClassDescriptor( + c, getContainingDeclaration(), DescriptorUtils.getFqName(getContainingDeclaration()).child(name).toSafe(), jNestedClass + ) } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaPackageFragmentScope.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaPackageFragmentScope.kt index 694a001db5b..a4b067db6c0 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaPackageFragmentScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/descriptors/LazyJavaPackageFragmentScope.kt @@ -114,16 +114,10 @@ public class LazyPackageFragmentScopeForJavaPackage( else if (jClass == null) null else { - // TODO: this caching is a temporary workaround, should be replaced with properly caching the whole LazyJavaSubModule - val cached = c.javaResolverCache.getClass(jClass) - if (cached != null) - cached - else { - val classDescriptor = c.javaClassResolver.resolveClass(jClass) - assert(classDescriptor == null || classDescriptor.getContainingDeclaration() == packageFragment, - "Wrong package fragment for $classDescriptor, expected $packageFragment") - classDescriptor - } + val classDescriptor = c.javaClassResolver.resolveClass(jClass) + assert(classDescriptor == null || classDescriptor.getContainingDeclaration() == packageFragment, + "Wrong package fragment for $classDescriptor, expected $packageFragment") + classDescriptor } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/resolvers.kt b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/resolvers.kt index 19c1586394c..420fa53aa4d 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/resolvers.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/lazy/resolvers.kt @@ -75,12 +75,6 @@ fun LazyJavaResolverContext.lookupBinaryClass(javaClass: JavaClass): ClassDescri } fun LazyJavaResolverContext.findClassInJava(fqName: FqName): JavaClassLookupResult { - // TODO: this should be governed by module separation logic - // Do not look for JavaClasses for Kotlin binaries & built-ins - if (DescriptorResolverUtils.getKotlinBuiltinClassDescriptor(fqName) != null) { - return JavaClassLookupResult() - } - val kotlinClass = kotlinClassFinder.findKotlinClass(fqName) val binaryClassResult = resolveBinaryClass(kotlinClass) if (binaryClassResult != null) return binaryClassResult diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java index 5da167163b9..048bc4213de 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java @@ -287,22 +287,4 @@ public final class DescriptorResolverUtils { return false; } - - @Nullable - public static ClassDescriptor getKotlinBuiltinClassDescriptor(@NotNull FqName qualifiedName) { - if (!qualifiedName.firstSegmentIs(KotlinBuiltIns.BUILT_INS_PACKAGE_NAME)) return null; - - List segments = qualifiedName.pathSegments(); - if (segments.size() < 2) return null; - - JetScope scope = KotlinBuiltIns.getInstance().getBuiltInsPackageScope(); - for (int i = 1, size = segments.size(); i < size; i++) { - ClassifierDescriptor classifier = scope.getClassifier(segments.get(i)); - if (classifier == null) return null; - assert classifier instanceof ClassDescriptor : "Unexpected classifier in built-ins: " + classifier; - scope = ((ClassDescriptor) classifier).getUnsubstitutedInnerClassesScope(); - } - - return (ClassDescriptor) scope.getContainingDeclaration(); - } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaResolverCache.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaResolverCache.java index d500259a5e0..ab4c243997f 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaResolverCache.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaResolverCache.java @@ -18,7 +18,10 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor; +import org.jetbrains.jet.lang.descriptors.PropertyDescriptor; +import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.java.structure.JavaElement; import org.jetbrains.jet.lang.resolve.java.structure.JavaField; @@ -29,9 +32,6 @@ public interface JavaResolverCache { @Nullable ClassDescriptor getClassResolvedFromSource(@NotNull FqName fqName); - @Nullable - ClassDescriptor getClass(@NotNull JavaClass javaClass); - void recordMethod(@NotNull JavaMethod method, @NotNull SimpleFunctionDescriptor descriptor); void recordConstructor(@NotNull JavaElement element, @NotNull ConstructorDescriptor descriptor);