[FIR] Implement INT_LITERAL_OUT_OF_RANGE diagnostics, fix tests

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

@@ -56,6 +56,7 @@ enum class PositioningStrategy(private val strategy: String? = null) {
     VALUE_ARGUMENTS,
     SUPERTYPES_LIST,
     RETURN_WITH_LABEL,
+    INT_LITERAL_OUT_OF_RANGE,
     LONG_LITERAL_SUFFIX,
 
     ;

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

@@ -61,6 +61,7 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
         val EMPTY_CHARACTER_LITERAL by error<FirSourceElement, PsiElement>()
         val TOO_MANY_CHARACTERS_IN_CHARACTER_LITERAL by error<FirSourceElement, PsiElement>()
         val ILLEGAL_ESCAPE by error<FirSourceElement, PsiElement>()
+        val INT_LITERAL_OUT_OF_RANGE by error<FirSourceElement, PsiElement>()
         val WRONG_LONG_SUFFIX by error<FirSourceElement, KtElement>(PositioningStrategy.LONG_LITERAL_SUFFIX)
     }
 

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

@@ -86,6 +86,7 @@ object FirErrors {
     val EMPTY_CHARACTER_LITERAL by error0<FirSourceElement, PsiElement>()
     val TOO_MANY_CHARACTERS_IN_CHARACTER_LITERAL by error0<FirSourceElement, PsiElement>()
     val ILLEGAL_ESCAPE by error0<FirSourceElement, PsiElement>()
+    val INT_LITERAL_OUT_OF_RANGE by error0<FirSourceElement, PsiElement>()
     val WRONG_LONG_SUFFIX by error0<FirSourceElement, KtElement>(SourceElementPositioningStrategies.LONG_LITERAL_SUFFIX)
 
     // Unresolved

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

@@ -179,6 +179,7 @@ private fun ConeSimpleDiagnostic.getFactory(): FirDiagnosticFactory0<FirSourceEl
         DiagnosticKind.UnknownCallableKind -> FirErrors.UNKNOWN_CALLABLE_KIND
         DiagnosticKind.IllegalProjectionUsage -> FirErrors.ILLEGAL_PROJECTION_USAGE
         DiagnosticKind.MissingStdlibClass -> FirErrors.MISSING_STDLIB_CLASS
+        DiagnosticKind.IntLiteralOutOfRange -> FirErrors.INT_LITERAL_OUT_OF_RANGE
         DiagnosticKind.WrongLongSuffix -> FirErrors.WRONG_LONG_SUFFIX
         DiagnosticKind.Other -> FirErrors.OTHER_ERROR
         DiagnosticKind.IncorrectCharacterLiteral -> FirErrors.INCORRECT_CHARACTER_LITERAL

compiler/fir/raw-fir/raw-fir.common/src/org/jetbrains/kotlin/fir/builder/BaseFirBuilder.kt

@@ -295,6 +295,12 @@ abstract class BaseFirBuilder<T>(val baseSession: FirSession, val context: Conte
                 val number: Long?
 
                 val kind = when {
+                    convertedText == null -> {
+                        number = null
+                        diagnostic = DiagnosticKind.IntLiteralOutOfRange
+                        ConstantValueKind.IntegerLiteral
+                    }
+
                     convertedText !is Long -> return reportIncorrectConstant(DiagnosticKind.IllegalConstExpression)
 
                     hasUnsignedLongSuffix(text) -> {

compiler/fir/tree/src/org/jetbrains/kotlin/fir/diagnostics/ConeSimpleDiagnostic.kt

@@ -36,6 +36,7 @@ enum class DiagnosticKind {
     TooManyCharactersInCharacterLiteral,
     IllegalEscape,
 
+    IntLiteralOutOfRange,
     WrongLongSuffix,
 
     Other

compiler/testData/diagnostics/tests/numbers/intValuesOutOfRange.fir.kt

@@ -6,12 +6,12 @@ fun foo(i: Int) = i
 fun bar(l: Long) = l
 
 fun main() {
-    val i = <!ILLEGAL_CONST_EXPRESSION!>111111111111111777777777777777<!>
+    val i = <!INT_LITERAL_OUT_OF_RANGE!>111111111111111777777777777777<!>
 
     //todo add diagnostic text messages
     //report only 'The value is out of range'
     //not 'An integer literal does not conform to the expected type Int/Long'
-    val l: Long = <!ILLEGAL_CONST_EXPRESSION!>1111111111111117777777777777777<!>
+    val l: Long = <!INT_LITERAL_OUT_OF_RANGE!>1111111111111117777777777777777<!>
-    foo(<!ILLEGAL_CONST_EXPRESSION!>11111111111111177777777777777<!>)
+    foo(<!INT_LITERAL_OUT_OF_RANGE!>11111111111111177777777777777<!>)
-    bar(<!ILLEGAL_CONST_EXPRESSION!>11111111111111177777777777777<!>)
+    bar(<!INT_LITERAL_OUT_OF_RANGE!>11111111111111177777777777777<!>)
 }

compiler/testData/diagnostics/tests/unsignedTypes/conversions/signedToUnsignedConversionWithExpectedType.fir.kt

@@ -27,7 +27,7 @@ fun test() {
     takeUInt(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
     takeULong(<!ARGUMENT_TYPE_MISMATCH!>1<!>)
 
-    takeULong(<!ILLEGAL_CONST_EXPRESSION!>18446744073709551615<!>)
+    takeULong(<!INT_LITERAL_OUT_OF_RANGE!>18446744073709551615<!>)
     takeULong(<!ARGUMENT_TYPE_MISMATCH!>1844674407370955161<!>)
     takeULong(18446744073709551615u)
 

compiler/testData/diagnostics/tests/unsignedTypes/unsignedLiteralsOverflowSignedBorder.fir.kt

@@ -22,4 +22,4 @@ fun test() {
 }
 
 val s1: UByte = 256u
-val s2 = <!ILLEGAL_CONST_EXPRESSION!>18446744073709551616u<!>
+val s2 = <!INT_LITERAL_OUT_OF_RANGE!>18446744073709551616u<!>

compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg/1.1.fir.kt

@@ -1,5 +0,0 @@
-// TESTCASE NUMBER: 1
-val value_1 = <!ILLEGAL_CONST_EXPRESSION!>0b<!>
-
-// TESTCASE NUMBER: 2
-val value_2 = <!ILLEGAL_CONST_EXPRESSION!>0B<!>

compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/binary-integer-literals/p-1/neg/1.1.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 /*
  * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
  *

compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg/1.1.fir.kt

@@ -1,5 +0,0 @@
-// TESTCASE NUMBER: 1
-val value_1 = <!ILLEGAL_CONST_EXPRESSION!>0x<!>
-
-// TESTCASE NUMBER: 2
-val value_2 = <!ILLEGAL_CONST_EXPRESSION!>0X<!>

compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/integer-literals/hexadecimal-integer-literals/p-1/neg/1.1.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 /*
  * KOTLIN DIAGNOSTICS SPEC TEST (NEGATIVE)
  *

compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/1.1.fir.kt

@@ -1,14 +1,14 @@
 // TESTCASE NUMBER: 1
-val value_1 = <!ILLEGAL_CONST_EXPRESSION!>0bl<!>
+val value_1 = <!INT_LITERAL_OUT_OF_RANGE!>0bl<!>
 
 // TESTCASE NUMBER: 2
-val value_2 = <!ILLEGAL_CONST_EXPRESSION!>0BL<!>
+val value_2 = <!INT_LITERAL_OUT_OF_RANGE!>0BL<!>
 
 // TESTCASE NUMBER: 3
-val value_3 = <!ILLEGAL_CONST_EXPRESSION!>0Xl<!>
+val value_3 = <!INT_LITERAL_OUT_OF_RANGE!>0Xl<!>
 
 // TESTCASE NUMBER: 4
-val value_4 = <!ILLEGAL_CONST_EXPRESSION!>0xL<!>
+val value_4 = <!INT_LITERAL_OUT_OF_RANGE!>0xL<!>
 
 // TESTCASE NUMBER: 5
 val value_5 = <!ILLEGAL_UNDERSCORE!>0b_l<!>

compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.3.fir.kt

@@ -101,12 +101,12 @@ fun case_5() {
 
 // TESTCASE NUMBER: 6
 fun case_6() {
-    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!><!>)
+    checkSubtype<Byte>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!><!>)
-    checkSubtype<Short>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!><!>)
+    checkSubtype<Short>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!><!>)
-    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!><!>)
+    checkSubtype<Int>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!><!>)
-    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!><!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!><!>)
-    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Byte>() }
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Byte>() }
-    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Short>() }
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Short>() }
-    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Int>() }
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Int>() }
-    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 }

compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.4.fir.kt

@@ -2,24 +2,24 @@
 
 // TESTCASE NUMBER: 1
 fun case_1() {
-    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!><!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>9223372036854775808L<!><!>)
-    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>9223372036854775808L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH, ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH, INT_LITERAL_OUT_OF_RANGE!>9223372036854775808L<!>)
-    <!ILLEGAL_CONST_EXPRESSION!>9223372036854775808L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!INT_LITERAL_OUT_OF_RANGE!>9223372036854775808L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 }
 
 // TESTCASE NUMBER: 2
 fun case_2() {
-    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH, ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH, INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000L<!>)
-    <!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH, ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH, INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000l<!>)
-    <!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000l<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!><!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000L<!><!>)
-    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000L<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 
-    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!><!>)
+    checkSubtype<Long>(<!ARGUMENT_TYPE_MISMATCH!><!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000l<!><!>)
-    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>100000000000000000000000000000000l<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>100000000000000000000000000000000l<!> <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!NONE_APPLICABLE!>check<!><Long>() }
 }

compiler/tests-spec/testData/diagnostics/linked/expressions/constant-literals/the-types-for-integer-literals/p-1/neg/2.5.fir.kt

@@ -27,8 +27,8 @@ fun case_1() {
     f1(<!ARGUMENT_TYPE_MISMATCH!>-2147483648<!>)
     f1(<!ARGUMENT_TYPE_MISMATCH!>9223372036854775807<!>)
     f1(<!ARGUMENT_TYPE_MISMATCH!>-9223372036854775807<!>)
-    f1(<!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
+    f1(<!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
-    f1(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
+    f1(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
 }
 
 // TESTCASE NUMBER: 2
@@ -39,20 +39,20 @@ fun case_2() {
     f2(<!ARGUMENT_TYPE_MISMATCH!>-2147483648<!>)
     f2(<!ARGUMENT_TYPE_MISMATCH!>9223372036854775807<!>)
     f2(<!ARGUMENT_TYPE_MISMATCH!>-9223372036854775807<!>)
-    f2(<!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
+    f2(<!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
-    f2(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
+    f2(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
 }
 
 // TESTCASE NUMBER: 3
 fun case_3() {
     f3(<!ARGUMENT_TYPE_MISMATCH!>9223372036854775807<!>)
     f3(<!ARGUMENT_TYPE_MISMATCH!>-9223372036854775807<!>)
-    f3(<!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
+    f3(<!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
-    f3(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
+    f3(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
 }
 
 // TESTCASE NUMBER: 4
 fun case_4() {
-    f3(<!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
+    f3(<!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
-    f3(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!ILLEGAL_CONST_EXPRESSION!>1000000000000000000000000000000000000000000000000<!>)
+    f3(<!OVERLOAD_RESOLUTION_AMBIGUITY!>-<!><!INT_LITERAL_OUT_OF_RANGE!>1000000000000000000000000000000000000000000000000<!>)
 }

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

@@ -149,6 +149,12 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
             token,
         )
     }
+    add(FirErrors.INT_LITERAL_OUT_OF_RANGE) { firDiagnostic ->
+        IntLiteralOutOfRangeImpl(
+            firDiagnostic as FirPsiDiagnostic<*>,
+            token,
+        )
+    }
     add(FirErrors.WRONG_LONG_SUFFIX) { firDiagnostic ->
         WrongLongSuffixImpl(
             firDiagnostic as FirPsiDiagnostic<*>,

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

@@ -124,6 +124,10 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
         override val diagnosticClass get() = IllegalEscape::class
     }
 
+    abstract class IntLiteralOutOfRange : KtFirDiagnostic<PsiElement>() {
+        override val diagnosticClass get() = IntLiteralOutOfRange::class
+    }
+
     abstract class WrongLongSuffix : KtFirDiagnostic<KtElement>() {
         override val diagnosticClass get() = WrongLongSuffix::class
     }

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

@@ -173,6 +173,13 @@ internal class IllegalEscapeImpl(
     override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
 }
 
+internal class IntLiteralOutOfRangeImpl(
+    firDiagnostic: FirPsiDiagnostic<*>,
+    override val token: ValidityToken,
+) : KtFirDiagnostic.IntLiteralOutOfRange(), KtAbstractFirDiagnostic<PsiElement> {
+    override val firDiagnostic: FirPsiDiagnostic<*> by weakRef(firDiagnostic)
+}
+
 internal class WrongLongSuffixImpl(
     firDiagnostic: FirPsiDiagnostic<*>,
     override val token: ValidityToken,