[FIR] Add inline checker for bodies of inline functions

This checker doesn't support `@PublishedAPI` yet, so some BB tests for it
 were muted. #KT-46270

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt

@@ -731,6 +731,49 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
         val RETURN_NOT_ALLOWED by error<KtReturnExpression>(PositioningStrategy.RETURN_WITH_LABEL)
         val RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY by error<KtReturnExpression>(PositioningStrategy.RETURN_WITH_LABEL)
     }
+
+    val INLINE by object : DiagnosticGroup("Inline") {
+        val USAGE_IS_NOT_INLINABLE by error<KtElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
+            parameter<Symbol>("parameter")
+        }
+
+        val NON_LOCAL_RETURN_NOT_ALLOWED by error<KtElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
+            parameter<Symbol>("parameter")
+        }
+
+        val RECURSION_IN_INLINE by error<KtElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
+            parameter<Symbol>("symbol")
+        }
+
+        val NON_PUBLIC_CALL_FROM_PUBLIC_INLINE by error<KtElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
+            parameter<Symbol>("inlineDeclaration")
+            parameter<Symbol>("referencedDeclaration")
+        }
+
+        val PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE by error<KtElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
+            parameter<Symbol>("inlineDeclaration")
+            parameter<Symbol>("referencedDeclaration")
+        }
+
+        val PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR by error<KtElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
+            parameter<Symbol>("inlineDeclaration")
+            parameter<Symbol>("referencedDeclaration")
+        }
+
+        val PROTECTED_CALL_FROM_PUBLIC_INLINE by warning<KtElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
+            parameter<Symbol>("inlineDeclaration")
+            parameter<Symbol>("referencedDeclaration")
+        }
+
+        val PRIVATE_CLASS_MEMBER_FROM_INLINE by error<KtElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
+            parameter<Symbol>("inlineDeclaration")
+            parameter<Symbol>("referencedDeclaration")
+        }
+
+        val SUPER_CALL_FROM_PUBLIC_INLINE by warning<KtElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
+            parameter<Symbol>("symbol")
+        }
+    }
 }
 
 private val exposedVisibilityDiagnosticInit: DiagnosticBuilder.() -> Unit = {

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt

@@ -440,4 +440,15 @@ object FirErrors {
     val RETURN_NOT_ALLOWED by error0<KtReturnExpression>(SourceElementPositioningStrategies.RETURN_WITH_LABEL)
     val RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY by error0<KtReturnExpression>(SourceElementPositioningStrategies.RETURN_WITH_LABEL)
 
+    // Inline
+    val USAGE_IS_NOT_INLINABLE by error1<KtElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val NON_LOCAL_RETURN_NOT_ALLOWED by error1<KtElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val RECURSION_IN_INLINE by error1<KtElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val NON_PUBLIC_CALL_FROM_PUBLIC_INLINE by error2<KtElement, AbstractFirBasedSymbol<*>, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE by error2<KtElement, AbstractFirBasedSymbol<*>, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR by error2<KtElement, AbstractFirBasedSymbol<*>, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val PROTECTED_CALL_FROM_PUBLIC_INLINE by warning2<KtElement, AbstractFirBasedSymbol<*>, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val PRIVATE_CLASS_MEMBER_FROM_INLINE by error2<KtElement, AbstractFirBasedSymbol<*>, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val SUPER_CALL_FROM_PUBLIC_INLINE by warning1<KtElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+
 }

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

@@ -186,7 +186,8 @@ internal val FirDeclaration.isEnumEntryInitializer: Boolean
         return (containingClassAttr as? ConeClassLookupTagWithFixedSymbol)?.symbol?.fir?.classKind == ClassKind.ENUM_ENTRY
     }
 
