Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.jetbrains.kotlin.resolve.PlatformConfiguratorBase.kt Maven / Gradle / Ivy
/*
* Copyright 2000-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
* 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.resolve
import org.jetbrains.kotlin.builtins.PlatformToKotlinClassMapper
import org.jetbrains.kotlin.container.*
import org.jetbrains.kotlin.resolve.calls.checkers.*
import org.jetbrains.kotlin.resolve.calls.results.TypeSpecificityComparator
import org.jetbrains.kotlin.resolve.checkers.*
import org.jetbrains.kotlin.resolve.lazy.DelegationFilter
import org.jetbrains.kotlin.types.DynamicTypesSettings
private val DEFAULT_DECLARATION_CHECKERS = listOf(
DataClassDeclarationChecker(),
ConstModifierChecker,
UnderscoreChecker,
InlineParameterChecker,
InfixModifierChecker(),
SinceKotlinAnnotationValueChecker,
RequireKotlinAnnotationValueChecker,
ReifiedTypeParameterAnnotationChecker(),
DynamicReceiverChecker,
DelegationChecker(),
KClassWithIncorrectTypeArgumentChecker,
SuspendLimitationsChecker,
InlineClassDeclarationChecker,
InnerClassInsideInlineClass(),
PropertiesWithInlineClassAsReceiver(),
AnnotationClassTargetAndRetentionChecker(),
ReservedMembersAndConstructsForInlineClass(),
ResultClassInReturnTypeChecker(),
LocalVariableTypeParametersChecker(),
ExplicitApiDeclarationChecker(),
TailrecFunctionChecker,
TrailingCommaDeclarationChecker,
MissingDependencySupertypeChecker.ForDeclarations,
FunInterfaceDeclarationChecker(),
DeprecatedSinceKotlinAnnotationChecker,
ContractDescriptionBlockChecker,
PrivateInlineFunctionsReturningAnonymousObjectsChecker,
SealedInheritorInSamePackageChecker,
SealedInheritorInSameModuleChecker,
SealedInterfaceAllowedChecker,
)
private val DEFAULT_CALL_CHECKERS = listOf(
CapturingInClosureChecker(), InlineCheckerWrapper(), SafeCallChecker(), TrailingCommaCallChecker,
DeprecatedCallChecker, CallReturnsArrayOfNothingChecker(), InfixCallChecker(), OperatorCallChecker(),
ConstructorHeaderCallChecker, ProtectedConstructorCallChecker, ApiVersionCallChecker,
CoroutineSuspendCallChecker, BuilderFunctionsCallChecker, DslScopeViolationCallChecker, MissingDependencyClassChecker,
CallableReferenceCompatibilityChecker(), LateinitIntrinsicApplicabilityChecker,
UnderscoreUsageChecker, AssigningNamedArgumentToVarargChecker(), ImplicitNothingAsTypeParameterCallChecker,
PrimitiveNumericComparisonCallChecker, LambdaWithSuspendModifierCallChecker,
UselessElvisCallChecker(), ResultTypeWithNullableOperatorsChecker(), NullableVarargArgumentCallChecker,
NamedFunAsExpressionChecker, ContractNotAllowedCallChecker, ReifiedTypeParameterSubstitutionChecker(),
MissingDependencySupertypeChecker.ForCalls, AbstractClassInstantiationChecker, SuspendConversionCallChecker,
UnitConversionCallChecker, FunInterfaceConstructorReferenceChecker, NullableExtensionOperatorWithSafeCallChecker,
ReferencingToUnderscoreNamedParameterOfCatchBlockChecker, VarargWrongExecutionOrderChecker
)
private val DEFAULT_TYPE_CHECKERS = emptyList()
private val DEFAULT_CLASSIFIER_USAGE_CHECKERS = listOf(
DeprecatedClassifierUsageChecker(), ApiVersionClassifierUsageChecker, MissingDependencyClassChecker.ClassifierUsage,
OptionalExpectationUsageChecker()
)
private val DEFAULT_ANNOTATION_CHECKERS = listOf()
private val DEFAULT_CLASH_RESOLVERS = listOf>(
IdentifierCheckerClashesResolver(),
/**
* We should use NONE for clash resolution, because:
* - JvmTypeSpecificityComparator covers cases with flexible types and primitive types loaded from Java, and all this is irrelevant for
* non-JVM modules
* - JsTypeSpecificityComparator covers case with dynamics, which are not allowed in non-JS modules either
*/
PlatformExtensionsClashResolver.FallbackToDefault(TypeSpecificityComparator.NONE, TypeSpecificityComparator::class.java),
PlatformExtensionsClashResolver.FallbackToDefault(DynamicTypesSettings(), DynamicTypesSettings::class.java)
)
fun StorageComponentContainer.configureDefaultCheckers() {
DEFAULT_DECLARATION_CHECKERS.forEach { useInstance(it) }
DEFAULT_CALL_CHECKERS.forEach { useInstance(it) }
DEFAULT_TYPE_CHECKERS.forEach { useInstance(it) }
DEFAULT_CLASSIFIER_USAGE_CHECKERS.forEach { useInstance(it) }
DEFAULT_ANNOTATION_CHECKERS.forEach { useInstance(it) }
DEFAULT_CLASH_RESOLVERS.forEach { useClashResolver(it) }
}
abstract class PlatformConfiguratorBase(
private val dynamicTypesSettings: DynamicTypesSettings? = null,
private val additionalDeclarationCheckers: List = emptyList(),
private val additionalCallCheckers: List = emptyList(),
private val additionalTypeCheckers: List = emptyList(),
private val additionalClassifierUsageCheckers: List = emptyList(),
private val additionalAnnotationCheckers: List = emptyList(),
private val additionalClashResolvers: List> = emptyList(),
private val identifierChecker: IdentifierChecker? = null,
private val overloadFilter: OverloadFilter? = null,
private val platformToKotlinClassMapper: PlatformToKotlinClassMapper? = null,
private val delegationFilter: DelegationFilter? = null,
private val overridesBackwardCompatibilityHelper: OverridesBackwardCompatibilityHelper? = null,
private val declarationReturnTypeSanitizer: DeclarationReturnTypeSanitizer? = null
) : PlatformConfigurator {
override val platformSpecificContainer = composeContainer(this::class.java.simpleName) {
configureDefaultCheckers()
configureExtensionsAndCheckers(this)
}
override fun configureModuleDependentCheckers(container: StorageComponentContainer) {
container.useImpl()
}
fun configureExtensionsAndCheckers(container: StorageComponentContainer) {
with(container) {
useInstanceIfNotNull(dynamicTypesSettings)
additionalDeclarationCheckers.forEach { useInstance(it) }
additionalCallCheckers.forEach { useInstance(it) }
additionalTypeCheckers.forEach { useInstance(it) }
additionalClassifierUsageCheckers.forEach { useInstance(it) }
additionalAnnotationCheckers.forEach { useInstance(it) }
additionalClashResolvers.forEach { useClashResolver(it) }
useInstanceIfNotNull(identifierChecker)
useInstanceIfNotNull(overloadFilter)
useInstanceIfNotNull(platformToKotlinClassMapper)
useInstanceIfNotNull(delegationFilter)
useInstanceIfNotNull(overridesBackwardCompatibilityHelper)
useInstanceIfNotNull(declarationReturnTypeSanitizer)
}
}
}
fun createContainer(id: String, analyzerServices: PlatformDependentAnalyzerServices, init: StorageComponentContainer.() -> Unit) =
composeContainer(id, analyzerServices.platformConfigurator.platformSpecificContainer, init)
