diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java index c1fe753b8a8..c6d0248aeee 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java @@ -27,8 +27,11 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.name.Name; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeUtils; +import org.jetbrains.jet.lang.types.checker.JetTypeChecker; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.Collections; import java.util.List; @@ -196,9 +199,26 @@ public abstract class ClassBodyCodegen extends MemberCodegen { private void generateRemoveInIterator() { // generates stub 'remove' function for subclasses of Iterator to be compatible with java.util.Iterator - if (DescriptorUtils.isIteratorWithoutRemoveImpl(descriptor)) { + if (isIteratorWithoutRemoveImpl(descriptor)) { MethodVisitor mv = v.getVisitor().visitMethod(ACC_PUBLIC, "remove", "()V", null, null); genMethodThrow(mv, "java/lang/UnsupportedOperationException", "Mutating method called on a Kotlin Iterator"); } } + + private static boolean isIteratorWithoutRemoveImpl(@NotNull ClassDescriptor classDescriptor) { + ClassDescriptor iteratorOfT = KotlinBuiltIns.getInstance().getIterator(); + JetType iteratorOfAny = + TypeUtils.substituteParameters(iteratorOfT, Collections.singletonList(KotlinBuiltIns.getInstance().getAnyType())); + if (!JetTypeChecker.INSTANCE.isSubtypeOf(classDescriptor.getDefaultType(), iteratorOfAny)) { + return false; + } + + for (FunctionDescriptor function : classDescriptor.getDefaultType().getMemberScope().getFunctions(Name.identifier("remove"))) { + if (function.getValueParameters().isEmpty() && function.getTypeParameters().isEmpty()) { + return false; + } + } + + return true; + } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java index 06a0208adf2..75a690b0ec4 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java @@ -251,7 +251,13 @@ public class CodegenUtil { !specialTypeProperty && (accessorDescriptor == null || accessorDescriptor.isDefault() && - (!DescriptorUtils.isExternallyAccessible(propertyDescriptor) || accessorDescriptor.getModality() == Modality.FINAL)); + (!isExternallyAccessible(propertyDescriptor) || accessorDescriptor.getModality() == Modality.FINAL)); + } + + private static boolean isExternallyAccessible(@NotNull PropertyDescriptor propertyDescriptor) { + return propertyDescriptor.getVisibility() != Visibilities.PRIVATE || + DescriptorUtils.isClassObject(propertyDescriptor.getContainingDeclaration()) || + DescriptorUtils.isTopLevelDeclaration(propertyDescriptor); } @NotNull diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 3b0c425c3cb..cd070ce9629 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -467,11 +467,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { private List getDataProperties() { ArrayList result = Lists.newArrayList(); for (JetParameter parameter : getPrimaryConstructorParameters()) { - if (parameter.getValOrVarNode() == null) continue; - - PropertyDescriptor propertyDescriptor = DescriptorUtils.getPropertyDescriptor(parameter, bindingContext); - - result.add(propertyDescriptor); + if (parameter.getValOrVarNode() != null) { + result.add(bindingContext.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter)); + } } return result; } @@ -1107,9 +1105,9 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { Type type = typeMapper.mapType(descriptor); iv.load(0, classAsmType); iv.load(codegen.myFrameMap.getIndex(descriptor), type); - iv.putfield(classAsmType.getInternalName(), - context.getFieldName(DescriptorUtils.getPropertyDescriptor(parameter, bindingContext)), - type.getDescriptor()); + PropertyDescriptor propertyDescriptor = bindingContext.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, parameter); + assert propertyDescriptor != null : "Property descriptor is not found for primary constructor parameter: " + parameter; + iv.putfield(classAsmType.getInternalName(), context.getFieldName(propertyDescriptor), type.getDescriptor()); } curParam++; } @@ -1740,7 +1738,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { CallableMemberDescriptor candidate = null; for (CallableMemberDescriptor overriddenDeclaration : filteredOverriddenDeclarations) { - if (isKindOf(overriddenDeclaration.getContainingDeclaration(), ClassKind.TRAIT) && + if (isTrait(overriddenDeclaration.getContainingDeclaration()) && overriddenDeclaration.getModality() != Modality.ABSTRACT) { candidate = overriddenDeclaration; count++; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java index 3363fe06bf6..37efbd34d5b 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java @@ -34,7 +34,6 @@ 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.DescriptorFactory; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.java.JvmAbi; @@ -82,7 +81,10 @@ public class PropertyCodegen extends GenerationStateAware { } public void gen(JetProperty p) { - PropertyDescriptor propertyDescriptor = DescriptorUtils.getPropertyDescriptor(p, bindingContext); + VariableDescriptor variableDescriptor = bindingContext.get(BindingContext.VARIABLE, p); + assert variableDescriptor instanceof PropertyDescriptor : "Property should have a property descriptor: " + variableDescriptor; + + PropertyDescriptor propertyDescriptor = (PropertyDescriptor) variableDescriptor; assert kind instanceof OwnerKind.StaticDelegateKind || kind == OwnerKind.NAMESPACE || kind == OwnerKind.IMPLEMENTATION || kind == OwnerKind.TRAIT_IMPL : "Generating property with a wrong kind (" + kind + "): " + propertyDescriptor; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java index 37267c094cc..8d4e64ad9b5 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.codegen.state; +import com.google.common.collect.Lists; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -132,10 +133,9 @@ public class JetTypeMapper extends BindingTraceAware { @NotNull DeclarationDescriptor descriptor, boolean insideModule ) { - StringBuilder r = new StringBuilder(); - List path = DescriptorUtils.getPathWithoutRootNsAndModule(namespace); + List path = getPathWithoutRootNsAndModule(namespace); for (DeclarationDescriptor pathElement : path) { NamespaceDescriptor ns = (NamespaceDescriptor) pathElement; @@ -173,6 +173,20 @@ public class JetTypeMapper extends BindingTraceAware { return JvmClassName.byInternalName(r.toString()); } + @NotNull + public static List getPathWithoutRootNsAndModule(@NotNull NamespaceDescriptor descriptor) { + List path = new ArrayList(); + DeclarationDescriptor current = descriptor; + while (true) { + if (current instanceof NamespaceDescriptor && DescriptorUtils.isRootNamespace((NamespaceDescriptor) current)) { + return Lists.reverse(path); + } + path.add(current); + assert current != null : "Namespace must have a parent: " + descriptor; + current = current.getContainingDeclaration(); + } + } + @NotNull public Type mapReturnType(@NotNull JetType jetType) { return mapReturnType(jetType, null); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java index 77f8398bd7c..7dc56806fa2 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationResolver.java @@ -24,12 +24,12 @@ import org.jetbrains.jet.lang.descriptors.annotations.Annotated; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; -import org.jetbrains.jet.lang.resolve.calls.util.CallMaker; import org.jetbrains.jet.lang.resolve.calls.CallResolver; -import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults; -import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; +import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; +import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument; +import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResults; +import org.jetbrains.jet.lang.resolve.calls.util.CallMaker; import org.jetbrains.jet.lang.resolve.constants.*; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; @@ -341,13 +341,10 @@ public class AnnotationResolver { } private static boolean isEnumProperty(@NotNull PropertyDescriptor descriptor) { - if (DescriptorUtils.isKindOf(descriptor.getType(), ClassKind.ENUM_CLASS)) { - DeclarationDescriptor enumClassObject = descriptor.getContainingDeclaration(); - if (DescriptorUtils.isKindOf(enumClassObject, ClassKind.CLASS_OBJECT)) { - return DescriptorUtils.isKindOf(enumClassObject.getContainingDeclaration(), ClassKind.ENUM_CLASS); - } - } - return false; + ClassifierDescriptor classifier = descriptor.getType().getConstructor().getDeclarationDescriptor(); + return classifier != null && + DescriptorUtils.isEnumClass(classifier) && + DescriptorUtils.isEnumClassObject(descriptor.getContainingDeclaration()); } @NotNull 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 26622112274..84114f3c18e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -1083,14 +1083,14 @@ public class DescriptorResolver { } @Nullable - private JetType transformAnonymousTypeIfNeeded( + private static JetType transformAnonymousTypeIfNeeded( @NotNull DeclarationDescriptorWithVisibility descriptor, @NotNull JetNamedDeclaration declaration, @NotNull JetType type, @NotNull BindingTrace trace ) { ClassifierDescriptor classifierDescriptor = type.getConstructor().getDeclarationDescriptor(); - if (!DescriptorUtils.isAnonymous(classifierDescriptor)) { + if (classifierDescriptor == null || !DescriptorUtils.isAnonymous(classifierDescriptor)) { return type; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java index 2641bee5a09..eeea8bcb6d9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java @@ -24,17 +24,12 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor; -import org.jetbrains.jet.lang.psi.JetElement; -import org.jetbrains.jet.lang.psi.JetFunction; -import org.jetbrains.jet.lang.psi.JetParameter; -import org.jetbrains.jet.lang.psi.JetProperty; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.FilteringScope; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -45,6 +40,8 @@ import java.util.*; import static org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER; public class DescriptorUtils { + private DescriptorUtils() { + } @NotNull public static D substituteBounds(@NotNull D functionDescriptor) { @@ -59,7 +56,8 @@ public class DescriptorUtils { return substitutedFunction; } - public static Modality convertModality(Modality modality, boolean makeNonAbstract) { + @NotNull + public static Modality convertModality(@NotNull Modality modality, boolean makeNonAbstract) { if (makeNonAbstract && modality == Modality.ABSTRACT) return Modality.OPEN; return modality; } @@ -126,7 +124,7 @@ public class DescriptorUtils { return FqName.ROOT.toUnsafe(); } } - throw new IllegalStateException("descriptor is not module descriptor and has null containingDeclaration: " + containingDeclaration); + throw new IllegalStateException("descriptor is not module descriptor and has null containingDeclaration: " + descriptor); } if (containingDeclaration instanceof ClassDescriptor && ((ClassDescriptor) containingDeclaration).getKind() == ClassKind.CLASS_OBJECT) { @@ -143,8 +141,8 @@ public class DescriptorUtils { } public static boolean isInSameModule(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) { - ModuleDescriptor parentModule = DescriptorUtils.getParentOfType(first, ModuleDescriptorImpl.class, false); - ModuleDescriptor fromModule = DescriptorUtils.getParentOfType(second, ModuleDescriptorImpl.class, false); + ModuleDescriptor parentModule = getParentOfType(first, ModuleDescriptorImpl.class, false); + ModuleDescriptor fromModule = getParentOfType(second, ModuleDescriptorImpl.class, false); assert parentModule != null && fromModule != null; return parentModule.equals(fromModule); } @@ -153,7 +151,7 @@ public class DescriptorUtils { public static DeclarationDescriptor findTopLevelParent(@NotNull DeclarationDescriptor declarationDescriptor) { DeclarationDescriptor descriptor = declarationDescriptor; if (declarationDescriptor instanceof PropertyAccessorDescriptor) { - descriptor = ((PropertyAccessorDescriptor)descriptor).getCorrespondingProperty(); + descriptor = ((PropertyAccessorDescriptor) descriptor).getCorrespondingProperty(); } while (!(descriptor == null || isTopLevelDeclaration(descriptor))) { descriptor = descriptor.getContainingDeclaration(); @@ -162,12 +160,19 @@ public class DescriptorUtils { } @Nullable - public static D getParentOfType(@Nullable DeclarationDescriptor descriptor, @NotNull Class aClass) { + public static D getParentOfType( + @Nullable DeclarationDescriptor descriptor, + @NotNull Class aClass + ) { return getParentOfType(descriptor, aClass, true); } @Nullable - public static D getParentOfType(@Nullable DeclarationDescriptor descriptor, @NotNull Class aClass, boolean strict) { + public static D getParentOfType( + @Nullable DeclarationDescriptor descriptor, + @NotNull Class aClass, + boolean strict + ) { if (descriptor == null) return null; if (strict) { descriptor = descriptor.getContainingDeclaration(); @@ -182,7 +187,11 @@ public class DescriptorUtils { return null; } - public static boolean isAncestor(@Nullable DeclarationDescriptor ancestor, @NotNull DeclarationDescriptor declarationDescriptor, boolean strict) { + public static boolean isAncestor( + @Nullable DeclarationDescriptor ancestor, + @NotNull DeclarationDescriptor declarationDescriptor, + boolean strict + ) { if (ancestor == null) return false; DeclarationDescriptor descriptor = strict ? declarationDescriptor.getContainingDeclaration() : declarationDescriptor; while (descriptor != null) { @@ -192,23 +201,6 @@ public class DescriptorUtils { return false; } - @NotNull - public static JetType getFunctionExpectedReturnType(@NotNull FunctionDescriptor descriptor, @NotNull JetElement function) { - JetType expectedType; - if (function instanceof JetFunction) { - if (((JetFunction) function).getReturnTypeRef() != null || ((JetFunction) function).hasBlockBody()) { - expectedType = descriptor.getReturnType(); - } - else { - expectedType = TypeUtils.NO_EXPECTED_TYPE; - } - } - else { - expectedType = descriptor.getReturnType(); - } - return expectedType != null ? expectedType : TypeUtils.NO_EXPECTED_TYPE; - } - public static boolean isSubclass(@NotNull ClassDescriptor subClass, @NotNull ClassDescriptor superClass) { return isSubtypeOfClass(subClass.getDefaultType(), superClass.getOriginal()); } @@ -226,7 +218,7 @@ public class DescriptorUtils { return false; } - public static void addSuperTypes(JetType type, Set set) { + public static void addSuperTypes(@NotNull JetType type, @NotNull Set set) { set.add(type); for (JetType jetType : type.getConstructor().getSupertypes()) { @@ -238,19 +230,6 @@ public class DescriptorUtils { return namespaceDescriptor.getContainingDeclaration() instanceof ModuleDescriptor; } - @NotNull - public static List getPathWithoutRootNsAndModule(@NotNull DeclarationDescriptor descriptor) { - List path = Lists.newArrayList(); - DeclarationDescriptor current = descriptor; - while (true) { - if (current instanceof NamespaceDescriptor && isRootNamespace((NamespaceDescriptor) current)) { - return Lists.reverse(path); - } - path.add(current); - current = current.getContainingDeclaration(); - } - } - public static boolean isFunctionLiteral(@NotNull FunctionDescriptor descriptor) { return descriptor instanceof AnonymousFunctionDescriptor; } @@ -259,7 +238,7 @@ public class DescriptorUtils { return isKindOf(descriptor, ClassKind.CLASS_OBJECT); } - public static boolean isAnonymous(@Nullable ClassifierDescriptor descriptor) { + public static boolean isAnonymous(@NotNull ClassifierDescriptor descriptor) { return isKindOf(descriptor, ClassKind.OBJECT) && descriptor.getName().isSpecial(); } @@ -275,20 +254,16 @@ public class DescriptorUtils { return isKindOf(descriptor, ClassKind.ANNOTATION_CLASS); } + public static boolean isTrait(@NotNull DeclarationDescriptor descriptor) { + return isKindOf(descriptor, ClassKind.TRAIT); + } + public static boolean isClass(@NotNull DeclarationDescriptor descriptor) { return isKindOf(descriptor, ClassKind.CLASS); } - public static boolean isKindOf(@NotNull JetType jetType, @NotNull ClassKind classKind) { - ClassifierDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor(); - return isKindOf(descriptor, classKind); - } - public static boolean isKindOf(@Nullable DeclarationDescriptor descriptor, @NotNull ClassKind classKind) { - if (descriptor instanceof ClassDescriptor) { - return ((ClassDescriptor) descriptor).getKind() == classKind; - } - return false; + return descriptor instanceof ClassDescriptor && ((ClassDescriptor) descriptor).getKind() == classKind; } @NotNull @@ -311,11 +286,10 @@ public class DescriptorUtils { @NotNull public static ClassDescriptor getClassDescriptorForTypeConstructor(@NotNull TypeConstructor typeConstructor) { - DeclarationDescriptor superClassDescriptor = - typeConstructor.getDeclarationDescriptor(); - assert superClassDescriptor instanceof ClassDescriptor - : "Superclass descriptor of a type should be of type ClassDescriptor"; - return (ClassDescriptor)superClassDescriptor; + ClassifierDescriptor descriptor = typeConstructor.getDeclarationDescriptor(); + assert descriptor instanceof ClassDescriptor + : "Classifier descriptor of a type should be of type ClassDescriptor: " + typeConstructor; + return (ClassDescriptor) descriptor; } public static boolean isAny(@NotNull DeclarationDescriptor superClassDescriptor) { @@ -338,24 +312,6 @@ public class DescriptorUtils { return false; } - public static boolean isIteratorWithoutRemoveImpl(@NotNull ClassDescriptor classDescriptor) { - ClassDescriptor iteratorOfT = KotlinBuiltIns.getInstance().getIterator(); - JetType iteratorOfAny = TypeUtils.substituteParameters(iteratorOfT, Collections.singletonList(KotlinBuiltIns.getInstance().getAnyType())); - boolean isIterator = JetTypeChecker.INSTANCE.isSubtypeOf(classDescriptor.getDefaultType(), iteratorOfAny); - boolean hasRemove = hasMethod(classDescriptor, Name.identifier("remove")); - return isIterator && !hasRemove; - } - - private static boolean hasMethod(ClassDescriptor classDescriptor, Name name) { - Collection removeFunctions = classDescriptor.getDefaultType().getMemberScope().getFunctions(name); - for (FunctionDescriptor function : removeFunctions) { - if (function.getValueParameters().isEmpty() && function.getTypeParameters().isEmpty()) { - return true; - } - } - return false; - } - @NotNull public static Name getClassObjectName(@NotNull Name className) { return Name.special(""); @@ -438,35 +394,10 @@ public class DescriptorUtils { return receiverParameterDescriptor.getType(); } - @NotNull - public static ReceiverValue safeGetValue(@Nullable ReceiverParameterDescriptor receiverParameterDescriptor) { - if (receiverParameterDescriptor == null) { - return ReceiverValue.NO_RECEIVER; - } - return receiverParameterDescriptor.getValue(); - } - - - public static boolean isExternallyAccessible(PropertyDescriptor propertyDescriptor) { - return propertyDescriptor.getVisibility() != Visibilities.PRIVATE || isClassObject(propertyDescriptor.getContainingDeclaration()) - || isTopLevelDeclaration(propertyDescriptor); - } - @NotNull public static JetType getVarargParameterType(@NotNull JetType elementType) { - return getVarargParameterType(elementType, Variance.INVARIANT); - } - - @NotNull - public static JetType getVarargParameterType(@NotNull JetType elementType, @NotNull Variance projectionKind) { - KotlinBuiltIns builtIns = KotlinBuiltIns.getInstance(); - JetType primitiveArrayType = builtIns.getPrimitiveArrayJetTypeByPrimitiveJetType(elementType); - if (primitiveArrayType != null) { - return primitiveArrayType; - } - else { - return builtIns.getArrayType(projectionKind, elementType); - } + JetType primitiveArrayType = KotlinBuiltIns.getInstance().getPrimitiveArrayJetTypeByPrimitiveJetType(elementType); + return primitiveArrayType != null ? primitiveArrayType : KotlinBuiltIns.getInstance().getArrayType(Variance.INVARIANT, elementType); } @NotNull @@ -536,24 +467,6 @@ public class DescriptorUtils { return allSuperclasses; } - @NotNull - public static PropertyDescriptor getPropertyDescriptor(@NotNull JetProperty property, @NotNull BindingContext bindingContext) { - VariableDescriptor descriptor = bindingContext.get(BindingContext.VARIABLE, property); - if (!(descriptor instanceof PropertyDescriptor)) { - throw new UnsupportedOperationException("expect a property to have a property descriptor"); - } - return (PropertyDescriptor) descriptor; - } - - - @NotNull - public static PropertyDescriptor getPropertyDescriptor(@NotNull JetParameter constructorParameter, @NotNull BindingContext bindingContext) { - assert constructorParameter.getValOrVarNode() != null; - PropertyDescriptor descriptor = bindingContext.get(BindingContext.PRIMARY_CONSTRUCTOR_PARAMETER, constructorParameter); - assert descriptor != null; - return descriptor; - } - /** * @return true iff {@code descriptor}'s first non-class container is a namespace */ diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java index a1ff2368054..88cb9ad8c25 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java @@ -384,8 +384,8 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor { } } if (result != null) { - if (DescriptorUtils.isKindOf(thisType, ClassKind.TRAIT)) { - if (DescriptorUtils.isKindOf(result, ClassKind.CLASS)) { + if (DescriptorUtils.isTrait(thisType.getConstructor().getDeclarationDescriptor())) { + if (DescriptorUtils.isClass(result.getConstructor().getDeclarationDescriptor())) { context.trace.report(SUPERCLASS_NOT_ACCESSIBLE_FROM_TRAIT.on(expression)); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java index 3a789cfb40e..b6624d54df7 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ControlStructureTypingVisitor.java @@ -542,7 +542,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { resultType = ErrorUtils.createErrorType(RETURN_NOT_ALLOWED_MESSAGE); } if (containingFunctionDescriptor != null) { - expectedType = DescriptorUtils.getFunctionExpectedReturnType(containingFunctionDescriptor, (JetElement) containingFunction); + expectedType = getFunctionExpectedReturnType(containingFunctionDescriptor, (JetElement) containingFunction); } } else { @@ -554,7 +554,7 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { else if (labelTargetElement != null) { SimpleFunctionDescriptor functionDescriptor = context.trace.get(FUNCTION, labelTargetElement); if (functionDescriptor != null) { - expectedType = DescriptorUtils.getFunctionExpectedReturnType(functionDescriptor, labelTargetElement); + expectedType = getFunctionExpectedReturnType(functionDescriptor, labelTargetElement); if (functionDescriptor != containingFunctionDescriptor) { // Qualified, non-local context.trace.report(RETURN_NOT_ALLOWED.on(expression)); @@ -593,4 +593,21 @@ public class ControlStructureTypingVisitor extends ExpressionTypingVisitor { context.labelResolver.resolveLabel(expression, context); return DataFlowUtils.checkType(KotlinBuiltIns.getInstance().getNothingType(), expression, context, context.dataFlowInfo); } + + @NotNull + private static JetType getFunctionExpectedReturnType(@NotNull FunctionDescriptor descriptor, @NotNull JetElement function) { + JetType expectedType; + if (function instanceof JetFunction) { + if (((JetFunction) function).getReturnTypeRef() != null || ((JetFunction) function).hasBlockBody()) { + expectedType = descriptor.getReturnType(); + } + else { + expectedType = TypeUtils.NO_EXPECTED_TYPE; + } + } + else { + expectedType = descriptor.getReturnType(); + } + return expectedType != null ? expectedType : TypeUtils.NO_EXPECTED_TYPE; + } } diff --git a/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java b/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java index dd3783ad95a..509edf9b18f 100644 --- a/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java +++ b/idea/src/org/jetbrains/jet/plugin/intentions/SpecifyTypeExplicitlyAction.java @@ -32,6 +32,7 @@ import com.intellij.psi.util.PsiTreeUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.JetNodeTypes; +import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor; import org.jetbrains.jet.lang.descriptors.VariableDescriptor; @@ -42,7 +43,6 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeConstructor; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.plugin.JetBundle; import org.jetbrains.jet.plugin.codeInsight.ReferenceToClassesShortening; @@ -219,8 +219,8 @@ public class SpecifyTypeExplicitlyAction extends PsiElementBaseIntentionAction { ) { assert !ErrorUtils.isErrorType(exprType) : "Unexpected error type: " + namedDeclaration.getText(); - TypeConstructor constructor = exprType.getConstructor(); - boolean isAnonymous = DescriptorUtils.isAnonymous(constructor.getDeclarationDescriptor()); + ClassifierDescriptor descriptor = exprType.getConstructor().getDeclarationDescriptor(); + boolean isAnonymous = descriptor != null && DescriptorUtils.isAnonymous(descriptor); Set allSupertypes = TypeUtils.getAllSupertypes(exprType); List types = isAnonymous ? new ArrayList() : Lists.newArrayList(exprType); diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallBuilder.java b/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallBuilder.java index d6d3a4f11ae..b4637fd3f40 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallBuilder.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/reference/CallBuilder.java @@ -21,15 +21,16 @@ import com.google.dart.compiler.backend.js.ast.JsExpression; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.CallableDescriptor; +import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor; import org.jetbrains.jet.lang.resolve.BindingTraceContext; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace; import org.jetbrains.jet.lang.resolve.calls.model.MutableDataFlowInfoForArguments; -import org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind; -import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionCandidate; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallImpl; +import org.jetbrains.jet.lang.resolve.calls.tasks.ExplicitReceiverKind; +import org.jetbrains.jet.lang.resolve.calls.tasks.ResolutionCandidate; import org.jetbrains.jet.lang.resolve.calls.tasks.TracingStrategy; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue; import org.jetbrains.k2js.translate.context.TranslationContext; import java.util.Arrays; @@ -107,8 +108,8 @@ public final class CallBuilder { private CallTranslator finish() { if (resolvedCall == null) { assert descriptor != null; - resolvedCall = ResolvedCallImpl.create(ResolutionCandidate.create(descriptor, DescriptorUtils.safeGetValue(descriptor.getExpectedThisObject()), - DescriptorUtils.safeGetValue(descriptor.getReceiverParameter()), + resolvedCall = ResolvedCallImpl.create(ResolutionCandidate.create(descriptor, safeGetValue(descriptor.getExpectedThisObject()), + safeGetValue(descriptor.getReceiverParameter()), ExplicitReceiverKind.THIS_OBJECT, false), TemporaryBindingTrace.create(new BindingTraceContext(), "trace to resolve call (in js)"), TracingStrategy.EMPTY, @@ -121,10 +122,13 @@ public final class CallBuilder { return new CallTranslator(receiver, callee, args, resolvedCall, descriptor, callType, context); } + @NotNull + private static ReceiverValue safeGetValue(@Nullable ReceiverParameterDescriptor descriptor) { + return descriptor == null ? ReceiverValue.NO_RECEIVER : descriptor.getValue(); + } + @NotNull public JsExpression translate() { return finish().translate(); } - - }