GenerationState refactored to be (almost) immutable and methodless (modulo little protection from reuse)

GenerationStrategy introduced to handle separately cases of regular compilation and building of JetLightClasses (this was only real overridable behavior of GenerationState in old code)
state subpackage introduced

compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java

@@ -20,6 +20,7 @@ import org.jetbrains.asm4.MethodVisitor;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.context.CodegenContext;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
 import org.jetbrains.jet.lang.psi.*;
@@ -88,8 +89,7 @@ public abstract class ClassBodyCodegen {
 
     protected void generateDeclaration(PropertyCodegen propertyCodegen, JetDeclaration declaration, FunctionCodegen functionCodegen) {
         if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) {
-            state.getInjector().getMemberCodegen().generateFunctionOrProperty(
+            state.getMemberCodegen().generateFunctionOrProperty((JetTypeParameterListOwner) declaration, context, v);
-                    (JetTypeParameterListOwner) declaration, context, v);
         }
     }
 
@@ -109,7 +109,7 @@ public abstract class ClassBodyCodegen {
                         }
                     }
                     else {
-                        Type type = state.getInjector().getJetTypeMapper().mapType(propertyDescriptor.getType(), MapTypeMode.VALUE);
+                        Type type = state.getTypeMapper().mapType(propertyDescriptor.getType(), MapTypeMode.VALUE);
                         v.newMethod(p, ACC_PUBLIC | ACC_ABSTRACT, p.getName(), "()" + type.getDescriptor(), null, null);
                     }
                 }

compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.codegen;
 
 import org.jetbrains.jet.codegen.context.CodegenContext;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
