Don't check class object visibility when it's in qualifier position

(visibility for member is checked anyway).
It might be better to underline invisible qualifier in a chain (class or class object), not the last one (member) - for later improvement.

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/receivers/Qualifier.kt

@@ -149,7 +149,6 @@ private fun QualifierReceiver.resolveAsReceiverInQualifiedExpression(context: Ex
         context.trace.report(TYPE_PARAMETER_ON_LHS_OF_DOT.on(referenceExpression, classifier as TypeParameterDescriptor))
     }
     else if (classifier is ClassDescriptor && classifier.getClassObjectDescriptor() != null) {
-        checkClassObjectVisibility(context)
         context.trace.record(EXPRESSION_TYPE, referenceExpression, classifier.getClassObjectType())
     }
 }
@@ -183,16 +182,3 @@ private fun QualifierReceiver.resolveReferenceTarget(selector: DeclarationDescri
 
     return descriptor
 }
-
-private fun QualifierReceiver.checkClassObjectVisibility(context: ExpressionTypingContext) {
-    if (classifier !is ClassDescriptor) return
-
-    val scopeContainer = context.scope.getContainingDeclaration()
-    val classObject = classifier.getClassObjectDescriptor()
-    assert(classObject != null) { "This check should be done only for classes with class objects: " + classifier }
-    if (!Visibilities.isVisible(classObject!!, scopeContainer)) {
-        context.trace.report(INVISIBLE_MEMBER.on(referenceExpression, classObject, classObject.getVisibility(), scopeContainer))
-    }
-}
-
-

compiler/testData/diagnostics/tests/classObjects/ClassObjectVisibility.kt

@@ -3,8 +3,9 @@ package foo
 fun test() {
   A.d
   A.<!INVISIBLE_MEMBER!>f<!>
+  B.<!INVISIBLE_MEMBER!>D<!>
   <!INVISIBLE_MEMBER!>CCC<!>
-  <!INVISIBLE_MEMBER!>CCC<!>.<!INVISIBLE_MEMBER!>classObjectVar<!>
+  CCC.<!INVISIBLE_MEMBER!>classObjectVar<!>
 }
 
 class A() {
@@ -16,6 +17,12 @@ class A() {
   }
 }
 
+class B {
+    class D {
+        private class object
+    }
+}
+
 class CCC() {
   private class object {
     val classObjectVar = 3

compiler/testData/diagnostics/tests/classObjects/invisibleClassObjects.kt

@@ -40,12 +40,12 @@ fun test() {
     f(<!INVISIBLE_MEMBER!>D<!>)
 
     A.foo()
-    <!INVISIBLE_MEMBER!>B<!>.<!INVISIBLE_MEMBER!>bar<!>()
-    <!INVISIBLE_MEMBER!>C<!>.<!INVISIBLE_MEMBER!>baz<!>()
-    <!INVISIBLE_MEMBER!>D<!>.<!INVISIBLE_MEMBER!>quux<!>()
+    B.<!INVISIBLE_MEMBER!>bar<!>()
+    C.<!INVISIBLE_MEMBER!>baz<!>()
+    D.<!INVISIBLE_MEMBER!>quux<!>()
 
     a.A.foo()
-    a.<!INVISIBLE_MEMBER!>C<!>.<!INVISIBLE_MEMBER!>baz<!>()
+    a.C.<!INVISIBLE_MEMBER!>baz<!>()
 }
 
 fun f(<!UNUSED_PARAMETER!>unused<!>: Any) {}

compiler/testData/diagnostics/tests/classObjects/nestedClassInPrivateClassObject.kt

@@ -10,6 +10,6 @@ class A {
     }
 }
 
-fun f1() = <!INVISIBLE_MEMBER!>A<!>.B.<!INVISIBLE_MEMBER!>C<!>
+fun f1() = A.B.<!INVISIBLE_MEMBER!>C<!>
 
-fun f2() = <!INVISIBLE_MEMBER!>A<!>.B.<!INVISIBLE_MEMBER!>C<!>.<!INVISIBLE_MEMBER!>foo<!>()
+fun f2() = A.B.C.<!INVISIBLE_MEMBER!>foo<!>()