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

New resolveLazily(): accounts for Java interop

Browse Source
This commit is contained in:
Andrey Breslav
2012-07-10 21:10:39 +04:00
parent 33dfd5bb6b
commit 20860cb40b
4 changed files with 88 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java
+1 -1
View File
@@ -47,7 +47,7 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends Abstract
protected void doTest(@NotNull String testFile) throws IOException {
InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer(getRegularEnvironment());
InjectorForTopDownAnalyzer injectorForTopDownAnalyzer = getEagerInjectorForTopDownAnalyzer(getRegularEnvironment().jetCoreEnvironment);
JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true));
Collection<JetFile> files = Lists.newArrayList(psiFile);
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java
+10 -11
View File
@@ -23,7 +23,6 @@ import com.intellij.util.Function;
import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.jvm.compiler.NamespaceComparator;
import org.jetbrains.jet.lang.ModuleConfiguration;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
@@ -74,8 +73,8 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
Predicate<NamespaceDescriptor> filterJetNamespace,
File serializeResultsTo
) {
ModuleDescriptor module = resolveEagerly(files, ConfigurationKind.JDK_ONLY);
ModuleDescriptor lazyModule = resolveLazily(files, ConfigurationKind.JDK_ONLY);
ModuleDescriptor module = resolveEagerly(files, new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_ONLY).jetCoreEnvironment);
ModuleDescriptor lazyModule = resolveLazily(files, new JetCoreEnvironmentWithDisposable(ConfigurationKind.JDK_ONLY).jetCoreEnvironment);
Pair<NamespaceDescriptor, NamespaceDescriptor> namespacesToCompare = transform.fun(Pair.create(module, lazyModule));
@@ -83,14 +82,14 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends Abstract
includeMembersOfObject, filterJetNamespace, serializeResultsTo);
}
private ModuleDescriptor resolveLazily(List<JetFile> files, ConfigurationKind configurationKind) {
ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind);
ModuleConfiguration moduleConfiguration = getEagerInjectorForTopDownAnalyzer(environment).getModuleConfiguration();
ResolveSession
session = new ResolveSession(getProject(), lazyModule, moduleConfiguration, new FileBasedDeclarationProviderFactory(files));
return lazyModule;
}
//private ModuleDescriptor resolveLazily(List<JetFile> files, ConfigurationKind configurationKind) {
// ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
// JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind);
// ModuleConfiguration moduleConfiguration = getEagerInjectorForTopDownAnalyzer(environment).getModuleConfiguration();
// ResolveSession
// session = new ResolveSession(getProject(), lazyModule, moduleConfiguration, new FileBasedDeclarationProviderFactory(files));
// return lazyModule;
//}
protected void doTest(String testFileName) throws Exception {
doTest(testFileName, new Function<Pair<ModuleDescriptor, ModuleDescriptor>, Pair<NamespaceDescriptor, NamespaceDescriptor>>() {
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java
+72 -9
View File
@@ -16,21 +16,34 @@
package org.jetbrains.jet.lang.resolve.lazy;
import com.google.common.base.Predicate;
import com.google.common.base.Predicates;
import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiFile;
import org.jetbrains.jet.ConfigurationKind;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.KotlinTestWithDefaultEnvironment;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
import org.jetbrains.jet.di.InjectorForTopDownAnalyzer;
import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
import org.jetbrains.jet.lang.DefaultModuleConfiguration;
import org.jetbrains.jet.lang.ModuleConfiguration;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.psi.JetImportDirective;
import org.jetbrains.jet.lang.psi.JetPsiFactory;
import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter;
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
import org.jetbrains.jet.lang.resolve.java.JavaPackageScope;
import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.types.lang.JetStandardLibrary;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
@@ -39,7 +52,7 @@ import java.util.List;
*/
public abstract class AbstractLazyResolveTest extends KotlinTestWithDefaultEnvironment {
protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironmentWithDisposable environment) {
protected InjectorForTopDownAnalyzer getEagerInjectorForTopDownAnalyzer(JetCoreEnvironment environment) {
ModuleDescriptor eagerModuleForLazy = new ModuleDescriptor(Name.special("<eager module for lazy>"));
InjectorForTopDownAnalyzer tdaInjectorForLazy = createInjectorForTDA(eagerModuleForLazy, environment);
@@ -49,18 +62,68 @@ public abstract class AbstractLazyResolveTest extends KotlinTestWithDefaultEnvir
return tdaInjectorForLazy;
}
protected InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module, JetCoreEnvironmentWithDisposable environment) {
protected InjectorForTopDownAnalyzer createInjectorForTDA(ModuleDescriptor module, JetCoreEnvironment environment) {
TopDownAnalysisParameters params = new TopDownAnalysisParameters(
Predicates.<PsiFile>alwaysTrue(), false, false, Collections.<AnalyzerScriptParameter>emptyList());
return new InjectorForTopDownAnalyzerForJvm(environment.project, params, new BindingTraceContext(), module, BuiltinsScopeExtensionMode.ALL);
return new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, new BindingTraceContext(), module, BuiltinsScopeExtensionMode.ALL);
}
protected ModuleDescriptor resolveEagerly(List<JetFile> files, ConfigurationKind configurationKind) {
protected ModuleDescriptor resolveEagerly(List<JetFile> files, JetCoreEnvironment environment) {
ModuleDescriptor module = new ModuleDescriptor(Name.special("<test module>"));
JetCoreEnvironmentWithDisposable environment = new JetCoreEnvironmentWithDisposable(configurationKind);
InjectorForTopDownAnalyzer injector = createInjectorForTDA(module, environment);
injector.getTopDownAnalyzer().analyzeFiles(files, Collections.<AnalyzerScriptParameter>emptyList());
return module;
}
protected ModuleDescriptor resolveLazily(List<JetFile> files, JetCoreEnvironment environment) {
ModuleDescriptor javaModule = new ModuleDescriptor(Name.special("<lazy module>"));
final Project project = environment.getProject();
InjectorForJavaDescriptorResolver injector =
new InjectorForJavaDescriptorResolver(project, new BindingTraceContext(), javaModule, BuiltinsScopeExtensionMode.ALL);
final PsiClassFinder psiClassFinder = injector.getPsiClassFinder();
final JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
final FileBasedDeclarationProviderFactory declarationProviderFactory = new FileBasedDeclarationProviderFactory(files, new Predicate<FqName>() {
@Override
public boolean apply(FqName fqName) {
return psiClassFinder.findPsiPackage(fqName) != null || new FqName("jet").equals(fqName);
}
});
//ModuleConfiguration moduleConfiguration = getEagerInjectorForTopDownAnalyzer().getModuleConfiguration();
ModuleConfiguration moduleConfiguration = new ModuleConfiguration() {
@Override
public void addDefaultImports(@NotNull Collection<JetImportDirective> directives) {
directives.add(JetPsiFactory.createImportDirective(project, new ImportPath("java.lang.*")));
for (ImportPath defaultJetImport : DefaultModuleConfiguration.DEFAULT_JET_IMPORTS) {
directives.add(JetPsiFactory.createImportDirective(project, defaultJetImport));
}
}
@Override
public void extendNamespaceScope(
@NotNull BindingTrace trace,
@NotNull NamespaceDescriptor namespaceDescriptor,
@NotNull WritableScope namespaceMemberScope
) {
FqName fqName = DescriptorUtils.getFQName(namespaceDescriptor).toSafe();
if (new FqName("jet").equals(fqName)) {
namespaceMemberScope.importScope(JetStandardLibrary.getInstance().getLibraryScope());
}
if (psiClassFinder.findPsiPackage(fqName) != null) {
System.out.println(fqName);
JavaPackageScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(fqName, namespaceDescriptor);
namespaceMemberScope.importScope(javaPackageScope);
}
}
};
ModuleDescriptor lazyModule = new ModuleDescriptor(Name.special("<lazy module>"));
ResolveSession
session = new ResolveSession(project, lazyModule, moduleConfiguration, declarationProviderFactory);
return lazyModule;
}
}
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveNamespaceComparingTestGenerated.java
+5
View File
@@ -1275,6 +1275,11 @@ public class LazyResolveNamespaceComparingTestGenerated extends AbstractLazyReso
doTest("compiler/testData/lazyResolve/namespaceComparator/genericFunction.kt");
}
@TestMetadata("iterator.kt")
public void testIterator() throws Exception {
doTest("compiler/testData/lazyResolve/namespaceComparator/iterator.kt");
}
@TestMetadata("packageLevelObject.kt")
public void testPackageLevelObject() throws Exception {
doTest("compiler/testData/lazyResolve/namespaceComparator/packageLevelObject.kt");