From c43c5fb697bc1b4e250497c213d89ee518b52263 Mon Sep 17 00:00:00 2001 From: Andrey Breslav Date: Tue, 5 Jun 2012 15:24:37 +0400 Subject: [PATCH] Initial lazy resolve test comparing descriptors with the existing resolve mechanisms --- compiler/testData/lazyResolve/simpleClass.txt | 5 + .../resolve/lazy/BasicLazyResolveTest.java | 37 +++--- .../lazy/LazyResolveComparingTest.java | 112 ++++++++++++++++++ 3 files changed, 136 insertions(+), 18 deletions(-) create mode 100644 compiler/testData/lazyResolve/simpleClass.txt create mode 100644 compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveComparingTest.java diff --git a/compiler/testData/lazyResolve/simpleClass.txt b/compiler/testData/lazyResolve/simpleClass.txt new file mode 100644 index 00000000000..9c862ba62f8 --- /dev/null +++ b/compiler/testData/lazyResolve/simpleClass.txt @@ -0,0 +1,5 @@ +namespace + +final class A : jet.Any { + final /*constructor*/ fun (): A +} diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/BasicLazyResolveTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/BasicLazyResolveTest.java index 52a719562e2..c05683f23c3 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/BasicLazyResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/BasicLazyResolveTest.java @@ -21,14 +21,16 @@ import com.intellij.openapi.util.Disposer; import org.jetbrains.jet.CompileCompilerDependenciesTest; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetPsiFactory; +import org.jetbrains.jet.lang.resolve.java.CompilerDependencies; import org.jetbrains.jet.lang.resolve.java.CompilerSpecialMode; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.TypeConstructor; import org.jetbrains.jet.lang.types.lang.JetStandardClasses; import org.junit.After; -import org.junit.Before; +import org.junit.BeforeClass; import org.junit.Test; import java.util.Arrays; @@ -37,7 +39,6 @@ import java.util.Comparator; import java.util.List; import static org.junit.Assert.*; -import static org.junit.Assert.assertNotNull; /** * @author abreslav @@ -52,8 +53,20 @@ public class BasicLazyResolveTest { } }; - @Before - public void setUp() throws Exception { + private final CompilerDependencies 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 { System.setProperty("java.awt.headless", "true"); } @@ -63,22 +76,10 @@ public class BasicLazyResolveTest { } @Test - public void test() { - JetCoreEnvironment jetCoreEnvironment = - new JetCoreEnvironment(rootDisposable, CompileCompilerDependenciesTest.compilerDependenciesForTests(CompilerSpecialMode.REGULAR, true)); - + public void testBasic() { ModuleDescriptor root = new ModuleDescriptor(Name.special("")); - Project project = jetCoreEnvironment.getProject(); - - ResolveSession session = new ResolveSession(project, root, new FileBasedDeclarationProviderFactory(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) {}") - ))); + ResolveSession session = new ResolveSession(project, root, new FileBasedDeclarationProviderFactory(files)); NamespaceDescriptor rootPackage = session.getPackageDescriptorByFqName(new FqName("")); assertNotNull(rootPackage); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveComparingTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveComparingTest.java new file mode 100644 index 00000000000..202fab16823 --- /dev/null +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveComparingTest.java @@ -0,0 +1,112 @@ +/* + * 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.google.common.base.Predicates; +import com.intellij.openapi.Disposable; +import com.intellij.openapi.project.Project; +import com.intellij.openapi.util.Disposer; +import com.intellij.psi.PsiFile; +import org.jetbrains.jet.CompileCompilerDependenciesTest; +import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; +import org.jetbrains.jet.cli.jvm.compiler.NamespaceComparator; +import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; +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; +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.util.Collections; +import java.util.List; + +/** + * @author abreslav + */ +public class LazyResolveComparingTest { + private final Disposable rootDisposable = new Disposable() { + @Override + public void dispose() { + } + }; + + private final CompilerDependencies + 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 { + System.setProperty("java.awt.headless", "true"); + } + + @After + public void tearDown() throws Exception { + Disposer.dispose(rootDisposable); + } + + @Test + public void testNamespacesAreEqual() throws Exception { + 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); + // } + //} + + 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")); + } +}