Minor, add DescriptorUtils.isClassOrEnumClass

compiler/backend-common/src/org/jetbrains/kotlin/backend/common/bridges/impl.kt

@@ -90,10 +90,9 @@ public fun findImplementationFromInterface(descriptor: CallableMemberDescriptor)
     val overridden = OverrideResolver.getOverriddenDeclarations(descriptor)
     val filtered = OverrideResolver.filterOutOverridden(overridden)
 
-    val result = filtered.firstOrNull { it.getModality() != Modality.ABSTRACT } ?: return null
+    val result = filtered.firstOrNull { it.modality != Modality.ABSTRACT } ?: return null
 
-    val container = result.getContainingDeclaration()
-    if (DescriptorUtils.isClass(container) || DescriptorUtils.isEnumClass(container)) return null
+    if (DescriptorUtils.isClassOrEnumClass(result.containingDeclaration)) return null
 
     return result
 }

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

@@ -65,7 +65,6 @@ import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isJvmInterface;
 import static org.jetbrains.kotlin.load.java.JvmAnnotationNames.KOTLIN_SYNTHETIC_CLASS;
 import static org.jetbrains.kotlin.resolve.DescriptorUtils.*;
 import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*;
-import static org.jetbrains.kotlin.resolve.jvm.annotations.AnnotationUtilKt.hasJvmFieldAnnotation;
 import static org.jetbrains.kotlin.types.TypeUtils.isNullableType;
 import static org.jetbrains.org.objectweb.asm.Opcodes.*;
 
@@ -542,7 +541,7 @@ public class AsmUtil {
                 if (opToken == KtTokens.EXCLEQ || opToken == KtTokens.EXCLEQEQEQ) {
                     genInvertBoolean(v);
                 }
-                return Unit.INSTANCE$;
+                return Unit.INSTANCE;
             }
         });
     }
