KT-8263: Conditional operators are not parsed correctly
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 1ecc29b..d85c1e3 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
@@ -32150,6 +32150,28 @@
}
@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")
public class TypeParameters {
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 b35843a..277a3d1 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
@@ -32150,6 +32150,28 @@
}
@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")
public class TypeParameters {
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 3669397..665ad8d 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
@@ -32150,6 +32150,28 @@
}
@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")
public class TypeParameters {
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/kotlin/diagnostics/Errors.java
index d489c85..2ef6afd 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 @@
DiagnosticFactoryForDeprecation1<PsiElement, CallableDescriptor> PROGRESSIONS_CHANGING_RESOLVE = DiagnosticFactoryForDeprecation1.create(LanguageFeature.ProgressionsChangingResolve);
DiagnosticFactory0<PsiElement> EXPRESSION_AFTER_TYPE_REFERENCE_WITHOUT_SPACING_NOT_ALLOWED = DiagnosticFactory0.create(ERROR);
+ DiagnosticFactory0<PsiElement> 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 90f906e..dd3ca33 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 @@
"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 8d1fcf4..92817d8 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 @@
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 0000000..67da88b
--- /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 3705c99..48c1485 100644
--- a/compiler/psi/src/org/jetbrains/kotlin/KtNodeTypes.java
+++ b/compiler/psi/src/org/jetbrains/kotlin/KtNodeTypes.java
@@ -149,6 +149,8 @@
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 931b5aa..94df92a 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.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 @@
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<bar, baz>=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 @@
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 @@
@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 @@
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 @@
}
}
- 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 @@
/*
* 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 @@
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 @@
error("Expecting a type");
}
else {
- myKotlinParsing.parseTypeRef();
+ myKotlinParsing.parseTypeRef(/* partOfExpression */ false);
}
condition.done(WHEN_CONDITION_IS_PATTERN);
break;
@@ -1271,7 +1393,7 @@
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 @@
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 @@
}
/*
- * "this" ("<" type ">")? label?
+ * "super" ("<" type ">")? label?
*/
private void parseSuperExpression() {
assert _at(SUPER_KEYWORD);
@@ -1830,7 +1952,7 @@
myBuilder.disableNewlines();
advance(); // LT
- myKotlinParsing.parseTypeRef();
+ myKotlinParsing.parseTypeRef(/* partOfExpression */ false);
if (at(GT)) {
advance(); // GT
@@ -1888,6 +2010,10 @@
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 1bf9760..b5655b7 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 @@
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 @@
void parseTypeCodeFragment() {
PsiBuilder.Marker marker = mark();
- parseTypeRef();
+ parseTypeRef(/* partOfExpression */ false);
checkForUnexpectedSymbols();
@@ -714,7 +729,7 @@
if (myExpressionParsing.isAtLabelDefinitionOrMissingIdentifier()) {
myExpressionParsing.parseLabelDefinition();
}
- parseTypeRef();
+ parseTypeRef(/* partOfExpression */ false);
contextReceiver.done(CONTEXT_RECEIVER);
}
@@ -939,11 +954,11 @@
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 @@
expect(EQ, "Expecting '='", TOP_LEVEL_DECLARATION_FIRST_SEMICOLON_SET);
- parseTypeRef();
+ parseTypeRef(/* partOfExpression */ false);
consumeIf(SEMICOLON);
@@ -1497,7 +1512,7 @@
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 @@
if (at(COLON)) {
advance(); // COLON
- parseTypeRef(follow);
+ parseTypeRef(follow, /* partOfExpression */ false);
}
property.done(DESTRUCTURING_DECLARATION_ENTRY);
@@ -1694,7 +1709,7 @@
if (at(COLON)) {
advance(); // COLON
- parseTypeRef();
+ parseTypeRef(/* partOfExpression */ false);
}
setterParameter.done(VALUE_PARAMETER);
if (at(COMMA)) {
@@ -1714,7 +1729,7 @@
if (at(COLON)) {
advance();
- parseTypeRef();
+ parseTypeRef(/* partOfExpression */ false);
}
if (propertyComponentKind != PropertyComponentKind.FIELD) {
@@ -1808,7 +1823,7 @@
if (at(COLON)) {
advance(); // COLON
- parseTypeRef();
+ parseTypeRef(/* partOfExpression */ false);
}
boolean functionContractOccurred = parseFunctionContract();
@@ -1851,7 +1866,7 @@
if (!receiverPresent) return false;
- createTruncatedBuilder(lastDot).parseTypeRefWithoutIntersections();
+ createTruncatedBuilder(lastDot).parseTypeRefWithoutIntersections(/* partOfExpression */ false);
if (atSet(RECEIVER_TYPE_TERMINATORS)) {
advance(); // expectation
@@ -1992,7 +2007,7 @@
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 @@
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 @@
if (at(COLON)) {
advance(); // COLON
- parseTypeRef();
+ parseTypeRef(/* partOfExpression */ false);
}
mark.done(TYPE_PARAMETER);
@@ -2158,26 +2173,30 @@
* : 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<x, 1, y>(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 @@
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 @@
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 @@
* - (Mutable)List<Foo>!
* - Array<(out) Foo>!
*/
- private void parseUserType() {
+ private void parseUserType(boolean partOfExpression) {
PsiBuilder.Marker userType = mark();
if (at(PACKAGE_KEYWORD)) {
@@ -2340,7 +2359,7 @@
break;
}
- parseTypeArgumentList();
+ parseTypeArgumentList(partOfExpression);
recoverOnPlatformTypeSuffix();
@@ -2410,20 +2429,72 @@
/*
* (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.
+ * <p>
+ * The returned value of the method indicates to what degree the parsed section can be considered a type
+ * argument list.
+ * <p>
+ * {@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:
+ * <ul>
+ * <li> the type argument list contains no syntax errors.
+ * <li> the type argument list is empty
+ * </ul>
+ * <p>
+ * {@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:
+ * <ul>
+ * <li> the sections contains syntax errors, but ends with a '>'
+ * </ul>
+ * <p>
+ * {@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 @@
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 @@
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 @@
if (!tryParseValueParameter(typeRequired)) {
PsiBuilder.Marker valueParameter = mark();
parseFunctionTypeValueParameterModifierList();
- parseTypeRef();
+ parseTypeRef(/* partOfExpression */ false);
closeDeclarationWithCommentBinders(valueParameter, VALUE_PARAMETER, false);
}
}
@@ -2593,7 +2685,7 @@
else {
noErrors = false;
}
- parseTypeRef();
+ parseTypeRef(/* partOfExpression */ false);
}
else {
expect(IDENTIFIER, "Parameter name expected", PARAMETER_NAME_RECOVERY_SET);
@@ -2608,7 +2700,7 @@
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 64b05d6..1c6b644 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 @@
@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 55f2bc8..2a90b11 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 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 7ef5b63..287b41e 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 @@
}
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 7fe44c5..0000000
--- 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 (<!CONDITION_TYPE_MISMATCH!>x < (<!SYNTAX!>if<!><!SYNTAX!><!> <!SYNTAX!>(<!><!UNRESOLVED_REFERENCE!><!SYNTAX!><!>y<!> ><!><!SYNTAX!><!> 115<!SYNTAX!>) 1 else 2))<!> {
- Unit
- }
-}
diff --git a/compiler/testData/diagnostics/tests/syntax/complicatedLTGT.kt b/compiler/testData/diagnostics/tests/syntax/complicatedLTGT.kt
index 5ae6154..ec6ebc0 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 (<!UNRESOLVED_REFERENCE!>x<!> < (<!SYNTAX!>if<!><!SYNTAX!><!> <!SYNTAX!>(<!><!UNRESOLVED_REFERENCE!><!SYNTAX!><!>y<!> ><!SYNTAX!><!> 115<!SYNTAX!>) 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 0000000..9c029ba
--- /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 0000000..3fcb421
--- /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 0000000..cea14e9
--- /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 0000000..0b8a87f506
--- /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 <!TYPE_ARGUMENT_LIST_LIKE_EXPRESSION!><<!> (-1), (-3) > 3)
+ a(x < y, -3 > 3)
+ a(x <!TYPE_ARGUMENT_LIST_LIKE_EXPRESSION!><<!> y, x > 2)
+
+ b(x < if (y > (0)) y else 0)
+ b(x <!TYPE_ARGUMENT_LIST_LIKE_EXPRESSION!><<!> (if (y > (0)) y else 0))
+ b(x < when (y > (0)) { else -> 0 })
+ b(x <!TYPE_ARGUMENT_LIST_LIKE_EXPRESSION!><<!> (when (y > (0)) { else -> 0 }))
+
+ b(z() as Int <!TYPE_ARGUMENT_LIST_LIKE_EXPRESSION!><<!> 15)
+ b(z() as Int <!TYPE_ARGUMENT_LIST_LIKE_EXPRESSION!><<!> y)
+ b(z() is Int <!TYPE_ARGUMENT_LIST_LIKE_EXPRESSION!><<!> true)
+ b(z() !is Int <!TYPE_ARGUMENT_LIST_LIKE_EXPRESSION!><<!> true)
+ b(z() !is Int <!TYPE_ARGUMENT_LIST_LIKE_EXPRESSION!><<!> 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 0000000..3fcb421
--- /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 ed39825..0c1b785 100644
--- a/compiler/testData/psi/DoubleColon_ERR.txt
+++ b/compiler/testData/psi/DoubleColon_ERR.txt
@@ -159,37 +159,39 @@
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 @@
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 3ff766d..5f75167 100644
--- a/compiler/testData/psi/TypeExpressionAmbiguities_ERR.txt
+++ b/compiler/testData/psi/TypeExpressionAmbiguities_ERR.txt
@@ -299,50 +299,46 @@
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
<empty list>
+ 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
<empty list>
+ 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 cbeb21e..3d445cb 100644
--- a/compiler/testData/psi/complicateLTGT.txt
+++ b/compiler/testData/psi/complicateLTGT.txt
@@ -37,57 +37,48 @@
PsiWhiteSpace(' ')
PsiElement(LPAR)('(')
CONDITION
- CALL_EXPRESSION
+ BINARY_EXPRESSION
REFERENCE_EXPRESSION
PsiElement(IDENTIFIER)('x')
PsiWhiteSpace(' ')
- TYPE_ARGUMENT_LIST
+ TYPE_ARGUMENT_LIST_LIKE_EXPRESSION
+ <empty list>
+ 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 ')'
- <empty list>
- PsiWhiteSpace(' ')
- PsiErrorElement:Expecting ')'
- PsiElement(LPAR)('(')
- PsiErrorElement:Expecting '->' to specify return type of a function type
- <empty list>
- TYPE_REFERENCE
- USER_TYPE
- REFERENCE_EXPRESSION
- PsiElement(IDENTIFIER)('y')
- PsiWhiteSpace(' ')
- PsiElement(GT)('>')
- PsiErrorElement:Expecting ')
- <empty list>
+ 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
- <empty list>
- 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 61b65e9..b8c3f56 100644
--- a/compiler/testData/psi/complicateLTGTE.txt
+++ b/compiler/testData/psi/complicateLTGTE.txt
@@ -41,6 +41,8 @@
REFERENCE_EXPRESSION
PsiElement(IDENTIFIER)('x')
PsiWhiteSpace(' ')
+ TYPE_ARGUMENT_LIST_LIKE_EXPRESSION
+ <empty list>
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 0000000..97f804e
--- /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 0000000..eb8cbcb
--- /dev/null
+++ b/compiler/testData/psi/typeArgumentList/correctness/binaryExpressionsInFunctionCall.txt
@@ -0,0 +1,1308 @@
+KtFile: binaryExpressionsInFunctionCall.kt
+ PACKAGE_DIRECTIVE
+ <empty list>
+ IMPORT_LIST
+ <empty 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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 0000000..00a7668
--- /dev/null
+++ b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsAnyLHSAtomicExpression.kt
@@ -0,0 +1,27 @@
+fun f() {
+ (x)<y, z>(0)
+ x[]<y, z>(0)
+ this<y, z>(0)
+ super<y, z>(0)
+ this<y, z>(0)
+ object : C{}<y, z>(0)
+ throw<y, z>(0)
+ return<y, z>(0)
+ continue<y, z>(0)
+ break<y, z>(0)
+ if (x < 0) { 1 } else { 1 }<y, z>(0)
+ when { else -> 1 }<y, z>(0)
+ try { 1 } finally {}<y, z>(0)
+ for (i in 0 until 10) {}<y, z>(0)
+ while (true) {}<y, z>(0)
+ do {} while (true)<y, z>(0)
+ x<y, z>(0);
+ { x }<y, z>(0)
+ ""<y, z>(0)
+ 1<y, z>(0)
+ 0L<y, z>(0)
+ 3.141<y, z>(0)
+ 2.718f<y, z>(0)
+ 0xF7E<y, z>(0)
+ 0b101<y, z>(0)
+}
diff --git a/compiler/testData/psi/typeArgumentList/correctness/callExpressionsAnyLHSAtomicExpression.txt b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsAnyLHSAtomicExpression.txt
new file mode 100644
index 0000000..73e857d
--- /dev/null
+++ b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsAnyLHSAtomicExpression.txt
@@ -0,0 +1,785 @@
+KtFile: callExpressionsAnyLHSAtomicExpression.kt
+ PACKAGE_DIRECTIVE
+ <empty list>
+ IMPORT_LIST
+ <empty 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
+ <empty list>
+ 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
+ <empty list>
+ 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 0000000..cb4c6d0
--- /dev/null
+++ b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsInFunctionCall.kt
@@ -0,0 +1,22 @@
+fun f() {
+ a(x<y>(3))
+ a(x<y> { "" })
+ a(x<y, z>(""))
+ a(x<y, z> { 7 })
+ a(x<(y), z> { 1.011f })
+ a(x<y, (z)>(0x5F))
+ a(x<(y), (z)>(0b1110))
+ a(x<v.x, v.y> { 7 })
+ a(x<v.x, (v.y)>(0))
+ a(x<(v.x.z), v.y>('y'))
+ a(x<(v), (v.x.y.z)>("""word"""))
+ a(Array<String>::class)
+ a(Array<String>?::class)
+
+ a(x as List<String>)
+ a(x as? List<String>)
+ a(x is List<String>)
+ a(x !is List<String>)
+ a(x as Int<x> > false)
+ a(x as Int<x, y> == z)
+}
diff --git a/compiler/testData/psi/typeArgumentList/correctness/callExpressionsInFunctionCall.txt b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsInFunctionCall.txt
new file mode 100644
index 0000000..6b1e765
--- /dev/null
+++ b/compiler/testData/psi/typeArgumentList/correctness/callExpressionsInFunctionCall.txt
@@ -0,0 +1,664 @@
+KtFile: callExpressionsInFunctionCall.kt
+ PACKAGE_DIRECTIVE
+ <empty list>
+ IMPORT_LIST
+ <empty 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 0000000..377d682
--- /dev/null
+++ b/compiler/testData/psi/typeArgumentList/recovery/callExpressions.kt
@@ -0,0 +1,24 @@
+fun f() {
+ call<x>
+ call<x>()
+ call<x> { }
+ call<x>::
+ call<x>[]
+ call<x>?
+ call<x>?.
+ call<x>.
+ call<x>++
+ call<x>--
+ call<x>!!
+
+ a(call<x>())
+ a(call<x> { })
+ a(call<x>::)
+ a(call<x>[])
+ a(call<x>?)
+ a(call<x>?.)
+ a(call<x>.)
+ a(call<x>++)
+ a(call<x>--)
+ a(call<x>!!)
+}
\ 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 0000000..a34fd0d
--- /dev/null
+++ b/compiler/testData/psi/typeArgumentList/recovery/callExpressions.txt
@@ -0,0 +1,417 @@
+KtFile: callExpressions.kt
+ PACKAGE_DIRECTIVE
+ <empty list>
+ IMPORT_LIST
+ <empty 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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 0000000..04ff987
--- /dev/null
+++ b/compiler/testData/psi/typeArgumentList/recovery/callExpressions_ERR.kt
@@ -0,0 +1,45 @@
+fun f() {
+ call<>
+ call<x.>
+ call<>()
+ call<x.>()
+ call<> { }
+ call<x.> { }
+ call<>::
+ call<x.>::
+ call<>[]
+ call<x.>[]
+ call<>?
+ call<x.>?
+ call<>?.
+ call<x.>?.
+ call<>.
+ call<x.>.
+ call<>++
+ call<x.>++
+ call<>--
+ call<x.>--
+ call<>!!
+ call<x.>!!
+
+ a(call<>())
+ a(call<x.>())
+ a(call<> { })
+ a(call<x.> { })
+ a(call<>::)
+ a(call<x.>::)
+ a(call<>[])
+ a(call<x.>[])
+ a(call<>?)
+ a(call<x.>?)
+ a(call<>?.)
+ a(call<x.>?.)
+ a(call<>.)
+ a(call<x.>.)
+ a(call<>++)
+ a(call<x.>++)
+ a(call<>--)
+ a(call<x.>--)
+ a(call<>!!)
+ a(call<x.>!!)
+}
\ 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 0000000..6adf1b7
--- /dev/null
+++ b/compiler/testData/psi/typeArgumentList/recovery/callExpressions_ERR.txt
@@ -0,0 +1,800 @@
+KtFile: callExpressions_ERR.kt
+ PACKAGE_DIRECTIVE
+ <empty list>
+ IMPORT_LIST
+ <empty 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ PsiElement(GT)('>')
+ PsiWhiteSpace(' ')
+ LAMBDA_ARGUMENT
+ LAMBDA_EXPRESSION
+ FUNCTION_LITERAL
+ PsiElement(LBRACE)('{')
+ PsiWhiteSpace(' ')
+ BLOCK
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ PsiElement(GT)('>')
+ INDICES
+ PsiElement(LBRACKET)('[')
+ PsiErrorElement:Expecting an index element
+ <empty list>
+ 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
+ <empty list>
+ PsiElement(RBRACKET)(']')
+ PsiWhiteSpace('\n ')
+ CALL_EXPRESSION
+ REFERENCE_EXPRESSION
+ PsiElement(IDENTIFIER)('call')
+ TYPE_ARGUMENT_LIST
+ PsiElement(LT)('<')
+ TYPE_PROJECTION
+ TYPE_REFERENCE
+ PsiErrorElement:Type expected
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ PsiElement(GT)('>')
+ PsiWhiteSpace(' ')
+ LAMBDA_ARGUMENT
+ LAMBDA_EXPRESSION
+ FUNCTION_LITERAL
+ PsiElement(LBRACE)('{')
+ PsiWhiteSpace(' ')
+ BLOCK
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ PsiElement(GT)('>')
+ PsiElement(COLONCOLON)('::')
+ REFERENCE_EXPRESSION
+ PsiErrorElement:Expecting an identifier
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ PsiElement(GT)('>')
+ INDICES
+ PsiElement(LBRACKET)('[')
+ PsiErrorElement:Expecting an index element
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ PsiElement(GT)('>')
+ PsiElement(SAFE_ACCESS)('?.')
+ PsiErrorElement:Expecting an element
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ PsiElement(GT)('>')
+ PsiElement(DOT)('.')
+ PsiErrorElement:Expecting an element
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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
+ <empty list>
+ 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 52106c6..4525519 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
@@ -32240,6 +32240,28 @@
}
@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")
public class TypeParameters {
diff --git a/compiler/tests-gen/org/jetbrains/kotlin/parsing/ParsingTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/parsing/ParsingTestGenerated.java
index 69faed2..835334b 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 @@
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 6754cd0..a9f2d35 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 @@
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
