Remove BindingTrace from Java function and property resolvers

Extract FakeOverrideVisibilityResolver which invokes OverrideResolver with the
trace

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java

@@ -21,6 +21,7 @@ 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.resolver.FakeOverrideVisibilityResolverImpl;
 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;
@@ -48,6 +49,7 @@ public class InjectorForJavaDescriptorResolver {
     private final JavaClassFinderImpl javaClassFinder;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
     private final TraceBasedJavaResolverCache traceBasedJavaResolverCache;
+    private final FakeOverrideVisibilityResolverImpl fakeOverrideVisibilityResolver;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final PsiClassFinderImpl psiClassFinder;
     private final VirtualFileFinder virtualFileFinder;
@@ -74,6 +76,7 @@ public class InjectorForJavaDescriptorResolver {
         this.javaClassFinder = new JavaClassFinderImpl();
         this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
         this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
+        this.fakeOverrideVisibilityResolver = new FakeOverrideVisibilityResolverImpl();
         this.javaDescriptorResolver = new JavaDescriptorResolver();
         this.psiClassFinder = new PsiClassFinderImpl();
         this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class);
@@ -97,6 +100,8 @@ public class InjectorForJavaDescriptorResolver {
 
         traceBasedJavaResolverCache.setTrace(bindingTrace);
 
+        fakeOverrideVisibilityResolver.setTrace(bindingTrace);
+
         this.javaDescriptorResolver.setClassResolver(javaClassResolver);
         this.javaDescriptorResolver.setConstructorResolver(javaConstructorResolver);
         this.javaDescriptorResolver.setFunctionResolver(javaFunctionResolver);
@@ -126,7 +131,7 @@ public class InjectorForJavaDescriptorResolver {
         javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
         javaFunctionResolver.setCache(traceBasedJavaResolverCache);
         javaFunctionResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
-        javaFunctionResolver.setTrace(bindingTrace);
+        javaFunctionResolver.setFakeOverrideVisibilityResolver(fakeOverrideVisibilityResolver);
         javaFunctionResolver.setTypeParameterResolver(javaTypeParameterResolver);
         javaFunctionResolver.setTypeTransformer(javaTypeTransformer);
         javaFunctionResolver.setValueParameterResolver(javaValueParameterResolver);
@@ -164,7 +169,7 @@ public class InjectorForJavaDescriptorResolver {
         javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver);
         javaPropertyResolver.setCache(traceBasedJavaResolverCache);
         javaPropertyResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
-        javaPropertyResolver.setTrace(bindingTrace);
+        javaPropertyResolver.setFakeOverrideVisibilityResolver(fakeOverrideVisibilityResolver);
         javaPropertyResolver.setTypeTransformer(javaTypeTransformer);
 
         psiClassFinder.initialize();

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -33,6 +33,7 @@ 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.java.resolver.FakeOverrideVisibilityResolverImpl;
 import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl;
 import org.jetbrains.jet.lang.resolve.java.vfilefinder.VirtualFileFinder;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
@@ -87,6 +88,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final JavaClassFinderImpl javaClassFinder;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
     private final TraceBasedJavaResolverCache traceBasedJavaResolverCache;
+    private final FakeOverrideVisibilityResolverImpl fakeOverrideVisibilityResolver;
     private final NamespaceFactoryImpl namespaceFactory;
     private final VirtualFileFinder virtualFileFinder;
     private final DeclarationResolver declarationResolver;
@@ -142,6 +144,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.javaClassFinder = new JavaClassFinderImpl();
         this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
         this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
+        this.fakeOverrideVisibilityResolver = new FakeOverrideVisibilityResolverImpl();
         this.namespaceFactory = new NamespaceFactoryImpl();
         this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class);
         this.declarationResolver = new DeclarationResolver();
@@ -223,6 +226,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         traceBasedJavaResolverCache.setTrace(bindingTrace);
 
+        fakeOverrideVisibilityResolver.setTrace(bindingTrace);
+
         this.namespaceFactory.setModuleDescriptor(moduleDescriptor);
         this.namespaceFactory.setTrace(bindingTrace);
 
@@ -313,7 +318,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
         javaFunctionResolver.setCache(traceBasedJavaResolverCache);
         javaFunctionResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
-        javaFunctionResolver.setTrace(bindingTrace);
+        javaFunctionResolver.setFakeOverrideVisibilityResolver(fakeOverrideVisibilityResolver);
         javaFunctionResolver.setTypeParameterResolver(javaTypeParameterResolver);
         javaFunctionResolver.setTypeTransformer(javaTypeTransformer);
         javaFunctionResolver.setValueParameterResolver(javaValueParameterResolver);
@@ -351,7 +356,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver);
         javaPropertyResolver.setCache(traceBasedJavaResolverCache);
         javaPropertyResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
-        javaPropertyResolver.setTrace(bindingTrace);
+        javaPropertyResolver.setFakeOverrideVisibilityResolver(fakeOverrideVisibilityResolver);
         javaPropertyResolver.setTypeTransformer(javaTypeTransformer);
 
         psiClassFinder.initialize();

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java

@@ -24,8 +24,8 @@ 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.BindingTrace;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
+import org.jetbrains.jet.lang.resolve.java.resolver.FakeOverrideVisibilityResolver;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaField;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaMember;
@@ -76,7 +76,7 @@ public final class DescriptorResolverUtils {
             @NotNull Collection<D> membersFromSupertypes,
             @NotNull Collection<D> membersFromCurrent,
             @NotNull ClassDescriptor classDescriptor,
-            @NotNull BindingTrace trace
+            @NotNull final FakeOverrideVisibilityResolver visibilityResolver
     ) {
         final Set<D> result = new HashSet<D>();
 
@@ -86,6 +86,7 @@ public final class DescriptorResolverUtils {
                     @Override
                     @SuppressWarnings("unchecked")
                     public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
+                        visibilityResolver.resolveUnknownVisibilityForMember(fakeOverride);
                         result.add((D) fakeOverride);
                     }
 
@@ -96,8 +97,6 @@ public final class DescriptorResolverUtils {
                 }
         );
 
-        OverrideResolver.resolveUnknownVisibilities(result, trace);
-
         return result;
     }
 

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

