Refactor OverridingUtil.resolveUnknownVisibilities

Get rid of dependency on BindingTrace, move the corresponding error reporting
logic to OverrideResolver

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

@@ -21,7 +21,6 @@ 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.resolver.TraceBasedErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
@@ -53,7 +52,6 @@ public class InjectorForJavaDescriptorResolver {
     private final JavaClassFinderImpl javaClassFinder;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
     private final TraceBasedJavaResolverCache traceBasedJavaResolverCache;
-    private final FakeOverrideVisibilityResolverImpl fakeOverrideVisibilityResolver;
     private final TraceBasedErrorReporter traceBasedErrorReporter;
     private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
@@ -84,7 +82,6 @@ public class InjectorForJavaDescriptorResolver {
         this.javaClassFinder = new JavaClassFinderImpl();
         this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
         this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
-        this.fakeOverrideVisibilityResolver = new FakeOverrideVisibilityResolverImpl();
         this.traceBasedErrorReporter = new TraceBasedErrorReporter();
         this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
         this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver();
@@ -113,8 +110,6 @@ public class InjectorForJavaDescriptorResolver {
 
         traceBasedJavaResolverCache.setTrace(bindingTrace);
 
-        fakeOverrideVisibilityResolver.setTrace(bindingTrace);
-
         traceBasedErrorReporter.setTrace(bindingTrace);
 
         psiBasedMethodSignatureChecker.setAnnotationResolver(javaAnnotationResolver);
@@ -176,8 +171,8 @@ public class InjectorForJavaDescriptorResolver {
 
         javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
         javaFunctionResolver.setCache(traceBasedJavaResolverCache);
+        javaFunctionResolver.setErrorReporter(traceBasedErrorReporter);
         javaFunctionResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
-        javaFunctionResolver.setFakeOverrideVisibilityResolver(fakeOverrideVisibilityResolver);
         javaFunctionResolver.setSignatureChecker(psiBasedMethodSignatureChecker);
         javaFunctionResolver.setTypeParameterResolver(javaTypeParameterResolver);
         javaFunctionResolver.setTypeTransformer(javaTypeTransformer);
@@ -187,8 +182,8 @@ public class InjectorForJavaDescriptorResolver {
 
         javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver);
         javaPropertyResolver.setCache(traceBasedJavaResolverCache);
+        javaPropertyResolver.setErrorReporter(traceBasedErrorReporter);
         javaPropertyResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
-        javaPropertyResolver.setFakeOverrideVisibilityResolver(fakeOverrideVisibilityResolver);
         javaPropertyResolver.setTypeTransformer(javaTypeTransformer);
 
         javaSupertypeResolver.setClassResolver(javaClassResolver);

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

@@ -34,7 +34,6 @@ import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap;
 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.resolver.TraceBasedErrorReporter;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker;
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
@@ -94,7 +93,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final JavaClassFinderImpl javaClassFinder;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
     private final TraceBasedJavaResolverCache traceBasedJavaResolverCache;
-    private final FakeOverrideVisibilityResolverImpl fakeOverrideVisibilityResolver;
     private final TraceBasedErrorReporter traceBasedErrorReporter;
     private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker;
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
@@ -155,7 +153,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.javaClassFinder = new JavaClassFinderImpl();
         this.traceBasedExternalSignatureResolver = new TraceBasedExternalSignatureResolver();
         this.traceBasedJavaResolverCache = new TraceBasedJavaResolverCache();
-        this.fakeOverrideVisibilityResolver = new FakeOverrideVisibilityResolverImpl();
         this.traceBasedErrorReporter = new TraceBasedErrorReporter();
         this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker();
         this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver();
@@ -239,8 +236,6 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         traceBasedJavaResolverCache.setTrace(bindingTrace);
 
-        fakeOverrideVisibilityResolver.setTrace(bindingTrace);
-
         traceBasedErrorReporter.setTrace(bindingTrace);
 
         psiBasedMethodSignatureChecker.setAnnotationResolver(javaAnnotationResolver);
@@ -367,8 +362,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         javaFunctionResolver.setAnnotationResolver(javaAnnotationResolver);
         javaFunctionResolver.setCache(traceBasedJavaResolverCache);
+        javaFunctionResolver.setErrorReporter(traceBasedErrorReporter);
         javaFunctionResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
-        javaFunctionResolver.setFakeOverrideVisibilityResolver(fakeOverrideVisibilityResolver);
         javaFunctionResolver.setSignatureChecker(psiBasedMethodSignatureChecker);
         javaFunctionResolver.setTypeParameterResolver(javaTypeParameterResolver);
         javaFunctionResolver.setTypeTransformer(javaTypeTransformer);
@@ -378,8 +373,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         javaPropertyResolver.setAnnotationResolver(javaAnnotationResolver);
         javaPropertyResolver.setCache(traceBasedJavaResolverCache);
+        javaPropertyResolver.setErrorReporter(traceBasedErrorReporter);
         javaPropertyResolver.setExternalSignatureResolver(traceBasedExternalSignatureResolver);
-        javaPropertyResolver.setFakeOverrideVisibilityResolver(fakeOverrideVisibilityResolver);
         javaPropertyResolver.setTypeTransformer(javaTypeTransformer);
 
         javaSupertypeResolver.setClassResolver(javaClassResolver);

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

@@ -1,22 +0,0 @@
-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.OverridingUtil;
-
-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) {
-        OverridingUtil.resolveUnknownVisibilityForMember(null, descriptor, trace);
-    }
-}

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

@@ -17,7 +17,11 @@
 package org.jetbrains.jet.lang.resolve.java.resolver;
 
 import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
+import org.jetbrains.jet.lang.psi.JetDeclaration;
+import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.util.slicedmap.BasicWritableSlice;
@@ -26,6 +30,8 @@ import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
 import javax.inject.Inject;
 
+import static org.jetbrains.jet.lang.diagnostics.Errors.CANNOT_INFER_VISIBILITY;
+
 public class TraceBasedErrorReporter implements ErrorReporter {
     public static final WritableSlice<AbiVersionErrorLocation, Integer> ABI_VERSION_ERRORS =
             new BasicWritableSlice<AbiVersionErrorLocation, Integer>(Slices.ONLY_REWRITE_TO_EQUAL, true);
@@ -41,6 +47,14 @@ public class TraceBasedErrorReporter implements ErrorReporter {
         trace.record(ABI_VERSION_ERRORS, new AbiVersionErrorLocation(fqName, file), actualVersion);
     }
 
+    @Override
+    public void reportCannotInferVisibility(@NotNull CallableMemberDescriptor descriptor) {
+        PsiElement element = BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), descriptor);
+        if (element instanceof JetDeclaration) {
+            trace.report(CANNOT_INFER_VISIBILITY.on((JetDeclaration) element));
+        }
+    }
+
     public static final class AbiVersionErrorLocation {
         @NotNull
         private final FqName classFqName;

compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java

@@ -26,7 +26,6 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.*;
 import org.jetbrains.jet.lang.resolve.DescriptorFactory;
 import org.jetbrains.jet.lang.resolve.OverridingUtil;
-import org.jetbrains.jet.lang.resolve.TraceUtil;
 import org.jetbrains.jet.lang.resolve.lazy.storage.MemoizedFunctionToNullable;
 import org.jetbrains.jet.lang.resolve.lazy.storage.NotNullLazyValue;
 import org.jetbrains.jet.lang.resolve.lazy.storage.NullableLazyValue;
@@ -430,7 +429,13 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements
                     new OverridingUtil.DescriptorSink() {
                         @Override
                         public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
-                            OverridingUtil.resolveUnknownVisibilityForMember(null, fakeOverride, TraceUtil.TRACE_STUB);
+                            OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, new OverridingUtil.NotInferredVisibilitySink() {
+                                @Override
+                                public void cannotInferVisibility(@NotNull CallableMemberDescriptor descriptor) {
+                                    // Do nothing
+                                    // TODO: do something
+                                }
+                            });
                             //noinspection unchecked
                             result.add((D) fakeOverride);
                         }

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

@@ -168,16 +168,21 @@ public class OverrideResolver {
     public static void resolveUnknownVisibilities(
             @NotNull Collection<? extends CallableMemberDescriptor> descriptors,
             @NotNull BindingTrace trace) {
-        for (CallableMemberDescriptor memberDescriptor : descriptors) {
+        for (CallableMemberDescriptor descriptor : descriptors) {
-            JetDeclaration declaration = null;
+            resolveUnknownVisibilityForMember(descriptor, trace);
-            if (memberDescriptor.getKind() == CallableMemberDescriptor.Kind.DECLARATION) {
+        }
-                PsiElement element = BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), memberDescriptor);
+    }
+
+    public static void resolveUnknownVisibilityForMember(@NotNull CallableMemberDescriptor descriptor, @NotNull final BindingTrace trace) {
+        OverridingUtil.resolveUnknownVisibilityForMember(descriptor, new OverridingUtil.NotInferredVisibilitySink() {
+            @Override
+            public void cannotInferVisibility(@NotNull CallableMemberDescriptor descriptor) {
+                PsiElement element = BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), descriptor);
                 if (element instanceof JetDeclaration) {
-                    declaration = (JetDeclaration) element;
+                    trace.report(CANNOT_INFER_VISIBILITY.on((JetDeclaration) element));
                 }
             }
-            OverridingUtil.resolveUnknownVisibilityForMember(declaration, memberDescriptor, trace);
+        });
-        }
     }
 
     private static <T extends DeclarationDescriptor> MultiMap<Name, T> groupDescriptorsByName(Collection<T> properties) {

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

@@ -18,7 +18,6 @@ package org.jetbrains.jet.lang.resolve;
 
 import com.google.common.base.Predicate;
 import com.google.common.collect.*;
-import com.intellij.psi.PsiElement;
 import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
@@ -27,14 +26,12 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.impl.FunctionDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.PropertyAccessorDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.PropertyDescriptorImpl;
-import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 
 import java.util.*;
 
-import static org.jetbrains.jet.lang.diagnostics.Errors.CANNOT_INFER_VISIBILITY;
 import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.CONFLICT;
 import static org.jetbrains.jet.lang.resolve.OverridingUtil.OverrideCompatibilityInfo.Result.OVERRIDABLE;
 
@@ -489,28 +486,34 @@ public class OverridingUtil {
         return overridable;
     }
 
-    public static void resolveUnknownVisibilityForMember(@Nullable JetDeclaration member, @NotNull CallableMemberDescriptor memberDescriptor, @NotNull BindingTrace trace) {
+    public static void resolveUnknownVisibilityForMember(
-        resolveUnknownVisibilityForOverriddenDescriptors(memberDescriptor.getOverriddenDescriptors(), trace);
+            @NotNull CallableMemberDescriptor memberDescriptor,
+            @NotNull NotInferredVisibilitySink sink
+    ) {
+        for (CallableMemberDescriptor descriptor : memberDescriptor.getOverriddenDescriptors()) {
+            if (descriptor.getVisibility() == Visibilities.INHERITED) {
+                resolveUnknownVisibilityForMember(descriptor, sink);
+            }
+        }
+
         if (memberDescriptor.getVisibility() != Visibilities.INHERITED) {
             return;
         }
 
         Visibility visibility = findMaxVisibility(memberDescriptor.getOverriddenDescriptors());
         if (visibility == null) {
-            if (member != null) {
+            sink.cannotInferVisibility(memberDescriptor);
-                trace.report(CANNOT_INFER_VISIBILITY.on(member));
-            }
             visibility = Visibilities.PUBLIC;
         }
 
         if (memberDescriptor instanceof PropertyDescriptorImpl) {
-            ((PropertyDescriptorImpl)memberDescriptor).setVisibility(visibility.normalize());
+            ((PropertyDescriptorImpl) memberDescriptor).setVisibility(visibility.normalize());
             for (PropertyAccessorDescriptor accessor : ((PropertyDescriptor) memberDescriptor).getAccessors()) {
-                resolveUnknownVisibilityForMember(null, accessor, trace);
+                resolveUnknownVisibilityForMember(accessor, sink);
             }
         }
         else if (memberDescriptor instanceof FunctionDescriptorImpl) {
-            ((FunctionDescriptorImpl)memberDescriptor).setVisibility(visibility.normalize());
+            ((FunctionDescriptorImpl) memberDescriptor).setVisibility(visibility.normalize());
         }
         else {
             assert memberDescriptor instanceof PropertyAccessorDescriptorImpl;
@@ -518,16 +521,6 @@ public class OverridingUtil {
         }
     }
 
-    private static void resolveUnknownVisibilityForOverriddenDescriptors(@NotNull Collection<? extends CallableMemberDescriptor> descriptors, @NotNull BindingTrace trace) {
-        for (CallableMemberDescriptor descriptor : descriptors) {
-            if (descriptor.getVisibility() == Visibilities.INHERITED) {
-                PsiElement element = BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), descriptor);
-                JetDeclaration declaration = (element instanceof JetDeclaration) ? (JetDeclaration) element : null;
-                resolveUnknownVisibilityForMember(declaration, descriptor, trace);
-            }
-        }
-    }
-
     @Nullable
     private static Visibility findMaxVisibility(@NotNull Collection<? extends CallableMemberDescriptor> descriptors) {
         if (descriptors.isEmpty()) {
@@ -567,6 +560,10 @@ public class OverridingUtil {
         void conflict(@NotNull CallableMemberDescriptor fromSuper, @NotNull CallableMemberDescriptor fromCurrent);
     }
 
+    public interface NotInferredVisibilitySink {
+        void cannotInferVisibility(@NotNull CallableMemberDescriptor descriptor);
+    }
+
     public static class OverrideCompatibilityInfo {
 
         public enum Result {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java

@@ -19,7 +19,6 @@ package org.jetbrains.jet.lang.resolve.lazy.descriptors;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Lists;
 import com.intellij.openapi.util.Computable;
-import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
@@ -140,10 +139,9 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
         // TODO: this should be handled by lazy function descriptors
         Set<FunctionDescriptor> functions = super.getFunctions(name);
         for (FunctionDescriptor functionDescriptor : functions) {
-            if (functionDescriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) continue;
+            if (functionDescriptor.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
-            PsiElement element =
+                OverrideResolver.resolveUnknownVisibilityForMember(functionDescriptor, resolveSession.getTrace());
-                    BindingContextUtils.callableDescriptorToDeclaration(resolveSession.getTrace().getBindingContext(), functionDescriptor);
+            }
-            OverridingUtil.resolveUnknownVisibilityForMember((JetDeclaration) element, functionDescriptor, resolveSession.getTrace());
         }
         return functions;
     }
@@ -214,10 +212,9 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
         Set<VariableDescriptor> properties = super.getProperties(name);
         for (VariableDescriptor variableDescriptor : properties) {
             PropertyDescriptor propertyDescriptor = (PropertyDescriptor) variableDescriptor;
-            if (propertyDescriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) continue;
+            if (propertyDescriptor.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
-            PsiElement element =
+                OverrideResolver.resolveUnknownVisibilityForMember(propertyDescriptor, resolveSession.getTrace());
-                    BindingContextUtils.callableDescriptorToDeclaration(resolveSession.getTrace().getBindingContext(), propertyDescriptor);
+            }
-            OverridingUtil.resolveUnknownVisibilityForMember((JetDeclaration) element, propertyDescriptor, resolveSession.getTrace());
         }
         return properties;
     }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java

@@ -66,7 +66,7 @@ public final class DescriptorResolverUtils {
             @NotNull Collection<D> membersFromSupertypes,
             @NotNull Collection<D> membersFromCurrent,
             @NotNull ClassDescriptor classDescriptor,
-            @NotNull final FakeOverrideVisibilityResolver visibilityResolver
+            @NotNull final ErrorReporter errorReporter
     ) {
         final Set<D> result = new HashSet<D>();
 
@@ -76,7 +76,12 @@ public final class DescriptorResolverUtils {
                     @Override
                     @SuppressWarnings("unchecked")
                     public void addToScope(@NotNull CallableMemberDescriptor fakeOverride) {
-                        visibilityResolver.resolveUnknownVisibilityForMember(fakeOverride);
+                        OverridingUtil.resolveUnknownVisibilityForMember(fakeOverride, new OverridingUtil.NotInferredVisibilitySink() {
+                            @Override
+                            public void cannotInferVisibility(@NotNull CallableMemberDescriptor descriptor) {
+                                errorReporter.reportCannotInferVisibility(descriptor);
+                            }
+                        });
                         result.add((D) fakeOverride);
                     }
 

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/ErrorReporter.java

@@ -18,8 +18,11 @@ package org.jetbrains.jet.lang.resolve.java.resolver;
 
 import com.intellij.openapi.vfs.VirtualFile;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 public interface ErrorReporter {
     void reportIncompatibleAbiVersion(@NotNull FqName fqName, @NotNull VirtualFile file, int actualVersion);
+
+    void reportCannotInferVisibility(@NotNull CallableMemberDescriptor descriptor);
 }

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/FakeOverrideVisibilityResolver.java

@@ -1,24 +0,0 @@
-/*
- * 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);
-}

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java

@@ -47,7 +47,7 @@ public final class JavaFunctionResolver {
     private JavaValueParameterResolver valueParameterResolver;
     private JavaAnnotationResolver annotationResolver;
     private ExternalSignatureResolver externalSignatureResolver;
-    private FakeOverrideVisibilityResolver fakeOverrideVisibilityResolver;
+    private ErrorReporter errorReporter;
     private MethodSignatureChecker signatureChecker;
 
     @Inject
@@ -81,8 +81,8 @@ public final class JavaFunctionResolver {
     }
 
     @Inject
-    public void setFakeOverrideVisibilityResolver(FakeOverrideVisibilityResolver fakeOverrideVisibilityResolver) {
+    public void setErrorReporter(ErrorReporter errorReporter) {
-        this.fakeOverrideVisibilityResolver = fakeOverrideVisibilityResolver;
+        this.errorReporter = errorReporter;
     }
 
     @Inject
@@ -211,8 +211,7 @@ public final class JavaFunctionResolver {
 
             Collection<SimpleFunctionDescriptor> functionsFromSupertypes = getFunctionsFromSupertypes(methodName, classDescriptor);
 
-            functions.addAll(resolveOverrides(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor,
+            functions.addAll(resolveOverrides(methodName, functionsFromSupertypes, functionsFromCurrent, classDescriptor, errorReporter));
-                                              fakeOverrideVisibilityResolver));
         }
 
         if (isEnumClassObject(owner)) {

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java

@@ -41,10 +41,7 @@ public final class JavaPropertyResolver {
     private JavaResolverCache cache;
     private JavaAnnotationResolver annotationResolver;
     private ExternalSignatureResolver externalSignatureResolver;
-    private FakeOverrideVisibilityResolver fakeOverrideVisibilityResolver;
+    private ErrorReporter errorReporter;
-
-    public JavaPropertyResolver() {
-    }
 
     @Inject
     public void setTypeTransformer(@NotNull JavaTypeTransformer javaTypeTransformer) {
@@ -67,8 +64,8 @@ public final class JavaPropertyResolver {
     }
 
     @Inject
-    public void setFakeOverrideVisibilityResolver(FakeOverrideVisibilityResolver fakeOverrideVisibilityResolver) {
+    public void setErrorReporter(ErrorReporter errorReporter) {
-        this.fakeOverrideVisibilityResolver = fakeOverrideVisibilityResolver;
+        this.errorReporter = errorReporter;
     }
 
     @NotNull
@@ -93,7 +90,7 @@ public final class JavaPropertyResolver {
             Collection<PropertyDescriptor> propertiesFromSupertypes = getPropertiesFromSupertypes(propertyName, classDescriptor);
 
             properties.addAll(resolveOverrides(propertyName, propertiesFromSupertypes, propertiesFromCurrent, classDescriptor,
-                                               fakeOverrideVisibilityResolver));
+                                               errorReporter));
         }
 
         properties.addAll(propertiesFromCurrent);

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

@@ -114,7 +114,6 @@ public class GenerateInjectors {
         generator.addField(JavaClassFinderImpl.class);
         generator.addField(TraceBasedExternalSignatureResolver.class);
         generator.addField(TraceBasedJavaResolverCache.class);
-        generator.addField(FakeOverrideVisibilityResolverImpl.class);
         generator.addField(TraceBasedErrorReporter.class);
         generator.addField(PsiBasedMethodSignatureChecker.class);
         generator.addField(PsiBasedExternalAnnotationResolver.class);
@@ -137,7 +136,6 @@ public class GenerateInjectors {
         generator.addField(JavaClassFinderImpl.class);
         generator.addField(TraceBasedExternalSignatureResolver.class);
         generator.addField(TraceBasedJavaResolverCache.class);
-        generator.addField(FakeOverrideVisibilityResolverImpl.class);
         generator.addField(TraceBasedErrorReporter.class);
         generator.addField(PsiBasedMethodSignatureChecker.class);
         generator.addField(PsiBasedExternalAnnotationResolver.class);