Fix edge case with lambda ending with match at end of argument

Godot can't parse the argument delimiter in this case, seems it tries to
parse the comma (marking end of argument) as part of the match statement

Fix 301

Author: NathanLovato

CHANGELOG.md

@@ -8,6 +8,10 @@ This file documents the changes made to the formatter with each release.
 
 - You can not exclude files and folders using the `--exclude/-x` flag or `gdscript_formatter_exclude` in your editorconfig files (#299)
 
+### Fixed
+
+- Fixed edge case when a lambda is at the end of an argument list and ends with a match statement, causing the formatter to insert a trailing comma (#301)
+
 ## Release 0.23.0 (2026-07-24)
 
 ### Added

src/formatter.rs

@@ -1637,6 +1637,46 @@ fn process_container(
         false
     }
 
+    /// Returns true if the lambda ends with a match statement.
+    fn lambda_ends_with_match(lambda: tree_sitter::Node) -> bool {
+        let mut body = None;
+        let mut child_index = 0;
+        while child_index < lambda.child_count() {
+            if let Some(child) = lambda.child(child_index as u32)
+                && GDScriptNodeKind::get_kind_from_ast_node(child) == GDScriptNodeKind::Body
+            {
+                body = Some(child);
+                break;
+            }
+            child_index += 1;
+        }
+        let Some(body) = body else {
+            return false;
+        };
+        let mut last_statement = None;
+        child_index = 0;
+        while child_index < body.named_child_count() {
+            last_statement = body.named_child(child_index as u32);
+            child_index += 1;
+        }
+        last_statement.is_some_and(|statement| {
+            if GDScriptNodeKind::get_kind_from_ast_node(statement) == GDScriptNodeKind::MatchBody {
+                return true;
+            }
+            let mut child_index = 0;
+            while child_index < statement.child_count() {
+                if let Some(child) = statement.child(child_index as u32)
+                    && GDScriptNodeKind::get_kind_from_ast_node(child)
+                        == GDScriptNodeKind::MatchBody
+                {
+                    return true;
+                }
+                child_index += 1;
+            }
+            false
+        })
+    }
+
     // A container's children are: [open_delimiter, elements_and_commas...,
     // close_delimiter]. The minimal single-element form is 3 children
     // ([open, element, close]); child_count >= 4 means there is either a
@@ -1664,11 +1704,18 @@ fn process_container(
         && node.child(1).is_some_and(|child| {
             GDScriptNodeKind::get_kind_from_ast_node(child) == GDScriptNodeKind::Lambda
         });
+    // This works around an edge case of the GDScript parser in Godot failing to
+    // parse an unparenthesized lambda argument if its final statement is match
+    // and the formatter adds a comma to the last match branch.
+    let is_unparenthesized_lambda_with_match = is_single_lambda
+        && node_kind == GDScriptNodeKind::Arguments
+        && node.child(1).is_some_and(lambda_ends_with_match);
     let needs_lambda_trailing_comma = is_single_lambda
         && matches!(
             node_kind,
             GDScriptNodeKind::Array | GDScriptNodeKind::Arguments
-        );
+        )
+        && !is_unparenthesized_lambda_with_match;
     if (contains_more_than_one_element || needs_lambda_trailing_comma)
         && !trailing_comma_handled
         && !last_was_comment

src/main.rs

@@ -461,10 +461,10 @@ fn find_gdscript_files(
                 }
             }
         } else if let Some(extension) = current_path.extension() {
-            if extension == "gd" {
-                if !gdscript_formatter::editorconfig::is_excluded_by_editorconfig(&current_path) {
-                    gdscript_file_paths.push(current_path);
-                }
+            if extension == "gd"
+                && !gdscript_formatter::editorconfig::is_excluded_by_editorconfig(&current_path)
+            {
+                gdscript_file_paths.push(current_path);
             }
         }
     }

tests/expected/lambda.gd

@@ -56,3 +56,17 @@ func issue_287() -> void:
 			),
 		self,
 	)
+
+
+# Godot doesn't support a trailing comma in a lambda ending an argument list
+# when the lambda ends with a match statement. We make sure the formatter
+# doesn't insert a trailing comma in this case.
+func issue_301() -> void:
+	[0, 2, 3].filter(
+		func(value: int):
+			match value:
+				0:
+					return false
+				_:
+					return true
+	)

tests/input/lambda.gd

@@ -50,3 +50,16 @@ func issue_287() -> void:
 		),
 		self,
 	)
+
+
+# Godot doesn't support a trailing comma in a lambda ending an argument list
+# when the lambda ends with a match statement. We make sure the formatter
+# doesn't insert a trailing comma in this case.
+func issue_301() -> void:
+	[0, 2, 3].filter(func(value: int):
+		match value:
+			0:
+				return false
+			_:
+				return true
+	)