Added visibility information to descriptors

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaClassDescriptor.java

@@ -23,6 +23,7 @@ public class JavaClassDescriptor extends MutableDeclarationDescriptor implements
     private JetType classObjectType;
     private final WritableFunctionGroup constructors = new WritableFunctionGroup("<init>");
     private Modality modality;
+    private Visibility visibility;
     private JetType superclassType;
     private final ClassKind kind;
     private ClassReceiver implicitReceiver;
@@ -41,6 +42,10 @@ public class JavaClassDescriptor extends MutableDeclarationDescriptor implements
         this.modality = modality;
     }
 
+    public void setVisibility(Visibility visibility) {
+        this.visibility = visibility;
+    }
+
     public void setUnsubstitutedMemberScope(JavaClassMembersScope memberScope) {
         this.unsubstitutedMemberScope = memberScope;
     }
@@ -149,6 +154,12 @@ public class JavaClassDescriptor extends MutableDeclarationDescriptor implements
         return modality;
     }
 
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return visibility;
+    }
+
     @Override
     public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
         return visitor.visitClassDescriptor(this, data);

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java

@@ -10,6 +10,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.types.*;
 
 import java.util.*;
@@ -110,6 +111,7 @@ public class JavaDescriptorResolver {
                 psiClass.hasModifierProperty(PsiModifier.ABSTRACT) || psiClass.isInterface(),
                 !psiClass.hasModifierProperty(PsiModifier.FINAL))
         );
+        classDescriptor.setVisibility(resolveVisibilityFromPsiModifiers(semanticServices.getTrace(), psiClass));
         classDescriptorCache.put(psiClass.getQualifiedName(), classDescriptor);
         classDescriptor.setUnsubstitutedMemberScope(new JavaClassMembersScope(classDescriptor, psiClass, semanticServices, false));
         classDescriptor.setClassObjectMemberScope(new JavaClassMembersScope(classDescriptor, psiClass, semanticServices, true));
@@ -135,7 +137,7 @@ public class JavaDescriptorResolver {
                         classDescriptor,
                         Collections.<AnnotationDescriptor>emptyList(),
                         false);
-                constructorDescriptor.initialize(typeParameters, Collections.<ValueParameterDescriptor>emptyList(), Modality.FINAL);
+                constructorDescriptor.initialize(typeParameters, Collections.<ValueParameterDescriptor>emptyList(), Modality.FINAL, classDescriptor.getVisibility());
                 constructorDescriptor.setReturnType(classDescriptor.getDefaultType());
                 classDescriptor.addConstructor(constructorDescriptor);
                 semanticServices.getTrace().record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor);
@@ -147,7 +149,8 @@ public class JavaDescriptorResolver {
                         classDescriptor,
                         Collections.<AnnotationDescriptor>emptyList(), // TODO
                         false);
-                constructorDescriptor.initialize(typeParameters, resolveParameterDescriptors(constructorDescriptor, constructor.getParameterList().getParameters()), Modality.FINAL);
+                constructorDescriptor.initialize(typeParameters, resolveParameterDescriptors(constructorDescriptor, constructor.getParameterList().getParameters()), Modality.FINAL,
+                                                 resolveVisibilityFromPsiModifiers(semanticServices.getTrace(), constructor));
                 constructorDescriptor.setReturnType(classDescriptor.getDefaultType());
                 classDescriptor.addConstructor(constructorDescriptor);
                 semanticServices.getTrace().record(BindingContext.CONSTRUCTOR, constructor, constructorDescriptor);
