Convert usages of existing generated injectors to dynamic injectors

Rewrite RuntimeModuleData to use hand-written code as we do not pack container module into runtime This change introduces some overhead (up to 10% for the tests I ran) in some scenarios in IDE, that should be addressed later
2015-04-28 19:37:14 +03:00
parent 5db541ee24
commit df529f1a4b
33 changed files with 580 additions and 164 deletions
@@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
-import org.jetbrains.kotlin.di.InjectorForLazyResolve
+import org.jetbrains.kotlin.frontend.di.createLazyResolveSession
 import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
 import org.jetbrains.kotlin.psi.*
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
@@ -49,11 +49,11 @@ public abstract class AbstractDescriptorRendererTest : KotlinTestWithEnvironment

        val context = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(getProject())

-        val resolveSession = InjectorForLazyResolve(
+        val resolveSession = createLazyResolveSession(
                context,
                FileBasedDeclarationProviderFactory(context.storageManager, listOf(psiFile)),
                CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
-                KotlinJvmCheckerProvider, DynamicTypesSettings()).getResolveSession()
+                KotlinJvmCheckerProvider, DynamicTypesSettings())

        context.initializeModuleContents(resolveSession.getPackageFragmentProvider())

@@ -21,7 +21,6 @@ import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.descriptors.*;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
@@ -31,6 +30,8 @@ import org.jetbrains.kotlin.resolve.descriptorUtil.DescriptorUtilPackage;
 import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.ContainerForTests;
+import org.jetbrains.kotlin.tests.di.DiPackage;
 import org.jetbrains.kotlin.types.JetType;
 import org.jetbrains.kotlin.types.TypeUtils;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingContext;
@@ -126,13 +127,13 @@ public class JetExpectedResolveDataUtil {
            JetType... parameterTypes
    ) {
        ModuleDescriptor emptyModule = JetTestUtils.createEmptyModule();
-        InjectorForTests injector = new InjectorForTests(project, emptyModule);
+        ContainerForTests container = DiPackage.createContainerForTests(project, emptyModule);

        ExpressionTypingContext context = ExpressionTypingContext.newContext(
-                injector.getAdditionalCheckerProvider(), new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),
+                container.getAdditionalCheckerProvider(), new BindingTraceContext(), classDescriptor.getDefaultType().getMemberScope(),
                DataFlowInfo.EMPTY, TypeUtils.NO_EXPECTED_TYPE);

