Stepan Koltsov
373 lines
13 KiB
Java
373 lines
13 KiB
Java
package org.jetbrains.jet;
|
|
|
|
import com.intellij.openapi.Disposable;
|
|
import com.intellij.openapi.util.Disposer;
|
|
import com.intellij.openapi.util.io.FileUtil;
|
|
import com.intellij.openapi.vfs.CharsetToolkit;
|
|
import com.intellij.psi.PsiFileFactory;
|
|
import com.intellij.psi.impl.PsiFileFactoryImpl;
|
|
import com.intellij.testFramework.LightVirtualFile;
|
|
import com.intellij.testFramework.UsefulTestCase;
|
|
import junit.framework.Test;
|
|
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.compiler.CompileEnvironment;
|
|
import org.jetbrains.jet.lang.JetSemanticServices;
|
|
import org.jetbrains.jet.lang.descriptors.*;
|
|
import org.jetbrains.jet.lang.psi.JetFile;
|
|
import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
|
|
import org.jetbrains.jet.lang.resolve.BindingContext;
|
|
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
|
|
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
|
|
import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
|
|
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
|
|
import org.jetbrains.jet.lang.types.JetType;
|
|
import org.jetbrains.jet.lang.types.TypeProjection;
|
|
import org.jetbrains.jet.lang.types.Variance;
|
|
import org.jetbrains.jet.plugin.JetLanguage;
|
|
import org.junit.Assert;
|
|
|
|
import java.io.File;
|
|
import java.lang.reflect.Method;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
|
|
/**
|
|
* @author Stepan Koltsov
|
|
*/
|
|
public class ReadClassDataTest extends UsefulTestCase {
|
|
|
|
protected final Disposable myTestRootDisposable = new Disposable() {
|
|
@Override
|
|
public void dispose() {
|
|
}
|
|
};
|
|
|
|
private JetCoreEnvironment jetCoreEnvironment;
|
|
private File tmpdir;
|
|
|
|
private final File testFile;
|
|
|
|
public ReadClassDataTest(@NotNull File testFile) {
|
|
this.testFile = testFile;
|
|
setName(testFile.getName());
|
|
}
|
|
|
|
@Override
|
|
protected void setUp() throws Exception {
|
|
super.setUp();
|
|
tmpdir = new File("tmp/" + this.getClass().getSimpleName() + "." + this.getName());
|
|
JetTestUtils.recreateDirectory(tmpdir);
|
|
}
|
|
|
|
@Override
|
|
public void tearDown() throws Exception {
|
|
Disposer.dispose(myTestRootDisposable);
|
|
}
|
|
|
|
private void createMockCoreEnvironment() {
|
|
jetCoreEnvironment = new JetCoreEnvironment(myTestRootDisposable);
|
|
|
|
final File rtJar = new File(JetTestCaseBuilder.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/rt.jar");
|
|
jetCoreEnvironment.addToClasspath(rtJar);
|
|
jetCoreEnvironment.addToClasspath(new File(JetTestCaseBuilder.getHomeDirectory(), "compiler/testData/mockJDK-1.7/jre/lib/annotations.jar"));
|
|
}
|
|
|
|
@Override
|
|
public void runTest() throws Exception {
|
|
jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdk(myTestRootDisposable);
|
|
|
|
String text = FileUtil.loadFile(testFile);
|
|
|
|
LightVirtualFile virtualFile = new LightVirtualFile(testFile.getName(), JetLanguage.INSTANCE, text);
|
|
virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET);
|
|
JetFile psiFile = (JetFile) ((PsiFileFactoryImpl) PsiFileFactory.getInstance(jetCoreEnvironment.getProject())).trySetupPsiForFile(virtualFile, JetLanguage.INSTANCE, true, false);
|
|
|
|
GenerationState state = new GenerationState(jetCoreEnvironment.getProject(), ClassBuilderFactory.BINARIES);
|
|
AnalyzingUtils.checkForSyntacticErrors(psiFile);
|
|
BindingContext bindingContext = state.compile(psiFile);
|
|
|
|
ClassFileFactory classFileFactory = state.getFactory();
|
|
|
|
CompileEnvironment.writeToOutputDirectory(classFileFactory, tmpdir.getPath());
|
|
|
|
NamespaceDescriptor namespaceFromSource = (NamespaceDescriptor) bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, psiFile.getRootNamespace());
|
|
|
|
Assert.assertEquals("test", namespaceFromSource.getName());
|
|
|
|
Disposer.dispose(myTestRootDisposable);
|
|
|
|
|
|
jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdk(myTestRootDisposable);
|
|
|
|
jetCoreEnvironment.addToClasspath(tmpdir);
|
|
|
|
JetSemanticServices jetSemanticServices = JetSemanticServices.createSemanticServices(jetCoreEnvironment.getProject());
|
|
JavaSemanticServices semanticServices = new JavaSemanticServices(jetCoreEnvironment.getProject(), jetSemanticServices, new BindingTraceContext());
|
|
|
|
JavaDescriptorResolver javaDescriptorResolver = semanticServices.getDescriptorResolver();
|
|
NamespaceDescriptor namespaceFromClass = javaDescriptorResolver.resolveNamespace("test");
|
|
|
|
compareNamespaces(namespaceFromSource, namespaceFromClass);
|
|
}
|
|
|
|
private void compareNamespaces(@NotNull NamespaceDescriptor nsa, @NotNull NamespaceDescriptor nsb) {
|
|
Assert.assertEquals(nsa.getName(), nsb.getName());
|
|
System.out.println("namespace " + nsa.getName());
|
|
for (DeclarationDescriptor ad : nsa.getMemberScope().getAllDescriptors()) {
|
|
if (ad instanceof ClassifierDescriptor) {
|
|
ClassifierDescriptor bd = nsb.getMemberScope().getClassifier(ad.getName());
|
|
compareClassifiers((ClassifierDescriptor) ad, bd);
|
|
} else if (ad instanceof FunctionDescriptor) {
|
|
Set<FunctionDescriptor> functions = nsb.getMemberScope().getFunctions(ad.getName());
|
|
Assert.assertTrue(functions.size() >= 1);
|
|
Assert.assertTrue("not implemented", functions.size() == 1);
|
|
FunctionDescriptor bd = functions.iterator().next();
|
|
compareFunctions((FunctionDescriptor) ad, bd);
|
|
} else {
|
|
throw new AssertionError("Unknown member: " + ad);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void compareClassifiers(@NotNull ClassifierDescriptor a, @NotNull ClassifierDescriptor b) {
|
|
String as = serializeContent((ClassDescriptor) a);
|
|
String bs = serializeContent((ClassDescriptor) b);
|
|
|
|
Assert.assertEquals(as, bs);
|
|
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
|
|
|
|
sb.append(" {\n");
|
|
|
|
List<TypeProjection> typeArguments = new ArrayList<TypeProjection>();
|
|
for (TypeParameterDescriptor param : klass.getTypeConstructor().getParameters()) {
|
|
typeArguments.add(new TypeProjection(Variance.INVARIANT, param.getDefaultType()));
|
|
}
|
|
|
|
JetScope memberScope = klass.getMemberScope(typeArguments);
|
|
for (DeclarationDescriptor member : memberScope.getAllDescriptors()) {
|
|
// TODO
|
|
if (member.getName().equals("equals") || member.getName().equals("hashCode")
|
|
|| member.getName().equals("wait") || member.getName().equals("notify") || member.getName().equals("notifyAll")
|
|
|| member.getName().equals("toString") || member.getName().equals("getClass")
|
|
|| member.getName().equals("clone") || member.getName().equals("finalize")
|
|
|| member.getName().equals("getTypeInfo") || member.getName().equals("$setTypeInfo") || member.getName().equals("$typeInfo")
|
|
)
|
|
{
|
|
continue;
|
|
}
|
|
sb.append(" ");
|
|
serialize(member, sb);
|
|
sb.append("\n");
|
|
}
|
|
|
|
sb.append("}\n");
|
|
return sb.toString();
|
|
}
|
|
|
|
|
|
private void compareFunctions(@NotNull FunctionDescriptor a, @NotNull FunctionDescriptor b) {
|
|
String as = serialize(a);
|
|
String bs = serialize(b);
|
|
|
|
Assert.assertEquals(as, bs);
|
|
System.out.println(as);
|
|
}
|
|
|
|
|
|
private static Object invoke(Method method, Object thiz, Object... args) {
|
|
try {
|
|
return method.invoke(thiz, args);
|
|
} catch (Exception e) {
|
|
throw new RuntimeException("failed to invoke " + method + ": " + e, e);
|
|
}
|
|
}
|
|
|
|
|
|
private void serialize(FunctionDescriptor fun, StringBuilder sb) {
|
|
sb.append("fun ");
|
|
if (!fun.getTypeParameters().isEmpty()) {
|
|
sb.append("<");
|
|
serializeCommaSeparated(fun.getTypeParameters(), sb);
|
|
sb.append(">");
|
|
}
|
|
sb.append(fun.getName());
|
|
sb.append("(");
|
|
serializeCommaSeparated(fun.getValueParameters(), sb);
|
|
sb.append("): ");
|
|
serialize(fun.getReturnType(), sb);
|
|
}
|
|
|
|
private void serialize(PropertyDescriptor prop, StringBuilder sb) {
|
|
if (prop.isVar()) {
|
|
sb.append("var ");
|
|
} else {
|
|
sb.append("val ");
|
|
}
|
|
sb.append(prop.getName());
|
|
sb.append(": ");
|
|
serialize(prop.getOutType(), sb);
|
|
}
|
|
|
|
private void serialize(ValueParameterDescriptor valueParameter, StringBuilder sb) {
|
|
sb.append(valueParameter.getName());
|
|
sb.append(": ");
|
|
if (valueParameter.getVarargElementType() != null) {
|
|
sb.append("vararg ");
|
|
serialize(valueParameter.getVarargElementType());
|
|
} else {
|
|
serialize(valueParameter.getOutType(), sb);
|
|
}
|
|
if (valueParameter.hasDefaultValue()) {
|
|
sb.append(" = ?");
|
|
}
|
|
}
|
|
|
|
private void serialize(Variance variance, StringBuilder sb) {
|
|
if (variance == Variance.INVARIANT) {
|
|
|
|
} else {
|
|
sb.append(variance);
|
|
sb.append(' ');
|
|
}
|
|
}
|
|
|
|
private void serialize(JetType type, StringBuilder sb) {
|
|
serialize(type.getConstructor().getDeclarationDescriptor(), sb);
|
|
if (!type.getArguments().isEmpty()) {
|
|
sb.append("<");
|
|
boolean first = true;
|
|
for (TypeProjection proj : type.getArguments()) {
|
|
serialize(proj.getProjectionKind(), sb);
|
|
serialize(proj.getType(), sb);
|
|
if (!first) {
|
|
sb.append(", ");
|
|
}
|
|
first = false;
|
|
}
|
|
sb.append(">");
|
|
}
|
|
}
|
|
|
|
private String serialize(Object o) {
|
|
StringBuilder sb = new StringBuilder();
|
|
serialize(o, sb);
|
|
return sb.toString();
|
|
}
|
|
|
|
private void serializeCommaSeparated(List<?> list, StringBuilder sb) {
|
|
serializeSeparated(list, sb, ", ");
|
|
}
|
|
|
|
private void serializeSeparated(List<?> list, StringBuilder sb, String sep) {
|
|
boolean first = true;
|
|
for (Object o : list) {
|
|
if (!first) {
|
|
sb.append(sep);
|
|
}
|
|
serialize(o, sb);
|
|
first = false;
|
|
}
|
|
}
|
|
|
|
private Method getMethodToSerialize(Object o) {
|
|
// TODO: cache
|
|
for (Method method : ReadClassDataTest.class.getDeclaredMethods()) {
|
|
if (!method.getName().equals("serialize")) {
|
|
continue;
|
|
}
|
|
if (method.getParameterTypes().length != 2) {
|
|
continue;
|
|
}
|
|
if (!method.getParameterTypes()[1].equals(StringBuilder.class)) {
|
|
continue;
|
|
}
|
|
if (method.getParameterTypes()[0].equals(Object.class)) {
|
|
continue;
|
|
}
|
|
if (method.getParameterTypes()[0].isInstance(o)) {
|
|
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(String s, StringBuilder sb) {
|
|
sb.append(s);
|
|
}
|
|
|
|
private void serialize(ModuleDescriptor module, StringBuilder sb) {
|
|
// nop
|
|
}
|
|
|
|
private void serialize(ClassDescriptor clazz, StringBuilder sb) {
|
|
serialize(clazz.getContainingDeclaration(), sb);
|
|
sb.append(".");
|
|
sb.append(clazz.getName());
|
|
}
|
|
|
|
private void serialize(NamespaceDescriptor ns, StringBuilder sb) {
|
|
if (ns.getContainingDeclaration() == null) {
|
|
// root ns
|
|
return;
|
|
}
|
|
serialize(ns.getContainingDeclaration(), sb);
|
|
sb.append(".");
|
|
sb.append(ns.getName());
|
|
}
|
|
|
|
private void serialize(TypeParameterDescriptor param, StringBuilder sb) {
|
|
serialize(param.getVariance(), sb);
|
|
sb.append(param.getName());
|
|
if (!param.getUpperBounds().isEmpty()) {
|
|
sb.append(" : ");
|
|
List<String> list = new ArrayList<String>();
|
|
for (JetType upper : param.getUpperBounds()) {
|
|
list.add(serialize(upper));
|
|
}
|
|
Collections.sort(list);
|
|
serializeSeparated(list, sb, " & "); // TODO: use where
|
|
}
|
|
// TODO: lower bounds
|
|
}
|
|
|
|
|
|
public static Test suite() {
|
|
return JetTestCaseBuilder.suiteForDirectory(JetTestCaseBuilder.getTestDataPathBase(), "/readClass", true, new JetTestCaseBuilder.NamedTestFactory() {
|
|
@NotNull
|
|
@Override
|
|
public Test createTest(@NotNull String dataPath, @NotNull String name, @NotNull File file) {
|
|
return new ReadClassDataTest(file);
|
|
}
|
|
});
|
|
}
|
|
|
|
}
|