Create JavaResolverCache

An abstraction over BindingTrace which will be used in JDR

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

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

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

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java

@@ -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) {

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) {
+    public void setCache(JavaResolverCache cache) {
-        this.trace = trace;
+        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;
     }
 }

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) {
+        if (record) {
-            BindingContextUtils.recordFunctionDeclarationToDescriptor(trace, method.getPsi(), functionDescriptorImpl);
+            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;
     }
 

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

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

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

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

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",