Merge pull request #21351 from ChayimFriedman2/format-args-kw

fix: Fix parsing of `format_args!("...", keyword=...)`

Author: Veykril

crates/hir-def/src/expr_store/lower/format_args.rs

@@ -1,12 +1,9 @@
 //! Lowering of `format_args!()`.
 
 use base_db::FxIndexSet;
-use hir_expand::name::{AsName, Name};
+use hir_expand::name::Name;
 use intern::{Symbol, sym};
-use syntax::{
-    AstPtr, AstToken as _,
-    ast::{self, HasName},
-};
+use syntax::{AstPtr, AstToken as _, ast};
 
 use crate::{
     builtin_type::BuiltinUint,
@@ -32,8 +29,8 @@ impl<'db> ExprCollector<'db> {
         let mut args = FormatArgumentsCollector::default();
         f.args().for_each(|arg| {
             args.add(FormatArgument {
-                kind: match arg.name() {
-                    Some(name) => FormatArgumentKind::Named(name.as_name()),
+                kind: match arg.arg_name() {
+                    Some(name) => FormatArgumentKind::Named(Name::new_root(name.name().text())),
                     None => FormatArgumentKind::Normal,
                 },
                 expr: self.collect_expr_opt(arg.expr()),

crates/ide/src/syntax_highlighting/test_data/highlight_strings.html

@@ -278,14 +278,20 @@ fn builtin_expr(p: &mut Parser<'_>) -> Option<CompletedMarker> {
         }
         Some(m.complete(p, OFFSET_OF_EXPR))
     } else if p.eat_contextual_kw(T![format_args]) {
+        // test format_args_named_arg_keyword
+        // fn main() {
+        //     builtin#format_args("{type}", type=1);
+        // }
         p.expect(T!['(']);
         expr(p);
         if p.eat(T![,]) {
             while !p.at(EOF) && !p.at(T![')']) {
                 let m = p.start();
-                if p.at(IDENT) && p.nth_at(1, T![=]) && !p.nth_at(2, T![=]) {
-                    name(p);
+                if p.current().is_any_identifier() && p.nth_at(1, T![=]) && !p.nth_at(2, T![=]) {
+                    let m = p.start();
+                    p.bump_any();
                     p.bump(T![=]);
+                    m.complete(p, FORMAT_ARGS_ARG_NAME);
                 }
                 if expr(p).is_none() {
                     m.abandon(p);

crates/parser/src/grammar/expressions/atom.rs

@@ -201,6 +201,7 @@ pub enum SyntaxKind {
     FN,
     FN_PTR_TYPE,
     FORMAT_ARGS_ARG,
+    FORMAT_ARGS_ARG_NAME,
     FORMAT_ARGS_EXPR,
     FOR_BINDER,
     FOR_EXPR,
@@ -373,6 +374,7 @@ impl SyntaxKind {
             | FN
             | FN_PTR_TYPE
             | FORMAT_ARGS_ARG
+            | FORMAT_ARGS_ARG_NAME
             | FORMAT_ARGS_EXPR
             | FOR_BINDER
             | FOR_EXPR

crates/parser/src/syntax_kind/generated.rs

@@ -265,6 +265,10 @@ mod ok {
     #[test]
     fn for_type() { run_and_expect_no_errors("test_data/parser/inline/ok/for_type.rs"); }
     #[test]
+    fn format_args_named_arg_keyword() {
+        run_and_expect_no_errors("test_data/parser/inline/ok/format_args_named_arg_keyword.rs");
+    }
+    #[test]
     fn frontmatter() { run_and_expect_no_errors("test_data/parser/inline/ok/frontmatter.rs"); }
     #[test]
     fn full_range_expr() {

crates/parser/test_data/generated/runner.rs

@@ -44,10 +44,10 @@ SOURCE_FILE
             COMMA ","
             WHITESPACE " "
             FORMAT_ARGS_ARG
-              NAME
+              FORMAT_ARGS_ARG_NAME
                 IDENT "a"
-              WHITESPACE " "
-              EQ "="
+                WHITESPACE " "
+                EQ "="
               WHITESPACE " "
               BIN_EXPR
                 LITERAL

crates/parser/test_data/parser/inline/ok/builtin_expr.rast

@@ -0,0 +1,35 @@
+SOURCE_FILE
+  FN
+    FN_KW "fn"
+    WHITESPACE " "
+    NAME
+      IDENT "main"
+    PARAM_LIST
+      L_PAREN "("
+      R_PAREN ")"
+    WHITESPACE " "
+    BLOCK_EXPR
+      STMT_LIST
+        L_CURLY "{"
+        WHITESPACE "\n    "
+        EXPR_STMT
+          FORMAT_ARGS_EXPR
+            BUILTIN_KW "builtin"
+            POUND "#"
+            FORMAT_ARGS_KW "format_args"
+            L_PAREN "("
+            LITERAL
+              STRING "\"{type}\""
+            COMMA ","
+            WHITESPACE " "
+            FORMAT_ARGS_ARG
+              FORMAT_ARGS_ARG_NAME
+                TYPE_KW "type"
+                EQ "="
+              LITERAL
+                INT_NUMBER "1"
+            R_PAREN ")"
+          SEMICOLON ";"
+        WHITESPACE "\n"
+        R_CURLY "}"
+  WHITESPACE "\n"

crates/parser/test_data/parser/inline/ok/format_args_named_arg_keyword.rast

@@ -0,0 +1,3 @@
+fn main() {
+    builtin#format_args("{type}", type=1);
+}

crates/parser/test_data/parser/inline/ok/format_args_named_arg_keyword.rs

@@ -438,7 +438,10 @@ FormatArgsExpr =
   ')'
 
 FormatArgsArg =
-  (Name '=')? Expr
+  arg_name:FormatArgsArgName? Expr
+
+FormatArgsArgName =
+  '=' // This also has a name, but it's any token and we can't put it here
 
 MacroExpr =
   MacroCall

crates/syntax/rust.ungram

@@ -639,10 +639,16 @@ impl ForType {
 pub struct FormatArgsArg {
     pub(crate) syntax: SyntaxNode,
 }
-impl ast::HasName for FormatArgsArg {}
 impl FormatArgsArg {
+    #[inline]
+    pub fn arg_name(&self) -> Option<FormatArgsArgName> { support::child(&self.syntax) }
     #[inline]
     pub fn expr(&self) -> Option<Expr> { support::child(&self.syntax) }
+}
+pub struct FormatArgsArgName {
+    pub(crate) syntax: SyntaxNode,
+}
+impl FormatArgsArgName {
     #[inline]
     pub fn eq_token(&self) -> Option<SyntaxToken> { support::token(&self.syntax, T![=]) }
 }
@@ -3722,6 +3728,38 @@ impl fmt::Debug for FormatArgsArg {
         f.debug_struct("FormatArgsArg").field("syntax", &self.syntax).finish()
     }
 }
+impl AstNode for FormatArgsArgName {
+    #[inline]
+    fn kind() -> SyntaxKind
+    where
+        Self: Sized,
+    {
+        FORMAT_ARGS_ARG_NAME
+    }
+    #[inline]
+    fn can_cast(kind: SyntaxKind) -> bool { kind == FORMAT_ARGS_ARG_NAME }
+    #[inline]
+    fn cast(syntax: SyntaxNode) -> Option<Self> {
+        if Self::can_cast(syntax.kind()) { Some(Self { syntax }) } else { None }
+    }
+    #[inline]
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+}
+impl hash::Hash for FormatArgsArgName {
+    fn hash<H: hash::Hasher>(&self, state: &mut H) { self.syntax.hash(state); }
+}
+impl Eq for FormatArgsArgName {}
+impl PartialEq for FormatArgsArgName {
+    fn eq(&self, other: &Self) -> bool { self.syntax == other.syntax }
+}
+impl Clone for FormatArgsArgName {
+    fn clone(&self) -> Self { Self { syntax: self.syntax.clone() } }
+}
+impl fmt::Debug for FormatArgsArgName {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FormatArgsArgName").field("syntax", &self.syntax).finish()
+    }
+}
 impl AstNode for FormatArgsExpr {
     #[inline]
     fn kind() -> SyntaxKind
@@ -8947,7 +8985,6 @@ impl AstNode for AnyHasName {
                 | CONST_PARAM
                 | ENUM
                 | FN
-                | FORMAT_ARGS_ARG
                 | IDENT_PAT
                 | MACRO_DEF
                 | MACRO_RULES
@@ -9006,10 +9043,6 @@ impl From<Fn> for AnyHasName {
     #[inline]
     fn from(node: Fn) -> AnyHasName { AnyHasName { syntax: node.syntax } }
 }
-impl From<FormatArgsArg> for AnyHasName {
-    #[inline]
-    fn from(node: FormatArgsArg) -> AnyHasName { AnyHasName { syntax: node.syntax } }
-}
 impl From<IdentPat> for AnyHasName {
     #[inline]
     fn from(node: IdentPat) -> AnyHasName { AnyHasName { syntax: node.syntax } }
@@ -9541,6 +9574,11 @@ impl std::fmt::Display for FormatArgsArg {
         std::fmt::Display::fmt(self.syntax(), f)
     }
 }
+impl std::fmt::Display for FormatArgsArgName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        std::fmt::Display::fmt(self.syntax(), f)
+    }
+}
 impl std::fmt::Display for FormatArgsExpr {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         std::fmt::Display::fmt(self.syntax(), f)