From 480ef9ea66088a241c5a7d06456f63a3285fcc3e Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 7 Aug 2013 17:58:51 +0400 Subject: [PATCH] Create JavaResolverCache An abstraction over BindingTrace which will be used in JDR --- .../di/InjectorForJavaDescriptorResolver.java | 11 +- .../di/InjectorForTopDownAnalyzerForJvm.java | 11 +- .../resolve/java/DescriptorResolverUtils.java | 9 -- .../java/resolver/JavaClassResolver.java | 10 +- .../resolver/JavaConstructorResolver.java | 19 ++- .../java/resolver/JavaFunctionResolver.java | 18 +-- .../java/resolver/JavaNamespaceResolver.java | 14 ++- .../java/resolver/JavaPropertyResolver.java | 18 ++- .../java/resolver/JavaResolverCache.java | 52 ++++++++ .../resolver/TraceBasedJavaResolverCache.java | 115 ++++++++++++++++++ .../injectors/GenerateInjectors.java | 3 + 11 files changed, 234 insertions(+), 46 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaResolverCache.java create mode 100644 compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.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 f4c64524a09..d6963490734 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -20,6 +20,7 @@ import com.intellij.openapi.project.Project; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedJavaResolverCache; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder; @@ -46,6 +47,7 @@ public class InjectorForJavaDescriptorResolver { private final BindingTrace bindingTrace; private final JavaClassFinderImpl javaClassFinder; private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver; + private final TraceBasedJavaResolverCache traceBasedJavaResolverCache; private final JavaDescriptorResolver javaDescriptorResolver; private final PsiClassFinderImpl psiClassFinder; private final VirtualFileFinder virtualFileFinder; @@ -71,6 +73,7 @@ public class InjectorForJavaDescriptorResolver { this.bindingTrace = bindingTrace; this.javaClassFinder = new JavaClassFinderImpl(); this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver(); + this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache(); this.javaDescriptorResolver = new JavaDescriptorResolver(); this.psiClassFinder = new PsiClassFinderImpl(); this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class); @@ -92,6 +95,8 @@ public class InjectorForJavaDescriptorResolver { traceBasedExternalSignatureResolver.setTrace(bindingTrace); + traceBasedJavaResolverCache.setTrace(bindingTrace); + this.javaDescriptorResolver.setClassResolver(javaClassResolver); this.javaDescriptorResolver.setConstructorResolver(javaConstructorResolver); this.javaDescriptorResolver.setFunctionResolver(javaFunctionResolver); @@ -101,6 +106,7 @@ public class InjectorForJavaDescriptorResolver { this.psiClassFinder.setProject(project); javaClassResolver.setAnnotationResolver(javaAnnotationResolver); + javaClassResolver.setCache(traceBasedJavaResolverCache); javaClassResolver.setFunctionResolver(javaFunctionResolver); javaClassResolver.setJavaClassFinder(javaClassFinder); javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver); @@ -118,6 +124,7 @@ public class InjectorForJavaDescriptorResolver { javaAnnotationArgumentResolver.setClassResolver(javaClassResolver); javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver); + javaFunctionResolver.setCache(traceBasedJavaResolverCache); javaFunctionResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver); javaFunctionResolver.setTrace(bindingTrace); javaFunctionResolver.setTypeParameterResolver(javaTypeParameterResolver); @@ -138,6 +145,7 @@ public class InjectorForJavaDescriptorResolver { annotationDescriptorDeserializer.setPsiClassFinder(psiClassFinder); annotationDescriptorDeserializer.setVirtualFileFinder(virtualFileFinder); + javaNamespaceResolver.setCache(traceBasedJavaResolverCache); javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver); javaNamespaceResolver.setJavaClassFinder(javaClassFinder); javaNamespaceResolver.setJavaDescriptorResolver(javaDescriptorResolver); @@ -148,12 +156,13 @@ public class InjectorForJavaDescriptorResolver { javaSupertypeResolver.setTrace(bindingTrace); javaSupertypeResolver.setTypeTransformer(javaTypeTransformer); + javaConstructorResolver.setCache(traceBasedJavaResolverCache); javaConstructorResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver); - javaConstructorResolver.setTrace(bindingTrace); javaConstructorResolver.setTypeTransformer(javaTypeTransformer); javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver); javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver); + javaPropertyResolver.setCache(traceBasedJavaResolverCache); javaPropertyResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver); javaPropertyResolver.setTrace(bindingTrace); javaPropertyResolver.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 7b357d85d01..117a91a3993 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -32,6 +32,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedJavaResolverCache; import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder; import org.jetbrains.jet.lang.resolve.DeclarationResolver; @@ -85,6 +86,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final PsiClassFinderImpl psiClassFinder; private final JavaClassFinderImpl javaClassFinder; private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver; + private final TraceBasedJavaResolverCache traceBasedJavaResolverCache; private final NamespaceFactoryImpl namespaceFactory; private final VirtualFileFinder virtualFileFinder; private final DeclarationResolver declarationResolver; @@ -139,6 +141,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.psiClassFinder = new PsiClassFinderImpl(); this.javaClassFinder = new JavaClassFinderImpl(); this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver(); + this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache(); this.namespaceFactory = new NamespaceFactoryImpl(); this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class); this.declarationResolver = new DeclarationResolver(); @@ -218,6 +221,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly traceBasedExternalSignatureResolver.setTrace(bindingTrace); + traceBasedJavaResolverCache.setTrace(bindingTrace); + this.namespaceFactory.setModuleDescriptor(moduleDescriptor); this.namespaceFactory.setTrace(bindingTrace); @@ -288,6 +293,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly scriptBodyResolver.setTrace(bindingTrace); javaClassResolver.setAnnotationResolver(javaAnnotationResolver); + javaClassResolver.setCache(traceBasedJavaResolverCache); javaClassResolver.setFunctionResolver(javaFunctionResolver); javaClassResolver.setJavaClassFinder(javaClassFinder); javaClassResolver.setJavaDescriptorResolver(javaDescriptorResolver); @@ -305,6 +311,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaAnnotationArgumentResolver.setClassResolver(javaClassResolver); javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver); + javaFunctionResolver.setCache(traceBasedJavaResolverCache); javaFunctionResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver); javaFunctionResolver.setTrace(bindingTrace); javaFunctionResolver.setTypeParameterResolver(javaTypeParameterResolver); @@ -325,6 +332,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly annotationDescriptorDeserializer.setPsiClassFinder(psiClassFinder); annotationDescriptorDeserializer.setVirtualFileFinder(virtualFileFinder); + javaNamespaceResolver.setCache(traceBasedJavaResolverCache); javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver); javaNamespaceResolver.setJavaClassFinder(javaClassFinder); javaNamespaceResolver.setJavaDescriptorResolver(javaDescriptorResolver); @@ -335,12 +343,13 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaSupertypeResolver.setTrace(bindingTrace); javaSupertypeResolver.setTypeTransformer(javaTypeTransformer); + javaConstructorResolver.setCache(traceBasedJavaResolverCache); javaConstructorResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver); - javaConstructorResolver.setTrace(bindingTrace); javaConstructorResolver.setTypeTransformer(javaTypeTransformer); javaConstructorResolver.setValueParameterResolver(javaValueParameterResolver); javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver); + javaPropertyResolver.setCache(traceBasedJavaResolverCache); javaPropertyResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver); javaPropertyResolver.setTrace(bindingTrace); javaPropertyResolver.setTypeTransformer(javaTypeTransformer); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java index d2dd9b2d992..2fa892c8296 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java @@ -24,7 +24,6 @@ import com.intellij.psi.util.PsiFormatUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.OverrideResolver; import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; @@ -161,12 +160,4 @@ public final class DescriptorResolverUtils { return result; } - - public static void recordSourceDescriptorForSynthesized( - @NotNull FunctionDescriptor synthesized, - @NotNull DeclarationDescriptor original, - @NotNull BindingTrace trace - ) { - trace.record(BindingContext.SOURCE_DESCRIPTOR_FOR_SYNTHESIZED, synthesized, original); - } } 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 7e5532689ec..fd11b886bdb 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 @@ -86,6 +86,7 @@ public final class JavaClassResolver { private final Set unresolvedCache = Sets.newHashSet(); private BindingTrace trace; + private JavaResolverCache cache; private JavaTypeParameterResolver typeParameterResolver; private JavaDescriptorResolver javaDescriptorResolver; private JavaAnnotationResolver annotationResolver; @@ -109,6 +110,11 @@ public final class JavaClassResolver { this.trace = trace; } + @Inject + public void setCache(JavaResolverCache cache) { + this.cache = cache; + } + @Inject public void setKotlinDescriptorResolver(DeserializedDescriptorResolver kotlinDescriptorResolver) { this.kotlinDescriptorResolver = kotlinDescriptorResolver; @@ -252,7 +258,7 @@ public final class JavaClassResolver { } // Class may have been resolved previously by different Java resolver instance, and we are reusing its trace - ClassDescriptor alreadyResolved = trace.get(BindingContext.CLASS, javaClass.getPsi()); + ClassDescriptor alreadyResolved = cache.getClass(javaClass); if (alreadyResolved != null) { return alreadyResolved; } @@ -327,7 +333,7 @@ public final class JavaClassResolver { classDescriptor.setAnnotations(annotationResolver.resolveAnnotations(javaClass, taskList)); - trace.record(BindingContext.CLASS, javaClass.getPsi(), classDescriptor); + cache.recordClass(javaClass, classDescriptor); JavaMethod samInterfaceMethod = SingleAbstractMethodUtils.getSamInterfaceMethod(javaClass); if (samInterfaceMethod != null) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java index ad4c127caca..989b4254eaa 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java @@ -24,10 +24,7 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.ConstructorDescriptorImpl; import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorResolver; -import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; import org.jetbrains.jet.lang.resolve.java.JavaVisibilities; import org.jetbrains.jet.lang.resolve.java.descriptor.SamAdapterDescriptor; import org.jetbrains.jet.lang.resolve.java.structure.JavaArrayType; @@ -46,7 +43,7 @@ import static org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils. import static org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils.isSamAdapterNecessary; public final class JavaConstructorResolver { - private BindingTrace trace; + private JavaResolverCache cache; private JavaTypeTransformer typeTransformer; private JavaValueParameterResolver valueParameterResolver; private ExternalSignatureResolver externalSignatureResolver; @@ -55,8 +52,8 @@ public final class JavaConstructorResolver { } @Inject - public void setTrace(BindingTrace trace) { - this.trace = trace; + public void setCache(JavaResolverCache cache) { + this.cache = cache; } @Inject @@ -103,7 +100,7 @@ public final class JavaConstructorResolver { @Nullable private ConstructorDescriptor resolveDefaultConstructor(@NotNull JavaClass javaClass, @NotNull ClassDescriptor containingClass) { - ConstructorDescriptor alreadyResolved = trace.get(BindingContext.CONSTRUCTOR, javaClass.getPsi()); + ConstructorDescriptor alreadyResolved = cache.getConstructor(javaClass); if (alreadyResolved != null) { return alreadyResolved; } @@ -130,7 +127,7 @@ public final class JavaConstructorResolver { constructorDescriptor.initialize(typeParameters, valueParameters, getConstructorVisibility(containingClass), javaClass.isStatic()); - trace.record(BindingContext.CONSTRUCTOR, javaClass.getPsi(), constructorDescriptor); + cache.recordConstructor(javaClass, constructorDescriptor); return constructorDescriptor; } @@ -190,7 +187,7 @@ public final class JavaConstructorResolver { @NotNull ClassDescriptor classDescriptor, boolean isStaticClass ) { - ConstructorDescriptor alreadyResolved = trace.get(BindingContext.CONSTRUCTOR, constructor.getPsi()); + ConstructorDescriptor alreadyResolved = cache.getConstructor(constructor); if (alreadyResolved != null) { return alreadyResolved; } @@ -219,7 +216,7 @@ public final class JavaConstructorResolver { externalSignatureResolver.reportSignatureErrors(constructorDescriptor, signatureErrors); } - trace.record(BindingContext.CONSTRUCTOR, constructor.getPsi(), constructorDescriptor); + cache.recordConstructor(constructor, constructorDescriptor); return constructorDescriptor; } @@ -228,7 +225,7 @@ public final class JavaConstructorResolver { if (!isSamAdapterNecessary(original)) return null; SamAdapterDescriptor adapter = createSamAdapterConstructor(original); - DescriptorResolverUtils.recordSourceDescriptorForSynthesized(adapter, original, trace); + cache.recordSourceDescriptorForSynthesized(adapter, original); return (ConstructorDescriptor) adapter; } } \ No newline at end of file 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 6efd83484cf..18d890a92eb 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 @@ -26,8 +26,6 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent; import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; @@ -58,6 +56,7 @@ public final class JavaFunctionResolver { private JavaTypeTransformer typeTransformer; private BindingTrace trace; + private JavaResolverCache cache; private JavaTypeParameterResolver typeParameterResolver; private JavaValueParameterResolver valueParameterResolver; private JavaAnnotationResolver annotationResolver; @@ -73,6 +72,11 @@ public final class JavaFunctionResolver { this.trace = trace; } + @Inject + public void setCache(JavaResolverCache cache) { + this.cache = cache; + } + @Inject public void setTypeParameterResolver(JavaTypeParameterResolver typeParameterResolver) { this.typeParameterResolver = typeParameterResolver; @@ -114,7 +118,7 @@ public final class JavaFunctionResolver { return null; } - SimpleFunctionDescriptor alreadyResolved = trace.get(BindingContext.FUNCTION, method.getPsi()); + SimpleFunctionDescriptor alreadyResolved = cache.getMethod(method); if (alreadyResolved != null) { return alreadyResolved; } @@ -176,8 +180,8 @@ public final class JavaFunctionResolver { /*isInline = */ false ); - if (functionDescriptorImpl.getKind() == CallableMemberDescriptor.Kind.DECLARATION && record) { - BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, method.getPsi(), functionDescriptorImpl); + if (record) { + cache.recordMethod(method, functionDescriptorImpl); } if (!RawTypesCheck.hasRawTypesInHierarchicalSignature(method) @@ -316,7 +320,7 @@ public final class JavaFunctionResolver { ClassDescriptorFromJvmBytecode klass = findClassInNamespace(owner, namedMembers.getName()); if (klass != null) { SamConstructorDescriptor constructor = createSamConstructorFunction(owner, klass); - DescriptorResolverUtils.recordSourceDescriptorForSynthesized(constructor, klass, trace); + cache.recordSourceDescriptorForSynthesized(constructor, klass); return constructor; } } @@ -328,7 +332,7 @@ public final class JavaFunctionResolver { if (!isSamAdapterNecessary(original)) return null; SamAdapterDescriptor adapter = createSamAdapterFunction(original); - DescriptorResolverUtils.recordSourceDescriptorForSynthesized(adapter, original, trace); + cache.recordSourceDescriptorForSynthesized(adapter, original); return (SimpleFunctionDescriptor) adapter; } 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 134b1c3ea55..5fc24e9689a 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 @@ -62,6 +62,7 @@ public final class JavaNamespaceResolver { private JavaClassFinder javaClassFinder; private BindingTrace trace; + private JavaResolverCache cache; private JavaDescriptorResolver javaDescriptorResolver; private DeserializedDescriptorResolver deserializedDescriptorResolver; @@ -82,6 +83,11 @@ public final class JavaNamespaceResolver { this.trace = trace; } + @Inject + public void setCache(JavaResolverCache cache) { + this.cache = cache; + } + @Inject public void setJavaDescriptorResolver(@NotNull JavaDescriptorResolver javaDescriptorResolver) { this.javaDescriptorResolver = javaDescriptorResolver; @@ -157,7 +163,7 @@ public final class JavaNamespaceResolver { FqName packageClassFqName = PackageClassUtils.getPackageClassFqName(fqName); VirtualFile virtualFile = virtualFileFinder.find(packageClassFqName); - trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, namespaceDescriptor, JavaNamespaceKind.PROPER); + cache.recordProperNamespace(namespaceDescriptor); if (virtualFile != null) { ErrorReporter errorReporter = AbiVersionUtil.abiVersionErrorReporter(virtualFile, packageClassFqName, trace); @@ -171,7 +177,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 if (record) { - trace.record(BindingContext.NAMESPACE, javaPackage.getPsi(), namespaceDescriptor); + cache.recordPackage(javaPackage, namespaceDescriptor); } return new JavaPackageScope(namespaceDescriptor, javaPackage, fqName, javaDescriptorResolver); @@ -189,10 +195,10 @@ public final class JavaNamespaceResolver { return null; } - trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, namespaceDescriptor, JavaNamespaceKind.CLASS_STATICS); + cache.recordClassStaticMembersNamespace(namespaceDescriptor); if (record) { - trace.record(BindingContext.NAMESPACE, javaClass.getPsi(), namespaceDescriptor); + cache.recordPackage(javaClass, namespaceDescriptor); } return new JavaClassStaticMembersScope(namespaceDescriptor, fqName, javaClass, javaDescriptorResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java index 64e8e8fcd1a..8b6ad92f225 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java @@ -47,6 +47,7 @@ import static org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils.resolv public final class JavaPropertyResolver { private JavaTypeTransformer typeTransformer; private BindingTrace trace; + private JavaResolverCache cache; private JavaAnnotationResolver annotationResolver; private ExternalSignatureResolver externalSignatureResolver; @@ -63,6 +64,11 @@ public final class JavaPropertyResolver { this.trace = trace; } + @Inject + public void setCache(JavaResolverCache cache) { + this.cache = cache; + } + @Inject public void setAnnotationResolver(JavaAnnotationResolver annotationResolver) { this.annotationResolver = annotationResolver; @@ -128,18 +134,8 @@ public final class JavaPropertyResolver { (JetType) null ); - trace.record(BindingContext.VARIABLE, field.getPsi(), propertyDescriptor); + cache.recordField(field, propertyDescriptor); - if (AnnotationUtils.isPropertyAcceptableAsAnnotationParameter(propertyDescriptor)) { - PsiExpression initializer = field.getPsi().getInitializer(); - if (initializer instanceof PsiLiteralExpression) { - CompileTimeConstant constant = JavaAnnotationArgumentResolver - .resolveCompileTimeConstantValue(((PsiLiteralExpression) initializer).getValue(), propertyType); - if (constant != null) { - trace.record(BindingContext.COMPILE_TIME_INITIALIZER, propertyDescriptor, constant); - } - } - } return propertyDescriptor; } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaResolverCache.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaResolverCache.java new file mode 100644 index 00000000000..d4a6d6808e2 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaResolverCache.java @@ -0,0 +1,52 @@ +/* + * 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.resolver; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.*; +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; +import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; + +public interface JavaResolverCache { + void recordSourceDescriptorForSynthesized(@NotNull FunctionDescriptor synthesized, @NotNull DeclarationDescriptor source); + + @Nullable + SimpleFunctionDescriptor getMethod(@NotNull JavaMethod method); + + @Nullable + ConstructorDescriptor getConstructor(@NotNull JavaElement constructor); + + @Nullable + ClassDescriptor getClass(@NotNull JavaClass javaClass); + + void recordMethod(@NotNull JavaMethod method, @NotNull SimpleFunctionDescriptor descriptor); + + void recordConstructor(@NotNull JavaElement element, @NotNull ConstructorDescriptor descriptor); + + void recordField(@NotNull JavaField field, @NotNull PropertyDescriptor descriptor); + + void recordClass(@NotNull JavaClass javaClass, @NotNull ClassDescriptor descriptor); + + void recordProperNamespace(@NotNull NamespaceDescriptor descriptor); + + void recordClassStaticMembersNamespace(@NotNull NamespaceDescriptor descriptor); + + void recordPackage(@NotNull JavaElement element, @NotNull NamespaceDescriptor 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 new file mode 100644 index 00000000000..08cd3d646c5 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java @@ -0,0 +1,115 @@ +/* + * 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.resolver; + +import com.intellij.psi.PsiExpression; +import com.intellij.psi.PsiLiteralExpression; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.resolve.AnnotationUtils; +import org.jetbrains.jet.lang.resolve.BindingContextUtils; +import org.jetbrains.jet.lang.resolve.BindingTrace; +import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; +import org.jetbrains.jet.lang.resolve.java.JavaBindingContext; +import org.jetbrains.jet.lang.resolve.java.JavaNamespaceKind; +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; +import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; + +import javax.inject.Inject; + +import static org.jetbrains.jet.lang.resolve.BindingContext.*; + +public class TraceBasedJavaResolverCache implements JavaResolverCache { + private BindingTrace trace; + + @Inject + public void setTrace(BindingTrace trace) { + this.trace = trace; + } + + @Override + public void recordSourceDescriptorForSynthesized(@NotNull FunctionDescriptor synthesized, @NotNull DeclarationDescriptor source) { + trace.record(SOURCE_DESCRIPTOR_FOR_SYNTHESIZED, synthesized, source); + } + + @Nullable + @Override + public SimpleFunctionDescriptor getMethod(@NotNull JavaMethod method) { + return trace.get(FUNCTION, method.getPsi()); + } + + @Nullable + @Override + public ConstructorDescriptor getConstructor(@NotNull JavaElement constructor) { + return trace.get(CONSTRUCTOR, constructor.getPsi()); + } + + @Nullable + @Override + public ClassDescriptor getClass(@NotNull JavaClass javaClass) { + return trace.get(CLASS, javaClass.getPsi()); + } + + @Override + public void recordMethod(@NotNull JavaMethod method, @NotNull SimpleFunctionDescriptor descriptor) { + BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, method.getPsi(), descriptor); + } + + @Override + public void recordConstructor(@NotNull JavaElement element, @NotNull ConstructorDescriptor descriptor) { + trace.record(CONSTRUCTOR, element.getPsi(), descriptor); + } + + @Override + public void recordField(@NotNull JavaField field, @NotNull PropertyDescriptor descriptor) { + trace.record(VARIABLE, field.getPsi(), descriptor); + + if (AnnotationUtils.isPropertyAcceptableAsAnnotationParameter(descriptor)) { + PsiExpression initializer = field.getPsi().getInitializer(); + if (initializer instanceof PsiLiteralExpression) { + CompileTimeConstant constant = JavaAnnotationArgumentResolver + .resolveCompileTimeConstantValue(((PsiLiteralExpression) initializer).getValue(), descriptor.getType()); + if (constant != null) { + trace.record(COMPILE_TIME_INITIALIZER, descriptor, constant); + } + } + } + } + + @Override + public void recordClass(@NotNull JavaClass javaClass, @NotNull ClassDescriptor descriptor) { + trace.record(CLASS, javaClass.getPsi(), descriptor); + } + + @Override + public void recordProperNamespace(@NotNull NamespaceDescriptor descriptor) { + trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, descriptor, JavaNamespaceKind.PROPER); + } + + @Override + public void recordClassStaticMembersNamespace(@NotNull NamespaceDescriptor descriptor) { + trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, descriptor, JavaNamespaceKind.CLASS_STATICS); + } + + @Override + public void recordPackage(@NotNull JavaElement element, @NotNull NamespaceDescriptor descriptor) { + trace.record(NAMESPACE, element.getPsi(), descriptor); + } +} diff --git a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java b/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java index 6a8fefd997c..ed241e12bc7 100644 --- a/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java +++ b/generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java @@ -38,6 +38,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.PsiClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedJavaResolverCache; import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider; @@ -107,6 +108,7 @@ public class GenerateInjectors { generator.addField(PsiClassFinderImpl.class); generator.addField(JavaClassFinderImpl.class); generator.addField(TraceBasedExternalSignatureResolver.class); + generator.addField(TraceBasedJavaResolverCache.class); generator.addPublicField(NamespaceFactoryImpl.class); generator.addField(false, VirtualFileFinder.class, "virtualFileFinder", new GivenExpression( @@ -125,6 +127,7 @@ public class GenerateInjectors { // Fields generator.addField(JavaClassFinderImpl.class); generator.addField(TraceBasedExternalSignatureResolver.class); + generator.addField(TraceBasedJavaResolverCache.class); generator.addPublicField(JavaDescriptorResolver.class); generator.addPublicField(PsiClassFinderImpl.class); generator.addField(false, VirtualFileFinder.class, "virtualFileFinder",