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()) {
if (declaration instanceof JetClass) {
if (declaration instanceof JetEnumEntry && !state.getInjector().getClosureAnnotator().enumEntryNeedSubclass(
if (declaration instanceof JetEnumEntry && !state.getInjector().getCodegenAnnotator().enumEntryNeedSubclass(
(JetEnumEntry) declaration)) {
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.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();
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) {
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<StackValue, StackValue> 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<StackValue, StackValue> 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<StackValue, StackValue> 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) {
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) {
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);
compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
+4 -4
View File
@@ -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("<init>", 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;
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.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
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) {
boolean multiFile = state.getInjector().getClosureAnnotator().isMultiFileNamespace(name);
boolean multiFile = state.getInjector().getCodegenAnnotator().isMultiFileNamespace(name);
for (JetFile file : files) {
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.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(), "<init>", "()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<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
*/
public class ClosureAnnotator {
public class CodegenAnnotator {
private final Map<ClassDescriptor, CalculatedClosure> closuresForClassDescriptor = new HashMap<ClassDescriptor, CalculatedClosure>();
private final Map<ScriptDescriptor, JvmClassName> classNameForScript = new HashMap<ScriptDescriptor, 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();
return new ClosureContext(typeMapper, funDescriptor,
typeMapper.getClosureAnnotator().classDescriptorForFunctionDescriptor(funDescriptor),
typeMapper.getCodegenAnnotator().classDescriptorForFunctionDescriptor(funDescriptor),
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;
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();
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.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);
}
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.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;
}
}
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));
}
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<JetFile> 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<JetTypeMapper>(typeMapper, PsiModificationTracker.MODIFICATION_COUNT);
}
}, 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);
JetTypeMapper typeMapper = new InjectorForJetTypeMapper(state.getBindingContext(), files).getJetTypeMapper();
typeMapper.getClosureAnnotator().init();
typeMapper.getCodegenAnnotator().init();
for (JetFile file : files) {
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 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");
}