LTDA: Assert context was created for light class generation

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java

@@ -18,7 +18,6 @@ package org.jetbrains.jet.cli.jvm.compiler;
 
 import com.google.common.base.Predicate;
 import com.google.common.collect.Collections2;
-import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiClass;
@@ -30,6 +29,7 @@ import com.intellij.util.SmartList;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.jet.asJava.KotlinLightClassForExplicitDeclaration;
 import org.jetbrains.jet.asJava.LightClassConstructionContext;
 import org.jetbrains.jet.asJava.LightClassGenerationSupport;
@@ -79,12 +79,11 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport
         this.bindingContext = trace.getBindingContext();
         this.module = module;
 
-        if (trace instanceof CliBindingTrace) {
+        if (!(trace instanceof CliBindingTrace)) {
-            ((CliBindingTrace) trace).setKotlinCodeAnalyzer(analyzer);
+            throw new IllegalArgumentException("Shared trace is expected to be subclass of " + CliBindingTrace.class.getSimpleName() + " class");
-        }
-        else {
-            assert ApplicationManager.getApplication().isUnitTestMode();
         }
+
+        ((CliBindingTrace) trace).setKotlinCodeAnalyzer(analyzer);
     }
 
     @NotNull
@@ -217,13 +216,13 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport
         return KotlinLightClassForExplicitDeclaration.create(classOrObject.getManager(), classOrObject);
     }
 