@@ -0,0 +1,24 @@
+/*
+ * 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.jet.lang.descriptors.CallableMemberDescriptor;
+
+public interface FakeOverrideVisibilityResolver {
+    void resolveUnknownVisibilityForMember(@NotNull CallableMemberDescriptor descriptor);
+}

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

@@ -0,0 +1,22 @@
+package org.jetbrains.jet.lang.resolve.java.resolver;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.OverrideResolver;
+
+import javax.inject.Inject;
+
+public class FakeOverrideVisibilityResolverImpl implements FakeOverrideVisibilityResolver {
+    private BindingTrace trace;
+
+    @Inject
+    public void setTrace(BindingTrace trace) {
+        this.trace = trace;
+    }
+
+    @Override
+    public void resolveUnknownVisibilityForMember(@NotNull CallableMemberDescriptor descriptor) {
+        OverrideResolver.resolveUnknownVisibilityForMember(null, descriptor, trace);
+    }
+}

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

@@ -26,7 +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.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 import org.jetbrains.jet.lang.resolve.java.TypeUsage;
@@ -55,23 +54,18 @@ public final class JavaFunctionResolver {
     private static final Logger LOG = Logger.getInstance(JavaFunctionResolver.class);
 
     private JavaTypeTransformer typeTransformer;
-    private BindingTrace trace;
     private JavaResolverCache cache;
     private JavaTypeParameterResolver typeParameterResolver;
     private JavaValueParameterResolver valueParameterResolver;
     private JavaAnnotationResolver annotationResolver;
     private ExternalSignatureResolver externalSignatureResolver;
+    private FakeOverrideVisibilityResolver fakeOverrideVisibilityResolver;
 
     @Inject
     public void setTypeTransformer(JavaTypeTransformer typeTransformer) {
         this.typeTransformer = typeTransformer;
     }
 
-    @Inject
-    public void setTrace(BindingTrace trace) {
-        this.trace = trace;
-    }
-
     @Inject
     public void setCache(JavaResolverCache cache) {
         this.cache = cache;
@@ -97,6 +91,11 @@ public final class JavaFunctionResolver {
         this.externalSignatureResolver = externalSignatureResolver;
     }
 
+    @Inject
+    public void setFakeOverrideVisibilityResolver(FakeOverrideVisibilityResolver fakeOverrideVisibilityResolver) {
+        this.fakeOverrideVisibilityResolver = fakeOverrideVisibilityResolver;
+    }
+
     @Nullable
     SimpleFunctionDescriptor resolveFunctionMutely(@NotNull JavaMethod method, @NotNull ClassOrNamespaceDescriptor owner) {
         return resolveMethodToFunctionDescriptor(method, owner, false);
@@ -259,7 +258,8 @@ public final class JavaFunctionResolver {
 
             Collection<SimpleFunctionDescriptor> functionsFromSupertypes = getFunctionsFromSupertypes(methodName, classDescriptor);
 
-            functions.addAll(resolveOverrides(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor, trace));
+            functions.addAll(resolveOverrides(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor,
+                                              fakeOverrideVisibilityResolver));
         }
 
         if (isEnumClassObject(owner)) {

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

@@ -17,18 +17,12 @@
 package org.jetbrains.jet.lang.resolve.java.resolver;
 
 import com.google.common.collect.Sets;
-import com.intellij.psi.PsiExpression;
-import com.intellij.psi.PsiLiteralExpression;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ClassDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorImpl;
-import org.jetbrains.jet.lang.resolve.AnnotationUtils;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPropertyDescriptor;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPropertyDescriptorForObject;
@@ -46,10 +40,10 @@ 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;
+    private FakeOverrideVisibilityResolver fakeOverrideVisibilityResolver;
 
     public JavaPropertyResolver() {
     }
@@ -59,11 +53,6 @@ public final class JavaPropertyResolver {
         this.typeTransformer = javaTypeTransformer;
     }
 
-    @Inject
-    public void setTrace(BindingTrace trace) {
-        this.trace = trace;
-    }
-
     @Inject
     public void setCache(JavaResolverCache cache) {
         this.cache = cache;
@@ -79,6 +68,11 @@ public final class JavaPropertyResolver {
         this.externalSignatureResolver = externalSignatureResolver;
     }
 
+    @Inject
+    public void setFakeOverrideVisibilityResolver(FakeOverrideVisibilityResolver fakeOverrideVisibilityResolver) {
+        this.fakeOverrideVisibilityResolver = fakeOverrideVisibilityResolver;
+    }
+
     @NotNull
     public Set<VariableDescriptor> resolveFieldGroup(@NotNull NamedMembers members, @NotNull ClassOrNamespaceDescriptor owner) {
         Name propertyName = members.getName();
@@ -100,7 +94,8 @@ public final class JavaPropertyResolver {
 
             Collection<PropertyDescriptor> propertiesFromSupertypes = getPropertiesFromSupertypes(propertyName, classDescriptor);
 
-            properties.addAll(resolveOverrides(propertyName, propertiesFromSupertypes, propertiesFromCurrent, classDescriptor, trace));
+            properties.addAll(resolveOverrides(propertyName, propertiesFromSupertypes, propertiesFromCurrent, classDescriptor,
+                                               fakeOverrideVisibilityResolver));
         }
 
         properties.addAll(propertiesFromCurrent);

compiler/testData/loadJava/compiledJava/OverrideMethod.java

@@ -0,0 +1,24 @@
+package test;
+
+public class OverrideMethod {
+    class SuperBase {
+        void quux(int x) {}
+    }
+
+    class Base extends SuperBase {
+        String foo(String s) {
+            return s;
+        }
+
+        void bar() {}
+    }
+
+    class Derived extends Base {
+        @Override
+        String foo(String s) {
+            return null;
+        }
+
+        void baz() {}
+    }
+}

compiler/testData/loadJava/compiledJava/OverrideMethod.txt

@@ -0,0 +1,25 @@
+package test
+
+public open class OverrideMethod : java.lang.Object {
+    public constructor OverrideMethod()
+    
+    public/*package*/ open inner class Base : test.OverrideMethod.SuperBase {
+        public/*package*/ constructor Base()
+        public/*package*/ open fun bar(): jet.Unit
+        public/*package*/ open fun foo(/*0*/ p0: jet.String?): jet.String?
+        internal open override /*1*/ /*fake_override*/ fun quux(/*0*/ p0: jet.Int): jet.Unit
+    }
+    
+    public/*package*/ open inner class Derived : test.OverrideMethod.Base {
+        public/*package*/ constructor Derived()
+        internal open override /*1*/ /*fake_override*/ fun bar(): jet.Unit
+        public/*package*/ open fun baz(): jet.Unit
+        public/*package*/ open override /*1*/ fun foo(/*0*/ p0: jet.String?): jet.String?
+        internal open override /*1*/ /*fake_override*/ fun quux(/*0*/ p0: jet.Int): jet.Unit
+    }
+    
+    public/*package*/ open inner class SuperBase : java.lang.Object {
+        public/*package*/ constructor SuperBase()
+        public/*package*/ open fun quux(/*0*/ p0: jet.Int): jet.Unit
+    }
+}

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaTestGenerated.java

