fix(affected.py): Fix detection when argument names don't match

Author: lucasssvaz

.github/scripts/get_affected.py

@@ -222,6 +222,80 @@ def detect_universal_ctags() -> bool:
     except Exception:
         return False
 
+def normalize_function_signature(signature: str) -> str:
+    """
+    Normalize a function signature by removing parameter names, keeping only types.
+
+    This handles cases where header declarations and implementations have different parameter names.
+    Uses a simple heuristic: the last word in each parameter is typically the parameter name.
+
+    For example:
+    - "ltoa(long val, char *s, int radix)" -> "ltoa(long,char *,int)"
+    - "ltoa(long value, char *result, int base)" -> "ltoa(long,char *,int)"
+
+    Args:
+        signature: The function signature string, e.g., "(long val, char *s, int radix)"
+
+    Returns:
+        Normalized signature with parameter names removed, e.g., "(long,char *,int)"
+    """
+    if not signature:
+        return signature
+
+    # Normalize signatures: treat (void) and () as equivalent (both mean no parameters)
+    if signature == "(void)":
+        return "()"
+
+    if not (signature.startswith("(") and signature.endswith(")")):
+        return signature
+
+    # Handle const qualifier at the end (e.g., "(int i) const")
+    const_qualifier = ""
+    if signature.endswith(" const"):
+        signature = signature[:-6]  # Remove " const"
+        const_qualifier = " const"
+
+    # Extract parameter list without parentheses
+    param_list = signature[1:-1]
+    if not param_list.strip():
+        return "()" + const_qualifier
+
+    # Split by comma and process each parameter
+    params = []
+    for param in param_list.split(","):
+        param = param.strip()
+        if not param:
+            continue
+
+        # Handle default parameters (e.g., "int x = 5")
+        if "=" in param:
+            param = param.split("=")[0].strip()
+
+        # Simple heuristic: remove the last word (parameter name)
+        # This works for most cases: "int x" -> "int", "char *ptr" -> "char *"
+        tokens = param.split()
+        if len(tokens) > 1:
+            # Check if the last token starts with * (like *ptr) - this is a pointer parameter name
+            if tokens[-1].startswith('*'):
+                # Remove the last token and add * to the type
+                type_tokens = tokens[:-1] + ['*']
+                params.append(" ".join(type_tokens))
+            else:
+                # Remove the last token (parameter name)
+                type_tokens = tokens[:-1]
+                params.append(" ".join(type_tokens))
+        else:
+            # Single word - could be a type or parameter name
+            # In C/C++, single-word parameters are rare, so we assume it's a type
+            # This handles both basic types (int, char) and typedefs (MACType, boolean)
+            params.append(tokens[0])
+
+    result = "(" + ",".join(params) + ")"
+    if const_qualifier:
+        result += const_qualifier
+
+    return result
+
 def build_qname_from_tag(tag: dict) -> str:
     """
     Compose a qualified name for a function/method using scope + name + signature.
@@ -231,9 +305,8 @@ def build_qname_from_tag(tag: dict) -> str:
     name = tag.get("name") or ""
     signature = tag.get("signature") or ""
 
-    # Normalize signatures: treat (void) and () as equivalent (both mean no parameters)
-    if signature == "(void)":
-        signature = "()"
+    # Normalize the signature to remove parameter names
+    signature = normalize_function_signature(signature)
 
     qparts = []
     if scope: