Added platform static checker with provider implementation

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);