Invisible call candidates removed from consideration

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/TaskPrioritizer.java

@@ -16,6 +16,8 @@
 
 package org.jetbrains.jet.lang.resolve.calls;
 
+import com.google.common.base.Predicate;
+import com.google.common.collect.Collections2;
 import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -30,6 +32,7 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.NamespaceType;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
@@ -212,9 +215,19 @@ import static org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor
         return false;
     }
 
-    private void addTask(@NotNull List<ResolutionTask<D>> result, @NotNull Collection<ResolvedCallImpl<D>> candidates, @NotNull BasicResolutionContext context, @NotNull JetReferenceExpression functionReference) {
+    private void addTask(@NotNull List<ResolutionTask<D>> result, @NotNull Collection<ResolvedCallImpl<D>> candidates, @NotNull final BasicResolutionContext context, @NotNull JetReferenceExpression functionReference) {
-        if (candidates.isEmpty()) return;
+        Collection<ResolvedCallImpl<D>> visibleCandidates = Collections2.filter(candidates, new Predicate<ResolvedCallImpl<D>>() {
-        result.add(new ResolutionTask<D>(candidates, functionReference, context));
+            @Override
+            public boolean apply(@Nullable ResolvedCallImpl<D> call) {
+                if (call == null) return false;
+                D candidateDescriptor = call.getCandidateDescriptor();
+                if (ErrorUtils.isError(candidateDescriptor)) return true;
+                Visibility visibility = candidateDescriptor.getVisibility();
+                return visibility.isVisible(candidateDescriptor, context.scope.getContainingDeclaration());
+            }
+        });
+        if (visibleCandidates.isEmpty()) return;
+        result.add(new ResolutionTask<D>(visibleCandidates, functionReference, context));
     }
 
     @NotNull

compiler/testData/diagnostics/tests/scopes/visibility.jet

@@ -0,0 +1,90 @@
+//FILE:a.kt
+package test_visibility
+
+<!PACKAGE_MEMBER_CANNOT_BE_PROTECTED!>protected<!> val protected_val : Int = 4
+<!PACKAGE_MEMBER_CANNOT_BE_PROTECTED!>protected<!> fun protected_fun() {}
+
+private val private_val : Int = 4
+private fun private_fun() {}
+
+val internal_val : Int = 34
+fun internal_fun() {}
+
+fun test1() {
+    private_fun();
+}
+
+class Y {
+    fun test2() {
+        private_fun();
+    }
+}
+
+class A {
+    private val i = 23
+    private val v: B = B()
+    private fun f(<!UNUSED_PARAMETER!>i<!>: Int): B = B()
+
+    fun test() {
+        doSmth(i)
+    }
+}
+
+class B {
+    fun bMethod() {}
+}
+
+fun test3(a: A) {
+    a.<!UNRESOLVED_REFERENCE!>v<!> //todo .bMethod()
+    a.<!UNRESOLVED_REFERENCE!>f<!>(0, 1) //todo .bMethod()
+}
+
+trait T
+
+open class C : T {
+    protected var i : Int = 34
+    fun test5() {
+        doSmth(i)
+    }
+}
+
+fun test4(c: C) {
+    c.<!UNRESOLVED_REFERENCE!>i<!>++
+}
+
+class D : C() {
+    val j = i
+    fun test6() {
+        doSmth(i)
+    }
+}
+
+class E : C() {
+    fun test7() {
+        doSmth(i)
+    }
+}
+
+class F : C() {
+    fun test8(c: C) {
+        doSmth(c.i)
+    }
+}
+
+class G : T {
+    fun test8(c: C) {
+        doSmth(c.<!UNRESOLVED_REFERENCE!>i<!>)
+    }
+}
+
+fun doSmth(i: Int) = i
+
+//FILE:b.kt
+package test_visibility2
+
+import test_visibility.*
+
+fun test() {
+    internal_fun()
+    <!UNRESOLVED_REFERENCE!>private_fun<!>()
+}