c-next 0.1.61 → 0.1.62

package/grammar/CNext.g4

@@ -248,14 +248,11 @@ assignmentOperator
     ;
 
 // Assignment target with unified postfix chain approach (Issue #387)
-// global/this prefixes use postfixTargetOp* for any combination of member/array access
-// Bare identifiers fall back to existing memberAccess/arrayAccess rules for compatibility
+// All patterns use postfixTargetOp* for member/array access chains
 assignmentTarget
     : 'global' '.' IDENTIFIER postfixTargetOp*    // global.x, global.x[i][j].y, etc.
     | 'this' '.' IDENTIFIER postfixTargetOp*      // this.x, this.x[i].y, etc.
-    | arrayAccess                                  // arr[i], reg[start, width]
-    | memberAccess                                 // GPIO7.DR_SET, arr[i].field
-    | IDENTIFIER                                   // Simple identifier
+    | IDENTIFIER postfixTargetOp*                  // x, arr[i], obj.field, arr[i].field, etc.
     ;
 
 // Unified postfix operation for assignment targets (Issue #387)
@@ -459,18 +456,7 @@ arrayInitializerElement
     | arrayInitializer                               // For nested arrays: [[1,2], [3,4]]
     ;
 
-memberAccess
-    : IDENTIFIER ('.' IDENTIFIER)+ ('[' expression ']')+           // ADR-036: screen.pixels[0][0]
-    | IDENTIFIER ('.' IDENTIFIER)+ '[' expression ',' expression ']' // GPIO7.DR[start, width]
-    | IDENTIFIER ('.' IDENTIFIER)+                                  // GPIO7.DR_SET
-    | IDENTIFIER ('[' expression ']')+ ('.' IDENTIFIER)+           // arr[i].field1.field2...
-    | IDENTIFIER (('[' expression ']') | ('.' IDENTIFIER))+        // arr[i].field[j].member... (any mix)
-    ;
-
-arrayAccess
-    : IDENTIFIER '[' expression ']'                       // Single element/bit
-    | IDENTIFIER '[' expression ',' expression ']'        // Bit range [start, width]
-    ;
+// Note: memberAccess and arrayAccess rules removed - unified into assignmentTarget with postfixTargetOp*
 
 argumentList
     : expression (',' expression)*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.61",
+  "version": "0.1.62",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",

package/src/cli/serve/ServeCommand.ts

@@ -35,6 +35,14 @@ interface IMethodResult {
   errorMessage?: string;
 }
 
+/**
+ * Result of validating and extracting source parameters.
+ */
+interface ISourceParams {
+  source: string;
+  filePath: string | undefined;
+}
+
 /**
  * Options for the serve command
  */
@@ -58,9 +66,15 @@ class ServeCommand {
   private static readonly methods: Record<string, MethodHandler> = {
     getVersion: ServeCommand.handleGetVersion,
     initialize: ServeCommand.handleInitialize,
-    transpile: ServeCommand.handleTranspile,
-    parseSymbols: ServeCommand.handleParseSymbols,
-    parseCHeader: ServeCommand.handleParseCHeader,
+    transpile: ServeCommand._withSourceValidation(
+      ServeCommand._handleTranspile,
+    ),
+    parseSymbols: ServeCommand._withSourceValidation(
+      ServeCommand._handleParseSymbols,
+    ),
+    parseCHeader: ServeCommand._withSourceValidation(
+      ServeCommand._handleParseCHeader,
+    ),
     shutdown: ServeCommand.handleShutdown,
   };
 
@@ -104,6 +118,34 @@ class ServeCommand {
     }
   }
 
