From 009f18f1f4416fefd95063b8bcb714ba1656549f Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Fri, 28 Sep 2018 17:11:21 +0200 Subject: [PATCH] Split AnalysisFlag values to AnalysisFlags and JvmAnalysisFlags Declare AnalysisFlags in module 'frontend', and JvmAnalysisFlags in module 'frontend.java', to avoid leaking Java-related logic to common compiler code --- .../kotlin/codegen/ClassFileFactory.java | 7 +-- .../kotlin/codegen/state/GenerationState.kt | 2 +- .../kotlin/codegen/writeAnnotationUtil.kt | 4 +- .../arguments/CommonCompilerArguments.kt | 14 ++--- .../arguments/K2JVMCompilerArguments.kt | 8 +-- .../JvmRuntimeVersionsConsistencyChecker.kt | 2 +- .../kotlin/daemon/KotlinRemoteReplService.kt | 2 +- .../kotlin/config/JvmAnalysisFlags.kt | 17 ++++++ .../kotlin/frontend/java/di/injection.kt | 4 +- .../resolve/jvm/checkers/JvmDefaultChecker.kt | 4 +- .../platform/JvmDefaultSuperCallChecker.kt | 5 +- .../jetbrains/kotlin/config/AnalysisFlags.kt | 32 +++++++++++ .../parsing/ContractParsingServices.kt | 6 +-- .../CompilerDeserializationConfiguration.kt | 4 +- .../resolve/FunctionDescriptorResolver.kt | 4 +- .../kotlin/resolve/calls/CallResolver.java | 4 +- .../ExpectedActualDeclarationChecker.kt | 4 +- .../checkers/ExperimentalUsageChecker.kt | 12 ++--- .../ResultClassInReturnTypeChecker.kt | 5 +- .../AbstractDiagnosticsWithUnsignedTypes.kt | 6 +-- .../AbstractForeignAnnotationsTest.kt | 7 +-- .../CompilerTestLanguageVersionSettings.kt | 13 +++-- .../LoadJavaPackageAnnotationsTest.kt | 2 +- .../TypeQualifierAnnotationResolverTest.kt | 2 +- .../JvmVersionRequirementTest.kt | 3 +- .../jetbrains/kotlin/config/AnalysisFlag.kt | 53 ++++--------------- .../jetbrains/kotlin/idea/project/Platform.kt | 2 +- .../inspections/UnusedSymbolInspection.kt | 6 +-- .../jetbrains/kotlin/js/config/JsConfig.java | 7 +-- .../js/KotlinJavascriptSerializationUtil.kt | 4 +- .../kotlin/js/test/BasicIrBoxTest.kt | 4 +- .../jvmhost/impl/KJvmCompilerImpl.kt | 2 +- .../KotlinJsr223JvmLocalScriptEngine.kt | 2 +- 33 files changed, 130 insertions(+), 123 deletions(-) create mode 100644 compiler/frontend.java/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt create mode 100644 compiler/frontend/src/org/jetbrains/kotlin/config/AnalysisFlags.kt diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java index 49065851085..81858ba4467 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java @@ -27,7 +27,8 @@ import org.jetbrains.annotations.TestOnly; import org.jetbrains.kotlin.backend.common.output.OutputFile; import org.jetbrains.kotlin.backend.common.output.OutputFileCollection; import org.jetbrains.kotlin.codegen.state.GenerationState; -import org.jetbrains.kotlin.config.AnalysisFlag; +import org.jetbrains.kotlin.config.AnalysisFlags; +import org.jetbrains.kotlin.config.JvmAnalysisFlags; import org.jetbrains.kotlin.descriptors.ClassDescriptor; import org.jetbrains.kotlin.descriptors.DescriptorUtilKt; import org.jetbrains.kotlin.descriptors.ModuleDescriptor; @@ -113,7 +114,7 @@ public class ClassFileFactory implements OutputFileCollection { part.addTo(builder); } - List experimental = state.getLanguageVersionSettings().getFlag(AnalysisFlag.getExperimental()); + List experimental = state.getLanguageVersionSettings().getFlag(AnalysisFlags.getExperimental()); if (!experimental.isEmpty()) { writeExperimentalMarkers(state.getModule(), builder, experimental); } @@ -124,7 +125,7 @@ public class ClassFileFactory implements OutputFileCollection { @Override public byte[] asBytes(ClassBuilderFactory factory) { int flags = 0; - if (state.getLanguageVersionSettings().getFlag(AnalysisFlag.getStrictMetadataVersionSemantics())) { + if (state.getLanguageVersionSettings().getFlag(JvmAnalysisFlags.getStrictMetadataVersionSemantics())) { flags |= ModuleMapping.STRICT_METADATA_VERSION_SEMANTICS_FLAG; } return ModuleMappingKt.serializeToByteArray(moduleProto, state.getMetadataVersion(), flags); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt index c637da15de5..7e58f72337a 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt @@ -245,7 +245,7 @@ class GenerationState private constructor( JVMConstructorCallNormalizationMode.DISABLE } - val jvmDefaultMode = languageVersionSettings.getFlag(AnalysisFlag.jvmDefaultMode) + val jvmDefaultMode = languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode) val disableOptimization = configuration.get(JVMConfigurationKeys.DISABLE_OPTIMIZATION, false) diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt index 2e50e2a34a2..dd4c80fbf71 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt @@ -17,7 +17,7 @@ package org.jetbrains.kotlin.codegen import org.jetbrains.kotlin.codegen.state.GenerationState -import org.jetbrains.kotlin.config.AnalysisFlag +import org.jetbrains.kotlin.config.JvmAnalysisFlags import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmBytecodeBinaryVersion @@ -38,7 +38,7 @@ fun writeKotlinMetadata( if (state.languageVersionSettings.isPreRelease()) { flags = flags or JvmAnnotationNames.METADATA_PRE_RELEASE_FLAG } - if (state.languageVersionSettings.getFlag(AnalysisFlag.strictMetadataVersionSemantics)) { + if (state.languageVersionSettings.getFlag(JvmAnalysisFlags.strictMetadataVersionSemantics)) { flags = flags or JvmAnnotationNames.METADATA_STRICT_VERSION_SEMANTICS_FLAG } if (flags != 0) { diff --git a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt index acbb3b47078..eb947e5658d 100644 --- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt +++ b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt @@ -198,13 +198,13 @@ abstract class CommonCompilerArguments : CommonToolArguments() { open fun configureAnalysisFlags(collector: MessageCollector): MutableMap, Any> { return HashMap, Any>().apply { - put(AnalysisFlag.skipMetadataVersionCheck, skipMetadataVersionCheck) - put(AnalysisFlag.multiPlatformDoNotCheckActual, noCheckActual) - put(AnalysisFlag.allowKotlinPackage, allowKotlinPackage) - put(AnalysisFlag.experimental, experimental?.toList().orEmpty()) - put(AnalysisFlag.useExperimental, useExperimental?.toList().orEmpty()) - put(AnalysisFlag.explicitApiVersion, apiVersion != null) - put(AnalysisFlag.allowResultReturnType, allowResultReturnType) + put(AnalysisFlags.skipMetadataVersionCheck, skipMetadataVersionCheck) + put(AnalysisFlags.multiPlatformDoNotCheckActual, noCheckActual) + put(AnalysisFlags.allowKotlinPackage, allowKotlinPackage) + put(AnalysisFlags.experimental, experimental?.toList().orEmpty()) + put(AnalysisFlags.useExperimental, useExperimental?.toList().orEmpty()) + put(AnalysisFlags.explicitApiVersion, apiVersion != null) + put(AnalysisFlags.allowResultReturnType, allowResultReturnType) } } diff --git a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt index e5f66b8138d..03a5995be65 100644 --- a/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt +++ b/compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt @@ -261,13 +261,13 @@ class K2JVMCompilerArguments : CommonCompilerArguments() { override fun configureAnalysisFlags(collector: MessageCollector): MutableMap, Any> { val result = super.configureAnalysisFlags(collector) - result.put(AnalysisFlag.strictMetadataVersionSemantics, strictMetadataVersionSemantics) - result[AnalysisFlag.jsr305] = Jsr305Parser(collector).parse( + result[JvmAnalysisFlags.strictMetadataVersionSemantics] = strictMetadataVersionSemantics + result[JvmAnalysisFlags.jsr305] = Jsr305Parser(collector).parse( jsr305, supportCompatqualCheckerFrameworkAnnotations ) - result[AnalysisFlag.ignoreDataFlowInAssert] = JVMAssertionsMode.fromString(assertionsMode) != JVMAssertionsMode.LEGACY - JvmDefaultMode.fromStringOrNull(jvmDefault)?.let { result[AnalysisFlag.jvmDefaultMode] = it } + result[AnalysisFlags.ignoreDataFlowInAssert] = JVMAssertionsMode.fromString(assertionsMode) != JVMAssertionsMode.LEGACY + JvmDefaultMode.fromStringOrNull(jvmDefault)?.let { result[JvmAnalysisFlags.jvmDefaultMode] = it } ?: collector.report( CompilerMessageSeverity.ERROR, "Unknown @JvmDefault mode: $jvmDefault, " + diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/JvmRuntimeVersionsConsistencyChecker.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/JvmRuntimeVersionsConsistencyChecker.kt index e8c45dd1378..6bb88abfadf 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/JvmRuntimeVersionsConsistencyChecker.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/JvmRuntimeVersionsConsistencyChecker.kt @@ -131,7 +131,7 @@ object JvmRuntimeVersionsConsistencyChecker { val actualApi = ApiVersion.parse(actualRuntimeVersion.toString()) if (actualApi == null) { messageCollector.issue(null, "Could not parse runtime JAR version: $actualRuntimeVersion") - } else if (!languageVersionSettings.getFlag(AnalysisFlag.explicitApiVersion) && actualApi < currentApi) { + } else if (!languageVersionSettings.getFlag(AnalysisFlags.explicitApiVersion) && actualApi < currentApi) { // If there's no explicit "-api-version" AND there's an old stdlib in the classpath (older than the default value of API), // we infer API = the version of that stdlib. // Note that "no explicit -api-version" requirement is necessary because for example, in diff --git a/compiler/daemon/src/org/jetbrains/kotlin/daemon/KotlinRemoteReplService.kt b/compiler/daemon/src/org/jetbrains/kotlin/daemon/KotlinRemoteReplService.kt index 1b2208d6e45..94b6bb7f567 100644 --- a/compiler/daemon/src/org/jetbrains/kotlin/daemon/KotlinRemoteReplService.kt +++ b/compiler/daemon/src/org/jetbrains/kotlin/daemon/KotlinRemoteReplService.kt @@ -54,7 +54,7 @@ open class KotlinJvmReplService( addJvmClasspathRoots(templateClasspath) put(CommonConfigurationKeys.MODULE_NAME, "kotlin-script") languageVersionSettings = LanguageVersionSettingsImpl( - LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(AnalysisFlag.skipMetadataVersionCheck to true) + LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(AnalysisFlags.skipMetadataVersionCheck to true) ) } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt new file mode 100644 index 00000000000..522fc801638 --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt @@ -0,0 +1,17 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.config + +object JvmAnalysisFlags { + @JvmStatic + val strictMetadataVersionSemantics by AnalysisFlag.Delegates.Boolean + + @JvmStatic + val jsr305 by AnalysisFlag.Delegates.Jsr305StateWarnByDefault + + @JvmStatic + val jvmDefaultMode by AnalysisFlag.Delegates.JvmDefaultModeDisabledByDefault +} 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 baac22b6287..b2cd8ea956c 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 @@ -20,7 +20,7 @@ import com.intellij.openapi.project.Project import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.builtins.jvm.JvmBuiltIns import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsPackageFragmentProvider -import org.jetbrains.kotlin.config.AnalysisFlag +import org.jetbrains.kotlin.config.JvmAnalysisFlags import org.jetbrains.kotlin.config.JvmTarget import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings @@ -108,7 +108,7 @@ fun createContainerForLazyResolveWithJava( useInstance(languageVersionSettings) - useInstance(languageVersionSettings.getFlag(AnalysisFlag.jsr305)) + useInstance(languageVersionSettings.getFlag(JvmAnalysisFlags.jsr305)) if (useBuiltInsProvider) { useInstance((moduleContext.module.builtIns as JvmBuiltIns).settings) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt index 47ed4a87498..ddada618b2f 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.resolve.jvm.checkers -import org.jetbrains.kotlin.config.AnalysisFlag +import org.jetbrains.kotlin.config.JvmAnalysisFlags import org.jetbrains.kotlin.config.JvmTarget import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.load.java.descriptors.JavaMethodDescriptor @@ -23,7 +23,7 @@ import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm class JvmDefaultChecker(val jvmTarget: JvmTarget) : DeclarationChecker { override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) { - val jvmDefaultMode = context.languageVersionSettings.getFlag(AnalysisFlag.jvmDefaultMode) + val jvmDefaultMode = context.languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode) descriptor.annotations.findAnnotation(JVM_DEFAULT_FQ_NAME)?.let { annotationDescriptor -> val reportOn = DescriptorToSourceUtils.getSourceFromAnnotation(annotationDescriptor) ?: declaration diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmDefaultSuperCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmDefaultSuperCallChecker.kt index a27a9f3e082..7f10a4b30ce 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmDefaultSuperCallChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmDefaultSuperCallChecker.kt @@ -6,7 +6,7 @@ package org.jetbrains.kotlin.resolve.jvm.platform import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.config.AnalysisFlag +import org.jetbrains.kotlin.config.JvmAnalysisFlags import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.calls.callResolverUtil.getSuperCallExpression @@ -17,9 +17,8 @@ import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmDefaultAnnotation import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm class JvmDefaultSuperCallChecker : CallChecker { - override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) { - val jvmDefaultMode = context.languageVersionSettings.getFlag(AnalysisFlag.jvmDefaultMode) + val jvmDefaultMode = context.languageVersionSettings.getFlag(JvmAnalysisFlags.jvmDefaultMode) if (jvmDefaultMode.isEnabled) return val superExpression = getSuperCallExpression(resolvedCall.call) ?: return val resultingDescriptor = resolvedCall.resultingDescriptor as? CallableMemberDescriptor ?: return diff --git a/compiler/frontend/src/org/jetbrains/kotlin/config/AnalysisFlags.kt b/compiler/frontend/src/org/jetbrains/kotlin/config/AnalysisFlags.kt new file mode 100644 index 00000000000..3beff6cda51 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/config/AnalysisFlags.kt @@ -0,0 +1,32 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.config + +object AnalysisFlags { + @JvmStatic + val skipMetadataVersionCheck by AnalysisFlag.Delegates.Boolean + + @JvmStatic + val multiPlatformDoNotCheckActual by AnalysisFlag.Delegates.Boolean + + @JvmStatic + val allowKotlinPackage by AnalysisFlag.Delegates.Boolean + + @JvmStatic + val experimental by AnalysisFlag.Delegates.ListOfStrings + + @JvmStatic + val useExperimental by AnalysisFlag.Delegates.ListOfStrings + + @JvmStatic + val explicitApiVersion by AnalysisFlag.Delegates.Boolean + + @JvmStatic + val ignoreDataFlowInAssert by AnalysisFlag.Delegates.Boolean + + @JvmStatic + val allowResultReturnType by AnalysisFlag.Delegates.Boolean +} diff --git a/compiler/frontend/src/org/jetbrains/kotlin/contracts/parsing/ContractParsingServices.kt b/compiler/frontend/src/org/jetbrains/kotlin/contracts/parsing/ContractParsingServices.kt index 1e4909f19a1..c18601a4e94 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/contracts/parsing/ContractParsingServices.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/contracts/parsing/ContractParsingServices.kt @@ -16,7 +16,7 @@ package org.jetbrains.kotlin.contracts.parsing -import org.jetbrains.kotlin.config.AnalysisFlag +import org.jetbrains.kotlin.config.AnalysisFlags import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.contracts.description.ContractDescription @@ -25,7 +25,7 @@ import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor import org.jetbrains.kotlin.descriptors.isOverridable -import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.psi.KtExpression import org.jetbrains.kotlin.psi.psiUtil.isContractDescriptionCallPsiCheck import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.BindingTrace @@ -69,7 +69,7 @@ class ContractParsingServices(val languageVersionSettings: LanguageVersionSettin private fun checkFeatureEnabled(collector: ContractParsingDiagnosticsCollector) { val isFeatureTurnedOn = languageVersionSettings.supportsFeature(LanguageFeature.AllowContractsForCustomFunctions) || // This condition is here for technical purposes of compiling 1.2-runtime with contracts - languageVersionSettings.getFlag(AnalysisFlag.Flags.allowKotlinPackage) + languageVersionSettings.getFlag(AnalysisFlags.allowKotlinPackage) if (!isFeatureTurnedOn) { collector.unsupportedFeature(languageVersionSettings) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompilerDeserializationConfiguration.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompilerDeserializationConfiguration.kt index 8c3701756d4..c5e2d39716f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompilerDeserializationConfiguration.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/CompilerDeserializationConfiguration.kt @@ -5,14 +5,14 @@ package org.jetbrains.kotlin.resolve -import org.jetbrains.kotlin.config.AnalysisFlag +import org.jetbrains.kotlin.config.AnalysisFlags import org.jetbrains.kotlin.config.KotlinCompilerVersion import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.serialization.deserialization.DeserializationConfiguration class CompilerDeserializationConfiguration(languageVersionSettings: LanguageVersionSettings) : DeserializationConfiguration { - override val skipMetadataVersionCheck = languageVersionSettings.getFlag(AnalysisFlag.skipMetadataVersionCheck) + override val skipMetadataVersionCheck = languageVersionSettings.getFlag(AnalysisFlags.skipMetadataVersionCheck) override val reportErrorsOnPreReleaseDependencies = !skipMetadataVersionCheck && !languageVersionSettings.isPreRelease() && !KotlinCompilerVersion.isPreRelease() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt index 6bdd100d42d..f4327995dbe 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt @@ -21,7 +21,7 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.builtins.getReceiverTypeFromFunctionType import org.jetbrains.kotlin.builtins.getValueParameterTypesFromFunctionType import org.jetbrains.kotlin.builtins.isBuiltinFunctionalType -import org.jetbrains.kotlin.config.AnalysisFlag +import org.jetbrains.kotlin.config.AnalysisFlags import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.contracts.description.ContractProviderKey @@ -261,7 +261,7 @@ class FunctionDescriptorResolver( val isContractsEnabled = languageVersionSettings.supportsFeature(LanguageFeature.AllowContractsForCustomFunctions) || // We need to enable contracts if we're compiling "kotlin"-package to be able to ship contracts in stdlib in 1.2 - languageVersionSettings.getFlag(AnalysisFlag.allowKotlinPackage) + languageVersionSettings.getFlag(AnalysisFlags.allowKotlinPackage) if (!isContractsEnabled || !function.isContractPresentPsiCheck()) return null diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java index 0d68dd56fd2..9ca4569bfa4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java @@ -12,7 +12,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.builtins.FunctionTypesKt; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; -import org.jetbrains.kotlin.config.AnalysisFlag; +import org.jetbrains.kotlin.config.AnalysisFlags; import org.jetbrains.kotlin.config.LanguageFeature; import org.jetbrains.kotlin.config.LanguageVersionSettings; import org.jetbrains.kotlin.descriptors.*; @@ -690,7 +690,7 @@ public class CallResolver { // a.length // we should ignore data flow info from assert argument, since assertions can be disabled and // thus it will lead to NPE in runtime otherwise - if (languageVersionSettings.getFlag(AnalysisFlag.getIgnoreDataFlowInAssert()) && result.isSingleResult()) { + if (languageVersionSettings.getFlag(AnalysisFlags.getIgnoreDataFlowInAssert()) && result.isSingleResult()) { D descriptor = result.getResultingDescriptor(); if (descriptor.getName().equals(Name.identifier("assert"))) { DeclarationDescriptor declaration = descriptor.getContainingDeclaration(); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt index ef517891a73..91147aaea4f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt @@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve.checkers import com.intellij.openapi.vfs.VfsUtilCore import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.config.AnalysisFlag +import org.jetbrains.kotlin.config.AnalysisFlags import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.diagnostics.Errors @@ -51,7 +51,7 @@ object ExpectedActualDeclarationChecker : DeclarationChecker { if (descriptor.isExpect) { checkExpectedDeclarationHasActual(declaration, descriptor, context.trace, descriptor.module, context.expectActualTracker) } else { - val checkActual = !context.languageVersionSettings.getFlag(AnalysisFlag.multiPlatformDoNotCheckActual) + val checkActual = !context.languageVersionSettings.getFlag(AnalysisFlags.multiPlatformDoNotCheckActual) checkActualDeclarationHasExpected(declaration, descriptor, context.trace, checkActual) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalUsageChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalUsageChecker.kt index 2afe47f7906..e1f1ffed8ac 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalUsageChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalUsageChecker.kt @@ -18,7 +18,7 @@ package org.jetbrains.kotlin.resolve.checkers import com.intellij.openapi.project.Project import com.intellij.psi.PsiElement -import org.jetbrains.kotlin.config.AnalysisFlag +import org.jetbrains.kotlin.config.AnalysisFlags import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1 @@ -168,8 +168,8 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { languageVersionSettings: LanguageVersionSettings, bindingContext: BindingContext ): Boolean = - annotationFqName.asString() in languageVersionSettings.getFlag(AnalysisFlag.experimental) || - annotationFqName.asString() in languageVersionSettings.getFlag(AnalysisFlag.useExperimental) || + annotationFqName.asString() in languageVersionSettings.getFlag(AnalysisFlags.experimental) || + annotationFqName.asString() in languageVersionSettings.getFlag(AnalysisFlags.useExperimental) || anyParentMatches { element -> element.isDeclarationAnnotatedWith(annotationFqName, bindingContext) || element.isElementAnnotatedWithUseExperimentalOf(annotationFqName, bindingContext) @@ -240,8 +240,8 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { return false } - val validExperimental = languageVersionSettings.getFlag(AnalysisFlag.experimental).filter(::checkAnnotation) - val validUseExperimental = languageVersionSettings.getFlag(AnalysisFlag.useExperimental).filter { fqName -> + val validExperimental = languageVersionSettings.getFlag(AnalysisFlags.experimental).filter(::checkAnnotation) + val validUseExperimental = languageVersionSettings.getFlag(AnalysisFlags.useExperimental).filter { fqName -> fqName == EXPERIMENTAL_FQ_NAME.asString() || checkAnnotation(fqName) } @@ -286,7 +286,7 @@ class ExperimentalUsageChecker(project: Project) : CallChecker { } private fun checkUsageOfKotlinExperimentalOrUseExperimental(element: PsiElement, context: CheckerContext) { - if (EXPERIMENTAL_FQ_NAME.asString() !in context.languageVersionSettings.getFlag(AnalysisFlag.useExperimental)) { + if (EXPERIMENTAL_FQ_NAME.asString() !in context.languageVersionSettings.getFlag(AnalysisFlags.useExperimental)) { context.trace.report(Errors.EXPERIMENTAL_IS_NOT_ENABLED.on(element)) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ResultClassInReturnTypeChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ResultClassInReturnTypeChecker.kt index 3b8be7b2a7c..1724cb964ec 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ResultClassInReturnTypeChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ResultClassInReturnTypeChecker.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.resolve.checkers -import org.jetbrains.kotlin.config.AnalysisFlag +import org.jetbrains.kotlin.config.AnalysisFlags import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.diagnostics.reportDiagnosticOnce @@ -16,9 +16,8 @@ import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.types.KotlinType class ResultClassInReturnTypeChecker : DeclarationChecker { - override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) { - if (context.languageVersionSettings.getFlag(AnalysisFlag.allowResultReturnType)) return + if (context.languageVersionSettings.getFlag(AnalysisFlags.allowResultReturnType)) return if (declaration !is KtCallableDeclaration || descriptor !is CallableMemberDescriptor) return diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithUnsignedTypes.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithUnsignedTypes.kt index 046a3061f8d..1baf29522af 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithUnsignedTypes.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithUnsignedTypes.kt @@ -5,7 +5,7 @@ package org.jetbrains.kotlin.checkers -import org.jetbrains.kotlin.config.AnalysisFlag +import org.jetbrains.kotlin.config.AnalysisFlags import org.jetbrains.kotlin.config.ApiVersion import org.jetbrains.kotlin.config.LanguageVersion import org.jetbrains.kotlin.config.LanguageVersionSettings @@ -21,6 +21,6 @@ abstract class AbstractDiagnosticsWithUnsignedTypes : AbstractDiagnosticsTest() DEFAULT_DIAGNOSTIC_TESTS_FEATURES, ApiVersion.KOTLIN_1_3, LanguageVersion.KOTLIN_1_3, - mapOf(AnalysisFlag.useExperimental to listOf("kotlin.ExperimentalUnsignedTypes")) + mapOf(AnalysisFlags.useExperimental to listOf("kotlin.ExperimentalUnsignedTypes")) ) -} \ No newline at end of file +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt index fec41d8ac7e..24068cfa9a5 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt @@ -17,10 +17,7 @@ package org.jetbrains.kotlin.checkers import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime -import org.jetbrains.kotlin.config.AnalysisFlag -import org.jetbrains.kotlin.config.ApiVersion -import org.jetbrains.kotlin.config.LanguageVersion -import org.jetbrains.kotlin.config.LanguageVersionSettings +import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.test.ConfigurationKind import org.jetbrains.kotlin.test.InTextDirectivesUtils import org.jetbrains.kotlin.test.MockLibraryUtil @@ -85,7 +82,7 @@ abstract class AbstractForeignAnnotationsTest : AbstractDiagnosticsTest() { name to state }.toMap() - return mapOf(AnalysisFlag.jsr305 to Jsr305State(globalState, migrationState, userAnnotationsState)) + return mapOf(JvmAnalysisFlags.jsr305 to Jsr305State(globalState, migrationState, userAnnotationsState)) } private fun List.getDirectiveValue(directive: String): ReportLevel? = mapNotNull { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/CompilerTestLanguageVersionSettings.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/CompilerTestLanguageVersionSettings.kt index 4a72ff7b85c..0a6b5a9f099 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/CompilerTestLanguageVersionSettings.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/checkers/CompilerTestLanguageVersionSettings.kt @@ -11,7 +11,6 @@ import org.jetbrains.kotlin.test.KotlinTestUtils import org.junit.Assert import java.io.File import java.util.regex.Pattern -import kotlin.collections.HashMap const val LANGUAGE_DIRECTIVE = "LANGUAGE" const val API_VERSION_DIRECTIVE = "API_VERSION" @@ -54,12 +53,12 @@ fun parseLanguageVersionSettingsOrDefault(directiveMap: Map): Co fun parseLanguageVersionSettings(directiveMap: Map): CompilerTestLanguageVersionSettings? { val apiVersionString = directiveMap[API_VERSION_DIRECTIVE] val languageFeaturesString = directiveMap[LANGUAGE_DIRECTIVE] - val experimental = directiveMap[EXPERIMENTAL_DIRECTIVE]?.split(' ')?.let { AnalysisFlag.experimental to it } - val useExperimental = directiveMap[USE_EXPERIMENTAL_DIRECTIVE]?.split(' ')?.let { AnalysisFlag.useExperimental to it } - val ignoreDataFlowInAssert = AnalysisFlag.ignoreDataFlowInAssert to directiveMap.containsKey(IGNORE_DATA_FLOW_IN_ASSERT_DIRECTIVE) - val enableJvmDefault = directiveMap[JVM_DEFAULT_MODE]?.let { AnalysisFlag.jvmDefaultMode to JvmDefaultMode.fromStringOrNull(it)!! } - val skipMetadataVersionCheck = AnalysisFlag.skipMetadataVersionCheck to directiveMap.containsKey(SKIP_METADATA_VERSION_CHECK) - val allowResultReturnType = AnalysisFlag.allowResultReturnType to directiveMap.containsKey(ALLOW_RESULT_RETURN_TYPE) + val experimental = directiveMap[EXPERIMENTAL_DIRECTIVE]?.split(' ')?.let { AnalysisFlags.experimental to it } + val useExperimental = directiveMap[USE_EXPERIMENTAL_DIRECTIVE]?.split(' ')?.let { AnalysisFlags.useExperimental to it } + val ignoreDataFlowInAssert = AnalysisFlags.ignoreDataFlowInAssert to directiveMap.containsKey(IGNORE_DATA_FLOW_IN_ASSERT_DIRECTIVE) + val enableJvmDefault = directiveMap[JVM_DEFAULT_MODE]?.let { JvmAnalysisFlags.jvmDefaultMode to JvmDefaultMode.fromStringOrNull(it)!! } + val skipMetadataVersionCheck = AnalysisFlags.skipMetadataVersionCheck to directiveMap.containsKey(SKIP_METADATA_VERSION_CHECK) + val allowResultReturnType = AnalysisFlags.allowResultReturnType to directiveMap.containsKey(ALLOW_RESULT_RETURN_TYPE) if (apiVersionString == null && languageFeaturesString == null && experimental == null && useExperimental == null && !ignoreDataFlowInAssert.second && !allowResultReturnType.second diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt index 3cbc39b3f48..3a4c4f37c12 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt @@ -47,7 +47,7 @@ class LoadJavaPackageAnnotationsTest : KtUsefulTestCase() { put(JVMConfigurationKeys.USE_JAVAC, true) } languageVersionSettings = LanguageVersionSettingsImpl( - LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(AnalysisFlag.jsr305 to Jsr305State.STRICT) + LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(JvmAnalysisFlags.jsr305 to Jsr305State.STRICT) ) configurator(this) } diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt index 96533b34b09..f545f8b7963 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt @@ -97,7 +97,7 @@ class TypeQualifierAnnotationResolverTest : KtUsefulTestCase() { listOf(File(TEST_DATA_PATH)) ).apply { languageVersionSettings = LanguageVersionSettingsImpl( - LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(AnalysisFlag.jsr305 to Jsr305State.STRICT) + LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(JvmAnalysisFlags.jsr305 to Jsr305State.STRICT) ) } diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt b/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt index d5f5ccea127..b00e3b745bc 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt +++ b/compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt @@ -21,7 +21,6 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment import org.jetbrains.kotlin.config.* import org.jetbrains.kotlin.descriptors.ModuleDescriptor import org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil -import org.jetbrains.kotlin.metadata.ProtoBuf import org.jetbrains.kotlin.metadata.ProtoBuf.VersionRequirement.VersionKind.COMPILER_VERSION import org.jetbrains.kotlin.metadata.deserialization.VersionRequirement import org.jetbrains.kotlin.resolve.lazy.JvmResolveUtil @@ -41,7 +40,7 @@ class JvmVersionRequirementTest : AbstractVersionRequirementTest() { languageVersionSettings = LanguageVersionSettingsImpl( languageVersion, ApiVersion.createByLanguageVersion(languageVersion), - mapOf(AnalysisFlag.jvmDefaultMode to JvmDefaultMode.ENABLE), + mapOf(JvmAnalysisFlags.jvmDefaultMode to JvmDefaultMode.ENABLE), emptyMap() ) }, diff --git a/compiler/util/src/org/jetbrains/kotlin/config/AnalysisFlag.kt b/compiler/util/src/org/jetbrains/kotlin/config/AnalysisFlag.kt index 9ea861a8c23..0b8c94acf76 100644 --- a/compiler/util/src/org/jetbrains/kotlin/config/AnalysisFlag.kt +++ b/compiler/util/src/org/jetbrains/kotlin/config/AnalysisFlag.kt @@ -10,8 +10,8 @@ import kotlin.properties.ReadOnlyProperty import kotlin.reflect.KProperty class AnalysisFlag internal constructor( - private val name: String, - val defaultValue: T + private val name: String, + val defaultValue: T ) { override fun equals(other: Any?): Boolean = other is AnalysisFlag<*> && other.name == name @@ -19,60 +19,27 @@ class AnalysisFlag internal constructor( override fun toString(): String = name - private class Flag(name: String, defaultValue: T) : ReadOnlyProperty> { + class Delegate(name: String, defaultValue: T) : ReadOnlyProperty> { private val flag = AnalysisFlag(name, defaultValue) override fun getValue(thisRef: Any?, property: KProperty<*>): AnalysisFlag = flag + } + object Delegates { object Boolean { - operator fun provideDelegate(instance: Any?, property: KProperty<*>) = Flag(property.name, false) + operator fun provideDelegate(instance: Any?, property: KProperty<*>) = Delegate(property.name, false) } object Jsr305StateWarnByDefault { - operator fun provideDelegate(instance: Any?, property: KProperty<*>) = Flag(property.name, Jsr305State.DEFAULT) + operator fun provideDelegate(instance: Any?, property: KProperty<*>) = Delegate(property.name, Jsr305State.DEFAULT) } - object JvmDefaultModeDisabledByDefaul { - operator fun provideDelegate(instance: Any?, property: KProperty<*>) = Flag(property.name, org.jetbrains.kotlin.config.JvmDefaultMode.DISABLE) + object JvmDefaultModeDisabledByDefault { + operator fun provideDelegate(instance: Any?, property: KProperty<*>) = Delegate(property.name, JvmDefaultMode.DISABLE) } object ListOfStrings { - operator fun provideDelegate(instance: Any?, property: KProperty<*>) = Flag(property.name, emptyList()) + operator fun provideDelegate(instance: Any?, property: KProperty<*>) = Delegate(property.name, emptyList()) } } - - companion object Flags { - @JvmStatic - val skipMetadataVersionCheck by Flag.Boolean - - @JvmStatic - val strictMetadataVersionSemantics by Flag.Boolean - - @JvmStatic - val multiPlatformDoNotCheckActual by Flag.Boolean - - @JvmStatic - val jsr305 by Flag.Jsr305StateWarnByDefault - - @JvmStatic - val allowKotlinPackage by Flag.Boolean - - @JvmStatic - val experimental by Flag.ListOfStrings - - @JvmStatic - val useExperimental by Flag.ListOfStrings - - @JvmStatic - val explicitApiVersion by Flag.Boolean - - @JvmStatic - val ignoreDataFlowInAssert by Flag.Boolean - - @JvmStatic - val jvmDefaultMode by Flag.JvmDefaultModeDisabledByDefaul - - @JvmStatic - val allowResultReturnType by Flag.Boolean - } } diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt index a875eb14413..fb30d593c0c 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt @@ -146,7 +146,7 @@ fun Project.getLanguageVersionSettings( } val extraAnalysisFlags = additionalArguments.configureAnalysisFlags(MessageCollector.NONE).apply { - if (jsr305State != null) put(AnalysisFlag.jsr305, jsr305State) + if (jsr305State != null) put(JvmAnalysisFlags.jsr305, jsr305State) } return LanguageVersionSettingsImpl( diff --git a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt index 2eb6dec197f..c6263179634 100644 --- a/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt +++ b/idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt @@ -35,7 +35,7 @@ import org.jetbrains.kotlin.asJava.LightClassUtil import org.jetbrains.kotlin.asJava.classes.KtLightClass import org.jetbrains.kotlin.asJava.toLightClass import org.jetbrains.kotlin.asJava.toLightMethods -import org.jetbrains.kotlin.config.AnalysisFlag +import org.jetbrains.kotlin.config.AnalysisFlags import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.idea.caches.project.implementingDescriptors import org.jetbrains.kotlin.idea.caches.resolve.analyze @@ -175,8 +175,8 @@ class UnusedSymbolInspection : AbstractKotlinInspection() { if (descriptor is ClassDescriptor && descriptor.kind == ClassKind.ANNOTATION_CLASS) { val fqName = descriptor.fqNameSafe.asString() val languageVersionSettings = declaration.languageVersionSettings - if (fqName in languageVersionSettings.getFlag(AnalysisFlag.experimental) || - fqName in languageVersionSettings.getFlag(AnalysisFlag.useExperimental) + if (fqName in languageVersionSettings.getFlag(AnalysisFlags.experimental) || + fqName in languageVersionSettings.getFlag(AnalysisFlags.useExperimental) ) return } diff --git a/js/js.frontend/src/org/jetbrains/kotlin/js/config/JsConfig.java b/js/js.frontend/src/org/jetbrains/kotlin/js/config/JsConfig.java index fb4ff039126..fa34ec70455 100644 --- a/js/js.frontend/src/org/jetbrains/kotlin/js/config/JsConfig.java +++ b/js/js.frontend/src/org/jetbrains/kotlin/js/config/JsConfig.java @@ -169,10 +169,7 @@ public class JsConfig { Set modules = new HashSet<>(); - boolean skipMetadataVersionCheck = - getLanguageVersionSettings().getFlag( - AnalysisFlag.getSkipMetadataVersionCheck() - ); + boolean skipMetadataVersionCheck = getLanguageVersionSettings().getFlag(AnalysisFlags.getSkipMetadataVersionCheck()); for (String path : libraries) { if (librariesToSkip != null && librariesToSkip.contains(path)) continue; @@ -309,7 +306,7 @@ public class JsConfig { return factoryMap.computeIfAbsent(metadata, m -> { LanguageVersionSettings languageVersionSettings = CommonConfigurationKeysKt.getLanguageVersionSettings(configuration); assert m.getVersion().isCompatible() || - languageVersionSettings.getFlag(AnalysisFlag.getSkipMetadataVersionCheck()) : + languageVersionSettings.getFlag(AnalysisFlags.getSkipMetadataVersionCheck()) : "Expected JS metadata version " + JsMetadataVersion.INSTANCE + ", but actual metadata version is " + m.getVersion(); ModuleDescriptorImpl moduleDescriptor = new ModuleDescriptorImpl( diff --git a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt index 8c37bc8c4f3..a85ddeaee01 100644 --- a/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt +++ b/js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt @@ -16,7 +16,7 @@ package org.jetbrains.kotlin.serialization.js -import org.jetbrains.kotlin.config.AnalysisFlag +import org.jetbrains.kotlin.config.AnalysisFlags import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.incremental.components.LookupTracker @@ -256,7 +256,7 @@ object KotlinJavascriptSerializationUtil { header.flags = 1 } - val experimentalAnnotationFqNames = languageVersionSettings.getFlag(AnalysisFlag.experimental) + val experimentalAnnotationFqNames = languageVersionSettings.getFlag(AnalysisFlags.experimental) if (experimentalAnnotationFqNames.isNotEmpty()) { val stringTable = StringTableImpl() for (fqName in experimentalAnnotationFqNames) { diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicIrBoxTest.kt b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicIrBoxTest.kt index ed8f7f9f959..2a0d29de282 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicIrBoxTest.kt +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/BasicIrBoxTest.kt @@ -151,8 +151,8 @@ abstract class BasicIrBoxTest( LanguageFeature.MultiPlatformProjects to LanguageFeature.State.ENABLED ), analysisFlags = mapOf( - AnalysisFlag.useExperimental to listOf("kotlin.contracts.ExperimentalContracts", "kotlin.Experimental"), - AnalysisFlag.allowResultReturnType to true + AnalysisFlags.useExperimental to listOf("kotlin.contracts.ExperimentalContracts", "kotlin.Experimental"), + AnalysisFlags.allowResultReturnType to true ) ) diff --git a/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJvmCompilerImpl.kt b/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJvmCompilerImpl.kt index 467e407cb55..c8ce3e2bfa2 100644 --- a/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJvmCompilerImpl.kt +++ b/libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJvmCompilerImpl.kt @@ -109,7 +109,7 @@ class KJvmCompilerImpl(val hostConfiguration: ScriptingHostConfiguration) : KJvm put(CommonConfigurationKeys.MODULE_NAME, "kotlin-script") // TODO" take meaningful and valid name from somewhere languageVersionSettings = LanguageVersionSettingsImpl( - LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(AnalysisFlag.skipMetadataVersionCheck to true) + LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(AnalysisFlags.skipMetadataVersionCheck to true) ) } environment = KotlinCoreEnvironment.createForProduction( diff --git a/libraries/tools/kotlin-script-util/src/main/kotlin/org/jetbrains/kotlin/script/jsr223/KotlinJsr223JvmLocalScriptEngine.kt b/libraries/tools/kotlin-script-util/src/main/kotlin/org/jetbrains/kotlin/script/jsr223/KotlinJsr223JvmLocalScriptEngine.kt index 9b8d8377bfa..0a6da0e96d7 100644 --- a/libraries/tools/kotlin-script-util/src/main/kotlin/org/jetbrains/kotlin/script/jsr223/KotlinJsr223JvmLocalScriptEngine.kt +++ b/libraries/tools/kotlin-script-util/src/main/kotlin/org/jetbrains/kotlin/script/jsr223/KotlinJsr223JvmLocalScriptEngine.kt @@ -69,7 +69,7 @@ class KotlinJsr223JvmLocalScriptEngine( addJvmClasspathRoots(templateClasspath) put(CommonConfigurationKeys.MODULE_NAME, "kotlin-script") languageVersionSettings = LanguageVersionSettingsImpl( - LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(AnalysisFlag.skipMetadataVersionCheck to true) + LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(AnalysisFlags.skipMetadataVersionCheck to true) ) } }