objcjs-types 0.4.0 → 0.5.0

package/generator/ast-parser.ts

@@ -7,7 +7,7 @@ import type { ClangASTNode } from "./clang.ts";
 export interface ObjCMethod {
   selector: string;
   returnType: string;
-  parameters: { name: string; type: string }[];
+  parameters: { name: string; type: string; blockParamNames?: string[] }[];
   isClassMethod: boolean;
   isDeprecated: boolean;
   deprecationMessage?: string;
@@ -484,6 +484,224 @@ function scanForDeprecation(
   return { isDeprecated: false };
 }
 
+// --- Block parameter name extraction from header source ---
+
+/**
+ * Extract block parameter names from header source text for a method declaration.
+ *
+ * Clang's AST strips parameter names from block qualType strings. For example,
+ * `void (^)(ObjectType obj, NSUInteger idx, BOOL *stop)` becomes
+ * `void (^)(ObjectType _Nonnull, NSUInteger, BOOL * _Nonnull)` in the AST.
+ *
+ * This function reads the raw header source text around the method declaration line
+ * and extracts the actual parameter names from the block's inner parameter list.
+ *
+ * @returns An array of block param name arrays, one per block-typed parameter,
+ *   in the order they appear in the method declaration. Returns empty array if
+ *   no block parameters are found or source is unavailable.
+ */
+function extractBlockParamNamesFromMethod(
+  methodNode: ClangASTNode,
+  headerLines: string[] | undefined,
+  headerLinesMap?: Map<string, string[]>,
+  contextFile?: string
+): string[][] {
+  const lines = resolveHeaderLines(methodNode, headerLines, headerLinesMap, contextFile);
+  if (!lines) return [];
+
+  const line = getLocLine(methodNode);
+  if (!line || line < 1 || line > lines.length) return [];
+
+  // Grab a window of source text: the declaration line + up to 20 lines after
+  // (ObjC method declarations can span many lines with long block param types)
+  const startLine = Math.max(0, line - 1);
+  const endLine = Math.min(lines.length, line + 20);
+  const sourceChunk = lines.slice(startLine, endLine).join(" ");
+
+  return extractBlockParamNamesFromText(sourceChunk);
+}
+
+/**
+ * Extract block parameter names from a chunk of ObjC source text.
+ *
+ * Finds all block parameter patterns `(^...)(param_list)` and extracts the
+ * last identifier from each comma-separated parameter in the inner list.
+ *
+ * For example, from:
+ *   `- (void)enumerateObjectsUsingBlock:(void (NS_NOESCAPE ^)(ObjectType obj, NSUInteger idx, BOOL *stop))block;`
+ * Extracts: `[["obj", "idx", "stop"]]`
+ */
+function extractBlockParamNamesFromText(source: string): string[][] {
+  const results: string[][] = [];
+
+  // Find each block type pattern in ObjC source.
+  // Block types appear as: ReturnType (^)(ParamList) or ReturnType (NS_NOESCAPE ^)(ParamList)
+  // The caret (^) marks a block pointer, possibly preceded by annotations like NS_NOESCAPE.
+  // We search for ^ and then look for the enclosing (...) and the parameter list (...) after it.
+  let pos = 0;
+  while (pos < source.length) {
+    const caretIdx = source.indexOf("^", pos);
+    if (caretIdx === -1) break;
+
+    // Find the opening ( that contains this ^
+    // Walk backward from ^ to find the matching (
+    let openParen = caretIdx - 1;
+    while (openParen >= 0 && source[openParen] !== "(") {
+      // Only skip whitespace and known annotations between ( and ^
+      if (/\s/.test(source[openParen]!) || /[A-Za-z_]/.test(source[openParen]!)) {
+        openParen--;
+      } else {
+        break;
+      }
+    }
+
+    if (openParen < 0 || source[openParen] !== "(") {
+      pos = caretIdx + 1;
+      continue;
+    }
+
+    // Verify the text between ( and ^ is whitespace or known annotations
+    const betweenText = source.slice(openParen + 1, caretIdx).trim();
+    const validAnnotations =
+      /^(NS_NOESCAPE|NS_SWIFT_SENDABLE|NS_SWIFT_NONISOLATED|NS_SWIFT_UI_ACTOR|__nullable|__nonnull|_Nullable|_Nonnull|\s)*$/;
+    if (betweenText && !validAnnotations.test(betweenText)) {
+      pos = caretIdx + 1;
+      continue;
+    }
+
+    // Find the closing ) of (^...) from the caret position
+    let i = caretIdx + 1;
+    let depth = 1; // We're inside the ( that openParen points to
+    while (i < source.length && depth > 0) {
+      if (source[i] === "(") depth++;
+      else if (source[i] === ")") depth--;
+      i++;
+    }
+    // i now points past the closing ) of (^...)
+
+    // Skip whitespace
+    while (i < source.length && /\s/.test(source[i]!)) i++;
+
+    // Expect opening ( for the parameter list
+    if (i >= source.length || source[i] !== "(") {
+      pos = i;
+      continue;
+    }
+
+    // Find the matching close paren for the parameter list
+    const paramStart = i + 1;
+    depth = 1;
+    i++;
+    while (i < source.length && depth > 0) {
+      if (source[i] === "(") depth++;
+      else if (source[i] === ")") depth--;
+      i++;
+    }
+    const paramEnd = i - 1;
+    const paramStr = source.slice(paramStart, paramEnd).trim();
+
+    pos = i;
+
+    // Skip void / empty parameter lists
+    if (paramStr === "void" || paramStr === "") {
+      results.push([]);
+      continue;
+    }
+
+    // Split by comma, respecting nested parens (for nested blocks/function pointers)
+    const params = splitByComma(paramStr);
+    const names: string[] = [];
+    for (const p of params) {
+      const name = extractLastIdentifier(p.trim());
+      names.push(name ?? "");
+    }
+    results.push(names);
+  }
+
+  return results;
+}
+
+/**
+ * Split a parameter list string by commas, respecting nested parentheses and angle brackets.
+ */
+function splitByComma(s: string): string[] {
+  const parts: string[] = [];
+  let depth = 0;
+  let angleDepth = 0;
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === "<") angleDepth++;
+    else if (ch === ">") angleDepth--;
+    else if (ch === "," && depth === 0 && angleDepth === 0) {
+      parts.push(s.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(s.slice(start));
+  return parts;
+}
+
+/**
+ * Extract the last identifier (parameter name) from a single ObjC parameter declaration.
+ *
+ * Examples:
+ *   "ObjectType obj" → "obj"
+ *   "NSUInteger idx" → "idx"
+ *   "BOOL *stop" → "stop"
+ *   "void (^handler)(BOOL granted)" → null (nested block — name is outside)
+ *   "NSData *" → null (no name)
+ *   "id" → null (type-only)
+ *
+ * Strips nullability annotations and API_AVAILABLE macros first.
+ */
+function extractLastIdentifier(param: string): string | null {
+  // Strip nullability annotations and common macros
+  let cleaned = param
+    .replace(/\b_Nonnull\b/g, "")
+    .replace(/\b_Nullable\b/g, "")
+    .replace(/\b__nonnull\b/g, "")
+    .replace(/\b__nullable\b/g, "")
+    .replace(/\bNS_NOESCAPE\b/g, "")
+    .replace(/\bNS_SWIFT_SENDABLE\b/g, "")
+    .replace(/\bNS_SWIFT_NONISOLATED\b/g, "")
+    .replace(/\bNS_SWIFT_UI_ACTOR\b/g, "")
+    .replace(/\b__kindof\b/g, "")
+    .replace(/\bAPI_AVAILABLE\([^)]*\)/g, "")
+    .replace(/\bAPI_UNAVAILABLE\([^)]*\)/g, "")
+    .replace(/\bAPI_DEPRECATED\([^)]*\)/g, "")
+    .trim();
+
+  // If it contains a nested block `(^`, the name would be inside the (^name) part
+  // or after the whole block type — but those are outer param names, not inner block params.
+  // For nested block params, don't try to extract.
+  if (cleaned.includes("(^")) return null;
+
+  // For pointer types: look for identifier after the last *
+  const lastStar = cleaned.lastIndexOf("*");
+  if (lastStar !== -1) {
+    const afterStar = cleaned.slice(lastStar + 1).trim();
+    if (afterStar && /^[a-zA-Z_]\w*$/.test(afterStar)) {
+      return afterStar;
+    }
+    return null;
+  }
+
+  // For non-pointer types: the last word is the name (if there are multiple words)
+  const words = cleaned.split(/\s+/).filter((w) => w.length > 0);
+  if (words.length < 2) return null;
+
+  const lastWord = words[words.length - 1]!;
+  // Verify it looks like an identifier
+  if (/^[a-zA-Z_]\w*$/.test(lastWord)) {
+    return lastWord;
+  }
+
+  return null;
+}
+
 /**
  * Parse a clang AST root node and extract all ObjC class declarations.
  * Merges categories into their base class.
@@ -539,13 +757,32 @@ export function parseAST(
     const deprecated = attrDeprecated || sourceDeprecation.isDeprecated;
     const description = extractDescription(node) ?? scanForDocComment(node, headerLines, headerLinesMap, contextFile);
 
-    const parameters: { name: string; type: string }[] = [];
+    const parameters: { name: string; type: string; blockParamNames?: string[] }[] = [];
+    // Extract block parameter names from header source for this method declaration
+    let blockParamNamesList: string[][] | undefined;
     if (node.inner) {
       for (const child of node.inner) {
         if (child.kind === "ParmVarDecl") {
+          const qualType = child.type?.qualType ?? "id";
+          let blockParamNames: string[] | undefined;
+
+          // For block-typed parameters, extract inner param names from source
+          if (qualType.includes("(^")) {
+            if (!blockParamNamesList) {
+              blockParamNamesList = extractBlockParamNamesFromMethod(node, headerLines, headerLinesMap, contextFile);
+            }
+            // Match this block parameter to the next entry in the extracted names list
+            // by counting which block-typed ParmVarDecl we're on
+            const blockIdx = parameters.filter((p) => p.type.includes("(^")).length;
+            if (blockParamNamesList[blockIdx] && blockParamNamesList[blockIdx]!.length > 0) {
+              blockParamNames = blockParamNamesList[blockIdx];
+            }
+          }
+
           parameters.push({
             name: child.name ?? "arg",
-            type: child.type?.qualType ?? "id"
+            type: qualType,
+            ...(blockParamNames ? { blockParamNames } : {})
           });
         }
       }
@@ -716,13 +953,31 @@ export function parseProtocols(
     const deprecated = attrDeprecated || sourceDeprecation.isDeprecated;
     const description = extractDescription(node) ?? scanForDocComment(node, headerLines, headerLinesMap, contextFile);
 
-    const parameters: { name: string; type: string }[] = [];
+    const parameters: { name: string; type: string; blockParamNames?: string[] }[] = [];
+    // Extract block parameter names from header source for this method declaration
+    let blockParamNamesList: string[][] | undefined;
     if (node.inner) {
       for (const child of node.inner) {
         if (child.kind === "ParmVarDecl") {
+          const qualType = child.type?.qualType ?? "id";
+          let blockParamNames: string[] | undefined;
+
+          // For block-typed parameters, extract inner param names from source
+          if (qualType.includes("(^")) {
+            if (!blockParamNamesList) {
+              blockParamNamesList = extractBlockParamNamesFromMethod(node, headerLines, headerLinesMap, contextFile);
+            }
+            // Match this block parameter to the next entry in the extracted names list
+            const blockIdx = parameters.filter((p) => p.type.includes("(^")).length;
+            if (blockParamNamesList[blockIdx] && blockParamNamesList[blockIdx]!.length > 0) {
+              blockParamNames = blockParamNamesList[blockIdx];
+            }
+          }
+
           parameters.push({
             name: child.name ?? "arg",
-            type: child.type?.qualType ?? "id"
+            type: qualType,
+            ...(blockParamNames ? { blockParamNames } : {})
           });
         }
       }
@@ -1033,6 +1288,117 @@ export function parseStringEnums(root: ClangASTNode, targetEnums: Set<string>):
   return enums;
 }
 
+/**
+ * Parse a clang AST root node and extract integer typed extensible enums.
+ *
+ * These appear as TypedefDecl nodes with a SwiftNewTypeAttr child and an
+ * NSInteger/NSUInteger underlying type (e.g., `typedef NSInteger ASCOSEAlgorithmIdentifier
+ * NS_TYPED_EXTENSIBLE_ENUM;`). Their values are static const VarDecl nodes
+ * whose type.typeAliasDeclId links back to the TypedefDecl.
+ *
+ * @param targetEnums - Set of integer typed enum names to extract (from discovery)
+ */
+export function parseIntegerTypedEnums(root: ClangASTNode, targetEnums: Set<string>): Map<string, ObjCIntegerEnum> {
+  const enums = new Map<string, ObjCIntegerEnum>();
+  // Map from TypedefDecl id → enum name, for linking VarDecls
+  const typedefIdToName = new Map<string, string>();
+
+  function walkForTypedefs(node: ClangASTNode): void {
+    if (node.kind === "TypedefDecl" && node.name && targetEnums.has(node.name)) {
+      // Check for SwiftNewTypeAttr in inner (marks NS_TYPED_EXTENSIBLE_ENUM)
+      const hasSwiftNewType = node.inner?.some((child) => child.kind === "SwiftNewTypeAttr") ?? false;
+
+      // Check that the underlying type is an integer type
+      const qualType = node.type?.qualType ?? "";
+      const desugared = node.type?.desugaredQualType ?? "";
+      const isIntegerType =
+        qualType === "NSInteger" || qualType === "NSUInteger" || desugared === "long" || desugared === "unsigned long";
+
+      if (hasSwiftNewType && isIntegerType) {
+        typedefIdToName.set(node.id, node.name);
+        if (!enums.has(node.name)) {
+          enums.set(node.name, {
+            kind: "integer",
+            name: node.name,
+            underlyingType: qualType,
+            isOptions: false,
+            values: []
+          });
+        }
+      }
+    }
+
+    if (node.inner) {
+      for (const child of node.inner) {
+        walkForTypedefs(child);
+      }
+    }
+  }
+
+  function walkForVarDecls(node: ClangASTNode): void {
+    if (node.kind === "VarDecl" && node.name && node.storageClass === "static" && node.type?.typeAliasDeclId) {
+      const enumName = typedefIdToName.get(node.type.typeAliasDeclId);
+      if (enumName) {
+        const enumDef = enums.get(enumName);
+        if (enumDef) {
+          // Extract integer value from the initializer expression tree
+          const value = extractIntegerValue(node);
+          if (value !== null) {
+            enumDef.values.push({ name: node.name, value });
+          }
+        }
+      }
+    }
+
+    if (node.inner) {
+      for (const child of node.inner) {
+        walkForVarDecls(child);
+      }
+    }
+  }
+
+  // First pass: find TypedefDecl nodes
+  walkForTypedefs(root);
+  // Second pass: find VarDecl nodes that reference the typedefs
+  walkForVarDecls(root);
+
+  return enums;
+}
+
+/**
+ * Extract an integer value from a VarDecl's initializer expression tree.
+ * Handles IntegerLiteral, UnaryOperator("-"), and ImplicitCastExpr wrappers.
+ * Returns the value as a string, or null if it can't be extracted.
+ */
+function extractIntegerValue(node: ClangASTNode): string | null {
+  if (!node.inner) return null;
+
+  function evaluate(n: ClangASTNode): number | null {
+    if (n.kind === "IntegerLiteral" && n.value !== undefined) {
+      return parseInt(n.value, 10);
+    }
+    if (n.kind === "UnaryOperator" && (n as any).opcode === "-" && n.inner?.length === 1) {
+      const operand = evaluate(n.inner[0]!);
+      return operand !== null ? -operand : null;
+    }
+    // Walk through transparent wrappers (ImplicitCastExpr, ParenExpr, ConstantExpr, etc.)
+    if (n.inner?.length === 1) {
+      return evaluate(n.inner[0]!);
+    }
+    // Try all children for multi-child wrappers
+    if (n.inner) {
+      for (const child of n.inner) {
+        const val = evaluate(child);
+        if (val !== null) return val;
+      }
+    }
+    return null;
+  }
+
+  const val = evaluate(node);
+  return val !== null ? String(val) : null;
+}
+
 // --- Struct parsing ---
 
 /**

package/generator/custom.ts

@@ -23,6 +23,7 @@ import {
   parseAST,
   parseProtocols,
   parseIntegerEnums,
+  parseIntegerTypedEnums,
   parseStringEnums,
   parseStructs,
   parseTypedefs
@@ -839,6 +840,11 @@ async function main(): Promise<void> {
   const parsedClasses = parseAST(ast, customDiscovery.classes);
   const parsedProtocols = parseProtocols(ast, customDiscovery.protocols);
   const parsedIntegerEnums = parseIntegerEnums(ast, customDiscovery.integerEnums);
+  // Also parse integer typed extensible enums (typedef NSInteger Foo NS_TYPED_EXTENSIBLE_ENUM)
+  const intTypedEnums = parseIntegerTypedEnums(ast, customDiscovery.integerEnums);
+  for (const [name, enumDef] of intTypedEnums) {
+    if (!parsedIntegerEnums.has(name)) parsedIntegerEnums.set(name, enumDef);
+  }
   const parsedStringEnums = parseStringEnums(ast, customDiscovery.stringEnums);
 
   const parseTime = ((performance.now() - parseStart) / 1000).toFixed(1);

package/generator/discover.ts

@@ -27,11 +27,12 @@ const CATEGORY_RE = /@interface\s+\w+(?:<[^>]*>)?\s*\(/;
 const PROTOCOL_RE = /@protocol\s+(\w+)/;
 
 /**
- * Matches NS_ENUM / NS_OPTIONS integer enum declarations.
+ * Matches NS_ENUM / NS_OPTIONS / NS_CLOSED_ENUM integer enum declarations.
  * e.g., `typedef NS_ENUM(NSInteger, NSWindowStyleMask) {`
  * e.g., `typedef NS_OPTIONS(NSUInteger, NSWindowStyleMask) {`
+ * e.g., `typedef NS_CLOSED_ENUM(NSInteger, NSComparisonResult) {`
  */
