JS: use 'external' word instead of 'native' in diagnostic messages

See KT-20639

compiler/testData/diagnostics/testsWithJsStdLib/native/rtti/castToNativeInterface.kt

@@ -1,5 +1,5 @@
 external interface I
 
 fun box(a: Any, b: Any): Pair<I, I?> {
-    return Pair(<!UNCHECKED_CAST_TO_NATIVE_INTERFACE!>a as I<!>, <!UNCHECKED_CAST_TO_NATIVE_INTERFACE!>b as? I<!>)
+    return Pair(<!UNCHECKED_CAST_TO_EXTERNAL_INTERFACE!>a as I<!>, <!UNCHECKED_CAST_TO_EXTERNAL_INTERFACE!>b as? I<!>)
 }

compiler/testData/diagnostics/testsWithJsStdLib/native/rtti/checkForNativeInterface.kt

@@ -1,5 +1,5 @@
 external interface I
 
 fun box(a: Any, b: Any): Boolean {
-    return <!CANNOT_CHECK_FOR_NATIVE_INTERFACE!>a is I<!> && <!CANNOT_CHECK_FOR_NATIVE_INTERFACE!>b !is I<!>
+    return <!CANNOT_CHECK_FOR_EXTERNAL_INTERFACE!>a is I<!> && <!CANNOT_CHECK_FOR_EXTERNAL_INTERFACE!>b !is I<!>
 }

compiler/testData/diagnostics/testsWithJsStdLib/native/rtti/nativeInterfaceAsReifiedTypeArgument.kt

@@ -14,8 +14,8 @@ fun bar() {
     foo(C())
 
     val c: I = C()
-    <!NATIVE_INTERFACE_AS_REIFIED_TYPE_ARGUMENT!>foo(c)<!>
+    <!EXTERNAL_INTERFACE_AS_REIFIED_TYPE_ARGUMENT!>foo(c)<!>
-    foo<<!NATIVE_INTERFACE_AS_REIFIED_TYPE_ARGUMENT!>I<!>>(C())
+    foo<<!EXTERNAL_INTERFACE_AS_REIFIED_TYPE_ARGUMENT!>I<!>>(C())
 
-    <!NATIVE_INTERFACE_AS_REIFIED_TYPE_ARGUMENT!>C() + c<!>
+    <!EXTERNAL_INTERFACE_AS_REIFIED_TYPE_ARGUMENT!>C() + c<!>
 }

compiler/testData/diagnostics/testsWithJsStdLib/native/rtti/nativeInterfaceClassLiteral.kt

@@ -1,5 +1,5 @@
 external interface I
 
 fun box() {
-    println(<!NATIVE_INTERFACE_AS_CLASS_LITERAL!>I::class<!>)
+    println(<!EXTERNAL_INTERFACE_AS_CLASS_LITERAL!>I::class<!>)
 }

compiler/testData/diagnostics/testsWithJsStdLib/native/rtti/whenIsNativeInterface.kt

@@ -3,7 +3,7 @@ external interface I
 external interface J
 
 fun box(a: Any) = when (a) {
-    <!CANNOT_CHECK_FOR_NATIVE_INTERFACE!>is I<!> -> 0
+    <!CANNOT_CHECK_FOR_EXTERNAL_INTERFACE!>is I<!> -> 0
-    <!CANNOT_CHECK_FOR_NATIVE_INTERFACE!>!is J<!> -> 1
+    <!CANNOT_CHECK_FOR_EXTERNAL_INTERFACE!>!is J<!> -> 1
     else -> 2
 }

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/DefaultErrorMessagesJs.kt

@@ -69,10 +69,10 @@ private val DIAGNOSTIC_FACTORY_TO_RENDERER by lazy {
             "Can''t put non-external declarations in file marked with {0} annotation", RENDER_TYPE)
         put(ErrorsJs.WRONG_JS_QUALIFIER, "Qualifier contains illegal characters")
 
-        put(ErrorsJs.CANNOT_CHECK_FOR_NATIVE_INTERFACE, "Cannot check for native interface: {0}", RENDER_TYPE)
+        put(ErrorsJs.CANNOT_CHECK_FOR_EXTERNAL_INTERFACE, "Cannot check for external interface: {0}", RENDER_TYPE)
-        put(ErrorsJs.UNCHECKED_CAST_TO_NATIVE_INTERFACE, "Unchecked cast to native interface: {0} to {1}", RENDER_TYPE, RENDER_TYPE)
+        put(ErrorsJs.UNCHECKED_CAST_TO_EXTERNAL_INTERFACE, "Unchecked cast to external interface: {0} to {1}", RENDER_TYPE, RENDER_TYPE)
-        put(ErrorsJs.NATIVE_INTERFACE_AS_REIFIED_TYPE_ARGUMENT, "Cannot pass native interface {0} for reified type parameter", RENDER_TYPE)
+        put(ErrorsJs.EXTERNAL_INTERFACE_AS_REIFIED_TYPE_ARGUMENT, "Cannot pass external interface {0} for reified type parameter", RENDER_TYPE)
-        put(ErrorsJs.NATIVE_INTERFACE_AS_CLASS_LITERAL, "Can't refer to native interface from class literal")
+        put(ErrorsJs.EXTERNAL_INTERFACE_AS_CLASS_LITERAL, "Can't refer to external interface from class literal")
         put(ErrorsJs.EXTERNAL_TYPE_EXTENDS_NON_EXTERNAL_TYPE, "External type extends non-external type")
 
         put(ErrorsJs.WRONG_OPERATION_WITH_DYNAMIC, "Wrong operation with dynamic value: {0}", Renderers.STRING)

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/ErrorsJs.java

