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

J2K TopDownAnalyzerFacadeFor{JVM,JS}: convert to Kotlin

Browse Source
This commit is contained in:
Alexander Udalov
2016-09-26 18:31:01 +03:00
parent b34150e1ce
commit 4467e127f0
2 changed files with 148 additions and 164 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.kt
+91 -102
View File
@@ -14,146 +14,135 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.resolve.jvm; package org.jetbrains.kotlin.resolve.jvm
import com.intellij.openapi.project.Project; import com.intellij.openapi.project.Project
import com.intellij.psi.search.GlobalSearchScope; import com.intellij.psi.search.GlobalSearchScope
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.analyzer.AnalysisResult
import org.jetbrains.kotlin.analyzer.AnalysisResult; import org.jetbrains.kotlin.config.*
import org.jetbrains.kotlin.config.CommonConfigurationKeys; import org.jetbrains.kotlin.context.*
import org.jetbrains.kotlin.config.CompilerConfiguration; import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.config.JVMConfigurationKeys; import org.jetbrains.kotlin.context.MutableModuleContext
import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl; import org.jetbrains.kotlin.context.ProjectContext
import org.jetbrains.kotlin.context.ContextKt; import org.jetbrains.kotlin.descriptors.ModuleDescriptor
import org.jetbrains.kotlin.context.ModuleContext; import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
import org.jetbrains.kotlin.context.MutableModuleContext; import org.jetbrains.kotlin.descriptors.PackagePartProvider
import org.jetbrains.kotlin.context.ProjectContext; import org.jetbrains.kotlin.frontend.java.di.ContainerForTopDownAnalyzerForJvm
import org.jetbrains.kotlin.descriptors.ModuleDescriptor; import org.jetbrains.kotlin.frontend.java.di.*
import org.jetbrains.kotlin.descriptors.PackageFragmentProvider; import org.jetbrains.kotlin.incremental.components.LookupTracker
import org.jetbrains.kotlin.descriptors.PackagePartProvider; import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackageFragmentProvider
import org.jetbrains.kotlin.frontend.java.di.ContainerForTopDownAnalyzerForJvm; import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackagePartProvider
import org.jetbrains.kotlin.frontend.java.di.InjectionKt; import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache
import org.jetbrains.kotlin.incremental.components.LookupTracker; import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackageFragmentProvider; import org.jetbrains.kotlin.modules.Module
import org.jetbrains.kotlin.load.kotlin.incremental.IncrementalPackagePartProvider; import org.jetbrains.kotlin.modules.TargetId
import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache; import org.jetbrains.kotlin.modules.*
import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents; import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.modules.Module; import org.jetbrains.kotlin.platform.JvmBuiltIns
import org.jetbrains.kotlin.modules.TargetId; import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.modules.TargetIdKt; import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.resolve.BindingTrace
import org.jetbrains.kotlin.platform.JvmBuiltIns; import org.jetbrains.kotlin.resolve.TopDownAnalysisMode
import org.jetbrains.kotlin.psi.KtFile; import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension
import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension
import org.jetbrains.kotlin.resolve.BindingTrace; import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform
import org.jetbrains.kotlin.resolve.TopDownAnalysisMode; import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
import org.jetbrains.kotlin.resolve.jvm.extensions.AnalysisCompletedHandlerExtension;
import org.jetbrains.kotlin.resolve.jvm.extensions.PackageFragmentProviderExtension;
import org.jetbrains.kotlin.resolve.jvm.platform.JvmPlatform;
import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory;
import java.util.ArrayList; import java.util.ArrayList
import java.util.Collection;
import java.util.List;
public enum TopDownAnalyzerFacadeForJVM { object TopDownAnalyzerFacadeForJVM {
@JvmStatic
fun analyzeFilesWithJavaIntegration(
moduleContext: ModuleContext,
files: Collection<KtFile>,
trace: BindingTrace,
configuration: CompilerConfiguration,
packagePartProvider: PackagePartProvider
): AnalysisResult {
var packagePartProvider = packagePartProvider
val project = moduleContext.project
INSTANCE; val providerFactory = FileBasedDeclarationProviderFactory(moduleContext.storageManager, files)
@NotNull val incrementalCompilationComponents = configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS)
public static AnalysisResult analyzeFilesWithJavaIntegration( val lookupTracker = if (incrementalCompilationComponents != null)
@NotNull ModuleContext moduleContext, incrementalCompilationComponents.getLookupTracker()
@NotNull Collection<KtFile> files, else
@NotNull BindingTrace trace, LookupTracker.DO_NOTHING
@NotNull CompilerConfiguration configuration,
@NotNull PackagePartProvider packagePartProvider
) {
Project project = moduleContext.getProject();
FileBasedDeclarationProviderFactory providerFactory = var targetIds: MutableList<TargetId>? = null
new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), files); val modules = configuration.get(JVMConfigurationKeys.MODULES)
IncrementalCompilationComponents incrementalCompilationComponents =
configuration.get(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS);
LookupTracker lookupTracker =
incrementalCompilationComponents != null
? incrementalCompilationComponents.getLookupTracker()
: LookupTracker.Companion.getDO_NOTHING();
List<TargetId> targetIds = null;
List<Module> modules = configuration.get(JVMConfigurationKeys.MODULES);
if (modules != null) { if (modules != null) {
targetIds = new ArrayList<TargetId>(modules.size()); targetIds = ArrayList<TargetId>(modules.size)
for (Module module : modules) { for (module in modules) {
targetIds.add(TargetIdKt.TargetId(module)); targetIds.add(TargetId(module))
} }
} }
packagePartProvider = IncrementalPackagePartProvider.create( packagePartProvider = IncrementalPackagePartProvider.create(
packagePartProvider, files, targetIds, incrementalCompilationComponents, moduleContext.getStorageManager() packagePartProvider, files, targetIds, incrementalCompilationComponents, moduleContext.storageManager
); )
ContainerForTopDownAnalyzerForJvm container = InjectionKt.createContainerForTopDownAnalyzerForJvm( val container = createContainerForTopDownAnalyzerForJvm(
moduleContext, moduleContext,
trace, trace,
providerFactory, providerFactory,
GlobalSearchScope.allScope(project), GlobalSearchScope.allScope(project),
lookupTracker, lookupTracker,
packagePartProvider, packagePartProvider,
configuration.get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT) configuration.get<LanguageVersionSettings>(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
); )
List<PackageFragmentProvider> additionalProviders = new ArrayList<PackageFragmentProvider>(); val additionalProviders = ArrayList<PackageFragmentProvider>()
if (targetIds != null && incrementalCompilationComponents != null) { if (targetIds != null && incrementalCompilationComponents != null) {
for (TargetId targetId : targetIds) { for (targetId in targetIds) {
IncrementalCache incrementalCache = incrementalCompilationComponents.getIncrementalCache(targetId); val incrementalCache = incrementalCompilationComponents.getIncrementalCache(targetId)
additionalProviders.add( additionalProviders.add(
new IncrementalPackageFragmentProvider( IncrementalPackageFragmentProvider(
files, moduleContext.getModule(), moduleContext.getStorageManager(), files, moduleContext.module, moduleContext.storageManager,
container.getDeserializationComponentsForJava().getComponents(), container.deserializationComponentsForJava.components,
incrementalCache, targetId incrementalCache, targetId
) )
); )
} }
} }
additionalProviders.add(container.getJavaDescriptorResolver().getPackageFragmentProvider()); additionalProviders.add(container.javaDescriptorResolver.packageFragmentProvider)
for (PackageFragmentProviderExtension extension : PackageFragmentProviderExtension.Companion.getInstances(project)) { for (extension in PackageFragmentProviderExtension.getInstances(project)) {
PackageFragmentProvider provider = extension.getPackageFragmentProvider( val provider = extension.getPackageFragmentProvider(
project, moduleContext.getModule(), moduleContext.getStorageManager(), trace, null); project, moduleContext.module, moduleContext.storageManager, trace, null)
if (provider != null) additionalProviders.add(provider); if (provider != null) additionalProviders.add(provider)
} }
container.getLazyTopDownAnalyzerForTopLevel().analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, additionalProviders); container.lazyTopDownAnalyzerForTopLevel.analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, additionalProviders)
BindingContext bindingContext = trace.getBindingContext(); val bindingContext = trace.bindingContext
ModuleDescriptor module = moduleContext.getModule(); val module = moduleContext.module
Collection<AnalysisCompletedHandlerExtension> analysisCompletedHandlerExtensions = val analysisCompletedHandlerExtensions = AnalysisCompletedHandlerExtension.getInstances(moduleContext.project)
AnalysisCompletedHandlerExtension.Companion.getInstances(moduleContext.getProject());
for (AnalysisCompletedHandlerExtension extension : analysisCompletedHandlerExtensions) { for (extension in analysisCompletedHandlerExtensions) {
AnalysisResult result = extension.analysisCompleted(project, module, trace, files); val result = extension.analysisCompleted(project, module, trace, files)
if (result != null) return result; if (result != null) return result
} }
return AnalysisResult.success(bindingContext, module); return AnalysisResult.success(bindingContext, module)
} }
@NotNull @JvmStatic
public static MutableModuleContext createContextWithSealedModule( fun createContextWithSealedModule(
@NotNull Project project, @NotNull CompilerConfiguration configuration project: Project, configuration: CompilerConfiguration
) { ): MutableModuleContext {
ProjectContext projectContext = ContextKt.ProjectContext(project); val projectContext = ProjectContext(project)
JvmBuiltIns builtIns = new JvmBuiltIns(projectContext.getStorageManager()); val builtIns = JvmBuiltIns(projectContext.storageManager)
MutableModuleContext context = ContextKt.ContextForNewModule( val context = ContextForNewModule(
projectContext, Name.special("<" + configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME) + ">"), projectContext, Name.special("<" + configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME) + ">"),
JvmPlatform.INSTANCE, builtIns JvmPlatform, builtIns
); )
context.setDependencies(context.getModule(), builtIns.getBuiltInsModule()); context.setDependencies(context.module, builtIns.builtInsModule)
return context; return context
} }
} }
js/js.frontend/src/org/jetbrains/kotlin/js/analyze/TopDownAnalyzerFacadeForJS.kt
+57 -62
View File
@@ -14,80 +14,75 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.js.analyze; package org.jetbrains.kotlin.js.analyze
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.config.CommonConfigurationKeys
import org.jetbrains.kotlin.config.CommonConfigurationKeys; import org.jetbrains.kotlin.config.LanguageVersionSettings
import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl; import org.jetbrains.kotlin.config.LanguageVersionSettingsImpl
import org.jetbrains.kotlin.context.ContextKt; import org.jetbrains.kotlin.context.*
import org.jetbrains.kotlin.context.ModuleContext; import org.jetbrains.kotlin.context.ModuleContext
import org.jetbrains.kotlin.context.MutableModuleContext; import org.jetbrains.kotlin.context.MutableModuleContext
import org.jetbrains.kotlin.descriptors.PackageFragmentProvider; import org.jetbrains.kotlin.descriptors.PackageFragmentProvider
import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
import org.jetbrains.kotlin.frontend.js.di.InjectionKt; import org.jetbrains.kotlin.frontend.js.di.*
import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult; import org.jetbrains.kotlin.js.analyzer.JsAnalysisResult
import org.jetbrains.kotlin.js.config.JsConfig; import org.jetbrains.kotlin.js.config.JsConfig
import org.jetbrains.kotlin.js.resolve.JsPlatform; import org.jetbrains.kotlin.js.resolve.JsPlatform
import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.KtFile; import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.resolve.*; import org.jetbrains.kotlin.resolve.*
import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory; import org.jetbrains.kotlin.resolve.lazy.declarations.FileBasedDeclarationProviderFactory
import org.jetbrains.kotlin.serialization.js.JsModuleDescriptor; import org.jetbrains.kotlin.serialization.js.JsModuleDescriptor
import java.util.ArrayList; import java.util.ArrayList
import java.util.Collection; import java.util.Collections
import java.util.Collections;
import java.util.List;
public final class TopDownAnalyzerFacadeForJS { object TopDownAnalyzerFacadeForJS {
private TopDownAnalyzerFacadeForJS() { @JvmStatic
fun analyzeFiles(files: Collection<KtFile>, config: JsConfig): JsAnalysisResult {
val trace = BindingTraceContext()
val newModuleContext = ContextForNewModule(
ProjectContext(config.project), Name.special("<" + config.moduleId + ">"), JsPlatform,
JsPlatform.builtIns
)
newModuleContext.setDependencies(computeDependencies(newModuleContext.module, config))
return analyzeFilesWithGivenTrace(files, trace, newModuleContext, config)
} }
@NotNull private fun computeDependencies(module: ModuleDescriptorImpl, config: JsConfig): List<ModuleDescriptorImpl> {
public static JsAnalysisResult analyzeFiles(@NotNull Collection<KtFile> files, @NotNull JsConfig config) { val allDependencies = ArrayList<ModuleDescriptorImpl>()
BindingTrace trace = new BindingTraceContext(); allDependencies.add(module)
for (descriptor in config.moduleDescriptors) {
MutableModuleContext newModuleContext = ContextKt.ContextForNewModule( allDependencies.add(descriptor.data)
ContextKt.ProjectContext(config.getProject()), Name.special("<" + config.getModuleId() + ">"), JsPlatform.INSTANCE,
JsPlatform.INSTANCE.getBuiltIns()
);
newModuleContext.setDependencies(computeDependencies(newModuleContext.getModule(), config));
return analyzeFilesWithGivenTrace(files, trace, newModuleContext, config);
}
@NotNull
private static List<ModuleDescriptorImpl> computeDependencies(ModuleDescriptorImpl module, @NotNull JsConfig config) {
List<ModuleDescriptorImpl> allDependencies = new ArrayList<ModuleDescriptorImpl>();
allDependencies.add(module);
for (JsModuleDescriptor<ModuleDescriptorImpl> descriptor : config.getModuleDescriptors()) {
allDependencies.add(descriptor.getData());
} }
allDependencies.add(JsPlatform.INSTANCE.getBuiltIns().getBuiltInsModule()); allDependencies.add(JsPlatform.builtIns.builtInsModule)
return allDependencies; return allDependencies
} }
@NotNull @JvmStatic
public static JsAnalysisResult analyzeFilesWithGivenTrace( fun analyzeFilesWithGivenTrace(
@NotNull Collection<KtFile> files, files: Collection<KtFile>,
@NotNull BindingTrace trace, trace: BindingTrace,
@NotNull ModuleContext moduleContext, moduleContext: ModuleContext,
@NotNull JsConfig config config: JsConfig
) { ): JsAnalysisResult {
Collection<KtFile> allFiles = JsConfig.withJsLibAdded(files, config); val allFiles = JsConfig.withJsLibAdded(files, config)
LazyTopDownAnalyzerForTopLevel analyzerForJs = InjectionKt.createTopDownAnalyzerForJs( val analyzerForJs = createTopDownAnalyzerForJs(
moduleContext, trace, moduleContext, trace,
new FileBasedDeclarationProviderFactory(moduleContext.getStorageManager(), allFiles), FileBasedDeclarationProviderFactory(moduleContext.storageManager, allFiles),
config.getConfiguration().get(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT) config.configuration.get<LanguageVersionSettings>(CommonConfigurationKeys.LANGUAGE_VERSION_SETTINGS, LanguageVersionSettingsImpl.DEFAULT)
); )
analyzerForJs.analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, Collections.<PackageFragmentProvider>emptyList()); analyzerForJs.analyzeFiles(TopDownAnalysisMode.TopLevelDeclarations, files, emptyList<PackageFragmentProvider>())
return JsAnalysisResult.success(trace, moduleContext.getModule()); return JsAnalysisResult.success(trace, moduleContext.module)
} }
public static void checkForErrors(@NotNull Collection<KtFile> allFiles, @NotNull BindingContext bindingContext) { @JvmStatic
AnalyzingUtils.throwExceptionOnErrors(bindingContext); fun checkForErrors(allFiles: Collection<KtFile>, bindingContext: BindingContext) {
for (KtFile file : allFiles) { AnalyzingUtils.throwExceptionOnErrors(bindingContext)
AnalyzingUtils.checkForSyntacticErrors(file); for (file in allFiles) {
AnalyzingUtils.checkForSyntacticErrors(file)
} }
} }
} }