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

Split AnalysisFlag values to AnalysisFlags and JvmAnalysisFlags

Browse Source 
Declare AnalysisFlags in module 'frontend', and JvmAnalysisFlags in
module 'frontend.java', to avoid leaking Java-related logic to common
compiler code
This commit is contained in:
Alexander Udalov
2018-09-28 17:11:21 +02:00
parent c59779f5b9
commit 009f18f1f4
33 changed files with 130 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/backend/src/org/jetbrains/kotlin/codegen/ClassFileFactory.java
+4 -3
View File
@@ -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<String> experimental = state.getLanguageVersionSettings().getFlag(AnalysisFlag.getExperimental());
List<String> 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);
compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt
+1 -1
View File
@@ -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)
compiler/backend/src/org/jetbrains/kotlin/codegen/writeAnnotationUtil.kt
+2 -2
View File
@@ -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) {
compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/CommonCompilerArguments.kt
+7 -7
View File
@@ -198,13 +198,13 @@ abstract class CommonCompilerArguments : CommonToolArguments() {
open fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, Any> {
return HashMap<AnalysisFlag<*>, 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)
}
}
compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2JVMCompilerArguments.kt
+4 -4
View File
@@ -261,13 +261,13 @@ class K2JVMCompilerArguments : CommonCompilerArguments() {
override fun configureAnalysisFlags(collector: MessageCollector): MutableMap<AnalysisFlag<*>, 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, " +
compiler/cli/src/org/jetbrains/kotlin/cli/jvm/JvmRuntimeVersionsConsistencyChecker.kt
+1 -1
View File
@@ -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
compiler/daemon/src/org/jetbrains/kotlin/daemon/KotlinRemoteReplService.kt
+1 -1
View File
@@ -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)
)
}
compiler/frontend.java/src/org/jetbrains/kotlin/config/JvmAnalysisFlags.kt
+17
View File
@@ -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
}
compiler/frontend.java/src/org/jetbrains/kotlin/frontend/java/di/injection.kt
+2 -2
View File
@@ -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)
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/JvmDefaultChecker.kt
+2 -2
View File
@@ -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
compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/platform/JvmDefaultSuperCallChecker.kt
+2 -3
View File
@@ -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
compiler/frontend/src/org/jetbrains/kotlin/config/AnalysisFlags.kt
+32
View File
@@ -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
}
compiler/frontend/src/org/jetbrains/kotlin/contracts/parsing/ContractParsingServices.kt
+3 -3
View File
@@ -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)
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/CompilerDeserializationConfiguration.kt
+2 -2
View File
@@ -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()
compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt
+2 -2
View File
@@ -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
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/CallResolver.java
+2 -2
View File
@@ -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();
compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExpectedActualDeclarationChecker.kt
+2 -2
View File
@@ -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)
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ExperimentalUsageChecker.kt
+6 -6
View File
@@ -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))
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/ResultClassInReturnTypeChecker.kt
+2 -3
View File
@@ -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
compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractDiagnosticsWithUnsignedTypes.kt
+3 -3
View File
@@ -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"))
)
}
}
compiler/tests-common/tests/org/jetbrains/kotlin/checkers/AbstractForeignAnnotationsTest.kt
+2 -5
View File
@@ -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<TestFile>.getDirectiveValue(directive: String): ReportLevel? = mapNotNull {
compiler/tests-common/tests/org/jetbrains/kotlin/checkers/CompilerTestLanguageVersionSettings.kt
+6 -7
View File
@@ -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<String, String>): Co
fun parseLanguageVersionSettings(directiveMap: Map<String, String>): 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
compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaPackageAnnotationsTest.kt
+1 -1
View File
@@ -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)
}
compiler/tests/org/jetbrains/kotlin/jvm/compiler/TypeQualifierAnnotationResolverTest.kt
+1 -1
View File
@@ -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)
)
}
compiler/tests/org/jetbrains/kotlin/serialization/JvmVersionRequirementTest.kt
+1 -2
View File
@@ -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()
)
},
compiler/util/src/org/jetbrains/kotlin/config/AnalysisFlag.kt
+10 -43
View File
@@ -10,8 +10,8 @@ import kotlin.properties.ReadOnlyProperty
import kotlin.reflect.KProperty
class AnalysisFlag<out T> 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<out T> internal constructor(
override fun toString(): String = name
private class Flag<out T>(name: String, defaultValue: T) : ReadOnlyProperty<Any?, AnalysisFlag<T>> {
class Delegate<out T>(name: String, defaultValue: T) : ReadOnlyProperty<Any?, AnalysisFlag<T>> {
private val flag = AnalysisFlag(name, defaultValue)
override fun getValue(thisRef: Any?, property: KProperty<*>): AnalysisFlag<T> = 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<String>())
operator fun provideDelegate(instance: Any?, property: KProperty<*>) = Delegate(property.name, emptyList<String>())
}
}
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
}
}
idea/idea-analysis/src/org/jetbrains/kotlin/idea/project/Platform.kt
+1 -1
View File
@@ -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(
idea/src/org/jetbrains/kotlin/idea/inspections/UnusedSymbolInspection.kt
+3 -3
View File
@@ -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
}
js/js.frontend/src/org/jetbrains/kotlin/js/config/JsConfig.java
+2 -5
View File
@@ -169,10 +169,7 @@ public class JsConfig {
Set<String> 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(
js/js.serializer/src/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializationUtil.kt
+2 -2
View File
@@ -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) {
js/js.tests/test/org/jetbrains/kotlin/js/test/BasicIrBoxTest.kt
+2 -2
View File
@@ -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
)
)
libraries/scripting/jvm-host/src/kotlin/script/experimental/jvmhost/impl/KJvmCompilerImpl.kt
+1 -1
View File
@@ -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(
libraries/tools/kotlin-script-util/src/main/kotlin/org/jetbrains/kotlin/script/jsr223/KotlinJsr223JvmLocalScriptEngine.kt
+1 -1
View File
@@ -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)
)
}
}