[FIR] do not treat external ide annotations as real one

Such annotations are supposed to affect only diagnostic warnings

^KT-62310 Fixed

analysis/analysis-api/testData/symbols/symbolByReference/javaMethodWithExternalNotNullAnnotation.descriptors.pretty.txt

@@ -1 +0,0 @@
-open fun foo(): kotlin.String!

analysis/analysis-api/testData/symbols/symbolByReference/javaMethodWithExternalNotNullAnnotation.pretty.txt

@@ -1 +1 @@
-open fun foo(): kotlin.String
+open fun foo(): kotlin.String!

analysis/analysis-api/testData/symbols/symbolByReference/javaMethodWithExternalNotNullAnnotation.txt

@@ -22,10 +22,9 @@ KtFunctionSymbol:
   name: foo
   origin: JAVA
   receiverParameter: null
-  returnType: KtUsualClassType:
+  returnType: KtFlexibleType:
     annotationsList: []
-    ownTypeArguments: []
+    type: kotlin/String!
-    type: @EnhancedNullability kotlin/String
   symbolKind: CLASS_MEMBER
   typeParameters: []
   valueParameters: []

analysis/low-level-api-fir/testData/getOrBuildFir/wholeDeclaration/externalJavaAnnotation.txt

@@ -3,12 +3,12 @@ FIR element: FirSimpleFunctionImpl
 FIR source kind: KtRealSourceElementKind
 
 FIR element rendered:
