feat: keep trailing commas in TSX arrow and function expression type parameters in order to help prevent parsing ambiguities

Closes #274

Author: dsherret

src/format_text.rs

@@ -45,6 +45,7 @@ pub fn format_text(file_path: &Path, file_text: &str, config: &Configuration) ->
     let parsed_source_file = parse_swc_ast(file_path, file_text)?;
     Ok(dprint_core::formatting::format(|| {
         let print_items = parse(&SourceFileInfo {
+            is_jsx: parsed_source_file.is_jsx,
             module: &parsed_source_file.module,
             info: &parsed_source_file.info,
             tokens: &parsed_source_file.tokens,
@@ -58,6 +59,7 @@ pub fn format_text(file_path: &Path, file_text: &str, config: &Configuration) ->
 
 #[derive(Clone)]
 pub struct SourceFileInfo<'a> {
+    pub is_jsx: bool,
     pub module: &'a swc_ecmascript::ast::Module,
     pub info: &'a dyn swc_ast_view::SourceFile,
     pub tokens: &'a [TokenAndSpan],

src/parsing/context.rs

@@ -7,6 +7,7 @@ use crate::configuration::*;
 use crate::utils::Stack;
 
 pub struct Context<'a> {
+    pub is_jsx: bool,
     pub module: &'a Module<'a>,
     pub config: &'a Configuration,
     pub comments: CommentTracker<'a>,
@@ -27,12 +28,14 @@ pub struct Context<'a> {
 
 impl<'a> Context<'a> {
     pub fn new(
-        config: &'a Configuration,
+        is_jsx: bool,
         tokens: &'a [TokenAndSpan],
         current_node: Node<'a>,
         module: &'a Module,
+        config: &'a Configuration,
     ) -> Context<'a> {
         Context {
+            is_jsx,
             module,
             config,
             comments: CommentTracker::new(module, tokens),

src/parsing/parser.rs

@@ -24,10 +24,11 @@ pub fn parse(info: &SourceFileInfo<'_>, config: &Configuration) -> PrintItems {
     swc_ast_view::with_ast_view_for_module(source_file_info, |module| {
         let module_node = Node::Module(module);
         let mut context = Context::new(
-            config,
+            info.is_jsx,
             info.tokens,
             module_node,
             module,
+            config,
         );
         let mut items = parse_node(module_node, &mut context);
         items.push_condition(if_true(
@@ -4566,6 +4567,15 @@ fn parse_type_parameters<'a>(node: TypeParamNode<'a>, context: &mut Context<'a>)
         // trailing commas should be allowed in type parameters only—not arguments
         if let Some(type_params) = node.parent().get_type_parameters() {
             if type_params.lo() == node.lo() {
+                // Always use trailing commas for arrow function expressions in a JSX file
+                // if one exists as it may be used to assist with parsing ambiguity.
+                if context.is_jsx && (node.parent().kind() == NodeKind::ArrowExpr || node.parent().parent().unwrap().kind() == NodeKind::FnExpr) {
+                    let comma_count = type_params.tokens_fast(context.module).iter().filter(|t| t.token == Token::Comma).count();
+                    let has_trailing_comma = comma_count >= type_params.params.len();
+                    if has_trailing_comma {
+                        return TrailingCommas::Always;
+                    }
+                }
                 return trailing_commas;
             }
         }

src/swc/parse_swc_ast.rs

@@ -6,6 +6,7 @@ use dprint_core::types::{ErrBox, Error};
 use swc_ast_view::SourceFileTextInfo;
 
 pub struct ParsedSourceFile {
+    pub is_jsx: bool,
     pub module: swc_ecmascript::ast::Module,
     pub info: SourceFileTextInfo,
     pub tokens: Vec<TokenAndSpan>,
@@ -34,11 +35,12 @@ pub fn parse_swc_ast(file_path: &Path, file_text: &str) -> Result<ParsedSourceFi
 fn parse_inner(file_path: &Path, file_text: &str) -> Result<ParsedSourceFile, ErrBox> {
     let string_input = StringInput::new(file_text, BytePos(0), BytePos(file_text.len() as u32));
     let source_file_info = SourceFileTextInfo::new(BytePos(0), file_text.to_string());
+    let is_jsx = should_parse_as_jsx(file_path);
 
     let comments: SingleThreadedComments = Default::default();
     let (module, tokens) = {
         let ts_config = swc_ecmascript::parser::TsConfig {
-            tsx: should_parse_as_jsx(file_path),
+            tsx: is_jsx,
             dynamic_import: true,
             decorators: true,
             import_assertions: true,
@@ -73,6 +75,7 @@ fn parse_inner(file_path: &Path, file_text: &str) -> Result<ParsedSourceFile, Er
     // }
 
     return Ok(ParsedSourceFile {
+        is_jsx,
         leading_comments,
         trailing_comments,
         module,

tests/specs/general/Jsx_TrailingCommas.txt

@@ -0,0 +1,25 @@
+== should not keep trailing comma in expression type parameters in non-jsx file since there is no parsing ambiguity ==
+const Test1 = <T,>() => false;
+const Test2 = function<T,>() {};
+
+[expect]
+const Test1 = <T>() => false;
+const Test2 = function<T>() {};
+
+== should keep trailing comma in expression type parameters in file parsed as jsx since there is no parsing ambiguity ==
+const Test1 = <T,>() => false;
+const Test2 = function<T,>() {};
+const Test3 = <div></div>;
+
+// not for declarations though
+function test<T,>() {
+}
+
+[expect]
+const Test1 = <T,>() => false;
+const Test2 = function<T,>() {};
+const Test3 = <div></div>;
+
+// not for declarations though
+function test<T>() {
+}