-const NS_ENUM_RE = /typedef\s+NS_(?:ENUM|OPTIONS)\s*\(\s*\w+\s*,\s*(\w+)\s*\)/;
+const NS_ENUM_RE = /typedef\s+NS_(?:ENUM|OPTIONS|CLOSED_ENUM)\s*\(\s*\w+\s*,\s*(\w+)\s*\)/;
 
 /**
  * Matches NS_TYPED_EXTENSIBLE_ENUM / NS_STRING_ENUM / NS_TYPED_ENUM string enum declarations.
@@ -41,6 +42,22 @@ const NS_ENUM_RE = /typedef\s+NS_(?:ENUM|OPTIONS)\s*\(\s*\w+\s*,\s*(\w+)\s*\)/;
  */
 const NS_STRING_ENUM_RE = /typedef\s+NSString\s*\*\s*(\w+)\s+NS_(?:TYPED_EXTENSIBLE_ENUM|STRING_ENUM|TYPED_ENUM)/;
 
+/**
+ * Matches integer-typed NS_TYPED_EXTENSIBLE_ENUM / NS_TYPED_ENUM declarations.
+ * These are NSInteger/NSUInteger typedefs with the macro trailing after the name.
+ * e.g., `typedef NSInteger ASCOSEAlgorithmIdentifier NS_TYPED_EXTENSIBLE_ENUM;`
+ * e.g., `typedef NSInteger NSModalResponse NS_TYPED_EXTENSIBLE_ENUM;`
+ * Their values are declared as `static TypeName const ConstantName = value;`.
+ */
+const NS_INTEGER_TYPED_ENUM_RE = /typedef\s+NSU?Integer\s+(\w+)\s+NS_(?:TYPED_EXTENSIBLE_ENUM|TYPED_ENUM)/;
+
+/**
+ * Matches NS_ERROR_ENUM declarations.
+ * e.g., `typedef NS_ERROR_ENUM(NSURLErrorDomain, NSURLError) {`
+ * Captures the error type name (second parameter), not the domain.
+ */
+const NS_ERROR_ENUM_RE = /typedef\s+NS_ERROR_ENUM\s*\(\s*\w+\s*,\s*(\w+)\s*\)/;
+
 /**
  * Scan all .h files in a framework's Headers directory and discover
  * every ObjC class and protocol declaration, mapping each to its header file.
@@ -104,6 +121,26 @@ export async function discoverFramework(headersPath: string): Promise<DiscoveryR
           stringEnums.set(name, headerName);
         }
       }
+
+      // --- Integer typed extensible enum declarations ---
+      // e.g., `typedef NSInteger ASCOSEAlgorithmIdentifier NS_TYPED_EXTENSIBLE_ENUM;`
+      const intTypedEnumMatch = NS_INTEGER_TYPED_ENUM_RE.exec(line);
+      if (intTypedEnumMatch) {
+        const name = intTypedEnumMatch[1]!;
+        if (!integerEnums.has(name)) {
+          integerEnums.set(name, headerName);
+        }
+      }
+
+      // --- Error enum declarations (NS_ERROR_ENUM) ---
+      // e.g., `typedef NS_ERROR_ENUM(WKWebExtensionErrorDomain, WKWebExtensionError) {`
+      const errorEnumMatch = NS_ERROR_ENUM_RE.exec(line);
+      if (errorEnumMatch) {
+        const name = errorEnumMatch[1]!;
+        if (!integerEnums.has(name)) {
+          integerEnums.set(name, headerName);
+        }
+      }
     }
   }
 

package/generator/emitter.ts

@@ -111,11 +111,15 @@ function collectReferencedStructs(cls: ObjCClass): Set<string> {
   const refs = new Set<string>();
 
   function extractStructRefs(typeStr: string): void {
-    for (const structName of STRUCT_TS_TYPES) {
-      // Match the struct name as a whole word in the mapped type string.
-      // Struct types appear as bare names (e.g., "CGRect") or in union (e.g., "CGRect | null").
-      if (typeStr === structName || typeStr.startsWith(structName + " ")) {
-        refs.add(structName);
+    // Match all identifiers and check against known struct types.
+    // Uses [a-zA-Z_] to catch both uppercase (CGRect) and lowercase (simd_float4x4,
+    // timespec, ether_addr) struct type names appearing anywhere in the type string,
+    // including inside block/function types like "(arg0: CGRect) => void".
+    const words = typeStr.match(/\b[a-zA-Z_]\w*\b/g);
+    if (!words) return;
+    for (const word of words) {
+      if (STRUCT_TS_TYPES.has(word)) {
+        refs.add(word);
       }
     }
   }
@@ -291,7 +295,7 @@ function emitMethodSignature(method: ObjCMethod, containingClass: string): strin
   const params: string[] = [];
   const seenNames = new Map<string, number>();
   for (const param of method.parameters) {
-    const tsType = mapParamType(param.type, containingClass);
+    const tsType = mapParamType(param.type, containingClass, param.blockParamNames);
     // Sanitize param name (avoid TS reserved words)
     let safeName = sanitizeParamName(param.name);
     // Deduplicate: append numeric suffix for repeated parameter names
@@ -1101,13 +1105,14 @@ function collectReferencedEnums(cls: ObjCClass): Set<string> {
   const strEnums = getKnownStringEnums();
 
   function extractEnumRefs(typeStr: string): void {
-    // Enum types appear as bare names (e.g., "ASAuthorizationPublicKeyCredentialAttestationKind")
-    // or in union with null (e.g., "ASAuthorizationPublicKeyCredentialAttestationKind | null").
-    // Split on " | " to handle union types.
-    for (const part of typeStr.split(" | ")) {
-      const trimmed = part.trim();
-      if (intEnums.has(trimmed) || strEnums.has(trimmed)) {
-        refs.add(trimmed);
+    // Match capitalized identifiers and check against known enum types.
+    // This handles enums appearing anywhere in the type string, including
+    // inside block/function types like "(arg0: NobjcObject) => NSComparisonResult".
+    const words = typeStr.match(/\b[A-Z]\w*\b/g);
+    if (!words) return;
+    for (const word of words) {
+      if (intEnums.has(word) || strEnums.has(word)) {
+        refs.add(word);
       }
     }
   }
@@ -1136,10 +1141,11 @@ function collectProtocolReferencedEnums(proto: ObjCProtocol): Set<string> {
   const strEnums = getKnownStringEnums();
 
   function extractEnumRefs(typeStr: string): void {
-    for (const part of typeStr.split(" | ")) {
-      const trimmed = part.trim();
-      if (intEnums.has(trimmed) || strEnums.has(trimmed)) {
-        refs.add(trimmed);
+    const words = typeStr.match(/\b[A-Z]\w*\b/g);
+    if (!words) return;
+    for (const word of words) {
+      if (intEnums.has(word) || strEnums.has(word)) {
+        refs.add(word);
       }
     }
   }
@@ -1205,9 +1211,12 @@ function collectProtocolReferencedStructs(proto: ObjCProtocol): Set<string> {
   const refs = new Set<string>();
 
   function extractStructRefs(typeStr: string): void {
-    for (const structName of STRUCT_TS_TYPES) {
-      if (typeStr === structName || typeStr.startsWith(structName + " ")) {
-        refs.add(structName);
+    // Match all identifiers (including lowercase like simd_float4x4, timespec, ether_addr)
+    const words = typeStr.match(/\b[a-zA-Z_]\w*\b/g);
+    if (!words) return;
+    for (const word of words) {
+      if (STRUCT_TS_TYPES.has(word)) {
+        refs.add(word);
       }
     }
   }
@@ -1339,7 +1348,7 @@ export function emitProtocolFile(
       const params: string[] = [];
       const seenNames = new Map<string, number>();
       for (const param of method.parameters) {
-        const tsType = mapParamType(param.type, proto.name);
+        const tsType = mapParamType(param.type, proto.name, param.blockParamNames);
         let safeName = sanitizeParamName(param.name);
         // Deduplicate: append numeric suffix for repeated parameter names
         const prev = seenNames.get(safeName) ?? 0;
@@ -1819,18 +1828,17 @@ function extractFunctionTypeRefs(
     classRefs.add(match[1]!);
   }
 
-  // Struct references
-  for (const structName of STRUCT_TS_TYPES) {
-    if (typeStr === structName || typeStr.startsWith(structName + " ")) {
-      structRefs.add(structName);
-    }
-  }
-
-  // Enum references
-  for (const part of typeStr.split(" | ")) {
-    const trimmed = part.trim();
-    if (intEnums.has(trimmed) || strEnums.has(trimmed)) {
-      enumRefs.add(trimmed);
+  // Struct and enum references: match capitalized identifiers anywhere in
+  // the type string (handles block/function types like "(arg0: CGRect) => void").
+  const words = typeStr.match(/\b[A-Z]\w*\b/g);
+  if (words) {
+    for (const word of words) {
+      if (STRUCT_TS_TYPES.has(word)) {
+        structRefs.add(word);
+      }
+      if (intEnums.has(word) || strEnums.has(word)) {
+        enumRefs.add(word);
+      }
     }
   }
 }