Support platformStatic for properties

#KT-5766 Fixed

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/DefaultErrorMessagesJvm.java

@@ -23,8 +23,6 @@ import org.jetbrains.jet.lang.diagnostics.rendering.DiagnosticFactoryToRendererM
 import org.jetbrains.jet.renderer.DescriptorRenderer;
 import org.jetbrains.jet.renderer.Renderer;
 
-import static org.jetbrains.jet.lang.diagnostics.PositioningStrategies.DECLARATION_SIGNATURE;
-
 public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension {
 
     private static final Renderer<ConflictingJvmDeclarationsData> CONFLICTING_JVM_DECLARATIONS_DATA = new Renderer<ConflictingJvmDeclarationsData>() {
@@ -46,8 +44,8 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension {
     static {
         MAP.put(ErrorsJvm.CONFLICTING_JVM_DECLARATIONS, "Platform declaration clash: {0}", CONFLICTING_JVM_DECLARATIONS_DATA);
         MAP.put(ErrorsJvm.ACCIDENTAL_OVERRIDE, "Accidental override: {0}", CONFLICTING_JVM_DECLARATIONS_DATA);
-        MAP.put(ErrorsJvm.PLATFORM_STATIC_NOT_IN_OBJECT, "Only functions in named objects and class objects of classes can be annotated with ''platformStatic''", DescriptorRenderer.SHORT_NAMES_IN_TYPES);
-        MAP.put(ErrorsJvm.OVERRIDE_CANNOT_BE_STATIC, "Override cannot be ''platformStatic'' in object", DescriptorRenderer.SHORT_NAMES_IN_TYPES);
+        MAP.put(ErrorsJvm.PLATFORM_STATIC_NOT_IN_OBJECT, "Only functions in named objects and class objects of classes can be annotated with ''platformStatic''");
+        MAP.put(ErrorsJvm.OVERRIDE_CANNOT_BE_STATIC, "Override cannot be ''platformStatic'' in object");
         MAP.put(ErrorsJvm.PLATFORM_STATIC_ILLEGAL_USAGE, "This declaration does not support ''platformStatic''", DescriptorRenderer.SHORT_NAMES_IN_TYPES);
     }
 

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/diagnostics/ErrorsJvm.java

@@ -22,7 +22,6 @@ import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory0;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticFactory1;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
-import org.jetbrains.jet.lang.psi.JetElement;
 
 import static org.jetbrains.jet.lang.diagnostics.PositioningStrategies.DECLARATION_SIGNATURE;
 import static org.jetbrains.jet.lang.diagnostics.PositioningStrategies.DECLARATION_SIGNATURE_OR_DEFAULT;
@@ -35,8 +34,8 @@ public interface ErrorsJvm {
     DiagnosticFactory1<PsiElement, ConflictingJvmDeclarationsData> ACCIDENTAL_OVERRIDE =
             DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT);
 
-    DiagnosticFactory1<JetDeclaration, DeclarationDescriptor> OVERRIDE_CANNOT_BE_STATIC = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE);
-    DiagnosticFactory1<JetDeclaration, DeclarationDescriptor> PLATFORM_STATIC_NOT_IN_OBJECT = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<JetDeclaration> OVERRIDE_CANNOT_BE_STATIC = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
+    DiagnosticFactory0<JetDeclaration> PLATFORM_STATIC_NOT_IN_OBJECT = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
     DiagnosticFactory1<JetDeclaration, DeclarationDescriptor> PLATFORM_STATIC_ILLEGAL_USAGE = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE);
 
     @SuppressWarnings("UnusedDeclaration")

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/kotlin/JavaDeclarationCheckerProvider.kt

@@ -44,6 +44,7 @@ import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
 import org.jetbrains.jet.lang.resolve.name.Name
 import org.jetbrains.jet.lang.resolve.annotations.hasIntrinsicAnnotation
+import org.jetbrains.jet.lang.psi.JetPropertyAccessor
 
 public object JavaDeclarationCheckerProvider : AdditionalCheckerProvider {
 
@@ -68,18 +69,10 @@ public class PlatformStaticAnnotationChecker : AnnotationChecker {
 
     override fun check(declaration: JetDeclaration, descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink) {
         if (descriptor.hasPlatformStaticAnnotation()) {
-            if (declaration is JetNamedFunction) {
-                val insideObject = DescriptorUtils.containerKindIs(descriptor, ClassKind.OBJECT)
-                val insideClassObject = DescriptorUtils.containerKindIs(descriptor, ClassKind.CLASS_OBJECT)
-
-                if (!insideObject && !(insideClassObject && DescriptorUtils.containerKindIs(descriptor.getContainingDeclaration()!!, ClassKind.CLASS))) {
-                    diagnosticHolder.report(ErrorsJvm.PLATFORM_STATIC_NOT_IN_OBJECT.on(declaration, descriptor));
-                }
-
-                if (insideObject && declaration.hasModifier(JetTokens.OVERRIDE_KEYWORD)) {
-                    diagnosticHolder.report(ErrorsJvm.OVERRIDE_CANNOT_BE_STATIC.on(declaration, descriptor));
-                }
-            } else {
+            if (declaration is JetNamedFunction || declaration is JetProperty) {
+                checkDeclaration(declaration, descriptor, diagnosticHolder, declaration)
+            }
+            else {
                 //TODO: there should be general mechanism
                 diagnosticHolder.report(ErrorsJvm.PLATFORM_STATIC_ILLEGAL_USAGE.on(declaration, descriptor));
             }
@@ -88,14 +81,44 @@ public class PlatformStaticAnnotationChecker : AnnotationChecker {
         if (declaration is JetProperty) {
             val getter = declaration.getGetter()
             if (getter != null) {
-                check(getter, (descriptor as PropertyDescriptor).getGetter()!!, diagnosticHolder)
+                val propertyGetterDescriptor = (descriptor as PropertyDescriptor).getGetter()!!
+                if (propertyGetterDescriptor.hasPlatformStaticAnnotation()) {
+                    checkDeclaration(declaration, descriptor, diagnosticHolder, getter)
+                }
             }
+
             val setter = declaration.getSetter()
             if (setter != null) {
-                check(setter, (descriptor as PropertyDescriptor).getSetter()!!, diagnosticHolder)
+                val propertySetterDescriptor = (descriptor as PropertyDescriptor).getSetter()!!
+                if (propertySetterDescriptor.hasPlatformStaticAnnotation()) {
+                    checkDeclaration(declaration, descriptor, diagnosticHolder, setter)
+                }
             }
         }
     }
+
+    private fun checkDeclaration(
+            declaration: JetDeclaration,
+            descriptor: DeclarationDescriptor,
+            diagnosticHolder: DiagnosticSink,
+            reportDiagnosticOn: JetDeclaration
+    ) {
+        val insideObject = containerKindIs(descriptor, ClassKind.OBJECT)
+        val insideClassObject = containerKindIs(descriptor, ClassKind.CLASS_OBJECT)
+
+        if (!insideObject && !(insideClassObject && containerKindIs(descriptor.getContainingDeclaration()!!, ClassKind.CLASS))) {
+            diagnosticHolder.report(ErrorsJvm.PLATFORM_STATIC_NOT_IN_OBJECT.on(reportDiagnosticOn));
+        }
+
+        if (insideObject && declaration.hasModifier(JetTokens.OVERRIDE_KEYWORD)) {
+            diagnosticHolder.report(ErrorsJvm.OVERRIDE_CANNOT_BE_STATIC.on(reportDiagnosticOn));
+        }
+    }
+
+    private fun containerKindIs(descriptor: DeclarationDescriptor, kind: ClassKind): Boolean {
+        val parentDeclaration = descriptor.getContainingDeclaration()
+        return parentDeclaration != null && DescriptorUtils.isKindOf(parentDeclaration, kind)
+    }
 }
 
 public class ReifiedTypeParameterAnnotationChecker : AnnotationChecker {