[FIR] Implement deprecation for accessing private operators from public inline function

This only affects delegation operators as well as the for-loop-related
next and hasNext operators.
All the other operators worked correctly before.
In K2, the previously mentioned operator calls will be flagged with a
deprecation error and will become and error in 2.1.

#KT-59782 Fixed

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

@@ -4721,6 +4721,14 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
+    add(FirErrors.NON_PUBLIC_CALL_FROM_PUBLIC_INLINE_DEPRECATION) { firDiagnostic ->
+        NonPublicCallFromPublicInlineDeprecationImpl(
+            firSymbolBuilder.buildSymbol(firDiagnostic.a),
+            firSymbolBuilder.buildSymbol(firDiagnostic.b),
+            firDiagnostic as KtPsiDiagnostic,
+            token,
+        )
+    }
     add(FirErrors.PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE) { firDiagnostic ->
         ProtectedConstructorCallFromPublicInlineImpl(
             firSymbolBuilder.buildSymbol(firDiagnostic.a),

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

@@ -3288,6 +3288,12 @@ sealed interface KtFirDiagnostic<PSI : PsiElement> : KtDiagnosticWithPsi<PSI> {
         val referencedDeclaration: KtSymbol
     }
 
+    interface NonPublicCallFromPublicInlineDeprecation : KtFirDiagnostic<KtElement> {
+        override val diagnosticClass get() = NonPublicCallFromPublicInlineDeprecation::class
+        val inlineDeclaration: KtSymbol
+        val referencedDeclaration: KtSymbol
+    }
+
     interface ProtectedConstructorCallFromPublicInline : KtFirDiagnostic<KtElement> {
         override val diagnosticClass get() = ProtectedConstructorCallFromPublicInline::class
         val inlineDeclaration: KtSymbol

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

@@ -3963,6 +3963,13 @@ internal class NonPublicCallFromPublicInlineImpl(
     token: KtLifetimeToken,
 ) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NonPublicCallFromPublicInline
 
+internal class NonPublicCallFromPublicInlineDeprecationImpl(
+    override val inlineDeclaration: KtSymbol,
+    override val referencedDeclaration: KtSymbol,
+    firDiagnostic: KtPsiDiagnostic,
+    token: KtLifetimeToken,
+) : KtAbstractFirDiagnostic<KtElement>(firDiagnostic, token), KtFirDiagnostic.NonPublicCallFromPublicInlineDeprecation
+
 internal class ProtectedConstructorCallFromPublicInlineImpl(
     override val inlineDeclaration: KtSymbol,
     override val referencedDeclaration: KtSymbol,

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosticCompilerTestFE10TestdataTestGenerated.java

@@ -20734,6 +20734,18 @@ public class DiagnosticCompilerTestFE10TestdataTestGenerated extends AbstractDia
                 runTest("compiler/testData/diagnostics/tests/inline/privateClass.kt");
             }
 
+            @Test
+            @TestMetadata("privateOperatorsInInlineAfter.kt")
+            public void testPrivateOperatorsInInlineAfter() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inline/privateOperatorsInInlineAfter.kt");
+            }
+
+            @Test
+            @TestMetadata("privateOperatorsInInlineBefore.kt")
+            public void testPrivateOperatorsInInlineBefore() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inline/privateOperatorsInInlineBefore.kt");
+            }
+
             @Test
             @TestMetadata("propagation.kt")
             public void testPropagation() throws Exception {

analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated.java

@@ -20734,6 +20734,18 @@ public class LLFirPreresolvedReversedDiagnosticCompilerFE10TestDataTestGenerated
                 runTest("compiler/testData/diagnostics/tests/inline/privateClass.kt");
             }
 
+            @Test
+            @TestMetadata("privateOperatorsInInlineAfter.kt")
+            public void testPrivateOperatorsInInlineAfter() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inline/privateOperatorsInInlineAfter.kt");
+            }
+
+            @Test
+            @TestMetadata("privateOperatorsInInlineBefore.kt")
+            public void testPrivateOperatorsInInlineBefore() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inline/privateOperatorsInInlineBefore.kt");
+            }
+
             @Test
             @TestMetadata("propagation.kt")
             public void testPropagation() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirLightTreeOldFrontendDiagnosticsTestGenerated.java

@@ -20728,6 +20728,18 @@ public class FirLightTreeOldFrontendDiagnosticsTestGenerated extends AbstractFir
                 runTest("compiler/testData/diagnostics/tests/inline/privateClass.kt");
             }
 
