diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java index d11185aa1ec..e189693e34e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClassBodyCodegen.java @@ -89,7 +89,7 @@ public abstract class ClassBodyCodegen extends GenerationStateAware { protected void generateDeclaration(PropertyCodegen propertyCodegen, JetDeclaration declaration, FunctionCodegen functionCodegen) { if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) { - state.getMemberCodegen().generateFunctionOrProperty((JetTypeParameterListOwner) declaration, context, v); + CodegenUtil.generateFunctionOrProperty(state, (JetTypeParameterListOwner) declaration, context, v); } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java deleted file mode 100644 index b996608ca10..00000000000 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java +++ /dev/null @@ -1,108 +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.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.*; -import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.types.ErrorUtils; - -import java.util.Map; - -import static org.jetbrains.jet.codegen.binding.CodegenBinding.enumEntryNeedSubclass; - -/** - * @author max - * @author alex.tkachman - */ -public class ClassCodegen extends GenerationStateAware { - public ClassCodegen(@NotNull GenerationState state) { - super(state); - } - - public void generate(CodegenContext context, JetClassOrObject aClass) { - ClassDescriptor descriptor = state.getBindingContext().get(BindingContext.CLASS, aClass); - - if (descriptor == null || ErrorUtils.isError(descriptor) || descriptor.getName().equals(JetPsiUtil.NO_NAME_PROVIDED)) { - if (state.getClassBuilderMode() != ClassBuilderMode.SIGNATURES) { - throw new IllegalStateException( - "Generating bad descriptor in ClassBuilderMode = " + state.getClassBuilderMode() + ": " + descriptor); - } - return; - } - - ClassBuilder classBuilder = state.getFactory().forClassImplementation(descriptor); - - final CodegenContext contextForInners = context.intoClass(descriptor, OwnerKind.IMPLEMENTATION, state); - - if (state.getClassBuilderMode() == ClassBuilderMode.SIGNATURES) { - // Outer class implementation must happen prior inner classes so we get proper scoping tree in JetLightClass's delegate - // The same code is present below for the case when we generate real bytecode. This is because the order should be - // different for the case when we compute closures - generateImplementation(context, aClass, OwnerKind.IMPLEMENTATION, contextForInners.getAccessors(), classBuilder); - } - - for (JetDeclaration declaration : aClass.getDeclarations()) { - if (declaration instanceof JetClass) { - if (declaration instanceof JetEnumEntry && !enumEntryNeedSubclass( - state.getBindingContext(), (JetEnumEntry) declaration)) { - continue; - } - - generate(contextForInners, (JetClass) declaration); - } - else if (declaration instanceof JetClassObject) { - generate(contextForInners, ((JetClassObject) declaration).getObjectDeclaration()); - } - else if (declaration instanceof JetObjectDeclaration) { - generate(contextForInners, (JetObjectDeclaration) declaration); - } - } - - if (state.getClassBuilderMode() != ClassBuilderMode.SIGNATURES) { - generateImplementation(context, aClass, OwnerKind.IMPLEMENTATION, contextForInners.getAccessors(), classBuilder); - } - - classBuilder.done(); - } - - private void generateImplementation( - CodegenContext context, - JetClassOrObject aClass, - OwnerKind kind, - Map accessors, - ClassBuilder classBuilder - ) { - ClassDescriptor descriptor = state.getBindingContext().get(BindingContext.CLASS, aClass); - CodegenContext classContext = context.intoClass(descriptor, kind, state); - classContext.copyAccessors(accessors); - - new ImplementationBodyCodegen(aClass, classContext, classBuilder, state).generate(); - - if (aClass instanceof JetClass && ((JetClass) aClass).isTrait()) { - ClassBuilder traitBuilder = state.getFactory().forTraitImplementation(descriptor, state); - new TraitImplBodyCodegen(aClass, context.intoClass(descriptor, OwnerKind.TRAIT_IMPL, state), traitBuilder, state) - .generate(); - traitBuilder.done(); - } - } -} diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java index 6d92972a1a9..3cc89f3a442 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java @@ -29,18 +29,20 @@ import org.jetbrains.asm4.MethodVisitor; import org.jetbrains.asm4.Type; import org.jetbrains.asm4.commons.InstructionAdapter; import org.jetbrains.jet.codegen.binding.CalculatedClosure; +import org.jetbrains.jet.codegen.context.CodegenContext; import org.jetbrains.jet.codegen.signature.BothSignatureWriter; import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind; import org.jetbrains.jet.codegen.signature.JvmMethodSignature; +import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.codegen.state.JetTypeMapper; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.psi.JetClassObject; -import org.jetbrains.jet.lang.psi.JetClassOrObject; -import org.jetbrains.jet.lang.psi.JetObjectDeclaration; +import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.name.Name; +import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.jetbrains.jet.lang.types.lang.JetStandardLibrary; @@ -49,6 +51,7 @@ import org.jetbrains.jet.lexer.JetTokens; import java.util.*; import static org.jetbrains.asm4.Opcodes.*; +import static org.jetbrains.jet.codegen.binding.CodegenBinding.enumEntryNeedSubclass; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isClassObject; import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.JAVA_STRING_TYPE; import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.OBJECT_TYPE; @@ -566,4 +569,109 @@ public class CodegenUtil { v.neg(expectedType); return expectedType; } + + public static void generate(GenerationState state, CodegenContext context, JetClassOrObject aClass) { + ClassDescriptor descriptor = state.getBindingContext().get(BindingContext.CLASS, aClass); + + if (descriptor == null || ErrorUtils.isError(descriptor) || descriptor.getName().equals(JetPsiUtil.NO_NAME_PROVIDED)) { + if (state.getClassBuilderMode() != ClassBuilderMode.SIGNATURES) { + throw new IllegalStateException( + "Generating bad descriptor in ClassBuilderMode = " + state.getClassBuilderMode() + ": " + descriptor); + } + return; + } + + ClassBuilder classBuilder = state.getFactory().forClassImplementation(descriptor); + + final CodegenContext contextForInners = context.intoClass(descriptor, OwnerKind.IMPLEMENTATION, state); + + if (state.getClassBuilderMode() == ClassBuilderMode.SIGNATURES) { + // Outer class implementation must happen prior inner classes so we get proper scoping tree in JetLightClass's delegate + // The same code is present below for the case when we generate real bytecode. This is because the order should be + // different for the case when we compute closures + generateImplementation(state, context, aClass, OwnerKind.IMPLEMENTATION, contextForInners.getAccessors(), classBuilder); + } + + genInners(state, aClass, contextForInners); + + if (state.getClassBuilderMode() != ClassBuilderMode.SIGNATURES) { + generateImplementation(state, context, aClass, OwnerKind.IMPLEMENTATION, contextForInners.getAccessors(), classBuilder); + } + + classBuilder.done(); + } + + public static void genInners(GenerationState state, JetClassOrObject aClass, CodegenContext contextForInners) { + for (JetDeclaration declaration : aClass.getDeclarations()) { + if (declaration instanceof JetClass) { + if (declaration instanceof JetEnumEntry && !enumEntryNeedSubclass( + state.getBindingContext(), (JetEnumEntry) declaration)) { + continue; + } + + generate(state, contextForInners, (JetClass) declaration); + } + else if (declaration instanceof JetClassObject) { + generate(state, contextForInners, ((JetClassObject) declaration).getObjectDeclaration()); + } + else if (declaration instanceof JetObjectDeclaration) { + generate(state, contextForInners, (JetObjectDeclaration) declaration); + } + } + } + + private static void generateImplementation( + GenerationState state, + CodegenContext context, + JetClassOrObject aClass, + OwnerKind kind, + Map accessors, + ClassBuilder classBuilder + ) { + ClassDescriptor descriptor = state.getBindingContext().get(BindingContext.CLASS, aClass); + CodegenContext classContext = context.intoClass(descriptor, kind, state); + classContext.copyAccessors(accessors); + + new ImplementationBodyCodegen(aClass, classContext, classBuilder, state).generate(); + + if (aClass instanceof JetClass && ((JetClass) aClass).isTrait()) { + ClassBuilder traitBuilder = state.getFactory().forTraitImplementation(descriptor, state); + new TraitImplBodyCodegen(aClass, context.intoClass(descriptor, OwnerKind.TRAIT_IMPL, state), traitBuilder, state) + .generate(); + traitBuilder.done(); + } + } + + public static void generateFunctionOrProperty( + GenerationState state, + @NotNull JetTypeParameterListOwner functionOrProperty, + @NotNull CodegenContext context, @NotNull ClassBuilder classBuilder + ) { + FunctionCodegen functionCodegen = new FunctionCodegen(context, classBuilder, state); + if (functionOrProperty instanceof JetNamedFunction) { + try { + functionCodegen.gen((JetNamedFunction) functionOrProperty); + } + catch (CompilationException e) { + throw e; + } + catch (Exception e) { + throw new CompilationException("Failed to generate function " + functionOrProperty.getName(), e, functionOrProperty); + } + } + else if (functionOrProperty instanceof JetProperty) { + try { + new PropertyCodegen(context, classBuilder, functionCodegen).gen((JetProperty) functionOrProperty); + } + catch (CompilationException e) { + throw e; + } + catch (Exception e) { + throw new CompilationException("Failed to generate property " + functionOrProperty.getName(), e, functionOrProperty); + } + } + else { + throw new IllegalArgumentException("Unknown parameter: " + functionOrProperty); + } + } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 9888174ac73..2b6cbae0b8a 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -116,8 +116,11 @@ public class ExpressionCodegen extends JetVisitor implem //noinspection SuspiciousMethodCalls final CalculatedClosure closure = bindingContext.get(CLOSURE, classDescriptor); - final CodegenContext objectContext = context.intoAnonymousClass(classDescriptor, this); + final CodegenContext contextForInners = context.intoClass(classDescriptor, OwnerKind.IMPLEMENTATION, state); + genInners(state, objectDeclaration, contextForInners); + final CodegenContext objectContext = context.intoAnonymousClass(classDescriptor, this); + objectContext.copyAccessors(contextForInners.getAccessors()); new ImplementationBodyCodegen(objectDeclaration, objectContext, classBuilder, state).generate(); return closure; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/MemberCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/MemberCodegen.java deleted file mode 100644 index 420c64c3b75..00000000000 --- a/compiler/backend/src/org/jetbrains/jet/codegen/MemberCodegen.java +++ /dev/null @@ -1,67 +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.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; - -/** - * @author Stepan Koltsov - */ -public class MemberCodegen extends GenerationStateAware { - - public MemberCodegen(@NotNull GenerationState state) { - super(state); - } - - public void generateFunctionOrProperty( - @NotNull JetTypeParameterListOwner functionOrProperty, - @NotNull CodegenContext context, @NotNull ClassBuilder classBuilder - ) { - FunctionCodegen functionCodegen = new FunctionCodegen(context, classBuilder, state); - if (functionOrProperty instanceof JetNamedFunction) { - try { - functionCodegen.gen((JetNamedFunction) functionOrProperty); - } - catch (CompilationException e) { - throw e; - } - catch (Exception e) { - throw new CompilationException("Failed to generate function " + functionOrProperty.getName(), e, functionOrProperty); - } - } - else if (functionOrProperty instanceof JetProperty) { - try { - new PropertyCodegen(context, classBuilder, functionCodegen).gen((JetProperty) functionOrProperty); - } - catch (CompilationException e) { - throw e; - } - catch (Exception e) { - throw new CompilationException("Failed to generate property " + functionOrProperty.getName(), e, functionOrProperty); - } - } - else { - throw new IllegalArgumentException("Unknown parameter: " + functionOrProperty); - } - } -} diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java index 3e6ea88f71b..864ddaf5a0f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java @@ -128,19 +128,19 @@ public class NamespaceCodegen extends GenerationStateAware { for (JetDeclaration declaration : file.getDeclarations()) { if (declaration instanceof JetProperty) { final CodegenContext context = CodegenContext.STATIC.intoNamespace(descriptor); - state.getMemberCodegen().generateFunctionOrProperty( - (JetTypeParameterListOwner) declaration, context, v.getClassBuilder()); + CodegenUtil.generateFunctionOrProperty( + state, (JetTypeParameterListOwner) declaration, context, v.getClassBuilder()); } else if (declaration instanceof JetNamedFunction) { if (!multiFile) { final CodegenContext context = CodegenContext.STATIC.intoNamespace(descriptor); - state.getMemberCodegen().generateFunctionOrProperty( - (JetTypeParameterListOwner) declaration, context, v.getClassBuilder()); + CodegenUtil.generateFunctionOrProperty( + state, (JetTypeParameterListOwner) declaration, context, v.getClassBuilder()); } } else if (declaration instanceof JetClassOrObject) { final CodegenContext context = CodegenContext.STATIC.intoNamespace(descriptor); - state.getClassCodegen().generate(context, (JetClassOrObject) declaration); + CodegenUtil.generate(state, context, (JetClassOrObject) declaration); } else if (declaration instanceof JetScript) { state.getScriptCodegen().generate((JetScript) declaration); @@ -176,14 +176,16 @@ public class NamespaceCodegen extends GenerationStateAware { { final CodegenContext context = CodegenContext.STATIC.intoNamespace(descriptor); - state.getMemberCodegen() - .generateFunctionOrProperty((JetTypeParameterListOwner) declaration, context, builder); + CodegenUtil + .generateFunctionOrProperty(state, (JetTypeParameterListOwner) declaration, + context, builder); } { final CodegenContext context = CodegenContext.STATIC.intoNamespacePart(className, descriptor); - state.getMemberCodegen() - .generateFunctionOrProperty((JetTypeParameterListOwner) declaration, context, v.getClassBuilder()); + CodegenUtil + .generateFunctionOrProperty(state, (JetTypeParameterListOwner) declaration, + context, v.getClassBuilder()); } } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java index b7026d1c5f6..c2b8416bcfc 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java @@ -42,8 +42,8 @@ import java.util.Collections; import java.util.List; import static org.jetbrains.asm4.Opcodes.*; -import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.OBJECT_TYPE; import static org.jetbrains.jet.codegen.binding.CodegenBinding.*; +import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.OBJECT_TYPE; /** * @author Stepan Koltsov @@ -52,8 +52,6 @@ public class ScriptCodegen extends GenerationStateAware { @NotNull private ClassFileFactory classFileFactory; - @NotNull - private MemberCodegen memberCodegen; private List earlierScripts; private Method scriptConstructorMethod; @@ -67,11 +65,6 @@ public class ScriptCodegen extends GenerationStateAware { this.classFileFactory = classFileFactory; } - @Inject - public void setMemberCodegen(@NotNull MemberCodegen memberCodegen) { - this.memberCodegen = memberCodegen; - } - public void generate(JetScript scriptDeclaration) { ScriptDescriptor scriptDescriptor = state.getBindingContext().get(BindingContext.SCRIPT, scriptDeclaration); @@ -209,7 +202,7 @@ public class ScriptCodegen extends GenerationStateAware { private void genMembers(@NotNull JetScript scriptDeclaration, @NotNull CodegenContext context, @NotNull ClassBuilder classBuilder) { for (JetDeclaration decl : scriptDeclaration.getDeclarations()) { - memberCodegen.generateFunctionOrProperty((JetTypeParameterListOwner) decl, context, classBuilder); + CodegenUtil.generateFunctionOrProperty(state, (JetTypeParameterListOwner) decl, context, classBuilder); } } 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 b750818b2a3..8ef4e9be8a1 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java @@ -68,12 +68,6 @@ public class GenerationState { @NotNull private final JetTypeMapper typeMapper; - @NotNull - private final MemberCodegen memberCodegen; - - @NotNull - private final ClassCodegen classCodegen; - public GenerationState(Project project, ClassBuilderFactory builderFactory, AnalyzeExhaust analyzeExhaust, List files) { this(project, builderFactory, Progress.DEAF, analyzeExhaust, files, BuiltinToJavaTypesMapping.ENABLED); } @@ -98,8 +92,6 @@ public class GenerationState { builtinToJavaTypesMapping, this, builderFactory, project); this.scriptCodegen = injector.getScriptCodegen(); - this.memberCodegen = injector.getMemberCodegen(); - this.classCodegen = injector.getClassCodegen(); this.intrinsics = injector.getIntrinsics(); this.classFileFactory = injector.getClassFileFactory(); } @@ -154,16 +146,6 @@ public class GenerationState { return intrinsics; } - @NotNull - public MemberCodegen getMemberCodegen() { - return memberCodegen; - } - - @NotNull - public ClassCodegen getClassCodegen() { - return classCodegen; - } - public void beforeCompile() { markUsed(); diff --git a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java index b0e94b6bc63..46661b46e1c 100644 --- a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java @@ -17,23 +17,18 @@ package org.jetbrains.jet.di; -import org.jetbrains.jet.codegen.state.JetTypeMapper; -import java.util.List; -import org.jetbrains.jet.lang.psi.JetFile; -import org.jetbrains.jet.codegen.BuiltinToJavaTypesMapping; -import org.jetbrains.jet.codegen.state.GenerationState; -import org.jetbrains.jet.codegen.ClassBuilderFactory; import com.intellij.openapi.project.Project; -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; -import org.jetbrains.jet.codegen.ClassFileFactory; -import org.jetbrains.jet.codegen.MemberCodegen; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.codegen.*; +import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods; +import org.jetbrains.jet.codegen.state.GenerationState; +import org.jetbrains.jet.codegen.state.JetTypeMapper; +import org.jetbrains.jet.lang.psi.JetFile; +import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.resolve.BindingTrace; + import javax.annotation.PreDestroy; +import java.util.List; /* This file is generated by org.jetbrains.jet.di.AllInjectorsGenerator. DO NOT EDIT! */ public class InjectorForJvmCodegen { @@ -47,11 +42,9 @@ public class InjectorForJvmCodegen { private BindingTrace bindingTrace; private BindingContext bindingContext; private ClassBuilderMode classBuilderMode; - private ClassCodegen classCodegen; private ScriptCodegen scriptCodegen; private IntrinsicMethods intrinsics; private ClassFileFactory classFileFactory; - private MemberCodegen memberCodegen; public InjectorForJvmCodegen( @NotNull JetTypeMapper jetTypeMapper, @@ -70,14 +63,11 @@ public class InjectorForJvmCodegen { 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(getGenerationState()); - this.memberCodegen = new MemberCodegen(getGenerationState()); this.scriptCodegen.setClassFileFactory(classFileFactory); - this.scriptCodegen.setMemberCodegen(memberCodegen); this.classFileFactory.setBuilderFactory(classBuilderFactory); @@ -105,10 +95,6 @@ public class InjectorForJvmCodegen { return this.project; } - public ClassCodegen getClassCodegen() { - return this.classCodegen; - } - public ScriptCodegen getScriptCodegen() { return this.scriptCodegen; } @@ -121,8 +107,4 @@ public class InjectorForJvmCodegen { return this.classFileFactory; } - public MemberCodegen getMemberCodegen() { - return this.memberCodegen; - } - } diff --git a/compiler/testData/codegen/regressions/kt2607.kt b/compiler/testData/codegen/regressions/kt2607.kt new file mode 100644 index 00000000000..9bc3b5c2b35 --- /dev/null +++ b/compiler/testData/codegen/regressions/kt2607.kt @@ -0,0 +1,9 @@ +fun box() : String { + val o = object { + + class C { + fun foo() = "OK" + } + } + return o.C().foo() +} \ No newline at end of file diff --git a/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java index e400c98c9cb..d81ffb3ae79 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java @@ -606,4 +606,9 @@ public class ClassGenTest extends CodegenTestCase { createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.JDK_ONLY); blackBoxFileWithJava("regressions/kt2781.kt", true); } + + public void testKt2607() throws Exception { + createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.JDK_ONLY); + blackBoxFile("regressions/kt2607.kt"); + } } diff --git a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java index a51bd899b0b..2a0d5691031 100644 --- a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java +++ b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java @@ -210,11 +210,9 @@ public class AllInjectorsGenerator { 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"); }