From a57f74c278b182c94ae7ec360927a561ddfa47f6 Mon Sep 17 00:00:00 2001 From: "Pavel V. Talanov" Date: Wed, 3 Jul 2013 16:39:54 +0400 Subject: [PATCH] Introduce VariableDescriptorForObject interface Add implementations Use this interface instead of CLASS_OBJECT_DECLARATION key in BindingContext --- .../jet/codegen/ExpressionCodegen.java | 10 +- .../java/resolver/JavaPropertyResolver.java | 110 ++++++++++-------- .../DeserializedClassDescriptor.java | 6 +- .../jetbrains/jet/lang/cfg/WhenChecker.java | 9 +- .../VariableDescriptorForObject.java | 24 ++++ .../LocalVariableDescriptorForObject.java | 47 ++++++++ .../impl/PropertyDescriptorForObjectImpl.java | 46 ++++++++ .../jet/lang/resolve/BindingContext.java | 2 - .../jet/lang/resolve/DescriptorResolver.java | 13 +-- .../resolve/QualifiedExpressionResolver.java | 3 +- .../recursiveProcessor/declarations.txt | 6 +- .../AnnotationDescriptorResolveTest.java | 7 +- .../libraries/DecompiledDataFactory.java | 13 +-- .../k2js/translate/context/StaticContext.java | 2 +- .../translate/reference/CallTranslator.java | 2 +- .../k2js/translate/utils/BindingUtils.java | 7 +- 16 files changed, 209 insertions(+), 98 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorForObject.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/LocalVariableDescriptorForObject.java create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/PropertyDescriptorForObjectImpl.java diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index e7e5969e585..55aa5f13e1b 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -1639,12 +1639,10 @@ public class ExpressionCodegen extends JetVisitor implem assert descriptor != null; - if (descriptor instanceof VariableDescriptor) { - VariableDescriptor variableDescriptor = (VariableDescriptor) descriptor; - ClassDescriptor objectClassDescriptor = getBindingContext().get(BindingContext.OBJECT_DECLARATION_CLASS, variableDescriptor); - if (objectClassDescriptor != null) { - return genObjectClassInstance(variableDescriptor, objectClassDescriptor); - } + if (descriptor instanceof VariableDescriptorForObject) { + VariableDescriptorForObject variableDescriptor = (VariableDescriptorForObject) descriptor; + ClassDescriptor objectClassDescriptor = variableDescriptor.getObjectClass(); + return genObjectClassInstance(variableDescriptor, objectClassDescriptor); } int index = lookupLocalIndex(descriptor); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java index 5720faeda56..1fcb6a6da86 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java @@ -181,32 +181,7 @@ public final class JavaPropertyResolver { kind = DescriptorKindUtils.flagsToKind(methodAnnotation.kind()); } - boolean isEnumEntry = psiData.getCharacteristicPsi() instanceof PsiEnumConstant; - PropertyDescriptorImpl propertyDescriptor = new PropertyDescriptorImpl( - owner, - annotationResolver.resolveAnnotations(psiData.getCharacteristicPsi()), - DescriptorResolverUtils.resolveModality(characteristicMember.getMember(), - isFinal || isEnumEntry || psiData.isPropertyForNamedObject()), - visibility, - isVar, - propertyName, - kind); - - //TODO: this is a hack to indicate that this enum entry is an object - // class descriptor for enum entries is not used by backends so for now this should be safe to use - // remove this when JavaDescriptorResolver gets rewritten - if (isEnumEntry) { - assert DescriptorUtils.isEnumClassObject(owner) : "Enum entries should be put into class object of enum only: " + owner; - ClassDescriptorImpl dummyClassDescriptorForEnumEntryObject = - new ClassDescriptorImpl(owner, Collections.emptyList(), Modality.FINAL, propertyName); - dummyClassDescriptorForEnumEntryObject.initialize( - true, - Collections.emptyList(), - Collections.emptyList(), JetScope.EMPTY, - Collections.emptySet(), null, - false); - trace.record(BindingContext.OBJECT_DECLARATION_CLASS, propertyDescriptor, dummyClassDescriptorForEnumEntryObject); - } + PropertyDescriptorImpl propertyDescriptor = createPropertyDescriptor(owner, propertyName, psiData, isFinal, isVar, visibility, kind); PropertyGetterDescriptorImpl getterDescriptor = resolveGetter(visibility, kind, getter, propertyDescriptor); PropertySetterDescriptorImpl setterDescriptor = resolveSetter(psiData, kind, propertyDescriptor); @@ -221,7 +196,6 @@ public final class JavaPropertyResolver { JetType propertyType = getPropertyType(psiData, characteristicMember, typeVariableResolverForPropertyInternals); JetType receiverType = getReceiverType(characteristicMember, typeVariableResolverForPropertyInternals); - propertyType = getAlternativeSignatureData(isVar, characteristicMember, propertyDescriptor, propertyType); propertyDescriptor.setType( @@ -236,8 +210,6 @@ public final class JavaPropertyResolver { trace.record(BindingContext.VARIABLE, psiData.getCharacteristicPsi(), propertyDescriptor); } - recordObjectDeclarationClassIfNeeded(psiData, owner, propertyDescriptor, propertyType); - if (scopeData.getDeclarationOrigin() == JAVA) { trace.record(JavaBindingContext.IS_DECLARED_IN_JAVA, propertyDescriptor); } @@ -255,6 +227,62 @@ public final class JavaPropertyResolver { return propertyDescriptor; } + @NotNull + private PropertyDescriptorImpl createPropertyDescriptor( + @NotNull ClassOrNamespaceDescriptor owner, + @NotNull Name propertyName, + @NotNull PropertyPsiData psiData, + boolean isFinal, + boolean isVar, + @NotNull Visibility visibility, + @NotNull CallableMemberDescriptor.Kind kind + ) { + boolean isEnumEntry = psiData.getCharacteristicPsi() instanceof PsiEnumConstant; + if (isEnumEntry) { + assert !isVar && isFinal : "Enum entries should be final and immutable."; + assert DescriptorUtils.isEnumClassObject(owner) : "Enum entries should be put into class object of enum only: " + owner; + //TODO: this is a hack to indicate that this enum entry is an object + // class descriptor for enum entries is not used by backends so for now this should be safe to use + ClassDescriptorImpl dummyClassDescriptorForEnumEntryObject = + new ClassDescriptorImpl(owner, Collections.emptyList(), Modality.FINAL, propertyName); + dummyClassDescriptorForEnumEntryObject.initialize( + true, + Collections.emptyList(), + Collections.emptyList(), JetScope.EMPTY, + Collections.emptySet(), null, + false); + return new PropertyDescriptorForObjectImpl( + owner, + annotationResolver.resolveAnnotations(psiData.getCharacteristicPsi()), + visibility, + propertyName, + dummyClassDescriptorForEnumEntryObject); + } + else if (psiData.isPropertyForNamedObject() && owner instanceof NamespaceDescriptor) { + //TODO: support nested classes and objects + assert !isVar && isFinal : "Objects should be final and immutable."; + ClassDescriptor objectClass = ((NamespaceDescriptor) owner).getMemberScope().getObjectDescriptor(propertyName); + assert objectClass != null; + return new PropertyDescriptorForObjectImpl( + owner, + annotationResolver.resolveAnnotations(psiData.getCharacteristicPsi()), + visibility, + propertyName, + objectClass); + } + else { + return new PropertyDescriptorImpl( + owner, + annotationResolver.resolveAnnotations(psiData.getCharacteristicPsi()), + DescriptorResolverUtils.resolveModality(psiData.getCharacteristicMember().getMember(), + isFinal || psiData.isPropertyForNamedObject()), + visibility, + isVar, + propertyName, + kind); + } + } + @NotNull private JetType getAlternativeSignatureData( boolean isVar, @@ -307,24 +335,6 @@ public final class JavaPropertyResolver { } } - private void recordObjectDeclarationClassIfNeeded( - PropertyPsiData psiData, - DeclarationDescriptor realOwner, - PropertyDescriptor propertyDescriptor, - JetType propertyType - ) { - if (!psiData.isPropertyForNamedObject()) { - return; - } - ClassDescriptor objectDescriptor = (ClassDescriptor) propertyType.getConstructor().getDeclarationDescriptor(); - - assert objectDescriptor != null; - assert objectDescriptor.getKind() == ClassKind.OBJECT; - assert objectDescriptor.getContainingDeclaration() == realOwner; - - trace.record(BindingContext.OBJECT_DECLARATION_CLASS, propertyDescriptor, objectDescriptor); - } - @Nullable private PropertyGetterDescriptorImpl resolveGetter( Visibility visibility, @@ -418,9 +428,11 @@ public final class JavaPropertyResolver { return null; } if (!characteristicMember.getReceiverType().getTypeString().isEmpty()) { - return semanticServices.getTypeTransformer().transformToType(characteristicMember.getReceiverType().getTypeString(), typeVariableResolverForPropertyInternals); + return semanticServices.getTypeTransformer() + .transformToType(characteristicMember.getReceiverType().getTypeString(), typeVariableResolverForPropertyInternals); } - return semanticServices.getTypeTransformer().transformToType(characteristicMember.getReceiverType().getPsiType(), typeVariableResolverForPropertyInternals); + return semanticServices.getTypeTransformer() + .transformToType(characteristicMember.getReceiverType().getPsiType(), typeVariableResolverForPropertyInternals); } private static int getNumberOfNonExtensionProperties(@NotNull Collection propertyPsiDataCollection) { diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java index f9a65793ba0..457108ed7c6 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedClassDescriptor.java @@ -295,9 +295,9 @@ public class DeserializedClassDescriptor extends ClassDescriptorBase implements } private void createEnumEntry(@NotNull MutableClassDescriptor enumClassObject, @NotNull Name name) { - PropertyDescriptorImpl property = new PropertyDescriptorImpl(enumClassObject, Collections.emptyList(), - Modality.FINAL, Visibilities.PUBLIC, false, name, - CallableMemberDescriptor.Kind.DECLARATION); + PropertyDescriptorImpl property = new PropertyDescriptorForObjectImpl(enumClassObject, + Collections.emptyList(), + Visibilities.PUBLIC, name, this); property.setType(getDefaultType(), Collections.emptyList(), enumClassObject.getThisAsReceiverParameter(), NO_RECEIVER_PARAMETER); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/WhenChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/WhenChecker.java index 8808288a0db..2cc4d0ae3a3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/WhenChecker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/WhenChecker.java @@ -18,10 +18,7 @@ package org.jetbrains.jet.lang.cfg; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ClassKind; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.VariableDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; @@ -90,11 +87,11 @@ public final class WhenChecker { if (reference == null) return false; DeclarationDescriptor target = trace.get(BindingContext.REFERENCE_TARGET, reference); - if (!(target instanceof VariableDescriptor)) { + if (!(target instanceof VariableDescriptorForObject)) { return false; } - ClassDescriptor classDescriptor = trace.get(BindingContext.OBJECT_DECLARATION_CLASS, (VariableDescriptor) target); + ClassDescriptor classDescriptor = ((VariableDescriptorForObject) target).getObjectClass(); return classDescriptor == enumEntry; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorForObject.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorForObject.java new file mode 100644 index 00000000000..17267cf8f34 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableDescriptorForObject.java @@ -0,0 +1,24 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.descriptors; + +import org.jetbrains.annotations.NotNull; + +public interface VariableDescriptorForObject extends VariableDescriptor { + @NotNull + ClassDescriptor getObjectClass(); +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/LocalVariableDescriptorForObject.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/LocalVariableDescriptorForObject.java new file mode 100644 index 00000000000..3911ff7d706 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/LocalVariableDescriptorForObject.java @@ -0,0 +1,47 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.descriptors.impl; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.VariableDescriptorForObject; +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; +import org.jetbrains.jet.lang.resolve.name.Name; + +import java.util.List; + +public class LocalVariableDescriptorForObject extends LocalVariableDescriptor implements VariableDescriptorForObject { + + private final ClassDescriptor objectClass; + + public LocalVariableDescriptorForObject( + @NotNull DeclarationDescriptor containingDeclaration, + @NotNull List annotations, + @NotNull Name name, + @NotNull ClassDescriptor objectClass + ) { + super(containingDeclaration, annotations, name, objectClass.getDefaultType(), false); + this.objectClass = objectClass; + } + + @NotNull + @Override + public ClassDescriptor getObjectClass() { + return objectClass; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/PropertyDescriptorForObjectImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/PropertyDescriptorForObjectImpl.java new file mode 100644 index 00000000000..95e468ae3f0 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/PropertyDescriptorForObjectImpl.java @@ -0,0 +1,46 @@ +/* + * Copyright 2010-2013 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.descriptors.impl; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; +import org.jetbrains.jet.lang.resolve.name.Name; + +import java.util.List; + +public class PropertyDescriptorForObjectImpl extends PropertyDescriptorImpl implements VariableDescriptorForObject { + + private final ClassDescriptor objectClass; + + public PropertyDescriptorForObjectImpl( + @NotNull DeclarationDescriptor containingDeclaration, + @NotNull List annotations, + @NotNull Visibility visibility, + @NotNull Name name, + @NotNull ClassDescriptor objectClass + ) { + super(containingDeclaration, annotations, Modality.FINAL, visibility, false, name, Kind.DECLARATION); + this.objectClass = objectClass; + } + + @NotNull + @Override + public ClassDescriptor getObjectClass() { + return objectClass; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java index 530749a1dd8..8f792fe371c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java @@ -142,8 +142,6 @@ public interface BindingContext { WritableSlice, Boolean> DEFERRED_TYPE = Slices.createCollectiveSetSlice(); - WritableSlice OBJECT_DECLARATION_CLASS = Slices.createSimpleSlice(); - WritableSlice BACKING_FIELD_REQUIRED = new Slices.SetSlice(DO_NOTHING) { @Override public Boolean computeValue( diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java index 7de7dfd3a8a..989d673c815 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -840,19 +840,16 @@ public class DescriptorResolver { @NotNull ClassDescriptor classDescriptor, BindingTrace trace ) { JetModifierList modifierList = objectDeclaration.getModifierList(); - PropertyDescriptorImpl propertyDescriptor = new PropertyDescriptorImpl( + PropertyDescriptorImpl propertyDescriptor = new PropertyDescriptorForObjectImpl( containingDeclaration, annotationResolver.getResolvedAnnotations(modifierList, trace), - Modality.FINAL, resolveVisibilityFromModifiers(objectDeclaration, getDefaultVisibilityForObjectPropertyDescriptor(classDescriptor)), - false, JetPsiUtil.safeName(objectDeclaration.getName()), - CallableMemberDescriptor.Kind.DECLARATION + classDescriptor ); propertyDescriptor.setType(getTypeForObjectDeclaration(classDescriptor), Collections.emptyList(), getExpectedThisObjectIfNeeded(containingDeclaration), NO_RECEIVER_PARAMETER); propertyDescriptor.initialize(null, null); - trace.record(BindingContext.OBJECT_DECLARATION_CLASS, propertyDescriptor, classDescriptor); JetObjectDeclarationName nameAsDeclaration = objectDeclaration.getNameAsDeclaration(); if (nameAsDeclaration != null) { trace.record(BindingContext.OBJECT_DECLARATION, nameAsDeclaration, propertyDescriptor); @@ -878,13 +875,11 @@ public class DescriptorResolver { @NotNull JetClassOrObject objectDeclaration, @NotNull ClassDescriptor classDescriptor, BindingTrace trace ) { - VariableDescriptorImpl variableDescriptor = new LocalVariableDescriptor( + VariableDescriptorImpl variableDescriptor = new LocalVariableDescriptorForObject( containingDeclaration, annotationResolver.getResolvedAnnotations(objectDeclaration.getModifierList(), trace), JetPsiUtil.safeName(objectDeclaration.getName()), - classDescriptor.getDefaultType(), - /*isVar =*/ false); - trace.record(BindingContext.OBJECT_DECLARATION_CLASS, variableDescriptor, classDescriptor); + classDescriptor); JetObjectDeclarationName nameAsDeclaration = objectDeclaration.getNameAsDeclaration(); if (nameAsDeclaration != null) { trace.record(BindingContext.VARIABLE, nameAsDeclaration, variableDescriptor); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java index 0163c60f60f..5ee455ea3ab 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java @@ -325,8 +325,7 @@ public class QualifiedExpressionResolver { public boolean apply(@Nullable DeclarationDescriptor descriptor) { return (descriptor instanceof NamespaceDescriptor) || (descriptor instanceof ClassifierDescriptor) || - ((descriptor instanceof PropertyDescriptor) && - (trace.get(BindingContext.OBJECT_DECLARATION_CLASS, ((PropertyDescriptor) descriptor)) != null)); + (descriptor instanceof VariableDescriptorForObject); } })); } diff --git a/compiler/testData/recursiveProcessor/declarations.txt b/compiler/testData/recursiveProcessor/declarations.txt index a64a5a01527..89fd476d728 100644 --- a/compiler/testData/recursiveProcessor/declarations.txt +++ b/compiler/testData/recursiveProcessor/declarations.txt @@ -25,7 +25,7 @@ Object.():ConstructorDescriptor Object.nestedFunc:SimpleFunctionDescriptor Object.this:ReceiverParameterDescriptor Object:ClassDescriptor -Outer.Object:PropertyDescriptor +Outer.Object:VariableDescriptorForObject Outer.this:ReceiverParameterDescriptor Outer:ClassDescriptor T1:TypeParameterDescriptor @@ -46,11 +46,11 @@ func.this:ReceiverParameterDescriptor innerTest.:PropertyGetterDescriptor innerTest.:PropertyGetterDescriptor innerTest.:PropertySetterDescriptor -innerTest.Object:PropertyDescriptor +innerTest.Object:VariableDescriptorForObject innerTest.func:SimpleFunctionDescriptor innerTest.prop:PropertyDescriptor innerTest.propVar:PropertyDescriptor innerTest:NamespaceDescriptor prop.this:ReceiverParameterDescriptor prop.this:ReceiverParameterDescriptor -test:NamespaceDescriptor +test:NamespaceDescriptor \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/resolve/annotation/AnnotationDescriptorResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/annotation/AnnotationDescriptorResolveTest.java index e689c63f531..9f29ccf454b 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/annotation/AnnotationDescriptorResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/annotation/AnnotationDescriptorResolveTest.java @@ -254,10 +254,9 @@ public class AnnotationDescriptorResolveTest extends JetLiteFixture { @NotNull private ClassDescriptor getLocalObjectDescriptor(@NotNull String name) { - for (ClassDescriptor descriptor : context.getSliceContents(BindingContext.OBJECT_DECLARATION_CLASS).values()) { - if (descriptor.getName().asString().equals(name)) { - return descriptor; - } + ClassDescriptor localClassDescriptor = getLocalClassDescriptor(name); + if (localClassDescriptor.getKind() == ClassKind.OBJECT) { + return localClassDescriptor; } fail("Failed to find local object " + name); diff --git a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java index 65949436084..339ab450343 100644 --- a/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java +++ b/idea/src/org/jetbrains/jet/plugin/libraries/DecompiledDataFactory.java @@ -33,7 +33,6 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.MemberComparator; import org.jetbrains.jet.lang.resolve.java.*; -import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.renderer.DescriptorRenderer; import org.jetbrains.jet.renderer.DescriptorRendererBuilder; @@ -84,7 +83,7 @@ public class DecompiledDataFactory { if (nd != null) { for (DeclarationDescriptor member : sortDeclarations(nd.getMemberScope().getAllDescriptors())) { if (member instanceof ClassDescriptor || member instanceof NamespaceDescriptor - || isNamedObjectProperty(member, bindingContext)) { + || isNamedObjectProperty(member)) { continue; } appendDescriptor(member, ""); @@ -159,7 +158,7 @@ public class DecompiledDataFactory { if (member instanceof CallableMemberDescriptor && ((CallableMemberDescriptor) member).getKind() != CallableMemberDescriptor.Kind.DECLARATION) { continue; } - if (isNamedObjectProperty(member, bindingContext)) { + if (isNamedObjectProperty(member)) { continue; } @@ -201,10 +200,10 @@ public class DecompiledDataFactory { } } - private static boolean isNamedObjectProperty(@NotNull DeclarationDescriptor descriptor, BindingContext bindingContext) { - if (descriptor instanceof PropertyDescriptor) { - ClassDescriptor objectDeclaration = bindingContext.get(BindingContext.OBJECT_DECLARATION_CLASS, (PropertyDescriptor) descriptor); - if (objectDeclaration != null && objectDeclaration.getKind() == ClassKind.OBJECT) { + private static boolean isNamedObjectProperty(@NotNull DeclarationDescriptor descriptor) { + if (descriptor instanceof PropertyDescriptor && descriptor instanceof VariableDescriptorForObject) { + ClassDescriptor objectClass = ((VariableDescriptorForObject) descriptor).getObjectClass(); + if (objectClass.getKind() == ClassKind.OBJECT) { return true; } } diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java b/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java index 107c5ed9c8c..80b2e53fbef 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/context/StaticContext.java @@ -225,7 +225,7 @@ public final class StaticContext { PropertyAccessorDescriptor accessorDescriptor = (PropertyAccessorDescriptor) descriptor; String propertyName = accessorDescriptor.getCorrespondingProperty().getName().asString(); - if (isObjectDeclaration(bindingContext, accessorDescriptor.getCorrespondingProperty())) { + if (isObjectDeclaration(accessorDescriptor.getCorrespondingProperty())) { return declareName(descriptor, propertyName); } diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallTranslator.java b/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallTranslator.java index 8d9d5a3bc50..475bc6cb7b1 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallTranslator.java @@ -195,7 +195,7 @@ public final class CallTranslator extends AbstractTranslator { private boolean isObjectAccessor(@NotNull PropertyAccessorDescriptor propertyAccessorDescriptor) { PropertyDescriptor correspondingProperty = propertyAccessorDescriptor.getCorrespondingProperty(); - return isObjectDeclaration(bindingContext(), correspondingProperty); + return isObjectDeclaration(correspondingProperty); } @NotNull diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/utils/BindingUtils.java b/js/js.translator/src/org/jetbrains/k2js/translate/utils/BindingUtils.java index b1b1ef15dcc..fc55ef7b428 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/utils/BindingUtils.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/utils/BindingUtils.java @@ -264,10 +264,7 @@ public final class BindingUtils { return bindingContext.get(BindingContext.FUNCTION, function); } - public static boolean isObjectDeclaration( - @NotNull BindingContext bindingContext, - @NotNull PropertyDescriptor propertyDescriptor - ) { - return bindingContext.get(BindingContext.OBJECT_DECLARATION_CLASS, propertyDescriptor) != null; + public static boolean isObjectDeclaration(@NotNull PropertyDescriptor propertyDescriptor) { + return propertyDescriptor instanceof VariableDescriptorForObject; } }