-    public static BindingTrace createTrace() {
+    @NotNull
-        return new CliBindingTrace();
+    @Override
+    public BindingTraceContext createTrace() {
+        return new NoScopeRecordCliBindingTrace();
     }
 
-    public static class CliBindingTrace extends BindingTraceContext {
+    public static class NoScopeRecordCliBindingTrace extends CliBindingTrace {
-        private KotlinCodeAnalyzer kotlinCodeAnalyzer;
-
         @Override
         public <K, V> void record(WritableSlice<K, V> slice, K key, V value) {
             if (slice == BindingContext.RESOLUTION_SCOPE || slice == BindingContext.TYPE_RESOLUTION_SCOPE) {
@@ -233,6 +232,19 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport
             super.record(slice, key, value);
         }
 
+        @Override
+        public String toString() {
+            return NoScopeRecordCliBindingTrace.class.getName();
+        }
+    }
+
+    public static class CliBindingTrace extends BindingTraceContext {
+        private KotlinCodeAnalyzer kotlinCodeAnalyzer;
+
+        @TestOnly
+        public CliBindingTrace() {
+        }
+
         @Override
         public String toString() {
             return CliBindingTrace.class.getName();

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java

@@ -291,7 +291,7 @@ public class KotlinToJVMBytecodeCompiler {
                     @NotNull
                     @Override
                     public AnalysisResult invoke() {
-                        BindingTrace sharedTrace = CliLightClassGenerationSupport.createTrace();
+                        BindingTrace sharedTrace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
                         ModuleDescriptorImpl analyzeModule = TopDownAnalyzerFacadeForJVM.createAnalyzeModule();
 
                         return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(

compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java

@@ -37,6 +37,7 @@ import org.jetbrains.jet.cli.common.messages.AnalyzerWithCompilerReport;
 import org.jetbrains.jet.cli.common.messages.MessageCollector;
 import org.jetbrains.jet.cli.common.messages.MessageCollectorToString;
 import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys;
+import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.codegen.ClassBuilderFactories;
 import org.jetbrains.jet.codegen.CompilationErrorHandler;
@@ -102,7 +103,7 @@ public class ReplInterpreter {
         JetCoreEnvironment environment = JetCoreEnvironment.createForProduction(disposable, configuration);
         Project project = environment.getProject();
         this.psiFileFactory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(project);
-        this.trace = new BindingTraceContext();
+        this.trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
         this.module = TopDownAnalyzerFacadeForJVM.createJavaModule("<repl>");
 
         GlobalContextImpl context = ContextPackage.GlobalContext();

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAnalyzerFacade.kt

@@ -33,6 +33,7 @@ import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.jet.analyzer.ModuleInfo
 import org.jetbrains.jet.analyzer.ModuleContent
 import org.jetbrains.jet.di.InjectorForLazyResolveWithJava
+import org.jetbrains.jet.lang.resolve.CodeAnalyzerInitializer
 
 public class JvmResolverForModule(
         override val lazyResolveSession: ResolveSession,
@@ -63,7 +64,9 @@ public object JvmAnalyzerFacade : AnalyzerFacade<JvmResolverForModule, JvmPlatfo
             resolverForProject.resolverForModule(moduleInfo as M).javaDescriptorResolver
         }
         val injector = InjectorForLazyResolveWithJava(
-                project, globalContext, moduleDescriptor, moduleContentScope, BindingTraceContext(), declarationProviderFactory, moduleClassResolver
+                project, globalContext, moduleDescriptor, moduleContentScope,
+                CodeAnalyzerInitializer.getInstance(project).createTrace(),
+                declarationProviderFactory, moduleClassResolver
         )
 
         val resolveSession = injector.getResolveSession()!!

compiler/frontend/src/org/jetbrains/jet/lang/resolve/CodeAnalyzerInitializer.kt

@@ -17,15 +17,14 @@
 package org.jetbrains.jet.lang.resolve
 
 import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer
-import kotlin.platform.platformStatic
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.components.ServiceManager
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
-import javax.annotation.PostConstruct
 
 public trait CodeAnalyzerInitializer {
     public fun initialize(trace: BindingTrace, module: ModuleDescriptor, codeAnalyzer: KotlinCodeAnalyzer?)
-
+    public fun createTrace(): BindingTrace
+    
     class object {
         public fun getInstance(project: Project): CodeAnalyzerInitializer =
                 ServiceManager.getService<CodeAnalyzerInitializer>(project, javaClass<CodeAnalyzerInitializer>())!!
@@ -36,4 +35,6 @@ public class DummyCodeAnalyzerInitializer: CodeAnalyzerInitializer {
     public override fun initialize(trace: BindingTrace, module: ModuleDescriptor, codeAnalyzer: KotlinCodeAnalyzer?) {
         // Do nothing
     }
+
+    public override fun createTrace(): BindingTrace = BindingTraceContext()
 }

compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java

@@ -98,7 +98,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
             allJetFiles.addAll(jetFiles);
 
             ModuleDescriptorImpl module = modules.get(testModule);
-            BindingTrace moduleTrace = CliLightClassGenerationSupport.createTrace();
+            BindingTrace moduleTrace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
 
             moduleBindings.put(testModule, moduleTrace.getBindingContext());
 

compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java

@@ -145,7 +145,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
         configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, new File("compiler/tests")); // for @ExpectLoadError annotation
         JetCoreEnvironment environment = JetCoreEnvironment.createForTests(getTestRootDisposable(), configuration);
 
-        BindingTrace trace = CliLightClassGenerationSupport.createTrace();
+        BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
         ModuleDescriptorImpl module = TopDownAnalyzerFacadeForJVM.createAnalyzeModule();
 
         TopDownAnalysisParameters parameters = TopDownAnalysisParameters.create(

compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractSdkAnnotationsValidityTest.java

@@ -21,6 +21,7 @@ import com.intellij.openapi.Disposable;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
@@ -69,7 +70,7 @@ public abstract class AbstractSdkAnnotationsValidityTest extends UsefulTestCase
             try {
                 JetCoreEnvironment commonEnvironment = createEnvironment(parentDisposable);
 
-                BindingTrace trace = new BindingTraceContext();
+                BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
                 InjectorForJavaDescriptorResolver injector =
                         InjectorForJavaDescriptorResolverUtil.create(commonEnvironment.getProject(), trace, false);
 

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java

@@ -41,7 +41,7 @@ import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
 import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.BindingTraceContext;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -90,7 +90,7 @@ public final class LoadDescriptorUtil {
                 new File("compiler/tests") // for @ExpectLoadError annotation
         );
         JetCoreEnvironment jetCoreEnvironment = JetCoreEnvironment.createForTests(disposable, configuration);
-        BindingTraceContext trace = new BindingTraceContext();
+        BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
         InjectorForJavaDescriptorResolver injector =
                 InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), trace, true);
         ModuleDescriptorImpl module = injector.getModule();

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java

@@ -80,8 +80,7 @@ public class JvmResolveUtil {
         module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
         module.seal();
 
-        CliLightClassGenerationSupport lightClassGenerationSupport = CliLightClassGenerationSupport.getInstanceForCli(project);
+        BindingTrace trace = new CliLightClassGenerationSupport.CliBindingTrace();
-        BindingTrace trace = lightClassGenerationSupport != null ? CliLightClassGenerationSupport.createTrace() : new BindingTraceContext();
 
         return TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
                 project, files, trace, filesToAnalyzeCompletely, module, null, null);

compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java

@@ -53,7 +53,7 @@ public class LazyResolveTestUtil {
                 globalContext.getExceptionTracker(),
                 Predicates.<PsiFile>alwaysTrue(),
                 false, false);
-        BindingTrace trace = CliLightClassGenerationSupport.createTrace();
+        BindingTrace trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
         ModuleDescriptorImpl sharedModule = TopDownAnalyzerFacadeForJVM.createAnalyzeModule();
 
         TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(

compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java

@@ -20,6 +20,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
 import org.jetbrains.jet.di.InjectorForTests;
@@ -116,7 +117,8 @@ public class JetExpectedResolveDataUtil {
 
     @NotNull
     private static PsiClass findClass(String qualifiedName, Project project) {
-        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, new BindingTraceContext(), false);
+        BindingTraceContext trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
+        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, trace, false);
         JavaClass javaClass = injector.getJavaClassFinder().findClass(ClassId.topLevel(new FqName(qualifiedName)));
         Assert.assertNotNull("Class wasn't found: " + qualifiedName, javaClass);
         assertInstanceOf(javaClass, JavaClassImpl.class);

compiler/tests/org/jetbrains/jet/resolve/constraintSystem/AbstractConstraintSystemTest.kt

@@ -55,7 +55,7 @@ abstract public class AbstractConstraintSystemTest() : JetLiteFixture() {
     override fun setUp() {
         super.setUp()
 
-        val injector = InjectorForTests(getProject(), JetTestUtils.createEmptyModule()!!)
+        val injector = InjectorForTests(getProject(), JetTestUtils.createEmptyModule())
         _typeResolver = injector.getTypeResolver()!!
         _myDeclarations = analyzeDeclarations()
     }

compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java

@@ -24,6 +24,7 @@ import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetLiteFixture;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
 import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
@@ -600,8 +601,8 @@ public class JetTypeCheckerTest extends JetLiteFixture {
     private WritableScopeImpl addImports(JetScope scope) {
         WritableScopeImpl writableScope = new WritableScopeImpl(
                 scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports");
-        InjectorForJavaDescriptorResolver injector =
+        BindingTraceContext trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace();
-                InjectorForJavaDescriptorResolverUtil.create(getProject(), new BindingTraceContext(), true);
+        InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(getProject(), trace, true);
         ModuleDescriptor module = injector.getModule();
         for (ImportPath defaultImport : module.getDefaultImports()) {
             writableScope.importScope(module.getPackage(defaultImport.fqnPart()).getMemberScope());

libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt

@@ -120,7 +120,7 @@ class NoInternalVisibilityInStdLibTest {
             TopDownAnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
                     environment.getProject(),
                     environment.getSourceFiles(),
-                    BindingTraceContext(),
+                    CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(),
                     { true },
                     module,
                     null,