diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/BothSignatureWriter.java b/compiler/backend/src/org/jetbrains/jet/codegen/BothSignatureWriter.java index 440d0587873..70c66da4870 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/BothSignatureWriter.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/BothSignatureWriter.java @@ -1,8 +1,8 @@ package org.jetbrains.jet.codegen; -import jet.typeinfo.TypeInfoVariance; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.resolve.java.JetSignatureUtils; import org.jetbrains.jet.rt.signature.JetSignatureAdapter; import org.jetbrains.jet.rt.signature.JetSignatureReader; import org.jetbrains.jet.rt.signature.JetSignatureWriter; @@ -184,21 +184,12 @@ public class BothSignatureWriter { signatureVisitor().visitTypeVariable(name); jetSignatureWriter.visitTypeVariable(name, nullable); } - - private TypeInfoVariance translateVariance(Variance variance) { - switch (variance) { - case IN_VARIANCE: return TypeInfoVariance.IN; - case OUT_VARIANCE: return TypeInfoVariance.OUT; - case INVARIANT: return TypeInfoVariance.INVARIANT; - default: throw new IllegalStateException(); - } - } - + public void writeFormalTypeParameter(final String name, Variance variance) { checkTopLevel(); signatureVisitor().visitFormalTypeParameter(name); - jetSignatureWriter.visitFormalTypeParameter(name, translateVariance(variance)); + jetSignatureWriter.visitFormalTypeParameter(name, JetSignatureUtils.translateVariance(variance)); } public void writeFormalTypeParameterEnd() { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index 4513595264f..39101c75e48 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -1254,7 +1254,15 @@ public class ExpressionCodegen extends JetVisitor { if(descriptor instanceof ClassReceiver) { Type exprType = asmType(descriptor.getType()); ClassReceiver classReceiver = (ClassReceiver) descriptor; - generateThisOrOuter((ClassDescriptor) classReceiver.getDeclarationDescriptor()).put(exprType, v); + ClassDescriptor classReceiverDeclarationDescriptor = (ClassDescriptor) classReceiver.getDeclarationDescriptor(); + if(CodegenUtil.isClassObject(classReceiverDeclarationDescriptor)) { + ClassDescriptor containingDeclaration = (ClassDescriptor) classReceiverDeclarationDescriptor.getContainingDeclaration(); + Type classObjType = typeMapper.mapType(containingDeclaration.getDefaultType()); + v.getstatic(classObjType.getInternalName(), "$classobj", exprType.getDescriptor()); + } + else { + generateThisOrOuter(classReceiverDeclarationDescriptor).put(exprType, v); + } if(type != null) StackValue.onStack(exprType).put(type, v); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index 001ff53bf88..befdaf21a7e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -100,12 +100,12 @@ public class FunctionCodegen { } if(kind == OwnerKind.TRAIT_IMPL) { - AnnotationVisitor av = mv.visitParameterAnnotation(start++, StdlibNames.JET_VALUE_PARAMETER_DESCRIPTOR, true); + AnnotationVisitor av = mv.visitParameterAnnotation(start++, StdlibNames.JET_VALUE_PARAMETER.getDescriptor(), true); av.visit(StdlibNames.JET_VALUE_PARAMETER_NAME_FIELD, "this$self"); av.visitEnd(); } if(receiverParameter.exists()) { - AnnotationVisitor av = mv.visitParameterAnnotation(start++, StdlibNames.JET_VALUE_PARAMETER_DESCRIPTOR, true); + AnnotationVisitor av = mv.visitParameterAnnotation(start++, StdlibNames.JET_VALUE_PARAMETER.getDescriptor(), true); av.visit(StdlibNames.JET_VALUE_PARAMETER_NAME_FIELD, "this$receiver"); if(receiverParameter.getType().isNullable()) { av.visit(StdlibNames.JET_VALUE_PARAMETER_NULLABLE_FIELD, true); @@ -113,12 +113,12 @@ public class FunctionCodegen { av.visitEnd(); } for (final TypeParameterDescriptor typeParameterDescriptor : typeParameters) { - AnnotationVisitor av = mv.visitParameterAnnotation(start++, StdlibNames.JET_TYPE_PARAMETER_DESCRIPTOR, true); + AnnotationVisitor av = mv.visitParameterAnnotation(start++, StdlibNames.JET_TYPE_PARAMETER.getDescriptor(), true); av.visit(StdlibNames.JET_TYPE_PARAMETER_NAME_FIELD, typeParameterDescriptor.getName()); av.visitEnd(); } for(int i = 0; i != paramDescrs.size(); ++i) { - AnnotationVisitor av = mv.visitParameterAnnotation(i + start, StdlibNames.JET_VALUE_PARAMETER_DESCRIPTOR, true); + AnnotationVisitor av = mv.visitParameterAnnotation(i + start, StdlibNames.JET_VALUE_PARAMETER.getDescriptor(), true); ValueParameterDescriptor parameterDescriptor = paramDescrs.get(i); av.visit(StdlibNames.JET_VALUE_PARAMETER_NAME_FIELD, parameterDescriptor.getName()); if(parameterDescriptor.hasDefaultValue()) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 1fe54ebc47f..2d36920442d 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -72,9 +72,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { } if(myClass instanceof JetClass && signature.getKotlinGenericSignature() != null) { - AnnotationVisitor annotationVisitor = v.newAnnotation(myClass, "Ljet/typeinfo/JetSignature;", true); - //annotationVisitor.visit("value", SignatureUtil.classToSignature((JetClass)myClass, bindingContext, typeMapper)); - annotationVisitor.visit("value", signature.getKotlinGenericSignature()); + AnnotationVisitor annotationVisitor = v.newAnnotation(myClass, StdlibNames.JET_CLASS.getDescriptor(), true); + annotationVisitor.visit(StdlibNames.JET_CLASS_SIGNATURE, signature.getKotlinGenericSignature()); annotationVisitor.visitEnd(); } } @@ -107,7 +106,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { { // superinterfaces - superInterfacesLinkedHashSet.add(StdlibNames.JET_OBJECT_INTERNAL); + superInterfacesLinkedHashSet.add(StdlibNames.JET_OBJECT.getInternalName()); for (JetDelegationSpecifier specifier : myClass.getDelegationSpecifiers()) { JetType superType = bindingContext.get(BindingContext.TYPE, specifier.getTypeReference()); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index 9a2bd50a811..88689127062 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -17,6 +17,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.plugin.JetFileType; +import org.jetbrains.jet.rt.signature.JetSignatureAdapter; import org.jetbrains.jet.rt.signature.JetSignatureExceptionsAdapter; import org.jetbrains.jet.rt.signature.JetSignatureReader; import org.jetbrains.jet.rt.signature.JetSignatureVisitor; @@ -124,9 +125,9 @@ public class JavaDescriptorResolver { resolveParentDescriptor(psiClass), psiClass.isInterface() ? ClassKind.TRAIT : ClassKind.CLASS ); classDescriptor.setName(name); - + List supertypes = new ArrayList(); - List typeParameters = makeUninitializedTypeParameters(classDescriptor, psiClass.getTypeParameters()); + List typeParameters = resolveClassTypeParameters(psiClass, classDescriptor); classDescriptor.setTypeConstructor(new TypeConstructorImpl( classDescriptor, Collections.emptyList(), // TODO @@ -144,8 +145,11 @@ public class JavaDescriptorResolver { classDescriptorCache.put(psiClass.getQualifiedName(), classDescriptor); classDescriptor.setUnsubstitutedMemberScope(new JavaClassMembersScope(classDescriptor, psiClass, semanticServices, false)); - // UGLY HACK - initializeTypeParameters(psiClass); + // TODO: initialize + if (psiClass.getModifierList().findAnnotation(StdlibNames.JET_CLASS.getFqName()) == null) { + // UGLY HACK (Andrey Breslav is not sure what did he mean) + initializeTypeParameters(psiClass); + } supertypes.addAll(getSupertypes(psiClass)); if (psiClass.isInterface()) { @@ -197,6 +201,82 @@ public class JavaDescriptorResolver { return classDescriptor; } + private List resolveClassTypeParameters(PsiClass psiClass, JavaClassDescriptor classDescriptor) { + for (PsiAnnotation annotation : psiClass.getModifierList().getAnnotations()) { + if (annotation.getQualifiedName().equals(StdlibNames.JET_CLASS.getFqName())) { + PsiLiteralExpression attributeValue = (PsiLiteralExpression) annotation.findAttributeValue(StdlibNames.JET_CLASS_SIGNATURE); + if (attributeValue != null) { + String typeParametersString = (String) attributeValue.getValue(); + if (typeParametersString != null) { + return resolveClassTypeParametersFromJetSignature(typeParametersString, classDescriptor); + } + } + } + } + return makeUninitializedTypeParameters(classDescriptor, psiClass.getTypeParameters()); + } + + /** + * @see #resolveMethodTypeParametersFromJetSignature(String, FunctionDescriptor) + */ + private List resolveClassTypeParametersFromJetSignature(String jetSignature, final JavaClassDescriptor classDescriptor) { + final List r = new ArrayList(); + new JetSignatureReader(jetSignature).accept(new JetSignatureExceptionsAdapter() { + @Override + public JetSignatureVisitor visitFormalTypeParameter(final String name, final TypeInfoVariance variance) { + return new JetSignatureExceptionsAdapter() { + int index = 0; + + @Override + public JetSignatureVisitor visitClassBound() { + return new JetTypeJetSignatureReader(JavaDescriptorResolver.this, semanticServices.getJetSemanticServices().getStandardLibrary()) { + @Override + protected void done(@NotNull JetType jetType) { + // TODO + } + }; + } + + @Override + public JetSignatureVisitor visitInterfaceBound() { + return new JetTypeJetSignatureReader(JavaDescriptorResolver.this, semanticServices.getJetSemanticServices().getStandardLibrary()) { + @Override + protected void done(@NotNull JetType jetType) { + // TODO + } + }; + } + + @Override + public void visitFormalTypeParameterEnd() { + TypeParameterDescriptor typeParameter = TypeParameterDescriptor.createForFurtherModification( + classDescriptor, + Collections.emptyList(), // TODO: wrong + true, // TODO: wrong + JetSignatureUtils.translateVariance(variance), + name, + ++index); + r.add(typeParameter); + } + + }; + } + + @Override + public JetSignatureVisitor visitSuperclass() { + // TODO + return new JetSignatureAdapter(); + } + + @Override + public JetSignatureVisitor visitInterface() { + // TODO + return new JetSignatureAdapter(); + } + }); + return r; + } + private DeclarationDescriptor resolveParentDescriptor(PsiClass psiClass) { PsiClass containingClass = psiClass.getContainingClass(); if (containingClass != null) { @@ -381,7 +461,7 @@ public class JavaDescriptorResolver { PsiNameValuePair[] attributes = annotation.getParameterList().getAttributes(); attributes.toString(); - if (annotation.getQualifiedName().equals(StdlibNames.JET_VALUE_PARAMETER_CLASS)) { + if (annotation.getQualifiedName().equals(StdlibNames.JET_VALUE_PARAMETER.getFqName())) { PsiLiteralExpression nameExpression = (PsiLiteralExpression) annotation.findAttributeValue(StdlibNames.JET_VALUE_PARAMETER_NAME_FIELD); if (nameExpression != null) { name = (String) nameExpression.getValue(); @@ -400,7 +480,7 @@ public class JavaDescriptorResolver { if (signatureExpression != null) { typeFromAnnotation = (String) signatureExpression.getValue(); } - } else if (annotation.getQualifiedName().equals(StdlibNames.JET_TYPE_PARAMETER_CLASS)) { + } else if (annotation.getQualifiedName().equals(StdlibNames.JET_TYPE_PARAMETER.getFqName())) { return null; } } @@ -531,7 +611,7 @@ public class JavaDescriptorResolver { private List resolveMethodTypeParameters(PsiMethod method, FunctionDescriptorImpl functionDescriptorImpl) { for (PsiAnnotation annotation : method.getModifierList().getAnnotations()) { - if (annotation.getQualifiedName().equals(StdlibNames.JET_METHOD_CLASS)) { + if (annotation.getQualifiedName().equals(StdlibNames.JET_METHOD.getFqName())) { PsiLiteralExpression attributeValue = (PsiLiteralExpression) annotation.findAttributeValue(StdlibNames.JET_METHOD_TYPE_PARAMETERS_FIELD); if (attributeValue != null) { String typeParametersString = (String) attributeValue.getValue(); @@ -546,12 +626,15 @@ public class JavaDescriptorResolver { initializeTypeParameters(method); return typeParameters; } - + + /** + * @see #resolveClassTypeParametersFromJetSignature(String, JavaClassDescriptor) + */ private List resolveMethodTypeParametersFromJetSignature(String jetSignature, final FunctionDescriptor functionDescriptor) { final List r = new ArrayList(); new JetSignatureReader(jetSignature).acceptFormalTypeParametersOnly(new JetSignatureExceptionsAdapter() { @Override - public JetSignatureVisitor visitFormalTypeParameter(final String name, TypeInfoVariance variance) { + public JetSignatureVisitor visitFormalTypeParameter(final String name, final TypeInfoVariance variance) { return new JetSignatureExceptionsAdapter() { int index = 0; @@ -582,7 +665,7 @@ public class JavaDescriptorResolver { functionDescriptor, Collections.emptyList(), // TODO: wrong true, // TODO: wrong - Variance.INVARIANT, // TOOD: wrong + JetSignatureUtils.translateVariance(variance), name, ++index); r.add(typeParameter); @@ -600,7 +683,7 @@ public class JavaDescriptorResolver { String returnTypeFromAnnotation = null; for (PsiAnnotation annotation : method.getModifierList().getAnnotations()) { - if (annotation.getQualifiedName().equals(StdlibNames.JET_METHOD_CLASS)) { + if (annotation.getQualifiedName().equals(StdlibNames.JET_METHOD.getFqName())) { PsiLiteralExpression nullableExpression = (PsiLiteralExpression) annotation.findAttributeValue(StdlibNames.JET_METHOD_NULLABLE_RETURN_TYPE_FIELD); if (nullableExpression != null) { nullable = (Boolean) nullableExpression.getValue(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetSignatureUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetSignatureUtils.java new file mode 100644 index 00000000000..a1207b905fe --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JetSignatureUtils.java @@ -0,0 +1,28 @@ +package org.jetbrains.jet.lang.resolve.java; + +import jet.typeinfo.TypeInfoVariance; +import org.jetbrains.jet.lang.types.Variance; + +/** + * @author Stepan Koltsov + */ +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()]; + } + +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java new file mode 100644 index 00000000000..db1bcac52ff --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java @@ -0,0 +1,42 @@ +package org.jetbrains.jet.lang.resolve.java; + +import org.jetbrains.annotations.NotNull; + +/** + * @author Stepan Koltsov + */ +public class JvmClassName { + + private final String fqName; + + public JvmClassName(@NotNull String fqName) { + this.fqName = fqName; + } + + public String getFqName() { + return fqName; + } + + private String internalName; + + public String getInternalName() { + if (internalName == null) { + String descriptor = getDescriptor(); + internalName = descriptor.substring(1, descriptor.length() - 1); + } + return internalName; + } + + private String descriptor; + + public String getDescriptor() { + if (descriptor == null) { + StringBuilder sb = new StringBuilder(fqName.length() + 2); + sb.append('L'); + sb.append(fqName.replace('.', '/')); + sb.append(';'); + descriptor = sb.toString(); + } + return descriptor; + } +} diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/StdlibNames.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/StdlibNames.java index 6e3e8abeb34..dd071b38631 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/StdlibNames.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/StdlibNames.java @@ -7,32 +7,33 @@ import org.objectweb.asm.Type; */ public class StdlibNames { - public static final String JET_VALUE_PARAMETER_CLASS = "jet.typeinfo.JetValueParameter"; - public static final String JET_VALUE_PARAMETER_DESCRIPTOR = "Ljet/typeinfo/JetValueParameter;"; - + public static final JvmClassName JET_VALUE_PARAMETER = new JvmClassName("jet.typeinfo.JetValueParameter"); + public static final String JET_VALUE_PARAMETER_NAME_FIELD = "name"; public static final String JET_VALUE_PARAMETER_HAS_DEFAULT_VALUE_FIELD = "hasDefaultValue"; public static final String JET_VALUE_PARAMETER_NULLABLE_FIELD = "nullable"; public static final String JET_VALUE_PARAMETER_TYPE_FIELD = "type"; - public static final String JET_TYPE_PARAMETER_CLASS = "jet.typeinfo.JetTypeParameter"; - public static final String JET_TYPE_PARAMETER_DESCRIPTOR = "Ljet/typeinfo/JetTypeParameter;"; - + public static final JvmClassName JET_TYPE_PARAMETER = new JvmClassName("jet.typeinfo.JetTypeParameter"); + public static final String JET_TYPE_PARAMETER_NAME_FIELD = "name"; - public static final String JET_METHOD_CLASS = "jet.typeinfo.JetMethod"; - public static final String JET_METHOD_DESCRIPTOR = "Ljet/typeinfo/JetMethod;"; - + public static final JvmClassName JET_METHOD = new JvmClassName("jet.typeinfo.JetMethod"); + public static final String JET_METHOD_NULLABLE_RETURN_TYPE_FIELD = "nullableReturnType"; public static final String JET_METHOD_RETURN_TYPE_FIELD = "returnType"; public static final String JET_METHOD_TYPE_PARAMETERS_FIELD = "typeParameters"; - public static final String JET_OBJECT_INTERNAL = "jet/JetObject"; - public static final String JET_OBJECT_CLASS = "jet.JetObject"; - public static final String JET_OBJECT_DESCRIPTOR = "Ljet/JetObject;"; + public static final JvmClassName JET_CLASS = new JvmClassName("jet.typeinfo.JetClass"); + + public static final String JET_CLASS_SIGNATURE = "signature"; + + + public static final JvmClassName JET_OBJECT = new JvmClassName("jet.JetObject"); + private StdlibNames() { } diff --git a/compiler/testData/readClass/Class.kt b/compiler/testData/readClass/class/Class.kt similarity index 100% rename from compiler/testData/readClass/Class.kt rename to compiler/testData/readClass/class/Class.kt diff --git a/compiler/testData/readClass/class/ClassInParam.kt b/compiler/testData/readClass/class/ClassInParam.kt new file mode 100644 index 00000000000..a1a3ec98d39 --- /dev/null +++ b/compiler/testData/readClass/class/ClassInParam.kt @@ -0,0 +1,3 @@ +namespace test + +class Wine diff --git a/compiler/testData/readClass/class/ClassOutParam.kt b/compiler/testData/readClass/class/ClassOutParam.kt new file mode 100644 index 00000000000..83195ecae37 --- /dev/null +++ b/compiler/testData/readClass/class/ClassOutParam.kt @@ -0,0 +1,3 @@ +namespace test + +class Juice diff --git a/compiler/testData/readClass/class/ClassParam.kt b/compiler/testData/readClass/class/ClassParam.kt new file mode 100644 index 00000000000..7457e5a7ffe --- /dev/null +++ b/compiler/testData/readClass/class/ClassParam.kt @@ -0,0 +1,3 @@ +namespace test + +class Beer diff --git a/compiler/testData/readClass/ClassFun.kt b/compiler/testData/readClass/fun/ClassFun.kt similarity index 100% rename from compiler/testData/readClass/ClassFun.kt rename to compiler/testData/readClass/fun/ClassFun.kt diff --git a/compiler/testData/readClass/FunClassParamNotNull.kt b/compiler/testData/readClass/fun/FunClassParamNotNull.kt similarity index 100% rename from compiler/testData/readClass/FunClassParamNotNull.kt rename to compiler/testData/readClass/fun/FunClassParamNotNull.kt diff --git a/compiler/testData/readClass/FunClassParamNullable.kt b/compiler/testData/readClass/fun/FunClassParamNullable.kt similarity index 100% rename from compiler/testData/readClass/FunClassParamNullable.kt rename to compiler/testData/readClass/fun/FunClassParamNullable.kt diff --git a/compiler/testData/readClass/FunGenericParam.kt b/compiler/testData/readClass/fun/FunGenericParam.kt similarity index 100% rename from compiler/testData/readClass/FunGenericParam.kt rename to compiler/testData/readClass/fun/FunGenericParam.kt diff --git a/compiler/testData/readClass/fun/FunInParam.kt b/compiler/testData/readClass/fun/FunInParam.kt new file mode 100644 index 00000000000..c12eb63fc3e --- /dev/null +++ b/compiler/testData/readClass/fun/FunInParam.kt @@ -0,0 +1,3 @@ +namespace test + +fun f() = 1 diff --git a/compiler/testData/readClass/fun/FunOutParam.kt b/compiler/testData/readClass/fun/FunOutParam.kt new file mode 100644 index 00000000000..7198872c6f8 --- /dev/null +++ b/compiler/testData/readClass/fun/FunOutParam.kt @@ -0,0 +1,3 @@ +namespace test + +fun f() = 1 diff --git a/compiler/testData/readClass/FunParamNotNull.kt b/compiler/testData/readClass/fun/FunParamNotNull.kt similarity index 100% rename from compiler/testData/readClass/FunParamNotNull.kt rename to compiler/testData/readClass/fun/FunParamNotNull.kt diff --git a/compiler/testData/readClass/FunParamNullable.kt b/compiler/testData/readClass/fun/FunParamNullable.kt similarity index 100% rename from compiler/testData/readClass/FunParamNullable.kt rename to compiler/testData/readClass/fun/FunParamNullable.kt diff --git a/compiler/testData/readClass/NsFun.kt b/compiler/testData/readClass/fun/NsFun.kt similarity index 100% rename from compiler/testData/readClass/NsFun.kt rename to compiler/testData/readClass/fun/NsFun.kt diff --git a/compiler/testData/readClass/ReturnTypeClassParamNotNull.kt b/compiler/testData/readClass/fun/ReturnTypeClassParamNotNull.kt similarity index 100% rename from compiler/testData/readClass/ReturnTypeClassParamNotNull.kt rename to compiler/testData/readClass/fun/ReturnTypeClassParamNotNull.kt diff --git a/compiler/testData/readClass/ReturnTypeClassParamNullable.kt b/compiler/testData/readClass/fun/ReturnTypeClassParamNullable.kt similarity index 100% rename from compiler/testData/readClass/ReturnTypeClassParamNullable.kt rename to compiler/testData/readClass/fun/ReturnTypeClassParamNullable.kt diff --git a/compiler/testData/readClass/ReturnTypeNotNull.kt b/compiler/testData/readClass/fun/ReturnTypeNotNull.kt similarity index 100% rename from compiler/testData/readClass/ReturnTypeNotNull.kt rename to compiler/testData/readClass/fun/ReturnTypeNotNull.kt diff --git a/compiler/testData/readClass/ReturnTypeNullable.kt b/compiler/testData/readClass/fun/ReturnTypeNullable.kt similarity index 100% rename from compiler/testData/readClass/ReturnTypeNullable.kt rename to compiler/testData/readClass/fun/ReturnTypeNullable.kt diff --git a/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java b/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java index 03936722192..83e7f8d13c4 100644 --- a/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java +++ b/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java @@ -153,16 +153,22 @@ public class ReadClassDataTest extends UsefulTestCase { String bs = serializeContent((ClassDescriptor) b); Assert.assertEquals(as, bs); - System.out.println(a); + System.out.println(as); } private String serializeContent(ClassDescriptor klass) { StringBuilder sb = new StringBuilder(); sb.append("class "); - + serialize(klass, sb); + if (!klass.getTypeConstructor().getParameters().isEmpty()) { + sb.append("<"); + serializeCommaSeparated(klass.getTypeConstructor().getParameters(), sb); + sb.append(">"); + } + // TODO: supers // TODO: constructors @@ -200,7 +206,6 @@ public class ReadClassDataTest extends UsefulTestCase { private static Object invoke(Method method, Object thiz, Object... args) { try { - method.setAccessible(true); return method.invoke(thiz, args); } catch (Exception e) { throw new RuntimeException("failed to invoke " + method + ": " + e, e); @@ -229,7 +234,7 @@ public class ReadClassDataTest extends UsefulTestCase { sb.append("vararg "); serialize(valueParameter.getVarargElementType()); } else { - serialize(valueParameter.getOutType()); + serialize(valueParameter.getOutType(), sb); } if (valueParameter.hasDefaultValue()) { sb.append(" = ?"); @@ -237,7 +242,12 @@ public class ReadClassDataTest extends UsefulTestCase { } private void serialize(Variance variance, StringBuilder sb) { - sb.append(variance); + if (variance == Variance.INVARIANT) { + + } else { + sb.append(variance); + sb.append(' '); + } } private void serialize(JetType type, StringBuilder sb) { @@ -274,7 +284,7 @@ public class ReadClassDataTest extends UsefulTestCase { } } - private void serialize(Object o, StringBuilder sb) { + private Method getMethodToSerialize(Object o) { // TODO: cache for (Method method : ReadClassDataTest.class.getDeclaredMethods()) { if (!method.getName().equals("serialize")) { @@ -290,12 +300,17 @@ public class ReadClassDataTest extends UsefulTestCase { continue; } if (method.getParameterTypes()[0].isInstance(o)) { - invoke(method, this, o, sb); - return; + method.setAccessible(true); + return method; } } throw new IllegalStateException("don't know how to serialize " + o + " (of " + o.getClass() + ")"); } + + private void serialize(Object o, StringBuilder sb) { + Method method = getMethodToSerialize(o); + invoke(method, this, o, sb); + } private void serialize(ModuleDescriptor module, StringBuilder sb) { // nop @@ -318,9 +333,7 @@ public class ReadClassDataTest extends UsefulTestCase { } private void serialize(TypeParameterDescriptor param, StringBuilder sb) { - if (param.getVariance() != Variance.INVARIANT) { - serialize(param.getVariance(), sb); - } + serialize(param.getVariance(), sb); sb.append(param.getName()); // TODO: serialize bounds } diff --git a/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java index 88e445a6bb1..9312dadc793 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/ClassGenTest.java @@ -166,6 +166,12 @@ public class ClassGenTest extends CodegenTestCase { assertEquals(0xFF0000, rgbMethod.invoke(redValue)); } + public void testClassObjFields() throws Exception { + loadText("class A() { class object { val value = 10 } }\n" + + "fun box() = if(A.value == 10) \"OK\" else \"fail\""); + blackBox(); + } + public void testKt249() throws Exception { blackBoxFile("regressions/kt249.jet"); } diff --git a/stdlib/src/jet/typeinfo/JetSignature.java b/stdlib/src/jet/typeinfo/JetClass.java similarity index 85% rename from stdlib/src/jet/typeinfo/JetSignature.java rename to stdlib/src/jet/typeinfo/JetClass.java index c93f818951b..7a887134347 100644 --- a/stdlib/src/jet/typeinfo/JetSignature.java +++ b/stdlib/src/jet/typeinfo/JetClass.java @@ -11,7 +11,7 @@ import java.util.*; * @url http://confluence.jetbrains.net/display/JET/Jet+Signatures */ @Retention(RetentionPolicy.RUNTIME) -public @interface JetSignature { - String value(); +public @interface JetClass { + String signature(); } diff --git a/stdlib/src/org/jetbrains/jet/rt/TypeInfoParser.java b/stdlib/src/org/jetbrains/jet/rt/TypeInfoParser.java index 78fa32782e4..99910c810e7 100644 --- a/stdlib/src/org/jetbrains/jet/rt/TypeInfoParser.java +++ b/stdlib/src/org/jetbrains/jet/rt/TypeInfoParser.java @@ -1,6 +1,6 @@ package org.jetbrains.jet.rt; -import jet.typeinfo.JetSignature; +import jet.typeinfo.JetClass; import jet.typeinfo.TypeInfo; import jet.typeinfo.TypeInfoProjection; import jet.typeinfo.TypeInfoVariance; @@ -51,9 +51,9 @@ class TypeInfoParser { return signature; } - JetSignature annotation = (JetSignature) klass.getAnnotation(JetSignature.class); + JetClass annotation = (JetClass) klass.getAnnotation(JetClass.class); if(annotation != null) { - String value = annotation.value(); + String value = annotation.signature(); if(value != null) { Class enclosingClass = klass.getEnclosingClass(); Signature signature = new Signature(klass); diff --git a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureReader.java b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureReader.java index a163c8c6d4d..bda1063e04c 100644 --- a/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureReader.java +++ b/stdlib/src/org/jetbrains/jet/rt/signature/JetSignatureReader.java @@ -36,6 +36,10 @@ public class JetSignatureReader { pos = parseType(signature, pos, v.visitInterface()); } } + + if (pos != signature.length()) { + throw new IllegalStateException(); + } } public int acceptFormalTypeParameters(JetSignatureVisitor v) {