@@ -49,7 +50,7 @@ public class ClassCodegen {
 
     public void generate(CodegenContext context, JetClassOrObject aClass) {
         ClassDescriptor descriptor = state.getBindingContext().get(BindingContext.CLASS, aClass);
-        ClassBuilder classBuilder = state.forClassImplementation(descriptor);
+        ClassBuilder classBuilder = state.getFactory().forClassImplementation(descriptor);
 
         final CodegenContext contextForInners = context.intoClass(descriptor, OwnerKind.IMPLEMENTATION, state);
 
@@ -95,7 +96,7 @@ public class ClassCodegen {
         new ImplementationBodyCodegen(aClass, classContext, classBuilder, state).generate();
 
         if (aClass instanceof JetClass && ((JetClass) aClass).isTrait()) {
-            ClassBuilder traitBuilder = state.forTraitImplementation(descriptor);
+            ClassBuilder traitBuilder = state.getFactory().forTraitImplementation(descriptor, state);
             new TraitImplBodyCodegen(aClass, context.intoClass(descriptor, OwnerKind.TRAIT_IMPL, state), traitBuilder, state)
                     .generate();
             traitBuilder.done();

compiler/backend/src/org/jetbrains/jet/codegen/ClassFileFactory.java

@@ -17,8 +17,9 @@
 package org.jetbrains.jet.codegen;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.codegen.state.GenerationState;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import javax.inject.Inject;
@@ -26,8 +27,9 @@ import java.util.*;
 
 /**
  * @author max
+ * @author alex.tkachman
  */
-public class ClassFileFactory {
+public final class ClassFileFactory {
     private ClassBuilderFactory builderFactory;
     private GenerationState state;
 
@@ -47,7 +49,6 @@ public class ClassFileFactory {
         this.state = state;
     }
 
-
     ClassBuilder newVisitor(String filePath) {
         state.getProgress().log("Emitting: " + filePath);
         final ClassBuilder answer = builderFactory.newClassBuilder();
@@ -55,28 +56,6 @@ public class ClassFileFactory {
         return answer;
     }
 
-    ClassBuilder forAnonymousSubclass(@NotNull JvmClassName className) {
-        return newVisitor(className.getInternalName() + ".class");
-    }
-
-    NamespaceCodegen forNamespace(final FqName fqName, Collection<JetFile> files) {
-        assert !isDone : "Already done!";
-        NamespaceCodegen codegen = ns2codegen.get(fqName);
-        if (codegen == null) {
-            ClassBuilderOnDemand onDemand = new ClassBuilderOnDemand() {
-                @NotNull
-                @Override
-                protected ClassBuilder createClassBuilder() {
-                    return newVisitor(NamespaceCodegen.getJVMClassNameForKotlinNs(fqName).getInternalName() + ".class");
-                }
-            };
-            codegen = new NamespaceCodegen(onDemand, fqName, state, files);
-            ns2codegen.put(fqName, codegen);
-        }
-
-        return codegen;
-    }
-
     private void done() {
         if (!isDone) {
             isDone = true;
@@ -100,4 +79,50 @@ public class ClassFileFactory {
         done();
         return new ArrayList<String>(generators.keySet());
     }
+
+    public String createText() {
+        StringBuilder answer = new StringBuilder();
+
+        List<String> files = files();
+        for (String file : files) {
+            //            if (!file.startsWith("kotlin/")) {
+            answer.append("@").append(file).append('\n');
+            answer.append(asText(file));
+            //            }
+        }
+
+        return answer.toString();
+    }
+
+    public NamespaceCodegen forNamespace(final FqName fqName, Collection<JetFile> files) {
+        assert !isDone : "Already done!";
+        NamespaceCodegen codegen = ns2codegen.get(fqName);
+        if (codegen == null) {
+            ClassBuilderOnDemand onDemand = new ClassBuilderOnDemand() {
+                @NotNull
+                @Override
+                protected ClassBuilder createClassBuilder() {
+                    return newVisitor(NamespaceCodegen.getJVMClassNameForKotlinNs(fqName).getInternalName() + ".class");
+                }
+            };
+            codegen = new NamespaceCodegen(onDemand, fqName, state, files);
+            ns2codegen.put(fqName, codegen);
+        }
+
+        return codegen;
+    }
+
+    public ClassBuilder forClassImplementation(ClassDescriptor aClass) {
+        return newVisitor(
+                state.getTypeMapper().mapType(aClass.getDefaultType(), MapTypeMode.IMPL).getInternalName() + ".class");
+    }
+
+    public ClassBuilder forNamespacepart(String name) {
+        return newVisitor(name + ".class");
+    }
+
+    public ClassBuilder forTraitImplementation(ClassDescriptor aClass, GenerationState state) {
+        return newVisitor(
+                state.getTypeMapper().mapType(aClass.getDefaultType(), MapTypeMode.TRAIT_IMPL).getInternalName() + ".class");
+    }
 }

compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java

@@ -32,6 +32,7 @@ import org.jetbrains.jet.codegen.context.CalculatedClosure;
 import org.jetbrains.jet.codegen.context.CodegenContext;
 import org.jetbrains.jet.codegen.context.MutableClosure;
 import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.JetDeclarationWithBody;
 import org.jetbrains.jet.lang.psi.JetElement;
@@ -66,20 +67,18 @@ public class ClosureCodegen {
         this.state = state;
         this.closure = closure;
         bindingContext = state.getBindingContext();
-        typeMapper = state.getInjector().getJetTypeMapper();
+        typeMapper = state.getTypeMapper();
     }
 
     public ClosureCodegen gen(JetExpression fun, CodegenContext context, ExpressionCodegen expressionCodegen) {
         final SimpleFunctionDescriptor descriptor = bindingContext.get(BindingContext.FUNCTION, fun);
         assert descriptor != null;
 
-        final Pair<JvmClassName, ClassBuilder> nameAndVisitor = state.forAnonymousSubclass(fun);
+        name = classNameForAnonymousClass(state.getBindingContext(), fun);
+        final ClassBuilder cv = state.getFactory().newVisitor(name.getInternalName() + ".class");
 
         final FunctionDescriptor funDescriptor = bindingContext.get(BindingContext.FUNCTION, fun);
 
-        ClassBuilder cv = nameAndVisitor.getSecond();
-        name = nameAndVisitor.getFirst();
-
         SignatureWriter signatureWriter = new SignatureWriter();
 
         assert funDescriptor != null;
@@ -113,7 +112,7 @@ public class ClosureCodegen {
             generateConstInstance(fun, cv);
         }
 
-        generateClosureFields(closure, cv, state.getInjector().getJetTypeMapper());
+        generateClosureFields(closure, cv, state.getTypeMapper());
 
         cv.done();
 

compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java

@@ -20,7 +20,6 @@ import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.progress.ProcessCanceledException;
-import com.intellij.openapi.util.Pair;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.tree.IElementType;
@@ -35,6 +34,7 @@ import org.jetbrains.asm4.commons.Method;
 import org.jetbrains.jet.codegen.context.*;
 import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethod;
 import org.jetbrains.jet.codegen.signature.JvmPropertyAccessorSignature;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.*;
@@ -92,6 +92,29 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
      */
     private final Map<JetElement, StackValue.Local> tempVariables = Maps.newHashMap();
 
+    public CalculatedClosure generateObjectLiteral(
+            GenerationState state,
+            JetObjectLiteralExpression literal
+    ) {
+        JetObjectDeclaration objectDeclaration = literal.getObjectDeclaration();
+
+        JvmClassName className =
+                classNameForAnonymousClass(bindingContext, objectDeclaration);
+        ClassBuilder classBuilder = state.getFactory().newVisitor(className.getInternalName() + ".class");
+
+        final ClassDescriptor classDescriptor = bindingContext.get(CLASS, objectDeclaration);
+        assert classDescriptor != null;
+
+        //noinspection SuspiciousMethodCalls
+        final CalculatedClosure closure = bindingContext.get(CLOSURE, classDescriptor);
+
+        final CodegenContext objectContext = context.intoAnonymousClass(classDescriptor, this);
+
+        new ImplementationBodyCodegen(objectDeclaration, objectContext, classBuilder, state).generate();
+
+        return closure;
+    }
+
     static class BlockStackElement {
     }
 
@@ -124,7 +147,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             GenerationState state
     ) {
         this.myFrameMap = myMap;
-        this.typeMapper = state.getInjector().getJetTypeMapper();
+        this.typeMapper = state.getTypeMapper();
         this.returnType = returnType;
         this.state = state;
         this.v = new InstructionAdapter(v) {
@@ -227,11 +250,13 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
         ClassDescriptor descriptor = bindingContext.get(BindingContext.CLASS, declaration);
         assert descriptor != null;
 
-        Pair<JvmClassName, ClassBuilder> nameAndVisitor = state.forAnonymousSubclass(declaration);
+        JvmClassName className =
+                classNameForAnonymousClass(state.getBindingContext(), declaration);
+        ClassBuilder classBuilder = state.getFactory().newVisitor(className.getInternalName() + ".class");
 
         final CodegenContext objectContext = context.intoAnonymousClass(descriptor, this);
 
-        new ImplementationBodyCodegen(declaration, objectContext, nameAndVisitor.getSecond(), state).generate();
+        new ImplementationBodyCodegen(declaration, objectContext, classBuilder, state).generate();
         return StackValue.none();
     }
 
@@ -1036,7 +1061,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
 
     @Override
     public StackValue visitObjectLiteralExpression(JetObjectLiteralExpression expression, StackValue receiver) {
-        CalculatedClosure closure = state.generateObjectLiteral(expression, this);
+        CalculatedClosure closure = this.generateObjectLiteral(state, expression);
 
         ConstructorDescriptor constructorDescriptor = bindingContext.get(BindingContext.CONSTRUCTOR, expression.getObjectDeclaration());
         assert constructorDescriptor != null;
@@ -1302,7 +1327,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
             while (memberDescriptor.getKind() == CallableMemberDescriptor.Kind.FAKE_OVERRIDE) {
                 memberDescriptor = memberDescriptor.getOverriddenDescriptors().iterator().next();
             }
-            intrinsic = state.getInjector().getIntrinsics().getIntrinsic(memberDescriptor);
+            intrinsic = state.getIntrinsics().getIntrinsic(memberDescriptor);
         }
         if (intrinsic != null) {
             final Type expectedType = expressionType(expression);
@@ -1741,7 +1766,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
     }
 
     Callable resolveToCallable(@NotNull FunctionDescriptor fd, boolean superCall) {
-        final IntrinsicMethod intrinsic = state.getInjector().getIntrinsics().getIntrinsic(fd);
+        final IntrinsicMethod intrinsic = state.getIntrinsics().getIntrinsic(fd);
         if (intrinsic != null) {
             return intrinsic;
         }
@@ -1917,7 +1942,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
                     JvmClassName className =
                             classNameForScriptDescriptor(state.getBindingContext(),
                                                                         receiver.getDeclarationDescriptor());
-                    String fieldName = state.getInjector().getScriptCodegen().getScriptFieldName(receiver.getDeclarationDescriptor());
+                    String fieldName = state.getScriptCodegen().getScriptFieldName(receiver.getDeclarationDescriptor());
                     result.put(currentScriptClassName.getAsmType(), v);
                     StackValue.field(className.getAsmType(), currentScriptClassName, fieldName, false).put(className.getAsmType(), v);
                 }
@@ -3556,7 +3581,7 @@ The "returned" value of try expression with no finally is either the last expres
     }
 
     private Call makeFakeCall(ReceiverDescriptor initializerAsReceiver) {
-        JetSimpleNameExpression fake = JetPsiFactory.createSimpleName(state.getInjector().getProject(), "fake");
+        JetSimpleNameExpression fake = JetPsiFactory.createSimpleName(state.getProject(), "fake");
         return CallMaker.makeCall(fake, initializerAsReceiver);
     }
 

compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java

@@ -30,6 +30,7 @@ import org.jetbrains.jet.codegen.context.MethodContext;
 import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
 import org.jetbrains.jet.codegen.signature.kotlin.JetMethodAnnotationWriter;
 import org.jetbrains.jet.codegen.signature.kotlin.JetValueParameterAnnotationWriter;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -70,7 +71,7 @@ public class FunctionCodegen {
         final SimpleFunctionDescriptor functionDescriptor = state.getBindingContext().get(BindingContext.FUNCTION, f);
         assert functionDescriptor != null;
         JvmMethodSignature method =
-                state.getInjector().getJetTypeMapper().mapToCallableMethod(functionDescriptor, false, owner.getContextKind())
+                state.getTypeMapper().mapToCallableMethod(functionDescriptor, false, owner.getContextKind())
                         .getSignature();
         generateMethod(f, method, true, null, functionDescriptor);
     }
@@ -142,7 +143,7 @@ public class FunctionCodegen {
             final MethodVisitor mv =
                     v.newMethod(fun, flags, jvmSignature.getAsmMethod().getName(), jvmSignature.getAsmMethod().getDescriptor(),
                                 jvmSignature.getGenericsSignature(), null);
-            AnnotationCodegen.forMethod(mv, state.getInjector().getJetTypeMapper()).genAnnotations(functionDescriptor);
+            AnnotationCodegen.forMethod(mv, state.getTypeMapper()).genAnnotations(functionDescriptor);
             if (state.getClassBuilderMode() != ClassBuilderMode.SIGNATURES) {
                 int start = 0;
                 if (needJetAnnotations) {
@@ -185,7 +186,7 @@ public class FunctionCodegen {
                     }
                     for (int i = 0; i != paramDescrs.size(); ++i) {
                         ValueParameterDescriptor parameterDescriptor = paramDescrs.get(i);
-                        AnnotationCodegen.forParameter(i, mv, state.getInjector().getJetTypeMapper()).genAnnotations(parameterDescriptor);
+                        AnnotationCodegen.forParameter(i, mv, state.getTypeMapper()).genAnnotations(parameterDescriptor);
                         JetValueParameterAnnotationWriter av = JetValueParameterAnnotationWriter.visitParameterAnnotation(mv, i + start);
                         av.writeName(parameterDescriptor.getName().getName());
                         av.writeHasDefaultValue(parameterDescriptor.declaresDefaultValue());
@@ -209,7 +210,7 @@ public class FunctionCodegen {
                 Label methodBegin = new Label();
                 mv.visitLabel(methodBegin);
 
-                FrameMap frameMap = context.prepareFrame(state.getInjector().getJetTypeMapper());
+                FrameMap frameMap = context.prepareFrame(state.getTypeMapper());
 
                 ExpressionCodegen codegen =
                         new ExpressionCodegen(mv, frameMap, jvmSignature.getAsmMethod().getReturnType(), context, state);
@@ -264,9 +265,9 @@ public class FunctionCodegen {
                 }
                 else {
                     for (ValueParameterDescriptor parameter : paramDescrs) {
-                        Type sharedVarType = state.getInjector().getJetTypeMapper().getSharedVarType(parameter);
+                        Type sharedVarType = state.getTypeMapper().getSharedVarType(parameter);
                         if (sharedVarType != null) {
-                            Type localVarType = state.getInjector().getJetTypeMapper().mapType(parameter.getType(), MapTypeMode.VALUE);
+                            Type localVarType = state.getTypeMapper().mapType(parameter.getType(), MapTypeMode.VALUE);
                             int index = frameMap.getIndex(parameter);
                             mv.visitTypeInsn(NEW, sharedVarType.getInternalName());
                             mv.visitInsn(DUP);
@@ -300,32 +301,32 @@ public class FunctionCodegen {
                 int k = 0;
 
                 if (expectedThisObject.exists()) {
-                    Type type = state.getInjector().getJetTypeMapper().mapType(expectedThisObject.getType(), MapTypeMode.VALUE);
+                    Type type = state.getTypeMapper().mapType(expectedThisObject.getType(), MapTypeMode.VALUE);
                     // TODO: specify signature
                     mv.visitLocalVariable("this", type.getDescriptor(), null, methodBegin, methodEnd, k++);
                 }
                 else if (fun instanceof JetFunctionLiteralExpression ||
                          isLocalFun(state.getBindingContext(), functionDescriptor)) {
-                    Type type = state.getInjector().getJetTypeMapper().mapType(
+                    Type type = state.getTypeMapper().mapType(
                             context.getThisDescriptor().getDefaultType(), MapTypeMode.VALUE);
                     mv.visitLocalVariable("this", type.getDescriptor(), null, methodBegin, methodEnd, k++);
                 }
 
                 if (receiverParameter.exists()) {
-                    Type type = state.getInjector().getJetTypeMapper().mapType(receiverParameter.getType(), MapTypeMode.VALUE);
+                    Type type = state.getTypeMapper().mapType(receiverParameter.getType(), MapTypeMode.VALUE);
                     // TODO: specify signature
                     mv.visitLocalVariable("this$receiver", type.getDescriptor(), null, methodBegin, methodEnd, k);
                     k += type.getSize();
                 }
 
                 for (ValueParameterDescriptor parameter : paramDescrs) {
-                    Type type = state.getInjector().getJetTypeMapper().mapType(parameter.getType(), MapTypeMode.VALUE);
+                    Type type = state.getTypeMapper().mapType(parameter.getType(), MapTypeMode.VALUE);
                     // TODO: specify signature
 
                     Label divideLabel = mapLabelsToDivideLocalVarVisibilityForSharedVar.get(parameter.getName());
                     String parameterName = parameter.getName().getName();
                     if (divideLabel != null) {
-                        Type sharedVarType = state.getInjector().getJetTypeMapper().getSharedVarType(parameter);
+                        Type sharedVarType = state.getTypeMapper().getSharedVarType(parameter);
                         mv.visitLocalVariable(parameterName, type.getDescriptor(), null, methodBegin, divideLabel, k);
 
                         String nameForSharedVar = generateTmpVariableName(localVariableNames);
@@ -381,7 +382,7 @@ public class FunctionCodegen {
         }
 
         Method method =
-                state.getInjector().getJetTypeMapper().mapSignature(functionDescriptor.getName(), functionDescriptor).getAsmMethod();
+                state.getTypeMapper().mapSignature(functionDescriptor.getName(), functionDescriptor).getAsmMethod();
 
         Queue<FunctionDescriptor> bfsQueue = new LinkedList<FunctionDescriptor>();
         Set<FunctionDescriptor> visited = new HashSet<FunctionDescriptor>();
@@ -401,7 +402,7 @@ public class FunctionCodegen {
             FunctionDescriptor descriptor = bfsQueue.poll();
             if (descriptor.getKind() == CallableMemberDescriptor.Kind.DECLARATION) {
                 Method overridden =
-                        state.getInjector().getJetTypeMapper().mapSignature(descriptor.getName(), descriptor.getOriginal()).getAsmMethod();
+                        state.getTypeMapper().mapSignature(descriptor.getName(), descriptor.getOriginal()).getAsmMethod();
                 if (differentMethods(method, overridden)) {
                     bridgesToGenerate.add(overridden);
                 }
@@ -458,7 +459,7 @@ public class FunctionCodegen {
             ownerInternalName = NamespaceCodegen.getJVMClassNameForKotlinNs(DescriptorUtils.getFQName(contextClass).toSafe());
         }
         else {
-            ownerInternalName = JvmClassName.byType(state.getInjector().getJetTypeMapper()
+            ownerInternalName = JvmClassName.byType(state.getTypeMapper()
                                                             .mapType(((ClassDescriptor) contextClass).getDefaultType(),
                                                                      MapTypeMode.IMPL));
         }
@@ -498,7 +499,7 @@ public class FunctionCodegen {
     ) {
         mv.visitCode();
 
-        FrameMap frameMap = owner.prepareFrame(state.getInjector().getJetTypeMapper());
+        FrameMap frameMap = owner.prepareFrame(state.getTypeMapper());
 
         if (kind instanceof OwnerKind.StaticDelegateKind) {
             frameMap.leaveTemp(OBJECT_TYPE);
@@ -513,7 +514,7 @@ public class FunctionCodegen {
 
         Type receiverType;
         if (hasReceiver) {
-            receiverType = state.getInjector().getJetTypeMapper().mapType(receiverParameter.getType(), MapTypeMode.VALUE);
+            receiverType = state.getTypeMapper().mapType(receiverParameter.getType(), MapTypeMode.VALUE);
             var += receiverType.getSize();
         }
         else {
@@ -664,7 +665,7 @@ public class FunctionCodegen {
                 reg += argType.getSize();
             }
 
-            iv.invokevirtual(state.getInjector().getJetTypeMapper().mapType(
+            iv.invokevirtual(state.getTypeMapper().mapType(
                     ((ClassDescriptor) owner.getContextDescriptor()).getDefaultType(), MapTypeMode.VALUE).getInternalName(),
                              jvmSignature.getName(), jvmSignature.getDescriptor());
             if (isPrimitive(jvmSignature.getReturnType()) && !isPrimitive(overridden.getReturnType())) {
@@ -680,7 +681,7 @@ public class FunctionCodegen {
 
     public void genDelegate(FunctionDescriptor functionDescriptor, CallableMemberDescriptor overriddenDescriptor, StackValue field) {
         JvmMethodSignature jvmMethodSignature =
-                state.getInjector().getJetTypeMapper().mapSignature(functionDescriptor.getName(), functionDescriptor);
+                state.getTypeMapper().mapSignature(functionDescriptor.getName(), functionDescriptor);
         genDelegate(functionDescriptor, overriddenDescriptor, field, jvmMethodSignature);
     }
 
@@ -721,7 +722,7 @@ public class FunctionCodegen {
             field.put(field.type, iv);
             ClassDescriptor classDescriptor = (ClassDescriptor) overriddenDescriptor.getContainingDeclaration();
             String internalName =
-                    state.getInjector().getJetTypeMapper().mapType(classDescriptor.getDefaultType(), MapTypeMode.VALUE).getInternalName();
+                    state.getTypeMapper().mapType(classDescriptor.getDefaultType(), MapTypeMode.VALUE).getInternalName();
             if (classDescriptor.getKind() == ClassKind.TRAIT) {
                 iv.invokeinterface(internalName, method.getName(), method.getDescriptor());
             }

compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java

@@ -1,239 +0,0 @@
-/*
- * Copyright 2010-2012 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.
- */
-
-/*
- * @author max
- */
-package org.jetbrains.jet.codegen;
-
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Pair;
-import com.intellij.util.containers.MultiMap;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.asm4.commons.Method;
-import org.jetbrains.jet.analyzer.AnalyzeExhaust;
-import org.jetbrains.jet.codegen.context.CalculatedClosure;
-import org.jetbrains.jet.codegen.context.CodegenBinding;
-import org.jetbrains.jet.codegen.context.CodegenContext;
-import org.jetbrains.jet.di.InjectorForJvmCodegen;
-import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
-import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
-import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
-import org.jetbrains.jet.lang.resolve.ScriptNameUtil;
-import org.jetbrains.jet.lang.resolve.java.JvmClassName;
-import org.jetbrains.jet.lang.resolve.name.FqName;
-import org.jetbrains.jet.utils.Progress;
-
-import java.util.Collection;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-
-import static org.jetbrains.jet.codegen.context.CodegenBinding.*;
-
-public class GenerationState {
-    private final Progress progress;
-    @NotNull
-    private final List<JetFile> files;
-    @NotNull
-    private final InjectorForJvmCodegen injector;
-    @NotNull
-    private final ClassBuilderMode classBuilderMode;
-
-
-    private boolean used = false;
-
-    // out parameter
-    private Method scriptConstructorMethod;
-    private final BindingContext bindingContext;
-
-
-    public GenerationState(Project project, ClassBuilderFactory builderFactory, AnalyzeExhaust analyzeExhaust, List<JetFile> files) {
-        this(project, builderFactory, Progress.DEAF, analyzeExhaust, files, BuiltinToJavaTypesMapping.ENABLED);
-    }
-
-    public GenerationState(
-            @NotNull Project project,
-            ClassBuilderFactory builderFactory, Progress progress,
-            @NotNull AnalyzeExhaust exhaust, @NotNull List<JetFile> files, @NotNull BuiltinToJavaTypesMapping builtinToJavaTypesMapping
-    ) {
-        this.progress = progress;
-        this.files = files;
-        this.classBuilderMode = builderFactory.getClassBuilderMode();
-        final DelegatingBindingTrace trace = new DelegatingBindingTrace(exhaust.getBindingContext());
-        bindingContext = trace.getBindingContext();
-        this.injector = new InjectorForJvmCodegen(
-                trace,
-                this.files, builtinToJavaTypesMapping, builderFactory.getClassBuilderMode(), this, builderFactory, project);
-    }
-
-    private void markUsed() {
-        if (used) {
-            throw new IllegalStateException(
-                    GenerationState.class + " cannot be used more than once");
-        }
-        used = true;
-    }
-
-    @NotNull
-    public ClassFileFactory getFactory() {
-        return getInjector().getClassFileFactory();
-    }
-
-    public Progress getProgress() {
-        return progress;
-    }
-
-    @NotNull
-    public InjectorForJvmCodegen getInjector() {
-        return injector;
-    }
-
-    public BindingContext getBindingContext() {
-        return bindingContext;
-    }
-
-    @NotNull
-    public ClassBuilderMode getClassBuilderMode() {
-        return classBuilderMode;
-    }
-
-    public void setScriptConstructorMethod(@NotNull Method scriptConstructorMethod) {
-        this.scriptConstructorMethod = scriptConstructorMethod;
-    }
-
-    public Method getScriptConstructorMethod() {
-        return scriptConstructorMethod;
-    }
-
-    public ClassBuilder forClassImplementation(ClassDescriptor aClass) {
-        return getFactory().newVisitor(
-                getInjector().getJetTypeMapper().mapType(aClass.getDefaultType(), MapTypeMode.IMPL).getInternalName() + ".class");
-    }
-
-    public ClassBuilder forNamespacepart(String name) {
-        return getFactory().newVisitor(name + ".class");
-    }
-
-    public ClassBuilder forTraitImplementation(ClassDescriptor aClass) {
-        return getFactory().newVisitor(
-                getInjector().getJetTypeMapper().mapType(aClass.getDefaultType(), MapTypeMode.TRAIT_IMPL).getInternalName() + ".class");
-    }
-
-    public Pair<JvmClassName, ClassBuilder> forAnonymousSubclass(JetElement expression) {
-        JvmClassName className =
-                classNameForAnonymousClass(bindingContext, expression);
-        return Pair.create(className, getFactory().forAnonymousSubclass(className));
-    }
-
-    protected NamespaceCodegen forNamespace(FqName fqName, Collection<JetFile> jetFiles) {
-        return getFactory().forNamespace(fqName, jetFiles);
-    }
-
-    private void beforeCompile() {
-        markUsed();
-
-        //noinspection unchecked
-        CodegenBinding.initTrace(injector.getBindingTrace(), injector.getListOfJetFile());
-    }
-
-    public void compileCorrectFiles(@NotNull CompilationErrorHandler errorHandler) {
-        for (JetFile file : this.files) {
-            if (file.isScript()) {
-                String name = ScriptNameUtil.classNameForScript(file);
-                JetScript script = file.getScript();
-                assert script != null;
-                registerClassNameForScript(injector.getBindingTrace(), script, JvmClassName.byInternalName(name));
-            }
-        }
-
-        injector.getScriptCodegen().registerEarlierScripts(Collections.<Pair<ScriptDescriptor, JvmClassName>>emptyList());
-
-        beforeCompile();
-
-        MultiMap<FqName, JetFile> namespaceGrouping = new MultiMap<FqName, JetFile>();
-        for (JetFile file : this.files) {
-            if (file == null) throw new IllegalArgumentException("A null file given for compilation");
-            namespaceGrouping.putValue(JetPsiUtil.getFQName(file), file);
-        }
-
-        for (Map.Entry<FqName, Collection<JetFile>> entry : namespaceGrouping.entrySet()) {
-            generateNamespace(entry.getKey(), entry.getValue(), errorHandler, progress);
-        }
-    }
-
-    public void compileScript(
-            @NotNull JetScript script,
-            @NotNull JvmClassName className,
-            @NotNull List<Pair<ScriptDescriptor, JvmClassName>> earlierScripts,
-            @NotNull CompilationErrorHandler errorHandler
-    ) {
-
-        injector.getScriptCodegen().registerEarlierScripts(earlierScripts);
-        registerClassNameForScript(injector.getBindingTrace(), script, className);
-
-        beforeCompile();
-
-        generateNamespace(
-                JetPsiUtil.getFQName((JetFile) script.getContainingFile()),
-                Collections.singleton((JetFile) script.getContainingFile()),
-                errorHandler,
-                progress);
-    }
-
-    protected void generateNamespace(FqName fqName, Collection<JetFile> jetFiles, CompilationErrorHandler errorHandler, Progress progress) {
-        NamespaceCodegen codegen = forNamespace(fqName, jetFiles);
-        codegen.generate(errorHandler, progress);
-    }
-
-    public CalculatedClosure generateObjectLiteral(JetObjectLiteralExpression literal, ExpressionCodegen expressionCodegen) {
-        JetObjectDeclaration objectDeclaration = literal.getObjectDeclaration();
-        Pair<JvmClassName, ClassBuilder> nameAndVisitor = forAnonymousSubclass(objectDeclaration);
-
-        final ClassDescriptor classDescriptor = bindingContext.get(BindingContext.CLASS, objectDeclaration);
-        assert classDescriptor != null;
-
-        //noinspection SuspiciousMethodCalls
-        final CalculatedClosure closure = bindingContext.get(CLOSURE, classDescriptor);
-
-        final CodegenContext objectContext = expressionCodegen.context.intoAnonymousClass(classDescriptor, expressionCodegen);
-
-        new ImplementationBodyCodegen(objectDeclaration, objectContext, nameAndVisitor.getSecond(), this).generate();
-
-        return closure;
-    }
-
-    public String createText() {
-        StringBuilder answer = new StringBuilder();
-
-        final ClassFileFactory factory = getFactory();
-        List<String> files = factory.files();
-        for (String file : files) {
-            //            if (!file.startsWith("kotlin/")) {
-            answer.append("@").append(file).append('\n');
-            answer.append(factory.asText(file));
-            //            }
-        }
-
-        return answer.toString();
-    }
-
-    public void destroy() {
-        injector.destroy();
-    }
-}

compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java

@@ -30,6 +30,7 @@ import org.jetbrains.jet.codegen.context.*;
 import org.jetbrains.jet.codegen.signature.*;
 import org.jetbrains.jet.codegen.signature.kotlin.JetMethodAnnotationWriter;
 import org.jetbrains.jet.codegen.signature.kotlin.JetValueParameterAnnotationWriter;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -71,7 +72,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
     public ImplementationBodyCodegen(JetClassOrObject aClass, CodegenContext context, ClassBuilder v, GenerationState state) {
         super(aClass, context, v, state);
-        typeMapper = state.getInjector().getJetTypeMapper();
+        typeMapper = state.getTypeMapper();
         bindingContext = state.getBindingContext();
     }
 
@@ -345,7 +346,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         generateEnumMethods();
 
-        generateClosureFields(context.closure, v, state.getInjector().getJetTypeMapper());
+        generateClosureFields(context.closure, v, state.getTypeMapper());
     }
 
     private void generateEnumMethods() {
@@ -744,7 +745,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
             }
 
             for (ValueParameterDescriptor valueParameter : constructorDescriptor.getValueParameters()) {
-                AnnotationCodegen.forParameter(i, mv, state.getInjector().getJetTypeMapper()).genAnnotations(valueParameter);
+                AnnotationCodegen.forParameter(i, mv, state.getTypeMapper()).genAnnotations(valueParameter);
                 JetValueParameterAnnotationWriter jetValueParameterAnnotation =
                         JetValueParameterAnnotationWriter.visitParameterAnnotation(mv, i);
                 jetValueParameterAnnotation.writeName(valueParameter.getName().getName());
@@ -917,7 +918,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                 }
 
                 final MethodVisitor mv = v.newMethod(myClass, flags, function.getName(), function.getDescriptor(), null, null);
-                AnnotationCodegen.forMethod(mv, state.getInjector().getJetTypeMapper()).genAnnotations(fun);
+                AnnotationCodegen.forMethod(mv, state.getTypeMapper()).genAnnotations(fun);
 
                 JvmMethodSignature jvmSignature =
                         typeMapper.mapToCallableMethod(inheritedFun, false, OwnerKind.IMPLEMENTATION).getSignature();
@@ -943,7 +944,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
                 }
                 else if (state.getClassBuilderMode() == ClassBuilderMode.FULL) {
                     mv.visitCode();
-                    FrameMap frameMap = context.prepareFrame(state.getInjector().getJetTypeMapper());
+                    FrameMap frameMap = context.prepareFrame(state.getTypeMapper());
                     ExpressionCodegen codegen =
                             new ExpressionCodegen(mv, frameMap, jvmSignature.getAsmMethod().getReturnType(), context, state);
                     codegen.generateThisOrOuter(descriptor);    // ??? wouldn't it be addClosureToConstructorParameters good idea to put it?

compiler/backend/src/org/jetbrains/jet/codegen/MemberCodegen.java

@@ -18,6 +18,7 @@ package org.jetbrains.jet.codegen;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.codegen.context.CodegenContext;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.psi.JetProperty;
 import org.jetbrains.jet.lang.psi.JetTypeParameterListOwner;

compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java

@@ -26,6 +26,7 @@ import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.context.CodegenBinding;
 import org.jetbrains.jet.codegen.context.CodegenContext;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.descriptors.PropertyDescriptor;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
@@ -126,22 +127,22 @@ public class NamespaceCodegen {
         for (JetDeclaration declaration : file.getDeclarations()) {
             if (declaration instanceof JetProperty) {
                 final CodegenContext context = CodegenContext.STATIC.intoNamespace(descriptor);
-                state.getInjector().getMemberCodegen().generateFunctionOrProperty(
+                state.getMemberCodegen().generateFunctionOrProperty(
                         (JetTypeParameterListOwner) declaration, context, v.getClassBuilder());
             }
             else if (declaration instanceof JetNamedFunction) {
                 if (!multiFile) {
                     final CodegenContext context = CodegenContext.STATIC.intoNamespace(descriptor);
-                    state.getInjector().getMemberCodegen().generateFunctionOrProperty(
+                    state.getMemberCodegen().generateFunctionOrProperty(
                             (JetTypeParameterListOwner) declaration, context, v.getClassBuilder());
                 }
             }
             else if (declaration instanceof JetClassOrObject) {
                 final CodegenContext context = CodegenContext.STATIC.intoNamespace(descriptor);
-                state.getInjector().getClassCodegen().generate(context, (JetClassOrObject) declaration);
+                state.getClassCodegen().generate(context, (JetClassOrObject) declaration);
             }
             else if (declaration instanceof JetScript) {
-                state.getInjector().getScriptCodegen().generate((JetScript) declaration);
+                state.getScriptCodegen().generate((JetScript) declaration);
             }
         }
 
@@ -157,7 +158,7 @@ public class NamespaceCodegen {
                 PsiFile containingFile = file.getContainingFile();
                 String namespaceInternalName = name.child(Name.identifier(JvmAbi.PACKAGE_CLASS)).getFqName().replace('.', '/');
                 String className = getMultiFileNamespaceInternalName(namespaceInternalName, containingFile);
-                ClassBuilder builder = state.forNamespacepart(className);
+                ClassBuilder builder = state.getFactory().forNamespacepart(className);
 
                 builder.defineClass(containingFile, V1_6,
                                     ACC_PUBLIC/*|ACC_SUPER*/,
@@ -174,13 +175,13 @@ public class NamespaceCodegen {
                         {
                             final CodegenContext context =
                                     CodegenContext.STATIC.intoNamespace(descriptor);
-                            state.getInjector().getMemberCodegen()
+                            state.getMemberCodegen()
                                     .generateFunctionOrProperty((JetTypeParameterListOwner) declaration, context, builder);
                         }
                         {
                             final CodegenContext context =
                                     CodegenContext.STATIC.intoNamespacePart(className, descriptor);
-                            state.getInjector().getMemberCodegen()
+                            state.getMemberCodegen()
                                     .generateFunctionOrProperty((JetTypeParameterListOwner) declaration, context, v.getClassBuilder());
                         }
                     }

compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java

@@ -26,6 +26,7 @@ import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.context.CodegenContext;
 import org.jetbrains.jet.codegen.signature.JvmPropertyAccessorSignature;
 import org.jetbrains.jet.codegen.signature.kotlin.JetMethodAnnotationWriter;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -110,9 +111,9 @@ public class PropertyCodegen {
             if (JetStandardLibrary.getInstance().isVolatile(propertyDescriptor)) {
                 modifiers |= ACC_VOLATILE;
             }
-            Type type = state.getInjector().getJetTypeMapper().mapType(propertyDescriptor.getType(), MapTypeMode.VALUE);
+            Type type = state.getTypeMapper().mapType(propertyDescriptor.getType(), MapTypeMode.VALUE);
             FieldVisitor fieldVisitor = v.newField(p, modifiers, propertyDescriptor.getName().getName(), type.getDescriptor(), null, value);
-            AnnotationCodegen.forField(fieldVisitor, state.getInjector().getJetTypeMapper()).genAnnotations(propertyDescriptor);
+            AnnotationCodegen.forField(fieldVisitor, state.getTypeMapper()).genAnnotations(propertyDescriptor);
         }
     }
 
@@ -121,7 +122,7 @@ public class PropertyCodegen {
         if (getter != null) {
             if (getter.getBodyExpression() != null) {
                 JvmPropertyAccessorSignature signature =
-                        state.getInjector().getJetTypeMapper().mapGetterSignature(propertyDescriptor, kind);
+                        state.getTypeMapper().mapGetterSignature(propertyDescriptor, kind);
                 functionCodegen.generateMethod(getter, signature.getJvmMethodSignature(), true, signature.getPropertyTypeKotlinSignature(),
                                                propertyDescriptor.getGetter());
             }
@@ -146,7 +147,7 @@ public class PropertyCodegen {
                 final PropertySetterDescriptor setterDescriptor = propertyDescriptor.getSetter();
                 assert setterDescriptor != null;
                 JvmPropertyAccessorSignature signature =
-                        state.getInjector().getJetTypeMapper().mapSetterSignature(propertyDescriptor, kind);
+                        state.getTypeMapper().mapSetterSignature(propertyDescriptor, kind);
                 functionCodegen.generateMethod(setter, signature.getJvmMethodSignature(), true, signature.getPropertyTypeKotlinSignature(),
                                                setterDescriptor);
             }
@@ -192,7 +193,7 @@ public class PropertyCodegen {
             flags |= ACC_FINAL;
         }
 
-        JvmPropertyAccessorSignature signature = state.getInjector().getJetTypeMapper().mapGetterSignature(propertyDescriptor, kind);
+        JvmPropertyAccessorSignature signature = state.getTypeMapper().mapGetterSignature(propertyDescriptor, kind);
         final String descriptor = signature.getJvmMethodSignature().getAsmMethod().getDescriptor();
         String getterName = getterName(propertyDescriptor.getName());
         MethodVisitor mv = v.newMethod(origin, flags, getterName, descriptor, null, null);
@@ -206,7 +207,7 @@ public class PropertyCodegen {
         if (getter != null) {
             //noinspection ConstantConditions
             assert !getter.hasBody();
-            AnnotationCodegen.forMethod(mv, state.getInjector().getJetTypeMapper()).genAnnotations(getter);
+            AnnotationCodegen.forMethod(mv, state.getTypeMapper()).genAnnotations(getter);
         }
 
         if (state.getClassBuilderMode() != ClassBuilderMode.SIGNATURES && (!isTrait || kind instanceof OwnerKind.DelegateKind)) {
@@ -220,7 +221,7 @@ public class PropertyCodegen {
                     if (kind != OwnerKind.NAMESPACE) {
                         iv.load(0, OBJECT_TYPE);
                     }
-                    final Type type = state.getInjector().getJetTypeMapper().mapType(propertyDescriptor.getType(), MapTypeMode.VALUE);
+                    final Type type = state.getTypeMapper().mapType(propertyDescriptor.getType(), MapTypeMode.VALUE);
 
                     if ((kind instanceof OwnerKind.DelegateKind) != (propertyDescriptor.getKind() == FunctionDescriptor.Kind.DELEGATION)) {
                         throw new IllegalStateException("mismatching kind in " + propertyDescriptor);
@@ -234,7 +235,7 @@ public class PropertyCodegen {
                     else {
                         iv.visitFieldInsn(
                                 kind == OwnerKind.NAMESPACE ? GETSTATIC : GETFIELD,
-                                state.getInjector().getJetTypeMapper().getOwner(propertyDescriptor, kind).getInternalName(),
+                                state.getTypeMapper().getOwner(propertyDescriptor, kind).getInternalName(),
                                 propertyDescriptor.getName().getName(),
                                 type.getDescriptor());
                     }
@@ -298,7 +299,7 @@ public class PropertyCodegen {
             flags |= ACC_FINAL;
         }
 
-        JvmPropertyAccessorSignature signature = state.getInjector().getJetTypeMapper().mapSetterSignature(propertyDescriptor, kind);
+        JvmPropertyAccessorSignature signature = state.getTypeMapper().mapSetterSignature(propertyDescriptor, kind);
         assert true;
         final String descriptor = signature.getJvmMethodSignature().getAsmMethod().getDescriptor();
         MethodVisitor mv = v.newMethod(origin, flags, setterName(propertyDescriptor.getName()), descriptor, null, null);
@@ -309,7 +310,7 @@ public class PropertyCodegen {
                                       setter.getVisibility());
 
         assert !setter.hasBody();
-        AnnotationCodegen.forMethod(mv, state.getInjector().getJetTypeMapper()).genAnnotations(setter);
+        AnnotationCodegen.forMethod(mv, state.getTypeMapper()).genAnnotations(setter);
 
         if (state.getClassBuilderMode() != ClassBuilderMode.SIGNATURES && (!isTrait || kind instanceof OwnerKind.DelegateKind)) {
             if (propertyDescriptor.getModality() != Modality.ABSTRACT) {
@@ -319,7 +320,7 @@ public class PropertyCodegen {
                 }
                 else {
                     InstructionAdapter iv = new InstructionAdapter(mv);
-                    final Type type = state.getInjector().getJetTypeMapper().mapType(propertyDescriptor.getType(), MapTypeMode.VALUE);
+                    final Type type = state.getTypeMapper().mapType(propertyDescriptor.getType(), MapTypeMode.VALUE);
                     int paramCode = 0;
                     if (kind != OwnerKind.NAMESPACE) {
                         iv.load(0, OBJECT_TYPE);
@@ -341,7 +342,7 @@ public class PropertyCodegen {
                     else {
                         iv.load(paramCode, type);
                         iv.visitFieldInsn(kind == OwnerKind.NAMESPACE ? PUTSTATIC : PUTFIELD,
-                                          state.getInjector().getJetTypeMapper().getOwner(propertyDescriptor, kind).getInternalName(),
+                                          state.getTypeMapper().getOwner(propertyDescriptor, kind).getInternalName(),
                                           propertyDescriptor.getName().getName(),
                                           type.getDescriptor());
                     }
@@ -363,11 +364,11 @@ public class PropertyCodegen {
 
     public void genDelegate(PropertyDescriptor declaration, PropertyDescriptor overriddenDescriptor, StackValue field) {
         JvmPropertyAccessorSignature jvmPropertyAccessorSignature =
-                state.getInjector().getJetTypeMapper().mapGetterSignature(declaration, OwnerKind.IMPLEMENTATION);
+                state.getTypeMapper().mapGetterSignature(declaration, OwnerKind.IMPLEMENTATION);
         functionCodegen.genDelegate(declaration, overriddenDescriptor, field, jvmPropertyAccessorSignature.getJvmMethodSignature());
 
         if (declaration.isVar()) {
-            jvmPropertyAccessorSignature = state.getInjector().getJetTypeMapper().mapSetterSignature(declaration, OwnerKind.IMPLEMENTATION);
+            jvmPropertyAccessorSignature = state.getTypeMapper().mapSetterSignature(declaration, OwnerKind.IMPLEMENTATION);
             functionCodegen.genDelegate(declaration, overriddenDescriptor, field, jvmPropertyAccessorSignature.getJvmMethodSignature());
         }
     }

compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java

@@ -22,20 +22,22 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.MethodVisitor;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
+import org.jetbrains.asm4.commons.Method;
 import org.jetbrains.jet.codegen.context.CodegenContext;
 import org.jetbrains.jet.codegen.context.ScriptContext;
 import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
+import org.jetbrains.jet.codegen.state.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationStrategy;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
-import org.jetbrains.jet.lang.psi.JetDeclaration;
+import org.jetbrains.jet.lang.psi.*;
-import org.jetbrains.jet.lang.psi.JetScript;
-import org.jetbrains.jet.lang.psi.JetTypeParameterListOwner;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.ScriptNameUtil;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
 
 import javax.inject.Inject;
+import java.util.Collections;
 import java.util.List;
 
 import static org.jetbrains.asm4.Opcodes.*;
@@ -59,6 +61,7 @@ public class ScriptCodegen {
     private BindingContext bindingContext;
 
     private List<ScriptDescriptor> earlierScripts;
+    private Method scriptConstructorMethod;
 
 
     @Inject
@@ -136,7 +139,7 @@ public class ScriptCodegen {
 
         JvmMethodSignature jvmSignature = jetTypeMapper.mapScriptSignature(scriptDescriptor, importedScripts);
 
-        state.setScriptConstructorMethod(jvmSignature.getAsmMethod());
+        state.getScriptCodegen().setScriptConstructorMethod(jvmSignature.getAsmMethod());
 
         MethodVisitor mv = classBuilder.newMethod(
                 scriptDeclaration, ACC_PUBLIC, jvmSignature.getAsmMethod().getName(), jvmSignature.getAsmMethod().getDescriptor(),
@@ -233,7 +236,7 @@ public class ScriptCodegen {
             ScriptDescriptor earlierDescriptor = t.first;
             JvmClassName earlierClassName = t.second;
 
-            registerClassNameForScript(state.getInjector().getBindingTrace(), earlierDescriptor, earlierClassName);
+            registerClassNameForScript(state.getBindingTrace(), earlierDescriptor, earlierClassName);
         }
 
         List<ScriptDescriptor> earlierScriptDescriptors = Lists.newArrayList();
@@ -255,4 +258,29 @@ public class ScriptCodegen {
     public String getScriptFieldName(@NotNull ScriptDescriptor scriptDescriptor) {
         return "script$" + getScriptIndex(scriptDescriptor);
     }
+
+    public void setScriptConstructorMethod(Method scriptConstructorMethod) {
+        this.scriptConstructorMethod = scriptConstructorMethod;
+    }
+
+    public Method getScriptConstructorMethod() {
+        return scriptConstructorMethod;
+    }
+
+    public void compileScript(
+            @NotNull JetScript script,
+            @NotNull JvmClassName className,
+            @NotNull List<Pair<ScriptDescriptor, JvmClassName>> earlierScripts,
+            @NotNull CompilationErrorHandler errorHandler
+    ) {
+        registerEarlierScripts(earlierScripts);
+        registerClassNameForScript(state.getBindingTrace(), script, className);
+
+        state.beforeCompile();
+        GenerationStrategy.STANDARD.generateNamespace(
+                state,
+                JetPsiUtil.getFQName((JetFile) script.getContainingFile()),
+                Collections.singleton((JetFile) script.getContainingFile()),
+                errorHandler);
+    }
 }

compiler/backend/src/org/jetbrains/jet/codegen/StackValue.java

@@ -24,6 +24,7 @@ import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.asm4.commons.Method;
 import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethod;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.calls.ResolvedCall;

compiler/backend/src/org/jetbrains/jet/codegen/TraitImplBodyCodegen.java

@@ -17,6 +17,7 @@
 package org.jetbrains.jet.codegen;
 
 import org.jetbrains.jet.codegen.context.CodegenContext;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ClassKind;
 import org.jetbrains.jet.lang.psi.JetClassOrObject;
@@ -56,6 +57,6 @@ public class TraitImplBodyCodegen extends ClassBodyCodegen {
     }
 
     private String jvmName() {
-        return state.getInjector().getJetTypeMapper().mapType(descriptor.getDefaultType(), MapTypeMode.TRAIT_IMPL).getInternalName();
+        return state.getTypeMapper().mapType(descriptor.getDefaultType(), MapTypeMode.TRAIT_IMPL).getInternalName();
     }
 }

compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java

@@ -20,6 +20,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 
@@ -132,14 +133,14 @@ public abstract class CodegenContext {
     }
 
     public CodegenContext intoClass(ClassDescriptor descriptor, OwnerKind kind, GenerationState state) {
-        return new ClassContext(state.getInjector().getJetTypeMapper(), descriptor, kind, this, null);
+        return new ClassContext(state.getTypeMapper(), descriptor, kind, this, null);
     }
 
     public CodegenContext intoAnonymousClass(
             ClassDescriptor descriptor,
             ExpressionCodegen expressionCodegen
     ) {
-        final JetTypeMapper typeMapper = expressionCodegen.getState().getInjector().getJetTypeMapper();
+        final JetTypeMapper typeMapper = expressionCodegen.getState().getTypeMapper();
         return new AnonymousClassContext(typeMapper, descriptor, OwnerKind.IMPLEMENTATION, this,
                                          expressionCodegen);
     }
@@ -165,7 +166,7 @@ public abstract class CodegenContext {
             FunctionDescriptor funDescriptor,
             ExpressionCodegen expressionCodegen
     ) {
-        final JetTypeMapper typeMapper = expressionCodegen.getState().getInjector().getJetTypeMapper();
+        final JetTypeMapper typeMapper = expressionCodegen.getState().getTypeMapper();
         return new ClosureContext(typeMapper, funDescriptor,
                                   typeMapper.getBindingContext().get(CLASS_FOR_FUNCTION, funDescriptor),
                                   this, expressionCodegen);

compiler/backend/src/org/jetbrains/jet/codegen/context/EnclosedValueDescriptor.java

@@ -21,7 +21,7 @@ package org.jetbrains.jet.codegen.context;
 
 import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 

compiler/backend/src/org/jetbrains/jet/codegen/context/LocalLookup.java

@@ -18,6 +18,7 @@ package org.jetbrains.jet.codegen.context;
 
 import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.JetElement;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
@@ -52,8 +53,8 @@ public interface LocalLookup {
                 final boolean idx = localLookup != null && localLookup.lookupLocal(vd);
                 if (!idx) return null;
 
-                final Type sharedVarType = state.getInjector().getJetTypeMapper().getSharedVarType(vd);
+                final Type sharedVarType = state.getTypeMapper().getSharedVarType(vd);
-                Type localType = state.getInjector().getJetTypeMapper().mapType(vd.getType(), MapTypeMode.VALUE);
+                Type localType = state.getTypeMapper().mapType(vd.getType(), MapTypeMode.VALUE);
                 final Type type = sharedVarType != null ? sharedVarType : localType;
 
                 final String fieldName = "$" + vd.getName();
@@ -117,7 +118,7 @@ public interface LocalLookup {
                 if (closure.getEnclosingReceiverDescriptor() != d) return null;
 
                 final JetType receiverType = ((CallableDescriptor) d).getReceiverParameter().getType();
-                Type type = state.getInjector().getJetTypeMapper().mapType(receiverType, MapTypeMode.VALUE);
+                Type type = state.getTypeMapper().mapType(receiverType, MapTypeMode.VALUE);
                 StackValue innerValue = StackValue.field(type, className, CodegenUtil.RECEIVER$0, false);
                 closure.setCaptureReceiver();
 

compiler/backend/src/org/jetbrains/jet/codegen/context/MethodContext.java

@@ -19,7 +19,7 @@ package org.jetbrains.jet.codegen.context;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.codegen.AsmTypeConstants;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.OwnerKind;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayGet.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIndices.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArrayIterator.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.psi.JetCallExpression;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArraySet.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ArraySize.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/BinaryOp.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/CompareTo.java

@@ -22,7 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.psi.JetExpression;
 

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Concat.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/EmptyRange.java

@@ -22,7 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/EnumName.java

@@ -22,6 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/EnumOrdinal.java

@@ -22,6 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/EnumValueOf.java

@@ -22,6 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.psi.JetCallExpression;
 import org.jetbrains.jet.lang.psi.JetExpression;
@@ -47,7 +48,7 @@ public class EnumValueOf implements IntrinsicMethod {
         CallableDescriptor resultingDescriptor = resolvedCall.getResultingDescriptor();
         JetType returnType = resultingDescriptor.getReturnType();
         assert returnType != null;
-        Type type = state.getInjector().getJetTypeMapper().mapType(
+        Type type = state.getTypeMapper().mapType(
                 returnType, MapTypeMode.VALUE);
         assert arguments != null;
         codegen.gen(arguments.get(0), AsmTypeConstants.JAVA_STRING_TYPE);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/EnumValues.java

@@ -22,7 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.MapTypeMode;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
@@ -50,7 +50,7 @@ public class EnumValues implements IntrinsicMethod {
         CallableDescriptor resultingDescriptor = resolvedCall.getResultingDescriptor();
         JetType returnType = resultingDescriptor.getReturnType();
         assert returnType != null;
-        Type type = state.getInjector().getJetTypeMapper().mapType(
+        Type type = state.getTypeMapper().mapType(
                 returnType, MapTypeMode.VALUE);
         v.invokestatic(type.getElementType().getInternalName(), "values", "()" + type);
         StackValue.onStack(type).put(expectedType, v);

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Equals.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetCallExpression;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.BindingContext;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/HashCode.java

@@ -23,6 +23,7 @@ import org.jetbrains.asm4.Opcodes;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IdentityEquals.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetBinaryExpression;
 import org.jetbrains.jet.lang.psi.JetCallExpression;
 import org.jetbrains.jet.lang.psi.JetExpression;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Increment.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetParenthesizedExpression;
 import org.jetbrains.jet.lang.psi.JetReferenceExpression;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethod.java

@@ -23,7 +23,7 @@ import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.Callable;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.psi.JetExpression;
 

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Inv.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IteratorIterator.java

@@ -22,7 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.psi.JetExpression;
 

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IteratorNext.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassArray.java

@@ -22,7 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassFunction.java

@@ -22,6 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.psi.JetCallExpression;
 import org.jetbrains.jet.lang.psi.JetExpression;
@@ -48,7 +49,7 @@ public class JavaClassFunction implements IntrinsicMethod {
         CallableDescriptor resultingDescriptor = resolvedCall.getResultingDescriptor();
         JetType returnType = resultingDescriptor.getReturnType();
         assert returnType != null;
-        Type type = state.getInjector().getJetTypeMapper().mapType(
+        Type type = state.getTypeMapper().mapType(
                 returnType.getArguments().get(0).getType(), MapTypeMode.VALUE);
         JvmPrimitiveType primitiveType = JvmPrimitiveType.getByAsmType(type);
         if (primitiveType != null) {

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/JavaClassProperty.java

@@ -22,6 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType;
 

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/NewArray.java

@@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.psi.JetCallExpression;
 import org.jetbrains.jet.lang.psi.JetExpression;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Not.java

@@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.psi.JetExpression;
 

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/NumberCast.java

@@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.psi.JetExpression;
 

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/PsiMethodCall.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
 import org.jetbrains.jet.lang.psi.JetCallExpression;
 import org.jetbrains.jet.lang.psi.JetExpression;
@@ -44,7 +45,7 @@ public class PsiMethodCall implements IntrinsicMethod {
             List<JetExpression> arguments, StackValue receiver, @NotNull GenerationState state
     ) {
         final CallableMethod callableMethod =
-                state.getInjector().getJetTypeMapper().mapToCallableMethod(method, false, OwnerKind.IMPLEMENTATION);
+                state.getTypeMapper().mapToCallableMethod(method, false, OwnerKind.IMPLEMENTATION);
         codegen.invokeMethodWithArguments(callableMethod, (JetCallExpression) element, receiver);
         return StackValue.onStack(callableMethod.getSignature().getAsmMethod().getReturnType());
     }

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/RangeTo.java

@@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.psi.JetBinaryExpression;
 import org.jetbrains.jet.lang.psi.JetExpression;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StringGetChar.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StringLength.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StringPlus.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/StupidSync.java

@@ -22,6 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetCallExpression;
 import org.jetbrains.jet.lang.psi.JetExpression;
 

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/Sure.java

@@ -22,7 +22,7 @@ import org.jetbrains.asm4.Label;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.ExpressionCodegen;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.StackValue;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.psi.JetCallExpression;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/ToString.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/UnaryMinus.java

@@ -21,6 +21,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/UnaryPlus.java

@@ -22,6 +22,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.asm4.Type;
 import org.jetbrains.asm4.commons.InstructionAdapter;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetExpression;
 
 import java.util.List;

compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java

@@ -0,0 +1,182 @@
+/*
+ * Copyright 2010-2012 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.
+ */
+
+/*
+ * @author max
+ * @author alex.tkachman
+ */
+package org.jetbrains.jet.codegen.state;
+
+import com.intellij.openapi.project.Project;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.analyzer.AnalyzeExhaust;
+import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.context.CodegenBinding;
+import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods;
+import org.jetbrains.jet.di.InjectorForJvmCodegen;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
+import org.jetbrains.jet.utils.Progress;
+
+import java.util.List;
+
+public class GenerationState {
+    private boolean used = false;
+
+    @NotNull
+    private final Progress progress;
+
+    @NotNull
+    private final List<JetFile> files;
+
+    @NotNull
+    private final ClassBuilderMode classBuilderMode;
+
+    @NotNull
+    private final BindingContext bindingContext;
+
+    @NotNull
+    private final ClassFileFactory classFileFactory;
+
+    @NotNull
+    private final ScriptCodegen scriptCodegen;
+
+    @NotNull
+    private final Project project;
+
+    @NotNull
+    private final IntrinsicMethods intrinsics;
+
+    @NotNull
+    private final BindingTrace bindingTrace;
+
+    @NotNull
+    private final JetTypeMapper typeMapper;
+
+    @NotNull
+    private final MemberCodegen memberCodegen;
+
+    @NotNull
+    private final ClassCodegen classCodegen;
+
+    public GenerationState(Project project, ClassBuilderFactory builderFactory, AnalyzeExhaust analyzeExhaust, List<JetFile> files) {
+        this(project, builderFactory, Progress.DEAF, analyzeExhaust, files, BuiltinToJavaTypesMapping.ENABLED);
+    }
+
+    public GenerationState(
+            @NotNull Project project,
+            ClassBuilderFactory builderFactory, Progress progress,
+            @NotNull AnalyzeExhaust exhaust, @NotNull List<JetFile> files, @NotNull BuiltinToJavaTypesMapping builtinToJavaTypesMapping
+    ) {
+        this.progress = progress;
+        this.files = files;
+        this.classBuilderMode = builderFactory.getClassBuilderMode();
+
+        final DelegatingBindingTrace trace = new DelegatingBindingTrace(exhaust.getBindingContext());
+        this.bindingContext = trace.getBindingContext();
+
+        InjectorForJvmCodegen injector = new InjectorForJvmCodegen(
+                trace,
+                this.files, builtinToJavaTypesMapping, builderFactory.getClassBuilderMode(), this, builderFactory, project);
+        this.classFileFactory = injector.getClassFileFactory();
+        this.scriptCodegen = injector.getScriptCodegen();
+        this.bindingTrace = injector.getBindingTrace();
+        this.typeMapper = injector.getJetTypeMapper();
+        this.memberCodegen = injector.getMemberCodegen();
+        this.classCodegen = injector.getClassCodegen();
+        this.intrinsics = injector.getIntrinsics();
+        this.project = injector.getProject();
+    }
+
+    @NotNull
+    public ClassFileFactory getFactory() {
+        return classFileFactory;
+    }
+
+    @NotNull
+    public Progress getProgress() {
+        return progress;
+    }
+
+    @NotNull
+    public BindingContext getBindingContext() {
+        return bindingContext;
+    }
+
+    @NotNull
+    public ClassBuilderMode getClassBuilderMode() {
+        return classBuilderMode;
+    }
+
+    @NotNull
+    public List<JetFile> getFiles() {
+        return files;
+    }
+
+    @NotNull
+    public ScriptCodegen getScriptCodegen() {
+        return scriptCodegen;
+    }
+
+    @NotNull
+    public BindingTrace getBindingTrace() {
+        return bindingTrace;
+    }
+
+    @NotNull
+    public JetTypeMapper getTypeMapper() {
+        return typeMapper;
+    }
+
+    @NotNull
+    public Project getProject() {
+        return project;
+    }
+
+    @NotNull
+    public IntrinsicMethods getIntrinsics() {
+        return intrinsics;
+    }
+
+    @NotNull
+    public MemberCodegen getMemberCodegen() {
+        return memberCodegen;
+    }
+
+    @NotNull
+    public ClassCodegen getClassCodegen() {
+        return classCodegen;
+    }
+
+    public void beforeCompile() {
+        markUsed();
+
+        //noinspection unchecked
+        CodegenBinding.initTrace(getBindingTrace(), getFiles());
+    }
+
+    private void markUsed() {
+        if (used) {
+            throw new IllegalStateException(GenerationState.class + " cannot be used more than once");
+        }
+        used = true;
+    }
+
+    public void destroy() {
+    }
+}

compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationStrategy.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2010-2012 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.jet.codegen.state;
+
+import com.intellij.openapi.util.Pair;
+import com.intellij.util.containers.MultiMap;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.codegen.CompilationErrorHandler;
+import org.jetbrains.jet.codegen.NamespaceCodegen;
+import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.psi.JetPsiUtil;
+import org.jetbrains.jet.lang.psi.JetScript;
+import org.jetbrains.jet.lang.resolve.ScriptNameUtil;
+import org.jetbrains.jet.lang.resolve.java.JvmClassName;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+
+import static org.jetbrains.jet.codegen.context.CodegenBinding.registerClassNameForScript;
+
+/**
+ * @author alex.tkachman
+ */
+public class GenerationStrategy {
+    public static final GenerationStrategy STANDARD = new GenerationStrategy();
+
+    public void generateNamespace(GenerationState state,
+            FqName fqName,
+            Collection<JetFile> jetFiles,
+            CompilationErrorHandler errorHandler
+    ) {
+        NamespaceCodegen codegen = state.getFactory().forNamespace(fqName, jetFiles);
+        codegen.generate(errorHandler, state.getProgress());
+    }
+
+    public final void compileCorrectFiles(GenerationState state, @NotNull CompilationErrorHandler errorHandler) {
+        for (JetFile file : state.getFiles()) {
+            if (file.isScript()) {
+                String name = ScriptNameUtil.classNameForScript(file);
+                JetScript script = file.getScript();
+                assert script != null;
+                registerClassNameForScript(state.getBindingTrace(), script, JvmClassName.byInternalName(name));
+            }
+        }
+
+        state.getScriptCodegen().registerEarlierScripts(Collections.<Pair<ScriptDescriptor, JvmClassName>>emptyList());
+
+        state.beforeCompile();
+
+        MultiMap<FqName, JetFile> namespaceGrouping = new MultiMap<FqName, JetFile>();
+        for (JetFile file : state.getFiles()) {
+            if (file == null) throw new IllegalArgumentException("A null file given for compilation");
+            namespaceGrouping.putValue(JetPsiUtil.getFQName(file), file);
+        }
+
+        for (Map.Entry<FqName, Collection<JetFile>> entry : namespaceGrouping.entrySet()) {
+            generateNamespace(state, entry.getKey(), entry.getValue(), errorHandler);
+        }
+    }
+}

compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java

@@ -23,7 +23,7 @@ import java.util.List;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.codegen.BuiltinToJavaTypesMapping;
 import org.jetbrains.jet.codegen.ClassBuilderMode;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.ClassBuilderFactory;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.codegen.JetTypeMapper;

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

@@ -29,7 +29,7 @@ import org.jetbrains.jet.cli.common.messages.MessageCollector;
 import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.jet.codegen.ClassFileFactory;
 import org.jetbrains.jet.codegen.GeneratedClassLoader;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.lang.resolve.java.JvmAbi;

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

@@ -34,6 +34,8 @@ import org.jetbrains.jet.cli.common.CompilerPluginContext;
 import org.jetbrains.jet.cli.common.messages.*;
 import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationStrategy;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
@@ -344,7 +346,7 @@ public class KotlinToJVMBytecodeCompiler {
                                                               environment.getConfiguration().get(
                                                                       JVMConfigurationKeys.BUILTIN_TO_JAVA_TYPES_MAPPING_KEY,
                                                                       BuiltinToJavaTypesMapping.ENABLED));
-        generationState.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
+        GenerationStrategy.STANDARD.compileCorrectFiles(generationState, CompilationErrorHandler.THROW_EXCEPTION);
 
         CompilerPluginContext context = new CompilerPluginContext(project, exhaust.getBindingContext(), environment.getSourceFiles());
         for (CompilerPlugin plugin : environment.getConfiguration().getList(CLIConfigurationKeys.COMPILER_PLUGINS)) {

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

@@ -35,10 +35,8 @@ 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.JetCoreEnvironment;
-import org.jetbrains.jet.codegen.BuiltinToJavaTypesMapping;
+import org.jetbrains.jet.codegen.*;
-import org.jetbrains.jet.codegen.ClassBuilderFactories;
+import org.jetbrains.jet.codegen.state.GenerationState;
-import org.jetbrains.jet.codegen.CompilationErrorHandler;
-import org.jetbrains.jet.codegen.GenerationState;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
@@ -239,7 +237,8 @@ public class ReplInterpreter {
         GenerationState generationState = new GenerationState(psiFile.getProject(), ClassBuilderFactories.binaries(false), backendProgress,
                 AnalyzeExhaust.success(trace.getBindingContext()), Collections.singletonList(psiFile),
                 BuiltinToJavaTypesMapping.ENABLED);
-        generationState.compileScript(psiFile.getScript(), scriptClassName, earierScripts, CompilationErrorHandler.THROW_EXCEPTION);
+        generationState.getScriptCodegen().compileScript(psiFile.getScript(), scriptClassName, earierScripts,
+                                                         CompilationErrorHandler.THROW_EXCEPTION);
 
         for (String file : generationState.getFactory().files()) {
             classLoader.addClass(JvmClassName.byInternalName(file.replaceFirst("\\.class$", "")), generationState.getFactory().asBytes(file));

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/JetLightClass.java

@@ -27,13 +27,10 @@ import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Key;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.PsiClassImplUtil;
-import com.intellij.psi.impl.PsiManagerImpl;
-import com.intellij.psi.impl.compiled.ClsFileImpl;
 import com.intellij.psi.impl.java.stubs.PsiClassStub;
 import com.intellij.psi.impl.java.stubs.PsiJavaFileStub;
 import com.intellij.psi.impl.java.stubs.impl.PsiJavaFileStubImpl;
 import com.intellij.psi.impl.light.AbstractLightClass;
-import com.intellij.psi.stubs.PsiClassHolderFileStub;
 import com.intellij.psi.stubs.PsiFileStub;
 import com.intellij.psi.stubs.StubElement;
 import com.intellij.psi.util.*;
@@ -41,6 +38,8 @@ import com.intellij.util.containers.Stack;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.codegen.*;
+import org.jetbrains.jet.codegen.state.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationStrategy;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.psi.JetClass;
 import org.jetbrains.jet.lang.psi.JetFile;
@@ -51,14 +50,11 @@ import org.jetbrains.jet.lang.resolve.java.JetFilesProvider;
 import org.jetbrains.jet.lang.resolve.java.JetJavaMirrorMarker;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.plugin.JetLanguage;
-import org.jetbrains.jet.utils.Progress;
 
 import javax.swing.*;
-import java.util.Collection;
 import java.util.Collections;
 
 public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMarker {
-    private static final Logger LOG = Logger.getInstance("#org.jetbrains.jet.asJava.JetLightClass");
     private final static Key<CachedValue<PsiJavaFileStub>> JAVA_API_STUB = Key.create("JAVA_API_STUB");
 
     private final JetFile file;
@@ -179,34 +175,10 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
             throw new IllegalStateException("failed to analyze: " + context.getError(), context.getError());
         }
 
-        final GenerationState state = new GenerationState(project, builderFactory, context, Collections.singletonList(file)) {
+        final GenerationState state = new GenerationState(project, builderFactory, context, Collections.singletonList(file));
-            @Override
+        final GenerationStrategy strategy = new LightClassGenerationStrategy(this, stubStack, answer);
-            protected void generateNamespace(FqName fqName, Collection<JetFile> namespaceFiles, CompilationErrorHandler errorHandler, Progress progress) {
-                PsiManager manager = PsiManager.getInstance(project);
-                stubStack.push(answer);
 
-                answer.setPsiFactory(new ClsWrapperStubPsiFactory());
+        strategy.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION);
-                final ClsFileImpl fakeFile =
-                    new ClsFileImpl((PsiManagerImpl)manager, new ClassFileViewProvider(manager, file.getVirtualFile())) {
-                        @NotNull
-                        @Override
-                        public PsiClassHolderFileStub getStub() {
-                            return answer;
-                        }
-                    };
-
-                fakeFile.setPhysical(false);
-                answer.setPsi(fakeFile);
-
-                super.generateNamespace(fqName, namespaceFiles, errorHandler, progress);
-                final StubElement pop = stubStack.pop();
-                if (pop != answer) {
-                    LOG.error("Unbalanced stack operations: " + pop);
-                }
-            }
-        };
-
-        state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
         state.getFactory().files();
 
         return answer;
@@ -275,4 +247,8 @@ public class JetLightClass extends AbstractLightClass implements JetJavaMirrorMa
         }
         return null;
     }
+
+    public JetFile getFile() {
+        return file;
+    }
 }

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/LightClassGenerationStrategy.java

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2010-2012 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.jet.asJava;
+
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.psi.ClassFileViewProvider;
+import com.intellij.psi.PsiManager;
+import com.intellij.psi.impl.PsiManagerImpl;
+import com.intellij.psi.impl.compiled.ClsFileImpl;
+import com.intellij.psi.impl.java.stubs.impl.PsiJavaFileStubImpl;
+import com.intellij.psi.stubs.PsiClassHolderFileStub;
+import com.intellij.psi.stubs.StubElement;
+import com.intellij.util.containers.Stack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.codegen.CompilationErrorHandler;
+import org.jetbrains.jet.codegen.state.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationStrategy;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+
+import java.util.Collection;
+
+/**
+ * @author alex.tkachman
+*/
+class LightClassGenerationStrategy extends GenerationStrategy {
+    private static final Logger LOG = Logger.getInstance("#org.jetbrains.jet.asJava.LightClassGenerationStrategy");
+
+    private final Stack<StubElement> stubStack;
+    private final PsiJavaFileStubImpl answer;
+    private final JetLightClass theClass;
+
+    public LightClassGenerationStrategy(JetLightClass aClass, Stack<StubElement> stubStack, PsiJavaFileStubImpl answer) {
+        this.theClass = aClass;
+        this.stubStack = stubStack;
+        this.answer = answer;
+    }
+
+    @Override
+    public void generateNamespace(
+            GenerationState state,
+            FqName fqName,
+            Collection<JetFile> namespaceFiles,
+            CompilationErrorHandler errorHandler
+    ) {
+        PsiManager manager = PsiManager.getInstance(state.getProject());
+        stubStack.push(answer);
+
+        answer.setPsiFactory(new ClsWrapperStubPsiFactory());
+        final ClsFileImpl fakeFile =
+                new ClsFileImpl((PsiManagerImpl) manager, new ClassFileViewProvider(manager, theClass.getFile().getVirtualFile())) {
+                    @NotNull
+                    @Override
+                    public PsiClassHolderFileStub getStub() {
+                        return answer;
+                    }
+                };
+
+        fakeFile.setPhysical(false);
+        answer.setPsi(fakeFile);
+
+        super.generateNamespace(state, fqName, namespaceFiles, errorHandler);
+        final StubElement pop = stubStack.pop();
+        if (pop != answer) {
+            LOG.error("Unbalanced stack operations: " + pop);
+        }
+    }
+}

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

@@ -29,6 +29,8 @@ import org.jetbrains.jet.CompileCompilerDependenciesTest;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.TestJdkKind;
 import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys;
+import org.jetbrains.jet.codegen.state.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationStrategy;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.resolve.ScriptNameUtil;
 import org.jetbrains.jet.utils.ExceptionUtils;
@@ -213,7 +215,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
                 String scriptClassName = ScriptNameUtil.classNameForScript(myFiles.getPsiFile());
                 Class<?> scriptClass = loader.loadClass(scriptClassName);
 
-                Constructor constructor = getConstructor(scriptClass, state.getScriptConstructorMethod());
+                Constructor constructor = getConstructor(scriptClass, state.getScriptCodegen().getScriptConstructorMethod());
                 scriptInstance = constructor.newInstance(myFiles.getScriptParameterValues().toArray());
 
                 assertFalse("expecting at least one expectation", myFiles.getExpectedValues().isEmpty());
@@ -291,7 +293,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
     protected String generateToText() {
         if(alreadyGenerated == null)
             alreadyGenerated = generateCommon(ClassBuilderFactories.TEST);
-        return alreadyGenerated.createText();
+        return alreadyGenerated.getFactory().createText();
     }
 
     private GenerationState generateCommon(ClassBuilderFactory classBuilderFactory) {
@@ -307,7 +309,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
         analyzeExhaust.throwIfError();
         AnalyzingUtils.throwExceptionOnErrors(analyzeExhaust.getBindingContext());
         alreadyGenerated = new GenerationState(myEnvironment.getProject(), classBuilderFactory, analyzeExhaust, myFiles.getPsiFiles());
-        alreadyGenerated.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
+        GenerationStrategy.STANDARD.compileCorrectFiles(alreadyGenerated, CompilationErrorHandler.THROW_EXCEPTION);
         return alreadyGenerated;
     }
 

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

@@ -21,6 +21,8 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.PsiFile;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
+import org.jetbrains.jet.codegen.state.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationStrategy;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
@@ -29,6 +31,8 @@ import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
 import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.jet.codegen.context.CodegenBinding.registerClassNameForScript;
+
 /**
  * @author Stepan Koltsov
  */
@@ -61,7 +65,7 @@ public class GenerationUtils {
     public static GenerationState compileFilesGetGenerationState(@NotNull Project project, @NotNull AnalyzeExhaust analyzeExhaust, @NotNull List<JetFile> files) {
         analyzeExhaust.throwIfError();
         GenerationState state = new GenerationState(project, ClassBuilderFactories.TEST, analyzeExhaust, files);
-        state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
+        GenerationStrategy.STANDARD.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION);
         return state;
     }
 }

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

@@ -27,6 +27,7 @@ import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.TestJdkKind;
 import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.parsing.JetParsingTest;
 import org.jetbrains.jet.test.TestCaseWithTmpdir;
@@ -91,7 +92,7 @@ public class LineNumberTest extends TestCaseWithTmpdir {
                 actualLineNumbers.addAll(readLineNumbers(cr));
             }
             catch (Throwable e) {
-                System.out.println(state.createText());
+                System.out.println(state.getFactory().createText());
                 throw ExceptionUtils.rethrow(e);
             }
         }

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

@@ -30,6 +30,7 @@ import org.jetbrains.jet.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.cli.jvm.compiler.KotlinToJVMBytecodeCompiler;
 import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
@@ -91,7 +92,7 @@ public class TestlibTest extends CodegenTestCase {
                     new URLClassLoader(new URL[]{ForTestCompileRuntime.runtimeJarForTests().toURI().toURL(), junitJar.toURI().toURL()},
                                        TestCase.class.getClassLoader()));
 
-            JetTypeMapper typeMapper = generationState.getInjector().getJetTypeMapper();
+            JetTypeMapper typeMapper = generationState.getTypeMapper();
             TestSuite suite = new TestSuite("stdlib_test");
             try {
                 for(JetFile jetFile : myEnvironment.getSourceFiles()) {

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

@@ -28,7 +28,7 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust;
 import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
 import org.jetbrains.jet.codegen.ClassFileFactory;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.GenerationUtils;
 import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.jet.config.CompilerConfiguration;

idea/src/org/jetbrains/jet/plugin/internal/codewindow/BytecodeToolwindow.java

@@ -34,10 +34,9 @@ import com.intellij.openapi.util.Pair;
 import com.intellij.util.Alarm;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
-import org.jetbrains.jet.codegen.ClassBuilderFactories;
+import org.jetbrains.jet.codegen.*;
-import org.jetbrains.jet.codegen.ClassFileFactory;
+import org.jetbrains.jet.codegen.state.GenerationState;
-import org.jetbrains.jet.codegen.CompilationErrorHandler;
+import org.jetbrains.jet.codegen.state.GenerationStrategy;
-import org.jetbrains.jet.codegen.GenerationState;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.plugin.internal.Location;
 import org.jetbrains.jet.plugin.project.WholeProjectAnalyzerFacade;
@@ -96,7 +95,7 @@ public class BytecodeToolwindow extends JPanel implements Disposable {
                     return printStackTraceToString(binding.getError());
                 }
                 state = new GenerationState(jetFile.getProject(), ClassBuilderFactories.TEXT, binding, Collections.singletonList(jetFile));
-                state.compileCorrectFiles(CompilationErrorHandler.THROW_EXCEPTION);
+                GenerationStrategy.STANDARD.compileCorrectFiles(state, CompilationErrorHandler.THROW_EXCEPTION);
             }
             catch (ProcessCanceledException e) {
                 throw e;

idea/tests/org/jetbrains/jet/plugin/debugger/JetPositionManagerTest.java

@@ -18,7 +18,7 @@ package org.jetbrains.jet.plugin.debugger;
 
 import com.intellij.debugger.engine.DebugProcess;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.JetTypeMapper;
 import org.jetbrains.jet.codegen.context.CodegenBinding;
 import org.jetbrains.jet.di.InjectorForJetTypeMapper;

idea/tests/org/jetbrains/jet/plugin/debugger/PositionManagerTestCase.java

@@ -32,7 +32,7 @@ import com.sun.jdi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.codegen.ClassFileFactory;
-import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.codegen.GenerationUtils;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.utils.ExceptionUtils;

injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java

@@ -19,6 +19,7 @@ package org.jetbrains.jet.di;
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.codegen.*;
 import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods;
+import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.ModuleConfiguration;
 import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;