@@ -728,8 +727,7 @@ public class AsmUtil {
     }
 
     public static boolean isCompanionObjectWithBackingFieldsInOuter(@NotNull DeclarationDescriptor companionObject) {
-        DeclarationDescriptor containingClass = companionObject.getContainingDeclaration();
-        return isCompanionObject(companionObject) && (isClass(containingClass) || isEnumClass(containingClass));
+        return isCompanionObject(companionObject) && isClassOrEnumClass(companionObject.getContainingDeclaration());
     }
 
     private static boolean areBothAccessorDefault(@NotNull PropertyDescriptor propertyDescriptor) {

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt

@@ -69,11 +69,11 @@ public class PlatformStaticAnnotationChecker : DeclarationChecker {
             descriptor: DeclarationDescriptor,
             diagnosticHolder: DiagnosticSink
     ) {
-        val container = descriptor.getContainingDeclaration()
+        val container = descriptor.containingDeclaration
         val insideObject = container != null && DescriptorUtils.isNonCompanionObject(container)
         val insideCompanionObjectInClass =
                 container != null && DescriptorUtils.isCompanionObject(container) &&
-                container.getContainingDeclaration().let { DescriptorUtils.isClass(it) || DescriptorUtils.isEnumClass(it) }
+                DescriptorUtils.isClassOrEnumClass(container.containingDeclaration)
 
         if (!insideObject && !insideCompanionObjectInClass) {
             diagnosticHolder.report(ErrorsJvm.JVM_STATIC_NOT_IN_OBJECT.on(declaration))

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

@@ -36,7 +36,7 @@ public fun DeclarationDescriptor.hasJvmSyntheticAnnotation(): Boolean {
 }
 
 public fun CallableDescriptor.isPlatformStaticInObjectOrClass(): Boolean =
-        isPlatformStaticIn { DescriptorUtils.isNonCompanionObject(it) || DescriptorUtils.isClass(it) || DescriptorUtils.isEnumClass(it) }
+        isPlatformStaticIn { DescriptorUtils.isNonCompanionObject(it) || DescriptorUtils.isClassOrEnumClass(it) }
 
 public fun CallableDescriptor.isPlatformStaticInCompanionObject(): Boolean =
         isPlatformStaticIn { DescriptorUtils.isCompanionObject(it) }

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

@@ -312,6 +312,10 @@ public class DescriptorUtils {
         return isKindOf(descriptor, ClassKind.CLASS);
     }
 
+    public static boolean isClassOrEnumClass(@Nullable DeclarationDescriptor descriptor) {
+        return isClass(descriptor) || isEnumClass(descriptor);
+    }
+
     private static boolean isKindOf(@Nullable DeclarationDescriptor descriptor, @NotNull ClassKind classKind) {
         return descriptor instanceof ClassDescriptor && ((ClassDescriptor) descriptor).getKind() == classKind;
     }

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

@@ -18,9 +18,7 @@ package org.jetbrains.kotlin.resolve.descriptorUtil
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.ClassKind.ENUM_CLASS
-import org.jetbrains.kotlin.descriptors.ClassKind.ENUM_ENTRY
-import org.jetbrains.kotlin.descriptors.ClassKind.OBJECT
+import org.jetbrains.kotlin.descriptors.ClassKind.*
 import org.jetbrains.kotlin.descriptors.annotations.Annotated
 import org.jetbrains.kotlin.descriptors.annotations.KotlinRetention
 import org.jetbrains.kotlin.incremental.components.LookupLocation
@@ -109,11 +107,12 @@ public val DeclarationDescriptorWithVisibility.isEffectivelyPublicApi: Boolean
     }
 
 public fun ClassDescriptor.getSuperClassNotAny(): ClassDescriptor? {
-    for (supertype in getDefaultType().getConstructor().getSupertypes()) {
-        val superClassifier = supertype.getConstructor().getDeclarationDescriptor()
-        if (!KotlinBuiltIns.isAnyOrNullableAny(supertype) &&
-            (DescriptorUtils.isClass(superClassifier) || DescriptorUtils.isEnumClass(superClassifier))) {
-            return superClassifier as ClassDescriptor
+    for (supertype in defaultType.constructor.supertypes) {
+        if (!KotlinBuiltIns.isAnyOrNullableAny(supertype)) {
+            val superClassifier = supertype.constructor.declarationDescriptor
+            if (DescriptorUtils.isClassOrEnumClass(superClassifier)) {
+                return superClassifier as ClassDescriptor
+            }
         }
     }
     return null

core/descriptors/src/org/jetbrains/kotlin/types/TypeUtils.kt

@@ -17,7 +17,10 @@
 package org.jetbrains.kotlin.types.typeUtil
 
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.ClassDescriptor
+import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
 import org.jetbrains.kotlin.descriptors.annotations.Annotations
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import org.jetbrains.kotlin.types.*
@@ -170,9 +173,7 @@ private fun constituentTypes(result: MutableSet<KotlinType>, types: Collection<K
 
 fun KotlinType.getImmediateSuperclassNotAny(): KotlinType? {
     val superclasses = constructor.supertypes.filter {
-        val descriptor = it.constructor.declarationDescriptor
-        (DescriptorUtils.isClass(descriptor) || DescriptorUtils.isEnumClass(descriptor)) &&
-        !KotlinBuiltIns.isAnyOrNullableAny(it)
+        DescriptorUtils.isClassOrEnumClass(it.constructor.declarationDescriptor) && !KotlinBuiltIns.isAnyOrNullableAny(it)
     }
     return superclasses.singleOrNull()?.let {
         TypeUtils.createSubstitutedSupertype(this, it, TypeSubstitutor.create(this))

core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt

@@ -247,8 +247,7 @@ public class MemberDeserializer(private val c: DeserializationContext) {
         is PackageFragmentDescriptor -> ProtoContainer.Package(fqName, c.nameResolver, c.typeTable, c.packagePartSource)
         is DeserializedClassDescriptor -> ProtoContainer.Class(
                 classProto, c.nameResolver, c.typeTable,
-                isCompanionOfClass = DescriptorUtils.isCompanionObject(this) &&
-                                     containingDeclaration.let { DescriptorUtils.isClass(it) || DescriptorUtils.isEnumClass(it) },
+                isCompanionOfClass = DescriptorUtils.isCompanionObject(this) && DescriptorUtils.isClassOrEnumClass(containingDeclaration),
                 isInterface = kind == ClassKind.INTERFACE
         )
         else -> null // TODO: support annotations on lambdas and their parameters