diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InconsistentOperatorFromJavaCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InconsistentOperatorFromJavaCallChecker.kt index da3d02a7d2c..2e3b44bdc83 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InconsistentOperatorFromJavaCallChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InconsistentOperatorFromJavaCallChecker.kt @@ -37,13 +37,7 @@ object InconsistentOperatorFromJavaCallChecker : CallChecker { val containingClass = callableDescriptor.containingDeclaration as? ClassDescriptor ?: continue if (containingClass.fqNameOrNull() != CONCURRENT_HASH_MAP_FQ_NAME) continue - val diagnosticFactory = - if (context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitConcurrentHashMapContains)) - ErrorsJvm.CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR - else - ErrorsJvm.CONCURRENT_HASH_MAP_CONTAINS_OPERATOR - - context.trace.report(diagnosticFactory.on(reportOn)) + context.trace.report(ErrorsJvm.CONCURRENT_HASH_MAP_CONTAINS_OPERATOR.on(context.languageVersionSettings, reportOn)) break } } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InterfaceDefaultMethodCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InterfaceDefaultMethodCallChecker.kt index d2c03b4f971..f0a7f0cb0ae 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InterfaceDefaultMethodCallChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/InterfaceDefaultMethodCallChecker.kt @@ -51,8 +51,7 @@ class InterfaceDefaultMethodCallChecker(val jvmTarget: JvmTarget) : CallChecker isStaticDeclaration(descriptor) && isInterface(descriptor.containingDeclaration) && descriptor is JavaCallableMemberDescriptor) { - val diagnostic = if (isDefaultCallsProhibited(context)) INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_ERROR else INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET - context.trace.report(diagnostic.on(reportOn)) + context.trace.report(INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET.on(context.languageVersionSettings, reportOn)) } val superCallExpression = getSuperCallExpression(resolvedCall.call) ?: return @@ -76,9 +75,7 @@ class InterfaceDefaultMethodCallChecker(val jvmTarget: JvmTarget) : CallChecker } if (!supportDefaults) { - val diagnostic = - if (isDefaultCallsProhibited(context)) DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_ERROR else DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET - context.trace.report(diagnostic.on(reportOn)) + context.trace.report(DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET.on(context.languageVersionSettings, reportOn)) } } } @@ -104,8 +101,6 @@ class InterfaceDefaultMethodCallChecker(val jvmTarget: JvmTarget) : CallChecker return null } - private fun isDefaultCallsProhibited(context: CallCheckerContext) = - context.languageVersionSettings.supportsFeature(LanguageFeature.DefaultMethodsCallFromJava6TargetError) private fun getSuperCallLabelTarget( bindingContext: BindingContext, diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/PolymorphicSignatureCallChecker.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/PolymorphicSignatureCallChecker.kt index 599055f3ccc..be5261729dd 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/PolymorphicSignatureCallChecker.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/PolymorphicSignatureCallChecker.kt @@ -26,12 +26,7 @@ object PolymorphicSignatureCallChecker : CallChecker { if (valueArgument !is VarargValueArgument) continue for (argument in valueArgument.arguments) { val spread = argument.getSpreadElement() ?: continue - val diagnostic = - if (context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitSpreadOnSignaturePolymorphicCall)) - ErrorsJvm.SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_ERROR - else - ErrorsJvm.SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL - context.trace.report(diagnostic.on(spread)) + context.trace.report(ErrorsJvm.SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL.on(context.languageVersionSettings, spread)) } } } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt index cead9374ef9..aa35cc2bcde 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/checkers/declarationCheckers.kt @@ -235,13 +235,7 @@ class OverloadsAnnotationChecker : DeclarationChecker { diagnosticHolder.report(ErrorsJvm.OVERLOADS_LOCAL.on(annotationEntry)) descriptor.isAnnotationConstructor() -> { - val diagnostic = - if (context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses)) - ErrorsJvm.OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR - else - ErrorsJvm.OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_WARNING - - diagnosticHolder.report(diagnostic.on(annotationEntry)) + diagnosticHolder.report(ErrorsJvm.OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR.on(context.languageVersionSettings, annotationEntry)) } !descriptor.visibility.isPublicAPI && descriptor.visibility != DescriptorVisibilities.INTERNAL -> diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java index 011803d750f..a632f843203 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/DefaultErrorMessagesJvm.java @@ -51,7 +51,6 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension { MAP.put(OVERLOADS_INTERFACE, "'@JvmOverloads' annotation cannot be used on interface methods"); MAP.put(OVERLOADS_PRIVATE, "'@JvmOverloads' annotation has no effect on private declarations"); MAP.put(OVERLOADS_LOCAL, "'@JvmOverloads' annotation cannot be used on local declarations"); - MAP.put(OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_WARNING, "'@JvmOverloads' annotation on constructors of annotation classes is deprecated"); MAP.put(OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR, "'@JvmOverloads' annotation cannot be used on constructors of annotation classes"); MAP.put(OVERLOADS_ANNOTATION_HIDDEN_CONSTRUCTOR, "'@JvmOverloads' annotation cannot be used on constructors hidden by inline class rules"); MAP.put(OVERLOADS_ANNOTATION_MANGLED_FUNCTION, "'@JvmOverloads' annotation cannot be used on functions mangled by inline class rules"); @@ -147,10 +146,8 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension { "Please make explicit overrides (abstract or concrete) for the following non-abstract members of ''{1}'': {2}", NAME, NAME, STRING); - MAP.put(DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET, "Super calls to Java default methods are deprecated in JVM target 1.6. Recompile with '-jvm-target 1.8'"); - MAP.put(DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_ERROR, "Super calls to Java default methods are prohibited in JVM target 1.6. Recompile with '-jvm-target 1.8'"); - MAP.put(INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET, "Calls to static methods in Java interfaces are deprecated in JVM target 1.6. Recompile with '-jvm-target 1.8'"); - MAP.put(INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_ERROR, "Calls to static methods in Java interfaces are prohibited in JVM target 1.6. Recompile with '-jvm-target 1.8'"); + MAP.put(DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET, "Super calls to Java default methods are prohibited in JVM target 1.6. Recompile with '-jvm-target 1.8'"); + MAP.put(INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET, "Calls to static methods in Java interfaces are prohibited in JVM target 1.6. Recompile with '-jvm-target 1.8'"); MAP.put(INLINE_FROM_HIGHER_PLATFORM, "Cannot inline bytecode built with {0} into bytecode that is being built with {1}. Please specify proper ''-jvm-target'' option", STRING, STRING); MAP.put(INLINE_FROM_HIGHER_PLATFORM_WARNING, "Cannot inline bytecode built with {0} into bytecode that is being built with {1}. Please specify proper ''-jvm-target'' option", STRING, STRING); @@ -195,12 +192,10 @@ public class DefaultErrorMessagesJvm implements DefaultErrorMessages.Extension { "Use explicit form of the call to 'containsKey'/'containsValue'/'contains' or cast the value to kotlin.collections.Map instead. " + "See https://youtrack.jetbrains.com/issue/KT-18053 for more details"; MAP.put(CONCURRENT_HASH_MAP_CONTAINS_OPERATOR, MESSAGE_FOR_CONCURRENT_HASH_MAP_CONTAINS); - MAP.put(CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR, MESSAGE_FOR_CONCURRENT_HASH_MAP_CONTAINS); MAP.put(TAILREC_WITH_DEFAULTS, "Computation order of non-constant default arguments in tail-recursive functions will change in 1.4. See KT-31540 for more details"); String spreadOnPolymorphicSignature = "Spread operator is prohibited for arguments to signature-polymorphic calls"; MAP.put(SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL, spreadOnPolymorphicSignature); - MAP.put(SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_ERROR, spreadOnPolymorphicSignature); MAP.put(FUNCTION_DELEGATE_MEMBER_NAME_CLASH, "Functional interface member cannot have this name on JVM because it clashes with an internal member getFunctionDelegate"); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java index d74e6ec1e79..743af97e12e 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/diagnostics/ErrorsJvm.java @@ -6,6 +6,7 @@ package org.jetbrains.kotlin.resolve.jvm.diagnostics; import com.intellij.psi.PsiElement; +import org.jetbrains.kotlin.config.LanguageFeature; import org.jetbrains.kotlin.descriptors.CallableDescriptor; import org.jetbrains.kotlin.descriptors.ClassifierDescriptor; import org.jetbrains.kotlin.descriptors.DeclarationDescriptor; @@ -58,8 +59,7 @@ public interface ErrorsJvm { DiagnosticFactory0 OVERLOADS_INTERFACE = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 OVERLOADS_PRIVATE = DiagnosticFactory0.create(WARNING); DiagnosticFactory0 OVERLOADS_LOCAL = DiagnosticFactory0.create(ERROR); - DiagnosticFactory0 OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR_WARNING = DiagnosticFactory0.create(WARNING); - DiagnosticFactory0 OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR = DiagnosticFactory0.create(ERROR); + DiagnosticFactoryForDeprecation0 OVERLOADS_ANNOTATION_CLASS_CONSTRUCTOR = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses); DiagnosticFactory0 OVERLOADS_ANNOTATION_MANGLED_FUNCTION = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 OVERLOADS_ANNOTATION_HIDDEN_CONSTRUCTOR = DiagnosticFactory0.create(ERROR); @@ -113,10 +113,8 @@ public interface ErrorsJvm { DiagnosticFactory3 TARGET6_INTERFACE_INHERITANCE = DiagnosticFactory3.create(ERROR); - DiagnosticFactory0 DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET = DiagnosticFactory0.create(WARNING); - DiagnosticFactory0 DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET_ERROR = DiagnosticFactory0.create(ERROR); - DiagnosticFactory0 INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET = DiagnosticFactory0.create(WARNING); - DiagnosticFactory0 INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET_ERROR = DiagnosticFactory0.create(ERROR); + DiagnosticFactoryForDeprecation0 DEFAULT_METHOD_CALL_FROM_JAVA6_TARGET = DiagnosticFactoryForDeprecation0.create(LanguageFeature.DefaultMethodsCallFromJava6TargetError); + DiagnosticFactoryForDeprecation0 INTERFACE_STATIC_METHOD_CALL_FROM_JAVA6_TARGET = DiagnosticFactoryForDeprecation0.create(LanguageFeature.DefaultMethodsCallFromJava6TargetError); DiagnosticFactory2 INLINE_FROM_HIGHER_PLATFORM = DiagnosticFactory2.create(ERROR); DiagnosticFactory2 INLINE_FROM_HIGHER_PLATFORM_WARNING = DiagnosticFactory2.create(WARNING); @@ -175,13 +173,11 @@ public interface ErrorsJvm { DiagnosticFactory1 SUSPENSION_POINT_INSIDE_MONITOR = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 SUSPENSION_POINT_INSIDE_CRITICAL_SECTION = DiagnosticFactory1.create(ERROR); - DiagnosticFactory0 CONCURRENT_HASH_MAP_CONTAINS_OPERATOR = DiagnosticFactory0.create(WARNING); - DiagnosticFactory0 CONCURRENT_HASH_MAP_CONTAINS_OPERATOR_ERROR = DiagnosticFactory0.create(ERROR); + DiagnosticFactoryForDeprecation0 CONCURRENT_HASH_MAP_CONTAINS_OPERATOR = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitConcurrentHashMapContains); DiagnosticFactory0 TAILREC_WITH_DEFAULTS = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE); - DiagnosticFactory0 SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL = DiagnosticFactory0.create(WARNING); - DiagnosticFactory0 SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL_ERROR = DiagnosticFactory0.create(ERROR); + DiagnosticFactoryForDeprecation0 SPREAD_ON_SIGNATURE_POLYMORPHIC_CALL = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitSpreadOnSignaturePolymorphicCall); DiagnosticFactory0 FUNCTION_DELEGATE_MEMBER_NAME_CLASH = DiagnosticFactory0.create(ERROR); diff --git a/compiler/frontend/cfg/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProviderImpl.kt b/compiler/frontend/cfg/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProviderImpl.kt index 5a5aecbe244..fa05a324898 100644 --- a/compiler/frontend/cfg/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProviderImpl.kt +++ b/compiler/frontend/cfg/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProviderImpl.kt @@ -554,12 +554,7 @@ class ControlFlowInformationProviderImpl private constructor( } private fun reportValReassigned(expression: KtExpression, variableDescriptor: VariableDescriptor, ctxt: VariableInitContext) { - val diagnosticFactory = if (languageVersionSettings.supportsFeature(LanguageFeature.RestrictionOfValReassignmentViaBackingField)) - VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR - else - VAL_REASSIGNMENT_VIA_BACKING_FIELD - - report(diagnosticFactory.on(expression, variableDescriptor), ctxt) + report(VAL_REASSIGNMENT_VIA_BACKING_FIELD.on(languageVersionSettings, expression, variableDescriptor), ctxt) } private fun checkAssignmentBeforeDeclaration(ctxt: VariableInitContext, expression: KtExpression) = diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index d0b731f4725..bd601504a29 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -246,8 +246,7 @@ public interface Errors { // Annotations DiagnosticFactory0 SUPERTYPES_FOR_ANNOTATION_CLASS = DiagnosticFactory0.create(ERROR); - DiagnosticFactory0 ANNOTATION_ON_SUPERCLASS = DiagnosticFactory0.create(ERROR); - DiagnosticFactory0 ANNOTATION_ON_SUPERCLASS_WARNING = DiagnosticFactory0.create(WARNING); + DiagnosticFactoryForDeprecation0 ANNOTATION_ON_SUPERCLASS = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitUseSiteTargetAnnotationsOnSuperTypes); DiagnosticFactory0 MISSING_VAL_ON_ANNOTATION_PARAMETER = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 VAR_ANNOTATION_PARAMETER = DiagnosticFactory0.create(ERROR, VAL_OR_VAR_NODE); DiagnosticFactory0 ANNOTATION_CLASS_CONSTRUCTOR_CALL = DiagnosticFactory0.create(ERROR); @@ -265,11 +264,9 @@ public interface Errors { DiagnosticFactory0 ANNOTATION_USED_AS_ANNOTATION_ARGUMENT = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 ANNOTATION_ARGUMENT_IS_NON_CONST = DiagnosticFactory0.create(WARNING); - DiagnosticFactory0 RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION = DiagnosticFactory0.create(ERROR); - DiagnosticFactory0 RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION_WARNING = DiagnosticFactory0.create(WARNING); + DiagnosticFactoryForDeprecation0 RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION = DiagnosticFactoryForDeprecation0.create(LanguageFeature.RestrictRetentionForExpressionAnnotations); - DiagnosticFactory0 LOCAL_ANNOTATION_CLASS = DiagnosticFactory0.create(WARNING); - DiagnosticFactory0 LOCAL_ANNOTATION_CLASS_ERROR = DiagnosticFactory0.create(ERROR); + DiagnosticFactoryForDeprecation0 LOCAL_ANNOTATION_CLASS = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitLocalAnnotations); DiagnosticFactory1 ILLEGAL_KOTLIN_VERSION_STRING_VALUE = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 NEWER_VERSION_IN_SINCE_KOTLIN = DiagnosticFactory1.create(WARNING); @@ -448,8 +445,7 @@ public interface Errors { // Companion objects DiagnosticFactory0 MANY_COMPANION_OBJECTS = DiagnosticFactory0.create(ERROR, COMPANION_OBJECT); - DiagnosticFactory0 SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_WARNING = DiagnosticFactory0.create(WARNING); - DiagnosticFactory0 SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR = DiagnosticFactory0.create(ERROR); + DiagnosticFactoryForDeprecation0 SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitSelfCallsInNestedObjects); // Objects @@ -510,10 +506,9 @@ public interface Errors { DiagnosticFactory2 DATA_CLASS_OVERRIDE_CONFLICT = DiagnosticFactory2.create(ERROR); - DiagnosticFactory2 DATA_CLASS_OVERRIDE_DEFAULT_VALUES_WARNING = - DiagnosticFactory2.create(WARNING); - DiagnosticFactory2 DATA_CLASS_OVERRIDE_DEFAULT_VALUES_ERROR = - DiagnosticFactory2.create(ERROR); + DiagnosticFactoryForDeprecation2 DATA_CLASS_OVERRIDE_DEFAULT_VALUES = + DiagnosticFactoryForDeprecation2.create(LanguageFeature.ProhibitDataClassesOverridingCopy); + // DiagnosticFactory2.create(ERROR); DiagnosticFactory1 CANNOT_INFER_VISIBILITY = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE_OR_DEFAULT); @@ -562,10 +557,8 @@ public interface Errors { DiagnosticFactory2.create(ERROR, DECLARATION_NAME); DiagnosticFactory2 MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED_WARNING = DiagnosticFactory2.create(WARNING, DECLARATION_NAME); - DiagnosticFactory2> INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER = - DiagnosticFactory2.create(ERROR, DECLARATION_NAME); - DiagnosticFactory2> INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING = - DiagnosticFactory2.create(WARNING, DECLARATION_NAME); + DiagnosticFactoryForDeprecation2> INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER = + DiagnosticFactoryForDeprecation2.create(LanguageFeature.ProhibitInvisibleAbstractMethodsInSuperclasses, DECLARATION_NAME); DiagnosticFactory1> AMBIGUOUS_ANONYMOUS_TYPE_INFERRED = DiagnosticFactory1.create(ERROR, DECLARATION_SIGNATURE); @@ -644,8 +637,7 @@ public interface Errors { DiagnosticFactory0 VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 NO_TAIL_CALLS_FOUND = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE); - DiagnosticFactory0 TAILREC_ON_VIRTUAL_MEMBER = DiagnosticFactory0.create(WARNING, DECLARATION_SIGNATURE); - DiagnosticFactory0 TAILREC_ON_VIRTUAL_MEMBER_ERROR = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE); + DiagnosticFactoryForDeprecation0 TAILREC_ON_VIRTUAL_MEMBER = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitTailrecOnVirtualMember, DECLARATION_SIGNATURE); DiagnosticFactory0 ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE = DiagnosticFactory0.create(ERROR, PARAMETER_DEFAULT_VALUE); @@ -769,11 +761,9 @@ public interface Errors { DiagnosticFactory1 MISSING_RECEIVER = DiagnosticFactory1.create(ERROR); DiagnosticFactory0 NO_RECEIVER_ALLOWED = DiagnosticFactory0.create(ERROR); - DiagnosticFactory1 ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION = DiagnosticFactory1.create(WARNING); - DiagnosticFactory1 ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR = DiagnosticFactory1.create(ERROR); + DiagnosticFactoryForDeprecation1 ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION = DiagnosticFactoryForDeprecation1.create(LanguageFeature.ProhibitAssigningSingleElementsToVarargsInNamedForm); DiagnosticFactory0 REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_FUNCTION = DiagnosticFactory0.create(WARNING); - DiagnosticFactory0 ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION = DiagnosticFactory0.create(WARNING); - DiagnosticFactory0 ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_ERROR = DiagnosticFactory0.create(ERROR); + DiagnosticFactoryForDeprecation0 ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION = DiagnosticFactoryForDeprecation0.create(LanguageFeature.ProhibitAssigningSingleElementsToVarargsInNamedForm); DiagnosticFactory0 REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION = DiagnosticFactory0.create(WARNING); // Call resolution @@ -797,8 +787,7 @@ public interface Errors { DiagnosticFactory1> CALLABLE_REFERENCE_RESOLUTION_AMBIGUITY = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 TYPE_PARAMETER_AS_REIFIED = DiagnosticFactory1.create(ERROR); - DiagnosticFactory1 TYPE_PARAMETER_AS_REIFIED_ARRAY = DiagnosticFactory1.create(ERROR); - DiagnosticFactory1 TYPE_PARAMETER_AS_REIFIED_ARRAY_WARNING = DiagnosticFactory1.create(WARNING); + DiagnosticFactoryForDeprecation1 TYPE_PARAMETER_AS_REIFIED_ARRAY = DiagnosticFactoryForDeprecation1.create(LanguageFeature.ProhibitNonReifiedArraysAsReifiedTypeArguments); DiagnosticFactory1 REIFIED_TYPE_FORBIDDEN_SUBSTITUTION = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 REIFIED_TYPE_UNSAFE_SUBSTITUTION = DiagnosticFactory1.create(WARNING); DiagnosticFactory0 CANDIDATE_CHOSEN_USING_OVERLOAD_RESOLUTION_BY_LAMBDA_ANNOTATION = DiagnosticFactory0.create(WARNING); @@ -985,8 +974,7 @@ public interface Errors { DiagnosticFactory0 UNUSED_LAMBDA_EXPRESSION = DiagnosticFactory0.create(WARNING); DiagnosticFactory1 VAL_REASSIGNMENT = DiagnosticFactory1.create(ERROR); - DiagnosticFactory1 VAL_REASSIGNMENT_VIA_BACKING_FIELD = DiagnosticFactory1.create(WARNING); - DiagnosticFactory1 VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR = DiagnosticFactory1.create(ERROR); + DiagnosticFactoryForDeprecation1 VAL_REASSIGNMENT_VIA_BACKING_FIELD = DiagnosticFactoryForDeprecation1.create(LanguageFeature.RestrictionOfValReassignmentViaBackingField); DiagnosticFactory1 CAPTURED_VAL_INITIALIZATION = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 CAPTURED_MEMBER_VAL_INITIALIZATION = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 SETTER_PROJECTED_OUT = DiagnosticFactory1.create(ERROR); @@ -1165,9 +1153,8 @@ public interface Errors { DiagnosticFactory0 NON_LOCAL_RETURN_IN_DISABLED_INLINE = DiagnosticFactory0.create(ERROR); DiagnosticFactory0 INLINE_PROPERTY_WITH_BACKING_FIELD = DiagnosticFactory0.create(ERROR, DECLARATION_SIGNATURE); DiagnosticFactory0 NON_INTERNAL_PUBLISHED_API = DiagnosticFactory0.create(ERROR); - DiagnosticFactory1 PROTECTED_CALL_FROM_PUBLIC_INLINE = DiagnosticFactory1.create(WARNING); + DiagnosticFactoryForDeprecation1 PROTECTED_CALL_FROM_PUBLIC_INLINE = DiagnosticFactoryForDeprecation1.create(LanguageFeature.ProhibitProtectedCallFromInline); DiagnosticFactory1 PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE = DiagnosticFactory1.create(WARNING); - DiagnosticFactory1 PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR = DiagnosticFactory1.create(ERROR); DiagnosticFactory1 SUPER_CALL_FROM_PUBLIC_INLINE = DiagnosticFactory1.create(WARNING); DiagnosticFactory2 INVALID_DEFAULT_FUNCTIONAL_PARAMETER_FOR_INLINE = DiagnosticFactory2.create(ERROR); DiagnosticFactory2 NOT_SUPPORTED_INLINE_PARAMETER_IN_INLINE_PARAMETER_DEFAULT_VALUE = DiagnosticFactory2.create(ERROR); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index bcf4dc8b728..9fd46c5ed52 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -333,8 +333,7 @@ public class DefaultErrorMessages { MAP.put(VIRTUAL_MEMBER_HIDDEN, "''{0}'' hides member of supertype ''{2}'' and needs ''override'' modifier", NAME, NAME, NAME); MAP.put(DATA_CLASS_OVERRIDE_CONFLICT, "Function ''{0}'' generated for the data class conflicts with member of supertype ''{1}''", NAME, NAME); - MAP.put(DATA_CLASS_OVERRIDE_DEFAULT_VALUES_WARNING, "Function ''{0}'' generated for the data class has default values for parameters, and conflicts with member of supertype ''{1}''", NAME, NAME); - MAP.put(DATA_CLASS_OVERRIDE_DEFAULT_VALUES_ERROR, "Function ''{0}'' generated for the data class has default values for parameters, and conflicts with member of supertype ''{1}''", NAME, NAME); + MAP.put(DATA_CLASS_OVERRIDE_DEFAULT_VALUES, "Function ''{0}'' generated for the data class has default values for parameters, and conflicts with member of supertype ''{1}''", NAME, NAME); MAP.put(CANNOT_OVERRIDE_INVISIBLE_MEMBER, "''{0}'' has no access to ''{1}'', so it cannot override it", FQ_NAMES_IN_TYPES, FQ_NAMES_IN_TYPES); @@ -358,8 +357,7 @@ public class DefaultErrorMessages { MAP.put(UNUSED_LAMBDA_EXPRESSION, "The lambda expression is unused. If you mean a block, you can use 'run { ... }'"); MAP.put(VAL_REASSIGNMENT, "Val cannot be reassigned", NAME); - MAP.put(VAL_REASSIGNMENT_VIA_BACKING_FIELD, "Reassignment of read-only property via backing field is deprecated", NAME); - MAP.put(VAL_REASSIGNMENT_VIA_BACKING_FIELD_ERROR, "Reassignment of read-only property via backing field", NAME); + MAP.put(VAL_REASSIGNMENT_VIA_BACKING_FIELD, "Reassignment of read-only property via backing field", NAME); MAP.put(CAPTURED_VAL_INITIALIZATION, "Captured values initialization is forbidden due to possible reassignment", NAME); MAP.put(CAPTURED_MEMBER_VAL_INITIALIZATION, "Captured member values initialization is forbidden due to possible reassignment", NAME); MAP.put(SETTER_PROJECTED_OUT, "Setter for ''{0}'' is removed by type projection", NAME); @@ -377,7 +375,6 @@ public class DefaultErrorMessages { MAP.put(MANY_COMPANION_OBJECTS, "Only one companion object is allowed per class"); - MAP.put(SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_WARNING, "Self references to members of containing class are prohibited in constructor of nested object"); MAP.put(SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR, "Self references to members of containing class are prohibited in constructor of nested object"); MAP.put(DEPRECATION, "''{0}'' is deprecated. {1}", DEPRECATION_RENDERER, STRING); @@ -680,8 +677,7 @@ public class DefaultErrorMessages { MAP.put(ILLEGAL_SELECTOR, "The expression cannot be a selector (occur after a dot)"); MAP.put(NO_TAIL_CALLS_FOUND, "A function is marked as tail-recursive but no tail calls are found"); - MAP.put(TAILREC_ON_VIRTUAL_MEMBER, "Tailrec on open members is deprecated"); - MAP.put(TAILREC_ON_VIRTUAL_MEMBER_ERROR, "Tailrec is not allowed on open members"); + MAP.put(TAILREC_ON_VIRTUAL_MEMBER, "Tailrec is not allowed on open members"); MAP.put(VALUE_PARAMETER_WITH_NO_TYPE_ANNOTATION, "A type annotation is required on a value parameter"); MAP.put(BREAK_OR_CONTINUE_OUTSIDE_A_LOOP, "'break' and 'continue' are only allowed inside a loop"); @@ -877,7 +873,6 @@ public class DefaultErrorMessages { MAP.put(MANY_INTERFACES_MEMBER_NOT_IMPLEMENTED_WARNING, "Deprecated: {0} must override {1} because it inherits multiple interface methods of it", RENDER_CLASS_OR_OBJECT, FQ_NAMES_IN_TYPES); MAP.put(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER, "{0} inherits invisible abstract members: {1}", NAME, commaSeparated(FQ_NAMES_IN_TYPES)); - MAP.put(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING, "{0} inherits invisible abstract members: {1}", NAME, commaSeparated(FQ_NAMES_IN_TYPES)); MAP.put(CONFLICTING_OVERLOADS, "Conflicting overloads: {0}", commaSeparated(FQ_NAMES_IN_TYPES)); @@ -910,11 +905,9 @@ public class DefaultErrorMessages { MAP.put(NO_VALUE_FOR_PARAMETER, "No value passed for parameter ''{0}''", NAME); MAP.put(MISSING_RECEIVER, "A receiver of type {0} is required", RENDER_TYPE); MAP.put(NO_RECEIVER_ALLOWED, "No receiver can be passed to this function or property"); - MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION, "Assigning single elements to varargs in named form is deprecated", TO_STRING); - MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR, "Assigning single elements to varargs in named form is forbidden", TO_STRING); + MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION, "Assigning single elements to varargs in named form is forbidden", TO_STRING); MAP.put(REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_FUNCTION, "Redundant spread (*) operator"); - MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION, "Assigning single elements to varargs in named form is deprecated"); - MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_ERROR, "Assigning single elements to varargs in named form is forbidden"); + MAP.put(ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION, "Assigning single elements to varargs in named form is forbidden"); MAP.put(REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION, "Redundant spread (*) operator"); MAP.put(CREATING_AN_INSTANCE_OF_ABSTRACT_CLASS, "Cannot create an instance of an abstract class"); @@ -948,7 +941,6 @@ public class DefaultErrorMessages { MAP.put(TYPE_PARAMETER_AS_REIFIED, "Cannot use ''{0}'' as reified type parameter. Use a class instead.", NAME); MAP.put(TYPE_PARAMETER_AS_REIFIED_ARRAY, "Cannot use ''{0}'' as reified type parameter, since the array type parameter is not reified.", NAME); - MAP.put(TYPE_PARAMETER_AS_REIFIED_ARRAY_WARNING, "Cannot use ''{0}'' as reified type parameter, since the array type parameter is not reified.", NAME); MAP.put(REIFIED_TYPE_PARAMETER_NO_INLINE, "Only type parameters of inline functions can be reified"); MAP.put(REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, "Cannot use ''{0}'' as reified type parameter", RENDER_TYPE); MAP.put(REIFIED_TYPE_UNSAFE_SUBSTITUTION, "It may be not safe to use ''{0}'' as an argument for a reified type parameter. Use a non-generic type or * if possible", RENDER_TYPE); @@ -983,14 +975,10 @@ public class DefaultErrorMessages { MAP.put(RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION, "Expression annotations with retention other than SOURCE are prohibited"); - MAP.put(RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION_WARNING, - "Expression annotations with retention other than SOURCE are deprecated"); - MAP.put(LOCAL_ANNOTATION_CLASS, "Local annotation classes are deprecated and will be unsupported in a future release"); - MAP.put(LOCAL_ANNOTATION_CLASS_ERROR, "Annotation class cannot be local"); + MAP.put(LOCAL_ANNOTATION_CLASS, "Annotation class cannot be local"); MAP.put(ANNOTATION_ON_SUPERCLASS, "Annotations on superclass are meaningless"); - MAP.put(ANNOTATION_ON_SUPERCLASS_WARNING, "Annotations on superclass are meaningless and deprecated"); MAP.put(CONST_VAL_NOT_TOP_LEVEL_OR_OBJECT, "Const 'val' are only allowed on top level or in objects"); MAP.put(CONST_VAL_WITH_DELEGATE, "Const 'val' should not have a delegate"); @@ -1055,9 +1043,8 @@ public class DefaultErrorMessages { MAP.put(RECURSION_IN_INLINE, "Inline function ''{1}'' cannot be recursive", ELEMENT_TEXT, SHORT_NAMES_IN_TYPES); MAP.put(INLINE_PROPERTY_WITH_BACKING_FIELD, "Inline property cannot have backing field"); MAP.put(NON_INTERNAL_PUBLISHED_API, "@PublishedApi annotation is only applicable for internal declaration"); - MAP.put(PROTECTED_CALL_FROM_PUBLIC_INLINE, "Protected function call from public-API inline function is deprecated", NAME); + MAP.put(PROTECTED_CALL_FROM_PUBLIC_INLINE, "Protected function call from public-API inline function is prohibited", NAME); MAP.put(PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE, "Protected constructor call from public-API inline function is deprecated", NAME); - MAP.put(PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR, "Protected function call from public-API inline function is prohibited", NAME); MAP.put(SUPER_CALL_FROM_PUBLIC_INLINE, "Accessing super members from public-API inline function is deprecated", NAME); MAP.put(INVALID_DEFAULT_FUNCTIONAL_PARAMETER_FOR_INLINE, "Invalid default value for inline parameter: ''{0}''. Only lambdas, anonymous functions, and callable references are supported", ELEMENT_TEXT, SHORT_NAMES_IN_TYPES); MAP.put(NOT_SUPPORTED_INLINE_PARAMETER_IN_INLINE_PARAMETER_DEFAULT_VALUE, "Usage of inline parameter ''{0}'' in default value for another inline parameter is not supported", ELEMENT_TEXT, SHORT_NAMES_IN_TYPES); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt index faa69287e84..d3d0d62a634 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationChecker.kt @@ -170,13 +170,7 @@ class AnnotationChecker( } val actualTargets = getActualTargetList(reference, null, trace.bindingContext) if (entry.useSiteTarget != null && isSuperType) { - val reportError = languageVersionSettings.supportsFeature(ProhibitUseSiteTargetAnnotationsOnSuperTypes) - val diagnostic = if (reportError) { - Errors.ANNOTATION_ON_SUPERCLASS.on(entry) - } else { - Errors.ANNOTATION_ON_SUPERCLASS_WARNING.on(entry) - } - trace.report(diagnostic) + trace.report(Errors.ANNOTATION_ON_SUPERCLASS.on(languageVersionSettings, entry)) } else if (shouldRunCheck && (languageVersionSettings.supportsFeature(ProperCheckAnnotationsTargetInTypeUsePositions) || checkWithoutLanguageFeature)) { checkAnnotationEntry(entry, actualTargets, trace) } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt index 32b68c2ac4c..c9586d17109 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.kt @@ -347,11 +347,7 @@ class DeclarationsChecker( private fun checkLocalAnnotation(classDescriptor: ClassDescriptor, classOrObject: KtClassOrObject) { if (classDescriptor.kind == ClassKind.ANNOTATION_CLASS && DescriptorUtils.isLocal(classDescriptor)) { - if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitLocalAnnotations)) { - trace.report(LOCAL_ANNOTATION_CLASS_ERROR.on(classOrObject)) - } else { - trace.report(LOCAL_ANNOTATION_CLASS.on(classOrObject)) - } + trace.report(LOCAL_ANNOTATION_CLASS.on(languageVersionSettings, classOrObject)) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt index ab0f3460a12..07c561a4bf5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.kt @@ -270,11 +270,7 @@ class OverrideResolver( } if (abstractInvisibleSuper.isNotEmpty() && !canHaveAbstractMembers) { - if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitInvisibleAbstractMethodsInSuperclasses)) { - trace.report(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER.on(klass, classDescriptor, abstractInvisibleSuper)) - } else { - trace.report(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER_WARNING.on(klass, classDescriptor, abstractInvisibleSuper)) - } + trace.report(INVISIBLE_ABSTRACT_MEMBER_FROM_SUPER.on(languageVersionSettings, klass, classDescriptor, abstractInvisibleSuper)) } conflictingInterfaceMembers.removeAll(conflictingReturnTypes) @@ -410,11 +406,7 @@ class OverrideResolver( if (overridden != null) { val baseClassifier = overridden.containingDeclaration val dataModifier = findDataModifierForDataClass(copyFunction.containingDeclaration) - if (languageVersionSettings.supportsFeature(LanguageFeature.ProhibitDataClassesOverridingCopy)) { - trace.report(DATA_CLASS_OVERRIDE_DEFAULT_VALUES_ERROR.on(dataModifier, copyFunction, baseClassifier)) - } else { - trace.report(DATA_CLASS_OVERRIDE_DEFAULT_VALUES_WARNING.on(dataModifier, copyFunction, baseClassifier)) - } + trace.report(DATA_CLASS_OVERRIDE_DEFAULT_VALUES.on(languageVersionSettings, dataModifier, copyFunction, baseClassifier)) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AssigningNamedArgumentToVarargChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AssigningNamedArgumentToVarargChecker.kt index 4bdcc96bfe6..67a91bf129b 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AssigningNamedArgumentToVarargChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/AssigningNamedArgumentToVarargChecker.kt @@ -8,10 +8,8 @@ package org.jetbrains.kotlin.resolve.calls.checkers import com.intellij.psi.PsiElement import org.jetbrains.kotlin.config.LanguageFeature.* import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor -import org.jetbrains.kotlin.diagnostics.DiagnosticFactory import org.jetbrains.kotlin.diagnostics.Errors import org.jetbrains.kotlin.diagnostics.Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION -import org.jetbrains.kotlin.diagnostics.Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR import org.jetbrains.kotlin.psi.KtExpression import org.jetbrains.kotlin.psi.ValueArgument import org.jetbrains.kotlin.resolve.calls.callResolverUtil.isArrayOrArrayLiteral @@ -21,18 +19,6 @@ import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall import org.jetbrains.kotlin.resolve.descriptorUtil.isParameterOfAnnotation class AssigningNamedArgumentToVarargChecker : CallChecker { - companion object { - private val migrationDiagnosticsForFunction = MigrationDiagnostics( - ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION, - ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION_ERROR - ) - - private val migrationDiagnosticsForAnnotation = MigrationDiagnostics( - Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION, - Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION_ERROR - ) - } - override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) { for ((parameterDescriptor, resolvedArgument) in resolvedCall.valueArguments) { for (argument in resolvedArgument.arguments) { @@ -71,9 +57,9 @@ class AssigningNamedArgumentToVarargChecker : CallChecker { context.trace.report(Errors.REDUNDANT_SPREAD_OPERATOR_IN_NAMED_FORM_IN_ANNOTATION.on(argumentExpression)) } } else { - reportMigrationDiagnostic(migrationDiagnosticsForAnnotation, context) { diagnostic -> - context.trace.report(diagnostic.on(argumentExpression)) - } + context.trace.report( + Errors.ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_ANNOTATION.on(context.languageVersionSettings, argumentExpression) + ) } } @@ -92,30 +78,16 @@ class AssigningNamedArgumentToVarargChecker : CallChecker { } } else { if (!argument.hasSpread()) { - reportMigrationDiagnostic(migrationDiagnosticsForFunction, context) { diagnostic -> - context.trace.report(diagnostic.on(argumentExpression, parameterDescriptor.type)) - } + context.trace.report( + ASSIGNING_SINGLE_ELEMENT_TO_VARARG_IN_NAMED_FORM_FUNCTION.on( + context.languageVersionSettings, + argumentExpression, + parameterDescriptor.type + ) + ) } } } private fun ValueArgument.hasSpread() = getSpreadElement() != null - - private inline fun > reportMigrationDiagnostic( - migrationDiagnostics: MigrationDiagnostics, - context: ResolutionContext<*>, - report: (T) -> Unit - ) { - val (warning, error) = migrationDiagnostics - if (context.languageVersionSettings.supportsFeature(ProhibitAssigningSingleElementsToVarargsInNamedForm)) { - report(error) - } else { - report(warning) - } - } } - -private data class MigrationDiagnostics>(val warning: T, val error: T) - -private val ResolutionContext<*>.isAssigningArrayEnabled: Boolean - get() = languageVersionSettings.supportsFeature(AllowAssigningArrayElementsToVarargsInNamedFormForFunctions) \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.kt index 263f3caec5d..8708a5bffe5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/InlineChecker.kt @@ -60,14 +60,11 @@ internal class InlineChecker(private val descriptor: FunctionDescriptor) : CallC private var supportDefaultValueInline by Delegates.notNull() - private var prohibitProtectedCallFromInline by Delegates.notNull() - override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) { val call = resolvedCall.call val expression = call.calleeExpression ?: return supportDefaultValueInline = context.languageVersionSettings.supportsFeature(LanguageFeature.InlineDefaultFunctionalParameters) - prohibitProtectedCallFromInline = context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitProtectedCallFromInline) //checking that only invoke or inlinable extension called on function parameter val targetDescriptor = resolvedCall.resultingDescriptor @@ -282,11 +279,10 @@ internal class InlineChecker(private val descriptor: FunctionDescriptor) : CallC isConstructorCall -> { context.trace.report(PROTECTED_CONSTRUCTOR_CALL_FROM_PUBLIC_INLINE.on(expression, calledDescriptor)) } - prohibitProtectedCallFromInline -> { - context.trace.report(PROTECTED_CALL_FROM_PUBLIC_INLINE_ERROR.on(expression, calledDescriptor)) - } else -> { - context.trace.report(PROTECTED_CALL_FROM_PUBLIC_INLINE.on(expression, calledDescriptor)) + context.trace.report( + PROTECTED_CALL_FROM_PUBLIC_INLINE.on(context.languageVersionSettings, expression, calledDescriptor) + ) } } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ReifiedTypeParameterSubstitutionChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ReifiedTypeParameterSubstitutionChecker.java index deae8265e9e..34be17c9d67 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ReifiedTypeParameterSubstitutionChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/ReifiedTypeParameterSubstitutionChecker.java @@ -67,11 +67,7 @@ public class ReifiedTypeParameterSubstitutionChecker implements CallChecker { DiagnosticFactory1 diagnosticFactory; if (isArrayArgumentCheck) { - if (context.getLanguageVersionSettings().supportsFeature(LanguageFeature.ProhibitNonReifiedArraysAsReifiedTypeArguments)) { - diagnosticFactory = Errors.TYPE_PARAMETER_AS_REIFIED_ARRAY; - } else { - diagnosticFactory = Errors.TYPE_PARAMETER_AS_REIFIED_ARRAY_WARNING; - } + diagnosticFactory = Errors.TYPE_PARAMETER_AS_REIFIED_ARRAY.chooseFactory(context.getLanguageVersionSettings()); } else { diagnosticFactory = Errors.TYPE_PARAMETER_AS_REIFIED; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/SelfCallInNestedObjectConstructorChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/SelfCallInNestedObjectConstructorChecker.kt index 63ff6ba8de7..2824419493f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/SelfCallInNestedObjectConstructorChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/SelfCallInNestedObjectConstructorChecker.kt @@ -7,6 +7,7 @@ package org.jetbrains.kotlin.resolve.calls.checkers import com.intellij.psi.PsiElement import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.config.LanguageVersionSettings import org.jetbrains.kotlin.descriptors.ClassDescriptor import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.ConstructorDescriptor @@ -32,8 +33,7 @@ object SelfCallInNestedObjectConstructorChecker : CallChecker { if (constructedObject.kind != ClassKind.OBJECT) return val containingClass = constructedObject.containingDeclaration as? ClassDescriptor ?: return if (candidateDescriptor.constructedClass == containingClass) { - val reportError = context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitSelfCallsInNestedObjects) - val visitor = Visitor(containingClass, context.trace, reportError) + val visitor = Visitor(containingClass, context.trace, context.languageVersionSettings) resolvedCall.call.valueArgumentList?.accept(visitor) } } @@ -41,7 +41,7 @@ object SelfCallInNestedObjectConstructorChecker : CallChecker { private class Visitor( val containingClass: ClassDescriptor, val trace: BindingTrace, - val reportError: Boolean + val languageVersionSettings: LanguageVersionSettings ) : KtVisitorVoid() { override fun visitKtElement(element: KtElement) { element.acceptChildren(this, null) @@ -65,12 +65,7 @@ object SelfCallInNestedObjectConstructorChecker : CallChecker { val receiverType = receiver?.type ?: return val receiverClass = receiverType.constructor.declarationDescriptor as? ClassDescriptor ?: return if (DescriptorUtils.isSubclass(receiverClass, containingClass)) { - val factory = if (reportError) { - Errors.SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR - } else { - Errors.SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR_WARNING - } - trace.report(factory.on(argument)) + trace.report(Errors.SELF_CALL_IN_NESTED_OBJECT_CONSTRUCTOR.on(languageVersionSettings, argument)) } } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/AnnotationClassTargetAndRetentionChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/AnnotationClassTargetAndRetentionChecker.kt index aba08a6d7ca..0defde9809c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/AnnotationClassTargetAndRetentionChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/AnnotationClassTargetAndRetentionChecker.kt @@ -34,12 +34,12 @@ class AnnotationClassTargetAndRetentionChecker : DeclarationChecker { val retentionAnnotation = descriptor.annotations.findAnnotation(StandardNames.FqNames.retention) val targetAnnotation = descriptor.annotations.findAnnotation(StandardNames.FqNames.target) - val diagnostics = - if (context.languageVersionSettings.supportsFeature(LanguageFeature.RestrictRetentionForExpressionAnnotations)) - Errors.RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION - else - Errors.RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION_WARNING - context.trace.report(diagnostics.on(retentionAnnotation?.psi ?: targetAnnotation?.psi ?: declaration)) + context.trace.report( + Errors.RESTRICTED_RETENTION_FOR_EXPRESSION_ANNOTATION.on( + context.languageVersionSettings, + retentionAnnotation?.psi ?: targetAnnotation?.psi ?: declaration + ) + ) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/TailrecFunctionChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/TailrecFunctionChecker.kt index e9e68347674..129403b4dad 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/TailrecFunctionChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/TailrecFunctionChecker.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.resolve.checkers -import org.jetbrains.kotlin.config.LanguageFeature import org.jetbrains.kotlin.descriptors.DeclarationDescriptor import org.jetbrains.kotlin.descriptors.FunctionDescriptor import org.jetbrains.kotlin.diagnostics.Errors @@ -19,10 +18,6 @@ object TailrecFunctionChecker : DeclarationChecker { if (descriptor.isEffectivelyFinal(false)) return - if (!context.languageVersionSettings.supportsFeature(LanguageFeature.ProhibitTailrecOnVirtualMember)) { - context.trace.report(Errors.TAILREC_ON_VIRTUAL_MEMBER.on(declaration)) - } else { - context.trace.report(Errors.TAILREC_ON_VIRTUAL_MEMBER_ERROR.on(declaration)) - } + context.trace.report(Errors.TAILREC_ON_VIRTUAL_MEMBER.on(context.languageVersionSettings, declaration)) } -} \ No newline at end of file +} diff --git a/compiler/testData/codegen/box/intrinsics/javaPrimitiveType_UnitAndNothing.kt b/compiler/testData/codegen/box/intrinsics/javaPrimitiveType_UnitAndNothing.kt index ee33f2d42e8..5455ab48db9 100644 --- a/compiler/testData/codegen/box/intrinsics/javaPrimitiveType_UnitAndNothing.kt +++ b/compiler/testData/codegen/box/intrinsics/javaPrimitiveType_UnitAndNothing.kt @@ -10,8 +10,8 @@ fun box(): String { assertEquals(null, pNUnit!!::class.javaPrimitiveType) assertEquals(null, Unit::class.javaPrimitiveType) - @Suppress("TYPE_INFERENCE_ONLY_INPUT_TYPES") + @Suppress("TYPE_INFERENCE_ONLY_INPUT_TYPES_ERROR") assertEquals(java.lang.Void.TYPE, Nothing::class.javaPrimitiveType) return "OK" -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeArguments.kt b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeArguments.kt index fd3542996a7..eed0f43203c 100644 --- a/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeArguments.kt +++ b/compiler/testData/diagnostics/foreignAnnotationsTests/java8Tests/jsr305/typeArguments.kt @@ -84,9 +84,9 @@ fun main(a: test.A, l: L, Int?>, l1: L, Int>) a.bar(l1 as L, Int?>) a.baz1().t().containsKey("") - a.baz1().t().containsKey(null) + a.baz1().t().containsKey(null) a.baz1().t().containsValue(1) - a.baz1().t().containsValue(null) + a.baz1().t().containsValue(null) a.baz1().s().hashCode() a.baz1().setT(l.t()) @@ -100,8 +100,8 @@ fun main(a: test.A, l: L, Int?>, l1: L, Int>) a.baz2().s().hashCode() a.baz3().t().containsKey("") - a.baz3().t().containsKey(null) + a.baz3().t().containsKey(null) a.baz3().t().containsValue(1) - a.baz3().t().containsValue(null) + a.baz3().t().containsValue(null) a.baz3().s().hashCode() } diff --git a/compiler/testData/diagnostics/tests/annotations/RetentionsOfAnnotationWithExpressionTarget_after.kt b/compiler/testData/diagnostics/tests/annotations/RetentionsOfAnnotationWithExpressionTarget_after.kt index b229fad848b..48b07393be7 100644 --- a/compiler/testData/diagnostics/tests/annotations/RetentionsOfAnnotationWithExpressionTarget_after.kt +++ b/compiler/testData/diagnostics/tests/annotations/RetentionsOfAnnotationWithExpressionTarget_after.kt @@ -6,9 +6,9 @@ annotation class TestRetentionSource @Target(AnnotationTarget.EXPRESSION) -@Retention(AnnotationRetention.BINARY) +@Retention(AnnotationRetention.BINARY) annotation class TestRetentionBinary @Target(AnnotationTarget.EXPRESSION) -@Retention(AnnotationRetention.RUNTIME) -annotation class TestRetentionRuntime \ No newline at end of file +@Retention(AnnotationRetention.RUNTIME) +annotation class TestRetentionRuntime diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt23992_after.kt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt23992_after.kt index f2a4b2c94dc..4434897a555 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt23992_after.kt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/kt23992_after.kt @@ -6,6 +6,6 @@ interface Foo @Target(AnnotationTarget.TYPE) annotation class Ann -class E : @field:Ann @get:Ann @set:Ann @setparam:Ann Foo +class E : @field:Ann @get:Ann @set:Ann @setparam:Ann Foo -interface G : @Ann Foo \ No newline at end of file +interface G : @Ann Foo diff --git a/compiler/testData/diagnostics/tests/backingField/FieldReassignment_before.kt b/compiler/testData/diagnostics/tests/backingField/FieldReassignment_before.kt index 139250c506c..b96f631fcc4 100644 --- a/compiler/testData/diagnostics/tests/backingField/FieldReassignment_before.kt +++ b/compiler/testData/diagnostics/tests/backingField/FieldReassignment_before.kt @@ -3,6 +3,6 @@ val my: Int = 1 get() { - field++ + field++ return field - } \ No newline at end of file + } diff --git a/compiler/testData/diagnostics/tests/classObjects/selfCallsInCompanionSuperConstructor_error.kt b/compiler/testData/diagnostics/tests/classObjects/selfCallsInCompanionSuperConstructor_error.kt index 2608a9d2c65..4b62e501686 100644 --- a/compiler/testData/diagnostics/tests/classObjects/selfCallsInCompanionSuperConstructor_error.kt +++ b/compiler/testData/diagnostics/tests/classObjects/selfCallsInCompanionSuperConstructor_error.kt @@ -4,19 +4,19 @@ abstract class Base(val baseProp: String) open class Foo1(val prop: Int, baseProp: String) : Base(baseProp) { - companion object : Foo1(prop, baseProp) + companion object : Foo1(prop, baseProp) } open class Foo2(val prop: Int, baseProp: String) : Base(baseProp) { - companion object : Foo2(this.prop, this.baseProp) + companion object : Foo2(this.prop, this.baseProp) } open class Foo3(val prop: Int, baseProp: String) : Base(baseProp) { - companion object : Foo3(Companion.prop, Companion.baseProp) + companion object : Foo3(Companion.prop, Companion.baseProp) } open class Foo4(val prop: Int, baseProp: String) : Base(baseProp) { - object MyObject : Foo4(MyObject.prop, MyObject.baseProp) + object MyObject : Foo4(MyObject.prop, MyObject.baseProp) } open class CheckNested(a: Any) { @@ -26,5 +26,5 @@ open class CheckNested(a: Any) { } open class Foo5(val prop: Int) { - object MyObject : Foo5(with(MyObject) { prop }) + object MyObject : Foo5(with(MyObject) { prop }) } diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/backingFieldInsideGetter_before.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/backingFieldInsideGetter_before.kt index acbcd5a6394..a035b4e41c2 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/backingFieldInsideGetter_before.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/backingFieldInsideGetter_before.kt @@ -8,7 +8,7 @@ import java.util.HashSet val a: MutableSet? = null get() { if (a == null) { - field = HashSet() + field = HashSet() } return a } @@ -17,7 +17,7 @@ class R { val b: String? = null get() { if (b == null) { - field = "b" + field = "b" } return b } diff --git a/compiler/testData/diagnostics/tests/generics/tpAsReified/GenericArrayAsReifiedArgument.kt b/compiler/testData/diagnostics/tests/generics/tpAsReified/GenericArrayAsReifiedArgument.kt index 1780ee23d14..da4d103de70 100644 --- a/compiler/testData/diagnostics/tests/generics/tpAsReified/GenericArrayAsReifiedArgument.kt +++ b/compiler/testData/diagnostics/tests/generics/tpAsReified/GenericArrayAsReifiedArgument.kt @@ -6,8 +6,8 @@ inline fun foo() {} fun bar() { foo<T>() - foo<Array>() - foo<Array>>() + foo<Array>() + foo<Array>>() foo>() foo>>() foo() diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.kt b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.kt index cd1eead40ba..5d01937fcf3 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.kt @@ -444,7 +444,7 @@ fun poll8(): Flow { fun poll81(): Flow { return flow { - val inv = ::bar2 in setOf(::foo2) + val inv = ::bar2 in setOf(::foo2) inv() } } @@ -458,7 +458,7 @@ fun poll82(): Flow { fun poll83(): Flow { return flow { - val inv = ::bar4 in setOf(::foo4) + val inv = ::bar4 in setOf(::foo4) inv } } @@ -486,8 +486,8 @@ fun poll86(): Flow { fun poll87(): Flow { return flow { - val inv = ::Foo7 in setOf(foo7()) - inv + val inv = ::Foo7 in setOf(foo7()) + inv } } diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt index a42308ab07c..28feea9c513 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontRewriteAtSlice.kt @@ -57,14 +57,14 @@ fun poll75(): Flow { fun poll81(): Flow { return flow { - val inv = ::bar2 in setOf(::foo2) + val inv = ::bar2 in setOf(::foo2) inv() } } fun poll83(): Flow { return flow { - val inv = ::bar4 in setOf(::foo4) + val inv = ::bar4 in setOf(::foo4) inv } } diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt index b90cf87a4f9..c08b0f6aa49 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesNonStrictOnlyInputTypes.kt @@ -22,14 +22,14 @@ class Flow(private val block: suspend FlowCollector.() -> Unit) fun poll81(): Flow { return flow { - val inv = ::bar2 in setOf(::foo2) + val inv = ::bar2 in setOf(::foo2) inv() } } fun poll83(): Flow { return flow { - val inv = ::bar4 in setOf(::foo4) + val inv = ::bar4 in setOf(::foo4) inv } } diff --git a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt index 63fd5deb46e..de8680375e3 100644 --- a/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt +++ b/compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesUnrestricted.kt @@ -445,7 +445,7 @@ fun poll8(): Flow { fun poll81(): Flow { return flow { - val inv = ::bar2 in setOf(::foo2) + val inv = ::bar2 in setOf(::foo2) inv() } } @@ -459,7 +459,7 @@ fun poll82(): Flow { fun poll83(): Flow { return flow { - val inv = ::bar4 in setOf(::foo4) + val inv = ::bar4 in setOf(::foo4) inv } } @@ -487,8 +487,8 @@ fun poll86(): Flow { fun poll87(): Flow { return flow { - val inv = ::Foo7 in setOf(foo7()) - inv + val inv = ::Foo7 in setOf(foo7()) + inv } } diff --git a/compiler/testData/diagnostics/tests/inference/specialCallsWithCallableReferences.kt b/compiler/testData/diagnostics/tests/inference/specialCallsWithCallableReferences.kt index 097eeed81d6..3b110c6a4d9 100644 --- a/compiler/testData/diagnostics/tests/inference/specialCallsWithCallableReferences.kt +++ b/compiler/testData/diagnostics/tests/inference/specialCallsWithCallableReferences.kt @@ -274,7 +274,7 @@ fun poll8() { } fun poll81() { - val inv = ::bar2 in setOf(::foo2) + val inv = ::bar2 in setOf(::foo2) inv() } @@ -304,7 +304,7 @@ fun poll86() { } fun poll87() { - val inv = ::Foo7 in setOf(foo7()) + val inv = ::Foo7 in setOf(foo7()) inv } diff --git a/compiler/testData/diagnostics/tests/inline/protectedCallDepecation.kt b/compiler/testData/diagnostics/tests/inline/protectedCallDepecation.kt index 6db2baf2f2e..8d1c8a8465a 100644 --- a/compiler/testData/diagnostics/tests/inline/protectedCallDepecation.kt +++ b/compiler/testData/diagnostics/tests/inline/protectedCallDepecation.kt @@ -18,10 +18,10 @@ open class A { protected set(value) {} inline fun call() { - test() - z + test() + z zVar - zVar = "123" + zVar = "123" } internal inline fun callFromInternal() { @@ -32,10 +32,10 @@ open class A { @PublishedApi internal inline fun callFromPublished() { - test() - z + test() + z zVar - zVar = "123" + zVar = "123" } protected inline fun callFromProtected() { @@ -48,13 +48,13 @@ open class A { class B : A() { inline fun testB() { - test() + test() } } class C : JavaClass() { inline fun call() { - bind() + bind() } internal inline fun callFromInternal() { @@ -67,7 +67,7 @@ class C : JavaClass() { @PublishedApi internal inline fun callFromPublished() { - bind() + bind() } } diff --git a/compiler/testData/diagnostics/tests/j+k/defaultMethods_warning.kt b/compiler/testData/diagnostics/tests/j+k/defaultMethods_warning.kt index dd2e491be89..0dec9512494 100644 --- a/compiler/testData/diagnostics/tests/j+k/defaultMethods_warning.kt +++ b/compiler/testData/diagnostics/tests/j+k/defaultMethods_warning.kt @@ -22,7 +22,7 @@ import JavaInterface.testStatic interface KotlinInterface : JavaInterface { fun fooo() { - testStatic() + testStatic() super.test() object { @@ -51,7 +51,7 @@ interface KotlinInterface : JavaInterface { interface KotlinInterfaceIndirectInheritance : KotlinInterface { fun foooo() { - testStatic() + testStatic() super.test() object { @@ -76,25 +76,25 @@ interface KotlinInterfaceIndirectInheritance : KotlinInterface { open class KotlinClass : JavaInterface { fun foo(){ - testStatic() - super.test() - super.testOverride() + testStatic() + super.test() + super.testOverride() object { fun run () { - super@KotlinClass.test() + super@KotlinClass.test() } } } val property: String get() { - super.test() - super.testOverride() + super.test() + super.testOverride() object { fun run () { - super@KotlinClass.test() + super@KotlinClass.test() } } return "" @@ -103,7 +103,7 @@ open class KotlinClass : JavaInterface { class KotlinClassIndirectInheritance : KotlinClass() { fun foo2(){ - testStatic() + testStatic() super.test() super.testOverride() @@ -130,25 +130,25 @@ class KotlinClassIndirectInheritance : KotlinClass() { class KotlinClassIndirectInheritance2 : KotlinInterfaceIndirectInheritance { fun foo(){ - testStatic() - super.test() + testStatic() + super.test() super.testOverride() object { fun run () { - super@KotlinClassIndirectInheritance2.test() + super@KotlinClassIndirectInheritance2.test() } } } val property: String get() { - super.test() + super.test() super.testOverride() object { fun run () { - super@KotlinClassIndirectInheritance2.test() + super@KotlinClassIndirectInheritance2.test() } } return "" @@ -156,7 +156,7 @@ class KotlinClassIndirectInheritance2 : KotlinInterfaceIndirectInheritance { } fun test() { - JavaInterface.testStatic() + JavaInterface.testStatic() KotlinClass().foo() KotlinClass().property KotlinClassIndirectInheritance2().foo() diff --git a/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt index 2099f3d2a4c..42c7f094034 100644 --- a/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt +++ b/compiler/testData/diagnostics/tests/j+k/polymorphicSignature/spreadOperator_before.kt @@ -5,7 +5,7 @@ import java.lang.invoke.MethodHandle fun test(mh: MethodHandle) { mh.invokeExact("1", "2") - mh.invokeExact(*emptyArray(), "X") - mh.invokeExact(*arrayOf("A", "B"), "C", *arrayOf("D", "E")) - mh.invoke(*arrayOf("A")) + mh.invokeExact(*emptyArray(), "X") + mh.invokeExact(*arrayOf("A", "B"), "C", *arrayOf("D", "E")) + mh.invoke(*arrayOf("A")) } diff --git a/compiler/testData/diagnostics/tests/localClasses/localAnnotationClass.kt b/compiler/testData/diagnostics/tests/localClasses/localAnnotationClass.kt index 26eef4232be..a325fe8fde8 100644 --- a/compiler/testData/diagnostics/tests/localClasses/localAnnotationClass.kt +++ b/compiler/testData/diagnostics/tests/localClasses/localAnnotationClass.kt @@ -1,9 +1,9 @@ // !LANGUAGE: -ProhibitLocalAnnotations fun f() { - annotation class Anno + annotation class Anno @Anno class Local { - annotation class Nested + annotation class Nested } } diff --git a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.kt b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.kt index 13f51aa955d..a4c29bd2775 100644 --- a/compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.kt +++ b/compiler/testData/diagnostics/tests/scopes/protectedVisibility/kt7971.kt @@ -18,7 +18,7 @@ fun javaClass(): Class = null!! public class AppServiceModule : AbstractModule() { inline fun AbstractModule.bind() { - val x = bind(javaClass()) + val x = bind(javaClass()) x checkType { _() } // check that Class receiver is used instead of extension one } diff --git a/compiler/testData/diagnostics/tests/tailRecOnVirtualMember.kt b/compiler/testData/diagnostics/tests/tailRecOnVirtualMember.kt index b04804e2aad..e47f23cc695 100644 --- a/compiler/testData/diagnostics/tests/tailRecOnVirtualMember.kt +++ b/compiler/testData/diagnostics/tests/tailRecOnVirtualMember.kt @@ -1,15 +1,15 @@ //!LANGUAGE: -ProhibitTailrecOnVirtualMember open class A { - tailrec open fun foo(x: Int) { + tailrec open fun foo(x: Int) { foo(x) } - internal tailrec open fun bar(y: Int) { + internal tailrec open fun bar(y: Int) { bar(y) } - protected tailrec open fun baz(y: Int) { + protected tailrec open fun baz(y: Int) { baz(y) } @@ -38,15 +38,15 @@ open class B : A() { open class C : A() { - tailrec override fun foo(x: Int) { + tailrec override fun foo(x: Int) { foo(x) } - tailrec override fun bar(y: Int) { + tailrec override fun bar(y: Int) { bar(y) } - tailrec override fun baz(y: Int) { + tailrec override fun baz(y: Int) { baz(y) } } @@ -66,15 +66,15 @@ object D : A() { } sealed class E : A() { - tailrec override fun foo(x: Int) { + tailrec override fun foo(x: Int) { foo(x) } - tailrec override fun bar(y: Int) { + tailrec override fun bar(y: Int) { bar(y) } - tailrec override fun baz(y: Int) { + tailrec override fun baz(y: Int) { baz(y) } @@ -109,15 +109,15 @@ enum class F { } }; - tailrec open fun foo(x: Int) { + tailrec open fun foo(x: Int) { foo(x) } - internal tailrec open fun bar(y: Int) { + internal tailrec open fun bar(y: Int) { bar(y) } - protected tailrec open fun baz(y: Int) { + protected tailrec open fun baz(y: Int) { baz(y) } @@ -134,15 +134,15 @@ enum class G { G1; - tailrec open fun foo(x: Int) { + tailrec open fun foo(x: Int) { foo(x) } - internal tailrec open fun bar(y: Int) { + internal tailrec open fun bar(y: Int) { bar(y) } - protected tailrec open fun baz(y: Int) { + protected tailrec open fun baz(y: Int) { baz(y) } @@ -168,4 +168,4 @@ val z = object : A() { tailrec override fun baz(y: Int) { baz(y) } -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_before.kt b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_before.kt index b4738e722b2..2d0fe8c3ce0 100644 --- a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_before.kt +++ b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_before.kt @@ -11,7 +11,7 @@ annotation class Ann(vararg val s: String) -@Ann(s = "value") +@Ann(s = "value") fun test1() {} @Ann(s = *arrayOf("value")) @@ -20,7 +20,7 @@ fun test2() {} @Ann(s = *["value"]) fun test3() {} -@JavaAnn(value = "value") +@JavaAnn(value = "value") fun test4() {} @JavaAnn("value", path = arrayOf("path")) diff --git a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt index 934707a86ca..f2015459ef7 100644 --- a/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt +++ b/compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormFunDeprecation_before.kt @@ -6,41 +6,41 @@ fun foo(vararg s: Int) {} open class Cls(vararg p: Long) fun test(i: IntArray) { - foo(s = 1) - foo(s = i) + foo(s = 1) + foo(s = i) foo(s = *i) - foo(s = intArrayOf(1)) + foo(s = intArrayOf(1)) foo(s = *intArrayOf(1)) foo(1) - Cls(p = 1) + Cls(p = 1) - class Sub : Cls(p = 1) + class Sub : Cls(p = 1) - val c = object : Cls(p = 1) {} + val c = object : Cls(p = 1) {} - foo(s = *intArrayOf(elements = 1)) + foo(s = *intArrayOf(elements = 1)) } fun anyFoo(vararg a: Any) {} fun testAny() { - anyFoo(a = "") - anyFoo(a = arrayOf("")) + anyFoo(a = "") + anyFoo(a = arrayOf("")) anyFoo(a = *arrayOf("")) } fun genFoo(vararg t: T) {} fun testGen() { - genFoo(t = 1) - genFoo(t = null) - genFoo>(t = arrayOf()) + genFoo(t = 1) + genFoo(t = null) + genFoo>(t = arrayOf()) genFoo>(t = *arrayOf(arrayOf())) - genFoo(t = "") - genFoo(t = arrayOf("")) + genFoo(t = "") + genFoo(t = arrayOf("")) genFoo(t = *arrayOf("")) } @@ -48,12 +48,12 @@ fun manyFoo(vararg v: Int) {} fun manyFoo(vararg s: String) {} fun testMany(a: Any) { - manyFoo(v = 1) - manyFoo(s = "") + manyFoo(v = 1) + manyFoo(s = "") manyFoo(a) manyFoo(v = a) manyFoo(s = a) - manyFoo(v = a as Int) - manyFoo(s = a as String) + manyFoo(v = a as Int) + manyFoo(s = a as String) } diff --git a/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromJava.kt b/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromJava.kt index 8a65b451a41..4e6147ef89d 100644 --- a/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromJava.kt +++ b/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromJava.kt @@ -15,7 +15,7 @@ public abstract class Base { package impl import base.* -class Impl : Base() +class Impl : Base() fun foo() { Impl().foo() diff --git a/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlin.kt b/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlin.kt index 3e58a4dc1ce..514775ae891 100644 --- a/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlin.kt +++ b/compiler/testData/diagnostics/tests/visibility/abstractInvisibleMemberFromKotlin.kt @@ -28,9 +28,9 @@ package impl import base.* import intermediate.* -class ImplDirectFromBase : Base() +class ImplDirectFromBase : Base() -object ImplObjDirectFromBase : Base() +object ImplObjDirectFromBase : Base() class ImplDirectFromBaseWithOverride : BaseWithOverride() @@ -38,7 +38,7 @@ class ImplDirectFromBaseWithOverrid : Base() { override fun internalFoo(): String = "" } -class ImplViaIntermediate : Intermediate() +class ImplViaIntermediate : Intermediate() fun foo() { ImplDirectFromBase().foo() diff --git a/compiler/testData/diagnostics/testsWithStdLib/ArrayOfNothing.kt b/compiler/testData/diagnostics/testsWithStdLib/ArrayOfNothing.kt index 24fe9880e02..bc409b922e7 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/ArrayOfNothing.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/ArrayOfNothing.kt @@ -50,6 +50,6 @@ fun test6() = foo() class B(val array: Array) -fun bar() = B>(arrayOf()) +fun bar() = B>(arrayOf()) fun test7() = bar() diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.kt b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.kt index 9fb1cd93da6..fbe69c9cd9e 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/jvmOverloads/jvmOverloadsOnAnnotationClassConstructor_1_4.kt @@ -1,4 +1,4 @@ // !LANGUAGE: +ProhibitJvmOverloadsOnConstructorsOfAnnotationClasses -annotation class A1 @JvmOverloads constructor(val x: Int = 1) -annotation class A2 @JvmOverloads constructor() \ No newline at end of file +annotation class A1 @JvmOverloads constructor(val x: Int = 1) +annotation class A2 @JvmOverloads constructor() diff --git a/compiler/testData/diagnostics/testsWithStdLib/cast/AsInsideIn.kt b/compiler/testData/diagnostics/testsWithStdLib/cast/AsInsideIn.kt index 616e3154749..221495d1912 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/cast/AsInsideIn.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/cast/AsInsideIn.kt @@ -3,7 +3,7 @@ interface A class B : A fun foo1(list: List, arg: B?): Boolean { // Type mismatch - return arg in list // resolved to extension + return arg in list // resolved to extension } fun foo2(list: List, arg: B?): Boolean { // FAKE: no cast needed @@ -17,4 +17,4 @@ fun foo3(list: List, arg: B?): Boolean { fun foo4(list: List, arg: B): Boolean { // Ok return arg in list -} \ No newline at end of file +} diff --git a/compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt b/compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt index 9dda3d1cc3c..f987d7b36ae 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/commonCollections.kt @@ -2,7 +2,7 @@ import java.util.* fun foo() { val al = ArrayList() al.size - al.contains(1) + al.contains(1) al.contains("") al.remove("") @@ -10,7 +10,7 @@ fun foo() { val hs = HashSet() hs.size - hs.contains(1) + hs.contains(1) hs.contains("") hs.remove("") @@ -18,10 +18,10 @@ fun foo() { val hm = HashMap() hm.size - hm.containsKey(1) + hm.containsKey(1) hm.containsKey("") - hm[1] + hm[1] hm[""] hm.remove("") diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/explicitTypeArgumentAsValidInputType.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/explicitTypeArgumentAsValidInputType.kt index bddb3045bba..ee34ba979e8 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/explicitTypeArgumentAsValidInputType.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/explicitTypeArgumentAsValidInputType.kt @@ -7,6 +7,6 @@ object ChildB : Parent fun <@kotlin.internal.OnlyInputTypes T> select(a: T, b: T) {} fun test() { - select(ChildA, ChildB) // should be error + select(ChildA, ChildB) // should be error select(ChildA, ChildB) // should be ok } diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.kt index 737823dfc5e..b12d0f58aad 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.kt @@ -15,7 +15,7 @@ fun <@kotlin.internal.OnlyInputTypes T : Base> fooB(a: T, b: T) {} fun usage(x: CX, y: CY) { - foo(x, y) // expected err, got err - fooA(x, y) // expected err, got ok - fooB(x, y) // expected err, got ok + foo(x, y) // expected err, got err + fooA(x, y) // expected err, got ok + fooB(x, y) // expected err, got ok } diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt index 372c24663c2..5f6d8e12478 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt29307.kt @@ -2,7 +2,7 @@ // ISSUE: KT-29307 fun test_1(map: Map) { - val x = map[42] // OK + val x = map[42] // OK } open class A @@ -10,7 +10,7 @@ open class A class B : A() fun test_2(map: Map) { - val x = map[42] + val x = map[42] } fun test_3(m: Map<*, String>) { diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypes.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypes.kt index b80fbbd8833..6802cdfd797 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypes.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypes.kt @@ -35,12 +35,12 @@ fun test_4(list: List>, x: Out, y: Out, z: Out) { fun test_5(list: List>, x: Inv, y: Inv, z: Inv) { list.contains1(x) - list.contains1(y) - list.contains1(z) + list.contains1(y) + list.contains1(z) } fun test_6(list: List>, x: Inv, y: Inv, z: Inv) { list.contains1(x) - list.contains1(y) - list.contains1(z) + list.contains1(y) + list.contains1(z) } diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt index abb2457404d..c97975f356c 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.kt @@ -17,9 +17,9 @@ public fun Map.get1(key: Any?): Int = null!! public fun <@kotlin.internal.OnlyInputTypes K, V> Map.get1(key: K): V? = null!! fun test(map: Map) { - val a: Int = listOf(1).contains1("") + val a: Int = listOf(1).contains1("") val b: Boolean = listOf(1).contains1(1) - val c: String? = map.get1("") + val c: String? = map.get1("") val d: String? = map.get1(1) } diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.kt index 28bb9e6c8b9..37a19ad75e1 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.kt @@ -20,7 +20,7 @@ fun test( invOut.onlyOut(42) invOut.onlyOut(1L) - invOut.onlyOutUB("str") + invOut.onlyOutUB("str") invStar.onlyOutUB(0) invOut.onlyOutUB(42) invOut.onlyOutUB(1L) diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt index 1fef887c722..3cab312337d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.kt @@ -16,7 +16,7 @@ class Out // ------------------------------------------------------- fun test_0(x: Inv2, list: List>) { - list.foo(x) + list.foo(x) } // ------------------------- Inv ------------------------- @@ -26,27 +26,27 @@ fun test_1(x: Inv, list: List>) { } fun test_2(x: Inv, list: List>) { - list.contains1(x) + list.contains1(x) } fun test_3(x: Inv, list: List>) { - list.contains1(x) + list.contains1(x) } fun test_4(x: Inv, list: List>) { - list.contains1(x) + list.contains1(x) } fun test_5(x: Inv, list: List>) { - list.contains1(x) + list.contains1(x) } fun test_6(x: Inv, list: List>) { - list.contains1(x) + list.contains1(x) } fun test_7(x: Inv, list: List>) { - list.contains1(x) + list.contains1(x) } fun test_8(x: Inv, list: List>) { @@ -96,7 +96,7 @@ fun test_32(x: Inv, list: List>) { } fun test_33(x: Inv, list: List>) { - list.contains1(x) + list.contains1(x) } fun test_34(x: Inv, list: List>) { @@ -104,7 +104,7 @@ fun test_34(x: Inv, list: List>) { } fun test_35(x: Inv, list: List>) { - list.contains1(x) + list.contains1(x) } fun test_36(x: Inv, list: List>) { diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCommonConstraintSystem.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCommonConstraintSystem.kt index cb593c0dc7a..f6665db1914 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCommonConstraintSystem.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCommonConstraintSystem.kt @@ -43,11 +43,11 @@ fun testOK(first: First, bound: Bound, second: Second) { } fun testFail(first: First, bound: Bound, second: Second) { - strictSelect(InvB(first), InvB(bound)) - strictSelect(Inv(first), Inv(bound)) - strictSelect(Out(first), Out(second)) - strictSelect(In(first), In(second)) - strictSelect(InB(first), InB(second)) - strictSelect(Out(Inv(first)), Out(Inv(second))) - strictSelect(In(Inv(first)), In(Inv(second))) + strictSelect(InvB(first), InvB(bound)) + strictSelect(Inv(first), Inv(bound)) + strictSelect(Out(first), Out(second)) + strictSelect(In(first), In(second)) + strictSelect(InB(first), InB(second)) + strictSelect(Out(Inv(first)), Out(Inv(second))) + strictSelect(In(Inv(first)), In(Inv(second))) } diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt index 74d2b7ea787..94b0ee665b7 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.kt @@ -5,7 +5,7 @@ class Inv class Out fun foo(i: Inv, o: Out) { - bar(i, o) + bar(i, o) } fun <@kotlin.internal.OnlyInputTypes K> bar(r: Inv, o: Out): K = TODO() diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt index 8be2afc0ec6..09337b56616 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt @@ -10,7 +10,7 @@ class D fun test1(a: A, b: B, c: C) { assertEquals1(a, b) - assertEquals1(b, c) + assertEquals1(b, c) assertEquals1(3, 3) assertEquals1(1 or 2, 2 or 1) diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.kt index c04fe988406..1195daec1e7 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/kt36951.kt @@ -4,6 +4,6 @@ class BaseT> : HashSet() { fun foo() { - super.remove("") + super.remove("") } } diff --git a/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContains.kt b/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContains.kt index 0bc2a86660d..1afd85ba221 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContains.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContains.kt @@ -18,24 +18,24 @@ class C : java.util.concurrent.ConcurrentHashMap() { fun main() { val hm = java.util.concurrent.ConcurrentHashMap() - "" in hm - "" !in hm - 1 !in hm - 2 in hm + "" in hm + "" !in hm + 1 !in hm + 2 in hm hm.contains("") hm.contains(1) "" in (hm as Map) "" !in (hm as Map) - 1 in (hm as Map) - 1 !in (hm as Map) + 1 in (hm as Map) + 1 !in (hm as Map) val a = A() - "" in a - "" !in a - 1 !in a - 2 in a + "" in a + "" !in a + 1 !in a + 2 in a ' ' in a ' ' !in a @@ -44,35 +44,35 @@ fun main() { "" in (a as Map) "" !in (a as Map) - 1 in (a as Map) - 1 !in (a as Map) + 1 in (a as Map) + 1 !in (a as Map) val b = B() - "" in b - "" !in b - 1 !in b - 2 in b + "" in b + "" !in b + 1 !in b + 2 in b b.contains("") b.contains(1) "" in (b as Map) "" !in (b as Map) - 1 in (b as Map) - 1 !in (b as Map) + 1 in (b as Map) + 1 !in (b as Map) // Actually, we could've allow calls here because the owner explicitly declared as operator, but semantics is still weird val c = C() - "" in c - "" !in c - 1 !in c - 2 in c + "" in c + "" !in c + 1 !in c + 2 in c c.contains("") c.contains(1) "" in (c as Map) "" !in (c as Map) - 1 in (c as Map) - 1 !in (c as Map) + 1 in (c as Map) + 1 !in (c as Map) } diff --git a/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt b/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt index 3574bd1092f..1eede5465ec 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/java/concurrentHashMapContainsError.kt @@ -28,8 +28,8 @@ fun main() { "" in (hm as Map) "" !in (hm as Map) - 1 in (hm as Map) - 1 !in (hm as Map) + 1 in (hm as Map) + 1 !in (hm as Map) val a = A() "" in a @@ -44,8 +44,8 @@ fun main() { "" in (a as Map) "" !in (a as Map) - 1 in (a as Map) - 1 !in (a as Map) + 1 in (a as Map) + 1 !in (a as Map) val b = B() "" in b @@ -58,8 +58,8 @@ fun main() { "" in (b as Map) "" !in (b as Map) - 1 in (b as Map) - 1 !in (b as Map) + 1 in (b as Map) + 1 !in (b as Map) // Actually, we could've allow calls here because the owner explicitly declared as operator, but semantics is still weird val c = C() @@ -73,6 +73,6 @@ fun main() { "" in (c as Map) "" !in (c as Map) - 1 in (c as Map) - 1 !in (c as Map) + 1 in (c as Map) + 1 !in (c as Map) } diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.5.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.5.kt index 7208e7f0cef..574680809de 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.5.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.5.kt @@ -36,7 +36,7 @@ import base.* // TESTCASE NUMBER: 1 -class Case1 : BaseJava() {} +class Case1 : BaseJava() {} fun case1() { val v = Case1() @@ -48,7 +48,7 @@ fun case1() { */ abstract class AbstractClassCase2 : BaseJava() {} -class Case2 : AbstractClassCase2() {} +class Case2 : AbstractClassCase2() {} fun case2() { val v = Case2() diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.6.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.6.kt index 71b83e9bb1a..b49f96082c5 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.6.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.6.kt @@ -62,7 +62,7 @@ fun case2() { // TESTCASE NUMBER: 3 -class Case3 : BaseJava() {} +class Case3 : BaseJava() {} fun case3() { val v = Case3() @@ -74,7 +74,7 @@ fun case3() { */ abstract class AbstractClassCase4 : BaseJava() {} -class Case4 : AbstractClassCase4() {} +class Case4 : AbstractClassCase4() {} fun case4() { val v = Case4() diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.7.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.7.kt index 7859f9f1392..a849aff2f42 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.7.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.7.kt @@ -69,13 +69,13 @@ fun case2() { // TESTCASE NUMBER: 3 -class Case3 : BaseKotlin() {} +class Case3 : BaseKotlin() {} fun case3() { val v = Case3() v.boo(true) - val o = object : BaseKotlin() {} + val o = object : BaseKotlin() {} } /* @@ -83,12 +83,12 @@ fun case3() { */ abstract class AbstractClassCase4 : BaseKotlin() {} -class Case4 : AbstractClassCase4() {} +class Case4 : AbstractClassCase4() {} fun case4() { val v = Case4() v.boo(true) - val o = object : AbstractClassCase4() {} + val o = object : AbstractClassCase4() {} } diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.8.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.8.kt index acc6e6777a9..1a2b0c8287b 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.8.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.8.kt @@ -33,7 +33,7 @@ abstract class AbstractClassCase1() { public abstract val pub1: String } -class Case1 : AbstractClassCase1(){ +class Case1 : AbstractClassCase1(){ override fun prot() {} override fun int() { @@ -81,4 +81,4 @@ fun case2() { a.prot1 a.int1 a.pub1 -} \ No newline at end of file +} diff --git a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.9.kt b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.9.kt index 614a4a83c98..a5834b45ca0 100644 --- a/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.9.kt +++ b/compiler/tests-spec/testData/diagnostics/linked/declarations/classifier-declaration/class-declaration/abstract-classes/p-2/neg/1.9.kt @@ -70,7 +70,7 @@ import libModule.* // TESTCASE NUMBER: 2 class KotlinClassWithAbstractJavaClass() { fun foo() { - val baseJava1 = object : BaseJava1() {} - val baseKotlin = object : BaseKotlin1() {} + val baseJava1 = object : BaseJava1() {} + val baseKotlin = object : BaseKotlin1() {} } -} \ No newline at end of file +} diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg/1.kt b/compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg/1.kt index c77a02bd32b..4ad4cc4dda7 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg/1.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/annotations/annotation-classes/neg/1.kt @@ -18,57 +18,57 @@ annotation class Case12_1 annotation class Case12_2 // TESTCASE NUMBER: 1 -annotation class Case1 @JvmOverloads constructor(val x: Int) +annotation class Case1 @JvmOverloads constructor(val x: Int) // TESTCASE NUMBER: 2 -annotation class Case2 @[Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 JvmOverloads Case12_1] constructor(x: Int = 10) +annotation class Case2 @[Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 JvmOverloads Case12_1] constructor(x: Int = 10) // TESTCASE NUMBER: 3 -annotation class Case3 @Case12_2 @Case12_1 @Case12_2 @`JvmOverloads` @Case12_2 @Case12_2 constructor(x: Int = 10) +annotation class Case3 @Case12_2 @Case12_1 @Case12_2 @`JvmOverloads` @Case12_2 @Case12_2 constructor(x: Int = 10) // TESTCASE NUMBER: 4 -annotation class Case4 @Case12_2 @[Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 JvmOverloads Case12_1] @Case12_2 @Case12_2 constructor(x: Int = 10) +annotation class Case4 @Case12_2 @[Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 Case12_2 JvmOverloads Case12_1] @Case12_2 @Case12_2 constructor(x: Int = 10) // TESTCASE NUMBER: 5 -annotation class Case5 @[JvmOverloads] constructor(val x: Int) +annotation class Case5 @[JvmOverloads] constructor(val x: Int) // TESTCASE NUMBER: 6 -annotation class Case6 @JvmOverloads constructor() +annotation class Case6 @JvmOverloads constructor() // TESTCASE NUMBER: 7 -annotation class Case7@JvmOverloads constructor() {} +annotation class Case7@JvmOverloads constructor() {} // TESTCASE NUMBER: 8 -annotation class Case8 @`JvmOverloads` constructor() +annotation class Case8 @`JvmOverloads` constructor() // TESTCASE NUMBER: 9 -annotation class Case9 @JvmOverloads constructor(val x: Int) +annotation class Case9 @JvmOverloads constructor(val x: Int) // TESTCASE NUMBER: 10 -annotation class Case10 @JvmOverloads constructor(val x: Int) +annotation class Case10 @JvmOverloads constructor(val x: Int) // TESTCASE NUMBER: 11 -annotation class Case11 > @JvmOverloads constructor(val x: Int) +annotation class Case11 > @JvmOverloads constructor(val x: Int) // TESTCASE NUMBER: 12 -annotation class Case12 @JvmOverloads constructor(val x: Int) where T: Number +annotation class Case12 @JvmOverloads constructor(val x: Int) where T: Number // TESTCASE NUMBER: 13 annotation class Case13 constructor(val x: Int) { - annotation class Case1 @JvmOverloads constructor(val x: Int) + annotation class Case1 @JvmOverloads constructor(val x: Int) } // TESTCASE NUMBER: 14 -annotation class Case14 @JvmOverloads constructor(val x: Int) { +annotation class Case14 @JvmOverloads constructor(val x: Int) { annotation class Case1 constructor(val x: Int) } // TESTCASE NUMBER: 15 object Case15 { - annotation class Case15 @JvmOverloads constructor(val x: Int) + annotation class Case15 @JvmOverloads constructor(val x: Int) } // TESTCASE NUMBER: 16 class Case16 { - annotation class Case16 @JvmOverloads constructor(val x: Int) + annotation class Case16 @JvmOverloads constructor(val x: Int) } diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/25.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/25.kt index 1b5dad4abe4..140151f3b48 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/25.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/25.kt @@ -29,7 +29,7 @@ open class Case1 { x.get(0) x.size x.isEmpty() - x[null] + x[null] } } } diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/26.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/26.kt index be1a98c5f9b..95d70314581 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/26.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/26.kt @@ -29,7 +29,7 @@ open class Case1 { x.get(0) x.size x.isEmpty() - x[null] + x[null] } } } diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/27.kt b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/27.kt index a43861bfe6e..7182a272087 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/27.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/27.kt @@ -29,7 +29,7 @@ open class Case1 { x.get(0) x.size x.isEmpty() - x[null] + x[null] } } } diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/1.kt b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/1.kt index c406e0c1007..6a52d825622 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/1.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/1.kt @@ -9,7 +9,7 @@ // TESTCASE NUMBER: 1 open class Foo(val prop: Int) { - companion object : Foo(prop) + companion object : Foo(prop) } fun box(): String? { diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/2.kt b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/2.kt index 67c8063aa33..7b691d9da7f 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/2.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/2.kt @@ -9,7 +9,7 @@ // TESTCASE NUMBER: 2 open class Foo(val prop: Int) { - companion object MyCompanion : Foo(Foo.prop) + companion object MyCompanion : Foo(Foo.prop) } fun box(): String? { diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/3.kt b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/3.kt index ec14167f163..fbd81133aee 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/3.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/3.kt @@ -9,7 +9,7 @@ // TESTCASE NUMBER: 3 open class Foo(val prop: Int) { - object MyObject : Foo(MyObject.prop) + object MyObject : Foo(MyObject.prop) } fun box(): String? { diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/4.kt b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/4.kt index cdf9e43b058..7662796768b 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/4.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/4.kt @@ -9,7 +9,7 @@ // TESTCASE NUMBER: 4 open class Foo(val prop: Int) { - companion object : Foo(prop) + companion object : Foo(prop) } fun box(): String? { diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/5.kt b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/5.kt index 893f7174d6a..fd285293cc9 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/5.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/5.kt @@ -9,7 +9,7 @@ // TESTCASE NUMBER: 5 open class Foo(val prop: Int) { - companion object : Foo(this.prop) + companion object : Foo(this.prop) } fun box(): String? { diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/6.kt b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/6.kt index 0268eebe57b..d24e84d23a8 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/6.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/6.kt @@ -9,7 +9,7 @@ // TESTCASE NUMBER: 6 open class Foo(val prop: Int) { - companion object : Foo(Companion.prop) + companion object : Foo(Companion.prop) } fun box(): String? { diff --git a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/7.kt b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/7.kt index aeba95b3e0a..ccc9759f0dc 100644 --- a/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/7.kt +++ b/compiler/tests-spec/testData/diagnostics/notLinked/objects/inheritance/neg/7.kt @@ -9,7 +9,7 @@ // TESTCASE NUMBER: 7 open class Foo(val prop: Int) { - object MyObject : Foo(MyObject.prop) + object MyObject : Foo(MyObject.prop) } fun box(): String? {