diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java index 07b75c89b39..d5e77bc16a6 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForFunctionDescriptor.java @@ -48,8 +48,6 @@ public class AccessorForFunctionDescriptor extends AbstractAccessorForFunctionDe descriptor.getReturnType(), Modality.FINAL, Visibilities.LOCAL); - setOperator(descriptor.isOperator()); - setInfix(descriptor.isInfix()); } @NotNull diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyDescriptor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyDescriptor.java index b3225ab8beb..536a2c24739 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyDescriptor.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AccessorForPropertyDescriptor.java @@ -69,7 +69,9 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl implem public static class Getter extends PropertyGetterDescriptorImpl implements AccessorForCallableDescriptor { public Getter(AccessorForPropertyDescriptor property) { super(property, Annotations.Companion.getEMPTY(), Modality.FINAL, Visibilities.LOCAL, - false, false, Kind.DECLARATION, null, SourceElement.NO_SOURCE); + false, false, + /* isExternal = */ false, + Kind.DECLARATION, null, SourceElement.NO_SOURCE); initialize(property.getType()); } @@ -91,7 +93,9 @@ public class AccessorForPropertyDescriptor extends PropertyDescriptorImpl implem public static class Setter extends PropertySetterDescriptorImpl implements AccessorForCallableDescriptor{ public Setter(AccessorForPropertyDescriptor property) { super(property, Annotations.Companion.getEMPTY(), Modality.FINAL, Visibilities.LOCAL, - false, false, Kind.DECLARATION, null, SourceElement.NO_SOURCE); + false, false, + /* isExternal = */ false, + Kind.DECLARATION, null, SourceElement.NO_SOURCE); initializeDefault(); } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java index 4ecb255d932..4ceada00ad9 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AnnotationCodegen.java @@ -62,9 +62,7 @@ public abstract class AnnotationCodegen { public static final List METHOD_FLAGS = Arrays.asList( new JvmFlagAnnotation("kotlin.jvm.Strictfp", Opcodes.ACC_STRICT), - new JvmFlagAnnotation("kotlin.jvm.Synchronized", Opcodes.ACC_SYNCHRONIZED), - new JvmFlagAnnotation("kotlin.jvm.native", Opcodes.ACC_NATIVE), - new JvmFlagAnnotation("kotlin.external", Opcodes.ACC_NATIVE) + new JvmFlagAnnotation("kotlin.jvm.Synchronized", Opcodes.ACC_SYNCHRONIZED) ); private static final AnnotationVisitor NO_ANNOTATION_VISITOR = new AnnotationVisitor(Opcodes.ASM5) {}; diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java index 978c35ed566..dac28a7f51f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java @@ -192,6 +192,10 @@ public class AsmUtil { } } + if (functionDescriptor.getOriginal().isExternal()) { + flags |= Opcodes.ACC_NATIVE; + } + if (AnnotationUtilKt.isPlatformStaticInCompanionObject(functionDescriptor)) { // Native method will be a member of the class, the companion object method will be delegated to it flags &= ~Opcodes.ACC_NATIVE; diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java index 3c60c60a936..9b6041483be 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/ImplementationBodyCodegen.java @@ -479,7 +479,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { } private void generateFunctionsForDataClasses() { - if (!KotlinBuiltIns.isData(descriptor)) return; + if (!descriptor.isData()) return; new DataClassMethodGeneratorImpl(myClass, bindingContext).generate(); } @@ -763,8 +763,8 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { new DefaultParameterValueLoader() { @Override public StackValue genValue(ValueParameterDescriptor valueParameter, ExpressionCodegen codegen) { - assert KotlinBuiltIns.isData((ClassDescriptor) function.getContainingDeclaration()) - : "Function container should be annotated with [data]: " + function; + assert ((ClassDescriptor) function.getContainingDeclaration()).isData() + : "Function container must have [data] modifier: " + function; PropertyDescriptor property = bindingContext.get(BindingContext.VALUE_PARAMETER_AS_PROPERTY, valueParameter); assert property != null : "Copy function doesn't correspond to any property: " + function; return codegen.intermediateValueForProperty(property, false, null, StackValue.LOCAL_0); diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/MutableClassDescriptor.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/MutableClassDescriptor.java index 3462e773521..9bf5f18924f 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/MutableClassDescriptor.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/MutableClassDescriptor.java @@ -100,6 +100,11 @@ public class MutableClassDescriptor extends ClassDescriptorBase implements Class return isInner; } + @Override + public boolean isData() { + return false; + } + @Override public boolean isCompanionObject() { return false; diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.java index dadc3f4396b..ef050346d9e 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/serialization/JvmSerializerExtension.java @@ -20,7 +20,6 @@ import com.google.protobuf.MessageLite; import com.intellij.openapi.util.Pair; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.codegen.state.JetTypeMapper; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor; @@ -62,14 +61,6 @@ public class JvmSerializerExtension extends SerializerExtension { return useTypeTable; } - @Override - public void serializeClass(@NotNull ClassDescriptor descriptor, @NotNull ProtoBuf.Class.Builder proto) { - AnnotationDescriptor annotation = descriptor.getAnnotations().findAnnotation(KotlinBuiltIns.FQ_NAMES.annotation); - if (annotation != null) { - proto.addExtension(JvmProtoBuf.classAnnotation, annotationSerializer.serializeAnnotation(annotation)); - } - } - @Override public void serializeValueParameter(@NotNull ValueParameterDescriptor descriptor, @NotNull ProtoBuf.ValueParameter.Builder proto) { Integer index = bindings.get(INDEX_FOR_VALUE_PARAMETER, descriptor); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/inline/inlineUtil.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/inline/inlineUtil.kt new file mode 100644 index 00000000000..5f3e4d4b94a --- /dev/null +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/inline/inlineUtil.kt @@ -0,0 +1,69 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.inline + +import org.jetbrains.kotlin.load.kotlin.FileBasedKotlinClass +import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader +import org.jetbrains.kotlin.serialization.Flags +import org.jetbrains.kotlin.serialization.ProtoBuf +import org.jetbrains.kotlin.serialization.deserialization.NameResolver +import org.jetbrains.kotlin.serialization.deserialization.TypeTable +import org.jetbrains.kotlin.serialization.jvm.BitEncoding +import org.jetbrains.kotlin.serialization.jvm.JvmProtoBufUtil + +public fun inlineFunctionsJvmNames(bytes: ByteArray): Set { + val header = readKotlinHeader(bytes) + val annotationData = header.annotationData + val strings = header.strings + + if (annotationData == null || strings == null) return emptySet() + + return when (header.kind) { + KotlinClassHeader.Kind.CLASS -> { + val classData = JvmProtoBufUtil.readClassDataFrom(BitEncoding.decodeBytes(annotationData), strings) + inlineFunctionsJvmNames(classData.classProto.functionList, classData.nameResolver, classData.classProto.typeTable) + } + KotlinClassHeader.Kind.FILE_FACADE, + KotlinClassHeader.Kind.MULTIFILE_CLASS_PART -> { + val packageData = JvmProtoBufUtil.readPackageDataFrom(BitEncoding.decodeBytes(annotationData), strings) + inlineFunctionsJvmNames(packageData.packageProto.functionList, packageData.nameResolver, packageData.packageProto.typeTable) + } + else -> emptySet() + } +} + +private fun inlineFunctionsJvmNames(functions: List, nameResolver: NameResolver, protoTypeTable: ProtoBuf.TypeTable): Set { + val typeTable = TypeTable(protoTypeTable) + val inlineFunctions = functions.filter { Flags.IS_INLINE.get(it.flags) } + val jvmNames = inlineFunctions.map { + JvmProtoBufUtil.getJvmMethodSignature(it, nameResolver, typeTable) + } + return jvmNames.filterNotNull().toSet() +} + +private fun readKotlinHeader(bytes: ByteArray): KotlinClassHeader { + var header: KotlinClassHeader? = null + + FileBasedKotlinClass.create(bytes) { className, classHeader, innerClasses -> + header = classHeader + null + } + + if (header == null) throw AssertionError("Could not read kotlin header from byte array") + + return header!! +} diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java index 1de6557c7cb..f4faa045a4b 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/sam/SingleAbstractMethodUtils.java @@ -157,7 +157,11 @@ public class SingleAbstractMethodUtils { assert parameterType != null : "couldn't substitute type: " + parameterTypeUnsubstituted + ", substitutor = " + typeParameters.substitutor; ValueParameterDescriptor parameter = new ValueParameterDescriptorImpl( - result, null, 0, Annotations.Companion.getEMPTY(), Name.identifier("function"), parameterType, false, null, SourceElement.NO_SOURCE); + result, null, 0, Annotations.Companion.getEMPTY(), Name.identifier("function"), parameterType, + /* declaresDefaultValue = */ false, + /* isCrossinline = */ false, + /* isNoinline = */ false, + null, SourceElement.NO_SOURCE); JetType returnType = typeParameters.substitutor.substitute(samInterface.getDefaultType(), Variance.OUT_VARIANCE); assert returnType != null : "couldn't substitute type: " + samInterface.getDefaultType() + @@ -268,7 +272,11 @@ public class SingleAbstractMethodUtils { ValueParameterDescriptor newParam = new ValueParameterDescriptorImpl( samAdapter, null, originalParam.getIndex(), originalParam.getAnnotations(), - originalParam.getName(), newType, false, null, SourceElement.NO_SOURCE + originalParam.getName(), newType, + /* declaresDefaultValue = */ false, + /* isCrossinline = */ false, + /* isNoinline = */ false, + null, SourceElement.NO_SOURCE ); valueParameters.add(newParam); } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt index 5c0b3adaf3e..ba89afa2b9b 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/native.kt @@ -16,35 +16,23 @@ package org.jetbrains.kotlin.load.kotlin.nativeDeclarations -import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.DeclarationChecker -import org.jetbrains.kotlin.psi.JetDeclaration -import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.diagnostics.DiagnosticSink import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor -import org.jetbrains.kotlin.descriptors.ConstructorDescriptor -import org.jetbrains.kotlin.descriptors.Modality -import org.jetbrains.kotlin.diagnostics.Errors -import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm +import org.jetbrains.kotlin.psi.JetDeclaration import org.jetbrains.kotlin.psi.JetDeclarationWithBody import org.jetbrains.kotlin.resolve.BindingContext -import org.jetbrains.kotlin.resolve.annotations.hasInlineAnnotation -import org.jetbrains.kotlin.resolve.diagnostics.SuppressDiagnosticsByAnnotations +import org.jetbrains.kotlin.resolve.DeclarationChecker +import org.jetbrains.kotlin.resolve.DescriptorUtils import org.jetbrains.kotlin.resolve.diagnostics.FUNCTION_NO_BODY_ERRORS - -private val NATIVE_ANNOTATION_CLASS_NAME = FqName("kotlin.jvm.native") -private val EXTERNAL_ANNOTATION_CLASS_NAME = FqName("kotlin.external") - +import org.jetbrains.kotlin.resolve.diagnostics.SuppressDiagnosticsByAnnotations +import org.jetbrains.kotlin.resolve.inline.InlineUtil +import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm public fun DeclarationDescriptor.hasNativeAnnotation(): Boolean { - return getAnnotations().findAnnotation(EXTERNAL_ANNOTATION_CLASS_NAME) != null - || annotations.findAnnotation(NATIVE_ANNOTATION_CLASS_NAME) != null + return this is FunctionDescriptor && this.isExternal } -public class SuppressNoBodyErrorsForExternalDeclarations : SuppressDiagnosticsByAnnotations(FUNCTION_NO_BODY_ERRORS, EXTERNAL_ANNOTATION_CLASS_NAME) -public class SuppressNoBodyErrorsForNativeDeclarations : SuppressDiagnosticsByAnnotations(FUNCTION_NO_BODY_ERRORS, NATIVE_ANNOTATION_CLASS_NAME) - public class NativeFunChecker : DeclarationChecker { override fun check( declaration: JetDeclaration, @@ -66,7 +54,7 @@ public class NativeFunChecker : DeclarationChecker { diagnosticHolder.report(ErrorsJvm.EXTERNAL_DECLARATION_CANNOT_HAVE_BODY.on(declaration)) } - if (descriptor.hasInlineAnnotation()) { + if (InlineUtil.isInline(descriptor)) { diagnosticHolder.report(ErrorsJvm.EXTERNAL_DECLARATION_CANNOT_BE_INLINED.on(declaration)) } 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 527d68e41a2..7bb2de342dc 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 @@ -28,9 +28,9 @@ import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.DeclarationChecker import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.resolve.annotations.hasInlineAnnotation import org.jetbrains.kotlin.resolve.annotations.hasIntrinsicAnnotation import org.jetbrains.kotlin.resolve.annotations.hasPlatformStaticAnnotation +import org.jetbrains.kotlin.resolve.inline.InlineUtil import org.jetbrains.kotlin.resolve.jvm.annotations.hasJvmOverloadsAnnotation import org.jetbrains.kotlin.resolve.jvm.diagnostics.ErrorsJvm @@ -41,7 +41,7 @@ public class LocalFunInlineChecker : DeclarationChecker { descriptor: DeclarationDescriptor, diagnosticHolder: DiagnosticSink, bindingContext: BindingContext) { - if (descriptor.hasInlineAnnotation() && + if (InlineUtil.isInline(descriptor) && declaration is JetNamedFunction && descriptor is FunctionDescriptor && descriptor.getVisibility() == Visibilities.LOCAL) { @@ -217,9 +217,10 @@ public class ReifiedTypeParameterAnnotationChecker : DeclarationChecker { ) { if (descriptor.hasIntrinsicAnnotation()) return - if (descriptor is CallableDescriptor && !descriptor.hasInlineAnnotation()) { + if (descriptor is CallableDescriptor && !InlineUtil.isInline(descriptor)) { checkTypeParameterDescriptorsAreNotReified(descriptor.getTypeParameters(), diagnosticHolder) } + if (descriptor is ClassDescriptor) { checkTypeParameterDescriptorsAreNotReified(descriptor.getTypeConstructor().getParameters(), diagnosticHolder) } diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java index 6afc7d3fd7c..a3c623c1f8d 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/AlternativeMethodSignatureData.java @@ -229,6 +229,8 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD altName != null ? altName : originalParameterDescriptor.getName(), alternativeType, originalParameterDescriptor.declaresDefaultValue(), + originalParameterDescriptor.isCrossinline(), + originalParameterDescriptor.isNoinline(), alternativeVarargElementType, SourceElement.NO_SOURCE )); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java index ebdd57fc487..9840a884b1d 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/kotlinSignature/SignaturesPropagationData.java @@ -266,6 +266,8 @@ public class SignaturesPropagationData { stableName != null ? stableName : originalParam.getName(), altType, originalParam.declaresDefaultValue(), + originalParam.isCrossinline(), + originalParam.isNoinline(), varargCheckResult.isVararg ? DescriptorUtilsKt.getBuiltIns(originalParam).getArrayElementType(altType) : null, SourceElement.NO_SOURCE )); diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt index 58b266e3149..ea035835075 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/JavaSyntheticPropertiesScope.kt @@ -281,6 +281,7 @@ class JavaSyntheticPropertiesScope(storageManager: StorageManager) : JetScopeImp visibility, false, false, + getMethod.isExternal, CallableMemberDescriptor.Kind.SYNTHESIZED, null, SourceElement.NO_SOURCE) @@ -293,6 +294,7 @@ class JavaSyntheticPropertiesScope(storageManager: StorageManager) : JetScopeImp syntheticExtensionVisibility(setMethod), false, false, + setMethod.isExternal, CallableMemberDescriptor.Kind.SYNTHESIZED, null, SourceElement.NO_SOURCE) diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/SamAdapterFunctionsScope.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/SamAdapterFunctionsScope.kt index 532fe87f9bc..85697d95031 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/SamAdapterFunctionsScope.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/synthetic/SamAdapterFunctionsScope.kt @@ -30,9 +30,7 @@ import org.jetbrains.kotlin.resolve.scopes.DescriptorKindFilter import org.jetbrains.kotlin.resolve.scopes.JetScope import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.types.* -import java.util.ArrayList -import java.util.HashMap -import java.util.LinkedHashSet +import java.util.* import kotlin.properties.Delegates interface SamAdapterExtensionFunctionDescriptor : FunctionDescriptor { @@ -151,6 +149,9 @@ class SamAdapterFunctionsScope(storageManager: StorageManager) : JetScope by Jet newVisibility: Visibility, newIsOperator: Boolean, newIsInfix: Boolean, + newIsExternal: Boolean, + newIsInline: Boolean, + newIsTailrec: Boolean, original: FunctionDescriptor?, copyOverrides: Boolean, kind: CallableMemberDescriptor.Kind, @@ -159,7 +160,8 @@ class SamAdapterFunctionsScope(storageManager: StorageManager) : JetScope by Jet newReturnType: JetType ): FunctionDescriptor? { val descriptor = super.doSubstitute( - originalSubstitutor, newOwner, newModality, newVisibility, newIsOperator, newIsInfix, original, + originalSubstitutor, newOwner, newModality, newVisibility, + newIsOperator, newIsInfix, newIsExternal, newIsInline, newIsTailrec, original, copyOverrides, kind, newValueParameterDescriptors, newExtensionReceiverParameterType, newReturnType) as MyFunctionDescriptor? ?: return null diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java index 594cca2b472..954cc9984fe 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/JetFlowInformationProvider.java @@ -795,7 +795,7 @@ public class JetFlowInformationProvider { public void markTailCalls() { final DeclarationDescriptor subroutineDescriptor = trace.get(BindingContext.DECLARATION_TO_DESCRIPTOR, subroutine); if (!(subroutineDescriptor instanceof FunctionDescriptor)) return; - if (!KotlinBuiltIns.isTailRecursive(subroutineDescriptor)) return; + if (!((FunctionDescriptor) subroutineDescriptor).isTailrec()) return; // finally blocks are copied which leads to multiple diagnostics reported on one instruction class KindAndCall { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetTokens.java b/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetTokens.java index 65a98753ee1..47f016298cc 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetTokens.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/lexer/JetTokens.java @@ -216,11 +216,6 @@ public interface JetTokens { CONST_KEYWORD, OPERATOR_KEYWORD, INFIX_KEYWORD }; - // Please synchronize this array with org.jetbrains.kotlin.descriptors.annotations.ANNOTATION_MODIFIERS_FQ_NAMES - JetModifierKeywordToken[] ANNOTATION_MODIFIERS_KEYWORDS_ARRAY = new JetModifierKeywordToken[] { - DATA_KEYWORD, INLINE_KEYWORD, NOINLINE_KEYWORD, TAILREC_KEYWORD, EXTERNAL_KEYWORD, ANNOTATION_KEYWORD, CROSSINLINE_KEYWORD - }; - TokenSet MODIFIER_KEYWORDS = TokenSet.create(MODIFIER_KEYWORDS_ARRAY); TokenSet VISIBILITY_MODIFIERS = TokenSet.create(PRIVATE_KEYWORD, PUBLIC_KEYWORD, INTERNAL_KEYWORD, PROTECTED_KEYWORD); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt index 652c1dd93b2..148d92d043c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/JetClassOrObject.kt @@ -26,7 +26,6 @@ import com.intellij.psi.impl.source.codeStyle.CodeEditUtil import com.intellij.psi.stubs.IStubElementType import com.intellij.psi.util.PsiTreeUtil import org.jetbrains.kotlin.JetNodeTypes -import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.lexer.JetTokens import org.jetbrains.kotlin.psi.stubs.KotlinClassOrObjectStub import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes @@ -108,17 +107,7 @@ abstract public class JetClassOrObject : public fun getSecondaryConstructors(): List = getBody()?.getSecondaryConstructors().orEmpty() - public fun isAnnotation(): Boolean = - getAnnotation(KotlinBuiltIns.FQ_NAMES.annotation.shortName().asString()) != null || hasModifier(JetTokens.ANNOTATION_KEYWORD) - - private fun getAnnotation(name: String): JetAnnotationEntry? { - return getAnnotationEntries().firstOrNull() { entry -> - val typeReference = entry.getTypeReference() - val userType = typeReference?.getStubOrPsiChild(JetStubElementTypes.USER_TYPE) - - name == userType?.getReferencedName() - } - } + public fun isAnnotation(): Boolean = hasModifier(JetTokens.ANNOTATION_KEYWORD) public override fun delete() { CheckUtil.checkWritable(this); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileElementType.java b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileElementType.java index 09d77e9e401..d57370c5bdf 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileElementType.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/psi/stubs/elements/JetFileElementType.java @@ -34,7 +34,7 @@ import org.jetbrains.kotlin.psi.stubs.KotlinFileStub; import java.io.IOException; public class JetFileElementType extends IStubFileElementType { - public static final int STUB_VERSION = 61; + public static final int STUB_VERSION = 62; private static final String NAME = "kotlin.FILE"; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java index 8ce55f494e2..1de3597ed50 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationResolver.java @@ -18,14 +18,10 @@ package org.jetbrains.kotlin.resolve; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.annotations.*; import org.jetbrains.kotlin.diagnostics.Errors; -import org.jetbrains.kotlin.lexer.JetModifierKeywordToken; -import org.jetbrains.kotlin.lexer.JetTokens; import org.jetbrains.kotlin.psi.*; -import org.jetbrains.kotlin.resolve.annotations.AnnotationUtilKt; import org.jetbrains.kotlin.resolve.calls.CallResolver; import org.jetbrains.kotlin.resolve.calls.model.ResolvedValueArgument; import org.jetbrains.kotlin.resolve.calls.results.OverloadResolutionResults; @@ -55,19 +51,14 @@ public class AnnotationResolver { @NotNull private TypeResolver typeResolver; @NotNull private final ConstantExpressionEvaluator constantExpressionEvaluator; - @NotNull private final List modifiersAnnotations; - public AnnotationResolver( @NotNull CallResolver callResolver, @NotNull ConstantExpressionEvaluator constantExpressionEvaluator, - @NotNull StorageManager storageManager, - @NotNull KotlinBuiltIns kotlinBuiltIns + @NotNull StorageManager storageManager ) { this.callResolver = callResolver; this.constantExpressionEvaluator = constantExpressionEvaluator; this.storageManager = storageManager; - - modifiersAnnotations = AnnotationUtilKt.buildMigrationAnnotationDescriptors(kotlinBuiltIns); } @@ -123,31 +114,7 @@ public class AnnotationResolver { return Annotations.Companion.getEMPTY(); } - List annotationEntryElements = modifierList.getAnnotationEntries(); - - return resolveAndAppendAnnotationsFromModifiers( - resolveAnnotationEntries(scope, annotationEntryElements, trace, shouldResolveArguments), - modifierList - ); - } - - @NotNull - public Annotations resolveAndAppendAnnotationsFromModifiers( - @NotNull Annotations annotations, - @NotNull JetModifierList modifierList - ) { - List annotationFromModifiers = new ArrayList(); - - for (int i = 0; i < JetTokens.ANNOTATION_MODIFIERS_KEYWORDS_ARRAY.length; i++) { - JetModifierKeywordToken modifier = JetTokens.ANNOTATION_MODIFIERS_KEYWORDS_ARRAY[i]; - if (modifierList.hasModifier(modifier)) { - annotationFromModifiers.add(modifiersAnnotations.get(i)); - } - } - - if (annotationFromModifiers.isEmpty()) return annotations; - - return new CompositeAnnotations(annotations, new AnnotationsImpl(annotationFromModifiers)); + return resolveAnnotationEntries(scope, modifierList.getAnnotationEntries(), trace, shouldResolveArguments); } private Annotations resolveAnnotationEntries( diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt index b694f68498b..c7901b31ab4 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/AnnotationUtil.kt @@ -16,21 +16,14 @@ package org.jetbrains.kotlin.resolve.annotations -import org.jetbrains.kotlin.builtins.KotlinBuiltIns -import org.jetbrains.kotlin.descriptors.* +import org.jetbrains.kotlin.descriptors.CallableDescriptor +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.descriptors.PropertyAccessorDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor -import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptorImpl import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget import org.jetbrains.kotlin.descriptors.annotations.Annotations -import org.jetbrains.kotlin.lexer.JetTokens import org.jetbrains.kotlin.name.FqName -import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.DescriptorUtils -import org.jetbrains.kotlin.types.JetTypeImpl - -public fun DeclarationDescriptor.hasInlineAnnotation(): Boolean { - return getAnnotations().findAnnotation(FqName("kotlin.inline")) != null -} public fun DeclarationDescriptor.hasPlatformStaticAnnotation(): Boolean { return getAnnotations().findAnnotation(FqName("kotlin.platform.platformStatic")) != null || @@ -67,21 +60,4 @@ public fun AnnotationDescriptor.argumentValue(parameterName: String): Any? { return getAllValueArguments().entrySet() .singleOrNull { it.key.getName().asString() == parameterName } ?.value?.value -} - -public fun KotlinBuiltIns.buildMigrationAnnotationDescriptors(): List = - JetTokens.ANNOTATION_MODIFIERS_KEYWORDS_ARRAY.map { - modifierKeyword -> - - val name = Name.identifier(modifierKeyword.value) - val type = JetTypeImpl.create( - Annotations.EMPTY, - getBuiltInClassByNameNullable(name) ?: getAnnotationClassByName(name), - /* nullable = */false, /* arguments = */emptyList() - ) - - AnnotationDescriptorImpl( - type, - emptyMap(), SourceElement.NO_SOURCE - ) - } +} \ No newline at end of file diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassAnnotationChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassAnnotationChecker.kt index 979a162523c..05673d15831 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassAnnotationChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DataClassAnnotationChecker.kt @@ -16,10 +16,12 @@ package org.jetbrains.kotlin.resolve -import org.jetbrains.kotlin.psi.* -import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.diagnostics.* -import org.jetbrains.kotlin.builtins.* +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.diagnostics.DiagnosticSink +import org.jetbrains.kotlin.diagnostics.Errors +import org.jetbrains.kotlin.psi.JetClassOrObject +import org.jetbrains.kotlin.psi.JetDeclaration public class DataClassAnnotationChecker : DeclarationChecker { @@ -32,7 +34,7 @@ public class DataClassAnnotationChecker : DeclarationChecker { if (descriptor !is ClassDescriptor) return if (declaration !is JetClassOrObject) return - if (KotlinBuiltIns.isData(descriptor)) { + if (descriptor.isData) { if (descriptor.unsubstitutedPrimaryConstructor == null && descriptor.constructors.isNotEmpty()) { declaration.nameIdentifier?.let { diagnosticHolder.report(Errors.PRIMARY_CONSTRUCTOR_REQUIRED_FOR_DATA_CLASS.on(it)) } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java index e75992abd4b..d9cda69ef70 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DeclarationsChecker.java @@ -25,7 +25,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.diagnostics.DiagnosticFactory1; import org.jetbrains.kotlin.diagnostics.DiagnosticFactory0; import org.jetbrains.kotlin.diagnostics.Errors; import org.jetbrains.kotlin.lexer.JetModifierKeywordToken; @@ -714,6 +713,8 @@ public class DeclarationsChecker { DeclarationDescriptor containingDescriptor = functionDescriptor.getContainingDeclaration(); boolean hasAbstractModifier = function.hasModifier(JetTokens.ABSTRACT_KEYWORD); + boolean hasExternalModifier = function.hasModifier(JetTokens.EXTERNAL_KEYWORD); + if (containingDescriptor instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) containingDescriptor; boolean inTrait = classDescriptor.getKind() == ClassKind.INTERFACE; @@ -728,19 +729,19 @@ public class DeclarationsChecker { trace.report(ABSTRACT_FUNCTION_WITH_BODY.on(function, functionDescriptor)); } if (!hasBody && inTrait) { - if (function.hasModifier(JetTokens.FINAL_KEYWORD)) { + if (function.hasModifier(JetTokens.FINAL_KEYWORD) && !hasExternalModifier) { trace.report(FINAL_FUNCTION_WITH_NO_BODY.on(function, functionDescriptor)); } if (function.hasModifier(JetTokens.PRIVATE_KEYWORD)) { trace.report(PRIVATE_FUNCTION_WITH_NO_BODY.on(function, functionDescriptor)); } } - if (!hasBody && !hasAbstractModifier && !inTrait) { + if (!hasBody && !hasAbstractModifier && !hasExternalModifier && !inTrait) { trace.report(NON_ABSTRACT_FUNCTION_WITH_NO_BODY.on(function, functionDescriptor)); } return; } - if (!function.hasBody() && !hasAbstractModifier) { + if (!function.hasBody() && !hasAbstractModifier && !hasExternalModifier) { trace.report(NON_MEMBER_FUNCTION_NO_BODY.on(function, functionDescriptor)); } if (TypeUtilsKt.isNothing(functionDescriptor.getReturnType()) && !function.hasDeclaredReturnType()) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java index 1517ae08d6c..9b28337526e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/DescriptorResolver.java @@ -61,8 +61,7 @@ import java.util.*; import static org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget.*; import static org.jetbrains.kotlin.diagnostics.Errors.*; -import static org.jetbrains.kotlin.lexer.JetTokens.OVERRIDE_KEYWORD; -import static org.jetbrains.kotlin.lexer.JetTokens.VARARG_KEYWORD; +import static org.jetbrains.kotlin.lexer.JetTokens.*; import static org.jetbrains.kotlin.resolve.BindingContext.*; import static org.jetbrains.kotlin.resolve.DescriptorUtils.*; import static org.jetbrains.kotlin.resolve.ModifiersChecker.resolveModalityFromModifiers; @@ -278,6 +277,8 @@ public class DescriptorResolver { new ValueParameterDescriptorImpl(functionDescriptor, null, parameter.getIndex(), parameter.getAnnotations(), parameter.getName(), parameter.getType(), declaresDefaultValue, + parameter.isCrossinline(), + parameter.isNoinline(), parameter.getVarargElementType(), parameter.getSource()); parameterDescriptors.add(parameterDescriptor); if (declaresDefaultValue) { @@ -366,6 +367,8 @@ public class DescriptorResolver { JetPsiUtil.safeName(valueParameter.getName()), variableType, valueParameter.hasDefaultValue(), + valueParameter.hasModifier(CROSSINLINE_KEYWORD), + valueParameter.hasModifier(NOINLINE_KEYWORD), varargElementType, KotlinSourceElementKt.toSourceElement(valueParameter) ); @@ -1002,7 +1005,7 @@ public class DescriptorResolver { setterDescriptor = new PropertySetterDescriptorImpl(propertyDescriptor, annotations, resolveModalityFromModifiers(setter, propertyDescriptor.getModality()), resolveVisibilityFromModifiers(setter, propertyDescriptor.getVisibility()), - setter.hasBody(), false, + setter.hasBody(), false, setter.hasModifier(EXTERNAL_KEYWORD), CallableMemberDescriptor.Kind.DECLARATION, null, KotlinSourceElementKt .toSourceElement(setter)); if (parameter != null) { @@ -1042,7 +1045,8 @@ public class DescriptorResolver { } else if (property.isVar()) { Annotations setterAnnotations = annotationSplitter.getAnnotationsForTarget(PROPERTY_SETTER); - setterDescriptor = DescriptorFactory.createSetter(propertyDescriptor, setterAnnotations, !property.hasDelegate()); + setterDescriptor = DescriptorFactory.createSetter(propertyDescriptor, setterAnnotations, !property.hasDelegate(), + /* isExternal = */ false); } if (!property.isVar()) { @@ -1082,7 +1086,7 @@ public class DescriptorResolver { getterDescriptor = new PropertyGetterDescriptorImpl(propertyDescriptor, getterAnnotations, resolveModalityFromModifiers(getter, propertyDescriptor.getModality()), resolveVisibilityFromModifiers(getter, propertyDescriptor.getVisibility()), - getter.hasBody(), false, + getter.hasBody(), false, getter.hasModifier(EXTERNAL_KEYWORD), CallableMemberDescriptor.Kind.DECLARATION, null, KotlinSourceElementKt .toSourceElement(getter)); getterDescriptor.initialize(returnType); @@ -1090,7 +1094,8 @@ public class DescriptorResolver { } else { Annotations getterAnnotations = annotationSplitter.getAnnotationsForTarget(PROPERTY_GETTER); - getterDescriptor = DescriptorFactory.createGetter(propertyDescriptor, getterAnnotations, !property.hasDelegate()); + getterDescriptor = DescriptorFactory.createGetter(propertyDescriptor, getterAnnotations, !property.hasDelegate(), + /* isExternal = */ false); getterDescriptor.initialize(propertyDescriptor.getType()); } return getterDescriptor; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt index 70d3b71daf1..30ff42fb391 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorResolver.kt @@ -29,7 +29,9 @@ import org.jetbrains.kotlin.diagnostics.Errors.* import org.jetbrains.kotlin.lexer.JetTokens import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.* -import org.jetbrains.kotlin.resolve.DescriptorResolver.* +import org.jetbrains.kotlin.resolve.DescriptorResolver.getDefaultModality +import org.jetbrains.kotlin.resolve.DescriptorResolver.getDefaultVisibility +import org.jetbrains.kotlin.resolve.DescriptorResolver.transformAnonymousTypeIfNeeded import org.jetbrains.kotlin.resolve.DescriptorUtils.getDispatchReceiverParameterIfNeeded import org.jetbrains.kotlin.resolve.DescriptorUtils.isFunctionExpression import org.jetbrains.kotlin.resolve.DescriptorUtils.isFunctionLiteral @@ -178,6 +180,9 @@ class FunctionDescriptorResolver( ) functionDescriptor.isOperator = function.hasModifier(JetTokens.OPERATOR_KEYWORD) functionDescriptor.isInfix = function.hasModifier(JetTokens.INFIX_KEYWORD) + functionDescriptor.isExternal = function.hasModifier(JetTokens.EXTERNAL_KEYWORD) + functionDescriptor.isInline = function.hasModifier(JetTokens.INLINE_KEYWORD) + functionDescriptor.isTailrec = function.hasModifier(JetTokens.TAILREC_KEYWORD) receiverType?.let { ForceResolveUtil.forceResolveAllContents(it.getAnnotations()) } for (valueParameterDescriptor in valueParameterDescriptors) { ForceResolveUtil.forceResolveAllContents(valueParameterDescriptor.getType().getAnnotations()) @@ -198,6 +203,7 @@ class FunctionDescriptorResolver( val valueParameterDescriptor = expectedValueParameters.first() val it = ValueParameterDescriptorImpl(functionDescriptor, null, 0, Annotations.EMPTY, Name.identifier("it"), valueParameterDescriptor.getType(), valueParameterDescriptor.declaresDefaultValue(), + valueParameterDescriptor.isCrossinline, valueParameterDescriptor.isNoinline, valueParameterDescriptor.getVarargElementType(), SourceElement.NO_SOURCE) trace.record(BindingContext.AUTO_CREATED_IT, it) return listOf(it) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java index 936b47ed4d7..0cf7d052a19 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/FunctionDescriptorUtil.java @@ -141,6 +141,8 @@ public class FunctionDescriptorUtil { parameter.getName(), returnType, parameter.declaresDefaultValue(), + parameter.isCrossinline(), + parameter.isNoinline(), parameter.getVarargElementType(), SourceElement.NO_SOURCE ) @@ -158,6 +160,9 @@ public class FunctionDescriptorUtil { function.getVisibility()); descriptor.setOperator(function.isOperator()); descriptor.setInfix(function.isInfix()); + descriptor.setExternal(function.isExternal()); + descriptor.setInline(function.isInline()); + descriptor.setTailrec(function.isTailrec()); return descriptor; } } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt index 45979742ca1..a66625e5d3f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/ModifiersChecker.kt @@ -77,7 +77,7 @@ public object ModifierCheckerCore { COMPANION_KEYWORD to EnumSet.of(OBJECT), LATEINIT_KEYWORD to EnumSet.of(MEMBER_PROPERTY), DATA_KEYWORD to EnumSet.of(CLASS_ONLY, INNER_CLASS, LOCAL_CLASS), - INLINE_KEYWORD to EnumSet.of(FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER, PROPERTY), + INLINE_KEYWORD to EnumSet.of(FUNCTION), NOINLINE_KEYWORD to EnumSet.of(VALUE_PARAMETER), TAILREC_KEYWORD to EnumSet.of(FUNCTION), EXTERNAL_KEYWORD to EnumSet.of(FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER), diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java index 94a36ad7b05..06d55d2b298 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/OverrideResolver.java @@ -31,9 +31,7 @@ import kotlin.jvm.functions.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.ReadOnly; -import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.kotlin.incremental.components.NoLookupLocation; import org.jetbrains.kotlin.lexer.JetTokens; import org.jetbrains.kotlin.name.Name; @@ -733,7 +731,7 @@ public class OverrideResolver { } private void checkOverrideForComponentFunction(@NotNull final CallableMemberDescriptor componentFunction) { - final PsiElement dataAnnotation = findDataAnnotationForDataClass(componentFunction.getContainingDeclaration()); + final PsiElement dataModifier = findDataModifierForDataClass(componentFunction.getContainingDeclaration()); checkOverridesForMemberMarkedOverride(componentFunction, false, new CheckOverrideReportStrategy() { private boolean overrideConflict = false; @@ -742,7 +740,7 @@ public class OverrideResolver { public void overridingFinalMember(@NotNull CallableMemberDescriptor overridden) { if (!overrideConflict) { overrideConflict = true; - trace.report(DATA_CLASS_OVERRIDE_CONFLICT.on(dataAnnotation, componentFunction, overridden.getContainingDeclaration())); + trace.report(DATA_CLASS_OVERRIDE_CONFLICT.on(dataModifier, componentFunction, overridden.getContainingDeclaration())); } } @@ -750,7 +748,7 @@ public class OverrideResolver { public void returnTypeMismatchOnOverride(@NotNull CallableMemberDescriptor overridden) { if (!overrideConflict) { overrideConflict = true; - trace.report(DATA_CLASS_OVERRIDE_CONFLICT.on(dataAnnotation, componentFunction, overridden.getContainingDeclaration())); + trace.report(DATA_CLASS_OVERRIDE_CONFLICT.on(dataModifier, componentFunction, overridden.getContainingDeclaration())); } } @@ -777,16 +775,7 @@ public class OverrideResolver { } @NotNull - private static PsiElement findDataAnnotationForDataClass(@NotNull DeclarationDescriptor dataClass) { - AnnotationDescriptor annotation = dataClass.getAnnotations().findAnnotation(KotlinBuiltIns.FQ_NAMES.data); - if (annotation != null) { - JetAnnotationEntry entry = DescriptorToSourceUtils.getSourceFromAnnotation(annotation); - if (entry != null) { - return entry; - } - } - - + private static PsiElement findDataModifierForDataClass(@NotNull DeclarationDescriptor dataClass) { JetClass classDeclaration = (JetClass) DescriptorToSourceUtils.getSourceFromDescriptor(dataClass); if (classDeclaration != null && classDeclaration.getModifierList() != null) { PsiElement modifier = classDeclaration.getModifierList().getModifier(JetTokens.DATA_KEYWORD); @@ -795,7 +784,7 @@ public class OverrideResolver { } } - throw new IllegalStateException("No data annotation is found for data class " + dataClass); + throw new IllegalStateException("No data modifier is found for data class " + dataClass); } @Nullable diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt index 2a4fa6a111c..92422e84752 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/dynamicCalls.kt @@ -24,7 +24,6 @@ import org.jetbrains.kotlin.incremental.components.LookupLocation import org.jetbrains.kotlin.lexer.JetTokens import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.* -import org.jetbrains.kotlin.resolve.BindingTrace import org.jetbrains.kotlin.resolve.DescriptorFactory import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollector import org.jetbrains.kotlin.resolve.calls.tasks.collectors.CallableDescriptorCollectors @@ -166,7 +165,9 @@ class DynamicCallableDescriptors(private val builtIns: KotlinBuiltIns) { Annotations.EMPTY, arg.getArgumentName()?.asName ?: Name.identifier("p$index"), outType, - false, + /* declaresDefaultValue = */ false, + /* isCrossinline = */ false, + /* isNoinline = */ false, varargElementType, SourceElement.NO_SOURCE )) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt index 7ca0e497f3e..ef2115554f3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/synthesizedInvokes.kt @@ -27,7 +27,7 @@ import org.jetbrains.kotlin.descriptors.impl.ValueParameterDescriptorImpl import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.types.TypeSubstitutor import org.jetbrains.kotlin.util.OperatorNameConventions -import java.util.ArrayList +import java.util.* fun createSynthesizedInvokes(functions: Collection): Collection { val result = ArrayList(1) @@ -75,7 +75,7 @@ private fun createSynthesizedFunctionWithFirstParameterAsReceiver(descriptor: Fu original.getValueParameters().drop(1).map { p -> ValueParameterDescriptorImpl( result, null, p.getIndex() - 1, p.getAnnotations(), Name.identifier("p${p.getIndex() + 1}"), p.getType(), - p.declaresDefaultValue(), p.getVarargElementType(), p.getSource() + p.declaresDefaultValue(), p.isCrossinline, p.isNoinline, p.getVarargElementType(), p.getSource() ) }, original.getReturnType(), @@ -84,6 +84,9 @@ private fun createSynthesizedFunctionWithFirstParameterAsReceiver(descriptor: Fu ) result.isOperator = original.isOperator result.isInfix = original.isInfix + result.isExternal = original.isExternal + result.isInline = original.isInline + result.isTailrec = original.isTailrec return result } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java index a3869c6358b..5960c12737c 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/inline/InlineUtil.java @@ -22,7 +22,6 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.descriptors.*; -import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.BindingContext; import org.jetbrains.kotlin.resolve.BindingTrace; @@ -31,14 +30,11 @@ import org.jetbrains.kotlin.resolve.calls.callUtil.CallUtilKt; import org.jetbrains.kotlin.resolve.calls.model.ArgumentMapping; import org.jetbrains.kotlin.resolve.calls.model.ArgumentMatch; import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; -import org.jetbrains.kotlin.resolve.constants.ConstantValue; -import org.jetbrains.kotlin.resolve.constants.EnumValue; - -import static kotlin.CollectionsKt.firstOrNull; public class InlineUtil { public static boolean isInlineLambdaParameter(@NotNull ParameterDescriptor valueParameterOrReceiver) { - return !KotlinBuiltIns.isNoinline(valueParameterOrReceiver) && + return !(valueParameterOrReceiver instanceof ValueParameterDescriptor + && ((ValueParameterDescriptor) valueParameterOrReceiver).isNoinline()) && KotlinBuiltIns.isExactFunctionOrExtensionFunctionType(valueParameterOrReceiver.getOriginal().getType()); } @@ -48,20 +44,12 @@ public class InlineUtil { @NotNull public static InlineStrategy getInlineStrategy(@NotNull DeclarationDescriptor descriptor) { - AnnotationDescriptor annotation = descriptor.getAnnotations().findAnnotation(KotlinBuiltIns.FQ_NAMES.inline); - if (annotation == null) { - return InlineStrategy.NOT_INLINE; - } - ConstantValue argument = firstOrNull(annotation.getAllValueArguments().values()); - if (argument == null) { + if (descriptor instanceof FunctionDescriptor && + ((FunctionDescriptor) descriptor).isInline()) { return InlineStrategy.AS_FUNCTION; } - assert argument instanceof EnumValue : "Inline annotation parameter should be enum entry but was: " + argument; - return InlineStrategy.valueOf(((EnumValue) argument).getValue().getName().asString()); - } - public static boolean hasOnlyLocalReturn(@NotNull ValueParameterDescriptor descriptor) { - return descriptor.getAnnotations().findAnnotation(KotlinBuiltIns.FQ_NAMES.crossinline) != null; + return InlineStrategy.NOT_INLINE; } public static boolean checkNonLocalReturnUsage( @@ -141,7 +129,7 @@ public class InlineUtil { public static boolean allowsNonLocalReturns(@NotNull CallableDescriptor lambda) { if (lambda instanceof ValueParameterDescriptor) { - if (hasOnlyLocalReturn((ValueParameterDescriptor) lambda)) { + if (((ValueParameterDescriptor) lambda).isCrossinline()) { //annotated return false; } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java index 55d321869f1..7c4489459d7 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassDescriptor.java @@ -34,6 +34,7 @@ import org.jetbrains.kotlin.descriptors.*; import org.jetbrains.kotlin.descriptors.annotations.Annotations; import org.jetbrains.kotlin.descriptors.impl.ClassDescriptorBase; import org.jetbrains.kotlin.incremental.components.NoLookupLocation; +import org.jetbrains.kotlin.lexer.JetTokens; import org.jetbrains.kotlin.name.Name; import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.*; @@ -83,6 +84,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes private final Visibility visibility; private final NotNullLazyValue kind; private final NotNullLazyValue isInner; + private final NotNullLazyValue isData; private final Annotations annotations; private final Annotations danglingAnnotations; @@ -153,15 +155,22 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes } }); + this.isData = storageManager.createLazyValue(new Function0() { + @Override + public Boolean invoke() { + return modifierList != null && modifierList.hasModifier(JetTokens.DATA_KEYWORD); + } + }); + this.kind = storageManager.createLazyValue(new Function0() { @Override public ClassKind invoke() { - return (syntaxKind == ClassKind.CLASS && KotlinBuiltIns.isAnnotation(descriptor)) ? ClassKind.ANNOTATION_CLASS : syntaxKind; + return (syntaxKind == ClassKind.CLASS && modifierList != null && modifierList.hasModifier(JetTokens.ANNOTATION_KEYWORD)) ? ClassKind.ANNOTATION_CLASS : syntaxKind; } }); if (modifierList != null) { - LazyAnnotations classAnnotations = new LazyAnnotations( + this.annotations = new LazyAnnotations( new LazyAnnotationsContext( c.getAnnotationResolver(), storageManager, @@ -175,9 +184,6 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes }, modifierList.getAnnotationEntries() ); - this.annotations = c.getAnnotationResolver().resolveAndAppendAnnotationsFromModifiers( - classAnnotations, modifierList - ); } else { this.annotations = Annotations.Companion.getEMPTY(); @@ -405,6 +411,11 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements ClassDes return isInner.invoke(); } + @Override + public boolean isData() { + return isData.invoke(); + } + @Override public boolean isCompanionObject() { return isCompanionObject; diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt index 976a246773e..12d5f0170be 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyClassMemberScope.kt @@ -17,7 +17,6 @@ package org.jetbrains.kotlin.resolve.lazy.descriptors import com.google.common.collect.Lists -import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.* import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.DELEGATION import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor.Kind.FAKE_OVERRIDE @@ -136,7 +135,7 @@ public open class LazyClassMemberScope( } private fun generateDataClassMethods(result: MutableCollection, name: Name, location: LookupLocation) { - if (!KotlinBuiltIns.isData(thisDescriptor)) return + if (!thisDescriptor.isData) return val constructor = getPrimaryConstructor() ?: return @@ -243,7 +242,7 @@ public open class LazyClassMemberScope( } private fun addDataClassMethods(result: MutableCollection, location: LookupLocation) { - if (!KotlinBuiltIns.isData(thisDescriptor)) return + if (!thisDescriptor.isData) return if (getPrimaryConstructor() == null) return diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt index b5f82d980d5..3e9245010d0 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/lazy/descriptors/LazyScriptDescriptor.kt @@ -32,7 +32,8 @@ import org.jetbrains.kotlin.resolve.ScriptBodyResolver import org.jetbrains.kotlin.resolve.lazy.ForceResolveUtil import org.jetbrains.kotlin.resolve.lazy.LazyEntity import org.jetbrains.kotlin.resolve.lazy.ResolveSession -import org.jetbrains.kotlin.resolve.scopes.* +import org.jetbrains.kotlin.resolve.scopes.LexicalScope +import org.jetbrains.kotlin.resolve.scopes.LexicalScopeImpl import org.jetbrains.kotlin.resolve.scopes.receivers.ScriptReceiver import org.jetbrains.kotlin.resolve.source.toSourceElement import org.jetbrains.kotlin.types.DeferredType @@ -78,7 +79,10 @@ public class LazyScriptDescriptor( scriptDefinition.getScriptParameters().mapIndexed { index, scriptParameter -> ValueParameterDescriptorImpl( result, null, index, Annotations.EMPTY, scriptParameter.getName(), scriptParameter.getType(), - false, null, SourceElement.NO_SOURCE + /* declaresDefaultValue = */ false, + /* isCrossinline = */ false, + /* isNoinline = */ false, + null, SourceElement.NO_SOURCE ) }, DeferredType.create(resolveSession.storageManager, resolveSession.trace) { diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java index 28b41074cf8..116406c992d 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingUtils.java @@ -118,7 +118,11 @@ public class ControlStructureTypingUtils { JetType argumentType = isArgumentNullable.get(i) ? nullableType : type; ValueParameterDescriptorImpl valueParameter = new ValueParameterDescriptorImpl( function, null, i, Annotations.Companion.getEMPTY(), Name.identifier(argumentNames.get(i)), - argumentType, false, null, SourceElement.NO_SOURCE + argumentType, + /* declaresDefaultValue = */ false, + /* isCrossinline = */ false, + /* isNoinline = */ false, + null, SourceElement.NO_SOURCE ); valueParameters.add(valueParameter); } diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt index e3affaf7df5..114eca714e2 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/FunctionsTypingVisitor.kt @@ -25,6 +25,7 @@ import org.jetbrains.kotlin.descriptors.impl.AnonymousFunctionDescriptor import org.jetbrains.kotlin.descriptors.impl.SimpleFunctionDescriptorImpl import org.jetbrains.kotlin.diagnostics.DiagnosticUtils import org.jetbrains.kotlin.diagnostics.Errors.* +import org.jetbrains.kotlin.lexer.JetTokens import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.psiUtil.getAnnotationEntries import org.jetbrains.kotlin.resolve.* @@ -38,7 +39,6 @@ import org.jetbrains.kotlin.types.TypeUtils import org.jetbrains.kotlin.types.TypeUtils.CANT_INFER_FUNCTION_PARAM_TYPE import org.jetbrains.kotlin.types.TypeUtils.NO_EXPECTED_TYPE import org.jetbrains.kotlin.types.TypeUtils.noExpectedType -import org.jetbrains.kotlin.types.checker.JetTypeChecker import org.jetbrains.kotlin.types.expressions.CoercionStrategy.COERCION_TO_UNIT import org.jetbrains.kotlin.types.expressions.typeInfoFactory.createTypeInfo import org.jetbrains.kotlin.utils.addIfNotNull @@ -104,7 +104,7 @@ public class FunctionsTypingVisitor(facade: ExpressionTypingInternals) : Express components.modifiersChecker.withTrace(context.trace).checkModifiersForLocalDeclaration(function, functionDescriptor) components.identifierChecker.checkDeclaration(function, context.trace) - if (!function.hasBody()) { + if (!function.hasBody() && !function.hasModifier(JetTokens.EXTERNAL_KEYWORD)) { context.trace.report(NON_MEMBER_FUNCTION_NO_BODY.on(function, functionDescriptor)) } diff --git a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java index f193735b914..c87c51e8cca 100644 --- a/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java +++ b/compiler/serialization/src/org/jetbrains/kotlin/serialization/DescriptorSerializer.java @@ -125,7 +125,8 @@ public class DescriptorSerializer { ProtoBuf.Class.Builder builder = ProtoBuf.Class.newBuilder(); int flags = Flags.getClassFlags(hasAnnotations(classDescriptor), classDescriptor.getVisibility(), classDescriptor.getModality(), - classDescriptor.getKind(), classDescriptor.isInner(), classDescriptor.isCompanionObject()); + classDescriptor.getKind(), classDescriptor.isInner(), classDescriptor.isCompanionObject(), + classDescriptor.isData()); if (flags != builder.getFlags()) { builder.setFlags(flags); } @@ -211,6 +212,7 @@ public class DescriptorSerializer { hasAnnotations, descriptor.getVisibility(), descriptor.getModality(), + false, false ); @@ -283,7 +285,8 @@ public class DescriptorSerializer { int flags = Flags.getFunctionFlags( hasAnnotations(descriptor), descriptor.getVisibility(), descriptor.getModality(), descriptor.getKind(), - descriptor.isOperator(), descriptor.isInfix() + descriptor.isOperator(), descriptor.isInfix(), descriptor.isInline(), descriptor.isTailrec(), + descriptor.isExternal() ); if (flags != builder.getFlags()) { builder.setFlags(flags); @@ -355,7 +358,8 @@ public class DescriptorSerializer { hasAnnotations(accessor), accessor.getVisibility(), accessor.getModality(), - !accessor.isDefault() + !accessor.isDefault(), + accessor.isExternal() ); } @@ -363,7 +367,8 @@ public class DescriptorSerializer { private ProtoBuf.ValueParameter.Builder valueParameter(@NotNull ValueParameterDescriptor descriptor) { ProtoBuf.ValueParameter.Builder builder = ProtoBuf.ValueParameter.newBuilder(); - int flags = Flags.getValueParameterFlags(hasAnnotations(descriptor), descriptor.declaresDefaultValue()); + int flags = Flags.getValueParameterFlags(hasAnnotations(descriptor), descriptor.declaresDefaultValue(), + descriptor.isCrossinline(), descriptor.isNoinline()); if (flags != builder.getFlags()) { builder.setFlags(flags); } diff --git a/compiler/testData/builtin-classes.txt b/compiler/testData/builtin-classes.txt index f25116b6aef..a808276d83e 100644 --- a/compiler/testData/builtin-classes.txt +++ b/compiler/testData/builtin-classes.txt @@ -289,7 +289,7 @@ public interface Comparable { public abstract operator fun compareTo(/*0*/ other: T): kotlin.Int } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.PROPERTY_GETTER}) @kotlin.annotation.MustBeDocumented() @kotlin.annotation.annotation() public final class Deprecated : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.PROPERTY_GETTER}) @kotlin.annotation.MustBeDocumented() public final annotation class Deprecated : kotlin.Annotation { /*primary*/ public constructor Deprecated(/*0*/ message: kotlin.String, /*1*/ replaceWith: kotlin.ReplaceWith = ..., /*2*/ level: kotlin.DeprecationLevel = ...) public final val level: kotlin.DeprecationLevel public final fun (): kotlin.DeprecationLevel @@ -468,7 +468,7 @@ public abstract class Enum> : kotlin.Comparable { } } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.MustBeDocumented() @kotlin.annotation.annotation() public final class Extension : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.MustBeDocumented() public final annotation class Extension : kotlin.Annotation { /*primary*/ public constructor Extension() } @@ -621,7 +621,7 @@ public interface FloatingPointConstants { public interface Function { } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.CONSTRUCTOR}) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) @kotlin.annotation.MustBeDocumented() @kotlin.Deprecated(message = "Use @Deprecated("...", level = DeprecationLevel.HIDDEN) instead", replaceWith = kotlin.ReplaceWith(expression = "@Deprecated(, level = DeprecationLevel.HIDDEN)", imports = {})) @kotlin.annotation.annotation() public final class HiddenDeclaration : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.CONSTRUCTOR}) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) @kotlin.annotation.MustBeDocumented() @kotlin.Deprecated(message = "Use @Deprecated("...", level = DeprecationLevel.HIDDEN) instead", replaceWith = kotlin.ReplaceWith(expression = "@Deprecated(, level = DeprecationLevel.HIDDEN)", imports = {})) public final annotation class HiddenDeclaration : kotlin.Annotation { /*primary*/ public constructor HiddenDeclaration() } @@ -1104,7 +1104,7 @@ public interface Range> { public open fun isEmpty(): kotlin.Boolean } -@kotlin.annotation.Target(allowedTargets = {}) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) @kotlin.annotation.MustBeDocumented() @kotlin.annotation.annotation() public final class ReplaceWith : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {}) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) @kotlin.annotation.MustBeDocumented() public final annotation class ReplaceWith : kotlin.Annotation { /*primary*/ public constructor ReplaceWith(/*0*/ expression: kotlin.String, /*1*/ vararg imports: kotlin.String /*kotlin.Array*/) public final val expression: kotlin.String public final fun (): kotlin.String @@ -1265,7 +1265,7 @@ public final class String : kotlin.Comparable, kotlin.CharSequenc } } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.FIELD, AnnotationTarget.LOCAL_VARIABLE, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.TYPE, AnnotationTarget.EXPRESSION, AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.annotation() public final class Suppress : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.PROPERTY, AnnotationTarget.FIELD, AnnotationTarget.LOCAL_VARIABLE, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.TYPE, AnnotationTarget.EXPRESSION, AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final annotation class Suppress : kotlin.Annotation { /*primary*/ public constructor Suppress(/*0*/ vararg names: kotlin.String /*kotlin.Array*/) public final val names: kotlin.Array public final fun (): kotlin.Array @@ -1284,30 +1284,6 @@ public object Unit { /*primary*/ private constructor Unit() } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.MustBeDocumented() @kotlin.annotation.annotation() public final class UnsafeVariance : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.MustBeDocumented() public final annotation class UnsafeVariance : kotlin.Annotation { /*primary*/ public constructor UnsafeVariance() } - -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented() @kotlin.annotation.annotation() private final class crossinline : kotlin.Annotation { - /*primary*/ public constructor crossinline() -} - -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) @kotlin.annotation.MustBeDocumented() @kotlin.annotation.annotation() private final class data : kotlin.Annotation { - /*primary*/ public constructor data() -} - -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.MustBeDocumented() @kotlin.annotation.annotation() private final class external : kotlin.Annotation { - /*primary*/ public constructor external() -} - -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented() @kotlin.annotation.annotation() private final class inline : kotlin.Annotation { - /*primary*/ public constructor inline() -} - -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.MustBeDocumented() @kotlin.annotation.annotation() private final class noinline : kotlin.Annotation { - /*primary*/ public constructor noinline() -} - -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.annotation() private final class tailrec : kotlin.Annotation { - /*primary*/ public constructor tailrec() -} diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgs.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgs.txt index 38654872399..1e8d7ae0b64 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgs.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/defaultArgs.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ x: kotlin.Int = ..., /*1*/ e: kotlin.Any = ...): kotlin.Unit +public tailrec fun test(/*0*/ x: kotlin.Int = ..., /*1*/ e: kotlin.Any = ...): kotlin.Unit diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/extensionTailCall.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/extensionTailCall.txt index c2fc2c635d6..48175789377 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/extensionTailCall.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/extensionTailCall.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun kotlin.Int.foo(/*0*/ x: kotlin.Int): kotlin.Unit +public tailrec fun kotlin.Int.foo(/*0*/ x: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNoTails.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNoTails.txt index 6dc95f0a1c8..7ecae67b1cb 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNoTails.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNoTails.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun noTails(): kotlin.Unit +public tailrec fun noTails(): kotlin.Unit diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNonTailRecursions.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNonTailRecursions.txt index 3784a0d75db..34acf2c57af 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNonTailRecursions.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/functionWithNonTailRecursions.txt @@ -1,4 +1,4 @@ package -@kotlin.tailrec() public fun badTails(/*0*/ x: kotlin.Int): kotlin.Int +public tailrec fun badTails(/*0*/ x: kotlin.Int): kotlin.Int public fun box(): kotlin.String diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixCall.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixCall.txt index cce36af9c13..013cb7ee7b5 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixCall.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixCall.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public infix fun kotlin.Int.test(/*0*/ x: kotlin.Int): kotlin.Int +public infix tailrec fun kotlin.Int.test(/*0*/ x: kotlin.Int): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixRecursiveCall.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixRecursiveCall.txt index 76d50de06e3..641a4681712 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixRecursiveCall.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/infixRecursiveCall.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public infix fun kotlin.Int.foo(/*0*/ x: kotlin.Int): kotlin.Unit +public infix tailrec fun kotlin.Int.foo(/*0*/ x: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/insideElvis.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/insideElvis.txt index 9a9f1c2baaf..4322f6cd06e 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/insideElvis.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/insideElvis.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ counter: kotlin.Int): kotlin.Int? +public tailrec fun test(/*0*/ counter: kotlin.Int): kotlin.Int? diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/labeledThisReferences.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/labeledThisReferences.txt index 29ab9b70a61..26d9a88dbad 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/labeledThisReferences.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/labeledThisReferences.txt @@ -13,8 +13,8 @@ public final class B { public final inner class C { public constructor C() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.tailrec() public final fun h(/*0*/ counter: kotlin.Int): kotlin.Unit - @kotlin.tailrec() public final fun h2(/*0*/ x: kotlin.Any): kotlin.Unit + public final tailrec fun h(/*0*/ counter: kotlin.Int): kotlin.Unit + public final tailrec fun h2(/*0*/ x: kotlin.Any): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/loops.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/loops.txt index f9b66efa9b3..865b86f16eb 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/loops.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/loops.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ x: kotlin.Int): kotlin.Int +public tailrec fun test(/*0*/ x: kotlin.Int): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/multilevelBlocks.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/multilevelBlocks.txt index f9b66efa9b3..865b86f16eb 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/multilevelBlocks.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/multilevelBlocks.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ x: kotlin.Int): kotlin.Int +public tailrec fun test(/*0*/ x: kotlin.Int): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realIteratorFoldl.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realIteratorFoldl.txt index ee292ddc82e..56ce9124c04 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realIteratorFoldl.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realIteratorFoldl.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun kotlin.Iterator.foldl(/*0*/ acc: A, /*1*/ foldFunction: (T, A) -> A): A +public tailrec fun kotlin.Iterator.foldl(/*0*/ acc: A, /*1*/ foldFunction: (T, A) -> A): A diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringEscape.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringEscape.txt index 5ddd9697cbe..dbf328d0065 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringEscape.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringEscape.txt @@ -2,4 +2,4 @@ package public fun box(): kotlin.String public fun escapeChar(/*0*/ c: kotlin.Char): kotlin.String? -@kotlin.tailrec() public fun kotlin.String.escape(/*0*/ i: kotlin.Int = ..., /*1*/ result: java.lang.StringBuilder = ...): kotlin.String +public tailrec fun kotlin.String.escape(/*0*/ i: kotlin.Int = ..., /*1*/ result: java.lang.StringBuilder = ...): kotlin.String diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringRepeat.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringRepeat.txt index fa1ae492991..45afb437de6 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringRepeat.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/realStringRepeat.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun kotlin.String.repeat(/*0*/ num: kotlin.Int, /*1*/ acc: java.lang.StringBuilder = ...): kotlin.String +public tailrec fun kotlin.String.repeat(/*0*/ num: kotlin.Int, /*1*/ acc: java.lang.StringBuilder = ...): kotlin.String diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLambda.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLambda.txt index f67a5cac887..8c24a2ff136 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLambda.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLambda.txt @@ -2,4 +2,4 @@ package public fun bar(/*0*/ a: kotlin.Any): kotlin.Unit public fun box(): kotlin.String -@kotlin.tailrec() public fun foo(): kotlin.Unit +public tailrec fun foo(): kotlin.Unit diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLocalFunction.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLocalFunction.txt index 025c3fafc78..091eb5de165 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLocalFunction.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/recursiveCallInLocalFunction.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun foo(): kotlin.Unit +public tailrec fun foo(): kotlin.Unit diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnIf.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnIf.txt index f9b66efa9b3..865b86f16eb 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnIf.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnIf.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ x: kotlin.Int): kotlin.Int +public tailrec fun test(/*0*/ x: kotlin.Int): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInCatch.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInCatch.txt index d7d560c9540..fe405335127 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInCatch.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInCatch.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ counter: kotlin.Int): kotlin.Int +public tailrec fun test(/*0*/ counter: kotlin.Int): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInFinally.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInFinally.txt index d7d560c9540..fe405335127 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInFinally.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInFinally.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ counter: kotlin.Int): kotlin.Int +public tailrec fun test(/*0*/ counter: kotlin.Int): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInIfInFinally.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInIfInFinally.txt index d7d560c9540..fe405335127 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInIfInFinally.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInIfInFinally.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ counter: kotlin.Int): kotlin.Int +public tailrec fun test(/*0*/ counter: kotlin.Int): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInParentheses.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInParentheses.txt index 673c6b58634..4fd18812fe0 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInParentheses.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInParentheses.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun foo(/*0*/ x: kotlin.Int): kotlin.Unit +public tailrec fun foo(/*0*/ x: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInTry.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInTry.txt index d7d560c9540..fe405335127 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInTry.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/returnInTry.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ counter: kotlin.Int): kotlin.Int +public tailrec fun test(/*0*/ counter: kotlin.Int): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleBlock.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleBlock.txt index f9b66efa9b3..865b86f16eb 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleBlock.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleBlock.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ x: kotlin.Int): kotlin.Int +public tailrec fun test(/*0*/ x: kotlin.Int): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturn.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturn.txt index f9b66efa9b3..865b86f16eb 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturn.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturn.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ x: kotlin.Int): kotlin.Int +public tailrec fun test(/*0*/ x: kotlin.Int): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturnWithElse.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturnWithElse.txt index f9b66efa9b3..865b86f16eb 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturnWithElse.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/simpleReturnWithElse.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ x: kotlin.Int): kotlin.Int +public tailrec fun test(/*0*/ x: kotlin.Int): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/sum.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/sum.txt index 3bfd89bd660..cc7cff75ba0 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/sum.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/sum.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun sum(/*0*/ x: kotlin.Long, /*1*/ sum: kotlin.Long): kotlin.Long +public tailrec fun sum(/*0*/ x: kotlin.Long, /*1*/ sum: kotlin.Long): kotlin.Long diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInBlockInParentheses.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInBlockInParentheses.txt index 673c6b58634..4fd18812fe0 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInBlockInParentheses.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInBlockInParentheses.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun foo(/*0*/ x: kotlin.Int): kotlin.Unit +public tailrec fun foo(/*0*/ x: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInParentheses.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInParentheses.txt index 673c6b58634..4fd18812fe0 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInParentheses.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailCallInParentheses.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun foo(/*0*/ x: kotlin.Int): kotlin.Unit +public tailrec fun foo(/*0*/ x: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailRecursionInFinally.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailRecursionInFinally.txt index 6189da932dc..883abc7200c 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailRecursionInFinally.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/tailRecursionInFinally.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ go: kotlin.Boolean): kotlin.Unit +public tailrec fun test(/*0*/ go: kotlin.Boolean): kotlin.Unit diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/thisReferences.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/thisReferences.txt index d94b9c3fb4d..c919fcdf798 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/thisReferences.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/thisReferences.txt @@ -5,9 +5,9 @@ public fun box(): kotlin.String public final class A { public constructor A() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.tailrec() public final fun f1(/*0*/ c: kotlin.Int): kotlin.Unit - @kotlin.tailrec() public final fun f2(/*0*/ c: kotlin.Int): kotlin.Unit - @kotlin.tailrec() public final fun f3(/*0*/ a: A): kotlin.Unit + public final tailrec fun f1(/*0*/ c: kotlin.Int): kotlin.Unit + public final tailrec fun f2(/*0*/ c: kotlin.Int): kotlin.Unit + public final tailrec fun f3(/*0*/ a: A): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/unitBlocks.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/unitBlocks.txt index 5a3e0562e8a..6dd7b2f167f 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/unitBlocks.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/unitBlocks.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun test(/*0*/ x: kotlin.Int): kotlin.Unit +public tailrec fun test(/*0*/ x: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithCondition.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithCondition.txt index 1e09aec7a64..1aa338bd9c6 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithCondition.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithCondition.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun withWhen(/*0*/ counter: kotlin.Int): kotlin.Int +public tailrec fun withWhen(/*0*/ counter: kotlin.Int): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithInRange.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithInRange.txt index 8f3d58fc9eb..aa55835bd00 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithInRange.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithInRange.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun withWhen(/*0*/ counter: kotlin.Int, /*1*/ d: kotlin.Any): kotlin.Int +public tailrec fun withWhen(/*0*/ counter: kotlin.Int, /*1*/ d: kotlin.Any): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithIs.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithIs.txt index 8f3d58fc9eb..aa55835bd00 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithIs.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithIs.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun withWhen(/*0*/ counter: kotlin.Int, /*1*/ d: kotlin.Any): kotlin.Int +public tailrec fun withWhen(/*0*/ counter: kotlin.Int, /*1*/ d: kotlin.Any): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithoutCondition.txt b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithoutCondition.txt index 1fa05f951e1..5426fa21dfd 100644 --- a/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithoutCondition.txt +++ b/compiler/testData/codegen/box/diagnostics/functions/tailRecursion/whenWithoutCondition.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.tailrec() public fun withWhen2(/*0*/ counter: kotlin.Int): kotlin.Int +public tailrec fun withWhen2(/*0*/ counter: kotlin.Int): kotlin.Int diff --git a/compiler/testData/codegen/box/diagnostics/vararg/kt4172.txt b/compiler/testData/codegen/box/diagnostics/vararg/kt4172.txt index bbe26dab445..2b01eebc3f1 100644 --- a/compiler/testData/codegen/box/diagnostics/vararg/kt4172.txt +++ b/compiler/testData/codegen/box/diagnostics/vararg/kt4172.txt @@ -1,6 +1,6 @@ package -@kotlin.Suppress(names = {"UNCHECKED_CAST"}) @kotlin.inline() public fun array(/*0*/ vararg t: T /*kotlin.Array*/): kotlin.Array +@kotlin.Suppress(names = {"UNCHECKED_CAST"}) public inline fun array(/*0*/ vararg t: T /*kotlin.Array*/): kotlin.Array public fun box(): kotlin.String public fun main(/*0*/ args: kotlin.Array): kotlin.Unit diff --git a/compiler/testData/compileJavaAgainstKotlin/class/kt4050.txt b/compiler/testData/compileJavaAgainstKotlin/class/kt4050.txt index 63b9f3bd45e..a333cbb9acd 100644 --- a/compiler/testData/compileJavaAgainstKotlin/class/kt4050.txt +++ b/compiler/testData/compileJavaAgainstKotlin/class/kt4050.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class AAA : kotlin.Annotation { +public final annotation class AAA : kotlin.Annotation { public constructor AAA() } diff --git a/compiler/testData/compileJavaAgainstKotlin/property/ConstVal.txt b/compiler/testData/compileJavaAgainstKotlin/property/ConstVal.txt index 4395ce08599..85af54cc1e9 100644 --- a/compiler/testData/compileJavaAgainstKotlin/property/ConstVal.txt +++ b/compiler/testData/compileJavaAgainstKotlin/property/ConstVal.txt @@ -7,7 +7,7 @@ public object A { public const final val OBJECT: kotlin.String } -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ kotlin.String) public final val value: kotlin.String } diff --git a/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationClass.txt b/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationClass.txt index 168ad34e42c..84f735773b7 100644 --- a/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationClass.txt +++ b/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationClass.txt @@ -1,36 +1,36 @@ package test -@kotlin.annotation.annotation() public final class AByte : kotlin.Annotation { +public final annotation class AByte : kotlin.Annotation { public constructor AByte(/*0*/ kotlin.Byte) public final val value: kotlin.Byte } -@kotlin.annotation.annotation() public final class AChar : kotlin.Annotation { +public final annotation class AChar : kotlin.Annotation { public constructor AChar(/*0*/ kotlin.Char) public final val value: kotlin.Char } -@kotlin.annotation.annotation() public final class ADouble : kotlin.Annotation { +public final annotation class ADouble : kotlin.Annotation { public constructor ADouble(/*0*/ kotlin.Double) public final val value: kotlin.Double } -@kotlin.annotation.annotation() public final class AFloat : kotlin.Annotation { +public final annotation class AFloat : kotlin.Annotation { public constructor AFloat(/*0*/ kotlin.Float) public final val value: kotlin.Float } -@kotlin.annotation.annotation() public final class AInt : kotlin.Annotation { +public final annotation class AInt : kotlin.Annotation { public constructor AInt(/*0*/ kotlin.Int) public final val value: kotlin.Int } -@kotlin.annotation.annotation() public final class ALong : kotlin.Annotation { +public final annotation class ALong : kotlin.Annotation { public constructor ALong(/*0*/ kotlin.Long) public final val value: kotlin.Long } -@kotlin.annotation.annotation() public final class AString : kotlin.Annotation { +public final annotation class AString : kotlin.Annotation { public constructor AString(/*0*/ kotlin.String) public final val value: kotlin.String } diff --git a/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationTrait.txt b/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationTrait.txt index 78d944d5233..031ec3af900 100644 --- a/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationTrait.txt +++ b/compiler/testData/compileJavaAgainstKotlin/staticFields/AnnotationTrait.txt @@ -1,36 +1,36 @@ package test -@kotlin.annotation.annotation() public final class AByte : kotlin.Annotation { +public final annotation class AByte : kotlin.Annotation { public constructor AByte(/*0*/ kotlin.Byte) public final val value: kotlin.Byte } -@kotlin.annotation.annotation() public final class AChar : kotlin.Annotation { +public final annotation class AChar : kotlin.Annotation { public constructor AChar(/*0*/ kotlin.Char) public final val value: kotlin.Char } -@kotlin.annotation.annotation() public final class ADouble : kotlin.Annotation { +public final annotation class ADouble : kotlin.Annotation { public constructor ADouble(/*0*/ kotlin.Double) public final val value: kotlin.Double } -@kotlin.annotation.annotation() public final class AFloat : kotlin.Annotation { +public final annotation class AFloat : kotlin.Annotation { public constructor AFloat(/*0*/ kotlin.Float) public final val value: kotlin.Float } -@kotlin.annotation.annotation() public final class AInt : kotlin.Annotation { +public final annotation class AInt : kotlin.Annotation { public constructor AInt(/*0*/ kotlin.Int) public final val value: kotlin.Int } -@kotlin.annotation.annotation() public final class ALong : kotlin.Annotation { +public final annotation class ALong : kotlin.Annotation { public constructor ALong(/*0*/ kotlin.Long) public final val value: kotlin.Long } -@kotlin.annotation.annotation() public final class AString : kotlin.Annotation { +public final annotation class AString : kotlin.Annotation { public constructor AString(/*0*/ kotlin.String) public final val value: kotlin.String } diff --git a/compiler/testData/compileJavaAgainstKotlin/staticFields/kt3698.txt b/compiler/testData/compileJavaAgainstKotlin/staticFields/kt3698.txt index ad621277a3a..ae300c1e16c 100644 --- a/compiler/testData/compileJavaAgainstKotlin/staticFields/kt3698.txt +++ b/compiler/testData/compileJavaAgainstKotlin/staticFields/kt3698.txt @@ -12,7 +12,7 @@ public final class KotlinClass { public open class kt3698 { public constructor kt3698() - public/*package*/ final class Foo : kotlin.Annotation { + public/*package*/ final annotation class Foo : kotlin.Annotation { public/*package*/ constructor Foo(/*0*/ kotlin.Int) public final val value: kotlin.Int } diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/annotation.txt b/compiler/testData/compileJavaAgainstKotlin/targets/annotation.txt index bb99cdfd382..02adc0cecf4 100644 --- a/compiler/testData/compileJavaAgainstKotlin/targets/annotation.txt +++ b/compiler/testData/compileJavaAgainstKotlin/targets/annotation.txt @@ -1,9 +1,9 @@ package test -@test.meta() public/*package*/ final class MyAnn : kotlin.Annotation { +@test.meta() public/*package*/ final annotation class MyAnn : kotlin.Annotation { public/*package*/ constructor MyAnn() } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) @kotlin.annotation.annotation() public final class meta : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) public final annotation class meta : kotlin.Annotation { public constructor meta() } diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/base.txt b/compiler/testData/compileJavaAgainstKotlin/targets/base.txt index 0551a5f674a..6255d54b94c 100644 --- a/compiler/testData/compileJavaAgainstKotlin/targets/base.txt +++ b/compiler/testData/compileJavaAgainstKotlin/targets/base.txt @@ -5,6 +5,6 @@ package test @test.base() public/*package*/ open fun foo(/*0*/ @test.base() kotlin.Int): kotlin.Int } -@kotlin.annotation.annotation() public final class base : kotlin.Annotation { +public final annotation class base : kotlin.Annotation { public constructor base() } diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/classifier.txt b/compiler/testData/compileJavaAgainstKotlin/targets/classifier.txt index e3df79fbc4d..c711308bb61 100644 --- a/compiler/testData/compileJavaAgainstKotlin/targets/classifier.txt +++ b/compiler/testData/compileJavaAgainstKotlin/targets/classifier.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) @kotlin.annotation.annotation() public final class classifier : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class classifier : kotlin.Annotation { public constructor classifier() } diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/constructor.txt b/compiler/testData/compileJavaAgainstKotlin/targets/constructor.txt index c268229bf0e..f90171d8094 100644 --- a/compiler/testData/compileJavaAgainstKotlin/targets/constructor.txt +++ b/compiler/testData/compileJavaAgainstKotlin/targets/constructor.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CONSTRUCTOR}) @kotlin.annotation.annotation() public final class constructor : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CONSTRUCTOR}) public final annotation class constructor : kotlin.Annotation { public constructor constructor() } diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/empty.txt b/compiler/testData/compileJavaAgainstKotlin/targets/empty.txt index 90a46dd8f2a..ce0d54a407e 100644 --- a/compiler/testData/compileJavaAgainstKotlin/targets/empty.txt +++ b/compiler/testData/compileJavaAgainstKotlin/targets/empty.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {}) @kotlin.annotation.annotation() public final class empty : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {}) public final annotation class empty : kotlin.Annotation { public constructor empty() } diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/field.txt b/compiler/testData/compileJavaAgainstKotlin/targets/field.txt index 739fb2f93fb..e554e509478 100644 --- a/compiler/testData/compileJavaAgainstKotlin/targets/field.txt +++ b/compiler/testData/compileJavaAgainstKotlin/targets/field.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FIELD}) @kotlin.annotation.annotation() public final class field : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FIELD}) public final annotation class field : kotlin.Annotation { public constructor field() } diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/function.txt b/compiler/testData/compileJavaAgainstKotlin/targets/function.txt index 26da1f0fd18..f9219a9c1ca 100644 --- a/compiler/testData/compileJavaAgainstKotlin/targets/function.txt +++ b/compiler/testData/compileJavaAgainstKotlin/targets/function.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) @kotlin.annotation.annotation() public final class function : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) public final annotation class function : kotlin.Annotation { public constructor function() } diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/getter.txt b/compiler/testData/compileJavaAgainstKotlin/targets/getter.txt index d05c425ff52..d7a170d22ff 100644 --- a/compiler/testData/compileJavaAgainstKotlin/targets/getter.txt +++ b/compiler/testData/compileJavaAgainstKotlin/targets/getter.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.PROPERTY_GETTER}) @kotlin.annotation.annotation() public final class getter : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.PROPERTY_GETTER}) public final annotation class getter : kotlin.Annotation { public constructor getter() } diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/local.txt b/compiler/testData/compileJavaAgainstKotlin/targets/local.txt index f9a1f101bfb..3420731824c 100644 --- a/compiler/testData/compileJavaAgainstKotlin/targets/local.txt +++ b/compiler/testData/compileJavaAgainstKotlin/targets/local.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.LOCAL_VARIABLE}) @kotlin.annotation.annotation() public final class local : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.LOCAL_VARIABLE}) public final annotation class local : kotlin.Annotation { public constructor local() } diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/multiple.txt b/compiler/testData/compileJavaAgainstKotlin/targets/multiple.txt index f41ba89cd29..f46c55da0d6 100644 --- a/compiler/testData/compileJavaAgainstKotlin/targets/multiple.txt +++ b/compiler/testData/compileJavaAgainstKotlin/targets/multiple.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FUNCTION}) @kotlin.annotation.annotation() public final class multiple : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FUNCTION}) public final annotation class multiple : kotlin.Annotation { public constructor multiple() } diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/parameter.txt b/compiler/testData/compileJavaAgainstKotlin/targets/parameter.txt index 282dca0c64d..4a9fd968571 100644 --- a/compiler/testData/compileJavaAgainstKotlin/targets/parameter.txt +++ b/compiler/testData/compileJavaAgainstKotlin/targets/parameter.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) @kotlin.annotation.annotation() public final class parameter : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) public final annotation class parameter : kotlin.Annotation { public constructor parameter() } diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/property.txt b/compiler/testData/compileJavaAgainstKotlin/targets/property.txt index ac78c295adc..a1c305559f7 100644 --- a/compiler/testData/compileJavaAgainstKotlin/targets/property.txt +++ b/compiler/testData/compileJavaAgainstKotlin/targets/property.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.PROPERTY}) @kotlin.annotation.annotation() public final class property : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.PROPERTY}) public final annotation class property : kotlin.Annotation { public constructor property() } diff --git a/compiler/testData/compileJavaAgainstKotlin/targets/setter.txt b/compiler/testData/compileJavaAgainstKotlin/targets/setter.txt index c98ab0de902..e136a7d67ab 100644 --- a/compiler/testData/compileJavaAgainstKotlin/targets/setter.txt +++ b/compiler/testData/compileJavaAgainstKotlin/targets/setter.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.PROPERTY_SETTER}) @kotlin.annotation.annotation() public final class setter : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.PROPERTY_SETTER}) public final annotation class setter : kotlin.Annotation { public constructor setter() } diff --git a/compiler/testData/compileKotlinAgainstCustomBinaries/missingEnumReferencedInAnnotationArgument/missingEnumReferencedInAnnotationArgument.txt b/compiler/testData/compileKotlinAgainstCustomBinaries/missingEnumReferencedInAnnotationArgument/missingEnumReferencedInAnnotationArgument.txt index 741a6aa59d4..fe09641b246 100644 --- a/compiler/testData/compileKotlinAgainstCustomBinaries/missingEnumReferencedInAnnotationArgument/missingEnumReferencedInAnnotationArgument.txt +++ b/compiler/testData/compileKotlinAgainstCustomBinaries/missingEnumReferencedInAnnotationArgument/missingEnumReferencedInAnnotationArgument.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { public constructor Anno(/*0*/ e: [ERROR : test.E]) public final val e: [ERROR : test.E] } diff --git a/compiler/testData/diagnostics/tests/BacktickNames.txt b/compiler/testData/diagnostics/tests/BacktickNames.txt index ecb5390a0ef..48a812ce0ba 100644 --- a/compiler/testData/diagnostics/tests/BacktickNames.txt +++ b/compiler/testData/diagnostics/tests/BacktickNames.txt @@ -52,7 +52,7 @@ public final class B { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public final class Data { +public final data class Data { public constructor Data(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int) public final val x: kotlin.Int public final val y: kotlin.Int diff --git a/compiler/testData/diagnostics/tests/Underscore.txt b/compiler/testData/diagnostics/tests/Underscore.txt index 58e59817fce..135b51a3217 100644 --- a/compiler/testData/diagnostics/tests/Underscore.txt +++ b/compiler/testData/diagnostics/tests/Underscore.txt @@ -5,7 +5,7 @@ public val something: kotlin.Any? public fun __(/*0*/ ___: kotlin.Int, /*1*/ y: _?): kotlin.Int public fun doIt(/*0*/ f: (kotlin.Any?) -> kotlin.Any?): kotlin.Any? -@kotlin.Deprecated(message = "") @kotlin.data() public final class Pair { +@kotlin.Deprecated(message = "") public final data class Pair { public constructor Pair(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int) public final val x: kotlin.Int public final val y: kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedConstructor.txt b/compiler/testData/diagnostics/tests/annotations/AnnotatedConstructor.txt index 444a5489159..88627f0624c 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotatedConstructor.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedConstructor.txt @@ -8,7 +8,7 @@ public final class Annotated { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectFun.txt b/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectFun.txt index 428c943db4d..6376bc5a160 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectFun.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectFun.txt @@ -2,7 +2,7 @@ package public fun foo(): kotlin.Unit -@kotlin.annotation.annotation() public final class My : kotlin.Annotation { +public final annotation class My : kotlin.Annotation { public constructor My() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectProperty.txt b/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectProperty.txt index f41259c2831..6835c4b8748 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectProperty.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedLocalObjectProperty.txt @@ -2,7 +2,7 @@ package public fun foo(): kotlin.Int -@kotlin.annotation.annotation() public final class My : kotlin.Annotation { +public final annotation class My : kotlin.Annotation { public constructor My() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedLoop.txt b/compiler/testData/diagnostics/tests/annotations/AnnotatedLoop.txt index cebf0e0f098..a9679d1f65e 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotatedLoop.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedLoop.txt @@ -2,7 +2,7 @@ package public fun foo(): kotlin.Unit -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class My : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class My : kotlin.Annotation { public constructor My() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.txt b/compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.txt index fa3bd47901f..3c95914fa83 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedResultType.txt @@ -2,7 +2,7 @@ package public fun foo(): @My(x = 42) kotlin.Int -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class My : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class My : kotlin.Annotation { public constructor My(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotatedTryCatch.txt b/compiler/testData/diagnostics/tests/annotations/AnnotatedTryCatch.txt index 1cbe30feb2c..c1921dd28d2 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotatedTryCatch.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotatedTryCatch.txt @@ -2,7 +2,7 @@ package public fun foo(/*0*/ arg: kotlin.Int): kotlin.Int -@kotlin.annotation.annotation() public final class My : kotlin.Annotation { +public final annotation class My : kotlin.Annotation { public constructor My() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.txt b/compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.txt index adb513197c1..1ae4abcebea 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotationAsDefaultParameter.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class Base : kotlin.Annotation { +public final annotation class Base : kotlin.Annotation { public constructor Base(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -15,7 +15,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class UseBase : kotlin.Annotation { +public final annotation class UseBase : kotlin.Annotation { public constructor UseBase(/*0*/ b: Base = ...) public final val b: Base public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.txt b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.txt index a312a96d235..d3aa6c01a54 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.txt @@ -1,13 +1,13 @@ package -@kotlin.annotation.annotation() public final class A1 : kotlin.Annotation { +public final annotation class A1 : kotlin.Annotation { public constructor A1() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class A2 : kotlin.Annotation { +public final annotation class A2 : kotlin.Annotation { public constructor A2(/*0*/ some: kotlin.Int = ...) public final val some: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.txt b/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.txt index d3818cdc5e4..105d609e4f0 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.txt @@ -2,14 +2,14 @@ package public fun topFun(): kotlin.Int -@kotlin.annotation.annotation() public final class A1 : kotlin.Annotation { +public final annotation class A1 : kotlin.Annotation { public constructor A1() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class A2 : kotlin.Annotation { +public final annotation class A2 : kotlin.Annotation { public constructor A2(/*0*/ some: kotlin.Int = ...) public final val some: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationIdentifier.txt b/compiler/testData/diagnostics/tests/annotations/AnnotationIdentifier.txt index 8f8e1758c03..7f63c59a3da 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotationIdentifier.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotationIdentifier.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class annotation : kotlin.Annotation { +public final annotation class annotation : kotlin.Annotation { public constructor annotation() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -9,7 +9,7 @@ package package other { - @kotlin.annotation.annotation() public final class My : kotlin.Annotation { + public final annotation class My : kotlin.Annotation { public constructor My() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationOnObject.txt b/compiler/testData/diagnostics/tests/annotations/AnnotationOnObject.txt index 9b07e9d8122..a750322ba63 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotationOnObject.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotationOnObject.txt @@ -2,7 +2,7 @@ package package test { - @kotlin.annotation.annotation() public final class A : kotlin.Annotation { + public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ a: kotlin.Int = ..., /*1*/ b: kotlin.String = ..., /*2*/ c: kotlin.String) public final val a: kotlin.Int public final val b: kotlin.String diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationsForClasses.txt b/compiler/testData/diagnostics/tests/annotations/AnnotationsForClasses.txt index a63effc4fb7..0124c9824ce 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotationsForClasses.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotationsForClasses.txt @@ -1,6 +1,6 @@ package -@java.lang.Deprecated() @kotlin.annotation.annotation() public final class my : kotlin.Annotation { +@java.lang.Deprecated() public final annotation class my : kotlin.Annotation { public constructor my() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.txt b/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.txt index 23daa6d70cc..5fbd6594f40 100644 --- a/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.txt +++ b/compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.txt @@ -2,14 +2,14 @@ package public val T.topProp: kotlin.Int -@kotlin.annotation.annotation() public final class A1 : kotlin.Annotation { +public final annotation class A1 : kotlin.Annotation { public constructor A1() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class A2 : kotlin.Annotation { +public final annotation class A2 : kotlin.Annotation { public constructor A2(/*0*/ some: kotlin.Int = ...) public final val some: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/BasicAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/BasicAnnotations.txt index 0a51ba48041..c59ea42cd60 100644 --- a/compiler/testData/diagnostics/tests/annotations/BasicAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/BasicAnnotations.txt @@ -7,14 +7,14 @@ package @my2() public fun foo41(): kotlin.Unit @my2(i = 2) public fun foo42(): kotlin.Unit -@kotlin.annotation.annotation() public final class my : kotlin.Annotation { +public final annotation class my : kotlin.Annotation { public constructor my() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class my1 : kotlin.Annotation { +public final annotation class my1 : kotlin.Annotation { public constructor my1(/*0*/ i: kotlin.Int) public final val i: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -22,7 +22,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class my2 : kotlin.Annotation { +public final annotation class my2 : kotlin.Annotation { public constructor my2(/*0*/ i: kotlin.Int = ...) public final val i: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/ConstructorCall.txt b/compiler/testData/diagnostics/tests/annotations/ConstructorCall.txt index cbd95461381..e1cee8f0b7e 100644 --- a/compiler/testData/diagnostics/tests/annotations/ConstructorCall.txt +++ b/compiler/testData/diagnostics/tests/annotations/ConstructorCall.txt @@ -7,14 +7,14 @@ public fun foo(): kotlin.Unit public fun javaClass(): java.lang.Class public operator fun kotlin.String.invoke(): kotlin.Unit -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann1 : kotlin.Annotation { +public final annotation class Ann1 : kotlin.Annotation { public constructor Ann1(/*0*/ a: kotlin.Int) public final val a: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -22,7 +22,7 @@ public operator fun kotlin.String.invoke(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann2 : kotlin.Annotation { +public final annotation class Ann2 : kotlin.Annotation { public constructor Ann2(/*0*/ a: Ann1) public final val a: Ann1 public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -30,7 +30,7 @@ public operator fun kotlin.String.invoke(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann3 : kotlin.Annotation { +public final annotation class Ann3 : kotlin.Annotation { public constructor Ann3(/*0*/ a: Ann1 = ...) public final val a: Ann1 public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -38,7 +38,7 @@ public operator fun kotlin.String.invoke(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann4 : kotlin.Annotation { +public final annotation class Ann4 : kotlin.Annotation { public constructor Ann4(/*0*/ value: kotlin.String) public final val value: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/DanglingMixed.txt b/compiler/testData/diagnostics/tests/annotations/DanglingMixed.txt index 77481206fa9..dc8aaf388b7 100644 --- a/compiler/testData/diagnostics/tests/annotations/DanglingMixed.txt +++ b/compiler/testData/diagnostics/tests/annotations/DanglingMixed.txt @@ -1,13 +1,13 @@ package -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann2 : kotlin.Annotation { +public final annotation class Ann2 : kotlin.Annotation { public constructor Ann2() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/DanglingNoBrackets.txt b/compiler/testData/diagnostics/tests/annotations/DanglingNoBrackets.txt index 4fa18b7ea11..6447c21a282 100644 --- a/compiler/testData/diagnostics/tests/annotations/DanglingNoBrackets.txt +++ b/compiler/testData/diagnostics/tests/annotations/DanglingNoBrackets.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/DanglingWithBrackets.txt b/compiler/testData/diagnostics/tests/annotations/DanglingWithBrackets.txt index 109a16ff53c..c98a97f5c45 100644 --- a/compiler/testData/diagnostics/tests/annotations/DanglingWithBrackets.txt +++ b/compiler/testData/diagnostics/tests/annotations/DanglingWithBrackets.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/JavaAnnotationConstructors.txt b/compiler/testData/diagnostics/tests/annotations/JavaAnnotationConstructors.txt index 2448f2df1fa..ae899e89677 100644 --- a/compiler/testData/diagnostics/tests/annotations/JavaAnnotationConstructors.txt +++ b/compiler/testData/diagnostics/tests/annotations/JavaAnnotationConstructors.txt @@ -1,13 +1,13 @@ package -@java.lang.annotation.Retention(value = RetentionPolicy.CLASS) @kotlin.annotation.annotation() public final class my : kotlin.Annotation { +@java.lang.annotation.Retention(value = RetentionPolicy.CLASS) public final annotation class my : kotlin.Annotation { public constructor my() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@java.lang.annotation.Retention(value = RetentionPolicy.RUNTIME) @java.lang.annotation.Target(value = {ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR}) @kotlin.annotation.annotation() public final class my1 : kotlin.Annotation { +@java.lang.annotation.Retention(value = RetentionPolicy.RUNTIME) @java.lang.annotation.Target(value = {ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR}) public final annotation class my1 : kotlin.Annotation { public constructor my1() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/MultiDeclaration.txt b/compiler/testData/diagnostics/tests/annotations/MultiDeclaration.txt index 8da60a4ae83..636d002c734 100644 --- a/compiler/testData/diagnostics/tests/annotations/MultiDeclaration.txt +++ b/compiler/testData/diagnostics/tests/annotations/MultiDeclaration.txt @@ -2,14 +2,14 @@ package public fun foo(): kotlin.Int -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public final class Pair { +public final data class Pair { public constructor Pair(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int) public final val x: kotlin.Int public final val y: kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.txt b/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.txt index 4e0ebe0071f..c21ed33d38e 100644 --- a/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.txt +++ b/compiler/testData/diagnostics/tests/annotations/MutuallyRecursivelyAnnotatedGlobalFunction.txt @@ -3,7 +3,7 @@ package @ann() public fun bar(): kotlin.Int @ann() public fun foo(): kotlin.Int -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotated.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotated.txt index 8e92893cebe..5f9f9ad726a 100644 --- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotated.txt +++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotated.txt @@ -1,6 +1,6 @@ package -@RecursivelyAnnotated(x = 1) @kotlin.annotation.annotation() public final class RecursivelyAnnotated : kotlin.Annotation { +@RecursivelyAnnotated(x = 1) public final annotation class RecursivelyAnnotated : kotlin.Annotation { public constructor RecursivelyAnnotated(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedFunctionParameter.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedFunctionParameter.txt index a3c5e04f5fd..58c1bcaeff8 100644 --- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedFunctionParameter.txt +++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedFunctionParameter.txt @@ -2,7 +2,7 @@ package public fun foo(/*0*/ @ann() x: kotlin.Int): kotlin.Int -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.txt index a804de343c3..e5154d45912 100644 --- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.txt +++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalFunction.txt @@ -2,7 +2,7 @@ package @ann() public fun foo(): kotlin.Int -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalProperty.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalProperty.txt index 2340f83fb54..e686d941108 100644 --- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalProperty.txt +++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedGlobalProperty.txt @@ -2,7 +2,7 @@ package @ann(x = 1) public const val x: kotlin.Int = 1 -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameter.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameter.txt index 18df7a3bf97..795f9cb0f37 100644 --- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameter.txt +++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameter.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class RecursivelyAnnotated : kotlin.Annotation { +public final annotation class RecursivelyAnnotated : kotlin.Annotation { public constructor RecursivelyAnnotated(/*0*/ @RecursivelyAnnotated(x = 1) x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.txt index d294a813a4d..c5582197634 100644 --- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.txt +++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterType.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class RecursivelyAnnotated : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class RecursivelyAnnotated : kotlin.Annotation { public constructor RecursivelyAnnotated(/*0*/ x: @RecursivelyAnnotated(x = 1) kotlin.Int) public final val x: @RecursivelyAnnotated(x = 1) kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterWithAt.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterWithAt.txt index 18df7a3bf97..795f9cb0f37 100644 --- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterWithAt.txt +++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedParameterWithAt.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class RecursivelyAnnotated : kotlin.Annotation { +public final annotation class RecursivelyAnnotated : kotlin.Annotation { public constructor RecursivelyAnnotated(/*0*/ @RecursivelyAnnotated(x = 1) x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedProperty.txt b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedProperty.txt index 32da3851bbe..4ce15c0463c 100644 --- a/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedProperty.txt +++ b/compiler/testData/diagnostics/tests/annotations/RecursivelyAnnotatedProperty.txt @@ -8,7 +8,7 @@ public final class My { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.txt b/compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.txt index 23df6edf3a3..fa05787a9d5 100644 --- a/compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.txt +++ b/compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.txt @@ -3,7 +3,7 @@ package package test { public val some: test.SomeObject - @kotlin.annotation.annotation() public final class BadAnnotation : kotlin.Annotation { + public final annotation class BadAnnotation : kotlin.Annotation { public constructor BadAnnotation(/*0*/ s: kotlin.String) public final val s: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/annotationInheritance.txt b/compiler/testData/diagnostics/tests/annotations/annotationInheritance.txt index 8b6d7d30e67..06531dfb8ec 100644 --- a/compiler/testData/diagnostics/tests/annotations/annotationInheritance.txt +++ b/compiler/testData/diagnostics/tests/annotations/annotationInheritance.txt @@ -2,28 +2,28 @@ package public val a: T -@kotlin.annotation.annotation() public final class Ann : C { +public final annotation class Ann : C { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann2 : T { +public final annotation class Ann2 : T { public constructor Ann2() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann3 : T { +public final annotation class Ann3 : T { public constructor Ann3() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann4 : C, T { +public final annotation class Ann4 : C, T { public constructor Ann4() public open override /*2*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*2*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/annotationModifier.txt b/compiler/testData/diagnostics/tests/annotations/annotationModifier.txt index 67b1a41bf74..3880712816e 100644 --- a/compiler/testData/diagnostics/tests/annotations/annotationModifier.txt +++ b/compiler/testData/diagnostics/tests/annotations/annotationModifier.txt @@ -1,8 +1,8 @@ package -@kotlin.annotation.annotation() public val x: kotlin.Int = 0 -@kotlin.annotation.annotation() public var y: kotlin.Int -@kotlin.annotation.annotation() public fun f(): kotlin.Int +public val x: kotlin.Int = 0 +public var y: kotlin.Int +public fun f(): kotlin.Int public final class A { public constructor A() @@ -10,7 +10,7 @@ public final class A { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - @kotlin.annotation.annotation() public companion object Companion { + public companion object Companion { private constructor Companion() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -18,21 +18,21 @@ public final class A { } } -@kotlin.annotation.annotation() public final class B : kotlin.Annotation { +public final annotation class B : kotlin.Annotation { public constructor B() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public object O { +public object O { private constructor O() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public interface T { +public interface T { public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String diff --git a/compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.txt b/compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.txt index aac4c352255..b4fea6f7bc5 100644 --- a/compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.txt +++ b/compiler/testData/diagnostics/tests/annotations/annotationOnParameterInFunctionType.txt @@ -17,14 +17,14 @@ public final class A : (kotlin.Int) -> kotlin.Unit { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class TypeAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class TypeAnn : kotlin.Annotation { public constructor TypeAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.txt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.txt index 17f8780e104..5444762ced0 100644 --- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.txt +++ b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/booleanLocalVal.txt @@ -2,7 +2,7 @@ package public fun foo(): kotlin.Unit -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ vararg i: kotlin.Boolean /*kotlin.BooleanArray*/) public final val i: kotlin.BooleanArray public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.txt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.txt index 17f8780e104..5444762ced0 100644 --- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.txt +++ b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/compareAndEquals.txt @@ -2,7 +2,7 @@ package public fun foo(): kotlin.Unit -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ vararg i: kotlin.Boolean /*kotlin.BooleanArray*/) public final val i: kotlin.BooleanArray public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst.txt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst.txt index c1bfcdeb7e9..ccb9f6a514e 100644 --- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst.txt +++ b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst.txt @@ -2,7 +2,7 @@ package public val e: MyEnum -@kotlin.annotation.annotation() public final class AnnE : kotlin.Annotation { +public final annotation class AnnE : kotlin.Annotation { public constructor AnnE(/*0*/ i: MyEnum) public final val i: MyEnum public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.txt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.txt index 746bfd5aaaa..3b3bb892e73 100644 --- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.txt +++ b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/javaProperties.txt @@ -7,7 +7,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ vararg i: kotlin.Int /*kotlin.IntArray*/) public final val i: kotlin.IntArray public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.txt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.txt index 0b2ed7a8122..5bf8e356d9d 100644 --- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.txt +++ b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/kotlinProperties.txt @@ -7,7 +7,7 @@ public const val i4: kotlin.Int = 1 public var i5: kotlin.Int public var i6: kotlin.Int -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ vararg i: kotlin.Int /*kotlin.IntArray*/) public final val i: kotlin.IntArray public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.txt b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.txt index cf2e202495c..4cc2f288faa 100644 --- a/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.txt +++ b/compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/strings.txt @@ -3,7 +3,7 @@ package public const val topLevel: kotlin.String = "topLevel" public fun foo(): kotlin.Unit -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ vararg i: kotlin.String /*kotlin.Array*/) public final val i: kotlin.Array public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.txt b/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.txt index c483735e94d..0c6a7141bbc 100644 --- a/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.txt +++ b/compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.txt @@ -1,9 +1,9 @@ package -@kotlin.inline() public fun bar(/*0*/ block: () -> kotlin.Int): kotlin.Int +public inline fun bar(/*0*/ block: () -> kotlin.Int): kotlin.Int public fun foo(): kotlin.Unit -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ x: kotlin.Int = ...) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/annotationsOnNullableTypes.txt b/compiler/testData/diagnostics/tests/annotations/annotationsOnNullableTypes.txt index 671d01f0450..cabf4460f0e 100644 --- a/compiler/testData/diagnostics/tests/annotations/annotationsOnNullableTypes.txt +++ b/compiler/testData/diagnostics/tests/annotations/annotationsOnNullableTypes.txt @@ -17,14 +17,14 @@ public fun @b(i = 1) kotlin.Int?.bar1(): kotlin.Unit public fun @a() @b(i = 1) kotlin.Int?.bar2(): kotlin.Unit public fun @c() kotlin.Int?.bar3(): kotlin.Unit -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class a : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class a : kotlin.Annotation { public constructor a() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class b : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class b : kotlin.Annotation { public constructor b(/*0*/ i: kotlin.Int) public final val i: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -32,7 +32,7 @@ public fun @c() kotlin.Int?.bar3(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class c : kotlin.Annotation { +public final annotation class c : kotlin.Annotation { public constructor c() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.txt b/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.txt index 15ac40109ed..651a14f8331 100644 --- a/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.txt +++ b/compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.txt @@ -10,7 +10,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE, AnnotationTarget.CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.EXPRESSION, AnnotationTarget.PROPERTY}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE, AnnotationTarget.CLASS, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION, AnnotationTarget.EXPRESSION, AnnotationTarget.PROPERTY}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ x: kotlin.Int = ...) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/extensionFunctionType.txt b/compiler/testData/diagnostics/tests/annotations/extensionFunctionType.txt index 86e30fee234..ce3b233ff88 100644 --- a/compiler/testData/diagnostics/tests/annotations/extensionFunctionType.txt +++ b/compiler/testData/diagnostics/tests/annotations/extensionFunctionType.txt @@ -10,7 +10,7 @@ public interface Some { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class ann : kotlin.Annotation { public constructor ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/forParameterAnnotationResolve.txt b/compiler/testData/diagnostics/tests/annotations/forParameterAnnotationResolve.txt index ceeb787f8c7..ada91290c6f 100644 --- a/compiler/testData/diagnostics/tests/annotations/forParameterAnnotationResolve.txt +++ b/compiler/testData/diagnostics/tests/annotations/forParameterAnnotationResolve.txt @@ -3,7 +3,7 @@ package public fun bar(): kotlin.Array public fun foo(): kotlin.Unit -@kotlin.data() public final class A { +public final data class A { public constructor A(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int) public final val x: kotlin.Int public final val y: kotlin.Int @@ -15,7 +15,7 @@ public fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.txt b/compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.txt index 9665d0b7204..be8c3d48ba2 100644 --- a/compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.txt +++ b/compiler/testData/diagnostics/tests/annotations/invalidTypesInAnnotationConstructor.txt @@ -2,7 +2,7 @@ package package test { - @kotlin.annotation.annotation() public final class Ann1 : kotlin.Annotation { + public final annotation class Ann1 : kotlin.Annotation { public constructor Ann1(/*0*/ p1: kotlin.Int, /*1*/ p2: kotlin.Byte, /*2*/ p3: kotlin.Short, /*3*/ p4: kotlin.Long, /*4*/ p5: kotlin.Double, /*5*/ p6: kotlin.Float, /*6*/ p7: kotlin.Char, /*7*/ p8: kotlin.Boolean) public final val p1: kotlin.Int public final val p2: kotlin.Byte @@ -17,7 +17,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class Ann2 : kotlin.Annotation { + public final annotation class Ann2 : kotlin.Annotation { public constructor Ann2(/*0*/ p1: kotlin.String) public final val p1: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -25,7 +25,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class Ann3 : kotlin.Annotation { + public final annotation class Ann3 : kotlin.Annotation { public constructor Ann3(/*0*/ p1: test.Ann1) public final val p1: test.Ann1 public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -33,7 +33,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class Ann4 : kotlin.Annotation { + public final annotation class Ann4 : kotlin.Annotation { public constructor Ann4(/*0*/ p1: kotlin.IntArray, /*1*/ p2: kotlin.ByteArray, /*2*/ p3: kotlin.ShortArray, /*3*/ p4: kotlin.LongArray, /*4*/ p5: kotlin.DoubleArray, /*5*/ p6: kotlin.FloatArray, /*6*/ p7: kotlin.CharArray, /*7*/ p8: kotlin.BooleanArray) public final val p1: kotlin.IntArray public final val p2: kotlin.ByteArray @@ -48,7 +48,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class Ann5 : kotlin.Annotation { + public final annotation class Ann5 : kotlin.Annotation { public constructor Ann5(/*0*/ p1: test.MyEnum) public final val p1: test.MyEnum public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -56,7 +56,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class Ann6 : kotlin.Annotation { + public final annotation class Ann6 : kotlin.Annotation { public constructor Ann6(/*0*/ p: java.lang.Class<*>) public final val p: java.lang.Class<*> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -64,7 +64,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class Ann7 : kotlin.Annotation { + public final annotation class Ann7 : kotlin.Annotation { public constructor Ann7(/*0*/ p: java.lang.annotation.RetentionPolicy) public final val p: java.lang.annotation.RetentionPolicy public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -72,7 +72,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class Ann8 : kotlin.Annotation { + public final annotation class Ann8 : kotlin.Annotation { public constructor Ann8(/*0*/ p1: kotlin.Array, /*1*/ p2: kotlin.Array>, /*2*/ p3: kotlin.Array, /*3*/ p4: kotlin.Array) public final val p1: kotlin.Array public final val p2: kotlin.Array> @@ -83,7 +83,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class Ann9 : kotlin.Annotation { + public final annotation class Ann9 : kotlin.Annotation { public constructor Ann9(/*0*/ vararg p1: kotlin.String /*kotlin.Array*/, /*1*/ vararg p2: java.lang.Class<*> /*kotlin.Array>*/, /*2*/ vararg p3: test.MyEnum /*kotlin.Array*/, /*3*/ vararg p4: test.Ann1 /*kotlin.Array*/, /*4*/ vararg p5: kotlin.Int /*kotlin.IntArray*/) public final val p1: kotlin.Array public final val p2: kotlin.Array> @@ -95,7 +95,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class InAnn1 : kotlin.Annotation { + public final annotation class InAnn1 : kotlin.Annotation { public constructor InAnn1(/*0*/ p1: kotlin.Int?, /*1*/ p3: kotlin.Short?, /*2*/ p4: kotlin.Long?, /*3*/ p5: kotlin.Double?, /*4*/ p6: kotlin.Float?, /*5*/ p7: kotlin.Char?, /*6*/ p8: kotlin.Boolean?) public final val p1: kotlin.Int? public final val p3: kotlin.Short? @@ -109,7 +109,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class InAnn10 : kotlin.Annotation { + public final annotation class InAnn10 : kotlin.Annotation { public constructor InAnn10(/*0*/ p1: kotlin.String?) public final val p1: kotlin.String? public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -117,7 +117,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class InAnn11 : kotlin.Annotation { + public final annotation class InAnn11 : kotlin.Annotation { public constructor InAnn11(/*0*/ p1: test.Ann1?) public final val p1: test.Ann1? public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -125,7 +125,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class InAnn12 : kotlin.Annotation { + public final annotation class InAnn12 : kotlin.Annotation { public constructor InAnn12(/*0*/ p1: test.MyEnum?) public final val p1: test.MyEnum? public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -133,7 +133,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class InAnn4 : kotlin.Annotation { + public final annotation class InAnn4 : kotlin.Annotation { public constructor InAnn4(/*0*/ p1: kotlin.Array, /*1*/ p2: kotlin.Array?) public final val p1: kotlin.Array public final val p2: kotlin.Array? @@ -142,7 +142,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class InAnn6 : kotlin.Annotation { + public final annotation class InAnn6 : kotlin.Annotation { public constructor InAnn6(/*0*/ p: java.lang.Class<*>?) public final val p: java.lang.Class<*>? public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -150,7 +150,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class InAnn7 : kotlin.Annotation { + public final annotation class InAnn7 : kotlin.Annotation { public constructor InAnn7(/*0*/ p: java.lang.annotation.RetentionPolicy?) public final val p: java.lang.annotation.RetentionPolicy? public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -158,7 +158,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class InAnn8 : kotlin.Annotation { + public final annotation class InAnn8 : kotlin.Annotation { public constructor InAnn8(/*0*/ p1: kotlin.Array, /*1*/ p2: kotlin.Array, /*2*/ p3: kotlin.Array, /*3*/ p4: kotlin.Array) public final val p1: kotlin.Array public final val p2: kotlin.Array @@ -169,7 +169,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class InAnn9 : kotlin.Annotation { + public final annotation class InAnn9 : kotlin.Annotation { public constructor InAnn9(/*0*/ p: test.MyClass) public final val p: test.MyClass public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/kt1860-positive.txt b/compiler/testData/diagnostics/tests/annotations/kt1860-positive.txt index 1feed49022e..40dba668e6c 100644 --- a/compiler/testData/diagnostics/tests/annotations/kt1860-positive.txt +++ b/compiler/testData/diagnostics/tests/annotations/kt1860-positive.txt @@ -11,7 +11,7 @@ public final class Hello { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION}) @kotlin.annotation.annotation() public final class test : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION}) public final annotation class test : kotlin.Annotation { public constructor test() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.txt b/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.txt index c4e0a915fa2..57776614ef0 100644 --- a/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.txt +++ b/compiler/testData/diagnostics/tests/annotations/kt1886annotationBody.txt @@ -1,20 +1,20 @@ package -@kotlin.annotation.annotation() public final class Annotation1 : kotlin.Annotation { +public final annotation class Annotation1 : kotlin.Annotation { public constructor Annotation1() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Annotation10 : kotlin.Annotation { +public final annotation class Annotation10 : kotlin.Annotation { public constructor Annotation10() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Annotation2 : kotlin.Annotation { +public final annotation class Annotation2 : kotlin.Annotation { public constructor Annotation2() public final val s: kotlin.String = "" public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -22,7 +22,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Annotation3 : kotlin.Annotation { +public final annotation class Annotation3 : kotlin.Annotation { public constructor Annotation3() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public final fun foo(): kotlin.Unit @@ -30,7 +30,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Annotation4 : kotlin.Annotation { +public final annotation class Annotation4 : kotlin.Annotation { public constructor Annotation4() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -44,7 +44,7 @@ package } } -@kotlin.annotation.annotation() public final class Annotation5 : kotlin.Annotation { +public final annotation class Annotation5 : kotlin.Annotation { public constructor Annotation5() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -58,14 +58,14 @@ package } } -@kotlin.annotation.annotation() public final class Annotation6 : kotlin.Annotation { +public final annotation class Annotation6 : kotlin.Annotation { public constructor Annotation6() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Annotation7 : kotlin.Annotation { +public final annotation class Annotation7 : kotlin.Annotation { public constructor Annotation7(/*0*/ name: kotlin.String) public final val name: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -73,7 +73,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Annotation8 : kotlin.Annotation { +public final annotation class Annotation8 : kotlin.Annotation { public constructor Annotation8(/*0*/ name: kotlin.String = ...) public final var name: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -81,7 +81,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Annotation9 : kotlin.Annotation { +public final annotation class Annotation9 : kotlin.Annotation { public constructor Annotation9(/*0*/ name: kotlin.String) public final val name: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/missingValOnParameter.txt b/compiler/testData/diagnostics/tests/annotations/missingValOnParameter.txt index 9de82ba0434..f89c06896cc 100644 --- a/compiler/testData/diagnostics/tests/annotations/missingValOnParameter.txt +++ b/compiler/testData/diagnostics/tests/annotations/missingValOnParameter.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Int, /*2*/ c: kotlin.String) public final val a: kotlin.Int public final var b: kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/noNameProperty.txt b/compiler/testData/diagnostics/tests/annotations/noNameProperty.txt index 283b19f10d6..9e665a295ea 100644 --- a/compiler/testData/diagnostics/tests/annotations/noNameProperty.txt +++ b/compiler/testData/diagnostics/tests/annotations/noNameProperty.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ x: kotlin.Int, /*1*/ : [ERROR : Type annotation was missing for parameter ]) public final val : [ERROR : Annotation is absent] public final val x: kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/onExpression.txt b/compiler/testData/diagnostics/tests/annotations/onExpression.txt index 3f8f644d0a6..cdec0d920e9 100644 --- a/compiler/testData/diagnostics/tests/annotations/onExpression.txt +++ b/compiler/testData/diagnostics/tests/annotations/onExpression.txt @@ -2,7 +2,7 @@ package public fun foo(): kotlin.Int -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) public final annotation class ann : kotlin.Annotation { public constructor ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/onFunctionParameter.txt b/compiler/testData/diagnostics/tests/annotations/onFunctionParameter.txt index 9bd4f8995db..b45c8e56e43 100644 --- a/compiler/testData/diagnostics/tests/annotations/onFunctionParameter.txt +++ b/compiler/testData/diagnostics/tests/annotations/onFunctionParameter.txt @@ -3,7 +3,7 @@ package public val bar: (kotlin.Int) -> kotlin.Unit public fun test(/*0*/ @ann() p: kotlin.Int): kotlin.Unit -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/onInitializer.txt b/compiler/testData/diagnostics/tests/annotations/onInitializer.txt index 9568a82f7c4..1e02ab32bfa 100644 --- a/compiler/testData/diagnostics/tests/annotations/onInitializer.txt +++ b/compiler/testData/diagnostics/tests/annotations/onInitializer.txt @@ -13,7 +13,7 @@ public interface T { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/onLoops.txt b/compiler/testData/diagnostics/tests/annotations/onLoops.txt index dd4869ee518..60c6093b294 100644 --- a/compiler/testData/diagnostics/tests/annotations/onLoops.txt +++ b/compiler/testData/diagnostics/tests/annotations/onLoops.txt @@ -2,7 +2,7 @@ package public fun test(): kotlin.Unit -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/onLoopsUnreachable.txt b/compiler/testData/diagnostics/tests/annotations/onLoopsUnreachable.txt index dd4869ee518..60c6093b294 100644 --- a/compiler/testData/diagnostics/tests/annotations/onLoopsUnreachable.txt +++ b/compiler/testData/diagnostics/tests/annotations/onLoopsUnreachable.txt @@ -2,7 +2,7 @@ package public fun test(): kotlin.Unit -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/onMultiDeclaration.txt b/compiler/testData/diagnostics/tests/annotations/onMultiDeclaration.txt index df3be20e649..131183079b8 100644 --- a/compiler/testData/diagnostics/tests/annotations/onMultiDeclaration.txt +++ b/compiler/testData/diagnostics/tests/annotations/onMultiDeclaration.txt @@ -2,7 +2,7 @@ package public fun test(): kotlin.Any? -@kotlin.data() public final class P { +public final data class P { public constructor P(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Int) public final val a: kotlin.Int public final val b: kotlin.Int @@ -14,7 +14,7 @@ public fun test(): kotlin.Any? public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/assignment.txt b/compiler/testData/diagnostics/tests/annotations/options/assignment.txt index c076523e7bf..3cf8fa06393 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/assignment.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/assignment.txt @@ -2,7 +2,7 @@ package public fun foo(): kotlin.Int -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.annotation() public final class ExprAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) public final annotation class ExprAnn : kotlin.Annotation { public constructor ExprAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/documented.txt b/compiler/testData/diagnostics/tests/annotations/options/documented.txt index 003edbbd30a..cf7b8a4b8b9 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/documented.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/documented.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.MustBeDocumented() @kotlin.annotation.annotation() public final class DocAnn : kotlin.Annotation { +@kotlin.annotation.MustBeDocumented() public final annotation class DocAnn : kotlin.Annotation { public constructor DocAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -14,7 +14,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class NotDocAnn : kotlin.Annotation { +public final annotation class NotDocAnn : kotlin.Annotation { public constructor NotDocAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/forParam.txt b/compiler/testData/diagnostics/tests/annotations/options/forParam.txt index c507e596387..2cc53ec9630 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/forParam.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/forParam.txt @@ -2,7 +2,7 @@ package public fun foo(): kotlin.Unit -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) @kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/functionExpression.txt b/compiler/testData/diagnostics/tests/annotations/options/functionExpression.txt index 61f00b2a86b..e3a7f0b8b29 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/functionExpression.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/functionExpression.txt @@ -2,14 +2,14 @@ package public fun foo(): kotlin.Int -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.annotation() public final class ExprAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) public final annotation class ExprAnn : kotlin.Annotation { public constructor ExprAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) @kotlin.annotation.annotation() public final class FunAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) public final annotation class FunAnn : kotlin.Annotation { public constructor FunAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/functions.txt b/compiler/testData/diagnostics/tests/annotations/options/functions.txt index b2ede3bdbdb..8935e4453b4 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/functions.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/functions.txt @@ -1,26 +1,26 @@ package public fun bar(/*0*/ arg: () -> kotlin.Int): kotlin.Int -@kotlin.inline() public fun fast(/*0*/ arg: () -> kotlin.Int): kotlin.Int -@kotlin.inline() public fun fast2(/*0*/ x: kotlin.Int, /*1*/ arg: () -> kotlin.Int): kotlin.Int +public inline fun fast(/*0*/ arg: () -> kotlin.Int): kotlin.Int +public inline fun fast2(/*0*/ x: kotlin.Int, /*1*/ arg: () -> kotlin.Int): kotlin.Int public fun foo(/*0*/ arg: kotlin.Int): kotlin.Unit @FunAnn() public fun gav(): kotlin.Int -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.annotation() public final class ExprAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) public final annotation class ExprAnn : kotlin.Annotation { public constructor ExprAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) @kotlin.annotation.annotation() public final class FunAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) public final annotation class FunAnn : kotlin.Annotation { public constructor FunAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.annotation() public final class SourceAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final annotation class SourceAnn : kotlin.Annotation { public constructor SourceAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/javaDocumented.txt b/compiler/testData/diagnostics/tests/annotations/options/javaDocumented.txt index eae1bb1b836..7122c81ac6a 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/javaDocumented.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/javaDocumented.txt @@ -6,21 +6,21 @@ public open class DocumentedAnnotations { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - @kotlin.annotation.MustBeDocumented() public final class DocAnn : kotlin.Annotation { + @kotlin.annotation.MustBeDocumented() public final annotation class DocAnn : kotlin.Annotation { public constructor DocAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - public final class NotDocAnn : kotlin.Annotation { + public final annotation class NotDocAnn : kotlin.Annotation { public constructor NotDocAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.MustBeDocumented() @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final class RunDocAnn : kotlin.Annotation { + @kotlin.annotation.MustBeDocumented() @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final annotation class RunDocAnn : kotlin.Annotation { public constructor RunDocAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/javaKotlinTargetRetention.txt b/compiler/testData/diagnostics/tests/annotations/options/javaKotlinTargetRetention.txt index adbb8cce528..7708bb1a7a6 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/javaKotlinTargetRetention.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/javaKotlinTargetRetention.txt @@ -1,13 +1,13 @@ package -@java.lang.annotation.Target(value = {ElementType.PACKAGE}) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) @kotlin.annotation.annotation() public final class my : kotlin.Annotation { +@java.lang.annotation.Target(value = {ElementType.PACKAGE}) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class my : kotlin.Annotation { public constructor my() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@java.lang.annotation.Retention(value = RetentionPolicy.SOURCE) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) @kotlin.annotation.annotation() public final class your : kotlin.Annotation { +@java.lang.annotation.Retention(value = RetentionPolicy.SOURCE) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class your : kotlin.Annotation { public constructor your() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/javaretention.txt b/compiler/testData/diagnostics/tests/annotations/options/javaretention.txt index a715dd048c3..f69e612ba46 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/javaretention.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/javaretention.txt @@ -6,28 +6,28 @@ public open class AnnotationRetentions { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - public final class BaseAnnotation : kotlin.Annotation { + public final annotation class BaseAnnotation : kotlin.Annotation { public constructor BaseAnnotation() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final class BinaryAnnotation : kotlin.Annotation { + @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class BinaryAnnotation : kotlin.Annotation { public constructor BinaryAnnotation() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final class RuntimeAnnotation : kotlin.Annotation { + @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final annotation class RuntimeAnnotation : kotlin.Annotation { public constructor RuntimeAnnotation() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final class SourceAnnotation : kotlin.Annotation { + @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final annotation class SourceAnnotation : kotlin.Annotation { public constructor SourceAnnotation() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/multiDeclaration.txt b/compiler/testData/diagnostics/tests/annotations/options/multiDeclaration.txt index 5a77e5822dc..5be8a82f139 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/multiDeclaration.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/multiDeclaration.txt @@ -2,14 +2,14 @@ package public fun foo(): kotlin.Int -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) @kotlin.annotation.annotation() public final class My : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class My : kotlin.Annotation { public constructor My() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public final class Pair { +public final data class Pair { public constructor Pair(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Int) public final val a: kotlin.Int public final val b: kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/objectLiteral.txt b/compiler/testData/diagnostics/tests/annotations/options/objectLiteral.txt index b91bd97bb46..56c9b98ff29 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/objectLiteral.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/objectLiteral.txt @@ -2,7 +2,7 @@ package public fun foo(): My -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) @kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/prefix.txt b/compiler/testData/diagnostics/tests/annotations/options/prefix.txt index 61f00b2a86b..e3a7f0b8b29 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/prefix.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/prefix.txt @@ -2,14 +2,14 @@ package public fun foo(): kotlin.Int -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.annotation() public final class ExprAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) public final annotation class ExprAnn : kotlin.Annotation { public constructor ExprAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) @kotlin.annotation.annotation() public final class FunAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) public final annotation class FunAnn : kotlin.Annotation { public constructor FunAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/repeatable.txt b/compiler/testData/diagnostics/tests/annotations/options/repeatable.txt index 21772a70931..e77af898baf 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/repeatable.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/repeatable.txt @@ -30,21 +30,21 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Retention(value = AnnotationRetention.BINARY) @kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class binrepann : kotlin.Annotation { +@kotlin.annotation.Retention(value = AnnotationRetention.BINARY) @kotlin.annotation.Repeatable() public final annotation class binrepann : kotlin.Annotation { public constructor binrepann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class repann : kotlin.Annotation { +@kotlin.annotation.Repeatable() public final annotation class repann : kotlin.Annotation { public constructor repann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class repann1 : kotlin.Annotation { +@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() public final annotation class repann1 : kotlin.Annotation { public constructor repann1(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -52,7 +52,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class repann2 : kotlin.Annotation { +@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() public final annotation class repann2 : kotlin.Annotation { public constructor repann2(/*0*/ f: kotlin.Boolean) public final val f: kotlin.Boolean public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -60,7 +60,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class repexpr : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.Repeatable() public final annotation class repexpr : kotlin.Annotation { public constructor repexpr() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/retention.txt b/compiler/testData/diagnostics/tests/annotations/options/retention.txt index df5868fbafc..55c6561fb03 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/retention.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/retention.txt @@ -7,7 +7,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.annotation() public final class sourceann : kotlin.Annotation { +@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final annotation class sourceann : kotlin.Annotation { public constructor sourceann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/setterParam.txt b/compiler/testData/diagnostics/tests/annotations/options/setterParam.txt index 4d354900049..f709e8f8a98 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/setterParam.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/setterParam.txt @@ -2,7 +2,7 @@ package public var x: kotlin.Int -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) @kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/target.txt b/compiler/testData/diagnostics/tests/annotations/options/target.txt index 740e7f0b05a..088428331e8 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/target.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/target.txt @@ -1,6 +1,6 @@ package -@base() @kotlin.data() public final class My { +@base() public final data class My { public constructor My(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public final operator /*synthesized*/ fun component1(): kotlin.Int @@ -10,7 +10,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) @kotlin.annotation.annotation() public final class base : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/accessors.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/accessors.txt index ed639436c2e..d37b8692fd4 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/accessors.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/accessors.txt @@ -9,21 +9,21 @@ public final class My { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) @kotlin.annotation.annotation() public final class base : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.PROPERTY_GETTER}) @kotlin.annotation.annotation() public final class smartget : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.PROPERTY_GETTER}) public final annotation class smartget : kotlin.Annotation { public constructor smartget() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.PROPERTY_SETTER}) @kotlin.annotation.annotation() public final class smartset : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.PROPERTY_SETTER}) public final annotation class smartset : kotlin.Annotation { public constructor smartset() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/annotation.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/annotation.txt index d115fa8df83..f462484afda 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/annotation.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/annotation.txt @@ -23,7 +23,7 @@ package @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) @kotlin.annotation.annotation() public final class base : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -39,7 +39,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@base() @kotlin.annotation.annotation() public final class derived : kotlin.Annotation { +@base() public final annotation class derived : kotlin.Annotation { public constructor derived() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/classifier.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/classifier.txt index f67794f5904..65b0a4e103c 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/classifier.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/classifier.txt @@ -23,7 +23,7 @@ package @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) @kotlin.annotation.annotation() public final class base : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -39,7 +39,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@base() @kotlin.annotation.annotation() public final class derived : kotlin.Annotation { +@base() public final annotation class derived : kotlin.Annotation { public constructor derived() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/constructor.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/constructor.txt index 3197110d3ae..783cb1867b7 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/constructor.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/constructor.txt @@ -23,7 +23,7 @@ package @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CONSTRUCTOR}) @kotlin.annotation.annotation() public final class base : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CONSTRUCTOR}) public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -39,7 +39,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@base() @kotlin.annotation.annotation() public final class derived : kotlin.Annotation { +@base() public final annotation class derived : kotlin.Annotation { public constructor derived() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/empty.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/empty.txt index a514c87f1d0..85eeee02005 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/empty.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/empty.txt @@ -32,14 +32,14 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@empty() @kotlin.annotation.annotation() public final class derived : kotlin.Annotation { +@empty() public final annotation class derived : kotlin.Annotation { public constructor derived() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {}) @kotlin.annotation.annotation() public final class empty : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {}) public final annotation class empty : kotlin.Annotation { public constructor empty() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/expr.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/expr.txt index 2ba45500702..56370cbf4da 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/expr.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/expr.txt @@ -3,14 +3,14 @@ package @base() @special() public fun foo(/*0*/ i: kotlin.Int): kotlin.Int public fun transform(/*0*/ i: kotlin.Int, /*1*/ tr: (kotlin.Int) -> kotlin.Int): kotlin.Int -@kotlin.annotation.annotation() public final class base : kotlin.Annotation { +public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.annotation() public final class special : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) public final annotation class special : kotlin.Annotation { public constructor special() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/file.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/file.txt index 3d1fe72ac70..9c2f09d4e63 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/file.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/file.txt @@ -16,14 +16,14 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class common : kotlin.Annotation { + public final annotation class common : kotlin.Annotation { public constructor common() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FILE}) @kotlin.annotation.annotation() public final class special : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FILE}) public final annotation class special : kotlin.Annotation { public constructor special() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/function.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/function.txt index 91dad1289aa..003e18ee890 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/function.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/function.txt @@ -23,7 +23,7 @@ package @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) @kotlin.annotation.annotation() public final class base : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -40,7 +40,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@base() @kotlin.annotation.annotation() public final class derived : kotlin.Annotation { +@base() public final annotation class derived : kotlin.Annotation { public constructor derived() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.txt index c88cfc375a8..b13607a4888 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/funtypeargs.txt @@ -3,14 +3,14 @@ package public fun foo(/*0*/ i: kotlin.Int): kotlin.Int public fun transform(/*0*/ i: kotlin.Int, /*1*/ tr: (kotlin.Int) -> kotlin.Int): kotlin.Int -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class base : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.annotation() public final class special : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) public final annotation class special : kotlin.Annotation { public constructor special() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.txt index 2c5b84b2cd4..f706a77935e 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/incorrect.txt @@ -32,14 +32,14 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@incorrect() @kotlin.annotation.annotation() public final class derived : kotlin.Annotation { +@incorrect() public final annotation class derived : kotlin.Annotation { public constructor derived() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {}) @kotlin.annotation.annotation() public final class incorrect : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {}) public final annotation class incorrect : kotlin.Annotation { public constructor incorrect() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/init.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/init.txt index 50ca98b9da1..50f0962821e 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/init.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/init.txt @@ -7,7 +7,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class base : kotlin.Annotation { +public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/java.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/java.txt index 43a33ec5690..f5209c86af7 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/java.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/java.txt @@ -8,63 +8,63 @@ package test { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - public final class base : kotlin.Annotation { + public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FIELD}) public final class fieldann : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FIELD}) public final annotation class fieldann : kotlin.Annotation { public constructor fieldann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CONSTRUCTOR}) public final class konstructor : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CONSTRUCTOR}) public final annotation class konstructor : kotlin.Annotation { public constructor konstructor() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.LOCAL_VARIABLE}) public final class local : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.LOCAL_VARIABLE}) public final annotation class local : kotlin.Annotation { public constructor local() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) public final class meta : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) public final annotation class meta : kotlin.Annotation { public constructor meta() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER}) public final class method : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER}) public final annotation class method : kotlin.Annotation { public constructor method() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FIELD}) public final class multiple : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FIELD}) public final annotation class multiple : kotlin.Annotation { public constructor multiple() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) public final class parameter : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) public final annotation class parameter : kotlin.Annotation { public constructor parameter() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE}) public final class type : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE}) public final annotation class type : kotlin.Annotation { public constructor type() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -83,7 +83,7 @@ package test { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @test.AnnotationTargets.base() @test.AnnotationTargets.meta() @test.AnnotationTargets.type() @test.AnnotationTargets.konstructor() @kotlin.annotation.annotation() public final class KMeta : kotlin.Annotation { + @test.AnnotationTargets.base() @test.AnnotationTargets.meta() @test.AnnotationTargets.type() @test.AnnotationTargets.konstructor() public final annotation class KMeta : kotlin.Annotation { public constructor KMeta() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/local.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/local.txt index 6e9c199c399..0f4816eed3f 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/local.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/local.txt @@ -23,7 +23,7 @@ package @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.LOCAL_VARIABLE}) @kotlin.annotation.annotation() public final class base : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.LOCAL_VARIABLE}) public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -39,7 +39,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@base() @kotlin.annotation.annotation() public final class derived : kotlin.Annotation { +@base() public final annotation class derived : kotlin.Annotation { public constructor derived() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/nested.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/nested.txt index 9db9784b6d0..99338097ec0 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/nested.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/nested.txt @@ -7,7 +7,7 @@ package public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - @base() @meta() @kotlin.annotation.annotation() public final class Annotated : kotlin.Annotation { + @base() @meta() public final annotation class Annotated : kotlin.Annotation { public constructor Annotated() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -22,14 +22,14 @@ package } } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) @kotlin.annotation.annotation() public final class base : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) @kotlin.annotation.annotation() public final class meta : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) public final annotation class meta : kotlin.Annotation { public constructor meta() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/property.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/property.txt index 675efb0c9be..b592cf3cad1 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/property.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/property.txt @@ -23,7 +23,7 @@ package @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.PROPERTY}) @kotlin.annotation.annotation() public final class base : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.PROPERTY}) public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -39,7 +39,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@base() @kotlin.annotation.annotation() public final class derived : kotlin.Annotation { +@base() public final annotation class derived : kotlin.Annotation { public constructor derived() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/returntype.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/returntype.txt index f2c3ca251ef..e4cc57bcda1 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/returntype.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/returntype.txt @@ -10,14 +10,14 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class base : kotlin.Annotation { +public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class typed : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class typed : kotlin.Annotation { public constructor typed() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/type.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/type.txt index 64f4ecebef6..37c60e6842a 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/type.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/type.txt @@ -23,7 +23,7 @@ package @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class base : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -39,7 +39,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@base() @kotlin.annotation.annotation() public final class derived : kotlin.Annotation { +@base() public final annotation class derived : kotlin.Annotation { public constructor derived() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/typeParams.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/typeParams.txt index 0302134adf0..a88825b9315 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/typeParams.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/typeParams.txt @@ -7,14 +7,14 @@ public fun test(/*0*/ t: @A() T): T public fun test2(/*0*/ t: T): T public fun topFun(): kotlin.Int -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) @kotlin.annotation.annotation() public final class A : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation { public constructor A() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) @kotlin.annotation.annotation() public final class B : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class B : kotlin.Annotation { public constructor B(/*0*/ i: kotlin.Int = ...) public final val i: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -22,7 +22,7 @@ public fun topFun(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() internal final class C : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) internal final annotation class C : kotlin.Annotation { public constructor C() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.txt index 314c1130ba0..9c0e5aed368 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/typeargs.txt @@ -4,14 +4,14 @@ public val x: kotlin.List<@base() kotlin.String>? = null public val y: kotlin.List<@base() kotlin.String>? = null public fun foo(/*0*/ list: kotlin.List<@typeAnn() kotlin.Int>): kotlin.List<@typeAnn() kotlin.Int> -@kotlin.annotation.annotation() public final class base : kotlin.Annotation { +public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class typeAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class typeAnn : kotlin.Annotation { public constructor typeAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.txt b/compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.txt index b7336926a8d..9140f9ad6c4 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/targets/valueparam.txt @@ -23,7 +23,7 @@ package @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) @kotlin.annotation.annotation() public final class base : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) public final annotation class base : kotlin.Annotation { public constructor base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -39,7 +39,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@base() @kotlin.annotation.annotation() public final class derived : kotlin.Annotation { +@base() public final annotation class derived : kotlin.Annotation { public constructor derived() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/options/unrepeatable.txt b/compiler/testData/diagnostics/tests/annotations/options/unrepeatable.txt index 8609f753fed..0e90958fe26 100644 --- a/compiler/testData/diagnostics/tests/annotations/options/unrepeatable.txt +++ b/compiler/testData/diagnostics/tests/annotations/options/unrepeatable.txt @@ -16,7 +16,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann(/*0*/ y: kotlin.Int) public final val y: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -24,14 +24,14 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.annotation() public final class annexpr : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) public final annotation class annexpr : kotlin.Annotation { public constructor annexpr() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class unrepann : kotlin.Annotation { +public final annotation class unrepann : kotlin.Annotation { public constructor unrepann(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/annotations/typeAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/typeAnnotations.txt index 52569f6d4d6..b35bf1cb7b5 100644 --- a/compiler/testData/diagnostics/tests/annotations/typeAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/typeAnnotations.txt @@ -12,7 +12,7 @@ public final class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class x : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class x : kotlin.Annotation { public constructor x() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FieldAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FieldAnnotations.txt index deade42cfcd..778e76c9ac7 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FieldAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FieldAnnotations.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FileAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FileAnnotations.txt index b243db16bca..375a0f87e66 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FileAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/FileAnnotations.txt @@ -1,13 +1,13 @@ package -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) @kotlin.annotation.annotation() public final class ClassAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class ClassAnn : kotlin.Annotation { public constructor ClassAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FILE}) @kotlin.annotation.annotation() public final class FileAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FILE}) public final annotation class FileAnn : kotlin.Annotation { public constructor FileAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/GetterAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/GetterAnnotations.txt index 0802bdf9d2f..a5281afd33c 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/GetterAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/GetterAnnotations.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ParamAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ParamAnnotations.txt index 889b2365959..031919de27b 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ParamAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ParamAnnotations.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -15,7 +15,7 @@ public final class PrimaryConstructorClass { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Second : kotlin.Annotation { +public final annotation class Second : kotlin.Annotation { public constructor Second() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/PropertyAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/PropertyAnnotations.txt index 802e3f3e660..8eba94d4378 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/PropertyAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/PropertyAnnotations.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -15,7 +15,7 @@ public final class CustomDelegate { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Second : kotlin.Annotation { +public final annotation class Second : kotlin.Annotation { public constructor Second() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ReceiverAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ReceiverAnnotations.txt index 726e0e5fe39..e7c9d4658de 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ReceiverAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/ReceiverAnnotations.txt @@ -3,7 +3,7 @@ package public val @receiver:Ann() kotlin.String.extensionProperty: kotlin.String public fun @receiver:Ann() kotlin.String.length2(): kotlin.Int -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SetterAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SetterAnnotations.txt index b6419f615cf..6b9979906a0 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SetterAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SetterAnnotations.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SparamAnnotations.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SparamAnnotations.txt index bbba899ce5d..f63e0a1008b 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SparamAnnotations.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/SparamAnnotations.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.txt b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.txt index aa86b1a6e31..71830de16b2 100644 --- a/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.txt +++ b/compiler/testData/diagnostics/tests/annotations/withUseSiteTarget/repeatable.txt @@ -13,14 +13,14 @@ public final class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class RepeatableAnn : kotlin.Annotation { +@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() public final annotation class RepeatableAnn : kotlin.Annotation { public constructor RepeatableAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.txt b/compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.txt index 5ea1d72c77f..3133c96f0b8 100644 --- a/compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.txt +++ b/compiler/testData/diagnostics/tests/callableReference/function/abstractClassConstructors.txt @@ -15,7 +15,7 @@ public abstract class B { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class C : kotlin.Annotation { +public final annotation class C : kotlin.Annotation { public constructor C() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/callableReference/function/constructorFromCompanion.txt b/compiler/testData/diagnostics/tests/callableReference/function/constructorFromCompanion.txt index d11bac71346..afe3822cc36 100644 --- a/compiler/testData/diagnostics/tests/callableReference/function/constructorFromCompanion.txt +++ b/compiler/testData/diagnostics/tests/callableReference/function/constructorFromCompanion.txt @@ -1,6 +1,6 @@ package -@kotlin.inline() public fun createWith(/*0*/ x: T, /*1*/ f: (T) -> A?): A? +public inline fun createWith(/*0*/ x: T, /*1*/ f: (T) -> A?): A? public open class A { public constructor A(/*0*/ x: T) diff --git a/compiler/testData/diagnostics/tests/classLiteral/genericArrays.txt b/compiler/testData/diagnostics/tests/classLiteral/genericArrays.txt index 406a8f7b8cd..db9255fe89e 100644 --- a/compiler/testData/diagnostics/tests/classLiteral/genericArrays.txt +++ b/compiler/testData/diagnostics/tests/classLiteral/genericArrays.txt @@ -2,7 +2,7 @@ package public fun f1(): kotlin.reflect.KClass> public fun f2(): kotlin.reflect.KClass>> -@kotlin.inline() public fun f3(): kotlin.reflect.KClass> -@kotlin.inline() public fun f4(): kotlin.reflect.KClass>> +public inline fun f3(): kotlin.reflect.KClass> +public inline fun f4(): kotlin.reflect.KClass>> public fun f5(): kotlin.reflect.KClass> public fun f6(): kotlin.reflect.KClass> diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt5200DeadCodeInLambdas.txt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt5200DeadCodeInLambdas.txt index 29636d29545..94fc10e6368 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt5200DeadCodeInLambdas.txt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/deadCode/kt5200DeadCodeInLambdas.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun doCall(/*0*/ block: () -> kotlin.String): kotlin.String +public inline fun doCall(/*0*/ block: () -> kotlin.String): kotlin.String public fun test1(): kotlin.String public fun test2(/*0*/ nonLocal: kotlin.String, /*1*/ b: kotlin.Boolean): kotlin.String diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1189.txt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1189.txt index 4ed3bbfe5b6..5b70d31efbd 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1189.txt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt1189.txt @@ -2,5 +2,5 @@ package package kt1189 { public fun foo(): kotlin.Unit - @kotlin.inline() public fun java.util.concurrent.locks.ReentrantReadWriteLock.write(/*0*/ action: () -> T): T + public inline fun java.util.concurrent.locks.ReentrantReadWriteLock.write(/*0*/ action: () -> T): T } diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2972.txt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2972.txt index 8c2b4b7aeee..18746207f28 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2972.txt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2972.txt @@ -1,3 +1,3 @@ package -@kotlin.inline() public fun T.use(/*0*/ block: (T) -> R): R +public inline fun T.use(/*0*/ block: (T) -> R): R diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4126.txt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4126.txt index 909274cc8e8..7e7beab89d7 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4126.txt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/kt4126.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public final class ProductGroup { +public final data class ProductGroup { public constructor ProductGroup(/*0*/ short_name: kotlin.String, /*1*/ parent: ProductGroup?) public final val name: kotlin.String public final val parent: ProductGroup? diff --git a/compiler/testData/diagnostics/tests/dataClasses/componentNamedComponent1.txt b/compiler/testData/diagnostics/tests/dataClasses/componentNamedComponent1.txt index fdabd28b344..42d6e64c08f 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/componentNamedComponent1.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/componentNamedComponent1.txt @@ -2,7 +2,7 @@ package public fun foo(/*0*/ a: A): kotlin.Unit -@kotlin.data() public final class A { +public final data class A { public constructor A(/*0*/ component1: kotlin.Int) public final val component1: kotlin.Int public final operator /*synthesized*/ fun component1(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/dataClasses/conflictingCopyOverloads.txt b/compiler/testData/diagnostics/tests/dataClasses/conflictingCopyOverloads.txt index f2102065ccb..773abd4be96 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/conflictingCopyOverloads.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/conflictingCopyOverloads.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public final class A { +public final data class A { public constructor A(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String) public final val x: kotlin.Int public final val y: kotlin.String diff --git a/compiler/testData/diagnostics/tests/dataClasses/conflictingOverloads.txt b/compiler/testData/diagnostics/tests/dataClasses/conflictingOverloads.txt index 50cc83cd0d5..c426f360172 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/conflictingOverloads.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/conflictingOverloads.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public final class A { +public final data class A { public constructor A(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String) public final val x: kotlin.Int public final val y: kotlin.String diff --git a/compiler/testData/diagnostics/tests/dataClasses/copyOfPrivateClass.txt b/compiler/testData/diagnostics/tests/dataClasses/copyOfPrivateClass.txt index 1e1f52dbb8e..18ed9e50aa3 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/copyOfPrivateClass.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/copyOfPrivateClass.txt @@ -6,7 +6,7 @@ public final class Outer { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - @kotlin.data() private final class Nested { + private final data class Nested { public constructor Nested(/*0*/ c: kotlin.Int) public final val c: kotlin.Int public final operator /*synthesized*/ fun component1(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/dataClasses/dataClassNoName.txt b/compiler/testData/diagnostics/tests/dataClasses/dataClassNoName.txt index 63169e5a31b..76bb06d100f 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/dataClassNoName.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/dataClassNoName.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public final class { +public final data class { public constructor () public final /*synthesized*/ fun copy(): public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -8,7 +8,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public interface { +public data interface { public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String diff --git a/compiler/testData/diagnostics/tests/dataClasses/dataClassVarargParam.txt b/compiler/testData/diagnostics/tests/dataClasses/dataClassVarargParam.txt index ab617b66201..4f6f644a84c 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/dataClassVarargParam.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/dataClassVarargParam.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public final class My { +public final data class My { public constructor My(/*0*/ x: kotlin.Int, /*1*/ vararg y: kotlin.String /*kotlin.Array*/) public final val x: kotlin.Int public final val y: kotlin.Array @@ -12,7 +12,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public final class Your { +public final data class Your { public constructor Your(/*0*/ vararg z: kotlin.String /*kotlin.Array*/) public final /*synthesized*/ fun copy(/*0*/ vararg z: kotlin.String /*kotlin.Array*/): Your public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/dataClasses/dataInheritance.txt b/compiler/testData/diagnostics/tests/dataClasses/dataInheritance.txt index 9275ecb0a41..7d5e02b560e 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/dataInheritance.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/dataInheritance.txt @@ -6,7 +6,7 @@ public interface Allowed { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public abstract class Base { +public abstract data class Base { public constructor Base(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public final operator /*synthesized*/ fun component1(): kotlin.Int @@ -16,7 +16,7 @@ public interface Allowed { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public final class Complex : Allowed, NotAllowed { +public final data class Complex : Allowed, NotAllowed { public constructor Complex(/*0*/ y: kotlin.Int) public final val y: kotlin.Int public final operator /*synthesized*/ fun component1(): kotlin.Int @@ -36,7 +36,7 @@ public final class Derived : Base { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public final class Nasty : Base { +public final data class Nasty : Base { public constructor Nasty(/*0*/ z: kotlin.Int, /*1*/ y: kotlin.Int) public final override /*1*/ /*fake_override*/ val x: kotlin.Int public final val y: kotlin.Int diff --git a/compiler/testData/diagnostics/tests/dataClasses/emptyConstructor.txt b/compiler/testData/diagnostics/tests/dataClasses/emptyConstructor.txt index e48dadb0b21..d89fcfc4d27 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/emptyConstructor.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/emptyConstructor.txt @@ -2,7 +2,7 @@ package public fun foo(/*0*/ a: A): kotlin.Unit -@kotlin.data() public final class A { +public final data class A { public constructor A() public final /*synthesized*/ fun copy(): A public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasComponent1.txt b/compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasComponent1.txt index 1e01f38faec..33f5dce3721 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasComponent1.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasComponent1.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public final class A : T { +public final data class A : T { public constructor A(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public final operator override /*1*/ /*synthesized*/ fun component1(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasFinalComponent1.txt b/compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasFinalComponent1.txt index 4510a47d289..a7811b0adde 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasFinalComponent1.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/implementTraitWhichHasFinalComponent1.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public final class A : T { +public final data class A : T { public constructor A(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public final operator override /*1*/ /*synthesized*/ fun component1(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/dataClasses/innerDataClass.txt b/compiler/testData/diagnostics/tests/dataClasses/innerDataClass.txt index d5ac3e4a9ab..012fef42fc5 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/innerDataClass.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/innerDataClass.txt @@ -6,7 +6,7 @@ public final class Outer { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - @kotlin.data() public final inner class Inner { + public final inner data class Inner { public constructor Inner(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public final operator /*synthesized*/ fun component1(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/dataClasses/innerOuterDataClass.txt b/compiler/testData/diagnostics/tests/dataClasses/innerOuterDataClass.txt index 4ee5314accd..4c6f3154d8a 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/innerOuterDataClass.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/innerOuterDataClass.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public final class Outer { +public final data class Outer { public constructor Outer(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public final operator /*synthesized*/ fun component1(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/dataClasses/multiDeclaration.txt b/compiler/testData/diagnostics/tests/dataClasses/multiDeclaration.txt index 881b5024989..bdfbdc1aa80 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/multiDeclaration.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/multiDeclaration.txt @@ -2,7 +2,7 @@ package public fun foo(/*0*/ a: A): kotlin.Unit -@kotlin.data() public final class A { +public final data class A { public constructor A(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String) public final val x: kotlin.Int public final val y: kotlin.String diff --git a/compiler/testData/diagnostics/tests/dataClasses/multiDeclarationFor.txt b/compiler/testData/diagnostics/tests/dataClasses/multiDeclarationFor.txt index 3ef137100c3..e4e6c7a8e49 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/multiDeclarationFor.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/multiDeclarationFor.txt @@ -2,7 +2,7 @@ package public fun foo(/*0*/ arr: kotlin.Array): kotlin.Unit -@kotlin.data() public final class A { +public final data class A { public constructor A(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String) public final val x: kotlin.Int public final val y: kotlin.String diff --git a/compiler/testData/diagnostics/tests/dataClasses/noConstructor.txt b/compiler/testData/diagnostics/tests/dataClasses/noConstructor.txt index e48dadb0b21..d89fcfc4d27 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/noConstructor.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/noConstructor.txt @@ -2,7 +2,7 @@ package public fun foo(/*0*/ a: A): kotlin.Unit -@kotlin.data() public final class A { +public final data class A { public constructor A() public final /*synthesized*/ fun copy(): A public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/dataClasses/oneValParam.txt b/compiler/testData/diagnostics/tests/dataClasses/oneValParam.txt index 2eab33ecbfe..728b7ca1151 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/oneValParam.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/oneValParam.txt @@ -2,7 +2,7 @@ package public fun foo(/*0*/ a: A): kotlin.Unit -@kotlin.data() public final class A { +public final data class A { public constructor A(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public final operator /*synthesized*/ fun component1(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/dataClasses/repeatedProperties.txt b/compiler/testData/diagnostics/tests/dataClasses/repeatedProperties.txt index 7f653f24f2c..8a7f4c25cdc 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/repeatedProperties.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/repeatedProperties.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public final class A1 { +public final data class A1 { public constructor A1(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String, /*2*/ x: kotlin.Int) public final val x: kotlin.Int public final val x: kotlin.Int @@ -15,7 +15,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public final class A2 { +public final data class A2 { public constructor A2(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String) public final val x: kotlin.Int public final val x: kotlin.String = "" @@ -28,7 +28,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public final class A3 { +public final data class A3 { public constructor A3(/*0*/ : kotlin.Int, /*1*/ : kotlin.Int) public final val : kotlin.Int public final val : kotlin.Int diff --git a/compiler/testData/diagnostics/tests/dataClasses/sealedDataClass.txt b/compiler/testData/diagnostics/tests/dataClasses/sealedDataClass.txt index 4241804b766..414072771e3 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/sealedDataClass.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/sealedDataClass.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public sealed class My { +public sealed data class My { private constructor My(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public final operator /*synthesized*/ fun component1(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/dataClasses/strange.txt b/compiler/testData/diagnostics/tests/dataClasses/strange.txt index da093f1eb27..6f6abe32dff 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/strange.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/strange.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public final enum class First : kotlin.Enum { +public final data enum class First : kotlin.Enum { enum entry A enum entry B @@ -23,7 +23,7 @@ package @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } -@kotlin.data() @kotlin.annotation.annotation() public final class Fourth : kotlin.Annotation { +public final data annotation class Fourth : kotlin.Annotation { public constructor Fourth(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public final operator /*synthesized*/ fun component1(): kotlin.Int @@ -33,7 +33,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public object Second { +public data object Second { private constructor Second() public final /*synthesized*/ fun copy(): Second public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -41,7 +41,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public interface Third { +public data interface Third { public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String diff --git a/compiler/testData/diagnostics/tests/dataClasses/twoValParams.txt b/compiler/testData/diagnostics/tests/dataClasses/twoValParams.txt index 881b5024989..bdfbdc1aa80 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/twoValParams.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/twoValParams.txt @@ -2,7 +2,7 @@ package public fun foo(/*0*/ a: A): kotlin.Unit -@kotlin.data() public final class A { +public final data class A { public constructor A(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String) public final val x: kotlin.Int public final val y: kotlin.String diff --git a/compiler/testData/diagnostics/tests/dataClasses/twoVarParams.txt b/compiler/testData/diagnostics/tests/dataClasses/twoVarParams.txt index 43dbcc4d63f..b59cfc837c4 100644 --- a/compiler/testData/diagnostics/tests/dataClasses/twoVarParams.txt +++ b/compiler/testData/diagnostics/tests/dataClasses/twoVarParams.txt @@ -2,7 +2,7 @@ package public fun foo(/*0*/ a: A): kotlin.Unit -@kotlin.data() public final class A { +public final data class A { public constructor A(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String) public final var x: kotlin.Int public final var y: kotlin.String diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.txt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.txt index e5b85d9c5b8..24bc91e6ad1 100644 --- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.txt +++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/ArrayAccess.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun Array(/*0*/ n: kotlin.Int, /*1*/ block: (kotlin.Int) -> T): kotlin.Array +public inline fun Array(/*0*/ n: kotlin.Int, /*1*/ block: (kotlin.Int) -> T): kotlin.Array public fun bar(/*0*/ x: kotlin.Int): kotlin.Int public fun foo(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/For.txt b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/For.txt index e5b85d9c5b8..24bc91e6ad1 100644 --- a/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/For.txt +++ b/compiler/testData/diagnostics/tests/dataFlowInfoTraversal/For.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun Array(/*0*/ n: kotlin.Int, /*1*/ block: (kotlin.Int) -> T): kotlin.Array +public inline fun Array(/*0*/ n: kotlin.Int, /*1*/ block: (kotlin.Int) -> T): kotlin.Array public fun bar(/*0*/ x: kotlin.Int): kotlin.Int public fun foo(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.txt b/compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.txt index 6cbb6d2c60a..50de6fa4ab0 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.txt +++ b/compiler/testData/diagnostics/tests/declarationChecks/FunctionWithMissingNames.txt @@ -29,7 +29,7 @@ public final class Outer { public final fun B.(): kotlin.Unit } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE, AnnotationTarget.FUNCTION}) @kotlin.annotation.annotation() public final class a : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE, AnnotationTarget.FUNCTION}) public final annotation class a : kotlin.Annotation { public constructor a() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.txt b/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.txt index 0fc47fe918a..4269e6ebe63 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.txt +++ b/compiler/testData/diagnostics/tests/declarationChecks/illegalModifiersOnClass.txt @@ -85,7 +85,7 @@ public interface D { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public open class E : kotlin.Annotation { +public open annotation class E : kotlin.Annotation { public constructor E() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/declarationChecks/multiDeclarations/kt2829.txt b/compiler/testData/diagnostics/tests/declarationChecks/multiDeclarations/kt2829.txt index 4e172afa1ff..7fe15992cee 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/multiDeclarations/kt2829.txt +++ b/compiler/testData/diagnostics/tests/declarationChecks/multiDeclarations/kt2829.txt @@ -5,7 +5,7 @@ package test { public fun b(/*0*/ s: kotlin.String): kotlin.Unit public fun println(/*0*/ a: kotlin.Any?): kotlin.Any? - @kotlin.data() public final class Pair { + public final data class Pair { public constructor Pair(/*0*/ a: A, /*1*/ b: B) public final val a: A public final val b: B diff --git a/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.txt b/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.txt index c6d5cc2abf6..3b6c1ca54b9 100644 --- a/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.txt +++ b/compiler/testData/diagnostics/tests/delegatedProperty/inference/genericMethods.txt @@ -6,9 +6,9 @@ public var b: kotlin.Int public var c: kotlin.String public val cObj: C public operator fun B.getValue(/*0*/ t: kotlin.Any?, /*1*/ p: kotlin.reflect.KProperty<*>): T -@kotlin.inline() public operator fun C.getValue(/*0*/ t: kotlin.Any?, /*1*/ p: kotlin.reflect.KProperty<*>): T +public operator inline fun C.getValue(/*0*/ t: kotlin.Any?, /*1*/ p: kotlin.reflect.KProperty<*>): T public operator fun B.setValue(/*0*/ t: kotlin.Any?, /*1*/ p: kotlin.reflect.KProperty<*>, /*2*/ x: T): kotlin.Unit -@kotlin.inline() public operator fun C.setValue(/*0*/ t: kotlin.Any?, /*1*/ p: kotlin.reflect.KProperty<*>, /*2*/ x: T): kotlin.Unit +public operator inline fun C.setValue(/*0*/ t: kotlin.Any?, /*1*/ p: kotlin.reflect.KProperty<*>, /*2*/ x: T): kotlin.Unit public final class A { public constructor A() diff --git a/compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.txt b/compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.txt index 3b8cdd29a31..dcc675b56d4 100644 --- a/compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.txt +++ b/compiler/testData/diagnostics/tests/deparenthesize/annotatedSafeCall.txt @@ -2,7 +2,7 @@ package public fun f(/*0*/ s: kotlin.String?): kotlin.Boolean -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.annotation() public final class foo : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) public final annotation class foo : kotlin.Annotation { public constructor foo() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/deprecated/annotationUsage.txt b/compiler/testData/diagnostics/tests/deprecated/annotationUsage.txt index e31d253421d..d8af81f365d 100644 --- a/compiler/testData/diagnostics/tests/deprecated/annotationUsage.txt +++ b/compiler/testData/diagnostics/tests/deprecated/annotationUsage.txt @@ -14,14 +14,14 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.Deprecated(message = "text") @kotlin.annotation.annotation() public final class obsolete : kotlin.Annotation { +@kotlin.Deprecated(message = "text") public final annotation class obsolete : kotlin.Annotation { public constructor obsolete() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.Deprecated(message = "text") @kotlin.annotation.annotation() public final class obsoleteWithParam : kotlin.Annotation { +@kotlin.Deprecated(message = "text") public final annotation class obsoleteWithParam : kotlin.Annotation { public constructor obsoleteWithParam(/*0*/ text: kotlin.String) public final val text: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.txt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.txt index 0013e7926bd..621c6f70990 100644 --- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.txt +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/missingNames.txt @@ -34,7 +34,7 @@ public final enum class : kotlin.Enum<> { @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array<> } -@kotlin.annotation.annotation() public final class : kotlin.Annotation { +public final annotation class : kotlin.Annotation { public constructor () public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -85,7 +85,7 @@ public final class Outer { @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array> } - @kotlin.annotation.annotation() public final class : kotlin.Annotation { + public final annotation class : kotlin.Annotation { public constructor () public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/dataClassCopy.txt b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/dataClassCopy.txt index 17b0cac99f1..8b218fd3062 100644 --- a/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/dataClassCopy.txt +++ b/compiler/testData/diagnostics/tests/duplicateJvmSignature/specialNames/dataClassCopy.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public final class C { +public final data class C { public constructor C(/*0*/ c: kotlin.Int) public final val c: kotlin.Int public final operator /*synthesized*/ fun component1(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.txt b/compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.txt index c80a66ef732..943a4d8eae3 100644 --- a/compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.txt +++ b/compiler/testData/diagnostics/tests/enum/enumWithAnnotationKeyword.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final enum class E : kotlin.Enum { +public final enum class E : kotlin.Enum { enum entry D private constructor E() diff --git a/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.txt b/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.txt index 1cc262fa7e2..d708275edb9 100644 --- a/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.txt +++ b/compiler/testData/diagnostics/tests/enum/modifiersOnEnumEntry.txt @@ -21,7 +21,7 @@ public final enum class E : kotlin.Enum { enum entry INNER - @kotlin.annotation.annotation() enum entry ANNOTATION + enum entry ANNOTATION enum entry ENUM diff --git a/compiler/testData/diagnostics/tests/evaluate/divisionByZero.txt b/compiler/testData/diagnostics/tests/evaluate/divisionByZero.txt index 5f187fa353c..ec3df72eced 100644 --- a/compiler/testData/diagnostics/tests/evaluate/divisionByZero.txt +++ b/compiler/testData/diagnostics/tests/evaluate/divisionByZero.txt @@ -12,7 +12,7 @@ public val a9: kotlin.Int public val b1: kotlin.Byte @Ann() public val b2: kotlin.Int = 1 -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ i: kotlin.Int) public final val i: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/extensions/kt819ExtensionProperties.kt b/compiler/testData/diagnostics/tests/extensions/kt819ExtensionProperties.kt index 1a63b490b0d..83a43ec2657 100644 --- a/compiler/testData/diagnostics/tests/extensions/kt819ExtensionProperties.kt +++ b/compiler/testData/diagnostics/tests/extensions/kt819ExtensionProperties.kt @@ -2,10 +2,10 @@ import java.io.* -inline val InputStream.buffered : BufferedInputStream +inline val InputStream.buffered : BufferedInputStream get() = if(this is BufferedInputStream) this else BufferedInputStream(this) -inline val Reader.buffered : BufferedReader +inline val Reader.buffered : BufferedReader get() = if(this is BufferedReader) this else BufferedReader(this) diff --git a/compiler/testData/diagnostics/tests/extensions/kt819ExtensionProperties.txt b/compiler/testData/diagnostics/tests/extensions/kt819ExtensionProperties.txt index 59210825c3b..652c93d4b95 100644 --- a/compiler/testData/diagnostics/tests/extensions/kt819ExtensionProperties.txt +++ b/compiler/testData/diagnostics/tests/extensions/kt819ExtensionProperties.txt @@ -1,7 +1,7 @@ package -@kotlin.inline() public val java.io.InputStream.buffered: java.io.BufferedInputStream -@kotlin.inline() public val java.io.Reader.buffered: java.io.BufferedReader +public val java.io.InputStream.buffered: java.io.BufferedInputStream +public val java.io.Reader.buffered: java.io.BufferedReader public open class A { public constructor A() diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/Common.txt b/compiler/testData/diagnostics/tests/functionAsExpression/Common.txt index dd583e68284..702e3c70a49 100644 --- a/compiler/testData/diagnostics/tests/functionAsExpression/Common.txt +++ b/compiler/testData/diagnostics/tests/functionAsExpression/Common.txt @@ -18,7 +18,7 @@ public final class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann(/*0*/ name: kotlin.String) public final val name: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/functionAsExpression/WithoutBody.txt b/compiler/testData/diagnostics/tests/functionAsExpression/WithoutBody.txt index 5a152430a47..8192b3d5358 100644 --- a/compiler/testData/diagnostics/tests/functionAsExpression/WithoutBody.txt +++ b/compiler/testData/diagnostics/tests/functionAsExpression/WithoutBody.txt @@ -4,7 +4,7 @@ public val bas: () -> kotlin.Unit public fun bar(/*0*/ a: kotlin.Any): () -> kotlin.Unit public fun outer(): kotlin.Unit -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/generics/tpAsReified/Conventions.txt b/compiler/testData/diagnostics/tests/generics/tpAsReified/Conventions.txt index ab8123e08b7..f44aa3b4104 100644 --- a/compiler/testData/diagnostics/tests/generics/tpAsReified/Conventions.txt +++ b/compiler/testData/diagnostics/tests/generics/tpAsReified/Conventions.txt @@ -1,5 +1,5 @@ package public fun main(/*0*/ tp: A, /*1*/ any: kotlin.Any): kotlin.Unit -@kotlin.inline() public operator fun T.invoke(): T -@kotlin.inline() public operator fun T.plus(/*0*/ p: T): T +public operator inline fun T.invoke(): T +public operator inline fun T.plus(/*0*/ p: T): T diff --git a/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.txt b/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.txt index d39974f7504..70264cf24be 100644 --- a/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.txt +++ b/compiler/testData/diagnostics/tests/generics/tpAsReified/InFunction.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun f(): T +public inline fun f(): T public fun id(/*0*/ p: T): T public fun main(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/generics/tpAsReified/InlineableReified.txt b/compiler/testData/diagnostics/tests/generics/tpAsReified/InlineableReified.txt index 2a9afcee694..b327bb71389 100644 --- a/compiler/testData/diagnostics/tests/generics/tpAsReified/InlineableReified.txt +++ b/compiler/testData/diagnostics/tests/generics/tpAsReified/InlineableReified.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun bar(/*0*/ x: T1, /*1*/ y: T2): T2 +public inline fun bar(/*0*/ x: T1, /*1*/ y: T2): T2 public fun box(): kotlin.Unit -@kotlin.inline() public fun foo(/*0*/ z: R): R +public inline fun foo(/*0*/ z: R): R diff --git a/compiler/testData/diagnostics/tests/generics/tpAsReified/LocalFun.txt b/compiler/testData/diagnostics/tests/generics/tpAsReified/LocalFun.txt index eedd09f057a..c396e61d31c 100644 --- a/compiler/testData/diagnostics/tests/generics/tpAsReified/LocalFun.txt +++ b/compiler/testData/diagnostics/tests/generics/tpAsReified/LocalFun.txt @@ -1,3 +1,3 @@ package -@kotlin.inline() public fun foo(/*0*/ x: T): kotlin.Unit +public inline fun foo(/*0*/ x: T): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/incompleteCode/SupertypeOfErrorType.txt b/compiler/testData/diagnostics/tests/incompleteCode/SupertypeOfErrorType.txt index eef3e93ccad..61e87caeda3 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/SupertypeOfErrorType.txt +++ b/compiler/testData/diagnostics/tests/incompleteCode/SupertypeOfErrorType.txt @@ -2,6 +2,6 @@ package package a { public fun bar(/*0*/ i: kotlin.Int, /*1*/ a: [ERROR : U]): kotlin.Unit - @kotlin.inline() public fun comparator(/*0*/ fn: (T, T) -> kotlin.Int): java.util.Comparator + public inline fun comparator(/*0*/ fn: (T, T) -> kotlin.Int): java.util.Comparator public fun foo(): kotlin.Unit } diff --git a/compiler/testData/diagnostics/tests/inference/constraints/ignoreConstraintFromImplicitInNothing.txt b/compiler/testData/diagnostics/tests/inference/constraints/ignoreConstraintFromImplicitInNothing.txt index 44e72fc6209..66fee920817 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/ignoreConstraintFromImplicitInNothing.txt +++ b/compiler/testData/diagnostics/tests/inference/constraints/ignoreConstraintFromImplicitInNothing.txt @@ -1,7 +1,7 @@ package public fun foo1(/*0*/ f: (T) -> kotlin.Unit): Foo -@kotlin.inline() public fun foo2(/*0*/ f: (T) -> kotlin.Unit): Foo +public inline fun foo2(/*0*/ f: (T) -> kotlin.Unit): Foo public fun test1(): kotlin.Unit public final class Foo { diff --git a/compiler/testData/diagnostics/tests/inference/constraints/kt7433.txt b/compiler/testData/diagnostics/tests/inference/constraints/kt7433.txt index 7b7415fdbdd..80c82873f2b 100644 --- a/compiler/testData/diagnostics/tests/inference/constraints/kt7433.txt +++ b/compiler/testData/diagnostics/tests/inference/constraints/kt7433.txt @@ -1,4 +1,4 @@ package public fun test(/*0*/ ints: kotlin.List): kotlin.Unit -@kotlin.inline() public fun kotlin.Iterable.reduce1(/*0*/ operation: (S, T) -> S): S +public inline fun kotlin.Iterable.reduce1(/*0*/ operation: (S, T) -> S): S diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2841.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt2841.txt index 431ca7e55e3..e3ff01ae554 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2841.txt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2841.txt @@ -2,7 +2,7 @@ package package a { public fun main(/*0*/ args: kotlin.Array): kotlin.Unit - @kotlin.inline() public fun T.use1(/*0*/ block: (T) -> R): R + public inline fun T.use1(/*0*/ block: (T) -> R): R public final class C : a.Closeable { public constructor C() diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.txt index 38a77b78344..ec1191fc512 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.txt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2841_it.txt @@ -2,7 +2,7 @@ package package a { public fun test(): kotlin.Unit - @kotlin.inline() public fun T.use(/*0*/ block: (T) -> R): R + public inline fun T.use(/*0*/ block: (T) -> R): R public final class C : a.Closeable { public constructor C() diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.txt index 846422ee6c9..b71694cd965 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.txt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2841_it_this.txt @@ -2,7 +2,7 @@ package package a { public fun test(): kotlin.Unit - @kotlin.inline() public fun use(/*0*/ t: T, /*1*/ block: T.(T) -> R): R + public inline fun use(/*0*/ t: T, /*1*/ block: T.(T) -> R): R public final class C : a.Closeable { public constructor C() diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.txt index e3edb2a0ab6..fd662723186 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.txt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt2841_this.txt @@ -2,7 +2,7 @@ package package a { public fun test(): kotlin.Unit - @kotlin.inline() public fun T.use(/*0*/ block: T.() -> R): R + public inline fun T.use(/*0*/ block: T.() -> R): R public final class C : a.Closeable { public constructor C() diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt3559.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt3559.txt index 4c0e8992ec1..e46fe7cfbe7 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt3559.txt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt3559.txt @@ -1,4 +1,4 @@ package -@kotlin.inline() public fun let(/*0*/ subj: T?, /*1*/ body: (T) -> R): R? +public inline fun let(/*0*/ subj: T?, /*1*/ body: (T) -> R): R? public fun test(/*0*/ s: kotlin.String?): kotlin.String? diff --git a/compiler/testData/diagnostics/tests/inference/regressions/kt943.txt b/compiler/testData/diagnostics/tests/inference/regressions/kt943.txt index 5630bf79177..cd189ee7a28 100644 --- a/compiler/testData/diagnostics/tests/inference/regressions/kt943.txt +++ b/compiler/testData/diagnostics/tests/inference/regressions/kt943.txt @@ -1,7 +1,7 @@ package package maze { - @kotlin.inline() public fun comparator(/*0*/ fn: (T, T) -> kotlin.Int): java.util.Comparator + public inline fun comparator(/*0*/ fn: (T, T) -> kotlin.Int): java.util.Comparator public fun foo(/*0*/ lines: kotlin.List): kotlin.Unit public fun T?.sure(): T } diff --git a/compiler/testData/diagnostics/tests/inference/upperBounds/kt2856.txt b/compiler/testData/diagnostics/tests/inference/upperBounds/kt2856.txt index fdf8278c678..799e7111621 100644 --- a/compiler/testData/diagnostics/tests/inference/upperBounds/kt2856.txt +++ b/compiler/testData/diagnostics/tests/inference/upperBounds/kt2856.txt @@ -3,5 +3,5 @@ package package d { public fun main(/*0*/ args: kotlin.Array): kotlin.Unit public fun println(/*0*/ message: kotlin.Any?): kotlin.Unit - @kotlin.inline() public fun kotlin.Map.getOrElse1(/*0*/ key: K, /*1*/ defaultValue: () -> V1): V1 + public inline fun kotlin.Map.getOrElse1(/*0*/ key: K, /*1*/ defaultValue: () -> V1): V1 } diff --git a/compiler/testData/diagnostics/tests/inline/anonymousObjects.txt b/compiler/testData/diagnostics/tests/inline/anonymousObjects.txt index 20a99b39c8f..e1e15f407cb 100644 --- a/compiler/testData/diagnostics/tests/inline/anonymousObjects.txt +++ b/compiler/testData/diagnostics/tests/inline/anonymousObjects.txt @@ -1,3 +1,3 @@ package -@kotlin.inline() public fun inlineFun(/*0*/ p: () -> R): kotlin.Unit +public inline fun inlineFun(/*0*/ p: () -> R): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/assignment.txt b/compiler/testData/diagnostics/tests/inline/assignment.txt index 04b4f86e39e..d476368d9e2 100644 --- a/compiler/testData/diagnostics/tests/inline/assignment.txt +++ b/compiler/testData/diagnostics/tests/inline/assignment.txt @@ -1,4 +1,4 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/binaryExpressions/andOr.txt b/compiler/testData/diagnostics/tests/inline/binaryExpressions/andOr.txt index 21a90ca915b..d69a9b5d05b 100644 --- a/compiler/testData/diagnostics/tests/inline/binaryExpressions/andOr.txt +++ b/compiler/testData/diagnostics/tests/inline/binaryExpressions/andOr.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvokeNonInline(/*0*/ @kotlin.noinline() s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWithInvokeNonInline(/*0*/ noinline s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/binaryExpressions/arrayAccess.txt b/compiler/testData/diagnostics/tests/inline/binaryExpressions/arrayAccess.txt index 2635017aff3..3d7fc398cb8 100644 --- a/compiler/testData/diagnostics/tests/inline/binaryExpressions/arrayAccess.txt +++ b/compiler/testData/diagnostics/tests/inline/binaryExpressions/arrayAccess.txt @@ -1,7 +1,7 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T) -> U): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T, U) -> V, /*1*/ ext: T.(U, V) -> W): kotlin.Unit -@kotlin.inline() public operator fun ((T) -> U).get(/*0*/ index: kotlin.Int): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (T) -> U): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (T, U) -> V, /*1*/ ext: T.(U, V) -> W): kotlin.Unit +public operator inline fun ((T) -> U).get(/*0*/ index: kotlin.Int): kotlin.Unit public operator fun ((T, U) -> V).get(/*0*/ index: kotlin.Int): kotlin.Unit public operator fun (T.(U, V) -> W).get(/*0*/ index: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/binaryExpressions/assignment.txt b/compiler/testData/diagnostics/tests/inline/binaryExpressions/assignment.txt index 47530660624..77edfb625a9 100644 --- a/compiler/testData/diagnostics/tests/inline/binaryExpressions/assignment.txt +++ b/compiler/testData/diagnostics/tests/inline/binaryExpressions/assignment.txt @@ -1,9 +1,9 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T) -> U, /*1*/ ext: T.(U) -> V): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (T) -> U, /*1*/ ext: T.(U) -> V): kotlin.Unit public operator fun ((T) -> U).minusAssign(/*0*/ p: (T) -> U): kotlin.Unit public operator fun (T.(U) -> V).minusAssign(/*0*/ ext: T.(U) -> V): kotlin.Unit -@kotlin.inline() public operator fun ((T) -> U).modAssign(/*0*/ p: (T) -> U): () -> kotlin.Unit -@kotlin.inline() public operator fun (T.(U) -> V).modAssign(/*0*/ ext: T.(U) -> V): () -> kotlin.Unit -@kotlin.inline() public operator fun ((T) -> U).plusAssign(/*0*/ p: (T) -> U): kotlin.Unit -@kotlin.inline() public operator fun (T.(U) -> V).plusAssign(/*0*/ ext: T.(U) -> V): kotlin.Unit +public operator inline fun ((T) -> U).modAssign(/*0*/ p: (T) -> U): () -> kotlin.Unit +public operator inline fun (T.(U) -> V).modAssign(/*0*/ ext: T.(U) -> V): () -> kotlin.Unit +public operator inline fun ((T) -> U).plusAssign(/*0*/ p: (T) -> U): kotlin.Unit +public operator inline fun (T.(U) -> V).plusAssign(/*0*/ ext: T.(U) -> V): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/binaryExpressions/comparison.txt b/compiler/testData/diagnostics/tests/inline/binaryExpressions/comparison.txt index b8d73790960..944f5a13ef1 100644 --- a/compiler/testData/diagnostics/tests/inline/binaryExpressions/comparison.txt +++ b/compiler/testData/diagnostics/tests/inline/binaryExpressions/comparison.txt @@ -1,7 +1,7 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T) -> U): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T, U) -> V, /*1*/ ext: T.(U, V) -> W): kotlin.Unit -@kotlin.inline() public operator fun ((T) -> U).compareTo(/*0*/ p: (T) -> U): kotlin.Int +public inline fun inlineFunWithInvoke(/*0*/ s: (T) -> U): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (T, U) -> V, /*1*/ ext: T.(U, V) -> W): kotlin.Unit +public operator inline fun ((T) -> U).compareTo(/*0*/ p: (T) -> U): kotlin.Int public operator fun ((T, U) -> V).compareTo(/*0*/ index: (T, U) -> V): kotlin.Int public operator fun (T.(U, V) -> W).compareTo(/*0*/ index: T.(U, V) -> W): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/inline/binaryExpressions/componentAccess.txt b/compiler/testData/diagnostics/tests/inline/binaryExpressions/componentAccess.txt index 32deec85031..421418e976e 100644 --- a/compiler/testData/diagnostics/tests/inline/binaryExpressions/componentAccess.txt +++ b/compiler/testData/diagnostics/tests/inline/binaryExpressions/componentAccess.txt @@ -1,10 +1,10 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T) -> U): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T, U) -> V, /*1*/ ext: T.(U, V) -> W): kotlin.Unit -@kotlin.inline() public operator fun ((T) -> U).component1(): kotlin.Int +public inline fun inlineFunWithInvoke(/*0*/ s: (T) -> U): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (T, U) -> V, /*1*/ ext: T.(U, V) -> W): kotlin.Unit +public operator inline fun ((T) -> U).component1(): kotlin.Int public operator fun ((T, U) -> V).component1(): kotlin.Int public operator fun (T.(U, V) -> W).component1(): kotlin.Int -@kotlin.inline() public operator fun ((T) -> U).component2(): kotlin.Int +public operator inline fun ((T) -> U).component2(): kotlin.Int public operator fun ((T, U) -> V).component2(): kotlin.Int public operator fun (T.(U, V) -> W).component2(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/inline/binaryExpressions/contains.txt b/compiler/testData/diagnostics/tests/inline/binaryExpressions/contains.txt index 17542f73c28..7b9ef4de2a2 100644 --- a/compiler/testData/diagnostics/tests/inline/binaryExpressions/contains.txt +++ b/compiler/testData/diagnostics/tests/inline/binaryExpressions/contains.txt @@ -1,7 +1,7 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T) -> U): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T, U) -> U, /*1*/ ext: T.(U, U) -> V): kotlin.Unit -@kotlin.inline() public operator fun ((T) -> U).contains(/*0*/ p: (T) -> U): kotlin.Boolean +public inline fun inlineFunWithInvoke(/*0*/ s: (T) -> U): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (T, U) -> U, /*1*/ ext: T.(U, U) -> V): kotlin.Unit +public operator inline fun ((T) -> U).contains(/*0*/ p: (T) -> U): kotlin.Boolean public operator fun ((T, U) -> V).contains(/*0*/ p: (T, U) -> V): kotlin.Boolean public operator fun (T.(U, V) -> W).contains(/*0*/ ext: T.(U, V) -> W): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.txt b/compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.txt index 949c57f87ea..fcc58eaf1ff 100644 --- a/compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.txt +++ b/compiler/testData/diagnostics/tests/inline/binaryExpressions/mathOperations.txt @@ -1,10 +1,10 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T) -> U, /*1*/ ext: T.(U) -> V): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T) -> U, /*1*/ ext: T.(U) -> V): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (T) -> U, /*1*/ ext: T.(U) -> V): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (T) -> U, /*1*/ ext: T.(U) -> V): kotlin.Unit public operator fun ((T) -> U).minus(/*0*/ p: (T) -> U): kotlin.Unit public operator fun (T.(U) -> V).minus(/*0*/ p: T.(U) -> V): kotlin.Unit -@kotlin.inline() public operator fun ((T) -> U).plus(/*0*/ p: (T) -> U): kotlin.Unit -@kotlin.inline() public operator fun (T.(U) -> V).plus(/*0*/ p: T.(U) -> V): kotlin.Unit -@kotlin.inline() public fun ((T) -> U).submit(): kotlin.Unit -@kotlin.inline() public fun (T.(U) -> V).submit(): kotlin.Unit +public operator inline fun ((T) -> U).plus(/*0*/ p: (T) -> U): kotlin.Unit +public operator inline fun (T.(U) -> V).plus(/*0*/ p: T.(U) -> V): kotlin.Unit +public inline fun ((T) -> U).submit(): kotlin.Unit +public inline fun (T.(U) -> V).submit(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/binaryExpressions/rangeTo.txt b/compiler/testData/diagnostics/tests/inline/binaryExpressions/rangeTo.txt index a06249c1542..00101b4ec31 100644 --- a/compiler/testData/diagnostics/tests/inline/binaryExpressions/rangeTo.txt +++ b/compiler/testData/diagnostics/tests/inline/binaryExpressions/rangeTo.txt @@ -1,7 +1,7 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T) -> U): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T, U) -> U, /*1*/ ext: T.(U, U) -> V): kotlin.Unit -@kotlin.inline() public operator fun ((T) -> U).rangeTo(/*0*/ p: (T) -> U): kotlin.Range +public inline fun inlineFunWithInvoke(/*0*/ s: (T) -> U): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (T, U) -> U, /*1*/ ext: T.(U, U) -> V): kotlin.Unit +public operator inline fun ((T) -> U).rangeTo(/*0*/ p: (T) -> U): kotlin.Range public operator fun ((T, U) -> V).rangeTo(/*0*/ p: (T, U) -> V): kotlin.Range public operator fun (T.(U, V) -> W).rangeTo(/*0*/ ext: T.(U, V) -> W): kotlin.Range diff --git a/compiler/testData/diagnostics/tests/inline/capture.txt b/compiler/testData/diagnostics/tests/inline/capture.txt index ba276daa0ab..e432f1c90d3 100644 --- a/compiler/testData/diagnostics/tests/inline/capture.txt +++ b/compiler/testData/diagnostics/tests/inline/capture.txt @@ -1,9 +1,9 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvokeNonInline(/*0*/ @kotlin.noinline() s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWrongExtension(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun testExtension(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit -@kotlin.inline() public infix fun ((kotlin.Int) -> kotlin.Unit).inlineExt2(/*0*/ p: kotlin.Int): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWithInvokeNonInline(/*0*/ noinline s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWrongExtension(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun testExtension(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit +public infix inline fun ((kotlin.Int) -> kotlin.Unit).inlineExt2(/*0*/ p: kotlin.Int): kotlin.Unit public infix fun ((kotlin.Int) -> kotlin.Unit).noInlineExt(/*0*/ p: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/constructor.txt b/compiler/testData/diagnostics/tests/inline/constructor.txt index 56a8b02f38d..f119440a79f 100644 --- a/compiler/testData/diagnostics/tests/inline/constructor.txt +++ b/compiler/testData/diagnostics/tests/inline/constructor.txt @@ -1,6 +1,6 @@ package -@kotlin.inline() public fun test(/*0*/ s: (kotlin.Int) -> kotlin.Int): kotlin.Unit +public inline fun test(/*0*/ s: (kotlin.Int) -> kotlin.Int): kotlin.Unit public final class Z { public constructor Z(/*0*/ s: (kotlin.Int) -> kotlin.Int) diff --git a/compiler/testData/diagnostics/tests/inline/default.txt b/compiler/testData/diagnostics/tests/inline/default.txt index 2534f53a5a1..8ff51876af0 100644 --- a/compiler/testData/diagnostics/tests/inline/default.txt +++ b/compiler/testData/diagnostics/tests/inline/default.txt @@ -1,13 +1,13 @@ package -@kotlin.inline() public fun default(/*0*/ s: kotlin.Int = ...): kotlin.Unit -@kotlin.inline() public fun default2(/*0*/ p: kotlin.Int, /*1*/ s: kotlin.String = ...): kotlin.Unit +public inline fun default(/*0*/ s: kotlin.Int = ...): kotlin.Unit +public inline fun default2(/*0*/ p: kotlin.Int, /*1*/ s: kotlin.String = ...): kotlin.Unit public open class Base { public constructor Base() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.inline() public final fun foo(/*0*/ a: kotlin.Int = ...): kotlin.Unit - @kotlin.inline() public final fun foo2(/*0*/ a: kotlin.Int = ..., /*1*/ s: kotlin.String = ...): kotlin.Unit + public final inline fun foo(/*0*/ a: kotlin.Int = ...): kotlin.Unit + public final inline fun foo2(/*0*/ a: kotlin.Int = ..., /*1*/ s: kotlin.String = ...): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/tests/inline/extensionOnFunction.txt b/compiler/testData/diagnostics/tests/inline/extensionOnFunction.txt index 9c6b966fc01..36ccbc58a07 100644 --- a/compiler/testData/diagnostics/tests/inline/extensionOnFunction.txt +++ b/compiler/testData/diagnostics/tests/inline/extensionOnFunction.txt @@ -1,8 +1,8 @@ package -@kotlin.inline() public fun inlineFunNoInline(/*0*/ @kotlin.noinline() s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWrongExtension(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun testExtension(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit -@kotlin.inline() public infix fun ((kotlin.Int) -> kotlin.Unit).inlineExt2(/*0*/ p: kotlin.Int): kotlin.Unit +public inline fun inlineFunNoInline(/*0*/ noinline s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWrongExtension(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun testExtension(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit +public infix inline fun ((kotlin.Int) -> kotlin.Unit).inlineExt2(/*0*/ p: kotlin.Int): kotlin.Unit public infix fun ((kotlin.Int) -> kotlin.Unit).noInlineExt(/*0*/ p: kotlin.Int): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/fromInlineToNoInline.txt b/compiler/testData/diagnostics/tests/inline/fromInlineToNoInline.txt index dd9459c30fb..63c8c3743ab 100644 --- a/compiler/testData/diagnostics/tests/inline/fromInlineToNoInline.txt +++ b/compiler/testData/diagnostics/tests/inline/fromInlineToNoInline.txt @@ -1,4 +1,4 @@ package -@kotlin.inline() public fun inlineAll(/*0*/ @kotlin.noinline() p: () -> R): kotlin.Unit -@kotlin.inline() public fun onlyLocal(/*0*/ p: () -> R): kotlin.Unit +public inline fun inlineAll(/*0*/ noinline p: () -> R): kotlin.Unit +public inline fun onlyLocal(/*0*/ p: () -> R): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/functions.txt b/compiler/testData/diagnostics/tests/inline/functions.txt index 7c58fd35742..024179ccfab 100644 --- a/compiler/testData/diagnostics/tests/inline/functions.txt +++ b/compiler/testData/diagnostics/tests/inline/functions.txt @@ -1,5 +1,5 @@ package public fun getFun(/*0*/ s: (kotlin.Int) -> kotlin.Unit): (kotlin.Int) -> kotlin.Int -@kotlin.inline() public fun getInlineFun(/*0*/ s: (kotlin.Int) -> kotlin.Unit): (kotlin.Int) -> kotlin.Int -@kotlin.inline() public fun testExtension(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun getInlineFun(/*0*/ s: (kotlin.Int) -> kotlin.Unit): (kotlin.Int) -> kotlin.Int +public inline fun testExtension(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/inlineReified.txt b/compiler/testData/diagnostics/tests/inline/inlineReified.txt index 52c6cc776bd..5c159b898ee 100644 --- a/compiler/testData/diagnostics/tests/inline/inlineReified.txt +++ b/compiler/testData/diagnostics/tests/inline/inlineReified.txt @@ -1,3 +1,3 @@ package -@kotlin.inline() public fun foo(): T3 +public inline fun foo(): T3 diff --git a/compiler/testData/diagnostics/tests/inline/invoke.txt b/compiler/testData/diagnostics/tests/inline/invoke.txt index 21a90ca915b..d69a9b5d05b 100644 --- a/compiler/testData/diagnostics/tests/inline/invoke.txt +++ b/compiler/testData/diagnostics/tests/inline/invoke.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvokeNonInline(/*0*/ @kotlin.noinline() s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWithInvokeNonInline(/*0*/ noinline s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/kt4869.txt b/compiler/testData/diagnostics/tests/inline/kt4869.txt index 057a8815c3e..b41e75bbd7a 100644 --- a/compiler/testData/diagnostics/tests/inline/kt4869.txt +++ b/compiler/testData/diagnostics/tests/inline/kt4869.txt @@ -1,3 +1,3 @@ package -@kotlin.inline() public fun foo(/*0*/ f: () -> kotlin.Unit): kotlin.Unit +public inline fun foo(/*0*/ f: () -> kotlin.Unit): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/labeled.txt b/compiler/testData/diagnostics/tests/inline/labeled.txt index 781f8b69943..8e2c3c4e826 100644 --- a/compiler/testData/diagnostics/tests/inline/labeled.txt +++ b/compiler/testData/diagnostics/tests/inline/labeled.txt @@ -1,4 +1,4 @@ package -@kotlin.inline() public fun foo(/*0*/ bar1: (kotlin.String.() -> kotlin.Int) -> kotlin.Int, /*1*/ bar2: (() -> kotlin.Int) -> kotlin.Int): kotlin.Unit -@kotlin.inline() public fun foo2(/*0*/ bar1: (kotlin.String.() -> kotlin.Int) -> kotlin.Int): kotlin.Unit +public inline fun foo(/*0*/ bar1: (kotlin.String.() -> kotlin.Int) -> kotlin.Int, /*1*/ bar2: (() -> kotlin.Int) -> kotlin.Int): kotlin.Unit +public inline fun foo2(/*0*/ bar1: (kotlin.String.() -> kotlin.Int) -> kotlin.Int): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjects.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjects.txt index 888a8728a60..7d6e2e076ed 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjects.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjects.txt @@ -1,4 +1,4 @@ package -@kotlin.inline() public fun inlineFun(/*0*/ p: () -> R): kotlin.Unit -@kotlin.inline() public fun inlineFunOnlyLocal(/*0*/ @kotlin.crossinline() p: () -> R): kotlin.Unit +public inline fun inlineFun(/*0*/ p: () -> R): kotlin.Unit +public inline fun inlineFunOnlyLocal(/*0*/ crossinline p: () -> R): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjectsNested.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjectsNested.txt index a7342e25ea5..f3e04d1e181 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjectsNested.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/anonymousObjectsNested.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun doCall(/*0*/ p: () -> R): kotlin.Unit -@kotlin.inline() public fun inlineFun(/*0*/ p: () -> R): kotlin.Unit -@kotlin.inline() public fun inlineFunOnlyLocal(/*0*/ @kotlin.crossinline() p: () -> R): kotlin.Unit +public inline fun doCall(/*0*/ p: () -> R): kotlin.Unit +public inline fun inlineFun(/*0*/ p: () -> R): kotlin.Unit +public inline fun inlineFunOnlyLocal(/*0*/ crossinline p: () -> R): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/explicitReturnType.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/explicitReturnType.txt index 0f89a031f17..e7caf587926 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/explicitReturnType.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/explicitReturnType.txt @@ -2,6 +2,6 @@ package public fun inlineCall(): kotlin.String public fun inlineCallExplicitError(): kotlin.String -@kotlin.inline() public fun inlineFun(/*0*/ s: () -> kotlin.Int): kotlin.Unit +public inline fun inlineFun(/*0*/ s: () -> kotlin.Int): kotlin.Unit public fun noInline(/*0*/ s: () -> kotlin.Int): kotlin.Unit public fun noInlineCall(): kotlin.String diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/fromOnlyLocal.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/fromOnlyLocal.txt index 96ceb5b9a3c..17967fd49e0 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/fromOnlyLocal.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/fromOnlyLocal.txt @@ -1,4 +1,4 @@ package -@kotlin.inline() public fun inlineAll(/*0*/ p: () -> R): kotlin.Unit -@kotlin.inline() public fun onlyLocal(/*0*/ @kotlin.crossinline() p: () -> R): kotlin.Unit +public inline fun inlineAll(/*0*/ p: () -> R): kotlin.Unit +public inline fun onlyLocal(/*0*/ crossinline p: () -> R): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/inlineLambda.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/inlineLambda.txt index ca8ed285cd9..36dd2c9a45e 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/inlineLambda.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/inlineLambda.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun inlineFun(/*0*/ p: () -> R): kotlin.Unit -@kotlin.inline() public fun inlineFun2(/*0*/ p: () -> R): kotlin.Unit -@kotlin.inline() public fun inlineFunWithAnnotation(/*0*/ @kotlin.crossinline() p: () -> R): kotlin.Unit +public inline fun inlineFun(/*0*/ p: () -> R): kotlin.Unit +public inline fun inlineFun2(/*0*/ p: () -> R): kotlin.Unit +public inline fun inlineFunWithAnnotation(/*0*/ crossinline p: () -> R): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/labeledReturn.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/labeledReturn.txt index 3cd84a14317..ee14e80dc9c 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/labeledReturn.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/labeledReturn.txt @@ -1,6 +1,6 @@ package public fun inlineCall(): kotlin.String -@kotlin.inline() public fun inlineFun(/*0*/ s: () -> kotlin.Int): kotlin.Unit +public inline fun inlineFun(/*0*/ s: () -> kotlin.Int): kotlin.Unit public fun noInline(/*0*/ s: () -> kotlin.Int): kotlin.Unit public fun noInlineCall(): kotlin.String diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.txt index d096768127a..46c81f8cd1e 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsGeneric.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.inline() public fun test(/*0*/ p: T): kotlin.Unit +public inline fun test(/*0*/ p: T): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsNonFunction.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsNonFunction.txt index 7ad202381cb..39630942f75 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsNonFunction.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaAsNonFunction.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.String -@kotlin.inline() public fun test(/*0*/ p: kotlin.Any): kotlin.Unit +public inline fun test(/*0*/ p: kotlin.Any): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaWithGlobalReturnsInsideOnlyLocalOne.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaWithGlobalReturnsInsideOnlyLocalOne.txt index 9b0c1bba760..b6ad4601e07 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaWithGlobalReturnsInsideOnlyLocalOne.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/lambdaWithGlobalReturnsInsideOnlyLocalOne.txt @@ -1,4 +1,4 @@ package -@kotlin.inline() public fun doWork(/*0*/ @kotlin.crossinline() job: () -> R): R -@kotlin.inline() public fun testSameCaptured(/*0*/ lambdaWithResultCaptured: () -> kotlin.Unit): kotlin.String +public inline fun doWork(/*0*/ crossinline job: () -> R): R +public inline fun testSameCaptured(/*0*/ lambdaWithResultCaptured: () -> kotlin.Unit): kotlin.String diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/localFun.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/localFun.txt index 888a8728a60..7d6e2e076ed 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/localFun.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/localFun.txt @@ -1,4 +1,4 @@ package -@kotlin.inline() public fun inlineFun(/*0*/ p: () -> R): kotlin.Unit -@kotlin.inline() public fun inlineFunOnlyLocal(/*0*/ @kotlin.crossinline() p: () -> R): kotlin.Unit +public inline fun inlineFun(/*0*/ p: () -> R): kotlin.Unit +public inline fun inlineFunOnlyLocal(/*0*/ crossinline p: () -> R): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/nestedNonLocals.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/nestedNonLocals.txt index 498ed6217f8..093c479c0a1 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/nestedNonLocals.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/nestedNonLocals.txt @@ -1,6 +1,6 @@ package -@kotlin.inline() public fun doCall(/*0*/ block: () -> R): R +public inline fun doCall(/*0*/ block: () -> R): R public fun test1(/*0*/ intKind: Kind, /*1*/ extKind: Kind): Global public final class External { diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineAnnotation.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineAnnotation.txt index 6440b7c51d9..a7ceea7051f 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineAnnotation.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineAnnotation.txt @@ -1,4 +1,4 @@ package public fun main(/*0*/ args: kotlin.Array): kotlin.Unit -@kotlin.inline() public fun test(/*0*/ @kotlin.noinline() lambda: () -> kotlin.Unit): kotlin.Unit +public inline fun test(/*0*/ noinline lambda: () -> kotlin.Unit): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineLambda.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineLambda.txt index 888a8728a60..7d6e2e076ed 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineLambda.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/noInlineLambda.txt @@ -1,4 +1,4 @@ package -@kotlin.inline() public fun inlineFun(/*0*/ p: () -> R): kotlin.Unit -@kotlin.inline() public fun inlineFunOnlyLocal(/*0*/ @kotlin.crossinline() p: () -> R): kotlin.Unit +public inline fun inlineFun(/*0*/ p: () -> R): kotlin.Unit +public inline fun inlineFunOnlyLocal(/*0*/ crossinline p: () -> R): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/nonInlinedClass.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/nonInlinedClass.txt index 888a8728a60..7d6e2e076ed 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/nonInlinedClass.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/nonInlinedClass.txt @@ -1,4 +1,4 @@ package -@kotlin.inline() public fun inlineFun(/*0*/ p: () -> R): kotlin.Unit -@kotlin.inline() public fun inlineFunOnlyLocal(/*0*/ @kotlin.crossinline() p: () -> R): kotlin.Unit +public inline fun inlineFun(/*0*/ p: () -> R): kotlin.Unit +public inline fun inlineFunOnlyLocal(/*0*/ crossinline p: () -> R): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambda.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambda.txt index 539a12d683d..68804c0c618 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambda.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambda.txt @@ -6,4 +6,4 @@ public fun fun3(/*0*/ p: () -> R): kotlin.Unit public fun fun3ValueArgument(/*0*/ p: () -> R): kotlin.Unit public fun fun4(/*0*/ p: () -> R): kotlin.Unit public fun fun4ValueArgument(/*0*/ p: () -> R): kotlin.Unit -@kotlin.inline() public fun inlineFun(/*0*/ @kotlin.crossinline() p: () -> R): kotlin.Unit +public inline fun inlineFun(/*0*/ crossinline p: () -> R): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambdaBinaryExpr.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambdaBinaryExpr.txt index 4063f350520..9c9b9bdf966 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambdaBinaryExpr.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/onlyLocalReturnLambdaBinaryExpr.txt @@ -8,6 +8,6 @@ public final class Z { public constructor Z() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - @kotlin.inline() public final infix fun inlineFun(/*0*/ @kotlin.crossinline() p: () -> R): kotlin.Unit + public final infix inline fun inlineFun(/*0*/ crossinline p: () -> R): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/propertyAccessorsAndConstructor.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/propertyAccessorsAndConstructor.txt index 25b104b2926..128bbf9d9d0 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/propertyAccessorsAndConstructor.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/propertyAccessorsAndConstructor.txt @@ -1,7 +1,7 @@ package -@kotlin.inline() public fun doCall(/*0*/ p: () -> R): kotlin.Unit -@kotlin.inline() public fun doCallInt(/*0*/ p: () -> R): R +public inline fun doCall(/*0*/ p: () -> R): kotlin.Unit +public inline fun doCallInt(/*0*/ p: () -> R): R public final class A { public constructor A() diff --git a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/toOnlyLocal.txt b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/toOnlyLocal.txt index 9959ad1cc99..085c6a01486 100644 --- a/compiler/testData/diagnostics/tests/inline/nonLocalReturns/toOnlyLocal.txt +++ b/compiler/testData/diagnostics/tests/inline/nonLocalReturns/toOnlyLocal.txt @@ -1,4 +1,4 @@ package -@kotlin.inline() public fun inlineAll(/*0*/ p: () -> R): kotlin.Unit -@kotlin.inline() public fun toOnlyLocal(/*0*/ @kotlin.crossinline() p: () -> R): kotlin.Unit +public inline fun inlineAll(/*0*/ p: () -> R): kotlin.Unit +public inline fun toOnlyLocal(/*0*/ crossinline p: () -> R): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicClass.txt b/compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicClass.txt index 80760e2cfe6..eaac64270c2 100644 --- a/compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicClass.txt +++ b/compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicClass.txt @@ -1,7 +1,7 @@ package -@kotlin.inline() public fun test(): kotlin.Unit -@kotlin.inline() internal fun testInternal(): kotlin.Unit +public inline fun test(): kotlin.Unit +internal inline fun testInternal(): kotlin.Unit private final class Z { public constructor Z() @@ -20,7 +20,7 @@ private final class Z2 { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int private final fun privateFun(): kotlin.Unit public final fun publicFun(): kotlin.Unit - @kotlin.inline() public final fun test(): kotlin.Unit - @kotlin.inline() public final fun testInternal(): kotlin.Unit + public final inline fun test(): kotlin.Unit + public final inline fun testInternal(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicInnerClass.txt b/compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicInnerClass.txt index 2e93d22fa39..01f69f89e9c 100644 --- a/compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicInnerClass.txt +++ b/compiler/testData/diagnostics/tests/inline/nonPublicMember/inNonPublicInnerClass.txt @@ -14,8 +14,8 @@ private final class Z2 { public constructor ZInner() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int - @kotlin.inline() public final fun test(): kotlin.Unit - @kotlin.inline() public final fun testInternal(): kotlin.Unit + public final inline fun test(): kotlin.Unit + public final inline fun testInternal(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } } diff --git a/compiler/testData/diagnostics/tests/inline/nonPublicMember/inPackage.txt b/compiler/testData/diagnostics/tests/inline/nonPublicMember/inPackage.txt index d6d77fb9213..f19ce0593c5 100644 --- a/compiler/testData/diagnostics/tests/inline/nonPublicMember/inPackage.txt +++ b/compiler/testData/diagnostics/tests/inline/nonPublicMember/inPackage.txt @@ -4,7 +4,7 @@ internal val internalProperty: kotlin.Int = 11 private val privateProperty: kotlin.Int = 11 internal fun internalFun(): kotlin.Unit private fun privateFun(): kotlin.Unit -@kotlin.inline() public fun test(): kotlin.Unit -@kotlin.inline() public fun test2(): kotlin.Unit -@kotlin.inline() internal fun test2Internal(): kotlin.Unit -@kotlin.inline() internal fun testInternal(): kotlin.Unit +public inline fun test(): kotlin.Unit +public inline fun test2(): kotlin.Unit +internal inline fun test2Internal(): kotlin.Unit +internal inline fun testInternal(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nonPublicMember/inPublicClass.txt b/compiler/testData/diagnostics/tests/inline/nonPublicMember/inPublicClass.txt index c38be979de6..089d9f8ae1a 100644 --- a/compiler/testData/diagnostics/tests/inline/nonPublicMember/inPublicClass.txt +++ b/compiler/testData/diagnostics/tests/inline/nonPublicMember/inPublicClass.txt @@ -1,7 +1,7 @@ package -@kotlin.inline() public fun test(): kotlin.Unit -@kotlin.inline() internal fun testInternal(): kotlin.Unit +public inline fun test(): kotlin.Unit +internal inline fun testInternal(): kotlin.Unit public final class Z { public constructor Z() @@ -18,7 +18,7 @@ public final class Z2 { public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int private final fun privateFun(): kotlin.Unit - @kotlin.inline() public final fun test(): kotlin.Unit - @kotlin.inline() internal final fun testInternal(): kotlin.Unit + public final inline fun test(): kotlin.Unit + internal final inline fun testInternal(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/tests/inline/nonVirtualMembersWithInline.txt b/compiler/testData/diagnostics/tests/inline/nonVirtualMembersWithInline.txt index fddeb1f61b5..f05a0f82844 100644 --- a/compiler/testData/diagnostics/tests/inline/nonVirtualMembersWithInline.txt +++ b/compiler/testData/diagnostics/tests/inline/nonVirtualMembersWithInline.txt @@ -1,36 +1,36 @@ package -@kotlin.inline() private fun a(): kotlin.Unit -@kotlin.inline() public fun b(): kotlin.Unit -@kotlin.inline() public fun c(): kotlin.Unit +private inline fun a(): kotlin.Unit +public inline fun b(): kotlin.Unit +public inline fun c(): kotlin.Unit public abstract class A { public constructor A() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.inline() private final fun good1(): kotlin.Unit - @kotlin.inline() public final fun good2(): kotlin.Unit - @kotlin.inline() protected final fun good3(): kotlin.Unit - @kotlin.inline() public final fun good4(): kotlin.Unit + private final inline fun good1(): kotlin.Unit + public final inline fun good2(): kotlin.Unit + protected final inline fun good3(): kotlin.Unit + public final inline fun good4(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - @kotlin.inline() protected open fun wrong1(): kotlin.Unit - @kotlin.inline() public open fun wrong2(): kotlin.Unit - @kotlin.inline() public open fun wrong3(): kotlin.Unit - @kotlin.inline() protected abstract fun wrong4(): kotlin.Unit - @kotlin.inline() public abstract fun wrong5(): kotlin.Unit - @kotlin.inline() public abstract fun wrong6(): kotlin.Unit + protected open inline fun wrong1(): kotlin.Unit + public open inline fun wrong2(): kotlin.Unit + public open inline fun wrong3(): kotlin.Unit + protected abstract inline fun wrong4(): kotlin.Unit + public abstract inline fun wrong5(): kotlin.Unit + public abstract inline fun wrong6(): kotlin.Unit } public interface B { public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.inline() private final fun good1(): kotlin.Unit + private final inline fun good1(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - @kotlin.inline() public open fun wrong1(): kotlin.Unit - @kotlin.inline() public open fun wrong2(): kotlin.Unit - @kotlin.inline() public open fun wrong3(): kotlin.Unit - @kotlin.inline() public open fun wrong4(): kotlin.Unit - @kotlin.inline() public abstract fun wrong5(): kotlin.Unit - @kotlin.inline() public abstract fun wrong6(): kotlin.Unit - @kotlin.inline() public abstract fun wrong7(): kotlin.Unit + public open inline fun wrong1(): kotlin.Unit + public open inline fun wrong2(): kotlin.Unit + public open inline fun wrong3(): kotlin.Unit + public open inline fun wrong4(): kotlin.Unit + public abstract inline fun wrong5(): kotlin.Unit + public abstract inline fun wrong6(): kotlin.Unit + public abstract inline fun wrong7(): kotlin.Unit } diff --git a/compiler/testData/diagnostics/tests/inline/nothingToInline.txt b/compiler/testData/diagnostics/tests/inline/nothingToInline.txt index c71117d4889..4d884a83c12 100644 --- a/compiler/testData/diagnostics/tests/inline/nothingToInline.txt +++ b/compiler/testData/diagnostics/tests/inline/nothingToInline.txt @@ -1,9 +1,9 @@ package -@kotlin.inline() public fun test(): kotlin.Unit -@kotlin.inline() public fun test2(/*0*/ s: ((kotlin.Int) -> kotlin.Int)?): kotlin.Unit -@kotlin.inline() public fun test2(/*0*/ s: (kotlin.Int) -> kotlin.Int): kotlin.Unit -@kotlin.inline() public fun test3(/*0*/ @kotlin.noinline() s: (kotlin.Int) -> kotlin.Int): kotlin.Unit -@kotlin.inline() public fun test4(/*0*/ @kotlin.noinline() s: kotlin.Int.() -> kotlin.Int): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Int)?.test5(): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Int)?.test6(): kotlin.Unit +public inline fun test(): kotlin.Unit +public inline fun test2(/*0*/ s: ((kotlin.Int) -> kotlin.Int)?): kotlin.Unit +public inline fun test2(/*0*/ s: (kotlin.Int) -> kotlin.Int): kotlin.Unit +public inline fun test3(/*0*/ noinline s: (kotlin.Int) -> kotlin.Int): kotlin.Unit +public inline fun test4(/*0*/ noinline s: kotlin.Int.() -> kotlin.Int): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Int)?.test5(): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Int)?.test6(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nullabilityOperations.txt b/compiler/testData/diagnostics/tests/inline/nullabilityOperations.txt index 5dc960d8857..cfeb573171f 100644 --- a/compiler/testData/diagnostics/tests/inline/nullabilityOperations.txt +++ b/compiler/testData/diagnostics/tests/inline/nullabilityOperations.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun submit(/*0*/ action: (kotlin.Int) -> kotlin.Int): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Int).submit(): kotlin.Unit -@kotlin.inline() public fun kotlin.String.submit(/*0*/ action: (kotlin.Int) -> kotlin.Int): kotlin.Unit +public inline fun submit(/*0*/ action: (kotlin.Int) -> kotlin.Int): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Int).submit(): kotlin.Unit +public inline fun kotlin.String.submit(/*0*/ action: (kotlin.Int) -> kotlin.Int): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/nullableFunction.txt b/compiler/testData/diagnostics/tests/inline/nullableFunction.txt index fdaf6034914..895aa4db10e 100644 --- a/compiler/testData/diagnostics/tests/inline/nullableFunction.txt +++ b/compiler/testData/diagnostics/tests/inline/nullableFunction.txt @@ -1,7 +1,7 @@ package -@kotlin.inline() public fun submit(/*0*/ action: ((kotlin.Int) -> kotlin.Int)?): kotlin.Unit -@kotlin.inline() public fun submit(/*0*/ action: ((kotlin.Int) -> kotlin.Int)?, /*1*/ s: () -> kotlin.Int): kotlin.Unit -@kotlin.inline() public fun submitNoInline(/*0*/ @kotlin.noinline() action: ((kotlin.Int) -> kotlin.Int)?, /*1*/ s: () -> kotlin.Int): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Int)?.submit(): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Int)?.submit(/*0*/ action: () -> T): kotlin.Unit +public inline fun submit(/*0*/ action: ((kotlin.Int) -> kotlin.Int)?): kotlin.Unit +public inline fun submit(/*0*/ action: ((kotlin.Int) -> kotlin.Int)?, /*1*/ s: () -> kotlin.Int): kotlin.Unit +public inline fun submitNoInline(/*0*/ noinline action: ((kotlin.Int) -> kotlin.Int)?, /*1*/ s: () -> kotlin.Int): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Int)?.submit(): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Int)?.submit(/*0*/ action: () -> T): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/parenthesized.txt b/compiler/testData/diagnostics/tests/inline/parenthesized.txt index 1f7133f26f1..87b02cbf604 100644 --- a/compiler/testData/diagnostics/tests/inline/parenthesized.txt +++ b/compiler/testData/diagnostics/tests/inline/parenthesized.txt @@ -1,6 +1,6 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvoke2(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun propagation(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWithInvoke2(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun propagation(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/propagation.txt b/compiler/testData/diagnostics/tests/inline/propagation.txt index a05785f8d6a..66b28573df1 100644 --- a/compiler/testData/diagnostics/tests/inline/propagation.txt +++ b/compiler/testData/diagnostics/tests/inline/propagation.txt @@ -1,10 +1,10 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvokeClosure(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvokeClosureNoinline(/*0*/ @kotlin.noinline() s: (kotlin.Int) -> kotlin.Unit, /*1*/ @kotlin.noinline() ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvokeNonInline(/*0*/ @kotlin.noinline() s: (kotlin.Int) -> kotlin.Unit, /*1*/ @kotlin.noinline() ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun subInline(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWithInvokeClosure(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWithInvokeClosureNoinline(/*0*/ noinline s: (kotlin.Int) -> kotlin.Unit, /*1*/ noinline ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWithInvokeNonInline(/*0*/ noinline s: (kotlin.Int) -> kotlin.Unit, /*1*/ noinline ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun subInline(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit public fun subNoInline(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Unit).inlineExt(/*0*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Unit).inlineExtWithClosure(/*0*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Unit).inlineExt(/*0*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Unit).inlineExtWithClosure(/*0*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/recursion.txt b/compiler/testData/diagnostics/tests/inline/recursion.txt index 3192111f39d..0cb5df06f7b 100644 --- a/compiler/testData/diagnostics/tests/inline/recursion.txt +++ b/compiler/testData/diagnostics/tests/inline/recursion.txt @@ -1,7 +1,7 @@ package -@kotlin.inline() public fun inlineFun(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFun(/*0*/ s: T): kotlin.Unit -@kotlin.inline() public operator fun ((T) -> V).inc(): (T) -> V -@kotlin.inline() public fun (() -> T).inlineExt(): kotlin.Unit -@kotlin.inline() public operator fun ((T) -> V).not(): kotlin.Boolean +public inline fun inlineFun(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFun(/*0*/ s: T): kotlin.Unit +public operator inline fun ((T) -> V).inc(): (T) -> V +public inline fun (() -> T).inlineExt(): kotlin.Unit +public operator inline fun ((T) -> V).not(): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/inline/regressions/kt4341.txt b/compiler/testData/diagnostics/tests/inline/regressions/kt4341.txt index bebfd2df623..8f643494ff7 100644 --- a/compiler/testData/diagnostics/tests/inline/regressions/kt4341.txt +++ b/compiler/testData/diagnostics/tests/inline/regressions/kt4341.txt @@ -1,5 +1,5 @@ package package g { - @kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T) -> U): kotlin.Unit + public inline fun inlineFunWithInvoke(/*0*/ s: (T) -> U): kotlin.Unit } diff --git a/compiler/testData/diagnostics/tests/inline/returns.txt b/compiler/testData/diagnostics/tests/inline/returns.txt index 4c967d66064..77b823a216f 100644 --- a/compiler/testData/diagnostics/tests/inline/returns.txt +++ b/compiler/testData/diagnostics/tests/inline/returns.txt @@ -1,8 +1,8 @@ package -@kotlin.inline() public fun inlineFun(/*0*/ s: (kotlin.Int) -> kotlin.Unit): (kotlin.Int) -> kotlin.Unit -@kotlin.inline() public fun inlineFun2(/*0*/ s: (kotlin.Int) -> kotlin.Unit): (kotlin.Int) -> kotlin.Unit -@kotlin.inline() public fun inlineFunWithExt(/*0*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Int.(kotlin.Int) -> kotlin.Unit -@kotlin.inline() public fun inlineFunWithExt2(/*0*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Int.(kotlin.Int) -> kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): (kotlin.Int) -> kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Unit).inlineExt2(): (kotlin.Int) -> kotlin.Unit +public inline fun inlineFun(/*0*/ s: (kotlin.Int) -> kotlin.Unit): (kotlin.Int) -> kotlin.Unit +public inline fun inlineFun2(/*0*/ s: (kotlin.Int) -> kotlin.Unit): (kotlin.Int) -> kotlin.Unit +public inline fun inlineFunWithExt(/*0*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Int.(kotlin.Int) -> kotlin.Unit +public inline fun inlineFunWithExt2(/*0*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Int.(kotlin.Int) -> kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): (kotlin.Int) -> kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Unit).inlineExt2(): (kotlin.Int) -> kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/sam.txt b/compiler/testData/diagnostics/tests/inline/sam.txt index 5ec6e0aebca..ba76e24e598 100644 --- a/compiler/testData/diagnostics/tests/inline/sam.txt +++ b/compiler/testData/diagnostics/tests/inline/sam.txt @@ -1,9 +1,9 @@ package public /*synthesized*/ fun Run(/*0*/ function: () -> kotlin.Int): Run -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvokeNonInline(/*0*/ @kotlin.noinline() s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWithInvokeNonInline(/*0*/ noinline s: (kotlin.Int) -> kotlin.Unit, /*1*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Unit).inlineExt(): kotlin.Unit public interface Run { public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/inline/unaryExpressions/mathOperation.txt b/compiler/testData/diagnostics/tests/inline/unaryExpressions/mathOperation.txt index 0b4f05ec6a3..3da1e18c32a 100644 --- a/compiler/testData/diagnostics/tests/inline/unaryExpressions/mathOperation.txt +++ b/compiler/testData/diagnostics/tests/inline/unaryExpressions/mathOperation.txt @@ -1,12 +1,12 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T) -> V, /*1*/ ext: T.(T) -> V): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (T) -> V, /*1*/ ext: T.(T) -> V): kotlin.Unit public operator fun ((T) -> V).dec(): (T) -> V public operator fun (T.(T) -> V).dec(): T.(T) -> V -@kotlin.inline() public operator fun ((T) -> V).inc(): (T) -> V -@kotlin.inline() public operator fun (T.(T) -> V).inc(): T.(T) -> V -@kotlin.inline() public fun ((T) -> V).inlineFunWithInvoke(): kotlin.Unit +public operator inline fun ((T) -> V).inc(): (T) -> V +public operator inline fun (T.(T) -> V).inc(): T.(T) -> V +public inline fun ((T) -> V).inlineFunWithInvoke(): kotlin.Unit public operator fun ((T) -> V).unaryMinus(): (T) -> V public operator fun (T.(T) -> V).unaryMinus(): kotlin.Unit -@kotlin.inline() public operator fun ((T) -> V).unaryPlus(): (T) -> V -@kotlin.inline() public operator fun (T.(T) -> V).unaryPlus(): kotlin.Unit +public operator inline fun ((T) -> V).unaryPlus(): (T) -> V +public operator inline fun (T.(T) -> V).unaryPlus(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/unaryExpressions/notOnCall.txt b/compiler/testData/diagnostics/tests/inline/unaryExpressions/notOnCall.txt index d27bcc0fbfb..dda5a069467 100644 --- a/compiler/testData/diagnostics/tests/inline/unaryExpressions/notOnCall.txt +++ b/compiler/testData/diagnostics/tests/inline/unaryExpressions/notOnCall.txt @@ -1,3 +1,3 @@ package -@kotlin.inline() public fun test(/*0*/ predicate: (kotlin.Char) -> kotlin.Boolean): kotlin.Unit +public inline fun test(/*0*/ predicate: (kotlin.Char) -> kotlin.Boolean): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/unaryExpressions/notOperation.txt b/compiler/testData/diagnostics/tests/inline/unaryExpressions/notOperation.txt index 9cba57a5e90..efb0f65421d 100644 --- a/compiler/testData/diagnostics/tests/inline/unaryExpressions/notOperation.txt +++ b/compiler/testData/diagnostics/tests/inline/unaryExpressions/notOperation.txt @@ -1,7 +1,7 @@ package -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T) -> V): kotlin.Unit -@kotlin.inline() public fun inlineFunWithInvoke(/*0*/ s: (T, U) -> V, /*1*/ ext: T.(T, U) -> V): kotlin.Unit -@kotlin.inline() public operator fun ((T) -> V).not(): kotlin.Boolean +public inline fun inlineFunWithInvoke(/*0*/ s: (T) -> V): kotlin.Unit +public inline fun inlineFunWithInvoke(/*0*/ s: (T, U) -> V, /*1*/ ext: T.(T, U) -> V): kotlin.Unit +public operator inline fun ((T) -> V).not(): kotlin.Boolean public operator fun ((T, U) -> V).not(): kotlin.Boolean public operator fun (T.(U, V) -> W).not(): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/inline/unsupportedConstruction.txt b/compiler/testData/diagnostics/tests/inline/unsupportedConstruction.txt index c5ed648a0a3..797a4e03381 100644 --- a/compiler/testData/diagnostics/tests/inline/unsupportedConstruction.txt +++ b/compiler/testData/diagnostics/tests/inline/unsupportedConstruction.txt @@ -1,7 +1,7 @@ package -@kotlin.inline() public fun unsupported(): kotlin.Unit -@kotlin.inline() public fun unsupportedDefault(/*0*/ s: () -> kotlin.Unit = ...): kotlin.Unit +public inline fun unsupported(): kotlin.Unit +public inline fun unsupportedDefault(/*0*/ s: () -> kotlin.Unit = ...): kotlin.Unit public open class Base { public constructor Base() @@ -14,7 +14,7 @@ public open class Base { public final class Derived : Base { public constructor Derived() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.inline() public final override /*1*/ fun foo(/*0*/ a: kotlin.Int = ...): kotlin.Unit + public final inline override /*1*/ fun foo(/*0*/ a: kotlin.Int = ...): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/tests/inline/vararg.txt b/compiler/testData/diagnostics/tests/inline/vararg.txt index 33581ff2594..ef21f011607 100644 --- a/compiler/testData/diagnostics/tests/inline/vararg.txt +++ b/compiler/testData/diagnostics/tests/inline/vararg.txt @@ -1,6 +1,6 @@ package -@kotlin.inline() public fun inlineFun(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ @kotlin.noinline() b: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun subInline(/*0*/ vararg s: (kotlin.Int) -> kotlin.Unit /*kotlin.Array kotlin.Unit>*/): kotlin.Unit +public inline fun inlineFun(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ noinline b: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun subInline(/*0*/ vararg s: (kotlin.Int) -> kotlin.Unit /*kotlin.Array kotlin.Unit>*/): kotlin.Unit public fun subNoInline(/*0*/ vararg s: (kotlin.Int) -> kotlin.Unit /*kotlin.Array kotlin.Unit>*/): kotlin.Unit -@kotlin.inline() public fun ((kotlin.Int) -> kotlin.Unit).inlineExt(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ @kotlin.noinline() b: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun ((kotlin.Int) -> kotlin.Unit).inlineExt(/*0*/ s: (kotlin.Int) -> kotlin.Unit, /*1*/ noinline b: (kotlin.Int) -> kotlin.Unit): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inline/wrongUsage.txt b/compiler/testData/diagnostics/tests/inline/wrongUsage.txt index fdc1d7df927..1d46ec36454 100644 --- a/compiler/testData/diagnostics/tests/inline/wrongUsage.txt +++ b/compiler/testData/diagnostics/tests/inline/wrongUsage.txt @@ -1,8 +1,8 @@ package -@kotlin.inline() public fun inlineFunNoInline(/*0*/ @kotlin.noinline() s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunNoInline(/*0*/ @kotlin.noinline() ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWrongUsage(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWrongUsageExt(/*0*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWrongUsageInClosure(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit -@kotlin.inline() public fun inlineFunWrongUsageInClosureExt(/*0*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunNoInline(/*0*/ noinline s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunNoInline(/*0*/ noinline ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWrongUsage(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWrongUsageExt(/*0*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWrongUsageInClosure(/*0*/ s: (kotlin.Int) -> kotlin.Unit): kotlin.Unit +public inline fun inlineFunWrongUsageInClosureExt(/*0*/ ext: kotlin.Int.(kotlin.Int) -> kotlin.Unit): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.txt b/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.txt index 3ca7e9718dd..3bd9c43cfdd 100644 --- a/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.txt +++ b/compiler/testData/diagnostics/tests/inner/classesInClassObjectHeader.txt @@ -13,7 +13,7 @@ public final class Test { public open override /*2*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class InnerAnnotation : kotlin.Annotation { + public final annotation class InnerAnnotation : kotlin.Annotation { public constructor InnerAnnotation() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/inner/illegalModifier.txt b/compiler/testData/diagnostics/tests/inner/illegalModifier.txt index a684ff40d57..b604dc645e4 100644 --- a/compiler/testData/diagnostics/tests/inner/illegalModifier.txt +++ b/compiler/testData/diagnostics/tests/inner/illegalModifier.txt @@ -73,7 +73,7 @@ public final class D { @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } - @kotlin.annotation.annotation() public final class S : kotlin.Annotation { + public final annotation class S : kotlin.Annotation { public constructor S() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.txt b/compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.txt index edfff206d7e..df68c4f4140 100644 --- a/compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.txt +++ b/compiler/testData/diagnostics/tests/inner/selfAnnotationForClassObject.txt @@ -12,7 +12,7 @@ public final class Test { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - @kotlin.annotation.annotation() public final class ClassObjectAnnotation : kotlin.Annotation { + public final annotation class ClassObjectAnnotation : kotlin.Annotation { public constructor ClassObjectAnnotation() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -20,7 +20,7 @@ public final class Test { } } - @kotlin.annotation.annotation() public final class NestedAnnotation : kotlin.Annotation { + public final annotation class NestedAnnotation : kotlin.Annotation { public constructor NestedAnnotation() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/labels/kt1703.txt b/compiler/testData/diagnostics/tests/labels/kt1703.txt index b5dbed4ea91..81c6e7fe6d4 100644 --- a/compiler/testData/diagnostics/tests/labels/kt1703.txt +++ b/compiler/testData/diagnostics/tests/labels/kt1703.txt @@ -1,6 +1,6 @@ package -@kotlin.inline() public fun Array(/*0*/ n: kotlin.Int, /*1*/ block: (kotlin.Int) -> T): kotlin.Array +public inline fun Array(/*0*/ n: kotlin.Int, /*1*/ block: (kotlin.Int) -> T): kotlin.Array public fun test(): kotlin.Unit public fun use(/*0*/ a: kotlin.Any?): kotlin.Any? public fun kotlin.Array.forEach(/*0*/ operation: (T) -> kotlin.Unit): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt index 2b76219b0e1..19425d8c030 100644 --- a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt +++ b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.kt @@ -15,9 +15,12 @@ abstract class A() { class FinalClass() { open fun foo() {} val i: Int = 1 - open get(): Int = field + open inline get(): Int = field var j: Int = 1 - open set(v: Int) {} + open inline set(v: Int) {} + + inline val f: ()->Unit + get() = {} } private public class C diff --git a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.txt b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.txt index e08a73b7897..5ca81f2ca69 100644 --- a/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.txt +++ b/compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.txt @@ -29,6 +29,7 @@ package illegal_modifiers { public final class FinalClass { public constructor FinalClass() + public final val f: () -> kotlin.Unit public final val i: kotlin.Int = 1 public final var j: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -45,7 +46,7 @@ package illegal_modifiers { } public final class IllegalModifiers10 { - @kotlin.annotation.annotation() public constructor IllegalModifiers10() + public constructor IllegalModifiers10() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String @@ -100,15 +101,15 @@ package illegal_modifiers { public open class IllegalModifiers7 { public constructor IllegalModifiers7() - @kotlin.annotation.annotation() public final val x: kotlin.Int = 1 + public final val x: kotlin.Int = 1 public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.annotation.annotation() public final fun foo(): kotlin.Unit + public final fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } public final class IllegalModifiers8 { - @kotlin.annotation.annotation() public constructor IllegalModifiers8() + public constructor IllegalModifiers8() public constructor IllegalModifiers8(/*0*/ x: kotlin.Int) public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -138,7 +139,7 @@ package illegal_modifiers { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class annotated : kotlin.Annotation { + public final annotation class annotated : kotlin.Annotation { public constructor annotated(/*0*/ text: kotlin.String = ...) public final val text: kotlin.String public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/modifiers/annotations.txt b/compiler/testData/diagnostics/tests/modifiers/annotations.txt index ff98b4aaa6a..394e4f00029 100644 --- a/compiler/testData/diagnostics/tests/modifiers/annotations.txt +++ b/compiler/testData/diagnostics/tests/modifiers/annotations.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class His : Your { +public final annotation class His : Your { public constructor His(/*0*/ x: kotlin.Int) public open override /*1*/ val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -8,7 +8,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class My : kotlin.Annotation { +public final annotation class My : kotlin.Annotation { public constructor My(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int, /*2*/ z: kotlin.Int, /*3*/ w: kotlin.Int) private final val w: kotlin.Int public final val x: kotlin.Int diff --git a/compiler/testData/diagnostics/tests/modifiers/const/fromJava.txt b/compiler/testData/diagnostics/tests/modifiers/const/fromJava.txt index 30f97aed659..64c9a82ba96 100644 --- a/compiler/testData/diagnostics/tests/modifiers/const/fromJava.txt +++ b/compiler/testData/diagnostics/tests/modifiers/const/fromJava.txt @@ -17,7 +17,7 @@ public open class A { public const final val Y: kotlin.Int } -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/modifiers/inlineParameters.txt b/compiler/testData/diagnostics/tests/modifiers/inlineParameters.txt index 31c9525c8c3..ecb194d5805 100644 --- a/compiler/testData/diagnostics/tests/modifiers/inlineParameters.txt +++ b/compiler/testData/diagnostics/tests/modifiers/inlineParameters.txt @@ -1,6 +1,6 @@ package -@kotlin.inline() public fun bar(/*0*/ y: kotlin.Int, /*1*/ @kotlin.crossinline() x: kotlin.String): kotlin.Unit -@kotlin.inline() public fun correct(/*0*/ @kotlin.noinline() x: (kotlin.Int) -> kotlin.Unit, /*1*/ @kotlin.crossinline() y: (kotlin.String) -> kotlin.Int): kotlin.Unit -@kotlin.inline() public fun foo(/*0*/ @kotlin.noinline() x: kotlin.Int): kotlin.Unit -public fun gav(/*0*/ @kotlin.noinline() x: (kotlin.Int) -> kotlin.Unit, /*1*/ @kotlin.crossinline() y: (kotlin.String) -> kotlin.Int): kotlin.Unit +public inline fun bar(/*0*/ y: kotlin.Int, /*1*/ crossinline x: kotlin.String): kotlin.Unit +public inline fun correct(/*0*/ noinline x: (kotlin.Int) -> kotlin.Unit, /*1*/ crossinline y: (kotlin.String) -> kotlin.Int): kotlin.Unit +public inline fun foo(/*0*/ noinline x: kotlin.Int): kotlin.Unit +public fun gav(/*0*/ noinline x: (kotlin.Int) -> kotlin.Unit, /*1*/ crossinline y: (kotlin.String) -> kotlin.Int): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingKeyword.txt b/compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingKeyword.txt index f93c11f437a..ca110957cd1 100644 --- a/compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingKeyword.txt +++ b/compiler/testData/diagnostics/tests/modifiers/primaryConstructorMissingKeyword.txt @@ -17,7 +17,7 @@ public final class A { } } -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ x: kotlin.Int = ...) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/modifiers/protected.txt b/compiler/testData/diagnostics/tests/modifiers/protected.txt index 61808b6a6e1..6d2371af76e 100644 --- a/compiler/testData/diagnostics/tests/modifiers/protected.txt +++ b/compiler/testData/diagnostics/tests/modifiers/protected.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class His : kotlin.Annotation { +public final annotation class His : kotlin.Annotation { public constructor His(/*0*/ x: kotlin.Int) protected final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/namedArguments/allowForJavaAnnotation.txt b/compiler/testData/diagnostics/tests/namedArguments/allowForJavaAnnotation.txt index f29327238ff..e5e2cd3147d 100644 --- a/compiler/testData/diagnostics/tests/namedArguments/allowForJavaAnnotation.txt +++ b/compiler/testData/diagnostics/tests/namedArguments/allowForJavaAnnotation.txt @@ -2,7 +2,7 @@ package @A(x = 1, y = "2") public fun test(): kotlin.Unit -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String) public final val x: kotlin.Int public final val y: kotlin.String diff --git a/compiler/testData/diagnostics/tests/nullableTypes/safeAccessOnUnit.txt b/compiler/testData/diagnostics/tests/nullableTypes/safeAccessOnUnit.txt index 7090fe326cd..c42e6700292 100644 --- a/compiler/testData/diagnostics/tests/nullableTypes/safeAccessOnUnit.txt +++ b/compiler/testData/diagnostics/tests/nullableTypes/safeAccessOnUnit.txt @@ -2,7 +2,7 @@ package public fun foo(/*0*/ my: My?): kotlin.Int? -@kotlin.data() public final class My { +public final data class My { public constructor My(/*0*/ x: kotlin.Unit) public final val x: kotlin.Unit public final operator /*synthesized*/ fun component1(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/operatorsOverloading/kt3450.txt b/compiler/testData/diagnostics/tests/operatorsOverloading/kt3450.txt index a93713addd7..65f132f7c6c 100644 --- a/compiler/testData/diagnostics/tests/operatorsOverloading/kt3450.txt +++ b/compiler/testData/diagnostics/tests/operatorsOverloading/kt3450.txt @@ -24,7 +24,7 @@ public final class B { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public final class Pair { +public final data class Pair { public constructor Pair(/*0*/ first: A, /*1*/ second: B) public final val first: A public final val second: B diff --git a/compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.txt b/compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.txt index 5ba93dc7c20..2baab918742 100644 --- a/compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.txt +++ b/compiler/testData/diagnostics/tests/recovery/namelessToplevelDeclarations.txt @@ -32,7 +32,7 @@ public final enum class : kotlin.Enum<> { @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array<> } -@kotlin.annotation.annotation() public final class : kotlin.Annotation { +public final annotation class : kotlin.Annotation { public constructor () public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/regressions/kt312.txt b/compiler/testData/diagnostics/tests/regressions/kt312.txt index aa4d149e05b..b7649d72ea8 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt312.txt +++ b/compiler/testData/diagnostics/tests/regressions/kt312.txt @@ -3,5 +3,5 @@ package public val args: kotlin.Array public val name: kotlin.String public val name1: kotlin.String? -@kotlin.inline() public fun Array(/*0*/ n: kotlin.Int, /*1*/ block: (kotlin.Int) -> T): kotlin.Array +public inline fun Array(/*0*/ n: kotlin.Int, /*1*/ block: (kotlin.Int) -> T): kotlin.Array public fun kotlin.Array.safeGet(/*0*/ index: kotlin.Int): T? diff --git a/compiler/testData/diagnostics/tests/regressions/kt385.109.441.txt b/compiler/testData/diagnostics/tests/regressions/kt385.109.441.txt index 5040571b965..32597035087 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt385.109.441.txt +++ b/compiler/testData/diagnostics/tests/regressions/kt385.109.441.txt @@ -5,7 +5,7 @@ public fun generic_invoker(/*0*/ gen: () -> T): T public fun main(/*0*/ args: kotlin.Array): kotlin.Unit public fun println(/*0*/ message: kotlin.Int): kotlin.Unit public fun println(/*0*/ message: kotlin.Long): kotlin.Unit -@kotlin.inline() public fun run(/*0*/ body: () -> T): T +public inline fun run(/*0*/ body: () -> T): T public fun kotlin.Iterable.foreach(/*0*/ operation: (T) -> kotlin.Unit): kotlin.Unit public fun kotlin.Iterable.foreach(/*0*/ operation: (kotlin.Int, T) -> kotlin.Unit): kotlin.Unit public infix fun kotlin.Iterator.foreach(/*0*/ operation: (T) -> kotlin.Unit): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/regressions/kt439.txt b/compiler/testData/diagnostics/tests/regressions/kt439.txt index 8e5b4e52982..1cf4e3ea372 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt439.txt +++ b/compiler/testData/diagnostics/tests/regressions/kt439.txt @@ -1,4 +1,4 @@ package public fun main1(/*0*/ args: kotlin.Array): kotlin.Unit -@kotlin.inline() public fun run1(/*0*/ body: () -> T): T +public inline fun run1(/*0*/ body: () -> T): T diff --git a/compiler/testData/diagnostics/tests/regressions/kt4693.txt b/compiler/testData/diagnostics/tests/regressions/kt4693.txt index d4a35a19d2f..d98408bc3d2 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt4693.txt +++ b/compiler/testData/diagnostics/tests/regressions/kt4693.txt @@ -8,7 +8,7 @@ public final enum class MyEnum : kotlin.Enum { public final override /*1*/ /*fake_override*/ val ordinal: kotlin.Int protected final override /*1*/ /*fake_override*/ fun clone(): kotlin.Any public final override /*1*/ /*fake_override*/ fun compareTo(/*0*/ other: MyEnum): kotlin.Int - @kotlin.inline() public final fun doSmth(/*0*/ f: (MyEnum) -> kotlin.String): kotlin.String + public final inline fun doSmth(/*0*/ f: (MyEnum) -> kotlin.String): kotlin.String public final override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public final override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String diff --git a/compiler/testData/diagnostics/tests/regressions/kt7585/base.txt b/compiler/testData/diagnostics/tests/regressions/kt7585/base.txt index 81a235f2eca..75b4c10a526 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt7585/base.txt +++ b/compiler/testData/diagnostics/tests/regressions/kt7585/base.txt @@ -24,7 +24,7 @@ public final class MyWrapper : Wrapper { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public final class Pair { +public final data class Pair { public constructor Pair(/*0*/ a: T, /*1*/ b: T) public final val a: T public final val b: T diff --git a/compiler/testData/diagnostics/tests/regressions/kt7585/java.txt b/compiler/testData/diagnostics/tests/regressions/kt7585/java.txt index 0ba058571ba..b3a30a23db5 100644 --- a/compiler/testData/diagnostics/tests/regressions/kt7585/java.txt +++ b/compiler/testData/diagnostics/tests/regressions/kt7585/java.txt @@ -24,7 +24,7 @@ public final class MyWrapper : Wrapper { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public final class Pair { +public final data class Pair { public constructor Pair(/*0*/ a: T, /*1*/ b: T) public final val a: T public final val b: T diff --git a/compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.txt b/compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.txt index a44ca174212..3faf2ed057e 100644 --- a/compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.txt +++ b/compiler/testData/diagnostics/tests/resolve/resolveAnnotatedLambdaArgument.txt @@ -3,7 +3,7 @@ package public fun bar(/*0*/ block: (T) -> kotlin.Int): kotlin.Unit public fun foo(): kotlin.Unit -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() public final annotation class Ann : kotlin.Annotation { public constructor Ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenWithAdditionalMember.txt b/compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenWithAdditionalMember.txt index 57f3ef708a1..7bdb773312b 100644 --- a/compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenWithAdditionalMember.txt +++ b/compiler/testData/diagnostics/tests/sealed/ExhaustiveWhenWithAdditionalMember.txt @@ -44,7 +44,7 @@ public sealed class Sealed { } } - @kotlin.data() public final class Tuple { + public final data class Tuple { public constructor Tuple(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int) public final val x: kotlin.Int public final val y: kotlin.Int diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.txt b/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.txt index 451586c935b..663d5c166a9 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.txt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.txt @@ -9,14 +9,14 @@ public final class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann1 : kotlin.Annotation { +public final annotation class Ann1 : kotlin.Annotation { public constructor Ann1() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann2 : kotlin.Annotation { +public final annotation class Ann2 : kotlin.Annotation { public constructor Ann2(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/tests/secondaryConstructors/dataClasses.txt b/compiler/testData/diagnostics/tests/secondaryConstructors/dataClasses.txt index 0520c1a6954..ba29337c040 100644 --- a/compiler/testData/diagnostics/tests/secondaryConstructors/dataClasses.txt +++ b/compiler/testData/diagnostics/tests/secondaryConstructors/dataClasses.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public final class A1 { +public final data class A1 { public constructor A1() public constructor A1(/*0*/ x: kotlin.String) public final val x: kotlin.String @@ -11,7 +11,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public final class A2 { +public final data class A2 { public constructor A2(/*0*/ x: kotlin.String) public constructor A2(/*0*/ y: kotlin.String, /*1*/ z: kotlin.Int) public final val y: kotlin.String @@ -24,7 +24,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() public final class A3 { +public final data class A3 { public constructor A3() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/shadowing/ShadowMultiDeclarationWithFunParameter.txt b/compiler/testData/diagnostics/tests/shadowing/ShadowMultiDeclarationWithFunParameter.txt index 1aea448c2db..2733fc2e80f 100644 --- a/compiler/testData/diagnostics/tests/shadowing/ShadowMultiDeclarationWithFunParameter.txt +++ b/compiler/testData/diagnostics/tests/shadowing/ShadowMultiDeclarationWithFunParameter.txt @@ -1,6 +1,6 @@ package -@kotlin.inline() public fun Array(/*0*/ n: kotlin.Int, /*1*/ block: (kotlin.Int) -> T): kotlin.Array +public inline fun Array(/*0*/ n: kotlin.Int, /*1*/ block: (kotlin.Int) -> T): kotlin.Array public fun foo(/*0*/ a: A, /*1*/ c: kotlin.Int): kotlin.Unit public final class A { diff --git a/compiler/testData/diagnostics/tests/smartCasts/inference/kt1355.txt b/compiler/testData/diagnostics/tests/smartCasts/inference/kt1355.txt index 8cba4186338..2585099e57b 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/inference/kt1355.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/inference/kt1355.txt @@ -5,7 +5,7 @@ package a { public fun foo(/*0*/ map: kotlin.MutableMap, /*1*/ value: kotlin.String?): kotlin.Unit public operator fun kotlin.MutableMap.set(/*0*/ key: K, /*1*/ value: V): V? - @kotlin.data() public final class Tag { + public final data class Tag { public constructor Tag(/*0*/ tagName: kotlin.String) public final val attributes: kotlin.MutableMap public final val contents: kotlin.MutableList diff --git a/compiler/testData/diagnostics/tests/smartCasts/inference/kt6242.txt b/compiler/testData/diagnostics/tests/smartCasts/inference/kt6242.txt index a0cdbf548c3..d6367ea149b 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/inference/kt6242.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/inference/kt6242.txt @@ -1,4 +1,4 @@ package public fun baz(): kotlin.Unit -@kotlin.inline() public fun foo(/*0*/ block: () -> T): T +public inline fun foo(/*0*/ block: () -> T): T diff --git a/compiler/testData/diagnostics/tests/smartCasts/kt3711.txt b/compiler/testData/diagnostics/tests/smartCasts/kt3711.txt index 7076b7b05f9..e1581fe54a1 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/kt3711.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/kt3711.txt @@ -3,7 +3,7 @@ package public fun f(/*0*/ a: kotlin.String?): kotlin.Unit public infix fun kotlin.String.to(/*0*/ second: kotlin.String): StringPair -@kotlin.data() public final class StringPair { +public final data class StringPair { public constructor StringPair(/*0*/ first: kotlin.String, /*1*/ second: kotlin.String) public final val first: kotlin.String public final val second: kotlin.String diff --git a/compiler/testData/diagnostics/tests/smartCasts/kt3899.txt b/compiler/testData/diagnostics/tests/smartCasts/kt3899.txt index bfc97629990..f33c273f045 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/kt3899.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/kt3899.txt @@ -4,7 +4,7 @@ public fun F(): kotlin.MutableMap public fun hashMapOf(/*0*/ pair: StringPair): kotlin.MutableMap public infix fun kotlin.String.to(/*0*/ second: kotlin.String): StringPair -@kotlin.data() public final class StringPair { +public final data class StringPair { public constructor StringPair(/*0*/ first: kotlin.String, /*1*/ second: kotlin.String) public final val first: kotlin.String public final val second: kotlin.String diff --git a/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgument.txt b/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgument.txt index b18e5d3bcf2..b4571f7e32b 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgument.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgument.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun bar(/*0*/ l: (T) -> kotlin.Unit): T -@kotlin.inline() public fun foo(/*0*/ t1: T, /*1*/ t2: T): T +public inline fun bar(/*0*/ l: (T) -> kotlin.Unit): T +public inline fun foo(/*0*/ t1: T, /*1*/ t2: T): T public fun use(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgumentFun.txt b/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgumentFun.txt index b18e5d3bcf2..b4571f7e32b 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgumentFun.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/lambdaAndArgumentFun.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun bar(/*0*/ l: (T) -> kotlin.Unit): T -@kotlin.inline() public fun foo(/*0*/ t1: T, /*1*/ t2: T): T +public inline fun bar(/*0*/ l: (T) -> kotlin.Unit): T +public inline fun foo(/*0*/ t1: T, /*1*/ t2: T): T public fun use(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/smartCasts/lambdaCallAnnotated.txt b/compiler/testData/diagnostics/tests/smartCasts/lambdaCallAnnotated.txt index 77e23fb17c2..c71ad6cd9bf 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/lambdaCallAnnotated.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/lambdaCallAnnotated.txt @@ -2,7 +2,7 @@ package public fun bar(): kotlin.Int -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) @kotlin.annotation.annotation() public final class My : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.EXPRESSION}) public final annotation class My : kotlin.Annotation { public constructor My() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/tests/smartCasts/safecalls/property.txt b/compiler/testData/diagnostics/tests/smartCasts/safecalls/property.txt index 037a3e6223f..0c668999a23 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/safecalls/property.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/safecalls/property.txt @@ -2,7 +2,7 @@ package public fun foo(/*0*/ y: MyClass): kotlin.Int -@kotlin.data() public final class MyClass { +public final data class MyClass { public constructor MyClass(/*0*/ x: kotlin.String?) public final val x: kotlin.String? public final operator /*synthesized*/ fun component1(): kotlin.String? diff --git a/compiler/testData/diagnostics/tests/smartCasts/varInsideLocalFun.txt b/compiler/testData/diagnostics/tests/smartCasts/varInsideLocalFun.txt index 88f3d7d050d..03a662541ce 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varInsideLocalFun.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/varInsideLocalFun.txt @@ -2,7 +2,7 @@ package public final class MyClass { public constructor MyClass() - @kotlin.inline() public final fun callback(/*0*/ foo: () -> kotlin.Unit): kotlin.Unit + public final inline fun callback(/*0*/ foo: () -> kotlin.Unit): kotlin.Unit public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public final fun main(): kotlin.Unit diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/doWhileWithBreak.txt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/doWhileWithBreak.txt index 9caee9631f6..571281d3360 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/doWhileWithBreak.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/doWhileWithBreak.txt @@ -2,7 +2,7 @@ package public fun list(/*0*/ start: SomeObject): kotlin.Unit -@kotlin.data() public final class SomeObject { +public final data class SomeObject { public constructor SomeObject(/*0*/ n: SomeObject?) public final val n: SomeObject? public final operator /*synthesized*/ fun component1(): SomeObject? diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEach.txt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEach.txt index ccc372a0a90..8ba36a01d1a 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEach.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEach.txt @@ -2,7 +2,7 @@ package public fun list(/*0*/ start: SomeObject): SomeObject -@kotlin.data() public final class SomeObject { +public final data class SomeObject { public constructor SomeObject(/*0*/ n: SomeObject?) public final val n: SomeObject? public final operator /*synthesized*/ fun component1(): SomeObject? diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithBreak.txt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithBreak.txt index ccc372a0a90..8ba36a01d1a 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithBreak.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithBreak.txt @@ -2,7 +2,7 @@ package public fun list(/*0*/ start: SomeObject): SomeObject -@kotlin.data() public final class SomeObject { +public final data class SomeObject { public constructor SomeObject(/*0*/ n: SomeObject?) public final val n: SomeObject? public final operator /*synthesized*/ fun component1(): SomeObject? diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithContinue.txt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithContinue.txt index ccc372a0a90..8ba36a01d1a 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithContinue.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/forEachWithContinue.txt @@ -2,7 +2,7 @@ package public fun list(/*0*/ start: SomeObject): SomeObject -@kotlin.data() public final class SomeObject { +public final data class SomeObject { public constructor SomeObject(/*0*/ n: SomeObject?) public final val n: SomeObject? public final operator /*synthesized*/ fun component1(): SomeObject? diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/infiniteWhileWithBreak.txt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/infiniteWhileWithBreak.txt index 9caee9631f6..571281d3360 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/infiniteWhileWithBreak.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/infiniteWhileWithBreak.txt @@ -2,7 +2,7 @@ package public fun list(/*0*/ start: SomeObject): kotlin.Unit -@kotlin.data() public final class SomeObject { +public final data class SomeObject { public constructor SomeObject(/*0*/ n: SomeObject?) public final val n: SomeObject? public final operator /*synthesized*/ fun component1(): SomeObject? diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/iterations.txt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/iterations.txt index 4086efde3da..712d67b36cc 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/iterations.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/iterations.txt @@ -2,7 +2,7 @@ package public fun list(/*0*/ start: SomeObject): kotlin.Unit -@kotlin.data() public final class SomeObject { +public final data class SomeObject { public constructor SomeObject(/*0*/ n: SomeObject?) public final val n: SomeObject? public final operator /*synthesized*/ fun component1(): SomeObject? diff --git a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileWithBreak.txt b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileWithBreak.txt index 9caee9631f6..571281d3360 100644 --- a/compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileWithBreak.txt +++ b/compiler/testData/diagnostics/tests/smartCasts/varnotnull/whileWithBreak.txt @@ -2,7 +2,7 @@ package public fun list(/*0*/ start: SomeObject): kotlin.Unit -@kotlin.data() public final class SomeObject { +public final data class SomeObject { public constructor SomeObject(/*0*/ n: SomeObject?) public final val n: SomeObject? public final operator /*synthesized*/ fun component1(): SomeObject? diff --git a/compiler/testData/diagnostics/tests/when/AnnotatedWhenStatement.txt b/compiler/testData/diagnostics/tests/when/AnnotatedWhenStatement.txt index 58e3c4d010d..63d4385ff35 100644 --- a/compiler/testData/diagnostics/tests/when/AnnotatedWhenStatement.txt +++ b/compiler/testData/diagnostics/tests/when/AnnotatedWhenStatement.txt @@ -2,7 +2,7 @@ package public fun foo(/*0*/ a: kotlin.Int): kotlin.Unit -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithJava8/annotations/deprecatedRepeatable.txt b/compiler/testData/diagnostics/testsWithJava8/annotations/deprecatedRepeatable.txt index 6effb4c7295..62ada953559 100644 --- a/compiler/testData/diagnostics/testsWithJava8/annotations/deprecatedRepeatable.txt +++ b/compiler/testData/diagnostics/testsWithJava8/annotations/deprecatedRepeatable.txt @@ -1,6 +1,6 @@ package -@kotlin.annotation.annotation() public final class Annotations : kotlin.Annotation { +public final annotation class Annotations : kotlin.Annotation { public constructor Annotations(/*0*/ vararg value: RepAnn /*kotlin.Array*/) public final val value: kotlin.Array public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -8,14 +8,14 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@java.lang.annotation.Repeatable(value = OtherAnnotations::class) @kotlin.annotation.annotation() public final class OtherAnn : kotlin.Annotation { +@java.lang.annotation.Repeatable(value = OtherAnnotations::class) public final annotation class OtherAnn : kotlin.Annotation { public constructor OtherAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class OtherAnnotations : kotlin.Annotation { +public final annotation class OtherAnnotations : kotlin.Annotation { public constructor OtherAnnotations(/*0*/ vararg value: OtherAnn /*kotlin.Array*/) public final val value: kotlin.Array public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -23,7 +23,7 @@ package public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@java.lang.annotation.Repeatable(value = Annotations::class) @kotlin.annotation.annotation() public final class RepAnn : kotlin.Annotation { +@java.lang.annotation.Repeatable(value = Annotations::class) public final annotation class RepAnn : kotlin.Annotation { public constructor RepAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycle.txt b/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycle.txt index 3c7b92514fa..d82c2d46c0d 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycle.txt +++ b/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycle.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun f(): kotlin.Unit -@kotlin.inline() public fun g(): kotlin.Unit -@kotlin.inline() public fun h(): kotlin.Unit +public inline fun f(): kotlin.Unit +public inline fun g(): kotlin.Unit +public inline fun h(): kotlin.Unit diff --git a/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleLambda.txt b/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleLambda.txt index dfd556b8a96..6e47a33dee2 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleLambda.txt +++ b/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleLambda.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun f(): kotlin.Unit -@kotlin.inline() public fun g(): kotlin.Unit -@kotlin.inline() public fun h(/*0*/ fn: () -> kotlin.Unit): kotlin.Unit +public inline fun f(): kotlin.Unit +public inline fun g(): kotlin.Unit +public inline fun h(/*0*/ fn: () -> kotlin.Unit): kotlin.Unit diff --git a/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleWithPublicFun.txt b/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleWithPublicFun.txt index 3c7b92514fa..d82c2d46c0d 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleWithPublicFun.txt +++ b/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleWithPublicFun.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun f(): kotlin.Unit -@kotlin.inline() public fun g(): kotlin.Unit -@kotlin.inline() public fun h(): kotlin.Unit +public inline fun f(): kotlin.Unit +public inline fun g(): kotlin.Unit +public inline fun h(): kotlin.Unit diff --git a/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleWithStdlibCall.txt b/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleWithStdlibCall.txt index 1225f1809f0..d6b500bef60 100644 --- a/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleWithStdlibCall.txt +++ b/compiler/testData/diagnostics/testsWithJsStdLibAndBackendCompilation/inline/recursionCycleWithStdlibCall.txt @@ -1,4 +1,4 @@ package -@kotlin.inline() public fun f(): kotlin.Unit -@kotlin.inline() public fun g(): kotlin.Unit +public inline fun f(): kotlin.Unit +public inline fun g(): kotlin.Unit diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/ClassObjectAnnotatedWithItsKClass.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/ClassObjectAnnotatedWithItsKClass.txt index 744314ecd54..316f89ef6fc 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/ClassObjectAnnotatedWithItsKClass.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/ClassObjectAnnotatedWithItsKClass.txt @@ -2,7 +2,7 @@ package package test { - @kotlin.annotation.annotation() public final class AnnClass : kotlin.Annotation { + public final annotation class AnnClass : kotlin.Annotation { public constructor AnnClass(/*0*/ a: kotlin.reflect.KClass<*>) public final val a: kotlin.reflect.KClass<*> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPart.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPart.txt index d75e22b8133..d596d11f8b2 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPart.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPart.txt @@ -1,20 +1,20 @@ package -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.annotation() public final class FileAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final annotation class FileAnn : kotlin.Annotation { public constructor FileAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) @kotlin.annotation.annotation() public final class FileBinaryAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class FileBinaryAnn : kotlin.Annotation { public constructor FileBinaryAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.annotation() public final class FileSourceAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final annotation class FileSourceAnn : kotlin.Annotation { public constructor FileSourceAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPartWithJavaAnnotation.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPartWithJavaAnnotation.txt index 1cf02d796f5..d4be8f92601 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPartWithJavaAnnotation.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationApplicability/multifileClassPartWithJavaAnnotation.txt @@ -1,20 +1,20 @@ package -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final class JavaAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final annotation class JavaAnn : kotlin.Annotation { public constructor JavaAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final class JavaClassAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class JavaClassAnn : kotlin.Annotation { public constructor JavaClassAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final class JavaSourceAnn : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE}) @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final annotation class JavaSourceAnn : kotlin.Annotation { public constructor JavaSourceAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.txt index 3527139b05d..c3c39dbd6d0 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/array.txt @@ -6,7 +6,7 @@ public val i3: kotlin.Int public val iAnn: Ann public fun foo(): kotlin.Int -@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ i: kotlin.IntArray) public final val i: kotlin.IntArray public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -14,7 +14,7 @@ public fun foo(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class AnnAnn : kotlin.Annotation { +@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() public final annotation class AnnAnn : kotlin.Annotation { public constructor AnnAnn(/*0*/ i: kotlin.Array) public final val i: kotlin.Array public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/simple.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/simple.txt index 1bd4d48507b..ad50dbf164d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/simple.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/simple.txt @@ -6,7 +6,7 @@ public val ia: kotlin.IntArray public val sa: kotlin.Array public fun foo(): kotlin.Int -@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ i: kotlin.Int) public final val i: kotlin.Int public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -14,14 +14,14 @@ public fun foo(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann2 : kotlin.Annotation { +public final annotation class Ann2 : kotlin.Annotation { public constructor Ann2() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class AnnIA : kotlin.Annotation { +public final annotation class AnnIA : kotlin.Annotation { public constructor AnnIA(/*0*/ ia: kotlin.IntArray) public final val ia: kotlin.IntArray public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -29,7 +29,7 @@ public fun foo(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class AnnSA : kotlin.Annotation { +public final annotation class AnnSA : kotlin.Annotation { public constructor AnnSA(/*0*/ sa: kotlin.Array) public final val sa: kotlin.Array public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.txt index 82ee8aadf45..21810d46e03 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/useOfNonConstVal.txt @@ -6,7 +6,7 @@ public val nonConst: kotlin.Int = 1 @Ann(x = 4, y = "3") public fun foo2(): kotlin.Unit @ArrayAnn(x = {1, 3, 1}) public fun foo3(): kotlin.Unit -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.String) public final val x: kotlin.Int public final val y: kotlin.String @@ -15,7 +15,7 @@ public val nonConst: kotlin.Int = 1 public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class ArrayAnn : kotlin.Annotation { +public final annotation class ArrayAnn : kotlin.Annotation { public constructor ArrayAnn(/*0*/ x: kotlin.IntArray) public final val x: kotlin.IntArray public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/vararg.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/vararg.txt index 7289cae4321..29c02f78052 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/vararg.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameterMustBeConstant/vararg.txt @@ -6,7 +6,7 @@ public val i3: kotlin.Int public val iAnn: Ann public fun foo(): kotlin.Int -@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ vararg i: kotlin.Int /*kotlin.IntArray*/) public final val i: kotlin.IntArray public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -14,7 +14,7 @@ public fun foo(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() @kotlin.annotation.annotation() public final class AnnAnn : kotlin.Annotation { +@kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) @kotlin.annotation.Repeatable() public final annotation class AnnAnn : kotlin.Annotation { public constructor AnnAnn(/*0*/ vararg i: Ann /*kotlin.Array*/) public final val i: kotlin.Array public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithValue.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithValue.txt index bdf238c14e7..90557dac13d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithValue.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithValue.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ value: kotlin.String, /*1*/ b: kotlin.Double, /*2*/ x1: kotlin.reflect.KClass<*>, /*3*/ a: kotlin.Int, /*4*/ x: kotlin.reflect.KClass<*>, /*5*/ x2: kotlin.reflect.KClass<*>) public final val a: kotlin.Int public final val b: kotlin.Double diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithoutValue.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithoutValue.txt index 8162553c26d..ce7731b24ac 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithoutValue.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/orderWithoutValue.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ b: kotlin.Double, /*1*/ x1: kotlin.reflect.KClass<*>, /*2*/ a: kotlin.Int, /*3*/ x: kotlin.reflect.KClass<*>, /*4*/ x2: kotlin.reflect.KClass<*>) public final val a: kotlin.Int public final val b: kotlin.Double diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.txt index c3f133fc4e4..ba59731a58e 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.txt @@ -9,7 +9,7 @@ package @A(value = {}, y = 7) public fun test7(): kotlin.Unit @A(value = {"8", "9", "10"}) public fun test8(): kotlin.Unit -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ vararg value: kotlin.String /*kotlin.Array*/, /*1*/ x: kotlin.reflect.KClass<*> = ..., /*2*/ y: kotlin.Int) public final val value: kotlin.Array public final val x: kotlin.reflect.KClass<*> diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayAndOtherDefault.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayAndOtherDefault.txt index 45fc479dc72..edfeee37f9b 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayAndOtherDefault.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayAndOtherDefault.txt @@ -12,7 +12,7 @@ package @A(value = {}) public fun test8(): kotlin.Unit @A(value = {}, x = kotlin.Any::class, y = 3) public fun test9(): kotlin.Unit -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ vararg value: kotlin.String /*kotlin.Array*/, /*1*/ x: kotlin.reflect.KClass<*> = ..., /*2*/ y: kotlin.Int = ...) public final val value: kotlin.Array public final val x: kotlin.reflect.KClass<*> diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayOnly.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayOnly.txt index 53b02d6624f..40c3934de4f 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayOnly.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayOnly.txt @@ -6,7 +6,7 @@ package @A(value = {}) public fun test4(): kotlin.Unit @A(value = {}) public fun test5(): kotlin.Unit -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ vararg value: kotlin.String /*kotlin.Array*/) public final val value: kotlin.Array public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayWithDefault.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayWithDefault.txt index efd960ae8ba..7a53b037ca7 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayWithDefault.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayWithDefault.txt @@ -6,7 +6,7 @@ package @A() public fun test4(): kotlin.Unit @A() public fun test5(): kotlin.Unit -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ vararg value: kotlin.String /*kotlin.Array*/ = ...) public final val value: kotlin.Array public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.txt index 2668addc4f2..fca370b9dd0 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.txt @@ -2,7 +2,7 @@ package @A(value = {1, "b"}) public fun test(): kotlin.Unit -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ vararg value: kotlin.String /*kotlin.Array*/) public final val value: kotlin.Array public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.txt index 08fe1abceed..64736addae6 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.txt @@ -2,7 +2,7 @@ package @B(args = {1, "b"}) public fun test(): kotlin.Unit -@kotlin.annotation.annotation() public final class B : kotlin.Annotation { +public final annotation class B : kotlin.Annotation { public constructor B(/*0*/ vararg args: kotlin.String /*kotlin.Array*/) public final val args: kotlin.Array public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/defaultValueMustBeConstant.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/defaultValueMustBeConstant.txt index eeca8dba849..a8188c4ed7e 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/defaultValueMustBeConstant.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/defaultValueMustBeConstant.txt @@ -5,7 +5,7 @@ public val nonConst: kotlin.Int public val nonConstKClass: kotlin.reflect.KClass public fun foo(): kotlin.Int -@kotlin.annotation.annotation() public final class InvalidAnn : kotlin.Annotation { +public final annotation class InvalidAnn : kotlin.Annotation { public constructor InvalidAnn(/*0*/ p1: kotlin.Int = ..., /*1*/ p2: kotlin.Int = ..., /*2*/ p3: kotlin.reflect.KClass<*> = ...) public final val p1: kotlin.Int public final val p2: kotlin.Int @@ -15,7 +15,7 @@ public fun foo(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class ValidAnn : kotlin.Annotation { +public final annotation class ValidAnn : kotlin.Annotation { public constructor ValidAnn(/*0*/ p1: kotlin.Int = ..., /*1*/ p2: kotlin.String = ..., /*2*/ p3: kotlin.reflect.KClass<*> = ..., /*3*/ p4: kotlin.IntArray = ..., /*4*/ p5: kotlin.Array = ..., /*5*/ p6: kotlin.Array> = ...) public final val p1: kotlin.Int public final val p2: kotlin.String diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/annotationAsArgument.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/annotationAsArgument.txt index a751fb9601c..2a2ac957553 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/annotationAsArgument.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/annotationAsArgument.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ arg: kotlin.reflect.KClass<*> = ..., /*1*/ x: kotlin.Int = ..., /*2*/ b: B) public final val arg: kotlin.reflect.KClass<*> public final val b: B @@ -10,7 +10,7 @@ public final class A : kotlin.Annotation { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -public final class B : kotlin.Annotation { +public final annotation class B : kotlin.Annotation { public constructor B(/*0*/ arg: kotlin.reflect.KClass<*> = ..., /*1*/ y: kotlin.Int = ...) public final val arg: kotlin.reflect.KClass<*> public final val y: kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/arg.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/arg.txt index 51827e7fb76..85a6ef7e3ff 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/arg.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/arg.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ arg: kotlin.reflect.KClass<*>) public final val arg: kotlin.reflect.KClass<*> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argAndOtherDefault.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argAndOtherDefault.txt index a077648d781..9fc0cabdc16 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argAndOtherDefault.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argAndOtherDefault.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ arg: kotlin.reflect.KClass<*>, /*1*/ x: kotlin.Int = ...) public final val arg: kotlin.reflect.KClass<*> public final val x: kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argArray.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argArray.txt index 99afc92ef0f..dfb6d794e8b 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argArray.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argArray.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ arg: kotlin.Array>) public final val arg: kotlin.Array> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefault.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefault.txt index e6c1273acdc..1f297fc241b 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefault.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefault.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ arg: kotlin.reflect.KClass<*> = ...) public final val arg: kotlin.reflect.KClass<*> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefaultAndOther.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefaultAndOther.txt index 26441d98718..d856a31f3ab 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefaultAndOther.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/argWithDefaultAndOther.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ arg: kotlin.reflect.KClass<*> = ..., /*1*/ x: kotlin.Int) public final val arg: kotlin.reflect.KClass<*> public final val x: kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/twoArgs.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/twoArgs.txt index 50118c5fbe7..e595cae8457 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/twoArgs.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/twoArgs.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ arg1: kotlin.reflect.KClass<*>, /*1*/ arg2: kotlin.reflect.KClass<*>) public final val arg1: kotlin.reflect.KClass<*> public final val arg2: kotlin.reflect.KClass<*> diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/value.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/value.txt index 42ad6acc304..c2e2e1ae880 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/value.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/value.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ value: kotlin.reflect.KClass<*>) public final val value: kotlin.reflect.KClass<*> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueAndOtherDefault.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueAndOtherDefault.txt index 63a195f6efa..34c32e227f1 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueAndOtherDefault.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueAndOtherDefault.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ value: kotlin.reflect.KClass<*>, /*1*/ x: kotlin.Int = ...) public final val value: kotlin.reflect.KClass<*> public final val x: kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueArray.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueArray.txt index dcfc7a3ed1e..15cb385410d 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueArray.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueArray.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ vararg value: kotlin.reflect.KClass<*> /*kotlin.Array>*/) public final val value: kotlin.Array> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefault.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefault.txt index 45da90e22e2..0cb49513b5a 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefault.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefault.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ value: kotlin.reflect.KClass<*> = ...) public final val value: kotlin.reflect.KClass<*> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefaultAndOther.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefaultAndOther.txt index 0685cb796a2..1b15d7d8dca 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefaultAndOther.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/javaAnnotationsWithKClassParameter/valueWithDefaultAndOther.txt @@ -1,6 +1,6 @@ package -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ value: kotlin.reflect.KClass<*> = ..., /*1*/ x: kotlin.Int) public final val value: kotlin.reflect.KClass<*> public final val x: kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.txt index c6b817a9a80..80fecde8f53 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.txt @@ -7,7 +7,7 @@ public open class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann1 : kotlin.Annotation { +public final annotation class Ann1 : kotlin.Annotation { public constructor Ann1(/*0*/ arg: kotlin.Array>) public final val arg: kotlin.Array> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -15,7 +15,7 @@ public open class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann2 : kotlin.Annotation { +public final annotation class Ann2 : kotlin.Annotation { public constructor Ann2(/*0*/ arg: kotlin.Array>) public final val arg: kotlin.Array> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.txt index 791fe2fdf68..ca69686782a 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.txt @@ -7,7 +7,7 @@ public open class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann1 : kotlin.Annotation { +public final annotation class Ann1 : kotlin.Annotation { public constructor Ann1(/*0*/ arg: kotlin.Array>) public final val arg: kotlin.Array> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -15,7 +15,7 @@ public open class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann2 : kotlin.Annotation { +public final annotation class Ann2 : kotlin.Annotation { public constructor Ann2(/*0*/ arg: kotlin.Array>) public final val arg: kotlin.Array> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotation.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotation.txt index 0ffef520e91..e3ebbb3a743 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotation.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotation.txt @@ -16,7 +16,7 @@ public final class A2 { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann1 : kotlin.Annotation { +public final annotation class Ann1 : kotlin.Annotation { public constructor Ann1(/*0*/ arg: kotlin.reflect.KClass<*>) public final val arg: kotlin.reflect.KClass<*> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -24,7 +24,7 @@ public final class A2 { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann2 : kotlin.Annotation { +public final annotation class Ann2 : kotlin.Annotation { public constructor Ann2(/*0*/ vararg arg: kotlin.reflect.KClass<*> /*kotlin.Array>*/) public final val arg: kotlin.Array> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -32,7 +32,7 @@ public final class A2 { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann3 : kotlin.Annotation { +public final annotation class Ann3 : kotlin.Annotation { public constructor Ann3(/*0*/ arg: kotlin.Array>) public final val arg: kotlin.Array> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.txt index 4359fde8b1f..41dbc8f7eaf 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.txt @@ -7,7 +7,7 @@ public open class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann1 : kotlin.Annotation { +public final annotation class Ann1 : kotlin.Annotation { public constructor Ann1(/*0*/ arg: kotlin.reflect.KClass) public final val arg: kotlin.reflect.KClass public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -15,7 +15,7 @@ public open class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann2 : kotlin.Annotation { +public final annotation class Ann2 : kotlin.Annotation { public constructor Ann2(/*0*/ arg: kotlin.reflect.KClass) public final val arg: kotlin.reflect.KClass public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.txt index 940877289c3..9986ae110ea 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.txt @@ -7,7 +7,7 @@ public open class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann1 : kotlin.Annotation { +public final annotation class Ann1 : kotlin.Annotation { public constructor Ann1(/*0*/ arg: kotlin.reflect.KClass) public final val arg: kotlin.reflect.KClass public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -15,7 +15,7 @@ public open class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann2 : kotlin.Annotation { +public final annotation class Ann2 : kotlin.Annotation { public constructor Ann2(/*0*/ arg: kotlin.reflect.KClass) public final val arg: kotlin.reflect.KClass public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.txt index b9360e732bc..b800290410b 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.txt @@ -7,7 +7,7 @@ public open class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann1 : kotlin.Annotation { +public final annotation class Ann1 : kotlin.Annotation { public constructor Ann1(/*0*/ arg: kotlin.reflect.KClass) public final val arg: kotlin.reflect.KClass public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -15,7 +15,7 @@ public open class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann2 : kotlin.Annotation { +public final annotation class Ann2 : kotlin.Annotation { public constructor Ann2(/*0*/ arg: kotlin.reflect.KClass) public final val arg: kotlin.reflect.KClass public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassOutArrayInAnnotationsOutVariance.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassOutArrayInAnnotationsOutVariance.txt index ae3cd6c294e..b26ec046b74 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassOutArrayInAnnotationsOutVariance.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassOutArrayInAnnotationsOutVariance.txt @@ -7,7 +7,7 @@ public open class A { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.annotation.annotation() public final class Ann1 : kotlin.Annotation { +public final annotation class Ann1 : kotlin.Annotation { public constructor Ann1(/*0*/ arg: kotlin.Array>) public final val arg: kotlin.Array> public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/kotlinAnnotation.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/kotlinAnnotation.txt index 5727222684c..2c05595e472 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/kotlinAnnotation.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/kotlinAnnotation.txt @@ -4,7 +4,7 @@ package @Ann(value = "b", x = 2, y = 2.0.toDouble()) public fun foo2(): kotlin.Unit @Ann(value = "c", x = 3, y = 2.0.toDouble()) public fun foo3(): kotlin.Unit -@kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ x: kotlin.Int, /*1*/ value: kotlin.String, /*2*/ y: kotlin.Double) public final val value: kotlin.String public final val x: kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.txt index ed06fa75065..716fba1286a 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.txt @@ -2,7 +2,7 @@ package @A(a = false, b = 1.0.toDouble(), x = false) public fun foo1(): kotlin.Unit -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Double, /*2*/ x: kotlin.Boolean) public final val a: kotlin.Int public final val b: kotlin.Double diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.txt index 73b46c3c111..471a49e45c8 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.txt @@ -3,7 +3,7 @@ package @A(a = false, b = 1.0.toDouble(), x = false) public fun foo1(): kotlin.Unit @A(a = 2.0.toDouble(), b = 2.0.toDouble(), x = true) public fun foo2(): kotlin.Unit -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Double, /*2*/ x: kotlin.Boolean) public final val a: kotlin.Int public final val b: kotlin.Double diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withValue.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withValue.txt index 16eda1f6568..54418dd7d08 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withValue.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withValue.txt @@ -5,7 +5,7 @@ package @A(a = 4, b = 3.0.toDouble(), value = "v2", x = true) public fun foo3(): kotlin.Unit @A(a = 4, b = 3.0.toDouble(), value = "v2", x = true) public fun foo4(): kotlin.Unit -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ value: kotlin.String, /*1*/ a: kotlin.Int, /*2*/ b: kotlin.Double, /*3*/ x: kotlin.Boolean) public final val a: kotlin.Int public final val b: kotlin.Double diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withoutValue.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withoutValue.txt index a6af04de796..fedd71ed81f 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withoutValue.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/withoutValue.txt @@ -4,7 +4,7 @@ package @A(a = 2, b = 2.0.toDouble(), x = true) public fun foo2(): kotlin.Unit @A(a = 4, b = 3.0.toDouble(), x = true) public fun foo3(): kotlin.Unit -public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { public constructor A(/*0*/ a: kotlin.Int, /*1*/ b: kotlin.Double, /*2*/ x: kotlin.Boolean) public final val a: kotlin.Int public final val b: kotlin.Double diff --git a/compiler/testData/diagnostics/testsWithStdLib/annotations/qualifiedCallValue.txt b/compiler/testData/diagnostics/testsWithStdLib/annotations/qualifiedCallValue.txt index 39210b0b5a3..bbcd898883f 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/annotations/qualifiedCallValue.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/annotations/qualifiedCallValue.txt @@ -13,7 +13,7 @@ package a { public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String - @kotlin.annotation.annotation() public final class IAnn : kotlin.Annotation { + public final annotation class IAnn : kotlin.Annotation { public constructor IAnn() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int @@ -21,7 +21,7 @@ package a { } } - @kotlin.annotation.annotation() public final class ann1 : kotlin.Annotation { + public final annotation class ann1 : kotlin.Annotation { public constructor ann1(/*0*/ p: kotlin.Deprecated = ...) public final val p: kotlin.Deprecated public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -29,7 +29,7 @@ package a { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class ann2 : kotlin.Annotation { + public final annotation class ann2 : kotlin.Annotation { public constructor ann2(/*0*/ p: a.b.c.ann1 = ...) public final val p: a.b.c.ann1 public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean @@ -37,7 +37,7 @@ package a { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class ann3 : kotlin.Annotation { + public final annotation class ann3 : kotlin.Annotation { public constructor ann3(/*0*/ p: a.b.c.A.IAnn = ..., /*1*/ p2: a.b.c.A.IAnn = ...) public final val p: a.b.c.A.IAnn public final val p2: a.b.c.A.IAnn @@ -46,7 +46,7 @@ package a { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } - @kotlin.annotation.annotation() public final class annArray : kotlin.Annotation { + public final annotation class annArray : kotlin.Annotation { public constructor annArray(/*0*/ p: kotlin.Array = ...) public final val p: kotlin.Array public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean diff --git a/compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.txt b/compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.txt index aa6c6146023..8ef3e5656f0 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/functionLiterals/pseudocodeMemoryOverhead.txt @@ -33,7 +33,7 @@ public final class BigInteger { public final fun xor(/*0*/ o: BigInteger): BigInteger } -@kotlin.data() private final class BinaryOperationKey { +private final data class BinaryOperationKey { public constructor BinaryOperationKey(/*0*/ f: CompileTimeType, /*1*/ g: CompileTimeType, /*2*/ functionName: kotlin.String) public final val f: CompileTimeType public final val functionName: kotlin.String @@ -54,7 +54,7 @@ private final class CompileTimeType { public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } -@kotlin.data() private final class UnaryOperationKey { +private final data class UnaryOperationKey { public constructor UnaryOperationKey(/*0*/ f: CompileTimeType, /*1*/ functionName: kotlin.String) public final val f: CompileTimeType public final val functionName: kotlin.String diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt index e892898c94a..b904554b4f7 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.kt @@ -11,4 +11,11 @@ class D fun test1(a: A, b: B, c: C) { assertEquals1(a, b) assertEquals1(b, c) +} + +@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE") +public fun <@kotlin.internal.OnlyInputTypes T> expect1(expected: T, block: () -> T) {} + +fun test() { + expect1(2) { byteArrayOf(1, 2, 3).indexOf(3) } } \ No newline at end of file diff --git a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.txt b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.txt index ab366501ef7..325b223d2a9 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.txt @@ -1,6 +1,8 @@ package @kotlin.Suppress(names = {"INVISIBLE_MEMBER", "INVISIBLE_REFERENCE"}) public fun assertEquals1(/*0*/ t1: T, /*1*/ t2: T): kotlin.Unit +@kotlin.Suppress(names = {"INVISIBLE_MEMBER", "INVISIBLE_REFERENCE"}) public fun expect1(/*0*/ expected: T, /*1*/ block: () -> T): kotlin.Unit +public fun test(): kotlin.Unit public fun test1(/*0*/ a: A, /*1*/ b: B, /*2*/ c: C): kotlin.Unit public open class A { diff --git a/compiler/testData/diagnostics/testsWithStdLib/native/abstract.txt b/compiler/testData/diagnostics/testsWithStdLib/native/abstract.txt index 94b7771bfa3..dd89ae466ae 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/native/abstract.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/native/abstract.txt @@ -5,7 +5,7 @@ public fun test(): kotlin.Unit public abstract class C { public constructor C() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.external() public abstract fun foo(): kotlin.Unit + public abstract external fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/testsWithStdLib/native/body.txt b/compiler/testData/diagnostics/testsWithStdLib/native/body.txt index 5d23faa6c5f..90fc66404fc 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/native/body.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/native/body.txt @@ -1,19 +1,19 @@ package -@kotlin.external() public fun foo(): kotlin.Unit +public external fun foo(): kotlin.Unit public fun test(): kotlin.Unit public final class C { public constructor C() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.external() public final fun foo(): kotlin.Unit + public final external fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String public companion object Companion { private constructor Companion() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.external() public final fun foo(): kotlin.Unit + public final external fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } @@ -22,7 +22,7 @@ public final class C { public object O { private constructor O() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.external() public final fun foo(): kotlin.Unit + public final external fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/testsWithStdLib/native/constructor.txt b/compiler/testData/diagnostics/testsWithStdLib/native/constructor.txt index 56486e901f1..9ec505f92f4 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/native/constructor.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/native/constructor.txt @@ -1,14 +1,14 @@ package public final class A { - @kotlin.external() public constructor A() - @kotlin.external() public constructor A(/*0*/ x: kotlin.Int) + public constructor A() + public constructor A(/*0*/ x: kotlin.Int) public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String public final inner class B { - @kotlin.external() public constructor B() + public constructor B() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String @@ -16,7 +16,7 @@ public final class A { } public final class C { - @kotlin.external() public constructor C() + public constructor C() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String diff --git a/compiler/testData/diagnostics/testsWithStdLib/native/inline.txt b/compiler/testData/diagnostics/testsWithStdLib/native/inline.txt index 8499d349a06..799a1d545b4 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/native/inline.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/native/inline.txt @@ -5,7 +5,7 @@ public fun test(): kotlin.Unit public abstract class C { public constructor C() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.inline() @kotlin.external() public final fun foo(): kotlin.Unit + public final external inline fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/testsWithStdLib/native/noBody.txt b/compiler/testData/diagnostics/testsWithStdLib/native/noBody.txt index 5d23faa6c5f..90fc66404fc 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/native/noBody.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/native/noBody.txt @@ -1,19 +1,19 @@ package -@kotlin.external() public fun foo(): kotlin.Unit +public external fun foo(): kotlin.Unit public fun test(): kotlin.Unit public final class C { public constructor C() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.external() public final fun foo(): kotlin.Unit + public final external fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String public companion object Companion { private constructor Companion() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.external() public final fun foo(): kotlin.Unit + public final external fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } @@ -22,7 +22,7 @@ public final class C { public object O { private constructor O() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.external() public final fun foo(): kotlin.Unit + public final external fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/testsWithStdLib/native/override.txt b/compiler/testData/diagnostics/testsWithStdLib/native/override.txt index 47538f8dbdf..87385bcc0fa 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/native/override.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/native/override.txt @@ -10,7 +10,7 @@ public interface Base { public final class Derived : Base { public constructor Derived() public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.external() public open override /*1*/ fun foo(): kotlin.Unit + public open external override /*1*/ fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/testsWithStdLib/native/reified.txt b/compiler/testData/diagnostics/testsWithStdLib/native/reified.txt index b19af25dc7b..5764bb46634 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/native/reified.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/native/reified.txt @@ -1,4 +1,4 @@ package -@kotlin.inline() @kotlin.external() public fun bar(): kotlin.Unit -@kotlin.external() public fun foo(): kotlin.Unit +public external inline fun bar(): kotlin.Unit +public external fun foo(): kotlin.Unit diff --git a/compiler/testData/diagnostics/testsWithStdLib/native/trait.txt b/compiler/testData/diagnostics/testsWithStdLib/native/trait.txt index f8b8812bbc6..1f68c5c884c 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/native/trait.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/native/trait.txt @@ -1,17 +1,17 @@ package public interface Tr { - @kotlin.external() public open fun bar(): kotlin.Unit + public open external fun bar(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.external() public abstract fun foo(): kotlin.Unit + public abstract external fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String public companion object Companion { private constructor Companion() - @kotlin.external() public final fun bar(): kotlin.Unit + public final external fun bar(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean - @kotlin.external() public final fun foo(): kotlin.Unit + public final external fun foo(): kotlin.Unit public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String } diff --git a/compiler/testData/diagnostics/testsWithStdLib/regression/ea66827_dataClassWrongToString.txt b/compiler/testData/diagnostics/testsWithStdLib/regression/ea66827_dataClassWrongToString.txt index 00a61a89dd5..13973ae6dc5 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/regression/ea66827_dataClassWrongToString.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/regression/ea66827_dataClassWrongToString.txt @@ -1,6 +1,6 @@ package -@kotlin.data() public final class A { +public final data class A { public constructor A(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public final operator /*synthesized*/ fun component1(): kotlin.Int diff --git a/compiler/testData/diagnostics/testsWithStdLib/reified/arrayConstruction.txt b/compiler/testData/diagnostics/testsWithStdLib/reified/arrayConstruction.txt index 6229c5163e5..41183428008 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/reified/arrayConstruction.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/reified/arrayConstruction.txt @@ -4,7 +4,7 @@ public fun fail1(): kotlin.Array public fun fail2(): kotlin.Array public fun fail3(/*0*/ block: () -> T): kotlin.Pair, kotlin.Array> public fun ok1(/*0*/ block: () -> kotlin.Array): kotlin.Array -@kotlin.inline() public fun ok2(): kotlin.Array +public inline fun ok2(): kotlin.Array public fun ok3(/*0*/ block: () -> kotlin.Array): kotlin.Array -@kotlin.inline() public fun ok4(): kotlin.Array -@kotlin.inline() public fun ok5(/*0*/ block: () -> T): kotlin.Pair, kotlin.Array> +public inline fun ok4(): kotlin.Array +public inline fun ok5(/*0*/ block: () -> T): kotlin.Pair, kotlin.Array> diff --git a/compiler/testData/diagnostics/testsWithStdLib/reified/arrayOfNullsReified.txt b/compiler/testData/diagnostics/testsWithStdLib/reified/arrayOfNullsReified.txt index 2cd3e58a4c8..38bc858eede 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/reified/arrayOfNullsReified.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/reified/arrayOfNullsReified.txt @@ -1,5 +1,5 @@ package -@kotlin.inline() public fun bar(): kotlin.Unit +public inline fun bar(): kotlin.Unit public fun baz(): kotlin.Unit public fun foo(): kotlin.Unit diff --git a/compiler/testData/diagnostics/testsWithStdLib/reified/reifiedNothingSubstitution.txt b/compiler/testData/diagnostics/testsWithStdLib/reified/reifiedNothingSubstitution.txt index d030f366a88..06f92867336 100644 --- a/compiler/testData/diagnostics/testsWithStdLib/reified/reifiedNothingSubstitution.txt +++ b/compiler/testData/diagnostics/testsWithStdLib/reified/reifiedNothingSubstitution.txt @@ -1,4 +1,4 @@ package public fun box(): kotlin.Unit -@kotlin.inline() public fun foo(/*0*/ block: () -> T): kotlin.String +public inline fun foo(/*0*/ block: () -> T): kotlin.String diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedAnnotation.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedAnnotation.txt index 2c64eea7819..8759d50a6a7 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedAnnotation.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedAnnotation.txt @@ -1,5 +1,5 @@ package test -@test.AnnotatedAnnotation() public final class AnnotatedAnnotation : kotlin.Annotation { +@test.AnnotatedAnnotation() public final annotation class AnnotatedAnnotation : kotlin.Annotation { public constructor AnnotatedAnnotation() } diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.txt index 433ab9a2dfe..12ddc891fb8 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedConstructor.txt @@ -3,7 +3,7 @@ package test public open class AnnotatedConstructor { @test.AnnotatedConstructor.Anno(value = "constructor") public constructor AnnotatedConstructor() - public final class Anno : kotlin.Annotation { + public final annotation class Anno : kotlin.Annotation { public constructor Anno(/*0*/ value: kotlin.String) public final val value: kotlin.String } diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedField.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedField.txt index 35407d45f95..c7af5b681a1 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedField.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedField.txt @@ -4,7 +4,7 @@ public open class AnnotatedField { public constructor AnnotatedField() @test.AnnotatedField.Anno(value = "member") public final val y: kotlin.Int = 0 - public final class Anno : kotlin.Annotation { + public final annotation class Anno : kotlin.Annotation { public constructor Anno(/*0*/ value: kotlin.String) public final val value: kotlin.String } diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.txt index f828381c072..973a6572416 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.txt @@ -4,7 +4,7 @@ public open class AnnotatedMethod { public constructor AnnotatedMethod() @test.AnnotatedMethod.Anno(value = 42) public open fun f(): kotlin.Unit - public final class Anno : kotlin.Annotation { + public final annotation class Anno : kotlin.Annotation { public constructor Anno(/*0*/ value: kotlin.Int) public final val value: kotlin.Int } diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.txt index bd2ad379867..c51425416b0 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.txt @@ -4,7 +4,7 @@ public open class AnnotatedValueParameter { public constructor AnnotatedValueParameter() public open fun f(/*0*/ @test.AnnotatedValueParameter.Anno(value = "non-empty") p0: kotlin.(Mutable)List!): kotlin.Unit - public final class Anno : kotlin.Annotation { + public final annotation class Anno : kotlin.Annotation { public constructor Anno(/*0*/ value: kotlin.String) public final val value: kotlin.String } diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotationInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotationInParam.txt index 201f0b864ed..e3fc987f534 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotationInParam.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotationInParam.txt @@ -14,33 +14,33 @@ public interface AnnotationInParam { public constructor C() } - public final class MyAnnotation : kotlin.Annotation { + public final annotation class MyAnnotation : kotlin.Annotation { public constructor MyAnnotation(/*0*/ value: kotlin.String) public final val value: kotlin.String } - public final class MyAnnotation2 : kotlin.Annotation { + public final annotation class MyAnnotation2 : kotlin.Annotation { public constructor MyAnnotation2(/*0*/ vararg value: kotlin.String /*kotlin.Array*/) public final val value: kotlin.Array } - public final class MyAnnotation3 : kotlin.Annotation { + public final annotation class MyAnnotation3 : kotlin.Annotation { public constructor MyAnnotation3(/*0*/ first: kotlin.String, /*1*/ second: kotlin.String) public final val first: kotlin.String public final val second: kotlin.String } - public final class MyAnnotationWithParam : kotlin.Annotation { + public final annotation class MyAnnotationWithParam : kotlin.Annotation { public constructor MyAnnotationWithParam(/*0*/ value: test.AnnotationInParam.MyAnnotation) public final val value: test.AnnotationInParam.MyAnnotation } - public final class MyAnnotationWithParam2 : kotlin.Annotation { + public final annotation class MyAnnotationWithParam2 : kotlin.Annotation { public constructor MyAnnotationWithParam2(/*0*/ value: test.AnnotationInParam.MyAnnotation2) public final val value: test.AnnotationInParam.MyAnnotation2 } - public final class MyAnnotationWithParam3 : kotlin.Annotation { + public final annotation class MyAnnotationWithParam3 : kotlin.Annotation { public constructor MyAnnotationWithParam3(/*0*/ value: test.AnnotationInParam.MyAnnotation3) public final val value: test.AnnotationInParam.MyAnnotation3 } diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotationRetentions.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotationRetentions.txt index 20d481ac8bd..808191ab40d 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotationRetentions.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotationRetentions.txt @@ -3,7 +3,7 @@ package test public open class AnnotationRetentions { public constructor AnnotationRetentions() - public final class BaseAnnotation : kotlin.Annotation { + public final annotation class BaseAnnotation : kotlin.Annotation { public constructor BaseAnnotation() } @@ -11,7 +11,7 @@ public open class AnnotationRetentions { public/*package*/ constructor BaseClass() } - @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final class BinaryAnnotation : kotlin.Annotation { + @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) public final annotation class BinaryAnnotation : kotlin.Annotation { public constructor BinaryAnnotation() } @@ -19,7 +19,7 @@ public open class AnnotationRetentions { public/*package*/ constructor BinaryClass() } - @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final class RuntimeAnnotation : kotlin.Annotation { + @kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final annotation class RuntimeAnnotation : kotlin.Annotation { public constructor RuntimeAnnotation() } @@ -27,7 +27,7 @@ public open class AnnotationRetentions { public/*package*/ constructor RuntimeClass() } - @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final class SourceAnnotation : kotlin.Annotation { + @kotlin.annotation.Retention(value = AnnotationRetention.SOURCE) public final annotation class SourceAnnotation : kotlin.Annotation { public constructor SourceAnnotation() } diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotationTargets.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotationTargets.txt index b50c39fde64..cc18019c5a7 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotationTargets.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotationTargets.txt @@ -3,43 +3,43 @@ package test public open class AnnotationTargets { public constructor AnnotationTargets() - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) public final class annotation : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) public final annotation class annotation : kotlin.Annotation { public constructor annotation() } - public final class base : kotlin.Annotation { + public final annotation class base : kotlin.Annotation { public constructor base() } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CONSTRUCTOR}) public final class constructor : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CONSTRUCTOR}) public final annotation class constructor : kotlin.Annotation { public constructor constructor() } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FIELD}) public final class field : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FIELD}) public final annotation class field : kotlin.Annotation { public constructor field() } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.LOCAL_VARIABLE}) public final class local : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.LOCAL_VARIABLE}) public final annotation class local : kotlin.Annotation { public constructor local() } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER}) public final class method : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER}) public final annotation class method : kotlin.Annotation { public constructor method() } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FIELD}) public final class multiple : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY_GETTER, AnnotationTarget.PROPERTY_SETTER, AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FIELD}) public final annotation class multiple : kotlin.Annotation { public constructor multiple() } - @kotlin.annotation.Target(allowedTargets = {}) public final class packag : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {}) public final annotation class packag : kotlin.Annotation { public constructor packag() } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) public final class parameter : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) public final annotation class parameter : kotlin.Annotation { public constructor parameter() } - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE}) public final class type : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FILE}) public final annotation class type : kotlin.Annotation { public constructor type() } } diff --git a/compiler/testData/loadJava/compiledJava/annotations/ArithmeticExpressionInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/ArithmeticExpressionInParam.txt index 924c5bed2c8..cf986cc9829 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/ArithmeticExpressionInParam.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/ArithmeticExpressionInParam.txt @@ -3,7 +3,7 @@ package test public open class ArithmeticExpressionInParam { public constructor ArithmeticExpressionInParam() - public final class Anno : kotlin.Annotation { + public final annotation class Anno : kotlin.Annotation { public constructor Anno(/*0*/ value: kotlin.Int) public final val value: kotlin.Int } diff --git a/compiler/testData/loadJava/compiledJava/annotations/ArrayOfEnumInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/ArrayOfEnumInParam.txt index 372752d056b..21ec8703aa2 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/ArrayOfEnumInParam.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/ArrayOfEnumInParam.txt @@ -2,7 +2,7 @@ package test public interface ArrayOfEnumInParam { - @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FIELD, AnnotationTarget.CONSTRUCTOR}) public final class targetAnnotation : kotlin.Annotation { + @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FIELD, AnnotationTarget.CONSTRUCTOR}) public final annotation class targetAnnotation : kotlin.Annotation { public constructor targetAnnotation(/*0*/ value: kotlin.String) public final val value: kotlin.String } diff --git a/compiler/testData/loadJava/compiledJava/annotations/ArrayOfStringInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/ArrayOfStringInParam.txt index 820ccfaf8d6..9ea536f2016 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/ArrayOfStringInParam.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/ArrayOfStringInParam.txt @@ -6,7 +6,7 @@ public interface ArrayOfStringInParam { public constructor A() } - public final class MyAnnotation : kotlin.Annotation { + public final annotation class MyAnnotation : kotlin.Annotation { public constructor MyAnnotation(/*0*/ vararg value: kotlin.String /*kotlin.Array*/) public final val value: kotlin.Array } diff --git a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectArrayInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectArrayInParam.txt index 7a99ff36016..0de08fbe69c 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectArrayInParam.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectArrayInParam.txt @@ -3,7 +3,7 @@ package test public open class ClassObjectArrayInParam { public constructor ClassObjectArrayInParam() - public final class Anno : kotlin.Annotation { + public final annotation class Anno : kotlin.Annotation { public constructor Anno(/*0*/ vararg value: kotlin.reflect.KClass<*> /*kotlin.Array>*/) public final val value: kotlin.Array> } diff --git a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParam.txt index 54cf47aaf90..4f80c232a1b 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParam.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParam.txt @@ -3,7 +3,7 @@ package test public open class ClassObjectInParam { public constructor ClassObjectInParam() - public final class Anno : kotlin.Annotation { + public final annotation class Anno : kotlin.Annotation { public constructor Anno(/*0*/ value: kotlin.reflect.KClass<*>) public final val value: kotlin.reflect.KClass<*> } diff --git a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamRaw.txt b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamRaw.txt index 55ad93e9c6b..9e8d6f2016b 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamRaw.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamRaw.txt @@ -3,7 +3,7 @@ package test public open class ClassObjectInParamRaw { public constructor ClassObjectInParamRaw() - public final class Anno : kotlin.Annotation { + public final annotation class Anno : kotlin.Annotation { public constructor Anno(/*0*/ value: kotlin.reflect.KClass<*>, /*1*/ arg: kotlin.Array>) public final val arg: kotlin.Array> public final val value: kotlin.reflect.KClass<*> diff --git a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamVariance.txt b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamVariance.txt index c728d690cf0..9b7a5882a91 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamVariance.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/ClassObjectInParamVariance.txt @@ -3,7 +3,7 @@ package test public open class ClassObjectInParamVariance { public constructor ClassObjectInParamVariance() - public final class Anno : kotlin.Annotation { + public final annotation class Anno : kotlin.Annotation { public constructor Anno(/*0*/ arg1: kotlin.reflect.KClass, /*1*/ arg2: kotlin.reflect.KClass, /*2*/ arg3: kotlin.Array>, /*3*/ arg4: kotlin.Array>, /*4*/ arg5: kotlin.Array!>>, /*5*/ arg6: kotlin.Array!>>, /*6*/ arg7: kotlin.Array!>>, /*7*/ arg8: kotlin.Array!>>) public final val arg1: kotlin.reflect.KClass public final val arg2: kotlin.reflect.KClass diff --git a/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotation.txt b/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotation.txt index b73bf2570bc..8741875176c 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotation.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotation.txt @@ -2,7 +2,7 @@ package test public interface CustomAnnotation { - public final class MyAnnotation : kotlin.Annotation { + public final annotation class MyAnnotation : kotlin.Annotation { public constructor MyAnnotation(/*0*/ value: test.CustomAnnotation.MyEnum) public final val value: test.CustomAnnotation.MyEnum } diff --git a/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotationWithDefaultParameter.txt b/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotationWithDefaultParameter.txt index f43afe500c6..6802e51f42d 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotationWithDefaultParameter.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/CustomAnnotationWithDefaultParameter.txt @@ -2,7 +2,7 @@ package test public interface CustomAnnotationWithDefaultParameter { - public final class MyAnnotation : kotlin.Annotation { + public final annotation class MyAnnotation : kotlin.Annotation { public constructor MyAnnotation(/*0*/ first: kotlin.String, /*1*/ second: kotlin.String = ...) public final val first: kotlin.String public final val second: kotlin.String diff --git a/compiler/testData/loadJava/compiledJava/annotations/EmptyArrayInParam.txt b/compiler/testData/loadJava/compiledJava/annotations/EmptyArrayInParam.txt index 2470086a033..1a655bb6220 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/EmptyArrayInParam.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/EmptyArrayInParam.txt @@ -6,7 +6,7 @@ public interface EmptyArrayInParam { public constructor A() } - public final class MyAnnotation : kotlin.Annotation { + public final annotation class MyAnnotation : kotlin.Annotation { public constructor MyAnnotation(/*0*/ vararg value: kotlin.String /*kotlin.Array*/) public final val value: kotlin.Array } diff --git a/compiler/testData/loadJava/compiledJava/annotations/EnumArgumentWithCustomToString.txt b/compiler/testData/loadJava/compiledJava/annotations/EnumArgumentWithCustomToString.txt index 35f026542d3..f7341c90c58 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/EnumArgumentWithCustomToString.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/EnumArgumentWithCustomToString.txt @@ -19,12 +19,12 @@ public open class EnumArgumentWithCustomToString { @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } - public final class EnumAnno : kotlin.Annotation { + public final annotation class EnumAnno : kotlin.Annotation { public constructor EnumAnno(/*0*/ value: test.EnumArgumentWithCustomToString.E) public final val value: test.EnumArgumentWithCustomToString.E } - public final class EnumArrayAnno : kotlin.Annotation { + public final annotation class EnumArrayAnno : kotlin.Annotation { public constructor EnumArrayAnno(/*0*/ vararg value: test.EnumArgumentWithCustomToString.E /*kotlin.Array*/) public final val value: kotlin.Array } diff --git a/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.txt b/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.txt index 865340d7871..9e317ff1289 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.txt @@ -10,7 +10,7 @@ public final enum class EnumConstructorParameter : kotlin.Enum { @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } -@kotlin.annotation.annotation() public final class EnumOption : kotlin.Annotation { +public final annotation class EnumOption : kotlin.Annotation { /*primary*/ public constructor EnumOption(/*0*/ option: test.E) public final val option: test.E public final fun (): test.E } -@kotlin.annotation.annotation() public final class OptionGroups : kotlin.Annotation { +public final annotation class OptionGroups : kotlin.Annotation { /*primary*/ public constructor OptionGroups(/*0*/ o1: test.StringOptions, /*1*/ o2: test.EnumOption) public final val o1: test.StringOptions public final fun (): test.StringOptions @@ -36,7 +36,7 @@ public final enum class E : kotlin.Enum { public final fun (): test.EnumOption } -@kotlin.annotation.annotation() public final class StringOptions : kotlin.Annotation { +public final annotation class StringOptions : kotlin.Annotation { /*primary*/ public constructor StringOptions(/*0*/ vararg option: kotlin.String /*kotlin.Array*/) public final val option: kotlin.Array public final fun (): kotlin.Array diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/EnumArgumentWithCustomToString.txt b/compiler/testData/loadJava/compiledKotlin/annotations/EnumArgumentWithCustomToString.txt index 1b53c8751c6..e0451bf9dca 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/EnumArgumentWithCustomToString.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/EnumArgumentWithCustomToString.txt @@ -18,7 +18,7 @@ public final enum class E : kotlin.Enum { @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } -@kotlin.annotation.annotation() public final class EnumAnno : kotlin.Annotation { +public final annotation class EnumAnno : kotlin.Annotation { /*primary*/ public constructor EnumAnno(/*0*/ value: test.E) public final val value: test.E public final fun (): test.E @@ -29,7 +29,7 @@ public final class EnumArgumentWithCustomToString { @test.EnumAnno(value = E.CAKE) @test.EnumArrayAnno(value = {E.CAKE, E.CAKE}) public final fun annotated(): kotlin.Unit } -@kotlin.annotation.annotation() public final class EnumArrayAnno : kotlin.Annotation { +public final annotation class EnumArrayAnno : kotlin.Annotation { /*primary*/ public constructor EnumArrayAnno(/*0*/ vararg value: test.E /*kotlin.Array*/) public final val value: kotlin.Array public final fun (): kotlin.Array diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/MultiDimensionalArrayMethod.txt b/compiler/testData/loadJava/compiledKotlin/annotations/MultiDimensionalArrayMethod.txt index f067e97f1b3..f0bb72e79f6 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/MultiDimensionalArrayMethod.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/MultiDimensionalArrayMethod.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno(/*0*/ s: kotlin.String) public final val s: kotlin.String public final fun (): kotlin.String diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/SimpleAnnotation.txt b/compiler/testData/loadJava/compiledKotlin/annotations/SimpleAnnotation.txt index 87a69c07e09..99a705e74ff 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/SimpleAnnotation.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/SimpleAnnotation.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.annotation() public final class SimpleAnnotation : kotlin.Annotation { +public final annotation class SimpleAnnotation : kotlin.Annotation { /*primary*/ public constructor SimpleAnnotation() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.txt b/compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.txt index ffab67ff27d..27e9895cd19 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/TargetedAnnotation.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) @kotlin.annotation.annotation() public final class TargetedAnnotation : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class TargetedAnnotation : kotlin.Annotation { /*primary*/ public constructor TargetedAnnotation() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/ClassObjectPropertyField.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/ClassObjectPropertyField.txt index 318775598a3..0ac835afc78 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/ClassObjectPropertyField.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/ClassObjectPropertyField.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Constructor.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Constructor.txt index 240c15916de..60cd1131d46 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Constructor.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Constructor.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno(/*0*/ value: kotlin.String) public final val value: kotlin.String public final fun (): kotlin.String diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/DelegatedProperty.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/DelegatedProperty.txt index d7a988f36bb..580c423898b 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/DelegatedProperty.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/DelegatedProperty.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/EnumArgument.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/EnumArgument.txt index 74840bb97e5..6bbf764a74c 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/EnumArgument.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/EnumArgument.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno(/*0*/ t: java.lang.annotation.ElementType) public final val t: java.lang.annotation.ElementType public final fun (): java.lang.annotation.ElementType diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Function.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Function.txt index 91e12bc58eb..fa4aeeccf08 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Function.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Function.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Getter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Getter.txt index f9a2d85afbd..018f255d996 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Getter.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Getter.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/PropertyField.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/PropertyField.txt index e06f0cd9701..ee18c636f85 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/PropertyField.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/PropertyField.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Setter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Setter.txt index 8f43a4dc8bf..cbb9bc0b34a 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Setter.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classMembers/Setter.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/AnnotationInClassObject.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/AnnotationInClassObject.txt index d062816f7c8..e6877abd572 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/AnnotationInClassObject.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/AnnotationInClassObject.txt @@ -6,14 +6,14 @@ public final class A { public companion object Companion { /*primary*/ private constructor Companion() - @kotlin.annotation.annotation() public final class Anno1 : kotlin.Annotation { + public final annotation class Anno1 : kotlin.Annotation { /*primary*/ public constructor Anno1() } public final class B { /*primary*/ public constructor B() - @kotlin.annotation.annotation() public final class Anno2 : kotlin.Annotation { + public final annotation class Anno2 : kotlin.Annotation { /*primary*/ public constructor Anno2() } } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassInClassObject.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassInClassObject.txt index 5902a672460..ec47b99564a 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassInClassObject.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassInClassObject.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassObject.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassObject.txt index ee551a90cc6..21e9d19d59e 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassObject.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/ClassObject.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.txt index 2c08958dd8a..f877e7ffa32 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/DataClass.txt @@ -1,6 +1,6 @@ package test -@kotlin.data() public final class My { +public final data class My { /*primary*/ public constructor My(/*0*/ x: kotlin.Int) public final val x: kotlin.Int public final fun (): kotlin.Int diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/DollarsInAnnotationName.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/DollarsInAnnotationName.txt index 926431cfddf..39e781122a3 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/DollarsInAnnotationName.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/DollarsInAnnotationName.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class `$$$$$$` : kotlin.Annotation { +public final annotation class `$$$$$$` : kotlin.Annotation { /*primary*/ public constructor `$$$$$$`() } @@ -8,7 +8,7 @@ package test /*primary*/ public constructor A() } -@kotlin.annotation.annotation() public final class `Anno$tation` : kotlin.Annotation { +public final annotation class `Anno$tation` : kotlin.Annotation { /*primary*/ public constructor `Anno$tation`() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/EnumArgument.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/EnumArgument.txt index 519e046cb51..dcda9c0af6d 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/EnumArgument.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/EnumArgument.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno(/*0*/ t: java.lang.annotation.ElementType) public final val t: java.lang.annotation.ElementType public final fun (): java.lang.annotation.ElementType diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/MultipleAnnotations.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/MultipleAnnotations.txt index 07fba32a37a..7dc9f2840f7 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/MultipleAnnotations.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/MultipleAnnotations.txt @@ -1,14 +1,14 @@ package test -@kotlin.annotation.annotation() public final class A1 : kotlin.Annotation { +public final annotation class A1 : kotlin.Annotation { /*primary*/ public constructor A1() } -@kotlin.annotation.annotation() public final class A2 : kotlin.Annotation { +public final annotation class A2 : kotlin.Annotation { /*primary*/ public constructor A2() } -@kotlin.annotation.annotation() public final class A3 : kotlin.Annotation { +public final annotation class A3 : kotlin.Annotation { /*primary*/ public constructor A3() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedAnnotation.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedAnnotation.txt index 025b0ecec00..57e36ecd021 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedAnnotation.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedAnnotation.txt @@ -3,7 +3,7 @@ package test public final class A { /*primary*/ public constructor A() - @kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { + public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedClass.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedClass.txt index 2852d395011..e429cc38932 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedClass.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/NestedClass.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.txt index 24cf9369fc1..798b64f20b8 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/Retention.txt @@ -1,5 +1,5 @@ package test -@kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) @kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +@kotlin.annotation.Retention(value = AnnotationRetention.RUNTIME) public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/Simple.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/Simple.txt index c74609de6c2..5f2ac728039 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/Simple.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/Simple.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithArgument.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithArgument.txt index 1c90626c026..2dfa1bbc5c4 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithArgument.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithArgument.txt @@ -1,18 +1,18 @@ package test -@kotlin.annotation.annotation() public final class BooleanAnno : kotlin.Annotation { +public final annotation class BooleanAnno : kotlin.Annotation { /*primary*/ public constructor BooleanAnno(/*0*/ value: kotlin.Boolean) public final val value: kotlin.Boolean public final fun (): kotlin.Boolean } -@kotlin.annotation.annotation() public final class ByteAnno : kotlin.Annotation { +public final annotation class ByteAnno : kotlin.Annotation { /*primary*/ public constructor ByteAnno(/*0*/ value: kotlin.Byte) public final val value: kotlin.Byte public final fun (): kotlin.Byte } -@kotlin.annotation.annotation() public final class CharAnno : kotlin.Annotation { +public final annotation class CharAnno : kotlin.Annotation { /*primary*/ public constructor CharAnno(/*0*/ value: kotlin.Char) public final val value: kotlin.Char public final fun (): kotlin.Char @@ -22,31 +22,31 @@ package test /*primary*/ public constructor Class() } -@kotlin.annotation.annotation() public final class DoubleAnno : kotlin.Annotation { +public final annotation class DoubleAnno : kotlin.Annotation { /*primary*/ public constructor DoubleAnno(/*0*/ value: kotlin.Double) public final val value: kotlin.Double public final fun (): kotlin.Double } -@kotlin.annotation.annotation() public final class FloatAnno : kotlin.Annotation { +public final annotation class FloatAnno : kotlin.Annotation { /*primary*/ public constructor FloatAnno(/*0*/ value: kotlin.Float) public final val value: kotlin.Float public final fun (): kotlin.Float } -@kotlin.annotation.annotation() public final class IntAnno : kotlin.Annotation { +public final annotation class IntAnno : kotlin.Annotation { /*primary*/ public constructor IntAnno(/*0*/ value: kotlin.Int) public final val value: kotlin.Int public final fun (): kotlin.Int } -@kotlin.annotation.annotation() public final class LongAnno : kotlin.Annotation { +public final annotation class LongAnno : kotlin.Annotation { /*primary*/ public constructor LongAnno(/*0*/ value: kotlin.Long) public final val value: kotlin.Long public final fun (): kotlin.Long } -@kotlin.annotation.annotation() public final class ShortAnno : kotlin.Annotation { +public final annotation class ShortAnno : kotlin.Annotation { /*primary*/ public constructor ShortAnno(/*0*/ value: kotlin.Short) public final val value: kotlin.Short public final fun (): kotlin.Short diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithMultipleArguments.txt b/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithMultipleArguments.txt index b3ecca9404c..86386bcf49e 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithMultipleArguments.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/classes/WithMultipleArguments.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno(/*0*/ int: kotlin.Int, /*1*/ string: kotlin.String, /*2*/ double: kotlin.Double) public final val double: kotlin.Double public final fun (): kotlin.Double diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/DelegatedProperty.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/DelegatedProperty.txt index ab3ead115ca..3bed9e83b2f 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/DelegatedProperty.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/DelegatedProperty.txt @@ -3,6 +3,6 @@ package test @test.Anno() public val x: kotlin.Int public fun (): kotlin.Int -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArgument.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArgument.txt index 9556a71158b..8e1826e2daa 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArgument.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArgument.txt @@ -4,7 +4,7 @@ package test public fun (): kotlin.Int @test.Anno(t = ElementType.METHOD) public fun foo(): kotlin.Unit -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno(/*0*/ t: java.lang.annotation.ElementType) public final val t: java.lang.annotation.ElementType public final fun (): java.lang.annotation.ElementType diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArrayArgument.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArrayArgument.txt index c9ef7ab2718..348bc8db353 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArrayArgument.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/EnumArrayArgument.txt @@ -5,7 +5,7 @@ package test @test.Anno(t = {}) public fun baz(): kotlin.Unit @test.Anno(t = {ElementType.METHOD, ElementType.FIELD}) public fun foo(): kotlin.Unit -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno(/*0*/ vararg t: java.lang.annotation.ElementType /*kotlin.Array*/) public final val t: kotlin.Array public final fun (): kotlin.Array diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Function.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Function.txt index 7151484677a..c94eb67754a 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Function.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Function.txt @@ -2,6 +2,6 @@ package test @test.Anno() public fun function(): kotlin.Unit -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Getter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Getter.txt index 79c688a588d..330075011ea 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Getter.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Getter.txt @@ -3,6 +3,6 @@ package test public val property: kotlin.Int @test.Anno() public fun (): kotlin.Int -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/PropertyField.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/PropertyField.txt index f0b9727a800..96a3a240250 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/PropertyField.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/PropertyField.txt @@ -4,6 +4,6 @@ package test public fun (): kotlin.Int public fun (/*0*/ : kotlin.Int): kotlin.Unit -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Setter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Setter.txt index 1081078e840..55a70ee11a0 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Setter.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/Setter.txt @@ -4,6 +4,6 @@ public var property: kotlin.Int public fun (): kotlin.Int @test.Anno() public fun (/*0*/ value: kotlin.Int): kotlin.Unit -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/StringArrayArgument.txt b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/StringArrayArgument.txt index a09f9d3b0ab..f524b79c296 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/StringArrayArgument.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/packageMembers/StringArrayArgument.txt @@ -5,7 +5,7 @@ package test @test.Anno(t = {}) public fun baz(): kotlin.Unit @test.Anno(t = {"live", "long"}) public fun foo(): kotlin.Unit -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno(/*0*/ vararg t: kotlin.String /*kotlin.Array*/) public final val t: kotlin.Array public final fun (): kotlin.Array diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/Constructor.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/Constructor.txt index 69288c9a56c..82c15bac0dd 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/Constructor.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/Constructor.txt @@ -1,10 +1,10 @@ package test -@kotlin.annotation.annotation() public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A() } -@kotlin.annotation.annotation() public final class B : kotlin.Annotation { +public final annotation class B : kotlin.Annotation { /*primary*/ public constructor B() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/EnumConstructor.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/EnumConstructor.txt index d51e943ea55..dae063c3d6c 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/EnumConstructor.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/EnumConstructor.txt @@ -1,10 +1,10 @@ package test -@kotlin.annotation.annotation() public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A() } -@kotlin.annotation.annotation() public final class B : kotlin.Annotation { +public final annotation class B : kotlin.Annotation { /*primary*/ public constructor B() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunction.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunction.txt index 0d5358e4c69..a1512a5a7ed 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunction.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunction.txt @@ -2,6 +2,6 @@ package test public fun kotlin.Int.foo(/*0*/ @test.A() x: kotlin.Int): kotlin.Unit -@kotlin.annotation.annotation() public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunctionInClass.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunctionInClass.txt index d0a033a16e6..6e18f0390c2 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunctionInClass.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionFunctionInClass.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionPropertySetter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionPropertySetter.txt index 19c853c9291..a28155de459 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionPropertySetter.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ExtensionPropertySetter.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInClass.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInClass.txt index 565edf4175e..af1d36bcd4a 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInClass.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInClass.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInTrait.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInTrait.txt index fe4dcfb4a49..fdc5b58bbd3 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInTrait.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/FunctionInTrait.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/InnerClassConstructor.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/InnerClassConstructor.txt index e24d0c9354c..824d5f9b9de 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/InnerClassConstructor.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/InnerClassConstructor.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A(/*0*/ s: kotlin.String) public final val s: kotlin.String public final fun (): kotlin.String diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ManyAnnotations.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ManyAnnotations.txt index 0438d279290..cb7bbd8afae 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ManyAnnotations.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/ManyAnnotations.txt @@ -3,18 +3,18 @@ package test public fun bar(/*0*/ @test.A() @test.B() @test.C() @test.D() x: kotlin.Int): kotlin.Unit public fun foo(/*0*/ @test.A() @test.B() x: kotlin.Int, /*1*/ @test.A() @test.C() y: kotlin.Double, /*2*/ @test.B() @test.C() @test.D() z: kotlin.String): kotlin.Unit -@kotlin.annotation.annotation() public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A() } -@kotlin.annotation.annotation() public final class B : kotlin.Annotation { +public final annotation class B : kotlin.Annotation { /*primary*/ public constructor B() } -@kotlin.annotation.annotation() public final class C : kotlin.Annotation { +public final annotation class C : kotlin.Annotation { /*primary*/ public constructor C() } -@kotlin.annotation.annotation() public final class D : kotlin.Annotation { +public final annotation class D : kotlin.Annotation { /*primary*/ public constructor D() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/PropertySetterInClass.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/PropertySetterInClass.txt index 908ea64acca..410bc274916 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/PropertySetterInClass.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/PropertySetterInClass.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelFunction.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelFunction.txt index 2453554d121..194991f0a58 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelFunction.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelFunction.txt @@ -2,6 +2,6 @@ package test public fun foo(/*0*/ @test.Anno() x: kotlin.Int): kotlin.Unit -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelPropertySetter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelPropertySetter.txt index 291a30013ca..e4c0a41414e 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelPropertySetter.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/parameters/TopLevelPropertySetter.txt @@ -4,10 +4,10 @@ public var foo: kotlin.Int public fun (): kotlin.Int public fun (/*0*/ @test.A() @test.B() value: kotlin.Int): kotlin.Unit -@kotlin.annotation.annotation() public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A() } -@kotlin.annotation.annotation() public final class B : kotlin.Annotation { +public final annotation class B : kotlin.Annotation { /*primary*/ public constructor B() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Class.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Class.txt index 8c8df7d6d83..21d8a830cc9 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Class.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Class.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ClassObject.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ClassObject.txt index 2f9303e2c89..ae374d4d295 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ClassObject.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ClassObject.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNameClass.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNameClass.txt index 354ea9e9a44..74bd50082ed 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNameClass.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNameClass.txt @@ -10,14 +10,14 @@ public final class Class { public final fun kotlin.String.(): kotlin.String } -@kotlin.annotation.annotation() public final class DoubleAnno : kotlin.Annotation { +public final annotation class DoubleAnno : kotlin.Annotation { /*primary*/ public constructor DoubleAnno() } -@kotlin.annotation.annotation() public final class IntAnno : kotlin.Annotation { +public final annotation class IntAnno : kotlin.Annotation { /*primary*/ public constructor IntAnno() } -@kotlin.annotation.annotation() public final class StringAnno : kotlin.Annotation { +public final annotation class StringAnno : kotlin.Annotation { /*primary*/ public constructor StringAnno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNamePackage.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNamePackage.txt index de5e02601ae..62789193f02 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNamePackage.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/ExtensionsWithSameNamePackage.txt @@ -7,14 +7,14 @@ package test @test.StringAnno() public val kotlin.String.extension: kotlin.String public fun kotlin.String.(): kotlin.String -@kotlin.annotation.annotation() public final class DoubleAnno : kotlin.Annotation { +public final annotation class DoubleAnno : kotlin.Annotation { /*primary*/ public constructor DoubleAnno() } -@kotlin.annotation.annotation() public final class IntAnno : kotlin.Annotation { +public final annotation class IntAnno : kotlin.Annotation { /*primary*/ public constructor IntAnno() } -@kotlin.annotation.annotation() public final class StringAnno : kotlin.Annotation { +public final annotation class StringAnno : kotlin.Annotation { /*primary*/ public constructor StringAnno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/NestedTrait.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/NestedTrait.txt index 79650e6db64..f03bfb85277 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/NestedTrait.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/NestedTrait.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TopLevel.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TopLevel.txt index edb5536aff6..9bbe27db8ca 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TopLevel.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TopLevel.txt @@ -3,6 +3,6 @@ package test @test.Anno() public val property: kotlin.Int public fun (): kotlin.Int -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Trait.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Trait.txt index 61c03794b37..2c81e2fb706 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Trait.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/Trait.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TraitClassObject.txt b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TraitClassObject.txt index 75a298fdb77..d5354c038d4 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TraitClassObject.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/propertiesWithoutBackingFields/TraitClassObject.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/types/ReceiverParameter.txt b/compiler/testData/loadJava/compiledKotlin/annotations/types/ReceiverParameter.txt index 8e15f6ac2f3..b8aef7a90e0 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/types/ReceiverParameter.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/types/ReceiverParameter.txt @@ -2,6 +2,6 @@ package test public fun @test.A() kotlin.String.foo(): kotlin.Unit -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class A : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/types/SimpleTypeAnnotation.txt b/compiler/testData/loadJava/compiledKotlin/annotations/types/SimpleTypeAnnotation.txt index 102854ac633..5c758dfcb9a 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/types/SimpleTypeAnnotation.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/types/SimpleTypeAnnotation.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class A : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/types/SupertypesAndBounds.txt b/compiler/testData/loadJava/compiledKotlin/annotations/types/SupertypesAndBounds.txt index 45ac2ced2b0..244289f0fab 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/types/SupertypesAndBounds.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/types/SupertypesAndBounds.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeAnnotationWithArguments.txt b/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeAnnotationWithArguments.txt index 6c425f9137d..e920c01e936 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeAnnotationWithArguments.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeAnnotationWithArguments.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) @kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class Ann : kotlin.Annotation { /*primary*/ public constructor Ann(/*0*/ x: kotlin.String, /*1*/ y: kotlin.Double) public final val x: kotlin.String public final fun (): kotlin.String diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeParameterAnnotation.txt b/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeParameterAnnotation.txt index 87bdd862f69..0b35ce596c4 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeParameterAnnotation.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeParameterAnnotation.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) @kotlin.annotation.annotation() public final class A : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeParameterAnnotationWithArguments.txt b/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeParameterAnnotationWithArguments.txt index d18a79a6808..6c3cc6ec5bf 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeParameterAnnotationWithArguments.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/types/TypeParameterAnnotationWithArguments.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) @kotlin.annotation.annotation() public final class A : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE_PARAMETER}) public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A(/*0*/ x: kotlin.String, /*1*/ y: kotlin.Double) public final val x: kotlin.String public final fun (): kotlin.String diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget/FieldTarget.txt b/compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget/FieldTarget.txt index e06f0cd9701..ee18c636f85 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget/FieldTarget.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget/FieldTarget.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class Anno : kotlin.Annotation { +public final annotation class Anno : kotlin.Annotation { /*primary*/ public constructor Anno() } diff --git a/compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget/ReceiverTarget.txt b/compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget/ReceiverTarget.txt index ec9905404a2..32e3fe85237 100644 --- a/compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget/ReceiverTarget.txt +++ b/compiler/testData/loadJava/compiledKotlin/annotations/withUseSiteTarget/ReceiverTarget.txt @@ -10,6 +10,6 @@ public final class A { public final fun @receiver:test.Ann() kotlin.String.myLength(/*0*/ @test.Ann() q: kotlin.String): kotlin.Int } -@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) @kotlin.annotation.annotation() public final class Ann : kotlin.Annotation { +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.VALUE_PARAMETER}) public final annotation class Ann : kotlin.Annotation { /*primary*/ public constructor Ann() } diff --git a/compiler/testData/loadJava/compiledKotlin/dataClass/MixedComponents.txt b/compiler/testData/loadJava/compiledKotlin/dataClass/MixedComponents.txt index ea80c22c59f..2c05a6fff5b 100644 --- a/compiler/testData/loadJava/compiledKotlin/dataClass/MixedComponents.txt +++ b/compiler/testData/loadJava/compiledKotlin/dataClass/MixedComponents.txt @@ -1,6 +1,6 @@ package test -@kotlin.data() public final class DataClass { +public final data class DataClass { /*primary*/ public constructor DataClass(/*0*/ x: kotlin.String, /*1*/ z: kotlin.Double) public final var x: kotlin.String public final fun (): kotlin.String diff --git a/compiler/testData/loadJava/compiledKotlin/dataClass/NoComponents.txt b/compiler/testData/loadJava/compiledKotlin/dataClass/NoComponents.txt index fb95b898696..91594deeb3a 100644 --- a/compiler/testData/loadJava/compiledKotlin/dataClass/NoComponents.txt +++ b/compiler/testData/loadJava/compiledKotlin/dataClass/NoComponents.txt @@ -1,11 +1,11 @@ package test -@kotlin.data() public final class DataClass { +public final data class DataClass { /*primary*/ public constructor DataClass() public final /*synthesized*/ fun copy(): test.DataClass } -@kotlin.data() public final class OtherDataClass { +public final data class OtherDataClass { /*primary*/ public constructor OtherDataClass() public final /*synthesized*/ fun copy(): test.OtherDataClass } diff --git a/compiler/testData/loadJava/compiledKotlin/dataClass/OneVal.txt b/compiler/testData/loadJava/compiledKotlin/dataClass/OneVal.txt index eae153ff388..5313016513d 100644 --- a/compiler/testData/loadJava/compiledKotlin/dataClass/OneVal.txt +++ b/compiler/testData/loadJava/compiledKotlin/dataClass/OneVal.txt @@ -1,6 +1,6 @@ package test -@kotlin.data() public final class DataClass { +public final data class DataClass { /*primary*/ public constructor DataClass(/*0*/ x: kotlin.String) public final val x: kotlin.String public final fun (): kotlin.String diff --git a/compiler/testData/loadJava/compiledKotlin/dataClass/ParamNameSameToField.txt b/compiler/testData/loadJava/compiledKotlin/dataClass/ParamNameSameToField.txt index 9bc2a187819..ecd4282aa5d 100644 --- a/compiler/testData/loadJava/compiledKotlin/dataClass/ParamNameSameToField.txt +++ b/compiler/testData/loadJava/compiledKotlin/dataClass/ParamNameSameToField.txt @@ -1,6 +1,6 @@ package test -@kotlin.data() public final class A { +public final data class A { /*primary*/ public constructor A(/*0*/ foo: kotlin.String, /*1*/ bar: kotlin.Int, /*2*/ other: kotlin.Long) public final val bar: kotlin.Int public final fun (): kotlin.Int diff --git a/compiler/testData/loadJava/compiledKotlin/dataClass/TwoVals.txt b/compiler/testData/loadJava/compiledKotlin/dataClass/TwoVals.txt index 0ef5c0617ea..9041723eb1f 100644 --- a/compiler/testData/loadJava/compiledKotlin/dataClass/TwoVals.txt +++ b/compiler/testData/loadJava/compiledKotlin/dataClass/TwoVals.txt @@ -1,6 +1,6 @@ package test -@kotlin.data() public final class DataClass { +public final data class DataClass { /*primary*/ public constructor DataClass(/*0*/ x: kotlin.String, /*1*/ y: kotlin.Int) public final val x: kotlin.String public final fun (): kotlin.String diff --git a/compiler/testData/loadJava/compiledKotlin/dataClass/TwoVars.txt b/compiler/testData/loadJava/compiledKotlin/dataClass/TwoVars.txt index 892deef4705..feb84b8b3e3 100644 --- a/compiler/testData/loadJava/compiledKotlin/dataClass/TwoVars.txt +++ b/compiler/testData/loadJava/compiledKotlin/dataClass/TwoVars.txt @@ -1,6 +1,6 @@ package test -@kotlin.data() public final class DataClass { +public final data class DataClass { /*primary*/ public constructor DataClass(/*0*/ x: kotlin.String, /*1*/ y: kotlin.Int) public final var x: kotlin.String public final fun (): kotlin.String diff --git a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/classObjectAnnotation.txt b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/classObjectAnnotation.txt index 1fe17863856..f02742eaa6b 100644 --- a/compiler/testData/loadJava/compiledKotlin/fromLoadJava/classObjectAnnotation.txt +++ b/compiler/testData/loadJava/compiledKotlin/fromLoadJava/classObjectAnnotation.txt @@ -6,7 +6,7 @@ public final class Some { @test.Some.Companion.TestAnnotation() public companion object Companion { /*primary*/ private constructor Companion() - @kotlin.annotation.annotation() public final class TestAnnotation : kotlin.Annotation { + public final annotation class TestAnnotation : kotlin.Annotation { /*primary*/ public constructor TestAnnotation() } } diff --git a/compiler/testData/loadJava/compiledKotlin/inline/inlineFunction.txt b/compiler/testData/loadJava/compiledKotlin/inline/inlineFunction.txt index fcbcdd94128..77ea3256fda 100644 --- a/compiler/testData/loadJava/compiledKotlin/inline/inlineFunction.txt +++ b/compiler/testData/loadJava/compiledKotlin/inline/inlineFunction.txt @@ -1,6 +1,6 @@ package test -@kotlin.inline() public fun a(): kotlin.Unit -@kotlin.inline() public fun b(): kotlin.Unit -@kotlin.inline() public fun c(): kotlin.Unit -@kotlin.inline() public fun d(): kotlin.Unit +public inline fun a(): kotlin.Unit +public inline fun b(): kotlin.Unit +public inline fun c(): kotlin.Unit +public inline fun d(): kotlin.Unit diff --git a/compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames/functionName.txt b/compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames/functionName.txt index d5da0cd326f..1b02e351c5d 100644 --- a/compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames/functionName.txt +++ b/compiler/testData/loadJava/compiledKotlinWithStdlib/platformNames/functionName.txt @@ -5,7 +5,7 @@ package test @kotlin.platform.platformName(name = "vset") @test.A(s = "4") public fun (/*0*/ : kotlin.Int): kotlin.Unit @kotlin.platform.platformName(name = "bar") @test.A(s = "1") public fun foo(): kotlin.String -@kotlin.annotation.annotation() public final class A : kotlin.Annotation { +public final annotation class A : kotlin.Annotation { /*primary*/ public constructor A(/*0*/ s: kotlin.String) public final val s: kotlin.String public final fun (): kotlin.String diff --git a/compiler/testData/loadJava/sourceJava/NullInAnnotation.txt b/compiler/testData/loadJava/sourceJava/NullInAnnotation.txt index 60e0b2b5e6a..932dadfd12a 100644 --- a/compiler/testData/loadJava/sourceJava/NullInAnnotation.txt +++ b/compiler/testData/loadJava/sourceJava/NullInAnnotation.txt @@ -5,7 +5,7 @@ public /*synthesized*/ fun NullInAnnotation(/*0*/ function: () -> kotlin.Unit): public interface NullInAnnotation { @test.NullInAnnotation.Ann(a = null, b = {null}) public abstract fun foo(): kotlin.Unit - public final class Ann : kotlin.Annotation { + public final annotation class Ann : kotlin.Annotation { public constructor Ann(/*0*/ a: kotlin.String, /*1*/ b: kotlin.Array) public final val a: kotlin.String public final val b: kotlin.Array diff --git a/compiler/testData/renderer/Classes.kt b/compiler/testData/renderer/Classes.kt index 9e8c158c976..4eeffb3d49e 100644 --- a/compiler/testData/renderer/Classes.kt +++ b/compiler/testData/renderer/Classes.kt @@ -35,9 +35,9 @@ public class WithReified public interface TwoUpperBounds where T : Number, T : Any //package rendererTest -//@kotlin.annotation.annotation public final class TheAnnotation : kotlin.Annotation defined in rendererTest +//public final annotation class TheAnnotation : kotlin.Annotation defined in rendererTest //public constructor TheAnnotation() defined in rendererTest.TheAnnotation -//@kotlin.annotation.annotation public final class AnotherAnnotation : kotlin.Annotation defined in rendererTest +//public final annotation class AnotherAnnotation : kotlin.Annotation defined in rendererTest //public constructor AnotherAnnotation() defined in rendererTest.AnotherAnnotation //@rendererTest.TheAnnotation public open class TheClass defined in rendererTest // defined in rendererTest.TheClass diff --git a/compiler/testData/renderer/KeywordsInNames.kt b/compiler/testData/renderer/KeywordsInNames.kt index 10a68b35e2e..bf24c6ec2f5 100644 --- a/compiler/testData/renderer/KeywordsInNames.kt +++ b/compiler/testData/renderer/KeywordsInNames.kt @@ -17,7 +17,7 @@ val AS_SAFE = 1 val NOT_IN = 2 val NOT_IS = 3 -//@kotlin.annotation.annotation public final class `true` : kotlin.Annotation defined in root package +//public final annotation class `true` : kotlin.Annotation defined in root package //public constructor `true`() defined in `true` //public val `val`: kotlin.Int defined in root package //@`true` public interface `interface` defined in root package diff --git a/compiler/testData/serialization/builtinsSerializer/annotationArguments/annotation.txt b/compiler/testData/serialization/builtinsSerializer/annotationArguments/annotation.txt index 3d38cc5ad22..100c97e7ed4 100644 --- a/compiler/testData/serialization/builtinsSerializer/annotationArguments/annotation.txt +++ b/compiler/testData/serialization/builtinsSerializer/annotationArguments/annotation.txt @@ -1,6 +1,6 @@ package test -@kotlin.annotation.annotation() public final class AnnotationArray : kotlin.Annotation { +public final annotation class AnnotationArray : kotlin.Annotation { public constructor AnnotationArray(/*0*/ annotationArray: kotlin.Array) public final val annotationArray: kotlin.Array } @@ -13,11 +13,11 @@ package test public constructor C2() } -@kotlin.annotation.annotation() public final class Empty : kotlin.Annotation { +public final annotation class Empty : kotlin.Annotation { public constructor Empty() } -@kotlin.annotation.annotation() public final class JustAnnotation : kotlin.Annotation { +public final annotation class JustAnnotation : kotlin.Annotation { public constructor JustAnnotation(/*0*/ annotation: test.Empty) public final val annotation: test.Empty } diff --git a/compiler/testData/serialization/builtinsSerializer/annotationArguments/enum.txt b/compiler/testData/serialization/builtinsSerializer/annotationArguments/enum.txt index 709bbd77a09..6955aac82de 100644 --- a/compiler/testData/serialization/builtinsSerializer/annotationArguments/enum.txt +++ b/compiler/testData/serialization/builtinsSerializer/annotationArguments/enum.txt @@ -8,12 +8,12 @@ package test public constructor C2() } -@kotlin.annotation.annotation() public final class EnumArray : kotlin.Annotation { +public final annotation class EnumArray : kotlin.Annotation { public constructor EnumArray(/*0*/ enumArray: kotlin.Array) public final val enumArray: kotlin.Array } -@kotlin.annotation.annotation() public final class JustEnum : kotlin.Annotation { +public final annotation class JustEnum : kotlin.Annotation { public constructor JustEnum(/*0*/ weapon: test.Weapon) public final val weapon: test.Weapon } diff --git a/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitiveArrays.txt b/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitiveArrays.txt index 50c9ae75ab5..97d61a65e29 100644 --- a/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitiveArrays.txt +++ b/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitiveArrays.txt @@ -8,7 +8,7 @@ package test public constructor C2() } -@kotlin.annotation.annotation() public final class PrimitiveArrays : kotlin.Annotation { +public final annotation class PrimitiveArrays : kotlin.Annotation { public constructor PrimitiveArrays(/*0*/ byteArray: kotlin.ByteArray, /*1*/ charArray: kotlin.CharArray, /*2*/ shortArray: kotlin.ShortArray, /*3*/ intArray: kotlin.IntArray, /*4*/ longArray: kotlin.LongArray, /*5*/ floatArray: kotlin.FloatArray, /*6*/ doubleArray: kotlin.DoubleArray, /*7*/ booleanArray: kotlin.BooleanArray) public final val booleanArray: kotlin.BooleanArray public final val byteArray: kotlin.ByteArray diff --git a/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitives.txt b/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitives.txt index 1876bc4aff2..8194cd63f11 100644 --- a/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitives.txt +++ b/compiler/testData/serialization/builtinsSerializer/annotationArguments/primitives.txt @@ -4,7 +4,7 @@ package test public constructor C() } -@kotlin.annotation.annotation() public final class Primitives : kotlin.Annotation { +public final annotation class Primitives : kotlin.Annotation { public constructor Primitives(/*0*/ byte: kotlin.Byte, /*1*/ char: kotlin.Char, /*2*/ short: kotlin.Short, /*3*/ int: kotlin.Int, /*4*/ long: kotlin.Long, /*5*/ float: kotlin.Float, /*6*/ double: kotlin.Double, /*7*/ boolean: kotlin.Boolean) public final val boolean: kotlin.Boolean public final val byte: kotlin.Byte diff --git a/compiler/testData/serialization/builtinsSerializer/annotationArguments/string.txt b/compiler/testData/serialization/builtinsSerializer/annotationArguments/string.txt index aaae9f64b68..e280b342b9c 100644 --- a/compiler/testData/serialization/builtinsSerializer/annotationArguments/string.txt +++ b/compiler/testData/serialization/builtinsSerializer/annotationArguments/string.txt @@ -8,12 +8,12 @@ package test public constructor C2() } -@kotlin.annotation.annotation() public final class JustString : kotlin.Annotation { +public final annotation class JustString : kotlin.Annotation { public constructor JustString(/*0*/ string: kotlin.String) public final val string: kotlin.String } -@kotlin.annotation.annotation() public final class StringArray : kotlin.Annotation { +public final annotation class StringArray : kotlin.Annotation { public constructor StringArray(/*0*/ stringArray: kotlin.Array) public final val stringArray: kotlin.Array } diff --git a/compiler/testData/serialization/builtinsSerializer/annotationArguments/varargs.txt b/compiler/testData/serialization/builtinsSerializer/annotationArguments/varargs.txt index 793c7def20a..9a1eab59e4c 100644 --- a/compiler/testData/serialization/builtinsSerializer/annotationArguments/varargs.txt +++ b/compiler/testData/serialization/builtinsSerializer/annotationArguments/varargs.txt @@ -19,11 +19,11 @@ public final enum class My : kotlin.Enum { @kotlin.Deprecated(message = "Use 'values' property instead", replaceWith = kotlin.ReplaceWith(expression = "this.values", imports = {})) public final /*synthesized*/ fun values(): kotlin.Array } -@kotlin.annotation.annotation() public final class ann : kotlin.Annotation { +public final annotation class ann : kotlin.Annotation { public constructor ann(/*0*/ vararg m: test.My /*kotlin.Array*/) public final val m: kotlin.Array } -@test.ann(m = {My.ALPHA, My.BETA}) @kotlin.annotation.annotation() public final class annotated : kotlin.Annotation { +@test.ann(m = {My.ALPHA, My.BETA}) public final annotation class annotated : kotlin.Annotation { public constructor annotated() } diff --git a/compiler/testData/serialization/builtinsSerializer/annotationTargets.txt b/compiler/testData/serialization/builtinsSerializer/annotationTargets.txt index 5501513b114..bad57563ce4 100644 --- a/compiler/testData/serialization/builtinsSerializer/annotationTargets.txt +++ b/compiler/testData/serialization/builtinsSerializer/annotationTargets.txt @@ -21,7 +21,7 @@ package test } } -@kotlin.annotation.annotation() public final class anno : kotlin.Annotation { +public final annotation class anno : kotlin.Annotation { public constructor anno(/*0*/ x: kotlin.String) public final val x: kotlin.String } diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt b/compiler/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt index 8dcb6ae02d0..56382eccf7b 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt +++ b/compiler/tests/org/jetbrains/kotlin/codegen/InlineTestUtil.kt @@ -17,10 +17,10 @@ package org.jetbrains.kotlin.codegen; import org.jetbrains.kotlin.backend.common.output.OutputFile +import org.jetbrains.kotlin.inline.inlineFunctionsJvmNames import org.jetbrains.kotlin.load.java.JvmAbi import org.jetbrains.kotlin.load.java.JvmAnnotationNames import org.jetbrains.kotlin.load.kotlin.FileBasedKotlinClass -import org.jetbrains.kotlin.load.kotlin.PackageClassUtils import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader import org.jetbrains.kotlin.psi.JetFile import org.jetbrains.kotlin.resolve.jvm.JvmClassName @@ -32,7 +32,6 @@ import kotlin.properties.Delegates public object InlineTestUtil { - public val INLINE_ANNOTATION_CLASS: String = "kotlin/inline" private val KOTLIN_PACKAGE_DESC = "L" + AsmUtil.internalNameByFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_PACKAGE) + ";" private val KOTLIN_MULTIFILE_CLASS_DESC = "L" + AsmUtil.internalNameByFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_MULTIFILE_CLASS) + ";" @@ -62,27 +61,28 @@ public object InlineTestUtil { val classHeaders = hashMapOf() for (file in files) { - val cr = ClassReader(file.asByteArray()) + val bytes = file.asByteArray() + val cr = ClassReader(bytes) + + val inlineFunctions = inlineFunctionsJvmNames(bytes) + if (inlineFunctions.isEmpty()) continue val classVisitor = object : ClassVisitorWithName() { - override fun visitMethod(access: Int, name: String, desc: String, signature: String?, exceptions: Array?): MethodVisitor { return object : MethodNode(Opcodes.ASM5, access, name, desc, signature, exceptions) { - public override fun visitAnnotation(desc: String, visible: Boolean): AnnotationVisitor { - val type = Type.getType(desc) - val annotationClass = type.getInternalName() - if (INLINE_ANNOTATION_CLASS == annotationClass) { + override fun visitEnd() { + if (name + desc in inlineFunctions) { inlineMethods.add(MethodInfo(className, name, this.desc)) } - return super.visitAnnotation(desc, visible) } } } } - cr.accept(classVisitor, 0) + cr.accept(classVisitor, 0) classHeaders.put(classVisitor.className, getClassHeader(file)) } + return InlineInfo(inlineMethods, classHeaders) } diff --git a/compiler/tests/org/jetbrains/kotlin/serialization/DebugProtoBuf.java b/compiler/tests/org/jetbrains/kotlin/serialization/DebugProtoBuf.java index 5546cd421af..a212574fddc 100644 --- a/compiler/tests/org/jetbrains/kotlin/serialization/DebugProtoBuf.java +++ b/compiler/tests/org/jetbrains/kotlin/serialization/DebugProtoBuf.java @@ -9015,6 +9015,7 @@ public final class DebugProtoBuf { *Modality *ClassKind *isInner + *isData * */ boolean hasFlags(); @@ -9028,6 +9029,7 @@ public final class DebugProtoBuf { *Modality *ClassKind *isInner + *isData * */ int getFlags(); @@ -9627,6 +9629,7 @@ public final class DebugProtoBuf { *Modality *ClassKind *isInner + *isData * */ public boolean hasFlags() { @@ -9642,6 +9645,7 @@ public final class DebugProtoBuf { *Modality *ClassKind *isInner + *isData * */ public int getFlags() { @@ -10714,6 +10718,7 @@ public final class DebugProtoBuf { *Modality *ClassKind *isInner + *isData * */ public boolean hasFlags() { @@ -10729,6 +10734,7 @@ public final class DebugProtoBuf { *Modality *ClassKind *isInner + *isData * */ public int getFlags() { @@ -10744,6 +10750,7 @@ public final class DebugProtoBuf { *Modality *ClassKind *isInner + *isData * */ public Builder setFlags(int value) { @@ -10762,6 +10769,7 @@ public final class DebugProtoBuf { *Modality *ClassKind *isInner + *isData * */ public Builder clearFlags() { @@ -15312,6 +15320,9 @@ public final class DebugProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ boolean hasFlags(); @@ -15326,6 +15337,9 @@ public final class DebugProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ int getFlags(); @@ -15638,6 +15652,9 @@ public final class DebugProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ public boolean hasFlags() { @@ -15654,6 +15671,9 @@ public final class DebugProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ public int getFlags() { @@ -16397,6 +16417,9 @@ public final class DebugProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ public boolean hasFlags() { @@ -16413,6 +16436,9 @@ public final class DebugProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ public int getFlags() { @@ -16429,6 +16455,9 @@ public final class DebugProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ public Builder setFlags(int value) { @@ -16448,6 +16477,9 @@ public final class DebugProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ public Builder clearFlags() { @@ -17547,6 +17579,7 @@ public final class DebugProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ boolean hasGetterFlags(); @@ -17559,6 +17592,7 @@ public final class DebugProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ int getGetterFlags(); @@ -17950,6 +17984,7 @@ public final class DebugProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ public boolean hasGetterFlags() { @@ -17964,6 +17999,7 @@ public final class DebugProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ public int getGetterFlags() { @@ -19286,6 +19322,7 @@ public final class DebugProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ public boolean hasGetterFlags() { @@ -19300,6 +19337,7 @@ public final class DebugProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ public int getGetterFlags() { @@ -19314,6 +19352,7 @@ public final class DebugProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ public Builder setGetterFlags(int value) { @@ -19331,6 +19370,7 @@ public final class DebugProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ public Builder clearGetterFlags() { @@ -19396,6 +19436,8 @@ public final class DebugProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ boolean hasFlags(); @@ -19406,6 +19448,8 @@ public final class DebugProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ int getFlags(); @@ -19615,6 +19659,8 @@ public final class DebugProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ public boolean hasFlags() { @@ -19627,6 +19673,8 @@ public final class DebugProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ public int getFlags() { @@ -20110,6 +20158,8 @@ public final class DebugProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ public boolean hasFlags() { @@ -20122,6 +20172,8 @@ public final class DebugProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ public int getFlags() { @@ -20134,6 +20186,8 @@ public final class DebugProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ public Builder setFlags(int value) { @@ -20149,6 +20203,8 @@ public final class DebugProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ public Builder clearFlags() { diff --git a/core/builtins/src/kotlin/Annotations.kt b/core/builtins/src/kotlin/Annotations.kt index 709bf3b50cd..468b5bed1de 100644 --- a/core/builtins/src/kotlin/Annotations.kt +++ b/core/builtins/src/kotlin/Annotations.kt @@ -20,16 +20,6 @@ import kotlin.annotation.AnnotationRetention.BINARY import kotlin.annotation.AnnotationRetention.SOURCE import kotlin.annotation.AnnotationTarget.* -/** - * Marks the annotated class as a data class. The compiler automatically generates - * equals()/hashCode(), toString(), componentN() and copy() functions for data classes. - * See [the Kotlin language documentation](http://kotlinlang.org/docs/reference/data-classes.html) - * for more information. - */ -@Target(CLASS) -@MustBeDocumented -private annotation class data - /** * Marks the annotated class, function, property, variable or parameter as deprecated. * @property message the message explaining the deprecation and recommending an alternative API to use. @@ -90,16 +80,6 @@ public annotation class Extension @Retention(SOURCE) public annotation class Suppress(vararg val names: String) -/** - * Enables the tail call optimization for the annotated function. If the annotated function - * calls itself recursively as the last operation it performs, it will be executed without - * growing the stack depth. Tail call optimization is currently only supported by the JVM - * backend. - */ -@Target(FUNCTION) -@Retention(SOURCE) -private annotation class tailrec - /** * Hides the annotated function, property or constructor from the overload resolution, * thus preventing its usages from newly compiled code, but keeps compiling it @@ -111,15 +91,6 @@ private annotation class tailrec @Deprecated("Use @Deprecated(\"...\", level = DeprecationLevel.HIDDEN) instead", replaceWith = ReplaceWith("@Deprecated(, level = DeprecationLevel.HIDDEN)")) public annotation class HiddenDeclaration -/** - * Marks annotated function as `external`, meaning that it's not implemented - * in Kotlin but rather in a different language (for example, in C/C++ using JNI or JavaScript). - */ -@Target(FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER) -@Retention(SOURCE) -@MustBeDocumented -private annotation class external - /** * Suppresses errors about variance conflict */ diff --git a/core/builtins/src/kotlin/Inline.kt b/core/builtins/src/kotlin/Inline.kt deleted file mode 100644 index 2957e9ed7e4..00000000000 --- a/core/builtins/src/kotlin/Inline.kt +++ /dev/null @@ -1,48 +0,0 @@ -/* - * Copyright 2010-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package kotlin - -/** - * Annotates the parameter of a function annotated as [inline] and forbids inlining of - * function literals passed as arguments for this parameter. - */ -@Target(AnnotationTarget.VALUE_PARAMETER) -@Retention(AnnotationRetention.RUNTIME) -@MustBeDocumented -private annotation class noinline - -/** - * Enables inlining of the annotated function and the function literals that it takes as parameters into the - * calling functions. Inline functions can use reified type parameters, and lambdas passed to inline - * functions can contain non-local returns. - * See the [Kotlin language documentation](http://kotlinlang.org/docs/reference/inline-functions.html) for more information. - * - * @see noinline - * @see crossinline - */ -@Target(AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY) -@Retention(AnnotationRetention.RUNTIME) -@MustBeDocumented -private annotation class inline - -/** - * Forbids use of non-local control flow statements within lambdas passed as arguments for this parameter. - */ -@Target(AnnotationTarget.VALUE_PARAMETER) -@Retention(AnnotationRetention.RUNTIME) -@MustBeDocumented -private annotation class crossinline diff --git a/core/builtins/src/kotlin/annotation/Annotations.kt b/core/builtins/src/kotlin/annotation/Annotations.kt index 040b74808bf..a8b931cd5aa 100644 --- a/core/builtins/src/kotlin/annotation/Annotations.kt +++ b/core/builtins/src/kotlin/annotation/Annotations.kt @@ -76,15 +76,6 @@ public enum class AnnotationRetention { @MustBeDocumented public annotation class Target(vararg val allowedTargets: AnnotationTarget) -/** - * This special meta-annotation is used to declare an annotation. - * So a class in Kotlin is an annotation if and only if it has the "annotation" meta-annotation. - */ -@Target(AnnotationTarget.ANNOTATION_CLASS) -@Retention(AnnotationRetention.SOURCE) -@MustBeDocumented -private annotation class annotation - /** * This meta-annotation determines whether an annotation is stored in binary output and visible for reflection. By default, both are true. * diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java index e16ce126b8e..5b906b530bf 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/JvmAbi.java @@ -35,7 +35,7 @@ public final class JvmAbi { * - Patch version can be increased freely and is only supposed to be used for debugging. Increase the patch version when you * make a change to the metadata format or the bytecode which is both forward- and backward compatible. */ - public static final BinaryVersion VERSION = BinaryVersion.create(0, 31, 0); + public static final BinaryVersion VERSION = BinaryVersion.create(0, 32, 0); public static final String DEFAULT_IMPLS_CLASS_NAME = "DefaultImpls"; public static final String DEFAULT_IMPLS_SUFFIX = "$" + DEFAULT_IMPLS_CLASS_NAME; diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java index 290bc933d09..27df08bcc14 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaMethodDescriptor.java @@ -141,7 +141,8 @@ public class JavaMethodDescriptor extends SimpleFunctionDescriptorImpl implement // 1. creates full copy of descriptor // 2. copies method's type parameters (with new containing declaration) and properly substitute to them in value parameters, return type and etc. JavaMethodDescriptor enhancedMethod = (JavaMethodDescriptor) doSubstitute( - TypeSubstitutor.EMPTY, getContainingDeclaration(), getModality(), getVisibility(), isOperator(), isInfix(), getOriginal(), + TypeSubstitutor.EMPTY, getContainingDeclaration(), getModality(), getVisibility(), + isOperator(), isInfix(), isExternal(), isInline(), isTailrec(), getOriginal(), /* copyOverrides = */ true, getKind(), enhancedValueParameters, enhancedReceiverType, enhancedReturnType ); diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java index 50c6e5f8f18..eed0428eb07 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/JavaPropertyDescriptor.java @@ -76,7 +76,7 @@ public class JavaPropertyDescriptor extends PropertyDescriptorImpl implements Ja if (getter != null) { newGetter = new PropertyGetterDescriptorImpl( enhanced, getter.getAnnotations(), getter.getModality(), getter.getVisibility(), - getter.hasBody(), getter.isDefault(), getKind(), getter, SourceElement.NO_SOURCE); + getter.hasBody(), getter.isDefault(), getter.isExternal(), getKind(), getter, SourceElement.NO_SOURCE); newGetter.initialize(enhancedReturnType); } @@ -85,7 +85,7 @@ public class JavaPropertyDescriptor extends PropertyDescriptorImpl implements Ja if (setter != null) { newSetter = new PropertySetterDescriptorImpl( enhanced, setter.getAnnotations(), setter.getModality(), setter.getVisibility(), - setter.hasBody(), setter.isDefault(), getKind(), setter, SourceElement.NO_SOURCE); + setter.hasBody(), setter.isDefault(), setter.isExternal(), getKind(), setter, SourceElement.NO_SOURCE); newSetter.initialize(setter.getValueParameters().get(0)); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt index 6c24485256a..35428f2dae7 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/descriptors/util.kt @@ -51,6 +51,8 @@ fun copyValueParameters( oldParameter.getName(), newType, oldParameter.declaresDefaultValue(), + oldParameter.isCrossinline, + oldParameter.isNoinline, if (oldParameter.getVarargElementType() != null) newOwner.module.builtIns.getArrayElementType(newType) else null, oldParameter.getSource() ) diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt index c4bfa94eb1f..87bf3669148 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/LazyJavaAnnotations.kt @@ -45,7 +45,6 @@ class LazyJavaAnnotations( override fun iterator() = (annotationOwner.annotations.asSequence().map(annotationDescriptors) - + JavaAnnotationMapper.findMappedJavaAnnotation(KotlinBuiltIns.FQ_NAMES.annotation, annotationOwner, c) + JavaAnnotationMapper.findMappedJavaAnnotation(KotlinBuiltIns.FQ_NAMES.deprecated, annotationOwner, c)).filterNotNull().iterator() override fun isEmpty() = !iterator().hasNext() diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt index 0ed050a9eac..3b568f71e91 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassDescriptor.kt @@ -39,7 +39,7 @@ import org.jetbrains.kotlin.resolve.scopes.JetScope import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.utils.addIfNotNull import org.jetbrains.kotlin.utils.toReadOnlyList -import java.util.ArrayList +import java.util.* class LazyJavaClassDescriptor( private val outerC: LazyJavaResolverContext, @@ -73,6 +73,7 @@ class LazyJavaClassDescriptor( override fun getModality() = modality override fun getVisibility() = visibility override fun isInner() = isInner + override fun isData() = false private val typeConstructor = c.storageManager.createLazyValue { LazyJavaClassTypeConstructor() } override fun getTypeConstructor(): TypeConstructor = typeConstructor() diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt index ecc13574854..02892557b25 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaClassMemberScope.kt @@ -41,7 +41,10 @@ import org.jetbrains.kotlin.load.java.lazy.resolveAnnotations import org.jetbrains.kotlin.load.java.lazy.types.RawSubstitution import org.jetbrains.kotlin.load.java.lazy.types.toAttributes import org.jetbrains.kotlin.load.java.sources.JavaSourceElement -import org.jetbrains.kotlin.load.java.structure.* +import org.jetbrains.kotlin.load.java.structure.JavaArrayType +import org.jetbrains.kotlin.load.java.structure.JavaClass +import org.jetbrains.kotlin.load.java.structure.JavaConstructor +import org.jetbrains.kotlin.load.java.structure.JavaMethod import org.jetbrains.kotlin.load.java.typeEnhacement.enhanceSignatures import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.DescriptorFactory @@ -302,13 +305,15 @@ public class LazyJavaClassMemberScope( propertyDescriptor.setType(getterMethod.returnType!!, listOf(), getDispatchReceiverParameter(), null as JetType?) val getter = DescriptorFactory.createGetter( - propertyDescriptor, getterMethod.annotations, /* isDefault = */false, getterMethod.source + propertyDescriptor, getterMethod.annotations, /* isDefault = */false, + /* isExternal = */ false, getterMethod.source ).apply { initialize(propertyDescriptor.type) } val setter = setterMethod?.let { setterMethod -> - DescriptorFactory.createSetter(propertyDescriptor, setterMethod.annotations, /* isDefault = */false, setterMethod.visibility) + DescriptorFactory.createSetter(propertyDescriptor, setterMethod.annotations, /* isDefault = */false, + /* isExternal = */ false, setterMethod.visibility) } return propertyDescriptor.apply { initialize(getter, setter) } @@ -517,6 +522,8 @@ public class LazyJavaClassMemberScope( // Parameters of annotation constructors in Java are never nullable TypeUtils.makeNotNullable(returnType), method.hasAnnotationParameterDefaultValue(), + /* isCrossinline = */ false, + /* isNoinline = */ false, // Nulls are not allowed in annotation arguments in Java varargElementType?.let { TypeUtils.makeNotNullable(it) }, c.components.sourceElementFactory.source(method) diff --git a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt index 6f03ef904e2..a86b62ef756 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt +++ b/core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt @@ -207,7 +207,9 @@ public abstract class LazyJavaScope( annotations, name, outType, - false, + /* declaresDefaultValue = */ false, + /* isCrossinline = */ false, + /* isNoinline = */ false, varargElementType, c.components.sourceElementFactory.source(javaParameter) ) diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java index a49f0b24ffe..e8d752dd918 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/KotlinBuiltIns.java @@ -138,15 +138,10 @@ public abstract class KotlinBuiltIns { public final FqName throwable = fqName("Throwable"); - public final FqName data = fqName("data"); public final FqName deprecated = fqName("Deprecated"); public final FqName tailRecursive = fqName("tailrec"); - public final FqName inline = fqName("inline"); - public final FqName noinline = fqName("noinline"); - public final FqName crossinline = fqName("crossinline"); public final FqName extension = fqName("Extension"); public final FqName target = annotationName("Target"); - public final FqName annotation = annotationName("annotation"); public final FqName annotationTarget = annotationName("AnnotationTarget"); public final FqName annotationRetention = annotationName("AnnotationRetention"); public final FqName retention = annotationName("Retention"); @@ -429,11 +424,6 @@ public abstract class KotlinBuiltIns { return result instanceof ClassDescriptor ? (ClassDescriptor) result : null; } - @NotNull - public ClassDescriptor getAnnotationAnnotation() { - return getAnnotationClassByName(FQ_NAMES.annotation.shortName()); - } - @NotNull public ClassDescriptor getString() { return getBuiltInClassByName("String"); @@ -856,7 +846,11 @@ public abstract class KotlinBuiltIns { TypeProjection parameterType = parameterTypes.get(i); ValueParameterDescriptorImpl valueParameterDescriptor = new ValueParameterDescriptorImpl( functionDescriptor, null, i, Annotations.Companion.getEMPTY(), - Name.identifier("p" + (i + 1)), parameterType.getType(), false, null, SourceElement.NO_SOURCE + Name.identifier("p" + (i + 1)), parameterType.getType(), + /* declaresDefaultValue = */ false, + /* isCrossinline = */ false, + /* isNoinline = */ false, + null, SourceElement.NO_SOURCE ); valueParameters.add(valueParameterDescriptor); } @@ -1020,32 +1014,14 @@ public abstract class KotlinBuiltIns { return FQ_NAMES.array.equals(getFqName(descriptor)); } - public static boolean isAnnotation(@NotNull ClassDescriptor descriptor) { - return DescriptorUtils.getFqName(descriptor) == FQ_NAMES.annotation.toUnsafe() - || containsAnnotation(descriptor, FQ_NAMES.annotation); - } - public static boolean isCloneable(@NotNull ClassDescriptor descriptor) { return FQ_NAMES.cloneable.equals(getFqName(descriptor)); } - public static boolean isData(@NotNull ClassDescriptor classDescriptor) { - return containsAnnotation(classDescriptor, FQ_NAMES.data); - } - public static boolean isDeprecated(@NotNull DeclarationDescriptor declarationDescriptor) { return containsAnnotation(declarationDescriptor, FQ_NAMES.deprecated); } - public static boolean isTailRecursive(@NotNull DeclarationDescriptor declarationDescriptor) { - return containsAnnotation(declarationDescriptor, FQ_NAMES.tailRecursive); - } - - /** Checks that the symbol represented by the descriptor is annotated with the {@code kotlin.noinline} annotation */ - public static boolean isNoinline(@NotNull DeclarationDescriptor descriptor) { - return containsAnnotation(descriptor, FQ_NAMES.noinline); - } - public static boolean isSuppressAnnotation(@NotNull AnnotationDescriptor annotationDescriptor) { return isConstructedFromGivenClass(annotationDescriptor.getType(), FQ_NAMES.suppress); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt index fb6039b8c3b..98b6902d275 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionClassDescriptor.kt @@ -30,7 +30,7 @@ import org.jetbrains.kotlin.resolve.scopes.StaticScopeForKotlinClass import org.jetbrains.kotlin.storage.StorageManager import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.utils.toReadOnlyList -import java.util.ArrayList +import java.util.* /** * A [ClassDescriptor] representing the fictitious class for a function type, such as kotlin.Function1 or kotlin.reflect.KFunction2. @@ -82,6 +82,7 @@ public class FunctionClassDescriptor( override fun getVisibility() = Visibilities.PUBLIC override fun isCompanionObject() = false override fun isInner() = false + override fun isData() = false override fun getAnnotations() = Annotations.EMPTY override fun getSource() = SourceElement.NO_SOURCE diff --git a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionInvokeDescriptor.kt b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionInvokeDescriptor.kt index b7103583f5f..051ea6877e5 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionInvokeDescriptor.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/builtins/functions/FunctionInvokeDescriptor.kt @@ -46,6 +46,12 @@ public class FunctionInvokeDescriptor private constructor( return FunctionInvokeDescriptor(newOwner, original as FunctionInvokeDescriptor?, kind) } + override fun isExternal(): Boolean = false + + override fun isInline(): Boolean = false + + override fun isTailrec(): Boolean = false + companion object Factory { fun create(functionClass: FunctionClassDescriptor): FunctionInvokeDescriptor { val typeParameters = functionClass.getTypeConstructor().getParameters() @@ -87,6 +93,8 @@ public class FunctionInvokeDescriptor private constructor( Name.identifier(name), typeParameter.getDefaultType(), /* declaresDefaultValue = */ false, + /* isCrossinline = */ false, + /* isNoinline = */ false, /* varargElementType = */ null, SourceElement.NO_SOURCE ) diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassDescriptor.java index a4780e56c3f..e47c536b729 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassDescriptor.java @@ -87,6 +87,8 @@ public interface ClassDescriptor extends ClassifierDescriptor, MemberDescriptor, boolean isCompanionObject(); + boolean isData(); + @NotNull ReceiverParameterDescriptor getThisAsReceiverParameter(); diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/FunctionDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/FunctionDescriptor.java index 605a0aa52ae..320fb1a4331 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/FunctionDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/FunctionDescriptor.java @@ -45,4 +45,10 @@ public interface FunctionDescriptor extends CallableMemberDescriptor { boolean isOperator(); boolean isInfix(); + + boolean isInline(); + + boolean isTailrec(); + + boolean isExternal(); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/PropertyAccessorDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/PropertyAccessorDescriptor.java index 12786105e17..9b1d223eb43 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/PropertyAccessorDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/PropertyAccessorDescriptor.java @@ -45,4 +45,6 @@ public interface PropertyAccessorDescriptor extends FunctionDescriptor { Kind kind, boolean copyOverrides ); + + boolean isExternal(); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ValueParameterDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ValueParameterDescriptor.java index 2893a7e988c..569ce1b7f98 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ValueParameterDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ValueParameterDescriptor.java @@ -59,4 +59,8 @@ public interface ValueParameterDescriptor extends VariableDescriptor, ParameterD @NotNull @Override Collection getOverriddenDescriptors(); + + boolean isCrossinline(); + + boolean isNoinline(); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/annotationUtil.kt b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/annotationUtil.kt index dbe702a4070..1e92ef9c435 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/annotationUtil.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/annotations/annotationUtil.kt @@ -19,17 +19,12 @@ package org.jetbrains.kotlin.descriptors.annotations import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.SourceElement import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor -import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.constants.AnnotationValue import org.jetbrains.kotlin.resolve.constants.ArrayValue import org.jetbrains.kotlin.resolve.constants.StringValue import org.jetbrains.kotlin.types.Variance -// Please synchronize this set with JetTokens.ANNOTATION_MODIFIERS_KEYWORDS_ARRAY -public val ANNOTATION_MODIFIERS_FQ_NAMES: Set = - arrayOf("data", "inline", "noinline", "tailrec", "external", "annotation.annotation", "crossinline").map { FqName("kotlin.$it") }.toSet() - public fun KotlinBuiltIns.createDeprecatedAnnotation(message: String, replaceWith: String): AnnotationDescriptor { val deprecatedAnnotation = deprecatedAnnotation val parameters = deprecatedAnnotation.unsubstitutedPrimaryConstructor!!.valueParameters diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java index 33288e3adaa..64be2dc03b4 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ClassDescriptorImpl.java @@ -133,6 +133,11 @@ public class ClassDescriptorImpl extends ClassDescriptorBase { return Visibilities.PUBLIC; } + @Override + public boolean isData() { + return false; + } + @Override public boolean isInner() { return false; diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java index 836cd323067..98bf3c8025e 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/EnumEntrySyntheticClassDescriptor.java @@ -144,6 +144,11 @@ public class EnumEntrySyntheticClassDescriptor extends ClassDescriptorBase { return false; } + @Override + public boolean isData() { + return false; + } + @Override public boolean isCompanionObject() { return false; diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java index 47784f43381..89e0a36e8f4 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/FunctionDescriptorImpl.java @@ -44,6 +44,9 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo private Visibility visibility = Visibilities.UNKNOWN; private boolean isOperator = false; private boolean isInfix = false; + private boolean isExternal = false; + private boolean isInline = false; + private boolean isTailrec = false; private final Set overriddenFunctions = SmartSet.create(); private final FunctionDescriptor original; private final Kind kind; @@ -110,6 +113,18 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo this.isInfix = isInfix; } + public void setExternal(boolean isExternal) { + this.isExternal = isExternal; + } + + public void setInline(boolean isInline) { + this.isInline = isInline; + } + + public void setTailrec(boolean isTailrec) { + this.isTailrec = isTailrec; + } + public void setReturnType(@NotNull JetType unsubstitutedReturnType) { if (this.unsubstitutedReturnType != null) { // TODO: uncomment and fix tests @@ -170,6 +185,21 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo return false; } + @Override + public boolean isExternal() { + return isExternal; + } + + @Override + public boolean isInline() { + return isInline; + } + + @Override + public boolean isTailrec() { + return isTailrec; + } + @Override public void addOverriddenDescriptor(@NotNull CallableMemberDescriptor overriddenFunction) { overriddenFunctions.add((FunctionDescriptor) overriddenFunction); @@ -219,7 +249,9 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo if (originalSubstitutor.isEmpty()) { return this; } - return doSubstitute(originalSubstitutor, getContainingDeclaration(), modality, visibility, isOperator, isInfix, getOriginal(), true, getKind()); + return doSubstitute(originalSubstitutor, getContainingDeclaration(), modality, visibility, + isOperator, isInfix, isExternal, isInline, isTailrec, + getOriginal(), true, getKind()); } @Nullable @@ -229,12 +261,15 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo @NotNull Visibility newVisibility, boolean isOperator, boolean isInfix, + boolean isExternal, + boolean isInline, + boolean isTailrec, @Nullable FunctionDescriptor original, boolean copyOverrides, @NotNull Kind kind ) { return doSubstitute(originalSubstitutor, - newOwner, newModality, newVisibility, isOperator, isInfix, original, copyOverrides, kind, + newOwner, newModality, newVisibility, isOperator, isInfix, isExternal, isInline, isTailrec, original, copyOverrides, kind, getValueParameters(), getExtensionReceiverParameterType(), getReturnType() ); } @@ -253,6 +288,9 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo @NotNull Visibility newVisibility, boolean isOperator, boolean isInfix, + boolean isExternal, + boolean isInline, + boolean isTailrec, @Nullable FunctionDescriptor original, boolean copyOverrides, @NotNull Kind kind, @@ -317,6 +355,9 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo ); substitutedDescriptor.setOperator(isOperator); substitutedDescriptor.setInfix(isInfix); + substitutedDescriptor.setExternal(isExternal); + substitutedDescriptor.setInline(isInline); + substitutedDescriptor.setTailrec(isTailrec); if (copyOverrides) { for (FunctionDescriptor overriddenFunction : overriddenFunctions) { @@ -362,6 +403,8 @@ public abstract class FunctionDescriptorImpl extends DeclarationDescriptorNonRoo unsubstitutedValueParameter.getName(), substitutedType, unsubstitutedValueParameter.declaresDefaultValue(), + unsubstitutedValueParameter.isCrossinline(), + unsubstitutedValueParameter.isNoinline(), substituteVarargElementType, SourceElement.NO_SOURCE ) diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java index a754ce0cb2a..66f5b3eed75 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/LazySubstitutingClassDescriptor.java @@ -211,6 +211,11 @@ public class LazySubstitutingClassDescriptor implements ClassDescriptor { return original.isInner(); } + @Override + public boolean isData() { + return original.isData(); + } + @Override public boolean isCompanionObject() { return original.isCompanionObject(); diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyAccessorDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyAccessorDescriptorImpl.java index 2b9da990326..fbd1571d4ea 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyAccessorDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyAccessorDescriptorImpl.java @@ -32,6 +32,7 @@ public abstract class PropertyAccessorDescriptorImpl extends DeclarationDescript private final boolean hasBody; private final boolean isDefault; + private final boolean isExternal; private final Modality modality; private final PropertyDescriptor correspondingProperty; private final Kind kind; @@ -45,6 +46,7 @@ public abstract class PropertyAccessorDescriptorImpl extends DeclarationDescript @NotNull Name name, boolean hasBody, boolean isDefault, + boolean isExternal, Kind kind, @NotNull SourceElement source ) { @@ -54,6 +56,7 @@ public abstract class PropertyAccessorDescriptorImpl extends DeclarationDescript this.correspondingProperty = correspondingProperty; this.hasBody = hasBody; this.isDefault = isDefault; + this.isExternal = isExternal; this.kind = kind; } @@ -83,6 +86,21 @@ public abstract class PropertyAccessorDescriptorImpl extends DeclarationDescript return false; } + @Override + public boolean isExternal() { + return isExternal; + } + + @Override + public boolean isInline() { + return false; + } + + @Override + public boolean isTailrec() { + return false; + } + @NotNull @Override public FunctionDescriptor substitute(@NotNull TypeSubstitutor substitutor) { diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java index 1bcb687fe08..3283bc98408 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyDescriptorImpl.java @@ -257,7 +257,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp PropertyGetterDescriptorImpl newGetter = getter == null ? null : new PropertyGetterDescriptorImpl( substitutedDescriptor, getter.getAnnotations(), newModality, convertVisibility(getter.getVisibility(), newVisibility), - getter.hasBody(), getter.isDefault(), kind, original == null ? null : original.getGetter(), SourceElement.NO_SOURCE + getter.hasBody(), getter.isDefault(), getter.isExternal(), kind, original == null ? null : original.getGetter(), SourceElement.NO_SOURCE ); if (newGetter != null) { JetType returnType = getter.getReturnType(); @@ -265,7 +265,7 @@ public class PropertyDescriptorImpl extends VariableDescriptorWithInitializerImp } PropertySetterDescriptorImpl newSetter = setter == null ? null : new PropertySetterDescriptorImpl( substitutedDescriptor, setter.getAnnotations(), newModality, convertVisibility(setter.getVisibility(), newVisibility), - setter.hasBody(), setter.isDefault(), kind, original == null ? null : original.getSetter(), SourceElement.NO_SOURCE + setter.hasBody(), setter.isDefault(), setter.isExternal(), kind, original == null ? null : original.getSetter(), SourceElement.NO_SOURCE ); if (newSetter != null) { List substitutedValueParameters = FunctionDescriptorImpl.getSubstitutedValueParameters( diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyGetterDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyGetterDescriptorImpl.java index 150b1ac7b24..b223def6c00 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyGetterDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertyGetterDescriptorImpl.java @@ -40,13 +40,14 @@ public class PropertyGetterDescriptorImpl extends PropertyAccessorDescriptorImpl @NotNull Visibility visibility, boolean hasBody, boolean isDefault, + boolean isExternal, @NotNull Kind kind, @Nullable PropertyGetterDescriptor original, @NotNull SourceElement source ) { super(modality, visibility, correspondingProperty, annotations, Name.special(""), - hasBody, isDefault, kind, source); + hasBody, isDefault, isExternal, kind, source); this.original = original != null ? original : this; } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertySetterDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertySetterDescriptorImpl.java index efc8c75728d..7db7265cf03 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertySetterDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/PropertySetterDescriptorImpl.java @@ -42,12 +42,13 @@ public class PropertySetterDescriptorImpl extends PropertyAccessorDescriptorImpl @NotNull Visibility visibility, boolean hasBody, boolean isDefault, + boolean isExternal, @NotNull Kind kind, @Nullable PropertySetterDescriptor original, @NotNull SourceElement source ) { super(modality, visibility, correspondingProperty, annotations, Name.special(""), - hasBody, isDefault, kind, source); + hasBody, isDefault, isExternal, kind, source); this.original = original != null ? original : this; } @@ -66,7 +67,11 @@ public class PropertySetterDescriptorImpl extends PropertyAccessorDescriptorImpl @NotNull JetType type ) { return new ValueParameterDescriptorImpl( - setterDescriptor, null, 0, Annotations.Companion.getEMPTY(), Name.special(""), type, false, null, SourceElement.NO_SOURCE + setterDescriptor, null, 0, Annotations.Companion.getEMPTY(), Name.special(""), type, + /* declaresDefaultValue = */ false, + /* isCrossinline = */ false, + /* isNoinline = */ false, + null, SourceElement.NO_SOURCE ); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ScriptCodeDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ScriptCodeDescriptor.java index 2b39f1cd3b0..1ed6cbaebab 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ScriptCodeDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ScriptCodeDescriptor.java @@ -55,4 +55,19 @@ public class ScriptCodeDescriptor extends FunctionDescriptorImpl { public FunctionDescriptor copy(DeclarationDescriptor newOwner, Modality modality, Visibility visibility, Kind kind, boolean copyOverrides) { throw new IllegalStateException("no need to copy script code descriptor"); } + + @Override + public boolean isExternal() { + return false; + } + + @Override + public boolean isInline() { + return false; + } + + @Override + public boolean isTailrec() { + return false; + } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SimpleFunctionDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SimpleFunctionDescriptorImpl.java index bbd824ef4a7..c54877d57aa 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SimpleFunctionDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/SimpleFunctionDescriptorImpl.java @@ -99,7 +99,9 @@ public class SimpleFunctionDescriptorImpl extends FunctionDescriptorImpl impleme boolean copyOverrides ) { return (SimpleFunctionDescriptorImpl) doSubstitute( - TypeSubstitutor.EMPTY, newOwner, modality, visibility, isOperator(), isInfix(), null, copyOverrides, kind + TypeSubstitutor.EMPTY, newOwner, modality, visibility, + isOperator(), isInfix(), isExternal(), isInline(), isTailrec(), + null, copyOverrides, kind ); } } diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.java index 29162ed447c..a3cbc8d4162 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/impl/ValueParameterDescriptorImpl.java @@ -31,6 +31,8 @@ import java.util.Collection; public class ValueParameterDescriptorImpl extends VariableDescriptorImpl implements ValueParameterDescriptor { private final boolean declaresDefaultValue; + private final boolean isCrossinline; + private final boolean isNoinline; private final JetType varargElementType; private final int index; private final ValueParameterDescriptor original; @@ -43,6 +45,8 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme @NotNull Name name, @NotNull JetType outType, boolean declaresDefaultValue, + boolean isCrossinline, + boolean isNoinline, @Nullable JetType varargElementType, @NotNull SourceElement source ) { @@ -50,6 +54,8 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme this.original = original == null ? this : original; this.index = index; this.declaresDefaultValue = declaresDefaultValue; + this.isCrossinline = isCrossinline; + this.isNoinline = isNoinline; this.varargElementType = varargElementType; } @@ -69,6 +75,16 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme return declaresDefaultValue && ((CallableMemberDescriptor) getContainingDeclaration()).getKind().isReal(); } + @Override + public boolean isCrossinline() { + return isCrossinline; + } + + @Override + public boolean isNoinline() { + return isNoinline; + } + @Nullable @Override public JetType getVarargElementType() { @@ -108,7 +124,7 @@ public class ValueParameterDescriptorImpl extends VariableDescriptorImpl impleme @Override public ValueParameterDescriptor copy(@NotNull CallableDescriptor newOwner, @NotNull Name newName) { return new ValueParameterDescriptorImpl( - newOwner, null, index, getAnnotations(), newName, getType(), declaresDefaultValue(), varargElementType, + newOwner, null, index, getAnnotations(), newName, getType(), declaresDefaultValue(), isCrossinline(), isNoinline(), varargElementType, SourceElement.NO_SOURCE ); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt index ef154732dfb..084d9955983 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRenderer.kt @@ -152,7 +152,7 @@ public abstract class DescriptorRenderer : Renderer { ClassKind.INTERFACE -> "interface" ClassKind.ENUM_CLASS -> "enum class" ClassKind.OBJECT -> "object" - ClassKind.ANNOTATION_CLASS -> "class" + ClassKind.ANNOTATION_CLASS -> "annotation class" ClassKind.ENUM_ENTRY -> "enum entry" } } @@ -221,7 +221,8 @@ public enum class DescriptorRendererModifier(val includeByDefault: Boolean) { OVERRIDE(true), ANNOTATIONS(false), INNER(true), - MEMBER_KIND(true) + MEMBER_KIND(true), + DATA(true) ; diff --git a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt index c7ab2232a26..29a2a2d6711 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/renderer/DescriptorRendererImpl.kt @@ -18,7 +18,6 @@ package org.jetbrains.kotlin.renderer import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.descriptors.* -import org.jetbrains.kotlin.descriptors.annotations.ANNOTATION_MODIFIERS_FQ_NAMES import org.jetbrains.kotlin.descriptors.annotations.Annotated import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget @@ -31,7 +30,6 @@ import org.jetbrains.kotlin.resolve.constants.AnnotationValue import org.jetbrains.kotlin.resolve.constants.ArrayValue import org.jetbrains.kotlin.resolve.constants.ConstantValue import org.jetbrains.kotlin.resolve.constants.KClassValue -import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe import org.jetbrains.kotlin.resolve.descriptorUtil.hasDefaultValue import org.jetbrains.kotlin.types.* import org.jetbrains.kotlin.types.ErrorUtils.UninferredParameterTypeConstructor @@ -347,7 +345,7 @@ internal class DescriptorRendererImpl( // See AnnotationResolver.resolveAndAppendAnnotationsFromModifiers for clarification // This hack can be removed when modifiers will be resolved without annotations - val sortedAnnotations = annotated.getAnnotations().getAllAnnotations().sortedBy { p -> p.annotation.isBuiltinModifier() } + val sortedAnnotations = annotated.getAnnotations().getAllAnnotations() for ((annotation, target) in sortedAnnotations) { val annotationClass = annotation.getType().getConstructor().getDeclarationDescriptor() as ClassDescriptor @@ -360,9 +358,6 @@ internal class DescriptorRendererImpl( builder.append(annotationsBuilder) } - private fun AnnotationDescriptor.isBuiltinModifier() - = (type.constructor.declarationDescriptor as ClassDescriptor).fqNameSafe in ANNOTATION_MODIFIERS_FQ_NAMES - override fun renderAnnotation(annotation: AnnotationDescriptor, target: AnnotationUseSiteTarget?): String { return StringBuilder { append('@') @@ -426,6 +421,11 @@ internal class DescriptorRendererImpl( } } + private fun renderData(isData: Boolean, builder: StringBuilder) { + if (DescriptorRendererModifier.DATA !in modifiers || !isData) return + builder.append(renderKeyword("data")).append(" ") + } + private fun renderModalityForCallable(callable: CallableMemberDescriptor, builder: StringBuilder) { if (!DescriptorUtils.isTopLevelDeclaration(callable) || callable.getModality() != Modality.FINAL) { if (overridesSomething(callable) && overrideRenderingPolicy == OverrideRenderingPolicy.RENDER_OVERRIDE && callable.getModality() == Modality.OPEN) { @@ -467,6 +467,15 @@ internal class DescriptorRendererImpl( if (functionDescriptor.isInfix && functionDescriptor.overriddenDescriptors.none { it.isInfix }) { builder.append("infix ") } + if (functionDescriptor.isExternal) { + builder.append("external ") + } + if (functionDescriptor.isInline) { + builder.append("inline ") + } + if (functionDescriptor.isTailrec) { + builder.append("tailrec ") + } } override fun render(declarationDescriptor: DeclarationDescriptor): String { @@ -673,6 +682,13 @@ internal class DescriptorRendererImpl( renderAnnotations(valueParameter, builder) + if (valueParameter.isCrossinline) { + builder.append("crossinline ") + } + if (valueParameter.isNoinline) { + builder.append("noinline ") + } + renderVariable(valueParameter, includeName, builder, topLevel) val withDefaultValue = renderDefaultValues && (if (debugMode) valueParameter.declaresDefaultValue() else valueParameter.hasDefaultValue()) @@ -762,6 +778,7 @@ internal class DescriptorRendererImpl( renderModality(klass.modality, builder) } renderInner(klass.isInner, builder) + renderData(klass.isData, builder) renderClassKindPrefix(klass, builder) } @@ -835,6 +852,11 @@ internal class DescriptorRendererImpl( } } + private fun renderAccessorModifiers(descriptor: PropertyAccessorDescriptor, builder: StringBuilder) { + if (descriptor.isExternal) { + builder.append("external ") + } + } /* STUPID DISPATCH-ONLY VISITOR */ private inner class RenderDeclarationDescriptorVisitor : DeclarationDescriptorVisitor { @@ -852,6 +874,7 @@ internal class DescriptorRendererImpl( override fun visitPropertyGetterDescriptor(descriptor: PropertyGetterDescriptor, builder: StringBuilder) { if (renderAccessors) { + renderAccessorModifiers(descriptor, builder) builder.append("getter for ") renderProperty(descriptor.getCorrespondingProperty(), builder) } @@ -863,6 +886,7 @@ internal class DescriptorRendererImpl( override fun visitPropertySetterDescriptor(descriptor: PropertySetterDescriptor, builder: StringBuilder) { if (renderAccessors) { + renderAccessorModifiers(descriptor, builder) builder.append("setter for ") renderProperty(descriptor.getCorrespondingProperty(), builder) } diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java index a5f4dc9924c..ee921721db9 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorFactory.java @@ -50,16 +50,7 @@ public class DescriptorFactory { @NotNull PropertyDescriptor propertyDescriptor, @NotNull Annotations annotations ) { - return createSetter(propertyDescriptor, annotations, true); - } - - @NotNull - public static PropertySetterDescriptorImpl createSetter( - @NotNull PropertyDescriptor propertyDescriptor, - @NotNull Annotations annotations, - boolean isDefault - ) { - return createSetter(propertyDescriptor, annotations, isDefault, propertyDescriptor.getVisibility()); + return createSetter(propertyDescriptor, annotations, true, false); } @NotNull @@ -67,11 +58,22 @@ public class DescriptorFactory { @NotNull PropertyDescriptor propertyDescriptor, @NotNull Annotations annotations, boolean isDefault, + boolean isExternal + ) { + return createSetter(propertyDescriptor, annotations, isDefault, isExternal, propertyDescriptor.getVisibility()); + } + + @NotNull + public static PropertySetterDescriptorImpl createSetter( + @NotNull PropertyDescriptor propertyDescriptor, + @NotNull Annotations annotations, + boolean isDefault, + boolean isExternal, @NotNull Visibility visibility ) { PropertySetterDescriptorImpl setterDescriptor = new PropertySetterDescriptorImpl(propertyDescriptor, annotations, propertyDescriptor.getModality(), - visibility, !isDefault, isDefault, + visibility, !isDefault, isDefault, isExternal, CallableMemberDescriptor.Kind.DECLARATION, null, propertyDescriptor.getSource()); setterDescriptor.initializeDefault(); return setterDescriptor; @@ -82,15 +84,7 @@ public class DescriptorFactory { @NotNull PropertyDescriptor propertyDescriptor, @NotNull Annotations annotations ) { - return createGetter(propertyDescriptor, annotations, true); - } - - @NotNull - public static PropertyGetterDescriptorImpl createGetter( - @NotNull PropertyDescriptor propertyDescriptor, - @NotNull Annotations annotations, - boolean isDefault) { - return createGetter(propertyDescriptor, annotations, isDefault, propertyDescriptor.getSource()); + return createGetter(propertyDescriptor, annotations, true, false); } @NotNull @@ -98,9 +92,20 @@ public class DescriptorFactory { @NotNull PropertyDescriptor propertyDescriptor, @NotNull Annotations annotations, boolean isDefault, + boolean isExternal + ) { + return createGetter(propertyDescriptor, annotations, isDefault, isExternal, propertyDescriptor.getSource()); + } + + @NotNull + public static PropertyGetterDescriptorImpl createGetter( + @NotNull PropertyDescriptor propertyDescriptor, + @NotNull Annotations annotations, + boolean isDefault, + boolean isExternal, @NotNull SourceElement sourceElement) { return new PropertyGetterDescriptorImpl(propertyDescriptor, annotations, propertyDescriptor.getModality(), - propertyDescriptor.getVisibility(), !isDefault, isDefault, + propertyDescriptor.getVisibility(), !isDefault, isDefault, isExternal, CallableMemberDescriptor.Kind.DECLARATION, null, sourceElement); } @@ -153,7 +158,11 @@ public class DescriptorFactory { SimpleFunctionDescriptorImpl.create(enumClass, Annotations.Companion.getEMPTY(), DescriptorUtils.ENUM_VALUE_OF, CallableMemberDescriptor.Kind.SYNTHESIZED, enumClass.getSource()); ValueParameterDescriptor parameterDescriptor = new ValueParameterDescriptorImpl( - valueOf, null, 0, Annotations.Companion.getEMPTY(), Name.identifier("value"), getBuiltIns(enumClass).getStringType(), false, null, + valueOf, null, 0, Annotations.Companion.getEMPTY(), Name.identifier("value"), getBuiltIns(enumClass).getStringType(), + /* declaresDefaultValue = */ false, + /* isCrossinline = */ false, + /* isNoinline = */ false, + null, enumClass.getSource() ); return valueOf.initialize(null, null, Collections.emptyList(), diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt index a5a19934a6e..aeec7425cdb 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/ConstraintSystemImpl.kt @@ -84,13 +84,14 @@ public class ConstraintSystemImpl : ConstraintSystem { override fun hasContradiction() = hasParameterConstraintError() || hasConflictingConstraints() || hasCannotCaptureTypesError() || hasTypeInferenceIncorporationError() - || hasTypeParameterWithUnsatisfiedOnlyInputTypesError() + override fun hasViolatedUpperBound() = !isSuccessful() && filterConstraintsOut(TYPE_BOUND_POSITION).getStatus().isSuccessful() override fun hasConflictingConstraints() = localTypeParameterBounds.values().any { it.values.size() > 1 } - override fun hasUnknownParameters() = localTypeParameterBounds.values().any { it.values.isEmpty() } + override fun hasUnknownParameters() = + localTypeParameterBounds.values().any { it.values.isEmpty() } || hasTypeParameterWithUnsatisfiedOnlyInputTypesError() override fun hasParameterConstraintError() = errors.any { it is ParameterConstraintError } diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBoundsImpl.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBoundsImpl.kt index dcf8f716105..48331ae483b 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBoundsImpl.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/calls/inference/TypeBoundsImpl.kt @@ -36,10 +36,6 @@ public class TypeBoundsImpl( ) : TypeBounds { override val bounds = ArrayList() - private val typesInBoundsSet: Set by lazy { - bounds.filter { it.isProper }.map { it.constrainingType }.toSet() - } - private var resultValues: Collection? = null var isFixed: Boolean = false @@ -157,7 +153,10 @@ public class TypeBoundsImpl( // a captured type might be an answer if (!possibleAnswer.getConstructor().isDenotable() && !possibleAnswer.isCaptured()) return false - if (typeVariable.hasOnlyInputTypesAnnotation() && !typesInBoundsSet.contains(possibleAnswer)) return false + if (typeVariable.hasOnlyInputTypesAnnotation()) { + val typesInBoundsSet = bounds.filter { it.isProper && it.constrainingType.constructor.isDenotable }.map { it.constrainingType }.toSet() + if (!typesInBoundsSet.contains(possibleAnswer)) return false + } for (bound in bounds) { when (bound.kind) { diff --git a/core/deserialization/src/descriptors.proto b/core/deserialization/src/descriptors.proto index cd0666f32e7..0058407b38c 100644 --- a/core/deserialization/src/descriptors.proto +++ b/core/deserialization/src/descriptors.proto @@ -170,6 +170,7 @@ message Class { Modality ClassKind isInner + isData */ optional int32 flags = 1 [default = 6 /* public final class, no annotations */]; @@ -233,6 +234,9 @@ message Function { MemberKind isOperator isInfix + isInline + isTailrec + isExternal */ optional int32 flags = 1 [default = 6]; @@ -285,6 +289,7 @@ message Property { Visibility Modality isNotDefault + isExternal */ optional int32 getter_flags = 7 /* absent => same as property */; optional int32 setter_flags = 8 /* absent => same as property */; @@ -296,6 +301,8 @@ message ValueParameter { /* declaresDefault hasAnnotations + isCrossinline + isNoinline */ optional int32 flags = 1 [default = 0]; diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/Flags.java b/core/deserialization/src/org/jetbrains/kotlin/serialization/Flags.java index 1cba157e892..941112fd169 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/Flags.java +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/Flags.java @@ -34,6 +34,7 @@ public class Flags { public static final FlagField CLASS_KIND = FlagField.after(MODALITY, ProtoBuf.Class.Kind.values()); public static final BooleanFlagField IS_INNER = FlagField.booleanAfter(CLASS_KIND); + public static final BooleanFlagField IS_DATA = FlagField.booleanAfter(IS_INNER); // Callables @@ -51,6 +52,9 @@ public class Flags { public static final BooleanFlagField IS_OPERATOR = FlagField.booleanAfter(MEMBER_KIND); public static final BooleanFlagField IS_INFIX = FlagField.booleanAfter(IS_OPERATOR); + public static final BooleanFlagField IS_INLINE = FlagField.booleanAfter(IS_INFIX); + public static final BooleanFlagField IS_TAILREC = FlagField.booleanAfter(IS_INLINE); + public static final BooleanFlagField IS_EXTERNAL_FUNCTION = FlagField.booleanAfter(IS_TAILREC); // Properties @@ -64,11 +68,14 @@ public class Flags { // Parameters public static final BooleanFlagField DECLARES_DEFAULT_VALUE = FlagField.booleanAfter(HAS_ANNOTATIONS); + public static final BooleanFlagField IS_CROSSINLINE = FlagField.booleanAfter(DECLARES_DEFAULT_VALUE); + public static final BooleanFlagField IS_NOINLINE = FlagField.booleanAfter(IS_CROSSINLINE); // Accessors // It's important that this flag is negated: "is NOT default" instead of "is default" public static final BooleanFlagField IS_NOT_DEFAULT = FlagField.booleanAfter(MODALITY); + public static final BooleanFlagField IS_EXTERNAL_ACCESSOR = FlagField.booleanAfter(IS_NOT_DEFAULT); // --- @@ -87,13 +94,15 @@ public class Flags { Modality modality, ClassKind kind, boolean inner, - boolean isCompanionObject + boolean isCompanionObject, + boolean isData ) { return HAS_ANNOTATIONS.toFlags(hasAnnotations) | MODALITY.toFlags(modality(modality)) | VISIBILITY.toFlags(visibility(visibility)) | CLASS_KIND.toFlags(classKind(kind, isCompanionObject)) | IS_INNER.toFlags(inner) + | IS_DATA.toFlags(isData) ; } @@ -134,7 +143,10 @@ public class Flags { @NotNull Modality modality, @NotNull CallableMemberDescriptor.Kind memberKind, boolean isOperator, - boolean isInfix + boolean isInfix, + boolean isInline, + boolean isTailrec, + boolean isExternal ) { return HAS_ANNOTATIONS.toFlags(hasAnnotations) | VISIBILITY.toFlags(visibility(visibility)) @@ -142,6 +154,9 @@ public class Flags { | MEMBER_KIND.toFlags(memberKind(memberKind)) | IS_OPERATOR.toFlags(isOperator) | IS_INFIX.toFlags(isInfix) + | IS_INLINE.toFlags(isInline) + | IS_TAILREC.toFlags(isTailrec) + | IS_EXTERNAL_FUNCTION.toFlags(isExternal) ; } @@ -174,12 +189,14 @@ public class Flags { boolean hasAnnotations, @NotNull Visibility visibility, @NotNull Modality modality, - boolean isNotDefault + boolean isNotDefault, + boolean isExternal ) { return HAS_ANNOTATIONS.toFlags(hasAnnotations) | MODALITY.toFlags(modality(modality)) | VISIBILITY.toFlags(visibility(visibility)) | IS_NOT_DEFAULT.toFlags(isNotDefault) + | IS_EXTERNAL_ACCESSOR.toFlags(isExternal) ; } @@ -236,9 +253,16 @@ public class Flags { throw new IllegalArgumentException("Unknown member kind: " + kind); } - public static int getValueParameterFlags(boolean hasAnnotations, boolean declaresDefaultValue) { + public static int getValueParameterFlags( + boolean hasAnnotations, + boolean declaresDefaultValue, + boolean isCrossinline, + boolean isNoinline + ) { return HAS_ANNOTATIONS.toFlags(hasAnnotations) | DECLARES_DEFAULT_VALUE.toFlags(declaresDefaultValue) + | IS_CROSSINLINE.toFlags(isCrossinline) + | IS_NOINLINE.toFlags(isNoinline) ; } diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/ProtoBuf.java b/core/deserialization/src/org/jetbrains/kotlin/serialization/ProtoBuf.java index 2b70abb4c12..e5251b705f3 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/ProtoBuf.java +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/ProtoBuf.java @@ -7186,6 +7186,7 @@ public final class ProtoBuf { *Modality *ClassKind *isInner + *isData * */ boolean hasFlags(); @@ -7199,6 +7200,7 @@ public final class ProtoBuf { *Modality *ClassKind *isInner + *isData * */ int getFlags(); @@ -7697,6 +7699,7 @@ public final class ProtoBuf { *Modality *ClassKind *isInner + *isData * */ public boolean hasFlags() { @@ -7712,6 +7715,7 @@ public final class ProtoBuf { *Modality *ClassKind *isInner + *isData * */ public int getFlags() { @@ -8601,6 +8605,7 @@ public final class ProtoBuf { *Modality *ClassKind *isInner + *isData * */ public boolean hasFlags() { @@ -8616,6 +8621,7 @@ public final class ProtoBuf { *Modality *ClassKind *isInner + *isData * */ public int getFlags() { @@ -8631,6 +8637,7 @@ public final class ProtoBuf { *Modality *ClassKind *isInner + *isData * */ public Builder setFlags(int value) { @@ -8649,6 +8656,7 @@ public final class ProtoBuf { *Modality *ClassKind *isInner + *isData * */ public Builder clearFlags() { @@ -11702,6 +11710,9 @@ public final class ProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ boolean hasFlags(); @@ -11716,6 +11727,9 @@ public final class ProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ int getFlags(); @@ -11975,6 +11989,9 @@ public final class ProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ public boolean hasFlags() { @@ -11991,6 +12008,9 @@ public final class ProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ public int getFlags() { @@ -12596,6 +12616,9 @@ public final class ProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ public boolean hasFlags() { @@ -12612,6 +12635,9 @@ public final class ProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ public int getFlags() { @@ -12628,6 +12654,9 @@ public final class ProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ public Builder setFlags(int value) { @@ -12647,6 +12676,9 @@ public final class ProtoBuf { *MemberKind *isOperator *isInfix + *isInline + *isTailrec + *isExternal * */ public Builder clearFlags() { @@ -13326,6 +13358,7 @@ public final class ProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ boolean hasGetterFlags(); @@ -13338,6 +13371,7 @@ public final class ProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ int getGetterFlags(); @@ -13690,6 +13724,7 @@ public final class ProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ public boolean hasGetterFlags() { @@ -13704,6 +13739,7 @@ public final class ProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ public int getGetterFlags() { @@ -14648,6 +14684,7 @@ public final class ProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ public boolean hasGetterFlags() { @@ -14662,6 +14699,7 @@ public final class ProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ public int getGetterFlags() { @@ -14676,6 +14714,7 @@ public final class ProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ public Builder setGetterFlags(int value) { @@ -14693,6 +14732,7 @@ public final class ProtoBuf { *Visibility *Modality *isNotDefault + *isExternal * */ public Builder clearGetterFlags() { @@ -14758,6 +14798,8 @@ public final class ProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ boolean hasFlags(); @@ -14768,6 +14810,8 @@ public final class ProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ int getFlags(); @@ -14948,6 +14992,8 @@ public final class ProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ public boolean hasFlags() { @@ -14960,6 +15006,8 @@ public final class ProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ public int getFlags() { @@ -15370,6 +15418,8 @@ public final class ProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ public boolean hasFlags() { @@ -15382,6 +15432,8 @@ public final class ProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ public int getFlags() { @@ -15394,6 +15446,8 @@ public final class ProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ public Builder setFlags(int value) { @@ -15409,6 +15463,8 @@ public final class ProtoBuf { * *declaresDefault *hasAnnotations + *isCrossinline + *isNoinline * */ public Builder clearFlags() { diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt index 4a4134d37ee..59199780a71 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/MemberDeserializer.kt @@ -67,6 +67,7 @@ public class MemberDeserializer(private val c: DeserializationContext) { val getter = if (hasGetter) { val getterFlags = proto.getGetterFlags() val isNotDefault = proto.hasGetterFlags() && Flags.IS_NOT_DEFAULT.get(getterFlags) + val isExternal = proto.hasGetterFlags() && Flags.IS_EXTERNAL_ACCESSOR.get(getterFlags) val getter = if (isNotDefault) { PropertyGetterDescriptorImpl( property, @@ -75,6 +76,7 @@ public class MemberDeserializer(private val c: DeserializationContext) { Deserialization.visibility(Flags.VISIBILITY.get(getterFlags)), /* hasBody = */ isNotDefault, /* isDefault = */ !isNotDefault, + /* isExternal = */ isExternal, property.getKind(), null, SourceElement.NO_SOURCE ) } @@ -91,6 +93,7 @@ public class MemberDeserializer(private val c: DeserializationContext) { val setter = if (Flags.HAS_SETTER.get(flags)) { val setterFlags = proto.getSetterFlags() val isNotDefault = proto.hasSetterFlags() && Flags.IS_NOT_DEFAULT.get(setterFlags) + val isExternal = proto.hasSetterFlags() && Flags.IS_EXTERNAL_ACCESSOR.get(setterFlags) if (isNotDefault) { val setter = PropertySetterDescriptorImpl( property, @@ -99,6 +102,7 @@ public class MemberDeserializer(private val c: DeserializationContext) { Deserialization.visibility(Flags.VISIBILITY.get(setterFlags)), /* hasBody = */ isNotDefault, /* isDefault = */ !isNotDefault, + /* isExternal = */ isExternal, property.getKind(), null, SourceElement.NO_SOURCE ) val setterLocal = local.childContext(setter, listOf()) @@ -148,6 +152,9 @@ public class MemberDeserializer(private val c: DeserializationContext) { ) function.isOperator = Flags.IS_OPERATOR.get(proto.flags) function.isInfix = Flags.IS_INFIX.get(proto.flags) + function.isExternal = Flags.IS_EXTERNAL_FUNCTION.get(proto.flags) + function.isInline = Flags.IS_INLINE.get(proto.flags) + function.isTailrec = Flags.IS_TAILREC.get(proto.flags) return function } @@ -212,6 +219,8 @@ public class MemberDeserializer(private val c: DeserializationContext) { c.nameResolver.getName(proto.name), c.typeDeserializer.type(proto.type(c.typeTable)), Flags.DECLARES_DEFAULT_VALUE.get(flags), + Flags.IS_CROSSINLINE.get(flags), + Flags.IS_NOINLINE.get(flags), proto.varargElementType(c.typeTable)?.let { c.typeDeserializer.type(it) }, SourceElement.NO_SOURCE ) diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt index 43e2abbcd56..c9c2c78e750 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedClassDescriptor.kt @@ -54,6 +54,7 @@ public class DeserializedClassDescriptor( private val kind = Deserialization.classKind(kindFromProto) private val isCompanion = kindFromProto == ProtoBuf.Class.Kind.COMPANION_OBJECT private val isInner = Flags.IS_INNER.get(classProto.getFlags()) + private val isData = Flags.IS_DATA.get(classProto.flags) val c = outerContext.childContext(this, classProto.typeParameterList, nameResolver, TypeTable(classProto.typeTable)) @@ -90,6 +91,8 @@ public class DeserializedClassDescriptor( override fun isInner() = isInner + override fun isData() = isData + override fun getAnnotations() = annotations override fun getUnsubstitutedMemberScope() = memberScope diff --git a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedConstructorDescriptor.kt b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedConstructorDescriptor.kt index eddbe6b539c..aef1ca5689e 100644 --- a/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedConstructorDescriptor.kt +++ b/core/deserialization/src/org/jetbrains/kotlin/serialization/deserialization/descriptors/DeserializedConstructorDescriptor.kt @@ -45,4 +45,10 @@ public class DeserializedConstructorDescriptor( annotations, isPrimary, kind, proto, nameResolver, typeTable ) } + + override fun isExternal(): Boolean = false + + override fun isInline(): Boolean = false + + override fun isTailrec(): Boolean = false } diff --git a/generators/infrastructure/counter-padding.kts b/generators/infrastructure/counter-padding.kts new file mode 100644 index 00000000000..ba7bf8cbf10 --- /dev/null +++ b/generators/infrastructure/counter-padding.kts @@ -0,0 +1,63 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +import java.io.File + +fun main(args: Array) { + val filePathDefault = "padded-version.txt" + + if (args.isEmpty() || args.size > 2) { + error("Usage: kotlinc -script counter-padding.kts" + + " " + + " ") + } + + var versionStr = args[0] + + println("Version string: " + versionStr) + + val incrementPartStr = versionStr.takeLastWhile { it.isDigit() } + val versionPrefix = versionStr.take(versionStr.length - incrementPartStr.length) + + val incrementPart = incrementPartStr.toInt() + val padded = java.lang.String.format("%03d", incrementPart) + + var filePath = args.getOrNull(1) ?: filePathDefault + + val result = "${versionPrefix}$padded" + + println("prefix=$versionPrefix incrementPart=$incrementPart result=$padded filePath=$filePath") + + File("$filePath").writeText("$result") +} + +main(args) \ No newline at end of file diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/CallableClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/CallableClsStubBuilder.kt index 3e2ce826333..d41f929acbe 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/CallableClsStubBuilder.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/CallableClsStubBuilder.kt @@ -133,7 +133,7 @@ private class FunctionClsStubBuilder( val modalityModifier = if (isTopLevel) listOf() else listOf(MODALITY) val modifierListStubImpl = createModifierListStubForDeclaration( callableStub, functionProto.flags, - listOf(VISIBILITY, OPERATOR, INFIX) + modalityModifier + listOf(VISIBILITY, OPERATOR, INFIX, EXTERNAL_FUN, INLINE, TAILREC) + modalityModifier ) val annotationIds = c.components.annotationLoader.loadCallableAnnotations( diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt index 76bc5acf9e1..dfe59d02ce1 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClassClsStubBuilder.kt @@ -19,6 +19,7 @@ package org.jetbrains.kotlin.idea.decompiler.stubBuilder import com.intellij.psi.PsiElement import com.intellij.psi.stubs.StubElement import org.jetbrains.kotlin.builtins.KotlinBuiltIns +import org.jetbrains.kotlin.idea.decompiler.stubBuilder.FlagsToModifiers.DATA import org.jetbrains.kotlin.idea.decompiler.stubBuilder.FlagsToModifiers.INNER import org.jetbrains.kotlin.idea.decompiler.stubBuilder.FlagsToModifiers.MODALITY import org.jetbrains.kotlin.idea.decompiler.stubBuilder.FlagsToModifiers.VISIBILITY @@ -87,11 +88,13 @@ private class ClassClsStubBuilder( val relevantFlags = arrayListOf(VISIBILITY) if (isClass()) { relevantFlags.add(INNER) + relevantFlags.add(DATA) relevantFlags.add(MODALITY) } val additionalModifiers = when (classKind) { ProtoBuf.Class.Kind.ENUM_CLASS -> listOf(JetTokens.ENUM_KEYWORD) ProtoBuf.Class.Kind.COMPANION_OBJECT -> listOf(JetTokens.COMPANION_KEYWORD) + ProtoBuf.Class.Kind.ANNOTATION_CLASS -> listOf(JetTokens.ANNOTATION_KEYWORD) else -> listOf() } return createModifierListStubForDeclaration(parent, classProto.getFlags(), relevantFlags, additionalModifiers) diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt index cb5b93c4abe..f463830b532 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/TypeClsStubBuilder.kt @@ -30,6 +30,7 @@ import org.jetbrains.kotlin.psi.* import org.jetbrains.kotlin.psi.stubs.KotlinUserTypeStub import org.jetbrains.kotlin.psi.stubs.elements.JetStubElementTypes import org.jetbrains.kotlin.psi.stubs.impl.* +import org.jetbrains.kotlin.serialization.Flags import org.jetbrains.kotlin.serialization.ProtoBuf import org.jetbrains.kotlin.serialization.ProtoBuf.Type import org.jetbrains.kotlin.serialization.ProtoBuf.Type.Argument.Projection @@ -162,8 +163,13 @@ class TypeClsStubBuilder(private val c: ClsStubBuilderContext) { ) val varargElementType = valueParameterProto.varargElementType(c.typeTable) val typeProto = varargElementType ?: valueParameterProto.type(c.typeTable) - val modifierList = - if (varargElementType != null) createModifierListStub(parameterStub, listOf(JetTokens.VARARG_KEYWORD)) else null + val modifiers = arrayListOf() + + if (varargElementType != null) { modifiers.add(JetTokens.VARARG_KEYWORD) } + if (Flags.IS_CROSSINLINE.get(valueParameterProto.flags)) { modifiers.add(JetTokens.CROSSINLINE_KEYWORD) } + if (Flags.IS_NOINLINE.get(valueParameterProto.flags)) { modifiers.add(JetTokens.NOINLINE_KEYWORD) } + + val modifierList = createModifierListStub(parameterStub, modifiers) val parameterAnnotations = c.components.annotationLoader.loadValueParameterAnnotations( container, callableProto, callableProto.annotatedCallableKind, index, valueParameterProto ) diff --git a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt index 9356b65f25e..37fcc7a8af7 100644 --- a/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt +++ b/idea/idea-analysis/src/org/jetbrains/kotlin/idea/decompiler/stubBuilder/clsStubBuilding.kt @@ -203,6 +203,30 @@ enum class FlagsToModifiers { override fun getModifiers(flags: Int): JetModifierKeywordToken? { return if (Flags.IS_INFIX.get(flags)) JetTokens.INFIX_KEYWORD else null } + }, + + DATA { + override fun getModifiers(flags: Int): JetModifierKeywordToken? { + return if (Flags.IS_DATA.get(flags)) JetTokens.DATA_KEYWORD else null + } + }, + + EXTERNAL_FUN { + override fun getModifiers(flags: Int): JetModifierKeywordToken? { + return if (Flags.IS_EXTERNAL_FUNCTION.get(flags)) JetTokens.EXTERNAL_KEYWORD else null + } + }, + + INLINE { + override fun getModifiers(flags: Int): JetModifierKeywordToken? { + return if (Flags.IS_INLINE.get(flags)) JetTokens.INLINE_KEYWORD else null + } + }, + + TAILREC { + override fun getModifiers(flags: Int): JetModifierKeywordToken? { + return if (Flags.IS_TAILREC.get(flags)) JetTokens.TAILREC_KEYWORD else null + } }; abstract fun getModifiers(flags: Int): JetModifierKeywordToken? diff --git a/idea/src/META-INF/extensions/kotlin2jvm.xml b/idea/src/META-INF/extensions/kotlin2jvm.xml index 03a5b069f0a..2d8dc7f878e 100644 --- a/idea/src/META-INF/extensions/kotlin2jvm.xml +++ b/idea/src/META-INF/extensions/kotlin2jvm.xml @@ -4,9 +4,6 @@ - - - diff --git a/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeClassAnAnnotationClassFix.java b/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeClassAnAnnotationClassFix.java index 8644ea16ad3..41b7a33cfee 100644 --- a/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeClassAnAnnotationClassFix.java +++ b/idea/src/org/jetbrains/kotlin/idea/quickfix/MakeClassAnAnnotationClassFix.java @@ -26,11 +26,11 @@ import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.builtins.KotlinBuiltIns; import org.jetbrains.kotlin.diagnostics.Diagnostic; import org.jetbrains.kotlin.idea.JetBundle; import org.jetbrains.kotlin.idea.core.quickfix.QuickFixUtil; import org.jetbrains.kotlin.idea.references.ReferenceUtilKt; +import org.jetbrains.kotlin.lexer.JetTokens; import org.jetbrains.kotlin.psi.*; public class MakeClassAnAnnotationClassFix extends KotlinQuickFixAction { @@ -84,14 +84,13 @@ public class MakeClassAnAnnotationClassFix extends KotlinQuickFixAction().getName() != annotationName) { + + if (javaClass().getName() != annotationName) { to.addAnnotation(annotationName) } } diff --git a/idea/src/org/jetbrains/kotlin/idea/versions/KotlinRuntimeLibraryUtil.java b/idea/src/org/jetbrains/kotlin/idea/versions/KotlinRuntimeLibraryUtil.java index 0912a0a3793..b98c2ab5ca7 100644 --- a/idea/src/org/jetbrains/kotlin/idea/versions/KotlinRuntimeLibraryUtil.java +++ b/idea/src/org/jetbrains/kotlin/idea/versions/KotlinRuntimeLibraryUtil.java @@ -24,6 +24,7 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.roots.*; import com.intellij.openapi.roots.libraries.Library; import com.intellij.openapi.util.io.FileUtil; +import com.intellij.openapi.util.text.StringUtil; import com.intellij.openapi.vfs.JarFileSystem; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.search.GlobalSearchScope; @@ -225,11 +226,23 @@ public class KotlinRuntimeLibraryUtil { public static String bundledRuntimeVersion(@NotNull String pluginVersion) { int placeToSplit = -1; - for (int i = 1; i < pluginVersion.length(); i++) { - char ch = pluginVersion.charAt(i); - if (Character.isLetter(ch) && pluginVersion.charAt(i - 1) == '.') { - placeToSplit = i - 1; - break; + int ideaPatternIndex = StringUtil.indexOf(pluginVersion, "Idea"); + if (ideaPatternIndex >= 2 && Character.isDigit(pluginVersion.charAt(ideaPatternIndex - 2))) { + placeToSplit = ideaPatternIndex - 1; + } + + int ijPatternIndex = StringUtil.indexOf(pluginVersion, "IJ"); + if (ijPatternIndex >= 2 && Character.isDigit(pluginVersion.charAt(ijPatternIndex - 2))) { + placeToSplit = ijPatternIndex - 1; + } + + if (placeToSplit == -1) { + for (int i = 1; i < pluginVersion.length(); i++) { + char ch = pluginVersion.charAt(i); + if (Character.isLetter(ch) && pluginVersion.charAt(i - 1) == '.') { + placeToSplit = i - 1; + break; + } } } diff --git a/idea/src/org/jetbrains/kotlin/idea/versions/OutdatedKotlinRuntimeNotification.java b/idea/src/org/jetbrains/kotlin/idea/versions/OutdatedKotlinRuntimeNotification.java index b9fb07f17a4..d6c9798af62 100644 --- a/idea/src/org/jetbrains/kotlin/idea/versions/OutdatedKotlinRuntimeNotification.java +++ b/idea/src/org/jetbrains/kotlin/idea/versions/OutdatedKotlinRuntimeNotification.java @@ -246,9 +246,7 @@ public class OutdatedKotlinRuntimeNotification extends AbstractProjectComponent String runtimeVersion = KotlinRuntimeLibraryUtil.bundledRuntimeVersion(); - boolean isOutdated = libraryVersion == null - || libraryVersion.startsWith("internal-") != runtimeVersion.startsWith("internal-") - || VersionComparatorUtil.compare(runtimeVersion, libraryVersion) > 0; + boolean isOutdated = isRuntimeOutdated(libraryVersion, runtimeVersion); if (isOutdated) { outdatedLibraries.add(new VersionedLibrary(library, libraryVersion)); @@ -258,6 +256,12 @@ public class OutdatedKotlinRuntimeNotification extends AbstractProjectComponent return outdatedLibraries; } + public static boolean isRuntimeOutdated(String libraryVersion, String runtimeVersion) { + return libraryVersion == null + || libraryVersion.startsWith("internal-") != runtimeVersion.startsWith("internal-") + || VersionComparatorUtil.compare(runtimeVersion, libraryVersion) > 0; + } + @NotNull public static Runnable showRuntimeJarNotFoundDialog(@NotNull final Project project, final @NotNull String jarName) { return new Runnable() { diff --git a/idea/testData/decompiler/decompiledText/Annotations.expected.kt b/idea/testData/decompiler/decompiledText/Annotations.expected.kt index 505256ae69d..77d0d529a35 100644 --- a/idea/testData/decompiler/decompiledText/Annotations.expected.kt +++ b/idea/testData/decompiler/decompiledText/Annotations.expected.kt @@ -4,7 +4,7 @@ package test @dependency.A @dependency.B @dependency.C public final class Annotations public constructor() { - @dependency.A @dependency.B @dependency.C @kotlin.inline public final val p: @dependency.B kotlin.Int /* compiled code */ + @dependency.A @dependency.B @dependency.C public final val p: @dependency.B kotlin.Int /* compiled code */ - @dependency.A @dependency.B @dependency.C @kotlin.inline public final fun f(@dependency.A @dependency.B @dependency.C i: @dependency.A kotlin.Int): kotlin.Unit { /* compiled code */ } + @dependency.A @dependency.B @dependency.C public final inline fun f(@dependency.A @dependency.B @dependency.C i: @dependency.A kotlin.Int): kotlin.Unit { /* compiled code */ } } \ No newline at end of file diff --git a/idea/testData/decompiler/decompiledText/Annotations/Annotations.kt b/idea/testData/decompiler/decompiledText/Annotations/Annotations.kt index 963e55ac4f2..ce3c60122a2 100644 --- a/idea/testData/decompiler/decompiledText/Annotations/Annotations.kt +++ b/idea/testData/decompiler/decompiledText/Annotations/Annotations.kt @@ -7,5 +7,5 @@ import dependency.* inline @A("f") @B(2) @C fun f(@A("i") @B(3) @C i: @A("int") Int) { } - inline @A("p") @B(3) @C val p: @B(4) Int = 2 + @A("p") @B(3) @C val p: @B(4) Int = 2 } diff --git a/idea/testData/decompiler/decompiledText/Modifiers.expected.kt b/idea/testData/decompiler/decompiledText/Modifiers.expected.kt new file mode 100644 index 00000000000..6cdcdb57a09 --- /dev/null +++ b/idea/testData/decompiler/decompiledText/Modifiers.expected.kt @@ -0,0 +1,14 @@ +// IntelliJ API Decompiler stub source generated from a class file +// Implementation of methods is not available + +package test + +public final data class Modifiers public constructor(x: kotlin.Int) { + public final val x: kotlin.Int /* compiled code */ + + public final operator fun component1(): kotlin.Int { /* compiled code */ } + + public final inline fun inlined(crossinline arg1: () -> kotlin.Unit, noinline arg2: () -> kotlin.Unit): kotlin.Unit { /* compiled code */ } + + public final tailrec fun sum(x: kotlin.Long, sum: kotlin.Long): kotlin.Long { /* compiled code */ } +} diff --git a/idea/testData/decompiler/decompiledText/Modifiers/Modifiers.kt b/idea/testData/decompiler/decompiledText/Modifiers/Modifiers.kt new file mode 100644 index 00000000000..46f5123a019 --- /dev/null +++ b/idea/testData/decompiler/decompiledText/Modifiers/Modifiers.kt @@ -0,0 +1,12 @@ +package test + +data class Modifiers(val x: Int) { + tailrec fun sum(x: Long, sum: Long): Long { + if (x == 0.toLong()) return sum + return sum(x - 1, sum + x) + } + + inline fun inlined(crossinline arg1: ()->Unit, noinline arg2: ()->Unit): Unit {} +} + +annotation class Ann \ No newline at end of file diff --git a/idea/testData/decompiler/decompiledTextJvm/Modifiers.expected.kt b/idea/testData/decompiler/decompiledTextJvm/Modifiers.expected.kt new file mode 100644 index 00000000000..ade7a724e16 --- /dev/null +++ b/idea/testData/decompiler/decompiledTextJvm/Modifiers.expected.kt @@ -0,0 +1,11 @@ +// IntelliJ API Decompiler stub source generated from a class file +// Implementation of methods is not available + +package test + +public final class Modifiers public constructor() { + public final var extVar: kotlin.Int /* compiled code */ + + public final external fun extFun(): kotlin.Unit { /* compiled code */ } +} + diff --git a/idea/testData/decompiler/decompiledTextJvm/Modifiers/Modifiers.kt b/idea/testData/decompiler/decompiledTextJvm/Modifiers/Modifiers.kt new file mode 100644 index 00000000000..f10923c2379 --- /dev/null +++ b/idea/testData/decompiler/decompiledTextJvm/Modifiers/Modifiers.kt @@ -0,0 +1,9 @@ +package test + +class Modifiers { + external fun extFun() + + var extVar: Int = 1 + external get + external set +} diff --git a/idea/testData/decompiler/navigation/decompiled/MainKt.kt b/idea/testData/decompiler/navigation/decompiled/MainKt.kt index fd8839e3489..1ba7ee3ff70 100644 --- a/idea/testData/decompiler/navigation/decompiled/MainKt.kt +++ b/idea/testData/decompiler/navigation/decompiled/MainKt.kt @@ -33,4 +33,4 @@ package testData.libraries [public fun processDouble(d: testData.libraries.Double): kotlin.Unit { /* compiled code */ }] -[@kotlin.inline public fun T.filter(predicate: (T) -> kotlin.Boolean): T? { /* compiled code */ }] \ No newline at end of file +[public inline fun T.filter(predicate: (T) -> kotlin.Boolean): T? { /* compiled code */ }] \ No newline at end of file diff --git a/idea/testData/decompiler/stubBuilder/AnnotationClass/AnnotationClass.txt b/idea/testData/decompiler/stubBuilder/AnnotationClass/AnnotationClass.txt index 4f231a50cc5..cf8bc0020c3 100644 --- a/idea/testData/decompiler/stubBuilder/AnnotationClass/AnnotationClass.txt +++ b/idea/testData/decompiler/stubBuilder/AnnotationClass/AnnotationClass.txt @@ -5,16 +5,7 @@ PsiJetFileStubImpl[package=test.a] REFERENCE_EXPRESSION:[referencedName=a] IMPORT_LIST: CLASS:[fqName=test.a.AnnotationClass, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=true, name=AnnotationClass, superNames=[Annotation]] - MODIFIER_LIST:[public final] - ANNOTATION_ENTRY:[hasValueArguments=false, shortName=annotation] - CONSTRUCTOR_CALLEE: - TYPE_REFERENCE: - USER_TYPE:[isAbsoluteInRootPackage=false] - USER_TYPE:[isAbsoluteInRootPackage=false] - USER_TYPE:[isAbsoluteInRootPackage=false] - REFERENCE_EXPRESSION:[referencedName=kotlin] - REFERENCE_EXPRESSION:[referencedName=annotation] - REFERENCE_EXPRESSION:[referencedName=annotation] + MODIFIER_LIST:[public final annotation] PRIMARY_CONSTRUCTOR: MODIFIER_LIST:[public] VALUE_PARAMETER_LIST: diff --git a/idea/testData/decompiler/stubBuilder/ClassObject/ClassObject.txt b/idea/testData/decompiler/stubBuilder/ClassObject/ClassObject.txt index d6f1d91679d..a4233655fad 100644 --- a/idea/testData/decompiler/stubBuilder/ClassObject/ClassObject.txt +++ b/idea/testData/decompiler/stubBuilder/ClassObject/ClassObject.txt @@ -113,16 +113,7 @@ PsiJetFileStubImpl[package=test.class_object] REFERENCE_EXPRESSION:[referencedName=kotlin] REFERENCE_EXPRESSION:[referencedName=Unit] CLASS:[fqName=test.class_object.ClassObject.B.Companion.C.Companion.D.Companion.Anno, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=false, name=Anno, superNames=[Annotation]] - MODIFIER_LIST:[public final] - ANNOTATION_ENTRY:[hasValueArguments=false, shortName=annotation] - CONSTRUCTOR_CALLEE: - TYPE_REFERENCE: - USER_TYPE:[isAbsoluteInRootPackage=false] - USER_TYPE:[isAbsoluteInRootPackage=false] - USER_TYPE:[isAbsoluteInRootPackage=false] - REFERENCE_EXPRESSION:[referencedName=kotlin] - REFERENCE_EXPRESSION:[referencedName=annotation] - REFERENCE_EXPRESSION:[referencedName=annotation] + MODIFIER_LIST:[public final annotation] PRIMARY_CONSTRUCTOR: MODIFIER_LIST:[public] VALUE_PARAMETER_LIST: diff --git a/idea/testData/decompiler/stubBuilder/DataClass/DataClass.txt b/idea/testData/decompiler/stubBuilder/DataClass/DataClass.txt index 82a38a2011b..4b90a654d32 100644 --- a/idea/testData/decompiler/stubBuilder/DataClass/DataClass.txt +++ b/idea/testData/decompiler/stubBuilder/DataClass/DataClass.txt @@ -7,14 +7,7 @@ PsiJetFileStubImpl[package=a.b.c] REFERENCE_EXPRESSION:[referencedName=c] IMPORT_LIST: CLASS:[fqName=a.b.c.DataClass, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=true, name=DataClass, superNames=[]] - MODIFIER_LIST:[public final] - ANNOTATION_ENTRY:[hasValueArguments=false, shortName=data] - CONSTRUCTOR_CALLEE: - TYPE_REFERENCE: - USER_TYPE:[isAbsoluteInRootPackage=false] - USER_TYPE:[isAbsoluteInRootPackage=false] - REFERENCE_EXPRESSION:[referencedName=kotlin] - REFERENCE_EXPRESSION:[referencedName=data] + MODIFIER_LIST:[public final data] PRIMARY_CONSTRUCTOR: MODIFIER_LIST:[public] VALUE_PARAMETER_LIST: diff --git a/idea/testData/decompiler/stubBuilder/Modifiers/Modifiers.kt b/idea/testData/decompiler/stubBuilder/Modifiers/Modifiers.kt new file mode 100644 index 00000000000..08a9b9fae99 --- /dev/null +++ b/idea/testData/decompiler/stubBuilder/Modifiers/Modifiers.kt @@ -0,0 +1,18 @@ +package test + +data class Modifiers(val x: Int) { + external fun extFun() + + var extVar: Int = 1 + external get + external set + + tailrec fun sum(x: Long, sum: Long): Long { + if (x == 0.toLong()) return sum + return sum(x - 1, sum + x) + } + + inline fun inlined(crossinline arg1: ()->Unit, noinline arg2: ()->Unit): Unit {} + + annotation class Ann +} \ No newline at end of file diff --git a/idea/testData/decompiler/stubBuilder/Modifiers/Modifiers.txt b/idea/testData/decompiler/stubBuilder/Modifiers/Modifiers.txt new file mode 100644 index 00000000000..e3c6379ecb8 --- /dev/null +++ b/idea/testData/decompiler/stubBuilder/Modifiers/Modifiers.txt @@ -0,0 +1,107 @@ +PsiJetFileStubImpl[package=test] + PACKAGE_DIRECTIVE: + REFERENCE_EXPRESSION:[referencedName=test] + IMPORT_LIST: + CLASS:[fqName=test.Modifiers, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=true, name=Modifiers, superNames=[]] + MODIFIER_LIST:[public final data] + PRIMARY_CONSTRUCTOR: + MODIFIER_LIST:[public] + VALUE_PARAMETER_LIST: + VALUE_PARAMETER:[fqName=null, hasDefaultValue=false, hasValOrVar=false, isMutable=false, name=x] + TYPE_REFERENCE: + USER_TYPE:[isAbsoluteInRootPackage=false] + USER_TYPE:[isAbsoluteInRootPackage=false] + REFERENCE_EXPRESSION:[referencedName=kotlin] + REFERENCE_EXPRESSION:[referencedName=Int] + CLASS_BODY: + PROPERTY:[fqName=test.Modifiers.extVar, hasDelegate=false, hasDelegateExpression=false, hasInitializer=false, hasReturnTypeRef=true, isExtension=false, isTopLevel=false, isVar=true, name=extVar] + MODIFIER_LIST:[public final] + TYPE_REFERENCE: + USER_TYPE:[isAbsoluteInRootPackage=false] + USER_TYPE:[isAbsoluteInRootPackage=false] + REFERENCE_EXPRESSION:[referencedName=kotlin] + REFERENCE_EXPRESSION:[referencedName=Int] + PROPERTY:[fqName=test.Modifiers.x, hasDelegate=false, hasDelegateExpression=false, hasInitializer=false, hasReturnTypeRef=true, isExtension=false, isTopLevel=false, isVar=false, name=x] + MODIFIER_LIST:[public final] + TYPE_REFERENCE: + USER_TYPE:[isAbsoluteInRootPackage=false] + USER_TYPE:[isAbsoluteInRootPackage=false] + REFERENCE_EXPRESSION:[referencedName=kotlin] + REFERENCE_EXPRESSION:[referencedName=Int] + FUN:[fqName=test.Modifiers.component1, hasBlockBody=true, hasBody=true, hasTypeParameterListBeforeFunctionName=false, isExtension=false, isTopLevel=false, name=component1] + MODIFIER_LIST:[public final operator] + VALUE_PARAMETER_LIST: + TYPE_REFERENCE: + USER_TYPE:[isAbsoluteInRootPackage=false] + USER_TYPE:[isAbsoluteInRootPackage=false] + REFERENCE_EXPRESSION:[referencedName=kotlin] + REFERENCE_EXPRESSION:[referencedName=Int] + FUN:[fqName=test.Modifiers.extFun, hasBlockBody=true, hasBody=true, hasTypeParameterListBeforeFunctionName=false, isExtension=false, isTopLevel=false, name=extFun] + MODIFIER_LIST:[public final external] + VALUE_PARAMETER_LIST: + TYPE_REFERENCE: + USER_TYPE:[isAbsoluteInRootPackage=false] + USER_TYPE:[isAbsoluteInRootPackage=false] + REFERENCE_EXPRESSION:[referencedName=kotlin] + REFERENCE_EXPRESSION:[referencedName=Unit] + FUN:[fqName=test.Modifiers.inlined, hasBlockBody=true, hasBody=true, hasTypeParameterListBeforeFunctionName=false, isExtension=false, isTopLevel=false, name=inlined] + MODIFIER_LIST:[public final inline] + VALUE_PARAMETER_LIST: + VALUE_PARAMETER:[fqName=null, hasDefaultValue=false, hasValOrVar=false, isMutable=false, name=arg1] + MODIFIER_LIST:[crossinline] + TYPE_REFERENCE: + FUNCTION_TYPE: + VALUE_PARAMETER_LIST: + TYPE_REFERENCE: + USER_TYPE:[isAbsoluteInRootPackage=false] + USER_TYPE:[isAbsoluteInRootPackage=false] + REFERENCE_EXPRESSION:[referencedName=kotlin] + REFERENCE_EXPRESSION:[referencedName=Unit] + VALUE_PARAMETER:[fqName=null, hasDefaultValue=false, hasValOrVar=false, isMutable=false, name=arg2] + MODIFIER_LIST:[noinline] + TYPE_REFERENCE: + FUNCTION_TYPE: + VALUE_PARAMETER_LIST: + TYPE_REFERENCE: + USER_TYPE:[isAbsoluteInRootPackage=false] + USER_TYPE:[isAbsoluteInRootPackage=false] + REFERENCE_EXPRESSION:[referencedName=kotlin] + REFERENCE_EXPRESSION:[referencedName=Unit] + TYPE_REFERENCE: + USER_TYPE:[isAbsoluteInRootPackage=false] + USER_TYPE:[isAbsoluteInRootPackage=false] + REFERENCE_EXPRESSION:[referencedName=kotlin] + REFERENCE_EXPRESSION:[referencedName=Unit] + FUN:[fqName=test.Modifiers.sum, hasBlockBody=true, hasBody=true, hasTypeParameterListBeforeFunctionName=false, isExtension=false, isTopLevel=false, name=sum] + MODIFIER_LIST:[public final tailrec] + VALUE_PARAMETER_LIST: + VALUE_PARAMETER:[fqName=null, hasDefaultValue=false, hasValOrVar=false, isMutable=false, name=x] + TYPE_REFERENCE: + USER_TYPE:[isAbsoluteInRootPackage=false] + USER_TYPE:[isAbsoluteInRootPackage=false] + REFERENCE_EXPRESSION:[referencedName=kotlin] + REFERENCE_EXPRESSION:[referencedName=Long] + VALUE_PARAMETER:[fqName=null, hasDefaultValue=false, hasValOrVar=false, isMutable=false, name=sum] + TYPE_REFERENCE: + USER_TYPE:[isAbsoluteInRootPackage=false] + USER_TYPE:[isAbsoluteInRootPackage=false] + REFERENCE_EXPRESSION:[referencedName=kotlin] + REFERENCE_EXPRESSION:[referencedName=Long] + TYPE_REFERENCE: + USER_TYPE:[isAbsoluteInRootPackage=false] + USER_TYPE:[isAbsoluteInRootPackage=false] + REFERENCE_EXPRESSION:[referencedName=kotlin] + REFERENCE_EXPRESSION:[referencedName=Long] + CLASS:[fqName=test.Modifiers.Ann, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=false, name=Ann, superNames=[Annotation]] + MODIFIER_LIST:[public final annotation] + PRIMARY_CONSTRUCTOR: + MODIFIER_LIST:[public] + VALUE_PARAMETER_LIST: + DELEGATION_SPECIFIER_LIST: + DELEGATOR_SUPER_CLASS: + TYPE_REFERENCE: + USER_TYPE:[isAbsoluteInRootPackage=false] + USER_TYPE:[isAbsoluteInRootPackage=false] + REFERENCE_EXPRESSION:[referencedName=kotlin] + REFERENCE_EXPRESSION:[referencedName=Annotation] + CLASS_BODY: diff --git a/idea/testData/decompiler/stubBuilder/NamedCompanionObject/NamedCompanionObject.txt b/idea/testData/decompiler/stubBuilder/NamedCompanionObject/NamedCompanionObject.txt index f634410b424..384fb97707b 100644 --- a/idea/testData/decompiler/stubBuilder/NamedCompanionObject/NamedCompanionObject.txt +++ b/idea/testData/decompiler/stubBuilder/NamedCompanionObject/NamedCompanionObject.txt @@ -111,16 +111,7 @@ PsiJetFileStubImpl[package=test] REFERENCE_EXPRESSION:[referencedName=kotlin] REFERENCE_EXPRESSION:[referencedName=Unit] CLASS:[fqName=test.NamedCompanionObject.B.NamedInB.C.NamedInC.D.Companion.Anno, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=false, name=Anno, superNames=[Annotation]] - MODIFIER_LIST:[public final] - ANNOTATION_ENTRY:[hasValueArguments=false, shortName=annotation] - CONSTRUCTOR_CALLEE: - TYPE_REFERENCE: - USER_TYPE:[isAbsoluteInRootPackage=false] - USER_TYPE:[isAbsoluteInRootPackage=false] - USER_TYPE:[isAbsoluteInRootPackage=false] - REFERENCE_EXPRESSION:[referencedName=kotlin] - REFERENCE_EXPRESSION:[referencedName=annotation] - REFERENCE_EXPRESSION:[referencedName=annotation] + MODIFIER_LIST:[public final annotation] PRIMARY_CONSTRUCTOR: MODIFIER_LIST:[public] VALUE_PARAMETER_LIST: diff --git a/idea/testData/decompiler/stubBuilder/TypeParams/TypeParams.txt b/idea/testData/decompiler/stubBuilder/TypeParams/TypeParams.txt index 007ad2ea0f2..d6f4ba36af9 100644 --- a/idea/testData/decompiler/stubBuilder/TypeParams/TypeParams.txt +++ b/idea/testData/decompiler/stubBuilder/TypeParams/TypeParams.txt @@ -124,14 +124,7 @@ PsiJetFileStubImpl[package=test] USER_TYPE:[isAbsoluteInRootPackage=false] REFERENCE_EXPRESSION:[referencedName=G1] FUN:[fqName=test.TypeParams.f, hasBlockBody=true, hasBody=true, hasTypeParameterListBeforeFunctionName=true, isExtension=false, isTopLevel=false, name=f] - MODIFIER_LIST:[public final] - ANNOTATION_ENTRY:[hasValueArguments=false, shortName=inline] - CONSTRUCTOR_CALLEE: - TYPE_REFERENCE: - USER_TYPE:[isAbsoluteInRootPackage=false] - USER_TYPE:[isAbsoluteInRootPackage=false] - REFERENCE_EXPRESSION:[referencedName=kotlin] - REFERENCE_EXPRESSION:[referencedName=inline] + MODIFIER_LIST:[public final inline] TYPE_PARAMETER_LIST: TYPE_PARAMETER:[fqName=null, isInVariance=false, isOutVariance=false, name=G] MODIFIER_LIST:[reified] diff --git a/idea/testData/editor/quickDoc/MethodFromStdLib.kt b/idea/testData/editor/quickDoc/MethodFromStdLib.kt index a2e473d84fc..e699c32c094 100644 --- a/idea/testData/editor/quickDoc/MethodFromStdLib.kt +++ b/idea/testData/editor/quickDoc/MethodFromStdLib.kt @@ -2,4 +2,4 @@ fun test() { listOf(1, 2, 4).filter { it > 0 } } -//INFO: @inline public fun <T> Iterable<T>.filter(predicate: (T) → Boolean): List<T> defined in kotlin +//INFO: public inline fun <T> Iterable<T>.filter(predicate: (T) → Boolean): List<T> defined in kotlin

Returns a list containing all elements matching the given predicate.

diff --git a/idea/tests/org/jetbrains/kotlin/idea/OutdatedKotlinRuntimeNotificationTest.kt b/idea/tests/org/jetbrains/kotlin/idea/OutdatedKotlinRuntimeNotificationTest.kt index 1ebe3e29db5..144f3ce28fb 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/OutdatedKotlinRuntimeNotificationTest.kt +++ b/idea/tests/org/jetbrains/kotlin/idea/OutdatedKotlinRuntimeNotificationTest.kt @@ -34,6 +34,50 @@ public class KotlinRuntimeLibraryUtilTest : TestCase() { test("internal-0.1.2", "internal-0.1.2") test(".0.1.2", ".0.1.2") test("0.1.2.", "0.1.2.") + + test("1.0.0-beta1-001-Idea141-12", "1.0.0-beta1-001") + test("1.0.1-beta5-013-Idea143-1", "1.0.1-beta5-013") + test("1.0.1-beta1-2-Idea143-1", "1.0.1-beta1-2") + test("1.0.3-beta1-2", "1.0.3-beta1-2") + + test("1.0.0-beta1-001-IJ143-12", "1.0.0-beta1-001") + test("1.0.1-beta5-013-IJ142-1", "1.0.1-beta5-013") + test("1.0.1-beta1-2-IJ-2-1", "1.0.1-beta1-2") + test("1.0.3-beta1-2-IJ", "1.0.3-beta1-2") + + test("2.15.789-Idea147-14", "2.15.789") + + test("1.0.0-alpha", "1.0.0-alpha") + test("1.2.2123-alpha-023", "1.2.2123-alpha-023") + } + + public fun testOutdatedRuntime() { + outdated("1.0.0-beta1-001-Idea141-12", "0.12.15") + outdated("1.0.0-beta1-001-Idea141-1", "0.152.16") + outdated("1.0.0-beta1-001-Idea141-1", "0.152.16") + + notOutdated("1.0.0-beta1-001-Idea141-12", "1.0.0-beta1-001") + notOutdated("1.0.0-beta1-001-Idea143-14", "1.0.0-beta1-001") + notOutdated("1.0.0-beta1-001", "1.0.0-beta1-001") + notOutdated("1.0.0-beta1-001-Idea3-1", "1.0.0-beta1-001") + notOutdated("1.0.0-beta1-001-Idea3-(1)", "1.0.0-beta1-001") + + outdated("1.0.0-beta1-002-Idea141-1", "1.0.0-beta1-001") + outdated("1.0.0-beta1-010-Idea141-1", "1.0.0-beta1-009") + outdated("1.0.0-beta1-100-Idea141-1", "1.0.0-beta1-099") + outdated("1.0.0-beta2-000-Idea141-1", "1.0.0-beta1-999") + outdated("1.1.0-beta1-000-Idea141-1", "1.0.9-beta9-999") + outdated("2.0.0-beta1-000-Idea141-1", "1.9.9-beta9-999") + } + + private fun outdated(plugin: String, library: String) { + Assert.assertTrue("Should be outdated: plugin=$plugin, library=$library", + OutdatedKotlinRuntimeNotification.isRuntimeOutdated(library, KotlinRuntimeLibraryUtil.bundledRuntimeVersion(plugin))) + } + + private fun notOutdated(plugin: String, library: String) { + Assert.assertFalse("Should NOT be outdated: plugin=$plugin, library=$library", + OutdatedKotlinRuntimeNotification.isRuntimeOutdated(library, KotlinRuntimeLibraryUtil.bundledRuntimeVersion(plugin))) } private fun test(version: String, expected: String) { diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java index 64d09bf7141..3c431cec5e8 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java @@ -113,6 +113,12 @@ public class ClsStubBuilderTestGenerated extends AbstractClsStubBuilderTest { doTest(fileName); } + @TestMetadata("Modifiers") + public void testModifiers() throws Exception { + String fileName = JetTestUtils.navigationMetadata("idea/testData/decompiler/stubBuilder/Modifiers/"); + doTest(fileName); + } + @TestMetadata("MultifileClass") public void testMultifileClass() throws Exception { String fileName = JetTestUtils.navigationMetadata("idea/testData/decompiler/stubBuilder/MultifileClass/"); diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextFromJsMetadataTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextFromJsMetadataTestGenerated.java index 9197fea28ae..d3da0ade15b 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextFromJsMetadataTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextFromJsMetadataTestGenerated.java @@ -107,6 +107,12 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom doTest(fileName); } + @TestMetadata("Modifiers") + public void testModifiers() throws Exception { + String fileName = JetTestUtils.navigationMetadata("idea/testData/decompiler/decompiledText/Modifiers/"); + doTest(fileName); + } + @TestMetadata("Object") public void testObject() throws Exception { String fileName = JetTestUtils.navigationMetadata("idea/testData/decompiler/decompiledText/Object/"); diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextTestGenerated.java index 8ce0b30cf3a..b8ebbb7770a 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextTestGenerated.java @@ -95,6 +95,12 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT doTest(fileName); } + @TestMetadata("Modifiers") + public void testModifiers() throws Exception { + String fileName = JetTestUtils.navigationMetadata("idea/testData/decompiler/decompiledText/Modifiers/"); + doTest(fileName); + } + @TestMetadata("NestedClasses") public void testNestedClasses() throws Exception { String fileName = JetTestUtils.navigationMetadata("idea/testData/decompiler/decompiledText/NestedClasses/"); diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/JvmDecompiledTextTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/JvmDecompiledTextTestGenerated.java index ca5d31e0ebd..3bb8ee878a2 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/JvmDecompiledTextTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/JvmDecompiledTextTestGenerated.java @@ -35,6 +35,12 @@ public class JvmDecompiledTextTestGenerated extends AbstractJvmDecompiledTextTes JetTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/decompiler/decompiledTextJvm"), Pattern.compile("^([^\\.]+)$"), true); } + @TestMetadata("Modifiers") + public void testModifiers() throws Exception { + String fileName = JetTestUtils.navigationMetadata("idea/testData/decompiler/decompiledTextJvm/Modifiers/"); + doTest(fileName); + } + @TestMetadata("MultifileClass") public void testMultifileClass() throws Exception { String fileName = JetTestUtils.navigationMetadata("idea/testData/decompiler/decompiledTextJvm/MultifileClass/"); diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt index d7aeaf112a9..3de1a1a4800 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt @@ -27,17 +27,15 @@ import org.jetbrains.jps.incremental.ModuleBuildTarget import org.jetbrains.jps.incremental.storage.BuildDataManager import org.jetbrains.jps.incremental.storage.PathStringDescriptor import org.jetbrains.jps.incremental.storage.StorageOwner +import org.jetbrains.kotlin.inline.inlineFunctionsJvmNames import org.jetbrains.kotlin.jps.build.GeneratedJvmClass import org.jetbrains.kotlin.jps.build.KotlinBuilder import org.jetbrains.kotlin.jps.incremental.storage.BasicMap import org.jetbrains.kotlin.jps.incremental.storage.BasicStringMap -import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass import org.jetbrains.kotlin.load.kotlin.ModuleMapping -import org.jetbrains.kotlin.load.kotlin.PackageClassUtils import org.jetbrains.kotlin.load.kotlin.header.* import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache import org.jetbrains.kotlin.load.kotlin.incremental.components.JvmPackagePartProto -import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.resolve.jvm.JvmClassName import org.jetbrains.kotlin.resolve.jvm.JvmClassName.byInternalName import org.jetbrains.kotlin.serialization.jvm.BitEncoding @@ -49,8 +47,6 @@ import java.io.File import java.security.MessageDigest import java.util.* -val INLINE_ANNOTATION_DESC = "Lkotlin/inline;" - internal val CACHE_DIRECTORY_NAME = "kotlin" @TestOnly @@ -451,26 +447,21 @@ public class IncrementalCacheImpl( private fun getInlineFunctionsMap(bytes: ByteArray): Map { val result = HashMap() + val inlineFunctions = inlineFunctionsJvmNames(bytes) + if (inlineFunctions.isEmpty()) return emptyMap() + ClassReader(bytes).accept(object : ClassVisitor(Opcodes.ASM5) { override fun visitMethod(access: Int, name: String, desc: String, signature: String?, exceptions: Array?): MethodVisitor? { val dummyClassWriter = ClassWriter(Opcodes.ASM5) + return object : MethodVisitor(Opcodes.ASM5, dummyClassWriter.visitMethod(0, name, desc, null, exceptions)) { - var hasInlineAnnotation = false - - override fun visitAnnotation(desc: String, visible: Boolean): AnnotationVisitor? { - if (desc == INLINE_ANNOTATION_DESC) { - hasInlineAnnotation = true - } - return null - } - override fun visitEnd() { - if (hasInlineAnnotation) { - val dummyBytes = dummyClassWriter.toByteArray()!! - val hash = dummyBytes.md5() + val jvmName = name + desc + if (jvmName !in inlineFunctions) return - result[name + desc] = hash - } + val dummyBytes = dummyClassWriter.toByteArray()!! + val hash = dummyBytes.md5() + result[jvmName] = hash } } } diff --git a/jps-plugin/test/org/jetbrains/kotlin/jps/build/IncrementalLazyCachesTestGenerated.java b/jps-plugin/test/org/jetbrains/kotlin/jps/build/IncrementalLazyCachesTestGenerated.java index 2460cccbdca..2b29dff9834 100644 --- a/jps-plugin/test/org/jetbrains/kotlin/jps/build/IncrementalLazyCachesTestGenerated.java +++ b/jps-plugin/test/org/jetbrains/kotlin/jps/build/IncrementalLazyCachesTestGenerated.java @@ -71,4 +71,10 @@ public class IncrementalLazyCachesTestGenerated extends AbstractIncrementalLazyC doTest(fileName); } + @TestMetadata("topLevelPropertyAccess") + public void testTopLevelPropertyAccess() throws Exception { + String fileName = JetTestUtils.navigationMetadata("jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/"); + doTest(fileName); + } + } diff --git a/jps-plugin/testData/incremental/lazyKotlinCaches/constant/build.log b/jps-plugin/testData/incremental/lazyKotlinCaches/constant/build.log index b539afde438..b9269ba28f4 100644 --- a/jps-plugin/testData/incremental/lazyKotlinCaches/constant/build.log +++ b/jps-plugin/testData/incremental/lazyKotlinCaches/constant/build.log @@ -7,8 +7,10 @@ src/constant.kt End of files Cleaning output files: out/production/module/META-INF/module.kotlin_module +out/production/module/constant/ConstantKt.class out/production/module/usage/UsageKt.class End of files Compiling files: +src/constant.kt src/usage.kt End of files \ No newline at end of file diff --git a/jps-plugin/testData/incremental/lazyKotlinCaches/constant/constant.kt b/jps-plugin/testData/incremental/lazyKotlinCaches/constant/constant.kt index 5bb00251bf3..d86254c6145 100644 --- a/jps-plugin/testData/incremental/lazyKotlinCaches/constant/constant.kt +++ b/jps-plugin/testData/incremental/lazyKotlinCaches/constant/constant.kt @@ -1,3 +1,3 @@ package constant -val X = 10 \ No newline at end of file +const val X = 10 \ No newline at end of file diff --git a/jps-plugin/testData/incremental/lazyKotlinCaches/constant/constant.kt.new b/jps-plugin/testData/incremental/lazyKotlinCaches/constant/constant.kt.new index 922484aea23..e068bc3b724 100644 --- a/jps-plugin/testData/incremental/lazyKotlinCaches/constant/constant.kt.new +++ b/jps-plugin/testData/incremental/lazyKotlinCaches/constant/constant.kt.new @@ -1,3 +1,3 @@ package constant -val X = 11 \ No newline at end of file +const val X = 11 \ No newline at end of file diff --git a/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/build.log b/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/build.log new file mode 100644 index 00000000000..2914423d765 --- /dev/null +++ b/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/build.log @@ -0,0 +1,7 @@ +Cleaning output files: +out/production/module/META-INF/module.kotlin_module +out/production/module/constant/ConstantKt.class +End of files +Compiling files: +src/constant.kt +End of files \ No newline at end of file diff --git a/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/constant.kt b/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/constant.kt new file mode 100644 index 00000000000..5bb00251bf3 --- /dev/null +++ b/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/constant.kt @@ -0,0 +1,3 @@ +package constant + +val X = 10 \ No newline at end of file diff --git a/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/constant.kt.new b/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/constant.kt.new new file mode 100644 index 00000000000..922484aea23 --- /dev/null +++ b/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/constant.kt.new @@ -0,0 +1,3 @@ +package constant + +val X = 11 \ No newline at end of file diff --git a/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/expected-kotlin-caches.txt b/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/expected-kotlin-caches.txt new file mode 100644 index 00000000000..89837f47189 --- /dev/null +++ b/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/expected-kotlin-caches.txt @@ -0,0 +1,6 @@ +Module 'module' production + format-version.txt + package-parts.tab + proto.tab + source-to-classes.tab +Module 'module' tests \ No newline at end of file diff --git a/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/usage.kt b/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/usage.kt new file mode 100644 index 00000000000..4a70ee33065 --- /dev/null +++ b/jps-plugin/testData/incremental/lazyKotlinCaches/topLevelPropertyAccess/usage.kt @@ -0,0 +1,4 @@ +package usage + +fun f(): Int = + constant.X \ No newline at end of file diff --git a/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/build.log b/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/build.log index 60df58144eb..78dbad6abae 100644 --- a/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/build.log +++ b/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/build.log @@ -1,6 +1,6 @@ Cleaning output files: out/production/module/META-INF/module.kotlin_module -out/production/module/inline/InlineKt.class +out/production/module/test/InlineKt.class End of files Compiling files: End of files @@ -12,4 +12,4 @@ Compiling files: src/usage.kt End of files COMPILATION FAILED -Unresolved reference: f \ No newline at end of file +Unresolved reference: test \ No newline at end of file diff --git a/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/inline.kt b/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/inline.kt index 80d71e901a3..fb5e59f5432 100644 --- a/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/inline.kt +++ b/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/inline.kt @@ -1,4 +1,4 @@ -package inline +package test inline fun f(body: () -> Unit) { println("i'm inline function") diff --git a/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/usage.kt b/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/usage.kt index 6e64d97cde2..98840f6537a 100644 --- a/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/usage.kt +++ b/jps-plugin/testData/incremental/pureKotlin/fileWithInlineFunctionRemoved/usage.kt @@ -1,7 +1,7 @@ package usage fun main(args: Array) { - inline.f { + test.f { println("to be inlined") } } diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.kt index 4e12ae168db..f7c54f91906 100644 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.kt +++ b/js/js.translator/src/org/jetbrains/kotlin/js/translate/declaration/ClassTranslator.kt @@ -112,7 +112,7 @@ public class ClassTranslator private constructor( bodyVisitor.traverseContainer(classDeclaration, context) delegationTranslator.generateDelegated(properties) - if (KotlinBuiltIns.isData(descriptor)) { + if (descriptor.isData) { JsDataClassGenerator(classDeclaration, context, properties).generate() } diff --git a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/InlineAnnotation.kt b/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/InlineAnnotation.kt deleted file mode 100644 index 72286f9eb16..00000000000 --- a/js/js.translator/src/org/jetbrains/kotlin/js/translate/utils/InlineAnnotation.kt +++ /dev/null @@ -1,22 +0,0 @@ -/* - * Copyright 2010-2015 JetBrains s.r.o. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.jetbrains.kotlin.js.translate.utils - -enum class InlineAnnotation(val fqName: String) { - INLINE("kotlin.inline"), - NO_INLINE("kotlin.noinline") -} diff --git a/js/js.translator/testData/expression/misc/cases/KT-2314.kt b/js/js.translator/testData/expression/misc/cases/KT-2314.kt index dd5277482bc..365dbee22e5 100644 --- a/js/js.translator/testData/expression/misc/cases/KT-2314.kt +++ b/js/js.translator/testData/expression/misc/cases/KT-2314.kt @@ -19,7 +19,7 @@ inline public fun myArrayList(vararg values: T): ArrayList { return c } -inline public val ArrayList.myHead: T +public val ArrayList.myHead: T get() { return get(0) } diff --git a/libraries/stdlib/src/kotlin/internal/Annotations.kt b/libraries/stdlib/src/kotlin/internal/Annotations.kt index ddc4b0adaa1..1ff19c7ce47 100644 --- a/libraries/stdlib/src/kotlin/internal/Annotations.kt +++ b/libraries/stdlib/src/kotlin/internal/Annotations.kt @@ -20,25 +20,26 @@ package kotlin.internal * Specifies that the corresponding type should be ignored during type inference. */ @Target(AnnotationTarget.TYPE) -@Retention(AnnotationRetention.SOURCE) +@Retention(AnnotationRetention.BINARY) internal annotation class NoInfer /** * Specifies that the constraint built for the type during type inference should be an equality one. */ @Target(AnnotationTarget.TYPE) -@Retention(AnnotationRetention.SOURCE) +@Retention(AnnotationRetention.BINARY) internal annotation class Exact /** * Specifies that a corresponding member has the lowest priority in overload resolution. */ @Target(AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY) +@Retention(AnnotationRetention.BINARY) internal annotation class LowPriorityInOverloadResolution /** * The value of this type parameter should be mentioned in input types (argument types, receiver type or expected type). */ @Target(AnnotationTarget.TYPE_PARAMETER) -@Retention(AnnotationRetention.SOURCE) +@Retention(AnnotationRetention.BINARY) internal annotation class OnlyInputTypes \ No newline at end of file diff --git a/libraries/stdlib/src/kotlin/jvm/JvmFlagAnnotations.kt b/libraries/stdlib/src/kotlin/jvm/JvmFlagAnnotations.kt index 30fa040ba32..b269039b78f 100644 --- a/libraries/stdlib/src/kotlin/jvm/JvmFlagAnnotations.kt +++ b/libraries/stdlib/src/kotlin/jvm/JvmFlagAnnotations.kt @@ -54,13 +54,4 @@ public annotation class Strictfp @Target(FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER) @Retention(AnnotationRetention.SOURCE) @MustBeDocumented -public annotation class Synchronized - -/** - * Marks the JVM method generated from the annotated function as `native`, meaning that it's not implemented - * in Java but rather in a different language (for example, in C/C++ using JNI). - */ -@Target(FUNCTION, PROPERTY_GETTER, PROPERTY_SETTER) -@Retention(AnnotationRetention.SOURCE) -@MustBeDocumented -public annotation class native +public annotation class Synchronized \ No newline at end of file diff --git a/plugins/annotation-collector/testData/collectToFile/annotatedGettersSetters/annotations.txt b/plugins/annotation-collector/testData/collectToFile/annotatedGettersSetters/annotations.txt index dfd5d00c039..98f62b39b86 100644 --- a/plugins/annotation-collector/testData/collectToFile/annotatedGettersSetters/annotations.txt +++ b/plugins/annotation-collector/testData/collectToFile/annotatedGettersSetters/annotations.txt @@ -1,16 +1,14 @@ -a kotlin.data 0 +a java.lang.Deprecated 0 p org.test 0 -c 0 0/SomeClass -a java.lang.Deprecated 1 -m 1 0/SomeClass getImmutableProperty -a org.jetbrains.annotations.NotNull 2 -f 2 0/SomeClass mutableProperty +m 0 0/SomeClass getImmutableProperty +a org.jetbrains.annotations.NotNull 1 +f 1 0/SomeClass mutableProperty +m 0 0/SomeClass getMutableProperty m 1 0/SomeClass getMutableProperty -m 2 0/SomeClass getMutableProperty -m 1 0/SomeClass setMutableProperty -a org.jetbrains.annotations.Nullable 3 -f 3 0/SomeClass arg -m 3 0/SomeClass getArg -m 3 0/SomeClass component1 -m 2 0/SomeClass copy -m 2 0/SomeClass copy$default +m 0 0/SomeClass setMutableProperty +a org.jetbrains.annotations.Nullable 2 +f 2 0/SomeClass arg +m 2 0/SomeClass getArg +m 2 0/SomeClass component1 +m 1 0/SomeClass copy +m 1 0/SomeClass copy$default diff --git a/plugins/annotation-collector/testData/collectToFile/defaultPackage/annotations.txt b/plugins/annotation-collector/testData/collectToFile/defaultPackage/annotations.txt index 448be6bec88..ff4eed9936a 100644 --- a/plugins/annotation-collector/testData/collectToFile/defaultPackage/annotations.txt +++ b/plugins/annotation-collector/testData/collectToFile/defaultPackage/annotations.txt @@ -1,16 +1,12 @@ -a kotlin.data 0 -c 0 SomeClass -a java.lang.Deprecated 1 +a java.lang.Deprecated 0 +f 0 SomeClass annotatedProperty +a org.jetbrains.annotations.Nullable 1 f 1 SomeClass annotatedProperty -a org.jetbrains.annotations.Nullable 2 -f 2 SomeClass annotatedProperty -m 2 SomeClass getAnnotatedProperty -m 1 SomeClass annotatedFunction -a kotlin.inline 3 -m 3 SomeClass annotatedFunction -f 2 SomeClass arg -m 2 SomeClass getArg -m 2 SomeClass component1 -a org.jetbrains.annotations.NotNull 4 -m 4 SomeClass copy -m 4 SomeClass copy$default +m 1 SomeClass getAnnotatedProperty +m 0 SomeClass annotatedFunction +f 1 SomeClass arg +m 1 SomeClass getArg +m 1 SomeClass component1 +a org.jetbrains.annotations.NotNull 2 +m 2 SomeClass copy +m 2 SomeClass copy$default diff --git a/plugins/annotation-collector/testData/collectToFile/localClasses/annotations.txt b/plugins/annotation-collector/testData/collectToFile/localClasses/annotations.txt index 68e69348eee..c916765a87b 100644 --- a/plugins/annotation-collector/testData/collectToFile/localClasses/annotations.txt +++ b/plugins/annotation-collector/testData/collectToFile/localClasses/annotations.txt @@ -5,5 +5,3 @@ f 0 0/SomeClass$someFunction$LocalClass annotatedProperty a org.jetbrains.annotations.Nullable 1 f 1 0/SomeClass$someFunction$LocalClass annotatedProperty m 1 0/SomeClass$someFunction$LocalClass getAnnotatedProperty -a kotlin.inline 2 -m 2 0/SomeClass$someFunction$LocalClass annotatedFunction diff --git a/plugins/annotation-collector/testData/collectToFile/platformStatic/annotations.txt b/plugins/annotation-collector/testData/collectToFile/platformStatic/annotations.txt index 2c683a6adf5..c9029b62969 100644 --- a/plugins/annotation-collector/testData/collectToFile/platformStatic/annotations.txt +++ b/plugins/annotation-collector/testData/collectToFile/platformStatic/annotations.txt @@ -1,7 +1,4 @@ a kotlin.jvm.JvmStatic 0 p org.test 0 m 0 0/SomeClass$Companion a -a kotlin.inline 1 -m 1 0/SomeClass$Companion a m 0 0/SomeClass a -m 1 0/SomeClass a diff --git a/update_dependencies.xml b/update_dependencies.xml index 10ad5e4747b..0519547a0ac 100644 --- a/update_dependencies.xml +++ b/update_dependencies.xml @@ -1,7 +1,7 @@ - + @@ -13,6 +13,9 @@ + + +

Returns a list containing all elements matching the given predicate.