diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java index 2267922aeb7..75ee1e431fd 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java @@ -9,6 +9,7 @@ import org.jetbrains.jet.lang.descriptors.VariableDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; +import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.lexer.JetTokens; import org.objectweb.asm.MethodVisitor; import org.objectweb.asm.Opcodes; @@ -65,7 +66,7 @@ public class PropertyCodegen { value = compileTimeValue != null ? compileTimeValue.getValue() : null; } } - final int modifiers; + int modifiers; if (kind == OwnerKind.NAMESPACE) { int access = isExternallyAccessible(p) ? Opcodes.ACC_PUBLIC : Opcodes.ACC_PRIVATE; modifiers = access | Opcodes.ACC_STATIC; @@ -73,6 +74,9 @@ public class PropertyCodegen { else { modifiers = Opcodes.ACC_PRIVATE; } + if (!propertyDescriptor.isVar()) { + modifiers |= Opcodes.ACC_FINAL; + } v.newField(p, modifiers, p.getName(), state.getTypeMapper().mapType(propertyDescriptor.getOutType()).getDescriptor(), null, value); } } @@ -212,10 +216,10 @@ public class PropertyCodegen { } public static String getterName(String propertyName) { - return "get" + StringUtil.capitalizeWithJavaBeanConvention(propertyName); + return JvmAbi.GETTER_PREFIX + StringUtil.capitalizeWithJavaBeanConvention(propertyName); } public static String setterName(String propertyName) { - return "set" + StringUtil.capitalizeWithJavaBeanConvention(propertyName); + return JvmAbi.SETTER_PREFIX + StringUtil.capitalizeWithJavaBeanConvention(propertyName); } } 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 66dfe604e63..1cf784ea2de 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 @@ -86,11 +86,33 @@ public class JavaDescriptorResolver { } } - protected final Map classDescriptorCache = Maps.newHashMap(); + private static class ResolverClassData { + private JavaClassDescriptor classDescriptor; + private boolean kotlin; + + @NotNull + public ClassDescriptor getClassDescriptor() { + return classDescriptor; + } + } + + private static class ResolverNamespaceData { + private JavaNamespaceDescriptor namespaceDescriptor; + private boolean kotlin; + + @NotNull + public NamespaceDescriptor getNamespaceDescriptor() { + return namespaceDescriptor; + } + } + + protected final Map classDescriptorCache = Maps.newHashMap(); + protected final Map namespaceDescriptorCacheByFqn = Maps.newHashMap(); + protected final Map namespaceDescriptorCache = Maps.newHashMap(); + protected final Map typeParameterDescriptorCache = Maps.newHashMap(); protected final Map methodDescriptorCache = Maps.newHashMap(); protected final Map fieldDescriptorCache = Maps.newHashMap(); - protected final Map namespaceDescriptorCache = Maps.newHashMap(); protected final JavaPsiFacade javaFacade; protected final GlobalSearchScope javaSearchScope; protected final JavaSemanticServices semanticServices; @@ -122,12 +144,12 @@ public class JavaDescriptorResolver { } // Not let's take a descriptor of a Java class - ClassDescriptor classDescriptor = classDescriptorCache.get(qualifiedName); - if (classDescriptor == null) { - classDescriptor = createJavaClassDescriptor(psiClass); - classDescriptorCache.put(qualifiedName, classDescriptor); + ResolverClassData classData = classDescriptorCache.get(qualifiedName); + if (classData == null) { + classData = createJavaClassDescriptor(psiClass); + classDescriptorCache.put(qualifiedName, classData); } - return classDescriptor; + return classData.getClassDescriptor(); } @Nullable @@ -145,26 +167,27 @@ public class JavaDescriptorResolver { } // Not let's take a descriptor of a Java class - ClassDescriptor classDescriptor = classDescriptorCache.get(qualifiedName); - if (classDescriptor == null) { + ResolverClassData classData = classDescriptorCache.get(qualifiedName); + if (classData == null) { PsiClass psiClass = findClass(qualifiedName); if (psiClass == null) { return null; } - classDescriptor = createJavaClassDescriptor(psiClass); + classData = createJavaClassDescriptor(psiClass); } - return classDescriptor; + return classData.getClassDescriptor(); } - private ClassDescriptor createJavaClassDescriptor(@NotNull final PsiClass psiClass) { + private ResolverClassData createJavaClassDescriptor(@NotNull final PsiClass psiClass) { assert !classDescriptorCache.containsKey(psiClass.getQualifiedName()) : psiClass.getQualifiedName(); classDescriptorCache.put(psiClass.getQualifiedName(), null); // TODO String name = psiClass.getName(); - JavaClassDescriptor classDescriptor = new JavaClassDescriptor( + ResolverClassData classData = new ResolverClassData(); + classData.classDescriptor = new JavaClassDescriptor( resolveParentDescriptor(psiClass), psiClass.isInterface() ? ClassKind.TRAIT : ClassKind.CLASS ); - classDescriptor.setName(name); + classData.classDescriptor.setName(name); class OuterClassTypeVariableResolver implements TypeVariableResolver { @@ -176,9 +199,9 @@ public class JavaDescriptorResolver { } List supertypes = new ArrayList(); - List typeParameters = resolveClassTypeParameters(psiClass, classDescriptor, new OuterClassTypeVariableResolver()); - classDescriptor.setTypeConstructor(new TypeConstructorImpl( - classDescriptor, + List typeParameters = resolveClassTypeParameters(psiClass, classData, new OuterClassTypeVariableResolver()); + classData.classDescriptor.setTypeConstructor(new TypeConstructorImpl( + classData.classDescriptor, Collections.emptyList(), // TODO // TODO psiClass.hasModifierProperty(PsiModifier.FINAL), @@ -186,20 +209,20 @@ public class JavaDescriptorResolver { typeParameters, supertypes )); - classDescriptor.setModality(Modality.convertFromFlags( + classData.classDescriptor.setModality(Modality.convertFromFlags( psiClass.hasModifierProperty(PsiModifier.ABSTRACT) || psiClass.isInterface(), !psiClass.hasModifierProperty(PsiModifier.FINAL)) ); - classDescriptor.setVisibility(resolveVisibilityFromPsiModifiers(psiClass)); - classDescriptorCache.put(psiClass.getQualifiedName(), classDescriptor); - classDescriptor.setUnsubstitutedMemberScope(new JavaClassMembersScope(classDescriptor, psiClass, semanticServices, false)); + classData.classDescriptor.setVisibility(resolveVisibilityFromPsiModifiers(psiClass)); + classDescriptorCache.put(psiClass.getQualifiedName(), classData); + classData.classDescriptor.setUnsubstitutedMemberScope(new JavaClassMembersScope(classData.classDescriptor, psiClass, semanticServices, false)); // UGLY HACK (Andrey Breslav is not sure what did he mean) initializeTypeParameters(psiClass); supertypes.addAll(getSupertypes(psiClass)); if (psiClass.isInterface()) { - classDescriptor.setSuperclassType(JetStandardClasses.getAnyType()); // TODO : Make it java.lang.Object + classData.classDescriptor.setSuperclassType(JetStandardClasses.getAnyType()); // TODO : Make it java.lang.Object } else { PsiClassType[] extendsListTypes = psiClass.getExtendsListTypes(); @@ -207,7 +230,7 @@ public class JavaDescriptorResolver { JetType superclassType = extendsListTypes.length == 0 ? JetStandardClasses.getAnyType() : semanticServices.getTypeTransformer().transformToType(extendsListTypes[0]); - classDescriptor.setSuperclassType(superclassType); + classData.classDescriptor.setSuperclassType(superclassType); } PsiMethod[] psiConstructors = psiClass.getConstructors(); @@ -219,19 +242,19 @@ public class JavaDescriptorResolver { // abstract public class Java {} if (!psiClass.isInterface()) { ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl( - classDescriptor, + classData.classDescriptor, Collections.emptyList(), false); - constructorDescriptor.initialize(typeParameters, Collections.emptyList(), Modality.FINAL, classDescriptor.getVisibility()); - constructorDescriptor.setReturnType(classDescriptor.getDefaultType()); - classDescriptor.addConstructor(constructorDescriptor); + constructorDescriptor.initialize(typeParameters, Collections.emptyList(), Modality.FINAL, classData.classDescriptor.getVisibility()); + constructorDescriptor.setReturnType(classData.classDescriptor.getDefaultType()); + classData.classDescriptor.addConstructor(constructorDescriptor); semanticServices.getTrace().record(BindingContext.CONSTRUCTOR, psiClass, constructorDescriptor); } } else { for (PsiMethod constructor : psiConstructors) { ConstructorDescriptorImpl constructorDescriptor = new ConstructorDescriptorImpl( - classDescriptor, + classData.classDescriptor, Collections.emptyList(), // TODO false); ValueParameterDescriptors valueParameterDescriptors = resolveParameterDescriptors(constructorDescriptor, @@ -243,30 +266,31 @@ public class JavaDescriptorResolver { } constructorDescriptor.initialize(typeParameters, valueParameterDescriptors.descriptors, Modality.FINAL, resolveVisibilityFromPsiModifiers(constructor)); - constructorDescriptor.setReturnType(classDescriptor.getDefaultType()); - classDescriptor.addConstructor(constructorDescriptor); + constructorDescriptor.setReturnType(classData.classDescriptor.getDefaultType()); + classData.classDescriptor.addConstructor(constructorDescriptor); semanticServices.getTrace().record(BindingContext.CONSTRUCTOR, constructor, constructorDescriptor); } } - semanticServices.getTrace().record(BindingContext.CLASS, psiClass, classDescriptor); + semanticServices.getTrace().record(BindingContext.CLASS, psiClass, classData.classDescriptor); - return classDescriptor; + return classData; } - private List resolveClassTypeParameters(PsiClass psiClass, JavaClassDescriptor classDescriptor, TypeVariableResolver typeVariableResolver) { + private List resolveClassTypeParameters(PsiClass psiClass, ResolverClassData classData, TypeVariableResolver typeVariableResolver) { for (PsiAnnotation annotation : psiClass.getModifierList().getAnnotations()) { if (annotation.getQualifiedName().equals(JvmStdlibNames.JET_CLASS.getFqName())) { + classData.kotlin = true; PsiLiteralExpression attributeValue = (PsiLiteralExpression) annotation.findAttributeValue(JvmStdlibNames.JET_CLASS_SIGNATURE); if (attributeValue != null) { String typeParametersString = (String) attributeValue.getValue(); if (typeParametersString != null) { - return resolveClassTypeParametersFromJetSignature(typeParametersString, psiClass, classDescriptor, typeVariableResolver); + return resolveClassTypeParametersFromJetSignature(typeParametersString, psiClass, classData.classDescriptor, typeVariableResolver); } } } } - return makeUninitializedTypeParameters(classDescriptor, psiClass.getTypeParameters()); + return makeUninitializedTypeParameters(classData.classDescriptor, psiClass.getTypeParameters()); } @NotNull @@ -523,34 +547,40 @@ public class JavaDescriptorResolver { } private NamespaceDescriptor resolveNamespace(@NotNull PsiPackage psiPackage) { - NamespaceDescriptor namespaceDescriptor = namespaceDescriptorCache.get(psiPackage); - if (namespaceDescriptor == null) { - namespaceDescriptor = createJavaNamespaceDescriptor(psiPackage); - namespaceDescriptorCache.put(psiPackage, namespaceDescriptor); + ResolverNamespaceData namespaceData = namespaceDescriptorCache.get(psiPackage); + if (namespaceData == null) { + namespaceData = createJavaNamespaceDescriptor(psiPackage); + namespaceDescriptorCache.put(psiPackage, namespaceData); + namespaceDescriptorCacheByFqn.put(psiPackage.getQualifiedName(), namespaceData); } - return namespaceDescriptor; + return namespaceData.namespaceDescriptor; } private NamespaceDescriptor resolveNamespace(@NotNull PsiClass psiClass) { - NamespaceDescriptor namespaceDescriptor = namespaceDescriptorCache.get(psiClass); - if (namespaceDescriptor == null) { - namespaceDescriptor = createJavaNamespaceDescriptor(psiClass); - namespaceDescriptorCache.put(psiClass, namespaceDescriptor); + ResolverNamespaceData namespaceData = namespaceDescriptorCache.get(psiClass); + if (namespaceData == null) { + namespaceData = createJavaNamespaceDescriptor(psiClass); + namespaceDescriptorCache.put(psiClass, namespaceData); + namespaceDescriptorCacheByFqn.put(psiClass.getQualifiedName(), namespaceData); } - return namespaceDescriptor; + return namespaceData.namespaceDescriptor; } - private NamespaceDescriptor createJavaNamespaceDescriptor(@NotNull PsiPackage psiPackage) { + private ResolverNamespaceData createJavaNamespaceDescriptor(@NotNull PsiPackage psiPackage) { + ResolverNamespaceData namespaceData = new ResolverNamespaceData(); String name = psiPackage.getName(); - JavaNamespaceDescriptor namespaceDescriptor = new JavaNamespaceDescriptor( + namespaceData.namespaceDescriptor = new JavaNamespaceDescriptor( resolveParentDescriptor(psiPackage), Collections.emptyList(), // TODO - name == null ? JAVA_ROOT : name + name == null ? JAVA_ROOT : name, + name == null ? JAVA_ROOT : psiPackage.getQualifiedName() ); - namespaceDescriptor.setMemberScope(new JavaPackageScope(psiPackage.getQualifiedName(), namespaceDescriptor, semanticServices)); - semanticServices.getTrace().record(BindingContext.NAMESPACE, psiPackage, namespaceDescriptor); - return namespaceDescriptor; + namespaceData.namespaceDescriptor.setMemberScope(new JavaPackageScope(psiPackage.getQualifiedName(), namespaceData.namespaceDescriptor, semanticServices)); + semanticServices.getTrace().record(BindingContext.NAMESPACE, psiPackage, namespaceData.namespaceDescriptor); + // TODO: hack + namespaceData.kotlin = true; + return namespaceData; } private DeclarationDescriptor resolveParentDescriptor(@NotNull PsiPackage psiPackage) { @@ -561,15 +591,17 @@ public class JavaDescriptorResolver { return resolveNamespace(parentPackage); } - private NamespaceDescriptor createJavaNamespaceDescriptor(@NotNull final PsiClass psiClass) { - JavaNamespaceDescriptor namespaceDescriptor = new JavaNamespaceDescriptor( + private ResolverNamespaceData createJavaNamespaceDescriptor(@NotNull final PsiClass psiClass) { + ResolverNamespaceData namespaceData = new ResolverNamespaceData(); + namespaceData.namespaceDescriptor = new JavaNamespaceDescriptor( resolveParentDescriptor(psiClass), Collections.emptyList(), // TODO - psiClass.getName() + psiClass.getName(), + psiClass.getQualifiedName() ); - namespaceDescriptor.setMemberScope(new JavaClassMembersScope(namespaceDescriptor, psiClass, semanticServices, true)); - semanticServices.getTrace().record(BindingContext.NAMESPACE, psiClass, namespaceDescriptor); - return namespaceDescriptor; + namespaceData.namespaceDescriptor.setMemberScope(new JavaClassMembersScope(namespaceData.namespaceDescriptor, psiClass, semanticServices, true)); + semanticServices.getTrace().record(BindingContext.NAMESPACE, psiClass, namespaceData.namespaceDescriptor); + return namespaceData; } private static class ValueParameterDescriptors { @@ -819,6 +851,33 @@ public class JavaDescriptorResolver { } return functionDescriptor; } + + boolean kotlin; + if (owner instanceof JavaNamespaceDescriptor) { + JavaNamespaceDescriptor javaNamespaceDescriptor = (JavaNamespaceDescriptor) owner; + ResolverNamespaceData namespaceData = namespaceDescriptorCacheByFqn.get(javaNamespaceDescriptor.getQualifiedName()); + if (namespaceData == null) { + throw new IllegalStateException("namespaceData not found by name " + javaNamespaceDescriptor.getQualifiedName()); + } + kotlin = namespaceData.kotlin; + } else { + ResolverClassData classData = classDescriptorCache.get(psiClass.getQualifiedName()); + if (classData == null) { + throw new IllegalStateException("classData not found by name " + psiClass.getQualifiedName()); + } + kotlin = classData.kotlin; + } + + // TODO: hide getters and setters properly + if (kotlin) { + if (method.getName().startsWith(JvmAbi.GETTER_PREFIX) && method.getParameterList().getParametersCount() == 0) { + return null; + } + if (method.getName().startsWith(JvmAbi.SETTER_PREFIX) && method.getParameterList().getParametersCount() == 1) { + return null; + } + } + DeclarationDescriptor classDescriptor; final List classTypeParameters; if (method.hasModifierProperty(PsiModifier.STATIC)) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceDescriptor.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceDescriptor.java index 3443ebf0f79..5228ba22e14 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceDescriptor.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceDescriptor.java @@ -13,9 +13,12 @@ import java.util.List; */ public class JavaNamespaceDescriptor extends AbstractNamespaceDescriptorImpl { private JetScope memberScope; - - public JavaNamespaceDescriptor(DeclarationDescriptor containingDeclaration, List annotations, String name) { + private final String qualifiedName; + + public JavaNamespaceDescriptor(DeclarationDescriptor containingDeclaration, List annotations, + @NotNull String name, @NotNull String qualifiedName) { super(containingDeclaration, annotations, name); + this.qualifiedName = qualifiedName; } public void setMemberScope(@NotNull JetScope memberScope) { @@ -27,4 +30,8 @@ public class JavaNamespaceDescriptor extends AbstractNamespaceDescriptorImpl { public JetScope getMemberScope() { return memberScope; } + + public String getQualifiedName() { + return qualifiedName; + } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java index 45613dcb978..1e1c791fc14 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java @@ -2,6 +2,7 @@ package org.jetbrains.jet.lang.resolve.java; import com.google.common.collect.Sets; import com.intellij.psi.PsiClass; +import com.intellij.psi.PsiField; import com.intellij.psi.PsiModifier; import com.intellij.psi.PsiPackage; import org.jetbrains.annotations.NotNull; @@ -37,29 +38,59 @@ public class JavaPackageScope extends JetScopeImpl { public NamespaceDescriptor getNamespace(@NotNull String name) { return semanticServices.getDescriptorResolver().resolveNamespace(getQualifiedName(name)); } - - @NotNull - @Override - public Set getFunctions(@NotNull String name) { + + private PsiClass getPsiClassForPackage() { // If this package is actually a Kotlin namespace, then we access it through a namespace descriptor, and // Kotlin functions are already there NamespaceDescriptor kotlinNamespaceDescriptor = semanticServices.getKotlinNamespaceDescriptor(packageFQN); if (kotlinNamespaceDescriptor != null) { - return Collections.emptySet(); + return null; } // TODO: what is GlobalSearchScope PsiClass psiClass = semanticServices.getDescriptorResolver().javaFacade.findClass(getQualifiedName("namespace")); if (psiClass == null) { - return Collections.emptySet(); + return null; } if (containingDescriptor == null) { + return null; + } + + return psiClass; + } + + @NotNull + @Override + public Set getFunctions(@NotNull String name) { + PsiClass psiClassForPackage = getPsiClassForPackage(); + + if (psiClassForPackage == null) { return Collections.emptySet(); } - return semanticServices.getDescriptorResolver().resolveFunctionGroup(containingDescriptor, psiClass, null, name, true); -// return Collections.emptySet(); + return semanticServices.getDescriptorResolver().resolveFunctionGroup(containingDescriptor, psiClassForPackage, null, name, true); + } + + @NotNull + @Override + public Set getProperties(@NotNull String name) { + PsiClass psiClassForPackage = getPsiClassForPackage(); + + if (psiClassForPackage == null) { + return Collections.emptySet(); + } + + PsiField field = psiClassForPackage.findFieldByName(name, true); + if (field == null) { + return null; + } + if (!field.hasModifierProperty(PsiModifier.STATIC)) { + return null; + } + + // TODO: cache + return Collections.singleton(semanticServices.getDescriptorResolver().resolveFieldToVariableDescriptor(containingDescriptor, field)); } @NotNull diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAbi.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAbi.java index 0cb5f676a08..6ece6061f63 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAbi.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAbi.java @@ -6,4 +6,6 @@ package org.jetbrains.jet.lang.resolve.java; public class JvmAbi { public static final String TRAIT_IMPL_SUFFIX = "$$TImpl"; public static final String DEFAULT_PARAMS_IMPL_SUFFIX = "$default"; + public static final String GETTER_PREFIX = "get"; + public static final String SETTER_PREFIX = "set"; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java index facd569f63d..5b1f6695436 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java @@ -78,25 +78,6 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Callab setType(inType, outType, Collections.emptyList(), expectedThisObject, receiverType); } - private PropertyDescriptor( - @NotNull PropertyDescriptor original, - @Nullable JetType receiverType, - @NotNull ReceiverDescriptor expectedThisObject, - @Nullable JetType inType, - @NotNull JetType outType - ) { - this( - original, - original.getContainingDeclaration(), - original.getAnnotations(), // TODO : substitute? - original.getModality(), - original.getVisibility(), - original.isVar, - original.getName() - ); - setType(inType, outType, Collections.emptyList(), expectedThisObject, receiverType); - } - public void setType(@Nullable JetType inType, @NotNull JetType outType, @NotNull List typeParameters, @NotNull ReceiverDescriptor expectedThisObject, @Nullable JetType receiverType) { ReceiverDescriptor receiver = receiverType == null ? NO_RECEIVER diff --git a/compiler/testData/readClass/prop/ClassVal.kt b/compiler/testData/readClass/prop/ClassVal.kt new file mode 100644 index 00000000000..b0303be3744 --- /dev/null +++ b/compiler/testData/readClass/prop/ClassVal.kt @@ -0,0 +1,5 @@ +package test + +class ClassVal() { + val aa = 1 +} diff --git a/compiler/testData/readClass/prop/ClassVar.kt b/compiler/testData/readClass/prop/ClassVar.kt new file mode 100644 index 00000000000..4730972b7dd --- /dev/null +++ b/compiler/testData/readClass/prop/ClassVar.kt @@ -0,0 +1,5 @@ +package test + +class ClassVar() { + var aa = 1 +} diff --git a/compiler/testData/readClass/prop/NsVal.kt b/compiler/testData/readClass/prop/NsVal.kt new file mode 100644 index 00000000000..654f3ad18a0 --- /dev/null +++ b/compiler/testData/readClass/prop/NsVal.kt @@ -0,0 +1,3 @@ +package test + +val nsVal = 1 diff --git a/compiler/testData/readClass/prop/NsVar.kt b/compiler/testData/readClass/prop/NsVar.kt new file mode 100644 index 00000000000..5bc54696acd --- /dev/null +++ b/compiler/testData/readClass/prop/NsVar.kt @@ -0,0 +1,3 @@ +package test + +var nsVal = 1 diff --git a/compiler/tests/org/jetbrains/jet/CompileJavaAgainstKotlinTest.java b/compiler/tests/org/jetbrains/jet/CompileJavaAgainstKotlinTest.java index 8bb9e576bc6..b856970872d 100644 --- a/compiler/tests/org/jetbrains/jet/CompileJavaAgainstKotlinTest.java +++ b/compiler/tests/org/jetbrains/jet/CompileJavaAgainstKotlinTest.java @@ -53,7 +53,7 @@ public class CompileJavaAgainstKotlinTest extends UsefulTestCase { @Override protected void setUp() throws Exception { super.setUp(); - tmpdir = new File("tmp/" + this.getClass().getSimpleName() + "." + this.getName()); + tmpdir = JetTestUtils.tmpDirForTest(this); JetTestUtils.recreateDirectory(tmpdir); } diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index dc777e336fa..468862c1852 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -2,6 +2,7 @@ package org.jetbrains.jet; import com.google.common.collect.Lists; import com.intellij.openapi.Disposable; +import junit.framework.TestCase; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.cfg.pseudocode.JetControlFlowDataTraceFactory; import org.jetbrains.jet.lang.diagnostics.Diagnostic; @@ -166,6 +167,10 @@ public class JetTestUtils { file.delete(); } } + + public static File tmpDirForTest(TestCase test) { + return new File("tmp/" + test.getClass().getSimpleName() + "/" + test.getName()); + } public static void recreateDirectory(File file) throws IOException { rmrf(file); diff --git a/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java b/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java index d7e988b9052..d91f83f7123 100644 --- a/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java +++ b/compiler/tests/org/jetbrains/jet/ReadClassDataTest.java @@ -13,6 +13,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.codegen.ClassBuilderFactory; import org.jetbrains.jet.codegen.ClassFileFactory; import org.jetbrains.jet.codegen.GenerationState; +import org.jetbrains.jet.codegen.PropertyCodegen; import org.jetbrains.jet.compiler.CompileEnvironment; import org.jetbrains.jet.lang.JetSemanticServices; import org.jetbrains.jet.lang.descriptors.*; @@ -62,7 +63,7 @@ public class ReadClassDataTest extends UsefulTestCase { @Override protected void setUp() throws Exception { super.setUp(); - tmpdir = new File("tmp/" + this.getClass().getSimpleName() + "." + this.getName()); + tmpdir = JetTestUtils.tmpDirForTest(this); JetTestUtils.recreateDirectory(tmpdir); } @@ -132,7 +133,16 @@ public class ReadClassDataTest extends UsefulTestCase { Assert.assertTrue(functions.size() >= 1); Assert.assertTrue("not implemented", functions.size() == 1); FunctionDescriptor bd = functions.iterator().next(); - compareFunctions((FunctionDescriptor) ad, bd); + compareDescriptors(ad, bd); + } else if (ad instanceof PropertyDescriptor) { + Set properties = nsb.getMemberScope().getProperties(ad.getName()); + Assert.assertTrue(properties.size() >= 1); + Assert.assertTrue("not implemented", properties.size() == 1); + PropertyDescriptor bd = (PropertyDescriptor) properties.iterator().next(); + compareDescriptors(ad, bd); + + Assert.assertTrue(nsb.getMemberScope().getFunctions(PropertyCodegen.getterName(ad.getName())).isEmpty()); + Assert.assertTrue(nsb.getMemberScope().getFunctions(PropertyCodegen.setterName(ad.getName())).isEmpty()); } else { throw new AssertionError("Unknown member: " + ad); } @@ -153,7 +163,7 @@ public class ReadClassDataTest extends UsefulTestCase { System.out.println(as); } - private void compareFunctions(@NotNull FunctionDescriptor a, @NotNull FunctionDescriptor b) { + private void compareDescriptors(@NotNull DeclarationDescriptor a, @NotNull DeclarationDescriptor b) { StringBuilder sba = new StringBuilder(); StringBuilder sbb = new StringBuilder(); new Serializer(sba).serialize(a); diff --git a/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java b/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java index fc22ac350eb..52ce1309e36 100644 --- a/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java +++ b/compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java @@ -58,7 +58,7 @@ public class PropertyGenTest extends CodegenTestCase { final Field field = fields[0]; field.setAccessible(true); assertEquals("x", field.getName()); - assertEquals(Modifier.PRIVATE | Modifier.STATIC, field.getModifiers()); + assertEquals(Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL, field.getModifiers()); assertEquals(239, field.get(null)); }