Refactor OverridingUtil.resolveUnknownVisibilities

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

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) {
-            JetDeclaration declaration = null;
-            if (memberDescriptor.getKind() == CallableMemberDescriptor.Kind.DECLARATION) {
-                PsiElement element = BindingContextUtils.descriptorToDeclaration(trace.getBindingContext(), memberDescriptor);
+        for (CallableMemberDescriptor descriptor : descriptors) {
+            resolveUnknownVisibilityForMember(descriptor, trace);
+        }
+    }
+
+    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) {
-        resolveUnknownVisibilityForOverriddenDescriptors(memberDescriptor.getOverriddenDescriptors(), trace);
+    public static void resolveUnknownVisibilityForMember(
+            @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) {
-                trace.report(CANNOT_INFER_VISIBILITY.on(member));
-            }
+            sink.cannotInferVisibility(memberDescriptor);
             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;
-            PsiElement element =
-                    BindingContextUtils.callableDescriptorToDeclaration(resolveSession.getTrace().getBindingContext(), functionDescriptor);
-            OverridingUtil.resolveUnknownVisibilityForMember((JetDeclaration) element, functionDescriptor, resolveSession.getTrace());
+            if (functionDescriptor.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+                OverrideResolver.resolveUnknownVisibilityForMember(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;
-            PsiElement element =
-                    BindingContextUtils.callableDescriptorToDeclaration(resolveSession.getTrace().getBindingContext(), propertyDescriptor);
-            OverridingUtil.resolveUnknownVisibilityForMember((JetDeclaration) element, propertyDescriptor, resolveSession.getTrace());
+            if (propertyDescriptor.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
+                OverrideResolver.resolveUnknownVisibilityForMember(propertyDescriptor, resolveSession.getTrace());
+            }
         }
         return properties;
     }