@@ -1039,6 +1039,11 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest {
             doTestCompiledJava("compiler/testData/loadJava/compiledJava/JavaEnum.java");
         }
         
+        @TestMetadata("OverrideMethod.java")
+        public void testOverrideMethod() throws Exception {
+            doTestCompiledJava("compiler/testData/loadJava/compiledJava/OverrideMethod.java");
+        }
+        
         @TestMetadata("PackageLocalVisibility.java")
         public void testPackageLocalVisibility() throws Exception {
             doTestCompiledJava("compiler/testData/loadJava/compiledJava/PackageLocalVisibility.java");

generators/org/jetbrains/jet/generators/injectors/GenerateInjectors.java

@@ -37,6 +37,7 @@ import org.jetbrains.jet.lang.resolve.java.JavaBridgeConfiguration;
 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.FakeOverrideVisibilityResolverImpl;
 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;
@@ -109,6 +110,7 @@ public class GenerateInjectors {
         generator.addField(JavaClassFinderImpl.class);
         generator.addField(TraceBasedExternalSignatureResolver.class);
         generator.addField(TraceBasedJavaResolverCache.class);
+        generator.addField(FakeOverrideVisibilityResolverImpl.class);
         generator.addPublicField(NamespaceFactoryImpl.class);
         generator.addField(false, VirtualFileFinder.class, "virtualFileFinder",
                            new GivenExpression(
@@ -128,6 +130,7 @@ public class GenerateInjectors {
         generator.addField(JavaClassFinderImpl.class);
         generator.addField(TraceBasedExternalSignatureResolver.class);
         generator.addField(TraceBasedJavaResolverCache.class);
+        generator.addField(FakeOverrideVisibilityResolverImpl.class);
         generator.addPublicField(JavaDescriptorResolver.class);
         generator.addPublicField(PsiClassFinderImpl.class);
         generator.addField(false, VirtualFileFinder.class, "virtualFileFinder",