+            @Test
+            @TestMetadata("privateOperatorsInInlineAfter.kt")
+            public void testPrivateOperatorsInInlineAfter() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inline/privateOperatorsInInlineAfter.kt");
+            }
+
+            @Test
+            @TestMetadata("privateOperatorsInInlineBefore.kt")
+            public void testPrivateOperatorsInInlineBefore() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inline/privateOperatorsInInlineBefore.kt");
+            }
+
             @Test
             @TestMetadata("propagation.kt")
             public void testPropagation() throws Exception {

compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirPsiOldFrontendDiagnosticsTestGenerated.java

@@ -20734,6 +20734,18 @@ public class FirPsiOldFrontendDiagnosticsTestGenerated extends AbstractFirPsiDia
                 runTest("compiler/testData/diagnostics/tests/inline/privateClass.kt");
             }
 
+            @Test
+            @TestMetadata("privateOperatorsInInlineAfter.kt")
+            public void testPrivateOperatorsInInlineAfter() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inline/privateOperatorsInInlineAfter.kt");
+            }
+
+            @Test
+            @TestMetadata("privateOperatorsInInlineBefore.kt")
+            public void testPrivateOperatorsInInlineBefore() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inline/privateOperatorsInInlineBefore.kt");
+            }
+
             @Test
             @TestMetadata("propagation.kt")
             public void testPropagation() throws Exception {

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

@@ -1651,6 +1651,11 @@ object DIAGNOSTICS_LIST : DiagnosticList("FirErrors") {
             parameter<Symbol>("referencedDeclaration")
         }
 
+        val NON_PUBLIC_CALL_FROM_PUBLIC_INLINE_DEPRECATION by warning<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")

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

@@ -833,6 +833,7 @@ object FirErrors {
     val NULLABLE_INLINE_PARAMETER: KtDiagnosticFactory2<FirValueParameterSymbol, FirBasedSymbol<*>> by error2<KtDeclaration, FirValueParameterSymbol, FirBasedSymbol<*>>()
     val RECURSION_IN_INLINE: KtDiagnosticFactory1<FirBasedSymbol<*>> by error1<KtElement, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val NON_PUBLIC_CALL_FROM_PUBLIC_INLINE: KtDiagnosticFactory2<FirBasedSymbol<*>, FirBasedSymbol<*>> by error2<KtElement, FirBasedSymbol<*>, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val NON_PUBLIC_CALL_FROM_PUBLIC_INLINE_DEPRECATION: KtDiagnosticFactory2<FirBasedSymbol<*>, FirBasedSymbol<*>> by warning2<KtElement, FirBasedSymbol<*>, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE: KtDiagnosticFactory2<FirBasedSymbol<*>, FirBasedSymbol<*>> by error2<KtElement, FirBasedSymbol<*>, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR: KtDiagnosticFactory2<FirBasedSymbol<*>, FirBasedSymbol<*>> by error2<KtElement, FirBasedSymbol<*>, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val PROTECTED_CALL_FROM_PUBLIC_INLINE: KtDiagnosticFactory2<FirBasedSymbol<*>, FirBasedSymbol<*>> by warning2<KtElement, FirBasedSymbol<*>, FirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)

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

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactory2
 import org.jetbrains.kotlin.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.checkers.MppCheckerKind
@@ -26,6 +27,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.utils.*
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.FirSuperReference
+import org.jetbrains.kotlin.fir.references.symbol
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolve.transformers.publishedApiEffectiveVisibility
 import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
@@ -91,7 +93,7 @@ object FirInlineDeclarationChecker : FirFunctionChecker(MppCheckerKind.Common) {
             ) {
                 reporter.reportOn(
                     source,
-                    FirErrors.NON_PUBLIC_CALL_FROM_PUBLIC_INLINE,
+                    getNonPublicCallFromPublicInlineFactory(accessExpression, source, context),
                     inlineFunction.symbol,
                     accessedSymbol,
                     context
@@ -106,6 +108,24 @@ object FirInlineDeclarationChecker : FirFunctionChecker(MppCheckerKind.Common) {
             )
         }
 
+        private fun getNonPublicCallFromPublicInlineFactory(
+            accessExpression: FirStatement,
+            source: KtSourceElement,
+            context: CheckerContext,
+        ): KtDiagnosticFactory2<FirBasedSymbol<*>, FirBasedSymbol<*>> {
+            if (!context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitPrivateOperatorCallInInline)) {
+                val isDelegatedPropertyAccessor = source.kind == KtFakeSourceElementKind.DelegatedPropertyAccessor
+                val isForLoopButNotIteratorCall = source.kind == KtFakeSourceElementKind.DesugaredForLoop &&
+                        accessExpression.toReference(context.session)?.symbol?.memberDeclarationNameOrNull != OperatorNameConventions.ITERATOR
+
+                if (isDelegatedPropertyAccessor || isForLoopButNotIteratorCall) {
+                    return FirErrors.NON_PUBLIC_CALL_FROM_PUBLIC_INLINE_DEPRECATION
+                }
+            }
+
+            return FirErrors.NON_PUBLIC_CALL_FROM_PUBLIC_INLINE
+        }
+
         private fun EffectiveVisibility.isReachableDueToLocalDispatchReceiver(access: FirStatement, context: CheckerContext): Boolean {
             val receiverType = access.localDispatchReceiver(context) ?: return false
             val receiverProtected = EffectiveVisibility.Protected(receiverType.typeConstructor(context.session.typeContext))

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir.analysis.diagnostics
 
 import com.intellij.openapi.util.io.FileUtil
+import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.diagnostics.KtDiagnosticFactoryToRendererMap
 import org.jetbrains.kotlin.diagnostics.KtDiagnosticRenderers.CLASS_ID
 import org.jetbrains.kotlin.diagnostics.KtDiagnosticRenderers.COLLECTION
@@ -504,6 +505,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PLATFORM_CLASS_MA
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.COMPILER_REQUIRED_ANNOTATION_AMBIGUITY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.MULTIPLE_LABELS_ARE_FORBIDDEN
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.EXPECT_AND_ACTUAL_IN_THE_SAME_MODULE
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_PUBLIC_CALL_FROM_PUBLIC_INLINE_DEPRECATION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.POTENTIALLY_NON_REPORTED_ANNOTATION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRE_RELEASE_CLASS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED
@@ -2427,6 +2429,13 @@ object FirErrorsDefaultMessages : BaseDiagnosticRendererFactory() {
         )
         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 ''{0}''.", SYMBOL, SYMBOL)
+        map.put(
+            NON_PUBLIC_CALL_FROM_PUBLIC_INLINE_DEPRECATION,
+            "Public-API inline function cannot access non-public-API ''{0}''. " +
+                    "This will become an error in Kotlin ${LanguageFeature.ProhibitPrivateOperatorCallInInline.sinceVersion?.versionString}.",
+            SYMBOL,
+            SYMBOL
+        )
         map.put(
             PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE,
             "Protected constructor call from public-API inline function is deprecated.",

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

@@ -0,0 +1,63 @@
+// WITH_STDLIB
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// LANGUAGE: +ProhibitPrivateOperatorCallInInline
+
+import kotlin.reflect.KProperty
+import kotlin.properties.ReadOnlyProperty
+
+private operator fun String.getValue(nothing: Any?, property: KProperty<*>) = "OK"
+private operator fun String.setValue(nothing: Any?, property: KProperty<*>, s: String) {}
+private operator fun Int.provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, Int> = ReadOnlyProperty { _, _ -> this }
+
+private operator fun O.compareTo(other: O) = 1
+private operator fun O.contains(other: O) = true
+private operator fun O.invoke() {}
+private operator fun O.iterator() = O
+private operator fun O.next() = O
+private operator fun O.hasNext() = false
+private operator fun O.get(i: Int) = O
+private operator fun O.set(i: Int, o: O) {}
+private operator fun O.component1() = O
+private operator fun O.inc() = O
+private operator fun O.not() = O
+private operator fun O.plus(other: O) = O
+private operator fun O.unaryPlus() = O
+private operator fun O.rangeTo(other: O) = O
+private operator fun O.rangeUntil(other: O) = O
+private operator fun O.plusAssign(other: O) {}
+
+object O
+object P
+
+operator fun P.iterator() = P
+private operator fun P.next() = P
+private operator fun P.hasNext() = false
+
+inline fun foo() {
+    var x by <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE, NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>""<!>
+    x
+    x = ""
+
+    val y by <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>1<!>
+    y
+
+    var o = O
+    o <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!><<!> o
+    o <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>in<!> o
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>o<!>()
+    for (o1 in <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE, NON_PUBLIC_CALL_FROM_PUBLIC_INLINE, NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>o<!>) {
+    }
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>o[1]<!>
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>o[1]<!> = o
+    val (<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>o2<!>) = o
+    o<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>++<!>
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>!<!>o
+    o <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>+<!> o
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>+<!>o
+    o<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>..<!>o
+    o<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>..<<!>o
+    O <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>+=<!> o
+
+    for (p in <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE, NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>P<!>) {
+    }
+}

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

@@ -0,0 +1,63 @@
+// WITH_STDLIB
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// LANGUAGE: +ProhibitPrivateOperatorCallInInline
+
+import kotlin.reflect.KProperty
+import kotlin.properties.ReadOnlyProperty
+
+private operator fun String.getValue(nothing: Any?, property: KProperty<*>) = "OK"
+private operator fun String.setValue(nothing: Any?, property: KProperty<*>, s: String) {}
+private operator fun Int.provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, Int> = ReadOnlyProperty { _, _ -> this }
+
+private operator fun O.compareTo(other: O) = 1
+private operator fun O.contains(other: O) = true
+private operator fun O.invoke() {}
+private operator fun O.iterator() = O
+private operator fun O.next() = O
+private operator fun O.hasNext() = false
+private operator fun O.get(i: Int) = O
+private operator fun O.set(i: Int, o: O) {}
+private operator fun O.component1() = O
+private operator fun O.inc() = O
+private operator fun O.not() = O
+private operator fun O.plus(other: O) = O
+private operator fun O.unaryPlus() = O
+private operator fun O.rangeTo(other: O) = O
+private operator fun O.rangeUntil(other: O) = O
+private operator fun O.plusAssign(other: O) {}
+
+object O
+object P
+
+operator fun P.iterator() = P
+private operator fun P.next() = P
+private operator fun P.hasNext() = false
+
+inline fun foo() {
+    var x by ""
+    x
+    x = ""
+
+    val y by 1
+    y
+
+    var o = O
+    o <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!><<!> o
+    o <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>in<!> o
+    <!DEPRECATED_IMPLICIT_NON_PUBLIC_API_ACCESS!>o<!>()
+    for (o1 in <!ITERATOR_MISSING!>o<!>) {
+    }
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>o[1]<!>
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>o[1]<!> = o
+    val (o2) = <!COMPONENT_FUNCTION_MISSING!>o<!>
+    o<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>++<!>
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>!<!>o
+    o <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>+<!> o
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>+<!>o
+    o<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>..<!>o
+    o<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>..<<!>o
+    O <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>+=<!> o
+
+    for (p in P) {
+    }
+}

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

@@ -0,0 +1,63 @@
+// WITH_STDLIB
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// LANGUAGE: -ProhibitPrivateOperatorCallInInline
+
+import kotlin.reflect.KProperty
+import kotlin.properties.ReadOnlyProperty
+
+private operator fun String.getValue(nothing: Any?, property: KProperty<*>) = "OK"
+private operator fun String.setValue(nothing: Any?, property: KProperty<*>, s: String) {}
+private operator fun Int.provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, Int> = ReadOnlyProperty { _, _ -> this }
+
+private operator fun O.compareTo(other: O) = 1
+private operator fun O.contains(other: O) = true
+private operator fun O.invoke() {}
+private operator fun O.iterator() = O
+private operator fun O.next() = O
+private operator fun O.hasNext() = false
+private operator fun O.get(i: Int) = O
+private operator fun O.set(i: Int, o: O) {}
+private operator fun O.component1() = O
+private operator fun O.inc() = O
+private operator fun O.not() = O
+private operator fun O.plus(other: O) = O
+private operator fun O.unaryPlus() = O
+private operator fun O.rangeTo(other: O) = O
+private operator fun O.rangeUntil(other: O) = O
+private operator fun O.plusAssign(other: O) {}
+
+object O
+object P
+
+operator fun P.iterator() = P
+private operator fun P.next() = P
+private operator fun P.hasNext() = false
+
+inline fun foo() {
+    var x by <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE_DEPRECATION, NON_PUBLIC_CALL_FROM_PUBLIC_INLINE_DEPRECATION!>""<!>
+    x
+    x = ""
+
+    val y by <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE_DEPRECATION!>1<!>
+    y
+
+    var o = O
+    o <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!><<!> o
+    o <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>in<!> o
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>o<!>()
+    for (o1 in <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE, NON_PUBLIC_CALL_FROM_PUBLIC_INLINE_DEPRECATION, NON_PUBLIC_CALL_FROM_PUBLIC_INLINE_DEPRECATION!>o<!>) {
+    }
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>o[1]<!>
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>o[1]<!> = o
+    val (<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>o2<!>) = o
+    o<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>++<!>
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>!<!>o
+    o <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>+<!> o
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>+<!>o
+    o<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>..<!>o
+    o<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>..<<!>o
+    O <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>+=<!> o
+
+    for (p in <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE_DEPRECATION, NON_PUBLIC_CALL_FROM_PUBLIC_INLINE_DEPRECATION!>P<!>) {
+    }
+}

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

@@ -0,0 +1,63 @@
+// WITH_STDLIB
+// DIAGNOSTICS: -NOTHING_TO_INLINE
+// LANGUAGE: -ProhibitPrivateOperatorCallInInline
+
+import kotlin.reflect.KProperty
+import kotlin.properties.ReadOnlyProperty
+
+private operator fun String.getValue(nothing: Any?, property: KProperty<*>) = "OK"
+private operator fun String.setValue(nothing: Any?, property: KProperty<*>, s: String) {}
+private operator fun Int.provideDelegate(thisRef: Any?, prop: KProperty<*>): ReadOnlyProperty<Any?, Int> = ReadOnlyProperty { _, _ -> this }
+
+private operator fun O.compareTo(other: O) = 1
+private operator fun O.contains(other: O) = true
+private operator fun O.invoke() {}
+private operator fun O.iterator() = O
+private operator fun O.next() = O
+private operator fun O.hasNext() = false
+private operator fun O.get(i: Int) = O
+private operator fun O.set(i: Int, o: O) {}
+private operator fun O.component1() = O
+private operator fun O.inc() = O
+private operator fun O.not() = O
+private operator fun O.plus(other: O) = O
+private operator fun O.unaryPlus() = O
+private operator fun O.rangeTo(other: O) = O
+private operator fun O.rangeUntil(other: O) = O
+private operator fun O.plusAssign(other: O) {}
+
+object O
+object P
+
+operator fun P.iterator() = P
+private operator fun P.next() = P
+private operator fun P.hasNext() = false
+
+inline fun foo() {
+    var x by ""
+    x
+    x = ""
+
+    val y by 1
+    y
+
+    var o = O
+    o <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!><<!> o
+    o <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>in<!> o
+    <!DEPRECATED_IMPLICIT_NON_PUBLIC_API_ACCESS!>o<!>()
+    for (o1 in <!ITERATOR_MISSING!>o<!>) {
+    }
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>o[1]<!>
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>o[1]<!> = o
+    val (o2) = <!COMPONENT_FUNCTION_MISSING!>o<!>
+    o<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>++<!>
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>!<!>o
+    o <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>+<!> o
+    <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>+<!>o
+    o<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>..<!>o
+    o<!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>..<<!>o
+    O <!NON_PUBLIC_CALL_FROM_PUBLIC_INLINE!>+=<!> o
+
+    for (p in P) {
+    }
+}

compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java

@@ -20734,6 +20734,18 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest {
                 runTest("compiler/testData/diagnostics/tests/inline/privateClass.kt");
             }
 
+            @Test
+            @TestMetadata("privateOperatorsInInlineAfter.kt")
+            public void testPrivateOperatorsInInlineAfter() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inline/privateOperatorsInInlineAfter.kt");
+            }
+
+            @Test
+            @TestMetadata("privateOperatorsInInlineBefore.kt")
+            public void testPrivateOperatorsInInlineBefore() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/inline/privateOperatorsInInlineBefore.kt");
+            }
+
             @Test
             @TestMetadata("propagation.kt")
             public void testPropagation() throws Exception {

compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt

@@ -320,6 +320,7 @@ enum class LanguageFeature(
     ForbidLambdaParameterWithMissingDependencyType(KOTLIN_2_1, kind = BUG_FIX), // KT-64266
     JsAllowInvalidCharsIdentifiersEscaping(KOTLIN_2_1, kind = OTHER), // KT-31799
     SupportJavaErrorEnhancementOfArgumentsOfWarningLevelEnhanced(KOTLIN_2_1, kind = BUG_FIX), // KT-63209
+    ProhibitPrivateOperatorCallInInline(KOTLIN_2_1, kind = BUG_FIX), // KT-65494
 
     // End of 2.* language features --------------------------------------------------