@@ -71,10 +71,10 @@ public interface ErrorsJs {
             DiagnosticFactory1.create(ERROR, PositioningStrategies.DECLARATION_SIGNATURE_OR_DEFAULT);
     DiagnosticFactory0<KtValueArgument> WRONG_JS_QUALIFIER = DiagnosticFactory0.create(ERROR, PositioningStrategies.DEFAULT);
 
-    DiagnosticFactory1<PsiElement, KotlinType> CANNOT_CHECK_FOR_NATIVE_INTERFACE = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<PsiElement, KotlinType> CANNOT_CHECK_FOR_EXTERNAL_INTERFACE = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory2<PsiElement, KotlinType, KotlinType> UNCHECKED_CAST_TO_NATIVE_INTERFACE = DiagnosticFactory2.create(WARNING);
+    DiagnosticFactory2<PsiElement, KotlinType, KotlinType> UNCHECKED_CAST_TO_EXTERNAL_INTERFACE = DiagnosticFactory2.create(WARNING);
-    DiagnosticFactory1<PsiElement, KotlinType> NATIVE_INTERFACE_AS_REIFIED_TYPE_ARGUMENT = DiagnosticFactory1.create(ERROR);
+    DiagnosticFactory1<PsiElement, KotlinType> EXTERNAL_INTERFACE_AS_REIFIED_TYPE_ARGUMENT = DiagnosticFactory1.create(ERROR);
-    DiagnosticFactory0<PsiElement> NATIVE_INTERFACE_AS_CLASS_LITERAL = DiagnosticFactory0.create(ERROR);
+    DiagnosticFactory0<PsiElement> EXTERNAL_INTERFACE_AS_CLASS_LITERAL = DiagnosticFactory0.create(ERROR);
     DiagnosticFactory0<KtElement> EXTERNAL_TYPE_EXTENDS_NON_EXTERNAL_TYPE = DiagnosticFactory0.create(
             ERROR, PositioningStrategies.DECLARATION_SIGNATURE_OR_DEFAULT);
 

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsNativeRttiChecker.kt

@@ -36,10 +36,10 @@ class JsNativeRttiChecker : RttiExpressionChecker, ClassLiteralChecker {
         if (sourceType != null && targetDescriptor != null && AnnotationsUtils.isNativeInterface(targetDescriptor)) {
             when (rttiInformation.operation) {
                 RttiOperation.IS,
-                RttiOperation.NOT_IS -> trace.report(ErrorsJs.CANNOT_CHECK_FOR_NATIVE_INTERFACE.on(reportOn, targetType))
+                RttiOperation.NOT_IS -> trace.report(ErrorsJs.CANNOT_CHECK_FOR_EXTERNAL_INTERFACE.on(reportOn, targetType))
 
                 RttiOperation.AS,
-                RttiOperation.SAFE_AS -> trace.report(ErrorsJs.UNCHECKED_CAST_TO_NATIVE_INTERFACE.on(reportOn, sourceType, targetType))
+                RttiOperation.SAFE_AS -> trace.report(ErrorsJs.UNCHECKED_CAST_TO_EXTERNAL_INTERFACE.on(reportOn, sourceType, targetType))
             }
         }
     }
@@ -47,7 +47,7 @@ class JsNativeRttiChecker : RttiExpressionChecker, ClassLiteralChecker {
     override fun check(expression: KtClassLiteralExpression, type: KotlinType, context: ResolutionContext<*>) {
         val descriptor = type.constructor.declarationDescriptor as? ClassDescriptor ?: return
         if (AnnotationsUtils.isNativeInterface(descriptor)) {
-            context.trace.report(ErrorsJs.NATIVE_INTERFACE_AS_CLASS_LITERAL.on(expression))
+            context.trace.report(ErrorsJs.EXTERNAL_INTERFACE_AS_CLASS_LITERAL.on(expression))
         }
     }
 }

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/diagnostics/JsReifiedNativeChecker.kt

@@ -37,7 +37,7 @@ class JsReifiedNativeChecker : CallChecker {
                     resolvedCall.call.callElement
                 }
 
-                context.trace.report(ErrorsJs.NATIVE_INTERFACE_AS_REIFIED_TYPE_ARGUMENT.on(typeArgumentPsi!!, typeArg))
+                context.trace.report(ErrorsJs.EXTERNAL_INTERFACE_AS_REIFIED_TYPE_ARGUMENT.on(typeArgumentPsi!!, typeArg))
             }
         }
     }