From 3c5d4f685706148f9f978d9f39a7a22269bfab5d Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Thu, 29 Mar 2012 20:37:22 +0400 Subject: [PATCH] 'isVisible' strategy added to Visibility interface --- .../jetbrains/jet/codegen/CodegenContext.java | 2 +- .../jetbrains/jet/codegen/CodegenUtil.java | 2 +- .../jet/codegen/ExpressionCodegen.java | 2 +- .../codegen/ImplementationBodyCodegen.java | 4 +- .../jetbrains/jet/codegen/JetTypeMapper.java | 6 +- .../jet/codegen/PropertyCodegen.java | 2 +- .../resolve/java/JavaDescriptorResolver.java | 12 +- .../jet/lang/descriptors/ClassDescriptor.java | 1 - .../lang/descriptors/ClassDescriptorImpl.java | 2 +- .../ConstructorDescriptorImpl.java | 3 - .../descriptors/FunctionDescriptorUtil.java | 2 +- .../jet/lang/descriptors/Visibilities.java | 96 +++++++ .../jet/lang/descriptors/Visibility.java | 25 +- .../jet/lang/resolve/DescriptorResolver.java | 3 +- .../lang/resolve/TypeHierarchyResolver.java | 2 +- .../lang/resolve/calls/ResolutionTask.java | 264 +++++++++--------- .../calls/autocasts/DataFlowValueFactory.java | 2 +- .../jetbrains/jet/lang/types/ErrorUtils.java | 6 +- .../ClosureExpressionsTypingVisitor.java | 2 +- .../lang/types/lang/JetStandardClasses.java | 4 +- 20 files changed, 262 insertions(+), 180 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibilities.java diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java index dcc7ce06cf9..f91c55491fa 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenContext.java @@ -139,7 +139,7 @@ public abstract class CodegenContext { public ConstructorContext intoConstructor(ConstructorDescriptor descriptor, JetTypeMapper typeMapper) { if(descriptor == null) { descriptor = new ConstructorDescriptorImpl(getThisDescriptor(), Collections.emptyList(), true) - .initialize(Collections.emptyList(), Collections.emptyList(), Visibility.PUBLIC); + .initialize(Collections.emptyList(), Collections.emptyList(), Visibilities.PUBLIC); } return new ConstructorContext(descriptor, getContextKind(), this, typeMapper); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java index a9ae66f4cca..871d3c96c09 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java @@ -73,7 +73,7 @@ public class CodegenUtil { fd.getValueParameters(), fd.getReturnType(), Modality.FINAL, - Visibility.PUBLIC, + Visibilities.PUBLIC, /*isInline = */false ); return invokeDescriptor; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index f1e91b262c7..3e4e8831d06 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -1020,7 +1020,7 @@ public class ExpressionCodegen extends JetVisitor { final boolean directToField = expression.getReferencedNameElementType() == JetTokens.FIELD_IDENTIFIER && contextKind() != OwnerKind.TRAIT_IMPL ; JetExpression r = getReceiverForSelector(expression); final boolean isSuper = r instanceof JetSuperExpression; - if(propertyDescriptor.getVisibility() == Visibility.PRIVATE && !CodegenUtil.isClassObject(propertyDescriptor.getContainingDeclaration())) { + if(propertyDescriptor.getVisibility() == Visibilities.PRIVATE && !CodegenUtil.isClassObject(propertyDescriptor.getContainingDeclaration())) { if(context.getClassOrNamespaceDescriptor() != propertyDescriptor.getContainingDeclaration()) { DeclarationDescriptor enclosed = propertyDescriptor.getContainingDeclaration(); if(enclosed != null && enclosed != context.getThisDescriptor()) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index c6ba49925d9..1b5517fd293 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -316,7 +316,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { InstructionAdapter iv = new InstructionAdapter(mv); iv.load(0, JetTypeMapper.TYPE_OBJECT); - if(original.getVisibility() == Visibility.PRIVATE) + if(original.getVisibility() == Visibilities.PRIVATE) iv.getfield(typeMapper.getOwner(original, OwnerKind.IMPLEMENTATION), original.getName(), originalMethod.getReturnType().getDescriptor()); else iv.invokespecial(typeMapper.getOwner(original, OwnerKind.IMPLEMENTATION), originalMethod.getName(), originalMethod.getDescriptor()); @@ -349,7 +349,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { //noinspection AssignmentToForLoopParameter reg += argType.getSize(); } - if(original.getVisibility() == Visibility.PRIVATE && original.getModality() == Modality.FINAL) + if(original.getVisibility() == Visibilities.PRIVATE && original.getModality() == Modality.FINAL) iv.putfield(typeMapper.getOwner(original, OwnerKind.IMPLEMENTATION), original.getName(), originalMethod.getArgumentTypes()[0].getDescriptor()); else iv.invokespecial(typeMapper.getOwner(original, OwnerKind.IMPLEMENTATION), originalMethod.getName(), originalMethod.getDescriptor()); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index 541de5a85a9..7d1b0a83a68 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -757,13 +757,13 @@ public class JetTypeMapper { if(CodegenUtil.isInterface(declaration)) { return ACC_PUBLIC; } - if (p.getVisibility() == Visibility.PUBLIC) { + if (p.getVisibility() == Visibilities.PUBLIC) { return ACC_PUBLIC; } - else if (p.getVisibility() == Visibility.PROTECTED) { + else if (p.getVisibility() == Visibilities.PROTECTED) { return ACC_PROTECTED; } - else if (p.getVisibility() == Visibility.PRIVATE) { + else if (p.getVisibility() == Visibilities.PRIVATE) { if(CodegenUtil.isClassObject(declaration)) { return defaultFlags; } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java index deb7d56a42c..ff09feb49e1 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java @@ -119,7 +119,7 @@ public class PropertyCodegen { } private static boolean isExternallyAccessible(PropertyDescriptor p) { - return p.getVisibility() != Visibility.PRIVATE || CodegenUtil.isClassObject(p.getContainingDeclaration()); + return p.getVisibility() != Visibilities.PRIVATE || CodegenUtil.isClassObject(p.getContainingDeclaration()); } private void generateSetter(JetProperty p, PropertyDescriptor propertyDescriptor) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index dda711b4239..261421309ff 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -453,7 +453,7 @@ public class JavaDescriptorResolver { // TODO: wrong: class objects do not need visible constructors ConstructorDescriptorImpl constructor = new ConstructorDescriptorImpl(classData.classDescriptor, new ArrayList(0), true); constructor.setReturnType(classData.classDescriptor.getDefaultType()); - constructor.initialize(new ArrayList(0), new ArrayList(0), Visibility.PUBLIC); + constructor.initialize(new ArrayList(0), new ArrayList(0), Visibilities.PUBLIC); classData.classDescriptor.addConstructor(constructor, null); return classData.classDescriptor; @@ -1158,10 +1158,10 @@ public class JavaDescriptorResolver { PropertyGetterDescriptor getterDescriptor = null; PropertySetterDescriptor setterDescriptor = null; if (members.getter != null) { - getterDescriptor = new PropertyGetterDescriptor(propertyDescriptor, resolveAnnotations(members.getter.getMember().psiMember), Modality.OPEN, Visibility.PUBLIC, true, false, CallableMemberDescriptor.Kind.DECLARATION); + getterDescriptor = new PropertyGetterDescriptor(propertyDescriptor, resolveAnnotations(members.getter.getMember().psiMember), Modality.OPEN, Visibilities.PUBLIC, true, false, CallableMemberDescriptor.Kind.DECLARATION); } if (members.setter != null) { - setterDescriptor = new PropertySetterDescriptor(propertyDescriptor, resolveAnnotations(members.setter.getMember().psiMember), Modality.OPEN, Visibility.PUBLIC, true, false, CallableMemberDescriptor.Kind.DECLARATION); + setterDescriptor = new PropertySetterDescriptor(propertyDescriptor, resolveAnnotations(members.setter.getMember().psiMember), Modality.OPEN, Visibilities.PUBLIC, true, false, CallableMemberDescriptor.Kind.DECLARATION); } propertyDescriptor.initialize(getterDescriptor, setterDescriptor); @@ -1625,9 +1625,9 @@ public class JavaDescriptorResolver { private static Visibility resolveVisibilityFromPsiModifiers(PsiModifierListOwner modifierListOwner) { //TODO report error - return modifierListOwner.hasModifierProperty(PsiModifier.PUBLIC) ? Visibility.PUBLIC : - (modifierListOwner.hasModifierProperty(PsiModifier.PRIVATE) ? Visibility.PRIVATE : - (modifierListOwner.hasModifierProperty(PsiModifier.PROTECTED) ? Visibility.PROTECTED : Visibility.INTERNAL)); + return modifierListOwner.hasModifierProperty(PsiModifier.PUBLIC) ? Visibilities.PUBLIC : + (modifierListOwner.hasModifierProperty(PsiModifier.PRIVATE) ? Visibilities.PRIVATE : + (modifierListOwner.hasModifierProperty(PsiModifier.PROTECTED) ? Visibilities.PROTECTED : Visibilities.PUBLIC));//todo } public List resolveInnerClasses(DeclarationDescriptor owner, PsiClass psiClass, boolean staticMembers) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java index 1bc7952f732..b07992344d9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java @@ -24,7 +24,6 @@ import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeProjection; import org.jetbrains.jet.lang.types.TypeSubstitutor; -import java.util.Collection; import java.util.List; import java.util.Set; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java index 314c44dd9a3..5929c950711 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java @@ -164,7 +164,7 @@ public class ClassDescriptorImpl extends DeclarationDescriptorImpl implements Cl @NotNull @Override public Visibility getVisibility() { - return Visibility.PUBLIC; + return Visibilities.PUBLIC; } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java index 31482d43d18..9d949bc0982 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java @@ -17,12 +17,9 @@ package org.jetbrains.jet.lang.descriptors; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; -import org.jetbrains.jet.lang.types.JetType; -import org.jetbrains.jet.lang.types.TypeSubstitutor; import java.util.Collections; import java.util.List; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java index 62fa4b93c81..449261e72fd 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorUtil.java @@ -126,7 +126,7 @@ public class FunctionDescriptorUtil { Collections.emptyList(), JetStandardClasses.getValueParameters(functionDescriptor, functionType), JetStandardClasses.getReturnTypeFromFunctionType(functionType), - Modality.FINAL, Visibility.LOCAL); + Modality.FINAL, Visibilities.LOCAL); } public static D alphaConvertTypeParameters(D candidate) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibilities.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibilities.java new file mode 100644 index 00000000000..e7fc1613e73 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibilities.java @@ -0,0 +1,96 @@ +/* + * Copyright 2010-2012 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 com.google.common.collect.Sets; +import org.jetbrains.jet.lang.resolve.DescriptorUtils; + +import java.util.Set; + +/** + * @author svtk + */ +public class Visibilities { + public static final Visibility PRIVATE = new Visibility(false) { + @Override + public boolean isVisible(DeclarationDescriptorWithVisibility what, DeclarationDescriptor from) { + DeclarationDescriptor parent = what; + while (parent != null) { + parent = parent.getContainingDeclaration(); + if ((parent instanceof ClassDescriptor && ((ClassDescriptor)parent).getKind() != ClassKind.OBJECT) || + parent instanceof NamespaceDescriptor) { + break; + } + } + DeclarationDescriptor fromParent = from; + while (fromParent != null) { + if (parent == fromParent) { + return true; + } + fromParent = fromParent.getContainingDeclaration(); + } + return false; + } + }; + + public static final Visibility PROTECTED = new Visibility(true) { + @Override + public boolean isVisible(DeclarationDescriptorWithVisibility what, DeclarationDescriptor from) { + ClassDescriptor classDescriptor = DescriptorUtils.getParentOfType(what, ClassDescriptor.class); + if (classDescriptor == null) return false; + + ClassDescriptor fromClass = DescriptorUtils.getParentOfType(from, ClassDescriptor.class); + if (fromClass == null) return false; + if (DescriptorUtils.isSubclass(fromClass, classDescriptor)) { + return true; + } + return false; + } + }; + + public static final Visibility INTERNAL = new Visibility(false) { + @Override + public boolean isVisible(DeclarationDescriptorWithVisibility what, DeclarationDescriptor from) { + ModuleDescriptor parentModule = DescriptorUtils.getParentOfType(what, ModuleDescriptor.class, false); + ModuleDescriptor fromModule = DescriptorUtils.getParentOfType(from, ModuleDescriptor.class, false); + return parentModule == fromModule; + } + }; + + public static final Visibility PUBLIC = new Visibility(true) { + @Override + public boolean isVisible(DeclarationDescriptorWithVisibility what, DeclarationDescriptor from) { + return true; + } + }; + + public static final Visibility INTERNAL_PROTECTED = new Visibility(false) { + @Override + public boolean isVisible(DeclarationDescriptorWithVisibility what, DeclarationDescriptor from) { + return PROTECTED.isVisible(what, from) && INTERNAL.isVisible(what, from); + } + }; + + public static final Visibility LOCAL = new Visibility(false) { + @Override + public boolean isVisible(DeclarationDescriptorWithVisibility what, DeclarationDescriptor from) { + return true; + } + }; + + public static final Set INTERNAL_VISIBILITIES = Sets.newHashSet(PRIVATE, INTERNAL, INTERNAL_PROTECTED, LOCAL); +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibility.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibility.java index e56ec584038..9b08bfb951a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibility.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibility.java @@ -16,28 +16,19 @@ package org.jetbrains.jet.lang.descriptors; -import java.util.EnumSet; - /** * @author svtk */ -public enum Visibility { - PRIVATE(false), - PROTECTED(true), - INTERNAL(false), - PUBLIC(true), - INTERNAL_PROTECTED(false), - LOCAL(false); +public abstract class Visibility { + private final boolean isPublicAPI; - public static final EnumSet INTERNAL_VISIBILITIES = EnumSet.of(PRIVATE, INTERNAL, INTERNAL_PROTECTED, LOCAL); - - private final boolean isAPI; - - private Visibility(boolean visibleOutside) { - isAPI = visibleOutside; + protected Visibility(boolean api) { + isPublicAPI = api; } - public boolean isAPI() { - return isAPI; + public boolean isPublicAPI() { + return isPublicAPI; } + + public abstract boolean isVisible(DeclarationDescriptorWithVisibility what, DeclarationDescriptor from); } 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 137b9f49b84..cbea1f433a9 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java @@ -216,8 +216,7 @@ public class DescriptorResolver { } } boolean hasBody = function.getBodyExpression() != null; - Modality defaultModality = getDefaultModality(containingDescriptor, hasBody); - Modality modality = resolveModalityFromModifiers(function.getModifierList(), defaultModality); + Modality modality = resolveModalityFromModifiers(function.getModifierList(), getDefaultModality(containingDescriptor, hasBody)); Visibility visibility = resolveVisibilityFromModifiers(function.getModifierList()); JetModifierList modifierList = function.getModifierList(); boolean isInline = (modifierList != null) && modifierList.hasModifier(JetTokens.INLINE_KEYWORD); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java index cc25426d69c..3412a86e550 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java @@ -190,7 +190,7 @@ public class TypeHierarchyResolver { private void createPrimaryConstructorForObject(@Nullable JetDeclaration object, MutableClassDescriptor mutableClassDescriptor) { ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(mutableClassDescriptor, Collections.emptyList(), true); constructorDescriptor.initialize(Collections.emptyList(), Collections.emptyList(), - Visibility.INTERNAL);//TODO check set mutableClassDescriptor.getVisibility() + Visibilities.INTERNAL);//TODO check set mutableClassDescriptor.getVisibility() // TODO : make the constructor private? mutableClassDescriptor.setPrimaryConstructor(constructorDescriptor, trace); if (object != null) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java index e79d5d89da5..25ce3bbb424 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/ResolutionTask.java @@ -89,140 +89,140 @@ public class ResolutionTask extends ResolutionCont public interface DescriptorCheckStrategy { boolean performAdvancedChecks(D descriptor, BindingTrace trace, TracingStrategy tracing); } - + public final TracingStrategy tracing = new TracingStrategy() { - @Override - public void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl resolvedCall) { - D descriptor = resolvedCall.getCandidateDescriptor(); - // if (descriptor instanceof VariableAsFunctionDescriptor) { - // VariableAsFunctionDescriptor variableAsFunctionDescriptor = (VariableAsFunctionDescriptor) descriptor; - // trace.record(REFERENCE_TARGET, reference, variableAsFunctionDescriptor.getVariableDescriptor()); - // } - // else { - // } - trace.record(RESOLVED_CALL, call.getCalleeExpression(), resolvedCall); - trace.record(REFERENCE_TARGET, reference, descriptor); - } - - @Override - public void recordAmbiguity(BindingTrace trace, Collection> candidates) { - Collection descriptors = Sets.newHashSet(); - for (ResolvedCallImpl candidate : candidates) { - descriptors.add(candidate.getCandidateDescriptor()); - } - trace.record(AMBIGUOUS_REFERENCE_TARGET, reference, descriptors); - } - - @Override - public void unresolvedReference(@NotNull BindingTrace trace) { - trace.report(UNRESOLVED_REFERENCE.on(reference)); - } - - @Override - public void noValueForParameter(@NotNull BindingTrace trace, @NotNull ValueParameterDescriptor valueParameter) { - PsiElement reportOn; - JetValueArgumentList valueArgumentList = call.getValueArgumentList(); - if (valueArgumentList != null) { - reportOn = valueArgumentList; - } - else { - reportOn = reference; - } - trace.report(NO_VALUE_FOR_PARAMETER.on(reportOn, valueParameter)); - } - - @Override - public void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor expectedReceiver) { - trace.report(MISSING_RECEIVER.on(reference, expectedReceiver.getType())); - } - - @Override - public void wrongReceiverType(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor receiverParameter, @NotNull ReceiverDescriptor receiverArgument) { - if (receiverArgument instanceof ExpressionReceiver) { - ExpressionReceiver expressionReceiver = (ExpressionReceiver) receiverArgument; - trace.report(TYPE_MISMATCH.on(expressionReceiver.getExpression(), receiverParameter.getType(), receiverArgument.getType())); - } - else { - trace.report(TYPE_MISMATCH.on(reference, receiverParameter.getType(), receiverArgument.getType())); + @Override + public void bindReference(@NotNull BindingTrace trace, @NotNull ResolvedCallImpl resolvedCall) { + D descriptor = resolvedCall.getCandidateDescriptor(); + // if (descriptor instanceof VariableAsFunctionDescriptor) { + // VariableAsFunctionDescriptor variableAsFunctionDescriptor = (VariableAsFunctionDescriptor) descriptor; + // trace.record(REFERENCE_TARGET, reference, variableAsFunctionDescriptor.getVariableDescriptor()); + // } + // else { + // } + trace.record(RESOLVED_CALL, call.getCalleeExpression(), resolvedCall); + trace.record(REFERENCE_TARGET, reference, descriptor); + } + + @Override + public void recordAmbiguity(BindingTrace trace, Collection> candidates) { + Collection descriptors = Sets.newHashSet(); + for (ResolvedCallImpl candidate : candidates) { + descriptors.add(candidate.getCandidateDescriptor()); + } + trace.record(AMBIGUOUS_REFERENCE_TARGET, reference, descriptors); + } + + @Override + public void unresolvedReference(@NotNull BindingTrace trace) { + trace.report(UNRESOLVED_REFERENCE.on(reference)); + } + + @Override + public void noValueForParameter(@NotNull BindingTrace trace, @NotNull ValueParameterDescriptor valueParameter) { + PsiElement reportOn; + JetValueArgumentList valueArgumentList = call.getValueArgumentList(); + if (valueArgumentList != null) { + reportOn = valueArgumentList; + } + else { + reportOn = reference; + } + trace.report(NO_VALUE_FOR_PARAMETER.on(reportOn, valueParameter)); + } + + @Override + public void missingReceiver(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor expectedReceiver) { + trace.report(MISSING_RECEIVER.on(reference, expectedReceiver.getType())); + } + + @Override + public void wrongReceiverType(@NotNull BindingTrace trace, @NotNull ReceiverDescriptor receiverParameter, @NotNull ReceiverDescriptor receiverArgument) { + if (receiverArgument instanceof ExpressionReceiver) { + ExpressionReceiver expressionReceiver = (ExpressionReceiver)receiverArgument; + trace.report(TYPE_MISMATCH.on(expressionReceiver.getExpression(), receiverParameter.getType(), receiverArgument.getType())); + } + else { + trace.report(TYPE_MISMATCH.on(reference, receiverParameter.getType(), receiverArgument.getType())); + } + } + + @Override + public void noReceiverAllowed(@NotNull BindingTrace trace) { + trace.report(NO_RECEIVER_ADMITTED.on(reference)); + } + + @Override + public void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount) { + JetTypeArgumentList typeArgumentList = call.getTypeArgumentList(); + if (typeArgumentList != null) { + trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(typeArgumentList, expectedTypeArgumentCount)); + } + else { + trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(reference, expectedTypeArgumentCount)); + } + } + + @Override + public void ambiguity(@NotNull BindingTrace trace, @NotNull Collection> descriptors) { + trace.report(OVERLOAD_RESOLUTION_AMBIGUITY.on(call.getCallElement(), descriptors)); + } + + @Override + public void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection> descriptors) { + trace.report(NONE_APPLICABLE.on(reference, descriptors)); + } + + @Override + public void instantiationOfAbstractClass(@NotNull BindingTrace trace) { + trace.report(CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS.on(call.getCallElement())); + } + + @Override + public void typeInferenceFailed(@NotNull BindingTrace trace, SolutionStatus status) { + assert !status.isSuccessful(); + trace.report(TYPE_INFERENCE_FAILED.on(call.getCallElement(), status)); + } + + @Override + public void unsafeCall(@NotNull BindingTrace trace, @NotNull JetType type) { + ASTNode callOperationNode = call.getCallOperationNode(); + if (callOperationNode != null) { + trace.report(UNSAFE_CALL.on(callOperationNode.getPsi(), type)); + } + else { + PsiElement callElement = call.getCallElement(); + if (callElement instanceof JetBinaryExpression) { + JetBinaryExpression binaryExpression = (JetBinaryExpression)callElement; + JetSimpleNameExpression operationReference = binaryExpression.getOperationReference(); + + String operationString = operationReference.getReferencedNameElementType() == JetTokens.IDENTIFIER ? + operationReference.getText() : + OperatorConventions.getNameForOperationSymbol((JetToken)operationReference.getReferencedNameElementType()); + + JetExpression right = binaryExpression.getRight(); + if (right != null) { + trace.report(UNSAFE_INFIX_CALL.on(reference, binaryExpression.getLeft().getText(), operationString, right.getText())); } } - - @Override - public void noReceiverAllowed(@NotNull BindingTrace trace) { - trace.report(NO_RECEIVER_ADMITTED.on(reference)); + else { + trace.report(UNSAFE_CALL.on(reference, type)); } - - @Override - public void wrongNumberOfTypeArguments(@NotNull BindingTrace trace, int expectedTypeArgumentCount) { - JetTypeArgumentList typeArgumentList = call.getTypeArgumentList(); - if (typeArgumentList != null) { - trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(typeArgumentList, expectedTypeArgumentCount)); - } - else { - trace.report(WRONG_NUMBER_OF_TYPE_ARGUMENTS.on(reference, expectedTypeArgumentCount)); - } - } - - @Override - public void ambiguity(@NotNull BindingTrace trace, @NotNull Collection> descriptors) { - trace.report(OVERLOAD_RESOLUTION_AMBIGUITY.on(call.getCallElement(), descriptors)); - } - - @Override - public void noneApplicable(@NotNull BindingTrace trace, @NotNull Collection> descriptors) { - trace.report(NONE_APPLICABLE.on(reference, descriptors)); - } - - @Override - public void instantiationOfAbstractClass(@NotNull BindingTrace trace) { - trace.report(CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS.on(call.getCallElement())); - } - - @Override - public void typeInferenceFailed(@NotNull BindingTrace trace, SolutionStatus status) { - assert !status.isSuccessful(); - trace.report(TYPE_INFERENCE_FAILED.on(call.getCallElement(), status)); - } - - @Override - public void unsafeCall(@NotNull BindingTrace trace, @NotNull JetType type) { - ASTNode callOperationNode = call.getCallOperationNode(); - if (callOperationNode != null) { - trace.report(UNSAFE_CALL.on(callOperationNode.getPsi(), type)); - } - else { - PsiElement callElement = call.getCallElement(); - if (callElement instanceof JetBinaryExpression) { - JetBinaryExpression binaryExpression = (JetBinaryExpression) callElement; - JetSimpleNameExpression operationReference = binaryExpression.getOperationReference(); - - String operationString = operationReference.getReferencedNameElementType() == JetTokens.IDENTIFIER ? - operationReference.getText() : - OperatorConventions.getNameForOperationSymbol((JetToken) operationReference.getReferencedNameElementType()); - - JetExpression right = binaryExpression.getRight(); - if (right != null) { - trace.report(UNSAFE_INFIX_CALL.on(reference, binaryExpression.getLeft().getText(), operationString, right.getText())); - } - } - else { - trace.report(UNSAFE_CALL.on(reference, type)); - } - } - } - - @Override - public void unnecessarySafeCall(@NotNull BindingTrace trace, @NotNull JetType type) { - ASTNode callOperationNode = call.getCallOperationNode(); - assert callOperationNode != null; - trace.report(UNNECESSARY_SAFE_CALL.on(callOperationNode.getPsi(), type)); - } - - @Override - public void danglingFunctionLiteralArgumentSuspected(@NotNull BindingTrace trace, @NotNull List functionLiteralArguments) { - for (JetExpression functionLiteralArgument : functionLiteralArguments) { - trace.report(DANGLING_FUNCTION_LITERAL_ARGUMENT_SUSPECTED.on(functionLiteralArgument)); - } - } - }; + } + } + + @Override + public void unnecessarySafeCall(@NotNull BindingTrace trace, @NotNull JetType type) { + ASTNode callOperationNode = call.getCallOperationNode(); + assert callOperationNode != null; + trace.report(UNNECESSARY_SAFE_CALL.on(callOperationNode.getPsi(), type)); + } + + @Override + public void danglingFunctionLiteralArgumentSuspected(@NotNull BindingTrace trace, @NotNull List functionLiteralArguments) { + for (JetExpression functionLiteralArgument : functionLiteralArguments) { + trace.report(DANGLING_FUNCTION_LITERAL_ARGUMENT_SUSPECTED.on(functionLiteralArgument)); + } + } + }; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java index ba4025e0644..d774dcb972a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/autocasts/DataFlowValueFactory.java @@ -142,7 +142,7 @@ public class DataFlowValueFactory { } private static boolean isInternal(@NotNull DeclarationDescriptorWithVisibility descriptor) { - if (Visibility.INTERNAL_VISIBILITIES.contains(descriptor.getVisibility())) return true; + if (Visibilities.INTERNAL_VISIBILITIES.contains(descriptor.getVisibility())) return true; DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); if (!(containingDeclaration instanceof DeclarationDescriptorWithVisibility)) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java index 51b8dc94514..edcbfe55f4c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java @@ -153,7 +153,7 @@ public class ErrorUtils { ERROR_CLASS, Collections.emptyList(), Modality.OPEN, - Visibility.INTERNAL, + Visibilities.INTERNAL, true, false, null, @@ -172,7 +172,7 @@ public class ErrorUtils { Collections.emptyList(), // TODO createErrorType(""), Modality.OPEN, - Visibility.INTERNAL, + Visibilities.INTERNAL, /*isInline = */ false ); return function; @@ -183,7 +183,7 @@ public class ErrorUtils { r.initialize( Collections.emptyList(), // TODO Collections.emptyList(), // TODO - Visibility.INTERNAL + Visibilities.INTERNAL ); r.setReturnType(createErrorType("")); return r; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java index 1edc7de6d44..f43c59f3d6e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java @@ -151,7 +151,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor { valueParameterDescriptors, /*unsubstitutedReturnType = */ null, Modality.FINAL, - Visibility.LOCAL, + Visibilities.LOCAL, /*isInline = */ false ); context.trace.record(BindingContext.FUNCTION, expression, functionDescriptor); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardClasses.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardClasses.java index 52b52c85bb8..6ed1135cd21 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardClasses.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/lang/JetStandardClasses.java @@ -155,9 +155,9 @@ public class JetStandardClasses { Collections.emptyList(), true, Variance.OUT_VARIANCE, "T" + (j + 1), j); parameters.add(typeParameterDescriptor); - PropertyDescriptor propertyDescriptor = new PropertyDescriptor(classDescriptor, Collections.emptyList(), Modality.FINAL, Visibility.PUBLIC, false, false, "_" + (j + 1), CallableMemberDescriptor.Kind.DECLARATION); + PropertyDescriptor propertyDescriptor = new PropertyDescriptor(classDescriptor, Collections.emptyList(), Modality.FINAL, Visibilities.PUBLIC, false, false, "_" + (j + 1), CallableMemberDescriptor.Kind.DECLARATION); propertyDescriptor.setType(typeParameterDescriptor.getDefaultType(), Collections.emptyList(), classDescriptor.getImplicitReceiver(), ReceiverDescriptor.NO_RECEIVER); - PropertyGetterDescriptor getterDescriptor = new PropertyGetterDescriptor(propertyDescriptor, Collections.emptyList(), Modality.FINAL, Visibility.PUBLIC, false, true, CallableMemberDescriptor.Kind.DECLARATION); + PropertyGetterDescriptor getterDescriptor = new PropertyGetterDescriptor(propertyDescriptor, Collections.emptyList(), Modality.FINAL, Visibilities.PUBLIC, false, true, CallableMemberDescriptor.Kind.DECLARATION); getterDescriptor.initialize(typeParameterDescriptor.getDefaultType()); propertyDescriptor.initialize(getterDescriptor, null); writableScope.addPropertyDescriptor(propertyDescriptor);