From 7553d3f72b31aacd432d17b2500dbf3379fbde95 Mon Sep 17 00:00:00 2001 From: Denis Zharkov Date: Tue, 25 Oct 2016 17:13:43 +0300 Subject: [PATCH] Intoduce and support DslMarker annotation #KT-11551 In Progress --- .../jetbrains/kotlin/diagnostics/Errors.java | 2 + .../rendering/DefaultErrorMessages.java | 3 + .../kotlin/resolve/TargetPlatform.kt | 2 +- .../checkers/DslScopeViolationCallChecker.kt | 87 +++++++++++++ .../kotlin/resolve/calls/resolvedCallUtil.kt | 16 +++ .../builtin-classes/default/kotlin.txt | 4 + .../testData/builtin-classes/java6/kotlin.txt | 4 + .../testData/builtin-classes/java8/kotlin.txt | 4 + .../builtin-classes/newMethods/kotlin.txt | 4 + .../dslMarker/annotatedTypeArgument.kt | 26 ++++ .../dslMarker/annotatedTypeArgument.txt | 28 +++++ .../resolve/dslMarker/inheritedMarker.kt | 30 +++++ .../resolve/dslMarker/inheritedMarker.txt | 46 +++++++ .../dslMarker/insideTopLevelExtension.kt | 23 ++++ .../dslMarker/insideTopLevelExtension.txt | 27 ++++ .../insideTopLevelExtensionAnnotatedType.kt | 22 ++++ .../insideTopLevelExtensionAnnotatedType.txt | 27 ++++ .../resolve/dslMarker/markersIntersection.kt | 92 ++++++++++++++ .../resolve/dslMarker/markersIntersection.txt | 39 ++++++ .../dslMarker/nestedWithSameReceiver.kt | 40 ++++++ .../dslMarker/nestedWithSameReceiver.txt | 28 +++++ .../tests/resolve/dslMarker/properties.kt | 62 ++++++++++ .../tests/resolve/dslMarker/properties.txt | 30 +++++ .../dslMarker/simpleAnnotatedClasses.kt | 27 ++++ .../dslMarker/simpleAnnotatedClasses.txt | 28 +++++ .../resolve/dslMarker/simpleAnnotatedTypes.kt | 26 ++++ .../dslMarker/simpleAnnotatedTypes.txt | 28 +++++ .../substitutedReceiverAnnotatedClasses.kt | 27 ++++ .../substitutedReceiverAnnotatedClasses.txt | 28 +++++ .../substitutedReceiverAnnotatedType.kt | 26 ++++ .../substitutedReceiverAnnotatedType.txt | 28 +++++ .../dslMarker/threeImplicitReceivers.kt | 110 ++++++++++++++++ .../dslMarker/threeImplicitReceivers.txt | 62 ++++++++++ .../dslMarker/threeImplicitReceivers2.kt | 105 ++++++++++++++++ .../dslMarker/threeImplicitReceivers2.txt | 60 +++++++++ .../resolve/dslMarker/twoImplicitReceivers.kt | 102 +++++++++++++++ .../dslMarker/twoImplicitReceivers.txt | 43 +++++++ .../tests/resolve/dslMarker/twoLanguages.kt | 104 ++++++++++++++++ .../tests/resolve/dslMarker/twoLanguages.txt | 37 ++++++ .../resolve/dslMarker/useOfExtensions.kt | 27 ++++ .../resolve/dslMarker/useOfExtensions.txt | 28 +++++ .../tests/resolve/dslMarker/usingWith.kt | 24 ++++ .../tests/resolve/dslMarker/usingWith.txt | 26 ++++ .../tests/resolve/dslMarker/usingWithThis.kt | 30 +++++ .../tests/resolve/dslMarker/usingWithThis.txt | 28 +++++ .../checkers/DiagnosticsTestGenerated.java | 117 ++++++++++++++++++ core/builtins/src/kotlin/Annotations.kt | 19 +++ .../descriptors/ClassifierDescriptor.java | 4 + .../kotlin/resolve/DescriptorUtils.kt | 15 +++ 49 files changed, 1804 insertions(+), 1 deletion(-) create mode 100644 compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/DslScopeViolationCallChecker.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedTypeArgument.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedTypeArgument.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/inheritedMarker.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/inheritedMarker.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtension.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtension.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtensionAnnotatedType.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtensionAnnotatedType.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/markersIntersection.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/markersIntersection.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/nestedWithSameReceiver.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/nestedWithSameReceiver.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/properties.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/properties.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedClasses.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedClasses.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedTypes.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedTypes.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedClasses.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedClasses.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedType.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedType.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers2.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers2.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/twoImplicitReceivers.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/twoImplicitReceivers.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/twoLanguages.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/twoLanguages.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/useOfExtensions.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/useOfExtensions.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/usingWith.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/usingWith.txt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/usingWithThis.kt create mode 100644 compiler/testData/diagnostics/tests/resolve/dslMarker/usingWithThis.txt diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index 44bb6ba03df..cf3e2d5b718 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -644,6 +644,8 @@ public interface Errors { DiagnosticFactory2 INAPPLICABLE_MODIFIER = DiagnosticFactory2.create(ERROR); + DiagnosticFactory1 DSL_SCOPE_VIOLATION = DiagnosticFactory1.create(ERROR); + // Labels DiagnosticFactory0 LABEL_NAME_CLASH = DiagnosticFactory0.create(WARNING); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index 2c86e2361f6..6c721af2657 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -396,6 +396,9 @@ public class DefaultErrorMessages { MAP.put(INAPPLICABLE_MODIFIER, "''{0}'' modifier is inapplicable. The reason is that {1}", TO_STRING, STRING); + MAP.put(DSL_SCOPE_VIOLATION, "''{0}'' can't be called in this context by implicit receiver. " + + "Use the explicit one if necessary", COMPACT); + MAP.put(RETURN_IN_FUNCTION_WITH_EXPRESSION_BODY, "Returns are not allowed for functions with expression body. Use block body in '{...}'"); MAP.put(NO_RETURN_IN_FUNCTION_WITH_BLOCK_BODY, "A 'return' expression required in a function with a block body ('{...}')"); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TargetPlatform.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TargetPlatform.kt index 560461771ba..f8117b7853f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/TargetPlatform.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/TargetPlatform.kt @@ -72,7 +72,7 @@ private val DEFAULT_CALL_CHECKERS = listOf( CapturingInClosureChecker(), InlineCheckerWrapper(), ReifiedTypeParameterSubstitutionChecker(), SafeCallChecker(), DeprecatedCallChecker, CallReturnsArrayOfNothingChecker(), InfixCallChecker(), OperatorCallChecker(), ConstructorHeaderCallChecker, ProtectedConstructorCallChecker, ApiVersionCallChecker, - CoroutineSuspendCallChecker, BuilderFunctionsCallChecker + CoroutineSuspendCallChecker, BuilderFunctionsCallChecker, DslScopeViolationCallChecker ) private val DEFAULT_TYPE_CHECKERS = emptyList() private val DEFAULT_CLASSIFIER_USAGE_CHECKERS = listOf(DeprecatedClassifierUsageChecker(), ApiVersionClassifierUsageChecker) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/DslScopeViolationCallChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/DslScopeViolationCallChecker.kt new file mode 100644 index 00000000000..738d6f356a0 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/checkers/DslScopeViolationCallChecker.kt @@ -0,0 +1,87 @@ +/* + * Copyright 2010-2016 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.resolve.calls.checkers + +import com.intellij.psi.PsiElement +import org.jetbrains.kotlin.descriptors.ClassDescriptor +import org.jetbrains.kotlin.descriptors.annotations.AnnotationDescriptor +import org.jetbrains.kotlin.descriptors.annotations.Annotations +import org.jetbrains.kotlin.diagnostics.Errors +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall +import org.jetbrains.kotlin.resolve.calls.resolvedCallUtil.getImplicitReceivers +import org.jetbrains.kotlin.resolve.descriptorUtil.fqNameSafe +import org.jetbrains.kotlin.resolve.descriptorUtil.getAllSuperClassifiers +import org.jetbrains.kotlin.resolve.scopes.LexicalScope +import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue +import org.jetbrains.kotlin.resolve.scopes.utils.parentsWithSelf + +object DslScopeViolationCallChecker : CallChecker { + override fun check(resolvedCall: ResolvedCall<*>, reportOn: PsiElement, context: CallCheckerContext) { + val callImplicitReceivers = resolvedCall.getImplicitReceivers() + + for (callImplicitReceiver in callImplicitReceivers) { + checkCallImplicitReceiver(callImplicitReceiver, resolvedCall, reportOn, context) + } + } + + private fun checkCallImplicitReceiver( + callImplicitReceiver: ReceiverValue, + resolvedCall: ResolvedCall<*>, + reportOn: PsiElement, + context: CallCheckerContext + ) { + val receiversUntilOneFromTheCall = + context.scope.parentsWithSelf + .mapNotNull { (it as? LexicalScope)?.implicitReceiver?.value } + .takeWhile { it != callImplicitReceiver }.toList() + + if (receiversUntilOneFromTheCall.isEmpty()) return + + val callDslMarkers = callImplicitReceiver.extractDslMarkerFqNames() + if (callDslMarkers.isEmpty()) return + + val closestAnotherReceiverWithSameDslMarker = + receiversUntilOneFromTheCall.firstOrNull { receiver -> receiver.extractDslMarkerFqNames().any(callDslMarkers::contains) } + + if (closestAnotherReceiverWithSameDslMarker != null) { + // TODO: report receivers configuration (what's one is used and what's one is the closest) + context.trace.report(Errors.DSL_SCOPE_VIOLATION.on(reportOn, resolvedCall.resultingDescriptor)) + } + } +} + +private fun ReceiverValue.extractDslMarkerFqNames(): Set { + val result = mutableSetOf() + + result.addAll(type.annotations.extractDslMarkerFqNames()) + + type.constructor.declarationDescriptor?.getAllSuperClassifiers()?.asIterable() + ?.flatMapTo(result) { it.annotations.extractDslMarkerFqNames() } + + return result +} + +private fun Annotations.extractDslMarkerFqNames() = + filter(AnnotationDescriptor::isDslMarker).map { it.type.constructor.declarationDescriptor!!.fqNameSafe } + +private fun AnnotationDescriptor.isDslMarker(): Boolean { + val classDescriptor = type.constructor.declarationDescriptor as? ClassDescriptor ?: return false + return classDescriptor.annotations.hasAnnotation(DSL_MARKER_FQ_NAME) +} + +private val DSL_MARKER_FQ_NAME = FqName("kotlin.DslMarker") diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt index 44b993cdbe5..c6947fae9c5 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/resolvedCallUtil.kt @@ -23,6 +23,7 @@ import org.jetbrains.kotlin.resolve.BindingContext import org.jetbrains.kotlin.resolve.calls.callUtil.isSafeCall import org.jetbrains.kotlin.resolve.calls.context.CallResolutionContext import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall +import org.jetbrains.kotlin.resolve.calls.model.VariableAsFunctionResolvedCall import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValueFactory import org.jetbrains.kotlin.resolve.calls.smartcasts.getReceiverValueWithSmartCast import org.jetbrains.kotlin.resolve.calls.tasks.ExplicitReceiverKind @@ -82,6 +83,21 @@ fun ResolvedCall<*>.getImplicitReceiverValue(): ImplicitReceiver? { } as? ImplicitReceiver } +fun ResolvedCall<*>.getImplicitReceivers(): Collection { + if (this is VariableAsFunctionResolvedCall) { + val receivers = variableCall.getImplicitReceivers() + functionCall.getImplicitReceivers() + assert(receivers.size <= 3) { "There are ${receivers.size} for $this call" } + return receivers + } + + return when (explicitReceiverKind) { + ExplicitReceiverKind.NO_EXPLICIT_RECEIVER -> listOfNotNull(dispatchReceiver, extensionReceiver) + ExplicitReceiverKind.DISPATCH_RECEIVER -> listOfNotNull(extensionReceiver) + ExplicitReceiverKind.EXTENSION_RECEIVER -> listOfNotNull(dispatchReceiver) + ExplicitReceiverKind.BOTH_RECEIVERS -> emptyList() + } +} + private fun ResolvedCall<*>.hasSafeNullableReceiver(context: CallResolutionContext<*>): Boolean { if (!call.isSafeCall()) return false val receiverValue = getExplicitReceiverValue()?.let { DataFlowValueFactory.createDataFlowValue(it, context) } diff --git a/compiler/testData/builtin-classes/default/kotlin.txt b/compiler/testData/builtin-classes/default/kotlin.txt index 025c5182aea..52dca4cbff2 100644 --- a/compiler/testData/builtin-classes/default/kotlin.txt +++ b/compiler/testData/builtin-classes/default/kotlin.txt @@ -286,6 +286,10 @@ public final class DoubleArray { public final operator fun set(/*0*/ index: kotlin.Int, /*1*/ value: kotlin.Double): kotlin.Unit } +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) @kotlin.annotation.MustBeDocumented public final annotation class DslMarker : kotlin.Annotation { + /*primary*/ public constructor DslMarker() +} + public abstract class Enum> : kotlin.Comparable { /*primary*/ public constructor Enum>(/*0*/ name: kotlin.String, /*1*/ ordinal: kotlin.Int) public final val name: kotlin.String diff --git a/compiler/testData/builtin-classes/java6/kotlin.txt b/compiler/testData/builtin-classes/java6/kotlin.txt index 8ef1e79822a..ad41027ce95 100644 --- a/compiler/testData/builtin-classes/java6/kotlin.txt +++ b/compiler/testData/builtin-classes/java6/kotlin.txt @@ -297,6 +297,10 @@ public final class DoubleArray : kotlin.Any, kotlin.Cloneable, java.io.Serializa public final operator fun set(/*0*/ index: kotlin.Int, /*1*/ value: kotlin.Double): kotlin.Unit } +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) @kotlin.annotation.MustBeDocumented public final annotation class DslMarker : kotlin.Annotation { + /*primary*/ public constructor DslMarker() +} + public abstract class Enum> : kotlin.Comparable, java.io.Serializable { /*primary*/ public constructor Enum>(/*0*/ name: kotlin.String, /*1*/ ordinal: kotlin.Int) public final val name: kotlin.String diff --git a/compiler/testData/builtin-classes/java8/kotlin.txt b/compiler/testData/builtin-classes/java8/kotlin.txt index ebdd6d3ab23..47e38fd486e 100644 --- a/compiler/testData/builtin-classes/java8/kotlin.txt +++ b/compiler/testData/builtin-classes/java8/kotlin.txt @@ -299,6 +299,10 @@ public final class DoubleArray : kotlin.Any, kotlin.Cloneable, java.io.Serializa public final operator fun set(/*0*/ index: kotlin.Int, /*1*/ value: kotlin.Double): kotlin.Unit } +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) @kotlin.annotation.MustBeDocumented public final annotation class DslMarker : kotlin.Annotation { + /*primary*/ public constructor DslMarker() +} + public abstract class Enum> : kotlin.Comparable, java.io.Serializable { /*primary*/ public constructor Enum>(/*0*/ name: kotlin.String, /*1*/ ordinal: kotlin.Int) public final val name: kotlin.String diff --git a/compiler/testData/builtin-classes/newMethods/kotlin.txt b/compiler/testData/builtin-classes/newMethods/kotlin.txt index 8b84f58d70e..c4b21cfe85b 100644 --- a/compiler/testData/builtin-classes/newMethods/kotlin.txt +++ b/compiler/testData/builtin-classes/newMethods/kotlin.txt @@ -297,6 +297,10 @@ public final class DoubleArray : kotlin.Any, kotlin.Cloneable, java.io.Serializa public final operator fun set(/*0*/ index: kotlin.Int, /*1*/ value: kotlin.Double): kotlin.Unit } +@kotlin.annotation.Target(allowedTargets = {AnnotationTarget.ANNOTATION_CLASS}) @kotlin.annotation.Retention(value = AnnotationRetention.BINARY) @kotlin.annotation.MustBeDocumented public final annotation class DslMarker : kotlin.Annotation { + /*primary*/ public constructor DslMarker() +} + public abstract class Enum> : kotlin.Comparable, java.io.Serializable { /*primary*/ public constructor Enum>(/*0*/ name: kotlin.String, /*1*/ ordinal: kotlin.Int) public final val name: kotlin.String diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedTypeArgument.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedTypeArgument.kt new file mode 100644 index 00000000000..73574ec679f --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedTypeArgument.kt @@ -0,0 +1,26 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann + +class A { + fun a() = 1 +} + +class B { + fun b() = 2 +} + +fun foo(x: T.() -> Unit) {} +fun bar(x: E.() -> Unit) {} + +fun test() { + foo<@Ann A> { + a() + bar<@Ann B> { + a() + this@foo.a() + b() + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedTypeArgument.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedTypeArgument.txt new file mode 100644 index 00000000000..9178ec51f77 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedTypeArgument.txt @@ -0,0 +1,28 @@ +package + +public fun bar(/*0*/ x: E.() -> kotlin.Unit): kotlin.Unit +public fun foo(/*0*/ x: T.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +public final class A { + public constructor A() + public final fun a(): 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 +} + +@kotlin.DslMarker @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 + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class B { + public constructor B() + public final fun b(): 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 +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/inheritedMarker.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/inheritedMarker.kt new file mode 100644 index 00000000000..a216696fd21 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/inheritedMarker.kt @@ -0,0 +1,30 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +annotation class Ann + +@Ann +interface Common +interface C : Common +interface D : C + +class A : C { + fun a() = 1 +} + +class B : D { + fun b() = 2 +} + +fun foo(x: A.() -> Unit) {} +fun bar(x: B.() -> Unit) {} + +fun test() { + foo { + a() + bar { + a() + this@foo.a() + b() + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/inheritedMarker.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/inheritedMarker.txt new file mode 100644 index 00000000000..a01f8ef10fa --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/inheritedMarker.txt @@ -0,0 +1,46 @@ +package + +public fun bar(/*0*/ x: B.() -> kotlin.Unit): kotlin.Unit +public fun foo(/*0*/ x: A.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +public final class A : C { + public constructor A() + public final fun a(): 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 +} + +@kotlin.DslMarker 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 +} + +public final class B : D { + public constructor B() + public final fun b(): 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 interface C : 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 +} + +@Ann public interface 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 +} + +public interface D : 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/tests/resolve/dslMarker/insideTopLevelExtension.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtension.kt new file mode 100644 index 00000000000..4be529bdfd8 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtension.kt @@ -0,0 +1,23 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +annotation class Ann + +@Ann +class A { + fun a() = 1 +} + +@Ann +class B { + fun b() = 2 +} + +fun bar(x: B.() -> Unit) {} + +fun A.test() { + bar { + a() + this@test.a() + b() + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtension.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtension.txt new file mode 100644 index 00000000000..463293be6e5 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtension.txt @@ -0,0 +1,27 @@ +package + +public fun bar(/*0*/ x: B.() -> kotlin.Unit): kotlin.Unit +public fun A.test(): kotlin.Unit + +@Ann public final class A { + public constructor A() + public final fun a(): 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 +} + +@kotlin.DslMarker 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 +} + +@Ann public final class B { + public constructor B() + public final fun b(): 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 +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtensionAnnotatedType.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtensionAnnotatedType.kt new file mode 100644 index 00000000000..9a515c1e648 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtensionAnnotatedType.kt @@ -0,0 +1,22 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann + +class A { + fun a() = 1 +} + +class B { + fun b() = 2 +} + +fun bar(x: @Ann B.() -> Unit) {} + +fun @Ann A.test() { + bar { + a() + this@test.a() + b() + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtensionAnnotatedType.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtensionAnnotatedType.txt new file mode 100644 index 00000000000..2b667293445 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtensionAnnotatedType.txt @@ -0,0 +1,27 @@ +package + +public fun bar(/*0*/ x: @Ann B.() -> kotlin.Unit): kotlin.Unit +public fun @Ann A.test(): kotlin.Unit + +public final class A { + public constructor A() + public final fun a(): 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 +} + +@kotlin.DslMarker @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 + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class B { + public constructor B() + public final fun b(): 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 +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/markersIntersection.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/markersIntersection.kt new file mode 100644 index 00000000000..2ecc36ed40c --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/markersIntersection.kt @@ -0,0 +1,92 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class L1 + +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class L2 + +class A { + fun a() = 1 +} + +class B { + fun b() = 2 +} + +fun foo1(x: @L1 A.() -> Unit) {} +fun foo2(x: @L2 A.() -> Unit) {} + +fun foo12(x: @L1 @L2 A.() -> Unit) {} + +fun bar1(x: @L1 B.() -> Unit) {} +fun bar2(x: @L2 B.() -> Unit) {} + +fun bar1t(q: T, x: @L1 T.() -> Unit) {} + +fun test() { + foo12 { + a() + bar1 { + a() + b() + } + + bar2 { + a() + b() + } + } + + bar1 { + b() + foo12 { + a() + b() + } + } + + bar2 { + b() + foo12 { + a() + b() + } + } + + foo2 { + bar1t(this) { + a() + bar1 { + a() + b() + } + + bar2 { + a() + b() + } + } + } + + bar1 { + b() + foo2 { + bar1t(this) { + a() + b() + } + } + } + + bar2 { + b() + foo2 { + bar1t(this) { + a() + b() + } + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/markersIntersection.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/markersIntersection.txt new file mode 100644 index 00000000000..65d788b378f --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/markersIntersection.txt @@ -0,0 +1,39 @@ +package + +public fun bar1(/*0*/ x: @L1 B.() -> kotlin.Unit): kotlin.Unit +public fun bar1t(/*0*/ q: T, /*1*/ x: @L1 T.() -> kotlin.Unit): kotlin.Unit +public fun bar2(/*0*/ x: @L2 B.() -> kotlin.Unit): kotlin.Unit +public fun foo1(/*0*/ x: @L1 A.() -> kotlin.Unit): kotlin.Unit +public fun foo12(/*0*/ x: @L1 @L2 A.() -> kotlin.Unit): kotlin.Unit +public fun foo2(/*0*/ x: @L2 A.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +public final class A { + public constructor A() + public final fun a(): 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 class B { + public constructor B() + public final fun b(): 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 +} + +@kotlin.DslMarker @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class L1 : kotlin.Annotation { + public constructor L1() + 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.DslMarker @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class L2 : kotlin.Annotation { + public constructor L2() + 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/resolve/dslMarker/nestedWithSameReceiver.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/nestedWithSameReceiver.kt new file mode 100644 index 00000000000..050c5abda2f --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/nestedWithSameReceiver.kt @@ -0,0 +1,40 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann + +class A { + fun a() = 1 +} + +class B { + fun b() = 2 +} + +fun foo(x: @Ann A.() -> Unit) {} +fun bar(x: @Ann B.() -> Unit) {} + +fun test() { + foo { + a() + foo l1@{ + a() + bar l2@{ + a() + this@l1.a() + b() + + foo l3@{ + a() + b() + this@l2.b() + bar { + a() + this@l3.a() + b() + } + } + } + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/nestedWithSameReceiver.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/nestedWithSameReceiver.txt new file mode 100644 index 00000000000..f357dd91e2b --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/nestedWithSameReceiver.txt @@ -0,0 +1,28 @@ +package + +public fun bar(/*0*/ x: @Ann B.() -> kotlin.Unit): kotlin.Unit +public fun foo(/*0*/ x: @Ann A.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +public final class A { + public constructor A() + public final fun a(): 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 +} + +@kotlin.DslMarker @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 + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class B { + public constructor B() + public final fun b(): 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 +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/properties.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/properties.kt new file mode 100644 index 00000000000..fbb90904f91 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/properties.kt @@ -0,0 +1,62 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +annotation class Ann + +@Ann +class A { + var a = 1 +} + +var A.a1: Int + get() = 1 + set(value) {} + +@Ann +class B { + var b = 2 +} + +var B.b1: Int + get() = 1 + set(value) {} + +fun foo(x: A.() -> Unit) {} +fun bar(x: B.() -> Unit) {} + +fun test() { + foo { + a + 1 + a += a + 1 + a++ + + a1 + 1 + a1 += a1 + 1 + a1++ + + bar { + a + 1 + a += a + 1 + a++ + + a1 + 1 + a1 += a1 + 1 + a1++ + + this@foo.a + 1 + this@foo.a += this@foo.a + 1 + this@foo.a++ + + this@foo.a1 + 1 + this@foo.a1 += this@foo.a1 + 1 + this@foo.a1++ + + b + 1 + b += b + 1 + b++ + + b1 + 1 + b1 += b1 + 1 + b1++ + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/properties.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/properties.txt new file mode 100644 index 00000000000..075344d5963 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/properties.txt @@ -0,0 +1,30 @@ +package + +public var A.a1: kotlin.Int +public var B.b1: kotlin.Int +public fun bar(/*0*/ x: B.() -> kotlin.Unit): kotlin.Unit +public fun foo(/*0*/ x: A.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +@Ann public final class A { + public constructor A() + public final var a: 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 +} + +@kotlin.DslMarker 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 +} + +@Ann public final class B { + public constructor B() + public final var b: 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 +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedClasses.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedClasses.kt new file mode 100644 index 00000000000..5add0eb24ff --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedClasses.kt @@ -0,0 +1,27 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +annotation class Ann + +@Ann +class A { + fun a() = 1 +} + +@Ann +class B { + fun b() = 2 +} + +fun foo(x: A.() -> Unit) {} +fun bar(x: B.() -> Unit) {} + +fun test() { + foo { + a() + bar { + a() + this@foo.a() + b() + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedClasses.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedClasses.txt new file mode 100644 index 00000000000..7ca439a2bc5 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedClasses.txt @@ -0,0 +1,28 @@ +package + +public fun bar(/*0*/ x: B.() -> kotlin.Unit): kotlin.Unit +public fun foo(/*0*/ x: A.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +@Ann public final class A { + public constructor A() + public final fun a(): 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 +} + +@kotlin.DslMarker 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 +} + +@Ann public final class B { + public constructor B() + public final fun b(): 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 +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedTypes.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedTypes.kt new file mode 100644 index 00000000000..3806eae8dd0 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedTypes.kt @@ -0,0 +1,26 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann + +class A { + fun a() = 1 +} + +class B { + fun b() = 2 +} + +fun foo(x: @Ann A.() -> Unit) {} +fun bar(x: @Ann B.() -> Unit) {} + +fun test() { + foo { + a() + bar { + a() + this@foo.a() + b() + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedTypes.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedTypes.txt new file mode 100644 index 00000000000..f357dd91e2b --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedTypes.txt @@ -0,0 +1,28 @@ +package + +public fun bar(/*0*/ x: @Ann B.() -> kotlin.Unit): kotlin.Unit +public fun foo(/*0*/ x: @Ann A.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +public final class A { + public constructor A() + public final fun a(): 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 +} + +@kotlin.DslMarker @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 + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class B { + public constructor B() + public final fun b(): 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 +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedClasses.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedClasses.kt new file mode 100644 index 00000000000..558522df35a --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedClasses.kt @@ -0,0 +1,27 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +annotation class Ann + +@Ann +class A { + fun a() = 1 +} + +@Ann +class B { + fun b() = 2 +} + +fun foo(x: T.() -> Unit) {} +fun bar(x: E.() -> Unit) {} + +fun test() { + foo { + a() + bar { + a() + this@foo.a() + b() + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedClasses.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedClasses.txt new file mode 100644 index 00000000000..54e2ff1bb07 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedClasses.txt @@ -0,0 +1,28 @@ +package + +public fun bar(/*0*/ x: E.() -> kotlin.Unit): kotlin.Unit +public fun foo(/*0*/ x: T.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +@Ann public final class A { + public constructor A() + public final fun a(): 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 +} + +@kotlin.DslMarker 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 +} + +@Ann public final class B { + public constructor B() + public final fun b(): 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 +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedType.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedType.kt new file mode 100644 index 00000000000..5288b525775 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedType.kt @@ -0,0 +1,26 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann + +class A { + fun a() = 1 +} + +class B { + fun b() = 2 +} + +fun foo(x: @Ann T.() -> Unit) {} +fun bar(x: @Ann E.() -> Unit) {} + +fun test() { + foo { + a() + bar { + a() + this@foo.a() + b() + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedType.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedType.txt new file mode 100644 index 00000000000..752c1683b55 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedType.txt @@ -0,0 +1,28 @@ +package + +public fun bar(/*0*/ x: @Ann E.() -> kotlin.Unit): kotlin.Unit +public fun foo(/*0*/ x: @Ann T.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +public final class A { + public constructor A() + public final fun a(): 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 +} + +@kotlin.DslMarker @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 + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class B { + public constructor B() + public final fun b(): 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 +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers.kt new file mode 100644 index 00000000000..4a428a78cd5 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers.kt @@ -0,0 +1,110 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann1 + +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann2 + +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann3 + +class A { + operator fun B.invoke() {} + + val B.y: D get() = D() +} + +class B + +class C { + operator fun D.invoke() {} + + val D.x: B get() = B() +} + +class D + +fun foo(x: @Ann1 A.() -> Unit) {} +fun bar(x: @Ann2 B.() -> Unit) {} +fun baz(x: @Ann3 C.() -> Unit) {} +fun foo1(x: @Ann1 D.() -> Unit) {} +fun foo2(x: @Ann2 D.() -> Unit) {} +fun foo3(x: @Ann3 D.() -> Unit) {} + +fun test() { + foo { + bar { + baz { + y() + + x() + + with(D()) { + x() + } + D().x() + + foo1 { + x() + y() + + with(A()) { + x() + y() + } + + with(D()) { + x() + } + D().x() + } + + foo2 { + x() + y() + } + + foo3 { + x() + y() + } + } + } + } + + foo1 { + foo { + baz { + bar { + x() + y() + } + } + } + } + + foo2 { + foo { + baz { + bar { + x() + y() + } + } + } + } + + foo3 { + foo { + baz { + bar { + x() + y() + } + } + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers.txt new file mode 100644 index 00000000000..ca83745a4a9 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers.txt @@ -0,0 +1,62 @@ +package + +public fun bar(/*0*/ x: @Ann2 B.() -> kotlin.Unit): kotlin.Unit +public fun baz(/*0*/ x: @Ann3 C.() -> kotlin.Unit): kotlin.Unit +public fun foo(/*0*/ x: @Ann1 A.() -> kotlin.Unit): kotlin.Unit +public fun foo1(/*0*/ x: @Ann1 D.() -> kotlin.Unit): kotlin.Unit +public fun foo2(/*0*/ x: @Ann2 D.() -> kotlin.Unit): kotlin.Unit +public fun foo3(/*0*/ x: @Ann3 D.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +public final class A { + public constructor A() + public final val B.y: D + 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 operator fun B.invoke(): kotlin.Unit +} + +@kotlin.DslMarker @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) 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.DslMarker @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) 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.DslMarker @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class Ann3 : kotlin.Annotation { + 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 +} + +public final class 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 +} + +public final class C { + public constructor C() + public final val D.x: 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 + public final operator fun D.invoke(): kotlin.Unit +} + +public final class D { + public constructor D() + 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/resolve/dslMarker/threeImplicitReceivers2.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers2.kt new file mode 100644 index 00000000000..d3d35a014b0 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers2.kt @@ -0,0 +1,105 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann1 + +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann2 + +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann3 + +class A { + val B.y: (C.() -> Unit) get() = null!! +} + +class B + +class C { + val D.x: (A.() -> Unit) get() = null!! +} + +class D + +fun foo(x: @Ann1 A.() -> Unit) {} +fun bar(x: @Ann2 B.() -> Unit) {} +fun baz(x: @Ann3 C.() -> Unit) {} +fun foo1(x: @Ann1 D.() -> Unit) {} +fun foo2(x: @Ann2 D.() -> Unit) {} +fun foo3(x: @Ann3 D.() -> Unit) {} + +fun test() { + foo { + bar { + baz { + y() + + x() + + with(D()) { + x() + } + + foo1 { + x() + y() + + with(A()) { + x() + y() + } + + with(D()) { + x() + } + A().x() + } + + foo2 { + x() + y() + } + + foo3 { + x() + y() + } + } + } + } + + foo1 { + foo { + baz { + bar { + x() + y() + } + } + } + } + + foo2 { + foo { + baz { + bar { + x() + y() + } + } + } + } + + foo3 { + foo { + baz { + bar { + x() + y() + } + } + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers2.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers2.txt new file mode 100644 index 00000000000..b4ac66465be --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers2.txt @@ -0,0 +1,60 @@ +package + +public fun bar(/*0*/ x: @Ann2 B.() -> kotlin.Unit): kotlin.Unit +public fun baz(/*0*/ x: @Ann3 C.() -> kotlin.Unit): kotlin.Unit +public fun foo(/*0*/ x: @Ann1 A.() -> kotlin.Unit): kotlin.Unit +public fun foo1(/*0*/ x: @Ann1 D.() -> kotlin.Unit): kotlin.Unit +public fun foo2(/*0*/ x: @Ann2 D.() -> kotlin.Unit): kotlin.Unit +public fun foo3(/*0*/ x: @Ann3 D.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +public final class A { + public constructor A() + public final val B.y: C.() -> 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +@kotlin.DslMarker @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) 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.DslMarker @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) 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.DslMarker @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class Ann3 : kotlin.Annotation { + 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 +} + +public final class 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 +} + +public final class C { + public constructor C() + public final val D.x: A.() -> 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 open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class D { + public constructor D() + 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/resolve/dslMarker/twoImplicitReceivers.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/twoImplicitReceivers.kt new file mode 100644 index 00000000000..aa4515d90ce --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/twoImplicitReceivers.kt @@ -0,0 +1,102 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann1 + +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann2 + +class A { + fun D.extA() {} +} + +class B { + fun D.extB() {} +} + +class D + +fun foo(x: @Ann1 A.() -> Unit) {} +fun bar(x: @Ann2 B.() -> Unit) {} +fun baz(x: @Ann1 D.() -> Unit) {} + +fun test() { + foo { + bar { + baz { + extA() + extB() + + D().extA() + D().extB() + + with(D()) { + extA() + extB() + } + } + } + } + + foo { + baz { + extA() + D().extA() + + bar { + extA() + extB() + + D().extA() + D().extB() + + with(D()) { + extA() + extB() + } + } + } + } + + baz { + foo { + extA() + D().extA() + + bar { + extA() + extB() + + D().extA() + D().extB() + + with(D()) { + extA() + extB() + } + } + } + } + + baz { + bar { + extB() + + D().extB() + + foo { + extA() + extB() + + D().extA() + D().extB() + + with(D()) { + extA() + extB() + } + } + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/twoImplicitReceivers.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/twoImplicitReceivers.txt new file mode 100644 index 00000000000..025cce2dbee --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/twoImplicitReceivers.txt @@ -0,0 +1,43 @@ +package + +public fun bar(/*0*/ x: @Ann2 B.() -> kotlin.Unit): kotlin.Unit +public fun baz(/*0*/ x: @Ann1 D.() -> kotlin.Unit): kotlin.Unit +public fun foo(/*0*/ x: @Ann1 A.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +public final class A { + 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 + public final fun D.extA(): kotlin.Unit +} + +@kotlin.DslMarker @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) 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.DslMarker @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) 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 +} + +public final class 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 + public final fun D.extB(): kotlin.Unit +} + +public final class D { + public constructor D() + 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/resolve/dslMarker/twoLanguages.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/twoLanguages.kt new file mode 100644 index 00000000000..27f683b2443 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/twoLanguages.kt @@ -0,0 +1,104 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class L1 + +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class L2 + +class A { + fun a() = 1 +} + +class B { + fun b() = 2 +} + +fun foo1(x: @L1 A.() -> Unit) {} +fun foo2(x: @L2 A.() -> Unit) {} +fun bar1(x: @L1 B.() -> Unit) {} +fun bar2(x: @L2 B.() -> Unit) {} + +fun test() { + foo1 { + a() + + foo2 { + a() + + bar1 { + a() + b() + bar2 { + a() + b() + } + } + + bar2 { + a() + b() + } + } + + bar1 { + a() + b() + bar2 { + a() + b() + } + } + + bar2 { + a() + b() + } + } + + foo2 { + a() + + bar1 { + a() + b() + bar2 { + a() + b() + } + } + + bar2 { + a() + b() + } + } + + bar1 { + b() + bar2 { + b() + } + } + + bar2 { + b() + } + + foo1 { + bar1 { + a() + b() + foo2 { + a() + b() + + bar2 { + a() + b() + } + } + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/twoLanguages.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/twoLanguages.txt new file mode 100644 index 00000000000..fa000bc836c --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/twoLanguages.txt @@ -0,0 +1,37 @@ +package + +public fun bar1(/*0*/ x: @L1 B.() -> kotlin.Unit): kotlin.Unit +public fun bar2(/*0*/ x: @L2 B.() -> kotlin.Unit): kotlin.Unit +public fun foo1(/*0*/ x: @L1 A.() -> kotlin.Unit): kotlin.Unit +public fun foo2(/*0*/ x: @L2 A.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +public final class A { + public constructor A() + public final fun a(): 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 class B { + public constructor B() + public final fun b(): 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 +} + +@kotlin.DslMarker @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class L1 : kotlin.Annotation { + public constructor L1() + 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.DslMarker @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE}) public final annotation class L2 : kotlin.Annotation { + public constructor L2() + 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/resolve/dslMarker/useOfExtensions.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/useOfExtensions.kt new file mode 100644 index 00000000000..124d69b2eb2 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/useOfExtensions.kt @@ -0,0 +1,27 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +annotation class Ann + +@Ann +class A + +fun A.a() = 1 + +@Ann +class B + +fun B.b() = 2 + +fun foo(x: A.() -> Unit) {} +fun bar(x: B.() -> Unit) {} + +fun test() { + foo { + a() + bar { + a() + this@foo.a() + b() + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/useOfExtensions.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/useOfExtensions.txt new file mode 100644 index 00000000000..5b019779125 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/useOfExtensions.txt @@ -0,0 +1,28 @@ +package + +public fun bar(/*0*/ x: B.() -> kotlin.Unit): kotlin.Unit +public fun foo(/*0*/ x: A.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit +public fun A.a(): kotlin.Int +public fun B.b(): kotlin.Int + +@Ann public final class A { + 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.DslMarker 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 +} + +@Ann public final class 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 +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/usingWith.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/usingWith.kt new file mode 100644 index 00000000000..40a62297a5f --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/usingWith.kt @@ -0,0 +1,24 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +annotation class Ann + +@Ann +class A { + fun a() = 1 +} + +@Ann +class B { + fun b() = 2 +} + +fun test(a: A, b: B) { + with(a) l1@{ + a() + with(b) { + a() + this@l1.a() + b() + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/usingWith.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/usingWith.txt new file mode 100644 index 00000000000..cd8d572a83d --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/usingWith.txt @@ -0,0 +1,26 @@ +package + +public fun test(/*0*/ a: A, /*1*/ b: B): kotlin.Unit + +@Ann public final class A { + public constructor A() + public final fun a(): 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 +} + +@kotlin.DslMarker 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 +} + +@Ann public final class B { + public constructor B() + public final fun b(): 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 +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/usingWithThis.kt b/compiler/testData/diagnostics/tests/resolve/dslMarker/usingWithThis.kt new file mode 100644 index 00000000000..d9200592707 --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/usingWithThis.kt @@ -0,0 +1,30 @@ +// !DIAGNOSTICS: -UNUSED_PARAMETER +@DslMarker +@Target(AnnotationTarget.TYPE) +annotation class Ann + +class A { + fun a() = 1 +} + +class B { + fun b() = 2 +} + +fun foo(x: @Ann A.() -> Unit) {} +fun bar(x: @Ann B.() -> Unit) {} + +fun test() { + foo { + with(this) l1@{ + a() + bar { + with(this) { + a() + this@l1.a() + b() + } + } + } + } +} diff --git a/compiler/testData/diagnostics/tests/resolve/dslMarker/usingWithThis.txt b/compiler/testData/diagnostics/tests/resolve/dslMarker/usingWithThis.txt new file mode 100644 index 00000000000..f357dd91e2b --- /dev/null +++ b/compiler/testData/diagnostics/tests/resolve/dslMarker/usingWithThis.txt @@ -0,0 +1,28 @@ +package + +public fun bar(/*0*/ x: @Ann B.() -> kotlin.Unit): kotlin.Unit +public fun foo(/*0*/ x: @Ann A.() -> kotlin.Unit): kotlin.Unit +public fun test(): kotlin.Unit + +public final class A { + public constructor A() + public final fun a(): 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 +} + +@kotlin.DslMarker @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 + public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String +} + +public final class B { + public constructor B() + public final fun b(): 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 +} diff --git a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java index 8218b6c3fc0..ba8492b4e93 100644 --- a/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java @@ -15843,6 +15843,123 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTest { doTest(fileName); } + @TestMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class DslMarker extends AbstractDiagnosticsTest { + public void testAllFilesPresentInDslMarker() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/diagnostics/tests/resolve/dslMarker"), Pattern.compile("^(.+)\\.kt$"), true); + } + + @TestMetadata("annotatedTypeArgument.kt") + public void testAnnotatedTypeArgument() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedTypeArgument.kt"); + doTest(fileName); + } + + @TestMetadata("inheritedMarker.kt") + public void testInheritedMarker() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/inheritedMarker.kt"); + doTest(fileName); + } + + @TestMetadata("insideTopLevelExtension.kt") + public void testInsideTopLevelExtension() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtension.kt"); + doTest(fileName); + } + + @TestMetadata("insideTopLevelExtensionAnnotatedType.kt") + public void testInsideTopLevelExtensionAnnotatedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtensionAnnotatedType.kt"); + doTest(fileName); + } + + @TestMetadata("markersIntersection.kt") + public void testMarkersIntersection() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/markersIntersection.kt"); + doTest(fileName); + } + + @TestMetadata("nestedWithSameReceiver.kt") + public void testNestedWithSameReceiver() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/nestedWithSameReceiver.kt"); + doTest(fileName); + } + + @TestMetadata("properties.kt") + public void testProperties() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/properties.kt"); + doTest(fileName); + } + + @TestMetadata("simpleAnnotatedClasses.kt") + public void testSimpleAnnotatedClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedClasses.kt"); + doTest(fileName); + } + + @TestMetadata("simpleAnnotatedTypes.kt") + public void testSimpleAnnotatedTypes() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedTypes.kt"); + doTest(fileName); + } + + @TestMetadata("substitutedReceiverAnnotatedClasses.kt") + public void testSubstitutedReceiverAnnotatedClasses() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedClasses.kt"); + doTest(fileName); + } + + @TestMetadata("substitutedReceiverAnnotatedType.kt") + public void testSubstitutedReceiverAnnotatedType() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedType.kt"); + doTest(fileName); + } + + @TestMetadata("threeImplicitReceivers.kt") + public void testThreeImplicitReceivers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers.kt"); + doTest(fileName); + } + + @TestMetadata("threeImplicitReceivers2.kt") + public void testThreeImplicitReceivers2() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers2.kt"); + doTest(fileName); + } + + @TestMetadata("twoImplicitReceivers.kt") + public void testTwoImplicitReceivers() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/twoImplicitReceivers.kt"); + doTest(fileName); + } + + @TestMetadata("twoLanguages.kt") + public void testTwoLanguages() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/twoLanguages.kt"); + doTest(fileName); + } + + @TestMetadata("useOfExtensions.kt") + public void testUseOfExtensions() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/useOfExtensions.kt"); + doTest(fileName); + } + + @TestMetadata("usingWith.kt") + public void testUsingWith() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/usingWith.kt"); + doTest(fileName); + } + + @TestMetadata("usingWithThis.kt") + public void testUsingWithThis() throws Exception { + String fileName = KotlinTestUtils.navigationMetadata("compiler/testData/diagnostics/tests/resolve/dslMarker/usingWithThis.kt"); + doTest(fileName); + } + } + @TestMetadata("compiler/testData/diagnostics/tests/resolve/invoke") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/core/builtins/src/kotlin/Annotations.kt b/core/builtins/src/kotlin/Annotations.kt index 7fddb716486..4deccd3589a 100644 --- a/core/builtins/src/kotlin/Annotations.kt +++ b/core/builtins/src/kotlin/Annotations.kt @@ -107,3 +107,22 @@ public annotation class UnsafeVariance @Retention(AnnotationRetention.BINARY) @MustBeDocumented public annotation class SinceKotlin(val version: String) + +/** + * When applied to annotation class X specifies that X defines a DSL language + * + * The general rule: + * - an implicit receiver may *belong to a DSL @X* if marked with a corresponding DSL marker annotation + * - two implicit receivers of the same DSL are not accessible in the same scope + * - the closest one wins + * - other available receivers are resolved as usual, but if the resulting resolved call binds to such a receiver, it's a compilation error + * + * Marking rules: an implicit receiver is considered marked with @Ann if + * - its type is marked, or + * - its type's classifier is marked + * - or any of its superclasses/superinterfaces + */ +@Target(ANNOTATION_CLASS) +@Retention(BINARY) +@MustBeDocumented +public annotation class DslMarker diff --git a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassifierDescriptor.java b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassifierDescriptor.java index f8dbfd7451c..ca95ce4247b 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassifierDescriptor.java +++ b/core/descriptors/src/org/jetbrains/kotlin/descriptors/ClassifierDescriptor.java @@ -26,4 +26,8 @@ public interface ClassifierDescriptor extends DeclarationDescriptorNonRoot { @NotNull SimpleType getDefaultType(); + + @NotNull + @Override + ClassifierDescriptor getOriginal(); } diff --git a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt index a3aee0a2820..5d303e716e6 100644 --- a/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt +++ b/core/descriptors/src/org/jetbrains/kotlin/resolve/DescriptorUtils.kt @@ -336,3 +336,18 @@ val DeclarationDescriptor.isExtensionProperty: Boolean fun ClassDescriptor.getAllSuperclassesWithoutAny() = generateSequence(getSuperClassNotAny(), ClassDescriptor::getSuperClassNotAny).toCollection(SmartList()) + +fun ClassifierDescriptor.getAllSuperClassifiers(): Sequence { + val set = hashSetOf() + + fun ClassifierDescriptor.doGetAllSuperClassesAndInterfaces(): Sequence = + if (original in set) { + emptySequence() + } + else { + set += original + sequenceOf(original) + typeConstructor.supertypes.asSequence().flatMap { it.constructor.declarationDescriptor?.doGetAllSuperClassesAndInterfaces() ?: sequenceOf() } + } + + return doGetAllSuperClassesAndInterfaces() +}