Merged branch idea251.release into idea251.x

builduser · builduser · commit 765e26f8f21e · 2025-05-05T17:11:07.000+02:00
diff --git a/scala/scala-impl/resources/messages/ScalaBundle.properties b/scala/scala-impl/resources/messages/ScalaBundle.properties
@@ -238,6 +238,7 @@ export.qualifier.not.parameterless.companion.method=Export qualifier {0} is not
 
 ### org/jetbrains/plugins/scala/annotator/element/ScExpressionAnnotator.scala
 else.expected='else' expected
+expression.expected=Expression expected
 
 ### org/jetbrains/plugins/scala/annotator/element/ScForAnnotator.scala
 for.pattern.bindings.require.scala3='case' syntax in 'for' pattern bindings requires Scala 3.0
@@ -1357,7 +1358,6 @@ auxiliary.constructor.may.not.have.a.type.annotation=Auxiliary constructor may n
 auxiliary.constructor.definition.expected=Auxiliary constructor definition expected
 
 ### org/jetbrains/plugins/scala/lang/parser/parsing/statements/PatDef.scala
-expression.expected=Expression expected
 expected.another.pattern=Expected another pattern
 
 ### org/jetbrains/plugins/scala/lang/parser/parsing/statements/ValDcl.scala
diff --git a/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/completion/ScalaNamedTupleCompletionContributor.scala b/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/completion/ScalaNamedTupleCompletionContributor.scala
@@ -1,6 +1,6 @@
 package org.jetbrains.plugins.scala.lang.completion
 
-import com.intellij.codeInsight.completion.{CompletionContributor, CompletionParameters, CompletionType, InsertHandler, InsertionContext}
+import com.intellij.codeInsight.completion.{CompletionContributor, CompletionParameters, CompletionType, CompletionUtilCore, InsertHandler, InsertionContext}
 import com.intellij.codeInsight.lookup.{LookupElement, LookupElementBuilder}
 import com.intellij.codeInsight.template.TemplateBuilderImpl
 import com.intellij.openapi.util.TextRange
@@ -11,14 +11,16 @@ import com.intellij.util.ProcessingContext
 import org.jetbrains.plugins.scala.extensions.{PsiElementExt, ToNullSafe}
 import org.jetbrains.plugins.scala.lang.completion.ScalaNamedTupleCompletionContributor.ScalaNamedTupleCompletionProvider
 import org.jetbrains.plugins.scala.lang.psi.api.expr.{ScExpression, ScNamedTuple, ScNamedTupleExprComponent, ScParenthesisedExpr, ScReferenceExpression}
+import org.jetbrains.plugins.scala.lang.psi.types.ScType
 import org.jetbrains.plugins.scala.lang.psi.types.api.NamedTupleType
 
 import scala.annotation.tailrec