@@ -291,6 +294,7 @@ public class JavaDescriptorResolver {
                 containingDeclaration,
                 Collections.<AnnotationDescriptor>emptyList(),
                 Modality.FINAL,
+                resolveVisibilityFromPsiModifiers(semanticServices.getTrace(), field),
                 !isFinal,
                 null,
                 field.getName(),
@@ -359,7 +363,8 @@ public class JavaDescriptorResolver {
                 resolveTypeParameters(functionDescriptorImpl, method.getTypeParameters()),
                 semanticServices.getDescriptorResolver().resolveParameterDescriptors(functionDescriptorImpl, parameters),
                 semanticServices.getTypeTransformer().transformToType(returnType),
-                Modality.convertFromFlags(method.hasModifierProperty(PsiModifier.ABSTRACT), !method.hasModifierProperty(PsiModifier.FINAL))
+                Modality.convertFromFlags(method.hasModifierProperty(PsiModifier.ABSTRACT), !method.hasModifierProperty(PsiModifier.FINAL)),
+                resolveVisibilityFromPsiModifiers(semanticServices.getTrace(), method)
         );
         semanticServices.getTrace().record(BindingContext.FUNCTION, method, functionDescriptorImpl);
         FunctionDescriptor substitutedFunctionDescriptor = functionDescriptorImpl;
@@ -368,4 +373,12 @@ public class JavaDescriptorResolver {
         }
         return substitutedFunctionDescriptor;
     }
+
+    private static Visibility resolveVisibilityFromPsiModifiers(BindingTrace trace, 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));
+    }
+
 }

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptor.java

@@ -54,6 +54,9 @@ public interface ClassDescriptor extends ClassifierDescriptor {
 
     @NotNull
     Modality getModality();
+    
+    @NotNull
+    Visibility getVisibility();
 
     @NotNull
     ReceiverDescriptor getImplicitReceiver();

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorImpl.java

@@ -155,6 +155,12 @@ public class ClassDescriptorImpl extends DeclarationDescriptorImpl implements Cl
         return Modality.FINAL;
     }
 
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return Visibility.PUBLIC;
+    }
+
     @NotNull
     @Override
     public ReceiverDescriptor getImplicitReceiver() {

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ConstructorDescriptorImpl.java

@@ -28,13 +28,13 @@ public class ConstructorDescriptorImpl extends FunctionDescriptorImpl implements
 
     @Override
     @Deprecated
-    public FunctionDescriptorImpl initialize(@Nullable JetType receiverType, @NotNull List<TypeParameterDescriptor> typeParameters, @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters, @Nullable JetType unsubstitutedReturnType, Modality modality) {
+    public FunctionDescriptorImpl initialize(@Nullable JetType receiverType, @NotNull List<TypeParameterDescriptor> typeParameters, @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters, @Nullable JetType unsubstitutedReturnType, Modality modality, Visibility visibility) {
         assert receiverType == null;
-        return super.initialize(null, typeParameters, unsubstitutedValueParameters, unsubstitutedReturnType, modality);
+        return super.initialize(null, typeParameters, unsubstitutedValueParameters, unsubstitutedReturnType, modality, visibility);
     }
 
-    public ConstructorDescriptorImpl initialize(@NotNull List<TypeParameterDescriptor> typeParameters, @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters, Modality modality) {
+    public ConstructorDescriptorImpl initialize(@NotNull List<TypeParameterDescriptor> typeParameters, @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters, Modality modality, Visibility visibility) {
-        super.initialize(null, typeParameters, unsubstitutedValueParameters, null, modality);
+        super.initialize(null, typeParameters, unsubstitutedValueParameters, null, modality, visibility);
         return this;
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/FunctionDescriptorImpl.java

@@ -28,6 +28,7 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
     private ReceiverDescriptor receiver;
 
     private Modality modality;
+    private Visibility visibility;
     private final Set<FunctionDescriptor> overriddenFunctions = Sets.newLinkedHashSet();
     private final FunctionDescriptor original;
 
@@ -52,11 +53,13 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
             @NotNull List<TypeParameterDescriptor> typeParameters,
             @NotNull List<ValueParameterDescriptor> unsubstitutedValueParameters,
             @Nullable JetType unsubstitutedReturnType,
-            @Nullable Modality modality) {
+            @Nullable Modality modality,
+            @NotNull Visibility visibility) {
         this.typeParameters = typeParameters;
         this.unsubstitutedValueParameters = unsubstitutedValueParameters;
         this.unsubstitutedReturnType = unsubstitutedReturnType;
         this.modality = modality;
+        this.visibility = visibility;
         this.receiver = receiverType == null ? NO_RECEIVER : new ExtensionReceiver(this, receiverType);
         return this;
     }
@@ -83,6 +86,12 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
         return modality;
     }
 
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return visibility;
+    }
+
     public void addOverriddenFunction(@NotNull FunctionDescriptor overriddenFunction) {
         overriddenFunctions.add(overriddenFunction);
     }
@@ -144,7 +153,8 @@ public class FunctionDescriptorImpl extends DeclarationDescriptorImpl implements
                 substitutedTypeParameters,
                 substitutedValueParameters,
                 substitutedReturnType,
-                modality
+                modality,
+                visibility
         );
         for (FunctionDescriptor overriddenFunction : overriddenFunctions) {
             substitutedDescriptor.addOverriddenFunction(overriddenFunction);

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/LazySubstitutingClassDescriptor.java

@@ -163,6 +163,12 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor {
         return original.getModality();
     }
 
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return original.getVisibility();
+    }
+
     @Override
     public boolean isClassObjectAValue() {
         return original.isClassObjectAValue();

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MemberDescriptor.java

@@ -8,4 +8,7 @@ import org.jetbrains.annotations.NotNull;
 public interface MemberDescriptor {
     @NotNull
     Modality getModality();
+    
+    @NotNull
+    Visibility getVisibility();
 }

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java

@@ -29,6 +29,7 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
     private Collection<JetType> supertypes = Lists.newArrayList();
 
     private Modality modality;
+    private Visibility visibility;
     private TypeConstructor typeConstructor;
     private final WritableScope scopeForMemberResolution;
     private final WritableScope scopeForMemberLookup;
@@ -281,12 +282,22 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
         this.modality = modality;
     }
 
