[FIR] KT-58623: Unify FirInlineDeclarationChecker

> Condition 'isSuspendFunctionType' is always false when reached

The change in the native tests is needed, because K2
doesn't support disabling old language features

^KT-58623 Fixed

compiler/fir/checkers/checkers.js/src/org/jetbrains/kotlin/fir/analysis/js/checkers/JsDeclarationCheckers.kt

@@ -11,15 +11,9 @@ import org.jetbrains.kotlin.fir.analysis.js.checkers.declaration.*
 object JsDeclarationCheckers : DeclarationCheckers() {
     override val functionCheckers: Set<FirFunctionChecker>
         get() = setOf(
-            FirJsInlineDeclarationChecker,
             FirJsInheritanceFunctionChecker,
         )
 
-    override val propertyCheckers: Set<FirPropertyChecker>
-        get() = setOf(
-            FirJsInlinePropertyChecker,
-        )
-
     override val basicDeclarationCheckers: Set<FirBasicDeclarationChecker>
         get() = setOf(
             FirJsModuleChecker,

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

@@ -1,10 +0,0 @@
-/*
- * Copyright 2010-2022 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.js.checkers.declaration
-
-import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirInlineDeclarationChecker
-
-object FirJsInlineDeclarationChecker : FirInlineDeclarationChecker()

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

@@ -1,12 +0,0 @@
-/*
- * Copyright 2010-2022 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.js.checkers.declaration
-
-import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirInlinePropertyChecker
-
-object FirJsInlinePropertyChecker : FirInlinePropertyChecker() {
-    override val inlineDeclarationChecker get() = FirJsInlineDeclarationChecker
-}

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/FirJvmInlineCheckerComponent.kt

@@ -1,75 +1,37 @@
 /*
- * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2023 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.jvm.checkers.declaration
+package org.jetbrains.kotlin.fir.analysis.jvm.checkers
 
 import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.analysis.checkers.FirInlineCheckerPlatformSpecificComponent
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirInlineDeclarationChecker
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.isLocalMember
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.utils.effectiveVisibility
-import org.jetbrains.kotlin.fir.declarations.utils.isInline
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirValueParameterSymbol
 
-object FirJvmInlineDeclarationChecker : FirInlineDeclarationChecker() {
+class FirJvmInlineCheckerComponent : FirInlineCheckerPlatformSpecificComponent() {
-    override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
+    override fun isGenerallyOk(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter): Boolean {
-        if (!declaration.isInline) {
-            checkParametersInNotInline(declaration, context, reporter)
-            return
-        }
         // local inline functions are prohibited
-        if (declaration.isLocalMember) {
+        return if (declaration.isLocalMember) {
             reporter.reportOn(declaration.source, FirErrors.NOT_YET_SUPPORTED_IN_INLINE, "Local inline functions", context)
-            return
+            false
-        }
+        } else {
-        if (declaration !is FirPropertyAccessor && declaration !is FirSimpleFunction) return
+            true
-
-        val effectiveVisibility = declaration.effectiveVisibility
-        checkInlineFunctionBody(declaration, effectiveVisibility, context, reporter)
-        checkCallableDeclaration(declaration, context, reporter)
-    }
-
-    override val inlineVisitor get() = ::InlineVisitor
-
-    class InlineVisitor(
-        inlineFunction: FirFunction,
-        inlineFunEffectiveVisibility: EffectiveVisibility,
-        inalienableParameters: List<FirValueParameterSymbol>,
-        session: FirSession,
-        reporter: DiagnosticReporter
-    ) : BasicInlineVisitor(
-        inlineFunction,
-        inlineFunEffectiveVisibility,
-        inalienableParameters,
-        session,
-        reporter
-    ) {
-        override fun visitRegularClass(regularClass: FirRegularClass, data: CheckerContext) {
-            if (!regularClass.classKind.isSingleton && data.containingDeclarations.lastOrNull() === inlineFunction) {
-                reporter.reportOn(regularClass.source, FirErrors.NOT_YET_SUPPORTED_IN_INLINE, "Local classes", data)
-            } else {
-                super.visitRegularClass(regularClass, data)
-            }
-        }
-
-        override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: CheckerContext) {
-            if (data.containingDeclarations.lastOrNull() === inlineFunction) {
-                reporter.reportOn(simpleFunction.source, FirErrors.NOT_YET_SUPPORTED_IN_INLINE, "Local functions", data)
-            } else {
-                super.visitSimpleFunction(simpleFunction, data)
-            }
         }
     }
 
+    override val inlineVisitor get() = ::JvmInlineVisitor
+
     override fun checkSuspendFunctionalParameterWithDefaultValue(
         param: FirValueParameter,
         context: CheckerContext,
@@ -107,3 +69,33 @@ object FirJvmInlineDeclarationChecker : FirInlineDeclarationChecker() {
         }
     }
 }
+
+class JvmInlineVisitor(
+    inlineFunction: FirFunction,
+    inlineFunEffectiveVisibility: EffectiveVisibility,
+    inalienableParameters: List<FirValueParameterSymbol>,
+    session: FirSession,
+    reporter: DiagnosticReporter
+) : FirInlineDeclarationChecker.BasicInlineVisitor(
+    inlineFunction,
+    inlineFunEffectiveVisibility,
+    inalienableParameters,
+    session,
+    reporter
+) {
+    override fun visitRegularClass(regularClass: FirRegularClass, data: CheckerContext) {
+        if (!regularClass.classKind.isSingleton && data.containingDeclarations.lastOrNull() === inlineFunction) {
+            reporter.reportOn(regularClass.source, FirErrors.NOT_YET_SUPPORTED_IN_INLINE, "Local classes", data)
+        } else {
+            super.visitRegularClass(regularClass, data)
+        }
+    }
+
+    override fun visitSimpleFunction(simpleFunction: FirSimpleFunction, data: CheckerContext) {
+        if (data.containingDeclarations.lastOrNull() === inlineFunction) {
+            reporter.reportOn(simpleFunction.source, FirErrors.NOT_YET_SUPPORTED_IN_INLINE, "Local functions", data)
+        } else {
+            super.visitSimpleFunction(simpleFunction, data)
+        }
+    }
+}

compiler/fir/checkers/checkers.jvm/src/org/jetbrains/kotlin/fir/analysis/jvm/checkers/JvmDeclarationCheckers.kt

@@ -37,14 +37,12 @@ object JvmDeclarationCheckers : DeclarationCheckers() {
         get() = setOf(
             FirJvmFieldApplicabilityChecker,
             FirJvmSyntheticApplicabilityChecker,
-            FirJvmInlinePropertyChecker,
         )
 
     override val functionCheckers: Set<FirFunctionChecker>
         get() = setOf(
             FirSynchronizedAnnotationChecker,
             FirOverloadsChecker,
-            FirJvmInlineDeclarationChecker,
         )
 
     override val typeParameterCheckers: Set<FirTypeParameterChecker>

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

@@ -1,12 +0,0 @@
-/*
- * Copyright 2010-2022 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.jvm.checkers.declaration
-
-import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirInlinePropertyChecker
-
-object FirJvmInlinePropertyChecker : FirInlinePropertyChecker() {
-    override val inlineDeclarationChecker get() = FirJvmInlineDeclarationChecker
-}

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

@@ -47,6 +47,7 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
             FirContractChecker,
             FirFunctionParameterChecker,
             FirFunctionReturnChecker,
+            FirInlineDeclarationChecker,
         )
 
     override val simpleFunctionCheckers: Set<FirSimpleFunctionChecker>
@@ -78,6 +79,7 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
             FirLocalExtensionPropertyChecker,
             ContractSyntaxV2PropertyChecker,
             FirVolatileAnnotationChecker,
+            FirInlinePropertyChecker,
         )
 
     override val backingFieldCheckers: Set<FirBackingFieldChecker>

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/FirInlineCheckerPlatformSpecificComponent.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2010-2023 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
+
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.FirSessionComponent
+import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
+import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirInlineDeclarationChecker
+import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirDeclaration
+import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
+import org.jetbrains.kotlin.fir.declarations.FirValueParameter
+import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
+
+abstract class FirInlineCheckerPlatformSpecificComponent : FirSessionComponent {
+    open fun isGenerallyOk(declaration: FirDeclaration, context: CheckerContext, reporter: DiagnosticReporter): Boolean = true
+
+    open val inlineVisitor get() = FirInlineDeclarationChecker::BasicInlineVisitor
+
+    open fun checkSuspendFunctionalParameterWithDefaultValue(
+        param: FirValueParameter,
+        context: CheckerContext,
+        reporter: DiagnosticReporter,
+    ) {
+    }
+
+    open fun checkFunctionalParametersWithInheritedDefaultValues(
+        function: FirSimpleFunction,
+        context: CheckerContext,
+        reporter: DiagnosticReporter,
+        overriddenSymbols: List<FirCallableSymbol<out FirCallableDeclaration>>,
+    ) {
+    }
+}
+
+val FirSession.inlineCheckerExtension by FirSession.nullableSessionComponentAccessor<FirInlineCheckerPlatformSpecificComponent>()

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

@@ -18,6 +18,7 @@ import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContextForProvider
 import org.jetbrains.kotlin.fir.analysis.checkers.getModifier
+import org.jetbrains.kotlin.fir.analysis.checkers.inlineCheckerExtension
 import org.jetbrains.kotlin.fir.analysis.checkers.isInlineOnly
 import org.jetbrains.kotlin.fir.analysis.checkers.unsubstitutedScope
 import org.jetbrains.kotlin.fir.analysis.collectors.AbstractDiagnosticCollectorVisitor
@@ -39,13 +40,13 @@ import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.util.OperatorNameConventions
 import org.jetbrains.kotlin.utils.addToStdlib.shouldNotBeCalled
 
-abstract class FirInlineDeclarationChecker : FirFunctionChecker() {
+object FirInlineDeclarationChecker : FirFunctionChecker() {
     override fun check(declaration: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
         if (!declaration.isInline) {
             checkParametersInNotInline(declaration, context, reporter)
             return
         }
-
+        if (context.session.inlineCheckerExtension?.isGenerallyOk(declaration, context, reporter) == false) return
         if (declaration !is FirPropertyAccessor && declaration !is FirSimpleFunction) return
 
         val effectiveVisibility = declaration.effectiveVisibility
@@ -53,7 +54,7 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() {
         checkCallableDeclaration(declaration, context, reporter)
     }
 
-    protected fun checkInlineFunctionBody(
+    private fun checkInlineFunctionBody(
         function: FirFunction,
         effectiveVisibility: EffectiveVisibility,
         context: CheckerContext,
@@ -66,7 +67,8 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() {
             !type.isMarkedNullable && type.isNonReflectFunctionType(context.session)
         }.map { it.symbol }
 
-        val visitor = inlineVisitor(
+        val createVisitor = context.session.inlineCheckerExtension?.inlineVisitor ?: ::BasicInlineVisitor
+        val visitor = createVisitor(
             function,
             effectiveVisibility,
             inalienableParameters,
@@ -76,12 +78,10 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() {
         body.checkChildrenWithCustomVisitor(context, visitor, function)
     }
 
-    open val inlineVisitor get() = ::BasicInlineVisitor
-
     open class BasicInlineVisitor(
         val inlineFunction: FirFunction,
-        val inlineFunEffectiveVisibility: EffectiveVisibility,
+        private val inlineFunEffectiveVisibility: EffectiveVisibility,
-        val inalienableParameters: List<FirValueParameterSymbol>,
+        private val inalienableParameters: List<FirValueParameterSymbol>,
         val session: FirSession,
         val reporter: DiagnosticReporter
     ) : FirDefaultVisitor<Unit, CheckerContext>() {
@@ -381,21 +381,6 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() {
         }
     }
 
-    protected open fun checkSuspendFunctionalParameterWithDefaultValue(
-        param: FirValueParameter,
-        context: CheckerContext,
-        reporter: DiagnosticReporter,
-    ) {
-    }
-
-    protected open fun checkFunctionalParametersWithInheritedDefaultValues(
-        function: FirSimpleFunction,
-        context: CheckerContext,
-        reporter: DiagnosticReporter,
-        overriddenSymbols: List<FirCallableSymbol<out FirCallableDeclaration>>,
-    ) {
-    }
-
     private fun checkParameters(
         function: FirSimpleFunction,
         overriddenSymbols: List<FirCallableSymbol<out FirCallableDeclaration>>,
@@ -409,14 +394,14 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() {
             val isSuspendFunctionType = functionKind?.isSuspendOrKSuspendFunction == true
             val defaultValue = param.defaultValue
 
-            if (!(isFunctionalType || isSuspendFunctionType) && (param.isNoinline || param.isCrossinline)) {
+            if (!isFunctionalType && (param.isNoinline || param.isCrossinline)) {
                 reporter.reportOn(param.source, FirErrors.ILLEGAL_INLINE_PARAMETER_MODIFIER, context)
             }
 
             if (param.isNoinline) continue
 
             if (function.isSuspend && defaultValue != null && isSuspendFunctionType) {
-                checkSuspendFunctionalParameterWithDefaultValue(param, context, reporter)
+                context.session.inlineCheckerExtension?.checkSuspendFunctionalParameterWithDefaultValue(param, context, reporter)
             }
 
             if (isSuspendFunctionType && !param.isCrossinline) {
@@ -460,10 +445,12 @@ abstract class FirInlineDeclarationChecker : FirFunctionChecker() {
         }
 
         //check for inherited default values
-        checkFunctionalParametersWithInheritedDefaultValues(function, context, reporter, overriddenSymbols)
+        context.session.inlineCheckerExtension?.checkFunctionalParametersWithInheritedDefaultValues(
+            function, context, reporter, overriddenSymbols
+        )
     }
 
-    protected fun checkParametersInNotInline(function: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
+    private fun checkParametersInNotInline(function: FirFunction, context: CheckerContext, reporter: DiagnosticReporter) {
         for (param in function.valueParameters) {
             if (param.isNoinline || param.isCrossinline) {
                 reporter.reportOn(param.source, FirErrors.ILLEGAL_INLINE_PARAMETER_MODIFIER, context)

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

@@ -13,13 +13,11 @@ import org.jetbrains.kotlin.fir.declarations.FirProperty
 import org.jetbrains.kotlin.fir.declarations.utils.hasBackingField
 import org.jetbrains.kotlin.fir.declarations.utils.isInline
 
-abstract class FirInlinePropertyChecker : FirPropertyChecker() {
+object FirInlinePropertyChecker : FirPropertyChecker() {
-    abstract val inlineDeclarationChecker: FirInlineDeclarationChecker
-
     override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) {
         if (declaration.getter?.isInline != true && declaration.setter?.isInline != true) return
 
-        inlineDeclarationChecker.checkCallableDeclaration(declaration, context, reporter)
+        FirInlineDeclarationChecker.checkCallableDeclaration(declaration, context, reporter)
 
         if (declaration.hasBackingField || declaration.delegate != null) {
             reporter.reportOn(declaration.source, FirErrors.INLINE_PROPERTY_WITH_BACKING_FIELD, context)

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt

@@ -11,8 +11,10 @@ import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.CheckersComponent
 import org.jetbrains.kotlin.fir.analysis.FirOverridesBackwardCompatibilityHelper
+import org.jetbrains.kotlin.fir.analysis.checkers.FirInlineCheckerPlatformSpecificComponent
 import org.jetbrains.kotlin.fir.analysis.checkers.declaration.FirNameConflictsTracker
 import org.jetbrains.kotlin.fir.analysis.jvm.FirJvmOverridesBackwardCompatibilityHelper
+import org.jetbrains.kotlin.fir.analysis.jvm.checkers.FirJvmInlineCheckerComponent
 import org.jetbrains.kotlin.fir.caches.FirCachesFactory
 import org.jetbrains.kotlin.fir.caches.FirThreadUnsafeCachesFactory
 import org.jetbrains.kotlin.fir.declarations.SealedClassInheritorsProvider
@@ -153,6 +155,7 @@ fun FirSession.registerJavaSpecificResolveComponents() {
     register(FirPlatformClassMapper::class, FirJavaClassMapper(this))
     register(FirSyntheticNamesProvider::class, FirJavaSyntheticNamesProvider)
     register(FirOverridesBackwardCompatibilityHelper::class, FirJvmOverridesBackwardCompatibilityHelper)
+    register(FirInlineCheckerPlatformSpecificComponent::class, FirJvmInlineCheckerComponent())
 }
 
 @OptIn(SessionConfiguration::class)

compiler/testData/codegen/boxInline/syntheticAccessors/superCall.kt

@@ -1,5 +1,5 @@
-// IGNORE_BACKEND_K2: JVM_IR, JS_IR
+// IGNORE_BACKEND_K2: JVM_IR, JS_IR, NATIVE
-// IGNORE_BACKEND_K2_MULTI_MODULE: JVM_IR JVM_IR_SERIALIZE
+// IGNORE_BACKEND_K2_MULTI_MODULE: JVM_IR JVM_IR_SERIALIZE NATIVE
 // !LANGUAGE: -ProhibitSuperCallsFromPublicInline
 // FILE: 1.kt
 

compiler/testData/codegen/boxInline/syntheticAccessors/superCallFromMultipleSubclasses.kt

@@ -1,5 +1,5 @@
-// IGNORE_BACKEND_K2: JVM_IR, JS_IR
+// IGNORE_BACKEND_K2: JVM_IR, JS_IR, NATIVE
-// IGNORE_BACKEND_K2_MULTI_MODULE: JVM_IR JVM_IR_SERIALIZE
+// IGNORE_BACKEND_K2_MULTI_MODULE: JVM_IR JVM_IR_SERIALIZE NATIVE
 // !LANGUAGE: -ProhibitSuperCallsFromPublicInline
 // FILE: 1.kt
 

compiler/testData/codegen/boxInline/syntheticAccessors/superProperty.kt

@@ -1,5 +1,5 @@
-// IGNORE_BACKEND_K2: JVM_IR, JS_IR
+// IGNORE_BACKEND_K2: JVM_IR, JS_IR, NATIVE
-// IGNORE_BACKEND_K2_MULTI_MODULE: JVM_IR JVM_IR_SERIALIZE
+// IGNORE_BACKEND_K2_MULTI_MODULE: JVM_IR JVM_IR_SERIALIZE NATIVE
 // !LANGUAGE: -ProhibitSuperCallsFromPublicInline
 // FILE: 1.kt
 

compiler/testData/diagnostics/nativeTests/nativeProtectedFunCall.fir.kt

@@ -11,13 +11,13 @@ open class ProtectedInsideInlineError : ProtectedInsideInlineParent() {
     protected var protectedVar = 0
     protected fun protectedFun() = 0
 
-    inline fun publicInlineUserFun() {
+    <!NOTHING_TO_INLINE!>inline<!> fun publicInlineUserFun() {
-        <!UNRESOLVED_REFERENCE!>println<!>(protectedVar + protectedParentVar)
+        <!UNRESOLVED_REFERENCE!>println<!>(<!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>protectedVar<!> + <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>protectedParentVar<!>)
-        protectedFun()
+        <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>protectedFun<!>()
-        protectedParentFun()
+        <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>protectedParentFun<!>()
     }
 
     inline var publicInlineUserVal: Int
-        get() = protectedVar + protectedFun() + protectedParentVar + protectedParentFun()
+        get() = <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>protectedVar<!> + <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>protectedFun<!>() + <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>protectedParentVar<!> + <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>protectedParentFun<!>()
-        set(value) { protectedVar + protectedFun() + protectedParentVar + protectedParentFun() }
+        set(value) { <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>protectedVar<!> + <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>protectedFun<!>() + <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>protectedParentVar<!> + <!PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR!>protectedParentFun<!>() }
 }