J2K: move isEffectivelyExternal to kt-file, parameter -> receiver

js/js.frontend/src/org/jetbrains/kotlin/js/resolve/ExtensionFunctionToExternalIsInlinable.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.psi.KtCallableDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.DescriptorUtils
+import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal
 import org.jetbrains.kotlin.resolve.inline.ReasonableInlineRule
 
 object ExtensionFunctionToExternalIsInlinable : ReasonableInlineRule {
@@ -31,6 +31,6 @@ object ExtensionFunctionToExternalIsInlinable : ReasonableInlineRule {
     ): Boolean {
         val receiverParameter = descriptor.extensionReceiverParameter ?: return false
         val receiverClass = receiverParameter.value.type.constructor.declarationDescriptor as? ClassDescriptor ?: return false
-        return DescriptorUtils.isEffectivelyExternal(receiverClass)
+        return receiverClass.isEffectivelyExternal()
     }
 }

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

@@ -145,7 +145,7 @@ object JsExternalChecker : SimpleDeclarationChecker {
     }
 
     private fun checkDelegation(declaration: KtDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
-        if (descriptor !is MemberDescriptor || !DescriptorUtils.isEffectivelyExternal(descriptor)) return
+        if (descriptor !is MemberDescriptor || !descriptor.isEffectivelyExternal()) return
 
         if (declaration is KtClassOrObject) {
             for (superTypeEntry in declaration.superTypeListEntries) {

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

@@ -25,9 +25,9 @@ import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.psi.KtClassOrObject
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.checkers.SimpleDeclarationChecker
 import org.jetbrains.kotlin.resolve.descriptorUtil.hasDefaultValue
+import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
 import org.jetbrains.kotlin.types.typeUtil.immediateSupertypes
 
@@ -38,12 +38,12 @@ object JsInheritanceChecker : SimpleDeclarationChecker {
             diagnosticHolder: DiagnosticSink,
             bindingContext: BindingContext
     ) {
-        if (descriptor is FunctionDescriptor && !DescriptorUtils.isEffectivelyExternal(descriptor) &&
+        if (descriptor is FunctionDescriptor && !descriptor.isEffectivelyExternal() &&
             isOverridingExternalWithOptionalParams(descriptor)
         ) {
             diagnosticHolder.report(ErrorsJs.OVERRIDING_EXTERNAL_FUN_WITH_OPTIONAL_PARAMS.on(declaration))
         }
-        else if (descriptor is ClassDescriptor && !DescriptorUtils.isEffectivelyExternal(descriptor)) {
+        else if (descriptor is ClassDescriptor && !descriptor.isEffectivelyExternal()) {
             val fakeOverriddenMethod = findFakeMethodOverridingExternalWithOptionalParams(descriptor)
             if (fakeOverriddenMethod != null) {
                 diagnosticHolder.report(ErrorsJs.OVERRIDING_EXTERNAL_FUN_WITH_OPTIONAL_PARAMS_WITH_FAKE.on(
@@ -61,7 +61,7 @@ object JsInheritanceChecker : SimpleDeclarationChecker {
     private fun isOverridingExternalWithOptionalParams(function: FunctionDescriptor): Boolean {
         if (!function.kind.isReal && function.modality == Modality.ABSTRACT) return false
 
-        for (overriddenFunction in function.overriddenDescriptors.filter { DescriptorUtils.isEffectivelyExternal(it) }) {
+        for (overriddenFunction in function.overriddenDescriptors.filter { it.isEffectivelyExternal() }) {
             if (overriddenFunction.valueParameters.any { it.hasDefaultValue() }) return true
         }
 

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

@@ -23,10 +23,10 @@ import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention
 import org.jetbrains.kotlin.diagnostics.DiagnosticSink
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.resolve.BindingContext
-import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.checkers.SimpleDeclarationChecker
 import org.jetbrains.kotlin.resolve.descriptorUtil.annotationClass
 import org.jetbrains.kotlin.resolve.descriptorUtil.getAnnotationRetention
+import org.jetbrains.kotlin.resolve.descriptorUtil.isEffectivelyExternal
 import org.jetbrains.kotlin.resolve.source.PsiSourceElement
 
 object JsRuntimeAnnotationChecker : SimpleDeclarationChecker {
@@ -42,7 +42,7 @@ object JsRuntimeAnnotationChecker : SimpleDeclarationChecker {
 
             val annotationPsi = (annotationDescriptor.source as? PsiSourceElement)?.psi ?: declaration
 
-            if (descriptor is MemberDescriptor && DescriptorUtils.isEffectivelyExternal(descriptor)) {
+            if (descriptor is MemberDescriptor && descriptor.isEffectivelyExternal()) {
                 diagnosticHolder.report(ErrorsJs.RUNTIME_ANNOTATION_ON_EXTERNAL_DECLARATION.on(annotationPsi))
             }
             else {

js/js.frontend/src/org/jetbrains/kotlin/js/translate/utils/AnnotationsUtils.java

@@ -39,6 +39,7 @@ import java.util.Collections;
 import java.util.List;
 
 import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.getAnnotationClass;
+import static org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt.isEffectivelyExternal;
 
 public final class AnnotationsUtils {
     private static final String JS_NAME = "kotlin.js.JsName";
@@ -99,7 +100,7 @@ public final class AnnotationsUtils {
             return name != null ? name : descriptor.getName().asString();
         }
 
-        if (defaultJsName == null && isEffectivelyExternal(descriptor)) {
+        if (defaultJsName == null && isEffectivelyExternalMember(descriptor)) {
             return descriptor.getName().asString();
         }
 
@@ -121,7 +122,7 @@ public final class AnnotationsUtils {
     }
 
     public static boolean isNativeObject(@NotNull DeclarationDescriptor descriptor) {
-        if (hasAnnotationOrInsideAnnotatedClass(descriptor, PredefinedAnnotation.NATIVE) || isEffectivelyExternal(descriptor)) return true;
+        if (hasAnnotationOrInsideAnnotatedClass(descriptor, PredefinedAnnotation.NATIVE) || isEffectivelyExternalMember(descriptor)) return true;
 
         if (descriptor instanceof PropertyAccessorDescriptor) {
             PropertyAccessorDescriptor accessor = (PropertyAccessorDescriptor) descriptor;
@@ -135,8 +136,8 @@ public final class AnnotationsUtils {
         return isNativeObject(descriptor) && DescriptorUtils.isInterface(descriptor);
     }
 
-    private static boolean isEffectivelyExternal(@NotNull DeclarationDescriptor descriptor) {
-        return descriptor instanceof MemberDescriptor && DescriptorUtils.isEffectivelyExternal((MemberDescriptor) descriptor);
+    private static boolean isEffectivelyExternalMember(@NotNull DeclarationDescriptor descriptor) {
+        return descriptor instanceof MemberDescriptor && isEffectivelyExternal((MemberDescriptor) descriptor);
     }
 
     public static boolean isLibraryObject(@NotNull DeclarationDescriptor descriptor) {
@@ -164,7 +165,7 @@ public final class AnnotationsUtils {
 
     public static boolean isPredefinedObject(@NotNull DeclarationDescriptor descriptor) {
         if (descriptor instanceof MemberDescriptor && ((MemberDescriptor) descriptor).isHeader()) return true;
-        if (isEffectivelyExternal(descriptor)) return true;
+        if (isEffectivelyExternalMember(descriptor)) return true;
 
         for (PredefinedAnnotation annotation : PredefinedAnnotation.values()) {
             if (hasAnnotationOrInsideAnnotatedClass(descriptor, annotation)) {