Workaround to allow QualifiedExpressionResolver to be created without an Injector. Should be fixed by code owner.

compiler/frontend/src/org/jetbrains/kotlin/resolve/QualifiedExpressionResolver.java

@@ -33,6 +33,7 @@ import org.jetbrains.kotlin.resolve.calls.CallResolver;
 import org.jetbrains.kotlin.resolve.scopes.AbstractScopeAdapter;
 import org.jetbrains.kotlin.resolve.scopes.JetScope;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
+import org.jetbrains.kotlin.resolve.validation.CompositeSymbolUsageValidator;
 import org.jetbrains.kotlin.resolve.validation.SymbolUsageValidator;
 
 import javax.inject.Inject;
@@ -43,7 +44,14 @@ import java.util.Set;
 import static org.jetbrains.kotlin.diagnostics.Errors.*;
 
 public class QualifiedExpressionResolver {
-    private SymbolUsageValidator symbolUsageValidator;
+    private SymbolUsageValidator symbolUsageValidator = new CompositeSymbolUsageValidator();
+
+    /**
+     * @deprecated Instance of this class should be obtained from the Injector
+     */
+    @Deprecated
+    public QualifiedExpressionResolver() {
+    }
 
     @Inject
     public void setSymbolUsageValidator(SymbolUsageValidator symbolUsageValidator) {

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

@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingUtils;
 import org.jetbrains.kotlin.resolve.TypeResolver;
+import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
 import org.jetbrains.kotlin.context.GlobalContext;
 import org.jetbrains.kotlin.storage.StorageManager;
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider;
@@ -44,7 +45,6 @@ import org.jetbrains.kotlin.types.expressions.LocalClassifierAnalyzer;
 import org.jetbrains.kotlin.builtins.ReflectionTypes;
 import org.jetbrains.kotlin.resolve.calls.CallExpressionResolver;
 import org.jetbrains.kotlin.resolve.StatementFilter;
-import org.jetbrains.kotlin.resolve.QualifiedExpressionResolver;
 import org.jetbrains.kotlin.resolve.TypeResolver.FlexibleTypeCapabilitiesProvider;
 import org.jetbrains.kotlin.context.TypeLazinessToken;
 import org.jetbrains.annotations.NotNull;
@@ -63,6 +63,7 @@ public class InjectorForTests {
     private final ExpressionTypingServices expressionTypingServices;
     private final ExpressionTypingUtils expressionTypingUtils;
     private final TypeResolver typeResolver;
+    private final QualifiedExpressionResolver qualifiedExpressionResolver;
     private final GlobalContext globalContext;
     private final StorageManager storageManager;
     private final KotlinJvmCheckerProvider kotlinJvmCheckerProvider;
@@ -82,7 +83,6 @@ public class InjectorForTests {
     private final ReflectionTypes reflectionTypes;
     private final CallExpressionResolver callExpressionResolver;
     private final StatementFilter statementFilter;
-    private final QualifiedExpressionResolver qualifiedExpressionResolver;
     private final FlexibleTypeCapabilitiesProvider flexibleTypeCapabilitiesProvider;
     private final TypeLazinessToken typeLazinessToken;
 
@@ -102,7 +102,7 @@ public class InjectorForTests {
         this.storageManager = globalContext.getStorageManager();
         this.typeLazinessToken = new TypeLazinessToken();
         this.dynamicTypesSettings = new DynamicTypesSettings();
-        this.typeResolver = new TypeResolver(annotationResolver, qualifiedExpressionResolver, moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
+        this.typeResolver = new TypeResolver(annotationResolver, getQualifiedExpressionResolver(), moduleDescriptor, flexibleTypeCapabilitiesProvider, storageManager, typeLazinessToken, dynamicTypesSettings);
         this.expressionTypingComponents = new ExpressionTypingComponents();
         this.expressionTypingServices = new ExpressionTypingServices(expressionTypingComponents);
         this.functionDescriptorResolver = new FunctionDescriptorResolver(getTypeResolver(), getDescriptorResolver(), annotationResolver, storageManager, getExpressionTypingServices(), kotlinBuiltIns);
@@ -139,6 +139,8 @@ public class InjectorForTests {
         this.expressionTypingServices.setStatementFilter(statementFilter);
         this.expressionTypingServices.setTypeResolver(typeResolver);
 
+        this.qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator);
+
         annotationResolver.setCallResolver(callResolver);
         annotationResolver.setStorageManager(storageManager);
         annotationResolver.setTypeResolver(typeResolver);
@@ -181,8 +183,6 @@ public class InjectorForTests {
 
         callExpressionResolver.setExpressionTypingServices(expressionTypingServices);
 
-        qualifiedExpressionResolver.setSymbolUsageValidator(defaultSymbolUsageValidator);
-
     }
 
     @PreDestroy
@@ -209,4 +209,8 @@ public class InjectorForTests {
         return this.typeResolver;
     }
 
+    public QualifiedExpressionResolver getQualifiedExpressionResolver() {
+        return this.qualifiedExpressionResolver;
+    }
+
 }

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

@@ -227,6 +227,7 @@ private fun generatorForTests() =
             publicField<ExpressionTypingServices>()
             publicField<ExpressionTypingUtils>()
             publicField<TypeResolver>()
+            publicField<QualifiedExpressionResolver>()
 
             field<GlobalContext>(init = GivenExpression("org.jetbrains.kotlin.context.ContextPackage.GlobalContext()"),
                   useAsContext = true)

idea/tests/org/jetbrains/kotlin/addImport/AbstractAddImportTest.kt

@@ -30,6 +30,8 @@ import org.jetbrains.kotlin.renderer.DescriptorRenderer
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import com.intellij.psi.PsiDocumentManager
+import org.jetbrains.kotlin.di.InjectorForTests
+import org.jetbrains.kotlin.test.JetTestUtils
 
 public abstract class AbstractAddImportTest : AbstractImportsTest() {
     override fun doTest(file: JetFile) {
@@ -45,7 +47,7 @@ public abstract class AbstractAddImportTest : AbstractImportsTest() {
         val importDirective = JetPsiFactory(getProject()).createImportDirective(descriptorName)
         val moduleDescriptor = file.getResolutionFacade().findModuleDescriptor(file)
         val scope = JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor)
-        val descriptors = QualifiedExpressionResolver()
+        val descriptors = InjectorForTests(getProject(), moduleDescriptor).getQualifiedExpressionResolver()
                 .processImportReference(importDirective, scope, scope, BindingTraceContext(), LookupMode.EVERYTHING)
                 .getAllDescriptors()
                 .filter(filter)

idea/tests/org/jetbrains/kotlin/idea/debugger/evaluate/AbstractEditorForEvaluateExpressionTest.kt

@@ -23,6 +23,7 @@ import com.intellij.psi.PsiElement
 import com.intellij.psi.util.PsiTreeUtil
 import com.intellij.testFramework.fixtures.JavaCodeInsightTestFixture
 import org.jetbrains.kotlin.checkers.AbstractJetPsiCheckerTest
+import org.jetbrains.kotlin.di.InjectorForTests
 import org.jetbrains.kotlin.idea.caches.resolve.analyzeFully
 import org.jetbrains.kotlin.idea.caches.resolve.getResolutionFacade
 import org.jetbrains.kotlin.idea.completion.test.AbstractJvmBasicCompletionTest
@@ -57,7 +58,7 @@ public abstract class AbstractCodeFragmentHighlightingTest : AbstractJetPsiCheck
                 val importDirective = JetPsiFactory(getProject()).createImportDirective(it)
                 val moduleDescriptor = file.getResolutionFacade().findModuleDescriptor(file)
                 val scope = JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor)
-                val descriptor = QualifiedExpressionResolver()
+                val descriptor = InjectorForTests(getProject(), moduleDescriptor).getQualifiedExpressionResolver()
                                          .processImportReference(importDirective, scope, scope, BindingTraceContext(), LookupMode.EVERYTHING)
                                          .getAllDescriptors()
                                          .singleOrNull() ?: error("Could not resolve descriptor to import: $it")