+    public void setVisibility(Visibility visibility) {
+        this.visibility = visibility;
+    }
+
     @Override
     @NotNull
     public Modality getModality() {
         return modality;
     }
 
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return visibility;
+    }
+
     @Override
     public String toString() {
         return DescriptorRenderer.TEXT.render(this) + "[" + getClass().getCanonicalName() + "@" + System.identityHashCode(this) + "]";

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyAccessorDescriptor.java

@@ -15,18 +15,21 @@ public abstract class PropertyAccessorDescriptor extends DeclarationDescriptorIm
     private final boolean hasBody;
     private final boolean isDefault;
     private final Modality modality;
+    private final Visibility visibility;
     private final PropertyDescriptor correspondingProperty;
 
-    protected PropertyAccessorDescriptor(
+    public PropertyAccessorDescriptor(
             @NotNull Modality modality,
+            @NotNull Visibility visibility,
             @NotNull PropertyDescriptor correspondingProperty,
             @NotNull List<AnnotationDescriptor> annotations,
             @NotNull String name,
             boolean hasBody,
             boolean isDefault) {
         super(correspondingProperty.getContainingDeclaration(), annotations, name);
-        this.correspondingProperty = correspondingProperty;
         this.modality = modality;
+        this.visibility = visibility;
+        this.correspondingProperty = correspondingProperty;
         this.hasBody = hasBody;
         this.isDefault = isDefault;
     }
@@ -63,6 +66,12 @@ public abstract class PropertyAccessorDescriptor extends DeclarationDescriptorIm
         return modality;
     }
 
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return visibility;
+    }
+
     @NotNull
     public PropertyDescriptor getCorrespondingProperty() {
         return correspondingProperty;

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java

@@ -18,6 +18,7 @@ import java.util.List;
 public class PropertyDescriptor extends VariableDescriptorImpl implements MemberDescriptor {
 
     private final Modality modality;
+    private final Visibility visibility;
     private final boolean isVar;
     private final ReceiverDescriptor receiver;
     private final List<TypeParameterDescriptor> typeParemeters = Lists.newArrayListWithCapacity(0);
@@ -30,6 +31,7 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Member
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull List<AnnotationDescriptor> annotations,
             @NotNull Modality modality,
+            @NotNull Visibility visibility,
             boolean isVar,
             @Nullable JetType receiverType,
             @NotNull String name,
@@ -40,6 +42,7 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Member
 //        assert outType != null;
         this.isVar = isVar;
         this.modality = modality;
+        this.visibility = visibility;
         this.receiver = receiverType == null ? ReceiverDescriptor.NO_RECEIVER : new ExtensionReceiver(this, receiverType);
         this.original = original == null ? this : original.getOriginal();
     }
@@ -48,12 +51,13 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Member
             @NotNull DeclarationDescriptor containingDeclaration,
             @NotNull List<AnnotationDescriptor> annotations,
             @NotNull Modality modality,
+            @NotNull Visibility visibility,
             boolean isVar,
             @Nullable JetType receiverType,
             @NotNull String name,
             @Nullable JetType inType,
             @NotNull JetType outType) {
-        this(null, containingDeclaration, annotations, modality, isVar, receiverType, name, inType, outType);
+        this(null, containingDeclaration, annotations, modality, visibility, isVar, receiverType, name, inType, outType);
     }
 
     private PropertyDescriptor(
@@ -66,6 +70,7 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Member
                 original.getContainingDeclaration(),
                 original.getAnnotations(), // TODO : substitute?
                 original.getModality(),
+                original.getVisibility(),
                 original.isVar,
                 receiverType,
                 original.getName(),
@@ -107,6 +112,12 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Member
         return modality;
     }
 
+    @NotNull
+    @Override
+    public Visibility getVisibility() {
+        return visibility;
+    }
+
     @Nullable
     public PropertyGetterDescriptor getGetter() {
         return getter;

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyGetterDescriptor.java

@@ -18,8 +18,8 @@ public class PropertyGetterDescriptor extends PropertyAccessorDescriptor {
     private final Set<PropertyGetterDescriptor> overriddenGetters = Sets.newHashSet();
     private JetType returnType;
 
-    public PropertyGetterDescriptor(@NotNull Modality modality, @NotNull PropertyDescriptor correspondingProperty, @NotNull List<AnnotationDescriptor> annotations, @Nullable JetType returnType, boolean hasBody, boolean isDefault) {
+    public PropertyGetterDescriptor(@NotNull Modality modality, @NotNull Visibility visibility, @NotNull PropertyDescriptor correspondingProperty, @NotNull List<AnnotationDescriptor> annotations, @Nullable JetType returnType, boolean hasBody, boolean isDefault) {
-        super(modality, correspondingProperty, annotations, "get-" + correspondingProperty.getName(), hasBody, isDefault);
+        super(modality, visibility, correspondingProperty, annotations, "get-" + correspondingProperty.getName(), hasBody, isDefault);
         this.returnType = returnType == null ? correspondingProperty.getOutType() : returnType;
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertySetterDescriptor.java

@@ -19,8 +19,8 @@ public class PropertySetterDescriptor extends PropertyAccessorDescriptor {
     private MutableValueParameterDescriptor parameter;
     private final Set<PropertySetterDescriptor> overriddenSetters = Sets.newHashSet();
 
-    public PropertySetterDescriptor(@NotNull Modality modality, @NotNull PropertyDescriptor correspondingProperty, @NotNull List<AnnotationDescriptor> annotations, boolean hasBody, boolean isDefault) {
+    public PropertySetterDescriptor(@NotNull Modality modality, @NotNull Visibility visibility, @NotNull PropertyDescriptor correspondingProperty, @NotNull List<AnnotationDescriptor> annotations, boolean hasBody, boolean isDefault) {
-        super(modality, correspondingProperty, annotations, "set-" + correspondingProperty.getName(), hasBody, isDefault);
+        super(modality, visibility, correspondingProperty, annotations, "set-" + correspondingProperty.getName(), hasBody, isDefault);
     }
 
     public void initialize(@NotNull MutableValueParameterDescriptor parameter) {

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/VariableAsFunctionDescriptor.java

@@ -16,7 +16,7 @@ public class VariableAsFunctionDescriptor extends FunctionDescriptorImpl {
         assert outType != null;
         assert JetStandardClasses.isFunctionType(outType);
         VariableAsFunctionDescriptor result = new VariableAsFunctionDescriptor(variableDescriptor);
-        result.initialize(JetStandardClasses.getReceiverType(outType), Collections.<TypeParameterDescriptor>emptyList(), JetStandardClasses.getValueParameters(result, outType), JetStandardClasses.getReturnType(outType), Modality.FINAL);
+        result.initialize(JetStandardClasses.getReceiverType(outType), Collections.<TypeParameterDescriptor>emptyList(), JetStandardClasses.getValueParameters(result, outType), JetStandardClasses.getReturnType(outType), Modality.FINAL, Visibility.LOCAL);
         return result;
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/Visibility.java

@@ -0,0 +1,23 @@
+package org.jetbrains.jet.lang.descriptors;
+
+/**
+ * @author svtk
+ */
+public enum Visibility {
+    PRIVATE(false),
+    PROTECTED(true),
+    INTERNAL(false),
+    PUBLIC(true),
+    INTERNAL_PROTECTED(false),
+    LOCAL(false);
+
+    private final boolean isAPI;
+
+    private Visibility(boolean visibleOutside) {
+        isAPI = visibleOutside;
+    }
+
+    public boolean isAPI() {
+        return isAPI;
+    }
+}

compiler/frontend/src/org/jetbrains/jet/lang/resolve/ClassDescriptorResolver.java

@@ -21,6 +21,8 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lexer.JetKeywordToken;
+import org.jetbrains.jet.lexer.JetToken;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import java.util.*;
@@ -65,7 +67,8 @@ public class ClassDescriptorResolver {
         }
         descriptor.setTypeParameterDescriptors(typeParameters);
         Modality defaultModality = descriptor.getKind() == ClassKind.TRAIT ? Modality.ABSTRACT : Modality.FINAL;
-        descriptor.setModality(resolveModalityFromModifiers(classElement.getModifierList(), defaultModality));
+        descriptor.setModality(resolveModalityFromModifiers(trace, classElement.getModifierList(), defaultModality));
+        descriptor.setVisibility(resolveVisibilityFromModifiers(trace, classElement.getModifierList()));
 
         trace.record(BindingContext.CLASS, classElement, descriptor);
     }
@@ -195,14 +198,16 @@ public class ClassDescriptorResolver {
         } else {
             defaultModality = Modality.FINAL;
         }
-        Modality modality = resolveModalityFromModifiers(function.getModifierList(), defaultModality);
+        Modality modality = resolveModalityFromModifiers(trace, function.getModifierList(), defaultModality);
+        Visibility visibility = resolveVisibilityFromModifiers(trace, function.getModifierList());
 
         functionDescriptor.initialize(
                 receiverType,
                 typeParameterDescriptors,
                 valueParameterDescriptors,
                 returnType,
-                modality);
+                modality,
+                visibility);
 
         trace.record(BindingContext.FUNCTION, function, functionDescriptor);
         return functionDescriptor;
@@ -424,7 +429,8 @@ public class ClassDescriptorResolver {
         PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
                 containingDeclaration,
                 annotationResolver.createAnnotationStubs(modifierList),
-                resolveModalityFromModifiers(modifierList), // TODO : default modifiers differ in different contexts
+                resolveModalityFromModifiers(trace, objectDeclaration.getModifierList()), // TODO : default modifiers differ in different contexts
+                resolveVisibilityFromModifiers(trace, objectDeclaration.getModifierList()),
                 false,
                 null,
                 JetPsiUtil.safeName(objectDeclaration.getName()),
@@ -474,7 +480,8 @@ public class ClassDescriptorResolver {
         PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
                 containingDeclaration,
                 annotationResolver.resolveAnnotations(scope, modifierList),
-                resolveModalityFromModifiers(modifierList), // TODO : default modifiers differ in different contexts
+                resolveModalityFromModifiers(trace, property.getModifierList()), // TODO : default modifiers differ in different contexts
+                resolveVisibilityFromModifiers(trace, property.getModifierList()),
                 isVar,
                 receiverType,
                 JetPsiUtil.safeName(property.getName()),
@@ -523,20 +530,31 @@ public class ClassDescriptorResolver {
     }
 
     @NotNull
-    private Modality resolveModalityFromModifiers(@Nullable JetModifierList modifierList) {
+    /*package*/ static Modality resolveModalityFromModifiers(@NotNull BindingTrace trace, @Nullable JetModifierList modifierList) {
-        return resolveModalityFromModifiers(modifierList, Modality.FINAL);
+        return resolveModalityFromModifiers(trace, modifierList, Modality.FINAL);
     }
 
     @NotNull
-    private Modality resolveModalityFromModifiers(@Nullable JetModifierList modifierList, @NotNull Modality defaultModality) {
+    /*package*/ static Modality resolveModalityFromModifiers(@NotNull BindingTrace trace, @Nullable JetModifierList modifierList, @NotNull Modality defaultModality) {
         if (modifierList == null) return defaultModality;
-        if (modifierList.hasModifier(JetTokens.ABSTRACT_KEYWORD)) {
+        checkCompatibility(trace, modifierList, Lists.newArrayList(JetTokens.ABSTRACT_KEYWORD, JetTokens.OPEN_KEYWORD, JetTokens.FINAL_KEYWORD),
-            return Modality.ABSTRACT;
+                           Lists.<JetToken>newArrayList(JetTokens.ABSTRACT_KEYWORD, JetTokens.OPEN_KEYWORD));
-        }
+        boolean hasAbstractModifier = modifierList.hasModifier(JetTokens.ABSTRACT_KEYWORD);
+        boolean hasOverrideModifier = modifierList.hasModifier(JetTokens.OVERRIDE_KEYWORD);
+
         if (modifierList.hasModifier(JetTokens.OPEN_KEYWORD)) {
+            if (hasAbstractModifier || hasOverrideModifier) {
+                trace.report(Errors.REDUNDANT_MODIFIER.on(modifierList, JetTokens.OPEN_KEYWORD, hasAbstractModifier ? JetTokens.ABSTRACT_KEYWORD : JetTokens.OVERRIDE_KEYWORD));
+            }
+            if (hasAbstractModifier) {
+                return Modality.ABSTRACT;
+            }
             return Modality.OPEN;
         }
-        if (modifierList.hasModifier(JetTokens.OVERRIDE_KEYWORD)) {
+        if (hasAbstractModifier) {
+            return Modality.ABSTRACT;
+        }
+        if (hasOverrideModifier) {
             return Modality.OPEN;
         }
         if (modifierList.hasModifier(JetTokens.FINAL_KEYWORD)) {
@@ -545,6 +563,49 @@ public class ClassDescriptorResolver {
         return defaultModality;
     }
     
+    @NotNull
+    /*package*/ static Visibility resolveVisibilityFromModifiers(@NotNull BindingTrace trace, @Nullable JetModifierList modifierList) {
+        return resolveVisibilityFromModifiers(trace, modifierList, Visibility.INTERNAL);
+    }
+
+    @NotNull
+    /*package*/ static Visibility resolveVisibilityFromModifiers(@NotNull BindingTrace trace, @Nullable JetModifierList modifierList, @NotNull Visibility defaultVisibility) {
+        if (modifierList == null) return defaultVisibility;
+        checkCompatibility(trace, modifierList, Lists.newArrayList(JetTokens.PRIVATE_KEYWORD, JetTokens.PROTECTED_KEYWORD, JetTokens.PUBLIC_KEYWORD, JetTokens.INTERNAL_KEYWORD),
+                                       Lists.<JetToken>newArrayList(JetTokens.PROTECTED_KEYWORD, JetTokens.INTERNAL_KEYWORD));
+        if (modifierList.hasModifier(JetTokens.PRIVATE_KEYWORD)) return Visibility.PRIVATE;
+        if (modifierList.hasModifier(JetTokens.PUBLIC_KEYWORD)) return Visibility.PUBLIC;
+        if (modifierList.hasModifier(JetTokens.PROTECTED_KEYWORD)) {
+            if (modifierList.hasModifier(JetTokens.INTERNAL_KEYWORD)) {
+                return Visibility.INTERNAL_PROTECTED;
+            }
+            return Visibility.PROTECTED;
+        }
+        return defaultVisibility;
+    }
+    
+    /*package*/ static boolean checkCompatibility(@NotNull BindingTrace trace, @Nullable JetModifierList modifierList, Collection<JetKeywordToken> availableModifiers, Collection<JetToken>... availableCombinations) {
+        if (modifierList == null) return true;
+        Collection<JetKeywordToken> presentModifiers = Sets.newLinkedHashSet();
+        for (JetKeywordToken modifier : availableModifiers) {
+            if (modifierList.hasModifier(modifier)) {
+                presentModifiers.add(modifier);
+            }
+        }
+        if (presentModifiers.size() == 1) {
+            return true;
+        }
+        for (Collection<JetToken> combination : availableCombinations) {
+            if (presentModifiers.containsAll(combination) && combination.containsAll(presentModifiers)) {
+                return true;
+            }
+        }
+        for (JetKeywordToken token : presentModifiers) {
+            trace.report(Errors.INCOMPATIBLE_MODIFIERS.on(modifierList.getModifierNode(token), presentModifiers));
+        }
+        return false;
+    }
+    
     @Nullable
     private PropertySetterDescriptor resolvePropertySetterDescriptor(@NotNull JetScope scope, @NotNull JetProperty property, @NotNull PropertyDescriptor propertyDescriptor) {
         JetPropertyAccessor setter = property.getSetter();
@@ -554,7 +615,8 @@ public class ClassDescriptorResolver {
             JetParameter parameter = setter.getParameter();
 
             setterDescriptor = new PropertySetterDescriptor(
-                    resolveModalityFromModifiers(setter.getModifierList()), // TODO : default modifiers differ in different contexts
+                    resolveModalityFromModifiers(trace, setter.getModifierList()), // TODO : default modifiers differ in different contexts
+                    resolveVisibilityFromModifiers(trace, setter.getModifierList(), propertyDescriptor.getVisibility()),
                     propertyDescriptor, annotations, setter.getBodyExpression() != null, false);
             if (parameter != null) {
                 if (parameter.isRef()) {
@@ -596,6 +658,7 @@ public class ClassDescriptorResolver {
         else if (property.isVar()) {
             setterDescriptor = new PropertySetterDescriptor(
                     propertyDescriptor.getModality(),
+                    propertyDescriptor.getVisibility(),
                     propertyDescriptor, Collections.<AnnotationDescriptor>emptyList(), false, true);
         }
 
@@ -627,13 +690,15 @@ public class ClassDescriptorResolver {
             }
 
             getterDescriptor = new PropertyGetterDescriptor(
-                    resolveModalityFromModifiers(getter.getModifierList()), // TODO : default modifiers differ in different contexts
+                    resolveModalityFromModifiers(trace, getter.getModifierList()), // TODO : default modifiers differ in different contexts
+                    resolveVisibilityFromModifiers(trace, getter.getModifierList(), propertyDescriptor.getVisibility()),
                     propertyDescriptor, annotations, returnType, getter.getBodyExpression() != null, false);
             trace.record(BindingContext.PROPERTY_ACCESSOR, getter, getterDescriptor);
         }
         else {
             getterDescriptor = new PropertyGetterDescriptor(
                     propertyDescriptor.getModality(),
+                    propertyDescriptor.getVisibility(),
                     propertyDescriptor, Collections.<AnnotationDescriptor>emptyList(), propertyDescriptor.getOutType(), false, true);
         }
         return getterDescriptor;
@@ -664,7 +729,8 @@ public class ClassDescriptorResolver {
                         constructorDescriptor,
                         new WritableScopeImpl(scope, classDescriptor, new TraceBasedRedeclarationHandler(trace)).setDebugName("Scope with value parameters of a constructor"),
                         valueParameters),
-                        Modality.FINAL);
+                        Modality.FINAL,
+                        resolveVisibilityFromModifiers(trace, modifierList));
     }
 
     @Nullable
@@ -700,7 +766,8 @@ public class ClassDescriptorResolver {
         PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
                 classDescriptor,
                 annotationResolver.resolveAnnotations(scope, modifierList),
-                resolveModalityFromModifiers(modifierList),
+                resolveModalityFromModifiers(trace, parameter.getModifierList()),
+                resolveVisibilityFromModifiers(trace, parameter.getModifierList()),
                 isMutable,
                 null,
                 name == null ? "<no name>" : name,

compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java

@@ -96,6 +96,7 @@ public class TypeHierarchyResolver {
                         MutableClassDescriptor classObjectDescriptor = new MutableClassDescriptor(context.getTrace(), mutableClassDescriptor, outerScope, ClassKind.OBJECT);
                         classObjectDescriptor.setName("class-object-for-" + klass.getName());
                         classObjectDescriptor.setModality(Modality.FINAL);
+                        classObjectDescriptor.setVisibility(ClassDescriptorResolver.resolveVisibilityFromModifiers(context.getTrace(), klass.getModifierList()));
                         classObjectDescriptor.createTypeConstructor();
                         createPrimaryConstructor(classObjectDescriptor);
                         mutableClassDescriptor.setClassObjectDescriptor(classObjectDescriptor);
@@ -151,7 +152,7 @@ public class TypeHierarchyResolver {
                 private void createPrimaryConstructor(MutableClassDescriptor mutableClassDescriptor) {
                     ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl(mutableClassDescriptor, Collections.<AnnotationDescriptor>emptyList(), true);
                     constructorDescriptor.initialize(Collections.<TypeParameterDescriptor>emptyList(), Collections.<ValueParameterDescriptor>emptyList(),
-                                                     Modality.FINAL);
+                                                     Modality.FINAL, Visibility.INTERNAL);//TODO check set mutableClassDescriptor.getVisibility()
                     // TODO : make the constructor private?
                     mutableClassDescriptor.setPrimaryConstructor(constructorDescriptor);
                 }
@@ -265,8 +266,10 @@ public class TypeHierarchyResolver {
             descriptor.createTypeConstructor();
         }
         for (Map.Entry<JetObjectDeclaration, MutableClassDescriptor> entry : context.getObjects().entrySet()) {
+            JetObjectDeclaration objectDeclaration = entry.getKey();
             MutableClassDescriptor descriptor = entry.getValue();
             descriptor.setModality(Modality.FINAL);
+            descriptor.setVisibility(ClassDescriptorResolver.resolveVisibilityFromModifiers(context.getTrace(), objectDeclaration.getModifierList()));
             descriptor.createTypeConstructor();
         }
     }

compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java

@@ -118,6 +118,7 @@ public class ErrorUtils {
             ERROR_CLASS,
             Collections.<AnnotationDescriptor>emptyList(),
             Modality.OPEN,
+            Visibility.INTERNAL,
             true,
             null,
             "<ERROR PROPERTY>",
@@ -130,7 +131,8 @@ public class ErrorUtils {
                 typeParameters,
                 getValueParameters(functionDescriptor, positionedValueArgumentTypes),
                 createErrorType("<ERROR FUNCTION RETURN>"),
-                Modality.OPEN
+                Modality.OPEN,
+                Visibility.INTERNAL
         );
     }
 
@@ -140,7 +142,8 @@ public class ErrorUtils {
                 Collections.<TypeParameterDescriptor>emptyList(), // TODO
                 Collections.<ValueParameterDescriptor>emptyList(), // TODO
                 createErrorType("<ERROR FUNCTION RETURN TYPE>"),
-                Modality.OPEN
+                Modality.OPEN,
+                Visibility.INTERNAL
         );
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/types/JetTypeInferrer.java

@@ -975,7 +975,7 @@ public class JetTypeInferrer {
             else {
                 effectiveReceiverType = receiverType;
             }
-            functionDescriptor.initialize(effectiveReceiverType, Collections.<TypeParameterDescriptor>emptyList(), valueParameterDescriptors, null, Modality.FINAL);
+            functionDescriptor.initialize(effectiveReceiverType, Collections.<TypeParameterDescriptor>emptyList(), valueParameterDescriptors, null, Modality.FINAL, Visibility.LOCAL);
             context.trace.record(BindingContext.FUNCTION, expression, functionDescriptor);
 
             JetType returnType = NO_EXPECTED_TYPE;