minor codegen refactoring

* cleanup after yesterday
* remove BindingContext stack in GenerationState
* use more power and strength of di

TODO: also initialize GenerationState by DI

compiler/tests/org/jetbrains/jet/codegen/CodegenTestCase.java

@@ -19,15 +19,19 @@ package org.jetbrains.jet.codegen;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetLiteFixture;
+import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetPsiUtil;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
+import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust;
+import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.parsing.JetParsingTest;
 
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.MalformedURLException;
+import java.util.Collections;
 
 /**
  * @author yole
@@ -116,9 +120,12 @@ public abstract class CodegenTestCase extends JetLiteFixture {
     }
 
     protected String generateToText() {
-        GenerationState state = new GenerationState(getProject(), ClassBuilderFactories.TEXT);
         AnalyzingUtils.checkForSyntacticErrors(myFile);
-        state.compile(myFile);
+        final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(myFile, JetControlFlowDataTraceFactory.EMPTY);
+        GenerationState state = new GenerationState(getProject(), ClassBuilderFactories.TEXT, analyzeExhaust, Collections.singletonList(myFile));
+
+        AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
+        state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
 
         return state.createText();
     }
@@ -159,9 +166,13 @@ public abstract class CodegenTestCase extends JetLiteFixture {
     @NotNull
     protected ClassFileFactory generateClassesInFile() {
         try {
-            GenerationState state = new GenerationState(getProject(), ClassBuilderFactories.binaries(false));
             AnalyzingUtils.checkForSyntacticErrors(myFile);
-            state.compile(myFile);
+            final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(myFile, JetControlFlowDataTraceFactory.EMPTY);
+            GenerationState state = new GenerationState(getProject(), ClassBuilderFactories.binaries(false), analyzeExhaust, Collections.singletonList(myFile));
+
+            AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
+            state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
+            analyzeExhaust.getBindingContext();
 
             return state.getFactory();
         } catch (RuntimeException e) {

compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java

@@ -90,19 +90,15 @@ public class TestlibTest extends CodegenTestCase {
                 throw new RuntimeException("There were compilation errors");
             }
 
-            ClassFileFactory classFileFactory = session.generate(false);
+            GenerationState state = session.generate(false);
+            ClassFileFactory classFileFactory = state.getFactory();
 
             final GeneratedClassLoader loader = new GeneratedClassLoader(
                     classFileFactory,
                     new URLClassLoader(new URL[]{ForTestCompileStdlib.stdlibJarForTests().toURI().toURL(), junitJar.toURI().toURL()},
                                        TestCase.class.getClassLoader()));
 
-            InjectorForJvmCodegen injector = new InjectorForJvmCodegen(
-                    session.getBindingContext().getStandardLibrary(),
-                    session.getBindingContext().getBindingContext(),
-                    session.getSourceFileNamespaces(),
-                    getProject());
-            JetTypeMapper typeMapper = injector.getJetTypeMapper();
+            JetTypeMapper typeMapper = state.getInjector().getJetTypeMapper();
             TestSuite suite = new TestSuite("stdlib_test");
             try {
                 for(JetFile jetFile : session.getSourceFileNamespaces()) {

compiler/tests/org/jetbrains/jet/compiler/CompileJavaAgainstKotlinTest.java

@@ -28,9 +28,13 @@ import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.codegen.ClassBuilderFactories;
 import org.jetbrains.jet.codegen.ClassFileFactory;
+import org.jetbrains.jet.codegen.CompilationErrorHandler;
 import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
+import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust;
+import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.plugin.JetLanguage;
 import org.junit.Assert;
 
@@ -78,9 +82,13 @@ public class CompileJavaAgainstKotlinTest extends TestCaseWithTmpdir {
         virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
         JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false);
 
-        GenerationState state = new GenerationState(jetCoreEnvironment.getProject(), ClassBuilderFactories.binaries(false));
         AnalyzingUtils.checkForSyntacticErrors(psiFile);
-        state.compile(psiFile);
+        final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(psiFile, JetControlFlowDataTraceFactory.EMPTY);
+        GenerationState state = new GenerationState(jetCoreEnvironment.getProject(), ClassBuilderFactories.binaries(false), analyzeExhaust, Collections.singletonList(psiFile));
+
+        AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
+        state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
+        analyzeExhaust.getBindingContext();
 
         ClassFileFactory classFileFactory = state.getFactory();
 

compiler/tests/org/jetbrains/jet/compiler/CompileKotlinAgainstKotlinTest.java

@@ -27,12 +27,12 @@ import junit.framework.Test;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
-import org.jetbrains.jet.codegen.ClassBuilderFactories;
-import org.jetbrains.jet.codegen.ClassBuilderFactory;
-import org.jetbrains.jet.codegen.ClassFileFactory;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
+import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust;
+import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.plugin.JetLanguage;
 
 import java.io.File;
@@ -41,6 +41,7 @@ import java.io.IOException;
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLClassLoader;
+import java.util.Collections;
 
 /**
  * @author Stepan Koltsov
@@ -93,10 +94,14 @@ public class CompileKotlinAgainstKotlinTest extends TestCaseWithTmpdir  {
         virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
         JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false);
         
-        GenerationState state = new GenerationState(jetCoreEnvironment.getProject(), ClassBuilderFactories.binaries(false));
         AnalyzingUtils.checkForSyntacticErrors(psiFile);
-        
-        state.compile(psiFile);
+
+        final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(psiFile, JetControlFlowDataTraceFactory.EMPTY);
+        GenerationState state = new GenerationState(jetCoreEnvironment.getProject(), ClassBuilderFactories.binaries(false), analyzeExhaust, Collections.singletonList(psiFile));
+
+        AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
+        state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
+        analyzeExhaust.getBindingContext();
 
         ClassFileFactory classFileFactory = state.getFactory();
 
@@ -116,9 +121,13 @@ public class CompileKotlinAgainstKotlinTest extends TestCaseWithTmpdir  {
         virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
         JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false);
 
-        GenerationState state = new GenerationState(jetCoreEnvironment.getProject(), ClassBuilderFactories.binaries(false));
         AnalyzingUtils.checkForSyntacticErrors(psiFile);
-        state.compile(psiFile);
+        final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(psiFile, JetControlFlowDataTraceFactory.EMPTY);
+        GenerationState state = new GenerationState(jetCoreEnvironment.getProject(), ClassBuilderFactories.binaries(false), analyzeExhaust, Collections.singletonList(psiFile));
+
+        AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
+        state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
+        analyzeExhaust.getBindingContext();
 
         ClassFileFactory classFileFactory = state.getFactory();
 

compiler/tests/org/jetbrains/jet/compiler/ReadKotlinBinaryClassTest.java

@@ -28,19 +28,24 @@ import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.codegen.ClassBuilderFactories;
 import org.jetbrains.jet.codegen.ClassFileFactory;
+import org.jetbrains.jet.codegen.CompilationErrorHandler;
 import org.jetbrains.jet.codegen.GenerationState;
 import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
+import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.FqName;
+import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust;
+import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.plugin.JetLanguage;
 import org.junit.Assert;
 
 import java.io.File;
+import java.util.Collections;
 
 /**
  * Compile Kotlin and then parse model from .class files.
@@ -70,9 +75,13 @@ public class ReadKotlinBinaryClassTest extends TestCaseWithTmpdir {
         virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
         JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false);
 
-        GenerationState state = new GenerationState(jetCoreEnvironment.getProject(), ClassBuilderFactories.binaries(false));
         AnalyzingUtils.checkForSyntacticErrors(psiFile);
-        BindingContext bindingContext = state.compile(psiFile);
+        final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(psiFile, JetControlFlowDataTraceFactory.EMPTY);
+        GenerationState state = new GenerationState(jetCoreEnvironment.getProject(), ClassBuilderFactories.binaries(false), analyzeExhaust, Collections.singletonList(psiFile));
+
+        AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
+        state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
+        BindingContext bindingContext = analyzeExhaust.getBindingContext();
 
         ClassFileFactory classFileFactory = state.getFactory();
 

compiler/tests/org/jetbrains/jet/compiler/WriteSignatureTest.java

@@ -29,12 +29,12 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.JetTestCaseBuilder;
 import org.jetbrains.jet.JetTestUtils;
-import org.jetbrains.jet.codegen.ClassBuilderFactories;
-import org.jetbrains.jet.codegen.ClassBuilderFactory;
-import org.jetbrains.jet.codegen.ClassFileFactory;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
+import org.jetbrains.jet.lang.resolve.java.AnalyzeExhaust;
+import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
 import org.jetbrains.jet.plugin.JetLanguage;
 import org.junit.Assert;
@@ -48,6 +48,7 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.nio.charset.Charset;
+import java.util.Collections;
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -84,9 +85,14 @@ public class WriteSignatureTest extends TestCaseWithTmpdir {
         virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
         JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false);
 
-        GenerationState state = new GenerationState(jetCoreEnvironment.getProject(), ClassBuilderFactories.binaries(false));
         AnalyzingUtils.checkForSyntacticErrors(psiFile);
-        state.compile(psiFile);
+        final AnalyzeExhaust analyzeExhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(psiFile, JetControlFlowDataTraceFactory.EMPTY);
+        GenerationState state = new GenerationState(jetCoreEnvironment.getProject(), ClassBuilderFactories.binaries(false),
+                analyzeExhaust, Collections.singletonList(psiFile));
+
+        AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
+        state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
+        analyzeExhaust.getBindingContext();
 
         ClassFileFactory classFileFactory = state.getFactory();