-public final [ResolvedTo(BODY_RESOLVE)] fun test(): R|kotlin/String| {
+public final [ResolvedTo(BODY_RESOLVE)] fun test(): R|kotlin/String!| {
     ^test R|/ClassWithExternalAnnotatedMembers.ClassWithExternalAnnotatedMembers|().R|/ClassWithExternalAnnotatedMembers.externalNotNullMethod|()
 }
 
 FIR FILE:
 FILE: [ResolvedTo(IMPORTS)] usage.kt
-    public final [ResolvedTo(BODY_RESOLVE)] fun test(): R|kotlin/String| {
+    public final [ResolvedTo(BODY_RESOLVE)] fun test(): R|kotlin/String!| {
         ^test R|/ClassWithExternalAnnotatedMembers.ClassWithExternalAnnotatedMembers|().R|/ClassWithExternalAnnotatedMembers.externalNotNullMethod|()
     }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/declarations/FirJavaExternalAnnotation.kt

@@ -0,0 +1,102 @@
+/*
+ * 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.java.declarations
+
+import org.jetbrains.kotlin.KtSourceElement
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.fir.FirImplementationDetail
+import org.jetbrains.kotlin.fir.builder.FirBuilderDsl
+import org.jetbrains.kotlin.fir.expressions.FirAnnotation
+import org.jetbrains.kotlin.fir.expressions.FirAnnotationArgumentMapping
+import org.jetbrains.kotlin.fir.expressions.UnresolvedExpressionTypeAccess
+import org.jetbrains.kotlin.fir.types.ConeKotlinType
+import org.jetbrains.kotlin.fir.types.FirTypeProjection
+import org.jetbrains.kotlin.fir.types.FirTypeRef
+import org.jetbrains.kotlin.fir.types.coneTypeOrNull
+import org.jetbrains.kotlin.fir.visitors.FirTransformer
+import org.jetbrains.kotlin.fir.visitors.FirVisitor
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+
+class FirJavaExternalAnnotation @FirImplementationDetail constructor(
+    override var annotationTypeRef: FirTypeRef,
+    override var argumentMapping: FirAnnotationArgumentMapping,
+) : FirAnnotation() {
+    override val useSiteTarget: AnnotationUseSiteTarget? get() = null
+    override val source: KtSourceElement? get() = null
+
+    override val typeArguments: List<FirTypeProjection>
+        get() = emptyList()
+
+    @OptIn(UnresolvedExpressionTypeAccess::class)
+    override val coneTypeOrNull: ConeKotlinType?
+        get() = annotationTypeRef.coneTypeOrNull
+
+    override val annotations: List<FirAnnotation>
+        get() = emptyList()
+
+    override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {
+        annotationTypeRef.accept(visitor, data)
+        argumentMapping.accept(visitor, data)
+    }
+
+    override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirJavaExternalAnnotation {
+        transformAnnotationTypeRef(transformer, data)
+        argumentMapping = argumentMapping.transform(transformer, data)
+        return this
+    }
+
+    override fun <D> transformAnnotations(transformer: FirTransformer<D>, data: D): FirJavaExternalAnnotation {
+        return this
+    }
+
+    override fun <D> transformAnnotationTypeRef(transformer: FirTransformer<D>, data: D): FirJavaExternalAnnotation {
+        annotationTypeRef = annotationTypeRef.transform(transformer, data)
+        return this
+    }
+
+    override fun <D> transformTypeArguments(transformer: FirTransformer<D>, data: D): FirJavaExternalAnnotation {
+        return this
+    }
+
+    override fun replaceConeTypeOrNull(newConeTypeOrNull: ConeKotlinType?) {}
+
+    override fun replaceAnnotations(newAnnotations: List<FirAnnotation>) {}
+
+    override fun replaceUseSiteTarget(newUseSiteTarget: AnnotationUseSiteTarget?) {}
+
+    override fun replaceAnnotationTypeRef(newAnnotationTypeRef: FirTypeRef) {
+        annotationTypeRef = newAnnotationTypeRef
+    }
+
+    override fun replaceArgumentMapping(newArgumentMapping: FirAnnotationArgumentMapping) {
+        argumentMapping = newArgumentMapping
+    }
+
+    override fun replaceTypeArguments(newTypeArguments: List<FirTypeProjection>) {}
+}
+
+@FirBuilderDsl
+class FirJavaExternalAnnotationBuilder {
+    lateinit var annotationTypeRef: FirTypeRef
+    lateinit var argumentMapping: FirAnnotationArgumentMapping
+
+    @OptIn(FirImplementationDetail::class)
+    fun build(): FirJavaExternalAnnotation = FirJavaExternalAnnotation(
+        annotationTypeRef,
+        argumentMapping,
+    )
+}
+
+@OptIn(ExperimentalContracts::class)
+inline fun buildJavaExternalAnnotation(init: FirJavaExternalAnnotationBuilder.() -> Unit): FirJavaExternalAnnotation {
+    contract {
+        callsInPlace(init, InvocationKind.EXACTLY_ONCE)
+    }
+
+    return FirJavaExternalAnnotationBuilder().apply(init).build()
+}

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt

@@ -1,5 +1,5 @@
 /*
- * 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.
  */
 
@@ -722,8 +722,7 @@ private class EnhancementSignatureParts(
     override val typeSystem: TypeSystemContext
         get() = session.typeContext
 
-    override fun FirAnnotation.forceWarning(unenhancedType: KotlinTypeMarker?): Boolean =
+    override fun FirAnnotation.forceWarning(unenhancedType: KotlinTypeMarker?): Boolean = this is FirJavaExternalAnnotation
-        false // TODO: force warnings on IDEA external annotations
 
     override val KotlinTypeMarker.annotations: Iterable<FirAnnotation>
         get() = (this as ConeKotlinType).attributes.customAnnotations

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/javaAnnotationsMapping.kt

@@ -1,10 +1,13 @@
 /*
- * Copyright 2010-2021 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.java
 
+import com.intellij.patterns.PsiJavaPatterns.psiAnnotation
+import org.jetbrains.kotlin.KtFakeSourceElement
+import org.jetbrains.kotlin.KtFakeSourceElementKind
 import org.jetbrains.kotlin.KtSourceElement
 import org.jetbrains.kotlin.fir.FirAnnotationContainer
 import org.jetbrains.kotlin.fir.FirElement
@@ -17,6 +20,7 @@ import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic
 import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.expressions.builder.*
+import org.jetbrains.kotlin.fir.java.declarations.buildJavaExternalAnnotation
 import org.jetbrains.kotlin.fir.java.declarations.buildJavaValueParameter
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
 import org.jetbrains.kotlin.fir.references.builder.buildErrorNamedReference
@@ -42,6 +46,7 @@ import org.jetbrains.kotlin.name.*
 import org.jetbrains.kotlin.toKtPsiSourceElement
 import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty
+import org.jetbrains.kotlin.utils.exceptions.requireWithAttachment
 import java.util.*
 
 internal fun Iterable<JavaAnnotation>.convertAnnotationsToFir(
@@ -255,7 +260,25 @@ internal fun JavaAnnotation.isJavaDeprecatedAnnotation(): Boolean {
     return classId == JvmStandardClassIds.Annotations.Java.Deprecated
 }
 
-private fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotation = buildAnnotation {
+private fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotation {
+    val annotationData = buildFirAnnotation(this, session)
+    return if (isIdeExternalAnnotation) {
+        buildJavaExternalAnnotation {
+            annotationTypeRef = annotationData.annotationTypeRef
+            argumentMapping = annotationData.argumentsMapping
+        }
+    } else {
+        buildAnnotation {
+            annotationTypeRef = annotationData.annotationTypeRef
+            argumentMapping = annotationData.argumentsMapping
+        }
+    }
+}
+
+private class AnnotationData(val annotationTypeRef: FirResolvedTypeRef, val argumentsMapping: FirAnnotationArgumentMapping)
+
+private fun buildFirAnnotation(javaAnnotation: JavaAnnotation, session: FirSession): AnnotationData {
+    val classId = javaAnnotation.classId
     val lookupTag = when (classId) {
         JvmStandardClassIds.Annotations.Java.Target -> StandardClassIds.Annotations.Target
         JvmStandardClassIds.Annotations.Java.Retention -> StandardClassIds.Annotations.Retention
@@ -263,7 +286,7 @@ private fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotati
         JvmStandardClassIds.Annotations.Java.Deprecated -> StandardClassIds.Annotations.Deprecated
         else -> classId
     }?.toLookupTag()
-    annotationTypeRef = if (lookupTag != null) {
+    val annotationTypeRef = if (lookupTag != null) {
         buildResolvedTypeRef {
             type = ConeClassLikeTypeImpl(lookupTag, emptyArray(), isNullable = false)
         }
@@ -278,7 +301,7 @@ private fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotati
      * See KT-59342
      * TODO: KT-60520
      */
-    argumentMapping = object : FirAnnotationArgumentMapping() {
+    val argumentMapping = object : FirAnnotationArgumentMapping() {
         override fun <R, D> acceptChildren(visitor: FirVisitor<R, D>, data: D) {}
         override fun <D> transformChildren(transformer: FirTransformer<D>, data: D): FirElement = this
         override val source: KtSourceElement? get() = null
@@ -286,7 +309,7 @@ private fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotati
         override val mapping: Map<Name, FirExpression> by lazy {
             when {
                 classId == JvmStandardClassIds.Annotations.Java.Target -> {
-                    when (val argument = arguments.firstOrNull()) {
+                    when (val argument = javaAnnotation.arguments.firstOrNull()) {
                         is JavaArrayAnnotationArgument -> argument.getElements().mapJavaTargetArguments(session)
                         is JavaEnumValueAnnotationArgument -> listOf(argument).mapJavaTargetArguments(session)
                         else -> null
@@ -296,7 +319,7 @@ private fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotati
                 }
 
                 classId == JvmStandardClassIds.Annotations.Java.Retention -> {
-                    arguments.firstOrNull()?.mapJavaRetentionArgument(session)?.let {
+                    javaAnnotation.arguments.firstOrNull()?.mapJavaRetentionArgument(session)?.let {
                         mapOf(StandardClassIds.Annotations.ParameterNames.retentionValue to it)
                     }
                 }
@@ -310,7 +333,7 @@ private fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotati
                 }
 
                 lookupTag == null -> null
-                else -> arguments.ifNotEmpty {
+                else -> javaAnnotation.arguments.ifNotEmpty {
                     val mapping = LinkedHashMap<Name, FirExpression>(size)
                     fillAnnotationArgumentMapping(session, lookupTag, this, mapping)
                     mapping
@@ -318,4 +341,6 @@ private fun JavaAnnotation.toFirAnnotationCall(session: FirSession): FirAnnotati
             }.orEmpty()
         }
     }
+
+    return AnnotationData(annotationTypeRef, argumentMapping)
 }

compiler/testData/diagnostics/foreignAnnotationsTests/tests/externalAnnotations/constructorParameterNotNull.fir.kt

@@ -18,7 +18,7 @@ public class ClassWithExternalAnnotatedMembers {
 // FILE: usage.kt
 fun test() {
     val i: Int? = null
-    <!NONE_APPLICABLE!>ClassWithExternalAnnotatedMembers<!>(i)
+    ClassWithExternalAnnotatedMembers(i)
 
     val s: String? = null
     <!NONE_APPLICABLE!>ClassWithExternalAnnotatedMembers<!>(s)
@@ -26,7 +26,7 @@ fun test() {
     val b: Boolean? = null
     ClassWithExternalAnnotatedMembers(b)
 
-    ClassWithExternalAnnotatedMembers(null)
+    <!OVERLOAD_RESOLUTION_AMBIGUITY!>ClassWithExternalAnnotatedMembers<!>(null)
 }
 
 // FILE: annotations.xml

compiler/testData/diagnostics/foreignAnnotationsTests/tests/externalAnnotations/constructorParameterNotNull2.fir.kt

@@ -14,7 +14,7 @@ public class ClassWithExternalAnnotatedMembers {
 // FILE: usage.kt
 fun test() {
     val i: Int? = null
-    <!NONE_APPLICABLE!>ClassWithExternalAnnotatedMembers<!>(i)
+    ClassWithExternalAnnotatedMembers(i)
 
     val s: String? = null
     <!NONE_APPLICABLE!>ClassWithExternalAnnotatedMembers<!>(s)
@@ -22,7 +22,7 @@ fun test() {
     val b: Boolean? = null
     <!NONE_APPLICABLE!>ClassWithExternalAnnotatedMembers<!>(b)
 
-    <!NONE_APPLICABLE!>ClassWithExternalAnnotatedMembers<!>(null)
+    ClassWithExternalAnnotatedMembers(null)
 }
 
 // FILE: annotations.xml

compiler/testData/diagnostics/foreignAnnotationsTests/tests/externalAnnotations/fieldNotNull.fir.kt

@@ -0,0 +1,38 @@
+// FILE: ClassWithExternalAnnotatedMembers.java
+import org.jetbrains.annotations.NotNull;
+
+public class ClassWithExternalAnnotatedMembers {
+    public String externalNotNullField;
+
+    @NotNull
+    public String explicitNotNullField;
+
+    public static String staticExternalNotNullField;
+
+    @NotNull
+    public static String staticExplicitNotNullField;
+}
+
+// FILE: usage.kt
+fun test() {
+    val x = ClassWithExternalAnnotatedMembers()
+    x.externalNotNullField?.foo()
+    x.explicitNotNullField<!UNNECESSARY_SAFE_CALL!>?.<!>foo()
+
+    ClassWithExternalAnnotatedMembers.staticExternalNotNullField?.foo()
+    ClassWithExternalAnnotatedMembers.staticExplicitNotNullField<!UNNECESSARY_SAFE_CALL!>?.<!>foo()
+}
+
+fun String.foo() {
+
+}
+
+// FILE: annotations.xml
+<root>
+    <item name='ClassWithExternalAnnotatedMembers externalNotNullField'>
+        <annotation name='org.jetbrains.annotations.NotNull'/>
+    </item>
+    <item name='ClassWithExternalAnnotatedMembers staticExternalNotNullField'>
+        <annotation name='org.jetbrains.annotations.NotNull'/>
+    </item>
+</root>

compiler/testData/diagnostics/foreignAnnotationsTests/tests/externalAnnotations/fieldNotNull.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // FILE: ClassWithExternalAnnotatedMembers.java
 import org.jetbrains.annotations.NotNull;
 

compiler/testData/diagnostics/foreignAnnotationsTests/tests/externalAnnotations/fieldNotNullAnnotationWithPackage.fir.kt

@@ -0,0 +1,44 @@
+// FILE: one/two/ClassWithExternalAnnotatedMembers.java
+package one.two;
+
+import org.jetbrains.annotations.NotNull;
+
+public class ClassWithExternalAnnotatedMembers {
+    public String externalNotNullField;
+
+    @NotNull
+    public String explicitNotNullField;
+
+    public static String staticExternalNotNullField;
+
+    @NotNull
+    public static String staticExplicitNotNullField;
+}
+
+// FILE: one/usage.kt
+package one
+
+import one.two.ClassWithExternalAnnotatedMembers
+
+fun test() {
+    val x = ClassWithExternalAnnotatedMembers()
+    x.externalNotNullField?.foo()
+    x.explicitNotNullField<!UNNECESSARY_SAFE_CALL!>?.<!>foo()
+
+    ClassWithExternalAnnotatedMembers.staticExternalNotNullField?.foo()
+    ClassWithExternalAnnotatedMembers.staticExplicitNotNullField<!UNNECESSARY_SAFE_CALL!>?.<!>foo()
+}
+
+fun String.foo() {
+
+}
+
+// FILE: one/two/annotations.xml
+<root>
+    <item name='one.two.ClassWithExternalAnnotatedMembers externalNotNullField'>
+        <annotation name='org.jetbrains.annotations.NotNull'/>
+    </item>
+    <item name='one.two.ClassWithExternalAnnotatedMembers staticExternalNotNullField'>
+        <annotation name='org.jetbrains.annotations.NotNull'/>
+    </item>
+</root>

compiler/testData/diagnostics/foreignAnnotationsTests/tests/externalAnnotations/fieldNotNullAnnotationWithPackage.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // FILE: one/two/ClassWithExternalAnnotatedMembers.java
 package one.two;
 

compiler/testData/diagnostics/foreignAnnotationsTests/tests/externalAnnotations/methodNotNull.fir.kt

@@ -0,0 +1,46 @@
+// FILE: ClassWithExternalAnnotatedMembers.java
+import org.jetbrains.annotations.NotNull;
+
+public class ClassWithExternalAnnotatedMembers {
+    public String externalNotNullMethod() {
+        return "";
+    }
+
+    @NotNull
+    public String explicitNotNullMethod() {
+        return "";
+    }
+
+    public static String staticExternalNotNullMethod() {
+        return "";
+    }
+
+    @NotNull
+    public static String staticExplicitNotNullMethod() {
+        return "";
+    }
+}
+
+// FILE: usage.kt
+fun test() {
+    val x = ClassWithExternalAnnotatedMembers()
+    x.externalNotNullMethod()?.foo()
+    x.explicitNotNullMethod()<!UNNECESSARY_SAFE_CALL!>?.<!>foo()
+
+    ClassWithExternalAnnotatedMembers.staticExternalNotNullMethod()?.foo()
+    ClassWithExternalAnnotatedMembers.staticExplicitNotNullMethod()<!UNNECESSARY_SAFE_CALL!>?.<!>foo()
+}
+
+fun String.foo() {
+
+}
+
+// FILE: annotations.xml
+<root>
+    <item name='ClassWithExternalAnnotatedMembers java.lang.String externalNotNullMethod()'>
+        <annotation name='org.jetbrains.annotations.NotNull'/>
+    </item>
+    <item name='ClassWithExternalAnnotatedMembers java.lang.String staticExternalNotNullMethod()'>
+        <annotation name='org.jetbrains.annotations.NotNull'/>
+    </item>
+</root>

compiler/testData/diagnostics/foreignAnnotationsTests/tests/externalAnnotations/methodNotNull.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // FILE: ClassWithExternalAnnotatedMembers.java
 import org.jetbrains.annotations.NotNull;
 

compiler/testData/diagnostics/foreignAnnotationsTests/tests/externalAnnotations/methodNotNullFromAnotherModule.fir.kt

@@ -0,0 +1,71 @@
+// MODULE: javaModule
+// FILE: one/two/FirstModuleClass.java
+package one.two;
+
+import org.jetbrains.annotations.NotNull;
+
+public class FirstModuleClass {
+    public String externalNotNullMethod() {
+        return "";
+    }
+
+    @NotNull
+    public String explicitNotNullMethod() {
+        return "";
+    }
+}
+// FILE: one/two/annotations.xml
+<root>
+    <item name='one.two.FirstModuleClass java.lang.String externalNotNullMethod()'>
+        <annotation name='org.jetbrains.annotations.NotNull'/>
+    </item>
+</root>
+// FILE: usage.kt
+package usage1
+
+import one.two.FirstModuleClass
+
+fun test() {
+    val x = FirstModuleClass()
+    x.externalNotNullMethod()?.foo()
+    x.explicitNotNullMethod()<!UNNECESSARY_SAFE_CALL!>?.<!>foo()
+}
+
+fun String.foo() {
+
+}
+// MODULE: javaModule2
+// FILE: three/SecondModuleClass.java
+package three;
+
+import org.jetbrains.annotations.NotNull;
+
+public class SecondModuleClass {
+    public static String staticExternalNotNullMethod() {
+        return "";
+    }
+
+    @NotNull
+    public static String staticExplicitNotNullMethod() {
+        return "";
+    }
+}
+// FILE: three/annotations.xml
+<root>
+    <item name='three.SecondModuleClass java.lang.String staticExternalNotNullMethod()'>
+        <annotation name='org.jetbrains.annotations.NotNull'/>
+    </item>
+</root>
+// FILE: my/pack/usage.kt
+package my.pack
+
+import three.SecondModuleClass
+
+fun test() {
+    SecondModuleClass.staticExternalNotNullMethod()?.foo()
+    SecondModuleClass.staticExplicitNotNullMethod()<!UNNECESSARY_SAFE_CALL!>?.<!>foo()
+}
+
+fun String.foo() {
+
+}

compiler/testData/diagnostics/foreignAnnotationsTests/tests/externalAnnotations/methodNotNullFromAnotherModule.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // MODULE: javaModule
 // FILE: one/two/FirstModuleClass.java
 package one.two;

compiler/testData/diagnostics/foreignAnnotationsTests/tests/externalAnnotations/methodParameterNotNull.fir.kt

@@ -16,12 +16,12 @@ fun test() {
     instance.<!NONE_APPLICABLE!>method<!>(i)
 
     val s: String? = null
-    instance.<!NONE_APPLICABLE!>method<!>(s)
+    instance.method(s)
 
     val b: Boolean? = null
     instance.<!NONE_APPLICABLE!>method<!>(b)
 
-    instance.<!NONE_APPLICABLE!>method<!>(null)
+    instance.method(null)
 }
 
 // FILE: annotations.xml

compiler/testData/diagnostics/foreignAnnotationsTests/tests/externalAnnotations/methodParameterNotNull2.fir.kt

@@ -19,12 +19,12 @@ fun test() {
     instance.<!NONE_APPLICABLE!>method<!>(i)
 
     val s: String? = null
-    instance.<!NONE_APPLICABLE!>method<!>(s)
+    instance.method(s)
 
     val b: Boolean? = null
     instance.method(b)
 
-    instance.method(null)
+    instance.<!OVERLOAD_RESOLUTION_AMBIGUITY!>method<!>(null)
 }
 
 // FILE: annotations.xml