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

Rename platform to header.

Browse Source
This commit is contained in:
Stanislav Erokhin
2016-12-13 17:59:59 +03:00
parent facee84020
commit 59efedf610
134 changed files with 500 additions and 499 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt
+2 -2
View File
@@ -637,7 +637,7 @@ class ControlFlowInformationProvider private constructor(
is KtPrimaryConstructor -> if (!element.hasValOrVar()) {
val containingClass = owner.getContainingClassOrObject()
val containingClassDescriptor = trace.get(DECLARATION_TO_DESCRIPTOR, containingClass) as? ClassDescriptor
if (!DescriptorUtils.isAnnotationClass(containingClassDescriptor) && containingClassDescriptor?.isPlatform == false &&
if (!DescriptorUtils.isAnnotationClass(containingClassDescriptor) && containingClassDescriptor?.isHeader == false &&
!DescriptorUtils.isEffectivelyExternal(containingClassDescriptor)
) {
report(UNUSED_PARAMETER.on(element, variableDescriptor), ctxt)
@@ -653,7 +653,7 @@ class ControlFlowInformationProvider private constructor(
if (isMain
|| functionDescriptor.isOverridableOrOverrides
|| owner.hasModifier(KtTokens.OVERRIDE_KEYWORD)
|| functionDescriptor.isPlatform || functionDescriptor.isImpl
|| functionDescriptor.isHeader || functionDescriptor.isImpl
|| DescriptorUtils.isEffectivelyExternal(functionDescriptor)
|| OperatorNameConventions.GET_VALUE == functionName
|| OperatorNameConventions.SET_VALUE == functionName
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
+8 -8
View File
@@ -34,7 +34,7 @@ import org.jetbrains.kotlin.resolve.VarianceConflictDiagnosticData;
import org.jetbrains.kotlin.resolve.calls.inference.InferenceErrorData;
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
import org.jetbrains.kotlin.resolve.calls.tower.WrongResolutionToClassifier;
import org.jetbrains.kotlin.resolve.checkers.PlatformImplDeclarationChecker;
import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker;
import org.jetbrains.kotlin.serialization.deserialization.IncompatibleVersionErrorData;
import org.jetbrains.kotlin.types.KotlinType;
@@ -499,11 +499,11 @@ public interface Errors {
// Multi-platform projects
DiagnosticFactory0<KtDeclaration> PLATFORM_DECLARATION_WITH_BODY = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtParameter> PLATFORM_DECLARATION_WITH_DEFAULT_PARAMETER = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtConstructorDelegationCall> PLATFORM_CLASS_CONSTRUCTOR_DELEGATION_CALL = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtParameter> PLATFORM_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtExpression> PLATFORM_PROPERTY_INITIALIZER = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtDeclaration> HEADER_DECLARATION_WITH_BODY = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtParameter> HEADER_DECLARATION_WITH_DEFAULT_PARAMETER = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtConstructorDelegationCall> HEADER_CLASS_CONSTRUCTOR_DELEGATION_CALL = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtParameter> HEADER_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtExpression> HEADER_PROPERTY_INITIALIZER = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<KtTypeAlias> IMPL_TYPE_ALIAS_NOT_TO_CLASS = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<KtTypeAlias> IMPL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
@@ -511,9 +511,9 @@ public interface Errors {
DiagnosticFactory0<KtTypeAlias> IMPL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory2<KtDeclaration, MemberDescriptor,
Map<PlatformImplDeclarationChecker.Compatibility.Incompatible, Collection<MemberDescriptor>>> PLATFORM_DECLARATION_WITHOUT_DEFINITION =
Map<HeaderImplDeclarationChecker.Compatibility.Incompatible, Collection<MemberDescriptor>>> HEADER_WITHOUT_IMPLEMENTATION =
DiagnosticFactory2.create(ERROR, DECLARATION_SIGNATURE);
DiagnosticFactory0<PsiElement> PLATFORM_DEFINITION_WITHOUT_DECLARATION = DiagnosticFactory0.create(ERROR);
DiagnosticFactory0<PsiElement> IMPLEMENTATION_WITHOUT_HEADER = DiagnosticFactory0.create(ERROR);
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java
+7 -7
View File
@@ -259,19 +259,19 @@ public class DefaultErrorMessages {
MAP.put(USELESS_VARARG_ON_PARAMETER, "Vararg on this parameter is useless");
MAP.put(MULTIPLE_VARARG_PARAMETERS, "Multiple vararg-parameters are prohibited");
MAP.put(PLATFORM_DECLARATION_WITH_BODY, "Platform declaration must not have a body");
MAP.put(PLATFORM_DECLARATION_WITH_DEFAULT_PARAMETER, "Platform declaration cannot have parameters with default values");
MAP.put(PLATFORM_CLASS_CONSTRUCTOR_DELEGATION_CALL, "Explicit delegation call for constructor of a platform class is not allowed");
MAP.put(PLATFORM_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER, "Platform class constructor cannot have a property parameter");
MAP.put(PLATFORM_PROPERTY_INITIALIZER, "Platform property cannot have an initializer");
MAP.put(HEADER_DECLARATION_WITH_BODY, "Header declaration must not have a body");
MAP.put(HEADER_DECLARATION_WITH_DEFAULT_PARAMETER, "Header declaration cannot have parameters with default values");
MAP.put(HEADER_CLASS_CONSTRUCTOR_DELEGATION_CALL, "Explicit delegation call for constructor of a header class is not allowed");
MAP.put(HEADER_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER, "Header class constructor cannot have a property parameter");
MAP.put(HEADER_PROPERTY_INITIALIZER, "Header property cannot have an initializer");
MAP.put(IMPL_TYPE_ALIAS_NOT_TO_CLASS, "Right-hand side of 'impl' type alias should be a class, not another type alias");
MAP.put(IMPL_TYPE_ALIAS_TO_CLASS_WITH_DECLARATION_SITE_VARIANCE, "Aliased class should not have type parameters with declaration-site variance");
MAP.put(IMPL_TYPE_ALIAS_WITH_USE_SITE_VARIANCE, "Right-hand side of 'impl' type alias cannot contain use-site variance or star projections");
MAP.put(IMPL_TYPE_ALIAS_WITH_COMPLEX_SUBSTITUTION, "Type arguments in the right-hand side of 'impl' type alias should be its type parameters in the same order, e.g. 'impl typealias Foo<A, B> = Bar<A, B>'");
MAP.put(PLATFORM_DECLARATION_WITHOUT_DEFINITION, "No definition is found for platform declaration ''{0}''{1}", NAME, PlatformIncompatibilityDiagnosticRenderer.INSTANCE);
MAP.put(PLATFORM_DEFINITION_WITHOUT_DECLARATION, "Modifier 'impl' is only applicable to members that are initially declared in platform-independent code");
MAP.put(HEADER_WITHOUT_IMPLEMENTATION, "No implementation is found for header declaration ''{0}''{1}", NAME, PlatformIncompatibilityDiagnosticRenderer.INSTANCE);
MAP.put(IMPLEMENTATION_WITHOUT_HEADER, "Modifier 'impl' is only applicable to members that are initially declared in platform-independent code");
MAP.put(PROJECTION_ON_NON_CLASS_TYPE_ARGUMENT, "Projections are not allowed on type arguments of functions and properties");
MAP.put(SUPERTYPE_NOT_INITIALIZED, "This type has a constructor, and thus must be initialized here");
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/PlatformIncompatibilityDiagnosticRenderer.kt
+4 -4
View File
@@ -18,14 +18,14 @@ package org.jetbrains.kotlin.diagnostics.rendering
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
import org.jetbrains.kotlin.descriptors.MemberDescriptor
import org.jetbrains.kotlin.resolve.checkers.PlatformImplDeclarationChecker
import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker
object PlatformIncompatibilityDiagnosticRenderer :
DiagnosticParameterRenderer<Map<PlatformImplDeclarationChecker.Compatibility.Incompatible, Collection<MemberDescriptor>>> {
DiagnosticParameterRenderer<Map<HeaderImplDeclarationChecker.Compatibility.Incompatible, Collection<MemberDescriptor>>> {
private val INDENTATION_UNIT = " "
override fun render(
obj: Map<PlatformImplDeclarationChecker.Compatibility.Incompatible, Collection<MemberDescriptor>>,
obj: Map<HeaderImplDeclarationChecker.Compatibility.Incompatible, Collection<MemberDescriptor>>,
renderingContext: RenderingContext
): String {
if (obj.isEmpty()) return ""
@@ -39,7 +39,7 @@ object PlatformIncompatibilityDiagnosticRenderer :
}
private fun StringBuilder.render(
map: Map<PlatformImplDeclarationChecker.Compatibility.Incompatible, Collection<MemberDescriptor>>,
map: Map<HeaderImplDeclarationChecker.Compatibility.Incompatible, Collection<MemberDescriptor>>,
indent: String,
renderDescriptor: (DeclarationDescriptor) -> String
) {
compiler/frontend/src/org/jetbrains/kotlin/lexer/KtTokens.java
+3 -3
View File
@@ -189,7 +189,7 @@ public interface KtTokens {
KtModifierKeywordToken COROUTINE_KEYWORD = KtModifierKeywordToken.softKeywordModifier("coroutine");
KtModifierKeywordToken SUSPEND_KEYWORD = KtModifierKeywordToken.softKeywordModifier("suspend");
KtModifierKeywordToken PLATFORM_KEYWORD = KtModifierKeywordToken.softKeywordModifier("platform");
KtModifierKeywordToken HEADER_KEYWORD = KtModifierKeywordToken.softKeywordModifier("header");
KtModifierKeywordToken IMPL_KEYWORD = KtModifierKeywordToken.softKeywordModifier("impl");
TokenSet KEYWORDS = TokenSet.create(PACKAGE_KEYWORD, AS_KEYWORD, TYPE_ALIAS_KEYWORD, CLASS_KEYWORD, INTERFACE_KEYWORD,
@@ -212,7 +212,7 @@ public interface KtTokens {
LATEINIT_KEYWORD,
DATA_KEYWORD, INLINE_KEYWORD, NOINLINE_KEYWORD, TAILREC_KEYWORD, EXTERNAL_KEYWORD,
ANNOTATION_KEYWORD, CROSSINLINE_KEYWORD, CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD,
COROUTINE_KEYWORD, SUSPEND_KEYWORD, PLATFORM_KEYWORD, IMPL_KEYWORD
COROUTINE_KEYWORD, SUSPEND_KEYWORD, HEADER_KEYWORD, IMPL_KEYWORD
);
/*
@@ -226,7 +226,7 @@ public interface KtTokens {
PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD, OUT_KEYWORD, IN_KEYWORD, FINAL_KEYWORD, VARARG_KEYWORD,
REIFIED_KEYWORD, COMPANION_KEYWORD, SEALED_KEYWORD, LATEINIT_KEYWORD,
DATA_KEYWORD, INLINE_KEYWORD, NOINLINE_KEYWORD, TAILREC_KEYWORD, EXTERNAL_KEYWORD, ANNOTATION_KEYWORD, CROSSINLINE_KEYWORD,
CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD, COROUTINE_KEYWORD, SUSPEND_KEYWORD, PLATFORM_KEYWORD, IMPL_KEYWORD
CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD, COROUTINE_KEYWORD, SUSPEND_KEYWORD, HEADER_KEYWORD, IMPL_KEYWORD
};
TokenSet MODIFIER_KEYWORDS = TokenSet.create(MODIFIER_KEYWORDS_ARRAY);
compiler/frontend/src/org/jetbrains/kotlin/psi/synthetics/SyntheticClassOrObjectDescriptor.kt
+1 -1
View File
@@ -73,7 +73,7 @@ class SyntheticClassOrObjectDescriptor(
override fun isCompanionObject() = isCompanionObject
override fun isInner() = false
override fun isData() = false
override fun isPlatform() = false
override fun isHeader() = false
override fun isImpl() = false
override fun getCompanionObjectDescriptor() = null
compiler/frontend/src/org/jetbrains/kotlin/resolve/BodyResolver.java
+5 -5
View File
@@ -169,8 +169,8 @@ public class BodyResolver {
@NotNull KtSecondaryConstructor constructor,
@NotNull ClassConstructorDescriptor descriptor
) {
if (descriptor.isPlatform()) {
// For platform classes, we do not resolve constructor delegation calls because they are prohibited
if (descriptor.isHeader()) {
// For header classes, we do not resolve constructor delegation calls because they are prohibited
return DataFlowInfo.Companion.getEMPTY();
}
@@ -367,7 +367,7 @@ public class BodyResolver {
descriptor.getUnsubstitutedPrimaryConstructor() != null &&
superClass.getKind() != ClassKind.INTERFACE &&
!superClass.getConstructors().isEmpty() &&
!descriptor.isPlatform() &&
!descriptor.isHeader() &&
!ErrorUtils.isError(superClass)
) {
trace.report(SUPERTYPE_NOT_INITIALIZED.on(specifier));
@@ -562,8 +562,8 @@ public class BodyResolver {
if (classDescriptor.getConstructors().isEmpty()) {
trace.report(ANONYMOUS_INITIALIZER_IN_INTERFACE.on(anonymousInitializer));
}
if (classDescriptor.isPlatform()) {
trace.report(PLATFORM_DECLARATION_WITH_BODY.on(anonymousInitializer));
if (classDescriptor.isHeader()) {
trace.report(HEADER_DECLARATION_WITH_BODY.on(anonymousInitializer));
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationResolver.kt
+4 -4
View File
@@ -78,12 +78,12 @@ class DeclarationResolver(
for ((fqName, declarationsOrPackageDirectives) in topLevelFqNames.asMap()) {
if (fqName.isRoot) continue
// TODO: report error on platform class and impl val, or vice versa
val (platform, impl) =
// TODO: report error on header class and impl val, or vice versa
val (header, impl) =
getTopLevelDescriptorsByFqName(topLevelDescriptorProvider, fqName, NoLookupLocation.WHEN_CHECK_REDECLARATIONS)
.partition { it is MemberDescriptor && it.isPlatform }
.partition { it is MemberDescriptor && it.isHeader }
for (descriptors in listOf(platform, impl)) {
for (descriptors in listOf(header, impl)) {
if (descriptors.size > 1) {
for (directive in declarationsOrPackageDirectives) {
val reportAt = (directive as? KtPackageDirective)?.nameIdentifier ?: directive
compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt
+20 -20
View File
@@ -264,20 +264,20 @@ class DeclarationsChecker(
identifierChecker.checkDeclaration(declaration, trace)
checkVarargParameters(trace, constructorDescriptor)
checkConstructorVisibility(constructorDescriptor, declaration)
checkPlatformClassConstructor(constructorDescriptor, declaration)
checkHeaderClassConstructor(constructorDescriptor, declaration)
}
private fun checkPlatformClassConstructor(constructorDescriptor: ClassConstructorDescriptor, declaration: KtConstructor<*>) {
if (!constructorDescriptor.isPlatform) return
private fun checkHeaderClassConstructor(constructorDescriptor: ClassConstructorDescriptor, declaration: KtConstructor<*>) {
if (!constructorDescriptor.isHeader) return
if (declaration.hasBody()) {
trace.report(PLATFORM_DECLARATION_WITH_BODY.on(declaration))
trace.report(HEADER_DECLARATION_WITH_BODY.on(declaration))
}
if (declaration is KtPrimaryConstructor && !DescriptorUtils.isAnnotationClass(constructorDescriptor.constructedClass)) {
for (parameter in declaration.valueParameters) {
if (parameter.hasValOrVar()) {
trace.report(PLATFORM_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER.on(parameter))
trace.report(HEADER_CLASS_CONSTRUCTOR_PROPERTY_PARAMETER.on(parameter))
}
}
}
@@ -285,7 +285,7 @@ class DeclarationsChecker(
if (declaration is KtSecondaryConstructor) {
val delegationCall = declaration.getDelegationCall()
if (!delegationCall.isImplicit) {
trace.report(PLATFORM_CLASS_CONSTRUCTOR_DELEGATION_CALL.on(delegationCall))
trace.report(HEADER_CLASS_CONSTRUCTOR_DELEGATION_CALL.on(delegationCall))
}
}
}
@@ -703,13 +703,13 @@ class DeclarationsChecker(
val initializer = property.initializer
val delegate = property.delegate
val isPlatform = propertyDescriptor.isPlatform
val isHeader = propertyDescriptor.isHeader
if (initializer != null) {
if (inTrait) {
trace.report(PROPERTY_INITIALIZER_IN_INTERFACE.on(initializer))
}
else if (isPlatform) {
trace.report(PLATFORM_PROPERTY_INITIALIZER.on(initializer))
else if (isHeader) {
trace.report(HEADER_PROPERTY_INITIALIZER.on(initializer))
}
else if (!backingFieldRequired) {
trace.report(PROPERTY_INITIALIZER_NO_BACKING_FIELD.on(initializer))
@@ -726,7 +726,7 @@ class DeclarationsChecker(
else {
val isUninitialized = trace.bindingContext.get(BindingContext.IS_UNINITIALIZED, propertyDescriptor) ?: false
val isExternal = DescriptorUtils.isEffectivelyExternal(propertyDescriptor)
if (backingFieldRequired && !inTrait && !propertyDescriptor.isLateInit && !isPlatform && isUninitialized && !isExternal) {
if (backingFieldRequired && !inTrait && !propertyDescriptor.isLateInit && !isHeader && isUninitialized && !isExternal) {
if (containingDeclaration !is ClassDescriptor || hasAccessorImplementation) {
trace.report(MUST_BE_INITIALIZED.on(property))
}
@@ -766,7 +766,7 @@ class DeclarationsChecker(
if (containingDescriptor is ClassDescriptor) {
val inInterface = containingDescriptor.kind == ClassKind.INTERFACE
val isPlatformClass = containingDescriptor.isPlatform
val isHeaderClass = containingDescriptor.isHeader
if (hasAbstractModifier && !classCanHaveAbstractMembers(containingDescriptor)) {
trace.report(ABSTRACT_FUNCTION_IN_NON_ABSTRACT_CLASS.on(function, functionDescriptor.name.asString(), containingDescriptor))
}
@@ -782,29 +782,29 @@ class DeclarationsChecker(
trace.report(REDUNDANT_OPEN_IN_INTERFACE.on(function))
}
}
if (!hasBody && !hasAbstractModifier && !hasExternalModifier && !inInterface && !isPlatformClass) {
if (!hasBody && !hasAbstractModifier && !hasExternalModifier && !inInterface && !isHeaderClass) {
trace.report(NON_ABSTRACT_FUNCTION_WITH_NO_BODY.on(function, functionDescriptor))
}
}
else /* top-level only */ {
if (!function.hasBody() && !hasAbstractModifier && !hasExternalModifier && !functionDescriptor.isPlatform) {
if (!function.hasBody() && !hasAbstractModifier && !hasExternalModifier && !functionDescriptor.isHeader) {
trace.report(NON_MEMBER_FUNCTION_NO_BODY.on(function, functionDescriptor))
}
}
if (functionDescriptor.isPlatform) {
checkPlatformFunction(function)
if (functionDescriptor.isHeader) {
checkHeaderFunction(function)
}
}
private fun checkPlatformFunction(function: KtNamedFunction) {
private fun checkHeaderFunction(function: KtNamedFunction) {
if (function.hasBody()) {
trace.report(PLATFORM_DECLARATION_WITH_BODY.on(function))
trace.report(HEADER_DECLARATION_WITH_BODY.on(function))
}
for (parameter in function.valueParameters) {
if (parameter.hasDefaultValue()) {
trace.report(PLATFORM_DECLARATION_WITH_DEFAULT_PARAMETER.on(parameter))
trace.report(HEADER_DECLARATION_WITH_DEFAULT_PARAMETER.on(parameter))
}
}
}
@@ -858,8 +858,8 @@ class DeclarationsChecker(
accessorDescriptor: PropertyAccessorDescriptor?
) {
if (accessor == null || accessorDescriptor == null) return
if (propertyDescriptor.isPlatform && accessor.hasBody()) {
trace.report(PLATFORM_DECLARATION_WITH_BODY.on(accessor))
if (propertyDescriptor.isHeader && accessor.hasBody()) {
trace.report(HEADER_DECLARATION_WITH_BODY.on(accessor))
}
val accessorModifierList = accessor.modifierList ?: return
compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java
+3 -3
View File
@@ -820,8 +820,8 @@ public class DescriptorResolver {
KotlinSourceElementKt.toSourceElement(property),
modifierList != null && modifierList.hasModifier(KtTokens.LATEINIT_KEYWORD),
modifierList != null && modifierList.hasModifier(KtTokens.CONST_KEYWORD),
modifierList != null && modifierList.hasModifier(KtTokens.PLATFORM_KEYWORD) ||
containingDeclaration instanceof ClassDescriptor && ((ClassDescriptor) containingDeclaration).isPlatform(),
modifierList != null && modifierList.hasModifier(KtTokens.HEADER_KEYWORD) ||
containingDeclaration instanceof ClassDescriptor && ((ClassDescriptor) containingDeclaration).isHeader(),
modifierList != null && modifierList.hasModifier(KtTokens.IMPL_KEYWORD),
modifierList != null && modifierList.hasModifier(KtTokens.EXTERNAL_KEYWORD)
);
@@ -1141,7 +1141,7 @@ public class DescriptorResolver {
KotlinSourceElementKt.toSourceElement(parameter),
/* lateInit = */ false,
/* isConst = */ false,
/* isPlatform = */ false,
/* isHeader = */ false,
/* isImpl = */ false,
/* isExternal = */ false
);
compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt
+4 -4
View File
@@ -186,8 +186,8 @@ class FunctionDescriptorResolver(
functionDescriptor.isInline = function.hasModifier(KtTokens.INLINE_KEYWORD)
functionDescriptor.isTailrec = function.hasModifier(KtTokens.TAILREC_KEYWORD)
functionDescriptor.isSuspend = function.hasModifier(KtTokens.SUSPEND_KEYWORD)
functionDescriptor.isPlatform = function.hasModifier(KtTokens.PLATFORM_KEYWORD) ||
containingDescriptor is ClassDescriptor && containingDescriptor.isPlatform
functionDescriptor.isHeader = function.hasModifier(KtTokens.HEADER_KEYWORD) ||
containingDescriptor is ClassDescriptor && containingDescriptor.isHeader
functionDescriptor.isImpl = function.hasModifier(KtTokens.IMPL_KEYWORD)
receiverType?.let { ForceResolveUtil.forceResolveAllContents(it.annotations) }
@@ -299,8 +299,8 @@ class FunctionDescriptorResolver(
isPrimary,
declarationToTrace.toSourceElement()
)
if (classDescriptor.isPlatform) {
constructorDescriptor.isPlatform = true
if (classDescriptor.isHeader) {
constructorDescriptor.isHeader = true
}
if (classDescriptor.isImpl) {
constructorDescriptor.isImpl = true
compiler/frontend/src/org/jetbrains/kotlin/resolve/LocalVariableResolver.kt
+1 -1
View File
@@ -147,7 +147,7 @@ class LocalVariableResolver(
variable.toSourceElement(),
/* lateInit = */ false,
/* isConst = */ false,
/* isPlatform = */ false,
/* isHeader = */ false,
/* isImpl = */ false,
/* isExternal = */ false
)
compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt
+2 -2
View File
@@ -90,7 +90,7 @@ object ModifierCheckerCore {
CONST_KEYWORD to EnumSet.of(MEMBER_PROPERTY, TOP_LEVEL_PROPERTY),
OPERATOR_KEYWORD to EnumSet.of(FUNCTION),
INFIX_KEYWORD to EnumSet.of(FUNCTION),
PLATFORM_KEYWORD to EnumSet.of(TOP_LEVEL_FUNCTION, TOP_LEVEL_PROPERTY_WITHOUT_FIELD_OR_DELEGATE, CLASS_ONLY, OBJECT, INTERFACE, INNER_CLASS, ENUM_CLASS, ANNOTATION_CLASS),
HEADER_KEYWORD to EnumSet.of(TOP_LEVEL_FUNCTION, TOP_LEVEL_PROPERTY_WITHOUT_FIELD_OR_DELEGATE, CLASS_ONLY, OBJECT, INTERFACE, INNER_CLASS, ENUM_CLASS, ANNOTATION_CLASS),
IMPL_KEYWORD to EnumSet.of(TOP_LEVEL_FUNCTION, MEMBER_FUNCTION, TOP_LEVEL_PROPERTY, MEMBER_PROPERTY, CONSTRUCTOR, CLASS_ONLY, OBJECT, INTERFACE, INNER_CLASS, ENUM_CLASS, ANNOTATION_CLASS, TYPEALIAS)
)
@@ -98,7 +98,7 @@ object ModifierCheckerCore {
COROUTINE_KEYWORD to LanguageFeature.Coroutines,
SUSPEND_KEYWORD to LanguageFeature.Coroutines,
INLINE_KEYWORD to LanguageFeature.InlineProperties,
PLATFORM_KEYWORD to LanguageFeature.MultiPlatformProjects,
HEADER_KEYWORD to LanguageFeature.MultiPlatformProjects,
IMPL_KEYWORD to LanguageFeature.MultiPlatformProjects
)
compiler/frontend/src/org/jetbrains/kotlin/resolve/OverloadResolver.kt
+4 -4
View File
@@ -253,7 +253,7 @@ class OverloadResolver(
if (isConstructorsOfDifferentRedeclaredClasses(member1, member2)) continue
if (isTopLevelMainInDifferentFiles(member1, member2)) continue
if (isDefinitionsForDifferentPlatforms(member1, member2)) continue
if (isPlatformDeclarationAndDefinition(member1, member2) || isPlatformDeclarationAndDefinition(member2, member1)) continue
if (isHeaderDeclarationAndDefinition(member1, member2) || isHeaderDeclarationAndDefinition(member2, member1)) continue
if (!overloadChecker.isOverloadable(member1, member2)) {
redeclarations.add(member1)
@@ -283,9 +283,9 @@ class OverloadResolver(
return file1 == null || file2 == null || file1 !== file2
}
private fun isPlatformDeclarationAndDefinition(declaration: DeclarationDescriptor, definition: DeclarationDescriptor): Boolean {
return declaration is MemberDescriptor && declaration.isPlatform &&
definition is MemberDescriptor && !definition.isPlatform
private fun isHeaderDeclarationAndDefinition(declaration: DeclarationDescriptor, definition: DeclarationDescriptor): Boolean {
return declaration is MemberDescriptor && declaration.isHeader &&
definition is MemberDescriptor && !definition.isHeader
}
private fun isDefinitionsForDifferentPlatforms(member1: DeclarationDescriptorNonRoot, member2: DeclarationDescriptorNonRoot): Boolean {
compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt
+1 -1
View File
@@ -98,7 +98,7 @@ class DynamicCallableDescriptors(storageManager: StorageManager, builtIns: Kotli
SourceElement.NO_SOURCE,
/* lateInit = */ false,
/* isConst = */ false,
/* isPlatform = */ false,
/* isHeader = */ false,
/* isImpl = */ false,
/* isExternal = */ false
)
compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/PlatformImplDeclarationChecker.kt → compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/HeaderImplDeclarationChecker.kt
+13 -13
View File
@@ -28,8 +28,8 @@ import org.jetbrains.kotlin.psi.KtDeclaration
import org.jetbrains.kotlin.psi.KtElement
import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
import org.jetbrains.kotlin.resolve.checkers.PlatformImplDeclarationChecker.Compatibility.Compatible
import org.jetbrains.kotlin.resolve.checkers.PlatformImplDeclarationChecker.Compatibility.Incompatible
import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker.Compatibility.Compatible
import org.jetbrains.kotlin.resolve.checkers.HeaderImplDeclarationChecker.Compatibility.Incompatible
import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe
import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameUnsafe
import org.jetbrains.kotlin.resolve.descriptorUtil.module
@@ -43,7 +43,7 @@ import org.jetbrains.kotlin.types.typeUtil.asTypeProjection
import org.jetbrains.kotlin.utils.SmartList
import org.jetbrains.kotlin.utils.keysToMap
class PlatformImplDeclarationChecker : DeclarationChecker {
class HeaderImplDeclarationChecker : DeclarationChecker {
override fun check(
declaration: KtDeclaration,
descriptor: DeclarationDescriptor,
@@ -55,16 +55,16 @@ class PlatformImplDeclarationChecker : DeclarationChecker {
if (descriptor !is MemberDescriptor) return
if (descriptor.isPlatform && declaration.hasModifier(KtTokens.PLATFORM_KEYWORD)) {
if (descriptor.isHeader && declaration.hasModifier(KtTokens.HEADER_KEYWORD)) {
val checkImpl = !languageVersionSettings.supportsFeature(LanguageFeature.MultiPlatformDoNotCheckImpl)
checkPlatformDeclarationHasDefinition(declaration, descriptor, diagnosticHolder, checkImpl)
checkHeaderDeclarationHasImplementation(declaration, descriptor, diagnosticHolder, checkImpl)
}
else if (descriptor.isImpl && declaration.hasModifier(KtTokens.IMPL_KEYWORD)) {
checkImplementationHasPlatformDeclaration(declaration, descriptor, diagnosticHolder)
checkImplementationHasHeaderDeclaration(declaration, descriptor, diagnosticHolder)
}
}
private fun checkPlatformDeclarationHasDefinition(
private fun checkHeaderDeclarationHasImplementation(
reportOn: KtDeclaration, descriptor: MemberDescriptor, diagnosticHolder: DiagnosticSink, checkImpl: Boolean
) {
val compatibility = when (descriptor) {
@@ -92,17 +92,17 @@ class PlatformImplDeclarationChecker : DeclarationChecker {
assert(compatibility.keys.all { it is Incompatible })
@Suppress("UNCHECKED_CAST")
val incompatibility = compatibility as Map<Incompatible, Collection<MemberDescriptor>>
diagnosticHolder.report(Errors.PLATFORM_DECLARATION_WITHOUT_DEFINITION.on(reportOn, descriptor, incompatibility))
diagnosticHolder.report(Errors.HEADER_WITHOUT_IMPLEMENTATION.on(reportOn, descriptor, incompatibility))
}
}
private fun checkImplementationHasPlatformDeclaration(
private fun checkImplementationHasHeaderDeclaration(
reportOn: KtDeclaration, descriptor: MemberDescriptor, diagnosticHolder: DiagnosticSink
) {
fun ClassifierDescriptor.findDeclarationForClass(): ClassDescriptor? =
findClassifiersFromTheSameModule().firstOrNull { declaration ->
this != declaration &&
declaration is ClassDescriptor && declaration.isPlatform &&
declaration is ClassDescriptor && declaration.isHeader &&
areCompatibleClassifiers(declaration, this, checkImpl = false) == Compatible
} as? ClassDescriptor
@@ -116,7 +116,7 @@ class PlatformImplDeclarationChecker : DeclarationChecker {
}
candidates.any { declaration ->
descriptor != declaration &&
declaration.isPlatform &&
declaration.isHeader &&
areCompatibleCallables(declaration, descriptor, checkImpl = false) == Compatible
}
}
@@ -125,8 +125,8 @@ class PlatformImplDeclarationChecker : DeclarationChecker {
}
if (!hasDeclaration) {
// TODO: do not report this error for members which are "almost compatible" with some platform declarations
diagnosticHolder.report(Errors.PLATFORM_DEFINITION_WITHOUT_DECLARATION.on(reportOn.modifierList!!.getModifier(KtTokens.IMPL_KEYWORD)!!))
// TODO: do not report this error for members which are "almost compatible" with some header declarations
diagnosticHolder.report(Errors.IMPLEMENTATION_WITHOUT_HEADER.on(reportOn.modifierList!!.getModifier(KtTokens.IMPL_KEYWORD)!!))
}
}
compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineAnalyzerExtension.kt
+1 -1
View File
@@ -141,7 +141,7 @@ object InlineAnalyzerExtension : AnalyzerExtensions.AnalyzerExtension {
if (InlineUtil.containsReifiedTypeParameters(functionDescriptor) ||
functionDescriptor.isInlineOnlyOrReified() ||
functionDescriptor.isPlatform) return
functionDescriptor.isHeader) return
val reportOn = function.modifierList?.getModifier(KtTokens.INLINE_KEYWORD) ?: function
trace.report(Errors.NOTHING_TO_INLINE.on(reportOn, functionDescriptor))
compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java
+4 -4
View File
@@ -93,7 +93,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
private final ClassKind kind;
private final boolean isInner;
private final boolean isData;
private final boolean isPlatform;
private final boolean isHeader;
private final boolean isImpl;
private final Annotations annotations;
@@ -177,7 +177,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
this.isInner = isInnerClass(modifierList) && !ModifiersChecker.isIllegalInner(this);
this.isData = modifierList != null && modifierList.hasModifier(KtTokens.DATA_KEYWORD);
this.isPlatform = modifierList != null && modifierList.hasModifier(KtTokens.PLATFORM_KEYWORD);
this.isHeader = modifierList != null && modifierList.hasModifier(KtTokens.HEADER_KEYWORD);
this.isImpl = modifierList != null && modifierList.hasModifier(KtTokens.IMPL_KEYWORD);
// Annotation entries are taken from both own annotations (if any) and object literal annotations (if any)
@@ -529,8 +529,8 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes
}
@Override
public boolean isPlatform() {
return isPlatform;
public boolean isHeader() {
return isHeader;
}
@Override