+  // ========================================================================
+  // Parameter Validation Helpers (Issue #707: Reduce code duplication)
+  // ========================================================================
+
+  /**
+   * Wrapper that validates source params before calling handler.
+   * Eliminates duplicate validation code across handlers.
+   */
+  private static _withSourceValidation(
+    handler: (params: ISourceParams) => Promise<IMethodResult>,
+  ): MethodHandler {
+    return async (params?: Record<string, unknown>): Promise<IMethodResult> => {
+      if (!params || typeof params.source !== "string") {
+        return {
+          success: false,
+          errorCode: JsonRpcHandler.ERROR_INVALID_PARAMS,
+          errorMessage: "Missing required param: source",
+        };
+      }
+      const validated: ISourceParams = {
+        source: String(params.source),
+        filePath:
+          typeof params.filePath === "string" ? params.filePath : undefined,
+      };
+      return handler(validated);
+    };
+  }
+
   /**
    * Handle a single line of input
    */
@@ -224,20 +266,12 @@ class ServeCommand {
   }
 
   /**
-   * Handle transpile method
+   * Handle transpile method (called via _withSourceValidation wrapper)
    * Uses full Transpiler for include resolution and C++ auto-detection
    */
-  private static async handleTranspile(
-    params?: Record<string, unknown>,
+  private static async _handleTranspile(
+    params: ISourceParams,
   ): Promise<IMethodResult> {
-    if (!params || typeof params.source !== "string") {
-      return {
-        success: false,
-        errorCode: JsonRpcHandler.ERROR_INVALID_PARAMS,
-        errorMessage: "Missing required param: source",
-      };
-    }
-
     if (!ServeCommand.transpiler) {
       return {
         success: false,
@@ -246,9 +280,7 @@ class ServeCommand {
       };
     }
 
-    const source = String(params.source);
-    const filePath =
-      typeof params.filePath === "string" ? params.filePath : undefined;
+    const { source, filePath } = params;
 
     const options = filePath
       ? { workingDir: dirname(filePath), sourcePath: filePath }
@@ -271,24 +303,14 @@ class ServeCommand {
   }
 
   /**
-   * Handle parseSymbols method
+   * Handle parseSymbols method (called via _withSourceValidation wrapper)
    * Runs full transpilation for include/C++ detection, then extracts symbols
    * from the parse tree (preserving "extract symbols even with parse errors" behavior)
    */
-  private static async handleParseSymbols(
-    params?: Record<string, unknown>,
+  private static async _handleParseSymbols(
+    params: ISourceParams,
   ): Promise<IMethodResult> {
-    if (!params || typeof params.source !== "string") {
-      return {
-        success: false,
-        errorCode: JsonRpcHandler.ERROR_INVALID_PARAMS,
-        errorMessage: "Missing required param: source",
-      };
-    }
-
-    const source = String(params.source);
-    const filePath =
-      typeof params.filePath === "string" ? params.filePath : undefined;
+    const { source, filePath } = params;
 
     // If transpiler is initialized, run transpileSource to trigger header
     // resolution and C++ detection (results are discarded, we just want
@@ -314,23 +336,13 @@ class ServeCommand {
   }
 
   /**
-   * Handle parseCHeader method
+   * Handle parseCHeader method (called via _withSourceValidation wrapper)
    * Parses C/C++ header files and extracts symbols
    */
-  private static async handleParseCHeader(
-    params?: Record<string, unknown>,
+  private static async _handleParseCHeader(
+    params: ISourceParams,
   ): Promise<IMethodResult> {
-    if (!params || typeof params.source !== "string") {
-      return {
-        success: false,
-        errorCode: JsonRpcHandler.ERROR_INVALID_PARAMS,
-        errorMessage: "Missing required param: source",
-      };
-    }
-
-    const source = String(params.source);
-    const filePath =
-      typeof params.filePath === "string" ? params.filePath : undefined;
+    const { source, filePath } = params;
 
     const result = parseCHeader(source, filePath);
 

package/src/lib/__tests__/parseCHeader.mocked.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Unit tests for parseCHeader edge cases requiring mocks
+ * Separate file to avoid mock pollution with main test file
+ */
+
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import ESymbolKind from "../../utils/types/ESymbolKind";
+
+// Create mock collect function that we can control per test
+const mockCollect = vi.fn();
+
+// Mock CSymbolCollector before importing parseCHeader
+vi.mock("../../transpiler/logic/symbols/CSymbolCollector", () => {
+  return {
+    default: class MockCSymbolCollector {
+      collect() {
+        return mockCollect();
+      }
+    },
+  };
+});
+
+// Import after mock is set up
+import parseCHeader from "../parseCHeader";
+
+describe("parseCHeader mocked scenarios", () => {
+  beforeEach(() => {
+    mockCollect.mockReset();
+    // Default to returning empty array
+    mockCollect.mockReturnValue([]);
+  });
+
+  describe("mapSymbolKind default case", () => {
+    it("maps Namespace kind to variable (default case)", () => {
+      // Return a symbol with Namespace kind (not explicitly handled in switch)
+      mockCollect.mockReturnValue([
+        {
+          name: "TestNamespace",
+          kind: ESymbolKind.Namespace,
+          type: undefined,
+          parent: undefined,
+          sourceLine: 1,
+        },
+      ]);
+
+      const result = parseCHeader("// any valid C");
+
+      expect(result.success).toBe(true);
+      expect(result.symbols).toHaveLength(1);
+      expect(result.symbols[0].kind).toBe("variable");
+      expect(result.symbols[0].name).toBe("TestNamespace");
+    });
+
+    it("maps Class kind to variable (default case)", () => {
+      mockCollect.mockReturnValue([
+        {
+          name: "TestClass",
+          kind: ESymbolKind.Class,
+          type: "class",
+          parent: undefined,
+          sourceLine: 5,
+        },
+      ]);
+
+      const result = parseCHeader("// any valid C");
+
+      expect(result.success).toBe(true);
+      expect(result.symbols[0].kind).toBe("variable");
+    });
+
+    it("maps Bitmap kind to variable (default case)", () => {
+      mockCollect.mockReturnValue([
+        {
+          name: "TestBitmap",
+          kind: ESymbolKind.Bitmap,
+          type: undefined,
+          parent: undefined,
+          sourceLine: 1,
+        },
+      ]);
+
+      const result = parseCHeader("// any valid C");
+
+      expect(result.success).toBe(true);
+      expect(result.symbols[0].kind).toBe("variable");
+    });
+
+    it("defaults line to 0 when sourceLine is undefined", () => {
+      mockCollect.mockReturnValue([
+        {
+          name: "NoLineSymbol",
+          kind: ESymbolKind.Function,
+          type: "void",
+          parent: undefined,
+          sourceLine: undefined, // No source line info
+        },
+      ]);
+
+      const result = parseCHeader("// any valid C");
+
+      expect(result.success).toBe(true);
+      expect(result.symbols[0].line).toBe(0);
+    });
+  });
+
+  describe("error handling catch block", () => {
+    it("returns error result when collector throws Error", () => {
+      mockCollect.mockImplementation(() => {
+        throw new Error("Collector failed");
+      });
+
+      const result = parseCHeader("int x;");
+
+      expect(result.success).toBe(false);
+      expect(result.symbols).toHaveLength(0);
+      expect(result.errors).toHaveLength(1);
+      expect(result.errors[0].message).toBe("Collector failed");
+      expect(result.errors[0].severity).toBe("error");
+      expect(result.errors[0].line).toBe(1);
+      expect(result.errors[0].column).toBe(0);
+    });
+
+    it("handles non-Error exceptions (string throw)", () => {
+      mockCollect.mockImplementation(() => {
+        throw "String error message";
+      });
+
+      const result = parseCHeader("int x;");
+
+      expect(result.success).toBe(false);
+      expect(result.errors[0].message).toBe("String error message");
+    });
+
+    it("handles non-Error exceptions (number throw)", () => {
+      mockCollect.mockImplementation(() => {
+        throw 42;
+      });
+
+      const result = parseCHeader("int x;");
+
+      expect(result.success).toBe(false);
+      expect(result.errors[0].message).toBe("42");
+    });
+  });
+});