From 0852f3939ff9bfb950c483807188df68924ce1db Mon Sep 17 00:00:00 2001 From: Alex Tkachman Date: Thu, 30 Aug 2012 11:50:13 +0300 Subject: [PATCH] (BindingContext,BindingTrace,TypeMapper,GenerationState)Aware classes introduced and related changes in GenerationState construction/injection --- .../jetbrains/jet/codegen/ClassCodegen.java | 19 ++--- .../jet/codegen/ClassFileFactory.java | 18 ++--- .../jetbrains/jet/codegen/JetTypeMapper.java | 35 ++------- .../jetbrains/jet/codegen/MemberCodegen.java | 12 +-- .../jetbrains/jet/codegen/ScriptCodegen.java | 38 +++------- .../codegen/state/BindingContextAware.java | 36 +++++++++ .../jet/codegen/state/BindingTraceAware.java | 36 +++++++++ .../jet/codegen/state/GenerationState.java | 17 +++-- .../codegen/state/GenerationStateAware.java | 32 ++++++++ .../jet/codegen/state/TypeMapperAware.java | 36 +++++++++ .../jet/di/InjectorForJetTypeMapper.java | 73 ------------------- .../jet/di/InjectorForJvmCodegen.java | 56 +++++--------- .../plugin/debugger/JetPositionManager.java | 7 +- .../debugger/JetPositionManagerTest.java | 7 +- .../jet/di/AllInjectorsGenerator.java | 30 +++----- 15 files changed, 221 insertions(+), 231 deletions(-) create mode 100644 compiler/backend/src/org/jetbrains/jet/codegen/state/BindingContextAware.java create mode 100644 compiler/backend/src/org/jetbrains/jet/codegen/state/BindingTraceAware.java create mode 100644 compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationStateAware.java create mode 100644 compiler/backend/src/org/jetbrains/jet/codegen/state/TypeMapperAware.java delete mode 100644 compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java index 10b679469b4..ad946892c49 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java +++ b/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 { - private GenerationState state; - @SuppressWarnings({"FieldCanBeLocal", "UnusedDeclaration"}) private JetTypeMapper jetTypeMapper; - - @Inject - public void setState(GenerationState state) { - this.state = state; +public class ClassCodegen extends GenerationStateAware { + public ClassCodegen(@NotNull GenerationState state) { + super(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); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClassFileFactory.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassFileFactory.java index 42c80fadd03..ed2866def79 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClassFileFactory.java +++ b/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 { - private ClassBuilderFactory builderFactory; - private GenerationState state; - +public final class ClassFileFactory extends GenerationStateAware { + @NotNull private ClassBuilderFactory builderFactory; private final Map ns2codegen = new HashMap(); private final Map generators = new LinkedHashMap(); private boolean isDone = false; - - @Inject - public void setBuilderFactory(ClassBuilderFactory builderFactory) { - this.builderFactory = builderFactory; + public ClassFileFactory(@NotNull GenerationState state) { + super(state); } + @Inject - public void setState(GenerationState state) { - this.state = state; + public void setBuilderFactory(@NotNull ClassBuilderFactory builderFactory) { + this.builderFactory = builderFactory; } ClassBuilder newVisitor(String filePath) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index 473ced0835f..10833f2dc58 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/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 boolean mapBuiltinsToJava; - private ClassBuilderMode classBuilderMode; - private BindingTrace bindingTrace; + private final boolean mapBuiltinsToJava; + private final ClassBuilderMode classBuilderMode; - @Inject - public void setBindingTrace(BindingTrace bindingTrace) { - this.bindingTrace = bindingTrace; - this.bindingContext = bindingTrace.getBindingContext(); - } - - @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; + public JetTypeMapper(BindingTrace bindingTrace, boolean mapBuiltinsToJava, ClassBuilderMode mode) { + super(bindingTrace); + this.mapBuiltinsToJava = mapBuiltinsToJava; + classBuilderMode = mode; } @NotNull diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/MemberCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/MemberCodegen.java index 3387dc3e02b..2c8e8495fe3 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/MemberCodegen.java +++ b/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 - private GenerationState state; - - @Inject - public void setState(@NotNull GenerationState state) { - this.state = state; + public MemberCodegen(@NotNull GenerationState state) { + super(state); } - public void generateFunctionOrProperty( @NotNull JetTypeParameterListOwner functionOrProperty, @NotNull CodegenContext context, @NotNull ClassBuilder classBuilder diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java index ca6b1936596..cbac388ab27 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java +++ b/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 earlierScripts; private Method scriptConstructorMethod; - - @Inject - public void setState(@NotNull GenerationState state) { - this.state = state; + public ScriptCodegen(@NotNull GenerationState state) { + super(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 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); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/BindingContextAware.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/BindingContextAware.java new file mode 100644 index 00000000000..0e0ab13f41a --- /dev/null +++ b/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; + } +} diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/BindingTraceAware.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/BindingTraceAware.java new file mode 100644 index 00000000000..9f6a1e9d701 --- /dev/null +++ b/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; + } +} diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java index 230d5e37264..d5986f4ba70 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java +++ b/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 files, @NotNull BuiltinToJavaTypesMapping builtinToJavaTypesMapping ) { + this.project = project; this.progress = progress; this.files = files; this.classBuilderMode = builderFactory.getClassBuilderMode(); - final DelegatingBindingTrace trace = new DelegatingBindingTrace(exhaust.getBindingContext()); - this.bindingContext = trace.getBindingContext(); + bindingTrace = new DelegatingBindingTrace(exhaust.getBindingContext()); + bindingContext = bindingTrace.getBindingContext(); + + this.typeMapper = new JetTypeMapper(bindingTrace, builtinToJavaTypesMapping == BuiltinToJavaTypesMapping.ENABLED, classBuilderMode); InjectorForJvmCodegen injector = new InjectorForJvmCodegen( - trace, - this.files, builtinToJavaTypesMapping, builderFactory.getClassBuilderMode(), this, builderFactory, project); - this.classFileFactory = injector.getClassFileFactory(); + typeMapper, this.files, + builtinToJavaTypesMapping, this, builderFactory, project); + 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 diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationStateAware.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationStateAware.java new file mode 100644 index 00000000000..07e180808d1 --- /dev/null +++ b/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; + } +} diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/TypeMapperAware.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/TypeMapperAware.java new file mode 100644 index 00000000000..9184a78dcc1 --- /dev/null +++ b/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; + } +} diff --git a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java deleted file mode 100644 index 9c0eaaf3041..00000000000 --- a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java +++ /dev/null @@ -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 listOfJetFile; - private JetTypeMapper jetTypeMapper; - private BuiltinToJavaTypesMapping builtinToJavaTypesMapping; - private ClassBuilderMode classBuilderMode; - - public InjectorForJetTypeMapper( - @NotNull BindingTrace bindingTrace, - @NotNull List 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; - } - -} diff --git a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java index 409ea8b5760..232f5fb8b43 100644 --- a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java +++ b/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.lang.resolve.BindingContext; +import org.jetbrains.jet.codegen.JetTypeMapper; 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 BindingContext bindingContext; + private final JetTypeMapper jetTypeMapper; private final List 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 listOfJetFile, @NotNull BuiltinToJavaTypesMapping builtinToJavaTypesMapping, - @NotNull ClassBuilderMode classBuilderMode, @NotNull GenerationState generationState, @NotNull ClassBuilderFactory classBuilderFactory, @NotNull Project project ) { - this.bindingTrace = bindingTrace; - this.bindingContext = bindingTrace.getBindingContext(); + this.jetTypeMapper = jetTypeMapper; this.listOfJetFile = listOfJetFile; this.builtinToJavaTypesMapping = builtinToJavaTypesMapping; - this.classBuilderMode = classBuilderMode; this.generationState = generationState; this.classBuilderFactory = classBuilderFactory; this.project = project; - this.jetTypeMapper = new JetTypeMapper(); - this.classCodegen = new ClassCodegen(); - this.scriptCodegen = new ScriptCodegen(); + this.bindingTrace = jetTypeMapper.getBindingTrace(); + this.bindingContext = bindingTrace.getBindingContext(); + this.classBuilderMode = classBuilderFactory.getClassBuilderMode(); + this.classCodegen = new ClassCodegen(getGenerationState()); + this.scriptCodegen = new ScriptCodegen(getGenerationState()); this.intrinsics = new IntrinsicMethods(); - this.classFileFactory = new ClassFileFactory(); - this.memberCodegen = new MemberCodegen(); + this.classFileFactory = new ClassFileFactory(getGenerationState()); + 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() { - return this.bindingTrace; + public JetTypeMapper getJetTypeMapper() { + 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; } diff --git a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java index 2bab4197e12..2727b6514aa 100644 --- a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java +++ b/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 namespaceFiles = JetFilesProvider.getInstance(file.getProject()).allNamespaceFiles().fun(file); final DelegatingBindingTrace bindingTrace = new DelegatingBindingTrace(analyzeExhaust.getBindingContext()); - final InjectorForJetTypeMapper injector = new InjectorForJetTypeMapper(bindingTrace, namespaceFiles); - JetTypeMapper typeMapper = injector.getJetTypeMapper(); + JetTypeMapper typeMapper = new JetTypeMapper(bindingTrace, true, ClassBuilderMode.FULL); //noinspection unchecked - CodegenBinding.initTrace(bindingTrace, injector.getListOfJetFile()); + CodegenBinding.initTrace(bindingTrace, namespaceFiles); return new Result(typeMapper, PsiModificationTracker.MODIFICATION_COUNT); } }, false); diff --git a/idea/tests/org/jetbrains/jet/plugin/debugger/JetPositionManagerTest.java b/idea/tests/org/jetbrains/jet/plugin/debugger/JetPositionManagerTest.java index fbf0ae71e2f..2086809e752 100644 --- a/idea/tests/org/jetbrains/jet/plugin/debugger/JetPositionManagerTest.java +++ b/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 = injector.getJetTypeMapper(); + JetTypeMapper typeMapper = new JetTypeMapper(bindingTrace, true, ClassBuilderMode.FULL); //noinspection unchecked - CodegenBinding.initTrace(bindingTrace, injector.getListOfJetFile()); + CodegenBinding.initTrace(bindingTrace, files); for (JetFile file : files) { positionManager.addTypeMapper(file, typeMapper); } diff --git a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java index 60477576177..cc1f65de7a1 100644 --- a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java +++ b/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", - new GivenExpression("bindingTrace.getBindingContext()")); + + // Parameters + 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 { - 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"); + generator.generate("compiler/backend/src", "org.jetbrains.jet.di", "InjectorForJvmCodegen"); } private static void generateInjectorForBodyResolve() throws IOException {