azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ClosureAnnotator renamed to CodegenAnnotator

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