[FIR] Resolve infix calls to infix functions only

Implements INFIX_MODIFIER_REQUIRED diagnostics

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

@@ -233,6 +233,9 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
             parameter<FirNamedFunctionSymbol>("functionSymbol")
             parameter<String>("name")
         }
+        val INFIX_MODIFIER_REQUIRED by error<PsiElement> {
+            parameter<FirNamedFunctionSymbol>("functionSymbol")
+        }
     }
 
     val INLINE_CLASSES by object : DiagnosticGroup("Inline classes") {

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

@@ -209,6 +209,7 @@ object FirErrors {
     val REDUNDANT_OPEN_IN_INTERFACE by warning0<KtModifierListOwner>(SourceElementPositioningStrategies.OPEN_MODIFIER)
     val WRONG_MODIFIER_TARGET by error2<PsiElement, KtModifierKeywordToken, String>()
     val OPERATOR_MODIFIER_REQUIRED by error2<PsiElement, FirNamedFunctionSymbol, String>()
+    val INFIX_MODIFIER_REQUIRED by error1<PsiElement, FirNamedFunctionSymbol>()
 
     // Inline classes
     val INLINE_CLASS_NOT_TOP_LEVEL by error0<KtDeclaration>(SourceElementPositioningStrategies.INLINE_OR_VALUE_MODIFIER)

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

@@ -82,9 +82,11 @@ object FirInlineDeclarationChecker : FirMemberDeclarationChecker() {
 
         override fun visitFunctionCall(functionCall: FirFunctionCall, data: CheckerContext) {
             val targetSymbol = functionCall.toResolvedCallableSymbol()
-            checkReceiversOfQualifiedAccessExpression(functionCall, targetSymbol, data)
+            if (targetSymbol != null) {
-            checkArgumentsOfCall(functionCall, targetSymbol, data)
+                checkReceiversOfQualifiedAccessExpression(functionCall, targetSymbol, data)
-            checkQualifiedAccess(functionCall, targetSymbol, data)
+                checkArgumentsOfCall(functionCall, targetSymbol, data)
+                checkQualifiedAccess(functionCall, targetSymbol, data)
+            }
         }
 
         override fun visitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression, data: CheckerContext) {

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

@@ -154,6 +154,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INCOMPATIBLE_MODI
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INCOMPATIBLE_TYPES
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INCOMPATIBLE_TYPES_WARNING
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INFERENCE_ERROR
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INFIX_MODIFIER_REQUIRED
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INITIALIZER_TYPE_MISMATCH
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INLINE_CLASS_CANNOT_BE_RECURSIVE
@@ -539,6 +540,7 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
             map.put(INCOMPATIBLE_MODIFIERS, "Modifier ''{0}'' is incompatible with ''{1}''", TO_STRING, TO_STRING)
             map.put(REDUNDANT_OPEN_IN_INTERFACE, "Modifier 'open' is redundant for abstract interface members")
             map.put(WRONG_MODIFIER_TARGET, "Modifier ''{0}'' is not applicable to ''{1}''", TO_STRING, TO_STRING)
+            map.put(INFIX_MODIFIER_REQUIRED, "''infix'' modifier is required on ''{0}''", TO_STRING)
 
             // Classes and interfaces
             map.put(SUPERTYPE_NOT_INITIALIZED, "This type has a constructor, and thus must be initialized here")

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

@@ -142,6 +142,7 @@ private fun mapInapplicableCandidateError(
             )
             is UnsafeCall -> mapUnsafeCallError(diagnostic.candidate, rootCause, source, qualifiedAccessSource)
             is ManyLambdaExpressionArguments -> FirErrors.MANY_LAMBDA_EXPRESSION_ARGUMENTS.on(rootCause.argument.source ?: source)
+            is InfixCallOfNonInfixFunction -> FirErrors.INFIX_MODIFIER_REQUIRED.on(source, rootCause.function)
             else -> null
         }
     }.ifEmpty { listOf(FirErrors.INAPPLICABLE_CANDIDATE.on(source, diagnostic.candidate.symbol)) }

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

@@ -41,7 +41,7 @@ object CommonExpressionCheckers : ExpressionCheckers() {
         get() = setOf(
             FirConventionFunctionCallChecker,
             FirDivisionByZeroChecker,
-            FirConstructorCallChecker
+            FirConstructorCallChecker,
         )
 
     override val tryExpressionCheckers: Set<FirTryExpressionChecker>

compiler/fir/raw-fir/psi2fir/src/org/jetbrains/kotlin/fir/builder/RawFirBuilder.kt

@@ -1889,6 +1889,7 @@ open class RawFirBuilder(
                     }
                     explicitReceiver = leftArgument
                     argumentList = buildUnaryArgumentList(rightArgument)
+                    origin = if (conventionCallName != null) FirFunctionCallOrigin.REGULAR else FirFunctionCallOrigin.INFIX
                 }
             } else {
                 val firOperation = operationToken.toFirOperation()

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirCallResolver.kt

@@ -153,15 +153,28 @@ class FirCallResolver(
         towerResolver.reset()
         val result = towerResolver.runResolver(info, transformer.resolutionContext)
         val bestCandidates = result.bestCandidates()
-        var reducedCandidates = if (!result.currentApplicability.isSuccess) {
+
-            bestCandidates.toSet()
+        fun chooseMostSpecific(): Set<Candidate> {
-        } else {
             val onSuperReference = (explicitReceiver as? FirQualifiedAccessExpression)?.calleeReference is FirSuperReference
-            conflictResolver.chooseMaximallySpecificCandidates(
+            return conflictResolver.chooseMaximallySpecificCandidates(
                 bestCandidates, discriminateGenerics = true, discriminateAbstracts = onSuperReference
             )
         }
 
+        var reducedCandidates = if (!result.currentApplicability.isSuccess) {
+            val distinctApplicabilities = bestCandidates.flatMapTo(mutableSetOf()) { candidate ->
+                candidate.diagnostics.map { it.applicability }
+            }
+            //if all candidates have the same kind on inApplicability - try to choose the most specific one
+            if (distinctApplicabilities.size == 1 && distinctApplicabilities.single() > CandidateApplicability.INAPPLICABLE) {
+                chooseMostSpecific()
+            } else {
+                bestCandidates.toSet()
+            }
+        } else {
+            chooseMostSpecific()
+        }
+
         reducedCandidates = overloadByLambdaReturnTypeResolver.reduceCandidates(qualifiedAccess, bestCandidates, reducedCandidates)
 
         return ResolutionResult(info, result.currentApplicability, reducedCandidates)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/CallKind.kt

@@ -39,6 +39,7 @@ sealed class CallKind(vararg resolutionSequence: ResolutionStage) {
         CheckDispatchReceiver,
         CheckExtensionReceiver,
         CheckArguments,
+        CheckInfixCall,
         EagerResolveOfCallableReferences,
         CheckLowPriorityInOverloadResolution,
         PostponedVariablesInitializerResolutionStage

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionDiagnostic.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.fir.declarations.FirFunction
 import org.jetbrains.kotlin.fir.declarations.FirValueParameter
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirNamedArgumentExpression
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
 import org.jetbrains.kotlin.resolve.calls.tower.CandidateApplicability
@@ -102,3 +103,5 @@ class NullForNotNullType(
 class ManyLambdaExpressionArguments(
     val argument: FirExpression
 ) : ResolutionDiagnostic(INAPPLICABLE_ARGUMENTS_MAPPING_ERROR)
+
+class InfixCallOfNonInfixFunction(val function: FirNamedFunctionSymbol) : ResolutionDiagnostic(INAPPLICABLE_MODIFIER)

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/calls/ResolutionStages.kt

@@ -9,15 +9,14 @@ import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.FirSymbolOwner
 import org.jetbrains.kotlin.fir.FirVisibilityChecker
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.expressions.FirQualifiedAccessExpression
-import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
 import org.jetbrains.kotlin.fir.references.FirSuperReference
 import org.jetbrains.kotlin.fir.resolve.inference.*
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.symbols.SyntheticSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirFunctionSymbol
+import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.typeContext
 import org.jetbrains.kotlin.fir.types.*
@@ -267,3 +266,16 @@ internal object PostponedVariablesInitializerResolutionStage : ResolutionStage()
         }
     }
 }
+
+internal object CheckInfixCall : CheckerStage() {
+    override suspend fun check(candidate: Candidate, callInfo: CallInfo, sink: CheckerSink, context: ResolutionContext) {
+        if (callInfo.callSite is FirFunctionCall) {
+            if (callInfo.callSite.origin == FirFunctionCallOrigin.INFIX) {
+                val functionSymbol = candidate.symbol as? FirNamedFunctionSymbol ?: return
+                if (!functionSymbol.fir.isInfix) {
+                    sink.reportDiagnostic(InfixCallOfNonInfixFunction(functionSymbol))
+                }
+            }
+        }
+    }
+}

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirIntegerOperatorCall.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin
 import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirQualifiedAccessBuilder
@@ -43,6 +44,7 @@ class FirIntegerOperatorCall @FirImplementationDetail constructor(
     extensionReceiver,
     argumentList,
     calleeReference,
+    FirFunctionCallOrigin.OPERATOR
 )
 
 @FirBuilderDsl

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirComponentCall.kt

@@ -28,6 +28,7 @@ abstract class FirComponentCall : FirFunctionCall() {
     abstract override val extensionReceiver: FirExpression
     abstract override val argumentList: FirArgumentList
     abstract override val calleeReference: FirNamedReference
+    abstract override val origin: FirFunctionCallOrigin
     abstract override val explicitReceiver: FirExpression
     abstract val componentIndex: Int
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirFunctionCall.kt

@@ -29,6 +29,7 @@ abstract class FirFunctionCall : FirQualifiedAccessExpression(), FirCall {
     abstract override val extensionReceiver: FirExpression
     abstract override val argumentList: FirArgumentList
     abstract override val calleeReference: FirNamedReference
+    abstract val origin: FirFunctionCallOrigin
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitFunctionCall(this, data)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/FirImplicitInvokeCall.kt

@@ -29,6 +29,7 @@ abstract class FirImplicitInvokeCall : FirFunctionCall() {
     abstract override val extensionReceiver: FirExpression
     abstract override val argumentList: FirArgumentList
     abstract override val calleeReference: FirNamedReference
+    abstract override val origin: FirFunctionCallOrigin
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitImplicitInvokeCall(this, data)
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirAbstractFunctionCallBuilder.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin
 import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirQualifiedAccessBuilder
 import org.jetbrains.kotlin.fir.references.FirNamedReference
@@ -34,5 +35,6 @@ interface FirAbstractFunctionCallBuilder : FirQualifiedAccessBuilder, FirCallBui
     abstract override var argumentList: FirArgumentList
     abstract var typeRef: FirTypeRef
     abstract var calleeReference: FirNamedReference
+    abstract var origin: FirFunctionCallOrigin
     override fun build(): FirFunctionCall
 }

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirComponentCallBuilder.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirComponentCall
 import org.jetbrains.kotlin.fir.expressions.FirEmptyArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin
 import org.jetbrains.kotlin.fir.expressions.builder.FirCallBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.impl.FirComponentCallImpl

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirFunctionCallBuilder.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirEmptyArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin
 import org.jetbrains.kotlin.fir.expressions.builder.FirAbstractFunctionCallBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
 import org.jetbrains.kotlin.fir.expressions.impl.FirFunctionCallImpl
@@ -42,6 +43,7 @@ open class FirFunctionCallBuilder : FirAbstractFunctionCallBuilder, FirAnnotatio
     override var extensionReceiver: FirExpression = FirNoReceiverExpression
     override var argumentList: FirArgumentList = FirEmptyArgumentList
     override lateinit var calleeReference: FirNamedReference
+    override var origin: FirFunctionCallOrigin = FirFunctionCallOrigin.REGULAR
 
     @OptIn(FirImplementationDetail::class)
     override fun build(): FirFunctionCall {
@@ -55,6 +57,7 @@ open class FirFunctionCallBuilder : FirAbstractFunctionCallBuilder, FirAnnotatio
             extensionReceiver,
             argumentList,
             calleeReference,
+            origin,
         )
     }
 

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/builder/FirImplicitInvokeCallBuilder.kt

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirEmptyArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin
 import org.jetbrains.kotlin.fir.expressions.FirImplicitInvokeCall
 import org.jetbrains.kotlin.fir.expressions.builder.FirAbstractFunctionCallBuilder
 import org.jetbrains.kotlin.fir.expressions.builder.FirExpressionBuilder
@@ -62,6 +63,13 @@ open class FirImplicitInvokeCallBuilder : FirAbstractFunctionCallBuilder, FirAnn
         set(_) {
             throw IllegalStateException()
         }
+
+    @Deprecated("Modification of 'origin' has no impact for FirImplicitInvokeCallBuilder", level = DeprecationLevel.HIDDEN)
+    override var origin: FirFunctionCallOrigin
+        get() = throw IllegalStateException()
+        set(_) {
+            throw IllegalStateException()
+        }
 }
 
 @OptIn(ExperimentalContracts::class)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirComponentCallImpl.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirComponentCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.references.impl.FirSimpleNamedReference
@@ -38,6 +39,7 @@ internal class FirComponentCallImpl(
 ) : FirComponentCall() {
     override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null)
     override var calleeReference: FirNamedReference = FirSimpleNamedReference(source, Name.identifier("component$componentIndex"), null)
+    override val origin: FirFunctionCallOrigin = FirFunctionCallOrigin.REGULAR
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         typeRef.accept(visitor, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirFunctionCallImpl.kt

@@ -11,6 +11,7 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.FirFunctionCall
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirReference
 import org.jetbrains.kotlin.fir.types.FirTypeProjection
@@ -32,6 +33,7 @@ open class FirFunctionCallImpl @FirImplementationDetail constructor(
     override var extensionReceiver: FirExpression,
     override var argumentList: FirArgumentList,
     override var calleeReference: FirNamedReference,
+    override val origin: FirFunctionCallOrigin,
 ) : FirFunctionCall() {
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         typeRef.accept(visitor, data)

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/expressions/impl/FirImplicitInvokeCallImpl.kt

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirArgumentList
 import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirFunctionCallOrigin
 import org.jetbrains.kotlin.fir.expressions.FirImplicitInvokeCall
 import org.jetbrains.kotlin.fir.references.FirNamedReference
 import org.jetbrains.kotlin.fir.references.FirReference
@@ -34,6 +35,7 @@ internal class FirImplicitInvokeCallImpl(
     override var calleeReference: FirNamedReference,
 ) : FirImplicitInvokeCall() {
     override var typeRef: FirTypeRef = FirImplicitTypeRefImpl(null)
+    override val origin: FirFunctionCallOrigin = FirFunctionCallOrigin.REGULAR
 
     override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
         typeRef.accept(visitor, data)

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

@@ -0,0 +1,10 @@
+/*
+ * 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.expressions
+
+enum class FirFunctionCallOrigin {
+    REGULAR, INFIX, OPERATOR
+}

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/BuilderConfigurator.kt

@@ -176,7 +176,12 @@ object BuilderConfigurator : AbstractBuilderConfigurator<FirTreeBuilder>(FirTree
             useTypes(emptyArgumentListType)
         }
 
-        builder(functionCall, init = configurationForFunctionCallBuilder)
+        builder(functionCall) {
+            configurationForFunctionCallBuilder()
+            default("origin") {
+                value = "FirFunctionCallOrigin.REGULAR"
+            }
+        }
         builder(implicitInvokeCall, init = configurationForFunctionCallBuilder)
 
         builder(qualifiedAccessExpression) {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/ImplementationConfigurator.kt

@@ -153,6 +153,18 @@ object ImplementationConfigurator : AbstractFirTreeImplementationConfigurator()
             kind = OpenClass
         }
 
+        fun ImplementationContext.defaultFunctionOrigin() {
+            default("origin", "FirFunctionCallOrigin.REGULAR")
+        }
+
+        impl(implicitInvokeCall) {
+            defaultFunctionOrigin()
+        }
+
+        impl(componentCall) {
+            defaultFunctionOrigin()
+        }
+
         impl(qualifiedAccessExpression)
 
         noImpl(expressionWithSmartcast)

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -207,6 +207,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
 
         functionCall.configure {
             +field("calleeReference", namedReference)
+            +field("origin", functionCallOrigin)
         }
 
         comparisonExpression.configure {

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt

@@ -86,3 +86,5 @@ val annotationResolveStatusType = generatedType("expressions", "FirAnnotationRes
 val exhaustivenessStatusType = generatedType("expressions", "ExhaustivenessStatus")
 
 val callableReferenceMappedArgumentsType = type("fir.resolve.calls", "CallableReferenceMappedArguments")
+
+val functionCallOrigin = type("fir.expressions", "FirFunctionCallOrigin")

compiler/resolution.common/src/org/jetbrains/kotlin/resolve/calls/tower/CandidateApplicability.kt

@@ -11,6 +11,7 @@ enum class CandidateApplicability {
     INAPPLICABLE_WRONG_RECEIVER, // receiver not matched
     INAPPLICABLE_ARGUMENTS_MAPPING_ERROR, // arguments not mapped to parameters (i.e. different size of arguments and parameters)
     INAPPLICABLE, // arguments have wrong types
+    INAPPLICABLE_MODIFIER, // no expected modifier (eg infix call on non-infix function)
     IMPOSSIBLE_TO_GENERATE, // access to outer class from nested
     RUNTIME_ERROR, // problems with visibility
     UNSAFE_CALL, // receiver nullability doesn't match

compiler/testData/codegen/box/operatorConventions/infixFunctionOverBuiltinMember.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 infix fun Int.rem(other: Int) = 10
 infix operator fun Int.minus(other: Int): Int = 20
 

compiler/testData/diagnostics/tests/Infix.fir.kt

@@ -18,21 +18,21 @@ fun Example.withLambda(f: () -> Unit) = Pair(this, f)
 
 fun test() {
     Example() to Example()
-    Example() toNonInfix Example()
+    Example() <!INFIX_MODIFIER_REQUIRED!>toNonInfix<!> Example()
     Example().toNonInfix(Example())
 
     val a = Example()
     val b = Example()
 
     a toExt b
-    a toExtNonInfix b
+    a <!INFIX_MODIFIER_REQUIRED!>toExtNonInfix<!> b
     a.toExtNonInfix(b)
 
     a toExtWithExtraParams b
-    a toExtNonInfixWithExtraParams b
+    a <!INFIX_MODIFIER_REQUIRED!>toExtNonInfixWithExtraParams<!> b
 
     a toExtDefaultValues b
-    a toExtNonInfixDefaultValues b
+    a <!INFIX_MODIFIER_REQUIRED!>toExtNonInfixDefaultValues<!> b
 
-    a withLambda { }
+    a <!INFIX_MODIFIER_REQUIRED!>withLambda<!> { }
 }

compiler/testData/diagnostics/tests/NumberPrefixAndSuffix.fir.kt

@@ -12,7 +12,7 @@ fun test(a: Any) {
     1ffoo a
     1doo a
     1ddoo a
-    1contains a
+    1<!INFIX_MODIFIER_REQUIRED!>contains<!> a
 
     1Lfoo a
     1L<!UNRESOLVED_REFERENCE!>oo<!> a

compiler/testData/diagnostics/tests/evaluate/infixFunOverBuiltinMemberInConst.fir.kt

@@ -1,10 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER
-
-infix fun Int.rem(other: Int) = 10
-infix operator fun Int.minus(other: Int): Int = 20
-
-const val a1 = (-5) rem 2
-const val a2 = (-5).rem(2)
-
-const val b1 = 5 minus 3
-const val b2 = 5.minus(3)

compiler/testData/diagnostics/tests/evaluate/infixFunOverBuiltinMemberInConst.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_VARIABLE, -UNUSED_PARAMETER
 
 infix fun Int.rem(other: Int) = 10

compiler/testData/diagnostics/tests/evaluate/numberBinaryOperationsInfixCall.fir.kt

@@ -4,23 +4,23 @@ fun fooByte(p: Byte) = p
 fun fooShort(p: Short) = p
 
 fun test() {
-    fooInt(1 plus 1)
+    fooInt(1 <!INFIX_MODIFIER_REQUIRED!>plus<!> 1)
-    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 plus 1<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 <!INFIX_MODIFIER_REQUIRED!>plus<!> 1<!>)
-    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 plus 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 <!INFIX_MODIFIER_REQUIRED!>plus<!> 1<!>)
-    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 plus 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 <!INFIX_MODIFIER_REQUIRED!>plus<!> 1<!>)
 
-    fooInt(1 times 1)
+    fooInt(1 <!INFIX_MODIFIER_REQUIRED!>times<!> 1)
-    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 times 1<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 <!INFIX_MODIFIER_REQUIRED!>times<!> 1<!>)
-    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 times 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 <!INFIX_MODIFIER_REQUIRED!>times<!> 1<!>)
-    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 times 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 <!INFIX_MODIFIER_REQUIRED!>times<!> 1<!>)
 
-    fooInt(1 div 1)
+    fooInt(1 <!INFIX_MODIFIER_REQUIRED!>div<!> 1)
-    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 div 1<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 <!INFIX_MODIFIER_REQUIRED!>div<!> 1<!>)
-    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 div 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 <!INFIX_MODIFIER_REQUIRED!>div<!> 1<!>)
-    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 div 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 <!INFIX_MODIFIER_REQUIRED!>div<!> 1<!>)
 
-    fooInt(1 rem 1)
+    fooInt(1 <!INFIX_MODIFIER_REQUIRED!>rem<!> 1)
-    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 rem 1<!>)
+    fooByte(<!ARGUMENT_TYPE_MISMATCH!>1 <!INFIX_MODIFIER_REQUIRED!>rem<!> 1<!>)
-    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 rem 1<!>)
+    fooLong(<!ARGUMENT_TYPE_MISMATCH!>1 <!INFIX_MODIFIER_REQUIRED!>rem<!> 1<!>)
-    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 rem 1<!>)
+    fooShort(<!ARGUMENT_TYPE_MISMATCH!>1 <!INFIX_MODIFIER_REQUIRED!>rem<!> 1<!>)
 }

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

@@ -25,7 +25,7 @@ inline fun inlineFunWithInvoke(s: (p: Int) -> Unit) {
     {
         s(11)
         s.invoke(11)
-        s invoke 11
+        s <!INFIX_MODIFIER_REQUIRED!>invoke<!> 11
     }()
 }
 
@@ -33,7 +33,7 @@ inline fun inlineFunWithInvokeNonInline(noinline s: (p: Int) -> Unit) {
     {
         s(11)
         s.invoke(11)
-        s invoke 11
+        s <!INFIX_MODIFIER_REQUIRED!>invoke<!> 11
     }()
 }
 

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

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

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

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

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

@@ -3,13 +3,13 @@
 inline fun inlineFunWithInvoke(s: (p: Int) -> Unit) {
     (s)(11)
     (s).invoke(11)
-    (s) invoke 11
+    (s) <!INFIX_MODIFIER_REQUIRED!>invoke<!> 11
     (<!USAGE_IS_NOT_INLINABLE!>s<!>)
 }
 
 inline fun Function1<Int, Unit>.inlineExt() {
     (this).invoke(11)
-    (this) invoke 11
+    (this) <!INFIX_MODIFIER_REQUIRED!>invoke<!> 11
     (this)(11)
     (this)
 }
@@ -17,7 +17,7 @@ inline fun Function1<Int, Unit>.inlineExt() {
 inline fun inlineFunWithInvoke2(s: (p: Int) -> Unit) {
     (((s)))(11)
     (((s))).invoke(11)
-    (((s))) invoke 11
+    (((s))) <!INFIX_MODIFIER_REQUIRED!>invoke<!> 11
     (((<!USAGE_IS_NOT_INLINABLE!>s<!>)))
 }
 

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

@@ -17,10 +17,10 @@ inline fun inlineFunWithInvoke(s: (p: Int) -> Unit, ext: Int.(p: Int) -> Unit) {
     Test().test(){
         s(11)
         s.invoke(11)
-        s invoke 11
+        s <!INFIX_MODIFIER_REQUIRED!>invoke<!> 11
 
         11.ext(11)
-        11 ext 11
+        11 <!INFIX_MODIFIER_REQUIRED!>ext<!> 11
 
         <!USAGE_IS_NOT_INLINABLE!>s<!>
         <!USAGE_IS_NOT_INLINABLE!>ext<!>
@@ -32,10 +32,10 @@ inline fun inlineFunWithInvokeNonInline(noinline s: (p: Int) -> Unit, ext: Int.(
     Test().test(){
         s(11)
         s.invoke(11)
-        s invoke 11
+        s <!INFIX_MODIFIER_REQUIRED!>invoke<!> 11
 
         11.ext(11)
-        11 ext 11
+        11 <!INFIX_MODIFIER_REQUIRED!>ext<!> 11
 
         s
         <!USAGE_IS_NOT_INLINABLE!>ext<!>
@@ -48,7 +48,7 @@ inline fun Function1<Int, Unit>.inlineExt() {
     Test().test(){
         invoke(11)
         this.invoke(11)
-        this invoke 11
+        this <!INFIX_MODIFIER_REQUIRED!>invoke<!> 11
         this(11)
 
         this

compiler/testData/diagnostics/tests/modifiers/operatorInfix/LocalFunctions.fir.kt

@@ -24,13 +24,13 @@ fun a() {
             consumeInt(<!ARGUMENT_TYPE_MISMATCH!>a - b<!>)
 
             consumeString(a plus b)
-            consumeInt(<!ARGUMENT_TYPE_MISMATCH!>a minus b<!>)
+            consumeInt(a minus b)
 
             a * b
             a / b
 
             a times b
-            a div b
+            a <!INFIX_MODIFIER_REQUIRED!>div<!> b
         }
     }
 }

compiler/testData/diagnostics/tests/modifiers/operatorInfix/MemberFunctions.fir.kt

@@ -26,7 +26,7 @@ fun a() {
     a plus b
     a minus b
     a times b
-    a div b
+    a <!INFIX_MODIFIER_REQUIRED!>div<!> b
 
     with (Example()) {
         consumeInt(this + a)
@@ -35,9 +35,9 @@ fun a() {
         consumeInt(this / b)
 
         consumeInt(this plus a)
-        consumeString(<!ARGUMENT_TYPE_MISMATCH!>this minus b<!>)
+        consumeString(this minus b)
         consumeInt(this times a)
-        consumeInt(this div b)
+        consumeInt(this <!INFIX_MODIFIER_REQUIRED!>div<!> b)
     }
 }
 

compiler/testData/diagnostics/tests/modifiers/operatorInfix/Simple.fir.kt

@@ -37,7 +37,7 @@ fun test() {
 
     consumeExample2(<!ARGUMENT_TYPE_MISMATCH!>++a<!>)
 
-    consumeString(<!ARGUMENT_TYPE_MISMATCH!>a plus b<!>)
+    consumeString(a plus b)
 }
 
 fun consumeInt(i: Int) {}

compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/arithmetic.fir.kt

@@ -41,13 +41,13 @@ fun test() {
     platformN + 1
     platformJ + 1
 
-    1 plus platformNN
+    1 <!INFIX_MODIFIER_REQUIRED!>plus<!> platformNN
-    1 plus platformN
+    1 <!INFIX_MODIFIER_REQUIRED!>plus<!> platformN
-    1 plus platformJ
+    1 <!INFIX_MODIFIER_REQUIRED!>plus<!> platformJ
 
-    platformNN plus 1
+    platformNN <!INFIX_MODIFIER_REQUIRED!>plus<!> 1
-    platformN plus 1
+    platformN <!INFIX_MODIFIER_REQUIRED!>plus<!> 1
-    platformJ plus 1
+    platformJ <!INFIX_MODIFIER_REQUIRED!>plus<!> 1
 
     platformNN += 1
     platformN += 1

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

@@ -813,6 +813,13 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
+    add(FirErrors.INFIX_MODIFIER_REQUIRED) { firDiagnostic ->
+        InfixModifierRequiredImpl(
+            firSymbolBuilder.functionLikeBuilder.buildFunctionSymbol(firDiagnostic.a.fir),
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
     add(FirErrors.INLINE_CLASS_NOT_TOP_LEVEL) { firDiagnostic ->
         InlineClassNotTopLevelImpl(
             firDiagnostic as FirPsiDiagnostic<*>,

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

@@ -586,6 +586,11 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
         abstract val name: String
     }
 
+    abstract class InfixModifierRequired : KtFirDiagnostic<PsiElement>() {
+        override val diagnosticClass get() = InfixModifierRequired::class
+        abstract val functionSymbol: KtFunctionLikeSymbol
+    }
+
     abstract class InlineClassNotTopLevel : KtFirDiagnostic<KtDeclaration>() {
         override val diagnosticClass get() = InlineClassNotTopLevel::class
     }

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

@@ -938,6 +938,14 @@ internal class OperatorModifierRequiredImpl(
     override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
 }
 
+internal class InfixModifierRequiredImpl(
+    override val functionSymbol: KtFunctionLikeSymbol,
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.InfixModifierRequired(), KtAbstractFirDiagnostic<PsiElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
 internal class InlineClassNotTopLevelImpl(
     firDiagnostic: FirPsiDiagnostic<*>,
     override val token: ValidityToken,