(BindingContext,BindingTrace,TypeMapper,GenerationState)Aware classes introduced and related changes in GenerationState construction/injection

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

@@ -16,8 +16,10 @@
 
 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.codegen.state.GenerationStateAware;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
@@ -32,22 +34,11 @@ import static org.jetbrains.jet.codegen.context.CodegenBinding.enumEntryNeedSubc
  * @author max
  * @author alex.tkachman
  */
-public class ClassCodegen {
+public class ClassCodegen extends GenerationStateAware {
-    private GenerationState state;
+    public ClassCodegen(@NotNull GenerationState state) {
-    @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"}) private JetTypeMapper jetTypeMapper;
+        super(state);
-
-    @Inject
-    public void setState(GenerationState state) {
-        this.state = state;
     }
 
-    @SuppressWarnings("UnusedParameters")
-    @Inject
-    public void setJetTypeMapper(JetTypeMapper jetTypeMapper) {
-        this.jetTypeMapper = jetTypeMapper;
-    }
-
-
     public void generate(CodegenContext context, JetClassOrObject aClass) {
         ClassDescriptor descriptor = state.getBindingContext().get(BindingContext.CLASS, aClass);
         ClassBuilder classBuilder = state.getFactory().forClassImplementation(descriptor);

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

@@ -18,6 +18,7 @@ package org.jetbrains.jet.codegen;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.codegen.state.GenerationState;
+import org.jetbrains.jet.codegen.state.GenerationStateAware;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -29,24 +30,21 @@ import java.util.*;
  * @author max
  * @author alex.tkachman
  */
-public final class ClassFileFactory {
+public final class ClassFileFactory extends GenerationStateAware {
-    private ClassBuilderFactory builderFactory;
+    @NotNull private ClassBuilderFactory builderFactory;
-    private GenerationState state;
-
 
     private final Map<FqName, NamespaceCodegen> ns2codegen = new HashMap<FqName, NamespaceCodegen>();
     private final Map<String, ClassBuilder> generators = new LinkedHashMap<String, ClassBuilder>();
     private boolean isDone = false;
 
-
+    public ClassFileFactory(@NotNull GenerationState state) {
-    @Inject
+        super(state);
-    public void setBuilderFactory(ClassBuilderFactory builderFactory) {
-        this.builderFactory = builderFactory;
     }
 
+
     @Inject
-    public void setState(GenerationState state) {
+    public void setBuilderFactory(@NotNull ClassBuilderFactory builderFactory) {
-        this.state = state;
+        this.builderFactory = builderFactory;
     }
 
     ClassBuilder newVisitor(String filePath) {

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

@@ -23,6 +23,7 @@ import org.jetbrains.asm4.Type;
 import org.jetbrains.jet.codegen.context.CalculatedClosure;
 import org.jetbrains.jet.codegen.context.EnclosedValueDescriptor;
 import org.jetbrains.jet.codegen.signature.*;
+import org.jetbrains.jet.codegen.state.BindingTraceAware;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.JetDelegatorToSuperCall;
 import org.jetbrains.jet.lang.psi.JetElement;
@@ -51,35 +52,15 @@ import static org.jetbrains.jet.lang.resolve.BindingContextUtils.descriptorToDec
  * @author yole
  * @author alex.tkachman
  */
-public class JetTypeMapper {
+public class JetTypeMapper extends BindingTraceAware {
 
-    private BindingContext bindingContext;
+    private final boolean mapBuiltinsToJava;
-    private boolean mapBuiltinsToJava;
+    private final ClassBuilderMode classBuilderMode;
-    private ClassBuilderMode classBuilderMode;
-    private BindingTrace bindingTrace;
 
-    @Inject
+    public JetTypeMapper(BindingTrace bindingTrace, boolean mapBuiltinsToJava, ClassBuilderMode mode) {
-    public void setBindingTrace(BindingTrace bindingTrace) {
+        super(bindingTrace);
-        this.bindingTrace = bindingTrace;
+        this.mapBuiltinsToJava = mapBuiltinsToJava;
-        this.bindingContext = bindingTrace.getBindingContext();
+        classBuilderMode = mode;
-    }
-
-    @Inject
-    public void setBuiltinToJavaTypesMapping(BuiltinToJavaTypesMapping builtinToJavaTypesMapping) {
-        mapBuiltinsToJava = builtinToJavaTypesMapping == BuiltinToJavaTypesMapping.ENABLED;
-    }
-
-    @Inject
-    public void setClassBuilderMode(ClassBuilderMode classBuilderMode) {
-        this.classBuilderMode = classBuilderMode;
-    }
-
-    public BindingTrace getBindingTrace() {
-        return bindingTrace;
-    }
-
-    public BindingContext getBindingContext() {
-        return bindingContext;
     }
 
     @NotNull

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

@@ -19,6 +19,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.codegen.state.GenerationStateAware;
 import org.jetbrains.jet.lang.psi.JetNamedFunction;
 import org.jetbrains.jet.lang.psi.JetProperty;
 import org.jetbrains.jet.lang.psi.JetTypeParameterListOwner;
@@ -28,17 +29,12 @@ import javax.inject.Inject;
 /**
  * @author Stepan Koltsov
  */
-public class MemberCodegen {
+public class MemberCodegen extends GenerationStateAware {
 
-    @NotNull
+    public MemberCodegen(@NotNull GenerationState state) {
-    private GenerationState state;
+        super(state);
-
-    @Inject
-    public void setState(@NotNull GenerationState state) {
-        this.state = state;
     }
 
-
     public void generateFunctionOrProperty(
             @NotNull JetTypeParameterListOwner functionOrProperty,
             @NotNull CodegenContext context, @NotNull ClassBuilder classBuilder

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

@@ -27,6 +27,7 @@ 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.GenerationStateAware;
 import org.jetbrains.jet.codegen.state.GenerationStrategy;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
@@ -47,26 +48,18 @@ import static org.jetbrains.jet.codegen.context.CodegenBinding.*;
 /**
  * @author Stepan Koltsov
  */
-public class ScriptCodegen {
+public class ScriptCodegen extends GenerationStateAware {
 
-    @NotNull
-    private GenerationState state;
     @NotNull
     private ClassFileFactory classFileFactory;
     @NotNull
-    private JetTypeMapper jetTypeMapper;
-    @NotNull
     private MemberCodegen memberCodegen;
-    @NotNull
-    private BindingContext bindingContext;
 
     private List<ScriptDescriptor> earlierScripts;
     private Method scriptConstructorMethod;
 
-
+    public ScriptCodegen(@NotNull GenerationState state) {
-    @Inject
+        super(state);
-    public void setState(@NotNull GenerationState state) {
-        this.state = state;
     }
 
     @Inject
@@ -74,22 +67,11 @@ public class ScriptCodegen {
         this.classFileFactory = classFileFactory;
     }
 
-    @Inject
-    public void setJetTypeMapper(@NotNull JetTypeMapper jetTypeMapper) {
-        this.jetTypeMapper = jetTypeMapper;
-    }
-
     @Inject
     public void setMemberCodegen(@NotNull MemberCodegen memberCodegen) {
         this.memberCodegen = memberCodegen;
     }
 
-    @Inject
-    public void setBindingContext(@NotNull BindingContext bindingContext) {
-        this.bindingContext = bindingContext;
-    }
-
-
     public void generate(JetScript scriptDeclaration) {
 
         ScriptDescriptor scriptDescriptor = state.getBindingContext().get(BindingContext.SCRIPT, scriptDeclaration);
@@ -132,12 +114,12 @@ public class ScriptCodegen {
             @NotNull List<ScriptDescriptor> importedScripts
     ) {
 
-        Type blockType = jetTypeMapper.mapType(scriptDescriptor.getReturnType(), MapTypeMode.VALUE);
+        Type blockType = typeMapper.mapType(scriptDescriptor.getReturnType(), MapTypeMode.VALUE);
 
         classBuilder.newField(null, ACC_PUBLIC | ACC_FINAL, ScriptNameUtil.LAST_EXPRESSION_VALUE_FIELD_NAME,
                               blockType.getDescriptor(), null, null);
 
-        JvmMethodSignature jvmSignature = jetTypeMapper.mapScriptSignature(scriptDescriptor, importedScripts);
+        JvmMethodSignature jvmSignature = typeMapper.mapScriptSignature(scriptDescriptor, importedScripts);
 
         state.getScriptCodegen().setScriptConstructorMethod(jvmSignature.getAsmMethod());
 
@@ -157,7 +139,7 @@ public class ScriptCodegen {
 
         instructionAdapter.load(0, className.getAsmType());
 
-        FrameMap frameMap = context.prepareFrame(jetTypeMapper);
+        FrameMap frameMap = context.prepareFrame(typeMapper);
 
         for (ScriptDescriptor importedScript : importedScripts) {
             frameMap.enter(importedScript, OBJECT_TYPE);
@@ -176,7 +158,7 @@ public class ScriptCodegen {
                 instructionAdapter,
                 scriptDeclaration.getDeclarations(),
                 bindingContext,
-                jetTypeMapper);
+                typeMapper);
 
         int offset = 1;
 
@@ -190,7 +172,7 @@ public class ScriptCodegen {
         }
 
         for (ValueParameterDescriptor parameter : scriptDescriptor.getValueParameters()) {
-            Type parameterType = jetTypeMapper.mapType(parameter.getType(), MapTypeMode.VALUE);
+            Type parameterType = typeMapper.mapType(parameter.getType(), MapTypeMode.VALUE);
             instructionAdapter.load(0, className.getAsmType());
             instructionAdapter.load(offset, parameterType);
             offset += parameterType.getSize();
@@ -219,7 +201,7 @@ public class ScriptCodegen {
         }
 
         for (ValueParameterDescriptor parameter : script.getValueParameters()) {
-            Type parameterType = jetTypeMapper.mapType(parameter.getType(), MapTypeMode.VALUE);
+            Type parameterType = typeMapper.mapType(parameter.getType(), MapTypeMode.VALUE);
             int access = ACC_PUBLIC | ACC_FINAL;
             classBuilder.newField(null, access, parameter.getName().getIdentifier(), parameterType.getDescriptor(), null, null);
         }

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

@@ -0,0 +1,36 @@
+/*
+ * 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 org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+
+/**
+ * @author alex.tkachman
+ */
+public class BindingContextAware {
+    @NotNull protected final BindingContext bindingContext;
+
+    public BindingContextAware(@NotNull BindingContext context) {
+        bindingContext = context;
+    }
+
+    @NotNull
+    public final BindingContext getBindingContext() {
+        return bindingContext;
+    }
+}

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

@@ -0,0 +1,36 @@
+/*
+ * 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 org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+
+/**
+ * @author alex.tkachman
+ */
+public class BindingTraceAware extends BindingContextAware {
+    @NotNull protected final BindingTrace bindingTrace;
+
+    public BindingTraceAware(@NotNull BindingTrace bindingTrace) {
+        super(bindingTrace.getBindingContext());
+        this.bindingTrace = bindingTrace;
+    }
+
+    @NotNull public final BindingTrace getBindingTrace() {
+        return bindingTrace;
+    }
+}

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

@@ -83,24 +83,25 @@ public class GenerationState {
             ClassBuilderFactory builderFactory, Progress progress,
             @NotNull AnalyzeExhaust exhaust, @NotNull List<JetFile> files, @NotNull BuiltinToJavaTypesMapping builtinToJavaTypesMapping
     ) {
+        this.project = project;
         this.progress = progress;
         this.files = files;
         this.classBuilderMode = builderFactory.getClassBuilderMode();
 
-        final DelegatingBindingTrace trace = new DelegatingBindingTrace(exhaust.getBindingContext());
+        bindingTrace = new DelegatingBindingTrace(exhaust.getBindingContext());
-        this.bindingContext = trace.getBindingContext();
+        bindingContext = bindingTrace.getBindingContext();
+
+        this.typeMapper = new JetTypeMapper(bindingTrace, builtinToJavaTypesMapping == BuiltinToJavaTypesMapping.ENABLED, classBuilderMode);
 
         InjectorForJvmCodegen injector = new InjectorForJvmCodegen(
-                trace,
+                typeMapper, this.files,
-                this.files, builtinToJavaTypesMapping, builderFactory.getClassBuilderMode(), this, builderFactory, project);
+                builtinToJavaTypesMapping, 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();
+        this.classFileFactory = injector.getClassFileFactory();
     }
 
     @NotNull

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

@@ -0,0 +1,32 @@
+/*
+ * 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 org.jetbrains.annotations.NotNull;
+
+public class GenerationStateAware extends TypeMapperAware {
+    @NotNull protected final GenerationState state;
+
+    public GenerationStateAware(@NotNull GenerationState state) {
+        super(state.getTypeMapper());
+        this.state = state;
+    }
+
+    @NotNull public GenerationState getState() {
+        return state;
+    }
+}

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

@@ -0,0 +1,36 @@
+/*
+ * 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 org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.codegen.JetTypeMapper;
+
+/**
+ * @author alex.tkachman
+ */
+public class TypeMapperAware extends BindingTraceAware {
+    @NotNull protected final JetTypeMapper typeMapper;
+
+    public TypeMapperAware(@NotNull JetTypeMapper typeMapper) {
+        super(typeMapper.getBindingTrace());
+        this.typeMapper = typeMapper;
+    }
+
+    @NotNull public JetTypeMapper getTypeMapper() {
+        return typeMapper;
+    }
+}

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

@@ -1,73 +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.
- */
-
-
-package org.jetbrains.jet.di;
-
-import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.BindingContext;
-import java.util.List;
-import org.jetbrains.jet.lang.psi.JetFile;
-import org.jetbrains.jet.codegen.JetTypeMapper;
-import org.jetbrains.jet.codegen.BuiltinToJavaTypesMapping;
-import org.jetbrains.jet.codegen.ClassBuilderMode;
-import org.jetbrains.annotations.NotNull;
-import javax.annotation.PreDestroy;
-
-/* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */
-public class InjectorForJetTypeMapper {
-
-    private final BindingTrace bindingTrace;
-    private BindingContext bindingContext;
-    private final List<JetFile> listOfJetFile;
-    private JetTypeMapper jetTypeMapper;
-    private BuiltinToJavaTypesMapping builtinToJavaTypesMapping;
-    private ClassBuilderMode classBuilderMode;
-
-    public InjectorForJetTypeMapper(
-        @NotNull BindingTrace bindingTrace,
-        @NotNull List<JetFile> listOfJetFile
-    ) {
-        this.bindingTrace = bindingTrace;
-        this.bindingContext = bindingTrace.getBindingContext();
-        this.listOfJetFile = listOfJetFile;
-        this.jetTypeMapper = new JetTypeMapper();
-        this.builtinToJavaTypesMapping = BuiltinToJavaTypesMapping.ENABLED;
-        this.classBuilderMode = ClassBuilderMode.FULL;
-
-        this.jetTypeMapper.setBindingTrace(bindingTrace);
-        this.jetTypeMapper.setBuiltinToJavaTypesMapping(builtinToJavaTypesMapping);
-        this.jetTypeMapper.setClassBuilderMode(classBuilderMode);
-
-    }
-
-    @PreDestroy
-    public void destroy() {
-    }
-
-    public BindingTrace getBindingTrace() {
-        return this.bindingTrace;
-    }
-
-    public List getListOfJetFile() {
-        return this.listOfJetFile;
-    }
-
-    public JetTypeMapper getJetTypeMapper() {
-        return this.jetTypeMapper;
-    }
-
-}

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

@@ -17,16 +17,16 @@
 
 package org.jetbrains.jet.di;
 
-import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.codegen.JetTypeMapper;
-import org.jetbrains.jet.lang.resolve.BindingContext;
 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.state.GenerationState;
 import org.jetbrains.jet.codegen.ClassBuilderFactory;
 import com.intellij.openapi.project.Project;
-import org.jetbrains.jet.codegen.JetTypeMapper;
+import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.codegen.ClassBuilderMode;
 import org.jetbrains.jet.codegen.ClassCodegen;
 import org.jetbrains.jet.codegen.ScriptCodegen;
 import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods;
@@ -38,15 +38,15 @@ import javax.annotation.PreDestroy;
 /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */
 public class InjectorForJvmCodegen {
 
-    private final BindingTrace bindingTrace;
+    private final JetTypeMapper jetTypeMapper;
-    private BindingContext bindingContext;
     private final List<JetFile> listOfJetFile;
     private final BuiltinToJavaTypesMapping builtinToJavaTypesMapping;
-    private final ClassBuilderMode classBuilderMode;
     private final GenerationState generationState;
     private final ClassBuilderFactory classBuilderFactory;
     private final Project project;
-    private JetTypeMapper jetTypeMapper;
+    private BindingTrace bindingTrace;
+    private BindingContext bindingContext;
+    private ClassBuilderMode classBuilderMode;
     private ClassCodegen classCodegen;
     private ScriptCodegen scriptCodegen;
     private IntrinsicMethods intrinsics;
@@ -54,46 +54,32 @@ public class InjectorForJvmCodegen {
     private MemberCodegen memberCodegen;
 
     public InjectorForJvmCodegen(
-        @NotNull BindingTrace bindingTrace,
+        @NotNull JetTypeMapper jetTypeMapper,
         @NotNull List<JetFile> listOfJetFile,
         @NotNull BuiltinToJavaTypesMapping builtinToJavaTypesMapping,
-        @NotNull ClassBuilderMode classBuilderMode,
         @NotNull GenerationState generationState,
         @NotNull ClassBuilderFactory classBuilderFactory,
         @NotNull Project project
     ) {
-        this.bindingTrace = bindingTrace;
+        this.jetTypeMapper = jetTypeMapper;
-        this.bindingContext = bindingTrace.getBindingContext();
         this.listOfJetFile = listOfJetFile;
         this.builtinToJavaTypesMapping = builtinToJavaTypesMapping;
-        this.classBuilderMode = classBuilderMode;
         this.generationState = generationState;
         this.classBuilderFactory = classBuilderFactory;
         this.project = project;
-        this.jetTypeMapper = new JetTypeMapper();
+        this.bindingTrace = jetTypeMapper.getBindingTrace();
-        this.classCodegen = new ClassCodegen();
+        this.bindingContext = bindingTrace.getBindingContext();
-        this.scriptCodegen = new ScriptCodegen();
+        this.classBuilderMode = classBuilderFactory.getClassBuilderMode();
+        this.classCodegen = new ClassCodegen(getGenerationState());
+        this.scriptCodegen = new ScriptCodegen(getGenerationState());
         this.intrinsics = new IntrinsicMethods();
-        this.classFileFactory = new ClassFileFactory();
+        this.classFileFactory = new ClassFileFactory(getGenerationState());
-        this.memberCodegen = new MemberCodegen();
+        this.memberCodegen = new MemberCodegen(getGenerationState());
 
-        this.jetTypeMapper.setBindingTrace(bindingTrace);
-        this.jetTypeMapper.setBuiltinToJavaTypesMapping(builtinToJavaTypesMapping);
-        this.jetTypeMapper.setClassBuilderMode(classBuilderMode);
-
-        this.classCodegen.setJetTypeMapper(jetTypeMapper);
-        this.classCodegen.setState(generationState);
-
-        this.scriptCodegen.setBindingContext(bindingContext);
         this.scriptCodegen.setClassFileFactory(classFileFactory);
-        this.scriptCodegen.setJetTypeMapper(jetTypeMapper);
         this.scriptCodegen.setMemberCodegen(memberCodegen);
-        this.scriptCodegen.setState(generationState);
 
         this.classFileFactory.setBuilderFactory(classBuilderFactory);
-        this.classFileFactory.setState(generationState);
-
-        this.memberCodegen.setState(generationState);
 
         intrinsics.init();
 
@@ -103,8 +89,8 @@ public class InjectorForJvmCodegen {
     public void destroy() {
     }
 
-    public BindingTrace getBindingTrace() {
+    public JetTypeMapper getJetTypeMapper() {
-        return this.bindingTrace;
+        return this.jetTypeMapper;
     }
 
     public List getListOfJetFile() {
@@ -119,10 +105,6 @@ public class InjectorForJvmCodegen {
         return this.project;
     }
 
-    public JetTypeMapper getJetTypeMapper() {
-        return this.jetTypeMapper;
-    }
-
     public ClassCodegen getClassCodegen() {
         return this.classCodegen;
     }

idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java

@@ -37,11 +37,11 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.jet.analyzer.AnalyzeExhaust;
+import org.jetbrains.jet.codegen.ClassBuilderMode;
 import org.jetbrains.jet.codegen.JetTypeMapper;
 import org.jetbrains.jet.codegen.MapTypeMode;
 import org.jetbrains.jet.codegen.NamespaceCodegen;
 import org.jetbrains.jet.codegen.context.CodegenBinding;
-import org.jetbrains.jet.di.InjectorForJetTypeMapper;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -206,10 +206,9 @@ public class JetPositionManager implements PositionManager {
                     List<JetFile> namespaceFiles = JetFilesProvider.getInstance(file.getProject()).allNamespaceFiles().fun(file);
 
                     final DelegatingBindingTrace bindingTrace = new DelegatingBindingTrace(analyzeExhaust.getBindingContext());
-                    final InjectorForJetTypeMapper injector = new InjectorForJetTypeMapper(bindingTrace, namespaceFiles);
+                    JetTypeMapper typeMapper = new JetTypeMapper(bindingTrace, true, ClassBuilderMode.FULL);
-                    JetTypeMapper typeMapper = injector.getJetTypeMapper();
                     //noinspection unchecked
-                    CodegenBinding.initTrace(bindingTrace, injector.getListOfJetFile());
+                    CodegenBinding.initTrace(bindingTrace, namespaceFiles);
                     return new Result<JetTypeMapper>(typeMapper, PsiModificationTracker.MODIFICATION_COUNT);
                 }
             }, false);

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

@@ -18,10 +18,10 @@ package org.jetbrains.jet.plugin.debugger;
 
 import com.intellij.debugger.engine.DebugProcess;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.codegen.ClassBuilderMode;
 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;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
 import org.jetbrains.jet.plugin.PluginTestCaseBase;
@@ -47,10 +47,9 @@ public class JetPositionManagerTest extends PositionManagerTestCase {
         assertNotNull(positionManager);
 
         final DelegatingBindingTrace bindingTrace = new DelegatingBindingTrace(state.getBindingContext());
-        final InjectorForJetTypeMapper injector = new InjectorForJetTypeMapper(bindingTrace, files);
+        JetTypeMapper typeMapper = new JetTypeMapper(bindingTrace, true, ClassBuilderMode.FULL);
-        JetTypeMapper typeMapper = injector.getJetTypeMapper();
         //noinspection unchecked
-        CodegenBinding.initTrace(bindingTrace, injector.getListOfJetFile());
+        CodegenBinding.initTrace(bindingTrace, files);
         for (JetFile file : files) {
             positionManager.addTypeMapper(file, typeMapper);
         }

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

@@ -57,7 +57,6 @@ public class AllInjectorsGenerator {
         generateTestInjector();
         generateInjectorForJavaSemanticServices();
         generateInjectorForJvmCodegen();
-        generateInjectorForJetTypeMapper();
         generateInjectorForLazyResolve();
         generateInjectorForBodyResolve();
     }
@@ -191,34 +190,29 @@ public class AllInjectorsGenerator {
 
     private static void generateInjectorForJvmCodegen() throws IOException {
         DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false);
-        generator.addPublicParameter(BindingTrace.class);
+
-        generator.addField(false, BindingContext.class, "bindingContext",
+        // Parameters
-                           new GivenExpression("bindingTrace.getBindingContext()"));
+        generator.addPublicParameter(JetTypeMapper.class);
         generator.addPublicParameter(DiType.listOf(JetFile.class));
         generator.addParameter(BuiltinToJavaTypesMapping.class);
-        generator.addParameter(ClassBuilderMode.class);
         generator.addPublicParameter(GenerationState.class);
         generator.addParameter(ClassBuilderFactory.class);
         generator.addPublicParameter(Project.class);
-        generator.addPublicField(JetTypeMapper.class);
+
+        // Fields
+        generator.addField(false, BindingTrace.class, "bindingTrace",
+                           new GivenExpression("jetTypeMapper.getBindingTrace()"));
+        generator.addField(false, BindingContext.class, "bindingContext",
+                           new GivenExpression("bindingTrace.getBindingContext()"));
+        generator.addField(false, ClassBuilderMode.class, "classBuilderMode",
+                           new GivenExpression("classBuilderFactory.getClassBuilderMode()"));
         generator.addPublicField(ClassCodegen.class);
         generator.addPublicField(ScriptCodegen.class);
         generator.addField(true, IntrinsicMethods.class, "intrinsics", null);
         generator.addPublicField(ClassFileFactory.class);
         generator.addPublicField(MemberCodegen.class);
-        generator.generate("compiler/backend/src", "org.jetbrains.jet.di", "InjectorForJvmCodegen");
-    }
 
-    private static void generateInjectorForJetTypeMapper() throws IOException {
+        generator.generate("compiler/backend/src", "org.jetbrains.jet.di", "InjectorForJvmCodegen");
-        DependencyInjectorGenerator generator = new DependencyInjectorGenerator(false);
-        generator.addPublicParameter(BindingTrace.class);
-        generator.addField(false, BindingContext.class, "bindingContext",
-                           new GivenExpression("bindingTrace.getBindingContext()"));
-        generator.addPublicParameter(DiType.listOf(JetFile.class));
-        generator.addPublicField(JetTypeMapper.class);
-        generator.addField(BuiltinToJavaTypesMapping.ENABLED);
-        generator.addField(ClassBuilderMode.FULL);
-        generator.generate("compiler/backend/src", "org.jetbrains.jet.di", "InjectorForJetTypeMapper");
     }
 
     private static void generateInjectorForBodyResolve() throws IOException {