LTDA: Make resolve session field non-public in JS injector

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

@@ -134,12 +134,11 @@ private fun generatorForTopDownAnalyzerForJs() =
             parameter(javaClass<DeclarationProviderFactory>())
 
             publicFields(
-                    javaClass<ResolveSession>(),
                     javaClass<LazyTopDownAnalyzer>()
             )
 
+            field(javaClass<ResolveSession>())
             field(javaClass<MutablePackageFragmentProvider>())
-
             field(javaClass<AdditionalCheckerProvider>(),
                   init = GivenExpression(javaClass<AdditionalCheckerProvider.Empty>().getCanonicalName() + ".INSTANCE$"))
         }

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

@@ -23,10 +23,11 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
 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.lazy.ResolveSession;
 import org.jetbrains.jet.lang.resolve.LazyTopDownAnalyzer;
+import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
 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;
 import org.jetbrains.jet.lang.resolve.calls.ArgumentTypeResolver;
@@ -48,21 +49,20 @@ import org.jetbrains.jet.lang.resolve.PartialBodyResolveProvider;
 import org.jetbrains.jet.lang.resolve.calls.CallCompleter;
 import org.jetbrains.jet.lang.resolve.calls.CandidateResolver;
 import org.jetbrains.jet.lang.resolve.calls.tasks.TaskPrioritizer;
-import org.jetbrains.jet.lang.psi.JetImportsFactory;
-import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider;
-import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
-import org.jetbrains.jet.lang.resolve.BodyResolver;
 import org.jetbrains.jet.lang.resolve.ControlFlowAnalyzer;
 import org.jetbrains.jet.lang.resolve.DeclarationsChecker;
 import org.jetbrains.jet.lang.resolve.ModifiersChecker;
 import org.jetbrains.jet.lang.resolve.FunctionAnalyzerExtension;
+import org.jetbrains.jet.lang.resolve.ScriptBodyResolver;
 import org.jetbrains.jet.lang.resolve.DeclarationResolver;
 import org.jetbrains.jet.lang.resolve.ImportsResolver;
+import org.jetbrains.jet.lang.psi.JetImportsFactory;
 import org.jetbrains.jet.lang.resolve.OverloadResolver;
 import org.jetbrains.jet.lang.resolve.OverrideResolver;
 import org.jetbrains.jet.lang.resolve.TopDownAnalyzer;
 import org.jetbrains.jet.lang.resolve.TypeHierarchyResolver;
 import org.jetbrains.jet.lang.resolve.ScriptHeaderResolver;
+import org.jetbrains.jet.lang.resolve.lazy.ScopeProvider;
 import org.jetbrains.annotations.NotNull;
 import javax.annotation.PreDestroy;
 
@@ -77,10 +77,11 @@ public class InjectorForTopDownAnalyzerForJs {
     private final ModuleDescriptorImpl module;
     private final PlatformToKotlinClassMap platformToKotlinClassMap;
     private final DeclarationProviderFactory declarationProviderFactory;
-    private final ResolveSession resolveSession;
     private final LazyTopDownAnalyzer lazyTopDownAnalyzer;
+    private final ResolveSession resolveSession;
     private final MutablePackageFragmentProvider mutablePackageFragmentProvider;
     private final AdditionalCheckerProvider additionalCheckerProvider;
+    private final BodyResolver bodyResolver;
     private final AnnotationResolver annotationResolver;
     private final CallResolver callResolver;
     private final ArgumentTypeResolver argumentTypeResolver;
@@ -102,21 +103,20 @@ public class InjectorForTopDownAnalyzerForJs {
     private final CallCompleter callCompleter;
     private final CandidateResolver candidateResolver;
     private final TaskPrioritizer taskPrioritizer;
-    private final JetImportsFactory jetImportsFactory;
-    private final ScopeProvider scopeProvider;
-    private final ScriptBodyResolver scriptBodyResolver;
-    private final BodyResolver bodyResolver;
     private final ControlFlowAnalyzer controlFlowAnalyzer;
     private final DeclarationsChecker declarationsChecker;
     private final ModifiersChecker modifiersChecker;
     private final FunctionAnalyzerExtension functionAnalyzerExtension;
+    private final ScriptBodyResolver scriptBodyResolver;
     private final DeclarationResolver declarationResolver;
     private final ImportsResolver importsResolver;
+    private final JetImportsFactory jetImportsFactory;
     private final OverloadResolver overloadResolver;
     private final OverrideResolver overrideResolver;
     private final TopDownAnalyzer topDownAnalyzer;
     private final TypeHierarchyResolver typeHierarchyResolver;
     private final ScriptHeaderResolver scriptHeaderResolver;
+    private final ScopeProvider scopeProvider;
 
     public InjectorForTopDownAnalyzerForJs(
         @NotNull Project project,
@@ -132,10 +132,11 @@ public class InjectorForTopDownAnalyzerForJs {
         this.module = module;
         this.platformToKotlinClassMap = module.getPlatformToKotlinClassMap();
         this.declarationProviderFactory = declarationProviderFactory;
-        this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace);
         this.lazyTopDownAnalyzer = new LazyTopDownAnalyzer();
+        this.resolveSession = new ResolveSession(project, globalContext, module, declarationProviderFactory, bindingTrace);
         this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(module);
         this.additionalCheckerProvider = org.jetbrains.jet.lang.resolve.AdditionalCheckerProvider.Empty.INSTANCE$;
+        this.bodyResolver = new BodyResolver();
         this.annotationResolver = new AnnotationResolver();
         this.callResolver = new CallResolver();
         this.argumentTypeResolver = new ArgumentTypeResolver();
@@ -157,29 +158,20 @@ public class InjectorForTopDownAnalyzerForJs {
         this.candidateResolver = new CandidateResolver();
         this.callCompleter = new CallCompleter(argumentTypeResolver, candidateResolver);
         this.taskPrioritizer = new TaskPrioritizer(storageManager);
-        this.jetImportsFactory = new JetImportsFactory();
-        this.scopeProvider = new ScopeProvider(getResolveSession());
-        this.scriptBodyResolver = new ScriptBodyResolver();
-        this.bodyResolver = new BodyResolver();
         this.controlFlowAnalyzer = new ControlFlowAnalyzer();
         this.declarationsChecker = new DeclarationsChecker();
         this.modifiersChecker = new ModifiersChecker(bindingTrace, additionalCheckerProvider);
         this.functionAnalyzerExtension = new FunctionAnalyzerExtension();
+        this.scriptBodyResolver = new ScriptBodyResolver();
         this.declarationResolver = new DeclarationResolver();
         this.importsResolver = new ImportsResolver();
+        this.jetImportsFactory = new JetImportsFactory();
         this.overloadResolver = new OverloadResolver();
         this.overrideResolver = new OverrideResolver();
         this.topDownAnalyzer = new TopDownAnalyzer();
         this.typeHierarchyResolver = new TypeHierarchyResolver();
         this.scriptHeaderResolver = new ScriptHeaderResolver();
-
+        this.scopeProvider = new ScopeProvider(resolveSession);
-        this.resolveSession.setAnnotationResolve(annotationResolver);
-        this.resolveSession.setDescriptorResolver(descriptorResolver);
-        this.resolveSession.setJetImportFactory(jetImportsFactory);
-        this.resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
-        this.resolveSession.setScopeProvider(scopeProvider);
-        this.resolveSession.setScriptBodyResolver(scriptBodyResolver);
-        this.resolveSession.setTypeResolver(typeResolver);
 
         this.lazyTopDownAnalyzer.setBodyResolver(bodyResolver);
         this.lazyTopDownAnalyzer.setDeclarationResolver(declarationResolver);
@@ -190,6 +182,24 @@ public class InjectorForTopDownAnalyzerForJs {
         this.lazyTopDownAnalyzer.setTopDownAnalyzer(topDownAnalyzer);
         this.lazyTopDownAnalyzer.setTrace(bindingTrace);
 
+        resolveSession.setAnnotationResolve(annotationResolver);
+        resolveSession.setDescriptorResolver(descriptorResolver);
+        resolveSession.setJetImportFactory(jetImportsFactory);
+        resolveSession.setQualifiedExpressionResolver(qualifiedExpressionResolver);
+        resolveSession.setScopeProvider(scopeProvider);
+        resolveSession.setScriptBodyResolver(scriptBodyResolver);
+        resolveSession.setTypeResolver(typeResolver);
+
+        bodyResolver.setAnnotationResolver(annotationResolver);
+        bodyResolver.setCallResolver(callResolver);
+        bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
+        bodyResolver.setDeclarationsChecker(declarationsChecker);
+        bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
+        bodyResolver.setExpressionTypingServices(expressionTypingServices);
+        bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
+        bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
+        bodyResolver.setTrace(bindingTrace);
+
         annotationResolver.setCallResolver(callResolver);
         annotationResolver.setStorageManager(storageManager);
         annotationResolver.setTypeResolver(typeResolver);
@@ -240,20 +250,6 @@ public class InjectorForTopDownAnalyzerForJs {
 
         candidateResolver.setArgumentTypeResolver(argumentTypeResolver);
 
-        jetImportsFactory.setProject(project);
-
-        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
-
-        bodyResolver.setAnnotationResolver(annotationResolver);
-        bodyResolver.setCallResolver(callResolver);
-        bodyResolver.setControlFlowAnalyzer(controlFlowAnalyzer);
-        bodyResolver.setDeclarationsChecker(declarationsChecker);
-        bodyResolver.setDelegatedPropertyResolver(delegatedPropertyResolver);
-        bodyResolver.setExpressionTypingServices(expressionTypingServices);
-        bodyResolver.setFunctionAnalyzerExtension(functionAnalyzerExtension);
-        bodyResolver.setScriptBodyResolverResolver(scriptBodyResolver);
-        bodyResolver.setTrace(bindingTrace);
-
         controlFlowAnalyzer.setTrace(bindingTrace);
 
         declarationsChecker.setDescriptorResolver(descriptorResolver);
@@ -262,6 +258,8 @@ public class InjectorForTopDownAnalyzerForJs {
 
         functionAnalyzerExtension.setTrace(bindingTrace);
 
+        scriptBodyResolver.setExpressionTypingServices(expressionTypingServices);
+
         declarationResolver.setAnnotationResolver(annotationResolver);
         declarationResolver.setDescriptorResolver(descriptorResolver);
         declarationResolver.setImportsResolver(importsResolver);
@@ -272,6 +270,8 @@ public class InjectorForTopDownAnalyzerForJs {
         importsResolver.setQualifiedExpressionResolver(qualifiedExpressionResolver);
         importsResolver.setTrace(bindingTrace);
 
+        jetImportsFactory.setProject(project);
+
         overloadResolver.setTrace(bindingTrace);
 
         overrideResolver.setTrace(bindingTrace);
@@ -299,10 +299,6 @@ public class InjectorForTopDownAnalyzerForJs {
     public void destroy() {
     }
 
-    public ResolveSession getResolveSession() {
-        return this.resolveSession;
-    }
-
     public LazyTopDownAnalyzer getLazyTopDownAnalyzer() {
         return this.lazyTopDownAnalyzer;
     }