[FIR] Add EXPOSED_SUPER_(CLASS/INTERFACE) checker

compiler/fir/analysis-tests/testData/resolve/visibility/exposedSupertype.kt

@@ -0,0 +1,63 @@
+class A {
+    protected interface AProtectedI {
+
+    }
+
+    interface APublicI {
+
+    }
+}
+
+class B {
+    protected class BProtected {
+
+    }
+
+    inner class BInner {
+
+    }
+}
+
+private class C {
+    class CPublic {
+
+    }
+
+    interface CPublicI {
+
+    }
+}
+
+class D : A {
+    class Test1 : A.AProtectedI {
+
+    }
+}
+
+interface E {
+
+}
+
+class Test2 : A.APublicI, B.BInner {
+
+}
+
+class Test3 : C.CPublicI, <!EXPOSED_SUPER_CLASS!>C<!> {
+
+}
+
+class Test4 : E, A.AProtectedI {
+
+}
+
+class Test5 : C.CPublicI, B.BInner {
+
+}
+
+class Test6 : E, <!EXPOSED_SUPER_CLASS!>C.CPublic<!> {
+
+}
+
+class Test7 : D.PublicButProtected {
+
+}

compiler/fir/analysis-tests/testData/resolve/visibility/exposedSupertype.txt

@@ -0,0 +1,100 @@
+FILE: exposedSupertype.kt
+    public final class A : R|kotlin/Any| {
+        public constructor(): R|A| {
+            super<R|kotlin/Any|>()
+        }
+
+        protected abstract interface AProtectedI : R|kotlin/Any| {
+        }
+
+        public abstract interface APublicI : R|kotlin/Any| {
+        }
+
+    }
+    public final class B : R|kotlin/Any| {
+        public constructor(): R|B| {
+            super<R|kotlin/Any|>()
+        }
+
+        protected final class BProtected : R|kotlin/Any| {
+            public[protected] constructor(): R|B.BProtected| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+        public final inner class BInner : R|kotlin/Any| {
+            public constructor(): R|B.BInner| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+    }
+    private final class C : R|kotlin/Any| {
+        public[private] constructor(): R|C| {
+            super<R|kotlin/Any|>()
+        }
+
+        public[private] final class CPublic : R|kotlin/Any| {
+            public[private] constructor(): R|C.CPublic| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+        public[private] abstract interface CPublicI : R|kotlin/Any| {
+        }
+
+    }
+    public final class D : R|A| {
+        public constructor(): R|D| {
+            super<R|A|>()
+        }
+
+        public final class Test1 : R|A.AProtectedI| {
+            public constructor(): R|D.Test1| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+    }
+    public abstract interface E : R|kotlin/Any| {
+    }
+    public final class Test2 : R|A.APublicI|, R|B.BInner| {
+        public constructor(): R|Test2| {
+            super<R|B.BInner|>()
+        }
+
+    }
+    public final class Test3 : R|C.CPublicI|, R|C| {
+        public constructor(): R|Test3| {
+            super<R|C|>()
+        }
+
+    }
+    public final class Test4 : R|E|, R|A.AProtectedI| {
+        public constructor(): R|Test4| {
+            super<R|kotlin/Any|>()
+        }
+
+    }
+    public final class Test5 : R|C.CPublicI|, R|B.BInner| {
+        public constructor(): R|Test5| {
+            super<R|B.BInner|>()
+        }
+
+    }
+    public final class Test6 : R|E|, R|C.CPublic| {
+        public constructor(): R|Test6| {
+            super<R|C.CPublic|>()
+        }
+
+    }
+    public final class Test7 : R|ERROR CLASS: Symbol not found, for `D.PublicButProtected`| {
+        public constructor(): R|Test7| {
+            super<R|kotlin/Any|>()
+        }
+
+    }