+import scala.collection.mutable
 
 class ScalaNamedTupleCompletionContributor extends CompletionContributor {
   extend(
     CompletionType.BASIC,
-    identifierWithParentsPattern(classOf[ScReferenceExpression], classOf[ScNamedTupleExprComponent], classOf[ScNamedTuple]),
+    identifierWithParentsPattern(classOf[ScNamedTupleExprComponent], classOf[ScNamedTuple]),
     ScalaNamedTupleCompletionProvider,
   )
 
@@ -33,42 +35,55 @@ object ScalaNamedTupleCompletionContributor {
   object ScalaNamedTupleCompletionProvider extends ScalaCompletionProvider {
     override protected def completionsFor(position: PsiElement)
                                          (implicit parameters: CompletionParameters, context: ProcessingContext): Iterable[LookupElement] = {
-      val refParent = getContextOfType(position, classOf[ScReferenceExpression])
-        .nullSafe
-        .map(_.getParent)
-        .orNull
-      refParent match {
-        case expr: ScParenthesisedExpr => createCompletionFor(expr, Map.empty)
-        case comp: ScNamedTupleExprComponent =>
+      val identifierParent = getContextOfType(position, classOf[ScParenthesisedExpr], classOf[ScNamedTupleExprComponent])
+      identifierParent match {
+        case expr: ScParenthesisedExpr => createCompletionFor(expr, Seq.empty)
+        case comp: ScNamedTupleExprComponent if position == comp.nameId =>
           val namedTuple = comp.namedTuple
           val existingComponents =
             namedTuple
               .components
               .flatMap { comp =>
                 comp.nameElement.zip(comp.expr)
-                  .map { case (name, expr) => name.getText -> expr.getText }
-              }.toMap
+                  .map { case (name, expr) => name.getText.replace(CompletionUtilCore.DUMMY_IDENTIFIER_TRIMMED, "") -> expr.getText }
+              }
 
           createCompletionFor(namedTuple, existingComponents)
         case _ =>
           Seq.empty
       }
     }
 
-    private def createCompletionFor(expr: ScExpression, existingComponents: Map[String, String]): Seq[LookupElement] = {
+    private def createCompletionFor(expr: ScExpression, existingComponents: Seq[(String, String)]): Seq[LookupElement] = {
+      val existingComponentsMap = existingComponents.toMap
+      def hasNewComponent(components: Seq[(ScType, _)]): Boolean =
+        components.size > existingComponents.size || components.exists {
+          case (NamedTupleType.NameType(name), _) => !existingComponentsMap.contains(name)
+          case _ => false
+        }
+
       expr.expectedType() match {
-        case Some(NamedTupleType(components)) =>
+        case Some(NamedTupleType(components)) if hasNewComponent(components) =>
           val elements =
             components.map {
               case (NamedTupleType.NameType(name), _) => name //s"$name = " + existingComponents.getOrElse(name, s"???")
               case _ => "???"
             }
 
           val presentation = elements
-            .filterNot(existingComponents.contains)
+            .filterNot(existingComponentsMap.contains)
             .mkString("", ", ", " =")
+
+          // the identifier that we currently try to complete is of course not in components
+          // so just put down unmatched components in order
+          val unmatchedExpressions = existingComponents
+            .iterator
+            .collect { case (name, expr) if !elements.contains(name) => expr }
+            .to(mutable.Queue)
+          def nextUnmatchedExpression =
+            if (unmatchedExpressions.isEmpty) "???" else unmatchedExpressions.dequeue()
           val text = elements
-            .map(name => s"$name = ${existingComponents.getOrElse(name, "???")}")
+            .map(name => s"$name = ${existingComponentsMap.getOrElse(name, nextUnmatchedExpression)}")
             .mkString(", ")
           Seq(
             LookupElementBuilder
diff --git a/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/builder/ScalaPsiBuilder.scala b/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/builder/ScalaPsiBuilder.scala
@@ -63,4 +63,8 @@ trait ScalaPsiBuilder extends PsiBuilder {
   final def wrongExpressionError(): Unit = {
     error(ErrMsg("wrong.expression"))
   }
+
+  final def expressionExpectedError(): Unit = {
+    error(ErrMsg("expression.expected"))
+  }
 }
diff --git a/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/expressions/Enumerator.scala b/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/expressions/Enumerator.scala
@@ -21,7 +21,7 @@ object Enumerator extends ParsingRule {
         case ScalaTokenTypes.tASSIGN =>
           builder.advanceLexer() //Ate =
           if (!ExprInIndentationRegion()) {
-            builder.wrongExpressionError()
+            builder.expressionExpectedError()
           }
           enumeratorMarker.done(ScalaElementType.FOR_BINDING)
           true
diff --git a/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/expressions/Generator.scala b/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/expressions/Generator.scala
@@ -27,7 +27,7 @@ object Generator extends ParsingRule {
         builder.advanceLexer()
 
         if (!ExprInIndentationRegion()) {
-          builder.wrongExpressionError()
+          builder.expressionExpectedError()
         }
         genMarker.done(ScalaElementType.GENERATOR)
         builder.getTokenType match {
diff --git a/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/expressions/SimpleExpr.scala b/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/expressions/SimpleExpr.scala
@@ -112,20 +112,29 @@ object SimpleExpr extends ParsingRule {
               val namedTupleComponentMarker = builder.mark()
               var hasNamedTupleContent = false
               if (isNamedTuple) {
-                if (builder.lookAhead(tIDENTIFIER, tASSIGN)) {
-                  hasNamedTupleContent = true
-                  builder.advanceLexer()
-                  builder.advanceLexer()
-                } else if (builder.getTokenType == tASSIGN) {
-                  hasNamedTupleContent = true
-                  builder.error(ErrMsg("identifier.expected"))
-                  builder.advanceLexer()
-                } else {
-                  builder.error(ErrMsg("identifier.expected"))
+                builder.getTokenType match {
+                  case `tIDENTIFIER` =>
+                    hasNamedTupleContent = true
+                    builder.advanceLexer()
+
+                    if (builder.getTokenType == tASSIGN) {
+                      builder.advanceLexer()
+                    } else {
+                      builder.error(ScalaBundle.message("assignment.expected"))
+                    }
+                  case token =>
+                    builder.error(ErrMsg("identifier.expected"))
+
+                    if (token == `tASSIGN`) {
+                      builder.advanceLexer()
+                    }
                 }
               }
 
               val parsedExpr = Expr()
+              if (!parsedExpr) {
+                builder.expressionExpectedError()
+              }
 
               if (isNamedTuple && (hasNamedTupleContent || parsedExpr)) {
                 namedTupleComponentMarker.done(ScalaElementType.NAMED_TUPLE_COMPONENT)
diff --git a/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/params/Param.scala b/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/params/Param.scala
@@ -4,7 +4,7 @@ import org.jetbrains.plugins.scala.lang.lexer.{ScalaTokenType, ScalaTokenTypes}
 import org.jetbrains.plugins.scala.lang.parser.{ErrMsg, ScalaElementType}
 import org.jetbrains.plugins.scala.lang.parser.parsing.ParsingRule
 import org.jetbrains.plugins.scala.lang.parser.parsing.builder.ScalaPsiBuilder
-import org.jetbrains.plugins.scala.lang.parser.parsing.expressions.{Annotations, Expr}
+import org.jetbrains.plugins.scala.lang.parser.parsing.expressions.{Annotations, Expr, ExprInIndentationRegion}
 import org.jetbrains.plugins.scala.lang.parser.parsing.types.ParamType
 
 /**
@@ -49,7 +49,7 @@ object Param extends ParsingRule {
     builder.getTokenType match {
       case ScalaTokenTypes.tASSIGN =>
         builder.advanceLexer() //Ate =
-        if (!Expr()) builder error ErrMsg("expression.expected")
+        if (!ExprInIndentationRegion()) builder error ErrMsg("expression.expected")
       case _ =>
     }
     paramMarker.done(ScalaElementType.PARAM)
diff --git a/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/statements/FunDef.scala b/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/statements/FunDef.scala
@@ -42,7 +42,7 @@ object FunDef extends ParsingRule {
                   true
                 }
                 else {
-                  builder.wrongExpressionError()
+                  builder.expressionExpectedError()
                   faultMarker.drop()
                   true
                 }
@@ -59,7 +59,7 @@ object FunDef extends ParsingRule {
               true
             }
             else {
-              builder.error(ScalaBundle.message("expression.expected"))
+              builder.expressionExpectedError()
               faultMarker.drop()
               true
             }
diff --git a/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/statements/PatDef.scala b/scala/scala-impl/src/org/jetbrains/plugins/scala/lang/parser/parsing/statements/PatDef.scala
@@ -53,7 +53,7 @@ object PatDef extends ParsingRule {
         builder.checkedAdvanceLexer()
 
         if (!ExprInIndentationRegion()) {
-          builder.error(ErrMsg("expression.expected"))
+          builder.expressionExpectedError()
         }
 
         patDefMarker.drop()
diff --git a/scala/scala-impl/test/org/jetbrains/plugins/scala/lang/completion3/ScalaNamedTupleCompletionContributorTest.scala b/scala/scala-impl/test/org/jetbrains/plugins/scala/lang/completion3/ScalaNamedTupleCompletionContributorTest.scala
@@ -40,4 +40,40 @@ class ScalaNamedTupleCompletionContributorTest extends ScalaCompletionTestBase {
          |""".stripMargin,
     item = """a = ???, b = "test"""",
   )
+
+  def testCompleteExistingNamedTupleWithReordering2(): Unit = doCompletionTest(
+    fileText =
+      s"""val x: (a: Int, bbb: String) = (a = 1, b$CARET = "test")
+         |""".stripMargin,
+    resultText =
+      s"""val x: (a: Int, bbb: String) = (a = 1, bbb = "test")
+         |""".stripMargin,
+    item = """a = 1, bbb = "test"""",
+  )
+
+  def testCompleteExistingNamedTupleWithReordering3(): Unit = doCompletionTest(
+    fileText =
+      s"""val x: (a: Int, bbb: String, ccc: Boolean) = (b$CARET = "test", a = 1, c = true)
+         |""".stripMargin,
+    resultText =
+      s"""val x: (a: Int, bbb: String, ccc: Boolean) = (a = 1, bbb = "test", ccc = true)
+         |""".stripMargin,
+    item = """a = 1, bbb = "test", ccc = true""",
+  )
+
+  def testDontCompleteInExpr(): Unit =
+    checkNoCompletion(s"val x: (a: Int, b: String) = (a = $CARET)") {
+      item => item.getLookupString.contains(" = ")
+    }
+
+  // SCL-23823
+  def testDontCompleteInExpr2(): Unit =
+    checkNoCompletion(s"val x: (a: Int, b: String) = (a = p.$CARET, b = ???)") {
+      item => item.getLookupString.contains(" = ")
+    }
+
+  def testDontCompleteIfAllComponentsAreThere(): Unit =
+    checkNoCompletion(s"val x: (a: Int, b: String) = (a = ???, b$CARET = ???)") {
+      item => item.getLookupString.contains(" = ")
+    }
 }
diff --git a/scala/scala-impl/test/org/jetbrains/plugins/scala/lang/parser/scala3/ExprParserTest.scala b/scala/scala-impl/test/org/jetbrains/plugins/scala/lang/parser/scala3/ExprParserTest.scala
diff --git a/scala/scala-impl/test/org/jetbrains/plugins/scala/lang/parser/scala3/FunDefTest.scala b/scala/scala-impl/test/org/jetbrains/plugins/scala/lang/parser/scala3/FunDefTest.scala
diff --git a/scala/scala-impl/test/org/jetbrains/plugins/scala/lang/parser/scala3/TupleParserTest.scala b/scala/scala-impl/test/org/jetbrains/plugins/scala/lang/parser/scala3/TupleParserTest.scala

Original file line number	Diff line number	Diff line change
`@@ -63,4 +63,8 @@ trait ScalaPsiBuilder extends PsiBuilder {`
`63`	`63`	`final def wrongExpressionError(): Unit = {`
`64`	`64`	`error(ErrMsg("wrong.expression"))`
`65`	`65`	`}`
	`66`	`+`
	`67`	`+ final def expressionExpectedError(): Unit = {`
	`68`	`+ error(ErrMsg("expression.expected"))`
	`69`	`+ }`
`66`	`70`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,7 +21,7 @@ object Enumerator extends ParsingRule {`
`21`	`21`	`case ScalaTokenTypes.tASSIGN =>`
`22`	`22`	`builder.advanceLexer() //Ate =`
`23`	`23`	`if (!ExprInIndentationRegion()) {`
`24`		`- builder.wrongExpressionError()`
	`24`	`+ builder.expressionExpectedError()`
`25`	`25`	`}`
`26`	`26`	`enumeratorMarker.done(ScalaElementType.FOR_BINDING)`
`27`	`27`	`true`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ object Generator extends ParsingRule {`
`27`	`27`	`builder.advanceLexer()`
`28`	`28`
`29`	`29`	`if (!ExprInIndentationRegion()) {`
`30`		`- builder.wrongExpressionError()`
	`30`	`+ builder.expressionExpectedError()`
`31`	`31`	`}`
`32`	`32`	`genMarker.done(ScalaElementType.GENERATOR)`
`33`	`33`	`builder.getTokenType match {`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ object FunDef extends ParsingRule {`
`42`	`42`	`true`
`43`	`43`	`}`
`44`	`44`	`else {`
`45`		`- builder.wrongExpressionError()`
	`45`	`+ builder.expressionExpectedError()`
`46`	`46`	`faultMarker.drop()`
`47`	`47`	`true`
`48`	`48`	`}`
`@@ -59,7 +59,7 @@ object FunDef extends ParsingRule {`
`59`	`59`	`true`
`60`	`60`	`}`
`61`	`61`	`else {`
`62`		`- builder.error(ScalaBundle.message("expression.expected"))`
	`62`	`+ builder.expressionExpectedError()`
`63`	`63`	`faultMarker.drop()`
`64`	`64`	`true`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ object PatDef extends ParsingRule {`
`53`	`53`	`builder.checkedAdvanceLexer()`
`54`	`54`
`55`	`55`	`if (!ExprInIndentationRegion()) {`
`56`		`- builder.error(ErrMsg("expression.expected"))`
	`56`	`+ builder.expressionExpectedError()`
`57`	`57`	`}`
`58`	`58`
`59`	`59`	`patDefMarker.drop()`