diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt new file mode 100644 index 00000000000..a16123ea4cd --- /dev/null +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationChecker.kt @@ -0,0 +1,122 @@ +/* + * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. + * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.fir.analysis.checkers.declaration + +import org.jetbrains.kotlin.KtNodeTypes +import org.jetbrains.kotlin.fir.FirSourceElement +import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext +import org.jetbrains.kotlin.fir.analysis.checkers.extended.report +import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors +import org.jetbrains.kotlin.fir.declarations.FirProperty +import org.jetbrains.kotlin.fir.declarations.FirValueParameter +import org.jetbrains.kotlin.fir.declarations.FirVariable +import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic +import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind +import org.jetbrains.kotlin.fir.expressions.* +import org.jetbrains.kotlin.fir.references.FirErrorNamedReference +import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeAmbiguityError +import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedNameError +import org.jetbrains.kotlin.fir.symbols.impl.FirVariableSymbol + +object FirDestructuringDeclarationChecker : FirPropertyChecker() { + override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) { + val source = declaration.source ?: return + // val (...) = `destructuring_declaration` + if (source.elementType == KtNodeTypes.DESTRUCTURING_DECLARATION) { + assert(declaration.name.isSpecial && declaration.name.asString() == "") { + "Unexpected name: ${declaration.name.asString()} for destructuring declaration" + } + checkInitializer(source, declaration.initializer, reporter) + return + } + + // val (`destructuring_declaration_entry`, ...) = ... + if (source.elementType != KtNodeTypes.DESTRUCTURING_DECLARATION_ENTRY) return + + val componentCall = declaration.initializer as? FirComponentCall ?: return + val reference = componentCall.calleeReference as? FirErrorNamedReference ?: return + + val originalExpression = componentCall.explicitReceiverOfQualifiedAccess ?: return + val originalDestructuringDeclaration = originalExpression.resolvedVariable ?: return + val originalDestructuringDeclarationOrInitializer = + when (originalDestructuringDeclaration) { + is FirProperty -> { + if (originalDestructuringDeclaration.initializer?.source?.elementType == KtNodeTypes.FOR) { + // for ((entry, ...) = `destructuring_declaration`) { ... } + // It will be wrapped as `next()` call whose explicit receiver is `iterator()` on the actual source. + val iterator = originalDestructuringDeclaration.initializer?.explicitReceiverOfQualifiedAccess + (iterator?.resolvedVariable as? FirProperty)?.initializer?.explicitReceiverOfQualifiedAccess + } else { + // val (entry, ...) = `destructuring_declaration` + originalDestructuringDeclaration.initializer + } + } + is FirValueParameter -> { + // ... = { `(entry, ...)` -> ... } // value parameter itself is a destructuring declaration + originalDestructuringDeclaration + } + else -> null + } ?: return + val originalDestructuringDeclarationOrInitializerSource = originalDestructuringDeclarationOrInitializer.source ?: return + val originalDestructuringDeclarationType = + when (originalDestructuringDeclarationOrInitializer) { + is FirVariable<*> -> originalDestructuringDeclarationOrInitializer.returnTypeRef + is FirExpression -> originalDestructuringDeclarationOrInitializer.typeRef + else -> null + } ?: return + + when (val diagnostic = reference.diagnostic) { + is ConeUnresolvedNameError -> { + reporter.report( + FirErrors.COMPONENT_FUNCTION_MISSING.on( + originalDestructuringDeclarationOrInitializerSource, + diagnostic.name, + originalDestructuringDeclarationType + ) + ) + } + is ConeAmbiguityError -> { + reporter.report( + FirErrors.COMPONENT_FUNCTION_AMBIGUITY.on( + originalDestructuringDeclarationOrInitializerSource, + diagnostic.name, + diagnostic.candidates + ) + ) + } + // TODO: COMPONENT_FUNCTION_ON_NULLABLE + // TODO: COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH + } + } + + private fun checkInitializer(source: FirSourceElement, initializer: FirExpression?, reporter: DiagnosticReporter) { + val needToReport = + when (initializer) { + null -> true + is FirErrorExpression -> (initializer.diagnostic as? ConeSimpleDiagnostic)?.kind == DiagnosticKind.Syntax + else -> false + } + if (needToReport) { + reporter.report(source, FirErrors.INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION) + } + } + + private val FirExpression.explicitReceiverOfQualifiedAccess: FirQualifiedAccessExpression? + get() = (this as? FirQualifiedAccess)?.explicitReceiver?.unwrapped as? FirQualifiedAccessExpression + + private val FirExpression.unwrapped: FirExpression + get() = + when (this) { + is FirExpressionWithSmartcast -> this.originalExpression + is FirWrappedExpression -> this.expression + else -> this + } + + private val FirQualifiedAccessExpression.resolvedVariable: FirVariable<*>? + get() = ((calleeReference as? FirResolvedNamedReference)?.resolvedSymbol as? FirVariableSymbol)?.fir as? FirVariable<*> +} diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationInitializerChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationInitializerChecker.kt deleted file mode 100644 index a6d6e772892..00000000000 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirDestructuringDeclarationInitializerChecker.kt +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors. - * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file. - */ - -package org.jetbrains.kotlin.fir.analysis.checkers.declaration - -import org.jetbrains.kotlin.KtNodeTypes -import org.jetbrains.kotlin.fir.FirFakeSourceElementKind -import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext -import org.jetbrains.kotlin.fir.analysis.checkers.extended.report -import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter -import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors -import org.jetbrains.kotlin.fir.declarations.FirProperty -import org.jetbrains.kotlin.fir.diagnostics.ConeSimpleDiagnostic -import org.jetbrains.kotlin.fir.diagnostics.DiagnosticKind -import org.jetbrains.kotlin.fir.expressions.FirErrorExpression - -object FirDestructuringDeclarationInitializerChecker : FirPropertyChecker() { - override fun check(declaration: FirProperty, context: CheckerContext, reporter: DiagnosticReporter) { - if (!declaration.name.isSpecial || declaration.name.asString() != "") return - val source = declaration.source - if (source == null || source.kind is FirFakeSourceElementKind) return - if (source.elementType != KtNodeTypes.DESTRUCTURING_DECLARATION) return - val needToReport = - when (val initializer = declaration.initializer) { - null -> true - is FirErrorExpression -> (initializer.diagnostic as? ConeSimpleDiagnostic)?.kind == DiagnosticKind.Syntax - else -> false - } - if (needToReport) { - reporter.report(source, FirErrors.INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION) - } - } -} diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt index 4a154518f0c..33a800bf918 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/collectors/components/ErrorNodeDiagnosticCollectorComponent.kt @@ -59,6 +59,14 @@ class ErrorNodeDiagnosticCollectorComponent(collector: AbstractDiagnosticCollect } private fun reportFirDiagnostic(diagnostic: ConeDiagnostic, source: FirSourceElement, reporter: DiagnosticReporter) { + // Will be handled by [FirDestructuringDeclarationChecker] + if (source.elementType == KtNodeTypes.DESTRUCTURING_DECLARATION_ENTRY) { + // TODO: if all diagnostics are supported, we don't need the following check, and will bail out based on element type. + if (diagnostic is ConeUnresolvedNameError || diagnostic is ConeAmbiguityError) { + return + } + } + val coneDiagnostic = when (diagnostic) { is ConeUnresolvedReferenceError -> FirErrors.UNRESOLVED_REFERENCE.on(source, diagnostic.name?.asString() ?: "") is ConeUnresolvedSymbolError -> FirErrors.UNRESOLVED_REFERENCE.on(source, diagnostic.classId.asString()) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt index a038eb8dd01..3b40846d9ae 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt @@ -7,9 +7,11 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics import org.jetbrains.kotlin.diagnostics.rendering.DefaultErrorMessages import org.jetbrains.kotlin.diagnostics.rendering.DiagnosticFactoryToRendererMap +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.AMBIGUOUS_CALLS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.DECLARATION_NAME import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.NULLABLE_STRING import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.PROPERTY_NAME +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.RENDER_TYPE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.SYMBOL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.SYMBOLS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticRenderers.TO_STRING @@ -32,6 +34,8 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.BREAK_OR_CONTINUE import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CAN_BE_REPLACED_WITH_OPERATOR_ASSIGNMENT import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CAN_BE_VAL import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CLASS_IN_SUPERTYPE_FOR_ENUM +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.COMPONENT_FUNCTION_AMBIGUITY +import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.COMPONENT_FUNCTION_MISSING import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CONFLICTING_OVERLOADS import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CONFLICTING_PROJECTION import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.CONSTRUCTOR_IN_INTERFACE @@ -382,6 +386,18 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension { // Destructuring declaration map.put(INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION, "Initializer required for destructuring declaration") + map.put( + COMPONENT_FUNCTION_MISSING, + "Destructuring declaration initializer of type {1} must have a ''{0}()'' function", + TO_STRING, + RENDER_TYPE + ) + map.put( + COMPONENT_FUNCTION_AMBIGUITY, + "Function ''{0}''() is ambiguous for this expression: {1}", + TO_STRING, + AMBIGUOUS_CALLS + ) // Control flow diagnostics map.put(UNINITIALIZED_VARIABLE, "{0} must be initialized before access", PROPERTY_NAME) diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt index 906466b40e8..a06c569f83b 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDiagnosticRenderers.kt @@ -13,6 +13,7 @@ import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol import org.jetbrains.kotlin.fir.symbols.impl.FirPropertySymbol +import org.jetbrains.kotlin.fir.types.FirTypeRef object FirDiagnosticRenderers { val NULLABLE_STRING = Renderer { it ?: "null" } @@ -56,4 +57,15 @@ object FirDiagnosticRenderers { } name.asString() } + + val RENDER_TYPE = Renderer { typeRef: FirTypeRef -> + // TODO: need a way to tune granuality, e.g., without parameter names in functional types. + typeRef.render() + } + + val AMBIGUOUS_CALLS = Renderer { candidates: Collection> -> + candidates.joinToString(separator = "\n", prefix = "\n") { symbol -> + SYMBOL.render(symbol) + } + } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt index c8c56ec913f..6f9c6108c03 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt +++ b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt @@ -13,12 +13,15 @@ import org.jetbrains.kotlin.fir.FirSourceElement import org.jetbrains.kotlin.fir.declarations.FirClass import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration import org.jetbrains.kotlin.fir.expressions.FirExpression +import org.jetbrains.kotlin.fir.expressions.FirStatement import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol import org.jetbrains.kotlin.fir.symbols.impl.* import org.jetbrains.kotlin.fir.types.ConeKotlinType +import org.jetbrains.kotlin.fir.types.FirTypeRef import org.jetbrains.kotlin.lexer.KtModifierKeywordToken import org.jetbrains.kotlin.name.Name import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.types.KotlinType object FirErrors { // Miscellaneous @@ -174,6 +177,10 @@ object FirErrors { // Destructuring declaration val INITIALIZER_REQUIRED_FOR_DESTRUCTURING_DECLARATION by error0() + val COMPONENT_FUNCTION_MISSING by error2() + val COMPONENT_FUNCTION_AMBIGUITY by error2>>() + // TODO: val COMPONENT_FUNCTION_ON_NULLABLE by ... + // TODO: val COMPONENT_FUNCTION_RETURN_TYPE_MISMATCH by ... // Control flow diagnostics val UNINITIALIZED_VARIABLE by error1() diff --git a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonDeclarationCheckers.kt b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonDeclarationCheckers.kt index 61537e04d1f..099f3ffbf0c 100644 --- a/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonDeclarationCheckers.kt +++ b/compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/checkers/CommonDeclarationCheckers.kt @@ -32,7 +32,7 @@ object CommonDeclarationCheckers : DeclarationCheckers() { override val propertyCheckers: Set = setOf( FirInapplicableLateinitChecker, - FirDestructuringDeclarationInitializerChecker, + FirDestructuringDeclarationChecker, ) override val regularClassCheckers: Set = setOf( diff --git a/compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.fir.kt index e311960423f..93b54cc4397 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.fir.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/MultiDeclarationErrors.fir.kt @@ -11,7 +11,7 @@ class MyClass2 {} fun MyClass2.component1() = 1.3 fun test(mc1: MyClass, mc2: MyClass2) { - val (a, b) = mc1 + val (a, b) = mc1 val (c) = mc2 //a,b,c are error types diff --git a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionAmbiguity.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionAmbiguity.fir.kt index e845fef30e1..fddfd72aaca 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionAmbiguity.fir.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionAmbiguity.fir.kt @@ -9,7 +9,7 @@ class C { } fun test() { - for ((x, y) in C()) { + for ((x, y) in C()) { } } diff --git a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionMissing.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionMissing.fir.kt index 068be345d66..95924e4c839 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionMissing.fir.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopComponentFunctionMissing.fir.kt @@ -7,7 +7,7 @@ class C { } fun test() { - for ((x, y) in C()) { + for ((x, y) in C()) { } } diff --git a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopMissingLoopParameter.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopMissingLoopParameter.fir.kt index 0bc48dd8f5b..27d22aa856c 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopMissingLoopParameter.fir.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/ForLoopMissingLoopParameter.fir.kt @@ -1,13 +1,13 @@ // !WITH_NEW_INFERENCE fun useDeclaredVariables() { - for ((a, b)) { + for ((a, b)) { a b } } fun checkersShouldRun() { - for ((@A a, _)) { + for ((@A a, _)) { } } diff --git a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationAssignedUnresolved.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationAssignedUnresolved.fir.kt index da599329974..2a5ec373b5a 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationAssignedUnresolved.fir.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationAssignedUnresolved.fir.kt @@ -1,11 +1,11 @@ fun useDeclaredVariables() { - val (a, b) = unresolved + val (a, b) = unresolved a b } fun checkersShouldRun() { - val (@A a, _) = unresolved + val (@A a, _) = unresolved } annotation class A diff --git a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationMissingInitializer.fir.kt b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationMissingInitializer.fir.kt index 307dc46e555..3b11c44915f 100644 --- a/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationMissingInitializer.fir.kt +++ b/compiler/testData/diagnostics/tests/declarationChecks/destructuringDeclarations/destructuringDeclarationMissingInitializer.fir.kt @@ -1,11 +1,11 @@ fun useDeclaredVariables() { - val (a, b) + val (a, b) a b } fun checkersShouldRun() { - val (@A a, _) + val (@A a, _) } annotation class A diff --git a/compiler/testData/diagnostics/tests/functionLiterals/DeprecatedSyntax.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/DeprecatedSyntax.fir.kt index dac5ccb52fb..8111b18415b 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/DeprecatedSyntax.fir.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/DeprecatedSyntax.fir.kt @@ -6,12 +6,12 @@ val receiverAndReturnType = { Int.(): Int -> 5 } val receiverAndReturnTypeWithParameter = { Int.(a: Int): Int -> 5 } val returnType = { (): Int -> 5 } -val returnTypeWithParameter = { (b: Int): Int -> 5 } +val returnTypeWithParameter = { (b: Int): Int -> 5 } val receiverWithFunctionType = { ((Int) -> Int).() -> } -val parenthesizedParameters = { (a: Int) -> } -val parenthesizedParameters2 = { (b) -> } +val parenthesizedParameters = { (a: Int) -> } +val parenthesizedParameters2 = { (b) -> } val none = { -> } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.fir.kt index 5a90d6d1d9e..b12e1a7dcd1 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.fir.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/complexInference.fir.kt @@ -9,7 +9,7 @@ fun foo(y: Y, x: (X, Y) -> Unit) {} fun bar(aInstance: A, bInstance: B) { foo("") { - (a, b): A, c -> + (a, b): A, c -> a checkType { _() } b checkType { _() } c checkType { _() } diff --git a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/noExpectedType.fir.kt b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/noExpectedType.fir.kt index d7af54b0415..270d1deee1d 100644 --- a/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/noExpectedType.fir.kt +++ b/compiler/testData/diagnostics/tests/functionLiterals/destructuringInLambdas/noExpectedType.fir.kt @@ -4,28 +4,28 @@ data class A(val x: Int, val y: String) fun bar() { - val x = { (a, b): A -> + val x = { (a, b): A -> a checkType { _() } b checkType { _() } } x checkType { _<(A) -> Unit>() } - val y = { (a: Int, b): A -> + val y = { (a: Int, b): A -> a checkType { _() } b checkType { _() } } y checkType { _<(A) -> Unit>() } - val y2 = { (a: Number, b): A -> + val y2 = { (a: Number, b): A -> a checkType { _() } b checkType { _() } } y2 checkType { _<(A) -> Unit>() } - val z = { (a: Int, b: String) -> + val z = { (a: Int, b: String) -> a checkType { _() } b checkType { _() } } diff --git a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.fir.kt b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.fir.kt index 9818e905979..26b87f01991 100644 --- a/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.fir.kt +++ b/compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.fir.kt @@ -46,5 +46,5 @@ fun foo() { propertyWithType: Int val - (a, b) = 1 + (a, b) = 1 }