-internal val FirMemberDeclaration.isLocalMember: Boolean
+// contract: returns(true) implies (this is FirMemberDeclaration)
+internal val FirDeclaration.isLocalMember: Boolean
     get() = when (this) {
         is FirProperty -> this.isLocal
         is FirRegularClass -> this.isLocal

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

@@ -0,0 +1,310 @@
+/*
+ * Copyright 2010-2021 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 org.jetbrains.kotlin.config.LanguageFeature
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.fir.*
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.util.checkChildrenWithCustomVisitor
+import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
+import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.expressions.*
+import org.jetbrains.kotlin.fir.references.FirSuperReference
+import org.jetbrains.kotlin.fir.resolve.inference.isBuiltinFunctionalType
+import org.jetbrains.kotlin.fir.resolve.inference.isFunctionalType
+import org.jetbrains.kotlin.fir.resolve.toSymbol
+import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol
+import org.jetbrains.kotlin.fir.types.coneType
+import org.jetbrains.kotlin.fir.types.isMarkedNullable
+import org.jetbrains.kotlin.fir.types.toSymbol
+import org.jetbrains.kotlin.fir.visitors.FirDefaultVisitor
+import org.jetbrains.kotlin.util.OperatorNameConventions
+
+object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
+    override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
+        if (!declaration.isInline) return
+        // local inline functions are prohibited
+        if (declaration.isLocalMember) return
+        if (declaration !is FirPropertyAccessor && declaration !is FirSimpleFunction) return
+
+        val effectiveVisibility = declaration.effectiveVisibility
+        val function = declaration as FirFunction<*>
+        checkInlineFunctionBody(function, effectiveVisibility, context, reporter)
+    }
+
+    private fun checkInlineFunctionBody(
+        function: FirFunction<*>,
+        effectiveVisibility: EffectiveVisibility,
+        context: CheckerContext,
+        reporter: DiagnosticReporter
+    ) {
+        val body = function.body ?: return
+        val inlinableParameters = function.valueParameters.filter {
+            if (it.isNoinline) return@filter false
+            val type = it.returnTypeRef.coneType
+            !type.isMarkedNullable && type.isFunctionalType(context.session) { kind -> !kind.isReflectType }
+        }
+
+        val visitor = Visitor(
+            function,
+            effectiveVisibility,
+            inlinableParameters,
+            context.session,
+            reporter
+        )
+        body.checkChildrenWithCustomVisitor(context, visitor)
+    }
+
+    private class Visitor(
+        val inlineFunction: FirFunction<*>,
+        val inlineFunEffectiveVisibility: EffectiveVisibility,
+        val inlinableParameters: List<FirValueParameter>,
+        val session: FirSession,
+        val reporter: DiagnosticReporter
+    ) : FirDefaultVisitor<Unit, CheckerContext>() {
+        private val isEffectivelyPrivateApiFunction: Boolean = inlineFunEffectiveVisibility.privateApi
+
+        private val prohibitProtectedCallFromInline: Boolean =
+            session.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitProtectedCallFromInline)
+
+        override fun visitElement(element: FirElement, data: CheckerContext) {}
+
+        override fun visitFunctionCall(functionCall: FirFunctionCall, data: CheckerContext) {
+            val targetSymbol = functionCall.toResolvedCallableSymbol()
+            checkReceiversOfQualifiedAccessExpression(functionCall, targetSymbol, data)
+            checkArgumentsOfCall(functionCall, targetSymbol, data)
+            checkQualifiedAccess(functionCall, targetSymbol, data)
+        }
+
+        override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: CheckerContext) {
+            val targetSymbol = qualifiedAccessExpression.toResolvedCallableSymbol()
+            checkQualifiedAccess(qualifiedAccessExpression, targetSymbol, data)
+            checkReceiversOfQualifiedAccessExpression(qualifiedAccessExpression, targetSymbol, data)
+        }
+
+        override fun visitVariableAssignment(variableAssignment: FirVariableAssignment, data: CheckerContext) {
+            val propertySymbol = variableAssignment.calleeReference.toResolvedCallableSymbol() as? FirPropertySymbol ?: return
+            val setterSymbol = propertySymbol.fir.setter?.symbol ?: return
+            checkQualifiedAccess(variableAssignment, setterSymbol, data)
+        }
+
+        private fun checkReceiversOfQualifiedAccessExpression(
+            qualifiedAccessExpression: FirQualifiedAccessExpression,
+            targetSymbol: AbstractFirBasedSymbol<*>?,
+            context: CheckerContext
+        ) {
+            checkReceiver(qualifiedAccessExpression, qualifiedAccessExpression.dispatchReceiver, targetSymbol, context)
+            checkReceiver(qualifiedAccessExpression, qualifiedAccessExpression.extensionReceiver, targetSymbol, context)
+        }
+
+        private fun checkArgumentsOfCall(
+            functionCall: FirFunctionCall,
+            targetSymbol: AbstractFirBasedSymbol<*>?,
+            context: CheckerContext
+        ) {
+            val calledFunction = (targetSymbol as? FirNamedFunctionSymbol)?.fir ?: return
+            val argumentMapping = functionCall.resolvedArgumentMapping ?: return
+            for ((wrappedArgument, valueParameter) in argumentMapping) {
+                val argument = wrappedArgument.unwrapArgument()
+                val resolvedArgumentSymbol = argument.toResolvedCallableSymbol() as? FirVariableSymbol<*> ?: continue
+
+                val valueParameterOfOriginalInlineFunction = inlinableParameters.firstOrNull { it == resolvedArgumentSymbol.fir }
+                if (valueParameterOfOriginalInlineFunction != null) {
+                    val factory = when {
+                        calledFunction.isInline -> when {
+                            valueParameter.isNoinline -> FirErrors.USAGE_IS_NOT_INLINABLE
+                            valueParameter.isCrossinline && !valueParameterOfOriginalInlineFunction.isCrossinline
+                            -> FirErrors.NON_LOCAL_RETURN_NOT_ALLOWED
+                            else -> continue
+                        }
+                        else -> FirErrors.USAGE_IS_NOT_INLINABLE
+                    }
+                    reporter.reportOn(argument.source, factory, valueParameterOfOriginalInlineFunction.symbol, context)
+                }
+            }
+        }
+
+        private fun checkReceiver(
+            qualifiedAccessExpression: FirQualifiedAccessExpression,
+            receiverExpression: FirExpression,
+            targetSymbol: AbstractFirBasedSymbol<*>?,
+            context: CheckerContext
+        ) {
+            val receiverSymbol = receiverExpression.toResolvedCallableSymbol() ?: return
+            if (receiverSymbol.fir in inlinableParameters) {
+                val valueParameter = receiverSymbol.fir as FirValueParameter
+                if (!isInvokeOrInlineExtension(targetSymbol)) {
+                    reporter.reportOn(
+                        qualifiedAccessExpression.source,
+                        FirErrors.USAGE_IS_NOT_INLINABLE,
+                        valueParameter.symbol,
+                        context
+                    )
+                }
+            }
+        }
+
+        private fun isInvokeOrInlineExtension(targetSymbol: AbstractFirBasedSymbol<*>?): Boolean {
+            if (targetSymbol !is FirNamedFunctionSymbol) return false
+            val function = targetSymbol.fir
+            if (function.isInline) return true
+            return function.name == OperatorNameConventions.INVOKE &&
+                    function.dispatchReceiverType?.isBuiltinFunctionalType(session) == true
+        }
+
+        private fun checkQualifiedAccess(
+            qualifiedAccess: FirQualifiedAccess,
+            targetSymbol: AbstractFirBasedSymbol<*>?,
+            context: CheckerContext
+        ) {
+            val source = qualifiedAccess.source ?: return
+            if (targetSymbol == null) return
+            val targetFir = targetSymbol.fir as? FirCallableMemberDeclaration<*>
+
+            if (targetSymbol.fir in inlinableParameters) {
+                if (!qualifiedAccess.partOfCall(context)) {
+                    val valueParameter = targetSymbol.fir as FirValueParameter
+                    reporter.reportOn(source, FirErrors.USAGE_IS_NOT_INLINABLE, valueParameter.symbol, context)
+                }
+            }
+            checkVisibilityAndAccess(qualifiedAccess, targetFir, source, context)
+            checkRecursion(targetSymbol, source, context)
+        }
+
+        private fun FirQualifiedAccess.partOfCall(context: CheckerContext): Boolean {
+            if (this !is FirExpression) return false
+            val containingQualifiedAccess = context.qualifiedAccesses.getOrNull(context.qualifiedAccesses.size - 2) ?: return false
+            if (this == containingQualifiedAccess.explicitReceiver) return true
+            val call = containingQualifiedAccess as? FirCall ?: return false
+            return call.arguments.any { it.unwrapArgument() == this }
+        }
+
+        private fun checkVisibilityAndAccess(
+            accessExpression: FirQualifiedAccess,
+            calledDeclaration: FirCallableMemberDeclaration<*>?,
+            source: FirSourceElement,
+            context: CheckerContext
+        ) {
+            if (calledDeclaration == null) return
+            val calledFunEffectiveVisibility = calledDeclaration.effectiveVisibility.let {
+                if (it == EffectiveVisibility.Local) {
+                    EffectiveVisibility.Public
+                } else {
+                    it
+                }
+            }
+            val isCalledFunPublicOrPublishedApi = calledFunEffectiveVisibility.publicApi
+            val isInlineFunPublicOrPublishedApi = inlineFunEffectiveVisibility.publicApi
+            if (isInlineFunPublicOrPublishedApi &&
+                !isCalledFunPublicOrPublishedApi &&
+                calledDeclaration.visibility !== Visibilities.Local
+            ) {
+                reporter.reportOn(
+                    source,
+                    FirErrors.NON_PUBLIC_CALL_FROM_PUBLIC_INLINE,
+                    calledDeclaration.symbol,
+                    inlineFunction.symbol,
+                    context
+                )
+            } else {
+                checkPrivateClassMemberAccess(calledDeclaration, source, context)
+                if (isInlineFunPublicOrPublishedApi) {
+                    checkSuperCalls(calledDeclaration, accessExpression, context)
+                }
+            }
+
+            val isConstructorCall = calledDeclaration is FirConstructor
+            if (
+                isInlineFunPublicOrPublishedApi &&
+                inlineFunEffectiveVisibility.toVisibility() !== Visibilities.Protected &&
+                calledFunEffectiveVisibility.toVisibility() === Visibilities.Protected
+            ) {
+                val factory = when {
+                    isConstructorCall -> FirErrors.PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE
+                    prohibitProtectedCallFromInline -> FirErrors.PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR
+                    else -> FirErrors.PROTECTED_CALL_FROM_PUBLIC_INLINE
+                }
+                reporter.reportOn(source, factory, calledDeclaration.symbol, inlineFunction.symbol, context)
+            }
+        }
+
+        private fun checkPrivateClassMemberAccess(
+            calledDeclaration: FirCallableMemberDeclaration<*>,
+            source: FirSourceElement,
+            context: CheckerContext
+        ) {
+            if (!isEffectivelyPrivateApiFunction) {
+                if (calledDeclaration.isInsidePrivateClass()) {
+                    reporter.reportOn(
+                        source,
+                        FirErrors.PRIVATE_CLASS_MEMBER_FROM_INLINE,
+                        calledDeclaration.symbol,
+                        inlineFunction.symbol,
+                        context
+                    )
+                }
+            }
+        }
+
+        private fun checkSuperCalls(
+            calledDeclaration: FirCallableMemberDeclaration<*>,
+            callExpression: FirQualifiedAccess,
+            context: CheckerContext
+        ) {
+            val receiver = callExpression.dispatchReceiver as? FirQualifiedAccessExpression ?: return
+            if (receiver.calleeReference is FirSuperReference) {
+                val dispatchReceiverType = receiver.dispatchReceiver.typeRef.coneType
+                val classSymbol = dispatchReceiverType.toSymbol(session) ?: return
+                if (!classSymbol.isDefinedInInlineFunction()) {
+                    reporter.reportOn(
+                        callExpression.dispatchReceiver.source,
+                        FirErrors.SUPER_CALL_FROM_PUBLIC_INLINE,
+                        calledDeclaration.symbol,
+                        context
+                    )
+                }
+            }
+        }
+
+        private fun AbstractFirBasedSymbol<*>.isDefinedInInlineFunction(): Boolean {
+            return when (val fir = this.fir) {
+                is FirAnonymousFunction -> true
+                is FirMemberDeclaration -> fir.isLocalMember
+                is FirAnonymousObject -> true
+                is FirRegularClass -> fir.classId.isLocal
+                else -> error("Unknown callable declaration type: ${fir.render()}")
+            }
+        }
+
+        private fun checkRecursion(
+            targetSymbol: AbstractFirBasedSymbol<*>,
+            source: FirSourceElement,
+            context: CheckerContext
+        ) {
+            if (targetSymbol == inlineFunction.symbol) {
+                reporter.reportOn(source, FirErrors.RECURSION_IN_INLINE, targetSymbol, context)
+            }
+        }
+
+        private fun FirCallableMemberDeclaration<*>.isInsidePrivateClass(): Boolean {
+            val containingClass = this.containingClass()?.toSymbol(session)?.fir ?: return false
+
+            val containingClassVisibility = when (containingClass) {
+                is FirAnonymousObject -> return false
+                is FirRegularClass -> containingClass.visibility
+                is FirTypeAlias -> containingClass.visibility
+            }
+            return containingClassVisibility == Visibilities.Private || containingClassVisibility == Visibilities.PrivateToThis
+        }
+    }
+}

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/util/firCheckersUtils.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright 2010-2021 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.util
+
+import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.context.PersistentCheckerContext
+import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollectorVisitor
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+
+fun FirElement.checkChildrenWithCustomVisitor(
+    parentContext: CheckerContext,
+    visitorVoid: FirVisitor<Unit, CheckerContext>
+) {
+    val collectingVisitor = object : AbstractDiagnosticCollectorVisitor(parentContext as PersistentCheckerContext) {
+        override fun checkElement(element: FirElement) {
+            element.accept(visitorVoid, context)
+        }
+    }
+    this.accept(collectingVisitor, null)
+}

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt

@@ -170,9 +170,11 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NONE_APPLICABLE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_ABSTRACT_FUNCTION_WITH_NO_BODY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_FINAL_MEMBER_IN_FINAL_CLASS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_FINAL_MEMBER_IN_OBJECT
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_LOCAL_RETURN_NOT_ALLOWED
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_MEMBER_FUNCTION_NO_BODY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_PRIVATE_CONSTRUCTOR_IN_ENUM
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_PRIVATE_OR_PROTECTED_CONSTRUCTOR_IN_SEALED
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_PUBLIC_CALL_FROM_PUBLIC_INLINE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_VARARG_SPREAD
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NOTHING_TO_OVERRIDE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NOT_AN_ANNOTATION_CLASS
@@ -193,6 +195,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OVERLOAD_RESOLUTI
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OVERRIDING_FINAL_MEMBER
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRIVATE_CLASS_MEMBER_FROM_INLINE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRIVATE_FUNCTION_WITH_NO_BODY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRIVATE_PROPERTY_IN_INTERFACE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRIVATE_SETTER_FOR_ABSTRACT_PROPERTY
@@ -203,8 +206,12 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PROPERTY_INITIALI
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PROPERTY_TYPE_MISMATCH_ON_OVERRIDE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PROPERTY_WITH_BACKING_FIELD_INSIDE_INLINE_CLASS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PROPERTY_WITH_NO_TYPE_NO_INITIALIZER
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PROTECTED_CALL_FROM_PUBLIC_INLINE
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.QUALIFIED_SUPERTYPE_EXTENDED_BY_OTHER_SUPERTYPE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RECURSION_IN_IMPLICIT_TYPES
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RECURSION_IN_INLINE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.RECURSION_IN_SUPERTYPES
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDECLARATION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.REDUNDANT_CALL_OF_CONVERSION_METHOD
@@ -235,6 +242,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPERTYPE_INITIAL
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPERTYPE_INITIALIZED_WITHOUT_PRIMARY_CONSTRUCTOR
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPERTYPE_NOT_A_CLASS_OR_INTERFACE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPERTYPE_NOT_INITIALIZED
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPER_CALL_FROM_PUBLIC_INLINE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPER_IS_NOT_AN_EXPRESSION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPER_NOT_AVAILABLE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SYNTAX
@@ -269,6 +277,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UNSUPPORTED_FEATU
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UNUSED_VARIABLE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UPPER_BOUND_IS_EXTENSION_FUNCTION_TYPE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.UPPER_BOUND_VIOLATED
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.USAGE_IS_NOT_INLINABLE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.USELESS_ELVIS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.USELESS_ELVIS_RIGHT_IS_NULL
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.USELESS_VARARG_ON_PARAMETER
@@ -905,6 +914,45 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
                 "Returns are not allowed for functions with expression body. Use block body in '{...}'"
             )
 
+            // Inline
+            map.put(
+                USAGE_IS_NOT_INLINABLE,
+                "Illegal usage of inline-parameter ''{0}''. Add ''noinline'' modifier to the parameter declaration",
+                SYMBOL
+            )
+            map.put(
+                NON_LOCAL_RETURN_NOT_ALLOWED,
+                "Can''t inline ''{0}'' here: it may contain non-local returns. Add ''crossinline'' modifier to parameter declaration ''{0}''",
+                SYMBOL
+            )
+            map.put(RECURSION_IN_INLINE, "Inline function ''{0}'' cannot be recursive", SYMBOL)
+            map.put(NON_PUBLIC_CALL_FROM_PUBLIC_INLINE, "Public-API inline function cannot access non-public-API ''{1}''", SYMBOL, SYMBOL)
+            map.put(
+                PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE,
+                "Protected constructor call from public-API inline function is deprecated",
+                SYMBOL,
+                SYMBOL
+            )
+            map.put(
+                PROTECTED_CALL_FROM_PUBLIC_INLINE,
+                "Protected function call from public-API inline function is deprecated",
+                SYMBOL,
+                SYMBOL
+            )
+            map.put(
+                PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR,
+                "Protected function call from public-API inline function is prohibited",
+                SYMBOL,
+                SYMBOL
+            )
+            map.put(
+                PRIVATE_CLASS_MEMBER_FROM_INLINE,
+                "Non-private inline function cannot access members of private classes: ''{1}''",
+                SYMBOL,
+                SYMBOL
+            )
+            map.put(SUPER_CALL_FROM_PUBLIC_INLINE, "Accessing super members from public-API inline function is deprecated", SYMBOL)
+
             // Extended checkers group
             map.put(REDUNDANT_VISIBILITY_MODIFIER, "Redundant visibility modifier")
             map.put(REDUNDANT_MODALITY_MODIFIER, "Redundant modality modifier")

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonDeclarationCheckers.kt

@@ -31,6 +31,7 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
             FirSealedSupertypeChecker,
             FirTypeAliasChecker,
             FirCyclicTypeBoundsChecker,
+            FirInlineDeclarationChecker,
         )
 
     override val functionCheckers: Set<FirFunctionChecker>

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.expressions.impl.FirBlockImpl
 import org.jetbrains.kotlin.fir.expressions.impl.FirPartiallyResolvedArgumentList
 import org.jetbrains.kotlin.fir.expressions.impl.FirResolvedArgumentList
 import org.jetbrains.kotlin.fir.expressions.impl.FirSingleExpressionBlock
+import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
@@ -65,6 +66,10 @@ fun FirExpression.toResolvedCallableSymbol(): FirCallableSymbol<*>? {
     return toResolvedCallableReference()?.resolvedSymbol as FirCallableSymbol<*>?
 }
 
+fun FirReference.toResolvedCallableSymbol(): FirCallableSymbol<*>? {
+    return (this as? FirResolvedNamedReference)?.resolvedSymbol as? FirCallableSymbol<*>
+}
+
 fun buildErrorLoop(source: FirSourceElement?, diagnostic: ConeDiagnostic): FirErrorLoop {
     return buildErrorLoop {
         this.source = source
@@ -109,4 +114,4 @@ fun FirBlock.replaceFirstStatement(statement: FirStatement): FirStatement {
     return existed
 }
 
-fun FirExpression.unwrapArgument(): FirExpression = (this as? FirWrappedArgumentExpression)?.expression ?: this
+fun FirExpression.unwrapArgument(): FirExpression = (this as? FirWrappedArgumentExpression)?.expression ?: this

compiler/testData/codegen/box/publishedApi/noMangling.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 //WITH_REFLECT
 class A {

compiler/testData/codegen/box/publishedApi/simple.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND_FIR: JVM_IR
 // MODULE: lib
 // FILE: lib.kt
 class A {
@@ -13,4 +14,4 @@ class A {
 // FILE: main.kt
 fun box(): String {
     return A().test()
-}
+}

compiler/testData/codegen/box/publishedApi/topLevel.kt

@@ -1,3 +1,4 @@
+// IGNORE_BACKEND_FIR: JVM_IR
 // MODULE: lib
 // FILE: lib.kt
 @PublishedApi
@@ -7,4 +8,4 @@ inline fun test() = published()
 
 // MODULE: main(lib)
 // FILE: main.kt
-fun box() = test()
+fun box() = test()

compiler/testData/diagnostics/tests/inline/assignment.fir.kt

@@ -1,14 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
-inline fun inlineFunWithInvoke(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
-    var d = s
-    d = s
-
-    var e = ext
-    e = ext
-}
-
-
-inline fun Function1<Int, Unit>.inlineExt() {
-    var d = this
-    d = this
-}

compiler/testData/diagnostics/tests/inline/assignment.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE
 inline fun inlineFunWithInvoke(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
     var d = <!USAGE_IS_NOT_INLINABLE!>s<!>
@@ -11,4 +12,4 @@ inline fun inlineFunWithInvoke(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
 inline fun Function1<Int, Unit>.inlineExt() {
     var d = this
     d = this
-}
+}

compiler/testData/diagnostics/tests/inline/binaryExpressions/andOr.fir.kt

@@ -1,17 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -TYPE_MISMATCH
-
-inline fun inlineFunWithInvoke(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
-    s && ext
-    s || s
-}
-
-inline fun inlineFunWithInvokeNonInline(noinline s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
-    s && ext
-    s || s
-}
-
-inline fun Function1<Int, Unit>.inlineExt() {
-    invoke(11)
-    this && this
-    this || this
-}

compiler/testData/diagnostics/tests/inline/binaryExpressions/andOr.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -TYPE_MISMATCH
 
 inline fun inlineFunWithInvoke(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
@@ -14,4 +15,4 @@ inline fun Function1<Int, Unit>.inlineExt() {
     invoke(11)
     this && this
     this || this
-}
+}

compiler/testData/diagnostics/tests/inline/binaryExpressions/arrayAccess.fir.kt

@@ -17,6 +17,6 @@ operator fun <T, U, V, W> @ExtensionFunctionType Function3<T, U, V, W>.get(index
 }
 
 inline fun <T, U, V, W> inlineFunWithInvoke(s: (p: T, l: U) -> V, ext: T.(p: U, l: V) -> W) {
-    s[1]
-    ext[1]
+    <!USAGE_IS_NOT_INLINABLE!>s[1]<!>
+    <!USAGE_IS_NOT_INLINABLE!>ext[1]<!>
 }

compiler/testData/diagnostics/tests/inline/binaryExpressions/assignment.fir.kt

@@ -8,8 +8,8 @@ inline operator fun <T, U> Function1<T, U>.modAssign(p: Function1<T, U>) = {
 }
 
 inline operator fun <T, U> Function1<T, U>.plusAssign(p: Function1<T, U>) {
-    this -= p
-    p -= this
+    this -= <!USAGE_IS_NOT_INLINABLE!>p<!>
+    p <!USAGE_IS_NOT_INLINABLE!>-=<!> this
 }
 
 operator fun <T, U, V> @ExtensionFunctionType Function2<T, U, V>.minusAssign(ext : @ExtensionFunctionType Function2<T, U, V>) {}
@@ -20,11 +20,11 @@ inline operator fun <T, U, V> @ExtensionFunctionType Function2<T, U, V>.modAssig
 }
 
 inline operator fun <T, U, V> @ExtensionFunctionType Function2<T, U, V>.plusAssign(ext : @ExtensionFunctionType Function2<T, U, V>) {
-    this -= ext
-    ext -= this
+    this -= <!USAGE_IS_NOT_INLINABLE!>ext<!>
+    ext <!USAGE_IS_NOT_INLINABLE!>-=<!> this
 }
 
 inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
     s += s
     ext += ext
-}
+}

compiler/testData/diagnostics/tests/inline/binaryExpressions/comparison.fir.kt

@@ -14,13 +14,13 @@ operator fun <T, U, V> Function2<T, U, V>.compareTo(index : Function2<T, U, V>)
 operator fun <T, U, V, W> @ExtensionFunctionType Function3<T, U, V, W>.compareTo(index : @ExtensionFunctionType Function3<T, U, V, W>) = 1
 
 inline fun <T, U, V, W> inlineFunWithInvoke(s: (p: T, l: U) -> V, ext: T.(p: U, l: V) -> W) {
-    s < s
-    s <= s
-    s > s
-    s >= s
+    s <!USAGE_IS_NOT_INLINABLE!><<!> <!USAGE_IS_NOT_INLINABLE!>s<!>
+    s <!USAGE_IS_NOT_INLINABLE!><=<!> <!USAGE_IS_NOT_INLINABLE!>s<!>
+    s <!USAGE_IS_NOT_INLINABLE!>><!> <!USAGE_IS_NOT_INLINABLE!>s<!>
+    s <!USAGE_IS_NOT_INLINABLE!>>=<!> <!USAGE_IS_NOT_INLINABLE!>s<!>
 
-    ext < ext
-    ext > ext
-    ext <= ext
-    ext >= ext
+    ext <!USAGE_IS_NOT_INLINABLE!><<!> <!USAGE_IS_NOT_INLINABLE!>ext<!>
+    ext <!USAGE_IS_NOT_INLINABLE!>><!> <!USAGE_IS_NOT_INLINABLE!>ext<!>
+    ext <!USAGE_IS_NOT_INLINABLE!><=<!> <!USAGE_IS_NOT_INLINABLE!>ext<!>
+    ext <!USAGE_IS_NOT_INLINABLE!>>=<!> <!USAGE_IS_NOT_INLINABLE!>ext<!>
 }

compiler/testData/diagnostics/tests/inline/binaryExpressions/componentAccess.fir.kt

@@ -3,7 +3,7 @@ inline operator fun <T, U> Function1<T, U>.component1() = 1
 inline operator fun <T, U> Function1<T, U>.component2() = 2
 
 inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U) {
-    val (d1, e1) = s
+    val (d1, e1) = <!USAGE_IS_NOT_INLINABLE!>s<!>
 }
 
 operator fun <T, U, V> Function2<T, U, V>.component1() = 1
@@ -13,6 +13,6 @@ operator fun <T, U, V, W> @ExtensionFunctionType Function3<T, U, V, W>.component
 operator fun <T, U, V, W> @ExtensionFunctionType Function3<T, U, V, W>.component2() = 2
 
 inline fun <T, U, V, W> inlineFunWithInvoke(s: (p: T, l: U) -> V, ext: T.(p: U, l: V) -> W) {
-    val (d1, e1) = s
-    val (d2, e2) = ext
+    val (d1, e1) = <!USAGE_IS_NOT_INLINABLE!>s<!>
+    val (d2, e2) = <!USAGE_IS_NOT_INLINABLE!>ext<!>
 }

compiler/testData/diagnostics/tests/inline/binaryExpressions/contains.fir.kt

@@ -16,9 +16,9 @@ operator fun <T, U, V> Function2<T, U, V>.contains(p: Function2<T, U, V>): Boole
 operator fun <T, U, V, W> @ExtensionFunctionType Function3<T, U, V, W>.contains(ext: @ExtensionFunctionType Function3<T, U, V, W>): Boolean = false
 
 inline fun <T, U, V> inlineFunWithInvoke(s: (p: T, l: U) -> U, ext: T.(p: U, l: U) -> V) {
-    s in s
-    s !in s
+    <!USAGE_IS_NOT_INLINABLE!>s<!> <!USAGE_IS_NOT_INLINABLE!>in<!> s
+    <!USAGE_IS_NOT_INLINABLE!>s<!> <!USAGE_IS_NOT_INLINABLE!>!in<!> s
 
-    ext in ext
-    ext !in ext
+    <!USAGE_IS_NOT_INLINABLE!>ext<!> <!USAGE_IS_NOT_INLINABLE!>in<!> ext
+    <!USAGE_IS_NOT_INLINABLE!>ext<!> <!USAGE_IS_NOT_INLINABLE!>!in<!> ext
 }

compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.fir.kt

@@ -1,34 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -CONFLICTING_JVM_DECLARATIONS -CONFLICTING_OVERLOADS
-operator fun <T, U> Function1<T, U>.minus(p: Function1<T, U>) {
-
-}
-
-operator fun <T, U, V> @ExtensionFunctionType Function2<T, U, V>.minus(p: T.(p: U) -> V) {
-
-}
-
-inline operator fun <T, U> Function1<T, U>.plus(p: Function1<T, U>) {
-    this - p
-}
-
-inline operator fun <T, U, V> @ExtensionFunctionType Function2<T, U, V>.plus(p: T.(p: U) -> V) {
-    this - p
-}
-
-inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
-    s + s
-    ext + ext
-}
-
-inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U, ext: T.(p: U) -> V) {
-    s + s
-    ext + ext
-}
-
-inline fun <T, U> Function1<T, U>.submit() {
-    this + this
-}
-
-inline fun <T, U, V> @ExtensionFunctionType Function2<T, U, V>.submit() {
-    this + this
-}

compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -CONFLICTING_JVM_DECLARATIONS -CONFLICTING_OVERLOADS
 operator fun <T, U> Function1<T, U>.minus(p: Function1<T, U>) {
 

compiler/testData/diagnostics/tests/inline/binaryExpressions/rangeTo.fir.kt

@@ -21,9 +21,9 @@ operator fun <T, U, V, W> @ExtensionFunctionType Function3<T, U, V, W>.rangeTo(e
 }
 
 inline fun <T, U, V> inlineFunWithInvoke(s: (p: T, l: U) -> U, ext: T.(p: U, l: U) -> V) {
-    s..s
-    s..s
+    s<!USAGE_IS_NOT_INLINABLE!>..<!><!USAGE_IS_NOT_INLINABLE!>s<!>
+    s<!USAGE_IS_NOT_INLINABLE!>..<!><!USAGE_IS_NOT_INLINABLE!>s<!>
 
-    ext..ext
-    ext..ext
+    ext<!USAGE_IS_NOT_INLINABLE!>..<!><!USAGE_IS_NOT_INLINABLE!>ext<!>
+    ext<!USAGE_IS_NOT_INLINABLE!>..<!><!USAGE_IS_NOT_INLINABLE!>ext<!>
 }

compiler/testData/diagnostics/tests/inline/capture.fir.kt

@@ -46,6 +46,6 @@ inline fun testExtension(s: (p: Int) -> Unit) {
 
 inline fun inlineFunWrongExtension(s: (p: Int) -> Unit) {
     {
-        s.noInlineExt(11)
+        s.<!USAGE_IS_NOT_INLINABLE!>noInlineExt<!>(11)
     } ()
-}
+}

compiler/testData/diagnostics/tests/inline/extensionOnFunction.fir.kt

@@ -20,9 +20,9 @@ inline fun testExtension(s: (p: Int) -> Unit) {
 }
 
 inline fun inlineFunWrongExtension(s: (p: Int) -> Unit) {
-    s.noInlineExt(11)
+    s.<!USAGE_IS_NOT_INLINABLE!>noInlineExt<!>(11)
 }
 
 inline fun inlineFunNoInline(noinline s: (p: Int) -> Unit) {
     s.noInlineExt(11)
-}
+}

compiler/testData/diagnostics/tests/inline/fromInlineToNoInline.fir.kt

@@ -1,7 +1,7 @@
 inline fun <R> onlyLocal(p: () -> R) {
-    inlineAll(p)
+    inlineAll(<!USAGE_IS_NOT_INLINABLE!>p<!>)
 }
 
 inline fun <R> inlineAll(noinline p: () -> R) {
     p()
-}
+}

compiler/testData/diagnostics/tests/inline/functions.fir.kt

@@ -1,12 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -UNNECESSARY_NOT_NULL_ASSERTION -UNNECESSARY_SAFE_CALL
-
-fun getFun(s: (p: Int) -> Unit): Function1<Int, Int> = {11}
-
-inline fun getInlineFun(s: (p: Int) -> Unit): Function1<Int, Int> = {11}
-
-inline fun testExtension(s: (p: Int) -> Unit) {
-    getFun(s).invoke(10)
-    getInlineFun(s).invoke(10)
-    getInlineFun(s)!!.invoke(10)
-    getInlineFun(s)?.invoke(10)
-}

compiler/testData/diagnostics/tests/inline/functions.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -UNNECESSARY_NOT_NULL_ASSERTION -UNNECESSARY_SAFE_CALL
 
 fun getFun(s: (p: Int) -> Unit): Function1<Int, Int> = {11}
@@ -9,4 +10,4 @@ inline fun testExtension(s: (p: Int) -> Unit) {
     getInlineFun(s).invoke(10)
     getInlineFun(s)!!.invoke(10)
     getInlineFun(s)?.invoke(10)
-}
+}

compiler/testData/diagnostics/tests/inline/isCheck.fir.kt

@@ -5,6 +5,6 @@ inline public fun reg(converter: (Any) -> Any, flag: Boolean) {
 }
 
 public inline fun register(converter: (Any) -> Any) {
-    converter is (Any) -> Any
-    reg(converter, converter is (Any) -> Any)
-}
+    <!USAGE_IS_NOT_INLINABLE!>converter<!> is (Any) -> Any
+    reg(converter, <!USAGE_IS_NOT_INLINABLE!>converter<!> is (Any) -> Any)
+}

compiler/testData/diagnostics/tests/inline/kt15410.fir.kt

@@ -6,5 +6,5 @@ open class Foo protected constructor()
 inline fun foo(f: () -> Unit) = object: Foo() {}
 
 class A : Foo() {
-    inline fun foo(f: () -> Unit) = Foo()
+    inline fun foo(f: () -> Unit) = <!PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE!>Foo<!>()
 }

compiler/testData/diagnostics/tests/inline/kt19679.fir.kt

@@ -1,4 +1,4 @@
 inline fun test(s: () -> Unit, p: (() -> Unit)?) {
     s()
     p?.invoke()
-}
+}

compiler/testData/diagnostics/tests/inline/kt21177.fir.kt

@@ -1,18 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-
-class SomeContainer {
-    protected class Limit
-
-    protected fun makeLimit(): Limit = TODO()
-
-    public inline fun foo(f: () -> Unit) {
-        Limit()
-        makeLimit()
-    }
-}
-
-open class A protected constructor() {
-    inline fun foo(f: () -> Unit) {
-        A()
-    }
-}

compiler/testData/diagnostics/tests/inline/kt21177.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 class SomeContainer {

compiler/testData/diagnostics/tests/inline/kt4869.fir.kt

@@ -2,5 +2,5 @@ inline fun foo(f: () -> Unit) {
     val ff = { f: () -> Unit ->
         f.invoke()
     }
-    ff(f)
+    ff(<!USAGE_IS_NOT_INLINABLE!>f<!>)
 }

compiler/testData/diagnostics/tests/inline/labeled.fir.kt

@@ -24,7 +24,7 @@ inline fun foo(bar1: (String.() -> Int) -> Int, bar2: (()->Int) -> Int) {
 }
 
 inline fun foo2(bar1: (String.() -> Int) -> Int) {
-    l1@ bar1
+    l1@ <!USAGE_IS_NOT_INLINABLE!>bar1<!>
 
     l2@ bar1 {
         11
@@ -37,4 +37,4 @@ inline fun foo2(bar1: (String.() -> Int) -> Int) {
     (l5@ (l4@ bar1)) {
         11
     }
-}
+}

compiler/testData/diagnostics/tests/inline/lambdaCast.fir.kt

@@ -1,9 +0,0 @@
-// !DIAGNOSTICS: -UNCHECKED_CAST -USELESS_CAST
-inline public fun reg(convertFunc: (Any) -> Any) {
-    convertFunc("")
-}
-
-public inline fun <reified T : Any, reified R : Any> register(converter: (T) -> R) {
-    converter as (Any) -> Any
-    reg(converter as (Any) -> Any)
-}

compiler/testData/diagnostics/tests/inline/lambdaCast.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNCHECKED_CAST -USELESS_CAST
 inline public fun reg(convertFunc: (Any) -> Any) {
     convertFunc("")
@@ -6,4 +7,4 @@ inline public fun reg(convertFunc: (Any) -> Any) {
 public inline fun <reified T : Any, reified R : Any> register(converter: (T) -> R) {
     <!USAGE_IS_NOT_INLINABLE!>converter<!> as (Any) -> Any
     reg(<!USAGE_IS_NOT_INLINABLE!>converter<!> as (Any) -> Any)
-}
+}

compiler/testData/diagnostics/tests/inline/nonLocalReturns/toOnlyLocal.fir.kt

@@ -1,8 +0,0 @@
-
-inline fun <R> toOnlyLocal(crossinline p: () -> R) {
-    p()
-}
-
-inline fun <R> inlineAll(p: () -> R) {
-    toOnlyLocal(p)
-}

compiler/testData/diagnostics/tests/inline/nonLocalReturns/toOnlyLocal.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 
 inline fun <R> toOnlyLocal(crossinline p: () -> R) {
     p()

compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicClass.fir.kt

@@ -1,47 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -PRIVATE_CLASS_MEMBER_FROM_INLINE
-private class Z public constructor(){
-    public val publicProperty:Int = 12
-    public fun publicFun() {}
-}
-
-public inline fun test() {
-    Z().publicProperty
-    Z().publicFun()
-}
-
-internal inline fun testInternal() {
-    Z().publicProperty
-    Z().publicFun()
-}
-
-internal class Z2 {
-    private val privateProperty = 11;
-
-    public val publicProperty:Int = 12
-
-    private fun privateFun() {}
-
-    public fun publicFun() {}
-
-    public inline fun test() {
-        privateProperty
-        privateFun()
-        publicProperty
-        publicFun()
-        Z2().publicProperty
-        Z2().publicFun()
-        Z2().privateProperty
-        Z2().privateFun()
-    }
-
-    internal inline fun testInternal() {
-        privateProperty
-        privateFun()
-        publicProperty
-        publicFun()
-        Z2().publicProperty
-        Z2().publicFun()
-        Z2().privateProperty
-        Z2().privateFun()
-    }
-}

compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicClass.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -PRIVATE_CLASS_MEMBER_FROM_INLINE
 private class Z public constructor(){
     public val publicProperty:Int = 12

compiler/testData/diagnostics/tests/inline/nonPublicMember/inPackage.fir.kt

@@ -1,27 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE
-
-private val privateProperty = 11;
-private fun privateFun() {}
-
-internal val internalProperty = 11;
-internal fun internalFun() {}
-
-public inline fun test() {
-    privateFun()
-    privateProperty
-}
-
-public inline fun test2() {
-    internalFun()
-    internalProperty
-}
-
-internal inline fun testInternal() {
-    privateFun()
-    privateProperty
-}
-
-internal inline fun test2Internal() {
-    internalFun()
-    internalProperty
-}

compiler/testData/diagnostics/tests/inline/nonPublicMember/inPackage.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE
 
 private val privateProperty = 11;

compiler/testData/diagnostics/tests/inline/nonPublicMember/inPublicClass.fir.kt

@@ -1,37 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE
-public class Z {
-    internal val privateProperty = 11;
-
-    internal fun privateFun() {
-
-    }
-}
-
-public inline fun test() {
-    Z().privateProperty
-    Z().privateFun()
-}
-
-internal inline fun testInternal() {
-    Z().privateProperty
-    Z().privateFun()
-}
-
-
-public class Z2 {
-    private val privateProperty = 11;
-
-    private fun privateFun() {
-
-    }
-
-    public inline fun test() {
-        privateProperty
-        privateFun()
-    }
-
-    internal inline fun testInternal() {
-        privateProperty
-        privateFun()
-    }
-}

compiler/testData/diagnostics/tests/inline/nonPublicMember/inPublicClass.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE
 public class Z {
     internal val privateProperty = 11;

compiler/testData/diagnostics/tests/inline/nonPublicMember/publishedApi.fir.kt

@@ -2,11 +2,11 @@
 
 
 inline fun call(a: A) {
-    a.test()
+    a.<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>test<!>()
 
-    privateFun()
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>privateFun<!>()
 
-    internalFun()
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>internalFun<!>()
 }
 
 @PublishedApi

compiler/testData/diagnostics/tests/inline/nullabilityOperations.fir.kt

@@ -1,16 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNNECESSARY_SAFE_CALL -UNNECESSARY_NOT_NULL_ASSERTION -CONFLICTING_JVM_DECLARATIONS
-inline fun String.submit(action: Function1<Int, Int>) {
-
-}
-
-inline fun Function1<Int, Int>.submit() {
-    this?.invoke(11)
-    this!!.invoke(11)
-
-    submit(this!!)
-}
-
-inline fun submit(action: Function1<Int, Int>) {
-    action?.invoke(10)
-    action!!.invoke(10)
-}

compiler/testData/diagnostics/tests/inline/nullabilityOperations.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -UNNECESSARY_SAFE_CALL -UNNECESSARY_NOT_NULL_ASSERTION -CONFLICTING_JVM_DECLARATIONS
 inline fun String.submit(action: Function1<Int, Int>) {
 
@@ -13,4 +14,4 @@ inline fun Function1<Int, Int>.submit() {
 inline fun submit(action: Function1<Int, Int>) {
     <!USAGE_IS_NOT_INLINABLE!>action<!>?.invoke(10)
     <!USAGE_IS_NOT_INLINABLE!>action<!>!!.invoke(10)
-}
+}

compiler/testData/diagnostics/tests/inline/nullableFunction.fir.kt

@@ -18,4 +18,4 @@ public inline fun <T> Function1<Int, Int>?.submit() {
 
 public inline fun <T> submit(action: Function1<Int, Int>?) {
 
-}
+}

compiler/testData/diagnostics/tests/inline/parenthesized.fir.kt

@@ -4,7 +4,7 @@ inline fun inlineFunWithInvoke(s: (p: Int) -> Unit) {
     (s)(11)
     (s).invoke(11)
     (s) invoke 11
-    (s)
+    (<!USAGE_IS_NOT_INLINABLE!>s<!>)
 }
 
 inline fun Function1<Int, Unit>.inlineExt() {
@@ -18,10 +18,10 @@ inline fun inlineFunWithInvoke2(s: (p: Int) -> Unit) {
     (((s)))(11)
     (((s))).invoke(11)
     (((s))) invoke 11
-    (((s)))
+    (((<!USAGE_IS_NOT_INLINABLE!>s<!>)))
 }
 
 inline fun propagation(s: (p: Int) -> Unit) {
     inlineFunWithInvoke((label@ s))
     inlineFunWithInvoke((label2@ label@ s))
-}
+}

compiler/testData/diagnostics/tests/inline/privateClass.fir.kt

@@ -1,25 +0,0 @@
-// !DIAGNOSTICS: -EXPOSED_PARAMETER_TYPE
-
-private class S public constructor() {
-    fun a() {
-
-    }
-}
-
-internal inline fun x(s: S, z: () -> Unit) {
-    z()
-    S()
-    s.a()
-    test()
-}
-
-private inline fun x2(s: S, z: () -> Unit) {
-    z()
-    S()
-    s.a()
-    test()
-}
-
-private fun test(): S {
-    return S()
-}

compiler/testData/diagnostics/tests/inline/privateClass.kt

@@ -1,3 +1,5 @@
+// FIR_IDENTICAL
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -EXPOSED_PARAMETER_TYPE
 
 private class S public constructor() {

compiler/testData/diagnostics/tests/inline/propagation.fir.kt

@@ -1,37 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -NON_LOCAL_RETURN_NOT_ALLOWED
-
-inline fun inlineFunWithInvoke(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
-    subInline(s, ext)
-    subNoInline(s, ext)
-}
-
-inline fun inlineFunWithInvokeClosure(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
-    subInline({p: Int -> s(p)}, { p -> this.ext(p)})
-    subNoInline({p: Int -> s(p)}, { p -> this.ext(p)})
-}
-
-//No inline
-inline fun inlineFunWithInvokeNonInline(noinline s: (p: Int) -> Unit, noinline ext: Int.(p: Int) -> Unit) {
-    subInline(s, ext)
-    subNoInline(s, ext)
-}
-
-inline fun inlineFunWithInvokeClosureNoinline(noinline s: (p: Int) -> Unit, noinline ext: Int.(p: Int) -> Unit) {
-    subInline({p: Int -> s(p)}, { p -> this.ext(p)})
-    subNoInline({p: Int -> s(p)}, { p -> this.ext(p)})
-}
-
-//ext function
-inline fun Function1<Int, Unit>.inlineExt(ext: Int.(p: Int) -> Unit) {
-    subInline(this, ext)
-    subNoInline(this, ext)
-}
-
-inline fun Function1<Int, Unit>.inlineExtWithClosure(ext: Int.(p: Int) -> Unit) {
-    subInline({p: Int -> this(p)}, { p -> this.ext(p)})
-    subNoInline({p: Int -> this(p)}, { p -> this.ext(p)})
-}
-
-inline fun subInline(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {}
-
-fun subNoInline(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {}

compiler/testData/diagnostics/tests/inline/propagation.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -NON_LOCAL_RETURN_NOT_ALLOWED
 
 inline fun inlineFunWithInvoke(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {

compiler/testData/diagnostics/tests/inline/protectedCallDepecation.fir.kt

@@ -18,10 +18,10 @@ open class A {
         protected set(value) {}
 
     inline fun call() {
-        test()
-        z
+        <!PROTECTED_CALL_FROM_PUBLIC_INLINE!>test<!>()
+        <!PROTECTED_CALL_FROM_PUBLIC_INLINE!>z<!>
         zVar
-        zVar = "123"
+        zVar <!PROTECTED_CALL_FROM_PUBLIC_INLINE!>=<!> "123"
     }
 
     internal inline fun callFromInternal() {
@@ -48,13 +48,13 @@ open class A {
 
 class B : A() {
     inline fun testB() {
-        test()
+        <!PROTECTED_CALL_FROM_PUBLIC_INLINE!>test<!>()
     }
 }
 
 class C : JavaClass() {
     inline fun call() {
-        bind()
+        <!PROTECTED_CALL_FROM_PUBLIC_INLINE!>bind<!>()
     }
 
     internal inline fun callFromInternal() {
@@ -99,4 +99,4 @@ private class X {
         }
     }
 
-}
+}

compiler/testData/diagnostics/tests/inline/protectedCallError.fir.kt

@@ -18,10 +18,10 @@ open class A {
         protected set(value) {}
 
     inline fun call() {
-        test()
-        z
+        <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>test<!>()
+        <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>z<!>
         zVar
-        zVar = "123"
+        zVar <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>=<!> "123"
     }
 
     internal inline fun callFromInternal() {
@@ -48,13 +48,13 @@ open class A {
 
 class B : A() {
     inline fun testB() {
-        test()
+        <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>test<!>()
     }
 }
 
 class C : JavaClass() {
     inline fun call() {
-        bind()
+        <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>bind<!>()
     }
 
     internal inline fun callFromInternal() {
@@ -99,4 +99,4 @@ private class X {
         }
     }
 
-}
+}

compiler/testData/diagnostics/tests/inline/publishedApi.fir.kt

@@ -1,13 +1,13 @@
 // !DIAGNOSTICS: -EXPOSED_PARAMETER_TYPE -NOTHING_TO_INLINE
 inline fun call(a: A) {
-    a.test()
-    publishedTopLevel()
+    a.<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>test<!>()
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>publishedTopLevel<!>()
 
-    a.publishedVar
-    a.publishedVar = 1
+    a.<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>publishedVar<!>
+    a.publishedVar <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>=<!> 1
 
-    publishedVarTopLevel
-    publishedVarTopLevel = 1
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>publishedVarTopLevel<!>
+    publishedVarTopLevel <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>=<!> 1
 }
 
 inline var inlineVar: Int

compiler/testData/diagnostics/tests/inline/recursion.fir.kt

@@ -1,24 +0,0 @@
-// !CHECK_TYPE
-// !DIAGNOSTICS: -NOTHING_TO_INLINE -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -VARIABLE_EXPECTED
-
-inline fun inlineFun(s: (p: Int) -> Unit) {
-    inlineFun(s)
-}
-
-inline fun <T> inlineFun(s: T) {
-    inlineFun<Int>(11)
-}
-
-
-inline fun <T> Function0<T>.inlineExt() {
-    (checkSubtype<Function0<Int>>({11})).inlineExt();
-    {11}.inlineExt()
-}
-
-inline operator fun <T, V> Function1<T, V>.not() : Boolean {
-    return !this
-}
-
-inline operator fun <T, V> Function1<T, V>.inc() : Function1<T, V> {
-    return this++
-}

compiler/testData/diagnostics/tests/inline/recursion.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 // !DIAGNOSTICS: -NOTHING_TO_INLINE -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE -VARIABLE_EXPECTED
 

compiler/testData/diagnostics/tests/inline/regressions/kt4341.fir.kt

@@ -1,6 +0,0 @@
-//KT-4341 No resolved call for right-hand side of equals expression
-package g
-
-inline fun <T, U, V> inlineFunWithInvoke(s: (p: T) -> U) {
-    s == s //resolved call for right-hand side 's' not traced
-}

compiler/testData/diagnostics/tests/inline/regressions/kt4341.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 //KT-4341 No resolved call for right-hand side of equals expression
 package g
 

compiler/testData/diagnostics/tests/inline/returns.fir.kt

@@ -1,15 +1,15 @@
 inline fun inlineFun(s: (p: Int) -> Unit) : (p: Int) -> Unit {
-    return s
+    return <!USAGE_IS_NOT_INLINABLE!>s<!>
 }
 
-inline fun inlineFun2(s: (p: Int) -> Unit) : (p: Int) -> Unit = s
+inline fun inlineFun2(s: (p: Int) -> Unit) : (p: Int) -> Unit = <!USAGE_IS_NOT_INLINABLE!>s<!>
 
 
 inline fun inlineFunWithExt(ext: Int.(p: Int) -> Unit) : Int.(p: Int) -> Unit {
-    return ext
+    return <!USAGE_IS_NOT_INLINABLE!>ext<!>
 }
 
-inline fun inlineFunWithExt2(ext: Int.(p: Int) -> Unit) : Int.(p: Int) -> Unit = ext
+inline fun inlineFunWithExt2(ext: Int.(p: Int) -> Unit) : Int.(p: Int) -> Unit = <!USAGE_IS_NOT_INLINABLE!>ext<!>
 
 
 
@@ -17,4 +17,4 @@ inline fun Function1<Int, Unit>.inlineExt(): Function1<Int, Unit> {
     return this
 }
 
-inline fun Function1<Int, Unit>.inlineExt2(): Function1<Int, Unit> = this
+inline fun Function1<Int, Unit>.inlineExt2(): Function1<Int, Unit> = this

compiler/testData/diagnostics/tests/inline/sam.fir.kt

@@ -22,8 +22,8 @@ inline fun inlineFunWithInvoke(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
         11.ext(11)
         11 ext 11
 
-        s
-        ext
+        <!USAGE_IS_NOT_INLINABLE!>s<!>
+        <!USAGE_IS_NOT_INLINABLE!>ext<!>
         11
     }
 }
@@ -38,7 +38,7 @@ inline fun inlineFunWithInvokeNonInline(noinline s: (p: Int) -> Unit, ext: Int.(
         11 ext 11
 
         s
-        ext
+        <!USAGE_IS_NOT_INLINABLE!>ext<!>
 
         11
     }
@@ -55,4 +55,4 @@ inline fun Function1<Int, Unit>.inlineExt() {
 
         11
     }
-}
+}

compiler/testData/diagnostics/tests/inline/stringTemplate.fir.kt

@@ -1,10 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION
-inline public fun reg(converter: (Any) -> Any, str: String) {
-    str
-    converter("")
-}
-
-public inline fun register(converter: (Any) -> Any) {
-    "123$converter"
-    reg(converter, "123$converter")
-}

compiler/testData/diagnostics/tests/inline/stringTemplate.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION
 inline public fun reg(converter: (Any) -> Any, str: String) {
     str
@@ -7,4 +8,4 @@ inline public fun reg(converter: (Any) -> Any, str: String) {
 public inline fun register(converter: (Any) -> Any) {
     "123$<!USAGE_IS_NOT_INLINABLE!>converter<!>"
     reg(converter, "123$<!USAGE_IS_NOT_INLINABLE!>converter<!>")
-}
+}

compiler/testData/diagnostics/tests/inline/superCallDepecation.fir.kt

@@ -7,7 +7,7 @@ open class AndroidTargetConfigurator :
     AndroidModuleConfigurator {
 
     public inline fun inlineFun(): String {
-        return super.classFun() + super<ModuleConfiguratorWithTests>.getConfiguratorSettings() + super<AndroidModuleConfigurator>.getConfiguratorSettings()
+        return <!SUPER_CALL_FROM_PUBLIC_INLINE!>super<!>.classFun() + <!SUPER_CALL_FROM_PUBLIC_INLINE!>super<ModuleConfiguratorWithTests><!>.getConfiguratorSettings() + <!SUPER_CALL_FROM_PUBLIC_INLINE!>super<AndroidModuleConfigurator><!>.getConfiguratorSettings()
     }
 
     @PublishedApi
@@ -17,11 +17,11 @@ open class AndroidTargetConfigurator :
 
     public inline fun inlineFunAnonymousObjects(): String {
         {
-            super.classFun() + super<ModuleConfiguratorWithTests>.getConfiguratorSettings() + super<AndroidModuleConfigurator>.getConfiguratorSettings()
+            <!SUPER_CALL_FROM_PUBLIC_INLINE!>super<!>.classFun() + <!SUPER_CALL_FROM_PUBLIC_INLINE!>super<ModuleConfiguratorWithTests><!>.getConfiguratorSettings() + <!SUPER_CALL_FROM_PUBLIC_INLINE!>super<AndroidModuleConfigurator><!>.getConfiguratorSettings()
         }()
 
         return object {
-            fun run() = super@AndroidTargetConfigurator.classFun() + super<ModuleConfiguratorWithTests>@AndroidTargetConfigurator.getConfiguratorSettings() + super<AndroidModuleConfigurator>@AndroidTargetConfigurator.getConfiguratorSettings()
+            fun run() = <!SUPER_CALL_FROM_PUBLIC_INLINE!>super@AndroidTargetConfigurator<!>.classFun() + <!SUPER_CALL_FROM_PUBLIC_INLINE!>super<ModuleConfiguratorWithTests>@AndroidTargetConfigurator<!>.getConfiguratorSettings() + <!SUPER_CALL_FROM_PUBLIC_INLINE!>super<AndroidModuleConfigurator>@AndroidTargetConfigurator<!>.getConfiguratorSettings()
         }.run()
     }
 
@@ -94,7 +94,7 @@ sealed class FooSealed : Base() {
     class B: FooSealed()
 
     inline fun test() {
-        super.classFun()
+        <!SUPER_CALL_FROM_PUBLIC_INLINE!>super<!>.classFun()
     }
 
 }
@@ -114,8 +114,8 @@ class FooOuter : Base() {
 
     inner class FooInner: Base() {
         inline fun test() {
-            super@FooOuter.classFun()
-            super.classFun()
+            <!SUPER_CALL_FROM_PUBLIC_INLINE!>super@FooOuter<!>.classFun()
+            <!SUPER_CALL_FROM_PUBLIC_INLINE!>super<!>.classFun()
         }
     }
 

compiler/testData/diagnostics/tests/inline/unaryExpressions/mathOperation.fir.kt

@@ -12,17 +12,17 @@ operator fun <T, V> @ExtensionFunctionType Function2<T, T, V>.dec() = this
 
 inline fun <T, V> inlineFunWithInvoke(s: (p: T) -> V, ext: T.(p: T) -> V) {
     +s
-    -s
-    s++
-    ++s
-    s--
-    --s
+    <!USAGE_IS_NOT_INLINABLE!>-<!>s
+    <!USAGE_IS_NOT_INLINABLE!>s<!>++
+    <!USAGE_IS_NOT_INLINABLE!>++<!>s
+    <!USAGE_IS_NOT_INLINABLE!>s<!>--
+    <!USAGE_IS_NOT_INLINABLE, USAGE_IS_NOT_INLINABLE!>--<!>s
     +ext
-    -ext
-    ext++
-    ++ext
-    ext--
-    --ext
+    <!USAGE_IS_NOT_INLINABLE!>-<!>ext
+    <!USAGE_IS_NOT_INLINABLE!>ext<!>++
+    <!USAGE_IS_NOT_INLINABLE!>++<!>ext
+    <!USAGE_IS_NOT_INLINABLE!>ext<!>--
+    <!USAGE_IS_NOT_INLINABLE, USAGE_IS_NOT_INLINABLE!>--<!>ext
 }
 
 inline fun <T, V> Function1<T, V>.inlineFunWithInvoke() {

compiler/testData/diagnostics/tests/inline/unaryExpressions/notOperation.fir.kt

@@ -16,6 +16,6 @@ operator fun <T, U, V, W> @ExtensionFunctionType Function3<T, U, V, W>.not() : B
 }
 
 inline fun <T, U, V> inlineFunWithInvoke(s: (p: T, l: U) -> V, ext: T.(p: T, l : U) -> V) {
-    !s
-    !ext
+    <!USAGE_IS_NOT_INLINABLE!>!<!>s
+    <!USAGE_IS_NOT_INLINABLE!>!<!>ext
 }

compiler/testData/diagnostics/tests/inline/vararg.fir.kt

@@ -1,16 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE
-
-inline fun inlineFun(s: (p: Int) -> Unit, noinline b: (p: Int) -> Unit) {
-    subInline(s, b)
-    subNoInline(s, b)
-}
-
-inline fun Function1<Int, Unit>.inlineExt(s: (p: Int) -> Unit, noinline b: (p: Int) -> Unit) {
-    subInline(this, s, b)
-    subNoInline(this, s, b)
-}
-
-
-inline fun subInline(vararg s: (p: Int) -> Unit) {}
-
-fun subNoInline(vararg s: (p: Int) -> Unit) {}

compiler/testData/diagnostics/tests/inline/vararg.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -NOTHING_TO_INLINE
 
 inline fun inlineFun(s: (p: Int) -> Unit, noinline b: (p: Int) -> Unit) {
@@ -13,4 +14,4 @@ inline fun Function1<Int, Unit>.inlineExt(s: (p: Int) -> Unit, noinline b: (p: I
 
 inline fun subInline(vararg s: (p: Int) -> Unit) {}
 
-fun subNoInline(vararg s: (p: Int) -> Unit) {}
+fun subNoInline(vararg s: (p: Int) -> Unit) {}

compiler/testData/diagnostics/tests/inline/when.fir.kt

@@ -4,8 +4,8 @@ inline public fun reg(converter: (Any) -> Any) {
 }
 
 public inline fun register(converter: (Any) -> Any) {
-    reg(when(converter) {
-        is (Any) -> Any -> converter
-        else -> converter
+    reg(when(<!USAGE_IS_NOT_INLINABLE!>converter<!>) {
+        is (Any) -> Any -> <!USAGE_IS_NOT_INLINABLE!>converter<!>
+        else -> <!USAGE_IS_NOT_INLINABLE!>converter<!>
     })
-}
+}

compiler/testData/diagnostics/tests/inline/wrongUsage.fir.kt

@@ -1,51 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -NOTHING_TO_INLINE -USELESS_ELVIS
-
-inline fun inlineFunWrongUsage(s: (p: Int) -> Unit) {
-    s
-
-    if (true) s else 0
-
-    s ?: s
-}
-
-inline fun inlineFunWrongUsageExt(ext: Int.(p: Int) -> Unit) {
-    ext
-
-    if (true) ext else 0
-
-    ext ?: ext
-}
-
-inline fun inlineFunWrongUsageInClosure(s: (p: Int) -> Unit) {
-    {
-        s
-
-        if (true) s else 0
-
-        s ?: s
-    }()
-}
-
-inline fun inlineFunWrongUsageInClosureExt(ext: Int.(p: Int) -> Unit) {
-    {
-        ext
-
-        if (true) ext else 0
-
-        ext ?: ext
-    }()
-}
-
-inline fun inlineFunNoInline(noinline s: (p: Int) -> Unit) {
-    s
-    if (true) s else 0
-
-    s ?: s
-}
-
-inline fun inlineFunNoInline(noinline ext: Int.(p: Int) -> Unit) {
-    ext
-    if (true) ext else 0
-
-    ext ?: ext
-}

compiler/testData/diagnostics/tests/inline/wrongUsage.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE -ASSIGNED_BUT_NEVER_ACCESSED_VARIABLE -UNUSED_VALUE -NOTHING_TO_INLINE -USELESS_ELVIS
 
 inline fun inlineFunWrongUsage(s: (p: Int) -> Unit) {
@@ -48,4 +49,4 @@ inline fun inlineFunNoInline(noinline ext: Int.(p: Int) -> Unit) {
     if (true) ext else 0
 
     ext ?: ext
-}
+}

compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.fir.kt

@@ -18,7 +18,7 @@ fun <T> javaClass(): Class<T> = null!!
 
 public class AppServiceModule : AbstractModule<String>() {
     inline fun <reified T> AbstractModule<Int>.bind() {
-        val x = bind(javaClass<T>())
+        val x = <!PROTECTED_CALL_FROM_PUBLIC_INLINE!>bind<!>(javaClass<T>())
 
         x checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() } // check that Class receiver is used instead of extension one
     }

compiler/testData/diagnostics/testsWithStdLib/contracts/dsl/errors/notFirstStatement.fir.kt

@@ -15,16 +15,16 @@ fun foo(y: Boolean) {
 inline fun case1(block: () -> Unit) {
     val contracts = listOf(
         contract {
-            callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+            callsInPlace(<!USAGE_IS_NOT_INLINABLE!>block<!>, InvocationKind.EXACTLY_ONCE)
         }, contract {
-            callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+            callsInPlace(<!USAGE_IS_NOT_INLINABLE!>block<!>, InvocationKind.EXACTLY_ONCE)
         }
     )
     block()
 }
 
 inline fun case_2(block: () -> Unit) = contract {
-    callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    callsInPlace(<!USAGE_IS_NOT_INLINABLE!>block<!>, InvocationKind.EXACTLY_ONCE)
 }
 
 fun case_3(block: () -> Unit) {
@@ -73,4 +73,4 @@ fun case_7(cond: Boolean): Boolean {
         }
     }
     return true
-}
+}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfCrossinlineOrdinary.fir.kt

@@ -21,7 +21,7 @@ inline fun test(crossinline c: () -> Unit) {
         }
     }
     val l = { c() }
-    c.startCoroutine(EmptyContinuation)
+    c.<!USAGE_IS_NOT_INLINABLE!>startCoroutine<!>(EmptyContinuation)
 }
 
 suspend fun calculate() = "OK"

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfCrossinlineSuspend.fir.kt

@@ -25,7 +25,7 @@ inline fun test(crossinline c: suspend () -> Unit)  {
         }
     }
     val l: suspend () -> Unit = { c() }
-    c.startCoroutine(EmptyContinuation)
+    c.<!USAGE_IS_NOT_INLINABLE!>startCoroutine<!>(EmptyContinuation)
 }
 
 suspend fun calculate() = "OK"

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfOrdinary.fir.kt

@@ -21,7 +21,7 @@ inline fun test(c: () -> Unit) {
         }
     }
     val l = { c() }
-    c.startCoroutine(EmptyContinuation)
+    c.<!USAGE_IS_NOT_INLINABLE!>startCoroutine<!>(EmptyContinuation)
 }
 
 fun builder(c: suspend () -> Unit) {

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineOrdinaryOfSuspend.fir.kt

@@ -25,7 +25,7 @@ inline fun test(c: suspend () -> Unit) {
         }
     }
     val l: suspend () -> Unit = { c() }
-    c.startCoroutine(EmptyContinuation)
+    c.<!USAGE_IS_NOT_INLINABLE!>startCoroutine<!>(EmptyContinuation)
 }
 
 fun builder(c: suspend () -> Unit) {}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfCrossinlineOrdinary.fir.kt

@@ -20,7 +20,7 @@ suspend inline fun test(crossinline c: () -> Unit) {
         }
     }
     val l = { c() }
-    c.startCoroutine(EmptyContinuation)
+    c.<!USAGE_IS_NOT_INLINABLE!>startCoroutine<!>(EmptyContinuation)
 }
 
 fun builder(c: suspend () -> Unit) {

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfCrossinlineSuspend.fir.kt

@@ -24,7 +24,7 @@ suspend inline fun test(crossinline c: suspend () -> Unit) {
         }
     }
     val l: suspend () -> Unit = { c() }
-    c.startCoroutine(EmptyContinuation)
+    c.<!USAGE_IS_NOT_INLINABLE!>startCoroutine<!>(EmptyContinuation)
 }
 
 fun builder(c: suspend () -> Unit) {}

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfOrdinary.fir.kt

@@ -20,7 +20,7 @@ suspend inline fun test(c: () -> Unit) {
         }
     }
     val l = { c() }
-    c.startCoroutine(EmptyContinuation)
+    c.<!USAGE_IS_NOT_INLINABLE!>startCoroutine<!>(EmptyContinuation)
 }
 
 suspend fun calculate() = "OK"

compiler/testData/diagnostics/testsWithStdLib/coroutines/inlineCrossinline/inlineSuspendOfSuspend.fir.kt

@@ -24,7 +24,7 @@ suspend inline fun test(c: suspend () -> Unit) {
         }
     }
     val l: suspend () -> Unit = { c() }
-    c.startCoroutine(EmptyContinuation)
+    c.<!USAGE_IS_NOT_INLINABLE!>startCoroutine<!>(EmptyContinuation)
 }
 
 fun builder(c: suspend () -> Unit) {

compiler/tests-spec/testData/diagnostics/linked/overload-resolution/building-the-overload-candidate-set-ocs/operator-call/p-1/neg/2.2.fir.kt

@@ -20,8 +20,8 @@ inline operator fun B?.plusAssign( c: ()->Any) { } //(1)
 @JvmName("aa")
 inline  operator fun B?.plusAssign( c: ()->C) { //(2)
 
-    this += {1}
-    <!DEBUG_INFO_CALL("fqName: testPackCase1.plusAssign; typeCall: inline operator extension function")!>this += {1}<!>
+    this <!RECURSION_IN_INLINE!>+=<!> {1}
+    <!DEBUG_INFO_CALL("fqName: testPackCase1.plusAssign; typeCall: inline operator extension function")!>this <!RECURSION_IN_INLINE!>+=<!> {1}<!>
 }
 
 class C

compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/1.fir.kt

@@ -14,7 +14,7 @@ inline fun case_1(block: () -> Unit) {
 inline fun case_2(block: () -> Unit) {
     10 - 1
     contract {
-        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+        callsInPlace(<!USAGE_IS_NOT_INLINABLE!>block<!>, InvocationKind.EXACTLY_ONCE)
     }
     return block()
 }
@@ -23,7 +23,7 @@ inline fun case_2(block: () -> Unit) {
 inline fun case_3(block: () -> Unit) {
     throw Exception()
     contract {
-        callsInPlace(block, InvocationKind.UNKNOWN)
+        callsInPlace(<!USAGE_IS_NOT_INLINABLE!>block<!>, InvocationKind.UNKNOWN)
     }
     return block()
 }
@@ -35,7 +35,7 @@ inline fun case_3(block: () -> Unit) {
 inline fun case_4(block: () -> Unit) {
     .0009
     return contract {
-        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+        callsInPlace(<!USAGE_IS_NOT_INLINABLE!>block<!>, InvocationKind.EXACTLY_ONCE)
     }
 }
 

compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/11.fir.kt

@@ -8,7 +8,7 @@ import kotlin.contracts.*
 
 // TESTCASE NUMBER: 1, 2
 inline fun contractBuilder(block: () -> Unit): ContractBuilder.() -> Unit = {
-    callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    callsInPlace(<!USAGE_IS_NOT_INLINABLE!>block<!>, InvocationKind.EXACTLY_ONCE)
 }
 
 // FILE: main.kt

compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/12.fir.kt

@@ -8,7 +8,7 @@ import kotlin.contracts.*
 
 // TESTCASE NUMBER: 1, 2, 3
 inline fun ContractBuilder.callsInPlaceEffectBuilder(block: () -> Unit) =
-    callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+    callsInPlace(<!USAGE_IS_NOT_INLINABLE!>block<!>, InvocationKind.EXACTLY_ONCE)
 
 fun ContractBuilder.returnsEffectBuilder(value_1: Int?) =
     returns(true) implies (value_1 != null)

compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/14.fir.kt

@@ -6,7 +6,7 @@ import kotlin.contracts.*
 // TESTCASE NUMBER: 1
 inline fun case_1(block: () -> Unit) {
     return contract {
-        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+        callsInPlace(<!USAGE_IS_NOT_INLINABLE!>block<!>, InvocationKind.EXACTLY_ONCE)
     }
 }
 
@@ -16,7 +16,7 @@ fun case_2() = contract { }
 // TESTCASE NUMBER: 3
 inline fun case_3(block: () -> Unit) {
     val value_1 = contract {
-        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+        callsInPlace(<!USAGE_IS_NOT_INLINABLE!>block<!>, InvocationKind.EXACTLY_ONCE)
     }
     block()
 }
@@ -40,13 +40,13 @@ inline fun case_5(block: () -> Unit) {
 // TESTCASE NUMBER: 6
 inline fun case_6(block: () -> Unit) {
     throw Exception(contract {
-        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+        callsInPlace(<!USAGE_IS_NOT_INLINABLE!>block<!>, InvocationKind.EXACTLY_ONCE)
     }.toString())
 }
 
 // TESTCASE NUMBER: 7
 inline fun case_7(block: () -> Unit) {
     funWithAnyArg(contract {
-        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+        callsInPlace(<!USAGE_IS_NOT_INLINABLE!>block<!>, InvocationKind.EXACTLY_ONCE)
     })
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/6.fir.kt

@@ -58,6 +58,6 @@ class case_2(value_5: Boolean, val value_1: Boolean) {
 
     inline fun <reified K : Number> K.case_2_5(): Boolean? {
         contract { <!ERROR_IN_CONTRACT_DESCRIPTION!>returnsNotNull() implies (<!UNRESOLVED_REFERENCE!>value_4<!>)<!> }
-        return if (value_4) true else null
+        return if (<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>value_4<!>) true else null
     }
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractBuilder/common/neg/9.fir.kt

@@ -6,6 +6,6 @@ import kotlin.contracts.*
 // TESTCASE NUMBER: 1
 inline fun case_1(block: () -> Unit) = {
     contract {
-        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
+        callsInPlace(<!USAGE_IS_NOT_INLINABLE!>block<!>, InvocationKind.EXACTLY_ONCE)
     }
 }

compiler/tests-spec/testData/diagnostics/notLinked/contracts/declarations/contractFunction/neg/1.fir.kt

@@ -6,5 +6,5 @@ import kotlin.contracts.*
 inline fun case_1(block: () -> Unit) {
     <!WRONG_INVOCATION_KIND!>contract { callsInPlace(block, InvocationKind.EXACTLY_ONCE) }<!>
     block()
-    case_1(block)
+    <!RECURSION_IN_INLINE!>case_1<!>(block)
 }

idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticList
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticParameter
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccess
 import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -133,6 +134,14 @@ private object FirToKtConversionCreator {
                 "org.jetbrains.kotlin.fir.psi"
             )
         ),
+        FirQualifiedAccess::class to HLFunctionCallConversion(
+            "{0}.source!!.psi as KtExpression",
+            KtExpression::class.createType(),
+            importsToAdd = listOf(
+                "org.jetbrains.kotlin.psi.KtExpression",
+                "org.jetbrains.kotlin.fir.psi"
+            )
+        ),
         FirValueParameter::class to HLFunctionCallConversion(
             "firSymbolBuilder.buildSymbol({0})",
             KtSymbol::class.createType(),

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt

@@ -2092,4 +2092,72 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
+    add(FirErrors.USAGE_IS_NOT_INLINABLE) { firDiagnostic ->
+        UsageIsNotInlinableImpl(
+            firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.NON_LOCAL_RETURN_NOT_ALLOWED) { firDiagnostic ->
+        NonLocalReturnNotAllowedImpl(
+            firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.RECURSION_IN_INLINE) { firDiagnostic ->
+        RecursionInInlineImpl(
+            firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.NON_PUBLIC_CALL_FROM_PUBLIC_INLINE) { firDiagnostic ->
+        NonPublicCallFromPublicInlineImpl(
+            firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration),
+            firSymbolBuilder.buildSymbol(firDiagnostic.b.fir as FirDeclaration),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE) { firDiagnostic ->
+        ProtectedConstructorCallFromPublicInlineImpl(
+            firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration),
+            firSymbolBuilder.buildSymbol(firDiagnostic.b.fir as FirDeclaration),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR) { firDiagnostic ->
+        ProtectedCallFromPublicInlineErrorImpl(
+            firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration),
+            firSymbolBuilder.buildSymbol(firDiagnostic.b.fir as FirDeclaration),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.PROTECTED_CALL_FROM_PUBLIC_INLINE) { firDiagnostic ->
+        ProtectedCallFromPublicInlineImpl(
+            firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration),
+            firSymbolBuilder.buildSymbol(firDiagnostic.b.fir as FirDeclaration),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.PRIVATE_CLASS_MEMBER_FROM_INLINE) { firDiagnostic ->
+        PrivateClassMemberFromInlineImpl(
+            firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration),
+            firSymbolBuilder.buildSymbol(firDiagnostic.b.fir as FirDeclaration),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
+    add(FirErrors.SUPER_CALL_FROM_PUBLIC_INLINE) { firDiagnostic ->
+        SuperCallFromPublicInlineImpl(
+            firSymbolBuilder.buildSymbol(firDiagnostic.a.fir as FirDeclaration),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
 }

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt

@@ -1459,4 +1459,54 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
         override val diagnosticClass get() = ReturnInFunctionWithExpressionBody::class
     }
 
+    abstract class UsageIsNotInlinable : KtFirDiagnostic<KtElement>() {
+        override val diagnosticClass get() = UsageIsNotInlinable::class
+        abstract val parameter: KtSymbol
+    }
+
+    abstract class NonLocalReturnNotAllowed : KtFirDiagnostic<KtElement>() {
+        override val diagnosticClass get() = NonLocalReturnNotAllowed::class
+        abstract val parameter: KtSymbol
+    }
+
+    abstract class RecursionInInline : KtFirDiagnostic<KtElement>() {
+        override val diagnosticClass get() = RecursionInInline::class
+        abstract val symbol: KtSymbol
+    }
+
+    abstract class NonPublicCallFromPublicInline : KtFirDiagnostic<KtElement>() {
+        override val diagnosticClass get() = NonPublicCallFromPublicInline::class
+        abstract val inlineDeclaration: KtSymbol
+        abstract val referencedDeclaration: KtSymbol
+    }
+
+    abstract class ProtectedConstructorCallFromPublicInline : KtFirDiagnostic<KtElement>() {
+        override val diagnosticClass get() = ProtectedConstructorCallFromPublicInline::class
+        abstract val inlineDeclaration: KtSymbol
+        abstract val referencedDeclaration: KtSymbol
+    }
+
+    abstract class ProtectedCallFromPublicInlineError : KtFirDiagnostic<KtElement>() {
+        override val diagnosticClass get() = ProtectedCallFromPublicInlineError::class
+        abstract val inlineDeclaration: KtSymbol
+        abstract val referencedDeclaration: KtSymbol
+    }
+
+    abstract class ProtectedCallFromPublicInline : KtFirDiagnostic<KtElement>() {
+        override val diagnosticClass get() = ProtectedCallFromPublicInline::class
+        abstract val inlineDeclaration: KtSymbol
+        abstract val referencedDeclaration: KtSymbol
+    }
+
+    abstract class PrivateClassMemberFromInline : KtFirDiagnostic<KtElement>() {
+        override val diagnosticClass get() = PrivateClassMemberFromInline::class
+        abstract val inlineDeclaration: KtSymbol
+        abstract val referencedDeclaration: KtSymbol
+    }
+
+    abstract class SuperCallFromPublicInline : KtFirDiagnostic<KtElement>() {
+        override val diagnosticClass get() = SuperCallFromPublicInline::class
+        abstract val symbol: KtSymbol
+    }
+
 }

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt

@@ -2378,3 +2378,80 @@ internal class ReturnInFunctionWithExpressionBodyImpl(
     override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
 }
 
+internal class UsageIsNotInlinableImpl(
+    override val parameter: KtSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.UsageIsNotInlinable(), KtAbstractFirDiagnostic<KtElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class NonLocalReturnNotAllowedImpl(
+    override val parameter: KtSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.NonLocalReturnNotAllowed(), KtAbstractFirDiagnostic<KtElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class RecursionInInlineImpl(
+    override val symbol: KtSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.RecursionInInline(), KtAbstractFirDiagnostic<KtElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class NonPublicCallFromPublicInlineImpl(
+    override val inlineDeclaration: KtSymbol,
+    override val referencedDeclaration: KtSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.NonPublicCallFromPublicInline(), KtAbstractFirDiagnostic<KtElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class ProtectedConstructorCallFromPublicInlineImpl(
+    override val inlineDeclaration: KtSymbol,
+    override val referencedDeclaration: KtSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.ProtectedConstructorCallFromPublicInline(), KtAbstractFirDiagnostic<KtElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class ProtectedCallFromPublicInlineErrorImpl(
+    override val inlineDeclaration: KtSymbol,
+    override val referencedDeclaration: KtSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.ProtectedCallFromPublicInlineError(), KtAbstractFirDiagnostic<KtElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class ProtectedCallFromPublicInlineImpl(
+    override val inlineDeclaration: KtSymbol,
+    override val referencedDeclaration: KtSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.ProtectedCallFromPublicInline(), KtAbstractFirDiagnostic<KtElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class PrivateClassMemberFromInlineImpl(
+    override val inlineDeclaration: KtSymbol,
+    override val referencedDeclaration: KtSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.PrivateClassMemberFromInline(), KtAbstractFirDiagnostic<KtElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
+internal class SuperCallFromPublicInlineImpl(
+    override val symbol: KtSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.SuperCallFromPublicInline(), KtAbstractFirDiagnostic<KtElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+