[FIR] Support for EXPOSED_TYPEALIAS_EXPANDED_TYPE

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

@@ -0,0 +1,14 @@
+class A {
+    private inner class Inner
+}
+class B {
+    <!FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias AInner = A.Inner<!>
+    inner class Inner
+}
+
+class C {
+    typealias BInner = B.Inner
+}
+
+<!FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias AInner0 = A.Inner<!>
+typealias BInner0 = B.Inner

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

@@ -0,0 +1,39 @@
+FILE: exposedTypeAlias.kt
+    public final class A : R|kotlin/Any| {
+        public constructor(): R|A| {
+            super<R|kotlin/Any|>()
+        }
+
+        private final inner class Inner : R|kotlin/Any| {
+            public[private] constructor(): R|A.Inner| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+    }
+    public final class B : R|kotlin/Any| {
+        public constructor(): R|B| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final typealias AInner = R|A.Inner|
+
+        public final inner class Inner : R|kotlin/Any| {
+            public constructor(): R|B.Inner| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+    }
+    public final class C : R|kotlin/Any| {
+        public constructor(): R|C| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final typealias BInner = R|B.Inner|
+
+    }
+    public final typealias AInner0 = R|A.Inner|
+    public final typealias BInner0 = R|B.Inner|

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java

@@ -2138,6 +2138,11 @@ public class FirDiagnosticsTestGenerated extends AbstractFirDiagnosticsTest {
             KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/visibility"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
         }
 
+        @TestMetadata("exposedTypeAlias.kt")
+        public void testExposedTypeAlias() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeAlias.kt");
+        }
+
         @TestMetadata("protectedInCompanion.kt")
         public void testProtectedInCompanion() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/visibility/protectedInCompanion.kt");

compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java

@@ -2138,6 +2138,11 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
             KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/analysis-tests/testData/resolve/visibility"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
         }
 
+        @TestMetadata("exposedTypeAlias.kt")
+        public void testExposedTypeAlias() throws Exception {
+            runTest("compiler/fir/analysis-tests/testData/resolve/visibility/exposedTypeAlias.kt");
+        }
+
         @TestMetadata("protectedInCompanion.kt")
         public void testProtectedInCompanion() throws Exception {
             runTest("compiler/fir/analysis-tests/testData/resolve/visibility/protectedInCompanion.kt");

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/DeclarationCheckers.kt

@@ -14,7 +14,8 @@ object DeclarationCheckers {
         FirModifierChecker
     )
     val MEMBER_DECLARATIONS: List<FirDeclarationChecker<FirMemberDeclaration>> = DECLARATIONS + listOf(
-        FirInfixFunctionDeclarationChecker
+        FirInfixFunctionDeclarationChecker,
+        FirExposedVisibilityChecker
     )
     val CONSTRUCTORS: List<FirDeclarationChecker<FirConstructor>> = MEMBER_DECLARATIONS + listOf(
         FirConstructorChecker

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityChecker.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir.analysis.checkers.declaration
+
+import com.intellij.psi.PsiElement
+import org.jetbrains.kotlin.diagnostics.DiagnosticFactory2
+import org.jetbrains.kotlin.diagnostics.DiagnosticFactory3
+import org.jetbrains.kotlin.diagnostics.Errors
+import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.analysis.diagnostics.onSource
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.resolve.toSymbol
+import org.jetbrains.kotlin.fir.resolve.transformers.firClassLike
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.fir.types.coneTypeSafe
+
+object FirExposedVisibilityChecker : FirDeclarationChecker<FirMemberDeclaration>() {
+    override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+        if (declaration is FirTypeAlias) {
+            checkTypeAlias(declaration, context, reporter)
+        }
+    }
+
+    private fun checkTypeAlias(declaration: FirTypeAlias, context: CheckerContext, reporter: DiagnosticReporter) {
+        val expandedType = declaration.expandedConeType
+
+        val restricting = expandedType?.leastPermissiveDescriptor(declaration.session, declaration.effectiveVisibility)
+        if (restricting != null) {
+            reporter.reportExposure(Error.EXPOSED_TYPEALIAS_EXPANDED_TYPE, declaration.source)
+        }
+    }
+
+    private enum class Error {
+        EXPOSED_TYPEALIAS_EXPANDED_TYPE
+    }
+
+    private fun DiagnosticReporter.reportExposure(
+        error: Error,
+        source: FirSourceElement?
+    ) {
+        when (error) {
+            Error.EXPOSED_TYPEALIAS_EXPANDED_TYPE -> {
+                source?.let {
+                    report(Errors.FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE.onSource(it))
+                }
+            }
+        }
+    }
+}

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java

@@ -135,6 +135,9 @@ public interface Errors {
     DiagnosticFactory3<KtSuperTypeListEntry, EffectiveVisibility, DescriptorWithRelation, EffectiveVisibility> EXPOSED_SUPER_INTERFACE = DiagnosticFactory3.create(ERROR);
     DiagnosticFactory3<PsiElement, EffectiveVisibility, DescriptorWithRelation, EffectiveVisibility> EXPOSED_TYPEALIAS_EXPANDED_TYPE = DiagnosticFactory3.create(ERROR);
 
+    // (FIR) Exposed visibility group
+    DiagnosticFactory0<PsiElement> FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE = DiagnosticFactory0.create(ERROR);
+
     DiagnosticFactory2<KtExpression, KotlinType, Collection<ClassDescriptor>> INACCESSIBLE_TYPE = DiagnosticFactory2.create(WARNING);
 
     DiagnosticFactory1<KtElement, Collection<ClassDescriptor>> PLATFORM_CLASS_MAPPED_TO_KOTLIN = DiagnosticFactory1.create(WARNING);

compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java

@@ -82,6 +82,8 @@ public class DefaultErrorMessages {
         MAP.put(EXPOSED_SUPER_INTERFACE, "''{0}'' sub-interface exposes its ''{2}'' supertype{1}", TO_STRING, TO_STRING, TO_STRING);
         MAP.put(EXPOSED_TYPEALIAS_EXPANDED_TYPE, "''{0}'' typealias exposes ''{2}'' in expanded type{1}", TO_STRING, TO_STRING, TO_STRING);
 
+        MAP.put(FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE, "FIR_EXPOSED_TYPEALIAS_EXPANDED_TYPE");
+
         MAP.put(EXTENSION_SHADOWED_BY_MEMBER, "Extension is shadowed by a member: {0}", COMPACT_WITH_MODIFIERS);
         MAP.put(EXTENSION_FUNCTION_SHADOWED_BY_INNER_CLASS_CONSTRUCTOR,
                 "Extension function is shadowed by an inner class constructor: {0}", COMPACT_WITH_MODIFIERS);