Fix case where export_category would merge with next annotated variable

Author: NathanLovato

CHANGELOG.md

@@ -2,6 +2,12 @@
 
 This file documents the changes made to the formatter with each release.
 
+## Unreleased
+
+### Fixed
+
+- Fix `@export_category` annotations sometimes wrapping with variables on a single line (#358)
+
 ## Release 0.26.2 (2026-09-20)
 
 ### Fixed

src/formatter.rs

@@ -16,6 +16,7 @@ use crate::parser::{ParseInput, RegionWithDisabledFormatting};
 use crate::renderer::{GroupParentFit, RangeRenderElement, RangeSourceBytes, RenderElement};
 use crate::reorder;
 use crate::reorder::DeclarationKind;
+use crate::shared_utils::should_annotation_be_inline;
 
 fn begin_indent(render_elements: &mut Vec<RenderElement>, level: u16) -> usize {
     let index = render_elements.len();
@@ -209,9 +210,7 @@ fn is_annotation_that_should_stay_inline(source: &str, annotation: tree_sitter::
             && GDScriptNodeKind::get_kind_from_ast_node(child) == GDScriptNodeKind::Identifier
         {
             let annotation_name = &source[child.start_byte()..child.end_byte()];
-            return (annotation_name.starts_with("export")
-                && !["export_group", "export_subgroup"].contains(&annotation_name))
-                || annotation_name == "onready";
+            return should_annotation_be_inline(annotation_name);
         }
         child_index += 1;
     }

src/lib.rs

@@ -21,6 +21,7 @@ pub mod node_kind;
 pub mod parser;
 pub mod renderer;
 pub mod reorder;
+pub mod shared_utils;
 pub mod verify_structure;
 
 pub use renderer::{PrinterConfiguration, RenderElement};

src/reorder.rs

@@ -7,6 +7,7 @@
 //! bundled with it so they move together when reordered.
 
 use crate::node_kind::GDScriptNodeKind;
+use crate::shared_utils::should_annotation_be_inline;
 use tree_sitter::Node;
 
 #[derive(Debug, Clone)]
@@ -187,10 +188,10 @@ pub fn build_reorder_plan<'a>(parent: Node<'a>, content: &'a str) -> ReorderPlan
             } else {
                 is_child_attached_to_declaration[child_index] = true;
                 if let Some(annotation_identifier) = get_annotation_identifier(child, content) {
-                    if is_inline_export_annotation(annotation_identifier) {
-                        visited_annotations.has_export_annotation = true;
-                    } else if annotation_identifier == "onready" {
+                    if annotation_identifier == "onready" {
                         visited_annotations.has_onready_annotation = true;
+                    } else if should_annotation_be_inline(annotation_identifier) {
+                        visited_annotations.has_export_annotation = true;
                     }
                 }
             }
@@ -528,10 +529,10 @@ fn classify_variable<'a>(
             let Some(annotation_name) = get_annotation_identifier(annotation, content) else {
                 continue;
             };
-            if is_inline_export_annotation(annotation_name) {
-                has_export_annotation = true;
-            } else if annotation_name == "onready" {
+            if annotation_name == "onready" {
                 has_onready_annotation = true;
+            } else if should_annotation_be_inline(annotation_name) {
+                has_export_annotation = true;
             }
         }
     }
@@ -563,16 +564,6 @@ fn get_annotation_identifier<'a>(annotation: Node<'a>, content: &'a str) -> Opti
     None
 }
 
-/// Returns true when an annotation exports the variable it annotates. The
-/// `@export_group` and `@export_subgroup` annotations only mark groups of
-/// following properties and must not make an unannotated variable look
-/// exported.
-fn is_inline_export_annotation(annotation_name: &str) -> bool {
-    annotation_name.starts_with("export")
-        && annotation_name != "export_group"
-        && annotation_name != "export_subgroup"
-}
-
 /// Extract the "name" field child from a declaration node.
 fn extract_name<'a>(node: Node<'a>, content: &'a str) -> Option<&'a str> {
     let count = node.child_count();

src/shared_utils.rs

@@ -0,0 +1,8 @@
+/// Returns `true` if the annotation should be inline, `false` otherwise. All
+/// export annotations except those that create inspector groups or categories
+/// and the onready annotation should be written inline.
+pub fn should_annotation_be_inline(annotation_name: &str) -> bool {
+    (annotation_name.starts_with("export")
+        && !["export_group", "export_subgroup", "export_category"].contains(&annotation_name))
+        || annotation_name == "onready"
+}