Create JavaResolverCache

An abstraction over BindingTrace which will be used in JDR
2013-08-07 17:58:51 +04:00
parent 760e4002cf
commit 480ef9ea66
11 changed files with 234 additions and 46 deletions
@@ -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);
@@ -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);
@@ -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);
-    }
 }
@@ -86,6 +86,7 @@ public final class JavaClassResolver {
    private final Set<FqNameBase> 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) {
@@ -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<ConstructorDescriptor> adapter = createSamAdapterConstructor(original);
-        DescriptorResolverUtils.recordSourceDescriptorForSynthesized(adapter, original, trace);
+        cache.recordSourceDescriptorForSynthesized(adapter, original);
        return (ConstructorDescriptor) adapter;
    }
 }
@@ -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<SimpleFunctionDescriptor> adapter = createSamAdapterFunction(original);
-        DescriptorResolverUtils.recordSourceDescriptorForSynthesized(adapter, original, trace);
+        cache.recordSourceDescriptorForSynthesized(adapter, original);
        return (SimpleFunctionDescriptor) adapter;
    }

@@ -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);
@@ -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;
    }

@@ -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);
+}
@@ -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);
+    }
+}