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

FIR checkers: report specific errors instead of INAPPLICABLE_CANDIDATE

Browse Source 
Specifically, the report the following 4 errors.

* NON_VARARG_SPREAD
* ARGUMENT_PASSED_TWICE
* TOO_MANY_ARGUMENTS
* NO_VALUE_FOR_PARAMETER

Also added/updated the following position strategies.
* NAME_OF_NAMED_ARGUMENT
* VALUE_ARGUMENTS
This commit is contained in:
Tianyu Geng
2021-03-04 14:01:32 -08:00
committed by Mikhail Glukhikh
parent fc8d0e3ee0
commit 761a0a7d0d
143 changed files with 526 additions and 470 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/fir/analysis-tests/testData/resolve/arguments/argumentsOfAnnotations.kt
Vendored
+1 -1
View File
@@ -5,5 +5,5 @@ class A
annotation class AnnVarargs(val x: Int, vararg val y: String, val z: Int)
<!INAPPLICABLE_CANDIDATE!>@AnnVarargs(1, "a", "b", "c", 2)<!>
@AnnVarargs(1, "a", "b", "c", 2<!NO_VALUE_FOR_PARAMETER!>)<!>
class B
compiler/fir/analysis-tests/testData/resolve/arguments/default.kt
Vendored
+3 -3
View File
@@ -8,14 +8,14 @@ fun test() {
foo(1, 2.0, true)
foo(1, third = true)
<!INAPPLICABLE_CANDIDATE!>foo<!>()
<!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, "")
foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
foo(0, 0.0, false, <!TOO_MANY_ARGUMENTS!>""<!>)
bar(1, third = true)
bar(1, 2.0, true)
bar(1, 2.0, true, "my")
<!INAPPLICABLE_CANDIDATE!>bar<!>(1, true)
bar(1, true<!NO_VALUE_FOR_PARAMETER!>)<!>
baz(1)
baz(1, "my", "yours")
compiler/fir/analysis-tests/testData/resolve/arguments/defaultFromOverrides.kt
Vendored
+2 -2
View File
@@ -15,8 +15,8 @@ fun foo(a: A) {
a.foo()
a.foo(1)
a.<!INAPPLICABLE_CANDIDATE!>bar<!>()
a.<!INAPPLICABLE_CANDIDATE!>bar<!>("")
a.bar(<!NO_VALUE_FOR_PARAMETER!>)<!>
a.bar(""<!NO_VALUE_FOR_PARAMETER!>)<!>
a.bar(y = 1)
a.bar("", 2)
}
compiler/fir/analysis-tests/testData/resolve/arguments/lambda.kt
Vendored
+7 -7
View File
@@ -10,8 +10,8 @@ fun test() {
foo({})
// Bad
<!INAPPLICABLE_CANDIDATE!>foo<!>(1) {}
<!INAPPLICABLE_CANDIDATE!>foo<!>(f = {}) {}
foo(1) <!TOO_MANY_ARGUMENTS!>{}<!>
foo(f = {}) <!TOO_MANY_ARGUMENTS!>{}<!>
// OK
bar(1) {}
@@ -20,15 +20,15 @@ fun test() {
bar(x = 1, f = {})
// Bad
<!INAPPLICABLE_CANDIDATE!>bar<!> {}
<!INAPPLICABLE_CANDIDATE!>bar<!>({})
<!NO_VALUE_FOR_PARAMETER!>bar {}<!>
bar({}<!NO_VALUE_FOR_PARAMETER!>)<!>
// OK
baz(other = false, f = {})
baz({}, false)
// Bad
<!INAPPLICABLE_CANDIDATE!>baz<!> {}
<!INAPPLICABLE_CANDIDATE!>baz<!>() {}
<!INAPPLICABLE_CANDIDATE!>baz<!>(other = false) {}
<!NO_VALUE_FOR_PARAMETER!>baz {}<!>
baz(<!NO_VALUE_FOR_PARAMETER!>)<!> {}
baz(other = false<!NO_VALUE_FOR_PARAMETER!>)<!> <!TOO_MANY_ARGUMENTS!>{}<!>
}
compiler/fir/analysis-tests/testData/resolve/arguments/simple.kt
Vendored
+4 -4
View File
@@ -7,11 +7,11 @@ fun test() {
foo(1, second = 3.14, third = false, fourth = "!?")
foo(third = false, second = 2.71, fourth = "?!", first = 0)
<!INAPPLICABLE_CANDIDATE!>foo<!>()
foo(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(0.0, false, 0, "")
foo(1, 2.0, third = true, "")
<!INAPPLICABLE_CANDIDATE!>foo<!>(second = 0.0, first = 0, fourth = "")
foo(second = 0.0, first = 0, fourth = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0.0, second = 0, third = "", fourth = false)
<!INAPPLICABLE_CANDIDATE!>foo<!>(first = 0, second = 0.0, third = false, fourth = "", first = 1)
<!INAPPLICABLE_CANDIDATE!>foo<!>(0, 0.0, false, foth = "")
foo(first = 0, second = 0.0, third = false, fourth = "", <!ARGUMENT_PASSED_TWICE!>first<!> = 1)
foo(0, 0.0, false, foth = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/fir/analysis-tests/testData/resolve/arguments/vararg.fir.txt
Vendored
+1
View File
@@ -13,4 +13,5 @@ FILE: vararg.kt
R|/bar|(Int(1), z = Boolean(true), vararg(y = *R|kotlin/arrayOf|<R|kotlin/String|>(vararg(String(my), String(yours)))))
<Inapplicable(INAPPLICABLE): /bar>#(Int(0), z = Boolean(false), y = String(), y = String(other))
<Inapplicable(INAPPLICABLE_ARGUMENTS_MAPPING_ERROR): /bar>#(Int(0), String(), Boolean(true))
<Inapplicable(INAPPLICABLE): /bar>#(Int(0), z = Boolean(false), y = String(), y = String(other), y = String(yet other))
}
compiler/fir/analysis-tests/testData/resolve/arguments/vararg.kt
Vendored
+3 -2
View File
@@ -12,6 +12,7 @@ fun test() {
bar(1, z = true, y = *arrayOf("my", "yours"))
<!INAPPLICABLE_CANDIDATE!>bar<!>(0, z = false, y = "", y = "other")
<!INAPPLICABLE_CANDIDATE!>bar<!>(0, "", true)
bar(0, z = false, y = "", <!ARGUMENT_PASSED_TWICE!>y<!> = "other")
bar(0, "", true<!NO_VALUE_FOR_PARAMETER!>)<!>
bar(0, z = false, y = "", <!ARGUMENT_PASSED_TWICE!>y<!> = "other", <!ARGUMENT_PASSED_TWICE!>y<!> = "yet other")
}
compiler/fir/analysis-tests/testData/resolve/diagnostics/supertypeInitializedWithoutPrimaryConstructor.kt
Vendored
+1 -1
View File
@@ -2,7 +2,7 @@ class A
class B : <!SUPERTYPE_NOT_INITIALIZED!>A<!>
class C(x: Int)
<!INAPPLICABLE_CANDIDATE!>class D : <!SUPERTYPE_NOT_INITIALIZED!>C<!><!>
<!NO_VALUE_FOR_PARAMETER!>class D : <!SUPERTYPE_NOT_INITIALIZED!>C<!><!>
class E : C(10)
class F() : C(10)
compiler/fir/analysis-tests/testData/resolve/expresssions/CallBasedInExpressionGenerator.kt
Vendored
+1 -1
View File
@@ -21,7 +21,7 @@ class CallBasedInExpressionGenerator(
gen(argument).let { if (isInverted) <!UNRESOLVED_REFERENCE!>Invert<!>(it) else it }
private fun gen(argument: StackValue): BranchedValue =
object : <!INAPPLICABLE_CANDIDATE!>BranchedValue<!>(argument, null, argument.<!UNRESOLVED_REFERENCE!>type<!>, <!UNRESOLVED_REFERENCE!>Opcodes<!>.IFEQ) {
object : BranchedValue(<!TOO_MANY_ARGUMENTS!>argument<!>, <!TOO_MANY_ARGUMENTS!>null<!>, <!TOO_MANY_ARGUMENTS!>argument.<!UNRESOLVED_REFERENCE!>type<!><!>, <!TOO_MANY_ARGUMENTS!><!UNRESOLVED_REFERENCE!>Opcodes<!>.IFEQ<!>) {
override fun putSelector(type: Type, kotlinType: KotlinType?, v: InstructionAdapter) {
invokeFunction(v)
<!UNRESOLVED_REFERENCE!>coerceTo<!>(type, kotlinType, v)
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/DiagnosticData.kt
+3 -2
View File
@@ -50,8 +50,9 @@ enum class PositioningStrategy(private val strategy: String? = null) {
PRIVATE_MODIFIER,
COMPANION_OBJECT,
CONST_MODIFIER,
ARRAY_ACCESS
ARRAY_ACCESS,
NAME_OF_NAMED_ARGUMENT,
VALUE_ARGUMENTS,
;
val expressionToCreate get() = "SourceElementPositioningStrategies.${strategy ?: name}"
compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt
+12 -2
View File
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.checkers.generator.diagnostics
import com.intellij.psi.PsiElement
import com.intellij.psi.PsiTypeElement
import com.intellij.psi.impl.source.tree.LeafPsiElement
import org.jetbrains.kotlin.config.LanguageFeature
import org.jetbrains.kotlin.config.LanguageVersionSettings
import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
@@ -18,6 +19,7 @@ import org.jetbrains.kotlin.fir.PrivateForInline
import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
@@ -219,10 +221,18 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
val VARARG_OUTSIDE_PARENTHESES by error<FirSourceElement, KtExpression>()
// TODO: implement a position strategy that highlights the argument name instead of the whole named argument
val NAMED_ARGUMENTS_NOT_ALLOWED by error<FirSourceElement, PsiElement> {
val NAMED_ARGUMENTS_NOT_ALLOWED by error<FirSourceElement, KtValueArgument>(PositioningStrategy.NAME_OF_NAMED_ARGUMENT) {
parameter<ForbiddenNamedArgumentsTarget>("forbiddenNamedArgumentsTarget")
}
val NON_VARARG_SPREAD by error<FirSourceElement, LeafPsiElement>()
val ARGUMENT_PASSED_TWICE by error<FirSourceElement, KtValueArgument>(PositioningStrategy.NAME_OF_NAMED_ARGUMENT)
val TOO_MANY_ARGUMENTS by error<FirSourceElement, PsiElement> {
parameter<FirCallableDeclaration<*>>("function")
}
val NO_VALUE_FOR_PARAMETER by error<FirSourceElement, KtElement>(PositioningStrategy.VALUE_ARGUMENTS) {
parameter<FirValueParameter>("violatedParameter")
}
}
val AMBIGUITY by object : DiagnosticGroup("Ambiguity") {
compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt
+8 -1
View File
@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.analysis.diagnostics
import com.intellij.psi.PsiElement
import com.intellij.psi.PsiTypeElement
import com.intellij.psi.impl.source.tree.LeafPsiElement
import org.jetbrains.kotlin.config.LanguageFeature
import org.jetbrains.kotlin.config.LanguageVersionSettings
import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
@@ -18,6 +19,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.SourceElementPositioningStr
import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
import org.jetbrains.kotlin.fir.declarations.FirClass
import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
import org.jetbrains.kotlin.fir.declarations.FirValueParameter
import org.jetbrains.kotlin.fir.expressions.FirExpression
import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
@@ -48,6 +50,7 @@ import org.jetbrains.kotlin.psi.KtTypeAlias
import org.jetbrains.kotlin.psi.KtTypeParameter
import org.jetbrains.kotlin.psi.KtTypeParameterList
import org.jetbrains.kotlin.psi.KtTypeReference
import org.jetbrains.kotlin.psi.KtValueArgument
import org.jetbrains.kotlin.psi.KtWhenExpression
import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
@@ -179,7 +182,11 @@ object FirErrors {
val INAPPLICABLE_CANDIDATE by error1<FirSourceElement, PsiElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
val INAPPLICABLE_LATEINIT_MODIFIER by error1<FirSourceElement, KtModifierListOwner, String>(SourceElementPositioningStrategies.LATEINIT_MODIFIER)
val VARARG_OUTSIDE_PARENTHESES by error0<FirSourceElement, KtExpression>()
val NAMED_ARGUMENTS_NOT_ALLOWED by error1<FirSourceElement, PsiElement, ForbiddenNamedArgumentsTarget>()
val NAMED_ARGUMENTS_NOT_ALLOWED by error1<FirSourceElement, KtValueArgument, ForbiddenNamedArgumentsTarget>(SourceElementPositioningStrategies.NAME_OF_NAMED_ARGUMENT)
val NON_VARARG_SPREAD by error0<FirSourceElement, LeafPsiElement>()
val ARGUMENT_PASSED_TWICE by error0<FirSourceElement, KtValueArgument>(SourceElementPositioningStrategies.NAME_OF_NAMED_ARGUMENT)
val TOO_MANY_ARGUMENTS by error1<FirSourceElement, PsiElement, FirCallableDeclaration<*>>()
val NO_VALUE_FOR_PARAMETER by error1<FirSourceElement, KtElement, FirValueParameter>(SourceElementPositioningStrategies.VALUE_ARGUMENTS)
// Ambiguity
val AMBIGUITY by error1<FirSourceElement, PsiElement, Collection<AbstractFirBasedSymbol<*>>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt
+8
View File
@@ -38,6 +38,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_ARGUME
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_CLASS_MEMBER
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ANONYMOUS_FUNCTION_PARAMETER_WITH_DEFAULT_VALUE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ARGUMENT_PASSED_TWICE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ARRAY_EQUALITY_OPERATOR_CAN_BE_REPLACED_WITH_EQUALS
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ASSIGNED_VALUE_IS_NEVER_READ
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ASSIGN_OPERATOR_AMBIGUITY
@@ -139,6 +140,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_FINAL_MEMBER_
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_MEMBER_FUNCTION_NO_BODY
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_PRIVATE_CONSTRUCTOR_IN_ENUM
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_PRIVATE_OR_PROTECTED_CONSTRUCTOR_IN_SEALED
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NON_VARARG_SPREAD
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NOTHING_TO_OVERRIDE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NOT_AN_ANNOTATION_CLASS
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NOT_A_LOOP_LABEL
@@ -147,6 +149,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NO_ELSE_IN_WHEN
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NO_GET_METHOD
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NO_SET_METHOD
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NO_THIS
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NO_VALUE_FOR_PARAMETER
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NULLABLE_TYPE_IN_CLASS_LITERAL_LHS
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.NULLABLE_TYPE_OF_ANNOTATION_MEMBER
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.OTHER_ERROR
@@ -193,6 +196,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPERTYPE_NOT_INI
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPER_IS_NOT_AN_EXPRESSION
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SUPER_NOT_AVAILABLE
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.SYNTAX
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TOO_MANY_ARGUMENTS
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TOPLEVEL_TYPEALIASES_ONLY
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPE_ARGUMENTS_NOT_ALLOWED
import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.TYPE_MISMATCH
@@ -386,6 +390,10 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
map.put(INAPPLICABLE_LATEINIT_MODIFIER, "''lateinit'' modifier {0}", TO_STRING)
map.put(VARARG_OUTSIDE_PARENTHESES, "Passing value as a vararg is only allowed inside a parenthesized argument list")
map.put(NAMED_ARGUMENTS_NOT_ALLOWED, "Named arguments are not allowed for {0}", TO_STRING)
map.put(NON_VARARG_SPREAD, "The spread operator (*foo) may only be applied in a vararg position")
map.put(TOO_MANY_ARGUMENTS, "Too many arguments for {0}", FQ_NAMES_IN_TYPES)
map.put(ARGUMENT_PASSED_TWICE, "An argument is already passed for this parameter")
map.put(NO_VALUE_FOR_PARAMETER, "No value passed for parameter ''{0}''", NAME)
// Ambiguity
map.put(AMBIGUITY, "Ambiguity between candidates: {0}", SYMBOLS)
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/LightTreePositioningStrategies.kt
+48 -1
View File
@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.lexer.KtTokens
import org.jetbrains.kotlin.lexer.KtTokens.MODALITY_MODIFIERS
import org.jetbrains.kotlin.lexer.KtTokens.VISIBILITY_MODIFIERS
import org.jetbrains.kotlin.psi.KtParameter.VAL_VAR_TOKEN_SET
import org.jetbrains.kotlin.utils.addToStdlib.firstNotNullResult
object LightTreePositioningStrategies {
val DEFAULT = object : LightTreePositioningStrategy() {
@@ -336,6 +337,34 @@ object LightTreePositioningStrategies {
}
}
val NAME_OF_NAMED_ARGUMENT: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
override fun mark(
node: LighterASTNode,
startOffset: Int,
endOffset: Int,
tree: FlyweightCapableTreeStructure<LighterASTNode>
): List<TextRange> {
return tree.findChildByType(node, KtNodeTypes.VALUE_ARGUMENT_NAME)?.let { valueArgumentName ->
markElement(valueArgumentName, startOffset, endOffset, tree, node)
} ?: markElement(node, startOffset, endOffset, tree, node)
}
}
val VALUE_ARGUMENTS: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
override fun mark(
node: LighterASTNode,
startOffset: Int,
endOffset: Int,
tree: FlyweightCapableTreeStructure<LighterASTNode>
): List<TextRange> {
return tree.findDescendantByType(node, KtNodeTypes.VALUE_ARGUMENT_LIST)?.let { valueArgumentList ->
tree.findLastChildByType(valueArgumentList, KtTokens.RPAR)?.let { rpar ->
markElement(rpar, startOffset, endOffset, tree, node)
}
} ?: markElement(node, startOffset, endOffset, tree, node)
}
}
val DOT_BY_QUALIFIED: LightTreePositioningStrategy = object : LightTreePositioningStrategy() {
override fun mark(
node: LighterASTNode,
@@ -604,13 +633,31 @@ fun FlyweightCapableTreeStructure<LighterASTNode>.findChildByType(node: LighterA
return childrenRef.get()?.firstOrNull { it?.tokenType == type }
}
fun FlyweightCapableTreeStructure<LighterASTNode>.findLastChildByType(node: LighterASTNode, type: IElementType): LighterASTNode? {
val childrenRef = Ref<Array<LighterASTNode?>>()
getChildren(node, childrenRef)
return childrenRef.get()?.lastOrNull { it?.tokenType == type }
}
fun FlyweightCapableTreeStructure<LighterASTNode>.findDescendantByType(node: LighterASTNode, type: IElementType): LighterASTNode? {
val childrenRef = Ref<Array<LighterASTNode?>>()
getChildren(node, childrenRef)
return childrenRef.get()?.firstOrNull { it?.tokenType == type } ?: childrenRef.get()
?.firstNotNullResult { child -> child?.let { findDescendantByType(it, type) } }
}
private fun FlyweightCapableTreeStructure<LighterASTNode>.findChildByType(node: LighterASTNode, type: TokenSet): LighterASTNode? {
val childrenRef = Ref<Array<LighterASTNode?>>()
getChildren(node, childrenRef)
return childrenRef.get()?.firstOrNull { it?.tokenType in type }
}
private fun FlyweightCapableTreeStructure<LighterASTNode>.findParentOfType(node: LighterASTNode, type: IElementType): LighterASTNode? {
private fun FlyweightCapableTreeStructure<LighterASTNode>.findParentOfType(
node: LighterASTNode,
type: IElementType,
strict: Boolean = true
): LighterASTNode? {
if (!strict && node.tokenType == type) return node
var parent = getParent(node)
while (parent != null) {
if (parent.tokenType == type) return parent
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/SourceElementPositioningStrategies.kt
+11 -1
View File
@@ -107,7 +107,7 @@ object SourceElementPositioningStrategies {
LightTreePositioningStrategies.OPERATOR,
PositioningStrategies.OPERATOR
)
val PARAMETER_DEFAULT_VALUE = SourceElementPositioningStrategy(
LightTreePositioningStrategies.PARAMETER_DEFAULT_VALUE,
PositioningStrategies.PARAMETER_DEFAULT_VALUE
@@ -118,6 +118,16 @@ object SourceElementPositioningStrategies {
PositioningStrategies.PARAMETER_VARARG_MODIFIER
)
val NAME_OF_NAMED_ARGUMENT = SourceElementPositioningStrategy(
LightTreePositioningStrategies.NAME_OF_NAMED_ARGUMENT,
PositioningStrategies.NAME_OF_NAMED_ARGUMENT
)
val VALUE_ARGUMENTS = SourceElementPositioningStrategy(
LightTreePositioningStrategies.VALUE_ARGUMENTS,
PositioningStrategies.VALUE_ARGUMENTS
)
val DOT_BY_QUALIFIED = SourceElementPositioningStrategy(
LightTreePositioningStrategies.DOT_BY_QUALIFIED,
PositioningStrategies.DOT_BY_QUALIFIED
compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt
+6 -5
View File
@@ -13,10 +13,7 @@ import org.jetbrains.kotlin.fir.declarations.FirSimpleFunction
import org.jetbrains.kotlin.fir.declarations.isInfix
import org.jetbrains.kotlin.fir.declarations.isOperator
import org.jetbrains.kotlin.fir.diagnostics.*
import org.jetbrains.kotlin.fir.resolve.calls.InapplicableWrongReceiver
import org.jetbrains.kotlin.fir.resolve.calls.NamedArgumentNotAllowed
import org.jetbrains.kotlin.fir.resolve.calls.ResolutionDiagnostic
import org.jetbrains.kotlin.fir.resolve.calls.VarargArgumentOutsideParentheses
import org.jetbrains.kotlin.fir.resolve.calls.*
import org.jetbrains.kotlin.fir.resolve.diagnostics.*
import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
import org.jetbrains.kotlin.fir.types.*
@@ -137,9 +134,13 @@ private fun mapInapplicableCandidateError(
rootCause.argument.source ?: qualifiedAccessSource
)
is NamedArgumentNotAllowed -> FirErrors.NAMED_ARGUMENTS_NOT_ALLOWED.on(
rootCause.argument.source ?: qualifiedAccessSource,
rootCause.argument.source,
rootCause.forbiddenNamedArgumentsTarget
)
is NonVarargSpread -> FirErrors.NON_VARARG_SPREAD.on(rootCause.argument.source?.getChild(KtTokens.MUL, depth = 1)!!)
is ArgumentPassedTwice -> FirErrors.ARGUMENT_PASSED_TWICE.on(rootCause.argument.source)
is TooManyArguments -> FirErrors.TOO_MANY_ARGUMENTS.on(rootCause.argument.source ?: source, rootCause.function)
is NoValueForParameter -> FirErrors.NO_VALUE_FOR_PARAMETER.on(qualifiedAccessSource ?: source, rootCause.valueParameter)
else -> null
}
}.ifEmpty { listOf(FirErrors.INAPPLICABLE_CANDIDATE.on(source, diagnostic.candidate.symbol)) }
compiler/frontend/src/org/jetbrains/kotlin/diagnostics/PositioningStrategies.kt
+12 -1
View File
@@ -470,6 +470,17 @@ object PositioningStrategies {
}
}
/**
* Mark the name of a named argument. If the given element is not a named argument or doesn't have a name, then the entire given element
* is marked instead.
*/
@JvmField
val NAME_OF_NAMED_ARGUMENT: PositioningStrategy<KtValueArgument> = object : PositioningStrategy<KtValueArgument>() {
override fun mark(element: KtValueArgument): List<TextRange> {
return markElement(element.getArgumentName() ?: element)
}
}
@JvmField
val CALL_ELEMENT: PositioningStrategy<PsiElement> = object : PositioningStrategy<PsiElement>() {
override fun mark(element: PsiElement): List<TextRange> {
@@ -563,7 +574,7 @@ object PositioningStrategies {
@JvmField
val VALUE_ARGUMENTS: PositioningStrategy<KtElement> = object : PositioningStrategy<KtElement>() {
override fun mark(element: KtElement): List<TextRange> {
return markElement((element as? KtValueArgumentList)?.rightParenthesis ?: element)
return markElement(element.findDescendantOfType<KtValueArgumentList>()?.rightParenthesis ?: element)
}
}
compiler/testData/diagnostics/tests/Basic.fir.kt
Vendored
+1 -1
View File
@@ -10,7 +10,7 @@ fun test() : Int {
}
class A() {
val x : Int = <!INAPPLICABLE_CANDIDATE!>foo1<!>(<!UNRESOLVED_REFERENCE!>xx<!>)
val x : Int = foo1(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)
}
fun foo1() {}
compiler/testData/diagnostics/tests/CharacterLiterals.fir.kt
Vendored
+2 -2
View File
@@ -2,12 +2,12 @@ fun test(c : Char) {
test(<!ILLEGAL_CONST_EXPRESSION!>''<!>)
test('a')
test(<!ILLEGAL_CONST_EXPRESSION!>'aa'<!>)
<!INAPPLICABLE_CANDIDATE!>test<!>(<!ILLEGAL_CONST_EXPRESSION!>'a)<!>
test(<!ILLEGAL_CONST_EXPRESSION!>'a)<!>
<!UNRESOLVED_REFERENCE!>test<!>(<!ILLEGAL_CONST_EXPRESSION!>'<!>
<!UNRESOLVED_REFERENCE!>test<!>(0<!ILLEGAL_CONST_EXPRESSION!><!SYNTAX!><!>'<!>
<!UNRESOLVED_REFERENCE!>test<!>('\n')
test('\\')
test(<!ILLEGAL_CONST_EXPRESSION!>''<!><!ILLEGAL_CONST_EXPRESSION!><!SYNTAX!><!>''<!>)
test(<!ILLEGAL_CONST_EXPRESSION!>''<!><!ILLEGAL_CONST_EXPRESSION, TOO_MANY_ARGUMENTS!><!SYNTAX!><!>''<!>)
test('\'')
test('\"')
}
compiler/testData/diagnostics/tests/ConstructorsOfPrimitives.fir.kt
Vendored
+7 -7
View File
@@ -1,10 +1,10 @@
fun test() {
<!INAPPLICABLE_CANDIDATE!>Double<!>()
<!INAPPLICABLE_CANDIDATE!>Float<!>()
<!INAPPLICABLE_CANDIDATE!>Long<!>()
<!INAPPLICABLE_CANDIDATE!>Int<!>()
<!INAPPLICABLE_CANDIDATE!>Short<!>()
<!INAPPLICABLE_CANDIDATE!>Byte<!>()
Double(<!NO_VALUE_FOR_PARAMETER!>)<!>
Float(<!NO_VALUE_FOR_PARAMETER!>)<!>
Long(<!NO_VALUE_FOR_PARAMETER!>)<!>
Int(<!NO_VALUE_FOR_PARAMETER!>)<!>
Short(<!NO_VALUE_FOR_PARAMETER!>)<!>
Byte(<!NO_VALUE_FOR_PARAMETER!>)<!>
<!HIDDEN!>Char<!>()
<!INAPPLICABLE_CANDIDATE!>Boolean<!>()
Boolean(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/testData/diagnostics/tests/FunctionCalleeExpressions.fir.kt
Vendored
+5 -5
View File
@@ -28,8 +28,8 @@ fun <T> fooT2() : (t : T) -> T {
fun main(args : Array<String>) {
args.foo()()
<!INAPPLICABLE_CANDIDATE!>args.foo1()<!>()
<!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()<!>()
args.foo1(<!NO_VALUE_FOR_PARAMETER!>)<!>()
<!UNRESOLVED_REFERENCE!>a<!>.foo1(<!NO_VALUE_FOR_PARAMETER!>)<!>()
<!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
args.foo1()(1)
@@ -38,7 +38,7 @@ fun main(args : Array<String>) {
<!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
foo2()({})
<!INAPPLICABLE_CANDIDATE!>foo2<!>(){}
foo2()<!TOO_MANY_ARGUMENTS!>{}<!>
(foo2()){}
<!INAPPLICABLE_CANDIDATE!>(foo2())<!>{x -> }
<!INAPPLICABLE_CANDIDATE!>foo2()<!>({x -> })
@@ -76,8 +76,8 @@ fun main1() {
}
fun test() {
<!INAPPLICABLE_CANDIDATE!>{x : Int -> 1}<!>();
<!INAPPLICABLE_CANDIDATE!>(fun Int.() = 1)<!>()
{x : Int -> 1}(<!NO_VALUE_FOR_PARAMETER!>)<!>;
(fun Int.() = 1)(<!NO_VALUE_FOR_PARAMETER!>)<!>
"sd".(<!UNRESOLVED_REFERENCE!>fun Int.() = 1<!>)()
val i : Int? = null
i.(<!UNRESOLVED_REFERENCE!>fun Int.() = 1<!>)();
compiler/testData/diagnostics/tests/Nullability.fir.kt
Vendored
+6 -6
View File
@@ -44,7 +44,7 @@ fun test() {
if (out == null || out.println(0) == Unit) {
out?.println(1)
out.<!INAPPLICABLE_CANDIDATE!>println<!>(1)
out.println(<!TOO_MANY_ARGUMENTS!>1<!>)
}
else {
out.println(2)
@@ -66,11 +66,11 @@ fun test() {
if (1 == 2 || out != null && out.println(1) == Unit) {
out?.println(2);
out.<!INAPPLICABLE_CANDIDATE!>println<!>(2);
out.println(<!TOO_MANY_ARGUMENTS!>2<!>);
}
else {
out?.println(3)
out.<!INAPPLICABLE_CANDIDATE!>println<!>(3)
out.println(<!TOO_MANY_ARGUMENTS!>3<!>)
}
out?.println()
@@ -103,7 +103,7 @@ fun test() {
if (out == null || out.println(0) == Unit) {
out?.println(1)
out.<!INAPPLICABLE_CANDIDATE!>println<!>(1)
out.println(<!TOO_MANY_ARGUMENTS!>1<!>)
}
else {
out.println(2)
@@ -127,11 +127,11 @@ fun test() {
if (1 == 2 || out != null && out.println(1) == Unit) {
out?.println(2);
out.<!INAPPLICABLE_CANDIDATE!>println<!>(2);
out.println(<!TOO_MANY_ARGUMENTS!>2<!>);
}
else {
out?.println(3)
out.<!INAPPLICABLE_CANDIDATE!>println<!>(3)
out.println(<!TOO_MANY_ARGUMENTS!>3<!>)
}
if (1 > 2) {
compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.fir.kt
Vendored
+1 -1
View File
@@ -3,4 +3,4 @@ import java.util.ArrayList
<!NOT_AN_ANNOTATION_CLASS!>@ArrayList<Int>(1, 1)<!> fun b() {}
@<!UNRESOLVED_REFERENCE!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>) fun c() {}
<!INAPPLICABLE_CANDIDATE!>@java.lang.Deprecated(<!UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}
@java.lang.Deprecated(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>x<!>) fun a() {}
compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.fir.kt
Vendored
+3 -3
View File
@@ -1,10 +1,10 @@
annotation class A1
annotation class A2(val some: Int = 12)
class TopLevelClass<@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
class InnerClass<@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
class TopLevelClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
class InnerClass<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
fun test() {
class InFun<@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T>
class InFun<@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T>
}
}
}
compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.fir.kt
Vendored
+3 -3
View File
@@ -1,12 +1,12 @@
annotation class A1
annotation class A2(val some: Int = 12)
fun <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> topFun() = 12
fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> topFun() = 12
class SomeClass {
fun <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> method() = 12
fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> method() = 12
fun foo() {
fun <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> innerFun() = 12
fun <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> innerFun() = 12
}
}
compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.fir.kt
Vendored
+2 -2
View File
@@ -3,10 +3,10 @@
annotation class A1
annotation class A2(val some: Int = 12)
val <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> T.topProp: Int get() = 12
val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> T.topProp: Int get() = 12
class SomeClass {
val <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> T.field: Int get() = 12
val <@A1 @A2(3) @A2 @A1(<!TOO_MANY_ARGUMENTS!>12<!>) <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> T.field: Int get() = 12
fun foo() {
val <@A1 @A2(3) @A2 @A1(12) @A2("Test") T> localVal = 12
compiler/testData/diagnostics/tests/annotations/BasicAnnotations.fir.kt
Vendored
+1 -1
View File
@@ -3,7 +3,7 @@ annotation class my1(val i : Int)
annotation class my2(val i : Int = 0)
@my fun foo() {}
<!INAPPLICABLE_CANDIDATE!>@my1<!> fun foo2() {}
<!NO_VALUE_FOR_PARAMETER!>@my1<!> fun foo2() {}
@my1(2) fun foo3() {}
@my2() fun foo4() {}
@my2 fun foo41() {}
compiler/testData/diagnostics/tests/annotations/ConstructorCall.fir.kt
Vendored
+1 -1
View File
@@ -16,7 +16,7 @@ fun foo() {
Ann()
val a = Ann()
<!INAPPLICABLE_CANDIDATE!>Ann1<!>()
Ann1(<!NO_VALUE_FOR_PARAMETER!>)<!>
Ann1(1)
bar(Ann())
bar(a = Ann())
compiler/testData/diagnostics/tests/annotations/rendering/tooManyArguments.fir.kt
Vendored
+3 -3
View File
@@ -6,6 +6,6 @@ annotation class Ann(val s: String = "")
@Ann("s")
fun foo() {}
val bar = <!INAPPLICABLE_CANDIDATE!>foo<!>(
15
)
val bar = foo(
<!TOO_MANY_ARGUMENTS!>15<!>
)
compiler/testData/diagnostics/tests/callableReference/property/memberFromTopLevel.fir.kt
Vendored
+1 -1
View File
@@ -13,7 +13,7 @@ fun test() {
checkSubtype<KProperty1<A, Int>>(p)
<!INAPPLICABLE_CANDIDATE!>checkSubtype<!><KMutableProperty1<A, Int>>(p)
checkSubtype<Int>(p.get(A()))
p.<!INAPPLICABLE_CANDIDATE!>get<!>()
p.get(<!NO_VALUE_FOR_PARAMETER!>)<!>
p.<!UNRESOLVED_REFERENCE!>set<!>(A(), 239)
val q = A::bar
compiler/testData/diagnostics/tests/checkArguments/SpreadVarargs.fir.kt
Vendored
+4 -4
View File
@@ -10,7 +10,7 @@ fun main() {
join(1)
join(1, "2")
join(1, "2", "3")
<!INAPPLICABLE_CANDIDATE!>join<!>(*1, "2")
join(<!NON_VARARG_SPREAD!>*<!>1, "2")
<!INAPPLICABLE_CANDIDATE!>join<!>(1, *"2")
join(x = 1, a = "2")
join(x = *1, a = *"2")
@@ -30,7 +30,7 @@ fun main() {
join(a = a, x = 1)
joinG<String>(1, "2")
<!INAPPLICABLE_CANDIDATE!>joinG<!><String>(*1, "2")
joinG<String>(<!NON_VARARG_SPREAD!>*<!>1, "2")
<!INAPPLICABLE_CANDIDATE!>joinG<!><String>(1, *"2")
joinG<String>(x = 1, a = a)
joinG<String>(x = 1, a = "2")
@@ -43,7 +43,7 @@ fun main() {
joinG<String>(a = a, x = 1)
joinG(1, "2")
<!INAPPLICABLE_CANDIDATE!>joinG<!>(*1, "2")
joinG(<!NON_VARARG_SPREAD!>*<!>1, "2")
<!INAPPLICABLE_CANDIDATE!>joinG<!>(1, *"2")
joinG(x = 1, a = a)
joinG(x = 1, a = "2")
@@ -57,7 +57,7 @@ fun main() {
val x1 = joinT(1, "2")
checkSubtype<String?>(x1)
val x2 = <!INAPPLICABLE_CANDIDATE!>joinT<!>(*1, "2")
val x2 = joinT(<!NON_VARARG_SPREAD!>*<!>1, "2")
checkSubtype<String?>(x2)
val x6 = joinT(1, *a)
checkSubtype<String?>(x6)
compiler/testData/diagnostics/tests/checkArguments/arrayAccessSet.fir.kt
Vendored
+1 -1
View File
@@ -31,5 +31,5 @@ fun test() {
D[0] = ""
D[0] = 2.72
<!INAPPLICABLE_CANDIDATE!>Z[0]<!> = ""
Z[<!TOO_MANY_ARGUMENTS!>0<!>] = <!TOO_MANY_ARGUMENTS!>""<!>
}
compiler/testData/diagnostics/tests/checkArguments/arrayAccessSetTooManyArgs.fir.kt
Vendored
+1 -1
View File
@@ -6,6 +6,6 @@ class A {
operator fun set(x: String, value: Int) {}
fun d(x: Int) {
<!INAPPLICABLE_CANDIDATE!>this["", 1]<!> = 1
this["", 1] = <!TOO_MANY_ARGUMENTS!>1<!>
}
}
compiler/testData/diagnostics/tests/checkArguments/kt1897_diagnostic_part.fir.kt
Vendored
+7 -7
View File
@@ -9,21 +9,21 @@ fun foo(i: Int, s: String) {}
fun test() {
<!INAPPLICABLE_CANDIDATE!>bar<!>(<!UNRESOLVED_REFERENCE!>xx<!>)
bar(<!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)
<!INAPPLICABLE_CANDIDATE!>bar<!> { }
bar <!TOO_MANY_ARGUMENTS!>{ }<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>("", 1, <!UNRESOLVED_REFERENCE!>xx<!>)
foo("", 1, <!TOO_MANY_ARGUMENTS, UNRESOLVED_REFERENCE!>xx<!>)
<!INAPPLICABLE_CANDIDATE!>foo<!>(r = <!UNRESOLVED_REFERENCE!>xx<!>, i = "", s = "")
<!INAPPLICABLE_CANDIDATE!>foo<!>(i = 1, i = 1, s = 11)
foo(i = 1, <!ARGUMENT_PASSED_TWICE!>i<!> = 1, s = 11)
<!INAPPLICABLE_CANDIDATE!>foo<!>("", s = 2)
<!INAPPLICABLE_CANDIDATE!>foo<!>(i = "", s = 2, 33)
foo(i = "", s = 2, <!TOO_MANY_ARGUMENTS!>33<!>)
<!INAPPLICABLE_CANDIDATE!>foo<!>("", 1) {}
foo("", 1) <!TOO_MANY_ARGUMENTS!>{}<!>
<!INAPPLICABLE_CANDIDATE!>foo<!>("", 1) {} {}
foo("", 1) <!TOO_MANY_ARGUMENTS!>{}<!> <!TOO_MANY_ARGUMENTS!>{}<!>
}
compiler/testData/diagnostics/tests/checkArguments/kt1940.fir.kt
Vendored
-9
View File
@@ -1,9 +0,0 @@
//KT-1940 Exception while repeating named parameters
package kt1940
fun foo(i: Int) {}
fun test() {
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, i = 2) //exception
<!INAPPLICABLE_CANDIDATE!>foo<!>(i = 1, i = 2) //exception
}
compiler/testData/diagnostics/tests/checkArguments/kt1940.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
//KT-1940 Exception while repeating named parameters
package kt1940
compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.fir.kt
Vendored
+1 -1
View File
@@ -34,7 +34,7 @@ fun test6() {}
annotation class AnnArray(val a: Array<String>)
<!INAPPLICABLE_CANDIDATE!>@AnnArray(*["/"])<!>
@AnnArray(<!NON_VARARG_SPREAD!>*<!>["/"])
fun testArray() {}
@Ann1([""])
compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.fir.kt
Vendored
-5
View File
@@ -1,5 +0,0 @@
fun foo(a: Int, b: Int) = a + b
fun bar(i: Int) {
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, 1, i)
}
compiler/testData/diagnostics/tests/controlFlowAnalysis/unmappedArgs.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
fun foo(a: Int, b: Int) = a + b
fun bar(i: Int) {
compiler/testData/diagnostics/tests/controlStructures/kt799.fir.kt
Vendored
+1 -1
View File
@@ -9,7 +9,7 @@ fun test() {
doSmth(if (true) 3 else return)
<!INAPPLICABLE_CANDIDATE!>doSmth<!>(if (true) 3 else return, 1)
doSmth(if (true) 3 else return, <!TOO_MANY_ARGUMENTS!>1<!>)
}
val a : Nothing = return 1
compiler/testData/diagnostics/tests/declarationChecks/kt1193.fir.kt
Vendored
+2 -2
View File
@@ -5,9 +5,9 @@ package kt1193
enum class MyEnum(val i: Int) {
A(12),
<!INAPPLICABLE_CANDIDATE!>B<!> //no error
<!NO_VALUE_FOR_PARAMETER!>B<!> //no error
}
open class A(x: Int = 1)
val x: MyEnum = MyEnum.A
val x: MyEnum = MyEnum.A
compiler/testData/diagnostics/tests/delegatedProperty/kt4640.fir.kt
Vendored
+1 -1
View File
@@ -8,4 +8,4 @@ class ValueWrapper()
fun setValue(v: Int) { backingValue = v }
}
val foo by <!INAPPLICABLE_CANDIDATE!>ValueWrapper<!>()
val foo by <!TOO_MANY_ARGUMENTS, TOO_MANY_ARGUMENTS!>ValueWrapper()<!>
compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInGet.fir.kt
Vendored
+2 -2
View File
@@ -3,10 +3,10 @@
import kotlin.reflect.KProperty
class A {
val a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
val a: Int by Delegate(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
val aTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
val aTopLevel: Int by Delegate(<!NO_VALUE_FOR_PARAMETER!>)<!>
class Delegate {
fun getValue(t: Any?, p: KProperty<*>, a: Int): Int {
compiler/testData/diagnostics/tests/deprecated/javaDeprecated.fir.kt
Vendored
+1 -1
View File
@@ -11,6 +11,6 @@ public class A {
// FILE: B.kt
class B(private <!INAPPLICABLE_CANDIDATE, INAPPLICABLE_CANDIDATE!>@property:Deprecated<!> val foo: String) : A() {
class B(private @property:Deprecated val foo: String) : A() {
override fun getFoo(text: String): String = super.getFoo(text + foo)
}
compiler/testData/diagnostics/tests/enum/constructorWithDefaultParametersOnly.fir.kt
Vendored
+2 -2
View File
@@ -5,8 +5,8 @@ enum class TestOk(val x: String = "OK") {
}
enum class TestErrors(val x: String) {
<!INAPPLICABLE_CANDIDATE!>TEST1,<!>
TEST2<!INAPPLICABLE_CANDIDATE!><!>(),
<!NO_VALUE_FOR_PARAMETER!>TEST1,<!>
TEST2<!NO_VALUE_FOR_PARAMETER!><!>(),
TEST3("Hello")
}
compiler/testData/diagnostics/tests/extensions/ExtensionFunctions.fir.kt
Vendored
+1 -1
View File
@@ -20,7 +20,7 @@ class A
infix operator fun A.plus(a : Any) {
1.foo()
true.<!INAPPLICABLE_CANDIDATE!>foo<!>()
true.foo(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
1
}
compiler/testData/diagnostics/tests/extensions/ExtensionsCalledOnSuper.fir.kt
Vendored
+2 -2
View File
@@ -16,7 +16,7 @@ class C : T {
super.foo() // OK
super.<!UNRESOLVED_REFERENCE!>bar<!>() // Error
super.buzz() // OK, resolved to a member
super.<!INAPPLICABLE_CANDIDATE!>buzz1<!>() // Resolved to an extension
super.buzz1(<!NO_VALUE_FOR_PARAMETER!>)<!> // Resolved to an extension
super.<!INAPPLICABLE_CANDIDATE!>buzz1<!>("") // Resolved to a member
}
}
}
compiler/testData/diagnostics/tests/extensions/throwOutCandidatesByReceiver.fir.kt
Vendored
+2 -2
View File
@@ -20,8 +20,8 @@ fun Int.foo() {}
fun test3(s: String?) {
"".<!INAPPLICABLE_CANDIDATE!>foo<!>()
s<!UNSAFE_CALL!>.<!>foo()
"".<!INAPPLICABLE_CANDIDATE!>foo<!>(1)
s.<!INAPPLICABLE_CANDIDATE!>foo<!>("a")
"".foo(<!TOO_MANY_ARGUMENTS!>1<!>)
s.foo(<!TOO_MANY_ARGUMENTS!>"a"<!>)
}
interface A
compiler/testData/diagnostics/tests/extensions/variableInvoke.fir.kt
Vendored
+2 -2
View File
@@ -6,6 +6,6 @@ class A(foo: Int.() -> Unit) {
fun test(foo: Int.(String) -> Unit) {
4.foo("")
4.<!INAPPLICABLE_CANDIDATE!>foo<!>(p1 = "")
4.foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>p2 = ""<!>)
4.foo(p1 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
4.foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>p2<!> = "")
}
compiler/testData/diagnostics/tests/functionLiterals/higherOrderCallMissingParameters.fir.kt
Vendored
+6 -6
View File
@@ -2,15 +2,15 @@
fun foo(p: (Int, () -> Int) -> Unit) {
// Errors except last call
<!INAPPLICABLE_CANDIDATE!>p<!> { 1 }
<!INAPPLICABLE_CANDIDATE!>p<!>() { 2 }
<!NO_VALUE_FOR_PARAMETER!>p { 1 }<!>
p(<!NO_VALUE_FOR_PARAMETER!>)<!> { 2 }
p(3) { 4 }
}
fun bar(p: (String, Any, () -> String) -> Unit) {
// Errors except last call
<!INAPPLICABLE_CANDIDATE!>p<!> { "" }
<!INAPPLICABLE_CANDIDATE!>p<!>() { "x" }
<!INAPPLICABLE_CANDIDATE!>p<!>("y") { "z" }
<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>p { "" }<!>
p(<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!> { "x" }
p("y"<!NO_VALUE_FOR_PARAMETER!>)<!> { "z" }
p("v", Any()) { "w" }
}
}
compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.fir.kt
Vendored
+1 -1
View File
@@ -7,4 +7,4 @@ object Z {
infix fun add(b : Foo.() -> Unit) : Z = Z
}
val t2 = Z <!INAPPLICABLE_CANDIDATE!>add<!> <!INAPPLICABLE_CANDIDATE!>{ }<!> { }
val t2 = Z <!INAPPLICABLE_CANDIDATE!>add<!> { } <!TOO_MANY_ARGUMENTS!>{ }<!>
compiler/testData/diagnostics/tests/generics/Projections.fir.kt
Vendored
+1 -1
View File
@@ -50,5 +50,5 @@ fun testInOut() {
(null as Inv<out Int>).outf()
(null as Inv<*>).outf()
Inv<Int>().<!INAPPLICABLE_CANDIDATE!>outf<!>(1) // Wrong Arg
Inv<Int>().outf(<!TOO_MANY_ARGUMENTS!>1<!>) // Wrong Arg
}
compiler/testData/diagnostics/tests/imports/ImportOverloadFunctions.fir.kt
Vendored
+2 -2
View File
@@ -32,8 +32,8 @@ fun test() {
<!NONE_APPLICABLE!>zero<!>("")
one()
<!INAPPLICABLE_CANDIDATE!>one<!>(1)
<!INAPPLICABLE_CANDIDATE!>one<!>("")
one(<!TOO_MANY_ARGUMENTS!>1<!>)
one(<!TOO_MANY_ARGUMENTS!>""<!>)
two()
two(1)
compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/noTypeParamsInReturnType.fir.kt
Vendored
+1 -1
View File
@@ -6,5 +6,5 @@ fun <T, R> foo(map: Map<T, R>) : R = throw Exception()
fun <F, G> getMap() : Map<F, G> = throw Exception()
fun bar123() {
foo(<!INAPPLICABLE_CANDIDATE!>getMap<!>(
foo(<!TOO_MANY_ARGUMENTS!>getMap<!>(
<!SYNTAX!><!>}
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferences.fir.kt
Vendored
+9 -9
View File
@@ -39,7 +39,7 @@ fun <R> select(vararg x: R) = x[0]
fun poll0(): Flow<String> {
return flow {
val inv = select(::bar, ::foo)
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
@@ -123,7 +123,7 @@ fun poll14(flag: Boolean): Flow<String> {
fun poll15(flag: Boolean): Flow<String> {
return flow {
val inv = if (flag) { ::bar5 } else { ::foo5 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
@@ -144,7 +144,7 @@ fun poll17(flag: Boolean): Flow<String> {
fun poll2(flag: Boolean): Flow<String> {
return flow {
val inv = when (flag) { true -> ::bar else -> ::foo }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
@@ -193,7 +193,7 @@ fun poll26(flag: Boolean): Flow<String> {
fun poll3(flag: Boolean): Flow<String> {
return flow {
val inv = when (flag) { true -> ::bar false -> ::foo }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
@@ -242,7 +242,7 @@ fun poll36(flag: Boolean): Flow<String> {
fun poll4(): Flow<String> {
return flow {
val inv = try { ::bar } finally { ::foo }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
@@ -270,7 +270,7 @@ fun poll43(): Flow<String> {
fun poll44(): Flow<String> {
return flow {
val inv = try { ::bar5 } finally { ::foo5 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
@@ -291,7 +291,7 @@ fun poll46(): Flow<String> {
fun poll5(): Flow<String> {
return flow {
val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::foo }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
@@ -319,7 +319,7 @@ fun poll53(): Flow<String> {
fun poll54(): Flow<String> {
return flow {
val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::foo5 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
@@ -389,7 +389,7 @@ fun poll66(): Flow<String> {
fun poll7(): Flow<String> {
return flow {
val inv = ::bar!!
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesDontCareTypeInBlockExression.fir.kt
Vendored
+5 -5
View File
@@ -72,7 +72,7 @@ fun poll14(flag: Boolean): Flow<String> {
fun poll15(flag: Boolean): Flow<String> {
return flow {
val inv = if (flag) { ::bar5 } else { ::foo5 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
@@ -93,7 +93,7 @@ fun poll17(flag: Boolean): Flow<String> {
fun poll4(): Flow<String> {
return flow {
val inv = try { ::bar } finally { ::foo }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
@@ -121,7 +121,7 @@ fun poll43(): Flow<String> {
fun poll44(): Flow<String> {
return flow {
val inv = try { ::bar5 } finally { ::foo5 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
@@ -142,7 +142,7 @@ fun poll46(): Flow<String> {
fun poll5(): Flow<String> {
return flow {
val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::foo }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
@@ -170,7 +170,7 @@ fun poll53(): Flow<String> {
fun poll54(): Flow<String> {
return flow {
val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::foo5 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
compiler/testData/diagnostics/tests/inference/builderInference/specialCallsWithCallableReferencesErrorType.fir.kt
Vendored
+1 -1
View File
@@ -38,7 +38,7 @@ class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
fun poll7(): Flow<String> {
return flow {
val inv = ::bar!!
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}
compiler/testData/diagnostics/tests/inference/completion/postponedArgumentsAnalysis/basic.fir.kt
Vendored
+3 -3
View File
@@ -119,8 +119,8 @@ fun main() {
* K <: (A) -> Unit -> TypeVariable(_RP1) >: A
* K >: (C) -> TypeVariable(_R) -> TypeVariable(_RP1) <: C
*/
val x12 = <!INAPPLICABLE_CANDIDATE!>selectC<!>(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, id { x: B -> })
val x13 = <!INAPPLICABLE_CANDIDATE!>selectA<!>(id { <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> }, id { x: C -> })
val x12 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, id { x: B -> }<!NO_VALUE_FOR_PARAMETER!>)<!>
val x13 = selectA(id { <!DEBUG_INFO_EXPRESSION_TYPE("A")!>it<!> }, id { x: C -> }<!NO_VALUE_FOR_PARAMETER!>)<!>
val x14 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, id { x: A -> }, { x -> x })
val x15 = selectC(id { <!DEBUG_INFO_EXPRESSION_TYPE("C")!>it<!> }, { x: A -> }, id { x -> x })
/*
@@ -152,7 +152,7 @@ fun main() {
select(id(fun String.(x: String) {}), id(fun(x: String, y: String) { }), { x: String, y: String -> x })
// Convert to extension lambda is impossible because the lambda parameter types aren't specified explicitly
select(id(fun String.(x: String) {}), id(fun(x: String, y: String) { }), { x, y -> x })
select(<!INAPPLICABLE_CANDIDATE!>id<!>(id(fun(x: String, y: String) { }), fun String.(x: String) {}), { x, y -> x })
select(id(id(fun(x: String, y: String) { }), <!TOO_MANY_ARGUMENTS!>fun String.(x: String) {}<!>), { x, y -> x })
val x26: Int.(String) -> Int = fun (x: String) = 10 // it must be error, see KT-38439
// Receiver must be specified in anonymous function declaration
val x27: Int.(String) -> Int = id(fun (x: String) = 10)
compiler/testData/diagnostics/tests/inference/invokeLambdaAsFunction.fir.kt
Vendored
+2 -2
View File
@@ -2,6 +2,6 @@ fun test1(i: Int) = { i ->
i
}(i)
fun test2() = <!INAPPLICABLE_CANDIDATE!>{ i -> i }<!>()
fun test2() = { i -> i }(<!NO_VALUE_FOR_PARAMETER!>)<!>
fun test3() = { i -> i }(1)
fun test3() = { i -> i }(1)
compiler/testData/diagnostics/tests/inference/regressions/kt2057.fir.kt
Vendored
+2 -2
View File
@@ -8,5 +8,5 @@ fun <T> foo(a : T, b : Collection<T>, c : Int) {
fun <T> arrayListOf(vararg values: T): ArrayList<T> = throw Exception("$values")
val bar = <!INAPPLICABLE_CANDIDATE!>foo<!>("", arrayListOf(), )
val bar2 = <!INAPPLICABLE_CANDIDATE!>foo<!><String>("", arrayListOf(), )
val bar = foo("", arrayListOf(), <!NO_VALUE_FOR_PARAMETER!>)<!>
val bar2 = foo<String>("", arrayListOf(), <!NO_VALUE_FOR_PARAMETER!>)<!>
compiler/testData/diagnostics/tests/inference/specialCallsWithCallableReferences.fir.kt
Vendored
+22 -22
View File
@@ -30,22 +30,22 @@ fun poll11(flag: Boolean) {
fun poll12(flag: Boolean) {
val inv = if (flag) { ::bar3 } else { ::foo3 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll13(flag: Boolean) {
val inv = if (flag) { ::bar2 } else { ::foo3 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll14(flag: Boolean) {
val inv = if (flag) { ::bar4 } else { ::foo4 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll15(flag: Boolean) {
val inv = if (flag) { ::bar5 } else { ::foo5 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll16(flag: Boolean) {
@@ -60,7 +60,7 @@ fun poll17(flag: Boolean) {
fun poll2(flag: Boolean) {
val inv = when (flag) { true -> ::bar else -> ::foo }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll21(flag: Boolean) {
@@ -70,12 +70,12 @@ fun poll21(flag: Boolean) {
fun poll22(flag: Boolean) {
val inv = when (flag) { true -> ::bar3 else -> ::foo3 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll23(flag: Boolean) {
val inv = when (flag) { true -> ::bar4 else -> ::foo4 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll24(flag: Boolean) {
@@ -95,7 +95,7 @@ fun poll26(flag: Boolean) {
fun poll3(flag: Boolean) {
val inv = when (flag) { true -> ::bar false -> ::foo }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll31(flag: Boolean) {
@@ -105,12 +105,12 @@ fun poll31(flag: Boolean) {
fun poll32(flag: Boolean) {
val inv = when (flag) { true -> ::bar3 false -> ::foo3 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll33(flag: Boolean) {
val inv = when (flag) { true -> ::bar4 false -> ::foo4 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll34(flag: Boolean) {
@@ -130,7 +130,7 @@ fun poll36(flag: Boolean) {
fun poll4() {
val inv = try { ::bar } finally { ::<!UNRESOLVED_REFERENCE!>foo<!> }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll41() {
@@ -140,17 +140,17 @@ fun poll41() {
fun poll42() {
val inv = try { ::bar3 } finally { ::<!UNRESOLVED_REFERENCE!>foo3<!> }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll43() {
val inv = try { ::bar4 } finally { ::foo4 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll44() {
val inv = try { ::bar5 } finally { ::<!UNRESOLVED_REFERENCE!>foo5<!> }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll45() {
@@ -165,7 +165,7 @@ fun poll46() {
fun poll5() {
val inv = try { ::bar } catch (e: Exception) { ::foo } finally { ::<!UNRESOLVED_REFERENCE!>foo<!> }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll51() {
@@ -175,17 +175,17 @@ fun poll51() {
fun poll52() {
val inv = try { ::bar3 } catch (e: Exception) { ::foo3 } finally { ::<!UNRESOLVED_REFERENCE!>foo3<!> }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll53() {
val inv = try { ::bar4 } catch (e: Exception) { ::foo4 } finally { ::foo4 }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll54() {
val inv = try { ::bar5 } catch (e: Exception) { ::foo5 } finally { ::<!UNRESOLVED_REFERENCE!>foo5<!> }
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll55() {
@@ -235,7 +235,7 @@ fun poll66() {
fun poll7() {
val inv = ::bar!!
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll71() {
@@ -245,7 +245,7 @@ fun poll71() {
fun poll72() {
val inv = ::bar3!!
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll73() {
@@ -270,7 +270,7 @@ fun poll76() {
fun poll8() {
val inv = ::<!UNRESOLVED_REFERENCE!>bar<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(::<!UNRESOLVED_REFERENCE!>foo<!>)
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll81() {
@@ -280,7 +280,7 @@ fun poll81() {
fun poll82() {
val inv = ::<!UNRESOLVED_REFERENCE!>bar3<!> <!NONE_APPLICABLE!>in<!> <!NONE_APPLICABLE!>setOf<!>(::<!UNRESOLVED_REFERENCE!>foo3<!>)
<!INAPPLICABLE_CANDIDATE!>inv<!>()
inv(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun poll83() {
compiler/testData/diagnostics/tests/inner/innerConstructorsFromQualifiersWithIrrelevantCandidate.fir.kt
Vendored
+1 -1
View File
@@ -20,7 +20,7 @@ class Outer {
}
fun foo() {
Outer.<!INAPPLICABLE_CANDIDATE!>Inner<!>()
Outer.Inner(<!NO_VALUE_FOR_PARAMETER!>)<!>
Outer.<!INAPPLICABLE_CANDIDATE!>Inner<!>(1)
Outer.Inner("")
}
compiler/testData/diagnostics/tests/inner/kt5854.fir.kt
Vendored
-11
View File
@@ -1,11 +0,0 @@
//KT-5854 Incorrect 'Nested class should be qualified'
class A {
class Nested {
}
fun foo() {
<!INAPPLICABLE_CANDIDATE!>Nested<!>(1) //two errors here, the first one is wrong
}
}
compiler/testData/diagnostics/tests/inner/kt5854.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
//KT-5854 Incorrect 'Nested class should be qualified'
class A {
compiler/testData/diagnostics/tests/inner/kt6026.fir.kt
Vendored
+1 -1
View File
@@ -4,5 +4,5 @@ val oo = object {
// Forbidden in KT-13510
class Nested
fun f1() = <!INAPPLICABLE_CANDIDATE!>Nested<!>(11)
fun f1() = Nested(<!TOO_MANY_ARGUMENTS!>11<!>)
}
compiler/testData/diagnostics/tests/j+k/genericConstructor/recursive.fir.kt
Vendored
+1 -1
View File
@@ -9,4 +9,4 @@ public class C {
// FILE: main.kt
fun foo() = <!INAPPLICABLE_CANDIDATE!>C<!>()
fun foo() = C(<!NO_VALUE_FOR_PARAMETER!>)<!>
compiler/testData/diagnostics/tests/kt435.fir.kt
Vendored
+1 -1
View File
@@ -3,5 +3,5 @@ fun Any.foo1() : (i : Int) -> Unit {
}
fun test(a : Any) {
<!INAPPLICABLE_CANDIDATE!>a.foo1()<!>()
a.foo1(<!NO_VALUE_FOR_PARAMETER!>)<!>()
}
compiler/testData/diagnostics/tests/multiplatform/namedArguments.fir.kt
Vendored
+4 -4
View File
@@ -12,10 +12,10 @@ expect class Foo(zzz: Int) {
expect fun f2(xxx: Int)
fun testCommon() {
Foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>zzz = 0<!>)
val f = Foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>aaa = true<!>)
f.f1(<!NAMED_ARGUMENTS_NOT_ALLOWED!>xxx = ""<!>)
f2(<!NAMED_ARGUMENTS_NOT_ALLOWED!>xxx = 42<!>)
Foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>zzz<!> = 0)
val f = Foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>aaa<!> = true)
f.f1(<!NAMED_ARGUMENTS_NOT_ALLOWED!>xxx<!> = "")
f2(<!NAMED_ARGUMENTS_NOT_ALLOWED!>xxx<!> = 42)
}
// MODULE: m2-jvm(m1-common)
compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments1.fir.kt
Vendored
+5 -5
View File
@@ -11,8 +11,8 @@ interface D : B, A
fun foo(x : C, y : D){
x.foo(x = 0)
x.<!INAPPLICABLE_CANDIDATE!>foo<!>(y = 0)
y.<!INAPPLICABLE_CANDIDATE!>foo<!>(x = 0)
x.foo(y = 0<!NO_VALUE_FOR_PARAMETER!>)<!>
y.foo(x = 0<!NO_VALUE_FOR_PARAMETER!>)<!>
y.foo(y = 0)
}
@@ -21,7 +21,7 @@ abstract class D1 : A, B
fun bar(x : C1, y : D1){
x.foo(x = 0)
x.<!INAPPLICABLE_CANDIDATE!>foo<!>(y = 0)
x.foo(y = 0<!NO_VALUE_FOR_PARAMETER!>)<!>
y.foo(x = 0)
y.<!INAPPLICABLE_CANDIDATE!>foo<!>(y = 0)
}
y.foo(y = 0<!NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArguments2.fir.kt
Vendored
+6 -6
View File
@@ -14,11 +14,11 @@ interface C : A, B { // Warning here, this is correct
}
fun test(c: C) {
c.<!INAPPLICABLE_CANDIDATE!>foo<!>(b1 = 1, b2 = 1.0)
c.<!INAPPLICABLE_CANDIDATE!>foo<!>(a1 = 1, b2 = 1.0)
c.foo(b1 = 1, b2 = 1.0<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
c.foo(a1 = 1, b2 = 1.0<!NO_VALUE_FOR_PARAMETER!>)<!>
c.foo(a1 = 1, a2 = 1.0)
c.foo(a1 = 1, a2 = 1.0)
c.<!INAPPLICABLE_CANDIDATE!>bar<!>(a1 = 1, a2 = 1.0, b3= "")
c.<!INAPPLICABLE_CANDIDATE!>baz<!>(a1 = 1, b2 = 1.0, a3 = "", b4 = 2, a5 = "")
c.<!INAPPLICABLE_CANDIDATE!>baz<!>(a1 = 1, a2 = 1.0, a3 = "", b4 = 2, a5 = "")
}
c.bar(a1 = 1, a2 = 1.0, b3= ""<!NO_VALUE_FOR_PARAMETER!>)<!>
c.baz(a1 = 1, b2 = 1.0, a3 = "", b4 = 2, a5 = ""<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
c.baz(a1 = 1, a2 = 1.0, a3 = "", b4 = 2, a5 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics1.fir.kt
Vendored
+2 -2
View File
@@ -11,5 +11,5 @@ interface C : A<Int>, B { // Warning here, this is correct
fun test(c: C) {
c.foo(a = 1)
c.<!INAPPLICABLE_CANDIDATE!>foo<!>(b = 1)
}
c.foo(b = 1<!NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics2.fir.kt
Vendored
+2 -2
View File
@@ -11,5 +11,5 @@ interface C : A, B { // Warning here, this is correct
fun test(c: C) {
c.foo(a = 1)
c.<!INAPPLICABLE_CANDIDATE!>foo<!>(b = 1)
}
c.foo(b = 1<!NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/testData/diagnostics/tests/namedArguments/ambiguousNamedArgumentsWithGenerics3.fir.kt
Vendored
+2 -2
View File
@@ -11,5 +11,5 @@ interface C<U> : A<U>, B<U> { // Warning here, this is correct
fun test(c: C<Int>) {
c.foo(a = 1)
c.<!INAPPLICABLE_CANDIDATE!>foo<!>(b = 1)
}
c.foo(b = 1<!NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.fir.kt
Vendored
-9
View File
@@ -1,9 +0,0 @@
// FILE: A.java
public class A {
public A(int x, String y) {}
}
// FILE: 1.kt
val test = A(<!NAMED_ARGUMENTS_NOT_ALLOWED!>x = 1<!>, <!NAMED_ARGUMENTS_NOT_ALLOWED!>y = "2"<!>)
compiler/testData/diagnostics/tests/namedArguments/disallowForJavaConstructor.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// FILE: A.java
public class A {
compiler/testData/diagnostics/tests/namedArguments/disallowForJavaMethods.fir.kt
Vendored
+4 -4
View File
@@ -8,11 +8,11 @@ public class JavaSuperClass {
// FILE: 1.kt
fun directInvocation() = JavaSuperClass().foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>javaName = 1<!>)
fun directInvocation() = JavaSuperClass().foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>javaName<!> = 1)
open class KotlinSubClass : JavaSuperClass()
fun viaFakeOverride() = KotlinSubClass().foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>javaName = 2<!>)
fun viaFakeOverride() = KotlinSubClass().foo(<!NAMED_ARGUMENTS_NOT_ALLOWED!>javaName<!> = 2)
class KotlinSubSubClass : KotlinSubClass() {
override fun foo(kotlinName: Int) {}
@@ -21,7 +21,7 @@ class KotlinSubSubClass : KotlinSubClass() {
fun viaRealOverride() = KotlinSubSubClass().foo(kotlinName = 3)
fun unresolvedParameter() = JavaSuperClass().<!INAPPLICABLE_CANDIDATE!>foo<!>(nonexistentName = 4)
fun unresolvedParameter() = JavaSuperClass(<!NO_VALUE_FOR_PARAMETER!>)<!>.foo(nonexistentName = 4)
fun multipleParameters() = JavaSuperClass().multipleParameters(<!NAMED_ARGUMENTS_NOT_ALLOWED!>first = 1<!>, <!NAMED_ARGUMENTS_NOT_ALLOWED!>second = 2L<!>, <!NAMED_ARGUMENTS_NOT_ALLOWED!>third = "3"<!>)
fun multipleParameters() = JavaSuperClass().multipleParameters(<!NAMED_ARGUMENTS_NOT_ALLOWED!>first<!> = 1, <!NAMED_ARGUMENTS_NOT_ALLOWED!>second<!> = 2L, <!NAMED_ARGUMENTS_NOT_ALLOWED!>third<!> = "3")
compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.fir.kt
Vendored
-17
View File
@@ -1,17 +0,0 @@
// !WITH_NEW_INFERENCE
// FILE: test/J.java
package test;
public class J {
public J(String s, Runnable r, Boolean z) {
}
}
// FILE: usage.kt
package test
fun test() {
J("", <!NAMED_ARGUMENTS_NOT_ALLOWED!>r = { }<!>, <!NAMED_ARGUMENTS_NOT_ALLOWED!>z = false<!>)
}
compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterConstructor.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !WITH_NEW_INFERENCE
// FILE: test/J.java
compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.fir.kt
Vendored
-17
View File
@@ -1,17 +0,0 @@
// !WITH_NEW_INFERENCE
// FILE: test/J.java
package test;
public class J {
public static void foo(String s, Runnable r, Boolean z) {
}
}
// FILE: usage.kt
package test
fun test() {
J.foo("", <!NAMED_ARGUMENTS_NOT_ALLOWED!>r = { }<!>, <!NAMED_ARGUMENTS_NOT_ALLOWED!>z = false<!>)
}
compiler/testData/diagnostics/tests/namedArguments/disallowForSamAdapterFunction.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
// !WITH_NEW_INFERENCE
// FILE: test/J.java
compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/disabledFeature.fir.kt
Vendored
+2 -2
View File
@@ -15,6 +15,6 @@ fun main() {
foo(p1 = 1, p2 = "2", 3.0)
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, "")
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, 3.0)
foo(1, p3 = 2.0, ""<!NO_VALUE_FOR_PARAMETER!>)<!>
foo(1, p3 = 2.0, 3.0<!NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/oldInference.fir.kt
Vendored
+2 -2
View File
@@ -15,6 +15,6 @@ fun main() {
foo(p1 = 1, p2 = "2", 3.0)
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, "")
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, 3.0)
foo(1, p3 = 2.0, ""<!NO_VALUE_FOR_PARAMETER!>)<!>
foo(1, p3 = 2.0, 3.0<!NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/simple.fir.kt
Vendored
+2 -2
View File
@@ -15,6 +15,6 @@ fun main() {
foo(p1 = 1, p2 = "2", 3.0)
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, "")
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, p3 = 2.0, 3.0)
foo(1, p3 = 2.0, ""<!NO_VALUE_FOR_PARAMETER!>)<!>
foo(1, p3 = 2.0, 3.0<!NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/testData/diagnostics/tests/namedArguments/mixedNamedPosition/varargs.fir.kt
Vendored
+7 -7
View File
@@ -28,10 +28,10 @@ fun foo4(
) {}
fun main() {
<!INAPPLICABLE_CANDIDATE!>foo1<!>(1, 2, p2 = "3", 4.0)
foo1(1, 2, p2 = "3", 4.0<!NO_VALUE_FOR_PARAMETER!>)<!>
foo1(p1 = intArrayOf(1, 2), "3", p3 = 4.0)
<!INAPPLICABLE_CANDIDATE!>foo1<!>(p2 = "3", 4.0)
foo1(p2 = "3", 4.0<!NO_VALUE_FOR_PARAMETER!>)<!>
foo2(p1 = 1, "2", "3", p3 = 4.0)
foo2(1, p2 = arrayOf("2", "3"), 4.0)
@@ -40,11 +40,11 @@ fun main() {
foo3(p1 = 1, "2", 3.0, 4.0)
foo3(p1 = 1, "2", p3 = doubleArrayOf(3.0, 4.0))
<!INAPPLICABLE_CANDIDATE!>foo4<!>(p1 = 1, "2", "3", p3 = 4.0, 5)
<!INAPPLICABLE_CANDIDATE!>foo4<!>(1, "2", "3", p3 = 4.0, 5)
<!INAPPLICABLE_CANDIDATE!>foo4<!>(1, p3 = 4.0, 5)
foo4(p1 = 1, "2", "3", p3 = 4.0, 5<!NO_VALUE_FOR_PARAMETER!>)<!>
foo4(1, "2", "3", p3 = 4.0, 5<!NO_VALUE_FOR_PARAMETER!>)<!>
foo4(1, p3 = 4.0, 5<!NO_VALUE_FOR_PARAMETER!>)<!>
<!INAPPLICABLE_CANDIDATE!>foo1<!>(1, 2, p3 = 3.0, "4")
foo1(1, 2, p3 = 3.0, "4"<!NO_VALUE_FOR_PARAMETER!>)<!>
foo1(1, 2, p3 = 3.0, p2 = "4")
foo1(*intArrayOf(1, 2), p3 = 3.0, p2 = "4")
@@ -52,6 +52,6 @@ fun main() {
<!INAPPLICABLE_CANDIDATE!>foo2<!>(1, p3 = 2.0, *arrayOf("3", "4"))
foo2(1, p3 = 2.0, p2 = arrayOf("3", "4"))
<!INAPPLICABLE_CANDIDATE!>foo3<!>(1, p3 = doubleArrayOf(2.0, 3.0), "4")
foo3(1, p3 = doubleArrayOf(2.0, 3.0), "4"<!NO_VALUE_FOR_PARAMETER!>)<!>
foo3(1, p3 = doubleArrayOf(2.0, 3.0), p2 = "4")
}
compiler/testData/diagnostics/tests/namedArguments/namedArgumentsAndDefaultValues.fir.kt
Vendored
+5 -5
View File
@@ -11,17 +11,17 @@ fun test() {
foo(b = "")
foo(1, "")
foo(a = 2)
<!INAPPLICABLE_CANDIDATE!>foo<!>(1, "", "")
foo(1, "", <!TOO_MANY_ARGUMENTS!>""<!>)
bar(z = "")
<!INAPPLICABLE_CANDIDATE!>bar<!>()
<!INAPPLICABLE_CANDIDATE!>bar<!>("")
bar(<!NO_VALUE_FOR_PARAMETER!>)<!>
bar(""<!NO_VALUE_FOR_PARAMETER!>)<!>
bar(1, 1, "")
bar(1, 1, "")
bar(1, z = "")
bar(1, z = "", y = 2)
<!INAPPLICABLE_CANDIDATE!>bar<!>(z = "", 1)
<!INAPPLICABLE_CANDIDATE!>bar<!>(1, zz = "",
bar(1, zz = "",
<!UNRESOLVED_REFERENCE!>zz<!>.foo
)
<!NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/testData/diagnostics/tests/namedArguments/namedArgumentsInOverrides.fir.kt
Vendored
+2 -2
View File
@@ -18,5 +18,5 @@ fun test1(d: D) {
}
fun test2(c: C) {
c.<!INAPPLICABLE_CANDIDATE!>foo<!>(b1 = 1, b2 = 1.0)
}
c.foo(b1 = 1, b2 = 1.0<!NO_VALUE_FOR_PARAMETER, NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/testData/diagnostics/tests/objects/Objects.fir.kt
Vendored
+4 -4
View File
@@ -4,15 +4,15 @@ package toplevelObjectDeclarations
open fun foo() : Int = 1
}
<!INAPPLICABLE_CANDIDATE!>class T : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {}<!>
<!NO_VALUE_FOR_PARAMETER!>class T : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {}<!>
<!INAPPLICABLE_CANDIDATE!>object A : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {
object A : <!SUPERTYPE_NOT_INITIALIZED!>Foo<!> {
val x : Int = 2
fun test() : Int {
return x + foo()
return x + foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
}<!>
}
object B : A {}
compiler/testData/diagnostics/tests/operatorsOverloading/InconsistentGetSet.fir.kt
Vendored
+5 -5
View File
@@ -34,11 +34,11 @@ object MismatchingArities2 {
}
fun testMismatchingArities() {
++<!INAPPLICABLE_CANDIDATE!>MismatchingArities1[0]<!>
<!INAPPLICABLE_CANDIDATE!>MismatchingArities1[0]<!>++
<!NO_VALUE_FOR_PARAMETER!>++MismatchingArities1[0]<!>
<!NO_VALUE_FOR_PARAMETER!>MismatchingArities1[0]++<!>
MismatchingArities1[0] <!UNRESOLVED_REFERENCE!>+=<!> 1
++<!INAPPLICABLE_CANDIDATE!>MismatchingArities2[0]<!>
<!INAPPLICABLE_CANDIDATE!>MismatchingArities2[0]<!>++
<!INAPPLICABLE_CANDIDATE!>MismatchingArities2[0]<!> <!UNRESOLVED_REFERENCE!>+=<!> 1
<!NO_VALUE_FOR_PARAMETER!>++MismatchingArities2[0]<!>
<!NO_VALUE_FOR_PARAMETER!>MismatchingArities2[0]++<!>
<!NO_VALUE_FOR_PARAMETER!>MismatchingArities2[0]<!> <!UNRESOLVED_REFERENCE!>+=<!> 1
}
compiler/testData/diagnostics/tests/override/parameterNames/invokeInFunctionClass.fir.kt
Vendored
+8 -8
View File
@@ -4,24 +4,24 @@ class Function1Impl : (String) -> Unit {
fun test1(f: Function1Impl) {
f("")
<!INAPPLICABLE_CANDIDATE!>f<!>(p0 = "")
f(p0 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
f(myParamName = "")
f.invoke("")
f.<!INAPPLICABLE_CANDIDATE!>invoke<!>(p0 = "")
f.invoke(p0 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
f.invoke(myParamName = "")
}
fun test2(f: (String) -> Unit) {
f("")
<!INAPPLICABLE_CANDIDATE!>f<!>(p0 = "")
<!INAPPLICABLE_CANDIDATE!>f<!>(myParamName = "")
f(p0 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
f(myParamName = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
f.invoke("")
f.<!INAPPLICABLE_CANDIDATE!>invoke<!>(p0 = "")
f.<!INAPPLICABLE_CANDIDATE!>invoke<!>(myParamName = "")
f.invoke(p0 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
f.invoke(myParamName = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun test3(f: String.(String) -> Unit) {
"".f("")
"".<!INAPPLICABLE_CANDIDATE!>f<!>(p0 = "")
"".<!INAPPLICABLE_CANDIDATE!>f<!>(zzz = "")
"".f(p0 = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
"".f(zzz = ""<!NO_VALUE_FOR_PARAMETER!>)<!>
}
compiler/testData/diagnostics/tests/regressions/kt1736.fir.kt
Vendored
-10
View File
@@ -1,10 +0,0 @@
//KT-1736 AssertionError in CallResolver
package kt1736
object Obj {
fun method() {
}
}
val x = Obj.<!INAPPLICABLE_CANDIDATE!>method<!>{ -> }
compiler/testData/diagnostics/tests/regressions/kt1736.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
//KT-1736 AssertionError in CallResolver
package kt1736
compiler/testData/diagnostics/tests/resolve/incompleteConstructorInvocation.fir.kt
Vendored
+2 -2
View File
@@ -4,7 +4,7 @@ class X<V>(provider: () -> V, trackValue: Boolean) {
}
class B {
val c = <!INAPPLICABLE_CANDIDATE!>X<!><String> {
val c = <!NO_VALUE_FOR_PARAMETER!>X<String> {
"e"
}
}<!>
}
compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.fir.kt
Vendored
+2 -2
View File
@@ -1,7 +1,7 @@
fun test1(f: String.() -> Unit) {
(<!INAPPLICABLE_CANDIDATE!>f<!>)()
(f)(<!NO_VALUE_FOR_PARAMETER!>)<!>
<!INAPPLICABLE_CANDIDATE!>f<!>()
f(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun test2(f: (Int) -> Int) {
compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt
Vendored
+1 -1
View File
@@ -7,7 +7,7 @@ fun test1() {
fun test2(f: String.(Int) -> Unit) {
11.(<!INAPPLICABLE_CANDIDATE!>f<!>)(1)
11.(<!INAPPLICABLE_CANDIDATE!>f<!>)()
11.(f)(<!NO_VALUE_FOR_PARAMETER!>)<!>
}
fun test3() {
compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.fir.kt
Vendored
+2 -2
View File
@@ -8,7 +8,7 @@ class SomeClass
fun test(identifier: SomeClass, fn: String.() -> Unit) {
<!NONE_APPLICABLE!>identifier<!>()
<!INAPPLICABLE_CANDIDATE!>identifier<!>(123)
<!INAPPLICABLE_CANDIDATE!>identifier<!>(1, 2)
identifier(123<!NO_VALUE_FOR_PARAMETER!>)<!>
identifier(1, <!TOO_MANY_ARGUMENTS!>2<!>)
1.<!INAPPLICABLE_CANDIDATE!>fn<!>()
}
compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.fir.kt
Vendored
+3 -3
View File
@@ -11,10 +11,10 @@ fun test(a: A) {
<!UNSAFE_IMPLICIT_INVOKE_CALL!>(a.x)<!>("")
with("") {
a.<!INAPPLICABLE_CANDIDATE!>x<!>()
<!INAPPLICABLE_CANDIDATE!>(a.x)<!>()
a.x(<!NO_VALUE_FOR_PARAMETER!>)<!>
(a.x)(<!NO_VALUE_FOR_PARAMETER!>)<!>
if (a.x != null) {
a.<!INAPPLICABLE_CANDIDATE!>x<!>() // todo
a.x(<!NO_VALUE_FOR_PARAMETER!>)<!> // todo
(a.x)()
}
}
compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt
Vendored
+4 -4
View File
@@ -24,8 +24,8 @@ fun test(a: A, b: B) {
}
with(b) {
a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
a.(<!INAPPLICABLE_CANDIDATE!>foo<!>)()
a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
a.(foo)(<!NO_VALUE_FOR_PARAMETER!>)<!>
(a.foo)()
@@ -66,8 +66,8 @@ fun test(a: A, b: B) {
}
with(b) {
a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
a.(<!INAPPLICABLE_CANDIDATE!>foo<!>)()
a.foo(<!NO_VALUE_FOR_PARAMETER!>)<!>
a.(foo)(<!NO_VALUE_FOR_PARAMETER!>)<!>
(a.foo)()
compiler/testData/diagnostics/tests/resolve/invoke/kt9805.fir.kt
Vendored
-17
View File
@@ -1,17 +0,0 @@
class A {
val foo: B.() -> Unit get() = null!!
}
class B
fun test(a: A, b: B) {
with(b) {
a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // here must be error, because a is not extension receiver
a.foo(this)
(a.foo)()
(a.foo)(this)
}
}
compiler/testData/diagnostics/tests/resolve/invoke/kt9805.kt
Vendored
+1
View File
@@ -1,3 +1,4 @@
// FIR_IDENTICAL
class A {
val foo: B.() -> Unit get() = null!!
}
compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt
Vendored
+2 -2
View File
@@ -7,7 +7,7 @@ class SomeClass
fun test(identifier: SomeClass, fn: String.() -> Unit) {
<!INAPPLICABLE_CANDIDATE!>identifier<!>()
<!INAPPLICABLE_CANDIDATE!>identifier<!>(123)
<!INAPPLICABLE_CANDIDATE!>identifier<!>(1, 2)
identifier(<!TOO_MANY_ARGUMENTS!>123<!>)
identifier(<!TOO_MANY_ARGUMENTS!>1<!>, <!TOO_MANY_ARGUMENTS!>2<!>)
1.<!INAPPLICABLE_CANDIDATE!>fn<!>()
}

Some files were not shown because too many files have changed in this diff Show More