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

Replace ModuleDescriptorImpl implementation

Browse Source 
Change the way modules are configured:
Add dependencies on other modules instead of adding additional package fragment providers
Refactor related code
Drop DependencyKind
Hide common new module creation in CliLightClassGenerationSupport
This commit is contained in:
Pavel V. Talanov
2014-07-30 16:45:02 +04:00
parent 145aa5a276
commit 8496c535aa
30 changed files with 326 additions and 297 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java
+13 -2
View File
@@ -42,6 +42,7 @@ import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.resolve.java.JvmAbi;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.util.slicedmap.WritableSlice;
import java.util.Collection;
@@ -81,9 +82,19 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport
}
@NotNull
public ModuleDescriptorImpl getModule() {
public ModuleDescriptorImpl newModule() {
assert this.module == null : "module already configured: " + module;
module = AnalyzerFacadeForJVM.createJavaModule("<shared-module-for-cli-light-classes>");
module.addDependencyOnModule(module);
module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
module.seal();
return module;
}
@NotNull
private ModuleDescriptorImpl getModule() {
if (module == null) {
module = AnalyzerFacadeForJVM.createJavaModule("<module>");
return newModule();
}
return module;
}
compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java
+2 -2
View File
@@ -59,6 +59,7 @@ import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalCache;
import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalCacheProvider;
import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalPackage;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.plugin.MainFunctionDetector;
import org.jetbrains.jet.utils.KotlinPaths;
@@ -291,8 +292,7 @@ public class KotlinToJVMBytecodeCompiler {
public AnalyzeExhaust invoke() {
CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject());
BindingTrace sharedTrace = support.getTrace();
ModuleDescriptorImpl sharedModule = support.getModule();
ModuleDescriptorImpl sharedModule = support.newModule();
IncrementalCacheProvider incrementalCacheProvider = IncrementalCacheProvider.OBJECT$.getInstance();
File incrementalCacheBaseDir = environment.getConfiguration().get(JVMConfigurationKeys.INCREMENTAL_CACHE_BASE_DIR);
final IncrementalCache incrementalCache;
compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java
+10 -4
View File
@@ -43,6 +43,7 @@ import org.jetbrains.jet.codegen.state.GenerationState;
import org.jetbrains.jet.config.CompilerConfiguration;
import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
import org.jetbrains.jet.lang.descriptors.ScriptDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.CompositePackageFragmentProvider;
import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.impl.PackageLikeBuilderDummy;
import org.jetbrains.jet.lang.parsing.JetParserDefinition;
@@ -70,12 +71,12 @@ import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import static org.jetbrains.jet.codegen.AsmUtil.asmTypeByFqNameWithoutInnerClasses;
import static org.jetbrains.jet.codegen.binding.CodegenBinding.registerClassNameForScript;
import static org.jetbrains.jet.lang.descriptors.DependencyKind.*;
public class ReplInterpreter {
@@ -109,9 +110,14 @@ public class ReplInterpreter {
);
injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
topDownAnalysisContext = new TopDownAnalysisContext(topDownAnalysisParameters);
module.addFragmentProvider(SOURCES, injector.getTopDownAnalyzer().getPackageFragmentProvider());
module.addFragmentProvider(BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
module.addFragmentProvider(BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
module.initialize(new CompositePackageFragmentProvider(
Arrays.asList(injector.getTopDownAnalyzer().getPackageFragmentProvider(),
injector.getJavaDescriptorResolver().getPackageFragmentProvider()
)
));
module.addDependencyOnModule(module);
module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
module.seal();
List<URL> classpath = Lists.newArrayList();
compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolverUtil.java
+14 -3
View File
@@ -18,14 +18,25 @@ package org.jetbrains.jet.di;
import com.intellij.openapi.project.Project;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.DependencyKind;
import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
public class InjectorForJavaDescriptorResolverUtil {
@NotNull
public static InjectorForJavaDescriptorResolver create(@NotNull Project project, @NotNull BindingTrace bindingTrace) {
public static InjectorForJavaDescriptorResolver create(
@NotNull Project project,
@NotNull BindingTrace bindingTrace,
boolean dependendOnBuitlins
) {
InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(project, bindingTrace);
injector.getModule().addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
ModuleDescriptorImpl module = injector.getModule();
module.initialize(injector.getJavaDescriptorResolver().getPackageFragmentProvider());
module.addDependencyOnModule(module);
if (dependendOnBuitlins) {
module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
}
module.seal();
return injector;
}
}
compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java
+17 -15
View File
@@ -32,7 +32,8 @@ import org.jetbrains.jet.context.GlobalContext;
import org.jetbrains.jet.context.GlobalContextImpl;
import org.jetbrains.jet.di.InjectorForLazyResolveWithJava;
import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
import org.jetbrains.jet.lang.descriptors.DependencyKind;
import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider;
import org.jetbrains.jet.lang.descriptors.impl.CompositePackageFragmentProvider;
import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.BindingTrace;
@@ -41,7 +42,6 @@ import org.jetbrains.jet.lang.resolve.ImportPath;
import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap;
import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalCache;
import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalCacheProvider;
import org.jetbrains.jet.lang.resolve.kotlin.incremental.IncrementalPackageFragmentProvider;
import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFactory;
@@ -49,10 +49,7 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.DeclarationProviderFacto
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import java.io.File;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.*;
public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
@@ -128,14 +125,19 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
declarationProviderFactory,
trace);
resolveWithJava.getModule().addFragmentProvider(
DependencyKind.BINARIES, resolveWithJava.getJavaDescriptorResolver().getPackageFragmentProvider());
ModuleDescriptorImpl module = resolveWithJava.getModule();
module.initialize(
new CompositePackageFragmentProvider(
Arrays.asList(
resolveWithJava.getResolveSession().getPackageFragmentProvider(),
resolveWithJava.getJavaDescriptorResolver().getPackageFragmentProvider()
)));
module.addDependencyOnModule(module);
if (addBuiltIns) {
resolveWithJava.getModule().addFragmentProvider(
DependencyKind.BUILT_INS,
KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
}
module.seal();
return new JvmSetup(resolveWithJava.getResolveSession(), resolveWithJava.getJavaDescriptorResolver());
}
@@ -160,12 +162,11 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
InjectorForTopDownAnalyzerForJvm injector = new InjectorForTopDownAnalyzerForJvm(project, topDownAnalysisParameters, trace, module);
try {
module.addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
List<PackageFragmentProvider> additionalProviders = new ArrayList<PackageFragmentProvider>();
if (incrementalCache != null && moduleIds != null) {
for (String moduleId : moduleIds) {
module.addFragmentProvider(
DependencyKind.SOURCES,
additionalProviders.add(
new IncrementalPackageFragmentProvider(
files, module, globalContext.getStorageManager(), injector.getDeserializationGlobalContextForJava(),
incrementalCache, moduleId, injector.getJavaDescriptorResolver()
@@ -173,8 +174,9 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade {
);
}
}
additionalProviders.add(injector.getJavaDescriptorResolver().getPackageFragmentProvider());
injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, files);
injector.getTopDownAnalyzer().analyzeFiles(topDownAnalysisParameters, files, additionalProviders);
return AnalyzeExhaust.success(trace.getBindingContext(), module);
}
finally {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java
+14 -10
View File
@@ -38,14 +38,10 @@ import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.storage.LockBasedStorageManager;
import javax.inject.Inject;
import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.*;
public class TopDownAnalyzer {
@@ -253,16 +249,24 @@ public class TopDownAnalyzer {
@NotNull
public TopDownAnalysisContext analyzeFiles(
@NotNull TopDownAnalysisParameters topDownAnalysisParameters,
@NotNull Collection<JetFile> files
@NotNull Collection<JetFile> files,
@NotNull PackageFragmentProvider... additionalProviders
) {
((ModuleDescriptorImpl) moduleDescriptor).addFragmentProvider(DependencyKind.SOURCES, packageFragmentProvider);
return analyzeFiles(topDownAnalysisParameters, files, Arrays.asList(additionalProviders));
}
// "depend on" builtins module
((ModuleDescriptorImpl) moduleDescriptor).addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
@NotNull
public TopDownAnalysisContext analyzeFiles(
@NotNull TopDownAnalysisParameters topDownAnalysisParameters,
@NotNull Collection<JetFile> files,
@NotNull List<PackageFragmentProvider> additionalProviders
) {
CompositePackageFragmentProvider provider =
new CompositePackageFragmentProvider(KotlinPackage.plus(Arrays.asList(packageFragmentProvider), additionalProviders));
((ModuleDescriptorImpl) moduleDescriptor).initialize(provider);
// dummy builder is used because "root" is module descriptor,
// packages added to module explicitly in
TopDownAnalysisContext c = new TopDownAnalysisContext(topDownAnalysisParameters);
doProcess(c, JetModuleUtil.getSubpackagesOfRootScope(moduleDescriptor), new PackageLikeBuilderDummy(), files);
return c;
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java
-3
View File
@@ -150,9 +150,6 @@ public class ResolveSession implements KotlinCodeAnalyzer {
}
};
// TODO: parameter modification
rootDescriptor.addFragmentProvider(DependencyKind.SOURCES, packageFragmentProvider);
this.scriptDescriptors = storageManager.createMemoizedFunction(
new Function1<JetScript, LazyScriptDescriptor>() {
@Override
compiler/tests/org/jetbrains/jet/JetTestUtils.java
+3 -2
View File
@@ -50,7 +50,6 @@ import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
import org.jetbrains.jet.config.CommonConfigurationKeys;
import org.jetbrains.jet.config.CompilerConfiguration;
import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
import org.jetbrains.jet.lang.descriptors.DependencyKind;
import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor;
import org.jetbrains.jet.lang.diagnostics.Diagnostic;
@@ -845,7 +844,9 @@ public class JetTestUtils {
public static MutablePackageFragmentDescriptor createTestPackageFragment(@NotNull Name testPackageName, @NotNull String moduleName) {
ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule(moduleName);
MutablePackageFragmentProvider provider = new MutablePackageFragmentProvider(module);
module.addFragmentProvider(DependencyKind.SOURCES, provider);
module.initialize(provider);
module.addDependencyOnModule(module);
module.seal();
return provider.getOrCreateFragment(FqName.topLevel(testPackageName));
}
compiler/tests/org/jetbrains/jet/checkers/AbstractJetDiagnosticsTest.java
+12 -4
View File
@@ -26,7 +26,6 @@ import kotlin.KotlinPackage;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
import org.jetbrains.jet.lang.descriptors.DependencyKind;
import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.diagnostics.*;
import org.jetbrains.jet.lang.psi.Call;
@@ -37,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.*;
import org.jetbrains.jet.lang.resolve.calls.model.MutableResolvedCall;
import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import java.io.File;
import java.util.*;
@@ -78,6 +78,14 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
: supportTrace;
moduleBindings.put(testModule, moduleTrace.getBindingContext());
if (module == null) {
module = support.newModule();
}
else {
module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
module.seal();
}
// New JavaDescriptorResolver is created for each module, which is good because it emulates different Java libraries for each module,
// albeit with same class names
AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
@@ -85,7 +93,7 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
jetFiles,
moduleTrace,
Predicates.<PsiFile>alwaysTrue(),
module == null ? support.getModule() : module,
module,
null,
null
);
@@ -119,9 +127,9 @@ public abstract class AbstractJetDiagnosticsTest extends BaseDiagnosticsTest {
if (testModule == null) continue;
ModuleDescriptorImpl module = modules.get(testModule);
module.addDependencyOnModule(module);
for (TestModule dependency : testModule.getDependencies()) {
// Adding other modules as BINARIES here, because in teh reduced dependency ordering model they are equal to binaries
module.addFragmentProvider(DependencyKind.BINARIES, modules.get(dependency).getPackageFragmentProvider());
module.addDependencyOnModule(modules.get(dependency));
}
}
return modules;
compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java
+6 -5
View File
@@ -36,7 +36,6 @@ import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClass
import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
import org.jetbrains.jet.lang.descriptors.DependencyKind;
import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.psi.JetFile;
@@ -45,6 +44,7 @@ import org.jetbrains.jet.lang.resolve.BindingTrace;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
import org.jetbrains.jet.lang.resolve.lazy.JvmResolveUtil;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import org.jetbrains.jet.storage.ExceptionTracker;
import org.jetbrains.jet.storage.LockBasedStorageManager;
import org.jetbrains.jet.test.TestCaseWithTmpdir;
@@ -158,7 +158,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
// we need the same binding trace for resolve from Java and Kotlin
CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject());
BindingTrace trace = support.getTrace();
ModuleDescriptorImpl module = support.getModule();
ModuleDescriptorImpl module = support.newModule();
TopDownAnalysisParameters parameters = TopDownAnalysisParameters.create(
new LockBasedStorageManager(),
@@ -173,9 +173,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
trace,
module);
module.addFragmentProvider(DependencyKind.BINARIES, injectorForAnalyzer.getJavaDescriptorResolver().getPackageFragmentProvider());
injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(parameters, environment.getSourceFiles());
injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(
parameters, environment.getSourceFiles(),
injectorForAnalyzer.getJavaDescriptorResolver().getPackageFragmentProvider()
);
PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);
assert packageView != null : "Test package not found";
compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractSdkAnnotationsValidityTest.java
+1 -1
View File
@@ -71,7 +71,7 @@ public abstract class AbstractSdkAnnotationsValidityTest extends UsefulTestCase
BindingTrace trace = new BindingTraceContext();
InjectorForJavaDescriptorResolver injector =
InjectorForJavaDescriptorResolverUtil.create(commonEnvironment.getProject(), trace);
InjectorForJavaDescriptorResolverUtil.create(commonEnvironment.getProject(), trace, false);
BindingContext bindingContext = trace.getBindingContext();
compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java
+8 -5
View File
@@ -29,6 +29,7 @@ import org.jetbrains.jet.JetTestUtils;
import org.jetbrains.jet.TestJdkKind;
import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.cli.common.output.outputUtils.OutputUtilsPackage;
import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.codegen.GenerationUtils;
import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
@@ -36,8 +37,8 @@ import org.jetbrains.jet.codegen.state.GenerationState;
import org.jetbrains.jet.config.CompilerConfiguration;
import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
import org.jetbrains.jet.lang.descriptors.DependencyKind;
import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
@@ -92,10 +93,12 @@ public final class LoadDescriptorUtil {
);
JetCoreEnvironment jetCoreEnvironment = JetCoreEnvironment.createForTests(disposable, configuration);
BindingTraceContext trace = new BindingTraceContext();
InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), trace);
injector.getModule().addFragmentProvider(DependencyKind.BUILT_INS,
KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
PackageViewDescriptor packageView = injector.getModule().getPackage(TEST_PACKAGE_FQNAME);
InjectorForJavaDescriptorResolver injector =
InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), trace, true);
ModuleDescriptorImpl module = injector.getModule();
CliLightClassGenerationSupport.getInstanceForCli(jetCoreEnvironment.getProject()).setModule(module);
PackageViewDescriptor packageView = module.getPackage(TEST_PACKAGE_FQNAME);
assert packageView != null;
return Pair.create(packageView, trace.getBindingContext());
compiler/tests/org/jetbrains/jet/jvm/compiler/longTest/ResolveDescriptorsFromExternalLibraries.java
+2 -2
View File
@@ -168,8 +168,8 @@ public class ResolveDescriptorsFromExternalLibraries {
}
}
InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(
jetCoreEnvironment.getProject(), new BindingTraceContext());
InjectorForJavaDescriptorResolver injector =
InjectorForJavaDescriptorResolverUtil.create(jetCoreEnvironment.getProject(), new BindingTraceContext(), false);
ModuleDescriptor moduleDescriptor = injector.getModule();
boolean hasErrors;
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java
+4 -1
View File
@@ -63,12 +63,15 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe
Collection<JetFile> files = Lists.newArrayList(psiFile);
final ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule("<lazy module>");
lazyModule.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
lazyModule.addDependencyOnModule(lazyModule);
lazyModule.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
lazyModule.seal();
GlobalContextImpl globalContext = ContextPackage.GlobalContext();
final ResolveSession resolveSession = new InjectorForLazyResolve(
getProject(), globalContext, lazyModule,
new FileBasedDeclarationProviderFactory(globalContext.getStorageManager(), files),
new BindingTraceContext()).getResolveSession();
lazyModule.initialize(resolveSession.getPackageFragmentProvider());
final List<DeclarationDescriptor> descriptors = new ArrayList<DeclarationDescriptor>();
psiFile.accept(new JetVisitorVoid() {
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/JvmResolveUtil.java
+12 -1
View File
@@ -22,10 +22,13 @@ import com.intellij.openapi.project.Project;
import com.intellij.psi.PsiFile;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.analyzer.AnalyzeExhaust;
import org.jetbrains.jet.cli.jvm.compiler.CliLightClassGenerationSupport;
import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.psi.JetFile;
import org.jetbrains.jet.lang.resolve.AnalyzingUtils;
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import java.util.Collection;
import java.util.Collections;
@@ -73,8 +76,16 @@ public class JvmResolveUtil {
) {
BindingTraceContext bindingTraceContext = new BindingTraceContext();
ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule("<module>");
module.addDependencyOnModule(module);
module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
module.seal();
CliLightClassGenerationSupport lightClassGenerationSupport = CliLightClassGenerationSupport.getInstanceForCli(project);
if (lightClassGenerationSupport != null) {
lightClassGenerationSupport.setModule(module);
}
return AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(project, files, bindingTraceContext, filesToAnalyzeCompletely,
AnalyzerFacadeForJVM.createJavaModule("<module>"),
module,
null, null);
}
}
compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java
+3 -4
View File
@@ -28,7 +28,6 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.context.ContextPackage;
import org.jetbrains.jet.context.GlobalContextImpl;
import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm;
import org.jetbrains.jet.lang.descriptors.DependencyKind;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.psi.JetFile;
@@ -37,6 +36,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters;
import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.name.SpecialNames;
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
import java.util.List;
import java.util.Set;
@@ -53,12 +53,11 @@ public class LazyResolveTestUtil {
globalContext.getStorageManager(), globalContext.getExceptionTracker(), Predicates.<PsiFile>alwaysTrue(), false, false);
CliLightClassGenerationSupport support = CliLightClassGenerationSupport.getInstanceForCli(environment.getProject());
BindingTrace sharedTrace = support.getTrace();
ModuleDescriptorImpl sharedModule = support.getModule();
ModuleDescriptorImpl sharedModule = support.newModule();
InjectorForTopDownAnalyzerForJvm injector =
new InjectorForTopDownAnalyzerForJvm(environment.getProject(), params, sharedTrace, sharedModule);
sharedModule.addFragmentProvider(DependencyKind.BINARIES, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
injector.getTopDownAnalyzer().analyzeFiles(params, files);
injector.getTopDownAnalyzer().analyzeFiles(params, files, injector.getJavaDescriptorResolver().getPackageFragmentProvider());
return injector.getModuleDescriptor();
}
compiler/tests/org/jetbrains/jet/resolve/JetExpectedResolveDataUtil.java
+1 -1
View File
@@ -115,7 +115,7 @@ public class JetExpectedResolveDataUtil {
@NotNull
private static PsiClass findClass(String qualifiedName, Project project) {
InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, new BindingTraceContext());
InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(project, new BindingTraceContext(), false);
JavaClass javaClass = injector.getJavaClassFinder().findClass(new FqName(qualifiedName));
Assert.assertNotNull("Class wasn't found: " + qualifiedName, javaClass);
assertInstanceOf(javaClass, JavaClassImpl.class);
compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java
+3 -5
View File
@@ -28,11 +28,9 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver;
import org.jetbrains.jet.di.InjectorForJavaDescriptorResolverUtil;
import org.jetbrains.jet.di.InjectorForTests;
import org.jetbrains.jet.lang.descriptors.DependencyKind;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor;
import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.descriptors.impl.ReceiverParameterDescriptorImpl;
import org.jetbrains.jet.lang.psi.JetExpression;
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
@@ -597,10 +595,10 @@ public class JetTypeCheckerTest extends JetLiteFixture {
private WritableScopeImpl addImports(JetScope scope) {
WritableScopeImpl writableScope = new WritableScopeImpl(
scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports");
InjectorForJavaDescriptorResolver injector = InjectorForJavaDescriptorResolverUtil.create(getProject(), new BindingTraceContext());
InjectorForJavaDescriptorResolver injector =
InjectorForJavaDescriptorResolverUtil.create(getProject(), new BindingTraceContext(), true);
JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
ModuleDescriptorImpl module = (ModuleDescriptorImpl) javaDescriptorResolver.getModule();
module.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
ModuleDescriptor module = javaDescriptorResolver.getModule();
for (ImportPath defaultImport : module.getDefaultImports()) {
writableScope.importScope(module.getPackage(defaultImport.fqnPart()).getMemberScope());
}
core/descriptors/src/org/jetbrains/jet/lang/descriptors/DeclarationDescriptorVisitor.java
+3
View File
@@ -16,6 +16,8 @@
package org.jetbrains.jet.lang.descriptors;
import kotlin.jvm.KotlinSignature;
public interface DeclarationDescriptorVisitor<R, D> {
R visitPackageFragmentDescriptor(PackageFragmentDescriptor descriptor, D data);
@@ -30,6 +32,7 @@ public interface DeclarationDescriptorVisitor<R, D> {
R visitClassDescriptor(ClassDescriptor descriptor, D data);
@KotlinSignature("fun visitModuleDeclaration(descriptor: ModuleDescriptor, data: D): R")
R visitModuleDeclaration(ModuleDescriptor descriptor, D data);
R visitConstructorDescriptor(ConstructorDescriptor constructorDescriptor, D data);
core/descriptors/src/org/jetbrains/jet/lang/descriptors/DependencyKind.java
-24
View File
@@ -1,24 +0,0 @@
/*
* Copyright 2010-2014 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.descriptors;
public enum DependencyKind {
// Using this class is supposed to be a temporary measure before we switch to full-blown support for module dependency ordering
SOURCES,
BUILT_INS,
BINARIES
}
core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java
-52
View File
@@ -1,52 +0,0 @@
/*
* Copyright 2010-2013 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.descriptors;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
import org.jetbrains.jet.lang.resolve.ImportPath;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.scopes.JetScope;
import org.jetbrains.jet.lang.types.TypeSubstitutor;
import java.util.List;
public interface ModuleDescriptor extends DeclarationDescriptor {
@Override
@Nullable
DeclarationDescriptor getContainingDeclaration();
@NotNull
PackageFragmentProvider getPackageFragmentProvider();
@Nullable
PackageViewDescriptor getPackage(@NotNull FqName fqName);
@NotNull
List<ImportPath> getDefaultImports();
@NotNull
PlatformToKotlinClassMap getPlatformToKotlinClassMap();
@NotNull
@Override
ModuleDescriptor substitute(@NotNull TypeSubstitutor substitutor);
@Override
<R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data);
}
core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.kt
+46
View File
@@ -0,0 +1,46 @@
/*
* Copyright 2010-2014 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.descriptors
import org.jetbrains.jet.lang.PlatformToKotlinClassMap
import org.jetbrains.jet.lang.resolve.ImportPath
import org.jetbrains.jet.lang.resolve.name.FqName
import org.jetbrains.jet.lang.types.TypeSubstitutor
import org.jetbrains.jet.lang.descriptors.impl.PackageViewDescriptorImpl
public trait ModuleDescriptor : DeclarationDescriptor {
override fun getContainingDeclaration(): DeclarationDescriptor? = null
public fun getPackageFragmentProvider(): PackageFragmentProvider
public fun getPackage(fqName: FqName): PackageViewDescriptor? {
val fragments = getPackageFragmentProvider().getPackageFragments(fqName)
return if (!fragments.isEmpty()) PackageViewDescriptorImpl(this, fqName, fragments) else null
}
public val defaultImports: List<ImportPath>
public val platformToKotlinClassMap: PlatformToKotlinClassMap
override fun substitute(substitutor: TypeSubstitutor): ModuleDescriptor {
return this
}
override fun <R, D> accept(visitor: DeclarationDescriptorVisitor<R, D>, data: D): R {
return visitor.visitModuleDeclaration(this, data)
}
}
core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/ModuleDescriptorImpl.java
-122
View File
@@ -1,122 +0,0 @@
/*
* Copyright 2010-2013 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.descriptors.impl;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.intellij.openapi.diagnostic.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
import org.jetbrains.jet.lang.descriptors.*;
import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
import org.jetbrains.jet.lang.resolve.ImportPath;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.types.TypeSubstitutor;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements ModuleDescriptor {
private static final Logger LOG = Logger.getInstance(ModuleDescriptorImpl.class);
private final Map<DependencyKind, List<PackageFragmentProvider>> prioritizedFragmentProviders = Maps.newHashMap();
private final List<PackageFragmentProvider> fragmentProviders = Lists.newArrayList();
private final CompositePackageFragmentProvider packageFragmentProvider = new CompositePackageFragmentProvider(fragmentProviders);
private final List<ImportPath> defaultImports;
private final PlatformToKotlinClassMap platformToKotlinClassMap;
public ModuleDescriptorImpl(
@NotNull Name name,
@NotNull List<ImportPath> defaultImports,
@NotNull PlatformToKotlinClassMap platformToKotlinClassMap
) {
super(Annotations.EMPTY, name);
if (!name.isSpecial()) {
throw new IllegalArgumentException("module name must be special: " + name);
}
this.defaultImports = defaultImports;
this.platformToKotlinClassMap = platformToKotlinClassMap;
}
public void addFragmentProvider(@NotNull DependencyKind dependencyKind, @NotNull PackageFragmentProvider provider) {
if (fragmentProviders.contains(provider)) {
LOG.error("Trying to add already present fragment provider: " + provider);
}
List<PackageFragmentProvider> providers = prioritizedFragmentProviders.get(dependencyKind);
if (providers == null) {
providers = new ArrayList<PackageFragmentProvider>(1);
prioritizedFragmentProviders.put(dependencyKind, providers);
}
providers.add(provider);
buildProvidersList();
}
private void buildProvidersList() {
fragmentProviders.clear();
for (DependencyKind dependencyKind : DependencyKind.values()) {
List<PackageFragmentProvider> providers = prioritizedFragmentProviders.get(dependencyKind);
if (providers != null) {
fragmentProviders.addAll(providers);
}
}
}
@Override
@Nullable
public DeclarationDescriptor getContainingDeclaration() {
return null;
}
@NotNull
@Override
public PackageFragmentProvider getPackageFragmentProvider() {
return packageFragmentProvider;
}
@Nullable
@Override
public PackageViewDescriptor getPackage(@NotNull FqName fqName) {
List<PackageFragmentDescriptor> fragments = packageFragmentProvider.getPackageFragments(fqName);
return !fragments.isEmpty() ? new PackageViewDescriptorImpl(this, fqName, fragments) : null;
}
@NotNull
@Override
public List<ImportPath> getDefaultImports() {
return defaultImports;
}
@NotNull
@Override
public PlatformToKotlinClassMap getPlatformToKotlinClassMap() {
return platformToKotlinClassMap;
}
@NotNull
@Override
public ModuleDescriptor substitute(@NotNull TypeSubstitutor substitutor) {
return this;
}
@Override
public <R, D> R accept(DeclarationDescriptorVisitor<R, D> visitor, D data) {
return visitor.visitModuleDeclaration(this, data);
}
}
core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/ModuleDescriptorImpl.kt
+87
View File
@@ -0,0 +1,87 @@
/*
* Copyright 2010-2014 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.descriptors.impl
import org.jetbrains.jet.lang.resolve.name.Name
import org.jetbrains.jet.lang.PlatformToKotlinClassMap
import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider
import java.util.ArrayList
import org.jetbrains.jet.lang.resolve.ImportPath
import org.jetbrains.jet.lang.descriptors.annotations.Annotations
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
import kotlin.properties.Delegates
public class ModuleDescriptorImpl(
moduleName: Name,
override val defaultImports: List<ImportPath>,
override val platformToKotlinClassMap: PlatformToKotlinClassMap
) : DeclarationDescriptorImpl(Annotations.EMPTY, moduleName), ModuleDescriptor {
{
if (!moduleName.isSpecial()) {
throw IllegalArgumentException("Module name must be special: $moduleName")
}
}
private var isSealed = false
/*
* Sealed module cannot have its dependencies modified. Seal the module after you're done configuring it.
* Module will be sealed automatically as soon as you query its contents.
*/
public fun seal() {
if (isSealed) return
assert(this in dependencies, "Module $id is not contained in his own dependencies, this is probably a misconfiguration")
isSealed = true
}
private val dependencies: MutableList<ModuleDescriptorImpl> = ArrayList()
private var packageFragmentProviderForModuleContent: PackageFragmentProvider? = null
private val packageFragmentProviderForWholeModuleWithDependencies by Delegates.lazy {
seal()
dependencies.forEach {
dependency ->
assert(dependency.isInitialized, "Dependency module ${dependency.id} was not initialized by the time contents of dependent module ${this.id} were queried")
}
CompositePackageFragmentProvider(dependencies.map {
it.packageFragmentProviderForModuleContent!!
})
}
private val isInitialized: Boolean
get() = packageFragmentProviderForModuleContent != null
public fun addDependencyOnModule(dependency: ModuleDescriptorImpl) {
assert(!isSealed, "Can't modify dependencies of sealed module $id")
assert(dependency !in dependencies, "Trying to add dependency on module ${dependency.id} a second time for module ${this.id}, this is probably a misconfiguration")
dependencies.add(dependency)
}
private val id: String
get() = getName().toString()
/*
* Call initialize() to set module contents. Uninitialized module cannot be queried for its contents.
* Initialize() and seal() can be called in any order.
*/
public fun initialize(providerForModuleContent: PackageFragmentProvider) {
assert(!isInitialized, "Attempt to initialize module $id twice")
packageFragmentProviderForModuleContent = providerForModuleContent
}
override fun getPackageFragmentProvider() = packageFragmentProviderForWholeModuleWithDependencies
}
core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java
+3 -1
View File
@@ -109,7 +109,9 @@ public class KotlinBuiltIns {
Collections.<ImportPath>emptyList(),
PlatformToKotlinClassMap.EMPTY);
builtinsPackageFragment = new BuiltinsPackageFragment(new LockBasedStorageManager(), builtInsModule);
builtInsModule.addFragmentProvider(DependencyKind.SOURCES, builtinsPackageFragment.getProvider());
builtInsModule.initialize(builtinsPackageFragment.getProvider());
builtInsModule.addDependencyOnModule(builtInsModule);
builtInsModule.seal();
primitiveTypeToNullableJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);
primitiveTypeToArrayJetType = new EnumMap<PrimitiveType, JetType>(PrimitiveType.class);
idea/src/org/jetbrains/jet/plugin/libraries/DeserializerForDecompiler.kt
+13 -4
View File
@@ -58,6 +58,8 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
private val moduleDescriptor =
ModuleDescriptorImpl(Name.special("<module for building decompiled sources>"), listOf(), PlatformToKotlinClassMap.EMPTY)
private fun createDummyModule(name: String) = ModuleDescriptorImpl(Name.special("<$name>"), listOf(), PlatformToKotlinClassMap.EMPTY)
override fun resolveTopLevelClass(classFqName: FqName) = deserializationContext.classDeserializer.deserializeClass(classFqName.toClassId())
override fun resolveDeclarationsInPackage(packageFqName: FqName): Collection<DeclarationDescriptor> {
@@ -140,10 +142,17 @@ public class DeserializerForDecompiler(val packageDirectory: VirtualFile, val di
}
{
moduleDescriptor.addFragmentProvider(DependencyKind.BUILT_INS,
KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider())
moduleDescriptor.addFragmentProvider(DependencyKind.SOURCES, packageFragmentProvider)
moduleDescriptor.addFragmentProvider(DependencyKind.BINARIES, PackageFragmentProviderForMissingDependencies(moduleDescriptor))
moduleDescriptor.initialize(packageFragmentProvider)
moduleDescriptor.addDependencyOnModule(moduleDescriptor)
moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule())
val moduleContainingMissingDependencies = createDummyModule("module containing missing dependencies for decompiled sources")
moduleContainingMissingDependencies.addDependencyOnModule(moduleContainingMissingDependencies)
moduleContainingMissingDependencies.initialize(
PackageFragmentProviderForMissingDependencies(moduleContainingMissingDependencies)
)
moduleDescriptor.addDependencyOnModule(moduleContainingMissingDependencies)
moduleDescriptor.seal()
moduleContainingMissingDependencies.seal()
}
val deserializationContext = DeserializationGlobalContext(storageManager, moduleDescriptor, classDataFinder, annotationLoader,
constantLoader, packageFragmentProvider)
idea/src/org/jetbrains/jet/plugin/libraries/JetSourceNavigationHelper.java
+32 -19
View File
@@ -44,7 +44,6 @@ import org.jetbrains.jet.di.InjectorForLazyResolve;
import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
import org.jetbrains.jet.lang.descriptors.DependencyKind;
import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.psi.*;
import org.jetbrains.jet.lang.resolve.BindingTraceContext;
@@ -53,6 +52,7 @@ import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM;
import org.jetbrains.jet.lang.resolve.java.JvmClassName;
import org.jetbrains.jet.lang.resolve.java.mapping.KotlinToJavaTypesMap;
import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer;
import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
@@ -216,24 +216,7 @@ public class JetSourceNavigationHelper {
}
}
Project project = decompiledDeclaration.getProject();
GlobalContextImpl globalContext = ContextPackage.GlobalContext();
FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(
globalContext.getStorageManager(),
getContainingFiles(candidates));
ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<library module>"),
AnalyzerFacadeForJVM.DEFAULT_IMPORTS,
PlatformToKotlinClassMap.EMPTY);
moduleDescriptor.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
KotlinCodeAnalyzer analyzer = new InjectorForLazyResolve(
project,
globalContext,
moduleDescriptor,
providerFactory,
new BindingTraceContext()).getResolveSession();
KotlinCodeAnalyzer analyzer = createAnalyzer(candidates, decompiledDeclaration.getProject());
for (JetNamedDeclaration candidate : candidates) {
//noinspection unchecked
@@ -248,6 +231,36 @@ public class JetSourceNavigationHelper {
return null;
}
@NotNull
private static KotlinCodeAnalyzer createAnalyzer(
@NotNull Collection<JetNamedDeclaration> candidates,
@NotNull Project project
) {
GlobalContextImpl globalContext = ContextPackage.GlobalContext();
FileBasedDeclarationProviderFactory providerFactory = new FileBasedDeclarationProviderFactory(
globalContext.getStorageManager(),
getContainingFiles(candidates)
);
ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl(Name.special("<library module>"),
AnalyzerFacadeForJVM.DEFAULT_IMPORTS,
PlatformToKotlinClassMap.EMPTY);
moduleDescriptor.addDependencyOnModule(moduleDescriptor);
moduleDescriptor.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
moduleDescriptor.seal();
ResolveSession resolveSession = new InjectorForLazyResolve(
project,
globalContext,
moduleDescriptor,
providerFactory,
new BindingTraceContext()).getResolveSession();
moduleDescriptor.initialize(resolveSession.getPackageFragmentProvider());
return resolveSession;
}
@Nullable
private static JetClassOrObject getSourceForNamedClassOrObject(@NotNull JetClassOrObject decompiledClassOrObject) {
FqName classFqName = decompiledClassOrObject.getFqName();
idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java
+2
View File
@@ -102,6 +102,8 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent {
Predicates.<PsiFile>alwaysFalse(), true, false);
ModuleDescriptorImpl module = new ModuleDescriptorImpl(
Name.special("<fake_module>"), Collections.<ImportPath>emptyList(), PlatformToKotlinClassMap.EMPTY);
module.addDependencyOnModule(module);
module.seal();
BindingTraceContext trace = new BindingTraceContext();
InjectorForTopDownAnalyzerBasic injector = new InjectorForTopDownAnalyzerBasic(
myProject, topDownAnalysisParameters, trace, module);
js/js.translator/src/org/jetbrains/k2js/analyze/AnalyzerFacadeForJS.java
+10 -4
View File
@@ -30,7 +30,6 @@ import org.jetbrains.jet.context.GlobalContextImpl;
import org.jetbrains.jet.di.InjectorForLazyResolve;
import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJs;
import org.jetbrains.jet.lang.PlatformToKotlinClassMap;
import org.jetbrains.jet.lang.descriptors.DependencyKind;
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor;
import org.jetbrains.jet.lang.descriptors.impl.ModuleDescriptorImpl;
import org.jetbrains.jet.lang.psi.JetFile;
@@ -79,10 +78,13 @@ public final class AnalyzerFacadeForJS {
TopDownAnalysisParameters topDownAnalysisParameters = TopDownAnalysisParameters.create(
globalContext.getStorageManager(), globalContext.getExceptionTracker(), completely, false, false);
owner.addDependencyOnModule(owner);
owner.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
ModuleDescriptor libraryModule = config.getLibraryModule();
if (libraryModule != null) {
owner.addFragmentProvider(DependencyKind.BINARIES, libraryModule.getPackageFragmentProvider()); // "import" analyzed library module
owner.addDependencyOnModule((ModuleDescriptorImpl) libraryModule); // "import" analyzed library module
}
owner.seal();
BindingContext libraryContext = config.getLibraryContext();
BindingTrace trace = libraryContext == null
@@ -136,14 +138,18 @@ public final class AnalyzerFacadeForJS {
filesScope
);
ModuleDescriptorImpl module = createJsModule("<lazy module>");
module.addFragmentProvider(DependencyKind.BUILT_INS, KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider());
module.addDependencyOnModule(module);
module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule());
module.seal();
return new InjectorForLazyResolve(
ResolveSession session = new InjectorForLazyResolve(
config.getProject(),
globalContext,
module,
declarationProviderFactory,
new BindingTraceContext()).getResolveSession();
module.initialize(session.getPackageFragmentProvider());
return session;
}
@NotNull
libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt
+5 -1
View File
@@ -39,6 +39,7 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils
import org.jetbrains.jet.lang.descriptors.ModuleDescriptor
import org.junit.Assert
import java.util.HashSet
import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns
// this list is not designed to contain all packages, it is need for sanity check in case test code breaks
private val PACKAGES_SHOULD_BE_VALIDATED = listOf("kotlin", "kotlin.concurrent", "kotlin.jvm") map { FqName(it) }
@@ -102,12 +103,15 @@ class NoInternalVisibilityInStdLibTest {
configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, "../src/kotlin")
configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.getJdkClassesRoots())
val environment = JetCoreEnvironment.createForProduction(disposable, configuration)
val module = AnalyzerFacadeForJVM.createJavaModule("<module for validating std lib>")
module.addDependencyOnModule(module)
module.addDependencyOnModule(KotlinBuiltIns.getInstance().getBuiltInsModule())
AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration(
environment.getProject(),
environment.getSourceFiles(),
BindingTraceContext(),
{ true },
AnalyzerFacadeForJVM.createJavaModule("<module for validating std lib>"),
module,
null,
null
).getModuleDescriptor()