From 350864b22f031acf4826de9e78d7984d635d9a67 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Wed, 4 Mar 2015 14:51:37 +0300 Subject: [PATCH] Drop some of explicit ClassKind.CLASS_OBJECT and OBJECT usages --- .../src/org/jetbrains/kotlin/codegen/AsmUtil.java | 5 ++--- .../kotlin/codegen/ExpressionCodegen.java | 6 ++++-- .../org/jetbrains/kotlin/codegen/FieldInfo.java | 8 ++++---- .../kotlin/codegen/ImplementationBodyCodegen.java | 2 +- .../kotlin/load/kotlin/KotlinJvmCheckerProvider.kt | 14 ++++++-------- .../org/jetbrains/kotlin/resolve/AnnotationUtil.kt | 10 +++++----- .../kotlin/resolve/DeclarationResolver.kt | 2 +- .../jetbrains/kotlin/resolve/ModifiersChecker.java | 7 ++++--- .../AbstractAnnotationDescriptorResolveTest.java | 4 +++- .../kotlin/renderer/DescriptorRendererImpl.java | 3 ++- .../kotlin/idea/findUsages/UsageTypeUtils.kt | 5 +++-- .../completion/smart/TypeInstantiationItems.kt | 2 +- .../kotlin/idea/imports/KotlinImportOptimizer.kt | 2 +- .../introduce/extractionEngine/ExtractionData.kt | 4 ++-- .../kotlin/js/translate/context/UsageTracker.kt | 5 +++-- .../js/translate/declaration/ClassTranslator.java | 2 +- 16 files changed, 43 insertions(+), 38 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java index 241d1bea21c..53b9f45ef10 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java @@ -344,11 +344,10 @@ public class AsmUtil { } // the following code is only for PRIVATE visibility of member if (memberDescriptor instanceof ConstructorDescriptor) { - ClassKind kind = ((ClassDescriptor) containingDeclaration).getKind(); - if (kind == ClassKind.OBJECT || kind == ClassKind.ENUM_ENTRY) { + if (isNonDefaultObject(containingDeclaration) || isEnumEntry(containingDeclaration)) { return NO_FLAG_PACKAGE_PRIVATE; } - if (kind == ClassKind.ENUM_CLASS) { + if (isEnumClass(containingDeclaration)) { //TODO: should be ACC_PRIVATE // see http://youtrack.jetbrains.com/issue/KT-2680 return ACC_PROTECTED; diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index c1ab67b2af6..5306c5f557e 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -88,6 +88,8 @@ import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory; import static org.jetbrains.kotlin.resolve.BindingContext.*; import static org.jetbrains.kotlin.resolve.BindingContextUtils.getNotNull; import static org.jetbrains.kotlin.resolve.BindingContextUtils.isVarCapturedInClosure; +import static org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry; +import static org.jetbrains.kotlin.resolve.DescriptorUtils.isObject; import static org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage.getResolvedCall; import static org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilPackage.getResolvedCallWithAssert; import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.*; @@ -1913,10 +1915,10 @@ public class ExpressionCodegen extends JetVisitor implem if (descriptor instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) descriptor; - if (classDescriptor.getKind() == ClassKind.OBJECT || classDescriptor.getKind() == ClassKind.CLASS_OBJECT) { + if (isObject(classDescriptor)) { return StackValue.singleton(classDescriptor, typeMapper); } - if (classDescriptor.getKind() == ClassKind.ENUM_ENTRY) { + if (isEnumEntry(classDescriptor)) { DeclarationDescriptor enumClass = classDescriptor.getContainingDeclaration(); assert DescriptorUtils.isEnumClass(enumClass) : "Enum entry should be declared in enum class: " + descriptor; Type type = typeMapper.mapType((ClassDescriptor) enumClass); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java index 096cc68ac60..0072e6aaade 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java @@ -20,21 +20,21 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.codegen.intrinsics.IntrinsicObjects; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; import org.jetbrains.kotlin.descriptors.ClassDescriptor; -import org.jetbrains.kotlin.descriptors.ClassKind; import org.jetbrains.kotlin.descriptors.ClassifierDescriptor; import org.jetbrains.kotlin.load.java.JvmAbi; import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.org.objectweb.asm.Type; +import static org.jetbrains.kotlin.resolve.DescriptorUtils.isNonDefaultObject; + public class FieldInfo { @NotNull public static FieldInfo createForSingleton(@NotNull ClassDescriptor classDescriptor, @NotNull JetTypeMapper typeMapper) { - ClassKind kind = classDescriptor.getKind(); - if (!kind.isSingleton()) { + if (!classDescriptor.getKind().isSingleton()) { throw new UnsupportedOperationException("Can't create singleton field for class: " + classDescriptor); } - if (kind == ClassKind.OBJECT || IntrinsicObjects.INSTANCE$.hasMappingToObject(classDescriptor)) { + if (isNonDefaultObject(classDescriptor) || IntrinsicObjects.INSTANCE$.hasMappingToObject(classDescriptor)) { Type type = typeMapper.mapType(classDescriptor); return new FieldInfo(type, type, JvmAbi.INSTANCE_FIELD, true); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java index d1ab753c915..59851fe0079 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java @@ -140,7 +140,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { isEnum = true; } - if (descriptor.getKind() == ClassKind.OBJECT || descriptor.getKind() == ClassKind.CLASS_OBJECT) { + if (isObject(descriptor)) { isFinal = true; } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt index 51c26956bf6..b717cbe7078 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/KotlinJvmCheckerProvider.kt @@ -101,10 +101,13 @@ public class PlatformStaticAnnotationChecker : AnnotationChecker { descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink ) { - val insideObject = containerKindIs(descriptor, ClassKind.OBJECT) - val insideDefaultObject = containerKindIs(descriptor, ClassKind.CLASS_OBJECT) + val container = descriptor.getContainingDeclaration() + val insideObject = container != null && DescriptorUtils.isNonDefaultObject(container) + val insideDefaultObjectInClass = + container != null && DescriptorUtils.isDefaultObject(container) && DescriptorUtils.isClass(container.getContainingDeclaration()) + container != null && DescriptorUtils.isDefaultObject(container) && DescriptorUtils.isClass(container.getContainingDeclaration()) - if (!insideObject && !(insideDefaultObject && containerKindIs(descriptor.getContainingDeclaration()!!, ClassKind.CLASS))) { + if (!insideObject && !insideDefaultObjectInClass) { diagnosticHolder.report(ErrorsJvm.PLATFORM_STATIC_NOT_IN_OBJECT.on(declaration)); } @@ -112,11 +115,6 @@ public class PlatformStaticAnnotationChecker : AnnotationChecker { diagnosticHolder.report(ErrorsJvm.OVERRIDE_CANNOT_BE_STATIC.on(declaration)); } } - - private fun containerKindIs(descriptor: DeclarationDescriptor, kind: ClassKind): Boolean { - val parentDeclaration = descriptor.getContainingDeclaration() - return parentDeclaration != null && DescriptorUtils.isKindOf(parentDeclaration, kind) - } } public class ReifiedTypeParameterAnnotationChecker : AnnotationChecker { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt index 2fea4a6d972..20ce0c2cb67 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt @@ -36,17 +36,17 @@ public fun DeclarationDescriptor.hasIntrinsicAnnotation(): Boolean { } public fun CallableDescriptor.isPlatformStaticInObjectOrClass(): Boolean = - isPlatformStaticIn(ClassKind.OBJECT, ClassKind.CLASS) + isPlatformStaticIn { DescriptorUtils.isNonDefaultObject(it) || DescriptorUtils.isClass(it) } public fun CallableDescriptor.isPlatformStaticInDefaultObject(): Boolean = - isPlatformStaticIn(ClassKind.CLASS_OBJECT) + isPlatformStaticIn { DescriptorUtils.isDefaultObject(it) } -private fun CallableDescriptor.isPlatformStaticIn(vararg kinds: ClassKind): Boolean = +private fun CallableDescriptor.isPlatformStaticIn(predicate: (DeclarationDescriptor) -> Boolean): Boolean = when (this) { is PropertyAccessorDescriptor -> { val propertyDescriptor = getCorrespondingProperty() - kinds.any { DescriptorUtils.isKindOf(propertyDescriptor.getContainingDeclaration(), it) } && + predicate(propertyDescriptor.getContainingDeclaration()!!) && (hasPlatformStaticAnnotation() || propertyDescriptor.hasPlatformStaticAnnotation()) } - else -> kinds.any { DescriptorUtils.isKindOf(getContainingDeclaration(), it) } && hasPlatformStaticAnnotation() + else -> predicate(getContainingDeclaration()) && hasPlatformStaticAnnotation() } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt index 10009b3e5ca..14e4e9ebeaf 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt @@ -60,7 +60,7 @@ public class DeclarationResolver { public fun checkRedeclarationsInInnerClassNames(c: TopDownAnalysisContext) { for (classDescriptor in c.getDeclaredClasses().values()) { - if (classDescriptor.getKind() == ClassKind.CLASS_OBJECT) { + if (DescriptorUtils.isDefaultObject(classDescriptor)) { // Default objects should be considered during analysing redeclarations in classes continue } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java index 3b0f305ad16..bce5ff48f32 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java @@ -39,6 +39,8 @@ import java.util.*; import static org.jetbrains.kotlin.diagnostics.Errors.*; import static org.jetbrains.kotlin.lexer.JetTokens.*; +import static org.jetbrains.kotlin.resolve.DescriptorUtils.isDefaultObject; +import static org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry; public class ModifiersChecker { private static final Collection MODALITY_MODIFIERS = @@ -363,11 +365,10 @@ public class ModifiersChecker { @NotNull public static Visibility getDefaultClassVisibility(@NotNull ClassDescriptor descriptor) { - ClassKind kind = descriptor.getKind(); - if (kind == ClassKind.ENUM_ENTRY) { + if (isEnumEntry(descriptor)) { return Visibilities.PUBLIC; } - if (kind == ClassKind.CLASS_OBJECT) { + if (isDefaultObject(descriptor)) { return ((ClassDescriptor) descriptor.getContainingDeclaration()).getVisibility(); } return Visibilities.INTERNAL; diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java b/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java index e5b1a1cc1b7..7455c3eb214 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java +++ b/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java @@ -45,6 +45,8 @@ import java.util.Collection; import java.util.Collections; import java.util.List; +import static org.jetbrains.kotlin.resolve.DescriptorUtils.isNonDefaultObject; + public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFixture { private static final DescriptorRenderer WITH_ANNOTATION_ARGUMENT_TYPES = new DescriptorRendererBuilder() .setVerbose(true) @@ -228,7 +230,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix @NotNull private ClassDescriptor getLocalObjectDescriptor(@NotNull String name) { ClassDescriptor localClassDescriptor = getLocalClassDescriptor(name); - if (localClassDescriptor.getKind() == ClassKind.OBJECT) { + if (isNonDefaultObject(localClassDescriptor)) { return localClassDescriptor; } diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.java b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.java index acaea95211a..e3dabc549fb 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.java @@ -42,6 +42,7 @@ import org.jetbrains.kotlin.utils.UtilsPackage; import java.util.*; +import static org.jetbrains.kotlin.resolve.DescriptorUtils.isDefaultObject; import static org.jetbrains.kotlin.types.TypeUtils.CANT_INFER_LAMBDA_PARAM_TYPE; public class DescriptorRendererImpl implements DescriptorRenderer { @@ -951,7 +952,7 @@ public class DescriptorRendererImpl implements DescriptorRenderer { renderClassKindPrefix(klass, builder); } - if (klass.getKind() != ClassKind.CLASS_OBJECT) { + if (!isDefaultObject(klass)) { if (!startFromName) renderSpaceIfNeeded(builder); renderName(klass, builder); } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt index c80dea49640..3a466f6cf0e 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/findUsages/UsageTypeUtils.kt @@ -62,6 +62,7 @@ import org.jetbrains.kotlin.idea.caches.resolve.analyze import org.jetbrains.kotlin.psi.psiUtil.getParentOfTypeAndBranch import org.jetbrains.kotlin.idea.references.JetArrayAccessReference import org.jetbrains.kotlin.idea.references.JetInvokeFunctionReference +import org.jetbrains.kotlin.resolve.DescriptorUtils public object UsageTypeUtils { public fun getUsageType(element: PsiElement?): UsageTypeEnum? { @@ -229,9 +230,9 @@ public object UsageTypeUtils { val descriptor = context[BindingContext.REFERENCE_TARGET, refExpr] return when (descriptor) { - is ClassifierDescriptor -> when ((descriptor as? ClassDescriptor)?.getKind()) { + is ClassifierDescriptor -> when { // Treat object accesses as variables to simulate the old behaviour (when variables were created for objects) - ClassKind.OBJECT, ClassKind.ENUM_ENTRY -> getVariableUsageType() + DescriptorUtils.isNonDefaultObject(descriptor), DescriptorUtils.isEnumEntry(descriptor) -> getVariableUsageType() else -> getClassUsageType() } is PackageViewDescriptor -> { diff --git a/idea/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt b/idea/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt index 4684ad2933a..eb520be917a 100644 --- a/idea/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt +++ b/idea/src/org/jetbrains/kotlin/idea/completion/smart/TypeInstantiationItems.kt @@ -134,7 +134,7 @@ class TypeInstantiationItems( ): LookupElement? { var lookupElement = lookupElementFactory.createLookupElement(classifier, resolutionFacade, bindingContext, false) - if (classifier.getKind() == ClassKind.OBJECT) { + if (DescriptorUtils.isNonDefaultObject(classifier)) { return lookupElement.addTail(tail) } diff --git a/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt b/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt index 1b06c1f2fe8..6186fc439d5 100644 --- a/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt +++ b/idea/src/org/jetbrains/kotlin/idea/imports/KotlinImportOptimizer.kt @@ -223,7 +223,7 @@ public class KotlinImportOptimizer() : ImportOptimizer { private fun isAccessibleAsMember(target: DeclarationDescriptor, place: JetElement): Boolean { val container = target.getContainingDeclaration() if (container !is ClassDescriptor) return false - val scope = if (container.getKind() == ClassKind.CLASS_OBJECT) + val scope = if (DescriptorUtils.isDefaultObject(container)) container.getContainingDeclaration() as? ClassDescriptor ?: return false else container diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractionData.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractionData.kt index 393b8aa382a..f853c04d12a 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractionData.kt +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractionEngine/ExtractionData.kt @@ -52,6 +52,7 @@ import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils import org.jetbrains.kotlin.idea.util.psi.patternMatching.JetPsiRange import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType import org.jetbrains.kotlin.idea.refactoring.compareDescriptors +import org.jetbrains.kotlin.resolve.DescriptorUtils data class ExtractionOptions( val inferUnitTypeForUnusedValues: Boolean = true, @@ -161,8 +162,7 @@ data class ExtractionData( if (parent is JetQualifiedExpression && parent.getSelectorExpression() == ref) { val receiverDescriptor = (originalResolveResult.resolvedCall?.getDispatchReceiver() as? ThisReceiver)?.getDeclarationDescriptor() - if ((receiverDescriptor as? ClassDescriptor)?.getKind() != ClassKind.CLASS_OBJECT - && parent.getReceiverExpression() !is JetSuperExpression) continue + if (!DescriptorUtils.isDefaultObject(receiverDescriptor) && parent.getReceiverExpression() !is JetSuperExpression) continue } // Skip P in type references like 'P.Q' if (parent is JetUserType && (parent.getParent() as? JetUserType)?.getQualifier() == parent) continue diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/UsageTracker.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/UsageTracker.kt index 3f9d83928b0..728f8d2218d 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/UsageTracker.kt +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/UsageTracker.kt @@ -21,6 +21,7 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils.isAncestor import com.google.dart.compiler.backend.js.ast.JsName import org.jetbrains.kotlin.js.translate.utils.ManglingUtils.getSuggestedName import com.google.dart.compiler.backend.js.ast.JsFunctionScope +import org.jetbrains.kotlin.resolve.DescriptorUtils private val CAPTURED_RECEIVER_NAME_PREFIX : String = "this$" @@ -97,8 +98,8 @@ private fun ReceiverParameterDescriptor.getNameForCapturedReceiver(): String { "receiverDescriptor = $this, " +"containingDeclaration = $containingDeclaration" } - if (containingDeclaration is ClassDescriptor && containingDeclaration.getKind() == ClassKind.CLASS_OBJECT) { - return containingDeclaration.getContainingDeclaration().getNameForCapturedDescriptor(namePostfix = "$") + if (DescriptorUtils.isDefaultObject(containingDeclaration)) { + return containingDeclaration.getContainingDeclaration()!!.getNameForCapturedDescriptor(namePostfix = "$") } return containingDeclaration.getNameForCapturedDescriptor() diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.java index fd1c74e4554..83066d3ceb3 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.java @@ -184,7 +184,7 @@ public final class ClassTranslator extends AbstractTranslator { // Overlap alias of class object receiver for accessing from containing class(see previous if block), // because inside class object we should use simple name for access. - if (descriptor.getKind() == ClassKind.CLASS_OBJECT) { + if (isDefaultObject(descriptor)) { declarationContext = declarationContext.innerContextWithAliased(descriptor.getThisAsReceiverParameter(), JsLiteral.THIS); }