Move/inline stuff from DescriptorUtils to other modules

compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java

@@ -754,9 +754,10 @@ public class AsmUtil {
             return false;
         }
 
-        return isNonCompanionObject(propertyDescriptor.getContainingDeclaration()) ||
+        DeclarationDescriptor container = propertyDescriptor.getContainingDeclaration();
+        return isNonCompanionObject(container) ||
                isPropertyWithBackingFieldInOuterClass(propertyDescriptor) ||
-               isInterfaceCompanionObject(propertyDescriptor.getContainingDeclaration());
+               (isCompanionObject(container) && isInterface(container.getContainingDeclaration()));
     }
 
     public static boolean isPropertyWithBackingFieldInOuterClass(@NotNull PropertyDescriptor propertyDescriptor) {

compiler/backend/src/org/jetbrains/kotlin/codegen/ClosureCodegen.java

@@ -44,6 +44,7 @@ import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.serialization.DescriptorSerializer;
 import org.jetbrains.kotlin.serialization.ProtoBuf;
 import org.jetbrains.kotlin.types.KotlinType;
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.kotlin.util.OperatorNameConventions;
 import org.jetbrains.kotlin.utils.FunctionsKt;
 import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
@@ -442,7 +443,7 @@ public class ClosureCodegen extends MemberCodegen<KtElement> {
                                   : typeMapper.mapType((VariableDescriptor) descriptor);
                 args.add(FieldInfo.createForHiddenField(ownerType, type, "$" + descriptor.getName().asString()));
             }
-            else if (DescriptorUtils.isLocalFunction(descriptor)) {
+            else if (ExpressionTypingUtils.isLocalFunction(descriptor)) {
                 Type classType = asmTypeForAnonymousClass(bindingContext, (FunctionDescriptor) descriptor);
                 args.add(FieldInfo.createForHiddenField(ownerType, classType, "$" + descriptor.getName().asString()));
             }

compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java

@@ -99,9 +99,12 @@ import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isJvmInterface;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.*;
 import static org.jetbrains.kotlin.resolve.BindingContext.*;
 import static org.jetbrains.kotlin.resolve.BindingContextUtils.*;
-import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
+import static org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry;
+import static org.jetbrains.kotlin.resolve.DescriptorUtils.isObject;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
 import static org.jetbrains.kotlin.resolve.jvm.annotations.AnnotationUtilKt.hasJvmFieldAnnotation;
+import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isFunctionExpression;
+import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isFunctionLiteral;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
 public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> implements LocalLookup {
@@ -2508,7 +2511,7 @@ public class ExpressionCodegen extends KtVisitor<StackValue, StackValue> impleme
 
         // We should inline callable containing reified type parameters even if inline is disabled
         // because they may contain something to reify and straight call will probably fail at runtime
-        boolean isInline = (state.isInlineEnabled() || DescriptorUtils.containsReifiedTypeParameters(descriptor)) &&
+        boolean isInline = (state.isInlineEnabled() || InlineUtil.containsReifiedTypeParameters(descriptor)) &&
                            InlineUtil.isInline(descriptor);
 
         if (!isInline) return defaultCallGenerator;

compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java

@@ -58,7 +58,10 @@ import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterKind;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodParameterSignature;
 import org.jetbrains.kotlin.resolve.jvm.jvmSignature.JvmMethodSignature;
 import org.jetbrains.kotlin.types.KotlinType;
-import org.jetbrains.org.objectweb.asm.*;
+import org.jetbrains.org.objectweb.asm.AnnotationVisitor;
+import org.jetbrains.org.objectweb.asm.Label;
+import org.jetbrains.org.objectweb.asm.MethodVisitor;
+import org.jetbrains.org.objectweb.asm.Type;
 import org.jetbrains.org.objectweb.asm.commons.InstructionAdapter;
 import org.jetbrains.org.objectweb.asm.commons.Method;
 import org.jetbrains.org.objectweb.asm.util.TraceMethodVisitor;
@@ -78,6 +81,7 @@ import static org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarg
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.getSourceFromDescriptor;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE;
+import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.*;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
 public class FunctionCodegen {
@@ -328,8 +332,7 @@ public class FunctionCodegen {
         }
         else if (isFunctionLiteral(functionDescriptor) ||
                  isLocalFunction(functionDescriptor) ||
-                 isFunctionExpression(functionDescriptor)
+                 isFunctionExpression(functionDescriptor)) {
-                ) {
             return typeMapper.mapType(context.getThisDescriptor());
         }
         else {

compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java

@@ -85,6 +85,7 @@ import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.JAVA_STRING_TYPE;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.OBJECT_TYPE;
 import static org.jetbrains.kotlin.resolve.jvm.diagnostics.JvmDeclarationOrigin.NO_ORIGIN;
 import static org.jetbrains.kotlin.types.Variance.INVARIANT;
+import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isLocalFunction;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
 public class ImplementationBodyCodegen extends ClassBodyCodegen {

compiler/backend/src/org/jetbrains/kotlin/codegen/context/LocalLookup.java

@@ -30,7 +30,7 @@ import org.jetbrains.org.objectweb.asm.Type;
 
 import static org.jetbrains.kotlin.codegen.AsmUtil.CAPTURED_RECEIVER_FIELD;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.*;
-import static org.jetbrains.kotlin.resolve.DescriptorUtils.isLocalFunction;
+import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isLocalFunction;
 
 public interface LocalLookup {
     boolean lookupLocal(DeclarationDescriptor descriptor);

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/InlineCodegen.java

@@ -65,7 +65,7 @@ import static org.jetbrains.kotlin.codegen.AsmUtil.isPrimitive;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.CLASS_FOR_SCRIPT;
 import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil.addInlineMarker;
 import static org.jetbrains.kotlin.codegen.inline.InlineCodegenUtil.getConstant;
-import static org.jetbrains.kotlin.resolve.DescriptorUtils.isFunctionLiteral;
+import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isFunctionLiteral;
 
 public class InlineCodegen extends CallGenerator {
     private final GenerationState state;

compiler/backend/src/org/jetbrains/kotlin/codegen/inline/ReifiedTypeInliner.kt

@@ -20,7 +20,6 @@ import com.google.common.collect.ImmutableSet
 import org.jetbrains.kotlin.codegen.context.MethodContext
 import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicMethods
 import org.jetbrains.kotlin.codegen.intrinsics.TypeIntrinsics
-import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.org.objectweb.asm.MethodVisitor
 import org.jetbrains.org.objectweb.asm.Opcodes
@@ -246,8 +245,10 @@ public class ReifiedTypeParametersUsages {
         // 1. at least one of it's method contains operations to reify
         // 2. reified type parameter of these operations is not from current method signature
         // i.e. from outer scope
-        child.usedTypeParameters.filterNot {
+        child.usedTypeParameters.filterNot { name ->
-            DescriptorUtils.containsReifiedTypeParameterWithName(context.getContextDescriptor(), it)
+            context.contextDescriptor.typeParameters.any { typeParameter ->
+                typeParameter.isReified && typeParameter.name.asString() == name
+            }
         }.forEach { usedTypeParameters.add(it) }
     }
 

compiler/backend/src/org/jetbrains/kotlin/codegen/state/JetTypeMapper.java

@@ -82,6 +82,7 @@ import static org.jetbrains.kotlin.resolve.BindingContextUtils.getDelegationCons
 import static org.jetbrains.kotlin.resolve.BindingContextUtils.isVarCapturedInClosure;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.DEFAULT_CONSTRUCTOR_MARKER;
+import static org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.*;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
 public class JetTypeMapper {

compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt

@@ -19,18 +19,22 @@ package org.jetbrains.kotlin.resolve
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
-import org.jetbrains.kotlin.descriptors.annotations.*
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
+import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention
+import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget
+import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget.*
 import org.jetbrains.kotlin.diagnostics.Errors
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.psi.psiUtil.getAnnotationEntries
 import org.jetbrains.kotlin.resolve.constants.ArrayValue
 import org.jetbrains.kotlin.resolve.constants.EnumValue
+import org.jetbrains.kotlin.resolve.descriptorUtil.getAnnotationRetention
+import org.jetbrains.kotlin.resolve.descriptorUtil.isRepeatableAnnotation
+import org.jetbrains.kotlin.resolve.inline.InlineUtil
 import org.jetbrains.kotlin.types.KotlinType
 import org.jetbrains.kotlin.types.TypeUtils
-import org.jetbrains.kotlin.resolve.descriptorUtil.isRepeatableAnnotation
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
-import org.jetbrains.kotlin.descriptors.annotations.KotlinTarget.*
-import org.jetbrains.kotlin.resolve.descriptorUtil.getAnnotationRetention
-import org.jetbrains.kotlin.resolve.inline.InlineUtil
 
 public class AnnotationChecker(private val additionalCheckers: Iterable<AdditionalAnnotationChecker>) {
 
@@ -183,7 +187,7 @@ public class AnnotationChecker(private val additionalCheckers: Iterable<Addition
                 }
                 is KtConstructor<*> -> TargetLists.T_CONSTRUCTOR
                 is KtFunction -> {
-                    if (DescriptorUtils.isFunctionExpression(descriptor))
+                    if (ExpressionTypingUtils.isFunctionExpression(descriptor))
                         TargetLists.T_FUNCTION_EXPRESSION
                     else if (annotated.isLocal)
                         TargetLists.T_LOCAL_FUNCTION

compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java

@@ -482,7 +482,7 @@ public class BodyResolver {
                 trace.report(SUPERTYPE_APPEARS_TWICE.on(typeReference));
             }
 
-            if (DescriptorUtils.isSingleton(classDescriptor)) {
+            if (classDescriptor != null && classDescriptor.getKind().isSingleton()) {
                 trace.report(SINGLETON_IN_SUPERTYPE.on(typeReference));
             }
             else if (constructor.isFinal() && !allowedFinalSupertypes.contains(constructor)) {

compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java

@@ -852,17 +852,19 @@ public class DeclarationsChecker {
     private void checkEnumEntry(@NotNull KtEnumEntry enumEntry, @NotNull ClassDescriptor classDescriptor) {
         DeclarationDescriptor declaration = classDescriptor.getContainingDeclaration();
         if (DescriptorUtils.isEnumClass(declaration)) {
-            ClassDescriptor enumClass = (ClassDescriptor) declaration;
+            if (!enumEntry.hasInitializer() && !hasDefaultConstructor((ClassDescriptor) declaration)) {
-
-            if (!enumEntry.hasInitializer() && !DescriptorUtils.hasDefaultConstructor(enumClass)) {
                 trace.report(ENUM_ENTRY_SHOULD_BE_INITIALIZED.on(enumEntry));
             }
         }
         else {
-            assert DescriptorUtils.isInterface(declaration) : "Enum entry should be declared in enum class: " +
+            assert DescriptorUtils.isInterface(declaration) : "Enum entry should be declared in enum class: " + classDescriptor;
-                                                              classDescriptor + " " +
-                                                              classDescriptor.getKind();
         }
     }
 
+    private static boolean hasDefaultConstructor(@NotNull ClassDescriptor classDescriptor) {
+        for (ConstructorDescriptor constructor : classDescriptor.getConstructors()) {
+            if (constructor.getValueParameters().isEmpty()) return true;
+        }
+        return false;
+    }
 }

compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt

@@ -22,19 +22,14 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.descriptors.impl.ConstructorDescriptorImpl
 import org.jetbrains.kotlin.descriptors.impl.FunctionExpressionDescriptor
 import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl
-import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl.create
 import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl
 import org.jetbrains.kotlin.diagnostics.DiagnosticUtils
 import org.jetbrains.kotlin.diagnostics.Errors.*
 import org.jetbrains.kotlin.lexer.KtTokens
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.*
-import org.jetbrains.kotlin.resolve.DescriptorResolver.getDefaultModality
+import org.jetbrains.kotlin.resolve.DescriptorResolver.*
-import org.jetbrains.kotlin.resolve.DescriptorResolver.getDefaultVisibility
-import org.jetbrains.kotlin.resolve.DescriptorResolver.transformAnonymousTypeIfNeeded
 import org.jetbrains.kotlin.resolve.DescriptorUtils.getDispatchReceiverParameterIfNeeded
-import org.jetbrains.kotlin.resolve.DescriptorUtils.isFunctionExpression
-import org.jetbrains.kotlin.resolve.DescriptorUtils.isFunctionLiteral
 import org.jetbrains.kotlin.resolve.ModifiersChecker.resolveModalityFromModifiers
 import org.jetbrains.kotlin.resolve.ModifiersChecker.resolveVisibilityFromModifiers
 import org.jetbrains.kotlin.resolve.bindingContextUtil.recordScope
@@ -52,6 +47,8 @@ import org.jetbrains.kotlin.types.TypeUtils
 import org.jetbrains.kotlin.types.checker.KotlinTypeChecker
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isFunctionExpression
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils.isFunctionLiteral
 import org.jetbrains.kotlin.types.expressions.PreliminaryDeclarationVisitor
 import java.util.*
 

compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineAnalyzerExtension.java

@@ -24,7 +24,6 @@ import org.jetbrains.kotlin.diagnostics.Errors;
 import org.jetbrains.kotlin.lexer.KtTokens;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.BindingTrace;
-import org.jetbrains.kotlin.resolve.DescriptorUtils;
 import org.jetbrains.kotlin.resolve.FunctionAnalyzerExtension;
 import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilsKt;
 
@@ -124,7 +123,7 @@ public class InlineAnalyzerExtension implements FunctionAnalyzerExtension.Analyz
             hasInlinable |= checkInlinableParameter(receiverParameter, receiver, functionDescriptor, trace);
         }
 
-        hasInlinable |= DescriptorUtils.containsReifiedTypeParameters(functionDescriptor);
+        hasInlinable |= InlineUtil.containsReifiedTypeParameters(functionDescriptor);
 
         if (!hasInlinable) {
             KtModifierList modifierList = function.getModifierList();

compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java

@@ -136,4 +136,12 @@ public class InlineUtil {
         }
         return true;
     }
+
+    public static boolean containsReifiedTypeParameters(@NotNull CallableDescriptor descriptor) {
+        for (TypeParameterDescriptor typeParameterDescriptor : descriptor.getTypeParameters()) {
+            if (typeParameterDescriptor.isReified()) return true;
+        }
+
+        return false;
+    }
 }

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingUtils.java

@@ -23,6 +23,9 @@ import com.intellij.psi.util.PsiTreeUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.descriptors.*;
+import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
+import org.jetbrains.kotlin.descriptors.impl.FunctionExpressionDescriptor;
+import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.DiagnosticFactory;
 import org.jetbrains.kotlin.diagnostics.Errors;
@@ -241,4 +244,18 @@ public class ExpressionTypingUtils {
     private ExpressionTypingUtils() {
     }
 
+    public static boolean isFunctionLiteral(@Nullable DeclarationDescriptor descriptor) {
+        return descriptor instanceof AnonymousFunctionDescriptor;
+    }
+
+    public static boolean isLocalFunction(@Nullable DeclarationDescriptor descriptor) {
+        if (descriptor != null && descriptor.getClass() == SimpleFunctionDescriptorImpl.class) {
+            return ((SimpleFunctionDescriptorImpl) descriptor).getVisibility() == Visibilities.LOCAL;
+        }
+        return false;
+    }
+
+    public static boolean isFunctionExpression(@Nullable DeclarationDescriptor descriptor) {
+        return descriptor instanceof FunctionExpressionDescriptor;
+    }
 }

core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java

@@ -16,7 +16,6 @@
 
 package org.jetbrains.kotlin.resolve;
 
-import kotlin.CollectionsKt;
 import kotlin.jvm.functions.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -26,9 +25,6 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotated;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationWithTarget;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
-import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor;
-import org.jetbrains.kotlin.descriptors.impl.FunctionExpressionDescriptor;
-import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl;
 import org.jetbrains.kotlin.incremental.components.LookupLocation;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.FqNameUnsafe;
@@ -36,7 +32,6 @@ import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.name.SpecialNames;
 import org.jetbrains.kotlin.resolve.constants.ConstantValue;
 import org.jetbrains.kotlin.resolve.constants.StringValue;
-import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter;
 import org.jetbrains.kotlin.resolve.scopes.FilteringScope;
 import org.jetbrains.kotlin.resolve.scopes.KtScope;
 import org.jetbrains.kotlin.types.ErrorUtils;
@@ -214,6 +209,7 @@ public class DescriptorUtils {
             if (descriptor instanceof PackageViewDescriptor) {
                 return ((PackageViewDescriptor) descriptor).getModule();
             }
+            //noinspection ConstantConditions
             descriptor = descriptor.getContainingDeclaration();
         }
         return null;
@@ -282,21 +278,6 @@ public class DescriptorUtils {
         return false;
     }
 
-    public static boolean isFunctionLiteral(@Nullable DeclarationDescriptor descriptor) {
-        return descriptor instanceof AnonymousFunctionDescriptor;
-    }
-
-    public static boolean isLocalFunction(@Nullable DeclarationDescriptor descriptor) {
-        if (descriptor != null && descriptor.getClass() == SimpleFunctionDescriptorImpl.class) {
-            return ((SimpleFunctionDescriptorImpl) descriptor).getVisibility() == Visibilities.LOCAL;
-        }
-        return false;
-    }
-
-    public static boolean isFunctionExpression(@Nullable DeclarationDescriptor descriptor) {
-        return descriptor instanceof FunctionExpressionDescriptor;
-    }
-
     public static boolean isCompanionObject(@Nullable DeclarationDescriptor descriptor) {
         return isKindOf(descriptor, ClassKind.OBJECT) && ((ClassDescriptor) descriptor).isCompanionObject();
     }
@@ -309,10 +290,6 @@ public class DescriptorUtils {
         return isKindOf(descriptor, ClassKind.OBJECT) && !((ClassDescriptor) descriptor).isCompanionObject();
     }
 
-    public static boolean isInterfaceCompanionObject(@NotNull DeclarationDescriptor descriptor) {
-        return isCompanionObject(descriptor) && isInterface(descriptor.getContainingDeclaration());
-    }
-
     public static boolean isObject(@NotNull DeclarationDescriptor descriptor) {
         return isKindOf(descriptor, ClassKind.OBJECT);
     }
@@ -321,14 +298,6 @@ public class DescriptorUtils {
         return isKindOf(descriptor, ClassKind.ENUM_ENTRY);
     }
 
-    public static boolean isSingleton(@Nullable DeclarationDescriptor classifier) {
-        if (classifier instanceof ClassDescriptor) {
-            ClassDescriptor clazz = (ClassDescriptor) classifier;
-            return clazz.getKind().isSingleton();
-        }
-        return false;
-    }
-
     public static boolean isEnumClass(@Nullable DeclarationDescriptor descriptor) {
         return isKindOf(descriptor, ClassKind.ENUM_CLASS);
     }
@@ -537,22 +506,6 @@ public class DescriptorUtils {
         return result;
     }
 
-    public static boolean containsReifiedTypeParameterWithName(@NotNull CallableDescriptor descriptor, @NotNull String name) {
-        for (TypeParameterDescriptor typeParameterDescriptor : descriptor.getTypeParameters()) {
-            if (typeParameterDescriptor.isReified() && typeParameterDescriptor.getName().asString().equals(name)) return true;
-        }
-
-        return false;
-    }
-
-    public static boolean containsReifiedTypeParameters(@NotNull CallableDescriptor descriptor) {
-        for (TypeParameterDescriptor typeParameterDescriptor : descriptor.getTypeParameters()) {
-            if (typeParameterDescriptor.isReified()) return true;
-        }
-
-        return false;
-    }
-
     public static boolean isSingletonOrAnonymousObject(@NotNull ClassDescriptor classDescriptor) {
         return classDescriptor.getKind().isSingleton() || isAnonymousObject(classDescriptor);
     }
@@ -561,26 +514,6 @@ public class DescriptorUtils {
         return !isSingletonOrAnonymousObject(classDescriptor) && !isInterface(classDescriptor);
     }
 
-    public static boolean hasDefaultConstructor(@NotNull ClassDescriptor classDescriptor) {
-        for (ConstructorDescriptor constructor : classDescriptor.getConstructors()) {
-            if (constructor.getValueParameters().isEmpty()) return true;
-        }
-        return false;
-    }
-
-    public static Set<FqName> getPackagesFqNames(ModuleDescriptor module) {
-        Set<FqName> result = getSubPackagesFqNames(module.getPackage(FqName.ROOT));
-        result.add(FqName.ROOT);
-        return result;
-    }
-
-    public static Set<FqName> getSubPackagesFqNames(PackageViewDescriptor packageView) {
-        Set<FqName> result = new HashSet<FqName>();
-        getSubPackagesFqNames(packageView, result);
-
-        return result;
-    }
-
     @Nullable
     public static String getJvmName(@NotNull Annotated annotated) {
         AnnotationDescriptor jvmNameAnnotation = getJvmNameAnnotation(annotated.getAnnotations());
@@ -631,17 +564,4 @@ public class DescriptorUtils {
 
         return SourceFile.NO_SOURCE_FILE;
     }
-
-    private static void getSubPackagesFqNames(PackageViewDescriptor packageView, Set<FqName> result) {
-        FqName fqName = packageView.getFqName();
-        if (!fqName.isRoot()) {
-            result.add(fqName);
-        }
-
-        for (DeclarationDescriptor descriptor : packageView.getMemberScope().getDescriptors(DescriptorKindFilter.PACKAGES, KtScope.Companion.getALL_NAME_FILTER())) {
-            if (descriptor instanceof PackageViewDescriptor) {
-                getSubPackagesFqNames((PackageViewDescriptor) descriptor, result);
-            }
-        }
-    }
 }

js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.resolve.descriptorUtil.classId
 import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter
+import org.jetbrains.kotlin.resolve.scopes.KtScope
 import org.jetbrains.kotlin.serialization.DescriptorSerializer
 import org.jetbrains.kotlin.serialization.ProtoBuf
 import org.jetbrains.kotlin.serialization.StringTableImpl
@@ -30,6 +31,7 @@ import org.jetbrains.kotlin.utils.KotlinJavascriptMetadata
 import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
+import java.util.*
 import java.util.zip.GZIPInputStream
 import java.util.zip.GZIPOutputStream
 
@@ -169,7 +171,7 @@ public object KotlinJavascriptSerializationUtil {
     private fun ModuleDescriptor.toContentMap(): Map<String, ByteArray> {
         val contentMap = hashMapOf<String, ByteArray>()
 
-        DescriptorUtils.getPackagesFqNames(this).forEach {
+        getPackagesFqNames(this).forEach {
             serializePackage(this, it) {
                 fileName, bytes -> contentMap[fileName] = bytes
             }
@@ -178,6 +180,26 @@ public object KotlinJavascriptSerializationUtil {
         return contentMap
     }
 
+    private fun getPackagesFqNames(module: ModuleDescriptor): Set<FqName> {
+        return HashSet<FqName>().apply {
+            getSubPackagesFqNames(module.getPackage(FqName.ROOT), this)
+            add(FqName.ROOT)
+        }
+    }
+
+    private fun getSubPackagesFqNames(packageView: PackageViewDescriptor, result: MutableSet<FqName>) {
+        val fqName = packageView.fqName
+        if (!fqName.isRoot) {
+            result.add(fqName)
+        }
+
+        for (descriptor in packageView.memberScope.getDescriptors(DescriptorKindFilter.PACKAGES, KtScope.ALL_NAME_FILTER)) {
+            if (descriptor is PackageViewDescriptor) {
+                getSubPackagesFqNames(descriptor, result)
+            }
+        }
+    }
+
     private fun getPackages(contentMap: Map<String, ByteArray>): Set<String> {
         val keys = contentMap.keySet().map { (if (it.startsWith('/')) it else "/" + it).substringBeforeLast('/') }.toSet()