- Updated the docgen item type for fucntion to include matching based on possible generic implementations '<'.

- Updated the function generator to account for possible generics defined in a functions signature and still generate the comments. Additionally, an update to parsing function arguments where the parameters were split due to ',' now properly handles things like "test: HashMap<String, String>" as a single parameter to the argument.

- Added unit test for new functionality.

Author: chrisdbeard

src/docgen.js

@@ -46,7 +46,7 @@ function generateDocComment(line, options) {
  * @returns {"function"|"struct"|"enum"|null} - The detected item type.
  */
 function getRustItemType(line) {
-    if (/fn\s+\w+\s*\(/.test(line)) return 'function';
+    if (/fn\s+\w+\s*[(<]/.test(line)) return 'function';
     if (/struct\s+\w+/.test(line)) return 'struct';
     if (/enum\s+\w+/.test(line)) return 'enum';
     // if (/trait\s+\w+/.test(line)) return 'trait'; // TODO

src/gen_fn_doc.js

@@ -35,27 +35,22 @@ function generateFunctionDoc(line, includeExamples, examplesOnlyForPublicOrExter
     const hasExtern = !!modifierMatch?.[3];
 
     // Attempt to match a Rust function signature.
-    const fnMatch = cleanLine.match(/fn\s+(\w+)\s*\(([^)]*)\)\s*(?:->\s*([^;{]+))?/);
+    const fnMatch = cleanLine.match(/fn\s+(\w+)\s*(<[^>]*>)?\s*\(([^)]*)\)\s*(?:->\s*([^;{]+))?/);
     if (!fnMatch) return null; // If no match, return nothing (unsupported line)
 
     // Destructure the match results: function name, arguments, and optional return type.
-    const [, name, args, returnType] = fnMatch;
+    const [, name, _generics, args, returnType] = fnMatch;
 
     // Gets the return type.
     const cleanedReturn = returnType ? returnType.trim() : null;
 
     // Sets the tab stop count for the parameter. Description is always 1.
     let currentTabStop = 2;
 
-    // Parse and format each function argument into a markdown line with snippet placeholder.
-    const params = args
-        .split(',')
-        .map(p => p.trim())
-        .filter(Boolean) // Remove empty strings
-        .map(param => {
-            const [argName, argType] = param.split(':').map(s => s.trim());
-            return `- \`${argName}\` (\`${argType}\`) - \${${currentTabStop++}:Describe this parameter.}`;
-        });
+    const params = splitFunctionArgs(args).map(p => p.trim()).filter(Boolean).map(param => {
+        const [argName, argType] = param.split(':').map(s => s.trim());
+        return `- \`${argName}\` (\`${argType}\`) - \${${currentTabStop++}:Describe this parameter.}`;
+    });
 
     // Build the full documentation block line by line.
     const docLines = [];
@@ -117,6 +112,47 @@ function generateFunctionDoc(line, includeExamples, examplesOnlyForPublicOrExter
     ].join('\n');
 }
 
+/**
+ * Splits a Rust function's argument list into individual parameters,
+ * correctly handling nested generics and parentheses.
+ *
+ * This function is necessary because Rust function arguments may contain nested
+ * angle brackets (e.g., `HashMap<String, Vec<u8>>`) or tuples
+ * (e.g., `(i32, f64)`), which would cause a naive `.split(',')` to fail.
+ *
+ * It performs a linear scan of the argument string, tracking nesting levels of
+ * `< >` and `( )`, and only splits on commas that are outside these constructs.
+ *
+ * @param {string} argString - The comma-separated argument list from a Rust function signature.
+ * @returns {string[]} - An array of individual argument strings.
+ *
+ * @example
+ * splitFunctionArgs("x: u32, y: HashMap<String, Vec<u8>>")
+ * // returns: ["x: u32", "y: HashMap<String, Vec<u8>>"]
+ */
+function splitFunctionArgs(argString) {
+    const args = [];
+    let current = '';
+    let angle = 0, paren = 0;
+
+    for (let char of argString) {
+        if (char === '<') angle++;
+        else if (char === '>') angle--;
+        else if (char === '(') paren++;
+        else if (char === ')') paren--;
+
+        if (char === ',' && angle === 0 && paren === 0) {
+            args.push(current.trim());
+            current = '';
+        } else {
+            current += char;
+        }
+    }
+
+    if (current.trim()) args.push(current.trim());
+    return args;
+}
+
 /**
  * Generates the Rust documentation example section based on the function's modifiers.
  *

src/test/extension.test.js

@@ -78,6 +78,32 @@ describe('generateFunctionDoc()', () => {
         assert.ok(output.includes('`i32`'));
     });
 
+    it('handles generic parameters before arguments', () => {
+        const input = 'pub fn write_display<W: FmtWrite>(&self, w: &mut W) -> std::fmt::Result';
+        const output = generateFunctionDoc(input, false, false, false);
+        
+        assert.ok(output.includes('`w` (`&mut W`)'), 'Missing w parameter with generic type');
+        assert.ok(output.includes('&self'), 'Missing &self parameter');
+        assert.ok(output.includes('# Returns'), 'Missing return section');
+        assert.ok(output.includes('`std::fmt::Result`'), 'Missing return type');
+    });
+
+    it('handles nested generic types in arguments', () => {
+        const input = 'fn test(map: HashMap<String, Vec<u8>>)';
+        const output = generateFunctionDoc(input, false, false, false);
+
+        assert.ok(output.includes('# Arguments'), 'Missing arguments section');
+        assert.ok(output.includes('`map` (`HashMap<String, Vec<u8>>`)'), 'Missing correct nested generic param');
+    });
+
+    it('handles multiple complex arguments with nested generics', () => {
+        const input = 'fn process(data: Option<Result<u8, E>>, map: HashMap<String, Vec<u8>>)';
+        const output = generateFunctionDoc(input, false, false, false);
+
+        assert.ok(output.includes('`data` (`Option<Result<u8, E>>`)'), 'Missing complex param `data`');
+        assert.ok(output.includes('`map` (`HashMap<String, Vec<u8>>`)'), 'Missing complex param `map`');
+    });
+
     it('handles unsafe functions', () => {
         const input = 'pub unsafe fn access_raw(ptr: *const u8) -> u8 {';
         const output = generateFunctionDoc(input, true, true, true);