From 34452f4f4aeaeb484fc18624bee8a45ee2a3e6da Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Fri, 3 Nov 2017 13:54:35 +0300 Subject: [PATCH] Introduce JavaClassesTracker interface into java resolution components It's purpose is passing java classes being used during analysis to incremental compilation to let it track diffs Potentially it might be done the other way: incremental compilation could build a separate container to analyze necessary classes, but it's rather hard to implement now #KT-17621 In Progress --- .../jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt | 5 +++ .../compiler/TopDownAnalyzerFacadeForJVM.kt | 6 ++-- .../kotlin/config/JVMConfigurationKeys.java | 4 +++ .../kotlin/frontend/java/di/injection.kt | 13 ++++++-- .../kotlin/load/java/JavaClassesTracker.kt | 31 +++++++++++++++++++ .../kotlin/load/java/lazy/context.kt | 7 +++-- .../descriptors/LazyJavaClassMemberScope.kt | 1 + .../lazy/descriptors/LazyJavaPackageScope.kt | 1 + .../internal/components/RuntimeModuleData.kt | 4 ++- 9 files changed, 63 insertions(+), 9 deletions(-) create mode 100644 core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/JavaClassesTracker.kt diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt index f0ae761ed17..0cbe32b9e2f 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt @@ -44,6 +44,7 @@ import org.jetbrains.kotlin.codegen.CompilationException import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.javac.JavacWrapper +import org.jetbrains.kotlin.load.java.JavaClassesTracker import org.jetbrains.kotlin.load.java.JvmAbi import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents import org.jetbrains.kotlin.script.KotlinScriptDefinitionFromAnnotatedTemplate @@ -302,6 +303,10 @@ class K2JVMCompiler : CLICompiler() { services.get(IncrementalCompilationComponents::class.java)?.let { configuration.put(JVMConfigurationKeys.INCREMENTAL_COMPILATION_COMPONENTS, it) } + + services.get(JavaClassesTracker::class.java)?.let { + configuration.put(JVMConfigurationKeys.JAVA_CLASSES_TRACKER, it) + } } arguments.additionalJavaModules?.let { additionalJavaModules -> diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/TopDownAnalyzerFacadeForJVM.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/TopDownAnalyzerFacadeForJVM.kt index a9299d41c18..93382149105 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/TopDownAnalyzerFacadeForJVM.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/TopDownAnalyzerFacadeForJVM.kt @@ -38,7 +38,6 @@ import org.jetbrains.kotlin.descriptors.PackageFragmentProvider import org.jetbrains.kotlin.descriptors.PackagePartProvider import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider import org.jetbrains.kotlin.descriptors.impl.ModuleDependenciesImpl -import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor import org.jetbrains.kotlin.frontend.java.di.createContainerForTopDownAnalyzerForJvm import org.jetbrains.kotlin.frontend.java.di.initJvmBuiltInsForTopDownAnalysis import org.jetbrains.kotlin.frontend.java.di.initialize @@ -46,6 +45,7 @@ import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.javac.components.JavacBasedClassFinder import org.jetbrains.kotlin.javac.components.JavacBasedSourceElementFactory import org.jetbrains.kotlin.javac.components.StubJavaResolverCache +import org.jetbrains.kotlin.load.java.JavaClassesTracker import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver import org.jetbrains.kotlin.load.java.structure.JavaClass import org.jetbrains.kotlin.load.java.structure.impl.VirtualFileBoundJavaClass @@ -109,6 +109,7 @@ object TopDownAnalyzerFacadeForJVM { } container.get().analyzeDeclarations(TopDownAnalysisMode.TopLevelDeclarations, files) + container.get().onCompletedAnalysis(module) invokeExtensionsOnAnalysisComplete()?.let { return it } @@ -196,7 +197,8 @@ object TopDownAnalyzerFacadeForJVM { // TODO: get rid of duplicate invocation of CodeAnalyzerInitializer#initialize, or refactor CliLightClassGenerationSupport val container = createContainerForTopDownAnalyzerForJvm( moduleContext, trace, declarationProviderFactory(storageManager, files), sourceScope, lookupTracker, - partProvider, moduleClassResolver, jvmTarget, languageVersionSettings, configureJavaClassFinder + partProvider, moduleClassResolver, jvmTarget, languageVersionSettings, configureJavaClassFinder, + javaClassTracker = configuration[JVMConfigurationKeys.JAVA_CLASSES_TRACKER] ).apply { initJvmBuiltInsForTopDownAnalysis() (partProvider as? IncrementalPackagePartProvider)?.deserializationConfiguration = get() diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java b/compiler/frontend.java/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java index a059ed95b7b..295e9058274 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/config/JVMConfigurationKeys.java @@ -17,6 +17,7 @@ package org.jetbrains.kotlin.config; import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; +import org.jetbrains.kotlin.load.java.JavaClassesTracker; import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents; import org.jetbrains.kotlin.modules.Module; import org.jetbrains.kotlin.script.KotlinScriptDefinition; @@ -105,6 +106,9 @@ public class JVMConfigurationKeys { public static final CompilerConfigurationKey INCREMENTAL_COMPILATION_COMPONENTS = CompilerConfigurationKey.create("incremental cache provider"); + public static final CompilerConfigurationKey JAVA_CLASSES_TRACKER = + CompilerConfigurationKey.create("Java classes tracker"); + public static final CompilerConfigurationKey MODULE_XML_FILE = CompilerConfigurationKey.create("path to module.xml"); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt index bc387e50c1c..8a138ef6a42 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt @@ -33,6 +33,7 @@ import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.load.java.AbstractJavaClassFinder import org.jetbrains.kotlin.load.java.InternalFlexibleTypeTransformer import org.jetbrains.kotlin.load.java.JavaClassFinderImpl +import org.jetbrains.kotlin.load.java.JavaClassesTracker import org.jetbrains.kotlin.load.java.components.* import org.jetbrains.kotlin.load.java.lazy.ModuleClassResolver import org.jetbrains.kotlin.load.kotlin.DeserializationComponentsForJava @@ -82,7 +83,8 @@ fun createContainerForLazyResolveWithJava( jvmTarget: JvmTarget, languageVersionSettings: LanguageVersionSettings, useBuiltInsProvider: Boolean, - configureJavaClassFinder: (StorageComponentContainer.() -> Unit)? = null + configureJavaClassFinder: (StorageComponentContainer.() -> Unit)? = null, + javaClassTracker: JavaClassesTracker? = null ): StorageComponentContainer = createContainer("LazyResolveWithJava", JvmPlatform) { configureModule(moduleContext, JvmPlatform, jvmTarget, bindingTrace) configureJavaTopDownAnalysis(moduleContentScope, moduleContext.project, lookupTracker) @@ -109,6 +111,8 @@ fun createContainerForLazyResolveWithJava( useImpl() } + useInstance(javaClassTracker ?: JavaClassesTracker.Default) + targetEnvironment.configure(this) useImpl() @@ -127,11 +131,14 @@ fun createContainerForTopDownAnalyzerForJvm( moduleClassResolver: ModuleClassResolver, jvmTarget: JvmTarget, languageVersionSettings: LanguageVersionSettings, - configureJavaClassFinder: (StorageComponentContainer.() -> Unit)? = null + configureJavaClassFinder: (StorageComponentContainer.() -> Unit)? = null, + javaClassTracker: JavaClassesTracker? = null ): ComponentProvider = createContainerForLazyResolveWithJava( moduleContext, bindingTrace, declarationProviderFactory, moduleContentScope, moduleClassResolver, CompilerEnvironment, lookupTracker, packagePartProvider, jvmTarget, languageVersionSettings, - useBuiltInsProvider = true, configureJavaClassFinder = configureJavaClassFinder + useBuiltInsProvider = true, + configureJavaClassFinder = configureJavaClassFinder, + javaClassTracker = javaClassTracker ) diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/JavaClassesTracker.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/JavaClassesTracker.kt new file mode 100644 index 00000000000..ba6c0ee0b23 --- /dev/null +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/JavaClassesTracker.kt @@ -0,0 +1,31 @@ +/* + * Copyright 2010-2017 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.kotlin.load.java + +import org.jetbrains.kotlin.descriptors.ModuleDescriptor +import org.jetbrains.kotlin.load.java.descriptors.JavaClassDescriptor + +interface JavaClassesTracker { + fun reportClass(classDescriptor: JavaClassDescriptor) + + fun onCompletedAnalysis(module: ModuleDescriptor) + + object Default : JavaClassesTracker { + override fun reportClass(classDescriptor: JavaClassDescriptor) {} + override fun onCompletedAnalysis(module: ModuleDescriptor) {} + } +} diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt index 14d3cf5127b..670a6020d34 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/context.kt @@ -23,6 +23,7 @@ import org.jetbrains.kotlin.descriptors.annotations.Annotations import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver import org.jetbrains.kotlin.load.java.JavaClassFinder +import org.jetbrains.kotlin.load.java.JavaClassesTracker import org.jetbrains.kotlin.load.java.components.* import org.jetbrains.kotlin.load.java.lazy.types.JavaTypeResolver import org.jetbrains.kotlin.load.java.sources.JavaSourceElementFactory @@ -34,7 +35,6 @@ import org.jetbrains.kotlin.load.kotlin.DeserializedDescriptorResolver import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder import org.jetbrains.kotlin.serialization.deserialization.ErrorReporter import org.jetbrains.kotlin.storage.StorageManager -import org.jetbrains.kotlin.utils.ReportLevel import java.util.* class JavaResolverComponents( @@ -56,7 +56,8 @@ class JavaResolverComponents( val module: ModuleDescriptor, val reflectionTypes: ReflectionTypes, val annotationTypeQualifierResolver: AnnotationTypeQualifierResolver, - val signatureEnhancement: SignatureEnhancement + val signatureEnhancement: SignatureEnhancement, + val javaClassesTracker: JavaClassesTracker ) { fun replace( javaResolverCache: JavaResolverCache = this.javaResolverCache @@ -65,7 +66,7 @@ class JavaResolverComponents( externalAnnotationResolver, signaturePropagator, errorReporter, javaResolverCache, javaPropertyInitializerEvaluator, samConversionResolver, sourceElementFactory, moduleClassResolver, packageMapper, supertypeLoopChecker, lookupTracker, module, reflectionTypes, - annotationTypeQualifierResolver, signatureEnhancement + annotationTypeQualifierResolver, signatureEnhancement, javaClassesTracker ) } diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt index d82c268e24d..e80ce2ba8ba 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt @@ -639,6 +639,7 @@ class LazyJavaClassMemberScope( else { c.components.finder.findClass(ownerDescriptor.classId!!.createNestedClassId(name))?.let { LazyJavaClassDescriptor(c, ownerDescriptor, it) + .also(c.components.javaClassesTracker::reportClass) } } } diff --git a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageScope.kt b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageScope.kt index 2d9597a83af..90a19ab497c 100644 --- a/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageScope.kt +++ b/core/descriptors.jvm/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaPackageScope.kt @@ -85,6 +85,7 @@ class LazyJavaPackageScope( null else LazyJavaClassDescriptor(c, ownerDescriptor, javaClass) + .also(c.components.javaClassesTracker::reportClass) } } } diff --git a/core/descriptors.runtime/src/kotlin/reflect/jvm/internal/components/RuntimeModuleData.kt b/core/descriptors.runtime/src/kotlin/reflect/jvm/internal/components/RuntimeModuleData.kt index c78c0c29560..7fea1b8f848 100644 --- a/core/descriptors.runtime/src/kotlin/reflect/jvm/internal/components/RuntimeModuleData.kt +++ b/core/descriptors.runtime/src/kotlin/reflect/jvm/internal/components/RuntimeModuleData.kt @@ -23,6 +23,7 @@ import org.jetbrains.kotlin.descriptors.SupertypeLoopChecker import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.load.java.AnnotationTypeQualifierResolver +import org.jetbrains.kotlin.load.java.JavaClassesTracker import org.jetbrains.kotlin.load.java.components.* import org.jetbrains.kotlin.load.java.lazy.JavaResolverComponents import org.jetbrains.kotlin.load.java.lazy.LazyJavaPackageFragmentProvider @@ -67,7 +68,8 @@ class RuntimeModuleData private constructor( runtimePackagePartProvider, SupertypeLoopChecker.EMPTY, LookupTracker.DO_NOTHING, module, ReflectionTypes(module, notFoundClasses), annotationTypeQualifierResolver, - SignatureEnhancement(annotationTypeQualifierResolver) + SignatureEnhancement(annotationTypeQualifierResolver), + JavaClassesTracker.Default ) val lazyJavaPackageFragmentProvider = LazyJavaPackageFragmentProvider(globalJavaResolverContext)