diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java index 7589c24db32..cc2163cffbd 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java @@ -195,8 +195,8 @@ public class AsmUtil { } } - if (AnnotationsPackage.isPlatformStaticInClassObject(functionDescriptor)) { - // Native method will be a member of the class, the class object method will be delegated to it + if (AnnotationsPackage.isPlatformStaticInDefaultObject(functionDescriptor)) { + // Native method will be a member of the class, the default object method will be delegated to it flags &= ~Opcodes.ACC_NATIVE; } @@ -733,7 +733,7 @@ public class AsmUtil { public static boolean isPropertyWithBackingFieldInOuterClass(@NotNull PropertyDescriptor propertyDescriptor) { return propertyDescriptor.getKind() != CallableMemberDescriptor.Kind.FAKE_OVERRIDE && - isClassObjectWithBackingFieldsInOuter(propertyDescriptor.getContainingDeclaration()); + isDefaultObjectWithBackingFieldsInOuter(propertyDescriptor.getContainingDeclaration()); } public static int getVisibilityForSpecialPropertyBackingField(@NotNull PropertyDescriptor propertyDescriptor, boolean isDelegate) { @@ -762,14 +762,14 @@ public class AsmUtil { DeclarationDescriptor propertyContainer = propertyDescriptor.getContainingDeclaration(); return !propertyDescriptor.isVar() && !isExtensionProperty - && isClassObject(propertyContainer) && isTrait(propertyContainer.getContainingDeclaration()) + && isDefaultObject(propertyContainer) && isTrait(propertyContainer.getContainingDeclaration()) && areBothAccessorDefault(propertyDescriptor) && getVisibilityForSpecialPropertyBackingField(propertyDescriptor, false) == ACC_PUBLIC; } - public static boolean isClassObjectWithBackingFieldsInOuter(@NotNull DeclarationDescriptor classObject) { - DeclarationDescriptor containingClass = classObject.getContainingDeclaration(); - return isClassObject(classObject) && (isClass(containingClass) || isEnumClass(containingClass)); + public static boolean isDefaultObjectWithBackingFieldsInOuter(@NotNull DeclarationDescriptor defaultObject) { + DeclarationDescriptor containingClass = defaultObject.getContainingDeclaration(); + return isDefaultObject(defaultObject) && (isClass(containingClass) || isEnumClass(containingClass)); } private static boolean areBothAccessorDefault(@NotNull PropertyDescriptor propertyDescriptor) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java index b70c4ef6611..c1ab67b2af6 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ExpressionCodegen.java @@ -1922,9 +1922,9 @@ public class ExpressionCodegen extends JetVisitor implem Type type = typeMapper.mapType((ClassDescriptor) enumClass); return StackValue.field(type, type, descriptor.getName().asString(), true, StackValue.none()); } - ClassDescriptor classObjectDescriptor = classDescriptor.getDefaultObjectDescriptor(); - if (classObjectDescriptor != null) { - return StackValue.singleton(classObjectDescriptor, typeMapper); + ClassDescriptor defaultObjectDescriptor = classDescriptor.getDefaultObjectDescriptor(); + if (defaultObjectDescriptor != null) { + return StackValue.singleton(defaultObjectDescriptor, typeMapper); } return StackValue.none(); } @@ -2382,7 +2382,7 @@ public class ExpressionCodegen extends JetVisitor implem public StackValue generateReceiverValue(@NotNull ReceiverValue receiverValue) { if (receiverValue instanceof ClassReceiver) { ClassDescriptor receiverDescriptor = ((ClassReceiver) receiverValue).getDeclarationDescriptor(); - if (DescriptorUtils.isClassObject(receiverDescriptor)) { + if (DescriptorUtils.isDefaultObject(receiverDescriptor)) { CallableMemberDescriptor contextDescriptor = context.getContextDescriptor(); if (contextDescriptor instanceof FunctionDescriptor && receiverDescriptor == contextDescriptor.getContainingDeclaration()) { return StackValue.LOCAL_0; diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java index 0f5e6503836..13b27e094ad 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FieldInfo.java @@ -47,12 +47,12 @@ public class FieldInfo { @SuppressWarnings("deprecation") @NotNull - public static FieldInfo deprecatedFieldForClassObject(@NotNull ClassDescriptor classObject, @NotNull JetTypeMapper typeMapper) { - assert DescriptorUtils.isClassObject(classObject) : "Not a class object: " + classObject; + public static FieldInfo deprecatedFieldForDefaultObject(@NotNull ClassDescriptor defaultObject, @NotNull JetTypeMapper typeMapper) { + assert DescriptorUtils.isDefaultObject(defaultObject) : "Not a default object: " + defaultObject; return new FieldInfo( - typeMapper.mapType((ClassifierDescriptor) classObject.getContainingDeclaration()), - typeMapper.mapType(classObject), - JvmAbi.DEPRECATED_CLASS_OBJECT_FIELD, + typeMapper.mapType((ClassifierDescriptor) defaultObject.getContainingDeclaration()), + typeMapper.mapType(defaultObject), + JvmAbi.DEPRECATED_DEFAULT_OBJECT_FIELD, true ); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java index c8dea2936f0..8beb2d42eeb 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java @@ -168,8 +168,8 @@ public class FunctionCodegen { generateBridges(functionDescriptor); - boolean staticInClassObject = AnnotationsPackage.isPlatformStaticInClassObject(functionDescriptor); - if (staticInClassObject) { + boolean staticInDefaultObject = AnnotationsPackage.isPlatformStaticInDefaultObject(functionDescriptor); + if (staticInDefaultObject) { ImplementationBodyCodegen parentBodyCodegen = (ImplementationBodyCodegen) memberCodegen.getParentCodegen(); parentBodyCodegen.addAdditionalTask(new PlatformStaticGenerator(functionDescriptor, origin, state)); } @@ -192,8 +192,8 @@ public class FunctionCodegen { if (!isNative) { generateMethodBody(mv, functionDescriptor, methodContext, jvmSignature, strategy, memberCodegen); } - else if (staticInClassObject) { - // native platformStatic foo() in class object should delegate to the static native function moved to the outer class + else if (staticInDefaultObject) { + // native platformStatic foo() in default object should delegate to the static native function moved to the outer class mv.visitCode(); FunctionDescriptor staticFunctionDescriptor = PlatformStaticGenerator.createStaticFunctionDescriptor(functionDescriptor); JvmMethodSignature jvmMethodSignature = diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java index d45b08f18fd..ba726c739d5 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java @@ -43,7 +43,6 @@ import org.jetbrains.kotlin.name.FqName; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.BindingContext; -import org.jetbrains.kotlin.resolve.DeclarationResolver; import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils; import org.jetbrains.kotlin.resolve.DescriptorUtils; import org.jetbrains.kotlin.resolve.annotations.AnnotationsPackage; @@ -92,7 +91,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { private JetType superClassType; private final Type classAsmType; - private List classObjectPropertiesToCopy; + private List defaultObjectPropertiesToCopy; private final List> additionalTasks = new ArrayList>(); @@ -152,7 +151,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { isStatic = !jetClass.isInner(); } else { - isStatic = myClass instanceof JetObjectDeclaration && ((JetObjectDeclaration) myClass).isClassObject() ; + isStatic = myClass instanceof JetObjectDeclaration && ((JetObjectDeclaration) myClass).isDefault() ; isFinal = true; } @@ -370,7 +369,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { generateFieldForSingleton(); - generateClassObjectBackingFieldCopies(); + generateDefaultObjectBackingFieldCopies(); DelegationFieldsInfo delegationFieldsInfo = getDelegationFieldsInfo(myClass.getDelegationSpecifiers()); try { @@ -885,7 +884,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { @Override public void doGenerateBody(@NotNull ExpressionCodegen codegen, @NotNull JvmMethodSignature signature) { boolean forceField = AsmUtil.isPropertyWithBackingFieldInOuterClass(original) && - !isClassObject(bridge.getContainingDeclaration()); + !isDefaultObject(bridge.getContainingDeclaration()); StackValue property = codegen.intermediateValueForProperty(original, forceField, null, MethodKind.SYNTHETIC_ACCESSOR, StackValue.none()); @@ -975,7 +974,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { } private void generateFieldForSingleton() { - if (isEnumEntry(descriptor) || isClassObject(descriptor)) return; + if (isEnumEntry(descriptor) || isDefaultObject(descriptor)) return; if (isObject(descriptor)) { StackValue.Field field = StackValue.singleton(descriptor, typeMapper); @@ -990,34 +989,34 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { return; } - ClassDescriptor classObjectDescriptor = descriptor.getDefaultObjectDescriptor(); - if (classObjectDescriptor == null) { + ClassDescriptor defaultObjectDescriptor = descriptor.getDefaultObjectDescriptor(); + if (defaultObjectDescriptor == null) { return; } - JetObjectDeclaration classObject = ((JetClass) myClass).getClassObject(); - assert classObject != null : "Class object not found: " + myClass.getText(); + JetObjectDeclaration defaultObject = ((JetClass) myClass).getDefaultObject(); + assert defaultObject != null : "Default object not found: " + myClass.getText(); - StackValue.Field field = StackValue.singleton(classObjectDescriptor, typeMapper); - v.newField(OtherOrigin(classObject), ACC_PUBLIC | ACC_STATIC | ACC_FINAL, field.name, field.type.getDescriptor(), null, null); + StackValue.Field field = StackValue.singleton(defaultObjectDescriptor, typeMapper); + v.newField(OtherOrigin(defaultObject), ACC_PUBLIC | ACC_STATIC | ACC_FINAL, field.name, field.type.getDescriptor(), null, null); - StackValue.Field deprecatedField = StackValue.deprecatedClassObjectAccessor(classObjectDescriptor, typeMapper); - FieldVisitor fv = v.newField(OtherOrigin(classObject), ACC_PUBLIC | ACC_STATIC | ACC_FINAL | ACC_DEPRECATED, + StackValue.Field deprecatedField = StackValue.deprecatedDefaultObjectAccessor(defaultObjectDescriptor, typeMapper); + FieldVisitor fv = v.newField(OtherOrigin(defaultObject), ACC_PUBLIC | ACC_STATIC | ACC_FINAL | ACC_DEPRECATED, deprecatedField.name, deprecatedField.type.getDescriptor(), null, null); fv.visitAnnotation(asmDescByFqNameWithoutInnerClasses(new FqName("java.lang.Deprecated")), true).visitEnd(); if (state.getClassBuilderMode() != ClassBuilderMode.FULL) return; - if (!isClassObjectWithBackingFieldsInOuter(classObjectDescriptor)) { - generateClassObjectInitializer(classObjectDescriptor); + if (!isDefaultObjectWithBackingFieldsInOuter(defaultObjectDescriptor)) { + generateDefaultObjectInitializer(defaultObjectDescriptor); } } - private void generateClassObjectBackingFieldCopies() { - if (classObjectPropertiesToCopy == null) return; + private void generateDefaultObjectBackingFieldCopies() { + if (defaultObjectPropertiesToCopy == null) return; - for (PropertyAndDefaultValue info : classObjectPropertiesToCopy) { + for (PropertyAndDefaultValue info : defaultObjectPropertiesToCopy) { PropertyDescriptor property = info.descriptor; Type type = typeMapper.mapType(property); @@ -1033,40 +1032,40 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { // TODO: test this code if (state.getClassBuilderMode() == ClassBuilderMode.FULL && info.defaultValue == null) { ExpressionCodegen codegen = createOrGetClInitCodegen(); - int classObjectIndex = putClassObjectInLocalVar(codegen); - StackValue.local(classObjectIndex, OBJECT_TYPE).put(OBJECT_TYPE, codegen.v); - copyFieldFromClassObject(property); + int defaultObjectIndex = putDefaultObjectInLocalVar(codegen); + StackValue.local(defaultObjectIndex, OBJECT_TYPE).put(OBJECT_TYPE, codegen.v); + copyFieldFromDefaultObject(property); } } } - private int putClassObjectInLocalVar(ExpressionCodegen codegen) { + private int putDefaultObjectInLocalVar(ExpressionCodegen codegen) { FrameMap frameMap = codegen.myFrameMap; - ClassDescriptor classObjectDescriptor = descriptor.getDefaultObjectDescriptor(); - int classObjectIndex = frameMap.getIndex(classObjectDescriptor); - if (classObjectIndex == -1) { - classObjectIndex = frameMap.enter(classObjectDescriptor, OBJECT_TYPE); - StackValue classObject = StackValue.singleton(classObjectDescriptor, typeMapper); - StackValue.local(classObjectIndex, classObject.type).store(classObject, codegen.v); + ClassDescriptor defaultObjectDescriptor = descriptor.getDefaultObjectDescriptor(); + int defaultObjectIndex = frameMap.getIndex(defaultObjectDescriptor); + if (defaultObjectIndex == -1) { + defaultObjectIndex = frameMap.enter(defaultObjectDescriptor, OBJECT_TYPE); + StackValue defaultObject = StackValue.singleton(defaultObjectDescriptor, typeMapper); + StackValue.local(defaultObjectIndex, defaultObject.type).store(defaultObject, codegen.v); } - return classObjectIndex; + return defaultObjectIndex; } - private void copyFieldFromClassObject(PropertyDescriptor propertyDescriptor) { + private void copyFieldFromDefaultObject(PropertyDescriptor propertyDescriptor) { ExpressionCodegen codegen = createOrGetClInitCodegen(); StackValue property = codegen.intermediateValueForProperty(propertyDescriptor, false, null, StackValue.none()); StackValue.Field field = StackValue.field(property.type, classAsmType, propertyDescriptor.getName().asString(), true, StackValue.none()); field.store(property, codegen.v); } - private void generateClassObjectInitializer(@NotNull ClassDescriptor classObject) { + private void generateDefaultObjectInitializer(@NotNull ClassDescriptor defaultObject) { ExpressionCodegen codegen = createOrGetClInitCodegen(); - FunctionDescriptor constructor = codegen.accessibleFunctionDescriptor(KotlinPackage.single(classObject.getConstructors())); + FunctionDescriptor constructor = codegen.accessibleFunctionDescriptor(KotlinPackage.single(defaultObject.getConstructors())); generateMethodCallTo(constructor, codegen.v); codegen.v.dup(); - StackValue instance = StackValue.onStack(typeMapper.mapClass(classObject)); - StackValue.singleton(classObject, typeMapper).store(instance, codegen.v, true); - StackValue.deprecatedClassObjectAccessor(classObject, typeMapper).store(instance, codegen.v, true); + StackValue instance = StackValue.onStack(typeMapper.mapClass(defaultObject)); + StackValue.singleton(defaultObject, typeMapper).store(instance, codegen.v, true); + StackValue.deprecatedDefaultObjectAccessor(defaultObject, typeMapper).store(instance, codegen.v, true); } private void generatePrimaryConstructor(final DelegationFieldsInfo delegationFieldsInfo) { @@ -1098,7 +1097,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { CallableMethod callableMethod = typeMapper.mapToCallableMethod(constructorDescriptor); FunctionCodegen.generateConstructorWithoutParametersIfNeeded(state, callableMethod, constructorDescriptor, v, myClass); - if (isClassObject(descriptor)) { + if (isDefaultObject(descriptor)) { context.recordSyntheticAccessorIfNeeded(constructorDescriptor, bindingContext); } } @@ -1151,9 +1150,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { curParam++; } - if (isClassObjectWithBackingFieldsInOuter(descriptor)) { + if (isDefaultObjectWithBackingFieldsInOuter(descriptor)) { final ImplementationBodyCodegen parentCodegen = (ImplementationBodyCodegen) getParentCodegen(); - parentCodegen.generateClassObjectInitializer(descriptor); + parentCodegen.generateDefaultObjectInitializer(descriptor); generateInitializers(new Function0() { @Override public ExpressionCodegen invoke() { @@ -1638,11 +1637,11 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { } } - public void addClassObjectPropertyToCopy(@NotNull PropertyDescriptor descriptor, Object defaultValue) { - if (classObjectPropertiesToCopy == null) { - classObjectPropertiesToCopy = new ArrayList(); + public void addDefaultObjectPropertyToCopy(@NotNull PropertyDescriptor descriptor, Object defaultValue) { + if (defaultObjectPropertiesToCopy == null) { + defaultObjectPropertiesToCopy = new ArrayList(); } - classObjectPropertiesToCopy.add(new PropertyAndDefaultValue(descriptor, defaultValue)); + defaultObjectPropertiesToCopy.add(new PropertyAndDefaultValue(descriptor, defaultValue)); } @Override diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java index 9e73ca400dc..79cbc8360be 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/JvmCodegenUtil.java @@ -179,8 +179,8 @@ public class JvmCodegenUtil { // Delegated and extension properties have no backing fields if (isDelegated || property.getExtensionReceiverParameter() != null) return false; - // Class object properties cannot be accessed directly because their backing fields are stored in the containing class - if (DescriptorUtils.isClassObject(property.getContainingDeclaration())) return false; + // Default object properties cannot be accessed directly because their backing fields are stored in the containing class + if (DescriptorUtils.isDefaultObject(property.getContainingDeclaration())) return false; PropertyAccessorDescriptor accessor = forGetter ? property.getGetter() : property.getSetter(); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java index 7b6300efc29..56e8c4fcb71 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/PropertyCodegen.java @@ -48,7 +48,7 @@ import java.util.List; import static org.jetbrains.kotlin.codegen.AsmUtil.*; import static org.jetbrains.kotlin.codegen.JvmCodegenUtil.isInterface; import static org.jetbrains.kotlin.codegen.JvmSerializationBindings.*; -import static org.jetbrains.kotlin.resolve.DescriptorUtils.isClassObject; +import static org.jetbrains.kotlin.resolve.DescriptorUtils.isDefaultObject; import static org.jetbrains.kotlin.resolve.DescriptorUtils.isTrait; import static org.jetbrains.kotlin.resolve.jvm.AsmTypes.PROPERTY_METADATA_TYPE; import static org.jetbrains.kotlin.resolve.jvm.diagnostics.DiagnosticsPackage.OtherOrigin; @@ -144,8 +144,8 @@ public class PropertyCodegen { // Delegated or extension properties can only be referenced via accessors if (declaration.hasDelegate() || declaration.getReceiverTypeReference() != null) return true; - // Class object properties always should have accessors, because their backing fields are moved/copied to the outer class - if (isClassObject(descriptor.getContainingDeclaration())) return true; + // Default object properties always should have accessors, because their backing fields are moved/copied to the outer class + if (isDefaultObject(descriptor.getContainingDeclaration())) return true; // Private class properties have accessors only in cases when those accessors are non-trivial if (kind == OwnerKind.IMPLEMENTATION && Visibilities.isPrivate(descriptor.getVisibility())) { @@ -265,7 +265,7 @@ public class PropertyCodegen { if (AsmUtil.isPropertyWithBackingFieldCopyInOuterClass(propertyDescriptor)) { ImplementationBodyCodegen parentBodyCodegen = (ImplementationBodyCodegen) memberCodegen.getParentCodegen(); - parentBodyCodegen.addClassObjectPropertyToCopy(propertyDescriptor, defaultValue); + parentBodyCodegen.addDefaultObjectPropertyToCopy(propertyDescriptor, defaultValue); } String name = backingFieldContext.getFieldName(propertyDescriptor, isDelegate); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java index fe55f1c692d..2efe5689908 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/StackValue.java @@ -513,8 +513,8 @@ public abstract class StackValue { return field(FieldInfo.createForSingleton(classDescriptor, typeMapper)); } - public static Field deprecatedClassObjectAccessor(ClassDescriptor classDescriptor, JetTypeMapper typeMapper) { - return field(FieldInfo.deprecatedFieldForClassObject(classDescriptor, typeMapper)); + public static Field deprecatedDefaultObjectAccessor(ClassDescriptor classDescriptor, JetTypeMapper typeMapper) { + return field(FieldInfo.deprecatedFieldForDefaultObject(classDescriptor, typeMapper)); } public static StackValue operation(Type type, Function1 lambda) { diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/PsiCodegenPredictor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/PsiCodegenPredictor.java index de0267dcbb4..320f9d14953 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/PsiCodegenPredictor.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/binding/PsiCodegenPredictor.java @@ -51,7 +51,7 @@ public final class PsiCodegenPredictor { */ @Nullable public static String getPredefinedJvmInternalName(@NotNull JetDeclaration declaration) { - // TODO: Method won't work for declarations inside class objects + // TODO: Method won't work for declarations inside default objects // TODO: Method won't give correct class name for traits implementations JetDeclaration parentDeclaration = JetStubbedPsiUtil.getContainingDeclaration(declaration); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClassContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClassContext.java index f52126dc7df..c8b2b3e116f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClassContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/ClassContext.java @@ -61,7 +61,7 @@ public class ClassContext extends FieldOwnerContext { } @Nullable - public CodegenContext getClassObjectContext() { + public CodegenContext getDefaultObjectContext() { if (getContextDescriptor().getDefaultObjectDescriptor() != null) { return findChildContext(getContextDescriptor().getDefaultObjectDescriptor()); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java index e28df0b4a14..52a0711c275 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/context/CodegenContext.java @@ -361,7 +361,7 @@ public abstract class CodegenContext { CodegenContext descriptorContext = null; if (!fromOutsideContext || getClassOrPackageParentContext().getContextDescriptor() != descriptor.getContainingDeclaration()) { DeclarationDescriptor enclosed = descriptor.getContainingDeclaration(); - boolean isClassObjectMember = DescriptorUtils.isClassObject(enclosed); + boolean isDefaultObjectMember = DescriptorUtils.isDefaultObject(enclosed); //go upper if (hasThisDescriptor() && (enclosed != getThisDescriptor() || !fromOutsideContext)) { CodegenContext currentContext = this; @@ -371,12 +371,12 @@ public abstract class CodegenContext { break; } - //accessors for private members in class object for call from class - if (isClassObjectMember && currentContext instanceof ClassContext) { + //accessors for private members in default object for call from class + if (isDefaultObjectMember && currentContext instanceof ClassContext) { ClassContext classContext = (ClassContext) currentContext; - CodegenContext classObject = classContext.getClassObjectContext(); - if (classObject != null && classObject.getContextDescriptor() == enclosed) { - descriptorContext = classObject; + CodegenContext defaultObjectContext = classContext.getDefaultObjectContext(); + if (defaultObjectContext != null && defaultObjectContext.getContextDescriptor() == enclosed) { + descriptorContext = defaultObjectContext; break; } } @@ -417,7 +417,7 @@ public abstract class CodegenContext { } protected boolean shouldAddChild(@NotNull CodegenContext child) { - return DescriptorUtils.isClassObject(child.contextDescriptor); + return DescriptorUtils.isDefaultObject(child.contextDescriptor); } @Nullable diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java index b856fe42849..b988c25ba85 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java @@ -81,7 +81,7 @@ public abstract class FileBasedKotlinClass implements KotlinJvmBinaryClass { @NotNull protected abstract byte[] getFileContents(); - // TODO public to be accessible in class object of subclass, workaround for KT-3974 + // TODO public to be accessible in default object of subclass, workaround for KT-3974 @Nullable public static T create( @NotNull byte[] fileContents, 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 5cb93368679..51c26956bf6 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 @@ -102,9 +102,9 @@ public class PlatformStaticAnnotationChecker : AnnotationChecker { diagnosticHolder: DiagnosticSink ) { val insideObject = containerKindIs(descriptor, ClassKind.OBJECT) - val insideClassObject = containerKindIs(descriptor, ClassKind.CLASS_OBJECT) + val insideDefaultObject = containerKindIs(descriptor, ClassKind.CLASS_OBJECT) - if (!insideObject && !(insideClassObject && containerKindIs(descriptor.getContainingDeclaration()!!, ClassKind.CLASS))) { + if (!insideObject && !(insideDefaultObject && containerKindIs(descriptor.getContainingDeclaration()!!, ClassKind.CLASS))) { diagnosticHolder.report(ErrorsJvm.PLATFORM_STATIC_NOT_IN_OBJECT.on(declaration)); } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/NeedSyntheticChecker.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/NeedSyntheticChecker.java index 4b14c8dcc85..686c10c3cb7 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/NeedSyntheticChecker.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/calls/checkers/NeedSyntheticChecker.java @@ -42,7 +42,7 @@ public class NeedSyntheticChecker implements CallChecker { //Necessary synthetic accessors in outer classes generated via old logic: CodegenContext.getAccessor //Generation of accessors in nested classes (to invoke from outer, - // e.g.: from class to classobject) controlled via NEED_SYNTHETIC_ACCESSOR slice + // e.g.: from class to default object) controlled via NEED_SYNTHETIC_ACCESSOR slice private boolean needSyntheticAccessor(JetScope invokationScope, CallableDescriptor targetDescriptor) { return targetDescriptor instanceof CallableMemberDescriptor && Visibilities.isPrivate(targetDescriptor.getVisibility()) && diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java index 8f91ea1ca30..23bcb257a4a 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java @@ -45,7 +45,7 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension { static { MAP.put(ErrorsJvm.CONFLICTING_JVM_DECLARATIONS, "Platform declaration clash: {0}", CONFLICTING_JVM_DECLARATIONS_DATA); MAP.put(ErrorsJvm.ACCIDENTAL_OVERRIDE, "Accidental override: {0}", CONFLICTING_JVM_DECLARATIONS_DATA); - MAP.put(ErrorsJvm.PLATFORM_STATIC_NOT_IN_OBJECT, "Only functions in named objects and class objects of classes can be annotated with 'platformStatic'"); + MAP.put(ErrorsJvm.PLATFORM_STATIC_NOT_IN_OBJECT, "Only functions in named objects and default objects of classes can be annotated with 'platformStatic'"); MAP.put(ErrorsJvm.OVERRIDE_CANNOT_BE_STATIC, "Override cannot be 'platformStatic' in object"); MAP.put(ErrorsJvm.PLATFORM_STATIC_ILLEGAL_USAGE, "This declaration does not support ''platformStatic''", DescriptorRenderer.SHORT_NAMES_IN_TYPES); MAP.put(ErrorsJvm.NATIVE_DECLARATION_CANNOT_BE_ABSTRACT, "Native declaration can not be abstract"); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowProcessor.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowProcessor.java index d48c9e8731a..16a0d4d5c4b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowProcessor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetControlFlowProcessor.java @@ -1379,7 +1379,7 @@ public class JetControlFlowProcessor { @Override public void visitTypeProjection(@NotNull JetTypeProjection typeProjection) { - // TODO : Support Type Arguments. Class object may be initialized at this point"); + // TODO : Support Type Arguments. Default object may be initialized at this point"); } @Override diff --git a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/MutableClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/MutableClassDescriptor.java index 0fea34a0573..83b12faf38b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/MutableClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/descriptors/impl/MutableClassDescriptor.java @@ -44,7 +44,7 @@ public class MutableClassDescriptor extends ClassDescriptorBase implements Class private List typeParameters; private Collection supertypes = new ArrayList(); - private MutableClassDescriptor classObjectDescriptor; + private MutableClassDescriptor defaultObjectDescriptor; private final Set constructors = Sets.newLinkedHashSet(); private ConstructorDescriptor primaryConstructor; @@ -93,7 +93,7 @@ public class MutableClassDescriptor extends ClassDescriptorBase implements Class @Nullable @Override public MutableClassDescriptor getDefaultObjectDescriptor() { - return classObjectDescriptor; + return defaultObjectDescriptor; } @NotNull @@ -306,8 +306,8 @@ public class MutableClassDescriptor extends ClassDescriptorBase implements Class public void lockScopes() { getScopeForMemberLookupAsWritableScope().changeLockLevel(WritableScope.LockLevel.READING); - if (classObjectDescriptor != null) { - classObjectDescriptor.lockScopes(); + if (defaultObjectDescriptor != null) { + defaultObjectDescriptor.lockScopes(); } scopeForSupertypeResolution.changeLockLevel(WritableScope.LockLevel.READING); scopeForMemberResolution.changeLockLevel(WritableScope.LockLevel.READING); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index afa0addce27..40b7d0f7004 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -186,10 +186,10 @@ public interface Errors { DiagnosticFactory1 ENUM_ENTRY_ILLEGAL_TYPE = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 LOCAL_ENUM_NOT_ALLOWED = DiagnosticFactory1.create(ERROR, DECLARATION_NAME); - // Class objects + // Default objects - DiagnosticFactory0 MANY_CLASS_OBJECTS = DiagnosticFactory0.create(ERROR); - DiagnosticFactory0 CLASS_OBJECT_NOT_ALLOWED = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 MANY_DEFAULT_OBJECTS = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 DEFAULT_OBJECT_NOT_ALLOWED = DiagnosticFactory0.create(ERROR); // Objects @@ -198,12 +198,12 @@ public interface Errors { // Type parameter declarations DiagnosticFactory1 FINAL_UPPER_BOUND = DiagnosticFactory1.create(WARNING); - DiagnosticFactory1 FINAL_CLASS_OBJECT_UPPER_BOUND = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 FINAL_DEFAULT_OBJECT_UPPER_BOUND = DiagnosticFactory1.create(ERROR); DiagnosticFactory0 DYNAMIC_UPPER_BOUND = DiagnosticFactory0.create(ERROR); DiagnosticFactory1 CONFLICTING_UPPER_BOUNDS = DiagnosticFactory1.create(ERROR, DECLARATION_NAME); - DiagnosticFactory1 CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS + DiagnosticFactory1 CONFLICTING_DEFAULT_OBJECT_UPPER_BOUNDS = DiagnosticFactory1.create(ERROR, DECLARATION_NAME); DiagnosticFactory2 NAME_IN_CONSTRAINT_IS_NOT_A_TYPE_PARAMETER = @@ -605,7 +605,7 @@ public interface Errors { DiagnosticFactory0 NO_THIS = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 PACKAGE_IS_NOT_AN_EXPRESSION = DiagnosticFactory0.create(ERROR); - DiagnosticFactory1 NO_CLASS_OBJECT = DiagnosticFactory1.create(ERROR); + DiagnosticFactory1 NO_DEFAULT_OBJECT = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 TYPE_PARAMETER_IS_NOT_AN_EXPRESSION = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 TYPE_PARAMETER_ON_LHS_OF_DOT = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE = DiagnosticFactory1.create(ERROR); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index bb3923af581..799e7e957e9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -270,8 +270,8 @@ public class DefaultErrorMessages { MAP.put(UNREACHABLE_CODE, "Unreachable code", TO_STRING); - MAP.put(MANY_CLASS_OBJECTS, "Only one class object is allowed per class"); - MAP.put(CLASS_OBJECT_NOT_ALLOWED, "A class object is not allowed here"); + MAP.put(MANY_DEFAULT_OBJECTS, "Only one default object is allowed per class"); + MAP.put(DEFAULT_OBJECT_NOT_ALLOWED, "A default object is not allowed here"); MAP.put(LOCAL_OBJECT_NOT_ALLOWED, "Named object ''{0}'' is a singleton and cannot be local. Try to use anonymous object instead", NAME); MAP.put(LOCAL_ENUM_NOT_ALLOWED, "Enum class ''{0}'' cannot be local", NAME); MAP.put(DELEGATION_IN_TRAIT, "Traits cannot use delegation"); @@ -315,9 +315,9 @@ public class DefaultErrorMessages { MAP.put(USELESS_NULLABLE_CHECK, "Non-null type is checked for instance of nullable type"); MAP.put(WRONG_SETTER_PARAMETER_TYPE, "Setter parameter type must be equal to the type of the property, i.e. ''{0}''", RENDER_TYPE, RENDER_TYPE); MAP.put(WRONG_GETTER_RETURN_TYPE, "Getter return type must be equal to the type of the property, i.e. ''{0}''", RENDER_TYPE, RENDER_TYPE); - MAP.put(NO_CLASS_OBJECT, "Please specify constructor invocation; classifier ''{0}'' does not have a class object", NAME); + MAP.put(NO_DEFAULT_OBJECT, "Please specify constructor invocation; classifier ''{0}'' does not have a default object", NAME); MAP.put(TYPE_PARAMETER_IS_NOT_AN_EXPRESSION, "Type parameter ''{0}'' is not an expression", NAME); - MAP.put(TYPE_PARAMETER_ON_LHS_OF_DOT, "Type parameter ''{0}'' cannot have or inherit a class object, so it cannot be on the left hand side of dot", NAME); + MAP.put(TYPE_PARAMETER_ON_LHS_OF_DOT, "Type parameter ''{0}'' cannot have or inherit a default object, so it cannot be on the left hand side of dot", NAME); MAP.put(NO_GENERICS_IN_SUPERTYPE_SPECIFIER, "Generic arguments of the base type must be specified"); MAP.put(NESTED_CLASS_ACCESSED_VIA_INSTANCE_REFERENCE, "Nested {0} accessed via instance reference", RENDER_CLASS_OR_OBJECT_NAME); MAP.put(NESTED_CLASS_SHOULD_BE_QUALIFIED, "Nested {0} should be qualified as ''{1}''", RENDER_CLASS_OR_OBJECT_NAME, TO_STRING); @@ -375,12 +375,12 @@ public class DefaultErrorMessages { }); MAP.put(UPPER_BOUND_VIOLATED, "Type argument is not within its bounds: should be subtype of ''{0}''", RENDER_TYPE, RENDER_TYPE); - MAP.put(FINAL_CLASS_OBJECT_UPPER_BOUND, "''{0}'' is a final type, and thus a class object cannot extend it", RENDER_TYPE); + MAP.put(FINAL_DEFAULT_OBJECT_UPPER_BOUND, "''{0}'' is a final type, and thus a default object cannot extend it", RENDER_TYPE); MAP.put(FINAL_UPPER_BOUND, "''{0}'' is a final type, and thus a value of the type parameter is predetermined", RENDER_TYPE); MAP.put(DYNAMIC_UPPER_BOUND, "Dynamic type can not be used as an upper bound"); MAP.put(USELESS_ELVIS, "Elvis operator (?:) always returns the left operand of non-nullable type {0}", RENDER_TYPE); MAP.put(CONFLICTING_UPPER_BOUNDS, "Upper bounds of {0} have empty intersection", NAME); - MAP.put(CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS, "Class object upper bounds of {0} have empty intersection", NAME); + MAP.put(CONFLICTING_DEFAULT_OBJECT_UPPER_BOUNDS, "Default object upper bounds of {0} have empty intersection", NAME); MAP.put(TOO_MANY_ARGUMENTS, "Too many arguments for {0}", FQ_NAMES_IN_TYPES); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java index 38a9b6700d4..a0bcbd0eb98 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/parsing/JetParsing.java @@ -765,7 +765,7 @@ public class JetParsing extends AbstractJetParsing { * ; * * memberDeclaration' - * : classObject + * : defaultObject * : constructor * : function * : property @@ -798,7 +798,7 @@ public class JetParsing extends AbstractJetParsing { IElementType declType = null; if (keywordToken == CLASS_KEYWORD) { if (lookahead(1) == OBJECT_KEYWORD) { - declType = parseClassObject(); + declType = parseDefaultObject(); } else { declType = parseClass(isEnum); @@ -876,11 +876,11 @@ public class JetParsing extends AbstractJetParsing { } /* - * classObject + * defaultObject * : modifiers "class" object * ; */ - private IElementType parseClassObject() { + private IElementType parseDefaultObject() { assert _at(CLASS_KEYWORD) && lookahead(1) == OBJECT_KEYWORD; advance(); // CLASS_KEYWORD parseObject(NameParsingMode.ALLOWED, true); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/DebugTextUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/DebugTextUtil.kt index 41d76c6ac57..8875ed64669 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/psi/DebugTextUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/DebugTextUtil.kt @@ -237,7 +237,7 @@ private object DebugTextBuildingVisitor : JetVisitor() { return buildText { append("STUB: ") appendInn(declaration.getModifierList(), suffix = " ") - if (declaration.isClassObject()) { + if (declaration.isDefault()) { append("class ") } append("object ") @@ -273,7 +273,7 @@ private object DebugTextBuildingVisitor : JetVisitor() { override fun visitTypeConstraint(constraint: JetTypeConstraint, data: Unit?): String? { return buildText { - if (constraint.isClassObjectConstraint()) { + if (constraint.isDefaultObjectConstraint()) { append("class object ") } appendInn(constraint.getSubjectTypeParameterName()) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClass.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClass.java index f39b07909eb..3f6d3a6b99d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClass.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClass.java @@ -142,10 +142,10 @@ public class JetClass extends JetTypeParameterListOwnerStub imp } @Nullable - public JetObjectDeclaration getClassObject() { + public JetObjectDeclaration getDefaultObject() { JetClassBody body = getBody(); if (body == null) return null; - return body.getClassObject(); + return body.getDefaultObject(); } public List getProperties() { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassBody.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassBody.java index 07f8a0767c6..0cb5eba20f1 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassBody.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassBody.java @@ -67,15 +67,15 @@ public class JetClassBody extends JetElementImplStub getAllClassObjects() { + public List getAllDefaultObjects() { List result = Lists.newArrayList(); for (JetObjectDeclaration declaration : getStubOrPsiChildrenAsList(JetStubElementTypes.OBJECT_DECLARATION)) { - if (declaration.isClassObject()) { + if (declaration.isDefault()) { result.add(declaration); } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclarationStub.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclarationStub.java index d486dc6b88c..72a73344aa9 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclarationStub.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetNamedDeclarationStub.java @@ -95,10 +95,10 @@ abstract class JetNamedDeclarationStub extends J if (hasModifier(JetTokens.PRIVATE_KEYWORD)) { JetElement containingClass = PsiTreeUtil.getParentOfType(this, JetClassOrObject.class); - if (containingClass instanceof JetObjectDeclaration && ((JetObjectDeclaration) containingClass).isClassObject()) { - JetElement classObjectClass = PsiTreeUtil.getParentOfType(containingClass, JetClassOrObject.class); - if (classObjectClass != null) { - containingClass = classObjectClass; + if (containingClass instanceof JetObjectDeclaration && ((JetObjectDeclaration) containingClass).isDefault()) { + JetElement defaultObjectClass = PsiTreeUtil.getParentOfType(containingClass, JetClassOrObject.class); + if (defaultObjectClass != null) { + containingClass = defaultObjectClass; } } if (containingClass != null) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclaration.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclaration.java index 5d5e6b3593a..a6dd477701d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclaration.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetObjectDeclaration.java @@ -51,7 +51,7 @@ public class JetObjectDeclaration extends JetNamedDeclarationStub { } public trait KotlinObjectStub : KotlinClassOrObjectStub { - public fun isClassObject(): Boolean + public fun isDefault(): Boolean public fun isObjectLiteral(): Boolean } @@ -104,7 +104,7 @@ public trait KotlinPropertyStub : KotlinStubWithFqName { } public trait KotlinTypeConstraintStub : StubElement { - public fun isClassObjectConstraint(): Boolean + public fun isDefaultObjectConstraint(): Boolean } public trait KotlinTypeParameterStub : KotlinStubWithFqName { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetObjectElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetObjectElementType.java index 82cd27d33a4..f088e54ff8d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetObjectElementType.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetObjectElementType.java @@ -45,7 +45,7 @@ public class JetObjectElementType extends JetStubElementType superNames = PsiUtilPackage.getSuperNames(psi); return new KotlinObjectStubImpl(parentStub, StringRef.fromString(name), fqName, Utils.INSTANCE$.wrapStrings(superNames), - psi.isTopLevel(), psi.isClassObject(), psi.isLocal(), psi.isObjectLiteral()); + psi.isTopLevel(), psi.isDefault(), psi.isLocal(), psi.isObjectLiteral()); } @Override @@ -56,7 +56,7 @@ public class JetObjectElementType extends JetStubElementType, private val isTopLevel: Boolean, - private val isClassObject: Boolean, + private val isDefault: Boolean, private val isLocal: Boolean, private val isObjectLiteral: Boolean ) : KotlinStubBaseImpl(parent, JetStubElementTypes.OBJECT_DECLARATION), KotlinObjectStub { @@ -39,7 +39,7 @@ public class KotlinObjectStubImpl( override fun getName() = StringRef.toString(name) override fun getSuperNames() = superNames map { it.toString() } override fun isTopLevel() = isTopLevel - override fun isClassObject() = isClassObject + override fun isDefault() = isDefault override fun isObjectLiteral() = isObjectLiteral override fun isLocal() = isLocal } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinTypeConstraintStubImpl.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinTypeConstraintStubImpl.kt index 39e1126fab2..d6d9e92a726 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinTypeConstraintStubImpl.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/impl/KotlinTypeConstraintStubImpl.kt @@ -24,8 +24,8 @@ import com.intellij.psi.PsiElement public class KotlinTypeConstraintStubImpl( parent: StubElement?, - private val isClassObjectConstraint: Boolean + private val isDefaultObjectConstraint: Boolean ) : KotlinStubBaseImpl(parent, JetStubElementTypes.TYPE_CONSTRAINT), KotlinTypeConstraintStub { - override fun isClassObjectConstraint() = isClassObjectConstraint + override fun isDefaultObjectConstraint() = isDefaultObjectConstraint } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt index 2c563191be5..2fea4a6d972 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt @@ -38,7 +38,7 @@ public fun DeclarationDescriptor.hasIntrinsicAnnotation(): Boolean { public fun CallableDescriptor.isPlatformStaticInObjectOrClass(): Boolean = isPlatformStaticIn(ClassKind.OBJECT, ClassKind.CLASS) -public fun CallableDescriptor.isPlatformStaticInClassObject(): Boolean = +public fun CallableDescriptor.isPlatformStaticInDefaultObject(): Boolean = isPlatformStaticIn(ClassKind.CLASS_OBJECT) private fun CallableDescriptor.isPlatformStaticIn(vararg kinds: ClassKind): Boolean = diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt index 8e4ed4fbdc8..10009b3e5ca 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt @@ -61,16 +61,16 @@ public class DeclarationResolver { public fun checkRedeclarationsInInnerClassNames(c: TopDownAnalysisContext) { for (classDescriptor in c.getDeclaredClasses().values()) { if (classDescriptor.getKind() == ClassKind.CLASS_OBJECT) { - // Class objects should be considered during analysing redeclarations in classes + // Default objects should be considered during analysing redeclarations in classes continue } var allDescriptors = classDescriptor.getScopeForMemberLookup().getOwnDeclaredDescriptors() - val classObj = classDescriptor.getDefaultObjectDescriptor() - if (classObj != null) { - val classObjDescriptors = classObj.getScopeForMemberLookup().getOwnDeclaredDescriptors() - if (classObjDescriptors.isNotEmpty()) { - allDescriptors = allDescriptors + classObjDescriptors + val defaultObject = classDescriptor.getDefaultObjectDescriptor() + if (defaultObject != null) { + val descriptorsFromDefaultObject = defaultObject.getScopeForMemberLookup().getOwnDeclaredDescriptors() + if (descriptorsFromDefaultObject.isNotEmpty()) { + allDescriptors = allDescriptors + descriptorsFromDefaultObject } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java index 723bc3fe4fd..8f62acb23e2 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java @@ -154,7 +154,7 @@ public class DeclarationsChecker { for (JetTypeConstraint constraint : jetClass.getTypeConstraints()) { checkBoundsForTypeInClassHeader(constraint.getBoundTypeReference()); - checkFinalUpperBounds(constraint.getBoundTypeReference(), constraint.isClassObjectConstraint()); + checkFinalUpperBounds(constraint.getBoundTypeReference(), constraint.isDefaultObjectConstraint()); } } @@ -167,11 +167,11 @@ public class DeclarationsChecker { } } - private void checkFinalUpperBounds(@Nullable JetTypeReference typeReference, boolean isClassObjectConstraint) { + private void checkFinalUpperBounds(@Nullable JetTypeReference typeReference, boolean isDefaultObjectConstraint) { if (typeReference != null) { JetType type = trace.getBindingContext().get(TYPE, typeReference); if (type != null) { - DescriptorResolver.checkUpperBoundType(typeReference, type, isClassObjectConstraint, trace); + DescriptorResolver.checkUpperBoundType(typeReference, type, isDefaultObjectConstraint, trace); } } } @@ -260,7 +260,7 @@ public class DeclarationsChecker { private void checkObject(JetObjectDeclaration declaration, ClassDescriptor classDescriptor) { reportErrorIfHasIllegalModifier(declaration); - if (declaration.isLocal() && !declaration.isClassObject() && !declaration.isObjectLiteral()) { + if (declaration.isLocal() && !declaration.isDefault() && !declaration.isObjectLiteral()) { trace.report(LOCAL_OBJECT_NOT_ALLOWED.on(declaration, classDescriptor)); } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java index cc46e16b79f..1f91bb75257 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java @@ -651,12 +651,12 @@ public class DescriptorResolver { static final class UpperBoundCheckerTask { JetTypeReference upperBound; JetType upperBoundType; - boolean isClassObjectConstraint; + boolean isDefaultObjectConstraint; - private UpperBoundCheckerTask(JetTypeReference upperBound, JetType upperBoundType, boolean classObjectConstraint) { + private UpperBoundCheckerTask(JetTypeReference upperBound, JetType upperBoundType, boolean defaultObjectConstraint) { this.upperBound = upperBound; this.upperBoundType = upperBoundType; - isClassObjectConstraint = classObjectConstraint; + isDefaultObjectConstraint = defaultObjectConstraint; } } @@ -685,7 +685,7 @@ public class DescriptorResolver { } } for (JetTypeConstraint constraint : declaration.getTypeConstraints()) { - reportUnsupportedClassObjectConstraint(trace, constraint); + reportUnsupportedDefaultObjectConstraint(trace, constraint); JetSimpleNameExpression subjectTypeParameterName = constraint.getSubjectTypeParameterName(); if (subjectTypeParameterName == null) { @@ -698,15 +698,14 @@ public class DescriptorResolver { if (boundTypeReference != null) { bound = typeResolver.resolveType(scope, boundTypeReference, trace, false); deferredUpperBoundCheckerTasks - .add(new UpperBoundCheckerTask(boundTypeReference, bound, constraint.isClassObjectConstraint())); + .add(new UpperBoundCheckerTask(boundTypeReference, bound, constraint.isDefaultObjectConstraint())); } if (typeParameterDescriptor != null) { trace.record(BindingContext.REFERENCE_TARGET, subjectTypeParameterName, typeParameterDescriptor); if (bound != null) { - if (constraint.isClassObjectConstraint()) { - // Class object bounds are not supported - //typeParameterDescriptor.addClassObjectBound(bound); + if (constraint.isDefaultObjectConstraint()) { + // Default object bounds are not supported } else { typeParameterDescriptor.addUpperBound(bound); @@ -725,7 +724,7 @@ public class DescriptorResolver { if (!(declaration instanceof JetClass)) { for (UpperBoundCheckerTask checkerTask : deferredUpperBoundCheckerTasks) { - checkUpperBoundType(checkerTask.upperBound, checkerTask.upperBoundType, checkerTask.isClassObjectConstraint, trace); + checkUpperBoundType(checkerTask.upperBound, checkerTask.upperBoundType, checkerTask.isDefaultObjectConstraint, trace); } checkNamesInConstraints(declaration, descriptor, scope, trace); @@ -743,7 +742,7 @@ public class DescriptorResolver { JetType classObjectType = parameter.getClassObjectType(); if (classObjectType != null && KotlinBuiltIns.isNothing(classObjectType)) { - trace.report(CONFLICTING_CLASS_OBJECT_UPPER_BOUNDS.on(typeParameter, parameter)); + trace.report(CONFLICTING_DEFAULT_OBJECT_UPPER_BOUNDS.on(typeParameter, parameter)); } } @@ -778,21 +777,21 @@ public class DescriptorResolver { } } - public static void reportUnsupportedClassObjectConstraint(BindingTrace trace, JetTypeConstraint constraint) { - if (constraint.isClassObjectConstraint()) { - trace.report(UNSUPPORTED.on(constraint, "Class objects constraints are not supported yet")); + public static void reportUnsupportedDefaultObjectConstraint(BindingTrace trace, JetTypeConstraint constraint) { + if (constraint.isDefaultObjectConstraint()) { + trace.report(UNSUPPORTED.on(constraint, "Default objects constraints are not supported yet")); } } public static void checkUpperBoundType( JetTypeReference upperBound, @NotNull JetType upperBoundType, - boolean isClassObjectConstraint, + boolean isDefaultObjectConstraint, BindingTrace trace ) { if (!TypeUtils.canHaveSubtypes(JetTypeChecker.DEFAULT, upperBoundType)) { - if (isClassObjectConstraint) { - trace.report(FINAL_CLASS_OBJECT_UPPER_BOUND.on(upperBound, upperBoundType)); + if (isDefaultObjectConstraint) { + trace.report(FINAL_DEFAULT_OBJECT_UPPER_BOUND.on(upperBound, upperBoundType)); } else { trace.report(FINAL_UPPER_BOUND.on(upperBound, upperBoundType)); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.java index 693f2922819..b533bc5c586 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/LazyTopDownAnalyzer.java @@ -36,7 +36,7 @@ import java.util.ArrayList; import java.util.Collection; import java.util.List; -import static org.jetbrains.kotlin.diagnostics.Errors.MANY_CLASS_OBJECTS; +import static org.jetbrains.kotlin.diagnostics.Errors.MANY_DEFAULT_OBJECTS; import static org.jetbrains.kotlin.diagnostics.Errors.UNSUPPORTED; public class LazyTopDownAnalyzer { @@ -191,19 +191,19 @@ public class LazyTopDownAnalyzer { registerDeclarations(classOrObject.getDeclarations()); registerTopLevelFqName(topLevelFqNames, classOrObject, descriptor); - checkManyClassObjects(classOrObject); + checkManyDefaultObjects(classOrObject); } - private void checkManyClassObjects(JetClassOrObject classOrObject) { - boolean classObjectAlreadyFound = false; + private void checkManyDefaultObjects(JetClassOrObject classOrObject) { + boolean defaultObjectAlreadyFound = false; for (JetDeclaration jetDeclaration : classOrObject.getDeclarations()) { jetDeclaration.accept(this); - if (jetDeclaration instanceof JetObjectDeclaration && ((JetObjectDeclaration) jetDeclaration).isClassObject()) { - if (classObjectAlreadyFound) { - trace.report(MANY_CLASS_OBJECTS.on((JetObjectDeclaration) jetDeclaration)); + if (jetDeclaration instanceof JetObjectDeclaration && ((JetObjectDeclaration) jetDeclaration).isDefault()) { + if (defaultObjectAlreadyFound) { + trace.report(MANY_DEFAULT_OBJECTS.on((JetObjectDeclaration) jetDeclaration)); } - classObjectAlreadyFound = true; + defaultObjectAlreadyFound = true; } } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java index 87e5a93e96f..410f381ea34 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.java @@ -243,7 +243,7 @@ public class ModifiersChecker { if (DescriptorUtils.isTrait(containingDeclaration)) { return InnerModifierCheckResult.IN_TRAIT; } - else if (DescriptorUtils.isClassObject(containingDeclaration) || DescriptorUtils.isObject(containingDeclaration)) { + else if (DescriptorUtils.isDefaultObject(containingDeclaration) || DescriptorUtils.isObject(containingDeclaration)) { return InnerModifierCheckResult.IN_OBJECT; } else { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java index 5c975ef392a..5bea75b891e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.java @@ -121,7 +121,7 @@ public class OverloadResolver { return name; } if (jetClass instanceof JetObjectDeclaration) { - // must be class object + // must be default object name = classDescriptor.getContainingDeclaration().getName().asString(); return "class object " + name; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/FakeCallableDescriptorForObject.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/FakeCallableDescriptorForObject.kt index 49152690123..0d305ab1c24 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/FakeCallableDescriptorForObject.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/util/FakeCallableDescriptorForObject.kt @@ -35,7 +35,7 @@ public class FakeCallableDescriptorForObject( { assert(classDescriptor.getClassObjectType() != null) { - "FakeCallableDescriptorForObject can be created only for objects, classes with class object or enum entries: $classDescriptor" + "FakeCallableDescriptorForObject can be created only for objects, classes with default object or enum entries: $classDescriptor" } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt index acd24535f49..a0dcb8bd692 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/constants/evaluate/ConstantExpressionEvaluator.kt @@ -49,7 +49,7 @@ public class ConstantExpressionEvaluator private (val trace: BindingTrace) : Jet return false } if (DescriptorUtils.isObject(descriptor.getContainingDeclaration()) || - DescriptorUtils.isClassObject(descriptor.getContainingDeclaration()) || + DescriptorUtils.isDefaultObject(descriptor.getContainingDeclaration()) || DescriptorUtils.isStaticDeclaration(descriptor)) { val returnType = descriptor.getType() return KotlinBuiltIns.isPrimitiveType(returnType) || KotlinBuiltIns.isString(returnType) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfo.java index a4028be5141..e4728414135 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfo.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassInfo.java @@ -46,8 +46,8 @@ public class JetClassInfo extends JetClassOrObjectInfo { } @Override - public JetObjectDeclaration getClassObject() { - return element.getClassObject(); + public JetObjectDeclaration getDefaultObject() { + return element.getDefaultObject(); } @Nullable diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassLikeInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassLikeInfo.java index 9c10c34b58d..e88c8378e29 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassLikeInfo.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassLikeInfo.java @@ -34,11 +34,11 @@ public interface JetClassLikeInfo extends JetDeclarationContainer { JetModifierList getModifierList(); @Nullable - JetObjectDeclaration getClassObject(); + JetObjectDeclaration getDefaultObject(); @NotNull @ReadOnly - List getClassObjects(); + List getDefaultObjects(); // This element is used to identify resolution scope for the class @NotNull diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassOrObjectInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassOrObjectInfo.java index 93e12041d6b..da31d9c041a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassOrObjectInfo.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetClassOrObjectInfo.java @@ -58,12 +58,12 @@ public abstract class JetClassOrObjectInfo implement @NotNull @Override - public List getClassObjects() { + public List getDefaultObjects() { JetClassBody body = element.getBody(); if (body == null) { return Collections.emptyList(); } - return body.getAllClassObjects(); + return body.getAllDefaultObjects(); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetObjectInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetObjectInfo.java index 60266d5046e..3903b1b37b3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetObjectInfo.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetObjectInfo.java @@ -34,11 +34,11 @@ public class JetObjectInfo extends JetClassOrObjectInfo { super(element); this.kind = element.isObjectLiteral() ? ClassKind.CLASS - : (element.isClassObject() ? ClassKind.CLASS_OBJECT : ClassKind.OBJECT); + : (element.isDefault() ? ClassKind.CLASS_OBJECT : ClassKind.OBJECT); } @Override - public JetObjectDeclaration getClassObject() { + public JetObjectDeclaration getDefaultObject() { return null; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetScriptInfo.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetScriptInfo.kt index 9e023b41655..8bcd21a4c4f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetScriptInfo.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/data/JetScriptInfo.kt @@ -27,8 +27,8 @@ public class JetScriptInfo( public val fqName: FqName = ScriptNameUtil.classNameForScript(script) override fun getContainingPackageFqName() = fqName.parent() override fun getModifierList() = null - override fun getClassObject() = null - override fun getClassObjects() = listOf() + override fun getDefaultObject() = null + override fun getDefaultObjects() = listOf() override fun getScopeAnchor() = script override fun getCorrespondingClassOrObject() = null override fun getTypeParameterList() = null diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java index 54dbdb08454..fe6449d514c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java @@ -81,8 +81,8 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes private final Annotations annotations; private final Annotations danglingAnnotations; - private final NullableLazyValue classObjectDescriptor; - private final MemoizedFunctionToNotNull extraClassObjectDescriptors; + private final NullableLazyValue defaultObjectDescriptor; + private final MemoizedFunctionToNotNull extraDefaultObjectDescriptors; private final LazyClassMemberScope unsubstitutedMemberScope; private final JetScope staticScope = new StaticScopeForKotlinClass(this); @@ -177,16 +177,16 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes ); } - this.classObjectDescriptor = storageManager.createNullableLazyValue(new Function0() { + this.defaultObjectDescriptor = storageManager.createNullableLazyValue(new Function0() { @Override public LazyClassDescriptor invoke() { - return computeClassObjectDescriptor(getClassObjectIfAllowed()); + return computeDefaultObjectDescriptor(getDefaultObjectIfAllowed()); } }); - this.extraClassObjectDescriptors = storageManager.createMemoizedFunction(new Function1() { + this.extraDefaultObjectDescriptors = storageManager.createMemoizedFunction(new Function1() { @Override - public ClassDescriptor invoke(JetObjectDeclaration classObject) { - return computeClassObjectDescriptor(classObject); + public ClassDescriptor invoke(JetObjectDeclaration defaultObject) { + return computeDefaultObjectDescriptor(defaultObject); } }); this.scopeForClassHeaderResolution = storageManager.createLazyValue(new Function0() { @@ -266,8 +266,8 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes thisScope.setImplicitReceiver(this.getThisAsReceiverParameter()); thisScope.changeLockLevel(WritableScope.LockLevel.READING); - ClassDescriptor classObject = getDefaultObjectDescriptor(); - JetScope classObjectAdapterScope = (classObject != null) ? new ClassObjectMixinScope(classObject) : JetScope.Empty.INSTANCE$; + ClassDescriptor defaultObjectDescriptor = getDefaultObjectDescriptor(); + JetScope defaultObjectAdapterScope = (defaultObjectDescriptor != null) ? new DefaultObjectMixinScope(defaultObjectDescriptor) : JetScope.Empty.INSTANCE$; return new ChainedScope( this, @@ -275,7 +275,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes thisScope, getScopeForMemberLookup(), getScopeForClassHeaderResolution(), - classObjectAdapterScope, + defaultObjectAdapterScope, getStaticScope() ); } @@ -347,46 +347,46 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes @Override public LazyClassDescriptor getDefaultObjectDescriptor() { - return classObjectDescriptor.invoke(); + return defaultObjectDescriptor.invoke(); } @NotNull @ReadOnly - public List getDescriptorsForExtraClassObjects() { - final JetObjectDeclaration allowedClassObject = getClassObjectIfAllowed(); + public List getDescriptorsForExtraDefaultObjects() { + final JetObjectDeclaration allowedDefaultObject = getDefaultObjectIfAllowed(); return KotlinPackage.map( KotlinPackage.filter( - declarationProvider.getOwnerInfo().getClassObjects(), + declarationProvider.getOwnerInfo().getDefaultObjects(), new Function1() { @Override - public Boolean invoke(JetObjectDeclaration classObject) { - return classObject != allowedClassObject; + public Boolean invoke(JetObjectDeclaration defaultObject) { + return defaultObject != allowedDefaultObject; } } ), new Function1() { @Override - public ClassDescriptor invoke(JetObjectDeclaration classObject) { - return extraClassObjectDescriptors.invoke(classObject); + public ClassDescriptor invoke(JetObjectDeclaration defaultObject) { + return extraDefaultObjectDescriptors.invoke(defaultObject); } } ); } @Nullable - private LazyClassDescriptor computeClassObjectDescriptor(@Nullable JetObjectDeclaration classObject) { - JetClassLikeInfo classObjectInfo = getClassObjectInfo(classObject); - if (!(classObjectInfo instanceof JetClassOrObjectInfo)) { + private LazyClassDescriptor computeDefaultObjectDescriptor(@Nullable JetObjectDeclaration defaultObject) { + JetClassLikeInfo defaultObjectInfo = getDefaultObjectInfo(defaultObject); + if (!(defaultObjectInfo instanceof JetClassOrObjectInfo)) { return null; } - Name name = ((JetClassOrObjectInfo) classObjectInfo).getName(); + Name name = ((JetClassOrObjectInfo) defaultObjectInfo).getName(); assert name != null; getScopeForMemberLookup().getClassifier(name); - ClassDescriptor classObjectDescriptor = c.getTrace().get(BindingContext.CLASS, classObject); - if (classObjectDescriptor instanceof LazyClassDescriptor) { - assert DescriptorUtils.isClassObject(classObjectDescriptor) : "Not a class object: " + classObjectDescriptor; - return (LazyClassDescriptor) classObjectDescriptor; + ClassDescriptor defaultObjectDescriptor = c.getTrace().get(BindingContext.CLASS, defaultObject); + if (defaultObjectDescriptor instanceof LazyClassDescriptor) { + assert DescriptorUtils.isDefaultObject(defaultObjectDescriptor) : "Not a default object: " + defaultObjectDescriptor; + return (LazyClassDescriptor) defaultObjectDescriptor; } else { return null; @@ -394,25 +394,25 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes } @Nullable - private JetClassLikeInfo getClassObjectInfo(@Nullable JetObjectDeclaration classObject) { - if (classObject != null) { - if (!isClassObjectAllowed()) { - c.getTrace().report(CLASS_OBJECT_NOT_ALLOWED.on(classObject)); + private JetClassLikeInfo getDefaultObjectInfo(@Nullable JetObjectDeclaration defaultObject) { + if (defaultObject != null) { + if (!isDefaultObjectAllowed()) { + c.getTrace().report(DEFAULT_OBJECT_NOT_ALLOWED.on(defaultObject)); } - return JetClassInfoUtil.createClassLikeInfo(classObject); + return JetClassInfoUtil.createClassLikeInfo(defaultObject); } return null; } @Nullable - private JetObjectDeclaration getClassObjectIfAllowed() { - JetObjectDeclaration classObject = declarationProvider.getOwnerInfo().getClassObject(); - return (classObject != null && isClassObjectAllowed()) ? classObject : null; + private JetObjectDeclaration getDefaultObjectIfAllowed() { + JetObjectDeclaration defaultObject = declarationProvider.getOwnerInfo().getDefaultObject(); + return (defaultObject != null && isDefaultObjectAllowed()) ? defaultObject : null; } - private boolean isClassObjectAllowed() { + private boolean isDefaultObjectAllowed() { return !(getKind().isSingleton() || isInner() || DescriptorUtils.isLocal(this)); } @@ -463,13 +463,13 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes private void doForceResolveAllContents() { resolveMemberHeaders(); - ClassDescriptor classObjectDescriptor = getDefaultObjectDescriptor(); - if (classObjectDescriptor != null) { - ForceResolveUtil.forceResolveAllContents(classObjectDescriptor); + ClassDescriptor defaultObjectDescriptor = getDefaultObjectDescriptor(); + if (defaultObjectDescriptor != null) { + ForceResolveUtil.forceResolveAllContents(defaultObjectDescriptor); } ForceResolveUtil.forceResolveAllContents(getConstructors()); - ForceResolveUtil.forceResolveAllContents(getDescriptorsForExtraClassObjects()); + ForceResolveUtil.forceResolveAllContents(getDescriptorsForExtraDefaultObjects()); ForceResolveUtil.forceResolveAllContents(getScopeForMemberLookup()); ForceResolveUtil.forceResolveAllContents(getTypeConstructor()); } @@ -481,7 +481,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes getDefaultObjectDescriptor(); - getDescriptorsForExtraClassObjects(); + getDescriptorsForExtraDefaultObjects(); getClassObjectType(); getConstructors(); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt index 6149224b45d..9de2fb7d39d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt @@ -230,7 +230,7 @@ public open class LazyClassMemberScope( private fun generateDelegatingDescriptors(name: Name, extractor: MemberExtractor, existingDescriptors: Collection): Collection { val classOrObject = declarationProvider.getOwnerInfo().getCorrespondingClassOrObject() - ?: return setOf() // Enum class objects do not have delegated members + ?: return setOf() // Enum default objects do not have delegated members val lazyTypeResolver = DelegationResolver.TypeResolver { reference -> c.typeResolver.resolveType(thisDescriptor.getScopeForClassHeaderResolution(), reference, trace, false) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java index 9a62888cda9..3e570a50912 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java @@ -83,7 +83,7 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri if (classOrObject instanceof JetClass) { JetClass jetClass = (JetClass) classOrObject; for (JetTypeConstraint jetTypeConstraint : jetClass.getTypeConstraints()) { - DescriptorResolver.reportUnsupportedClassObjectConstraint(c.getTrace(), jetTypeConstraint); + DescriptorResolver.reportUnsupportedDefaultObjectConstraint(c.getTrace(), jetTypeConstraint); JetSimpleNameExpression constrainedParameterName = jetTypeConstraint.getSubjectTypeParameterName(); if (constrainedParameterName != null) { @@ -93,7 +93,7 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri JetTypeReference boundTypeReference = jetTypeConstraint.getBoundTypeReference(); if (boundTypeReference != null) { JetType boundType = resolveBoundType(boundTypeReference); - if (!jetTypeConstraint.isClassObjectConstraint()) { + if (!jetTypeConstraint.isDefaultObjectConstraint()) { upperBounds.add(boundType); } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/ClassObjectMixinScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/DefaultObjectMixinScope.kt similarity index 63% rename from compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/ClassObjectMixinScope.kt rename to compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/DefaultObjectMixinScope.kt index 33a15f4940f..c357388641a 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/ClassObjectMixinScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/DefaultObjectMixinScope.kt @@ -19,12 +19,12 @@ package org.jetbrains.kotlin.resolve.scopes import org.jetbrains.kotlin.descriptors.ClassDescriptor /** - * Members of the class object are accessible from the class. - * Scope lazily delegates requests to class object scope. + * Members of the default object are accessible from the class. + * Scope lazily delegates requests to default object scope. */ -public class ClassObjectMixinScope(private val classObjectDescriptor: ClassDescriptor) : AbstractScopeAdapter() { +public class DefaultObjectMixinScope(private val defaultObjectDescriptor: ClassDescriptor) : AbstractScopeAdapter() { override val workerScope: JetScope - get() = classObjectDescriptor.getDefaultType().getMemberScope() + get() = defaultObjectDescriptor.getDefaultType().getMemberScope() - override fun getImplicitReceiversHierarchy() = listOf(classObjectDescriptor.getThisAsReceiverParameter()) + override fun getImplicitReceiversHierarchy() = listOf(defaultObjectDescriptor.getThisAsReceiverParameter()) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/WritableScopeWithImports.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/WritableScopeWithImports.kt index f7cb1006e72..b5c42069a2f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/WritableScopeWithImports.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/WritableScopeWithImports.kt @@ -91,8 +91,8 @@ public abstract class WritableScopeWithImports(override val workerScope: JetScop protected open fun computeImplicitReceiversHierarchy(): List { val implicitReceiverHierarchy = Lists.newArrayList() // Imported scopes come with their receivers - // Example: class member resolution scope imports a scope of it's class object - // members of the class object must be able to find it as an implicit receiver + // Example: class member resolution scope imports a scope of it's default object + // members of the default object must be able to find it as an implicit receiver for (scope in getImports()) { implicitReceiverHierarchy.addAll(scope.getImplicitReceiversHierarchy()) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt index 7527f7caed8..262541df8e3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/scopes/receivers/Qualifier.kt @@ -129,7 +129,7 @@ private fun QualifierReceiver.resolveAsStandaloneExpression(context: ExpressionT context.trace.report(TYPE_PARAMETER_IS_NOT_AN_EXPRESSION.on(referenceExpression, classifier)) } else if (classifier is ClassDescriptor && classifier.getClassObjectType() == null) { - context.trace.report(NO_CLASS_OBJECT.on(referenceExpression, classifier)) + context.trace.report(NO_DEFAULT_OBJECT.on(referenceExpression, classifier)) } else if (packageView != null) { context.trace.report(EXPRESSION_EXPECTED_PACKAGE_FOUND.on(referenceExpression)) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt index 62487efe03f..8148a7b08f6 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt @@ -185,7 +185,7 @@ class DeclarationScopeProviderForLocalClassifierAnalyzer( } override fun getOuterDataFlowInfoForDeclaration(elementOfDeclaration: PsiElement): DataFlowInfo { - // nested (non-inner) classes and class objects are forbidden in local classes, so it's enough to be simply inside the class + // nested (non-inner) classes and default objects are forbidden in local classes, so it's enough to be simply inside the class if (localClassDescriptorManager.insideMyClass(elementOfDeclaration)) { return localClassDescriptorManager.expressionTypingContext.dataFlowInfo } diff --git a/compiler/testData/diagnostics/tests/MultipleBounds.kt b/compiler/testData/diagnostics/tests/MultipleBounds.kt index 6a8b1db31ba..764c78655ed 100644 --- a/compiler/testData/diagnostics/tests/MultipleBounds.kt +++ b/compiler/testData/diagnostics/tests/MultipleBounds.kt @@ -72,7 +72,7 @@ val t3 = test2(C()) class Test where - class object T : Foo, + class object T : Foo, class object T : A {} val x : Int = 0 \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/PackageInExpressionPosition.kt b/compiler/testData/diagnostics/tests/PackageInExpressionPosition.kt index f9160f181a8..5a331272c2a 100644 --- a/compiler/testData/diagnostics/tests/PackageInExpressionPosition.kt +++ b/compiler/testData/diagnostics/tests/PackageInExpressionPosition.kt @@ -3,24 +3,24 @@ package foo class X {} val s = java -val ss = System -val sss = X -val x = "${System}" +val ss = System +val sss = X +val x = "${System}" val xs = java.lang -val xss = java.lang.System -val xsss = foo.X +val xss = java.lang.System +val xsss = foo.X val xssss = foo -val f = { System } +val f = { System } fun main(args : Array) { java = null - System = null - System!! - java.lang.System = null - java.lang.System!! - System is Int + System = null + System!! + java.lang.System = null + java.lang.System!! + System is Int System() - (System) - @foo System - null in System -} + (System) + @foo System + null in System +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/classObjects/ClassObjects.kt b/compiler/testData/diagnostics/tests/classObjects/ClassObjects.kt index f5ade42c2bb..9d609c1a1aa 100644 --- a/compiler/testData/diagnostics/tests/classObjects/ClassObjects.kt +++ b/compiler/testData/diagnostics/tests/classObjects/ClassObjects.kt @@ -4,7 +4,7 @@ class A { class object { val x = 1 } - class object { + class object { val x = 1 } } @@ -13,10 +13,10 @@ class AA { class object { val x = 1 } - class object A { + class object A { val x = 1 } - class object AA { + class object AA { val x = 1 } } @@ -26,7 +26,7 @@ class B() { } object b { - class object { + class object { val x = 1 } // error } @@ -35,7 +35,7 @@ val a = A.x val c = B.x val d = b.x -val s = System // error +val s = System // error fun test() { System.out.println() java.lang.System.out.println() diff --git a/compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt b/compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt index 97f1c2db0f2..cc14658334f 100644 --- a/compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt +++ b/compiler/testData/diagnostics/tests/classObjects/InnerClassAccessThroughClassObject.kt @@ -28,7 +28,7 @@ object O { fun f() { A.c A.hashCode() - A().Nested + A().Nested A.Nested() A().Inner() A.Default.Nested diff --git a/compiler/testData/diagnostics/tests/classObjects/InnerClassClassObject.kt b/compiler/testData/diagnostics/tests/classObjects/InnerClassClassObject.kt index 51123e469b7..bea2ada539e 100644 --- a/compiler/testData/diagnostics/tests/classObjects/InnerClassClassObject.kt +++ b/compiler/testData/diagnostics/tests/classObjects/InnerClassClassObject.kt @@ -2,7 +2,7 @@ class A { inner class B { - class object { } + class object { } } } @@ -22,4 +22,4 @@ class C { class D { class object { } } -} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/classObjects/classObjectInLocalClass.kt b/compiler/testData/diagnostics/tests/classObjects/classObjectInLocalClass.kt index 775c2993c54..cb070ed3a3f 100644 --- a/compiler/testData/diagnostics/tests/classObjects/classObjectInLocalClass.kt +++ b/compiler/testData/diagnostics/tests/classObjects/classObjectInLocalClass.kt @@ -1,9 +1,9 @@ fun test() { class A { - class object {} + class object {} } object { - class object {} + class object {} } } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt b/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt index 580ec466fe8..ce5be2a6be0 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.kt @@ -1,4 +1,4 @@ -// !DIAGNOSTICS: -MANY_CLASS_OBJECTS -REDECLARATION +// !DIAGNOSTICS: -MANY_DEFAULT_OBJECTS -REDECLARATION // KT-3464 Front-end shouldn't allow override modifier in class declaration diff --git a/compiler/testData/diagnostics/tests/enum/enumEntryCannotHaveClassObject.kt b/compiler/testData/diagnostics/tests/enum/enumEntryCannotHaveClassObject.kt index 4a739758612..3286a9be55e 100644 --- a/compiler/testData/diagnostics/tests/enum/enumEntryCannotHaveClassObject.kt +++ b/compiler/testData/diagnostics/tests/enum/enumEntryCannotHaveClassObject.kt @@ -2,7 +2,7 @@ enum class E { FIRST SECOND { - class object { + class object { fun foo() = 42 } } diff --git a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.kt b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.kt index d5c89647e53..24cf0984f91 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/arrayExpression.kt @@ -1,5 +1,5 @@ package bar fun main(args : Array) { - String[] names = ["ads"] + String[] names = ["ads"] } \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/inner/deepInnerClass.kt b/compiler/testData/diagnostics/tests/inner/deepInnerClass.kt index 809b5f75c79..ad3d39ebd75 100644 --- a/compiler/testData/diagnostics/tests/inner/deepInnerClass.kt +++ b/compiler/testData/diagnostics/tests/inner/deepInnerClass.kt @@ -4,11 +4,11 @@ class A { class B { fun test() { class C() : PT> { - class object : P<W, T> { + class object : P<W, T> { } inner class D : PT> } } } -} +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/regressions/kt2956.kt b/compiler/testData/diagnostics/tests/regressions/kt2956.kt index 1b2de021183..3cf659d35ca 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt2956.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt2956.kt @@ -1 +1 @@ -val a: String = Nothing \ No newline at end of file +val a: String = Nothing \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/regressions/kt4827.kt b/compiler/testData/diagnostics/tests/regressions/kt4827.kt index 6285a8b89a7..5b5a3fb7040 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt4827.kt +++ b/compiler/testData/diagnostics/tests/regressions/kt4827.kt @@ -11,6 +11,6 @@ class C { } fun f() { - TestInterface() + TestInterface() C.I() } \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ClassGenTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/ClassGenTest.java index b79b5e97eda..e3f60804352 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ClassGenTest.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ClassGenTest.java @@ -144,8 +144,8 @@ public class ClassGenTest extends CodegenTestCase { loadFile("classes/classObjectIsInnerClass.kt"); GeneratedClassLoader loader = generateAndCreateClassLoader(); Class a = loader.loadClass("A"); - Class aClassObject = loader.loadClass("A$" + SpecialNames.DEFAULT_NAME_FOR_DEFAULT_OBJECT.asString()); - assertSameElements(a.getDeclaredClasses(), aClassObject); - assertEquals(a, aClassObject.getDeclaringClass()); + Class defaultObject = loader.loadClass("A$" + SpecialNames.DEFAULT_NAME_FOR_DEFAULT_OBJECT.asString()); + assertSameElements(a.getDeclaredClasses(), defaultObject); + assertEquals(a, defaultObject.getDeclaringClass()); } } diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/InnerClassInfoGenTest.java b/compiler/tests/org/jetbrains/kotlin/codegen/InnerClassInfoGenTest.java index 5e0bf62fd69..704c660bf02 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/InnerClassInfoGenTest.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/InnerClassInfoGenTest.java @@ -44,14 +44,14 @@ public class InnerClassInfoGenTest extends CodegenTestCase { public void testInnerClassInfo() { InnerClassAttribute innerB = new InnerClassAttribute("A$B", "A", "B", ACC_PUBLIC | ACC_STATIC | ACC_FINAL); InnerClassAttribute innerC = new InnerClassAttribute("A$B$C", "A$B", "C", ACC_PUBLIC | ACC_FINAL); - String classObjectDefaultName = SpecialNames.DEFAULT_NAME_FOR_DEFAULT_OBJECT.asString(); - InnerClassAttribute innerAClassObject = new InnerClassAttribute( - "A$" + classObjectDefaultName, "A", classObjectDefaultName, ACC_PUBLIC | ACC_STATIC | ACC_FINAL); + String defaultObjectDefaultName = SpecialNames.DEFAULT_NAME_FOR_DEFAULT_OBJECT.asString(); + InnerClassAttribute innerADefaultObject = new InnerClassAttribute( + "A$" + defaultObjectDefaultName, "A", defaultObjectDefaultName, ACC_PUBLIC | ACC_STATIC | ACC_FINAL); - extractAndCompareInnerClasses("A", innerB, innerAClassObject); + extractAndCompareInnerClasses("A", innerB, innerADefaultObject); extractAndCompareInnerClasses("A$B", innerB, innerC); extractAndCompareInnerClasses("A$B$C", innerB, innerC); - extractAndCompareInnerClasses("A$" + classObjectDefaultName, innerAClassObject); + extractAndCompareInnerClasses("A$" + defaultObjectDefaultName, innerADefaultObject); } public void testLocalClass() { diff --git a/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java b/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java index ecc3bfe8cfe..e5b1a1cc1b7 100644 --- a/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java +++ b/compiler/tests/org/jetbrains/kotlin/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java @@ -75,7 +75,9 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix ClassDescriptor myClass = getClassDescriptor(testPackage, "MyClass"); checkDescriptor(expectedAnnotation, myClass); - checkDescriptor(expectedAnnotation, getClassObjectDescriptor(myClass)); + ClassDescriptor defaultObjectDescriptor = myClass.getDefaultObjectDescriptor(); + assert defaultObjectDescriptor != null : "Cannot find default object for class " + myClass.getName(); + checkDescriptor(expectedAnnotation, defaultObjectDescriptor); checkDescriptor(expectedAnnotation, getInnerClassDescriptor(myClass, "InnerClass")); FunctionDescriptor foo = getFunctionDescriptor(myClass, "foo"); @@ -199,13 +201,6 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix return (ClassDescriptor) aClass; } - @NotNull - private static ClassDescriptor getClassObjectDescriptor(@NotNull ClassDescriptor classDescriptor) { - ClassDescriptor objectDescriptor = classDescriptor.getDefaultObjectDescriptor(); - assert objectDescriptor != null : "Cannot find class object for class " + classDescriptor.getName(); - return objectDescriptor; - } - @NotNull private static ClassDescriptor getInnerClassDescriptor(@NotNull ClassDescriptor classDescriptor, @NotNull String name) { Name propertyName = Name.identifier(name); diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java index eae2cbb2ebd..d39d8d36684 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java @@ -46,7 +46,7 @@ public final class JvmAbi { //TODO: To be removed after kotlin M11 @Deprecated - public static final String DEPRECATED_CLASS_OBJECT_FIELD = "OBJECT$"; + public static final String DEPRECATED_DEFAULT_OBJECT_FIELD = "OBJECT$"; @NotNull public static String getSyntheticMethodNameForAnnotatedProperty(@NotNull Name propertyName) { diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt index 1576e2cdfec..d4ad3a0a1de 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/kotlin/AbstractBinaryClassAnnotationAndConstantLoader.kt @@ -159,7 +159,7 @@ public abstract class AbstractBinaryClassAnnotationAndConstantLoader> enumMemberNames; /** - * Creates and initializes descriptors for enum entry with the given name and its class object + * Creates and initializes descriptors for enum entry with the given name and its default object * @param enumMemberNames needed for fake overrides resolution */ @NotNull @@ -214,7 +214,7 @@ public class EnumEntrySyntheticClassDescriptor extends ClassDescriptorBase { @NotNull private JetScope getSupertypeScope() { Collection supertype = getTypeConstructor().getSupertypes(); - assert supertype.size() == 1 : "Enum entry and its class object both should have exactly one supertype: " + supertype; + assert supertype.size() == 1 : "Enum entry and its default object both should have exactly one supertype: " + supertype; return supertype.iterator().next().getMemberScope(); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.java b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.java index b29ca5bbf86..12bba7cdf4c 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.java +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.java @@ -53,13 +53,14 @@ public interface DescriptorRenderer extends Renderer { .setWithoutTypeParameters(true) .setWithoutFunctionParameterNames(true) .setReceiverAfterName(true) - .setRenderClassObjectName(true) + .setRenderDefaultObjectName(true) .setWithoutSuperTypes(true) .setStartFromName(true).build(); DescriptorRenderer FQ_NAMES_IN_TYPES = new DescriptorRendererBuilder().build(); - DescriptorRenderer SHORT_NAMES_IN_TYPES = new DescriptorRendererBuilder().setNameShortness(NameShortness.SHORT).setIncludeSynthesizedParameterNames(false).build(); + DescriptorRenderer SHORT_NAMES_IN_TYPES = new DescriptorRendererBuilder().setNameShortness( + NameShortness.SHORT).setIncludeSynthesizedParameterNames(false).build(); DescriptorRenderer DEBUG_TEXT = new DescriptorRendererBuilder() .setDebugMode(true) @@ -77,7 +78,7 @@ public interface DescriptorRenderer extends Renderer { DescriptorRenderer HTML_NAMES_WITH_SHORT_TYPES = new DescriptorRendererBuilder() .setWithDefinedIn(false) .setNameShortness(NameShortness.SHORT) - .setRenderClassObjectName(true) + .setRenderDefaultObjectName(true) .setTextFormat(TextFormat.HTML).build(); DescriptorRenderer HTML = new DescriptorRendererBuilder().setTextFormat(TextFormat.HTML).build(); diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererBuilder.java b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererBuilder.java index 1d3d473f5ee..30024827f14 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererBuilder.java +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererBuilder.java @@ -63,7 +63,7 @@ public class DescriptorRendererBuilder { @NotNull private Collection excludedAnnotationClasses = Collections.emptyList(); private boolean receiverAfterName = false; - private boolean renderClassObjectName = false; + private boolean renderDefaultObjectName = false; public DescriptorRendererBuilder() { } @@ -200,8 +200,8 @@ public class DescriptorRendererBuilder { } @NotNull - public DescriptorRendererBuilder setRenderClassObjectName(boolean renderClassObjectName) { - this.renderClassObjectName = renderClassObjectName; + public DescriptorRendererBuilder setRenderDefaultObjectName(boolean renderDefaultObjectName) { + this.renderDefaultObjectName = renderDefaultObjectName; return this; } @@ -234,7 +234,7 @@ public class DescriptorRendererBuilder { normalizedVisibilities, showInternalKeyword, prettyFunctionTypes, uninferredTypeParameterAsName, overrideRenderingPolicy, valueParametersHandler, textFormat, excludedAnnotationClasses, includePropertyConstant, includeSynthesizedParameterNames, withoutFunctionParameterNames, withoutTypeParameters, receiverAfterName, - renderClassObjectName, withoutSuperTypes, typeNormalizer, renderDefaultValues, flexibleTypesForCode); + renderDefaultObjectName, withoutSuperTypes, typeNormalizer, renderDefaultValues, flexibleTypesForCode); } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.java b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.java index c096b2d591a..acaea95211a 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.java @@ -62,7 +62,7 @@ public class DescriptorRendererImpl implements DescriptorRenderer { private final boolean includeSynthesizedParameterNames; private final boolean withoutFunctionParameterNames; private final boolean withoutTypeParameters; - private final boolean renderClassObjectName; + private final boolean renderDefaultObjectName; private final boolean withoutSuperTypes; private final boolean receiverAfterName; private final boolean renderDefaultValues; @@ -100,7 +100,7 @@ public class DescriptorRendererImpl implements DescriptorRenderer { boolean withoutFunctionParameterNames, boolean withoutTypeParameters, boolean receiverAfterName, - boolean renderClassObjectName, + boolean renderDefaultObjectName, boolean withoutSuperTypes, @NotNull Function1 typeNormalizer, boolean renderDefaultValues, @@ -127,7 +127,7 @@ public class DescriptorRendererImpl implements DescriptorRenderer { this.withoutFunctionParameterNames = withoutFunctionParameterNames; this.withoutTypeParameters = withoutTypeParameters; this.receiverAfterName = receiverAfterName; - this.renderClassObjectName = renderClassObjectName; + this.renderDefaultObjectName = renderDefaultObjectName; this.withoutSuperTypes = withoutSuperTypes; this.typeNormalizer = typeNormalizer; this.renderDefaultValues = renderDefaultValues; @@ -234,8 +234,8 @@ public class DescriptorRendererImpl implements DescriptorRenderer { builder.append(renderName(descriptor.getName())); } - private void renderClassObjectName(@NotNull DeclarationDescriptor descriptor, @NotNull StringBuilder builder) { - if (renderClassObjectName) { + private void renderDefaultObjectName(@NotNull DeclarationDescriptor descriptor, @NotNull StringBuilder builder) { + if (renderDefaultObjectName) { if (startFromName) { builder.append("class object"); } @@ -956,7 +956,7 @@ public class DescriptorRendererImpl implements DescriptorRenderer { renderName(klass, builder); } else { - renderClassObjectName(klass, builder); + renderDefaultObjectName(klass, builder); } List typeParameters = klass.getTypeConstructor().getParameters(); diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java index e84ee378e07..eb82dc962ca 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.java @@ -191,7 +191,7 @@ public class DescriptorUtils { public static ClassDescriptor getContainingClass(@NotNull DeclarationDescriptor descriptor) { DeclarationDescriptor containing = descriptor.getContainingDeclaration(); while (containing != null) { - if (containing instanceof ClassDescriptor && !isClassObject(containing)) { + if (containing instanceof ClassDescriptor && !isDefaultObject(containing)) { return (ClassDescriptor) containing; } containing = containing.getContainingDeclaration(); @@ -240,7 +240,7 @@ public class DescriptorUtils { return descriptor instanceof AnonymousFunctionDescriptor; } - public static boolean isClassObject(@Nullable DeclarationDescriptor descriptor) { + public static boolean isDefaultObject(@Nullable DeclarationDescriptor descriptor) { return isKindOf(descriptor, ClassKind.CLASS_OBJECT); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/EnumValue.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/EnumValue.java index 7b92ed98937..a65bf2945b1 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/EnumValue.java +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/constants/EnumValue.java @@ -32,7 +32,7 @@ public class EnumValue extends CompileTimeConstant { @Override public JetType getType(@NotNull KotlinBuiltIns kotlinBuiltIns) { JetType type = value.getClassObjectType(); - assert type != null : "Enum entry should have a class object: " + value; + assert type != null : "Enum entry should have a default object: " + value; return type; } diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScope.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScope.kt index b7a642d2c96..2aa6f5b011b 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScope.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/scopes/JetScope.kt @@ -24,9 +24,6 @@ import java.lang.reflect.Modifier public trait JetScope { - /** - * Should not return object (class object or enum entry) class descriptors. - */ public fun getClassifier(name: Name): ClassifierDescriptor? public fun getPackage(name: Name): PackageViewDescriptor? diff --git a/core/serialization.jvm/src/jvm_descriptors.proto b/core/serialization.jvm/src/jvm_descriptors.proto index 0a1e1b3668e..2b78dca86d5 100644 --- a/core/serialization.jvm/src/jvm_descriptors.proto +++ b/core/serialization.jvm/src/jvm_descriptors.proto @@ -52,7 +52,7 @@ message JvmFieldSignature { required int32 name = 1; required JvmType type = 2; - // True iff this field is a backing field for a class object and is really present as a static + // True iff this field is a backing field for a default object and is really present as a static // field in the outer class, not as an instance field here optional bool is_static_in_outer = 3 [default = false]; } diff --git a/core/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java b/core/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java index f5fb97dc94e..fb7285ba6bd 100644 --- a/core/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java +++ b/core/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java @@ -131,9 +131,9 @@ public class DescriptorSerializer { } } - ClassDescriptor classObject = classDescriptor.getDefaultObjectDescriptor(); - if (classObject != null) { - builder.setClassObjectName(stringTable.getSimpleNameIndex(classObject.getName())); + ClassDescriptor defaultObjectDescriptor = classDescriptor.getDefaultObjectDescriptor(); + if (defaultObjectDescriptor != null) { + builder.setClassObjectName(stringTable.getSimpleNameIndex(defaultObjectDescriptor.getName())); } extension.serializeClass(classDescriptor, builder, stringTable); diff --git a/core/serialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt b/core/serialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt index 0b2e044bbca..44303234aca 100644 --- a/core/serialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt +++ b/core/serialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt @@ -60,7 +60,7 @@ public class DeserializedClassDescriptor( private val containingDeclaration = outerContext.containingDeclaration private val primaryConstructor = c.storageManager.createNullableLazyValue { computePrimaryConstructor() } - private val classObjectDescriptor = c.storageManager.createNullableLazyValue { computeClassObjectDescriptor() } + private val defaultObjectDescriptor = c.storageManager.createNullableLazyValue { computeDefaultObjectDescriptor() } private val annotations = if (!Flags.HAS_ANNOTATIONS.get(classProto.getFlags())) { @@ -109,14 +109,14 @@ public class DeserializedClassDescriptor( return listOf(constructor) } - private fun computeClassObjectDescriptor(): ClassDescriptor? { + private fun computeDefaultObjectDescriptor(): ClassDescriptor? { if (!classProto.hasClassObjectName()) return null - val classObjectName = c.nameResolver.getName(classProto.getClassObjectName()) - return memberScope.getClassifier(classObjectName) as? ClassDescriptor + val defaultObjectName = c.nameResolver.getName(classProto.getClassObjectName()) + return memberScope.getClassifier(defaultObjectName) as? ClassDescriptor } - override fun getDefaultObjectDescriptor(): ClassDescriptor? = classObjectDescriptor() + override fun getDefaultObjectDescriptor(): ClassDescriptor? = defaultObjectDescriptor() private fun computeSuperTypes(): Collection { val supertypes = ArrayList(classProto.getSupertypeCount()) diff --git a/grammar/src/class_members.grm b/grammar/src/class_members.grm index b3428fb4fe1..7a3a7c838e1 100644 --- a/grammar/src/class_members.grm +++ b/grammar/src/class_members.grm @@ -27,7 +27,7 @@ class Example(a : Foo, i : Int) : Bar(i), Some { */ memberDeclaration - : classObject + : defaultObject : object : function : property @@ -40,12 +40,9 @@ anonymousInitializer : block ; -classObject +defaultObject : modifiers "class" object ; -/** -See [Class objects](classes.html#class-objects) -*/ valueParameters : "(" functionParameter{","}? ")" // default values diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/codeInsight/ReferenceVariantsHelper.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/codeInsight/ReferenceVariantsHelper.kt index f52838d39b1..0e780e9612d 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/idea/codeInsight/ReferenceVariantsHelper.kt +++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/codeInsight/ReferenceVariantsHelper.kt @@ -88,7 +88,7 @@ public class ReferenceVariantsHelper( val qualifier = context[BindingContext.QUALIFIER, receiverExpression] if (qualifier != null) { - // It's impossible to add extension function for package or class (if it's class object, expression type is not null) + // It's impossible to add extension function for package or class (if it's default object, expression type is not null) qualifier.scope.getDescriptorsFiltered(kindFilter exclude DescriptorKindExclude.Extensions, nameFilter).filterTo(descriptors) { callType.canCall(it) } } diff --git a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/implicitReceiversUtils.kt b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/implicitReceiversUtils.kt index 78bbe05f771..d9b45e462af 100644 --- a/idea/ide-common/src/org/jetbrains/kotlin/idea/util/implicitReceiversUtils.kt +++ b/idea/ide-common/src/org/jetbrains/kotlin/idea/util/implicitReceiversUtils.kt @@ -24,7 +24,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor import java.util.HashSet public fun JetScope.getImplicitReceiversWithInstance(): List { - // we use a set to workaround a bug with receiver for class object present twice in the result of getImplicitReceiversHierarchy() + // we use a set to workaround a bug with receiver for default object present twice in the result of getImplicitReceiversHierarchy() val receivers = LinkedHashSet(getImplicitReceiversHierarchy()) val withInstance = HashSet() diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt index 165304fbfe1..8e0c27ce825 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt @@ -66,7 +66,7 @@ private class ClassClsStubBuilder( supertypeIds } } - private val classObjectName = if (classProto.hasClassObjectName()) c.nameResolver.getName(classProto.getClassObjectName()) else null + private val defaultObjectName = if (classProto.hasClassObjectName()) c.nameResolver.getName(classProto.getClassObjectName()) else null private val classOrObjectStub = createClassOrObjectStubAndModifierListStub() @@ -100,7 +100,7 @@ private class ClassClsStubBuilder( } private fun doCreateClassOrObjectStub(): StubElement { - val isClassObject = classKind == ProtoBuf.Class.Kind.CLASS_OBJECT + val isDefaultObject = classKind == ProtoBuf.Class.Kind.CLASS_OBJECT val fqName = outerContext.containerFqName.child(classId.getRelativeClassName().shortName()) val shortName = fqName.shortName()?.ref() val superTypeRefs = supertypeIds.filter { @@ -112,7 +112,7 @@ private class ClassClsStubBuilder( KotlinObjectStubImpl( parentStub, shortName, fqName, superTypeRefs, isTopLevel = !classId.isNestedClass(), - isClassObject = isClassObject, + isDefault = isDefaultObject, isLocal = false, isObjectLiteral = false ) @@ -163,19 +163,19 @@ private class ClassClsStubBuilder( private fun createClassBodyAndMemberStubs() { val classBody = KotlinPlaceHolderStubImpl(classOrObjectStub, JetStubElementTypes.CLASS_BODY) - createClassObjectStub(classBody) + createDefaultObjectStub(classBody) createEnumEntryStubs(classBody) createCallableMemberStubs(classBody) createInnerAndNestedClasses(classBody) } - private fun createClassObjectStub(classBody: KotlinPlaceHolderStubImpl) { - if (classObjectName == null) { + private fun createDefaultObjectStub(classBody: KotlinPlaceHolderStubImpl) { + if (defaultObjectName == null) { return } - val classObjectId = classId.createNestedClassId(classObjectName) - createNestedClassStub(classBody, classObjectId) + val defaultObjectId = classId.createNestedClassId(defaultObjectName) + createNestedClassStub(classBody, defaultObjectId) } private fun createEnumEntryStubs(classBody: KotlinPlaceHolderStubImpl) { @@ -211,7 +211,7 @@ private class ClassClsStubBuilder( private fun createInnerAndNestedClasses(classBody: KotlinPlaceHolderStubImpl) { classProto.getNestedClassNameList().forEach { id -> val nestedClassName = c.nameResolver.getName(id) - if (nestedClassName != classObjectName) { + if (nestedClassName != defaultObjectName) { val nestedClassId = classId.createNestedClassId(nestedClassName) createNestedClassStub(classBody, nestedClassId) } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt index 3fbf636c889..e7f74dc359c 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt @@ -210,7 +210,7 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) { } val typeConstraintListStub = KotlinPlaceHolderStubImpl(parent, JetStubElementTypes.TYPE_CONSTRAINT_LIST) for ((name, type) in protosForTypeConstraintList) { - val typeConstraintStub = KotlinTypeConstraintStubImpl(typeConstraintListStub, isClassObjectConstraint = false) + val typeConstraintStub = KotlinTypeConstraintStubImpl(typeConstraintListStub, isDefaultObjectConstraint = false) KotlinNameReferenceExpressionStubImpl(typeConstraintStub, name.ref()) createTypeReferenceStub(typeConstraintStub, type) } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextFactory.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextFactory.kt index 85f2444f958..ff130641f57 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextFactory.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/textBuilder/DecompiledTextFactory.kt @@ -146,17 +146,17 @@ private fun buildDecompiledText(packageFqName: FqName, descriptors: List( override fun visitParameter(d: JetParameter, _: Unit?) = detect(d, "parameter", newLineNeeded = false) override fun visitObjectDeclaration(d: JetObjectDeclaration, _: Unit?): AnnotationHostKind? { - if (d.isClassObject()) return detect(d, "class object", name = "${d.getName()} of ${d.getStrictParentOfType()?.getName()}") + if (d.isDefault()) return detect(d, "class object", name = "${d.getName()} of ${d.getStrictParentOfType()?.getName()}") if (d.getParent() is JetObjectLiteralExpression) return null return detect(d, "object") } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/referenceUtil.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/referenceUtil.kt index 516955fd135..d32b405c025 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/referenceUtil.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/references/referenceUtil.kt @@ -36,14 +36,14 @@ import org.jetbrains.kotlin.psi.psiUtil.getNonStrictParentOfType // Navigation element of the resolved reference // For property accessor return enclosing property -// For class object return enclosing class +// For default object return enclosing class public val PsiReference.unwrappedTargets: Set get() { fun PsiElement.adjust(): PsiElement? { val target = unwrapped?.getOriginalElement() return when { target is JetPropertyAccessor -> target.getNonStrictParentOfType() - target is JetObjectDeclaration && target.isClassObject() -> target.getNonStrictParentOfType() + target is JetObjectDeclaration && target.isDefault() -> target.getNonStrictParentOfType() else -> target } } diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/OverrideImplementMethodsHandler.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/OverrideImplementMethodsHandler.java index 18461509411..1ee9f3cb118 100644 --- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/OverrideImplementMethodsHandler.java +++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/OverrideImplementMethodsHandler.java @@ -308,7 +308,7 @@ public abstract class OverrideImplementMethodsHandler implements LanguageCodeIns PsiElement elementAtCaret = file.findElementAt(editor.getCaretModel().getOffset()); JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(elementAtCaret, JetClassOrObject.class); - assert classOrObject != null : "ClassObject should be checked in isValidFor method"; + assert classOrObject != null; Set missingImplementations = collectMethodsToGenerate(classOrObject); if (missingImplementations.isEmpty() && !implementAll) { diff --git a/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/JetDeclarationMover.java b/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/JetDeclarationMover.java index 085902e24fc..cebad271b8f 100644 --- a/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/JetDeclarationMover.java +++ b/idea/src/org/jetbrains/kotlin/idea/codeInsight/upDownMover/JetDeclarationMover.java @@ -61,7 +61,7 @@ public class JetDeclarationMover extends AbstractJetUpDownMover { @Override public void visitObjectDeclaration(@NotNull JetObjectDeclaration declaration) { - if (declaration.isClassObject()) { + if (declaration.isDefault()) { memberSuspects.add(declaration.getClassKeyword()); } } diff --git a/idea/src/org/jetbrains/kotlin/idea/completion/CompletionSorting.kt b/idea/src/org/jetbrains/kotlin/idea/completion/CompletionSorting.kt index ad06e2f4208..d50d1ca47b9 100644 --- a/idea/src/org/jetbrains/kotlin/idea/completion/CompletionSorting.kt +++ b/idea/src/org/jetbrains/kotlin/idea/completion/CompletionSorting.kt @@ -144,7 +144,7 @@ private class JetDeclarationRemotenessWeigher(private val file: JetFile) : Looku } val qualifiedName = qualifiedName(o) - // Invalid name can be met for class object descriptor: Test.MyTest.A..testOther + // Invalid name can be met for default object descriptor: Test.MyTest.A..testOther if (qualifiedName != null && isValidJavaFqName(qualifiedName)) { val importPath = ImportPath(qualifiedName) val fqName = importPath.fqnPart() diff --git a/idea/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt b/idea/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt index 68641728997..f906d78be6e 100644 --- a/idea/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt +++ b/idea/src/org/jetbrains/kotlin/idea/completion/smart/SmartCompletion.kt @@ -223,7 +223,7 @@ class SmartCompletion( val typeParameter = type.type.getConstructor().getDeclarationDescriptor() as? TypeParameterDescriptor ?: return false if (!type.freeParameters.contains(typeParameter)) return false return KotlinBuiltIns.isAnyOrNullableAny(typeParameter.getUpperBoundsAsType()) - //TODO: check for class object constraint when there will be supported + //TODO: check for default object constraint when they are supported } private fun calcExpectedInfos(expression: JetExpression): Collection? { diff --git a/idea/src/org/jetbrains/kotlin/idea/completion/smart/StaticMembers.kt b/idea/src/org/jetbrains/kotlin/idea/completion/smart/StaticMembers.kt index da018da72a0..3cab52b2c84 100644 --- a/idea/src/org/jetbrains/kotlin/idea/completion/smart/StaticMembers.kt +++ b/idea/src/org/jetbrains/kotlin/idea/completion/smart/StaticMembers.kt @@ -35,7 +35,7 @@ import org.jetbrains.kotlin.psi.JetSimpleNameExpression import org.jetbrains.kotlin.idea.completion.isVisible import org.jetbrains.kotlin.idea.completion.ExpectedInfo -// adds java static members, enum members and members from class object +// adds java static members, enum members and members from default object class StaticMembers( val bindingContext: BindingContext, val resolutionFacade: ResolutionFacade, @@ -85,9 +85,9 @@ class StaticMembers( classDescriptor.getStaticScope().getAllDescriptors().forEach(::processMember) - val classObject = classDescriptor.getDefaultObjectDescriptor() - if (classObject != null) { - classObject.getDefaultType().getMemberScope().getAllDescriptors() + val defaultObject = classDescriptor.getDefaultObjectDescriptor() + if (defaultObject != null) { + defaultObject.getDefaultType().getMemberScope().getAllDescriptors() .filter { !it.isExtension } .forEach(::processMember) } diff --git a/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt b/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt index eb9ad2f5469..2db9f037303 100644 --- a/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt +++ b/idea/src/org/jetbrains/kotlin/idea/debugger/JetPositionManager.kt @@ -249,7 +249,7 @@ public class JetPositionManager(private val myDebugProcess: DebugProcess) : Posi element is JetClassInitializer -> { val parent = getElementToCalculateClassName(element.getParent()) // Class-object initializer - if (parent is JetObjectDeclaration && parent.isClassObject()) { + if (parent is JetObjectDeclaration && parent.isDefault()) { return getClassNameForElement(parent.getParent(), typeMapper, file, isInLibrary) } return getClassNameForElement(element, typeMapper, file, isInLibrary) diff --git a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyNodeDescriptor.java b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyNodeDescriptor.java index b8fdabb8eb5..f1d6c1d6b32 100644 --- a/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyNodeDescriptor.java +++ b/idea/src/org/jetbrains/kotlin/idea/hierarchy/calls/KotlinCallHierarchyNodeDescriptor.java @@ -170,7 +170,7 @@ public class KotlinCallHierarchyNodeDescriptor extends HierarchyNodeDescriptor i if (descriptor == null) return null; if (element instanceof JetClassOrObject) { - if (element instanceof JetObjectDeclaration && ((JetObjectDeclaration) element).isClassObject()) { + if (element instanceof JetObjectDeclaration && ((JetObjectDeclaration) element).isDefault()) { descriptor = descriptor.getContainingDeclaration(); if (!(descriptor instanceof ClassDescriptor)) return null; diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt index 16cf7265183..6cbbeaac531 100644 --- a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt +++ b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt @@ -126,8 +126,8 @@ public class UnusedSymbolInspection : AbstractKotlinInspection() { if (declaration is JetProperty && declaration.isLocal()) return if (declaration is JetParameter && (declaration.getParent()?.getParent() !is JetClass || !declaration.hasValOrVarNode())) return if (declaration is JetNamedFunction && isConventionalName(declaration)) return - //TODO: support this inspection for class objects - if (declaration is JetObjectDeclaration && declaration.isClassObject()) return + //TODO: support this inspection for default objects + if (declaration is JetObjectDeclaration && declaration.isDefault()) return // More expensive, resolve-based checks if (isEntryPoint(declaration)) return diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt index 35d7b8c1180..2ed41012b03 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableBuilder.kt @@ -851,7 +851,7 @@ class CallableBuilder(val config: CallableBuilderConfiguration) { is ConstructorInfo -> with(callableInfo.classInfo) { !inner && kind != ClassKind.ENUM_ENTRY && kind != ClassKind.ENUM_CLASS } - else -> callableInfo.receiverTypeInfo.classObjectRequired + else -> callableInfo.receiverTypeInfo.staticContextRequired } modifierList.setModifierProperty(PsiModifier.STATIC, needStatic) diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableInfo.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableInfo.kt index b127ef03b7c..9c79476b2a6 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableInfo.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/callableBuilder/CallableInfo.kt @@ -75,12 +75,12 @@ abstract class TypeInfo(val variance: Variance) { override val substitutionsAllowed: Boolean = false } - class ClassObjectRequired(delegate: TypeInfo): DelegatingTypeInfo(delegate) { - override val classObjectRequired: Boolean = true + class StaticContextRequired(delegate: TypeInfo): DelegatingTypeInfo(delegate) { + override val staticContextRequired: Boolean = true } open val substitutionsAllowed: Boolean = true - open val classObjectRequired: Boolean = false + open val staticContextRequired: Boolean = false open val possibleNamesFromExpression: Array get() = ArrayUtil.EMPTY_STRING_ARRAY abstract fun getPossibleTypes(builder: CallableBuilder): List diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt index dc9e06d2b0d..79dcd759c76 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateCallableFromUsageFix.kt @@ -79,8 +79,8 @@ public class CreateCallableFromUsageFix( val receiverInfo = callableInfo.receiverTypeInfo if (receiverInfo is TypeInfo.Empty) return !isExtension - // TODO: Remove after class object extensions are supported - if (isExtension && receiverInfo.classObjectRequired) return false + // TODO: Remove after default object extensions are supported + if (isExtension && receiverInfo.staticContextRequired) return false val file = element.getContainingFile() as JetFile val project = file.getProject() @@ -93,9 +93,9 @@ public class CreateCallableFromUsageFix( val declaration = getDeclarationIfApplicable(project, it) val insertToJavaInterface = declaration is PsiClass && declaration.isInterface() when { - propertyInfo != null && insertToJavaInterface && (!receiverInfo.classObjectRequired || propertyInfo.writable) -> + propertyInfo != null && insertToJavaInterface && (!receiverInfo.staticContextRequired || propertyInfo.writable) -> false - isFunction && insertToJavaInterface && receiverInfo.classObjectRequired -> + isFunction && insertToJavaInterface && receiverInfo.staticContextRequired -> false else -> declaration != null diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateFunctionOrPropertyFromCallActionFactory.kt b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateFunctionOrPropertyFromCallActionFactory.kt index 218778239aa..132f9c6a92f 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateFunctionOrPropertyFromCallActionFactory.kt +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/createFromUsage/createCallable/CreateFunctionOrPropertyFromCallActionFactory.kt @@ -126,7 +126,7 @@ object CreateFunctionOrPropertyFromCallActionFactory : JetIntentionActionsFactor val classifier = receiver.classifier as? JavaClassDescriptor ?: return null val javaClass = DescriptorToDeclarationUtil.getDeclaration(project, classifier) as? PsiClass if (javaClass == null || !javaClass.canRefactor()) return null - TypeInfo.ClassObjectRequired(TypeInfo(classifier.getDefaultType(), Variance.IN_VARIANCE)) + TypeInfo.StaticContextRequired(TypeInfo(classifier.getDefaultType(), Variance.IN_VARIANCE)) } else -> TypeInfo(receiver.getType(), Variance.IN_VARIANCE) } diff --git a/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt b/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt index a5fed60fc8d..4e2af38dc01 100644 --- a/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt +++ b/idea/src/org/jetbrains/kotlin/idea/refactoring/jetRefactoringUtil.kt @@ -330,8 +330,8 @@ public fun chooseContainerElement( if (this is JetPropertyAccessor) { return (getParent() as JetProperty).renderName() + if (isGetter()) ".get" else ".set" } - if (this is JetObjectDeclaration && this.isClassObject()) { - return "Class object of ${getStrictParentOfType()?.renderName() ?: ""}" + if (this is JetObjectDeclaration && this.isDefault()) { + return "Default object of ${getStrictParentOfType()?.renderName() ?: ""}" } return (this as? PsiNamedElement)?.getName() ?: "" } diff --git a/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfigurationProducer.java b/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfigurationProducer.java index ab151d894ca..83edfd476cb 100644 --- a/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfigurationProducer.java +++ b/idea/src/org/jetbrains/kotlin/idea/run/JetRunConfigurationProducer.java @@ -78,7 +78,7 @@ public class JetRunConfigurationProducer extends RuntimeConfigurationProducer im if (container instanceof JetFile) return PackageClassUtils.getPackageClassFqName(((JetFile) container).getPackageFqName()); if (container instanceof JetClassOrObject) { JetClassOrObject classOrObject = (JetClassOrObject) container; - if (classOrObject instanceof JetObjectDeclaration && ((JetObjectDeclaration) classOrObject).isClassObject()) { + if (classOrObject instanceof JetObjectDeclaration && ((JetObjectDeclaration) classOrObject).isDefault()) { classOrObject = PsiTreeUtil.getParentOfType(classOrObject, JetClass.class); } return classOrObject != null ? classOrObject.getFqName() : null; @@ -117,7 +117,7 @@ public class JetRunConfigurationProducer extends RuntimeConfigurationProducer im currentElement = PsiTreeUtil.getParentOfType((PsiElement) currentElement, JetClassOrObject.class, JetFile.class)) { JetDeclarationContainer entryPointContainer = currentElement; if (entryPointContainer instanceof JetClass) { - entryPointContainer = ((JetClass) currentElement).getClassObject(); + entryPointContainer = ((JetClass) currentElement).getDefaultObject(); } if (entryPointContainer != null && mainFunctionDetector.hasMain(entryPointContainer.getDeclarations())) return entryPointContainer; } diff --git a/idea/testData/checker/ClassObjects.kt b/idea/testData/checker/ClassObjects.kt index e7bca713a65..e03a2111713 100644 --- a/idea/testData/checker/ClassObjects.kt +++ b/idea/testData/checker/ClassObjects.kt @@ -4,7 +4,7 @@ class A { class object { val x = 1 } - class object Another { // error + class object Another { // error val x = 1 } } @@ -14,7 +14,7 @@ class B() { } object b { - class object { + class object { val x = 1 } // error diff --git a/idea/testData/checker/PlatformStaticUsagesRuntime.kt b/idea/testData/checker/PlatformStaticUsagesRuntime.kt index 77c81fea26e..613e46bcd68 100644 --- a/idea/testData/checker/PlatformStaticUsagesRuntime.kt +++ b/idea/testData/checker/PlatformStaticUsagesRuntime.kt @@ -18,13 +18,13 @@ class s = object { - platformStatic fun a3() { + platformStatic fun a3() { } } } - platformStatic fun a4() { + platformStatic fun a4() { } } @@ -32,7 +32,7 @@ class B { class object { - platformStatic fun a1() { + platformStatic fun a1() { } } @@ -45,13 +45,13 @@ trait s = object { - platformStatic fun a3() { + platformStatic fun a3() { } } } - platformStatic fun a4() { + platformStatic fun a4() { } } \ No newline at end of file diff --git a/idea/testData/decompiler/stubBuilder/Annotations/Annotations.txt b/idea/testData/decompiler/stubBuilder/Annotations/Annotations.txt index b75c03a530c..4256f16d1e3 100644 --- a/idea/testData/decompiler/stubBuilder/Annotations/Annotations.txt +++ b/idea/testData/decompiler/stubBuilder/Annotations/Annotations.txt @@ -33,7 +33,7 @@ PsiJetFileStubImpl[package=] REFERENCE_EXPRESSION:[referencedName=kotlin] REFERENCE_EXPRESSION:[referencedName=Int] CLASS_BODY: - OBJECT_DECLARATION:[fqName=Annotations.Default, isClassObject=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] + OBJECT_DECLARATION:[fqName=Annotations.Default, isDefault=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] MODIFIER_LIST:[private] ANNOTATION_ENTRY:[hasValueArguments=false, shortName=b] CONSTRUCTOR_CALLEE: diff --git a/idea/testData/decompiler/stubBuilder/ClassObject/ClassObject.txt b/idea/testData/decompiler/stubBuilder/ClassObject/ClassObject.txt index d0b27fca6ef..fd9e05bfa37 100644 --- a/idea/testData/decompiler/stubBuilder/ClassObject/ClassObject.txt +++ b/idea/testData/decompiler/stubBuilder/ClassObject/ClassObject.txt @@ -7,7 +7,7 @@ PsiJetFileStubImpl[package=test.class_object] MODIFIER_LIST:[internal final] VALUE_PARAMETER_LIST: CLASS_BODY: - OBJECT_DECLARATION:[fqName=test.class_object.ClassObject.Default, isClassObject=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] + OBJECT_DECLARATION:[fqName=test.class_object.ClassObject.Default, isDefault=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] MODIFIER_LIST:[public] CLASS_BODY: PROPERTY:[fqName=test.class_object.ClassObject.Default.j, hasDelegate=false, hasDelegateExpression=false, hasInitializer=false, hasReceiverTypeRef=false, hasReturnTypeRef=true, isProbablyNothingType=false, isTopLevel=false, isVar=false, name=j] @@ -67,21 +67,21 @@ PsiJetFileStubImpl[package=test.class_object] MODIFIER_LIST:[internal final] VALUE_PARAMETER_LIST: CLASS_BODY: - OBJECT_DECLARATION:[fqName=test.class_object.ClassObject.B.Default, isClassObject=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] + OBJECT_DECLARATION:[fqName=test.class_object.ClassObject.B.Default, isDefault=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] MODIFIER_LIST:[internal] CLASS_BODY: CLASS:[fqName=test.class_object.ClassObject.B.Default.C, isEnumEntry=false, isLocal=false, isTopLevel=false, isTrait=false, name=C, superNames=[]] MODIFIER_LIST:[internal final] VALUE_PARAMETER_LIST: CLASS_BODY: - OBJECT_DECLARATION:[fqName=test.class_object.ClassObject.B.Default.C.Default, isClassObject=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] + OBJECT_DECLARATION:[fqName=test.class_object.ClassObject.B.Default.C.Default, isDefault=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] MODIFIER_LIST:[internal] CLASS_BODY: CLASS:[fqName=test.class_object.ClassObject.B.Default.C.Default.D, isEnumEntry=false, isLocal=false, isTopLevel=false, isTrait=false, name=D, superNames=[]] MODIFIER_LIST:[internal final] VALUE_PARAMETER_LIST: CLASS_BODY: - OBJECT_DECLARATION:[fqName=test.class_object.ClassObject.B.Default.C.Default.D.Default, isClassObject=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] + OBJECT_DECLARATION:[fqName=test.class_object.ClassObject.B.Default.C.Default.D.Default, isDefault=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] MODIFIER_LIST:[internal] CLASS_BODY: PROPERTY:[fqName=test.class_object.ClassObject.B.Default.C.Default.D.Default.i, hasDelegate=false, hasDelegateExpression=false, hasInitializer=false, hasReceiverTypeRef=false, hasReturnTypeRef=true, isProbablyNothingType=false, isTopLevel=false, isVar=false, name=i] diff --git a/idea/testData/decompiler/stubBuilder/Enum/Enum.txt b/idea/testData/decompiler/stubBuilder/Enum/Enum.txt index 539619c524e..68cc95985b3 100644 --- a/idea/testData/decompiler/stubBuilder/Enum/Enum.txt +++ b/idea/testData/decompiler/stubBuilder/Enum/Enum.txt @@ -35,7 +35,7 @@ PsiJetFileStubImpl[package=a.b.c.test.enum] REFERENCE_EXPRESSION:[referencedName=enum] REFERENCE_EXPRESSION:[referencedName=Enum] CLASS_BODY: - OBJECT_DECLARATION:[fqName=a.b.c.test.enum.Enum.Default, isClassObject=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] + OBJECT_DECLARATION:[fqName=a.b.c.test.enum.Enum.Default, isDefault=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] MODIFIER_LIST:[internal] CLASS_BODY: PROPERTY:[fqName=a.b.c.test.enum.Enum.Default.c, hasDelegate=false, hasDelegateExpression=false, hasInitializer=false, hasReceiverTypeRef=false, hasReturnTypeRef=true, isProbablyNothingType=false, isTopLevel=false, isVar=false, name=c] diff --git a/idea/testData/decompiler/stubBuilder/Objects/Objects.txt b/idea/testData/decompiler/stubBuilder/Objects/Objects.txt index 370f4980678..b686dd7025f 100644 --- a/idea/testData/decompiler/stubBuilder/Objects/Objects.txt +++ b/idea/testData/decompiler/stubBuilder/Objects/Objects.txt @@ -1,6 +1,6 @@ PsiJetFileStubImpl[package=] PACKAGE_DIRECTIVE: - OBJECT_DECLARATION:[fqName=Objects, isClassObject=false, isLocal=false, isObjectLiteral=false, isTopLevel=true, name=Objects, superNames=[]] + OBJECT_DECLARATION:[fqName=Objects, isDefault=false, isLocal=false, isObjectLiteral=false, isTopLevel=true, name=Objects, superNames=[]] MODIFIER_LIST:[public] CLASS_BODY: PROPERTY:[fqName=Objects.c, hasDelegate=false, hasDelegateExpression=false, hasInitializer=false, hasReceiverTypeRef=false, hasReturnTypeRef=true, isProbablyNothingType=false, isTopLevel=false, isVar=false, name=c] @@ -18,7 +18,7 @@ PsiJetFileStubImpl[package=] USER_TYPE:[isAbsoluteInRootPackage=false] REFERENCE_EXPRESSION:[referencedName=kotlin] REFERENCE_EXPRESSION:[referencedName=Unit] - OBJECT_DECLARATION:[fqName=Objects.InnerObject, isClassObject=false, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=InnerObject, superNames=[A]] + OBJECT_DECLARATION:[fqName=Objects.InnerObject, isDefault=false, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=InnerObject, superNames=[A]] MODIFIER_LIST:[private] DELEGATION_SPECIFIER_LIST: DELEGATOR_SUPER_CLASS: @@ -45,7 +45,7 @@ PsiJetFileStubImpl[package=] MODIFIER_LIST:[open internal] VALUE_PARAMETER_LIST: CLASS_BODY: - OBJECT_DECLARATION:[fqName=Objects.OtherObject, isClassObject=false, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=OtherObject, superNames=[NestedClass]] + OBJECT_DECLARATION:[fqName=Objects.OtherObject, isDefault=false, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=OtherObject, superNames=[NestedClass]] MODIFIER_LIST:[public] DELEGATION_SPECIFIER_LIST: DELEGATOR_SUPER_CLASS: diff --git a/idea/testData/decompiler/stubBuilder/TypeBoundsAndDelegationSpecifiers/TypeBoundsAndDelegationSpecifiers.txt b/idea/testData/decompiler/stubBuilder/TypeBoundsAndDelegationSpecifiers/TypeBoundsAndDelegationSpecifiers.txt index 50ccace92d7..cf984ff72cd 100644 --- a/idea/testData/decompiler/stubBuilder/TypeBoundsAndDelegationSpecifiers/TypeBoundsAndDelegationSpecifiers.txt +++ b/idea/testData/decompiler/stubBuilder/TypeBoundsAndDelegationSpecifiers/TypeBoundsAndDelegationSpecifiers.txt @@ -32,7 +32,7 @@ PsiJetFileStubImpl[package=test] REFERENCE_EXPRESSION:[referencedName=test] REFERENCE_EXPRESSION:[referencedName=T] TYPE_CONSTRAINT_LIST: - TYPE_CONSTRAINT:[isClassObjectConstraint=false] + TYPE_CONSTRAINT:[isDefaultObjectConstraint=false] REFERENCE_EXPRESSION:[referencedName=H] TYPE_REFERENCE: USER_TYPE:[isAbsoluteInRootPackage=false] @@ -46,14 +46,14 @@ PsiJetFileStubImpl[package=test] USER_TYPE:[isAbsoluteInRootPackage=false] REFERENCE_EXPRESSION:[referencedName=kotlin] REFERENCE_EXPRESSION:[referencedName=String] - TYPE_CONSTRAINT:[isClassObjectConstraint=false] + TYPE_CONSTRAINT:[isDefaultObjectConstraint=false] REFERENCE_EXPRESSION:[referencedName=G] TYPE_REFERENCE: USER_TYPE:[isAbsoluteInRootPackage=false] USER_TYPE:[isAbsoluteInRootPackage=false] REFERENCE_EXPRESSION:[referencedName=kotlin] REFERENCE_EXPRESSION:[referencedName=CharSequence] - TYPE_CONSTRAINT:[isClassObjectConstraint=false] + TYPE_CONSTRAINT:[isDefaultObjectConstraint=false] REFERENCE_EXPRESSION:[referencedName=C] TYPE_REFERENCE: NULLABLE_TYPE: diff --git a/idea/testData/decompiler/stubBuilder/TypeParams/TypeParams.txt b/idea/testData/decompiler/stubBuilder/TypeParams/TypeParams.txt index d250fd5a1c4..cde62692f9a 100644 --- a/idea/testData/decompiler/stubBuilder/TypeParams/TypeParams.txt +++ b/idea/testData/decompiler/stubBuilder/TypeParams/TypeParams.txt @@ -47,7 +47,7 @@ PsiJetFileStubImpl[package=test] REFERENCE_EXPRESSION:[referencedName=Any] VALUE_PARAMETER_LIST: TYPE_CONSTRAINT_LIST: - TYPE_CONSTRAINT:[isClassObjectConstraint=false] + TYPE_CONSTRAINT:[isDefaultObjectConstraint=false] REFERENCE_EXPRESSION:[referencedName=T1] TYPE_REFERENCE: NULLABLE_TYPE: @@ -55,7 +55,7 @@ PsiJetFileStubImpl[package=test] USER_TYPE:[isAbsoluteInRootPackage=false] REFERENCE_EXPRESSION:[referencedName=kotlin] REFERENCE_EXPRESSION:[referencedName=Any] - TYPE_CONSTRAINT:[isClassObjectConstraint=false] + TYPE_CONSTRAINT:[isDefaultObjectConstraint=false] REFERENCE_EXPRESSION:[referencedName=T1] TYPE_REFERENCE: NULLABLE_TYPE: @@ -63,14 +63,14 @@ PsiJetFileStubImpl[package=test] USER_TYPE:[isAbsoluteInRootPackage=false] REFERENCE_EXPRESSION:[referencedName=kotlin] REFERENCE_EXPRESSION:[referencedName=Int] - TYPE_CONSTRAINT:[isClassObjectConstraint=false] + TYPE_CONSTRAINT:[isDefaultObjectConstraint=false] REFERENCE_EXPRESSION:[referencedName=T1] TYPE_REFERENCE: USER_TYPE:[isAbsoluteInRootPackage=false] USER_TYPE:[isAbsoluteInRootPackage=false] REFERENCE_EXPRESSION:[referencedName=kotlin] REFERENCE_EXPRESSION:[referencedName=Int] - TYPE_CONSTRAINT:[isClassObjectConstraint=false] + TYPE_CONSTRAINT:[isDefaultObjectConstraint=false] REFERENCE_EXPRESSION:[referencedName=T7] TYPE_REFERENCE: USER_TYPE:[isAbsoluteInRootPackage=false] @@ -353,14 +353,14 @@ PsiJetFileStubImpl[package=test] REFERENCE_EXPRESSION:[referencedName=kotlin] REFERENCE_EXPRESSION:[referencedName=Unit] TYPE_CONSTRAINT_LIST: - TYPE_CONSTRAINT:[isClassObjectConstraint=false] + TYPE_CONSTRAINT:[isDefaultObjectConstraint=false] REFERENCE_EXPRESSION:[referencedName=G3] TYPE_REFERENCE: USER_TYPE:[isAbsoluteInRootPackage=false] USER_TYPE:[isAbsoluteInRootPackage=false] REFERENCE_EXPRESSION:[referencedName=kotlin] REFERENCE_EXPRESSION:[referencedName=String] - TYPE_CONSTRAINT:[isClassObjectConstraint=false] + TYPE_CONSTRAINT:[isDefaultObjectConstraint=false] REFERENCE_EXPRESSION:[referencedName=G3] TYPE_REFERENCE: NULLABLE_TYPE: diff --git a/idea/testData/quickfix/autoImports/afterUnresolvedReferenceInCall.kt b/idea/testData/quickfix/autoImports/afterUnresolvedReferenceInCall.kt index 6b6cd4d8555..a862e48b318 100644 --- a/idea/testData/quickfix/autoImports/afterUnresolvedReferenceInCall.kt +++ b/idea/testData/quickfix/autoImports/afterUnresolvedReferenceInCall.kt @@ -1,5 +1,5 @@ // "Import" "true" -// ERROR: Please specify constructor invocation; classifier 'ArrayList' does not have a class object +// ERROR: Please specify constructor invocation; classifier 'ArrayList' does not have a default object // KT-4000 diff --git a/idea/testData/quickfix/autoImports/beforeUnresolvedReferenceInCall.kt b/idea/testData/quickfix/autoImports/beforeUnresolvedReferenceInCall.kt index bef160a29e4..911e96502b9 100644 --- a/idea/testData/quickfix/autoImports/beforeUnresolvedReferenceInCall.kt +++ b/idea/testData/quickfix/autoImports/beforeUnresolvedReferenceInCall.kt @@ -1,5 +1,5 @@ // "Import" "true" -// ERROR: Please specify constructor invocation; classifier 'ArrayList' does not have a class object +// ERROR: Please specify constructor invocation; classifier 'ArrayList' does not have a default object // KT-4000 diff --git a/idea/testData/stubs/AnonymousObject.expected b/idea/testData/stubs/AnonymousObject.expected index 13ab8cd75e2..00c9b6ba0ef 100644 --- a/idea/testData/stubs/AnonymousObject.expected +++ b/idea/testData/stubs/AnonymousObject.expected @@ -3,7 +3,7 @@ PsiJetFileStubImpl[package=] CLASS:[fqName=A, isEnumEntry=false, isLocal=false, isTopLevel=true, isTrait=false, name=A, superNames=[]] CLASS:[fqName=T, isEnumEntry=false, isLocal=false, isTopLevel=true, isTrait=true, name=T, superNames=[]] PROPERTY:[fqName=obj, hasDelegate=false, hasDelegateExpression=false, hasInitializer=true, hasReceiverTypeRef=false, hasReturnTypeRef=false, isProbablyNothingType=false, isTopLevel=true, isVar=false, name=obj] - OBJECT_DECLARATION:[fqName=null, isClassObject=false, isLocal=true, isObjectLiteral=true, isTopLevel=false, name=null, superNames=[A, T]] + OBJECT_DECLARATION:[fqName=null, isDefault=false, isLocal=true, isObjectLiteral=true, isTopLevel=false, name=null, superNames=[A, T]] DELEGATION_SPECIFIER_LIST: DELEGATOR_SUPER_CALL: CONSTRUCTOR_CALLEE: diff --git a/idea/testData/stubs/ClassObject.expected b/idea/testData/stubs/ClassObject.expected index 2b1ada4a8d8..156380a273e 100644 --- a/idea/testData/stubs/ClassObject.expected +++ b/idea/testData/stubs/ClassObject.expected @@ -2,7 +2,7 @@ PsiJetFileStubImpl[package=] PACKAGE_DIRECTIVE: CLASS:[fqName=C, isEnumEntry=false, isLocal=false, isTopLevel=true, isTrait=false, name=C, superNames=[]] CLASS_BODY: - OBJECT_DECLARATION:[fqName=C.Default, isClassObject=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] + OBJECT_DECLARATION:[fqName=C.Default, isDefault=true, isLocal=false, isObjectLiteral=false, isTopLevel=false, name=Default, superNames=[]] CLASS_BODY: FUN:[fqName=C.Default.foo, hasBlockBody=true, hasBody=true, hasTypeParameterListBeforeFunctionName=false, isExtension=false, isProbablyNothingType=false, isTopLevel=false, name=foo] VALUE_PARAMETER_LIST: diff --git a/idea/testData/stubs/FunctionInNotNamedObject.expected b/idea/testData/stubs/FunctionInNotNamedObject.expected index 59672864393..e83c4ae05a1 100644 --- a/idea/testData/stubs/FunctionInNotNamedObject.expected +++ b/idea/testData/stubs/FunctionInNotNamedObject.expected @@ -1,6 +1,6 @@ PsiJetFileStubImpl[package=] PACKAGE_DIRECTIVE: - OBJECT_DECLARATION:[fqName=, isClassObject=false, isLocal=false, isObjectLiteral=false, isTopLevel=true, name=null, superNames=[]] + OBJECT_DECLARATION:[fqName=, isDefault=false, isLocal=false, isObjectLiteral=false, isTopLevel=true, name=null, superNames=[]] CLASS_BODY: FUN:[fqName=null, hasBlockBody=false, hasBody=true, hasTypeParameterListBeforeFunctionName=false, isExtension=false, isProbablyNothingType=false, isTopLevel=false, name=testing] VALUE_PARAMETER_LIST: diff --git a/idea/testData/stubs/LocalNamedObject.expected b/idea/testData/stubs/LocalNamedObject.expected index b0c6b7a41d9..74bd764abeb 100644 --- a/idea/testData/stubs/LocalNamedObject.expected +++ b/idea/testData/stubs/LocalNamedObject.expected @@ -4,7 +4,7 @@ PsiJetFileStubImpl[package=] CLASS:[fqName=T, isEnumEntry=false, isLocal=false, isTopLevel=true, isTrait=true, name=T, superNames=[]] FUN:[fqName=foo, hasBlockBody=true, hasBody=true, hasTypeParameterListBeforeFunctionName=false, isExtension=false, isProbablyNothingType=false, isTopLevel=true, name=foo] VALUE_PARAMETER_LIST: - OBJECT_DECLARATION:[fqName=null, isClassObject=false, isLocal=true, isObjectLiteral=false, isTopLevel=false, name=O, superNames=[A, T]] + OBJECT_DECLARATION:[fqName=null, isDefault=false, isLocal=true, isObjectLiteral=false, isTopLevel=false, name=O, superNames=[A, T]] DELEGATION_SPECIFIER_LIST: DELEGATOR_SUPER_CALL: CONSTRUCTOR_CALLEE: diff --git a/idea/testData/stubs/MembersInLocalObject.expected b/idea/testData/stubs/MembersInLocalObject.expected index a9357a528d8..35c0f7a9991 100644 --- a/idea/testData/stubs/MembersInLocalObject.expected +++ b/idea/testData/stubs/MembersInLocalObject.expected @@ -2,7 +2,7 @@ PsiJetFileStubImpl[package=] PACKAGE_DIRECTIVE: FUN:[fqName=f, hasBlockBody=true, hasBody=true, hasTypeParameterListBeforeFunctionName=false, isExtension=false, isProbablyNothingType=false, isTopLevel=true, name=f] VALUE_PARAMETER_LIST: - OBJECT_DECLARATION:[fqName=null, isClassObject=false, isLocal=true, isObjectLiteral=false, isTopLevel=false, name=foo, superNames=[]] + OBJECT_DECLARATION:[fqName=null, isDefault=false, isLocal=true, isObjectLiteral=false, isTopLevel=false, name=foo, superNames=[]] CLASS_BODY: FUN:[fqName=null, hasBlockBody=true, hasBody=true, hasTypeParameterListBeforeFunctionName=false, isExtension=false, isProbablyNothingType=false, isTopLevel=false, name=foo] VALUE_PARAMETER_LIST: diff --git a/idea/testData/stubs/NamedObject.expected b/idea/testData/stubs/NamedObject.expected index 0fdb4d4b00d..fa946c613b9 100644 --- a/idea/testData/stubs/NamedObject.expected +++ b/idea/testData/stubs/NamedObject.expected @@ -2,7 +2,7 @@ PsiJetFileStubImpl[package=] PACKAGE_DIRECTIVE: CLASS:[fqName=A, isEnumEntry=false, isLocal=false, isTopLevel=true, isTrait=false, name=A, superNames=[]] CLASS:[fqName=T, isEnumEntry=false, isLocal=false, isTopLevel=true, isTrait=true, name=T, superNames=[]] - OBJECT_DECLARATION:[fqName=Test, isClassObject=false, isLocal=false, isObjectLiteral=false, isTopLevel=true, name=Test, superNames=[A, T]] + OBJECT_DECLARATION:[fqName=Test, isDefault=false, isLocal=false, isObjectLiteral=false, isTopLevel=true, name=Test, superNames=[A, T]] DELEGATION_SPECIFIER_LIST: DELEGATOR_SUPER_CALL: CONSTRUCTOR_CALLEE: diff --git a/idea/testData/stubs/ObjectInInitializer.expected b/idea/testData/stubs/ObjectInInitializer.expected index efd4eaa6b41..d551da72542 100644 --- a/idea/testData/stubs/ObjectInInitializer.expected +++ b/idea/testData/stubs/ObjectInInitializer.expected @@ -1,7 +1,7 @@ PsiJetFileStubImpl[package=] PACKAGE_DIRECTIVE: PROPERTY:[fqName=p, hasDelegate=false, hasDelegateExpression=false, hasInitializer=true, hasReceiverTypeRef=false, hasReturnTypeRef=false, isProbablyNothingType=false, isTopLevel=true, isVar=false, name=p] - OBJECT_DECLARATION:[fqName=null, isClassObject=false, isLocal=true, isObjectLiteral=true, isTopLevel=false, name=null, superNames=[]] + OBJECT_DECLARATION:[fqName=null, isDefault=false, isLocal=true, isObjectLiteral=true, isTopLevel=false, name=null, superNames=[]] CLASS_BODY: FUN:[fqName=null, hasBlockBody=true, hasBody=true, hasTypeParameterListBeforeFunctionName=false, isExtension=false, isProbablyNothingType=false, isTopLevel=false, name=f] VALUE_PARAMETER_LIST: diff --git a/idea/testData/stubs/ObjectInPropertyDelegate.expected b/idea/testData/stubs/ObjectInPropertyDelegate.expected index 0f23998414e..aa3c4c1b855 100644 --- a/idea/testData/stubs/ObjectInPropertyDelegate.expected +++ b/idea/testData/stubs/ObjectInPropertyDelegate.expected @@ -1,7 +1,7 @@ PsiJetFileStubImpl[package=] PACKAGE_DIRECTIVE: PROPERTY:[fqName=p, hasDelegate=true, hasDelegateExpression=true, hasInitializer=false, hasReceiverTypeRef=false, hasReturnTypeRef=false, isProbablyNothingType=false, isTopLevel=true, isVar=false, name=p] - OBJECT_DECLARATION:[fqName=null, isClassObject=false, isLocal=true, isObjectLiteral=true, isTopLevel=false, name=null, superNames=[]] + OBJECT_DECLARATION:[fqName=null, isDefault=false, isLocal=true, isObjectLiteral=true, isTopLevel=false, name=null, superNames=[]] CLASS_BODY: FUN:[fqName=null, hasBlockBody=true, hasBody=true, hasTypeParameterListBeforeFunctionName=false, isExtension=false, isProbablyNothingType=false, isTopLevel=false, name=f] VALUE_PARAMETER_LIST: diff --git a/idea/tests/org/jetbrains/kotlin/idea/javaFacade/JetJavaFacadeTest.java b/idea/tests/org/jetbrains/kotlin/idea/javaFacade/JetJavaFacadeTest.java index 2804da99fb5..fd9dc820f56 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/javaFacade/JetJavaFacadeTest.java +++ b/idea/tests/org/jetbrains/kotlin/idea/javaFacade/JetJavaFacadeTest.java @@ -200,7 +200,7 @@ public class JetJavaFacadeTest extends JetLightCodeInsightFixtureTestCase { assertTrue(instance.hasModifierProperty(PsiModifier.STATIC)); assertTrue(instance.hasModifierProperty(PsiModifier.FINAL)); - PsiField deprecatedAccessor = theClass.findFieldByName(JvmAbi.DEPRECATED_CLASS_OBJECT_FIELD, false); + PsiField deprecatedAccessor = theClass.findFieldByName(JvmAbi.DEPRECATED_DEFAULT_OBJECT_FIELD, false); assertNotNull(deprecatedAccessor); assertEquals("foo.TheClass." + defaultClassObjectName, deprecatedAccessor.getType().getCanonicalText()); assertTrue(deprecatedAccessor.hasModifierProperty(PsiModifier.PUBLIC)); diff --git a/idea/tests/org/jetbrains/kotlin/idea/stubs/DebugTextByStubTest.kt b/idea/tests/org/jetbrains/kotlin/idea/stubs/DebugTextByStubTest.kt index 7afc5a3bf98..6a4fa9ae439 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/stubs/DebugTextByStubTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/stubs/DebugTextByStubTest.kt @@ -201,9 +201,9 @@ public class DebugTextByStubTest : LightCodeInsightFixtureTestCase() { fun testClassObject() { val tree = createStubTree("class A { class object Def {} }") - val classObject = tree.findChildStubByType(JetStubElementTypes.CLASS)!!.findChildStubByType(JetStubElementTypes.CLASS_BODY)!! + val defaultObject = tree.findChildStubByType(JetStubElementTypes.CLASS)!!.findChildStubByType(JetStubElementTypes.CLASS_BODY)!! .findChildStubByType(JetStubElementTypes.OBJECT_DECLARATION) - assertEquals("STUB: class object Def", JetObjectDeclaration(classObject as KotlinObjectStub).getDebugText()) + assertEquals("STUB: class object Def", JetObjectDeclaration(defaultObject as KotlinObjectStub).getDebugText()) } fun testPropertyAccessors() { diff --git a/idea/tests/org/jetbrains/kotlin/test/ReferenceUtils.java b/idea/tests/org/jetbrains/kotlin/test/ReferenceUtils.java index 44abae5a02e..61f9319f3a6 100644 --- a/idea/tests/org/jetbrains/kotlin/test/ReferenceUtils.java +++ b/idea/tests/org/jetbrains/kotlin/test/ReferenceUtils.java @@ -39,8 +39,8 @@ public final class ReferenceUtils { public static String renderAsGotoImplementation(@NotNull PsiElement element) { PsiElement navigationElement = element.getNavigationElement(); - if (navigationElement instanceof JetObjectDeclaration && ((JetObjectDeclaration) navigationElement).isClassObject()) { - //default presenter return null for class object + if (navigationElement instanceof JetObjectDeclaration && ((JetObjectDeclaration) navigationElement).isDefault()) { + //default presenter return null for default object JetClass containingClass = PsiTreeUtil.getParentOfType(navigationElement, JetClass.class); assert containingClass != null; return "class object of " + renderAsGotoImplementation(containingClass); diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ClassBodyConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/ClassBodyConverter.kt index 4c149f3b430..ac56c202bc3 100644 --- a/j2k/src/org/jetbrains/kotlin/j2k/ClassBodyConverter.kt +++ b/j2k/src/org/jetbrains/kotlin/j2k/ClassBodyConverter.kt @@ -77,10 +77,10 @@ class ClassBodyConverter(private val psiClass: PsiClass, convertedMembers.remove(member) } - val useClassObject = shouldGenerateClassObject(convertedMembers) + val useDefaultObject = shouldGenerateDefaultObject(convertedMembers) val members = ArrayList() - val classObjectMembers = ArrayList() + val defaultObjectMembers = ArrayList() val factoryFunctions = ArrayList() var primaryConstructorSignature: PrimaryConstructorSignature? = null for ((psiMember, member) in convertedMembers) { @@ -92,9 +92,9 @@ class ClassBodyConverter(private val psiClass: PsiClass, else if (member is FactoryFunction) { factoryFunctions.add(member) } - else if (useClassObject - && (if (member is Class) shouldGenerateIntoClassObject(member) else psiMember.hasModifierProperty(PsiModifier.STATIC))) { - classObjectMembers.add(member) + else if (useDefaultObject + && (if (member is Class) shouldGenerateIntoDefaultObject(member) else psiMember.hasModifierProperty(PsiModifier.STATIC))) { + defaultObjectMembers.add(member) } else { members.add(member) @@ -103,7 +103,7 @@ class ClassBodyConverter(private val psiClass: PsiClass, val lBrace = LBrace().assignPrototype(psiClass.getLBrace()) val rBrace = RBrace().assignPrototype(psiClass.getRBrace()) - val classBody = ClassBody(primaryConstructorSignature, constructorConverter?.baseClassParams ?: listOf(), members, classObjectMembers, factoryFunctions, lBrace, rBrace) + val classBody = ClassBody(primaryConstructorSignature, constructorConverter?.baseClassParams ?: listOf(), members, defaultObjectMembers, factoryFunctions, lBrace, rBrace) return if (constructorConverter != null) constructorConverter.postProcessConstructors(classBody) else classBody } @@ -120,17 +120,17 @@ class ClassBodyConverter(private val psiClass: PsiClass, } } - // do not convert private static methods into class object if possible - private fun shouldGenerateClassObject(convertedMembers: Map): Boolean { + // do not convert private static methods into default object if possible + private fun shouldGenerateDefaultObject(convertedMembers: Map): Boolean { if (psiClass.isEnum()) return false - if (convertedMembers.values().any { it is Class && shouldGenerateIntoClassObject(it) }) return true + if (convertedMembers.values().any { it is Class && shouldGenerateIntoDefaultObject(it) }) return true val members = convertedMembers.keySet().filter { !it.isConstructor() } - val classObjectMembers = members.filter { it !is PsiClass && it.hasModifierProperty(PsiModifier.STATIC) } + val defaultObjectMembers = members.filter { it !is PsiClass && it.hasModifierProperty(PsiModifier.STATIC) } val nestedClasses = members.filterIsInstance().filter { it.hasModifierProperty(PsiModifier.STATIC) } - if (classObjectMembers.all { it is PsiMethod && it.hasModifierProperty(PsiModifier.PRIVATE) }) { - return nestedClasses.any { nestedClass -> classObjectMembers.any { converter.referenceSearcher.findMethodCalls(it as PsiMethod, nestedClass).isNotEmpty() } } + if (defaultObjectMembers.all { it is PsiMethod && it.hasModifierProperty(PsiModifier.PRIVATE) }) { + return nestedClasses.any { nestedClass -> defaultObjectMembers.any { converter.referenceSearcher.findMethodCalls(it as PsiMethod, nestedClass).isNotEmpty() } } } else { return true @@ -138,7 +138,7 @@ class ClassBodyConverter(private val psiClass: PsiClass, } // we generate nested classes with factory functions into class object as a workaround until secondary constructors supported by Kotlin - private fun shouldGenerateIntoClassObject(nestedClass: Class) + private fun shouldGenerateIntoDefaultObject(nestedClass: Class) = !nestedClass.modifiers.contains(Modifier.INNER) && nestedClass.body.factoryFunctions.isNotEmpty() private fun processAccessorsToDrop() { diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ConstructorConverter.kt b/j2k/src/org/jetbrains/kotlin/j2k/ConstructorConverter.kt index 68991a006f1..d1e6a14aee9 100644 --- a/j2k/src/org/jetbrains/kotlin/j2k/ConstructorConverter.kt +++ b/j2k/src/org/jetbrains/kotlin/j2k/ConstructorConverter.kt @@ -367,7 +367,7 @@ class ConstructorConverter( val parameterList = ParameterList(parameters).assignNoPrototype() val constructorSignature = PrimaryConstructorSignature(Annotations.Empty, modifiers, parameterList).assignNoPrototype() val updatedMembers = classBody.members.filter { !propertiesToInitialize.contains(it) } - return ClassBody(constructorSignature, classBody.baseClassParams, updatedMembers, classBody.classObjectMembers, classBody.factoryFunctions, classBody.lBrace, classBody.rBrace) + return ClassBody(constructorSignature, classBody.baseClassParams, updatedMembers, classBody.defaultObjectMembers, classBody.factoryFunctions, classBody.lBrace, classBody.rBrace) } private fun processFactoryFunctionsWithConstructorCall(functions: List) { diff --git a/j2k/src/org/jetbrains/kotlin/j2k/Converter.kt b/j2k/src/org/jetbrains/kotlin/j2k/Converter.kt index 0ff5c9b8cb4..1510803ee31 100644 --- a/j2k/src/org/jetbrains/kotlin/j2k/Converter.kt +++ b/j2k/src/org/jetbrains/kotlin/j2k/Converter.kt @@ -213,7 +213,7 @@ class Converter private( // to convert fields and nested types - they are not allowed in Kotlin but we convert them and let user refactor code var classBody = ClassBodyConverter(psiClass, this, false).convertBody() - classBody = ClassBody(constructorSignature, classBody.baseClassParams, classBody.members, classBody.classObjectMembers, listOf(), classBody.lBrace, classBody.rBrace) + classBody = ClassBody(constructorSignature, classBody.baseClassParams, classBody.members, classBody.defaultObjectMembers, listOf(), classBody.lBrace, classBody.rBrace) val annotationAnnotation = Annotation(Identifier("annotation").assignNoPrototype(), listOf(), false, false).assignNoPrototype() return Class(psiClass.declarationIdentifier(), diff --git a/j2k/src/org/jetbrains/kotlin/j2k/ast/ClassBody.kt b/j2k/src/org/jetbrains/kotlin/j2k/ast/ClassBody.kt index c6242566ec3..68765c1f109 100644 --- a/j2k/src/org/jetbrains/kotlin/j2k/ast/ClassBody.kt +++ b/j2k/src/org/jetbrains/kotlin/j2k/ast/ClassBody.kt @@ -24,27 +24,27 @@ class ClassBody ( val primaryConstructorSignature: PrimaryConstructorSignature?, val baseClassParams: List>, val members: List, - val classObjectMembers: List, + val defaultObjectMembers: List, val factoryFunctions: List, val lBrace: LBrace, val rBrace: RBrace) { fun append(builder: CodeBuilder) { val membersFiltered = members.filter { !it.isEmpty } - if (membersFiltered.isEmpty() && classObjectMembers.isEmpty()) return + if (membersFiltered.isEmpty() && defaultObjectMembers.isEmpty()) return builder append " " append lBrace append "\n" builder.append(membersFiltered, "\n") - appendClassObject(builder, membersFiltered.isNotEmpty()) + appendDefaultObject(builder, membersFiltered.isNotEmpty()) builder append "\n" append rBrace } - private fun appendClassObject(builder: CodeBuilder, blankLineBefore: Boolean) { - if (classObjectMembers.isEmpty()) return + private fun appendDefaultObject(builder: CodeBuilder, blankLineBefore: Boolean) { + if (defaultObjectMembers.isEmpty()) return if (blankLineBefore) builder.append("\n\n") - builder.append(classObjectMembers, "\n", "class object {\n", "\n}") + builder.append(defaultObjectMembers, "\n", "class object {\n", "\n}") } } diff --git a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded/build.log b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded/build.log index 0a8d4fef107..28ca5a5e406 100644 --- a/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded/build.log +++ b/jps-plugin/testData/incremental/withJava/javaUsedInKotlin/samConversions/methodAdded/build.log @@ -18,6 +18,6 @@ src/usageWithFunctionLiteral.kt End of files COMPILATION FAILED Expression 'SamInterface' cannot be invoked as a function. The function invoke() is not found -Please specify constructor invocation; classifier 'SamInterface' does not have a class object +Please specify constructor invocation; classifier 'SamInterface' does not have a default object Expression 'SamInterface' cannot be invoked as a function. The function invoke() is not found -Please specify constructor invocation; classifier 'SamInterface' does not have a class object \ No newline at end of file +Please specify constructor invocation; classifier 'SamInterface' does not have a default object \ No newline at end of file diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/Namer.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/Namer.java index ae6c65df5a6..6a538e1a5a0 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/Namer.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/Namer.java @@ -78,8 +78,8 @@ public final class Namer { private static final String RECEIVER_PARAMETER_NAME = "$receiver"; private static final String THROW_NPE_FUN_NAME = "throwNPE"; - private static final String CLASS_OBJECT_GETTER = "object"; - private static final String CLASS_OBJECT_INITIALIZER = "object_initializer$"; + private static final String DEFAULT_OBJECT_GETTER = "object"; + private static final String DEFAULT_OBJECT_INITIALIZER = "object_initializer$"; private static final String PROTOTYPE_NAME = "prototype"; public static final String CAPTURED_VAR_FIELD = "v"; @@ -141,13 +141,13 @@ public final class Namer { } @NotNull - public static JsExpression getClassObjectAccessor(@NotNull JsExpression referenceToClass) { - return new JsNameRef(CLASS_OBJECT_GETTER, referenceToClass); + public static JsExpression getDefaultObjectAccessor(@NotNull JsExpression referenceToClass) { + return new JsNameRef(DEFAULT_OBJECT_GETTER, referenceToClass); } @NotNull - public static String getNameForClassObjectInitializer() { - return CLASS_OBJECT_INITIALIZER; + public static String getNameForDefaultObjectInitializer() { + return DEFAULT_OBJECT_INITIALIZER; } @NotNull diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/StaticContext.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/StaticContext.java index 47fd6ee5401..6ec1de05260 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/StaticContext.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/context/StaticContext.java @@ -267,10 +267,10 @@ public final class StaticContext { return scope.declareFreshName(getSuggestedName(descriptor)); } }; - Rule constructorOrClassObjectHasTheSameNameAsTheClass = new Rule() { + Rule constructorOrDefaultObjectHasTheSameNameAsTheClass = new Rule() { @Override public JsName apply(@NotNull DeclarationDescriptor descriptor) { - if (descriptor instanceof ConstructorDescriptor || (DescriptorUtils.isClassObject(descriptor))) { + if (descriptor instanceof ConstructorDescriptor || (DescriptorUtils.isDefaultObject(descriptor))) { //noinspection ConstantConditions return getNameForDescriptor(descriptor.getContainingDeclaration()); } @@ -355,7 +355,7 @@ public final class StaticContext { addRule(namesForDynamic); addRule(namesForStandardClasses); - addRule(constructorOrClassObjectHasTheSameNameAsTheClass); + addRule(constructorOrDefaultObjectHasTheSameNameAsTheClass); addRule(propertyOrPropertyAccessor); addRule(predefinedObjectsHasUnobfuscatableNames); addRule(overridingDescriptorsReferToOriginalName); @@ -501,10 +501,10 @@ public final class StaticContext { return element.getContainingFile().getUserData(LibrarySourcesConfig.EXTERNAL_MODULE_NAME); } }; - Rule constructorOrClassObjectHasTheSameQualifierAsTheClass = new Rule() { + Rule constructorOrDefaultObjectHasTheSameQualifierAsTheClass = new Rule() { @Override public JsExpression apply(@NotNull DeclarationDescriptor descriptor) { - if (descriptor instanceof ConstructorDescriptor || DescriptorUtils.isClassObject(descriptor)) { + if (descriptor instanceof ConstructorDescriptor || DescriptorUtils.isDefaultObject(descriptor)) { //noinspection ConstantConditions return getQualifierForDescriptor(descriptor.getContainingDeclaration()); } @@ -548,7 +548,7 @@ public final class StaticContext { }; addRule(libraryObjectsHaveKotlinQualifier); - addRule(constructorOrClassObjectHasTheSameQualifierAsTheClass); + addRule(constructorOrDefaultObjectHasTheSameQualifierAsTheClass); addRule(standardObjectsHaveKotlinQualifier); addRule(packageLevelDeclarationsHaveEnclosingPackagesNamesAsQualifier); addRule(nativeObjectsHaveNativePartOfFullQualifier); 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 74d5d92727f..fd1c74e4554 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 @@ -124,7 +124,7 @@ public final class ClassTranslator extends AbstractTranslator { declarationContext = declarationContext.newDeclaration(descriptor, definitionPlace); } - declarationContext = fixContextForClassObjectAccessing(declarationContext); + declarationContext = fixContextForDefaultObjectAccessing(declarationContext); invocationArguments.add(getSuperclassReferences(declarationContext)); DelegationTranslator delegationTranslator = new DelegationTranslator(classDeclaration, context()); @@ -171,15 +171,15 @@ public final class ClassTranslator extends AbstractTranslator { return invocationArguments; } - private TranslationContext fixContextForClassObjectAccessing(TranslationContext declarationContext) { - // In Kotlin we can access to class object members without qualifier just by name, but we should translate it to access with FQ name. - // So create alias for class object receiver parameter. - ClassDescriptor classObjectDescriptor = descriptor.getDefaultObjectDescriptor(); - if (classObjectDescriptor != null) { - JsExpression referenceToClass = translateAsFQReference(classObjectDescriptor.getContainingDeclaration(), declarationContext); - JsExpression classObjectAccessor = Namer.getClassObjectAccessor(referenceToClass); - ReceiverParameterDescriptor classObjectReceiver = getReceiverParameterForDeclaration(classObjectDescriptor); - declarationContext.aliasingContext().registerAlias(classObjectReceiver, classObjectAccessor); + private TranslationContext fixContextForDefaultObjectAccessing(TranslationContext declarationContext) { + // In Kotlin we can access to default object members without qualifier just by name, but we should translate it to access with FQ name. + // So create alias for default object receiver parameter. + ClassDescriptor defaultObjectDescriptor = descriptor.getDefaultObjectDescriptor(); + if (defaultObjectDescriptor != null) { + JsExpression referenceToClass = translateAsFQReference(defaultObjectDescriptor.getContainingDeclaration(), declarationContext); + JsExpression defaultObjectAccessor = Namer.getDefaultObjectAccessor(referenceToClass); + ReceiverParameterDescriptor defaultObjectReceiver = getReceiverParameterForDeclaration(defaultObjectDescriptor); + declarationContext.aliasingContext().registerAlias(defaultObjectReceiver, defaultObjectAccessor); } // Overlap alias of class object receiver for accessing from containing class(see previous if block), diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/DeclarationBodyVisitor.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/DeclarationBodyVisitor.java index 0ebad4b0d21..2ec1796cdde 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/DeclarationBodyVisitor.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/DeclarationBodyVisitor.java @@ -38,7 +38,7 @@ import org.jetbrains.kotlin.types.JetType; import java.util.List; -import static org.jetbrains.kotlin.js.translate.initializer.InitializerUtils.createClassObjectInitializer; +import static org.jetbrains.kotlin.js.translate.initializer.InitializerUtils.createDefaultObjectInitializer; import static org.jetbrains.kotlin.js.translate.utils.BindingUtils.getClassDescriptor; import static org.jetbrains.kotlin.js.translate.utils.BindingUtils.getFunctionDescriptor; import static org.jetbrains.kotlin.js.translate.utils.JsDescriptorUtils.getSupertypesWithoutFakes; @@ -85,7 +85,7 @@ public class DeclarationBodyVisitor extends TranslatorVisitor { @Override public Void visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, TranslationContext context) { - if (!declaration.isClassObject()) { + if (!declaration.isDefault()) { // parsed it in initializer visitor => no additional actions are needed return null; } @@ -93,7 +93,7 @@ public class DeclarationBodyVisitor extends TranslatorVisitor { ClassDescriptor descriptor = getClassDescriptor(context.bindingContext(), declaration); JsFunction fun = TranslationUtils.simpleReturnFunction(context.getScopeForDescriptor(descriptor), value); - staticResult.add(createClassObjectInitializer(fun, context)); + staticResult.add(createDefaultObjectInitializer(fun, context)); return null; } diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerUtils.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerUtils.java index be2e0469cf5..ae6ab642878 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerUtils.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerUtils.java @@ -70,8 +70,8 @@ public final class InitializerUtils { initializers.add(expression.makeStmt()); } - public static JsPropertyInitializer createClassObjectInitializer(JsExpression value, TranslationContext context) { - JsStringLiteral classObjectInitStr = context.program().getStringLiteral(Namer.getNameForClassObjectInitializer()); - return new JsPropertyInitializer(classObjectInitStr, value); + public static JsPropertyInitializer createDefaultObjectInitializer(JsExpression value, TranslationContext context) { + JsStringLiteral defaultObjectInitStr = context.program().getStringLiteral(Namer.getNameForDefaultObjectInitializer()); + return new JsPropertyInitializer(defaultObjectInitStr, value); } } diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerVisitor.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerVisitor.java index 292ac2c0e99..06d482ed7ce 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerVisitor.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/initializer/InitializerVisitor.java @@ -65,7 +65,7 @@ public final class InitializerVisitor extends TranslatorVisitor { @Override public Void visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, @NotNull TranslationContext context) { - if (!declaration.isClassObject()) { + if (!declaration.isDefault()) { InitializerUtils.generateObjectInitializer(declaration, result, context); } return null; diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ClassObjectAccessTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/DefaultObjectAccessTranslator.java similarity index 74% rename from js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ClassObjectAccessTranslator.java rename to js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/DefaultObjectAccessTranslator.java index 2de787e855e..3399c8fcba8 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ClassObjectAccessTranslator.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/DefaultObjectAccessTranslator.java @@ -36,45 +36,49 @@ import static org.jetbrains.kotlin.js.translate.utils.BindingUtils.getDescriptor import static org.jetbrains.kotlin.resolve.DescriptorUtils.isEnumEntry; import static org.jetbrains.kotlin.resolve.DescriptorUtils.isObject; -public class ClassObjectAccessTranslator extends AbstractTranslator implements CachedAccessTranslator { +public class DefaultObjectAccessTranslator extends AbstractTranslator implements CachedAccessTranslator { @NotNull - /*package*/ static ClassObjectAccessTranslator newInstance(@NotNull JetSimpleNameExpression expression, - @NotNull TranslationContext context) { + /*package*/ static DefaultObjectAccessTranslator newInstance( + @NotNull JetSimpleNameExpression expression, + @NotNull TranslationContext context + ) { DeclarationDescriptor referenceDescriptor = getDescriptorForReferenceExpression(context.bindingContext(), expression); assert referenceDescriptor != null : "JetSimpleName expression must reference a descriptor " + expression.getText(); - return new ClassObjectAccessTranslator(referenceDescriptor, context); + return new DefaultObjectAccessTranslator(referenceDescriptor, context); } - /*package*/ static boolean isClassObjectReference(@NotNull JetReferenceExpression expression, - @NotNull TranslationContext context) { + /*package*/ static boolean isDefaultObjectReference( + @NotNull JetReferenceExpression expression, + @NotNull TranslationContext context + ) { DeclarationDescriptor descriptor = getDescriptorForReferenceExpression(context.bindingContext(), expression); return descriptor instanceof ClassDescriptor && !AnnotationsUtils.isNativeObject(descriptor); } @NotNull - private final JsExpression referenceToClassObject; + private final JsExpression referenceToDefaultObject; - private ClassObjectAccessTranslator(@NotNull DeclarationDescriptor descriptor, @NotNull TranslationContext context) { + private DefaultObjectAccessTranslator(@NotNull DeclarationDescriptor descriptor, @NotNull TranslationContext context) { super(context); JsExpression fqReference = translateAsFQReference(descriptor, context()); if (isObject(descriptor) || isEnumEntry(descriptor)) { - this.referenceToClassObject = fqReference; + this.referenceToDefaultObject = fqReference; } else { - this.referenceToClassObject = Namer.getClassObjectAccessor(fqReference); + this.referenceToDefaultObject = Namer.getDefaultObjectAccessor(fqReference); } } @Override @NotNull public JsExpression translateAsGet() { - return referenceToClassObject; + return referenceToDefaultObject; } @Override @NotNull public JsExpression translateAsSet(@NotNull JsExpression toSetTo) { - throw new IllegalStateException("Class object can't set"); + throw new IllegalStateException("default object can't be set"); } @NotNull diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ReferenceTranslator.java b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ReferenceTranslator.java index cce1f41ae5f..e6ef3180d6c 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ReferenceTranslator.java +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/reference/ReferenceTranslator.java @@ -56,14 +56,14 @@ public final class ReferenceTranslator { // Ignore qualifier if expression is EnumEntry or default object reference and use always use FQ name. DeclarationDescriptor descriptor = BindingUtils.getDescriptorForReferenceExpression(context.bindingContext(), expression); //TODO: should go away when objects inside classes are supported - if (DescriptorUtils.isClassObject(descriptor) && !AnnotationsUtils.isNativeObject(descriptor)) { + if (DescriptorUtils.isDefaultObject(descriptor) && !AnnotationsUtils.isNativeObject(descriptor)) { return simpleName; } if (descriptor instanceof ClassDescriptor) { ClassDescriptor entryClass = (ClassDescriptor) descriptor; if (entryClass.getKind() == ClassKind.ENUM_ENTRY) { DeclarationDescriptor enumClass = entryClass.getContainingDeclaration(); - qualifier = Namer.getClassObjectAccessor(translateAsFQReference(enumClass, context)); + qualifier = Namer.getDefaultObjectAccessor(translateAsFQReference(enumClass, context)); } } @@ -109,8 +109,8 @@ public final class ReferenceTranslator { if (canBePropertyAccess(referenceExpression, context)) { return VariableAccessTranslator.newInstance(context, referenceExpression, receiver); } - if (ClassObjectAccessTranslator.isClassObjectReference(referenceExpression, context)) { - return ClassObjectAccessTranslator.newInstance(referenceExpression, context); + if (DefaultObjectAccessTranslator.isDefaultObjectReference(referenceExpression, context)) { + return DefaultObjectAccessTranslator.newInstance(referenceExpression, context); } return ReferenceAccessTranslator.newInstance(referenceExpression, context); }