diff --git a/compiler/testData/lazyResolve/genericFunction.kt b/compiler/testData/lazyResolve/genericFunction.kt new file mode 100644 index 00000000000..1a362e79552 --- /dev/null +++ b/compiler/testData/lazyResolve/genericFunction.kt @@ -0,0 +1 @@ +fun foo(t : T) : T {} \ No newline at end of file diff --git a/compiler/testData/lazyResolve/genericFunction.txt b/compiler/testData/lazyResolve/genericFunction.txt new file mode 100644 index 00000000000..46e07f29b6d --- /dev/null +++ b/compiler/testData/lazyResolve/genericFunction.txt @@ -0,0 +1,3 @@ +namespace + +final fun foo(/*0*/ t: T): T diff --git a/compiler/testData/lazyResolve/simpleClass.kt b/compiler/testData/lazyResolve/simpleClass.kt new file mode 100644 index 00000000000..db5e88bb2b0 --- /dev/null +++ b/compiler/testData/lazyResolve/simpleClass.kt @@ -0,0 +1,17 @@ +// FILE: a.kt +class A {} + +// FILE: b.kt +package p; class C {fun f() {}} + +// FILE: c.kt +package p; open class G {open fun f(): T {} fun a() {}} + +// FILE: d.kt +package p; class G2 : G { fun g() : E {} override fun f() : T {}} + +// FILE: e.kt +package p; fun foo() {} + +// FILE: f.kt +package p; fun foo(a: C) {} diff --git a/compiler/testData/lazyResolve/simpleClass.txt b/compiler/testData/lazyResolve/simpleClass.txt index 9c862ba62f8..58830c8b0a7 100644 --- a/compiler/testData/lazyResolve/simpleClass.txt +++ b/compiler/testData/lazyResolve/simpleClass.txt @@ -1,5 +1,26 @@ namespace +// +namespace p + +final class p.C : jet.Any { + final /*constructor*/ fun (): p.C + final fun f(): jet.Tuple0 +} +open class p.G : jet.Any { + final /*constructor*/ fun (): p.G + final fun a(): jet.Tuple0 + open fun f(): T +} +final class p.G2 : p.G { + final /*constructor*/ fun (): p.G2 + final override /*1*/ fun a(): jet.Tuple0 + open override /*1*/ fun f(): + final fun g(): E +} +final fun foo(): jet.Tuple0 +final fun foo(/*0*/ a: p.C): jet.Tuple0 +// final class A : jet.Any { final /*constructor*/ fun (): A } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveComparingTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveComparingTest.java similarity index 62% rename from compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveComparingTest.java rename to compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveComparingTest.java index 202fab16823..bc5e890f2ec 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveComparingTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveComparingTest.java @@ -20,8 +20,10 @@ import com.google.common.base.Predicates; import com.intellij.openapi.Disposable; import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Disposer; +import com.intellij.openapi.util.io.FileUtil; import com.intellij.psi.PsiFile; import org.jetbrains.jet.CompileCompilerDependenciesTest; +import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.cli.jvm.compiler.NamespaceComparator; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; @@ -29,7 +31,6 @@ import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; -import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; @@ -37,17 +38,16 @@ import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.name.Name; import org.junit.After; import org.junit.BeforeClass; -import org.junit.Test; import java.io.File; -import java.util.Arrays; +import java.io.IOException; import java.util.Collections; import java.util.List; /** * @author abreslav */ -public class LazyResolveComparingTest { +public abstract class AbstractLazyResolveComparingTest { private final Disposable rootDisposable = new Disposable() { @Override public void dispose() { @@ -58,14 +58,6 @@ public class LazyResolveComparingTest { compilerDependencies = CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true); private final JetCoreEnvironment jetCoreEnvironment = new JetCoreEnvironment(rootDisposable, compilerDependencies); private final Project project = jetCoreEnvironment.getProject(); - private final List files = Arrays.asList( - JetPsiFactory.createFile(project, "class A {}"), - JetPsiFactory.createFile(project, "package p; class C {fun f() {}}"), - JetPsiFactory.createFile(project, "package p; open class G {open fun f(): T {} fun a() {}}"), - JetPsiFactory.createFile(project, "package p; class G2 : G { fun g() : E {} override fun f() : T {}}"), - JetPsiFactory.createFile(project, "package p; fun foo() {}"), - JetPsiFactory.createFile(project, "package p; fun foo(a: C) {}") - ); @BeforeClass public static void setUp() throws Exception { @@ -77,36 +69,29 @@ public class LazyResolveComparingTest { Disposer.dispose(rootDisposable); } - @Test - public void testNamespacesAreEqual() throws Exception { + protected void doTest(String testFileName) throws IOException { TopDownAnalysisParameters params = new TopDownAnalysisParameters( Predicates.alwaysTrue(), false, false, Collections.emptyList()); ModuleDescriptor module = new ModuleDescriptor(Name.special("")); InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, params, new BindingTraceContext(), module, compilerDependencies); - injector.getTopDownAnalyzer().analyzeFiles(files, Collections.emptyList()); - final BindingTrace trace = injector.getBindingTrace(); - //for (JetFile file : files) { - // for (final JetDeclaration declaration : file.getDeclarations()) { - // declaration.accept(new JetTreeVisitor() { - // @Override - // public Void visitDeclaration(JetDeclaration dcl, Void data) { - // DeclarationDescriptor descriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, dcl); - // System.out.println(descriptor); - // return super.visitDeclaration(dcl, data); - // } - // }, null); - // } - //} + + List files = JetTestUtils + .createTestFiles(testFileName, FileUtil.loadFile(new File(testFileName)), new JetTestUtils.TestFileFactory() { + @Override + public JetFile create(String fileName, String text) { + return JetPsiFactory.createFile(project, fileName, text); + } + }); + + injector.getTopDownAnalyzer().analyzeFiles(files, Collections.emptyList()); ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("")); ResolveSession session = new ResolveSession(project, lazyModule, new FileBasedDeclarationProviderFactory(files)); - NamespaceComparator.compareNamespaces(lazyModule.getRootNamespace(), module.getRootNamespace(), true, - new File("compiler/testData/lazyResolve/simpleClass.txt")); - //NamespaceComparator.compareNamespaces(lazyModule.getRootNamespace().getMemberScope().getNamespace(Name.identifier("p")), - // module.getRootNamespace().getMemberScope().getNamespace(Name.identifier("p")), true, new File("log1.txt")); + NamespaceComparator.compareNamespaces(module.getRootNamespace(), lazyModule.getRootNamespace(), true, + new File(FileUtil.getNameWithoutExtension(testFileName) + ".txt")); } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveComparingTestGenerated.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveComparingTestGenerated.java new file mode 100644 index 00000000000..1754ef9c266 --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveComparingTestGenerated.java @@ -0,0 +1,60 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jetbrains.jet.lang.resolve.lazy; + +import org.junit.Assert; +import org.junit.Test; + +import java.io.File; +import java.io.FileFilter; +import java.lang.reflect.Method; +import java.util.HashSet; +import java.util.Set; + +/* This class is generated by LazyResolveComparingTestGenerator. DO NOT MODIFY MANUALLY */ +public class LazyResolveComparingTestGenerated extends AbstractLazyResolveComparingTest { + @Test + public void testGenericFunction() throws Exception { + doTest("compiler/testData/lazyResolve/genericFunction.kt"); + } + + @Test + public void testSimpleClass() throws Exception { + doTest("compiler/testData/lazyResolve/simpleClass.kt"); + } + + @Test + public void allTestsPresent() { + Set methodNames = new HashSet(); + for (Method method : LazyResolveComparingTestGenerated.class.getDeclaredMethods()) { + if (method.isAnnotationPresent(Test.class)) { + methodNames.add(method.getName().toLowerCase() + ".kt"); + } + } + File[] testDataFiles = new File("compiler/testData/lazyResolve").listFiles(new FileFilter() { + @Override + public boolean accept(File pathname) { + return pathname.getName().endsWith(".kt"); + } + }); + for (File testDataFile : testDataFiles) { + if (!methodNames.contains("test" + testDataFile.getName().toLowerCase())) { + Assert.fail("Test data file missing from the generated test class: " + testDataFile + "\nPlease re-run the generator: LazyResolveComparingTestGenerated"); + } + } + } + +} diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveComparingTestGenerator.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveComparingTestGenerator.java new file mode 100644 index 00000000000..e0cce2a49be --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveComparingTestGenerator.java @@ -0,0 +1,166 @@ +/* + * Copyright 2010-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.jet.lang.resolve.lazy; + +import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.util.text.StringUtil; +import org.jetbrains.annotations.NotNull; + +import java.io.File; +import java.io.FileFilter; +import java.io.IOException; + +/** + * @author abreslav + */ +public class LazyResolveComparingTestGenerator { + public static void main(String[] args) throws IOException { + new LazyResolveComparingTestGenerator().generateAndSave(); + } + + private final String baseDir; + private final String testDataFileExtension; + private final String testClassPackage; + private final String testClassName; + private final String baseTestClassPackage; + private final String baseTestClassName; + private final File testDataDir; + private final String generatorName; + + public LazyResolveComparingTestGenerator() { + baseDir = "compiler/tests/"; + testDataFileExtension = "kt"; + testClassPackage = "org.jetbrains.jet.lang.resolve.lazy"; + testClassName = "LazyResolveComparingTestGenerated"; + baseTestClassPackage = "org.jetbrains.jet.lang.resolve.lazy"; + baseTestClassName = "AbstractLazyResolveComparingTest"; + testDataDir = new File("compiler/testData/lazyResolve"); + generatorName = "LazyResolveComparingTestGenerator"; + } + + public void generateAndSave() throws IOException { + StringBuilder out = new StringBuilder(); + Printer p = new Printer(out); + + p.print(FileUtil.loadFile(new File("injector-generator/copyright.txt"))); + p.println("package ", testClassPackage, ";"); + p.println(); + p.println("import org.junit.Assert;"); + p.println("import org.junit.Test;"); + p.println(); + + p.println("import java.io.File;"); + p.println("import java.io.FileFilter;"); + p.println("import java.lang.reflect.Method;"); + p.println("import java.util.HashSet;"); + p.println("import java.util.Set;"); + p.println(); + + p.println("import ", baseTestClassPackage, ".", baseTestClassName, ";"); + p.println(); + + p.println("/* This class is generated by " + generatorName + ". DO NOT MODIFY MANUALLY */"); + p.println("public class ", testClassName, " extends ", baseTestClassName, " {"); + p.pushIndent(); + + File[] ktFiles = testDataDir.listFiles(new FileFilter() { + @Override + public boolean accept(File pathname) { + return pathname.getName().endsWith("." + testDataFileExtension); + } + }); + for (File file : ktFiles) { + p.println("@Test"); + p.println("public void test", FileUtil.getNameWithoutExtension(StringUtil.capitalize(file.getName())), "() throws Exception {"); + p.pushIndent(); + + p.println("doTest(\"", file.getPath(), "\");"); + + p.popIndent(); + p.println("}"); + p.println(); + } + + generateAllTestsPresent(p); + + p.popIndent(); + p.println("}"); + + String testSourceFilePath = baseDir + testClassPackage.replace(".", "/") + "/" + testClassName + ".java"; + FileUtil.writeToFile(new File(testSourceFilePath), out.toString()); + } + + private void generateAllTestsPresent(Printer p) { + String methodText = + "@Test\n" + + " public void allTestsPresent() {\n" + + " Set methodNames = new HashSet();\n" + + " for (Method method : " + testClassName + ".class.getDeclaredMethods()) {\n" + + " if (method.isAnnotationPresent(Test.class)) {\n" + + " methodNames.add(method.getName().toLowerCase() + \"." + testDataFileExtension + "\");\n" + + " }\n" + + " }\n" + + " File[] testDataFiles = new File(\"" + testDataDir + "\").listFiles(new FileFilter() {\n" + + " @Override\n" + + " public boolean accept(File pathname) {\n" + + " return pathname.getName().endsWith(\"." + testDataFileExtension + "\");\n" + + " }\n" + + " });\n" + + " for (File testDataFile : testDataFiles) {\n" + + " if (!methodNames.contains(\"test\" + testDataFile.getName().toLowerCase())) {\n" + + " Assert.fail(\"Test data file missing from the generated test class: \" + testDataFile + \"\\nPlease re-run the generator: " + testClassName + "\");\n" + + " }\n" + + " }\n" + + " }\n"; + + p.println(methodText); + } + + private static class Printer { + private static final String INDENTATION_UNIT = " "; + private String indent = ""; + private final StringBuilder out; + + private Printer(@NotNull StringBuilder out) { + this.out = out; + } + + public void println(Object... objects) { + print(objects); + out.append("\n"); + } + + public void print(Object... objects) { + out.append(indent); + for (Object object : objects) { + out.append(object); + } + } + + public void pushIndent() { + indent += INDENTATION_UNIT; + } + + public void popIndent() { + if (indent.length() < INDENTATION_UNIT.length()) { + throw new IllegalStateException("No indentation to pop"); + } + + indent = indent.substring(INDENTATION_UNIT.length()); + } + } +}