Refactoring: hide fact of using injector inside lazy resolve session

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * 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.
@@ -93,7 +93,7 @@ public class LazyImportScope implements JetScope {
                     directiveUnderResolve = directive;
 
                     try {
-                        resolveSession.getInjector().getQualifiedExpressionResolver().processImportReference(
+                        resolveSession.getQualifiedExpressionResolver().processImportReference(
                                 directive,
                                 rootScope,
                                 packageDescriptor.getMemberScope(),

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java

@@ -30,8 +30,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.di.InjectorForLazyResolve;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.*;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
 import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider;
@@ -70,7 +69,6 @@ public class ResolveSession implements KotlinCodeAnalyzer {
 
     private final Predicate<FqNameUnsafe> specialClasses;
 
-
     private final InjectorForLazyResolve injector;
 
     private final Function<FqName, Name> classifierAliases;
@@ -122,6 +120,8 @@ public class ResolveSession implements KotlinCodeAnalyzer {
                 return packageDescriptor.getDeclarationProvider().getAllDeclaredPackages();
             }
         };
+
+        // TODO: parameter modification
         rootDescriptor.addFragmentProvider(DependencyKind.SOURCES, packageFragmentProvider);
     }
 
@@ -147,11 +147,6 @@ public class ResolveSession implements KotlinCodeAnalyzer {
         return new LazyPackageDescriptor(module, fqName, this, provider);
     }
 
-    @NotNull
-    public InjectorForLazyResolve getInjector() {
-        return injector;
-    }
-
     public boolean isClassSpecial(@NotNull FqNameUnsafe fqName) {
         return specialClasses.apply(fqName);
     }
@@ -177,7 +172,7 @@ public class ResolveSession implements KotlinCodeAnalyzer {
         if (classOrObject.getParent() instanceof JetClassObject) {
             return getClassObjectDescriptor((JetClassObject) classOrObject.getParent());
         }
-        JetScope resolutionScope = getInjector().getScopeProvider().getResolutionScopeForDeclaration(classOrObject);
+        JetScope resolutionScope = getScopeProvider().getResolutionScopeForDeclaration(classOrObject);
         Name name = safeNameForLazyResolve(classOrObject.getNameAsName());
 
         // Why not use the result here. Because it may be that there is a redeclaration:
@@ -310,7 +305,7 @@ public class ResolveSession implements KotlinCodeAnalyzer {
 
             @Override
             public DeclarationDescriptor visitNamedFunction(@NotNull JetNamedFunction function, Void data) {
-                JetScope scopeForDeclaration = getInjector().getScopeProvider().getResolutionScopeForDeclaration(function);
+                JetScope scopeForDeclaration = getScopeProvider().getResolutionScopeForDeclaration(function);
                 scopeForDeclaration.getFunctions(safeNameForLazyResolve(function));
                 return getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, function);
             }
@@ -338,7 +333,7 @@ public class ResolveSession implements KotlinCodeAnalyzer {
 
             @Override
             public DeclarationDescriptor visitProperty(@NotNull JetProperty property, Void data) {
-                JetScope scopeForDeclaration = getInjector().getScopeProvider().getResolutionScopeForDeclaration(property);
+                JetScope scopeForDeclaration = getScopeProvider().getResolutionScopeForDeclaration(property);
                 scopeForDeclaration.getProperties(safeNameForLazyResolve(property));
                 return getBindingContext().get(BindingContext.DECLARATION_TO_DESCRIPTOR, property);
             }
@@ -393,4 +388,34 @@ public class ResolveSession implements KotlinCodeAnalyzer {
             ForceResolveUtil.forceResolveAllContents(lazyPackage);
         }
     }
+
+    @NotNull
+    public ScopeProvider getScopeProvider() {
+        return injector.getScopeProvider();
+    }
+
+    @NotNull
+    public JetImportsFactory getJetImportsFactory() {
+        return injector.getJetImportsFactory();
+    }
+
+    @NotNull
+    public AnnotationResolver getAnnotationResolver() {
+        return injector.getAnnotationResolver();
+    }
+
+    @NotNull
+    public DescriptorResolver getDescriptorResolver() {
+        return injector.getDescriptorResolver();
+    }
+
+    @NotNull
+    public TypeResolver getTypeResolver() {
+        return injector.getTypeResolver();
+    }
+
+    @NotNull
+    public QualifiedExpressionResolver getQualifiedExpressionResolver() {
+        return injector.getQualifiedExpressionResolver();
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * 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.
@@ -92,7 +92,7 @@ public class ScopeProvider {
             throw new IllegalStateException("Root package not found");
         }
 
-        JetImportsFactory importsFactory = resolveSession.getInjector().getJetImportsFactory();
+        JetImportsFactory importsFactory = resolveSession.getJetImportsFactory();
         List<ImportPath> defaultImports = resolveSession.getModuleDescriptor().getDefaultImports();
 
         Collection<JetImportDirective> defaultImportDirectives = importsFactory.createImportDirectives(defaultImports);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/AbstractLazyMemberScope.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * 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.
@@ -126,7 +126,7 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
         Collection<JetNamedFunction> declarations = declarationProvider.getFunctionDeclarations(name);
         for (JetNamedFunction functionDeclaration : declarations) {
             JetScope resolutionScope = getScopeForMemberDeclarationResolution(functionDeclaration);
-            result.add(resolveSession.getInjector().getDescriptorResolver().resolveFunctionDescriptorWithAnnotationArguments(
+            result.add(resolveSession.getDescriptorResolver().resolveFunctionDescriptorWithAnnotationArguments(
                   thisDescriptor, resolutionScope,
                   functionDeclaration,
                   resolveSession.getTrace(),
@@ -160,7 +160,7 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
         for (JetProperty propertyDeclaration : declarations) {
             JetScope resolutionScope = getScopeForMemberDeclarationResolution(propertyDeclaration);
             PropertyDescriptor propertyDescriptor =
-                    resolveSession.getInjector().getDescriptorResolver().resolvePropertyDescriptor(
+                    resolveSession.getDescriptorResolver().resolvePropertyDescriptor(
                            thisDescriptor, resolutionScope,
                            propertyDeclaration,
                            resolveSession.getTrace(),
@@ -168,7 +168,7 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
                            // thus doesn't have a surrounding data flow
                            DataFlowInfo.EMPTY);
             result.add(propertyDescriptor);
-            resolveSession.getInjector().getAnnotationResolver().resolveAnnotationsArguments(propertyDescriptor, resolveSession.getTrace(), resolutionScope);
+            resolveSession.getAnnotationResolver().resolveAnnotationsArguments(propertyDescriptor, resolveSession.getTrace(), resolutionScope);
         }
 
         getNonDeclaredProperties(name, result);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassDescriptor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * 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.
@@ -302,7 +302,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyEnti
         JetClassLikeInfo classInfo = declarationProvider.getOwnerInfo();
         JetModifierList modifierList = classInfo.getModifierList();
         if (modifierList != null) {
-            AnnotationResolver annotationResolver = resolveSession.getInjector().getAnnotationResolver();
+            AnnotationResolver annotationResolver = resolveSession.getAnnotationResolver();
             JetScope scopeForDeclaration = getScopeProvider().getResolutionScopeForDeclaration(classInfo.getScopeAnchor());
             return annotationResolver.resolveAnnotationsWithArguments(scopeForDeclaration, modifierList, resolveSession.getTrace());
         }
@@ -361,7 +361,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyEnti
                             return Collections.singleton(KotlinBuiltIns.getInstance().getAnyType());
                         }
 
-                        List<JetType> allSupertypes = resolveSession.getInjector().getDescriptorResolver()
+                        List<JetType> allSupertypes = resolveSession.getDescriptorResolver()
                                 .resolveSupertypes(getScopeForClassHeaderResolution(), LazyClassDescriptor.this, classOrObject,
                                                    resolveSession.getTrace());
 
@@ -468,6 +468,6 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyEnti
 
     @NotNull
     private ScopeProvider getScopeProvider() {
-        return resolveSession.getInjector().getScopeProvider();
+        return resolveSession.getScopeProvider();
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * 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.
@@ -235,7 +235,7 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
                 JetParameter parameter = primaryConstructorParameters.get(valueParameterDescriptor.getIndex());
                 if (parameter.getValOrVarNode() != null && name.equals(parameter.getNameAsName())) {
                     PropertyDescriptor propertyDescriptor =
-                            resolveSession.getInjector().getDescriptorResolver().resolvePrimaryConstructorParameterToAProperty(
+                            resolveSession.getDescriptorResolver().resolvePrimaryConstructorParameterToAProperty(
                                     thisDescriptor,
                                     valueParameterDescriptor,
                                     thisDescriptor.getScopeForClassHeaderResolution(),
@@ -271,7 +271,7 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
             @Nullable
             @Override
             public JetType resolve(@NotNull JetTypeReference reference) {
-                return resolveSession.getInjector().getTypeResolver().resolveType(
+                return resolveSession.getTypeResolver().resolveType(
                         thisDescriptor.getScopeForClassHeaderResolution(),
                         reference,
                         resolveSession.getTrace(),
@@ -359,7 +359,7 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
             JetClassOrObject classOrObject = declarationProvider.getOwnerInfo().getCorrespondingClassOrObject();
             if (!thisDescriptor.getKind().isSingleton()) {
                 JetClass jetClass = (JetClass) classOrObject;
-                ConstructorDescriptorImpl constructor = resolveSession.getInjector().getDescriptorResolver()
+                ConstructorDescriptorImpl constructor = resolveSession.getDescriptorResolver()
                         .resolvePrimaryConstructorDescriptor(thisDescriptor.getScopeForClassHeaderResolution(),
                                                              thisDescriptor,
                                                              jetClass,

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * 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.
@@ -54,7 +54,7 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope<PackageFragm
     @NotNull
     @Override
     protected JetScope getScopeForMemberDeclarationResolution(JetDeclaration declaration) {
-        return resolveSession.getInjector().getScopeProvider().getFileScope((JetFile) declaration.getContainingFile());
+        return resolveSession.getScopeProvider().getFileScope((JetFile) declaration.getContainingFile());
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyTypeParameterDescriptor.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * 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.
@@ -101,7 +101,7 @@ public class LazyTypeParameterDescriptor extends AbstractLazyTypeParameterDescri
     }
 
     private JetType resolveBoundType(@NotNull JetTypeReference boundTypeReference) {
-        return resolveSession.getInjector().getTypeResolver()
+        return resolveSession.getTypeResolver()
                     .resolveType(getContainingDeclaration().getScopeForClassHeaderResolution(), boundTypeReference,
                                  resolveSession.getTrace(), false);
     }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2010-2013 JetBrains s.r.o.
+ * 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.
@@ -142,7 +142,7 @@ public class ResolveElementCache {
         }
         else if (resolveElement instanceof JetImportDirective) {
             JetImportDirective importDirective = (JetImportDirective) resolveElement;
-            JetScope scope = resolveSession.getInjector().getScopeProvider().getFileScope((JetFile) importDirective.getContainingFile());
+            JetScope scope = resolveSession.getScopeProvider().getFileScope((JetFile) importDirective.getContainingFile());
 
             // Get all descriptors to force resolving all imports
             scope.getAllDescriptors();
@@ -242,8 +242,7 @@ public class ResolveElementCache {
     }
 
     private static void propertyAdditionalResolve(ResolveSession resolveSession, final JetProperty jetProperty, BindingTrace trace, JetFile file) {
-        final JetScope propertyResolutionScope = resolveSession.getInjector().getScopeProvider().getResolutionScopeForDeclaration(
+        final JetScope propertyResolutionScope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(jetProperty);
-                jetProperty);
 
         BodyResolveContextForLazy bodyResolveContext = new BodyResolveContextForLazy(
                 resolveSession.getStorageManager(),
@@ -279,7 +278,7 @@ public class ResolveElementCache {
     ) {
         BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(),
                                                                        trace, file, resolveSession.getModuleDescriptor());
-        JetScope scope = resolveSession.getInjector().getScopeProvider().getResolutionScopeForDeclaration(namedFunction);
+        JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(namedFunction);
         FunctionDescriptor functionDescriptor = (FunctionDescriptor) resolveSession.resolveToDescriptor(namedFunction);
         bodyResolver.resolveFunctionBody(trace, namedFunction, functionDescriptor, scope);
     }
@@ -292,7 +291,7 @@ public class ResolveElementCache {
     ) {
         BodyResolver bodyResolver = createBodyResolverWithEmptyContext(resolveSession.getStorageManager(),
                                                                        trace, file, resolveSession.getModuleDescriptor());
-        JetScope scope = resolveSession.getInjector().getScopeProvider().getResolutionScopeForDeclaration(klass);
+        JetScope scope = resolveSession.getScopeProvider().getResolutionScopeForDeclaration(klass);
 
         ClassDescriptor classDescriptor = (ClassDescriptor) resolveSession.resolveToDescriptor(klass);
         ConstructorDescriptor constructorDescriptor = classDescriptor.getUnsubstitutedPrimaryConstructor();
@@ -336,7 +335,7 @@ public class ResolveElementCache {
     }
 
     private static JetScope getExpressionResolutionScope(@NotNull ResolveSession resolveSession, @NotNull JetExpression expression) {
-        ScopeProvider provider = resolveSession.getInjector().getScopeProvider();
+        ScopeProvider provider = resolveSession.getScopeProvider();
         JetDeclaration parentDeclaration = PsiTreeUtil.getParentOfType(expression, JetDeclaration.class);
         if (parentDeclaration == null) {
             return provider.getFileScope((JetFile) expression.getContainingFile());
@@ -349,7 +348,7 @@ public class ResolveElementCache {
                 resolveSession.getBindingContext(), "trace to resolve a member scope of expression", expression));
 
         if (BindingContextUtils.isExpressionWithValidReference(expression, resolveSession.getBindingContext())) {
-            QualifiedExpressionResolver qualifiedExpressionResolver = resolveSession.getInjector().getQualifiedExpressionResolver();
+            QualifiedExpressionResolver qualifiedExpressionResolver = resolveSession.getQualifiedExpressionResolver();
 
             // In some type declaration
             if (expression.getParent() instanceof JetUserType) {