From cfbab55a4344fd06b6a5d4a470700831a582ceb6 Mon Sep 17 00:00:00 2001 From: Alex Tkachman Date: Mon, 27 Aug 2012 19:06:01 +0300 Subject: [PATCH] ClosureAnnotator renamed to CodegenAnnotator --- .../jetbrains/jet/codegen/ClassCodegen.java | 2 +- .../jetbrains/jet/codegen/ClosureCodegen.java | 8 +++--- .../jet/codegen/ExpressionCodegen.java | 18 ++++++------ .../jet/codegen/GenerationState.java | 10 +++---- .../codegen/ImplementationBodyCodegen.java | 8 +++--- .../jetbrains/jet/codegen/JetTypeMapper.java | 28 +++++++++---------- .../jet/codegen/NamespaceCodegen.java | 2 +- .../jetbrains/jet/codegen/ScriptCodegen.java | 20 ++++++------- ...reAnnotator.java => CodegenAnnotator.java} | 2 +- .../jet/codegen/context/CodegenContext.java | 2 +- .../jet/codegen/context/LocalLookup.java | 2 +- .../jet/di/InjectorForJetTypeMapper.java | 12 ++++---- .../jet/di/InjectorForJvmCodegen.java | 18 ++++++------ .../plugin/debugger/JetPositionManager.java | 8 +++--- .../debugger/JetPositionManagerTest.java | 2 +- .../jet/di/AllInjectorsGenerator.java | 7 +++-- 16 files changed, 76 insertions(+), 73 deletions(-) rename compiler/backend/src/org/jetbrains/jet/codegen/context/{ClosureAnnotator.java => CodegenAnnotator.java} (99%) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java index fdcbc731c56..7c147f4dfe3 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClassCodegen.java @@ -60,7 +60,7 @@ public class ClassCodegen { for (JetDeclaration declaration : aClass.getDeclarations()) { if (declaration instanceof JetClass) { - if (declaration instanceof JetEnumEntry && !state.getInjector().getClosureAnnotator().enumEntryNeedSubclass( + if (declaration instanceof JetEnumEntry && !state.getInjector().getCodegenAnnotator().enumEntryNeedSubclass( (JetEnumEntry) declaration)) { continue; } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java index 58c02ddfc58..62f421f1b2b 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java @@ -29,7 +29,7 @@ import org.jetbrains.asm4.commons.InstructionAdapter; import org.jetbrains.asm4.commons.Method; import org.jetbrains.asm4.signature.SignatureWriter; import org.jetbrains.jet.codegen.context.CalculatedClosure; -import org.jetbrains.jet.codegen.context.ClosureAnnotator; +import org.jetbrains.jet.codegen.context.CodegenAnnotator; import org.jetbrains.jet.codegen.context.CodegenContext; import org.jetbrains.jet.codegen.context.MutableClosure; import org.jetbrains.jet.codegen.signature.JvmMethodSignature; @@ -51,7 +51,7 @@ import static org.jetbrains.asm4.Opcodes.*; public class ClosureCodegen { private final BindingContext bindingContext; - private final ClosureAnnotator closureAnnotator; + private final CodegenAnnotator codegenAnnotator; private final JetTypeMapper typeMapper; Method constructor; @@ -65,7 +65,7 @@ public class ClosureCodegen { this.closure = closure; bindingContext = state.getBindingContext(); typeMapper = state.getInjector().getJetTypeMapper(); - closureAnnotator = typeMapper.getClosureAnnotator(); + codegenAnnotator = typeMapper.getCodegenAnnotator(); } public ClosureCodegen gen(JetExpression fun, CodegenContext context, ExpressionCodegen expressionCodegen) { @@ -282,7 +282,7 @@ public class ClosureCodegen { } else if (CodegenUtil.isNamedFun(descriptor, state.getBindingContext()) && descriptor.getContainingDeclaration() instanceof FunctionDescriptor) { - final Type type = closureAnnotator + final Type type = codegenAnnotator .classNameForAnonymousClass((JetElement) BindingContextUtils.descriptorToDeclaration(bindingContext, descriptor)) .getAsmType(); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 88ec2b2ae2f..841902f0fce 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -1007,9 +1007,9 @@ public class ExpressionCodegen extends JetVisitor implem private StackValue genClosure(JetExpression expression) { final FunctionDescriptor descriptor = bindingContext.get(BindingContext.FUNCTION, expression); - final ClosureAnnotator closureAnnotator = state.getInjector().getClosureAnnotator(); - final ClassDescriptor classDescriptor = closureAnnotator.classDescriptorForFunctionDescriptor(descriptor); - final CalculatedClosure closure = closureAnnotator.getCalculatedClosure(classDescriptor); + final CodegenAnnotator codegenAnnotator = state.getInjector().getCodegenAnnotator(); + final ClassDescriptor classDescriptor = codegenAnnotator.classDescriptorForFunctionDescriptor(descriptor); + final CalculatedClosure closure = codegenAnnotator.getCalculatedClosure(classDescriptor); ClosureCodegen closureCodegen = new ClosureCodegen(state, (MutableClosure) closure).gen(expression, context, this); @@ -1411,11 +1411,11 @@ public class ExpressionCodegen extends JetVisitor implem if (descriptor instanceof ValueParameterDescriptor && descriptor.getContainingDeclaration() instanceof ScriptDescriptor) { ScriptDescriptor scriptDescriptor = (ScriptDescriptor) descriptor.getContainingDeclaration(); - final ClosureAnnotator closureAnnotator = state.getInjector().getClosureAnnotator(); + final CodegenAnnotator codegenAnnotator = state.getInjector().getCodegenAnnotator(); assert scriptDescriptor != null; - JvmClassName scriptClassName = closureAnnotator.classNameForScriptDescriptor(scriptDescriptor); + JvmClassName scriptClassName = codegenAnnotator.classNameForScriptDescriptor(scriptDescriptor); ValueParameterDescriptor valueParameterDescriptor = (ValueParameterDescriptor) descriptor; - final ClassDescriptor scriptClass = closureAnnotator.classDescriptorForScriptDescriptor(scriptDescriptor); + final ClassDescriptor scriptClass = codegenAnnotator.classDescriptorForScriptDescriptor(scriptDescriptor); final StackValue script = StackValue.thisOrOuter(this, scriptClass); script.put(script.type, v); Type fieldType = typeMapper.mapType(valueParameterDescriptor.getType(), MapTypeMode.VALUE); @@ -1901,13 +1901,13 @@ public class ExpressionCodegen extends JetVisitor implem CodegenContext.ScriptContext scriptContext = (CodegenContext.ScriptContext) cur; JvmClassName currentScriptClassName = - state.getInjector().getClosureAnnotator().classNameForScriptDescriptor(scriptContext.getScriptDescriptor()); + state.getInjector().getCodegenAnnotator().classNameForScriptDescriptor(scriptContext.getScriptDescriptor()); if (scriptContext.getScriptDescriptor() == receiver.getDeclarationDescriptor()) { result.put(currentScriptClassName.getAsmType(), v); } else { JvmClassName className = - state.getInjector().getClosureAnnotator().classNameForScriptDescriptor(receiver.getDeclarationDescriptor()); + state.getInjector().getCodegenAnnotator().classNameForScriptDescriptor(receiver.getDeclarationDescriptor()); String fieldName = state.getInjector().getScriptCodegen().getScriptFieldName(receiver.getDeclarationDescriptor()); result.put(currentScriptClassName.getAsmType(), v); StackValue.field(className.getAsmType(), currentScriptClassName, fieldName, false).put(className.getAsmType(), v); @@ -2837,7 +2837,7 @@ public class ExpressionCodegen extends JetVisitor implem generateInitializer.fun(variableDescriptor); JetScript scriptPsi = JetPsiUtil.getScript(variableDeclaration); assert scriptPsi != null; - JvmClassName scriptClassName = state.getInjector().getClosureAnnotator().classNameForScriptPsi(scriptPsi); + JvmClassName scriptClassName = state.getInjector().getCodegenAnnotator().classNameForScriptPsi(scriptPsi); v.putfield(scriptClassName.getInternalName(), variableDeclaration.getName(), varType.getDescriptor()); } else if (sharedVarType == null) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java b/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java index 3d57bbecf60..0f417beb5b3 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/GenerationState.java @@ -131,7 +131,7 @@ public class GenerationState { } public Pair forAnonymousSubclass(JetElement expression) { - JvmClassName className = getInjector().getJetTypeMapper().getClosureAnnotator().classNameForAnonymousClass(expression); + JvmClassName className = getInjector().getJetTypeMapper().getCodegenAnnotator().classNameForAnonymousClass(expression); return Pair.create(className, getFactory().forAnonymousSubclass(className)); } @@ -142,7 +142,7 @@ public class GenerationState { private void beforeCompile() { markUsed(); - injector.getClosureAnnotator().init(); + injector.getCodegenAnnotator().init(); } public void compileCorrectFiles(@NotNull CompilationErrorHandler errorHandler) { @@ -151,7 +151,7 @@ public class GenerationState { String name = ScriptNameUtil.classNameForScript(file); JetScript script = file.getScript(); assert script != null; - injector.getClosureAnnotator().registerClassNameForScript(script, JvmClassName.byInternalName(name)); + injector.getCodegenAnnotator().registerClassNameForScript(script, JvmClassName.byInternalName(name)); } } @@ -178,7 +178,7 @@ public class GenerationState { ) { injector.getScriptCodegen().registerEarlierScripts(earlierScripts); - injector.getClosureAnnotator().registerClassNameForScript(script, className); + injector.getCodegenAnnotator().registerClassNameForScript(script, className); beforeCompile(); @@ -201,7 +201,7 @@ public class GenerationState { final ClassDescriptor classDescriptor = bindingContext.get(BindingContext.CLASS, objectDeclaration); assert classDescriptor != null; - final CalculatedClosure closure = getInjector().getClosureAnnotator().getCalculatedClosure(classDescriptor); + final CalculatedClosure closure = getInjector().getCodegenAnnotator().getCalculatedClosure(classDescriptor); final CodegenContext objectContext = expressionCodegen.context.intoAnonymousClass(classDescriptor, expressionCodegen); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index be1d99a86da..fa2f4f13910 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -136,7 +136,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { if (isEnum) { for (JetDeclaration declaration : myClass.getDeclarations()) { if (declaration instanceof JetEnumEntry) { - if (state.getInjector().getClosureAnnotator().enumEntryNeedSubclass((JetEnumEntry) declaration)) { + if (state.getInjector().getCodegenAnnotator().enumEntryNeedSubclass((JetEnumEntry) declaration)) { access &= ~ACC_FINAL; } } @@ -627,7 +627,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { if (hasThis0) { final Type type = typeMapper - .mapType(typeMapper.getClosureAnnotator().getEclosingClassDescriptor(descriptor).getDefaultType(), MapTypeMode.VALUE); + .mapType(typeMapper.getCodegenAnnotator().getEclosingClassDescriptor(descriptor).getDefaultType(), MapTypeMode.VALUE); String interfaceDesc = type.getDescriptor(); iv.load(0, classType); iv.load(frameMap.getOuterThisIndex(), type); @@ -704,7 +704,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { if (typeMapper.hasThis0(superClassDescriptor)) { iv.load(1, JetTypeMapper.OBJECT_TYPE); parameterTypes.add(typeMapper.mapType( - typeMapper.getClosureAnnotator().getEclosingClassDescriptor(descriptor).getDefaultType(), MapTypeMode.VALUE)); + typeMapper.getCodegenAnnotator().getEclosingClassDescriptor(descriptor).getDefaultType(), MapTypeMode.VALUE)); } Method superCallMethod = new Method("", Type.VOID_TYPE, parameterTypes.toArray(new Type[parameterTypes.size()])); //noinspection ConstantConditions @@ -1142,7 +1142,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { iv.aconst(enumConstant.getName()); iv.iconst(ordinal); - if (delegationSpecifiers.size() == 1 && !state.getInjector().getClosureAnnotator().enumEntryNeedSubclass(enumConstant)) { + if (delegationSpecifiers.size() == 1 && !state.getInjector().getCodegenAnnotator().enumEntryNeedSubclass(enumConstant)) { final JetDelegationSpecifier specifier = delegationSpecifiers.get(0); if (specifier instanceof JetDelegatorToSuperCall) { final JetDelegatorToSuperCall superCall = (JetDelegatorToSuperCall) specifier; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java index 75af01daf32..436d66c26ae 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/JetTypeMapper.java @@ -22,7 +22,7 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.asm4.Opcodes; import org.jetbrains.asm4.Type; import org.jetbrains.jet.codegen.context.CalculatedClosure; -import org.jetbrains.jet.codegen.context.ClosureAnnotator; +import org.jetbrains.jet.codegen.context.CodegenAnnotator; import org.jetbrains.jet.codegen.context.EnclosedValueDescriptor; import org.jetbrains.jet.codegen.signature.*; import org.jetbrains.jet.lang.descriptors.*; @@ -76,7 +76,7 @@ public class JetTypeMapper { public static final Type JET_SHARED_BOOLEAN_TYPE = Type.getObjectType("jet/runtime/SharedVar$Boolean"); public BindingContext bindingContext; - private ClosureAnnotator closureAnnotator; + private CodegenAnnotator codegenAnnotator; private boolean mapBuiltinsToJava; private ClassBuilderMode classBuilderMode; @@ -86,8 +86,8 @@ public class JetTypeMapper { } @Inject - public void setClosureAnnotator(ClosureAnnotator closureAnnotator) { - this.closureAnnotator = closureAnnotator; + public void setCodegenAnnotator(CodegenAnnotator codegenAnnotator) { + this.codegenAnnotator = codegenAnnotator; } @Inject @@ -101,16 +101,16 @@ public class JetTypeMapper { } public boolean hasThis0(ClassDescriptor classDescriptor) { - final CalculatedClosure closure = closureAnnotator.getCalculatedClosure(classDescriptor); + final CalculatedClosure closure = codegenAnnotator.getCalculatedClosure(classDescriptor); return closure != null && closure.getCaptureThis() != null; } public CalculatedClosure getCalculatedClosure(ClassDescriptor classDescriptor) { - return closureAnnotator.getCalculatedClosure(classDescriptor); + return codegenAnnotator.getCalculatedClosure(classDescriptor); } - public ClosureAnnotator getClosureAnnotator() { - return closureAnnotator; + public CodegenAnnotator getCodegenAnnotator() { + return codegenAnnotator; } public static boolean isIntPrimitive(Type type) { @@ -152,7 +152,7 @@ public class JetTypeMapper { return JvmClassName.byType(asmType); } else if (containingDeclaration instanceof ScriptDescriptor) { - return closureAnnotator.classNameForScriptDescriptor((ScriptDescriptor) containingDeclaration); + return codegenAnnotator.classNameForScriptDescriptor((ScriptDescriptor) containingDeclaration); } else { throw new UnsupportedOperationException("don't know how to generate owner for parent " + containingDeclaration); @@ -299,7 +299,7 @@ public class JetTypeMapper { } } else if (klass.getKind() == ClassKind.ENUM_ENTRY) { - if (closureAnnotator.enumEntryNeedSubclass(klass)) { + if (codegenAnnotator.enumEntryNeedSubclass(klass)) { return getJvmInternalFQName(klass.getContainingDeclaration()) + "$" + klass.getName().getName(); } else { @@ -307,7 +307,7 @@ public class JetTypeMapper { } } - JvmClassName name = closureAnnotator.classNameForClassDescriptor((ClassDescriptor) descriptor); + JvmClassName name = codegenAnnotator.classNameForClassDescriptor((ClassDescriptor) descriptor); if (name != null) { return name.getInternalName(); } @@ -533,7 +533,7 @@ public class JetTypeMapper { } else if (functionParent instanceof ScriptDescriptor) { thisClass = owner = - ownerForDefaultParam = ownerForDefaultImpl = closureAnnotator.classNameForScriptDescriptor((ScriptDescriptor) functionParent); + ownerForDefaultParam = ownerForDefaultImpl = codegenAnnotator.classNameForScriptDescriptor((ScriptDescriptor) functionParent); invokeOpcode = INVOKEVIRTUAL; } else if (functionParent instanceof ClassDescriptor) { @@ -954,7 +954,7 @@ public class JetTypeMapper { for (ScriptDescriptor importedScript : importedScripts) { signatureWriter.writeParameterType(JvmMethodParameterKind.VALUE); - mapType(closureAnnotator.classDescriptorForScriptDescriptor(importedScript).getDefaultType(), signatureWriter, + mapType(codegenAnnotator.classDescriptorForScriptDescriptor(importedScript).getDefaultType(), signatureWriter, MapTypeMode.VALUE); signatureWriter.writeParameterTypeEnd(); } @@ -1027,7 +1027,7 @@ public class JetTypeMapper { } else if (descriptor instanceof SimpleFunctionDescriptor && descriptor.getContainingDeclaration() instanceof FunctionDescriptor) { PsiElement psiElement = BindingContextUtils.descriptorToDeclaration(bindingContext, descriptor); - return closureAnnotator.classNameForAnonymousClass((JetElement) psiElement).getAsmType(); + return codegenAnnotator.classNameForAnonymousClass((JetElement) psiElement).getAsmType(); } else if (descriptor instanceof FunctionDescriptor) { return StackValue diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java index 350dfbb5c3f..6fd45df0c30 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java @@ -84,7 +84,7 @@ public class NamespaceCodegen { } public void generate(CompilationErrorHandler errorHandler, final Progress progress) { - boolean multiFile = state.getInjector().getClosureAnnotator().isMultiFileNamespace(name); + boolean multiFile = state.getInjector().getCodegenAnnotator().isMultiFileNamespace(name); for (JetFile file : files) { VirtualFile vFile = file.getVirtualFile(); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java index 2fa41e3e8f9..828c291a64c 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ScriptCodegen.java @@ -23,7 +23,7 @@ import org.jetbrains.asm4.MethodVisitor; import org.jetbrains.asm4.Opcodes; import org.jetbrains.asm4.Type; import org.jetbrains.asm4.commons.InstructionAdapter; -import org.jetbrains.jet.codegen.context.ClosureAnnotator; +import org.jetbrains.jet.codegen.context.CodegenAnnotator; import org.jetbrains.jet.codegen.context.CodegenContext; import org.jetbrains.jet.codegen.signature.JvmMethodSignature; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; @@ -56,7 +56,7 @@ public class ScriptCodegen { @NotNull private MemberCodegen memberCodegen; @NotNull - private ClosureAnnotator closureAnnotator; + private CodegenAnnotator codegenAnnotator; @NotNull private BindingContext bindingContext; @@ -84,8 +84,8 @@ public class ScriptCodegen { } @Inject - public void setClosureAnnotator(@NotNull ClosureAnnotator closureAnnotator) { - this.closureAnnotator = closureAnnotator; + public void setCodegenAnnotator(@NotNull CodegenAnnotator codegenAnnotator) { + this.codegenAnnotator = codegenAnnotator; } @Inject @@ -99,13 +99,13 @@ public class ScriptCodegen { ScriptDescriptor scriptDescriptor = state.getBindingContext().get(BindingContext.SCRIPT, scriptDeclaration); assert scriptDescriptor != null; - ClassDescriptor classDescriptorForScript = closureAnnotator.classDescriptorForScriptDescriptor(scriptDescriptor); + ClassDescriptor classDescriptorForScript = codegenAnnotator.classDescriptorForScriptDescriptor(scriptDescriptor); CodegenContext.ScriptContext context = (CodegenContext.ScriptContext) CodegenContext.STATIC .intoScript(scriptDescriptor, classDescriptorForScript); - JvmClassName className = closureAnnotator.classNameForClassDescriptor(classDescriptorForScript); + JvmClassName className = codegenAnnotator.classNameForClassDescriptor(classDescriptorForScript); ClassBuilder classBuilder = classFileFactory.newVisitor(className.getInternalName() + ".class"); classBuilder.defineClass(scriptDeclaration, @@ -151,7 +151,7 @@ public class ScriptCodegen { InstructionAdapter instructionAdapter = new InstructionAdapter(mv); - JvmClassName className = closureAnnotator.classNameForClassDescriptor(classDescriptorForScript); + JvmClassName className = codegenAnnotator.classNameForClassDescriptor(classDescriptorForScript); instructionAdapter.load(0, className.getAsmType()); instructionAdapter.invokespecial(JdkNames.JL_OBJECT.getInternalName(), "", "()V"); @@ -182,7 +182,7 @@ public class ScriptCodegen { int offset = 1; for (ScriptDescriptor earlierScript : importedScripts) { - JvmClassName earlierClassName = closureAnnotator.classNameForScriptDescriptor(earlierScript); + JvmClassName earlierClassName = codegenAnnotator.classNameForScriptDescriptor(earlierScript); instructionAdapter.load(0, className.getAsmType()); instructionAdapter.load(offset, earlierClassName.getAsmType()); offset += earlierClassName.getAsmType().getSize(); @@ -213,7 +213,7 @@ public class ScriptCodegen { private void genFieldsForParameters(@NotNull ScriptDescriptor script, @NotNull ClassBuilder classBuilder) { for (ScriptDescriptor earlierScript : earlierScripts) { - JvmClassName earlierClassName = closureAnnotator.classNameForScriptDescriptor(earlierScript); + JvmClassName earlierClassName = codegenAnnotator.classNameForScriptDescriptor(earlierScript); int access = Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL; classBuilder.newField(null, access, getScriptFieldName(earlierScript), earlierClassName.getDescriptor(), null, null); } @@ -236,7 +236,7 @@ public class ScriptCodegen { ScriptDescriptor earlierDescriptor = t.first; JvmClassName earlierClassName = t.second; - closureAnnotator.registerClassNameForScript(earlierDescriptor, earlierClassName); + codegenAnnotator.registerClassNameForScript(earlierDescriptor, earlierClassName); } List earlierScriptDescriptors = Lists.newArrayList(); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/context/ClosureAnnotator.java b/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenAnnotator.java similarity index 99% rename from compiler/backend/src/org/jetbrains/jet/codegen/context/ClosureAnnotator.java rename to compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenAnnotator.java index d77de3feae2..aa98624f811 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/context/ClosureAnnotator.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenAnnotator.java @@ -38,7 +38,7 @@ import java.util.*; /** * @author alex.tkachman */ -public class ClosureAnnotator { +public class CodegenAnnotator { private final Map closuresForClassDescriptor = new HashMap(); private final Map classNameForScript = new HashMap(); private final Set scriptClassNames = new HashSet(); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java b/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java index 3eb82b01d86..64789c0e6ce 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java @@ -179,7 +179,7 @@ public abstract class CodegenContext { ) { final JetTypeMapper typeMapper = expressionCodegen.getState().getInjector().getJetTypeMapper(); return new ClosureContext(typeMapper, funDescriptor, - typeMapper.getClosureAnnotator().classDescriptorForFunctionDescriptor(funDescriptor), + typeMapper.getCodegenAnnotator().classDescriptorForFunctionDescriptor(funDescriptor), this, expressionCodegen); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/context/LocalLookup.java b/compiler/backend/src/org/jetbrains/jet/codegen/context/LocalLookup.java index 4b6fa4a0915..10603ac3681 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/context/LocalLookup.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/context/LocalLookup.java @@ -74,7 +74,7 @@ public interface LocalLookup { if (!idx) return null; JetElement expression = (JetElement) BindingContextUtils.callableDescriptorToDeclaration(state.getBindingContext(), vd); - JvmClassName cn = state.getInjector().getJetTypeMapper().getClosureAnnotator().classNameForAnonymousClass(expression); + JvmClassName cn = state.getInjector().getJetTypeMapper().getCodegenAnnotator().classNameForAnonymousClass(expression); Type localType = cn.getAsmType(); final String fieldName = "$" + vd.getName(); diff --git a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java index f1a3fa6f2a0..fdc0ba5200d 100644 --- a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJetTypeMapper.java @@ -23,7 +23,7 @@ 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.jet.codegen.context.ClosureAnnotator; +import org.jetbrains.jet.codegen.context.CodegenAnnotator; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -35,7 +35,7 @@ public class InjectorForJetTypeMapper { private JetTypeMapper jetTypeMapper; private BuiltinToJavaTypesMapping builtinToJavaTypesMapping; private ClassBuilderMode classBuilderMode; - private ClosureAnnotator closureAnnotator; + private CodegenAnnotator codegenAnnotator; public InjectorForJetTypeMapper( @NotNull BindingContext bindingContext, @@ -46,15 +46,15 @@ public class InjectorForJetTypeMapper { this.jetTypeMapper = new JetTypeMapper(); this.builtinToJavaTypesMapping = BuiltinToJavaTypesMapping.ENABLED; this.classBuilderMode = ClassBuilderMode.FULL; - this.closureAnnotator = new ClosureAnnotator(); + this.codegenAnnotator = new CodegenAnnotator(); this.jetTypeMapper.setBindingContext(bindingContext); this.jetTypeMapper.setBuiltinToJavaTypesMapping(builtinToJavaTypesMapping); this.jetTypeMapper.setClassBuilderMode(classBuilderMode); - this.jetTypeMapper.setClosureAnnotator(closureAnnotator); + this.jetTypeMapper.setCodegenAnnotator(codegenAnnotator); - closureAnnotator.setBindingContext(bindingContext); - closureAnnotator.setFiles(listOfJetFile); + codegenAnnotator.setBindingContext(bindingContext); + codegenAnnotator.setFiles(listOfJetFile); } diff --git a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java index 41f664141b7..ea8838334c6 100644 --- a/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/di/InjectorForJvmCodegen.java @@ -31,7 +31,7 @@ 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.jet.codegen.context.ClosureAnnotator; +import org.jetbrains.jet.codegen.context.CodegenAnnotator; import org.jetbrains.annotations.NotNull; import javax.annotation.PreDestroy; @@ -51,7 +51,7 @@ public class InjectorForJvmCodegen { private IntrinsicMethods intrinsics; private ClassFileFactory classFileFactory; private MemberCodegen memberCodegen; - private ClosureAnnotator closureAnnotator; + private CodegenAnnotator codegenAnnotator; public InjectorForJvmCodegen( @NotNull BindingContext bindingContext, @@ -75,19 +75,19 @@ public class InjectorForJvmCodegen { this.intrinsics = new IntrinsicMethods(); this.classFileFactory = new ClassFileFactory(); this.memberCodegen = new MemberCodegen(); - this.closureAnnotator = new ClosureAnnotator(); + this.codegenAnnotator = new CodegenAnnotator(); this.jetTypeMapper.setBindingContext(bindingContext); this.jetTypeMapper.setBuiltinToJavaTypesMapping(builtinToJavaTypesMapping); this.jetTypeMapper.setClassBuilderMode(classBuilderMode); - this.jetTypeMapper.setClosureAnnotator(closureAnnotator); + this.jetTypeMapper.setCodegenAnnotator(codegenAnnotator); this.classCodegen.setJetTypeMapper(jetTypeMapper); this.classCodegen.setState(generationState); this.scriptCodegen.setBindingContext(bindingContext); this.scriptCodegen.setClassFileFactory(classFileFactory); - this.scriptCodegen.setClosureAnnotator(closureAnnotator); + this.scriptCodegen.setCodegenAnnotator(codegenAnnotator); this.scriptCodegen.setJetTypeMapper(jetTypeMapper); this.scriptCodegen.setMemberCodegen(memberCodegen); this.scriptCodegen.setState(generationState); @@ -97,8 +97,8 @@ public class InjectorForJvmCodegen { this.memberCodegen.setState(generationState); - this.closureAnnotator.setBindingContext(bindingContext); - this.closureAnnotator.setFiles(listOfJetFile); + this.codegenAnnotator.setBindingContext(bindingContext); + this.codegenAnnotator.setFiles(listOfJetFile); intrinsics.init(); @@ -140,8 +140,8 @@ public class InjectorForJvmCodegen { return this.memberCodegen; } - public ClosureAnnotator getClosureAnnotator() { - return this.closureAnnotator; + public CodegenAnnotator getCodegenAnnotator() { + return this.codegenAnnotator; } } diff --git a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java index 565c78aeaf8..6e0a0a2dd5d 100644 --- a/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java +++ b/idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java @@ -142,7 +142,7 @@ public class JetPositionManager implements PositionManager { result.set(getJvmInternalNameForImpl(typeMapper, (JetClassOrObject) element)); } else if (element instanceof JetFunctionLiteralExpression) { - result.set(typeMapper.getClosureAnnotator().classNameForAnonymousClass((JetFunctionLiteralExpression) element).getInternalName()); + result.set(typeMapper.getCodegenAnnotator().classNameForAnonymousClass((JetFunctionLiteralExpression) element).getInternalName()); } else if (element instanceof JetNamedFunction) { PsiElement parent = PsiTreeUtil.getParentOfType(element, JetClassOrObject.class, JetFunctionLiteralExpression.class, JetNamedFunction.class); @@ -150,13 +150,13 @@ public class JetPositionManager implements PositionManager { result.set(getJvmInternalNameForImpl(typeMapper, (JetClassOrObject) parent)); } else if (parent instanceof JetFunctionLiteralExpression || parent instanceof JetNamedFunction) { - result.set(typeMapper.getClosureAnnotator().classNameForAnonymousClass((JetElement) element).getInternalName()); + result.set(typeMapper.getCodegenAnnotator().classNameForAnonymousClass((JetElement) element).getInternalName()); } } if (result.isNull()) { FqName fqName = JetPsiUtil.getFQName(namespace); - boolean multiFileNamespace = typeMapper.getClosureAnnotator().isMultiFileNamespace(fqName); + boolean multiFileNamespace = typeMapper.getCodegenAnnotator().isMultiFileNamespace(fqName); String namespaceInternalName = NamespaceCodegen.getJVMClassNameForKotlinNs(fqName).getInternalName(); if (multiFileNamespace) { result.set(NamespaceCodegen.getMultiFileNamespaceInternalName(namespaceInternalName, namespace)); @@ -200,7 +200,7 @@ public class JetPositionManager implements PositionManager { List namespaceFiles = JetFilesProvider.getInstance(file.getProject()).allNamespaceFiles().fun(file); JetTypeMapper typeMapper = new InjectorForJetTypeMapper(analyzeExhaust.getBindingContext(), namespaceFiles).getJetTypeMapper(); - typeMapper.getClosureAnnotator().init(); + typeMapper.getCodegenAnnotator().init(); 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 78d4722d7a8..61b32ce4d6f 100644 --- a/idea/tests/org/jetbrains/jet/plugin/debugger/JetPositionManagerTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/debugger/JetPositionManagerTest.java @@ -45,7 +45,7 @@ public class JetPositionManagerTest extends PositionManagerTestCase { assertNotNull(positionManager); JetTypeMapper typeMapper = new InjectorForJetTypeMapper(state.getBindingContext(), files).getJetTypeMapper(); - typeMapper.getClosureAnnotator().init(); + typeMapper.getCodegenAnnotator().init(); 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 77f39e0feef..e630747126d 100644 --- a/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java +++ b/injector-generator/src/org/jetbrains/jet/di/AllInjectorsGenerator.java @@ -18,7 +18,7 @@ package org.jetbrains.jet.di; import com.intellij.openapi.project.Project; import org.jetbrains.jet.codegen.*; -import org.jetbrains.jet.codegen.context.ClosureAnnotator; +import org.jetbrains.jet.codegen.context.CodegenAnnotator; import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethods; import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode; import org.jetbrains.jet.lang.ModuleConfiguration; @@ -45,6 +45,9 @@ import java.io.IOException; // To do that, you can run either this class, or /build.xml/generateInjectors task public class AllInjectorsGenerator { + private AllInjectorsGenerator() { + } + public static void main(String[] args) throws IOException { generateInjectorForTopDownAnalyzerBasic(); generateInjectorForTopDownAnalyzerForJvm(); @@ -201,7 +204,7 @@ public class AllInjectorsGenerator { generator.addField(true, IntrinsicMethods.class, "intrinsics", null); generator.addPublicField(ClassFileFactory.class); generator.addPublicField(MemberCodegen.class); - generator.addPublicField(ClosureAnnotator.class); + generator.addPublicField(CodegenAnnotator.class); generator.generate("compiler/backend/src", "org.jetbrains.jet.di", "InjectorForJvmCodegen"); }