diff --git a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java index 1ecc29baafa..d85c1e36b22 100644 --- a/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java +++ b/analysis/low-level-api-fir/tests/org/jetbrains/kotlin/analysis/low/level/api/fir/diagnostic/compiler/based/DiagnosisCompilerTestFE10TestdataTestGenerated.java @@ -32149,6 +32149,28 @@ public class DiagnosisCompilerTestFE10TestdataTestGenerated extends AbstractDiag } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/typeArguments") + @TestDataPath("$PROJECT_ROOT") + public class TypeArguments { + @Test + public void testAllFilesPresentInTypeArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typeArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("allowTypeArgumentListLikeExpressions.kt") + public void testAllowTypeArgumentListLikeExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeArguments/allowTypeArgumentListLikeExpressions.kt"); + } + + @Test + @TestMetadata("forbidTypeArgumentListLikeExpressions.kt") + public void testForbidTypeArgumentListLikeExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeArguments/forbidTypeArgumentListLikeExpressions.kt"); + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/typeParameters") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java index b35843a6cc2..277a3d18b31 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsTestGenerated.java @@ -32149,6 +32149,28 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirDiagnosti } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/typeArguments") + @TestDataPath("$PROJECT_ROOT") + public class TypeArguments { + @Test + public void testAllFilesPresentInTypeArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typeArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("allowTypeArgumentListLikeExpressions.kt") + public void testAllowTypeArgumentListLikeExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeArguments/allowTypeArgumentListLikeExpressions.kt"); + } + + @Test + @TestMetadata("forbidTypeArgumentListLikeExpressions.kt") + public void testForbidTypeArgumentListLikeExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeArguments/forbidTypeArgumentListLikeExpressions.kt"); + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/typeParameters") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java index 366939768fb..665ad8d12ef 100644 --- a/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java +++ b/compiler/fir/analysis-tests/tests-gen/org/jetbrains/kotlin/test/runners/FirOldFrontendDiagnosticsWithLightTreeTestGenerated.java @@ -32149,6 +32149,28 @@ public class FirOldFrontendDiagnosticsWithLightTreeTestGenerated extends Abstrac } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/typeArguments") + @TestDataPath("$PROJECT_ROOT") + public class TypeArguments { + @Test + public void testAllFilesPresentInTypeArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typeArguments"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("allowTypeArgumentListLikeExpressions.kt") + public void testAllowTypeArgumentListLikeExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeArguments/allowTypeArgumentListLikeExpressions.kt"); + } + + @Test + @TestMetadata("forbidTypeArgumentListLikeExpressions.kt") + public void testForbidTypeArgumentListLikeExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeArguments/forbidTypeArgumentListLikeExpressions.kt"); + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/typeParameters") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java index d489c850ceb..2ef6afdf088 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java @@ -235,6 +235,7 @@ public interface Errors { DiagnosticFactoryForDeprecation1 PROGRESSIONS_CHANGING_RESOLVE = DiagnosticFactoryForDeprecation1.create(LanguageFeature.ProgressionsChangingResolve); DiagnosticFactory0 EXPRESSION_AFTER_TYPE_REFERENCE_WITHOUT_SPACING_NOT_ALLOWED = DiagnosticFactory0.create(ERROR); + DiagnosticFactory0 TYPE_ARGUMENT_LIST_LIKE_EXPRESSION = DiagnosticFactory0.create(ERROR); //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java index 90f906e9c18..dd3ca330f81 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java +++ b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/rendering/DefaultErrorMessages.java @@ -629,6 +629,7 @@ public class DefaultErrorMessages { "See https://youtrack.jetbrains.com/issue/KT-49276 for more details. " + "Please specify a progression type of argument explicitly through explicit cast to resolve to a proper declaration", COMPACT); MAP.put(EXPRESSION_AFTER_TYPE_REFERENCE_WITHOUT_SPACING_NOT_ALLOWED, "Expression body directly after type without a whitespace in-between the '>=' is only allowed since version 1.8"); + MAP.put(TYPE_ARGUMENT_LIST_LIKE_EXPRESSION, "Type argument list like expressions are only allowed since version 1.8"); MAP.put(TOO_MANY_ARGUMENTS, "Too many arguments for {0}", FQ_NAMES_IN_TYPES); diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/PlatformConfiguratorBase.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/PlatformConfiguratorBase.kt index 8d1fcf4b849..92817d8303e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/resolve/PlatformConfiguratorBase.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/PlatformConfiguratorBase.kt @@ -54,6 +54,7 @@ private val DEFAULT_DECLARATION_CHECKERS = listOf( UnsupportedUntilRangeDeclarationChecker, DataObjectContentChecker, ExpressionAfterTypeParameterWithoutSpacingChecker, + TypeArgumentListLikeExpressionsChecker, ) private val DEFAULT_CALL_CHECKERS = listOf( diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/TypeArgumentListLikeExpressionsChecker.kt b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/TypeArgumentListLikeExpressionsChecker.kt new file mode 100644 index 00000000000..67da88b2a86 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/kotlin/resolve/checkers/TypeArgumentListLikeExpressionsChecker.kt @@ -0,0 +1,50 @@ +/* + * Copyright 2010-2022 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.resolve.checkers + +import org.jetbrains.kotlin.KtNodeTypes +import org.jetbrains.kotlin.config.LanguageFeature +import org.jetbrains.kotlin.descriptors.DeclarationDescriptor +import org.jetbrains.kotlin.diagnostics.Errors +import org.jetbrains.kotlin.psi.* +import org.jetbrains.kotlin.psi.psiUtil.children + +object TypeArgumentListLikeExpressionsChecker : DeclarationChecker { + + override fun check(declaration: KtDeclaration, descriptor: DeclarationDescriptor, context: DeclarationCheckerContext) { + if (context.languageVersionSettings.supportsFeature(LanguageFeature.AllowTypeArgumentListLikeExpressions)) return + if (declaration.parent !is KtFile) return + + val visitor = object : KtTreeVisitorVoid() { + override fun visitBinaryExpression(expression: KtBinaryExpression) { + super.visitBinaryExpression(expression) + + if (wasTypeArgumentListLikeExpression(expression)) { + context.trace.report(Errors.TYPE_ARGUMENT_LIST_LIKE_EXPRESSION.on(expression.operationReference)) + } + } + + override fun visitUserType(type: KtUserType) { + super.visitUserType(type) + + if (wasTypeArgumentListLikeExpression(type)) { + var parent = type.parent ?: return + while (parent !is KtBinaryExpression) { + parent = parent.parent ?: return + } + + context.trace.report(Errors.TYPE_ARGUMENT_LIST_LIKE_EXPRESSION.on(parent.operationReference)) + } + } + + private fun wasTypeArgumentListLikeExpression(element: KtElement): Boolean { + return element.node.children().any { it.elementType == KtNodeTypes.TYPE_ARGUMENT_LIST_LIKE_EXPRESSION } + } + } + + declaration.accept(visitor) + } +} \ No newline at end of file diff --git a/compiler/psi/src/org/jetbrains/kotlin/KtNodeTypes.java b/compiler/psi/src/org/jetbrains/kotlin/KtNodeTypes.java index 3705c99c883..48c1485d57c 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/KtNodeTypes.java +++ b/compiler/psi/src/org/jetbrains/kotlin/KtNodeTypes.java @@ -149,6 +149,8 @@ public interface KtNodeTypes { IElementType CLASS_LITERAL_EXPRESSION = new KtNodeType("CLASS_LITERAL_EXPRESSION", KtClassLiteralExpression.class); IElementType SAFE_ACCESS_EXPRESSION = new KtNodeType("SAFE_ACCESS_EXPRESSION", KtSafeQualifiedExpression.class); + IElementType TYPE_ARGUMENT_LIST_LIKE_EXPRESSION = new IElementType("TYPE_ARGUMENT_LIST_LIKE_EXPRESSION", null); + IElementType OBJECT_LITERAL = new KtNodeType("OBJECT_LITERAL", KtObjectLiteralExpression.class); IElementType WHEN = new KtNodeType("WHEN", KtWhenExpression.class); diff --git a/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java b/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java index 931b5aa4b44..94df92a6c3c 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java +++ b/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinExpressionParsing.java @@ -21,6 +21,7 @@ import com.intellij.lang.ASTNode; import com.intellij.lang.Language; import com.intellij.lang.PsiBuilder; import com.intellij.openapi.project.Project; +import com.intellij.psi.TokenType; import com.intellij.psi.tree.IElementType; import com.intellij.psi.tree.TokenSet; import org.jetbrains.annotations.NotNull; @@ -68,20 +69,17 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { return builder.build(); } - private static final TokenSet TYPE_ARGUMENT_LIST_STOPPERS = TokenSet.create( - INTEGER_LITERAL, FLOAT_LITERAL, CHARACTER_LITERAL, OPEN_QUOTE, - PACKAGE_KEYWORD, AS_KEYWORD, TYPE_ALIAS_KEYWORD, INTERFACE_KEYWORD, CLASS_KEYWORD, THIS_KEYWORD, VAL_KEYWORD, VAR_KEYWORD, - FUN_KEYWORD, FOR_KEYWORD, NULL_KEYWORD, - TRUE_KEYWORD, FALSE_KEYWORD, IS_KEYWORD, THROW_KEYWORD, RETURN_KEYWORD, BREAK_KEYWORD, - CONTINUE_KEYWORD, OBJECT_KEYWORD, IF_KEYWORD, TRY_KEYWORD, ELSE_KEYWORD, WHILE_KEYWORD, DO_KEYWORD, - WHEN_KEYWORD, RBRACKET, RBRACE, RPAR, PLUSPLUS, MINUSMINUS, EXCLEXCL, - // MUL, - PLUS, MINUS, EXCL, DIV, PERC, LTEQ, - // TODO GTEQ, foo=x - EQEQEQ, EXCLEQEQEQ, EQEQ, EXCLEQ, ANDAND, OROR, SAFE_ACCESS, ELVIS, - SEMICOLON, RANGE, RANGE_UNTIL, EQ, MULTEQ, DIVEQ, PERCEQ, PLUSEQ, MINUSEQ, NOT_IN, NOT_IS, - COLONCOLON, - COLON + private static final TokenSet STRONG_TYPE_ARGUMENT_LIST_POSTFIX_INDICATORS = TokenSet.orSet( + TokenSet.create(COLONCOLON, QUEST, LBRACKET, TokenType.BAD_CHARACTER), Precedence.POSTFIX.getOperations() + ); + private static final TokenSet WEAK_TYPE_ARGUMENT_LIST_POSTFIX_INDICATORS = TokenSet.create( + RBRACKET, RBRACE, RPAR, EQ, COLON, SEMICOLON, COMMA, + + EQEQEQ, EXCLEQEQEQ, EQEQ, EXCLEQ, ELVIS, AS_KEYWORD, IS_KEYWORD, NOT_IS, NOT_IN, RANGE, RANGE_UNTIL, ARROW, + + PACKAGE_KEYWORD, CLASS_KEYWORD, INTERFACE_KEYWORD, OBJECT_KEYWORD, TYPE_ALIAS_KEYWORD, SUPER_KEYWORD, VAL_KEYWORD, + VAR_KEYWORD, FUN_KEYWORD, RETURN_KEYWORD, FOR_KEYWORD, WHILE_KEYWORD, DO_KEYWORD, BREAK_KEYWORD, CONTINUE_KEYWORD, + THROW_KEYWORD ); /*package*/ static final TokenSet EXPRESSION_FIRST = TokenSet.create( @@ -168,7 +166,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { AS(AS_KEYWORD, AS_SAFE) { @Override public IElementType parseRightHandSide(IElementType operation, KotlinExpressionParsing parser) { - parser.myKotlinParsing.parseTypeRefWithoutIntersections(); + parser.myKotlinParsing.parseTypeRefWithoutIntersections(/* partOfExpression */ true); return BINARY_WITH_TYPE; } @@ -187,7 +185,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { @Override public IElementType parseRightHandSide(IElementType operation, KotlinExpressionParsing parser) { if (operation == IS_KEYWORD || operation == NOT_IS) { - parser.myKotlinParsing.parseTypeRefWithoutIntersections(); + parser.myKotlinParsing.parseTypeRefWithoutIntersections(/* partOfExpression */ true); return IS_EXPRESSION; } @@ -402,7 +400,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { if (at(LT)) { PsiBuilder.Marker typeArgumentList = mark(); - if (myKotlinParsing.tryParseTypeArgumentList(TYPE_ARGUMENT_LIST_STOPPERS)) { + if (parseCallSuffixTypeArgumentList()) { typeArgumentList.error("Type arguments are not allowed"); } else { @@ -410,7 +408,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { } } - if (at(LPAR) && !myBuilder.newlineBeforeCurrentToken()) { + if (isAtValueArgumentList()) { PsiBuilder.Marker lpar = mark(); parseCallSuffix(); lpar.error("This syntax is reserved for future use; to call a reference, enclose it in parentheses: (foo::bar)(args)"); @@ -494,37 +492,143 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { /* * callSuffix - * : typeArguments? valueArguments annotatedLambda - * : typeArguments annotatedLambda + * : typeArguments? valueArguments? annotatedLambda* * ; */ private boolean parseCallSuffix() { - if (parseCallWithClosure()) { - // do nothing + if (at(LT) && parseCallSuffixTypeArgumentList()) { + if (at(LPAR) && !myBuilder.newlineBeforeCurrentToken()) parseValueArgumentList(); + parseCallWithClosure(); + + return true; } else if (at(LPAR)) { parseValueArgumentList(); parseCallWithClosure(); + + return true; } - else if (at(LT)) { - PsiBuilder.Marker typeArgumentList = mark(); - if (myKotlinParsing.tryParseTypeArgumentList(TYPE_ARGUMENT_LIST_STOPPERS)) { - typeArgumentList.done(TYPE_ARGUMENT_LIST); - if (!myBuilder.newlineBeforeCurrentToken() && at(LPAR)) parseValueArgumentList(); - parseCallWithClosure(); - } - else { - typeArgumentList.rollbackTo(); - return false; - } + else if (parseCallWithClosure()) { + return true; } - else { + + return false; + } + + private boolean parseCallSuffixTypeArgumentList() { + PsiBuilder.Marker typeArgumentList = mark(); + + KotlinParsing.TypeArgumentListKind kind = myKotlinParsing.tryParseTypeArgumentList(); + + // If the parsed section did not fulfill the criteria of a type argument list or + // if there's no indication of an intended call suffix, drop the type argument list. + if (kind == KotlinParsing.TypeArgumentListKind.NONE) { + typeArgumentList.rollbackTo(); + return false; } + if (!isAtTypeArgumentListPostfixIndicator()) { + typeArgumentList.rollbackTo(); + + mark().done(TYPE_ARGUMENT_LIST_LIKE_EXPRESSION); + return false; + } + + // If the parsed section could have been a faulty type argument type list, check + // whether it could have also been parsed as the right-hand side of a comparison + // expression correctly. If so, we have never had a faulty type argument list in + // the first place, and therefor it must be dropped. + if (kind == KotlinParsing.TypeArgumentListKind.FAULTY_TYPE_ARGUMENT_LIST) { + // For better error highlighting we only try to produce a faulty type argument list, if + // there are strong indicators. Otherwise, we would lean too much towards call suffixes + // in cases like when typing "x < 0 && 1 > ", where the last element hasn't been typed + // yet. + if (!isAtStrongTypeArgumentListPostfixIndicator()) { + typeArgumentList.rollbackTo(); + + mark().done(TYPE_ARGUMENT_LIST_LIKE_EXPRESSION); + return false; + } + + typeArgumentList.rollbackTo(); + + if (isAtConditionalExpression()) { + mark().done(TYPE_ARGUMENT_LIST_LIKE_EXPRESSION); + return false; + } + + typeArgumentList = mark(); + + myKotlinParsing.tryParseTypeArgumentList(); + } + + // At this point we're sure that it's either a correct type argument list followed + // by some indication of a call suffix or that it's faulty type argument list that + // is definitely not a correct right-hand side of an expression and is followed by + // a strong indication of a call suffix. + + typeArgumentList.done(TYPE_ARGUMENT_LIST); + return true; } + private boolean isAtTypeArgumentListPostfixIndicator() { + return isAtStrongTypeArgumentListPostfixIndicator() || isAtWeakTypeArgumentListPostfixIndicator(); + } + + private boolean isAtStrongTypeArgumentListPostfixIndicator() { + // The start of a value argument list or an annotated lambda indicates a type argument list. + // <...>( <...>{ <...>@identifier{ <...>identifier@{ <...>[ + // Postfix expression are usually not applied to non-null boolean comparisons. + // <...>:: <...>? <...>. <...>?. <...>!! <...>++ <...>-- + return isAtValueArgumentList() || isAtAnnotatedLambda() || atSet(STRONG_TYPE_ARGUMENT_LIST_POSTFIX_INDICATORS); + } + + private boolean isAtWeakTypeArgumentListPostfixIndicator() { + // Line breaks are only available outside of value argument list. This is an incomplete line of code. + // <...>↵ + // Other limiting tokens are also a likely indicator of an indented function call. + // <...>) <...>] <...>} <...>, <...>: <...>= + // Operators are unlikely to be applied to non-null booleans. + // <...>== <...>!= <...>=== <...>!== <...> as <...> is <...> in + // Hard keywords hint towards some formatting issue where line breaks are missing + // <...>fun <...>var <...>var <...>object + return myBuilder.newlineBeforeCurrentToken() || atSet(WEAK_TYPE_ARGUMENT_LIST_POSTFIX_INDICATORS); + } + + boolean isAtConditionalExpression() { + assert _at(LT) : "caller must check that current token is LT"; + + PsiBuilder.Marker marker = mark(); + + advance(); // LT + + boolean hasNoErrors; + + do { + PsiBuilder.Marker errorScope = mark(); + + parseExpression(); + + hasNoErrors = !myBuilder.hasErrorsAfter(errorScope); + errorScope.drop(); + + if (!hasNoErrors) break; + + if (at(COMMA)) { + advance(); + } + else { + break; + } + } while (true); + + marker.rollbackTo(); + + return hasNoErrors; + } + /* * atomicExpression typeParameters? valueParameters? functionLiteral* */ @@ -594,6 +698,24 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { return true; } + private boolean isAtAnnotatedLambda() { + // "{" + if (_at(LBRACE)) { + return true; + } + // IDENTIFIER "@" "{" + else if (_at(IDENTIFIER) && myBuilder.rawLookup(1) == AT && myBuilder.rawLookup(2) == LBRACE) { + return true; + } + // "@" + else if (_at(AT)) { + return true; + } + else { + return false; + } + } + private static void doneOrDrop( @NotNull PsiBuilder.Marker marker, @NotNull IElementType type, @@ -993,7 +1115,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { error("Expecting a type"); } else { - myKotlinParsing.parseTypeRef(); + myKotlinParsing.parseTypeRef(/* partOfExpression */ false); } condition.done(WHEN_CONDITION_IS_PATTERN); break; @@ -1271,7 +1393,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { if (at(COLON)) { advance(); // COLON - myKotlinParsing.parseTypeRef(ARROW_COMMA_SET); + myKotlinParsing.parseTypeRef(ARROW_COMMA_SET, /* partOfExpression */ false); } parameter.done(VALUE_PARAMETER); @@ -1497,7 +1619,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { if (at(COLON)) { advance(); // COLON - myKotlinParsing.parseTypeRef(IN_KEYWORD_SET); + myKotlinParsing.parseTypeRef(IN_KEYWORD_SET, /* partOfExpression */ false); } } parameter.done(VALUE_PARAMETER); @@ -1813,7 +1935,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { } /* - * "this" ("<" type ">")? label? + * "super" ("<" type ">")? label? */ private void parseSuperExpression() { assert _at(SUPER_KEYWORD); @@ -1830,7 +1952,7 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { myBuilder.disableNewlines(); advance(); // LT - myKotlinParsing.parseTypeRef(); + myKotlinParsing.parseTypeRef(/* partOfExpression */ false); if (at(GT)) { advance(); // GT @@ -1888,6 +2010,10 @@ public class KotlinExpressionParsing extends AbstractKotlinParsing { list.done(VALUE_ARGUMENT_LIST); } + private boolean isAtValueArgumentList() { + return _at(LPAR) && !myBuilder.newlineBeforeCurrentToken(); + } + /* * (SimpleName "=")? "*"? element */ diff --git a/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinParsing.java b/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinParsing.java index 1bf9760b766..b5655b7cbfe 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinParsing.java +++ b/compiler/psi/src/org/jetbrains/kotlin/parsing/KotlinParsing.java @@ -105,6 +105,21 @@ public class KotlinParsing extends AbstractKotlinParsing { private final static TokenSet EOL_OR_SEMICOLON_RBRACE_SET = TokenSet.create(EOL_OR_SEMICOLON, RBRACE); private final static TokenSet CLASS_INTERFACE_SET = TokenSet.create(CLASS_KEYWORD, INTERFACE_KEYWORD); + private static final TokenSet TYPE_ARGUMENT_LIST_RECOVERY_SET = TokenSet.create( + INTEGER_LITERAL, FLOAT_LITERAL, CHARACTER_LITERAL, OPEN_QUOTE, + PACKAGE_KEYWORD, AS_KEYWORD, TYPE_ALIAS_KEYWORD, INTERFACE_KEYWORD, CLASS_KEYWORD, THIS_KEYWORD, VAL_KEYWORD, VAR_KEYWORD, + FUN_KEYWORD, FOR_KEYWORD, NULL_KEYWORD, + TRUE_KEYWORD, FALSE_KEYWORD, IS_KEYWORD, THROW_KEYWORD, RETURN_KEYWORD, BREAK_KEYWORD, + CONTINUE_KEYWORD, OBJECT_KEYWORD, IF_KEYWORD, TRY_KEYWORD, ELSE_KEYWORD, WHILE_KEYWORD, DO_KEYWORD, + WHEN_KEYWORD, RBRACKET, RBRACE, RPAR, PLUSPLUS, MINUSMINUS, EXCLEXCL, + // MUL, + PLUS, MINUS, EXCL, DIV, PERC, LTEQ, + GTEQ, GT, EQEQEQ, EXCLEQEQEQ, EQEQ, EXCLEQ, ANDAND, OROR, SAFE_ACCESS, ELVIS, + SEMICOLON, RANGE, RANGE_UNTIL, EQ, MULTEQ, DIVEQ, PERCEQ, PLUSEQ, MINUSEQ, NOT_IN, NOT_IS, + COLONCOLON, + COLON + ); + static KotlinParsing createForTopLevel(SemanticWhitespaceAwarePsiBuilder builder) { return new KotlinParsing(builder, true); } @@ -195,7 +210,7 @@ public class KotlinParsing extends AbstractKotlinParsing { void parseTypeCodeFragment() { PsiBuilder.Marker marker = mark(); - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); checkForUnexpectedSymbols(); @@ -714,7 +729,7 @@ public class KotlinParsing extends AbstractKotlinParsing { if (myExpressionParsing.isAtLabelDefinitionOrMissingIdentifier()) { myExpressionParsing.parseLabelDefinition(); } - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); contextReceiver.done(CONTEXT_RECEIVER); } @@ -939,11 +954,11 @@ public class KotlinParsing extends AbstractKotlinParsing { PsiBuilder.Marker reference = mark(); PsiBuilder.Marker typeReference = mark(); - parseUserType(); + parseUserType(/* partOfExpression */ false); typeReference.done(TYPE_REFERENCE); reference.done(CONSTRUCTOR_CALLEE); - parseTypeArgumentList(); + parseTypeArgumentList(/* partOfExpression */ false); boolean whitespaceAfterAnnotation = WHITE_SPACE_OR_COMMENT_BIT_SET.contains(myBuilder.rawLookup(-1)); boolean shouldBeParsedNextAsFunctionalType = at(LPAR) && whitespaceAfterAnnotation && mode.withSignificantWhitespaceBeforeArguments; @@ -1425,7 +1440,7 @@ public class KotlinParsing extends AbstractKotlinParsing { expect(EQ, "Expecting '='", TOP_LEVEL_DECLARATION_FIRST_SEMICOLON_SET); - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); consumeIf(SEMICOLON); @@ -1497,7 +1512,7 @@ public class KotlinParsing extends AbstractKotlinParsing { noTypeReference = false; PsiBuilder.Marker type = mark(); advance(); // COLON - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); errorIf(type, multiDeclaration, "Type annotations are not allowed on destructuring declarations"); } @@ -1599,7 +1614,7 @@ public class KotlinParsing extends AbstractKotlinParsing { if (at(COLON)) { advance(); // COLON - parseTypeRef(follow); + parseTypeRef(follow, /* partOfExpression */ false); } property.done(DESTRUCTURING_DECLARATION_ENTRY); @@ -1694,7 +1709,7 @@ public class KotlinParsing extends AbstractKotlinParsing { if (at(COLON)) { advance(); // COLON - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); } setterParameter.done(VALUE_PARAMETER); if (at(COMMA)) { @@ -1714,7 +1729,7 @@ public class KotlinParsing extends AbstractKotlinParsing { if (at(COLON)) { advance(); - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); } if (propertyComponentKind != PropertyComponentKind.FIELD) { @@ -1808,7 +1823,7 @@ public class KotlinParsing extends AbstractKotlinParsing { if (at(COLON)) { advance(); // COLON - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); } boolean functionContractOccurred = parseFunctionContract(); @@ -1851,7 +1866,7 @@ public class KotlinParsing extends AbstractKotlinParsing { if (!receiverPresent) return false; - createTruncatedBuilder(lastDot).parseTypeRefWithoutIntersections(); + createTruncatedBuilder(lastDot).parseTypeRefWithoutIntersections(/* partOfExpression */ false); if (atSet(RECEIVER_TYPE_TERMINATORS)) { advance(); // expectation @@ -1992,7 +2007,7 @@ public class KotlinParsing extends AbstractKotlinParsing { private void parseDelegationSpecifier() { PsiBuilder.Marker delegator = mark(); PsiBuilder.Marker reference = mark(); - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); if (at(BY_KEYWORD)) { reference.drop(); @@ -2103,7 +2118,7 @@ public class KotlinParsing extends AbstractKotlinParsing { expect(COLON, "Expecting ':' before the upper bound", LBRACE_RBRACE_TYPE_REF_FIRST_SET); - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); constraint.done(TYPE_CONSTRAINT); } @@ -2135,7 +2150,7 @@ public class KotlinParsing extends AbstractKotlinParsing { if (at(COLON)) { advance(); // COLON - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); } mark.done(TYPE_PARAMETER); @@ -2158,26 +2173,30 @@ public class KotlinParsing extends AbstractKotlinParsing { * : typeReference "?" * ; */ - void parseTypeRef() { - parseTypeRef(TokenSet.EMPTY); + void parseTypeRef(boolean partOfExpression) { + parseTypeRef(TokenSet.EMPTY, partOfExpression); } - void parseTypeRefWithoutIntersections() { - parseTypeRef(TokenSet.EMPTY, /* allowSimpleIntersectionTypes */ false); + void parseTypeRefWithoutIntersections(boolean partOfExpression) { + parseTypeRef(TokenSet.EMPTY, partOfExpression, /* allowSimpleIntersectionTypes */ false); } - void parseTypeRef(TokenSet extraRecoverySet) { - parseTypeRef(extraRecoverySet, /* allowSimpleIntersectionTypes */ true); + void parseTypeRef(TokenSet extraRecoverySet, boolean partOfExpression) { + parseTypeRef(extraRecoverySet, partOfExpression, /* allowSimpleIntersectionTypes */ true); } - private void parseTypeRef(TokenSet extraRecoverySet, boolean allowSimpleIntersectionTypes) { - PsiBuilder.Marker typeRefMarker = parseTypeRefContents(extraRecoverySet, allowSimpleIntersectionTypes); + private void parseTypeRef(TokenSet extraRecoverySet, boolean partOfExpression, boolean allowSimpleIntersectionTypes) { + PsiBuilder.Marker typeRefMarker = parseTypeRefContents(extraRecoverySet, partOfExpression, allowSimpleIntersectionTypes); typeRefMarker.done(TYPE_REFERENCE); } // The extraRecoverySet is needed for the foo(bar(z)) case, to tell whether we should stop // on expression-indicating symbols or not - private PsiBuilder.Marker parseTypeRefContents(TokenSet extraRecoverySet, boolean allowSimpleIntersectionTypes) { + private PsiBuilder.Marker parseTypeRefContents( + TokenSet extraRecoverySet, + boolean partOfExpression, + boolean allowSimpleIntersectionTypes + ) { PsiBuilder.Marker typeRefMarker = mark(); parseTypeModifierList(); @@ -2203,14 +2222,14 @@ public class KotlinParsing extends AbstractKotlinParsing { dynamicType.done(DYNAMIC_TYPE); } else if (at(IDENTIFIER) || at(PACKAGE_KEYWORD) || atParenthesizedMutableForPlatformTypes(0)) { - parseUserType(); + parseUserType(partOfExpression); } else if (at(LPAR)) { PsiBuilder.Marker functionOrParenthesizedType = mark(); // This may be a function parameter list or just a parenthesized type advance(); // LPAR - parseTypeRefContents(TokenSet.EMPTY, /* allowSimpleIntersectionTypes */ true).drop(); // parenthesized types, no reference element around it is needed + parseTypeRefContents(TokenSet.EMPTY, /* partOfExpression */ false, /* allowSimpleIntersectionTypes */ true).drop(); // parenthesized types, no reference element around it is needed if (at(RPAR) && lookahead(1) != ARROW) { // It's a parenthesized type @@ -2252,7 +2271,7 @@ public class KotlinParsing extends AbstractKotlinParsing { leftTypeRef.done(TYPE_REFERENCE); advance(); // & - parseTypeRef(extraRecoverySet, /* allowSimpleIntersectionTypes */ true); + parseTypeRef(extraRecoverySet, /* allowSimpleIntersectionTypes */ false, true /* partOfExpression */); intersectionType.done(INTERSECTION_TYPE); wasIntersection = true; @@ -2317,7 +2336,7 @@ public class KotlinParsing extends AbstractKotlinParsing { * - (Mutable)List! * - Array<(out) Foo>! */ - private void parseUserType() { + private void parseUserType(boolean partOfExpression) { PsiBuilder.Marker userType = mark(); if (at(PACKAGE_KEYWORD)) { @@ -2340,7 +2359,7 @@ public class KotlinParsing extends AbstractKotlinParsing { break; } - parseTypeArgumentList(); + parseTypeArgumentList(partOfExpression); recoverOnPlatformTypeSuffix(); @@ -2410,20 +2429,72 @@ public class KotlinParsing extends AbstractKotlinParsing { /* * (optionalProjection type){","} */ - private void parseTypeArgumentList() { + private void parseTypeArgumentList(boolean partOfExpression) { if (!at(LT)) return; - PsiBuilder.Marker list = mark(); + PsiBuilder.Marker typeArgumentList = mark(); - tryParseTypeArgumentList(TokenSet.EMPTY); + TypeArgumentListKind kind = tryParseTypeArgumentList(); - list.done(TYPE_ARGUMENT_LIST); + if (kind == TypeArgumentListKind.NONE && partOfExpression) { + typeArgumentList.rollbackTo(); + + mark().done(TYPE_ARGUMENT_LIST_LIKE_EXPRESSION); + return; + } + + // Type argument lists that appear inside of expressions might also be comparisons: + // some(a as Int < 3, y > z) + if (kind == TypeArgumentListKind.FAULTY_TYPE_ARGUMENT_LIST && partOfExpression) { + typeArgumentList.rollbackTo(); + + if (myExpressionParsing.isAtConditionalExpression()) { + mark().done(TYPE_ARGUMENT_LIST_LIKE_EXPRESSION); + return; + } + + typeArgumentList = mark(); + + tryParseTypeArgumentList(); + } + + typeArgumentList.done(TYPE_ARGUMENT_LIST); } - boolean tryParseTypeArgumentList(TokenSet extraRecoverySet) { + /** + * Tries to parse a section into a type argument list and reports how successful the attempt was. + *

