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

Merge remote branch 'origin/master'

Browse Source
This commit is contained in:
Alex Tkachman
2011-12-30 10:34:01 +02:00
parent 01e6d6f7ec fb0752a41c
commit f2ff8823ac
14 changed files with 209 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java
+7 -3
View File
@@ -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);
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java
+116 -57
View File
@@ -86,11 +86,33 @@ public class JavaDescriptorResolver {
}
}
protected final Map<String, ClassDescriptor> 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<String, ResolverClassData> classDescriptorCache = Maps.newHashMap();
protected final Map<String, ResolverNamespaceData> namespaceDescriptorCacheByFqn = Maps.newHashMap();
protected final Map<PsiElement, ResolverNamespaceData> namespaceDescriptorCache = Maps.newHashMap();
protected final Map<PsiTypeParameter, TypeParameterDescriptorInitialization> typeParameterDescriptorCache = Maps.newHashMap();
protected final Map<PsiMethod, FunctionDescriptor> methodDescriptorCache = Maps.newHashMap();
protected final Map<PsiField, VariableDescriptor> fieldDescriptorCache = Maps.newHashMap();
protected final Map<PsiElement, NamespaceDescriptor> 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<JetType> supertypes = new ArrayList<JetType>();
List<TypeParameterDescriptor> typeParameters = resolveClassTypeParameters(psiClass, classDescriptor, new OuterClassTypeVariableResolver());
classDescriptor.setTypeConstructor(new TypeConstructorImpl(
classDescriptor,
List<TypeParameterDescriptor> typeParameters = resolveClassTypeParameters(psiClass, classData, new OuterClassTypeVariableResolver());
classData.classDescriptor.setTypeConstructor(new TypeConstructorImpl(
classData.classDescriptor,
Collections.<AnnotationDescriptor>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.<AnnotationDescriptor>emptyList(),
false);
constructorDescriptor.initialize(typeParameters, Collections.<ValueParameterDescriptor>emptyList(), Modality.FINAL, classDescriptor.getVisibility());
constructorDescriptor.setReturnType(classDescriptor.getDefaultType());
classDescriptor.addConstructor(constructorDescriptor);
constructorDescriptor.initialize(typeParameters, Collections.<ValueParameterDescriptor>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.<AnnotationDescriptor>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<TypeParameterDescriptor> resolveClassTypeParameters(PsiClass psiClass, JavaClassDescriptor classDescriptor, TypeVariableResolver typeVariableResolver) {
private List<TypeParameterDescriptor> 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.<AnnotationDescriptor>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.<AnnotationDescriptor>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<TypeParameterDescriptor> classTypeParameters;
if (method.hasModifierProperty(PsiModifier.STATIC)) {
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaNamespaceDescriptor.java
+9 -2
View File
@@ -13,9 +13,12 @@ import java.util.List;
*/
public class JavaNamespaceDescriptor extends AbstractNamespaceDescriptorImpl {
private JetScope memberScope;
public JavaNamespaceDescriptor(DeclarationDescriptor containingDeclaration, List<AnnotationDescriptor> annotations, String name) {
private final String qualifiedName;
public JavaNamespaceDescriptor(DeclarationDescriptor containingDeclaration, List<AnnotationDescriptor> 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;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java
+39 -8
View File
@@ -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<FunctionDescriptor> 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<FunctionDescriptor> 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<VariableDescriptor> 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
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JvmAbi.java
+2
View File
@@ -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";
}
compiler/frontend/src/org/jetbrains/jet/lang/descriptors/PropertyDescriptor.java
-19
View File
@@ -78,25 +78,6 @@ public class PropertyDescriptor extends VariableDescriptorImpl implements Callab
setType(inType, outType, Collections.<TypeParameterDescriptor>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.<TypeParameterDescriptor>emptyList(), expectedThisObject, receiverType);
}
public void setType(@Nullable JetType inType, @NotNull JetType outType, @NotNull List<TypeParameterDescriptor> typeParameters, @NotNull ReceiverDescriptor expectedThisObject, @Nullable JetType receiverType) {
ReceiverDescriptor receiver = receiverType == null
? NO_RECEIVER
compiler/testData/readClass/prop/ClassVal.kt
+5
View File
@@ -0,0 +1,5 @@
package test
class ClassVal() {
val aa = 1
}
compiler/testData/readClass/prop/ClassVar.kt
+5
View File
@@ -0,0 +1,5 @@
package test
class ClassVar() {
var aa = 1
}
compiler/testData/readClass/prop/NsVal.kt
+3
View File
@@ -0,0 +1,3 @@
package test
val nsVal = 1
compiler/testData/readClass/prop/NsVar.kt
+3
View File
@@ -0,0 +1,3 @@
package test
var nsVal = 1
compiler/tests/org/jetbrains/jet/CompileJavaAgainstKotlinTest.java
+1 -1
View File
@@ -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);
}
compiler/tests/org/jetbrains/jet/JetTestUtils.java
+5
View File
@@ -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);
compiler/tests/org/jetbrains/jet/ReadClassDataTest.java
+13 -3
View File
@@ -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<VariableDescriptor> 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);
compiler/tests/org/jetbrains/jet/codegen/PropertyGenTest.java
+1 -1
View File
@@ -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));
}