make modality 'FINAL' for non-class members

not depend on actual modifier since it's not legal there

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

@@ -758,12 +758,15 @@ public class DescriptorResolver {
         boolean isVar = property.isVar();
 
         boolean hasBody = hasBody(property);
-        Modality defaultModality = getDefaultModality(containingDeclaration, hasBody);
+        Modality modality = containingDeclaration instanceof ClassDescriptor
+                            ? ModifiersChecker.resolveModalityFromModifiers(property, getDefaultModality(containingDeclaration, hasBody))
+                            : Modality.FINAL;
+        Visibility visibility = ModifiersChecker.resolveVisibilityFromModifiers(property, getDefaultVisibility(property, containingDeclaration));
         PropertyDescriptor propertyDescriptor = new PropertyDescriptor(
                 containingDeclaration,
                 annotationResolver.resolveAnnotations(scope, modifierList, trace),
-                ModifiersChecker.resolveModalityFromModifiers(property, defaultModality),
+                modality,
-                ModifiersChecker.resolveVisibilityFromModifiers(property),
+                visibility,
                 isVar,
                 JetPsiUtil.safeName(property.getName()),
                 CallableMemberDescriptor.Kind.DECLARATION

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

@@ -179,11 +179,7 @@ public class ModifiersChecker {
 
     @NotNull
     public static Visibility resolveVisibilityFromModifiers(@NotNull JetModifierListOwner modifierListOwner) {
-        JetModifierList modifierList = modifierListOwner.getModifierList();
+        return resolveVisibilityFromModifiers(modifierListOwner, Visibilities.INTERNAL);
-        Visibility defaultVisibility = modifierList != null && modifierList.hasModifier(OVERRIDE_KEYWORD)
-                                       ? Visibilities.INHERITED
-                                       : Visibilities.INTERNAL;
-        return resolveVisibilityFromModifiers(modifierListOwner, defaultVisibility);
     }
 
     @NotNull

compiler/testData/diagnostics/tests/Abstract.kt

@@ -3,23 +3,23 @@ package MyNamespace
     //properties
     <!MUST_BE_INITIALIZED!>val a: Int<!>
     val a1: Int = 1
-    <!ILLEGAL_MODIFIER!>abstract<!> val a2: Int
+    <!MUST_BE_INITIALIZED!><!ILLEGAL_MODIFIER!>abstract<!> val a2: Int<!>
     <!ILLEGAL_MODIFIER!>abstract<!> val a3: Int = 1
 
     <!MUST_BE_INITIALIZED!>var b: Int<!>                private set
     var b1: Int = 0;                         private set
-    <!ILLEGAL_MODIFIER!>abstract<!> var b2: Int      private set
+    <!MUST_BE_INITIALIZED!><!ILLEGAL_MODIFIER!>abstract<!> var b2: Int<!>      private set
     <!ILLEGAL_MODIFIER!>abstract<!> var b3: Int = 0; private set
 
     <!MUST_BE_INITIALIZED!>var c: Int<!>                set(v: Int) { $c = v }
     var c1: Int = 0;                         set(v: Int) { $c1 = v }
-    <!ILLEGAL_MODIFIER!>abstract<!> var c2: Int      set(v: Int) { $c2 = v }
+    <!MUST_BE_INITIALIZED!><!ILLEGAL_MODIFIER!>abstract<!> var c2: Int<!>      set(v: Int) { $c2 = v }
     <!ILLEGAL_MODIFIER!>abstract<!> var c3: Int = 0; set(v: Int) { $c3 = v }
 
     val e: Int                               get() = a
     val e1: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>;          get() = a
     <!ILLEGAL_MODIFIER!>abstract<!> val e2: Int      get() = a
-    <!ILLEGAL_MODIFIER!>abstract<!> val e3: Int = 0; get() = a
+    <!ILLEGAL_MODIFIER!>abstract<!> val e3: Int = <!PROPERTY_INITIALIZER_NO_BACKING_FIELD!>0<!>; get() = a
 
     //methods
     <!NON_MEMBER_FUNCTION_NO_BODY!>fun f()<!>

compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.kt

@@ -1,6 +1,6 @@
 package d
 
-<!ILLEGAL_MODIFIER!>abstract<!> val a : Int
+<!ILLEGAL_MODIFIER!>abstract<!> val a : Int = 1
 
 <!ILLEGAL_MODIFIER!>override<!> val c : Int = 1
 

compiler/testData/diagnostics/tests/declarationChecks/propertyInPackageHasNoInheritVisibility.kt

@@ -0,0 +1,7 @@
+package d
+
+<!ILLEGAL_MODIFIER!>override<!> val f : ()-> Int = { 12 }
+
+fun test() {
+    f()
+}

compiler/tests/org/jetbrains/jet/checkers/JetDiagnosticsTestGenerated.java

@@ -1123,6 +1123,11 @@ public class JetDiagnosticsTestGenerated extends AbstractDiagnosticsTestWithEage
                 doTest("compiler/testData/diagnostics/tests/declarationChecks/packageDeclarationModifiers.kt");
             }
             
+            @TestMetadata("propertyInPackageHasNoInheritVisibility.kt")
+            public void testPropertyInPackageHasNoInheritVisibility() throws Exception {
+                doTest("compiler/testData/diagnostics/tests/declarationChecks/propertyInPackageHasNoInheritVisibility.kt");
+            }
+            
             @TestMetadata("RedeclarationsInMultiDecl.kt")
             public void testRedeclarationsInMultiDecl() throws Exception {
                 doTest("compiler/testData/diagnostics/tests/declarationChecks/RedeclarationsInMultiDecl.kt");

idea/testData/checker/Abstract.jet

@@ -122,23 +122,23 @@ abstract enum class MyAbstractEnum() {}
     //properties
     <error>val a: Int</error>
     val a1: Int = 1
-    <error>abstract</error> val a2: Int
+    <error><error>abstract</error> val a2: Int</error>
     <error>abstract</error> val a3: Int = 1
 
     <error>var b: Int</error>                private set
     var b1: Int = 0;                         private set
-    <error>abstract</error> var b2: Int      private set
+    <error><error>abstract</error> var b2: Int</error>      private set
     <error>abstract</error> var b3: Int = 0; private set
 
     <error>var c: Int</error>                set(v: Int) { $c = v }
     var c1: Int = 0;                         set(v: Int) { $c1 = v }
-    <error>abstract</error> var c2: Int      set(v: Int) { $c2 = v }
+    <error><error>abstract</error> var c2: Int</error>      set(v: Int) { $c2 = v }
     <error>abstract</error> var c3: Int = 0; set(v: Int) { $c3 = v }
 
     val e: Int                               get() = a
     val e1: Int = <error>0</error>;          get() = a
     <error>abstract</error> val e2: Int      get() = a
-    <error>abstract</error> val e3: Int = 0; get() = a
+    <error>abstract</error> val e3: Int = <error>0</error>; get() = a
 
     //methods
     <error>fun f()</error>
@@ -160,6 +160,6 @@ abstract class B3(i: Int) {
 }
 
 fun foo(<warning>a</warning>: B3) {
-    val <warning>a</warning> = <error>B3(1)</error>
+    val <warning><warning>a</warning></warning> = <error>B3(1)</error>
     val <warning>b</warning> = <error>B1(2, "s")</error>
 }