-        OverloadResolutionResults<FunctionDescriptor> functions = injector.getFakeCallResolver().resolveFakeCall(
+        OverloadResolutionResults<FunctionDescriptor> functions = container.getFakeCallResolver().resolveFakeCall(
                context, ReceiverValue.NO_RECEIVER, Name.identifier(name), null, parameterTypes);

        for (ResolvedCall<? extends FunctionDescriptor> resolvedCall : functions.getResultingCalls()) {
@@ -16,24 +16,23 @@

 package org.jetbrains.kotlin.resolve.constraintSystem

+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
+import org.jetbrains.kotlin.diagnostics.rendering.Renderers
+import org.jetbrains.kotlin.resolve.TypeResolver
+import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.SPECIAL
+import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.TYPE_BOUND_POSITION
+import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
 import org.jetbrains.kotlin.test.ConfigurationKind
 import org.jetbrains.kotlin.test.JetLiteFixture
 import org.jetbrains.kotlin.test.JetTestUtils
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.di.InjectorForTests
-import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor
-import org.jetbrains.kotlin.diagnostics.rendering.Renderers
-import org.jetbrains.kotlin.resolve.*
-import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemImpl
+import org.jetbrains.kotlin.tests.di.createContainerForTests
 import org.jetbrains.kotlin.types.Variance
 import java.io.File
-import java.util.regex.Pattern
-import org.jetbrains.kotlin.resolve.constraintSystem.AbstractConstraintSystemTest.MyConstraintKind
-import org.jetbrains.kotlin.resolve.constraintSystem.AbstractConstraintSystemTest.MyConstraint
 import java.util.ArrayList
 import java.util.LinkedHashMap
-import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil
-import org.jetbrains.kotlin.resolve.calls.inference.constraintPosition.ConstraintPositionKind.*
+import java.util.regex.Pattern

 abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
    private val typePattern = """([\w|<|>|\(|\)]+)"""
@@ -55,8 +54,7 @@ abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
    override fun setUp() {
        super.setUp()

-        val injector = InjectorForTests(getProject(), JetTestUtils.createEmptyModule())
-        _typeResolver = injector.getTypeResolver()!!
+        _typeResolver = createContainerForTests(getProject(), JetTestUtils.createEmptyModule()).typeResolver
        _testDeclarations = analyzeDeclarations()
    }

@@ -21,7 +21,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
-import org.jetbrains.kotlin.di.InjectorForTopDownAnalyzerForJvm
+import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerForJvm
 import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil
 import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.java.structure.reflect.classId
@@ -55,13 +55,13 @@ public abstract class AbstractLocalClassProtoTest : TestCaseWithTmpdir() {
        val moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(environment.project)
        val providerFactory = FileBasedDeclarationProviderFactory(moduleContext.storageManager, emptyList())

-        val injector = InjectorForTopDownAnalyzerForJvm(
+        val container = createContainerForTopDownAnalyzerForJvm(
                moduleContext, CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
                providerFactory, GlobalSearchScope.allScope(environment.project)
        )
-        moduleContext.initializeModuleContents(injector.getJavaDescriptorResolver().packageFragmentProvider)
+        moduleContext.initializeModuleContents(container.javaDescriptorResolver.packageFragmentProvider)

-        val components = injector.getDeserializationComponentsForJava().components
+        val components = container.deserializationComponentsForJava.components

        val classDescriptor = components.classDeserializer.deserializeClass(clazz.classId)
                              ?: error("Class is not resolved: $clazz (classId = ${clazz.classId})")
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010-2015 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.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.tests.di
+
+import com.intellij.openapi.project.Project
+import org.jetbrains.kotlin.container.StorageComponentContainer
+import org.jetbrains.kotlin.container.createContainer
+import org.jetbrains.kotlin.container.get
+import org.jetbrains.kotlin.container.useImpl
+import org.jetbrains.kotlin.context.ModuleContext
+import org.jetbrains.kotlin.descriptors.ModuleDescriptor
+import org.jetbrains.kotlin.frontend.di.configureModule
+import org.jetbrains.kotlin.load.kotlin.KotlinJvmCheckerProvider
+import org.jetbrains.kotlin.resolve.AdditionalCheckerProvider
+import org.jetbrains.kotlin.resolve.DescriptorResolver
+import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver
+import org.jetbrains.kotlin.resolve.TypeResolver
+import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices
+import org.jetbrains.kotlin.types.expressions.FakeCallResolver
+
+public fun createContainerForTests(project: Project, module: ModuleDescriptor): ContainerForTests {
+    return ContainerForTests(createContainer("Tests") {
+        configureModule(ModuleContext(module, project), KotlinJvmCheckerProvider)
+        useImpl<ExpressionTypingServices>()
+    })
+}
+
+class ContainerForTests(container: StorageComponentContainer) {
+    val descriptorResolver: DescriptorResolver by container
+    val functionDescriptorResolver: FunctionDescriptorResolver by container
+    val typeResolver: TypeResolver by container
+    val fakeCallResolver: FakeCallResolver by container
+    val expressionTypingServices: ExpressionTypingServices by container
+    val additionalCheckerProvider: AdditionalCheckerProvider by container
+}
@@ -23,8 +23,6 @@ import org.jetbrains.kotlin.context.ContextPackage;
 import org.jetbrains.kotlin.context.ModuleContext;
 import org.jetbrains.kotlin.descriptors.*;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
-import org.jetbrains.kotlin.di.InjectorForLazyResolve;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.psi.*;
 import org.jetbrains.kotlin.resolve.*;
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
@@ -38,10 +36,13 @@ import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.ContainerForTests;
+import org.jetbrains.kotlin.tests.di.DiPackage;

 import java.util.Collections;
 import java.util.List;

+import static org.jetbrains.kotlin.frontend.di.DiPackage.createLazyResolveSession;
 import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;

 public class JetDefaultModalityModifiersTest extends JetLiteFixture {
@@ -71,9 +72,9 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {
        private JetScope scope;

        public void setUp() throws Exception {
-            InjectorForTests injector = new InjectorForTests(getProject(), root);
-            descriptorResolver = injector.getDescriptorResolver();
-            functionDescriptorResolver = injector.getFunctionDescriptorResolver();
+            ContainerForTests containerForTests = DiPackage.createContainerForTests(getProject(), root);
+            descriptorResolver = containerForTests.getDescriptorResolver();
+            functionDescriptorResolver = containerForTests.getFunctionDescriptorResolver();
            scope = createScope(KotlinBuiltIns.getInstance().getBuiltInsPackageScope());
        }

@@ -99,14 +100,14 @@ public class JetDefaultModalityModifiersTest extends JetLiteFixture {

        private ClassDescriptorWithResolutionScopes createClassDescriptor(ClassKind kind, JetClass aClass) {
            ModuleContext moduleContext = ContextPackage.ModuleContext(root, getProject());
-            ResolveSession resolveSession = new InjectorForLazyResolve(
+            ResolveSession resolveSession = createLazyResolveSession(
                    moduleContext,
                    new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(),
                                                            Collections.singleton(aClass.getContainingJetFile())),
                    new BindingTraceContext(),
                    AdditionalCheckerProvider.DefaultProvider.INSTANCE$,
                    new DynamicTypesSettings()
-            ).getResolveSession();
+            );

            return (ClassDescriptorWithResolutionScopes) resolveSession.getClassDescriptor(aClass);
        }
@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.psi.JetNamedFunction;
 import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
 import org.jetbrains.kotlin.resolve.OverloadUtil;
@@ -28,6 +27,8 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.ContainerForTests;
+import org.jetbrains.kotlin.tests.di.DiPackage;

 import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;

@@ -44,8 +45,7 @@ public class JetOverloadTest extends JetLiteFixture {
    @Override
    public void setUp() throws Exception {
        super.setUp();
-        InjectorForTests injector = new InjectorForTests(getProject(), root);
-        functionDescriptorResolver = injector.getFunctionDescriptorResolver();
+        functionDescriptorResolver = DiPackage.createContainerForTests(getProject(), root).getFunctionDescriptorResolver();
    }

    @Override
@@ -20,7 +20,6 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.FunctionDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.psi.JetNamedFunction;
 import org.jetbrains.kotlin.resolve.FunctionDescriptorResolver;
 import org.jetbrains.kotlin.resolve.OverridingUtil;
@@ -28,6 +27,7 @@ import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.DiPackage;

 import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;

@@ -44,8 +44,7 @@ public class JetOverridingTest extends JetLiteFixture {
    @Override
    public void setUp() throws Exception {
        super.setUp();
-        InjectorForTests injector = new InjectorForTests(getProject(), root);
-        functionDescriptorResolver = injector.getFunctionDescriptorResolver();
+        functionDescriptorResolver = DiPackage.createContainerForTests(getProject(), root).getFunctionDescriptorResolver();
    }

    @Override
@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.PackageViewDescriptor;
 import org.jetbrains.kotlin.descriptors.ReceiverParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.impl.ReceiverParameterDescriptorImpl;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.JetExpression;
@@ -40,6 +39,8 @@ import org.jetbrains.kotlin.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.ContainerForTests;
+import org.jetbrains.kotlin.tests.di.DiPackage;
 import org.jetbrains.kotlin.types.checker.JetTypeChecker;
 import org.jetbrains.kotlin.types.expressions.ExpressionTypingServices;

@@ -72,9 +73,9 @@ public class JetTypeCheckerTest extends JetLiteFixture {

        builtIns = KotlinBuiltIns.getInstance();

-        InjectorForTests injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule());
-        typeResolver = injector.getTypeResolver();
-        expressionTypingServices = injector.getExpressionTypingServices();
+        ContainerForTests container = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule());
+        typeResolver = container.getTypeResolver();
+        expressionTypingServices = container.getExpressionTypingServices();

        scopeWithImports = getDeclarationsScope("compiler/testData/type-checker-test.kt");
    }
@@ -29,7 +29,6 @@ import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.ClassifierDescriptor;
 import org.jetbrains.kotlin.descriptors.ModuleDescriptor;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages;
 import org.jetbrains.kotlin.name.FqName;
@@ -45,6 +44,8 @@ import org.jetbrains.kotlin.resolve.lazy.LazyResolveTestUtil;
 import org.jetbrains.kotlin.resolve.scopes.*;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.ContainerForTests;
+import org.jetbrains.kotlin.tests.di.DiPackage;

 import java.io.File;
 import java.io.IOException;
@@ -56,7 +57,7 @@ import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
@SuppressWarnings("unchecked")
 public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
    private JetScope scope;
-    private InjectorForTests injector;
+    private ContainerForTests container;

    @Override
    protected KotlinCoreEnvironment createEnvironment() {
@@ -67,13 +68,13 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
    protected void setUp() throws Exception {
        super.setUp();

-        injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule());
+        container = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule());
        scope = getContextScope();
    }

    @Override
    protected void tearDown() throws Exception {
-        injector = null;
+        container = null;
        scope = null;
        super.tearDown();
    }
@@ -140,7 +141,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment {
        JetTypeReference jetTypeReference = JetPsiFactory(getProject()).createType(typeStr);
        AnalyzingUtils.checkForSyntacticErrors(jetTypeReference);
        BindingTrace trace = new BindingTraceContext();
-        JetType type = injector.getTypeResolver().resolveType(scope, jetTypeReference, trace, true);
+        JetType type = container.getTypeResolver().resolveType(scope, jetTypeReference, trace, true);
        if (!trace.getBindingContext().getDiagnostics().isEmpty()) {
            fail("Errors:\n" + StringUtil.join(
                    trace.getBindingContext().getDiagnostics(),
@@ -26,7 +26,6 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.descriptors.TypeParameterDescriptor;
 import org.jetbrains.kotlin.descriptors.annotations.Annotations;
 import org.jetbrains.kotlin.descriptors.impl.TypeParameterDescriptorImpl;
-import org.jetbrains.kotlin.di.InjectorForTests;
 import org.jetbrains.kotlin.name.Name;
 import org.jetbrains.kotlin.psi.JetTypeProjection;
 import org.jetbrains.kotlin.psi.JetTypeReference;
@@ -38,6 +37,8 @@ import org.jetbrains.kotlin.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
 import org.jetbrains.kotlin.test.JetTestUtils;
+import org.jetbrains.kotlin.tests.di.ContainerForTests;
+import org.jetbrains.kotlin.tests.di.DiPackage;

 import java.util.Map;
 import java.util.Set;
@@ -63,8 +64,7 @@ public class TypeUnifierTest extends JetLiteFixture {

        builtIns = KotlinBuiltIns.getInstance();

-        InjectorForTests injector = new InjectorForTests(getProject(), JetTestUtils.createEmptyModule());
-        typeResolver = injector.getTypeResolver();
+        typeResolver = DiPackage.createContainerForTests(getProject(), JetTestUtils.createEmptyModule()).getTypeResolver();
        x = createTypeVariable("X");
        y = createTypeVariable("Y");
        variables = Sets.newHashSet(x.getTypeConstructor(), y.getTypeConstructor());