Normalize pointer and reference spacing in parser output (#55901)

Summary:
Pull Request resolved: #55901

Fixes inconsistent spacing around pointer (`*`) and reference (`&`, `&&`) symbols in the parser output.

Doxygen outputs types with a space before `*` and `&` (e.g., `NSString *`), which is inconsistent. This diff adds `normalize_pointer_spacing()` to standardize the output:

- `NSString *` → `NSString*`
- `int &` → `int&`
- `T &&` → `T&&`
- For function arguments: `NSString *name` → `NSString* name`

## Changes

1. Added `normalize_pointer_spacing()` function in `text_resolution.py`
2. Applied normalization in `resolve_ref_text_name()` and `resolve_linked_text_name()`
3. Applied normalization to block property argsstrings in `builders.py`
4. Updated all affected snapshot files to use normalized spacing

Changelog:
[Internal]

Reviewed By: cortinico

Differential Revision: D95078214

Author: coado

scripts/cxx-api/parser/builders.py

@@ -33,6 +33,7 @@
     Argument,
     extract_qualifiers,
     InitializerType,
+    normalize_pointer_spacing,
     parse_qualified_path,
     resolve_linked_text_name,
 )
@@ -344,7 +345,9 @@ def get_property_member(
     if property_type.endswith("(^"):
         argsstring = member_def.get_argsstring()
         if argsstring:
-            property_type = f"{property_type}{property_name}{argsstring}"
+            # Normalize pointer spacing in the argsstring
+            normalized_argsstring = normalize_pointer_spacing(argsstring)
+            property_type = f"{property_type}{property_name}{normalized_argsstring}"
             property_name = ""
 
     return PropertyMember(

scripts/cxx-api/parser/utils/__init__.py

@@ -18,6 +18,7 @@
     extract_namespace_from_refid,
     InitializerType,
     normalize_angle_brackets,
+    normalize_pointer_spacing,
     resolve_linked_text_name,
 )
 from .type_qualification import qualify_arguments, qualify_parsed_type, qualify_type_str

scripts/cxx-api/parser/utils/text_resolution.py

@@ -83,13 +83,46 @@ def extract_namespace_from_refid(refid: str) -> str:
 
 def normalize_angle_brackets(text: str) -> str:
     """Doxygen adds spaces around < and > to avoid XML ambiguity.
-    e.g. "NSArray< id< RCTBridgeMethod > > *" -> "NSArray<id<RCTBridgeMethod>> *"
+    e.g. "NSArray< id< RCTBridgeMethod > > *" -> "NSArray<id<RCTBridgeMethod>>*"
     """
     text = re.sub(r"<\s+", "<", text)
     text = re.sub(r"\s+>", ">", text)
     return text
 
 
+def normalize_pointer_spacing(text: str) -> str:
+    """Normalize spacing around pointer (*) and reference (&, &&) symbols.
+
+    Doxygen outputs types with a space before * and &, e.g.:
+    - "NSString *" -> "NSString*"
+    - "int &" -> "int&"
+    - "T &&" -> "T&&"
+
+    But for function arguments like "NSString *name", we want "NSString* name"
+    (space moved from before * to after *).
+
+    This normalizes to have no space before the pointer/reference symbol,
+    while preserving the space after if there's an identifier following.
+    """
+    # For patterns like "Type *name" -> "Type* name" (move space from before to after)
+    # Match: word/type character or > followed by space(s), then *, then word char
+    text = re.sub(r"(\w|>)\s+\*(\w)", r"\1* \2", text)
+    # For patterns like "Type *" at end or before comma/paren/angle/open-paren -> "Type*"
+    text = re.sub(r"(\w|>)\s+\*(?=\s*[,)>(]|$)", r"\1*", text)
+    # For patterns like "Type *" followed by another * (pointer to pointer)
+    text = re.sub(r"(\w|>)\s+\*(?=\*)", r"\1*", text)
+
+    # Same for && (rvalue reference)
+    text = re.sub(r"(\w|>)\s+&&(\w)", r"\1&& \2", text)
+    text = re.sub(r"(\w|>)\s+&&(?=\s*[,)>(]|$)", r"\1&&", text)
+
+    # Same for & (lvalue reference) - but don't match &&
+    text = re.sub(r"(\w|>)\s+&(?!&)(\w)", r"\1& \2", text)
+    text = re.sub(r"(\w|>)\s+&(?!&)(?=\s*[,)>(]|$)", r"\1&", text)
+
+    return text
+
+
 class InitializerType(Enum):
     NONE = (0,)
     ASSIGNMENT = (1,)
@@ -145,7 +178,10 @@ def resolve_linked_text_name(
             initialier_type = InitializerType.BRACE
             name = name[1:-1].strip()
 
-    return (normalize_angle_brackets(name.strip()), initialier_type)
+    return (
+        normalize_pointer_spacing(normalize_angle_brackets(name.strip())),
+        initialier_type,
+    )
 
 
 def _qualify_text_with_refid(text: str, refid: str) -> str:

scripts/cxx-api/tests/snapshots/should_handle_class_public_method_arguments/snapshot.api

@@ -10,7 +10,7 @@ class test::Clss {
   public void fn7(std::vector<std::vector<std::pair<int, int>>> v);
   public void fn8(std::map<K, std::function<void(A, B)>> m);
   public void fn9(int(*)(int, int) callback);
-  public void fn10(void(*)(const char *, size_t) handler);
+  public void fn10(void(*)(const char*, size_t) handler);
   public void fn11(int(*(*fp)(int))(double));
   public void fn12(int x = 5, std::string s = "default");
   public void fn13(std::function<void()> f = nullptr);

scripts/cxx-api/tests/snapshots/should_handle_concept/snapshot.api

@@ -1,4 +1,4 @@
 template <typename T, typename ReturnT = std::any>
-concept test::CSSParserSink = requires(CSSSyntaxParser &parser) {
+concept test::CSSParserSink = requires(CSSSyntaxParser& parser) {
   { T::consume(parser) } -> std::convertible_to<ReturnT>;
 };

scripts/cxx-api/tests/snapshots/should_handle_concept_indent/snapshot.api

@@ -1,9 +1,9 @@
 template <typename ReturnT, typename... VisitorsT>
-concept test::CSSUniqueComponentValueVisitors = CSSSyntaxVisitorReturn<ReturnT> && (CSSComponentValueVisitor<VisitorsT, ReturnT> && ...) &&
-  ((CSSFunctionVisitor<VisitorsT, ReturnT> ? 1 : 0) + ... + 0) <= 1 &&
-  ((CSSPreservedTokenVisitor<VisitorsT, ReturnT> ? 1 : 0) + ... + 0) <= 1 &&
+concept test::CSSUniqueComponentValueVisitors = CSSSyntaxVisitorReturn<ReturnT>&& (CSSComponentValueVisitor<VisitorsT, ReturnT> && ...) &&
+  ((CSSFunctionVisitor<VisitorsT, ReturnT> ? 1 : 0) + ... + 0) <= 1&&
+  ((CSSPreservedTokenVisitor<VisitorsT, ReturnT> ? 1 : 0) + ... + 0) <= 1&&
   ((CSSSimpleBlockVisitor<VisitorsT, ReturnT> ? 1 : 0) + ... + 0) <= 1;
 template <typename T, typename ReturnT = std::any>
-concept test::CSSParserSink = requires(CSSSyntaxParser &parser) {
+concept test::CSSParserSink = requires(CSSSyntaxParser& parser) {
     { T::consume(parser) } -> std::convertible_to<ReturnT>;
 };

scripts/cxx-api/tests/snapshots/should_handle_deprecated_msg/snapshot.api

@@ -6,8 +6,8 @@ interface RCTDeprecatedInterface {
 }
 
 interface RCTTestInterface {
-  public virtual NSArray * deprecatedMethod:(id param);
-  public virtual void normalMethod:(NSString * name);
+  public virtual NSArray* deprecatedMethod:(id param);
+  public virtual void normalMethod:(NSString* name);
 }
 
 protocol RCTDeprecatedProtocol {

scripts/cxx-api/tests/snapshots/should_handle_function_pointer_variable/snapshot.api

@@ -1,5 +1,5 @@
 struct test::FunctionPointers {
   public int(*withReturn)(double, float);
-  public void *(*returnsPointer)(const char *);
   public void(*simple)(int);
+  public void*(*returnsPointer)(const char *);
 }

scripts/cxx-api/tests/snapshots/should_handle_interface_with_block_property/snapshot.api

@@ -1,5 +1,5 @@
 interface RCTInterfaceWithBlockProperty : public NSObject {
-  public @property (copy) NSString *(^blockWithReturn)(int value);
-  public @property (copy) void(^eventInterceptor)(NSString *eventName, NSDictionary *event, NSNumber *reactTag);
+  public @property (copy) NSString*(^blockWithReturn)(int value);
+  public @property (copy) void(^eventInterceptor)(NSString* eventName, NSDictionary* event, NSNumber* reactTag);
   public @property (copy) void(^simpleBlock)(void);
 }

scripts/cxx-api/tests/snapshots/should_handle_interface_with_method/snapshot.api

@@ -1,5 +1,5 @@
 interface RCTInterfaceWithMethod {
-  public virtual NSString * getTitle();
+  public virtual NSString* getTitle();
   public virtual void doSomething();
-  public virtual void processValue:withName:(int value, NSString * name);
+  public virtual void processValue:withName:(int value, NSString* name);
 }