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

Add JetTypeMapper.mapClass

Browse Source 
Should be used instead of "mapType(*.getDefaultType(), IMPL)" pattern
This commit is contained in:
Alexander Udalov
2013-10-16 19:32:57 +04:00
parent d22edcdbb3
commit af2a52bd4e
9 changed files with 45 additions and 86 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/jet/codegen/ClassFileFactory.java
+1 -2
View File
@@ -26,7 +26,6 @@ import org.jetbrains.annotations.NotNull;
import org.jetbrains.asm4.Type;
import org.jetbrains.jet.codegen.state.GenerationState;
import org.jetbrains.jet.codegen.state.GenerationStateAware;
import org.jetbrains.jet.codegen.state.JetTypeMapperMode;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -147,7 +146,7 @@ public final class ClassFileFactory extends GenerationStateAware {
}
public ClassBuilder forClassImplementation(ClassDescriptor aClass, PsiFile sourceFile) {
Type type = state.getTypeMapper().mapType(aClass.getDefaultType(), JetTypeMapperMode.IMPL);
Type type = state.getTypeMapper().mapClass(aClass);
if (isPrimitive(type)) {
throw new IllegalStateException("Codegen for primitive type is not possible: " + aClass);
}
compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java
+1 -3
View File
@@ -40,7 +40,6 @@ import org.jetbrains.jet.codegen.intrinsics.IntrinsicMethod;
import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
import org.jetbrains.jet.codegen.state.GenerationState;
import org.jetbrains.jet.codegen.state.JetTypeMapper;
import org.jetbrains.jet.codegen.state.JetTypeMapperMode;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
import org.jetbrains.jet.lang.psi.*;
@@ -1377,8 +1376,7 @@ public class ExpressionCodegen extends JetVisitor<StackValue, StackValue> implem
ClassifierDescriptor captureReceiver = closure.getCaptureReceiver();
if (captureReceiver != null) {
Type asmType = typeMapper.mapType(captureReceiver.getDefaultType(), JetTypeMapperMode.IMPL);
v.load(context.isStatic() ? 0 : 1, asmType);
v.load(context.isStatic() ? 0 : 1, typeMapper.mapClass(captureReceiver));
}
}
compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java
+1 -4
View File
@@ -31,15 +31,12 @@ import org.jetbrains.asm4.commons.Method;
import org.jetbrains.jet.codegen.binding.CodegenBinding;
import org.jetbrains.jet.codegen.context.CodegenContext;
import org.jetbrains.jet.codegen.context.MethodContext;
import org.jetbrains.jet.codegen.context.NamespaceContext;
import org.jetbrains.jet.codegen.context.NamespaceFacadeContext;
import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind;
import org.jetbrains.jet.codegen.signature.JvmMethodParameterSignature;
import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
import org.jetbrains.jet.codegen.state.GenerationState;
import org.jetbrains.jet.codegen.state.GenerationStateAware;
import org.jetbrains.jet.codegen.state.JetTypeMapper;
import org.jetbrains.jet.codegen.state.JetTypeMapperMode;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.psi.JetNamedFunction;
import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -549,7 +546,7 @@ public class FunctionCodegen extends ParentCodegenAwareImpl {
ownerType = state.getTypeMapper().getOwner(functionDescriptor, kind, true);
}
else if (contextClass instanceof ClassDescriptor) {
ownerType = state.getTypeMapper().mapType(((ClassDescriptor) contextClass).getDefaultType(), JetTypeMapperMode.IMPL);
ownerType = state.getTypeMapper().mapClass((ClassDescriptor) contextClass);
}
else if (isLocalNamedFun(functionDescriptor)) {
ownerType = asmTypeForAnonymousClass(state.getBindingContext(), functionDescriptor);
compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
+20 -33
View File
@@ -97,7 +97,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
@Nullable MemberCodegen parentCodegen
) {
super(aClass, context, v, state, parentCodegen);
this.classAsmType = typeMapper.mapType(descriptor.getDefaultType(), JetTypeMapperMode.IMPL);
this.classAsmType = typeMapper.mapClass(descriptor);
this.functionCodegen = new FunctionCodegen(context, v, state, this);
this.propertyCodegen = new PropertyCodegen(context, v, this.functionCodegen, this);
}
@@ -261,19 +261,15 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
}
@NotNull
private static String getOuterClassName(
@NotNull ClassDescriptor classDescriptor,
@NotNull JetTypeMapper typeMapper
) {
private static String getOuterClassName(@NotNull ClassDescriptor classDescriptor, @NotNull JetTypeMapper typeMapper) {
ClassDescriptor container = DescriptorUtils.getParentOfType(classDescriptor, ClassDescriptor.class);
if (container != null) {
return typeMapper.mapType(container.getDefaultType(), JetTypeMapperMode.IMPL).getInternalName();
}
else {
JetFile containingFile = BindingContextUtils.getContainingFile(typeMapper.getBindingContext(), classDescriptor);
assert containingFile != null : "Containing file should be present for " + classDescriptor;
return NamespaceCodegen.getNamespacePartInternalName(containingFile);
return typeMapper.mapClass(container).getInternalName();
}
JetFile containingFile = BindingContextUtils.getContainingFile(typeMapper.getBindingContext(), classDescriptor);
assert containingFile != null : "Containing file should be present for " + classDescriptor;
return NamespaceCodegen.getNamespacePartInternalName(containingFile);
}
private void writeInnerClasses() {
@@ -342,7 +338,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
@NotNull
private String getInternalNameForImpl(@NotNull ClassDescriptor descriptor) {
return typeMapper.mapType(descriptor.getDefaultType(), JetTypeMapperMode.IMPL).getInternalName();
return typeMapper.mapClass(descriptor).getInternalName();
}
private JvmClassSignature signature() {
@@ -416,7 +412,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
assert superClassDescriptor != null;
if (!isInterface(superClassDescriptor)) {
superClassType = superType;
superClassAsmType = typeMapper.mapType(superClassDescriptor.getDefaultType(), JetTypeMapperMode.IMPL);
superClassAsmType = typeMapper.mapClass(superClassDescriptor);
superCall = specifier;
}
}
@@ -921,23 +917,17 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
private void generateEnumMethods() {
if (myEnumConstants.size() > 0) {
{
Type type =
typeMapper.mapType(KotlinBuiltIns.getInstance().getArrayType(descriptor.getDefaultType()),
JetTypeMapperMode.IMPL);
Type type = typeMapper.mapType(KotlinBuiltIns.getInstance().getArrayType(descriptor.getDefaultType()));
MethodVisitor mv =
v.newMethod(myClass, ACC_PUBLIC | ACC_STATIC, "values", "()" + type.getDescriptor(), null, null);
MethodVisitor mv = v.newMethod(myClass, ACC_PUBLIC | ACC_STATIC, "values", "()" + type.getDescriptor(), null, null);
mv.visitCode();
mv.visitFieldInsn(GETSTATIC, typeMapper.mapType(descriptor).getInternalName(),
VALUES,
type.getDescriptor());
mv.visitFieldInsn(GETSTATIC, classAsmType.getInternalName(), VALUES, type.getDescriptor());
mv.visitMethodInsn(INVOKEVIRTUAL, type.getInternalName(), "clone", "()Ljava/lang/Object;");
mv.visitTypeInsn(CHECKCAST, type.getInternalName());
mv.visitInsn(ARETURN);
FunctionCodegen.endVisit(mv, "values()", myClass);
}
{
MethodVisitor mv =
v.newMethod(myClass, ACC_PUBLIC | ACC_STATIC, "valueOf", "(Ljava/lang/String;)" + classAsmType.getDescriptor(), null,
null);
@@ -1623,16 +1613,13 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
private void initializeEnumConstants(ExpressionCodegen codegen) {
InstructionAdapter iv = codegen.v;
int ordinal = -1;
JetType myType = descriptor.getDefaultType();
Type myAsmType = typeMapper.mapType(myType, JetTypeMapperMode.IMPL);
assert myEnumConstants.size() > 0;
JetType arrayType = KotlinBuiltIns.getInstance().getArrayType(myType);
Type arrayAsmType = typeMapper.mapType(arrayType, JetTypeMapperMode.IMPL);
v.newField(myClass, ACC_PRIVATE | ACC_STATIC | ACC_FINAL | ACC_SYNTHETIC, "$VALUES", arrayAsmType.getDescriptor(), null, null);
Type arrayAsmType = typeMapper.mapType(KotlinBuiltIns.getInstance().getArrayType(descriptor.getDefaultType()));
v.newField(myClass, ACC_PRIVATE | ACC_STATIC | ACC_FINAL | ACC_SYNTHETIC, VALUES, arrayAsmType.getDescriptor(), null, null);
iv.iconst(myEnumConstants.size());
iv.newarray(myAsmType);
iv.newarray(classAsmType);
iv.dup();
for (JetEnumEntry enumConstant : myEnumConstants) {
@@ -1643,14 +1630,14 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
ClassDescriptor classDescriptor = bindingContext.get(BindingContext.CLASS, enumConstant);
assert classDescriptor != null;
String implClass = typeMapper.mapType(classDescriptor.getDefaultType(), JetTypeMapperMode.IMPL).getInternalName();
Type implClass = typeMapper.mapClass(classDescriptor);
List<JetDelegationSpecifier> delegationSpecifiers = enumConstant.getDelegationSpecifiers();
if (delegationSpecifiers.size() > 1) {
throw new UnsupportedOperationException("multiple delegation specifiers for enum constant not supported");
}
iv.anew(Type.getObjectType(implClass));
iv.anew(implClass);
iv.dup();
iv.aconst(enumConstant.getName());
@@ -1673,13 +1660,13 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
}
}
else {
iv.invokespecial(implClass, "<init>", "(Ljava/lang/String;I)V");
iv.invokespecial(implClass.getInternalName(), "<init>", "(Ljava/lang/String;I)V");
}
iv.dup();
iv.putstatic(myAsmType.getInternalName(), enumConstant.getName(), "L" + myAsmType.getInternalName() + ";");
iv.putstatic(classAsmType.getInternalName(), enumConstant.getName(), classAsmType.getDescriptor());
iv.astore(OBJECT_TYPE);
}
iv.putstatic(myAsmType.getInternalName(), "$VALUES", arrayAsmType.getDescriptor());
iv.putstatic(classAsmType.getInternalName(), VALUES, arrayAsmType.getDescriptor());
}
public static void generateInitializers(
compiler/backend/src/org/jetbrains/jet/codegen/SamWrapperCodegen.java
+1 -3
View File
@@ -23,8 +23,6 @@ import org.jetbrains.asm4.Type;
import org.jetbrains.asm4.commons.InstructionAdapter;
import org.jetbrains.jet.codegen.context.CodegenContext;
import org.jetbrains.jet.codegen.state.GenerationState;
import org.jetbrains.jet.codegen.state.GenerationStateAware;
import org.jetbrains.jet.codegen.state.JetTypeMapperMode;
import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.descriptors.SimpleFunctionDescriptor;
@@ -79,7 +77,7 @@ public class SamWrapperCodegen extends ParentCodegenAwareImpl {
cv.visitSource(file.getName(), null);
// e.g. ASM type for Function2
Type functionAsmType = state.getTypeMapper().mapType(functionType, JetTypeMapperMode.VALUE);
Type functionAsmType = state.getTypeMapper().mapType(functionType);
cv.newField(null,
ACC_SYNTHETIC | ACC_PRIVATE | ACC_FINAL,
compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java
+11 -10
View File
@@ -73,10 +73,7 @@ public class JetTypeMapper extends BindingTraceAware {
}
else if (containingDeclaration instanceof ClassDescriptor) {
ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration;
if (kind == OwnerKind.TRAIT_IMPL) {
return mapTraitImpl(classDescriptor);
}
return mapType(classDescriptor.getDefaultType(), JetTypeMapperMode.IMPL);
return kind == OwnerKind.TRAIT_IMPL ? mapTraitImpl(classDescriptor) : mapClass(classDescriptor);
}
else if (containingDeclaration instanceof ScriptDescriptor) {
return asmTypeForScriptDescriptor(bindingContext, (ScriptDescriptor) containingDeclaration);
@@ -196,10 +193,15 @@ public class JetTypeMapper extends BindingTraceAware {
}
@NotNull
public Type mapType(@NotNull JetType jetType, @NotNull JetTypeMapperMode kind) {
private Type mapType(@NotNull JetType jetType, @NotNull JetTypeMapperMode kind) {
return mapType(jetType, null, kind);
}
@NotNull
public Type mapClass(@NotNull ClassifierDescriptor classifier) {
return mapType(classifier.getDefaultType(), null, JetTypeMapperMode.IMPL);
}
@NotNull
public Type mapType(@NotNull JetType jetType) {
return mapType(jetType, null, JetTypeMapperMode.VALUE);
@@ -474,8 +476,7 @@ public class JetTypeMapper extends BindingTraceAware {
}
else if (functionDescriptor instanceof ConstructorDescriptor) {
assert !superCall;
ClassDescriptor containingClass = (ClassDescriptor) functionParent;
owner = mapType(containingClass.getDefaultType(), JetTypeMapperMode.IMPL);
owner = mapClass((ClassDescriptor) functionParent);
ownerForDefaultImpl = ownerForDefaultParam = owner;
invokeOpcode = INVOKESPECIAL;
thisClass = null;
@@ -911,10 +912,10 @@ public class JetTypeMapper extends BindingTraceAware {
@NotNull
public CallableMethod mapToCallableMethod(@NotNull ConstructorDescriptor descriptor, @Nullable CalculatedClosure closure) {
JvmMethodSignature method = mapConstructorSignature(descriptor, closure);
JetType defaultType = descriptor.getContainingDeclaration().getDefaultType();
Type owner = mapType(defaultType, JetTypeMapperMode.IMPL);
ClassDescriptor container = descriptor.getContainingDeclaration();
Type owner = mapClass(container);
if (owner.getSort() != Type.OBJECT) {
throw new IllegalStateException("type must have been mapped to object: " + defaultType + ", actual: " + owner);
throw new IllegalStateException("type must have been mapped to object: " + container.getDefaultType() + ", actual: " + owner);
}
return new CallableMethod(owner, owner, owner, method, INVOKESPECIAL, null, null, null);
}
compiler/tests/org/jetbrains/jet/codegen/TestlibTest.java
+9 -21
View File
@@ -17,7 +17,6 @@
package org.jetbrains.jet.codegen;
import com.intellij.testFramework.UsefulTestCase;
import gnu.trove.THashSet;
import junit.extensions.TestSetup;
import junit.framework.Test;
import junit.framework.TestCase;
@@ -34,7 +33,6 @@ import org.jetbrains.jet.cli.jvm.compiler.KotlinToJVMBytecodeCompiler;
import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
import org.jetbrains.jet.codegen.state.GenerationState;
import org.jetbrains.jet.codegen.state.JetTypeMapper;
import org.jetbrains.jet.codegen.state.JetTypeMapperMode;
import org.jetbrains.jet.config.CommonConfigurationKeys;
import org.jetbrains.jet.config.CompilerConfiguration;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
@@ -43,14 +41,11 @@ import org.jetbrains.jet.lang.psi.JetDeclaration;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.types.JetType;
import java.io.File;
import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Set;
@SuppressWarnings("JUnitTestCaseWithNoTests")
public class TestlibTest extends UsefulTestCase {
@@ -123,22 +118,16 @@ public class TestlibTest extends UsefulTestCase {
typeMapper = generationState.getTypeMapper();
for (JetFile jetFile : myEnvironment.getSourceFiles()) {
for (JetDeclaration decl : jetFile.getDeclarations()) {
if (decl instanceof JetClass) {
JetClass jetClass = (JetClass) decl;
for (JetDeclaration declaration : jetFile.getDeclarations()) {
if (declaration instanceof JetClass) {
ClassDescriptor descriptor = (ClassDescriptor) generationState.getBindingContext().get(
BindingContext.DECLARATION_TO_DESCRIPTOR, jetClass);
BindingContext.DECLARATION_TO_DESCRIPTOR, declaration);
assertNotNull("Descriptor for declaration " + jetClass + " shouldn't be null", descriptor);
assertNotNull("Descriptor for declaration " + declaration + " shouldn't be null", descriptor);
Set<JetType> allSuperTypes = new THashSet<JetType>();
DescriptorUtils.addSuperTypes(descriptor.getDefaultType(), allSuperTypes);
for (JetType type : allSuperTypes) {
String internalName = typeMapper.mapType(type, JetTypeMapperMode.IMPL).getInternalName();
if (internalName.equals("junit/framework/Test")) {
String name = typeMapper.mapType(descriptor.getDefaultType(), JetTypeMapperMode.IMPL).getInternalName();
for (ClassDescriptor superClass : DescriptorUtils.getAllSuperClasses(descriptor)) {
if ("junit/framework/Test".equals(typeMapper.mapClass(superClass).getInternalName())) {
String name = typeMapper.mapClass(descriptor).getInternalName();
//noinspection UseOfSystemOutOrSystemErr
System.out.println(name);
@@ -146,10 +135,9 @@ public class TestlibTest extends UsefulTestCase {
@SuppressWarnings("unchecked")
Class<TestCase> aClass = (Class<TestCase>) classLoader.loadClass(name.replace('/', '.'));
if ((aClass.getModifiers() & Modifier.ABSTRACT) == 0 && (aClass.getModifiers() & Modifier.PUBLIC) != 0) {
if (!Modifier.isAbstract(aClass.getModifiers()) && Modifier.isPublic(aClass.getModifiers())) {
try {
Constructor<TestCase> constructor = aClass.getConstructor();
if ((constructor.getModifiers() & Modifier.PUBLIC) != 0) {
if (Modifier.isPublic(aClass.getConstructor().getModifiers())) {
suite.addTestSuite(aClass);
}
}
core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java
-8
View File
@@ -220,14 +220,6 @@ public class DescriptorUtils {
return false;
}
public static void addSuperTypes(@NotNull JetType type, @NotNull Set<JetType> set) {
set.add(type);
for (JetType jetType : type.getConstructor().getSupertypes()) {
addSuperTypes(jetType, set);
}
}
public static boolean isRootNamespace(@NotNull NamespaceDescriptor namespaceDescriptor) {
return namespaceDescriptor.getContainingDeclaration() instanceof ModuleDescriptor;
}
idea/src/org/jetbrains/jet/plugin/debugger/JetPositionManager.java
+1 -2
View File
@@ -40,7 +40,6 @@ import org.jetbrains.jet.codegen.ClassBuilderMode;
import org.jetbrains.jet.codegen.NamespaceCodegen;
import org.jetbrains.jet.codegen.binding.CodegenBinding;
import org.jetbrains.jet.codegen.state.JetTypeMapper;
import org.jetbrains.jet.codegen.state.JetTypeMapperMode;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -174,7 +173,7 @@ public class JetPositionManager implements PositionManager {
return typeMapper.mapTraitImpl(classDescriptor).getInternalName();
}
return typeMapper.mapType(classDescriptor.getDefaultType(), JetTypeMapperMode.IMPL).getInternalName();
return typeMapper.mapClass(classDescriptor).getInternalName();
}
private JetTypeMapper prepareTypeMapper(final JetFile file) {