Added platform static checker with provider implementation

compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java

@@ -31,6 +31,7 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.annotations.AnnotationsPackage;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.java.*;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaCallableMemberDescriptor;
@@ -169,7 +170,7 @@ public class AsmUtil {
     public static boolean isStaticMethod(OwnerKind kind, CallableMemberDescriptor functionDescriptor) {
         return isStaticKind(kind) ||
                JetTypeMapper.isAccessor(functionDescriptor) ||
-               JvmCodegenUtil.isPlatformStaticInObject(functionDescriptor);
+               AnnotationsPackage.isPlatformStaticInObject(functionDescriptor);
     }
 
     public static boolean isStaticKind(OwnerKind kind) {

compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -47,6 +47,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.BindingContextUtils;
 import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.annotations.AnnotationsPackage;
 import org.jetbrains.jet.lang.resolve.calls.model.*;
 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
 import org.jetbrains.jet.lang.resolve.calls.util.FakeCallableDescriptorForObject;
@@ -2308,7 +2309,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         if (isSingleton) {
             if (context.hasThisDescriptor() &&
                 context.getThisDescriptor().equals(calleeContainingClass) &&
-                !isPlatformStaticInObject(context.getContextDescriptor())) {
+                !AnnotationsPackage.isPlatformStaticInObject(context.getContextDescriptor())) {
                 return StackValue.local(0, typeMapper.mapType(calleeContainingClass));
             }
             else {

compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java

@@ -39,6 +39,8 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.ResolvePackage;
+import org.jetbrains.jet.lang.resolve.annotations.AnnotationsPackage;
 import org.jetbrains.jet.lang.resolve.calls.CallResolverUtil;
 import org.jetbrains.jet.lang.resolve.constants.ArrayValue;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
@@ -151,7 +153,7 @@ public class FunctionCodegen extends ParentCodegenAware {
         generateBridges(functionDescriptor);
 
 
-        if (JvmCodegenUtil.isPlatformStaticInClassObject(functionDescriptor)) {
+        if (AnnotationsPackage.isPlatformStaticInClassObject(functionDescriptor)) {
             MemberCodegen<?> codegen = getParentCodegen().getParentCodegen();
             ((ImplementationBodyCodegen) codegen).addAdditionalTask(new PlatformStaticGenerator(functionDescriptor, origin, state));
         }

compiler/backend/src/org/jetbrains/jet/codegen/JvmCodegenUtil.java

@@ -31,7 +31,6 @@ import org.jetbrains.jet.codegen.context.PackageContext;
 import org.jetbrains.jet.codegen.state.JetTypeMapper;
 import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedCallableMemberDescriptor;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.codeFragmentUtil.CodeFragmentUtilPackage;
 import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils;
@@ -40,7 +39,6 @@ import org.jetbrains.jet.lang.resolve.java.lazy.descriptors.LazyJavaPackageFragm
 import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass;
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileKotlinClass;
 import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalPackageFragmentProvider;
-import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.types.JetType;
 
 import java.io.File;
@@ -239,23 +237,4 @@ public class JvmCodegenUtil {
                ? ((PropertyAccessorDescriptor) descriptor).getCorrespondingProperty()
                : descriptor;
     }
-
-    public static boolean isPlatformStaticInObject(CallableDescriptor descriptor) {
-        if (DescriptorUtils.isObject(descriptor.getContainingDeclaration())) {
-            return hasPlatformStaticAnnotation(descriptor);
-        }
-        return false;
-    }
-
-    public static boolean isPlatformStaticInClassObject(CallableDescriptor descriptor) {
-        if (DescriptorUtils.isClassObject(descriptor.getContainingDeclaration())) {
-            return hasPlatformStaticAnnotation(descriptor);
-        }
-        return false;
-    }
-
-    public static boolean hasPlatformStaticAnnotation(@NotNull CallableDescriptor descriptor) {
-        AnnotationDescriptor platformStaticAnnotation = descriptor.getAnnotations().findAnnotation(new FqName("kotlin.platform.platformStatic"));
-        return platformStaticAnnotation != null;
-    }
 }

compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.state.JetTypeMapper;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.JetExpression;
+import org.jetbrains.jet.lang.resolve.annotations.AnnotationsPackage;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverValue;
@@ -1129,7 +1130,7 @@ public abstract class StackValue {
             ReceiverValue receiverArgument = resolvedCall.getReceiverArgument();
             int depth = 0;
             if (thisObject.exists()) {
-                if (!JvmCodegenUtil.isPlatformStaticInObject(descriptor)) {
+                if (!AnnotationsPackage.isPlatformStaticInObject(descriptor)) {
                     if (receiverArgument.exists()) {
                         //noinspection ConstantConditions
                         Type resultType =

compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java

@@ -31,10 +31,8 @@ import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.AnonymousFunctionDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.*;
-import org.jetbrains.jet.lang.resolve.DescriptorToSourceUtils;
+import org.jetbrains.jet.lang.resolve.annotations.AnnotationsPackage;
-import org.jetbrains.jet.lang.resolve.DescriptorUtils;
-import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.calls.model.DefaultValueArgument;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedValueArgument;
@@ -445,7 +443,7 @@ public class JetTypeMapper {
             else {
                 if (isStaticDeclaration(functionDescriptor) ||
                     isAccessor(functionDescriptor) ||
-                    isPlatformStaticInObject(functionDescriptor)) {
+                    AnnotationsPackage.isPlatformStaticInObject(functionDescriptor)) {
                     invokeOpcode = INVOKESTATIC;
                 }
                 else if (isInterface) {

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForLazyResolveWithJava.java

@@ -36,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureCheck
 import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaPropertyInitializerEvaluatorImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.JavaSourceElementFactoryImpl;
+import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
@@ -91,6 +92,7 @@ public class InjectorForLazyResolveWithJava {
     private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver;
     private final JavaPropertyInitializerEvaluatorImpl javaPropertyInitializerEvaluator;
     private final JavaSourceElementFactoryImpl javaSourceElementFactory;
+    private final AdditionalCheckerProvider additionalCheckerProvider;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
     private final ArgumentTypeResolver argumentTypeResolver;
@@ -152,6 +154,7 @@ public class InjectorForLazyResolveWithJava {
         this.globalJavaResolverContext = new GlobalJavaResolverContext(storageManager, javaClassFinder, virtualFileFinder, deserializedDescriptorResolver, psiBasedExternalAnnotationResolver, traceBasedExternalSignatureResolver, traceBasedErrorReporter, psiBasedMethodSignatureChecker, lazyResolveBasedCache, javaPropertyInitializerEvaluator, javaSourceElementFactory, moduleClassResolver);
         this.lazyJavaPackageFragmentProvider = new LazyJavaPackageFragmentProvider(globalJavaResolverContext, module);
         this.javaDescriptorResolver = new JavaDescriptorResolver(lazyJavaPackageFragmentProvider, module);
+        this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$;
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -221,6 +224,7 @@ public class InjectorForLazyResolveWithJava {
         expressionTypingServices.setProject(project);
         expressionTypingServices.setTypeResolver(typeResolver);
 
+        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
         expressionTypingComponents.setCallResolver(callResolver);
         expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);

compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java

@@ -27,6 +27,7 @@ import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava;
+import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl;
 import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver;
@@ -92,6 +93,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final JavaDescriptorResolver javaDescriptorResolver;
     private final DeserializationGlobalContextForJava deserializationGlobalContextForJava;
+    private final AdditionalCheckerProvider additionalCheckerProvider;
     private final GlobalSearchScope globalSearchScope;
     private final JavaClassFinderImpl javaClassFinder;
     private final TraceBasedExternalSignatureResolver traceBasedExternalSignatureResolver;
@@ -173,6 +175,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.annotationDescriptorLoader = new AnnotationDescriptorLoader();
         this.constantDescriptorLoader = new ConstantDescriptorLoader();
         this.deserializationGlobalContextForJava = new DeserializationGlobalContextForJava(storageManager, getModuleDescriptor(), javaClassDataFinder, annotationDescriptorLoader, constantDescriptorLoader, lazyJavaPackageFragmentProvider);
+        this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$;
         this.globalSearchScope = com.intellij.psi.search.GlobalSearchScope.allScope(project);
         this.bodyResolver = new BodyResolver();
         this.annotationResolver = new AnnotationResolver();
@@ -205,6 +208,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         this.scriptHeaderResolver = new ScriptHeaderResolver();
         this.descriptorLoadersStorage = new DescriptorLoadersStorage(storageManager);
 
+        this.topDownAnalyzer.setAdditionalCheckerProvider(additionalCheckerProvider);
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
         this.topDownAnalyzer.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
@@ -270,6 +274,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
         expressionTypingServices.setProject(project);
         expressionTypingServices.setTypeResolver(typeResolver);
 
+        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
         expressionTypingComponents.setCallResolver(callResolver);
         expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
@@ -302,6 +307,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly
 
         controlFlowAnalyzer.setTrace(bindingTrace);
 
+        declarationsChecker.setAdditionalCheckerProvider(additionalCheckerProvider);
         declarationsChecker.setDescriptorResolver(descriptorResolver);
         declarationsChecker.setTrace(bindingTrace);
 

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

@@ -23,6 +23,8 @@ 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>() {
@@ -44,6 +46,9 @@ 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_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

@@ -17,9 +17,14 @@
 package org.jetbrains.jet.lang.resolve.java.diagnostics;
 
 import com.intellij.psi.PsiElement;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+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;
 import static org.jetbrains.jet.lang.diagnostics.Severity.ERROR;
 
@@ -30,6 +35,10 @@ 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);
+    DiagnosticFactory1<JetDeclaration, DeclarationDescriptor> PLATFORM_STATIC_ILLEGAL_USAGE = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE);
+
     @SuppressWarnings("UnusedDeclaration")
     Object _initializer = new Object() {
         {

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

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2010-2014 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.resolve.kotlin
+
+import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider
+import com.google.common.collect.Lists
+import org.jetbrains.jet.lang.resolve.AnnotationChecker
+import org.jetbrains.jet.lang.psi.JetDeclaration
+import org.jetbrains.jet.lang.descriptors.MemberDescriptor
+import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder
+import org.jetbrains.jet.lang.resolve.annotations.hasPlatformStaticAnnotation
+import org.jetbrains.jet.lang.psi.JetNamedFunction
+import org.jetbrains.jet.lang.resolve.DescriptorUtils
+import org.jetbrains.jet.lang.descriptors.ClassKind
+import org.jetbrains.jet.lang.resolve.java.diagnostics.ErrorsJvm
+import org.jetbrains.jet.lexer.JetTokens
+import org.jetbrains.jet.lang.psi.JetProperty
+import org.jetbrains.jet.lang.descriptors.PropertyDescriptor
+
+public object JavaDeclarationCheckerProvider : AdditionalCheckerProvider {
+
+    override val annotationCheckers: List<AnnotationChecker> = listOf(PlatformStaticAnnotationChecker())
+}
+
+public class PlatformStaticAnnotationChecker : AnnotationChecker {
+
+    override fun check(declaration: JetDeclaration, descriptor: MemberDescriptor, diagnosticHolder: DiagnosticHolder) {
+        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 {
+                //TODO: there should be general mechanism
+                diagnosticHolder.report(ErrorsJvm.PLATFORM_STATIC_ILLEGAL_USAGE.on(declaration, descriptor));
+            }
+        }
+
+        if (declaration is JetProperty) {
+            val getter = declaration.getGetter()
+            if (getter != null) {
+                check(getter, (descriptor as PropertyDescriptor).getGetter()!!, diagnosticHolder)
+            }
+            val setter = declaration.getSetter()
+            if (setter != null) {
+                check(setter, (descriptor as PropertyDescriptor).getSetter()!!, diagnosticHolder)
+            }
+        }
+    }
+}

compiler/frontend/src/org/jetbrains/jet/di/InjectorForBodyResolve.java

@@ -22,6 +22,7 @@ import org.jetbrains.jet.storage.StorageManager;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
+import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.BodyResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
@@ -57,6 +58,7 @@ public class InjectorForBodyResolve {
     private final BindingTrace bindingTrace;
     private final ModuleDescriptor moduleDescriptor;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
+    private final AdditionalCheckerProvider additionalCheckerProvider;
     private final BodyResolver bodyResolver;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
@@ -84,7 +86,8 @@ public class InjectorForBodyResolve {
         @NotNull Project project,
         @NotNull GlobalContext globalContext,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptor moduleDescriptor
+        @NotNull ModuleDescriptor moduleDescriptor,
+        @NotNull AdditionalCheckerProvider additionalCheckerProvider
     ) {
         this.project = project;
         this.globalContext = globalContext;
@@ -92,6 +95,7 @@ public class InjectorForBodyResolve {
         this.bindingTrace = bindingTrace;
         this.moduleDescriptor = moduleDescriptor;
         this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
+        this.additionalCheckerProvider = additionalCheckerProvider;
         this.bodyResolver = new BodyResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
@@ -146,6 +150,7 @@ public class InjectorForBodyResolve {
         expressionTypingServices.setProject(project);
         expressionTypingServices.setTypeResolver(typeResolver);
 
+        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
         expressionTypingComponents.setCallResolver(callResolver);
         expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
@@ -178,6 +183,7 @@ public class InjectorForBodyResolve {
 
         controlFlowAnalyzer.setTrace(bindingTrace);
 
+        declarationsChecker.setAdditionalCheckerProvider(additionalCheckerProvider);
         declarationsChecker.setDescriptorResolver(descriptorResolver);
         declarationsChecker.setTrace(bindingTrace);
 

compiler/frontend/src/org/jetbrains/jet/di/InjectorForLazyResolve.java

@@ -23,6 +23,7 @@ import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
@@ -58,6 +59,7 @@ public class InjectorForLazyResolve {
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final DeclarationProviderFactory declarationProviderFactory;
     private final BindingTrace bindingTrace;
+    private final AdditionalCheckerProvider additionalCheckerProvider;
     private final ResolveSession resolveSession;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
@@ -85,7 +87,8 @@ public class InjectorForLazyResolve {
         @NotNull GlobalContext globalContext,
         @NotNull ModuleDescriptorImpl moduleDescriptor,
         @NotNull DeclarationProviderFactory declarationProviderFactory,
-        @NotNull BindingTrace bindingTrace
+        @NotNull BindingTrace bindingTrace,
+        @NotNull AdditionalCheckerProvider additionalCheckerProvider
     ) {
         this.project = project;
         this.globalContext = globalContext;
@@ -94,6 +97,7 @@ public class InjectorForLazyResolve {
         this.platformToKotlinClassMap = moduleDescriptor.getPlatformToKotlinClassMap();
         this.declarationProviderFactory = declarationProviderFactory;
         this.bindingTrace = bindingTrace;
+        this.additionalCheckerProvider = additionalCheckerProvider;
         this.resolveSession = new ResolveSession(project, globalContext, moduleDescriptor, declarationProviderFactory, bindingTrace);
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
@@ -145,6 +149,7 @@ public class InjectorForLazyResolve {
         expressionTypingServices.setProject(project);
         expressionTypingServices.setTypeResolver(typeResolver);
 
+        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
         expressionTypingComponents.setCallResolver(callResolver);
         expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);

compiler/frontend/src/org/jetbrains/jet/di/InjectorForMacros.java

@@ -24,6 +24,7 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingComponents;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.context.GlobalContext;
 import org.jetbrains.jet.storage.StorageManager;
+import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver;
@@ -53,6 +54,7 @@ public class InjectorForMacros {
     private final CallResolver callResolver;
     private final GlobalContext globalContext;
     private final StorageManager storageManager;
+    private final AdditionalCheckerProvider additionalCheckerProvider;
     private final AnnotationResolver annotationResolver;
     private final TypeResolver typeResolver;
     private final QualifiedExpressionResolver qualifiedExpressionResolver;
@@ -80,6 +82,7 @@ public class InjectorForMacros {
         this.callResolver = new CallResolver();
         this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext();
         this.storageManager = globalContext.getStorageManager();
+        this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider.Empty.INSTANCE$;
         this.annotationResolver = new AnnotationResolver();
         this.typeResolver = new TypeResolver();
         this.qualifiedExpressionResolver = new QualifiedExpressionResolver();
@@ -103,6 +106,7 @@ public class InjectorForMacros {
         this.expressionTypingServices.setProject(project);
         this.expressionTypingServices.setTypeResolver(typeResolver);
 
+        this.expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
         this.expressionTypingComponents.setCallResolver(callResolver);
         this.expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
         this.expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);

compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
+import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.BodyResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
@@ -70,6 +71,7 @@ public class InjectorForTopDownAnalyzerBasic {
     private final TopDownAnalyzer topDownAnalyzer;
     private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
+    private final AdditionalCheckerProvider additionalCheckerProvider;
     private final BodyResolver bodyResolver;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
@@ -104,7 +106,8 @@ public class InjectorForTopDownAnalyzerBasic {
         @NotNull Project project,
         @NotNull GlobalContext globalContext,
         @NotNull BindingTrace bindingTrace,
-        @NotNull ModuleDescriptor moduleDescriptor
+        @NotNull ModuleDescriptor moduleDescriptor,
+        @NotNull AdditionalCheckerProvider additionalCheckerProvider
     ) {
         this.project = project;
         this.globalContext = globalContext;
@@ -115,6 +118,7 @@ public class InjectorForTopDownAnalyzerBasic {
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
         this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor());
+        this.additionalCheckerProvider = additionalCheckerProvider;
         this.bodyResolver = new BodyResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
@@ -145,6 +149,7 @@ public class InjectorForTopDownAnalyzerBasic {
         this.typeHierarchyResolver = new TypeHierarchyResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
 
+        this.topDownAnalyzer.setAdditionalCheckerProvider(additionalCheckerProvider);
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
         this.topDownAnalyzer.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
@@ -194,6 +199,7 @@ public class InjectorForTopDownAnalyzerBasic {
         expressionTypingServices.setProject(project);
         expressionTypingServices.setTypeResolver(typeResolver);
 
+        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
         expressionTypingComponents.setCallResolver(callResolver);
         expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
@@ -226,6 +232,7 @@ public class InjectorForTopDownAnalyzerBasic {
 
         controlFlowAnalyzer.setTrace(bindingTrace);
 
+        declarationsChecker.setAdditionalCheckerProvider(additionalCheckerProvider);
         declarationsChecker.setDescriptorResolver(descriptorResolver);
         declarationsChecker.setTrace(bindingTrace);
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/AdditionalCheckerProvider.kt

@@ -0,0 +1,31 @@
+/*
+ * Copyright 2010-2014 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.resolve
+
+import org.jetbrains.annotations.ReadOnly
+
+import java.util.Collections
+
+public trait AdditionalCheckerProvider {
+
+    public val annotationCheckers: List<AnnotationChecker>
+
+    public object Empty : AdditionalCheckerProvider {
+
+        override val annotationCheckers: List<AnnotationChecker> = listOf()
+    }
+}

compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationChecker.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright 2010-2014 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.resolve
+
+import org.jetbrains.jet.lang.psi.JetDeclaration
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
+import org.jetbrains.jet.lang.descriptors.MemberDescriptor
+import org.jetbrains.jet.lang.psi.JetDeclarationModifierList
+import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder
+
+public trait AnnotationChecker {
+
+    public fun check(declaration: JetDeclaration, descriptor: MemberDescriptor, diagnosticHolder: DiagnosticHolder);
+
+}

compiler/frontend/src/org/jetbrains/jet/lang/resolve/AnnotationUtil.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2010-2014 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.resolve.annotations
+
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor
+import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor
+import org.jetbrains.jet.lang.resolve.name.FqName
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor
+import org.jetbrains.jet.lang.resolve.DescriptorUtils
+
+public fun DeclarationDescriptor.hasPlatformStaticAnnotation(): Boolean {
+    return getAnnotations().findAnnotation(FqName("kotlin.platform.platformStatic")) != null
+}
+
+public fun CallableDescriptor.isPlatformStaticInObject(): Boolean =
+        DescriptorUtils.isObject(getContainingDeclaration()) && hasPlatformStaticAnnotation()
+
+public fun CallableDescriptor.isPlatformStaticInClassObject(): Boolean =
+        DescriptorUtils.isClassObject(getContainingDeclaration()) && hasPlatformStaticAnnotation()

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

@@ -44,6 +44,9 @@ public class DeclarationsChecker {
     @NotNull
     private DescriptorResolver descriptorResolver;
 
+    @NotNull
+    private AdditionalCheckerProvider additionalCheckerProvider;
+
     @Inject
     public void setTrace(@NotNull BindingTrace trace) {
         this.trace = trace;
@@ -55,6 +58,11 @@ public class DeclarationsChecker {
         this.descriptorResolver = descriptorResolver;
     }
 
+    @Inject
+    public void setAdditionalCheckerProvider(@NotNull AdditionalCheckerProvider additionalCheckerProvider) {
+        this.additionalCheckerProvider = additionalCheckerProvider;
+    }
+
     public void process(@NotNull BodiesResolveContext bodiesResolveContext) {
         for (JetFile file : bodiesResolveContext.getFiles()) {
             checkModifiersAndAnnotationsInPackageDirective(file);
@@ -80,6 +88,7 @@ public class DeclarationsChecker {
             }
 
             modifiersChecker.checkModifiersForDeclaration(classOrObject, classDescriptor);
+            runAnnotationCheckers(classOrObject, classDescriptor);
         }
 
         Map<JetNamedFunction, SimpleFunctionDescriptor> functions = bodiesResolveContext.getFunctions();
@@ -90,6 +99,7 @@ public class DeclarationsChecker {
             if (!bodiesResolveContext.completeAnalysisNeeded(function)) continue;
             checkFunction(function, functionDescriptor);
             modifiersChecker.checkModifiersForDeclaration(function, functionDescriptor);
+            runAnnotationCheckers(function, functionDescriptor);
         }
 
         Map<JetProperty, PropertyDescriptor> properties = bodiesResolveContext.getProperties();
@@ -100,6 +110,7 @@ public class DeclarationsChecker {
             if (!bodiesResolveContext.completeAnalysisNeeded(property)) continue;
             checkProperty(property, propertyDescriptor);
             modifiersChecker.checkModifiersForDeclaration(property, propertyDescriptor);
+            runAnnotationCheckers(property, propertyDescriptor);
         }
 
     }
@@ -559,4 +570,10 @@ public class DeclarationsChecker {
             }
         }
     }
+
+    private void runAnnotationCheckers(@NotNull JetDeclaration declaration, @NotNull MemberDescriptor descriptor) {
+        for (AnnotationChecker checker : additionalCheckerProvider.getAnnotationCheckers()) {
+            checker.check(declaration, descriptor, trace);
+        }
+    }
 }

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

@@ -62,6 +62,8 @@ public class TopDownAnalyzer {
     @NotNull
     private BodyResolver bodyResolver;
     @NotNull
+    private AdditionalCheckerProvider additionalCheckerProvider;
+    @NotNull
     private Project project;
 
     @NotNull
@@ -117,6 +119,11 @@ public class TopDownAnalyzer {
         this.lazyTopDownAnalyzer = lazyTopDownAnalyzer;
     }
 
+    @Inject
+    public void setAdditionalCheckerProvider(@NotNull AdditionalCheckerProvider additionalCheckerProvider) {
+        this.additionalCheckerProvider = additionalCheckerProvider;
+    }
+
     public void doProcess(
             @NotNull TopDownAnalysisContext c,
             @NotNull JetScope outerScope,
@@ -132,7 +139,8 @@ public class TopDownAnalyzer {
                     new GlobalContextImpl((LockBasedStorageManager) c.getStorageManager(), c.getExceptionTracker()), // TODO
                     (ModuleDescriptorImpl) moduleDescriptor, // TODO
                     new FileBasedDeclarationProviderFactory(c.getStorageManager(), getFiles(declarations)),
-                    trace
+                    trace,
+                    additionalCheckerProvider
             ).getResolveSession();
 
             lazyTopDownAnalyzer.analyzeDeclarations(
@@ -193,7 +201,8 @@ public class TopDownAnalyzer {
             @Nullable final WritableScope scope,
             @NotNull ExpressionTypingContext context,
             @NotNull final DeclarationDescriptor containingDeclaration,
-            @NotNull JetClassOrObject object
+            @NotNull JetClassOrObject object,
+            @NotNull AdditionalCheckerProvider additionalCheckerProvider
     ) {
         TopDownAnalysisParameters topDownAnalysisParameters =
                 TopDownAnalysisParameters.createForLocalDeclarations(
@@ -203,7 +212,11 @@ public class TopDownAnalyzer {
                 );
 
         InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(
-                object.getProject(), topDownAnalysisParameters, context.trace, DescriptorUtils.getContainingModule(containingDeclaration)
+                object.getProject(),
+                topDownAnalysisParameters,
+                context.trace,
+                DescriptorUtils.getContainingModule(containingDeclaration),
+                additionalCheckerProvider
         );
 
         TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters);

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ClosureExpressionsTypingVisitor.java

@@ -89,7 +89,7 @@ public class ClosureExpressionsTypingVisitor extends ExpressionTypingVisitor {
                                              null, // don't need to add classifier of object literal to any scope
                                              context.replaceBindingTrace(traceAdapter).replaceContextDependency(INDEPENDENT),
                                              context.scope.getContainingDeclaration(),
-                                             expression.getObjectDeclaration());
+                                             expression.getObjectDeclaration(), components.additionalCheckerProvider);
 
         DelegatingBindingTrace cloneDelta = new DelegatingBindingTrace(
                 new BindingTraceContext().getBindingContext(), "cached delta trace for object literal expression resolve", expression);

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingComponents.java

@@ -20,6 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.context.GlobalContext;
 import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.reflect.ReflectionTypes;
+import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 
 import javax.inject.Inject;
@@ -33,6 +34,7 @@ public class ExpressionTypingComponents {
     /*package*/ ControlStructureTypingUtils controlStructureTypingUtils;
     /*package*/ ForLoopConventionsChecker forLoopConventionsChecker;
     /*package*/ ReflectionTypes reflectionTypes;
+    /*package*/ AdditionalCheckerProvider additionalCheckerProvider;
 
     @Inject
     public void setGlobalContext(@NotNull GlobalContext globalContext) {
@@ -74,6 +76,11 @@ public class ExpressionTypingComponents {
         this.reflectionTypes = reflectionTypes;
     }
 
+    @Inject
+    public void setAdditionalCheckerProvider(AdditionalCheckerProvider additionalCheckerProvider) {
+        this.additionalCheckerProvider = additionalCheckerProvider;
+    }
+
     @NotNull
     public ForLoopConventionsChecker getForLoopConventionsChecker() {
         return forLoopConventionsChecker;

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/ExpressionTypingVisitorForStatements.java

@@ -89,7 +89,8 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     public JetTypeInfo visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, ExpressionTypingContext context) {
         TopDownAnalyzer.processClassOrObject(
                 components.globalContext,
-                scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), declaration);
+                scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), declaration,
+                components.additionalCheckerProvider);
         return DataFlowUtils.checkStatementType(declaration, context, context.dataFlowInfo);
     }
 
@@ -185,7 +186,8 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     public JetTypeInfo visitClass(@NotNull JetClass klass, ExpressionTypingContext context) {
         TopDownAnalyzer.processClassOrObject(
                 components.globalContext,
-                scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), klass);
+                scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), klass,
+                components.additionalCheckerProvider);
         return DataFlowUtils.checkStatementType(klass, context, context.dataFlowInfo);
     }
 

compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/functions.kt

@@ -0,0 +1,54 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+import kotlin.platform.platformStatic
+
+class A {
+    class object {
+        platformStatic fun a1() {
+
+        }
+    }
+
+    object A {
+        platformStatic fun a2() {
+
+        }
+    }
+
+    fun test() {
+        val s = object {
+            <!PLATFORM_STATIC_NOT_IN_OBJECT!>platformStatic fun a3()<!> {
+
+            }
+        }
+    }
+
+    <!PLATFORM_STATIC_NOT_IN_OBJECT!>platformStatic fun a4()<!> {
+
+    }
+}
+
+trait B {
+    class object {
+        <!PLATFORM_STATIC_NOT_IN_OBJECT!>platformStatic fun a1()<!> {
+
+        }
+    }
+
+    object A {
+        platformStatic fun a2() {
+
+        }
+    }
+
+    fun test() {
+        val s = object {
+            <!PLATFORM_STATIC_NOT_IN_OBJECT!>platformStatic fun a3()<!> {
+
+            }
+        }
+    }
+
+    <!PLATFORM_STATIC_NOT_IN_OBJECT!>platformStatic fun a4()<!> {
+
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/property.kt

@@ -0,0 +1,29 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+import kotlin.platform.platformStatic
+
+class A {
+    class object {
+        var p1:Int = 1
+            <!PLATFORM_STATIC_ILLEGAL_USAGE!>[platformStatic] set(p: Int)<!> {
+                p1 = 1
+            }
+
+        <!PLATFORM_STATIC_ILLEGAL_USAGE!>[platformStatic] val z<!> = 1;
+    }
+
+    object A {
+        var p:Int = 1
+            <!PLATFORM_STATIC_ILLEGAL_USAGE!>[platformStatic] set(p1: Int)<!> {
+                p = 1
+            }
+
+        <!PLATFORM_STATIC_ILLEGAL_USAGE!>[platformStatic] val z<!> = 1;
+    }
+
+    var p:Int = 1
+        <!PLATFORM_STATIC_ILLEGAL_USAGE!>[platformStatic] set(p1: Int)<!> {
+            p = 1
+        }
+
+    <!PLATFORM_STATIC_ILLEGAL_USAGE!>[platformStatic] val z<!> = 1;
+}

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

@@ -41,7 +41,7 @@ public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnostic
     
     @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations")
     @TestDataPath("$PROJECT_ROOT")
-    @InnerTestClasses({Annotations.AnnotationApplicability.class, Annotations.AnnotationParameterMustBeConstant.class})
+    @InnerTestClasses({Annotations.AnnotationApplicability.class, Annotations.AnnotationParameterMustBeConstant.class, Annotations.PlatformStatic.class})
     @RunWith(org.jetbrains.jet.JUnit3RunnerWithInners.class)
     public static class Annotations extends AbstractJetDiagnosticsTestWithStdLib {
         public void testAllFilesPresentInAnnotations() throws Exception {
@@ -110,6 +110,28 @@ public class JetDiagnosticsTestWithStdLibGenerated extends AbstractJetDiagnostic
             
         }
         
+        @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic")
+        @TestDataPath("$PROJECT_ROOT")
+        @RunWith(org.jetbrains.jet.JUnit3RunnerWithInners.class)
+        public static class PlatformStatic extends AbstractJetDiagnosticsTestWithStdLib {
+            public void testAllFilesPresentInPlatformStatic() throws Exception {
+                JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic"), Pattern.compile("^(.+)\\.kt$"), true);
+            }
+            
+            @TestMetadata("functions.kt")
+            public void testFunctions() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/functions.kt");
+                doTest(fileName);
+            }
+            
+            @TestMetadata("property.kt")
+            public void testProperty() throws Exception {
+                String fileName = JetTestUtils.navigationMetadata("compiler/testData/diagnostics/testsWithStdLib/annotations/platformStatic/property.kt");
+                doTest(fileName);
+            }
+            
+        }
+        
     }
     
     @TestMetadata("compiler/testData/diagnostics/testsWithStdLib/callableReference")

compiler/tests/org/jetbrains/jet/di/InjectorForTests.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.jet.lang.resolve.TypeResolver;
 import org.jetbrains.jet.context.GlobalContext;
 import org.jetbrains.jet.storage.StorageManager;
+import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
@@ -54,6 +55,7 @@ public class InjectorForTests {
     private final TypeResolver typeResolver;
     private final GlobalContext globalContext;
     private final StorageManager storageManager;
+    private final AdditionalCheckerProvider additionalCheckerProvider;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
     private final ArgumentTypeResolver argumentTypeResolver;
@@ -83,6 +85,7 @@ public class InjectorForTests {
         this.typeResolver = new TypeResolver();
         this.globalContext = org.jetbrains.jet.context.ContextPackage.GlobalContext();
         this.storageManager = globalContext.getStorageManager();
+        this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider.INSTANCE$;
         this.annotationResolver = new AnnotationResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
         this.candidateResolver = new CandidateResolver();
@@ -131,6 +134,7 @@ public class InjectorForTests {
         delegatedPropertyResolver.setCallResolver(callResolver);
         delegatedPropertyResolver.setExpressionTypingServices(expressionTypingServices);
 
+        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
         expressionTypingComponents.setCallResolver(callResolver);
         expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java

@@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM;
+import org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -70,7 +71,8 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe
         final ResolveSession resolveSession = new InjectorForLazyResolve(
                 getProject(), globalContext, lazyModule,
                 new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), files),
-                new BindingTraceContext()).getResolveSession();
+                new BindingTraceContext(),
+                JavaDeclarationCheckerProvider.INSTANCE$).getResolveSession();
         lazyModule.initialize(resolveSession.getPackageFragmentProvider());
 
         final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();

core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java

@@ -267,6 +267,11 @@ public class DescriptorUtils {
         return isKindOf(descriptor, ClassKind.CLASS);
     }
 
+    public static boolean containerKindIs(@NotNull DeclarationDescriptor descriptor, @NotNull ClassKind kind) {
+        DeclarationDescriptor parentDeclaration = descriptor.getContainingDeclaration();
+        return  parentDeclaration != null && isKindOf(parentDeclaration, kind);
+    }
+
     public static boolean isKindOf(@Nullable DeclarationDescriptor descriptor, @NotNull ClassKind classKind) {
         return descriptor instanceof ClassDescriptor && ((ClassDescriptor) descriptor).getKind() == classKind;
     }

generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.kt

@@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.DeserializationGlobalContextForJava
 import org.jetbrains.jet.lang.resolve.java.lazy.SingleModuleClassResolver
 import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinderFactory
 import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM
+import org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider
 
 // NOTE: After making changes, you need to re-generate the injectors.
 //       To do that, you can run main in this file.
@@ -85,11 +86,15 @@ private fun DependencyInjectorGenerator.commonForTopDownAnalyzer() {
 private fun generatorForTopDownAnalyzerBasic() =
         generator("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic") {
             commonForTopDownAnalyzer()
+            parameter(javaClass<AdditionalCheckerProvider>())
         }
 
 private fun generatorForTopDownAnalyzerForJs() =
         generator("js/js.frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJs") {
             commonForTopDownAnalyzer()
+
+            field(javaClass<AdditionalCheckerProvider>(),
+                  init = GivenExpression(javaClass<AdditionalCheckerProvider.Empty>().getCanonicalName() + ".INSTANCE$"))
         }
 
 private fun generatorForTopDownAnalyzerForJvm() =
@@ -100,6 +105,9 @@ private fun generatorForTopDownAnalyzerForJvm() =
             publicField(javaClass<JavaDescriptorResolver>())
             publicField(javaClass<DeserializationGlobalContextForJava>())
 
+            field(javaClass<AdditionalCheckerProvider>(),
+                  init = GivenExpression(javaClass<JavaDeclarationCheckerProvider>().getName() + ".INSTANCE$"))
+
             field(javaClass <GlobalSearchScope>(),
                   init = GivenExpression(javaClass<GlobalSearchScope>().getName() + ".allScope(project)"))
             fields(
@@ -179,6 +187,8 @@ private fun generatorForLazyResolveWithJava() =
                     javaClass<JavaPropertyInitializerEvaluatorImpl>(),
                     javaClass<JavaSourceElementFactoryImpl>()
             )
+            field(javaClass<AdditionalCheckerProvider>(),
+                  init = GivenExpression(javaClass<JavaDeclarationCheckerProvider>().getName() + ".INSTANCE$"))
         }
 
 private fun generatorForMacro() =
@@ -192,6 +202,9 @@ private fun generatorForMacro() =
 
             field(javaClass<GlobalContext>(), useAsContext = true,
                   init = GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"))
+
+            field(javaClass<AdditionalCheckerProvider>(),
+                  init = GivenExpression(javaClass<AdditionalCheckerProvider.Empty>().getCanonicalName() + ".INSTANCE$"))
         }
 
 private fun generatorForTests() =
@@ -208,6 +221,9 @@ private fun generatorForTests() =
 
             field(javaClass<GlobalContext>(), init = GivenExpression("org.jetbrains.jet.context.ContextPackage.GlobalContext()"),
                   useAsContext = true)
+
+            field(javaClass<AdditionalCheckerProvider>(),
+                  init = GivenExpression(javaClass<JavaDeclarationCheckerProvider>().getName() + ".INSTANCE$"))
         }
 
 private fun generatorForBodyResolve() =
@@ -216,6 +232,7 @@ private fun generatorForBodyResolve() =
             parameter(javaClass<GlobalContext>(), useAsContext = true)
             parameter(javaClass<BindingTrace>())
             parameter(javaClass<ModuleDescriptor>(), useAsContext = true)
+            parameter(javaClass<AdditionalCheckerProvider>())
 
             publicField(javaClass<BodyResolver>())
         }
@@ -227,6 +244,7 @@ private fun generatorForLazyResolve() =
             parameter(javaClass<ModuleDescriptorImpl>(), useAsContext = true)
             parameter(javaClass<DeclarationProviderFactory>())
             parameter(javaClass<BindingTrace>())
+            parameter(javaClass<AdditionalCheckerProvider>())
 
             publicField(javaClass<ResolveSession>())
         }

idea/ide-lazy-resolve/src/org/jetbrains/jet/lang/resolve/lazy/ElementResolver.java

@@ -49,7 +49,7 @@ import java.util.Map;
 
 import static org.jetbrains.jet.lang.resolve.bindingContextUtil.BindingContextUtilPackage.getDataFlowInfo;
 
-public class ElementResolver {
+public abstract class ElementResolver {
 
     protected final ResolveSession resolveSession;
 
@@ -260,7 +260,7 @@ public class ElementResolver {
         parameterDescriptor.forceResolveAllContents();
     }
 
-    private static void delegationSpecifierAdditionalResolve(
+    private void delegationSpecifierAdditionalResolve(
             ResolveSession resolveSession,
             JetDelegationSpecifierList specifier, BindingTrace trace, JetFile file) {
 
@@ -277,7 +277,7 @@ public class ElementResolver {
                                                     descriptor.getScopeForMemberDeclarationResolution());
     }
 
-    private static void propertyAdditionalResolve(final ResolveSession resolveSession, final JetProperty jetProperty, BindingTrace trace, JetFile file) {
+    private void propertyAdditionalResolve(final ResolveSession resolveSession, final JetProperty jetProperty, BindingTrace trace, JetFile file) {
         JetScope propertyResolutionScope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(jetProperty);
 
         BodyResolveContextForLazy bodyResolveContext = new BodyResolveContextForLazy(
@@ -310,7 +310,7 @@ public class ElementResolver {
         }
     }
 
-    private static void functionAdditionalResolve(
+    private void functionAdditionalResolve(
             ResolveSession resolveSession,
             JetNamedFunction namedFunction,
             BindingTrace trace,
@@ -323,7 +323,7 @@ public class ElementResolver {
         bodyResolver.resolveFunctionBody(createEmptyContext(resolveSession), trace, namedFunction, functionDescriptor, scope);
     }
 
-    private static void constructorAdditionalResolve(
+    private void constructorAdditionalResolve(
             ResolveSession resolveSession,
             JetClass klass,
             BindingTrace trace,
@@ -340,7 +340,7 @@ public class ElementResolver {
                                                                             constructorDescriptor, scope);
     }
 
-    private static boolean initializerAdditionalResolve(
+    private boolean initializerAdditionalResolve(
             ResolveSession resolveSession,
             JetClassInitializer classInitializer,
             BindingTrace trace,
@@ -355,12 +355,13 @@ public class ElementResolver {
         return true;
     }
 
-    private static BodyResolver createBodyResolver(ResolveSession resolveSession, BindingTrace trace, JetFile file) {
+    private BodyResolver createBodyResolver(ResolveSession resolveSession, BindingTrace trace, JetFile file) {
         InjectorForBodyResolve bodyResolve = new InjectorForBodyResolve(
                 file.getProject(),
                 createParameters(resolveSession),
                 trace,
-                resolveSession.getModuleDescriptor()
+                resolveSession.getModuleDescriptor(),
+                getAdditionalCheckerProvider(file)
         );
         return bodyResolve.getBodyResolver();
     }
@@ -458,6 +459,9 @@ public class ElementResolver {
         return null;
     }
 
+    @NotNull
+    protected abstract AdditionalCheckerProvider getAdditionalCheckerProvider(@NotNull JetFile jetFile);
+
     private static class BodyResolveContextForLazy implements BodiesResolveContext {
 
         private final Function<? super JetDeclaration, JetScope> declaringScopes;

idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/JsAnalyzerFacade.kt

@@ -33,6 +33,7 @@ import org.jetbrains.jet.di.InjectorForLazyResolve
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.jet.analyzer.ModuleInfo
 import org.jetbrains.jet.analyzer.ModuleContent
+import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider
 
 public class JsResolverForModule(
         override val lazyResolveSession: ResolveSession
@@ -54,7 +55,7 @@ public object JsAnalyzerFacade : AnalyzerFacade<JsResolverForModule, PlatformAna
                 project, globalContext.storageManager, syntheticFiles, moduleContentScope
         )
 
-        val injector = InjectorForLazyResolve(project, globalContext, moduleDescriptor, declarationProviderFactory, BindingTraceContext())
+        val injector = InjectorForLazyResolve(project, globalContext, moduleDescriptor, declarationProviderFactory, BindingTraceContext(), AdditionalCheckerProvider.Empty)
         val resolveSession = injector.getResolveSession()!!
         moduleDescriptor.initialize(resolveSession.getPackageFragmentProvider())
         return JsResolverForModule(resolveSession)

idea/idea-analysis/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java

@@ -46,6 +46,7 @@ import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.BindingTraceContext;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.TopDownAnalyzerFacadeForJVM;
@@ -257,7 +258,8 @@ public class JetSourceNavigationHelper {
                 globalContext,
                 moduleDescriptor,
                 providerFactory,
-                new BindingTraceContext()).getResolveSession();
+                new BindingTraceContext(),
+                AdditionalCheckerProvider.Empty.INSTANCE$).getResolveSession();
 
         moduleDescriptor.initialize(resolveSession.getPackageFragmentProvider());
         return resolveSession;

idea/idea-analysis/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java

@@ -25,7 +25,10 @@ import kotlin.Function1;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.psi.JetElement;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.kotlin.JavaDeclarationCheckerProvider;
 import org.jetbrains.jet.lang.resolve.lazy.ElementResolver;
 import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 import org.jetbrains.jet.storage.LazyResolveStorageManager;
@@ -66,4 +69,14 @@ public class ResolveElementCache extends ElementResolver {
     public BindingContext getElementAdditionalResolve(@NotNull JetElement jetElement) {
         return additionalResolveCache.getValue().invoke(jetElement);
     }
+
+    @NotNull
+    @Override
+    public AdditionalCheckerProvider getAdditionalCheckerProvider(@NotNull JetFile jetFile) {
+        TargetPlatform platform = TargetPlatformDetector.getPlatform(jetFile);
+        if (platform == TargetPlatform.JS) {
+            return AdditionalCheckerProvider.Empty.INSTANCE$;
+        }
+        return JavaDeclarationCheckerProvider.INSTANCE$;
+    }
 }

idea/idea-analysis/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java

@@ -107,7 +107,7 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
                 module.seal();
                 BindingTraceContext trace = new BindingTraceContext();
                 InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(
-                        myProject, topDownAnalysisParameters, trace, module);
+                        myProject, topDownAnalysisParameters, trace, module, AdditionalCheckerProvider.Empty.INSTANCE$);
 
                 TopDownAnalyzer analyzer = injector.getTopDownAnalyzer();
                 analyzer.analyzeFiles(topDownAnalysisParameters, jetBuiltInsFiles);

js/js.frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java

@@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider;
+import org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider;
 import org.jetbrains.jet.lang.resolve.BodyResolver;
 import org.jetbrains.jet.lang.resolve.AnnotationResolver;
 import org.jetbrains.jet.lang.resolve.calls.CallResolver;
@@ -70,6 +71,7 @@ public class InjectorForTopDownAnalyzerForJs {
     private final TopDownAnalyzer topDownAnalyzer;
     private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
+    private final AdditionalCheckerProvider additionalCheckerProvider;
     private final BodyResolver bodyResolver;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
@@ -115,6 +117,7 @@ public class InjectorForTopDownAnalyzerForJs {
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
         this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor());
+        this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider.Empty.INSTANCE$;
         this.bodyResolver = new BodyResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
@@ -145,6 +148,7 @@ public class InjectorForTopDownAnalyzerForJs {
         this.typeHierarchyResolver = new TypeHierarchyResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
 
+        this.topDownAnalyzer.setAdditionalCheckerProvider(additionalCheckerProvider);
         this.topDownAnalyzer.setBodyResolver(bodyResolver);
         this.topDownAnalyzer.setDeclarationResolver(declarationResolver);
         this.topDownAnalyzer.setLazyTopDownAnalyzer(lazyTopDownAnalyzer);
@@ -194,6 +198,7 @@ public class InjectorForTopDownAnalyzerForJs {
         expressionTypingServices.setProject(project);
         expressionTypingServices.setTypeResolver(typeResolver);
 
+        expressionTypingComponents.setAdditionalCheckerProvider(additionalCheckerProvider);
         expressionTypingComponents.setCallResolver(callResolver);
         expressionTypingComponents.setControlStructureTypingUtils(controlStructureTypingUtils);
         expressionTypingComponents.setExpressionTypingServices(expressionTypingServices);
@@ -226,6 +231,7 @@ public class InjectorForTopDownAnalyzerForJs {
 
         controlFlowAnalyzer.setTrace(bindingTrace);
 
+        declarationsChecker.setAdditionalCheckerProvider(additionalCheckerProvider);
         declarationsChecker.setDescriptorResolver(descriptorResolver);
         declarationsChecker.setTrace(bindingTrace);