docs(claude): add support of non function typedefs

Author: qubka

parser/README.md

@@ -216,6 +216,20 @@ When a parameter is a function pointer typedef, the complete function signature
 }
 ```
 
+### Parameter or Return Type with Typedef Alias
+
+When a parameter or return type is named via a plain (non-function-pointer) typedef, such as `using MenuId = uint32_t;`, the resolved type is used and the original typedef name (plus its Doxygen description, if any) is preserved in an `alias` structure:
+
+```json
+{
+    "type": "uint32",
+    "description": "A handle to the created menu.",
+    "alias": {
+        "name": "MenuId"
+    }
+}
+```
+
 ### Field Descriptions
 
 - `name`: Function name
@@ -228,11 +242,13 @@ When a parameter is a function pointer typedef, the complete function signature
   - `ref`: Boolean indicating if it's a reference parameter
   - `description`: Parameter description from Doxygen comments (if available)
   - `enum`: (Optional) Full enum structure if parameter is an enum type
+  - `alias`: (Optional) `{name, description}` of the typedef if the parameter is named via a plain typedef (e.g. `MenuId`)
   - `prototype`: (Optional) Full function signature if parameter is a function pointer typedef
 - `retType`: Return type object:
   - `type`: Mapped return type
   - `description`: Return description from Doxygen comments (if available)
   - `enum`: (Optional) Full enum structure if return type is an enum
+  - `alias`: (Optional) `{name, description}` of the typedef if the return type is named via a plain typedef
 
 ## Advanced Features
 
@@ -282,7 +298,7 @@ The script maps C++ types to simplified types:
 | `Vector`, `QAngle`, `plg::vec3` | `vec3` |
 | Enums | Base type (e.g., `uint8`, `int32`) + enum structure |
 | Function pointer typedefs | `function` + prototype structure |
-| Other typedefs | `?` |
+| Other typedefs (e.g. `using MenuId = uint32_t;`) | Underlying type (e.g. `uint32`), resolved recursively through typedef chains + alias structure |
 
 Pointers (except `void*`) are mapped to `ptr64`, and unknown types default to `?`.
 

parser/convert.go

@@ -5,6 +5,10 @@ import "strings"
 // convertType converts a type string into its mapped type and reference flag.
 // Returns (mappedType, isReference), mirroring parser.py's convert_type().
 func convertType(typeStr string, enumsMap map[string]EnumInfo, typedefsMap map[string]TypedefInfo) (string, bool) {
+	return convertTypeSeen(typeStr, enumsMap, typedefsMap, map[string]bool{})
+}
+
+func convertTypeSeen(typeStr string, enumsMap map[string]EnumInfo, typedefsMap map[string]TypedefInfo, seen map[string]bool) (string, bool) {
 	if typeStr == "" {
 		return "?", false
 	}
@@ -40,6 +44,11 @@ func convertType(typeStr string, enumsMap map[string]EnumInfo, typedefsMap map[s
 			return mapped, !constFlag
 		}
 
+		// Check if it's a (non-function-pointer) typedef; resolve to its underlying type
+		if mapped, ok := resolveTypedefBase(baseType, enumsMap, typedefsMap, seen); ok {
+			return mapped, !constFlag
+		}
+
 		return mapType(baseType), !constFlag
 	}
 
@@ -52,9 +61,31 @@ func convertType(typeStr string, enumsMap map[string]EnumInfo, typedefsMap map[s
 		return mapped, false
 	}
 
+	// Check if it's a (non-function-pointer) typedef; resolve to its underlying type
+	if mapped, ok := resolveTypedefBase(t, enumsMap, typedefsMap, seen); ok {
+		return mapped, false
+	}
+
 	return mapType(t), false
 }
 
+// resolveTypedefBase resolves t as a plain (non-function-pointer) typedef name to
+// its underlying mapped type, following typedef chains recursively. Function-pointer
+// typedefs are left alone here - callers handle those separately by emitting a
+// "function" type with a prototype. ok is false when t is not such a typedef.
+func resolveTypedefBase(t string, enumsMap map[string]EnumInfo, typedefsMap map[string]TypedefInfo, seen map[string]bool) (string, bool) {
+	td, ok := typedefsMap[t]
+	if !ok || td.IsFunctionPointer {
+		return "", false
+	}
+	if seen[t] {
+		return "?", true
+	}
+	seen[t] = true
+	mapped, _ := convertTypeSeen(td.Underlying, enumsMap, typedefsMap, seen)
+	return mapped, true
+}
+
 // stripTypeQualifiers strips const/&/* substrings from a type name, mirroring
 // param_type_name.replace('const', ”).replace('&', ”).replace('*', ”).strip().
 func stripTypeQualifiers(s string) string {

parser/function.go

@@ -12,6 +12,7 @@ type Param struct {
 	Ref         bool               `json:"ref"`
 	Description string             `json:"description,omitempty"`
 	Enum        *EnumStruct        `json:"enum,omitempty"`
+	Alias       *AliasStruct       `json:"alias,omitempty"`
 	Prototype   *FunctionPrototype `json:"prototype,omitempty"`
 }
 
@@ -20,6 +21,7 @@ type RetType struct {
 	Type        string             `json:"type"`
 	Description string             `json:"description,omitempty"`
 	Enum        *EnumStruct        `json:"enum,omitempty"`
+	Alias       *AliasStruct       `json:"alias,omitempty"`
 	Prototype   *FunctionPrototype `json:"prototype,omitempty"`
 }
 
@@ -104,10 +106,14 @@ func processFunction(function map[string]interface{}, enumsMap map[string]EnumIn
 			if es := buildEnumStructure(baseTypeName, enumsMap); es != nil {
 				paramData.Enum = es
 			}
-		} else if td, ok := typedefsMap[baseTypeName]; ok && td.IsFunctionPointer {
-			paramData.Type = "function"
-			if proto := buildFunctionPrototype(baseTypeName, typedefsMap, enumsMap); proto != nil {
-				paramData.Prototype = proto
+		} else if td, ok := typedefsMap[baseTypeName]; ok {
+			if td.IsFunctionPointer {
+				paramData.Type = "function"
+				if proto := buildFunctionPrototype(baseTypeName, typedefsMap, enumsMap); proto != nil {
+					paramData.Prototype = proto
+				}
+			} else if alias := buildAliasStructure(baseTypeName, typedefsMap); alias != nil {
+				paramData.Alias = alias
 			}
 		}
 
@@ -132,10 +138,14 @@ func processFunction(function map[string]interface{}, enumsMap map[string]EnumIn
 		if es := buildEnumStructure(baseReturnType, enumsMap); es != nil {
 			retType.Enum = es
 		}
-	} else if td, ok := typedefsMap[baseReturnType]; ok && td.IsFunctionPointer {
-		retType.Type = "function"
-		if proto := buildFunctionPrototype(baseReturnType, typedefsMap, enumsMap); proto != nil {
-			retType.Prototype = proto
+	} else if td, ok := typedefsMap[baseReturnType]; ok {
+		if td.IsFunctionPointer {
+			retType.Type = "function"
+			if proto := buildFunctionPrototype(baseReturnType, typedefsMap, enumsMap); proto != nil {
+				retType.Prototype = proto
+			}
+		} else if alias := buildAliasStructure(baseReturnType, typedefsMap); alias != nil {
+			retType.Alias = alias
 		}
 	}
 

parser/parser.py

@@ -149,14 +149,35 @@ def map_type(t: str):
     return switch_dict.get(t, '?')
 
 
-def convert_type(type_str: str, enums_map: dict, typedefs_map: dict):
+def resolve_typedef_base(t: str, enums_map: dict, typedefs_map: dict, seen: set):
+    """
+    Resolve t as a plain (non-function-pointer) typedef name to its underlying
+    mapped type, following typedef chains recursively. Function-pointer typedefs
+    are left alone here - callers handle those separately by emitting a
+    "function" type with a prototype. Returns (mapped_type, True) if t is such a
+    typedef, or (None, False) otherwise.
+    """
+    typedef_info = typedefs_map.get(t)
+    if not typedef_info or typedef_info.get('IsFunctionPointer'):
+        return None, False
+    if t in seen:
+        return '?', True
+    seen.add(t)
+    mapped, _ = convert_type(typedef_info.get('Underlying', ''), enums_map, typedefs_map, seen)
+    return mapped, True
+
+
+def convert_type(type_str: str, enums_map: dict, typedefs_map: dict, seen: set = None):
     """
     Convert type string into its mapped type and reference flag.
     Returns (mapped_type, is_reference)
     """
     if not type_str:
         return '?', False
 
+    if seen is None:
+        seen = set()
+
     const = False
     t = type_str.strip()
 
@@ -181,19 +202,21 @@ def convert_type(type_str: str, enums_map: dict, typedefs_map: dict):
             mapped = enums_map[base_type].get('BaseType', '?')
             return mapped, not const
 
-        # Check if it's a typedef
-        #if base_type in typedefs_map:
-        #    return '?', not const  # Typedefs usually stay as '?'
+        # Check if it's a typedef; resolve to its underlying type
+        mapped, is_typedef = resolve_typedef_base(base_type, enums_map, typedefs_map, seen)
+        if is_typedef:
+            return mapped, not const
 
         return map_type(base_type), not const
 
     # Check if it's an enum
     if t in enums_map:
         return enums_map[t].get('BaseType', '?'), False
 
-    # Check if it's a typedef
-    #if t in typedefs_map:
-    #    return '?', False  # Typedefs usually stay as '?'
+    # Check if it's a typedef; resolve to its underlying type
+    mapped, is_typedef = resolve_typedef_base(t, enums_map, typedefs_map, seen)
+    if is_typedef:
+        return mapped, False
 
     return map_type(t), False
 
@@ -506,6 +529,19 @@ def build_enum_structure(enum_name: str, enums_map: dict, filter_sentinel_values
     return enum_struct
 
 
+def build_alias_structure(typedef_name: str, typedefs_map: dict):
+    """Build alias structure for a resolved, non-function-pointer typedef."""
+    typedef_info = typedefs_map.get(typedef_name)
+    if not typedef_info or typedef_info.get('IsFunctionPointer'):
+        return None
+
+    alias_struct = {'name': typedef_name}
+    if typedef_info.get('Description'):
+        alias_struct['description'] = typedef_info['Description']
+
+    return alias_struct
+
+
 def build_function_prototype(typedef_name: str, typedefs_map: dict, enums_map: dict):
     """Build function prototype structure for function pointer typedefs."""
     if typedef_name not in typedefs_map:
@@ -549,6 +585,10 @@ def build_function_prototype(typedef_name: str, typedefs_map: dict, enums_map: d
             enum_struct = build_enum_structure(base_type_name, enums_map)
             if enum_struct:
                 param_data['enum'] = enum_struct
+        else:
+            alias_struct = build_alias_structure(base_type_name, typedefs_map)
+            if alias_struct:
+                param_data['alias'] = alias_struct
 
         param_types_list.append(param_data)
 
@@ -576,6 +616,12 @@ def build_function_prototype(typedef_name: str, typedefs_map: dict, enums_map: d
         if prototype:
             ret_type['prototype'] = prototype
 
+    # Check if return type is a plain typedef and add alias structure
+    elif base_return_type in typedefs_map:
+        alias_struct = build_alias_structure(base_return_type, typedefs_map)
+        if alias_struct:
+            ret_type['alias'] = alias_struct
+
     prototype['retType'] = ret_type
 
     return prototype
@@ -645,6 +691,12 @@ def process_function(function, enums_map, typedefs_map, group_name=None):
             if prototype:
                 param_data['prototype'] = prototype
 
+        # Check if parameter is a plain typedef and add alias structure
+        elif base_type_name in typedefs_map:
+            alias_struct = build_alias_structure(base_type_name, typedefs_map)
+            if alias_struct:
+                param_data['alias'] = alias_struct
+
         param_types.append(param_data)
 
     # Process return type
@@ -673,6 +725,12 @@ def process_function(function, enums_map, typedefs_map, group_name=None):
         if prototype:
             ret_type['prototype'] = prototype
 
+    # Check if return type is a plain typedef and add alias structure
+    elif base_return_type in typedefs_map:
+        alias_struct = build_alias_structure(base_return_type, typedefs_map)
+        if alias_struct:
+            ret_type['alias'] = alias_struct
+
     # Build final function data
     function_data = {
         'name': func_name,

parser/typedefs.go

@@ -16,6 +16,26 @@ type TypedefInfo struct {
 	ParamTypes        []string
 }
 
+// AliasStruct records that a parameter/return type was named via a plain
+// (non-function-pointer) typedef, embedded into a Param or RetType.
+type AliasStruct struct {
+	Name        string `json:"name"`
+	Description string `json:"description,omitempty"`
+}
+
+// buildAliasStructure builds an alias structure for a resolved, non-function-pointer typedef.
+func buildAliasStructure(typedefName string, typedefsMap map[string]TypedefInfo) *AliasStruct {
+	td, ok := typedefsMap[typedefName]
+	if !ok || td.IsFunctionPointer {
+		return nil
+	}
+	alias := &AliasStruct{Name: typedefName}
+	if td.Description != "" {
+		alias.Description = td.Description
+	}
+	return alias
+}
+
 var fnPtrReturnTypeRe = regexp.MustCompile(`^\s*(.+?)\s*\(\*\)`)
 
 // parseFunctionPointerSignature parses a function pointer signature string, e.g.
@@ -139,6 +159,8 @@ func buildFunctionPrototype(typedefName string, typedefsMap map[string]TypedefIn
 			if es := buildEnumStructure(baseTypeName, enumsMap); es != nil {
 				paramData.Enum = es
 			}
+		} else if alias := buildAliasStructure(baseTypeName, typedefsMap); alias != nil {
+			paramData.Alias = alias
 		}
 
 		paramTypesList = append(paramTypesList, paramData)
@@ -155,10 +177,14 @@ func buildFunctionPrototype(typedefName string, typedefsMap map[string]TypedefIn
 		if es := buildEnumStructure(baseReturnType, enumsMap); es != nil {
 			retType.Enum = es
 		}
-	} else if td, ok := typedefsMap[baseReturnType]; ok && td.IsFunctionPointer {
-		retType.Type = "function"
-		if p := buildFunctionPrototype(baseReturnType, typedefsMap, enumsMap); p != nil {
-			retType.Prototype = p
+	} else if td, ok := typedefsMap[baseReturnType]; ok {
+		if td.IsFunctionPointer {
+			retType.Type = "function"
+			if p := buildFunctionPrototype(baseReturnType, typedefsMap, enumsMap); p != nil {
+				retType.Prototype = p
+			}
+		} else if alias := buildAliasStructure(baseReturnType, typedefsMap); alias != nil {
+			retType.Alias = alias
 		}
 	}
 	proto.RetType = retType