LocalClassifierAnalyzer dependencies

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/BasicExpressionTypingVisitor.java

@@ -642,13 +642,10 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         };
         ObservableBindingTrace traceAdapter = new ObservableBindingTrace(temporaryTrace);
         traceAdapter.addHandler(CLASS, handler);
-        components.localClassifierAnalyzer.processClassOrObject(components.globalContext,
-                                                                null, // don't need to add classifier of object literal to any scope
+        components.localClassifierAnalyzer.processClassOrObject(null, // don't need to add classifier of object literal to any scope
                                                                 context.replaceBindingTrace(traceAdapter).replaceContextDependency(INDEPENDENT),
                                                                 context.scope.getContainingDeclaration(),
-                                                                expression.getObjectDeclaration(),
-                                                                components.additionalCheckerProvider,
-                                                                components.dynamicTypesSettings);
+                                                                expression.getObjectDeclaration());
         temporaryTrace.commit();
         DataFlowInfo resultFlowInfo = context.dataFlowInfo;
         for (JetDelegationSpecifier specifier: expression.getObjectDeclaration().getDelegationSpecifiers()) {

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ExpressionTypingVisitorForStatements.java

@@ -96,10 +96,9 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     @Override
     public JetTypeInfo visitObjectDeclaration(@NotNull JetObjectDeclaration declaration, ExpressionTypingContext context) {
         components.localClassifierAnalyzer.processClassOrObject(
-                components.globalContext,
-                scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), declaration,
-                components.additionalCheckerProvider,
-                components.dynamicTypesSettings);
+                scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT),
+                scope.getContainingDeclaration(),
+                declaration);
         return TypeInfoFactoryPackage.createTypeInfo(DataFlowUtils.checkStatementType(declaration, context), context);
     }
 
@@ -195,10 +194,9 @@ public class ExpressionTypingVisitorForStatements extends ExpressionTypingVisito
     @Override
     public JetTypeInfo visitClass(@NotNull JetClass klass, ExpressionTypingContext context) {
         components.localClassifierAnalyzer.processClassOrObject(
-                components.globalContext,
-                scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT), scope.getContainingDeclaration(), klass,
-                components.additionalCheckerProvider,
-                components.dynamicTypesSettings);
+                scope, context.replaceScope(scope).replaceContextDependency(INDEPENDENT),
+                scope.getContainingDeclaration(),
+                klass);
         return TypeInfoFactoryPackage.createTypeInfo(DataFlowUtils.checkStatementType(klass, context), context);
     }
 

compiler/frontend/src/org/jetbrains/kotlin/types/expressions/LocalClassifierAnalyzer.kt

@@ -45,19 +45,20 @@ import org.jetbrains.kotlin.storage.StorageManager
 import org.jetbrains.kotlin.types.DynamicTypesSettings
 
 public class LocalClassifierAnalyzer(
+        val globalContext: GlobalContext,
+        val storageManager: StorageManager,
         val descriptorResolver: DescriptorResolver,
         val funcionDescriptorResolver: FunctionDescriptorResolver,
         val typeResolver: TypeResolver,
-        val annotationResolver: AnnotationResolver
+        val annotationResolver: AnnotationResolver,
+        val additionalCheckerProvider: AdditionalCheckerProvider,
+        val dynamicTypesSettings: DynamicTypesSettings
 ) {
     fun processClassOrObject(
-            globalContext: GlobalContext,
             scope: WritableScope?,
             context: ExpressionTypingContext,
             containingDeclaration: DeclarationDescriptor,
-            classOrObject: JetClassOrObject,
-            additionalCheckerProvider: AdditionalCheckerProvider,
-            dynamicTypesSettings: DynamicTypesSettings
+            classOrObject: JetClassOrObject
     ) {
         val module = DescriptorUtils.getContainingModule(containingDeclaration)
         val moduleContext = globalContext.withProject(classOrObject.getProject()).withModule(module)
@@ -70,7 +71,7 @@ public class LocalClassifierAnalyzer(
                         scope,
                         classOrObject,
                         containingDeclaration,
-                        globalContext.storageManager,
+                        storageManager,
                         context,
                         module,
                         descriptorResolver,