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

Delete almost all code related to signature writing

Browse Source 
Delete org.jetbrains.jet.rt.signature and jet.typeinfo packages from runtime,
refactor BothSignatureWriter so that it now writes only java generic signature
and saves parameter types and kinds
This commit is contained in:
Alexander Udalov
2013-07-24 15:28:18 +04:00
committed by Pavel V. Talanov
parent 5d647cac94
commit 763572663e
19 changed files with 77 additions and 1368 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/jet/codegen/ClosureCodegen.java
-2
View File
@@ -298,11 +298,9 @@ public class ClosureCodegen extends GenerationStateAware {
BothSignatureWriter sw = new BothSignatureWriter(BothSignatureWriter.Mode.CLASS, true);
typeMapper.writeFormalTypeParameters(Collections.<TypeParameterDescriptor>emptyList(), sw);
sw.writeSupersStart();
sw.writeSuperclass();
typeMapper.mapType(supertype, sw, JetTypeMapperMode.TYPE_PARAMETER);
sw.writeSuperclassEnd();
sw.writeSupersEnd();
String signature = sw.makeJavaGenericSignature();
assert signature != null : "Closure superclass must have a generic signature: " + funDescriptor;
compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java
+2 -8
View File
@@ -105,12 +105,8 @@ public class CodegenUtil {
public static JvmMethodSignature erasedInvokeSignature(FunctionDescriptor fd) {
BothSignatureWriter signatureWriter = new BothSignatureWriter(BothSignatureWriter.Mode.METHOD, false);
signatureWriter.writeFormalTypeParametersStart();
signatureWriter.writeFormalTypeParametersEnd();
boolean isExtensionFunction = fd.getReceiverParameter() != null;
int paramCount = fd.getValueParameters().size();
if (isExtensionFunction) {
@@ -121,14 +117,12 @@ public class CodegenUtil {
for (int i = 0; i < paramCount; ++i) {
signatureWriter.writeParameterType(JvmMethodParameterKind.VALUE);
signatureWriter.writeAsmType(OBJECT_TYPE, true);
signatureWriter.writeAsmType(OBJECT_TYPE);
signatureWriter.writeParameterTypeEnd();
}
signatureWriter.writeParametersEnd();
signatureWriter.writeReturnType();
signatureWriter.writeAsmType(OBJECT_TYPE, true);
signatureWriter.writeAsmType(OBJECT_TYPE);
signatureWriter.writeReturnTypeEnd();
return signatureWriter.makeJvmMethodSignature("invoke");
compiler/backend/src/org/jetbrains/jet/codegen/ConstructorFrameMap.java
+9 -14
View File
@@ -21,8 +21,6 @@ import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind;
import org.jetbrains.jet.codegen.signature.JvmMethodParameterSignature;
import org.jetbrains.jet.codegen.signature.JvmMethodSignature;
import java.util.List;
import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.OBJECT_TYPE;
public class ConstructorFrameMap extends FrameMap {
@@ -31,18 +29,15 @@ public class ConstructorFrameMap extends FrameMap {
public ConstructorFrameMap(@NotNull JvmMethodSignature signature) {
enterTemp(OBJECT_TYPE); // this
List<JvmMethodParameterSignature> parameterTypes = signature.getKotlinParameterTypes();
if (parameterTypes != null) {
for (JvmMethodParameterSignature parameterType : parameterTypes) {
if (parameterType.getKind() == JvmMethodParameterKind.OUTER) {
myOuterThisIndex = enterTemp(OBJECT_TYPE); // this0
}
else if (parameterType.getKind() != JvmMethodParameterKind.VALUE) {
enterTemp(parameterType.getAsmType());
}
else {
break;
}
for (JvmMethodParameterSignature parameterType : signature.getKotlinParameterTypes()) {
if (parameterType.getKind() == JvmMethodParameterKind.OUTER) {
myOuterThisIndex = enterTemp(OBJECT_TYPE); // this0
}
else if (parameterType.getKind() != JvmMethodParameterKind.VALUE) {
enterTemp(parameterType.getAsmType());
}
else {
break;
}
}
}
compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java
+3 -13
View File
@@ -355,12 +355,10 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
typeMapper.writeFormalTypeParameters(typeParameters, signatureVisitor);
}
signatureVisitor.writeSupersStart();
{ // superclass
signatureVisitor.writeSuperclass();
if (superClassType == null) {
signatureVisitor.writeClassBegin(superClassAsmType.getInternalName(), false, false);
signatureVisitor.writeClassBegin(superClassAsmType);
signatureVisitor.writeClassEnd();
}
else {
@@ -388,16 +386,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
superInterfaces = new ArrayList<String>(superInterfacesLinkedHashSet);
}
signatureVisitor.writeSupersEnd();
return new JvmClassSignature(jvmName(), superClassAsmType.getInternalName(), superInterfaces, signatureVisitor.makeJavaGenericSignature());
}
private String jvmName() {
if (kind != OwnerKind.IMPLEMENTATION) {
throw new IllegalStateException("must not call this method with kind " + kind);
}
return classAsmType.getInternalName();
return new JvmClassSignature(classAsmType.getInternalName(), superClassAsmType.getInternalName(), superInterfaces,
signatureVisitor.makeJavaGenericSignature());
}
protected void getSuperClass() {
compiler/backend/src/org/jetbrains/jet/codegen/signature/BothSignatureWriter.java
+30 -274
View File
@@ -25,22 +25,13 @@ import org.jetbrains.asm4.signature.SignatureVisitor;
import org.jetbrains.asm4.signature.SignatureWriter;
import org.jetbrains.asm4.util.CheckSignatureAdapter;
import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants;
import org.jetbrains.jet.lang.resolve.java.JetSignatureUtils;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.Variance;
import org.jetbrains.jet.rt.signature.JetSignatureAdapter;
import org.jetbrains.jet.rt.signature.JetSignatureReader;
import org.jetbrains.jet.rt.signature.JetSignatureVariance;
import org.jetbrains.jet.rt.signature.JetSignatureWriter;
import java.util.ArrayList;
import java.util.List;
public class BothSignatureWriter {
private static final boolean DEBUG_SIGNATURE_WRITER = true;
public enum Mode {
METHOD(CheckSignatureAdapter.METHOD_SIGNATURE),
CLASS(CheckSignatureAdapter.CLASS_SIGNATURE),
@@ -53,27 +44,9 @@ public class BothSignatureWriter {
}
}
private enum State {
START,
TYPE_PARAMETERS,
PARAMETERS,
PARAMETER,
RETURN_TYPE,
METHOD_END,
FIELD,
FIELD_END,
SUPERS,
CLASS_END,
}
private final SignatureWriter signatureWriter = new SignatureWriter();
private final SignatureVisitor signatureVisitor;
private JetSignatureWriter jetSignatureWriter;
private final List<JvmMethodParameterSignature> kotlinParameterTypes = new ArrayList<JvmMethodParameterSignature>();
private int jvmCurrentTypeArrayLevel;
@@ -82,26 +55,16 @@ public class BothSignatureWriter {
private JvmMethodParameterKind currentParameterKind;
private final Mode mode;
private final boolean needGenerics;
private State state = State.START;
private boolean generic = false;
public BothSignatureWriter(Mode mode, boolean needGenerics) {
this.mode = mode;
this.needGenerics = needGenerics;
if (DEBUG_SIGNATURE_WRITER) {
signatureVisitor = new CheckSignatureAdapter(mode.asmType, signatureWriter);
}
else {
signatureVisitor = signatureWriter;
}
this.signatureVisitor = new CheckSignatureAdapter(mode.asmType, signatureWriter);
}
// TODO: ignore when debugging is disabled
private final Stack<SignatureVisitor> visitors = new Stack<SignatureVisitor>();
private void push(SignatureVisitor visitor) {
@@ -112,96 +75,39 @@ public class BothSignatureWriter {
visitors.pop();
}
private SignatureVisitor signatureVisitor() {
return !visitors.isEmpty() ? visitors.peek() : signatureVisitor;
}
private void checkTopLevel() {
if (DEBUG_SIGNATURE_WRITER) {
if (!visitors.isEmpty()) {
throw new IllegalStateException();
}
}
}
private void checkMode(Mode mode) {
if (DEBUG_SIGNATURE_WRITER) {
if (mode != this.mode) {
throw new IllegalStateException();
}
}
}
private void checkState(State state) {
if (DEBUG_SIGNATURE_WRITER) {
if (state != this.state) {
throw new IllegalStateException();
}
if (jetSignatureWriter != null) {
throw new IllegalStateException();
}
checkTopLevel();
}
}
private void transitionState(State from, State to) {
checkState(from);
state = to;
}
public void writeAsmType(Type asmType, boolean nullable) {
writeAsmType(asmType, nullable, null);
}
/**
* Shortcut
*/
public void writeAsmType(Type asmType, boolean nullable, @Nullable String kotlinTypeName) {
public void writeAsmType(Type asmType) {
switch (asmType.getSort()) {
case Type.OBJECT:
writeClassBegin(asmType.getInternalName(), nullable, false, kotlinTypeName);
writeClassBegin(asmType);
writeClassEnd();
return;
case Type.ARRAY:
writeArrayType(nullable, Variance.INVARIANT);
writeAsmType(asmType.getElementType(), false, kotlinTypeName);
writeArrayType();
writeAsmType(asmType.getElementType());
writeArrayEnd();
return;
default:
String descriptor = asmType.getDescriptor();
if (descriptor.length() != 1) {
throw new IllegalStateException();
}
writeBaseType(descriptor.charAt(0), nullable);
signatureVisitor().visitBaseType(asmType.getDescriptor().charAt(0));
writeAsmType0(asmType);
}
}
private void writeBaseType(char c, boolean nullable) {
if (nullable) {
throw new IllegalStateException();
}
signatureVisitor().visitBaseType(c);
jetSignatureWriter.visitBaseType(c, nullable);
writeAsmType0(Type.getType(String.valueOf(c)));
public void writeNothing() {
signatureVisitor().visitBaseType('V');
writeAsmType0(Type.VOID_TYPE);
}
public void writeNothing(boolean nullable) {
if (nullable) {
signatureVisitor().visitClassType("java/lang/Object");
signatureVisitor().visitEnd();
}
else {
signatureVisitor().visitBaseType('V');
}
jetSignatureWriter.visitClassType("jet/Nothing", nullable, false);
jetSignatureWriter.visitEnd();
if (nullable) {
writeAsmType0(AsmTypeConstants.OBJECT_TYPE);
}
else {
writeAsmType0(Type.VOID_TYPE);
}
public void writeNullableNothing() {
signatureVisitor().visitClassType("java/lang/Object");
signatureVisitor().visitEnd();
writeAsmType0(AsmTypeConstants.OBJECT_TYPE);
}
private String makeArrayPrefix() {
@@ -218,24 +124,17 @@ public class BothSignatureWriter {
}
}
public void writeClassBegin(String internalName, boolean nullable, boolean real) {
writeClassBegin(internalName, nullable, real, null);
}
public void writeClassBegin(String internalName, boolean nullable, boolean real, @Nullable String kotlinTypeName) {
signatureVisitor().visitClassType(internalName);
jetSignatureWriter.visitClassType(kotlinTypeName == null ? internalName : kotlinTypeName, nullable, real);
writeAsmType0(Type.getObjectType(internalName));
public void writeClassBegin(Type asmType) {
signatureVisitor().visitClassType(asmType.getInternalName());
writeAsmType0(asmType);
}
public void writeClassEnd() {
signatureVisitor().visitEnd();
jetSignatureWriter.visitEnd();
}
public void writeArrayType(boolean nullable, Variance projectionKind) {
public void writeArrayType() {
push(signatureVisitor().visitArrayType());
jetSignatureWriter.visitArrayType(nullable, toJetSignatureVariance(projectionKind));
if (jvmCurrentType == null) {
++jvmCurrentTypeArrayLevel;
}
@@ -245,25 +144,18 @@ public class BothSignatureWriter {
pop();
}
private static JetSignatureVariance toJetSignatureVariance(Variance variance) {
private static char toJvmVariance(@NotNull Variance variance) {
switch (variance) {
case INVARIANT:
return JetSignatureVariance.INVARIANT;
case IN_VARIANCE:
return JetSignatureVariance.IN;
case OUT_VARIANCE:
return JetSignatureVariance.OUT;
default:
throw new IllegalStateException();
case INVARIANT: return '=';
case IN_VARIANCE: return '-';
case OUT_VARIANCE: return '+';
default: throw new IllegalStateException("Unknown variance: " + variance);
}
}
public void writeTypeArgument(Variance projectionKindForKotlin, Variance projectionKindForJava) {
push(signatureVisitor().visitTypeArgument(
toJetSignatureVariance(projectionKindForJava).getChar()
));
public void writeTypeArgument(@NotNull Variance projectionKind) {
push(signatureVisitor().visitTypeArgument(toJvmVariance(projectionKind)));
jetSignatureWriter.visitTypeArgument(toJetSignatureVariance(projectionKindForKotlin));
generic = true;
}
@@ -271,49 +163,20 @@ public class BothSignatureWriter {
pop();
}
public void writeTypeVariable(Name name, boolean nullable, Type asmType) {
public void writeTypeVariable(Name name, Type asmType) {
signatureVisitor().visitTypeVariable(name.asString());
jetSignatureWriter.visitTypeVariable(name.asString(), nullable);
generic = true;
writeAsmType0(asmType);
}
public void writeFormalTypeParameter(String name, Variance variance, boolean reified) {
checkTopLevel();
public void writeFormalTypeParameter(String name) {
signatureVisitor().visitFormalTypeParameter(name);
jetSignatureWriter.visitFormalTypeParameter(name, JetSignatureUtils.translateVariance(variance), reified);
generic = true;
}
public void writeFormalTypeParameterEnd() {
jetSignatureWriter.visitFormalTypeParameterEnd();
}
public void writeFormalTypeParametersStart() {
checkTopLevel();
transitionState(State.START, State.TYPE_PARAMETERS);
jetSignatureWriter = new JetSignatureWriter();
}
public void writeFormalTypeParametersEnd() {
jetSignatureWriter.visitSuperclass(); // just to call endFormals
String kotlinClassParameters = jetSignatureWriter.toString();
jetSignatureWriter = null;
if (DEBUG_SIGNATURE_WRITER) {
new JetSignatureReader(kotlinClassParameters).acceptFormalTypeParametersOnly(new JetSignatureAdapter());
}
checkState(State.TYPE_PARAMETERS);
}
public void writeClassBound() {
push(signatureVisitor().visitClassBound());
jetSignatureWriter.visitClassBound();
}
public void writeClassBoundEnd() {
@@ -322,7 +185,6 @@ public class BothSignatureWriter {
public void writeInterfaceBound() {
push(signatureVisitor().visitInterfaceBound());
jetSignatureWriter.visitInterfaceBound();
}
public void writeInterfaceBoundEnd() {
@@ -330,30 +192,12 @@ public class BothSignatureWriter {
}
public void writeParametersStart() {
transitionState(State.TYPE_PARAMETERS, State.PARAMETERS);
// hacks
jvmCurrentType = null;
jvmCurrentTypeArrayLevel = 0;
}
public void writeParametersEnd() {
checkState(State.PARAMETERS);
}
public void writeFieldTypeStart() {
transitionState(State.START, State.FIELD);
jetSignatureWriter = new JetSignatureWriter();
}
public void writeFieldTypeEnd() {
jetSignatureWriter = null;
transitionState(State.FIELD, State.FIELD_END);
}
public void writeParameterType(JvmMethodParameterKind parameterKind) {
transitionState(State.PARAMETERS, State.PARAMETER);
// This magic mimics the behavior of javac that enum constructor have these synthetic parameters in erased signature, but doesn't
// have them in generic signature. IDEA relies on this behavior.
if (parameterKind == JvmMethodParameterKind.ENUM_NAME || parameterKind == JvmMethodParameterKind.ENUM_ORDINAL) {
@@ -366,127 +210,50 @@ public class BothSignatureWriter {
push(signatureVisitor().visitParameterType());
}
jetSignatureWriter = new JetSignatureWriter();
if (jvmCurrentType != null || jvmCurrentTypeArrayLevel != 0) {
throw new IllegalStateException();
}
if (currentParameterKind != null) {
throw new IllegalStateException();
}
this.currentParameterKind = parameterKind;
//jetSignatureWriter.visitParameterType();
}
public void writeParameterTypeEnd() {
pop();
if (jvmCurrentType == null) {
throw new IllegalStateException();
}
String signature = jetSignatureWriter.toString();
kotlinParameterTypes.add(new JvmMethodParameterSignature(jvmCurrentType, signature, currentParameterKind));
if (DEBUG_SIGNATURE_WRITER) {
new JetSignatureReader(signature).acceptTypeOnly(new JetSignatureAdapter());
}
kotlinParameterTypes.add(new JvmMethodParameterSignature(jvmCurrentType, currentParameterKind));
currentParameterKind = null;
jvmCurrentType = null;
jvmCurrentTypeArrayLevel = 0;
jetSignatureWriter = null;
transitionState(State.PARAMETER, State.PARAMETERS);
}
public void writeReturnType() {
transitionState(State.PARAMETERS, State.RETURN_TYPE);
jetSignatureWriter = new JetSignatureWriter();
if (jvmCurrentType != null) {
throw new IllegalStateException();
}
push(signatureVisitor().visitReturnType());
//jetSignatureWriter.visitReturnType();
}
public void writeReturnTypeEnd() {
pop();
String kotlinReturnType = jetSignatureWriter.toString();
if (jvmCurrentType == null) {
throw new IllegalStateException();
}
jvmReturnType = jvmCurrentType;
jvmCurrentType = null;
jvmCurrentTypeArrayLevel = 0;
if (DEBUG_SIGNATURE_WRITER) {
new JetSignatureReader(kotlinReturnType).acceptTypeOnly(new JetSignatureAdapter());
}
jetSignatureWriter = null;
transitionState(State.RETURN_TYPE, State.METHOD_END);
}
public void writeVoidReturn() {
writeReturnType();
writeAsmType(Type.VOID_TYPE, false);
writeReturnTypeEnd();
}
public void writeSupersStart() {
transitionState(State.TYPE_PARAMETERS, State.SUPERS);
jetSignatureWriter = new JetSignatureWriter();
}
public void writeSupersEnd() {
String kotlinClassSignature = jetSignatureWriter.toString();
jetSignatureWriter = null;
if (DEBUG_SIGNATURE_WRITER) {
new JetSignatureReader(kotlinClassSignature).accept(new JetSignatureAdapter());
}
transitionState(State.SUPERS, State.CLASS_END);
}
public void writeSuperclass() {
push(signatureVisitor().visitSuperclass());
jetSignatureWriter.visitSuperclass();
}
public void writeSuperclassEnd() {
pop();
if (!visitors.isEmpty()) {
throw new IllegalStateException();
}
}
public void writeInterface() {
checkTopLevel();
checkMode(Mode.CLASS);
push(signatureVisitor().visitInterface());
jetSignatureWriter.visitInterface();
}
public void writeInterfaceEnd() {
pop();
if (!visitors.isEmpty()) {
throw new IllegalStateException();
}
}
@NotNull
protected Method makeAsmMethod(String name) {
private Method makeAsmMethod(String name) {
List<Type> jvmParameterTypes = new ArrayList<Type>(kotlinParameterTypes.size());
for (JvmMethodParameterSignature p : kotlinParameterTypes) {
jvmParameterTypes.add(p.getAsmType());
@@ -496,26 +263,15 @@ public class BothSignatureWriter {
@Nullable
public String makeJavaGenericSignature() {
if (state != State.METHOD_END && state != State.CLASS_END && state != State.FIELD_END) {
throw new IllegalStateException();
}
checkTopLevel();
return generic ? signatureWriter.toString() : null;
}
@NotNull
protected List<JvmMethodParameterSignature> makeKotlinParameterTypes() {
checkState(State.METHOD_END);
// TODO: return nulls if equal to #makeJavaString
return kotlinParameterTypes;
}
@NotNull
public JvmMethodSignature makeJvmMethodSignature(String name) {
return new JvmMethodSignature(
makeAsmMethod(name),
needGenerics ? makeJavaGenericSignature() : null,
makeKotlinParameterTypes()
kotlinParameterTypes
);
}
}
compiler/backend/src/org/jetbrains/jet/codegen/signature/JvmMethodParameterSignature.java
+1 -3
View File
@@ -25,9 +25,7 @@ public class JvmMethodParameterSignature {
@NotNull
private final JvmMethodParameterKind kind;
public JvmMethodParameterSignature(
@NotNull Type asmType, @NotNull String kotlinSignature, @NotNull JvmMethodParameterKind kind
) {
public JvmMethodParameterSignature(@NotNull Type asmType, @NotNull JvmMethodParameterKind kind) {
this.asmType = asmType;
this.kind = kind;
}
compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java
+29 -66
View File
@@ -181,19 +181,19 @@ public class JetTypeMapper extends BindingTraceAware {
private Type mapReturnType(@NotNull JetType jetType, @Nullable BothSignatureWriter signatureVisitor) {
if (jetType.equals(KotlinBuiltIns.getInstance().getUnitType())) {
if (signatureVisitor != null) {
signatureVisitor.writeAsmType(Type.VOID_TYPE, false);
signatureVisitor.writeAsmType(Type.VOID_TYPE);
}
return Type.VOID_TYPE;
}
else if (jetType.equals(KotlinBuiltIns.getInstance().getNothingType())) {
if (signatureVisitor != null) {
signatureVisitor.writeNothing(false);
signatureVisitor.writeNothing();
}
return Type.VOID_TYPE;
}
if (jetType.equals(KotlinBuiltIns.getInstance().getNullableNothingType())) {
if (signatureVisitor != null) {
signatureVisitor.writeNothing(true);
signatureVisitor.writeNullableNothing();
}
return AsmTypeConstants.OBJECT_TYPE;
}
@@ -289,7 +289,7 @@ public class JetTypeMapper extends BindingTraceAware {
}
Type asmType = Type.getObjectType("error/NonExistentClass");
if (signatureVisitor != null) {
signatureVisitor.writeAsmType(asmType, true);
signatureVisitor.writeAsmType(asmType);
}
checkValidType(asmType);
return asmType;
@@ -303,7 +303,7 @@ public class JetTypeMapper extends BindingTraceAware {
JetType memberType = memberProjection.getType();
if (signatureVisitor != null) {
signatureVisitor.writeArrayType(jetType.isNullable(), memberProjection.getProjectionKind());
signatureVisitor.writeArrayType();
mapType(memberType, signatureVisitor, JetTypeMapperMode.TYPE_PARAMETER, memberProjection.getProjectionKind(), true);
signatureVisitor.writeArrayEnd();
}
@@ -328,9 +328,8 @@ public class JetTypeMapper extends BindingTraceAware {
else {
asmType = name.getAsmType();
}
boolean forceReal = KotlinToJavaTypesMap.getInstance().isForceReal(name);
writeGenericType(signatureVisitor, asmType, jetType, forceReal, howThisTypeIsUsed);
writeGenericType(signatureVisitor, asmType, jetType, howThisTypeIsUsed);
checkValidType(asmType);
return asmType;
@@ -340,7 +339,7 @@ public class JetTypeMapper extends BindingTraceAware {
TypeParameterDescriptor typeParameterDescriptor = (TypeParameterDescriptor) descriptor;
Type type = mapType(typeParameterDescriptor.getUpperBoundsAsType(), kind);
if (signatureVisitor != null) {
signatureVisitor.writeTypeVariable(typeParameterDescriptor.getName(), jetType.isNullable(), type);
signatureVisitor.writeTypeVariable(typeParameterDescriptor.getName(), type);
}
checkValidType(type);
return type;
@@ -371,24 +370,21 @@ public class JetTypeMapper extends BindingTraceAware {
BothSignatureWriter signatureVisitor,
Type asmType,
JetType jetType,
boolean forceReal,
Variance howThisTypeIsUsed
) {
if (signatureVisitor != null) {
String kotlinTypeName = getKotlinTypeNameForSignature(jetType, asmType);
signatureVisitor.writeClassBegin(asmType.getInternalName(), jetType.isNullable(), forceReal, kotlinTypeName);
signatureVisitor.writeClassBegin(asmType);
List<TypeProjection> arguments = jetType.getArguments();
for (TypeParameterDescriptor parameter : jetType.getConstructor().getParameters()) {
TypeProjection argument = arguments.get(parameter.getIndex());
Variance projectionKindForKotlin = argument.getProjectionKind();
Variance projectionKindForJava = getEffectiveVariance(
Variance projectionKind = getEffectiveVariance(
parameter.getVariance(),
projectionKindForKotlin,
argument.getProjectionKind(),
howThisTypeIsUsed
);
signatureVisitor.writeTypeArgument(projectionKindForKotlin, projectionKindForJava);
signatureVisitor.writeTypeArgument(projectionKind);
mapType(argument.getType(), signatureVisitor, JetTypeMapperMode.TYPE_PARAMETER);
signatureVisitor.writeTypeArgumentEnd();
@@ -434,40 +430,19 @@ public class JetTypeMapper extends BindingTraceAware {
) {
if (signatureVisitor != null) {
if (jetType.getArguments().isEmpty()) {
if (arrayParameter
&& (howThisTypeIsUsed == Variance.IN_VARIANCE)) {
if (arrayParameter && howThisTypeIsUsed == Variance.IN_VARIANCE) {
asmType = AsmTypeConstants.OBJECT_TYPE;
}
String kotlinTypeName = getKotlinTypeNameForSignature(jetType, asmType, arrayParameter);
signatureVisitor.writeAsmType(asmType, jetType.isNullable(), kotlinTypeName);
signatureVisitor.writeAsmType(asmType);
}
else {
writeGenericType(signatureVisitor, asmType, jetType, false, howThisTypeIsUsed);
writeGenericType(signatureVisitor, asmType, jetType, howThisTypeIsUsed);
}
}
checkValidType(asmType);
return asmType;
}
@Nullable
private static String getKotlinTypeNameForSignature(@NotNull JetType jetType, @NotNull Type asmType) {
return getKotlinTypeNameForSignature(jetType, asmType, false);
}
@Nullable
private static String getKotlinTypeNameForSignature(@NotNull JetType jetType, @NotNull Type asmType, boolean arrayParameter) {
ClassifierDescriptor descriptor = jetType.getConstructor().getDeclarationDescriptor();
if (descriptor == null) return null;
if (asmType.getSort() != Type.OBJECT) return null;
JvmClassName jvmClassName = JvmClassName.byType(asmType);
if ((arrayParameter && JavaToKotlinClassMap.getInstance().mapPlatformClass(jvmClassName.getFqName()).size() >= 1)
|| ((!arrayParameter) && JavaToKotlinClassMap.getInstance().mapPlatformClass(jvmClassName.getFqName()).size() > 1)) {
return JvmClassName.byClassDescriptor(descriptor).getSignatureName();
}
return null;
}
private void checkValidType(@NotNull Type type) {
if (!mapBuiltinsToJava) {
String descriptor = type.getDescriptor();
@@ -653,10 +628,8 @@ public class JetTypeMapper extends BindingTraceAware {
writeParameter(signatureVisitor, parameter.getType());
}
signatureVisitor.writeParametersEnd();
if (f instanceof ConstructorDescriptor) {
signatureVisitor.writeVoidReturn();
writeVoidReturn(signatureVisitor);
}
else {
signatureVisitor.writeReturnType();
@@ -669,12 +642,16 @@ public class JetTypeMapper extends BindingTraceAware {
return signatureVisitor.makeJvmMethodSignature(methodName);
}
private static void writeVoidReturn(@NotNull BothSignatureWriter signatureVisitor) {
signatureVisitor.writeReturnType();
signatureVisitor.writeAsmType(Type.VOID_TYPE);
signatureVisitor.writeReturnTypeEnd();
}
@Nullable
public String mapFieldSignature(@NotNull JetType backingFieldType) {
BothSignatureWriter signatureVisitor = new BothSignatureWriter(BothSignatureWriter.Mode.TYPE, true);
signatureVisitor.writeFieldTypeStart();
mapType(backingFieldType, signatureVisitor, JetTypeMapperMode.VALUE);
signatureVisitor.writeFieldTypeEnd();
return signatureVisitor.makeJavaGenericSignature();
}
@@ -688,7 +665,7 @@ public class JetTypeMapper extends BindingTraceAware {
Type type = getTraitImplThisParameterType(containingDeclaration, this);
signatureVisitor.writeParameterType(JvmMethodParameterKind.THIS);
signatureVisitor.writeAsmType(type, false);
signatureVisitor.writeAsmType(type);
signatureVisitor.writeParameterTypeEnd();
}
else {
@@ -706,20 +683,15 @@ public class JetTypeMapper extends BindingTraceAware {
public void writeFormalTypeParameters(List<TypeParameterDescriptor> typeParameters, BothSignatureWriter signatureVisitor) {
if (signatureVisitor == null) {
return;
}
if (signatureVisitor == null) return;
signatureVisitor.writeFormalTypeParametersStart();
for (TypeParameterDescriptor typeParameterDescriptor : typeParameters) {
writeFormalTypeParameter(typeParameterDescriptor, signatureVisitor);
}
signatureVisitor.writeFormalTypeParametersEnd();
}
private void writeFormalTypeParameter(TypeParameterDescriptor typeParameterDescriptor, BothSignatureWriter signatureVisitor) {
signatureVisitor.writeFormalTypeParameter(typeParameterDescriptor.getName().asString(), typeParameterDescriptor.getVariance(),
typeParameterDescriptor.isReified());
signatureVisitor.writeFormalTypeParameter(typeParameterDescriptor.getName().asString());
classBound:
{
@@ -755,11 +727,8 @@ public class JetTypeMapper extends BindingTraceAware {
signatureVisitor.writeInterfaceBoundEnd();
}
}
signatureVisitor.writeFormalTypeParameterEnd();
}
private void writeReceiverIfNeeded(@Nullable ReceiverParameterDescriptor receiver, BothSignatureWriter signatureWriter) {
if (receiver != null) {
signatureWriter.writeParameterType(JvmMethodParameterKind.RECEIVER);
@@ -787,7 +756,6 @@ public class JetTypeMapper extends BindingTraceAware {
signatureWriter.writeParametersStart();
writeThisIfNeeded(descriptor, kind, signatureWriter);
writeReceiverIfNeeded(descriptor.getReceiverParameter(), signatureWriter);
signatureWriter.writeParametersEnd();
signatureWriter.writeReturnType();
mapType(descriptor.getType(), signatureWriter, JetTypeMapperMode.VALUE, Variance.OUT_VARIANCE);
@@ -811,9 +779,8 @@ public class JetTypeMapper extends BindingTraceAware {
writeThisIfNeeded(descriptor, kind, signatureWriter);
writeReceiverIfNeeded(descriptor.getReceiverParameter(), signatureWriter);
writeParameter(signatureWriter, descriptor.getType());
signatureWriter.writeParametersEnd();
signatureWriter.writeVoidReturn();
writeVoidReturn(signatureWriter);
String name = getPropertyAccessorName(descriptor, false);
return signatureWriter.makeJvmMethodSignature(name);
@@ -881,7 +848,7 @@ public class JetTypeMapper extends BindingTraceAware {
if (type != null) {
signatureWriter.writeParameterType(JvmMethodParameterKind.SHARED_VAR);
signatureWriter.writeAsmType(type, false);
signatureWriter.writeAsmType(type);
signatureWriter.writeParameterTypeEnd();
}
}
@@ -901,7 +868,7 @@ public class JetTypeMapper extends BindingTraceAware {
if (types != null) {
for (JvmMethodParameterSignature type : types) {
signatureWriter.writeParameterType(JvmMethodParameterKind.SUPER_CALL_PARAM);
signatureWriter.writeAsmType(type.getAsmType(), false);
signatureWriter.writeAsmType(type.getAsmType());
signatureWriter.writeParameterTypeEnd();
}
}
@@ -914,9 +881,7 @@ public class JetTypeMapper extends BindingTraceAware {
writeParameter(signatureWriter, parameter.getType());
}
signatureWriter.writeParametersEnd();
signatureWriter.writeVoidReturn();
writeVoidReturn(signatureWriter);
return signatureWriter.makeJvmMethodSignature("<init>");
}
@@ -941,9 +906,7 @@ public class JetTypeMapper extends BindingTraceAware {
writeParameter(signatureWriter, valueParameter.getType());
}
signatureWriter.writeParametersEnd();
signatureWriter.writeVoidReturn();
writeVoidReturn(signatureWriter);
return signatureWriter.makeJvmMethodSignature("<init>");
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaTypeTransformer.java
-1
View File
@@ -29,7 +29,6 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.types.*;
import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.rt.signature.JetSignatureReader;
import javax.inject.Inject;
import java.util.Collections;
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetSignatureUtils.java
-41
View File
@@ -1,41 +0,0 @@
/*
* Copyright 2010-2013 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.jet.lang.resolve.java;
import jet.typeinfo.TypeInfoVariance;
import org.jetbrains.jet.lang.types.Variance;
public class JetSignatureUtils {
static {
if (Variance.INVARIANT.ordinal() != TypeInfoVariance.INVARIANT.ordinal())
throw new IllegalStateException();
if (Variance.IN_VARIANCE.ordinal() != TypeInfoVariance.IN.ordinal())
throw new IllegalStateException();
if (Variance.OUT_VARIANCE.ordinal() != TypeInfoVariance.OUT.ordinal())
throw new IllegalStateException();
}
public static TypeInfoVariance translateVariance(Variance variance) {
return TypeInfoVariance.values()[variance.ordinal()];
}
public static Variance translateVariance(TypeInfoVariance variance) {
return Variance.values()[variance.ordinal()];
}
}
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/TypeParameterDescriptor.java
+1
View File
@@ -27,6 +27,7 @@ import java.util.Set;
public interface TypeParameterDescriptor extends ClassifierDescriptor {
boolean isReified();
@NotNull
Variance getVariance();
@NotNull
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/impl/TypeParameterDescriptorImpl.java
+1
View File
@@ -124,6 +124,7 @@ public class TypeParameterDescriptorImpl extends DeclarationDescriptorNonRootImp
}
@Override
@NotNull
public Variance getVariance() {
return variance;
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/AbstractLazyTypeParameterDescriptor.java
+1
View File
@@ -97,6 +97,7 @@ public abstract class AbstractLazyTypeParameterDescriptor implements TypeParamet
return reified;
}
@NotNull
@Override
public Variance getVariance() {
return variance;