+ * The returned value of the method indicates to what degree the parsed section can be considered a type + * argument list. + *

+ * {@link TypeArgumentListKind#TYPE_ARGUMENT_LIST} states the section should most likely be considered as + * a type argument list. This is the case, if any of the following conditions apply: + *

    + *
  • the type argument list contains no syntax errors. + *
  • the type argument list is empty + *
+ *

+ * {@link TypeArgumentListKind#FAULTY_TYPE_ARGUMENT_LIST} indicates that the section may be considered as + * a type argument list. This is the case, if any of the following conditions apply: + *

    + *
  • the sections contains syntax errors, but ends with a '>' + *
+ *

+ * {@link TypeArgumentListKind#NONE} indicates that the section must not be considered as a type argument + * list. This is the case, if none of the above cases apply. + */ + TypeArgumentListKind tryParseTypeArgumentList() { + assert _at(LT) : "caller must check that current token is LT"; + + PsiBuilder.Marker errorScope = mark(); + myBuilder.disableNewlines(); advance(); // LT + // Even if the type argument list is empty, we still want to "try" to parse it in + // order to get error highlighting for the missing type + boolean empty = at(GT) || at(GTEQ); + while (true) { PsiBuilder.Marker projection = mark(); @@ -2437,25 +2508,46 @@ public class KotlinParsing extends AbstractKotlinParsing { advance(); // MUL } else { - parseTypeRef(extraRecoverySet); + parseTypeRef(TYPE_ARGUMENT_LIST_RECOVERY_SET, /* partOfExpression */ false); } projection.done(TYPE_PROJECTION); + if (!at(COMMA)) break; advance(); // COMMA - if (at(GT)) { - break; - } + if (at(GT) || at(GTEQ)) break; } + myBuilder.disableJoiningComplexTokens(); + boolean atGT = at(GT); - if (!atGT) { - error("Expecting a '>'"); - } - else { + + if (atGT) { advance(); // GT } + else { + error("Expecting a '>'"); + } + + myBuilder.restoreJoiningComplexTokensState(); + myBuilder.restoreNewlinesState(); - return atGT; + + boolean success = !myBuilder.hasErrorsAfter(errorScope); + errorScope.drop(); + + if (success || empty) { + return TypeArgumentListKind.TYPE_ARGUMENT_LIST; + } + else if (atGT) { + return TypeArgumentListKind.FAULTY_TYPE_ARGUMENT_LIST; + } + else { + return TypeArgumentListKind.NONE; + } + } + + public enum TypeArgumentListKind { + TYPE_ARGUMENT_LIST, FAULTY_TYPE_ARGUMENT_LIST, NONE, } /* @@ -2473,7 +2565,7 @@ public class KotlinParsing extends AbstractKotlinParsing { parseValueParameterList(true, /* typeRequired = */ true, TokenSet.EMPTY); expect(ARROW, "Expecting '->' to specify return type of a function type", TYPE_REF_FIRST); - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); return functionType; } @@ -2513,7 +2605,7 @@ public class KotlinParsing extends AbstractKotlinParsing { if (!tryParseValueParameter(typeRequired)) { PsiBuilder.Marker valueParameter = mark(); parseFunctionTypeValueParameterModifierList(); - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); closeDeclarationWithCommentBinders(valueParameter, VALUE_PARAMETER, false); } } @@ -2593,7 +2685,7 @@ public class KotlinParsing extends AbstractKotlinParsing { else { noErrors = false; } - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); } else { expect(IDENTIFIER, "Parameter name expected", PARAMETER_NAME_RECOVERY_SET); @@ -2608,7 +2700,7 @@ public class KotlinParsing extends AbstractKotlinParsing { return false; } - parseTypeRef(); + parseTypeRef(/* partOfExpression */ false); } else if (typeRequired) { errorWithRecovery("Parameters must have type annotation", PARAMETER_NAME_RECOVERY_SET); diff --git a/compiler/psi/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilder.java b/compiler/psi/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilder.java index 64b05d6f7f3..1c6b6444fe2 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilder.java +++ b/compiler/psi/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilder.java @@ -34,4 +34,6 @@ public interface SemanticWhitespaceAwarePsiBuilder extends PsiBuilder { @Override boolean isWhitespaceOrComment(@NotNull IElementType elementType); + + boolean hasErrorsAfter(@NotNull PsiBuilder.Marker marker); } diff --git a/compiler/psi/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderAdapter.java b/compiler/psi/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderAdapter.java index 55f2bc80a00..2a90b113b8e 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderAdapter.java +++ b/compiler/psi/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderAdapter.java @@ -68,4 +68,9 @@ public class SemanticWhitespaceAwarePsiBuilderAdapter extends PsiBuilderAdapter public boolean isWhitespaceOrComment(@NotNull IElementType elementType) { return myBuilder.isWhitespaceOrComment(elementType); } + + @Override + public boolean hasErrorsAfter(@NotNull Marker marker) { + return myBuilder.hasErrorsAfter(marker); + } } diff --git a/compiler/psi/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java b/compiler/psi/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java index 7ef5b63a41b..287b41ebd5e 100644 --- a/compiler/psi/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java +++ b/compiler/psi/src/org/jetbrains/kotlin/parsing/SemanticWhitespaceAwarePsiBuilderImpl.java @@ -202,4 +202,10 @@ public class SemanticWhitespaceAwarePsiBuilderImpl extends PsiBuilderAdapter imp } return getJoinedTokenType(super.lookAhead(steps), 2); } + + @Override + public boolean hasErrorsAfter(@NotNull Marker marker) { + assert delegateImpl != null : "PsiBuilderImpl not found"; + return delegateImpl.hasErrorsAfter(marker); + } } diff --git a/compiler/testData/diagnostics/tests/syntax/complicatedLTGT.fir.kt b/compiler/testData/diagnostics/tests/syntax/complicatedLTGT.fir.kt deleted file mode 100644 index 7fe44c53a54..00000000000 --- a/compiler/testData/diagnostics/tests/syntax/complicatedLTGT.fir.kt +++ /dev/null @@ -1,8 +0,0 @@ -// SKIP_TXT -// ISSUE: KT-8263 - -fun test(x: Int, y: Int) { - if (x < (if (y > 115) 1 else 2)) { - Unit - } -} diff --git a/compiler/testData/diagnostics/tests/syntax/complicatedLTGT.kt b/compiler/testData/diagnostics/tests/syntax/complicatedLTGT.kt index 5ae615475da..ec6ebc08986 100644 --- a/compiler/testData/diagnostics/tests/syntax/complicatedLTGT.kt +++ b/compiler/testData/diagnostics/tests/syntax/complicatedLTGT.kt @@ -1,8 +1,9 @@ +// FIR_IDENTICAL // SKIP_TXT // ISSUE: KT-8263 fun test(x: Int, y: Int) { - if (x < (if (y > 115) 1 else 2)) { + if (x < (if (y > 115) 1 else 2)) { Unit } } diff --git a/compiler/testData/diagnostics/tests/typeArguments/allowTypeArgumentListLikeExpressions.kt b/compiler/testData/diagnostics/tests/typeArguments/allowTypeArgumentListLikeExpressions.kt new file mode 100644 index 00000000000..9c029ba7c1c --- /dev/null +++ b/compiler/testData/diagnostics/tests/typeArguments/allowTypeArgumentListLikeExpressions.kt @@ -0,0 +1,22 @@ +// FIR_IDENTICAL +// !LANGUAGE: +AllowTypeArgumentListLikeExpressions +// ISSUE: KT-8263 + +fun f(x: Int, y: Int, z: () -> Any, a: (Boolean, Boolean) -> Unit, b: (Any?) -> Unit) { + a(x < -1, (-3) > 3) + a(x < (-1), -3 > 3) + a(x < (-1), (-3) > 3) + a(x < y, -3 > 3) + a(x < y, x > 2) + + b(x < if (y > (0)) y else 0) + b(x < (if (y > (0)) y else 0)) + b(x < when (y > (0)) { else -> 0 }) + b(x < (when (y > (0)) { else -> 0 })) + + b(z() as Int < 15) + b(z() as Int < y) + b(z() is Int < true) + b(z() !is Int < true) + b(z() !is Int < true > false) +} diff --git a/compiler/testData/diagnostics/tests/typeArguments/allowTypeArgumentListLikeExpressions.txt b/compiler/testData/diagnostics/tests/typeArguments/allowTypeArgumentListLikeExpressions.txt new file mode 100644 index 00000000000..3fcb4211ec5 --- /dev/null +++ b/compiler/testData/diagnostics/tests/typeArguments/allowTypeArgumentListLikeExpressions.txt @@ -0,0 +1,4 @@ +package + +public fun f(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int, /*2*/ z: () -> kotlin.Any, /*3*/ a: (kotlin.Boolean, kotlin.Boolean) -> kotlin.Unit, /*4*/ b: (kotlin.Any?) -> kotlin.Unit): kotlin.Unit + diff --git a/compiler/testData/diagnostics/tests/typeArguments/forbidTypeArgumentListLikeExpressions.fir.kt b/compiler/testData/diagnostics/tests/typeArguments/forbidTypeArgumentListLikeExpressions.fir.kt new file mode 100644 index 00000000000..cea14e9e607 --- /dev/null +++ b/compiler/testData/diagnostics/tests/typeArguments/forbidTypeArgumentListLikeExpressions.fir.kt @@ -0,0 +1,21 @@ +// !LANGUAGE: -AllowTypeArgumentListLikeExpressions +// ISSUE: KT-8263 + +fun f(x: Int, y: Int, z: () -> Any, a: (Boolean, Boolean) -> Unit, b: (Any?) -> Unit) { + a(x < -1, (-3) > 3) + a(x < (-1), -3 > 3) + a(x < (-1), (-3) > 3) + a(x < y, -3 > 3) + a(x < y, x > 2) + + b(x < if (y > (0)) y else 0) + b(x < (if (y > (0)) y else 0)) + b(x < when (y > (0)) { else -> 0 }) + b(x < (when (y > (0)) { else -> 0 })) + + b(z() as Int < 15) + b(z() as Int < y) + b(z() is Int < true) + b(z() !is Int < true) + b(z() !is Int < true > false) +} \ No newline at end of file diff --git a/compiler/testData/diagnostics/tests/typeArguments/forbidTypeArgumentListLikeExpressions.kt b/compiler/testData/diagnostics/tests/typeArguments/forbidTypeArgumentListLikeExpressions.kt new file mode 100644 index 00000000000..0b8a87f506d --- /dev/null +++ b/compiler/testData/diagnostics/tests/typeArguments/forbidTypeArgumentListLikeExpressions.kt @@ -0,0 +1,21 @@ +// !LANGUAGE: -AllowTypeArgumentListLikeExpressions +// ISSUE: KT-8263 + +fun f(x: Int, y: Int, z: () -> Any, a: (Boolean, Boolean) -> Unit, b: (Any?) -> Unit) { + a(x < -1, (-3) > 3) + a(x < (-1), -3 > 3) + a(x < (-1), (-3) > 3) + a(x < y, -3 > 3) + a(x < y, x > 2) + + b(x < if (y > (0)) y else 0) + b(x < (if (y > (0)) y else 0)) + b(x < when (y > (0)) { else -> 0 }) + b(x < (when (y > (0)) { else -> 0 })) + + b(z() as Int < 15) + b(z() as Int < y) + b(z() is Int < true) + b(z() !is Int < true) + b(z() !is Int < true > false) +} diff --git a/compiler/testData/diagnostics/tests/typeArguments/forbidTypeArgumentListLikeExpressions.txt b/compiler/testData/diagnostics/tests/typeArguments/forbidTypeArgumentListLikeExpressions.txt new file mode 100644 index 00000000000..3fcb4211ec5 --- /dev/null +++ b/compiler/testData/diagnostics/tests/typeArguments/forbidTypeArgumentListLikeExpressions.txt @@ -0,0 +1,4 @@ +package + +public fun f(/*0*/ x: kotlin.Int, /*1*/ y: kotlin.Int, /*2*/ z: () -> kotlin.Any, /*3*/ a: (kotlin.Boolean, kotlin.Boolean) -> kotlin.Unit, /*4*/ b: (kotlin.Any?) -> kotlin.Unit): kotlin.Unit + diff --git a/compiler/testData/psi/DoubleColon_ERR.txt b/compiler/testData/psi/DoubleColon_ERR.txt index ed39825be88..0c1b7854d0d 100644 --- a/compiler/testData/psi/DoubleColon_ERR.txt +++ b/compiler/testData/psi/DoubleColon_ERR.txt @@ -159,37 +159,39 @@ KtFile: DoubleColon_ERR.kt REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('a') PsiErrorElement:Type arguments are not allowed - PsiElement(LT)('<') - TYPE_PROJECTION - TYPE_REFERENCE - USER_TYPE - REFERENCE_EXPRESSION - PsiElement(IDENTIFIER)('b') - PsiElement(GT)('>') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('b') + PsiElement(GT)('>') PsiWhiteSpace('\n ') CALLABLE_REFERENCE_EXPRESSION PsiElement(COLONCOLON)('::') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('a') PsiErrorElement:Type arguments are not allowed - PsiElement(LT)('<') - TYPE_PROJECTION - TYPE_REFERENCE - USER_TYPE - REFERENCE_EXPRESSION - PsiElement(IDENTIFIER)('b') - PsiElement(COMMA)(',') - TYPE_PROJECTION - TYPE_REFERENCE - USER_TYPE - REFERENCE_EXPRESSION - PsiElement(IDENTIFIER)('c') - TYPE_ARGUMENT_LIST - PsiElement(LT)('<') - TYPE_PROJECTION - PsiElement(MUL)('*') - PsiElement(GT)('>') - PsiElement(GT)('>') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('b') + PsiElement(COMMA)(',') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('c') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + PsiElement(MUL)('*') + PsiElement(GT)('>') + PsiElement(GT)('>') PsiWhiteSpace('\n ') CALLABLE_REFERENCE_EXPRESSION REFERENCE_EXPRESSION @@ -198,26 +200,28 @@ KtFile: DoubleColon_ERR.kt REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('b') PsiErrorElement:Type arguments are not allowed - PsiElement(LT)('<') - TYPE_PROJECTION - TYPE_REFERENCE - USER_TYPE - REFERENCE_EXPRESSION - PsiElement(IDENTIFIER)('c') - PsiElement(GT)('>') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('c') + PsiElement(GT)('>') PsiWhiteSpace('\n\n ') CALLABLE_REFERENCE_EXPRESSION PsiElement(COLONCOLON)('::') REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('a') PsiErrorElement:Type arguments are not allowed - PsiElement(LT)('<') - TYPE_PROJECTION - TYPE_REFERENCE - USER_TYPE - REFERENCE_EXPRESSION - PsiElement(IDENTIFIER)('b') - PsiElement(GT)('>') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('b') + PsiElement(GT)('>') PsiErrorElement:This syntax is reserved for future use; to call a reference, enclose it in parentheses: (foo::bar)(args) VALUE_ARGUMENT_LIST PsiElement(LPAR)('(') diff --git a/compiler/testData/psi/TypeExpressionAmbiguities_ERR.txt b/compiler/testData/psi/TypeExpressionAmbiguities_ERR.txt index 3ff766de449..5f751678e55 100644 --- a/compiler/testData/psi/TypeExpressionAmbiguities_ERR.txt +++ b/compiler/testData/psi/TypeExpressionAmbiguities_ERR.txt @@ -299,50 +299,46 @@ KtFile: TypeExpressionAmbiguities_ERR.kt PsiWhiteSpace(' ') PsiElement(IDENTIFIER)('c') PsiWhiteSpace('\n ') - BINARY_WITH_TYPE - REFERENCE_EXPRESSION - PsiElement(IDENTIFIER)('d') - PsiWhiteSpace(' ') - OPERATION_REFERENCE - PsiElement(as)('as') - PsiWhiteSpace(' ') - TYPE_REFERENCE - USER_TYPE - REFERENCE_EXPRESSION - PsiElement(IDENTIFIER)('Foo') - PsiWhiteSpace(' ') - TYPE_ARGUMENT_LIST - PsiElement(LT)('<') + BINARY_EXPRESSION + BINARY_WITH_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('d') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(as)('as') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Foo') PsiWhiteSpace(' ') - TYPE_PROJECTION - TYPE_REFERENCE - USER_TYPE - REFERENCE_EXPRESSION - PsiElement(IDENTIFIER)('bar') - PsiErrorElement:Expecting a '>' + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('bar') PsiWhiteSpace('\n ') - IS_EXPRESSION - REFERENCE_EXPRESSION - PsiElement(IDENTIFIER)('x') - PsiWhiteSpace(' ') - OPERATION_REFERENCE - PsiElement(is)('is') - PsiWhiteSpace(' ') - TYPE_REFERENCE - USER_TYPE - REFERENCE_EXPRESSION - PsiElement(IDENTIFIER)('Foo') - PsiWhiteSpace(' ') - TYPE_ARGUMENT_LIST - PsiElement(LT)('<') + BINARY_EXPRESSION + IS_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(is)('is') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Foo') PsiWhiteSpace(' ') - TYPE_PROJECTION - TYPE_REFERENCE - USER_TYPE - REFERENCE_EXPRESSION - PsiElement(IDENTIFIER)('bar') - PsiErrorElement:Expecting a '>' + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('bar') PsiWhiteSpace('\n') PsiElement(RBRACE)('}') \ No newline at end of file diff --git a/compiler/testData/psi/complicateLTGT.txt b/compiler/testData/psi/complicateLTGT.txt index cbeb21e8477..3d445cb4bf5 100644 --- a/compiler/testData/psi/complicateLTGT.txt +++ b/compiler/testData/psi/complicateLTGT.txt @@ -37,57 +37,48 @@ KtFile: complicateLTGT.kt PsiWhiteSpace(' ') PsiElement(LPAR)('(') CONDITION - CALL_EXPRESSION + BINARY_EXPRESSION REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('x') PsiWhiteSpace(' ') - TYPE_ARGUMENT_LIST + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE PsiElement(LT)('<') - PsiWhiteSpace(' ') - TYPE_PROJECTION - TYPE_REFERENCE - FUNCTION_TYPE - VALUE_PARAMETER_LIST - PsiElement(LPAR)('(') - VALUE_PARAMETER - TYPE_REFERENCE - PsiErrorElement:Type expected - PsiElement(if)('if') - PsiErrorElement:Expecting comma or ')' - - PsiWhiteSpace(' ') - PsiErrorElement:Expecting ')' - PsiElement(LPAR)('(') - PsiErrorElement:Expecting '->' to specify return type of a function type - - TYPE_REFERENCE - USER_TYPE - REFERENCE_EXPRESSION - PsiElement(IDENTIFIER)('y') - PsiWhiteSpace(' ') - PsiElement(GT)('>') - PsiErrorElement:Expecting ') - + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + IF + PsiElement(if)('if') + PsiWhiteSpace(' ') + PsiElement(LPAR)('(') + CONDITION + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('115') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + THEN + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiWhiteSpace(' ') + PsiElement(else)('else') + PsiWhiteSpace(' ') + ELSE + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('2') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') PsiWhiteSpace(' ') THEN - INTEGER_CONSTANT - PsiElement(INTEGER_LITERAL)('115') - PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line) - PsiElement(RPAR)(')') - PsiWhiteSpace(' ') - PsiElement(INTEGER_LITERAL)('1') - PsiWhiteSpace(' ') - PsiElement(else)('else') - PsiWhiteSpace(' ') - PsiElement(INTEGER_LITERAL)('2') - PsiElement(RPAR)(')') - PsiElement(RPAR)(')') - PsiWhiteSpace(' ') - LAMBDA_EXPRESSION - FUNCTION_LITERAL - PsiElement(LBRACE)('{') BLOCK - - PsiElement(RBRACE)('}') + PsiElement(LBRACE)('{') + PsiElement(RBRACE)('}') PsiWhiteSpace('\n') PsiElement(RBRACE)('}') \ No newline at end of file diff --git a/compiler/testData/psi/complicateLTGTE.txt b/compiler/testData/psi/complicateLTGTE.txt index 61b65e92678..b8c3f56615b 100644 --- a/compiler/testData/psi/complicateLTGTE.txt +++ b/compiler/testData/psi/complicateLTGTE.txt @@ -41,6 +41,8 @@ KtFile: complicateLTGTE.kt REFERENCE_EXPRESSION PsiElement(IDENTIFIER)('x') PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + OPERATION_REFERENCE PsiElement(LT)('<') PsiWhiteSpace(' ') diff --git a/compiler/testData/psi/typeArgumentList/correctness/binaryExpressionsInFunctionCall.kt b/compiler/testData/psi/typeArgumentList/correctness/binaryExpressionsInFunctionCall.kt new file mode 100644 index 00000000000..97f804eef07 --- /dev/null +++ b/compiler/testData/psi/typeArgumentList/correctness/binaryExpressionsInFunctionCall.kt @@ -0,0 +1,40 @@ +fun f() { + a(x < 1, 2 > 3) + a(x < 0x32, (9f) > 3) + a(x < (2.0), 2 > 3) + a(x < (-1), (-3) > 3) + a(x < y > false) + + a(x < "", 2 > (3)) + a(x < y, false > { 3 }) + a(x < (1), 2 > (3)) + a(x < (1), (2) > { 3 }) + a(x < (y + z), z > (3)) + a(x < y, z - w > { 10 }) + a(x < y++, z > { 7 }) + a(x < y, -z > (1)) + a(x < y + 1 > (0)) + a(x < (y + 1) > (false)) + a(x < (y++) > (false)) + a(x < y!! > (false)) + a(x < (y!!) > (false)) + a(x < (if (z > (y)) 1 else 0)) + a(x < (when (z > (y)) { else -> 5 })) + a(x < y && z > (0)) + a(x < y || z > { 3.141 }) + + a(x as Int < 1) + a(x as Int < y) + a(x as Int < 3 > false) + a(x as? Int < 10) + a(x as? Int < y) + a(x as? Int < 0.3 > "false") + a(x is Int < 100L) + a(x is Int < y) + a(x is Int < true > z) + a(x !is Int < 1000.0) + a(x !is Int < y) + a(x !is Int < 0b110 > 'c') + a(x !is Int < (if (z > (y)) 1 else 0)) + a(x as Int < (when (z > (y)) { else -> 5 })) +} diff --git a/compiler/testData/psi/typeArgumentList/correctness/binaryExpressionsInFunctionCall.txt b/compiler/testData/psi/typeArgumentList/correctness/binaryExpressionsInFunctionCall.txt new file mode 100644 index 00000000000..eb8cbcb2a56 --- /dev/null +++ b/compiler/testData/psi/typeArgumentList/correctness/binaryExpressionsInFunctionCall.txt @@ -0,0 +1,1308 @@ +KtFile: binaryExpressionsInFunctionCall.kt + PACKAGE_DIRECTIVE + + IMPORT_LIST + + FUN + PsiElement(fun)('fun') + PsiWhiteSpace(' ') + PsiElement(IDENTIFIER)('f') + VALUE_PARAMETER_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + BLOCK + PsiElement(LBRACE)('{') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + VALUE_ARGUMENT + BINARY_EXPRESSION + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('2') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('3') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0x32') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + VALUE_ARGUMENT + BINARY_EXPRESSION + PARENTHESIZED + PsiElement(LPAR)('(') + FLOAT_CONSTANT + PsiElement(FLOAT_CONSTANT)('9f') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('3') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + FLOAT_CONSTANT + PsiElement(FLOAT_CONSTANT)('2.0') + PsiElement(RPAR)(')') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + VALUE_ARGUMENT + BINARY_EXPRESSION + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('2') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('3') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + PREFIX_EXPRESSION + OPERATION_REFERENCE + PsiElement(MINUS)('-') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiElement(RPAR)(')') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + VALUE_ARGUMENT + BINARY_EXPRESSION + PARENTHESIZED + PsiElement(LPAR)('(') + PREFIX_EXPRESSION + OPERATION_REFERENCE + PsiElement(MINUS)('-') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('3') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('3') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + BOOLEAN_CONSTANT + PsiElement(false)('false') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + STRING_TEMPLATE + PsiElement(OPEN_QUOTE)('"') + PsiElement(CLOSING_QUOTE)('"') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + VALUE_ARGUMENT + BINARY_EXPRESSION + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('2') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('3') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + VALUE_ARGUMENT + BINARY_EXPRESSION + BOOLEAN_CONSTANT + PsiElement(false)('false') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('3') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiElement(RPAR)(')') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + VALUE_ARGUMENT + BINARY_EXPRESSION + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('2') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('3') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiElement(RPAR)(')') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + VALUE_ARGUMENT + BINARY_EXPRESSION + PARENTHESIZED + PsiElement(LPAR)('(') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('2') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('3') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(PLUS)('+') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(RPAR)(')') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('3') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(MINUS)('-') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('w') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('10') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + POSTFIX_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + OPERATION_REFERENCE + PsiElement(PLUSPLUS)('++') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('7') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + VALUE_ARGUMENT + BINARY_EXPRESSION + PREFIX_EXPRESSION + OPERATION_REFERENCE + PsiElement(MINUS)('-') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(PLUS)('+') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(PLUS)('+') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + BOOLEAN_CONSTANT + PsiElement(false)('false') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + POSTFIX_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + OPERATION_REFERENCE + PsiElement(PLUSPLUS)('++') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + BOOLEAN_CONSTANT + PsiElement(false)('false') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + POSTFIX_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + OPERATION_REFERENCE + PsiElement(EXCLEXCL)('!!') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + BOOLEAN_CONSTANT + PsiElement(false)('false') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + POSTFIX_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + OPERATION_REFERENCE + PsiElement(EXCLEXCL)('!!') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + BOOLEAN_CONSTANT + PsiElement(false)('false') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + IF + PsiElement(if)('if') + PsiWhiteSpace(' ') + PsiElement(LPAR)('(') + CONDITION + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + THEN + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiWhiteSpace(' ') + PsiElement(else)('else') + PsiWhiteSpace(' ') + ELSE + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + WHEN + PsiElement(when)('when') + PsiWhiteSpace(' ') + PsiElement(LPAR)('(') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + WHEN_ENTRY + PsiElement(else)('else') + PsiWhiteSpace(' ') + PsiElement(ARROW)('->') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('5') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(ANDAND)('&&') + PsiWhiteSpace(' ') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(OROR)('||') + PsiWhiteSpace(' ') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + FLOAT_CONSTANT + PsiElement(FLOAT_CONSTANT)('3.141') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_WITH_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(as)('as') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_WITH_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(as)('as') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_EXPRESSION + BINARY_WITH_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(as)('as') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('3') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + BOOLEAN_CONSTANT + PsiElement(false)('false') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_WITH_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(AS_SAFE)('as?') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('10') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_WITH_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(AS_SAFE)('as?') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_EXPRESSION + BINARY_WITH_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(AS_SAFE)('as?') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + FLOAT_CONSTANT + PsiElement(FLOAT_CONSTANT)('0.3') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + STRING_TEMPLATE + PsiElement(OPEN_QUOTE)('"') + LITERAL_STRING_TEMPLATE_ENTRY + PsiElement(REGULAR_STRING_PART)('false') + PsiElement(CLOSING_QUOTE)('"') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + IS_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(is)('is') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('100L') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + IS_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(is)('is') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_EXPRESSION + IS_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(is)('is') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + BOOLEAN_CONSTANT + PsiElement(true)('true') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + IS_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(NOT_IS)('!is') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + FLOAT_CONSTANT + PsiElement(FLOAT_CONSTANT)('1000.0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + IS_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(NOT_IS)('!is') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_EXPRESSION + IS_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(NOT_IS)('!is') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0b110') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + CHARACTER_CONSTANT + PsiElement(CHARACTER_LITERAL)(''c'') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + IS_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(NOT_IS)('!is') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + IF + PsiElement(if)('if') + PsiWhiteSpace(' ') + PsiElement(LPAR)('(') + CONDITION + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + THEN + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiWhiteSpace(' ') + PsiElement(else)('else') + PsiWhiteSpace(' ') + ELSE + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_WITH_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(as)('as') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + PsiWhiteSpace(' ') + TYPE_ARGUMENT_LIST_LIKE_EXPRESSION + + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + WHEN + PsiElement(when)('when') + PsiWhiteSpace(' ') + PsiElement(LPAR)('(') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + PARENTHESIZED + PsiElement(LPAR)('(') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + WHEN_ENTRY + PsiElement(else)('else') + PsiWhiteSpace(' ') + PsiElement(ARROW)('->') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('5') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n') + PsiElement(RBRACE)('}') \ No newline at end of file diff --git a/compiler/testData/psi/typeArgumentList/correctness/callExpressionsAnyLHSAtomicExpression.kt b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsAnyLHSAtomicExpression.kt new file mode 100644 index 00000000000..00a76680eeb --- /dev/null +++ b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsAnyLHSAtomicExpression.kt @@ -0,0 +1,27 @@ +fun f() { + (x)(0) + x[](0) + this(0) + super(0) + this(0) + object : C{}(0) + throw(0) + return(0) + continue(0) + break(0) + if (x < 0) { 1 } else { 1 }(0) + when { else -> 1 }(0) + try { 1 } finally {}(0) + for (i in 0 until 10) {}(0) + while (true) {}(0) + do {} while (true)(0) + x(0); + { x }(0) + ""(0) + 1(0) + 0L(0) + 3.141(0) + 2.718f(0) + 0xF7E(0) + 0b101(0) +} diff --git a/compiler/testData/psi/typeArgumentList/correctness/callExpressionsAnyLHSAtomicExpression.txt b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsAnyLHSAtomicExpression.txt new file mode 100644 index 00000000000..73e857d47cb --- /dev/null +++ b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsAnyLHSAtomicExpression.txt @@ -0,0 +1,785 @@ +KtFile: callExpressionsAnyLHSAtomicExpression.kt + PACKAGE_DIRECTIVE + + IMPORT_LIST + + FUN + PsiElement(fun)('fun') + PsiWhiteSpace(' ') + PsiElement(IDENTIFIER)('f') + VALUE_PARAMETER_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + BLOCK + PsiElement(LBRACE)('{') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + PARENTHESIZED + PsiElement(LPAR)('(') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(RPAR)(')') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + ARRAY_ACCESS_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + INDICES + PsiElement(LBRACKET)('[') + PsiErrorElement:Expecting an index element + + PsiElement(RBRACKET)(']') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + THIS_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(this)('this') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + SUPER_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(super)('super') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + THIS_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(this)('this') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + OBJECT_LITERAL + OBJECT_DECLARATION + PsiElement(object)('object') + PsiWhiteSpace(' ') + PsiElement(COLON)(':') + PsiWhiteSpace(' ') + SUPER_TYPE_LIST + SUPER_TYPE_ENTRY + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('C') + CLASS_BODY + PsiElement(LBRACE)('{') + PsiElement(RBRACE)('}') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + THROW + PsiElement(throw)('throw') + PsiErrorElement:Expecting an expression + + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + RETURN + PsiElement(return)('return') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + CONTINUE + PsiElement(continue)('continue') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + BREAK + PsiElement(break)('break') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + IF + PsiElement(if)('if') + PsiWhiteSpace(' ') + PsiElement(LPAR)('(') + CONDITION + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(LT)('<') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + THEN + BLOCK + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + PsiWhiteSpace(' ') + PsiElement(else)('else') + PsiWhiteSpace(' ') + ELSE + BLOCK + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + WHEN + PsiElement(when)('when') + PsiWhiteSpace(' ') + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + WHEN_ENTRY + PsiElement(else)('else') + PsiWhiteSpace(' ') + PsiElement(ARROW)('->') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + TRY + PsiElement(try)('try') + PsiWhiteSpace(' ') + BLOCK + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + PsiWhiteSpace(' ') + FINALLY + PsiElement(finally)('finally') + PsiWhiteSpace(' ') + BLOCK + PsiElement(LBRACE)('{') + PsiElement(RBRACE)('}') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + FOR + PsiElement(for)('for') + PsiWhiteSpace(' ') + PsiElement(LPAR)('(') + VALUE_PARAMETER + PsiElement(IDENTIFIER)('i') + PsiWhiteSpace(' ') + PsiElement(in)('in') + PsiWhiteSpace(' ') + LOOP_RANGE + BINARY_EXPRESSION + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(IDENTIFIER)('until') + PsiWhiteSpace(' ') + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('10') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + BODY + BLOCK + PsiElement(LBRACE)('{') + PsiElement(RBRACE)('}') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + WHILE + PsiElement(while)('while') + PsiWhiteSpace(' ') + PsiElement(LPAR)('(') + CONDITION + BOOLEAN_CONSTANT + PsiElement(true)('true') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + BODY + BLOCK + PsiElement(LBRACE)('{') + PsiElement(RBRACE)('}') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + DO_WHILE + PsiElement(do)('do') + PsiWhiteSpace(' ') + BODY + BLOCK + PsiElement(LBRACE)('{') + PsiElement(RBRACE)('}') + PsiWhiteSpace(' ') + PsiElement(while)('while') + PsiWhiteSpace(' ') + PsiElement(LPAR)('(') + CONDITION + BOOLEAN_CONSTANT + PsiElement(true)('true') + PsiElement(RPAR)(')') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiElement(SEMICOLON)(';') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + STRING_TEMPLATE + PsiElement(OPEN_QUOTE)('"') + PsiElement(CLOSING_QUOTE)('"') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('1') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0L') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + FLOAT_CONSTANT + PsiElement(FLOAT_CONSTANT)('3.141') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + FLOAT_CONSTANT + PsiElement(FLOAT_CONSTANT)('2.718f') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0xF7E') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0b101') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n') + PsiElement(RBRACE)('}') \ No newline at end of file diff --git a/compiler/testData/psi/typeArgumentList/correctness/callExpressionsInFunctionCall.kt b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsInFunctionCall.kt new file mode 100644 index 00000000000..cb4c6d0da6e --- /dev/null +++ b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsInFunctionCall.kt @@ -0,0 +1,22 @@ +fun f() { + a(x(3)) + a(x { "" }) + a(x("")) + a(x { 7 }) + a(x<(y), z> { 1.011f }) + a(x(0x5F)) + a(x<(y), (z)>(0b1110)) + a(x { 7 }) + a(x(0)) + a(x<(v.x.z), v.y>('y')) + a(x<(v), (v.x.y.z)>("""word""")) + a(Array::class) + a(Array?::class) + + a(x as List) + a(x as? List) + a(x is List) + a(x !is List) + a(x as Int > false) + a(x as Int == z) +} diff --git a/compiler/testData/psi/typeArgumentList/correctness/callExpressionsInFunctionCall.txt b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsInFunctionCall.txt new file mode 100644 index 00000000000..6b1e765d139 --- /dev/null +++ b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsInFunctionCall.txt @@ -0,0 +1,664 @@ +KtFile: callExpressionsInFunctionCall.kt + PACKAGE_DIRECTIVE + + IMPORT_LIST + + FUN + PsiElement(fun)('fun') + PsiWhiteSpace(' ') + PsiElement(IDENTIFIER)('f') + VALUE_PARAMETER_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + BLOCK + PsiElement(LBRACE)('{') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('3') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_ARGUMENT + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + STRING_TEMPLATE + PsiElement(OPEN_QUOTE)('"') + PsiElement(CLOSING_QUOTE)('"') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + STRING_TEMPLATE + PsiElement(OPEN_QUOTE)('"') + PsiElement(CLOSING_QUOTE)('"') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_ARGUMENT + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('7') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiElement(LPAR)('(') + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(RPAR)(')') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_ARGUMENT + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + FLOAT_CONSTANT + PsiElement(FLOAT_CONSTANT)('1.011f') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + PsiElement(LPAR)('(') + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(RPAR)(')') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0x5F') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiElement(LPAR)('(') + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(RPAR)(')') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + PsiElement(LPAR)('(') + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(RPAR)(')') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0b1110') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('v') + PsiElement(DOT)('.') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('v') + PsiElement(DOT)('.') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_ARGUMENT + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('7') + PsiWhiteSpace(' ') + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('v') + PsiElement(DOT)('.') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + PsiElement(LPAR)('(') + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('v') + PsiElement(DOT)('.') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(RPAR)(')') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + INTEGER_CONSTANT + PsiElement(INTEGER_LITERAL)('0') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiElement(LPAR)('(') + USER_TYPE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('v') + PsiElement(DOT)('.') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(RPAR)(')') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('v') + PsiElement(DOT)('.') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CHARACTER_CONSTANT + PsiElement(CHARACTER_LITERAL)(''y'') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiElement(LPAR)('(') + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('v') + PsiElement(RPAR)(')') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + PsiElement(LPAR)('(') + USER_TYPE + USER_TYPE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('v') + PsiElement(DOT)('.') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(DOT)('.') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(RPAR)(')') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + STRING_TEMPLATE + PsiElement(OPEN_QUOTE)('"""') + LITERAL_STRING_TEMPLATE_ENTRY + PsiElement(REGULAR_STRING_PART)('word') + PsiElement(CLOSING_QUOTE)('"""') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CLASS_LITERAL_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Array') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('String') + PsiElement(GT)('>') + PsiElement(COLONCOLON)('::') + PsiElement(class)('class') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CLASS_LITERAL_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Array') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('String') + PsiElement(GT)('>') + PsiElement(QUEST)('?') + PsiElement(COLONCOLON)('::') + PsiElement(class)('class') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_WITH_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(as)('as') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('List') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('String') + PsiElement(GT)('>') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_WITH_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(AS_SAFE)('as?') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('List') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('String') + PsiElement(GT)('>') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + IS_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(is)('is') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('List') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('String') + PsiElement(GT)('>') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + IS_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(NOT_IS)('!is') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('List') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('String') + PsiElement(GT)('>') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_WITH_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(as)('as') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(GT)('>') + PsiWhiteSpace(' ') + BOOLEAN_CONSTANT + PsiElement(false)('false') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + BINARY_WITH_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(as)('as') + PsiWhiteSpace(' ') + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('Int') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(COMMA)(',') + PsiWhiteSpace(' ') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('y') + PsiElement(GT)('>') + PsiWhiteSpace(' ') + OPERATION_REFERENCE + PsiElement(EQEQ)('==') + PsiWhiteSpace(' ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('z') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n') + PsiElement(RBRACE)('}') \ No newline at end of file diff --git a/compiler/testData/psi/typeArgumentList/recovery/callExpressions.kt b/compiler/testData/psi/typeArgumentList/recovery/callExpressions.kt new file mode 100644 index 00000000000..377d68213b9 --- /dev/null +++ b/compiler/testData/psi/typeArgumentList/recovery/callExpressions.kt @@ -0,0 +1,24 @@ +fun f() { + call + call() + call { } + call:: + call[] + call? + call?. + call. + call++ + call-- + call!! + + a(call()) + a(call { }) + a(call::) + a(call[]) + a(call?) + a(call?.) + a(call.) + a(call++) + a(call--) + a(call!!) +} \ No newline at end of file diff --git a/compiler/testData/psi/typeArgumentList/recovery/callExpressions.txt b/compiler/testData/psi/typeArgumentList/recovery/callExpressions.txt new file mode 100644 index 00000000000..a34fd0d41f3 --- /dev/null +++ b/compiler/testData/psi/typeArgumentList/recovery/callExpressions.txt @@ -0,0 +1,417 @@ +KtFile: callExpressions.kt + PACKAGE_DIRECTIVE + + IMPORT_LIST + + FUN + PsiElement(fun)('fun') + PsiWhiteSpace(' ') + PsiElement(IDENTIFIER)('f') + VALUE_PARAMETER_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + BLOCK + PsiElement(LBRACE)('{') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_ARGUMENT + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + + PsiElement(RBRACE)('}') + PsiWhiteSpace('\n ') + ARRAY_ACCESS_EXPRESSION + CALLABLE_REFERENCE_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + PsiElement(COLONCOLON)('::') + PsiWhiteSpace('\n ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + PsiErrorElement:Type arguments are not allowed + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + INDICES + PsiElement(LBRACKET)('[') + PsiErrorElement:Expecting an index element + + PsiElement(RBRACKET)(']') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line) + PsiElement(QUEST)('?') + PsiWhiteSpace('\n ') + POSTFIX_EXPRESSION + DOT_QUALIFIED_EXPRESSION + SAFE_ACCESS_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + PsiElement(SAFE_ACCESS)('?.') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + PsiElement(DOT)('.') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(PLUSPLUS)('++') + PsiWhiteSpace('\n ') + POSTFIX_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(MINUSMINUS)('--') + PsiWhiteSpace('\n ') + POSTFIX_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(EXCLEXCL)('!!') + PsiWhiteSpace('\n\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_ARGUMENT + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALLABLE_REFERENCE_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + PsiElement(COLONCOLON)('::') + REFERENCE_EXPRESSION + PsiErrorElement:Expecting an identifier + + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + ARRAY_ACCESS_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + INDICES + PsiElement(LBRACKET)('[') + PsiErrorElement:Expecting an index element + + PsiElement(RBRACKET)(']') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + PsiErrorElement:Expecting ')' + PsiElement(QUEST)('?') + PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line) + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + SAFE_ACCESS_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + PsiElement(SAFE_ACCESS)('?.') + PsiErrorElement:Expecting an element + + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + DOT_QUALIFIED_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + POSTFIX_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(PLUSPLUS)('++') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + POSTFIX_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(MINUSMINUS)('--') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + POSTFIX_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(EXCLEXCL)('!!') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n') + PsiElement(RBRACE)('}') diff --git a/compiler/testData/psi/typeArgumentList/recovery/callExpressions_ERR.kt b/compiler/testData/psi/typeArgumentList/recovery/callExpressions_ERR.kt new file mode 100644 index 00000000000..04ff987e7f1 --- /dev/null +++ b/compiler/testData/psi/typeArgumentList/recovery/callExpressions_ERR.kt @@ -0,0 +1,45 @@ +fun f() { + call<> + call + call<>() + call() + call<> { } + call { } + call<>:: + call:: + call<>[] + call[] + call<>? + call? + call<>?. + call?. + call<>. + call. + call<>++ + call++ + call<>-- + call-- + call<>!! + call!! + + a(call<>()) + a(call()) + a(call<> { }) + a(call { }) + a(call<>::) + a(call::) + a(call<>[]) + a(call[]) + a(call<>?) + a(call?) + a(call<>?.) + a(call?.) + a(call<>.) + a(call.) + a(call<>++) + a(call++) + a(call<>--) + a(call--) + a(call<>!!) + a(call!!) +} \ No newline at end of file diff --git a/compiler/testData/psi/typeArgumentList/recovery/callExpressions_ERR.txt b/compiler/testData/psi/typeArgumentList/recovery/callExpressions_ERR.txt new file mode 100644 index 00000000000..6adf1b763a9 --- /dev/null +++ b/compiler/testData/psi/typeArgumentList/recovery/callExpressions_ERR.txt @@ -0,0 +1,800 @@ +KtFile: callExpressions_ERR.kt + PACKAGE_DIRECTIVE + + IMPORT_LIST + + FUN + PsiElement(fun)('fun') + PsiWhiteSpace(' ') + PsiElement(IDENTIFIER)('f') + VALUE_PARAMETER_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiWhiteSpace(' ') + BLOCK + PsiElement(LBRACE)('{') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + PsiWhiteSpace('\n ') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + CALL_EXPRESSION + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_ARGUMENT + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + + PsiElement(RBRACE)('}') + PsiWhiteSpace('\n ') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + CALL_EXPRESSION + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_ARGUMENT + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + + PsiElement(RBRACE)('}') + PsiWhiteSpace('\n ') + BINARY_EXPRESSION + CALLABLE_REFERENCE_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + PsiElement(COLONCOLON)('::') + PsiWhiteSpace('\n ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + ARRAY_ACCESS_EXPRESSION + CALLABLE_REFERENCE_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + PsiElement(COLONCOLON)('::') + PsiWhiteSpace('\n ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + PsiErrorElement:Type arguments are not allowed + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + INDICES + PsiElement(LBRACKET)('[') + PsiErrorElement:Expecting an index element + + PsiElement(RBRACKET)(']') + PsiWhiteSpace('\n ') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + ARRAY_ACCESS_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + INDICES + PsiElement(LBRACKET)('[') + PsiErrorElement:Expecting an index element + + PsiElement(RBRACKET)(']') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line) + PsiElement(QUEST)('?') + PsiWhiteSpace('\n ') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line) + PsiElement(QUEST)('?') + PsiWhiteSpace('\n ') + BINARY_EXPRESSION + BINARY_EXPRESSION + SAFE_ACCESS_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + PsiElement(SAFE_ACCESS)('?.') + PsiWhiteSpace('\n ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + DOT_QUALIFIED_EXPRESSION + SAFE_ACCESS_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + PsiElement(SAFE_ACCESS)('?.') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + PsiElement(DOT)('.') + PsiWhiteSpace('\n ') + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + POSTFIX_EXPRESSION + DOT_QUALIFIED_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + PsiElement(DOT)('.') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(PLUSPLUS)('++') + PsiWhiteSpace('\n ') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + POSTFIX_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(PLUSPLUS)('++') + PsiWhiteSpace('\n ') + POSTFIX_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(MINUSMINUS)('--') + PsiWhiteSpace('\n ') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + POSTFIX_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(MINUSMINUS)('--') + PsiWhiteSpace('\n ') + POSTFIX_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(EXCLEXCL)('!!') + PsiWhiteSpace('\n ') + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + POSTFIX_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(EXCLEXCL)('!!') + PsiWhiteSpace('\n\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + CALL_EXPRESSION + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + PsiElement(RPAR)(')') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_ARGUMENT + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + CALL_EXPRESSION + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + PsiWhiteSpace(' ') + LAMBDA_ARGUMENT + LAMBDA_EXPRESSION + FUNCTION_LITERAL + PsiElement(LBRACE)('{') + PsiWhiteSpace(' ') + BLOCK + + PsiElement(RBRACE)('}') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALLABLE_REFERENCE_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + PsiElement(COLONCOLON)('::') + REFERENCE_EXPRESSION + PsiErrorElement:Expecting an identifier + + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + CALLABLE_REFERENCE_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + PsiElement(COLONCOLON)('::') + REFERENCE_EXPRESSION + PsiErrorElement:Expecting an identifier + + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + ARRAY_ACCESS_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + INDICES + PsiElement(LBRACKET)('[') + PsiErrorElement:Expecting an index element + + PsiElement(RBRACKET)(']') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + ARRAY_ACCESS_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + INDICES + PsiElement(LBRACKET)('[') + PsiErrorElement:Expecting an index element + + PsiElement(RBRACKET)(']') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + PsiErrorElement:Expecting ')' + PsiElement(QUEST)('?') + PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line) + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + PsiErrorElement:Expecting ')' + PsiElement(QUEST)('?') + PsiErrorElement:Unexpected tokens (use ';' to separate expressions on the same line) + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + SAFE_ACCESS_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + PsiElement(SAFE_ACCESS)('?.') + PsiErrorElement:Expecting an element + + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + SAFE_ACCESS_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + PsiElement(SAFE_ACCESS)('?.') + PsiErrorElement:Expecting an element + + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + DOT_QUALIFIED_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + DOT_QUALIFIED_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + POSTFIX_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(PLUSPLUS)('++') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + POSTFIX_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(PLUSPLUS)('++') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + POSTFIX_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(MINUSMINUS)('--') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + POSTFIX_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(MINUSMINUS)('--') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + POSTFIX_EXPRESSION + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + TYPE_ARGUMENT_LIST + PsiElement(LT)('<') + TYPE_PROJECTION + TYPE_REFERENCE + PsiErrorElement:Type expected + + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(EXCLEXCL)('!!') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n ') + CALL_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('a') + VALUE_ARGUMENT_LIST + PsiElement(LPAR)('(') + VALUE_ARGUMENT + BINARY_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('call') + OPERATION_REFERENCE + PsiElement(LT)('<') + POSTFIX_EXPRESSION + DOT_QUALIFIED_EXPRESSION + REFERENCE_EXPRESSION + PsiElement(IDENTIFIER)('x') + PsiElement(DOT)('.') + PsiErrorElement:Expecting an element + PsiElement(GT)('>') + OPERATION_REFERENCE + PsiElement(EXCLEXCL)('!!') + PsiElement(RPAR)(')') + PsiWhiteSpace('\n') + PsiElement(RBRACE)('}') diff --git a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java index 52106c6a5f2..452551985ab 100644 --- a/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java +++ b/compiler/tests-common-new/tests-gen/org/jetbrains/kotlin/test/runners/DiagnosticTestGenerated.java @@ -32239,6 +32239,28 @@ public class DiagnosticTestGenerated extends AbstractDiagnosticTest { } } + @Nested + @TestMetadata("compiler/testData/diagnostics/tests/typeArguments") + @TestDataPath("$PROJECT_ROOT") + public class TypeArguments { + @Test + public void testAllFilesPresentInTypeArguments() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/diagnostics/tests/typeArguments"), Pattern.compile("^(.*)\\.kts?$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true); + } + + @Test + @TestMetadata("allowTypeArgumentListLikeExpressions.kt") + public void testAllowTypeArgumentListLikeExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeArguments/allowTypeArgumentListLikeExpressions.kt"); + } + + @Test + @TestMetadata("forbidTypeArgumentListLikeExpressions.kt") + public void testForbidTypeArgumentListLikeExpressions() throws Exception { + runTest("compiler/testData/diagnostics/tests/typeArguments/forbidTypeArgumentListLikeExpressions.kt"); + } + } + @Nested @TestMetadata("compiler/testData/diagnostics/tests/typeParameters") @TestDataPath("$PROJECT_ROOT") diff --git a/compiler/tests-gen/org/jetbrains/kotlin/parsing/ParsingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/parsing/ParsingTestGenerated.java index 69faed2b17e..835334b9744 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/parsing/ParsingTestGenerated.java +++ b/compiler/tests-gen/org/jetbrains/kotlin/parsing/ParsingTestGenerated.java @@ -2908,6 +2908,70 @@ public class ParsingTestGenerated extends AbstractParsingTest { runTest("compiler/testData/psi/stringTemplates/StringTemplateWithTryWithoutBlockInShortEntry.kt"); } } + + @TestMetadata("compiler/testData/psi/typeArgumentList") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class TypeArgumentList extends AbstractParsingTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath); + } + + public void testAllFilesPresentInTypeArgumentList() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/typeArgumentList"), Pattern.compile("^(.*)\\.kts?$"), null, true); + } + + @TestMetadata("compiler/testData/psi/typeArgumentList/correctness") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Correctness extends AbstractParsingTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath); + } + + public void testAllFilesPresentInCorrectness() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/typeArgumentList/correctness"), Pattern.compile("^(.*)\\.kts?$"), null, true); + } + + @TestMetadata("binaryExpressionsInFunctionCall.kt") + public void testBinaryExpressionsInFunctionCall() throws Exception { + runTest("compiler/testData/psi/typeArgumentList/correctness/binaryExpressionsInFunctionCall.kt"); + } + + @TestMetadata("callExpressionsAnyLHSAtomicExpression.kt") + public void testCallExpressionsAnyLHSAtomicExpression() throws Exception { + runTest("compiler/testData/psi/typeArgumentList/correctness/callExpressionsAnyLHSAtomicExpression.kt"); + } + + @TestMetadata("callExpressionsInFunctionCall.kt") + public void testCallExpressionsInFunctionCall() throws Exception { + runTest("compiler/testData/psi/typeArgumentList/correctness/callExpressionsInFunctionCall.kt"); + } + } + + @TestMetadata("compiler/testData/psi/typeArgumentList/recovery") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class Recovery extends AbstractParsingTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doParsingTest, this, testDataFilePath); + } + + public void testAllFilesPresentInRecovery() throws Exception { + KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/testData/psi/typeArgumentList/recovery"), Pattern.compile("^(.*)\\.kts?$"), null, true); + } + + @TestMetadata("callExpressions.kt") + public void testCallExpressions() throws Exception { + runTest("compiler/testData/psi/typeArgumentList/recovery/callExpressions.kt"); + } + + @TestMetadata("callExpressions_ERR.kt") + public void testCallExpressions_ERR() throws Exception { + runTest("compiler/testData/psi/typeArgumentList/recovery/callExpressions_ERR.kt"); + } + } + } } @TestMetadata("compiler/testData/parseCodeFragment/expression") diff --git a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt index 6754cd04d2e..a9f2d351ed8 100644 --- a/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt +++ b/compiler/util/src/org/jetbrains/kotlin/config/LanguageVersionSettings.kt @@ -265,6 +265,7 @@ enum class LanguageFeature( DataObjects(KOTLIN_1_8), // KT-4107 LightweightLambdas(KOTLIN_1_8, defaultState = State.DISABLED), AllowExpressionAfterTypeReferenceWithoutSpacing(KOTLIN_1_8, kind = BUG_FIX), // KT-35811 + AllowTypeArgumentListLikeExpressions(KOTLIN_1_8, kind = BUG_FIX), // KT-8263 // 1.9