c-next 0.1.60 → 0.1.62

package/README.md

@@ -94,6 +94,14 @@ cnext src/ -o build/src --header-out build/include --clean
 cnext --help
 ```
 
+## VS Code Extension
+
+The C-Next VS Code extension provides syntax highlighting, live C preview, IntelliSense, and error diagnostics.
+
+**Install from:** [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=jlaustill.vscode-c-next) (coming soon)
+
+**Source:** [github.com/jlaustill/vscode-c-next](https://github.com/jlaustill/vscode-c-next)
+
 ## Getting Started with PlatformIO
 
 C-Next integrates seamlessly with PlatformIO embedded projects. The transpiler automatically converts `.cnx` files to `.c` before each build.

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.60",
+  "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

@@ -1,20 +1,29 @@
 /**
  * ServeCommand
  * JSON-RPC server for VS Code extension communication
+ *
+ * Phase 2b (ADR-060): Uses the full Transpiler for transpilation and symbol
+ * extraction, enabling include resolution, C++ auto-detection, and cross-file
+ * symbol support.
  */
 
 import { createInterface, Interface } from "node:readline";
+import { dirname } from "node:path";
 import JsonRpcHandler from "./JsonRpcHandler";
 import IJsonRpcRequest from "./types/IJsonRpcRequest";
 import IJsonRpcResponse from "./types/IJsonRpcResponse";
 import ConfigPrinter from "../ConfigPrinter";
-import transpile from "../../lib/transpiler";
+import ConfigLoader from "../ConfigLoader";
+import Transpiler from "../../transpiler/Transpiler";
 import parseWithSymbols from "../../lib/parseWithSymbols";
+import parseCHeader from "../../lib/parseCHeader";
 
 /**
- * Method handler type
+ * Method handler type (async to support Transpiler.transpileSource)
  */
-type MethodHandler = (params?: Record<string, unknown>) => IMethodResult;
+type MethodHandler = (
+  params?: Record<string, unknown>,
+) => Promise<IMethodResult>;
 
 /**
  * Result from a method handler
@@ -26,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
  */
@@ -41,14 +58,23 @@ class ServeCommand {
   private static shouldShutdown = false;
   private static readline: Interface | null = null;
   private static debugMode = false;
+  private static transpiler: Transpiler | null = null;
 
   /**
    * Method handlers registry
    */
   private static readonly methods: Record<string, MethodHandler> = {
     getVersion: ServeCommand.handleGetVersion,
-    transpile: ServeCommand.handleTranspile,
-    parseSymbols: ServeCommand.handleParseSymbols,
+    initialize: ServeCommand.handleInitialize,
+    transpile: ServeCommand._withSourceValidation(
+      ServeCommand._handleTranspile,
+    ),
+    parseSymbols: ServeCommand._withSourceValidation(
+      ServeCommand._handleParseSymbols,
+    ),
+    parseCHeader: ServeCommand._withSourceValidation(
+      ServeCommand._handleParseCHeader,
+    ),
     shutdown: ServeCommand.handleShutdown,
   };
 
@@ -92,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
    */
@@ -115,20 +169,23 @@ class ServeCommand {
     const request = parseResult.request!;
     this.log(`method: ${request.method}`);
 
-    // Dispatch to method handler
-    const response = this.dispatch(request);
-    this.writeResponse(response);
+    // Dispatch to method handler (async)
+    this.dispatch(request).then((response) => {
+      this.writeResponse(response);
 
-    // Handle shutdown after response is written
-    if (this.shouldShutdown) {
-      this.readline?.close();
-    }
+      // Handle shutdown after response is written
+      if (this.shouldShutdown) {
+        this.readline?.close();
+      }
+    });
   }
 
   /**
    * Dispatch a request to the appropriate handler
    */
-  private static dispatch(request: IJsonRpcRequest): IJsonRpcResponse {
+  private static async dispatch(
+    request: IJsonRpcRequest,
+  ): Promise<IJsonRpcResponse> {
     const handler = this.methods[request.method];
 
     if (!handler) {
@@ -139,7 +196,7 @@ class ServeCommand {
       );
     }
 
-    const result = handler(request.params);
+    const result = await handler(request.params);
 
     if (result.success) {
       return JsonRpcHandler.formatResponse(request.id, result.result);
@@ -162,7 +219,7 @@ class ServeCommand {
   /**
    * Handle getVersion method
    */
-  private static handleGetVersion(): IMethodResult {
+  private static async handleGetVersion(): Promise<IMethodResult> {
     return {
       success: true,
       result: { version: ConfigPrinter.getVersion() },
@@ -170,61 +227,135 @@ class ServeCommand {
   }
 
   /**
-   * Handle transpile method
+   * Handle initialize method
+   * Loads project config and creates a Transpiler instance
    */
-  private static handleTranspile(
+  private static async handleInitialize(
     params?: Record<string, unknown>,
-  ): IMethodResult {
-    if (!params || typeof params.source !== "string") {
+  ): Promise<IMethodResult> {
+    if (!params || typeof params.workspacePath !== "string") {
       return {
         success: false,
         errorCode: JsonRpcHandler.ERROR_INVALID_PARAMS,
-        errorMessage: "Missing required param: source",
+        errorMessage: "Missing required param: workspacePath",
       };
     }
 
-    const result = transpile(params.source);
+    const workspacePath = params.workspacePath;
+    ServeCommand.log(`initializing with workspace: ${workspacePath}`);
+
+    const config = ConfigLoader.load(workspacePath);
+
+    ServeCommand.transpiler = new Transpiler({
+      inputs: [],
+      includeDirs: config.include ?? [],
+      cppRequired: config.cppRequired ?? false,
+      target: config.target ?? "",
+      debugMode: config.debugMode ?? false,
+      noCache: config.noCache ?? false,
+    });
+
+    ServeCommand.log(
+      `initialized (cppRequired=${config.cppRequired ?? false}, includeDirs=${(config.include ?? []).length})`,
+    );
 
     return {
       success: true,
-      result: {
-        success: result.success,
-        code: result.code,
-        errors: result.errors,
-      },
+      result: { success: true },
     };
   }
 
   /**
-   * Handle parseSymbols method
+   * Handle transpile method (called via _withSourceValidation wrapper)
+   * Uses full Transpiler for include resolution and C++ auto-detection
    */
-  private static handleParseSymbols(
-    params?: Record<string, unknown>,
-  ): IMethodResult {
-    if (!params || typeof params.source !== "string") {
+  private static async _handleTranspile(
+    params: ISourceParams,
+  ): Promise<IMethodResult> {
+    if (!ServeCommand.transpiler) {
       return {
         success: false,
         errorCode: JsonRpcHandler.ERROR_INVALID_PARAMS,
-        errorMessage: "Missing required param: source",
+        errorMessage: "Server not initialized. Call initialize first.",
       };
     }
 
-    const result = parseWithSymbols(params.source);
+    const { source, filePath } = params;
+
+    const options = filePath
+      ? { workingDir: dirname(filePath), sourcePath: filePath }
+      : undefined;
+
+    const result = await ServeCommand.transpiler.transpileSource(
+      source,
+      options,
+    );
 
     return {
       success: true,
       result: {
         success: result.success,
+        code: result.code,
         errors: result.errors,
-        symbols: result.symbols,
+        cppDetected: ServeCommand.transpiler.isCppDetected(),
       },
     };
   }
 
+  /**
+   * 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: ISourceParams,
+  ): Promise<IMethodResult> {
+    const { source, filePath } = params;
+
+    // If transpiler is initialized, run transpileSource to trigger header
+    // resolution and C++ detection (results are discarded, we just want
+    // the side effects on the symbol table)
+    if (ServeCommand.transpiler && filePath) {
+      try {
+        await ServeCommand.transpiler.transpileSource(source, {
+          workingDir: dirname(filePath),
+          sourcePath: filePath,
+        });
+      } catch {
+        // Ignore transpilation errors - we still extract symbols below
+      }
+    }
+
+    // Delegate symbol extraction to parseWithSymbols (shared with WorkspaceIndex)
+    const result = parseWithSymbols(source);
+
+    return {
+      success: true,
+      result,
+    };
+  }
+
+  /**
+   * Handle parseCHeader method (called via _withSourceValidation wrapper)
+   * Parses C/C++ header files and extracts symbols
+   */
+  private static async _handleParseCHeader(
+    params: ISourceParams,
+  ): Promise<IMethodResult> {
+    const { source, filePath } = params;
+
+    const result = parseCHeader(source, filePath);
+
+    return {
+      success: true,
+      result,
+    };
+  }
+
   /**
    * Handle shutdown method
    */
-  private static handleShutdown(): IMethodResult {
+  private static async handleShutdown(): Promise<IMethodResult> {
     ServeCommand.shouldShutdown = true;
     return {
       success: true,

package/src/cli/serve/__tests__/ServeCommand.test.ts

@@ -25,7 +25,7 @@ describe("ServeCommand", () => {
     stdoutWriteSpy.mockRestore();
   });
 
-  // Helper to send a request and capture the response
+  // Helper to send a request and capture the async response
   async function sendRequest(request: object): Promise<object> {
     const line = JSON.stringify(request);
     // Access private handleLine method for testing
@@ -34,8 +34,14 @@ describe("ServeCommand", () => {
     ).handleLine.bind(ServeCommand);
     handleLine(line);
 
-    // Parse the response from stdout.write call
-    const writeCall = stdoutWriteSpy.mock.calls[0];
+    // Wait for async dispatch to complete and write response
+    await vi.waitFor(() => {
+      expect(stdoutWriteSpy.mock.calls.length).toBeGreaterThan(0);
+    });
+
+    // Parse the response from the latest stdout.write call
+    const writeCall =
+      stdoutWriteSpy.mock.calls[stdoutWriteSpy.mock.calls.length - 1];
     if (writeCall) {
       const responseStr = writeCall[0] as string;
       return JSON.parse(responseStr.trim());
@@ -54,8 +60,67 @@ describe("ServeCommand", () => {
     });
   });
 
+  describe("initialize", () => {
+    it("initializes with workspace path", async () => {
+      const response = await sendRequest({
+        id: 10,
+        method: "initialize",
+        params: { workspacePath: "/tmp" },
+      });
+
+      expect(response).toMatchObject({
+        id: 10,
+        result: { success: true },
+      });
+    });
+
+    it("returns error for missing workspacePath param", async () => {
+      const response = await sendRequest({
+        id: 11,
+        method: "initialize",
+        params: {},
+      });
+
+      expect(response).toMatchObject({
+        id: 11,
+        error: {
+          code: JsonRpcHandler.ERROR_INVALID_PARAMS,
+          message: "Missing required param: workspacePath",
+        },
+      });
+    });
+  });
+
   describe("transpile", () => {
+    it("returns error when server not initialized", async () => {
+      // Reset transpiler to null by accessing private field
+      (ServeCommand as unknown as { transpiler: null }).transpiler = null;
+      stdoutWriteSpy.mockClear();
+
+      const response = await sendRequest({
+        id: 50,
+        method: "transpile",
+        params: { source: "u8 x <- 5;" },
+      });
+
+      expect(response).toMatchObject({
+        id: 50,
+        error: {
+          code: JsonRpcHandler.ERROR_INVALID_PARAMS,
+          message: "Server not initialized. Call initialize first.",
+        },
+      });
+    });
+
     it("transpiles valid C-Next source", async () => {
+      // Initialize first (required for transpile)
+      await sendRequest({
+        id: 100,
+        method: "initialize",
+        params: { workspacePath: "/tmp" },
+      });
+      stdoutWriteSpy.mockClear();
+
       const response = await sendRequest({
         id: 2,
         method: "transpile",
@@ -73,6 +138,14 @@ describe("ServeCommand", () => {
     });
 
     it("returns errors for invalid source", async () => {
+      // Initialize first
+      await sendRequest({
+        id: 101,
+        method: "initialize",
+        params: { workspacePath: "/tmp" },
+      });
+      stdoutWriteSpy.mockClear();
+
       const response = await sendRequest({
         id: 3,
         method: "transpile",
@@ -139,6 +212,35 @@ describe("ServeCommand", () => {
       );
     });
 
+    it("parses symbols with filePath after initialization", async () => {
+      // Initialize first
+      await sendRequest({
+        id: 60,
+        method: "initialize",
+        params: { workspacePath: "/tmp" },
+      });
+      stdoutWriteSpy.mockClear();
+
+      const response = await sendRequest({
+        id: 61,
+        method: "parseSymbols",
+        params: {
+          source: "void myFunc() { }",
+          filePath: "/tmp/test.cnx",
+        },
+      });
+
+      const result = response as {
+        id: number;
+        result: { success: boolean; symbols: Array<{ name: string }> };
+      };
+      expect(result.id).toBe(61);
+      expect(result.result.success).toBe(true);
+      expect(result.result.symbols).toEqual(
+        expect.arrayContaining([expect.objectContaining({ name: "myFunc" })]),
+      );
+    });
+
     it("returns error for missing source param", async () => {
       const response = await sendRequest({
         id: 7,
@@ -154,6 +256,95 @@ describe("ServeCommand", () => {
         },
       });
     });
+
+    it("returns error for missing params", async () => {
+      const response = await sendRequest({
+        id: 70,
+        method: "parseSymbols",
+      });
+
+      expect(response).toMatchObject({
+        id: 70,
+        error: {
+          code: JsonRpcHandler.ERROR_INVALID_PARAMS,
+          message: "Missing required param: source",
+        },
+      });
+    });
+  });
+
+  describe("parseCHeader", () => {
+    it("parses symbols from C header source", async () => {
+      const response = await sendRequest({
+        id: 71,
+        method: "parseCHeader",
+        params: { source: "int myFunction(void);" },
+      });
+
+      const result = response as {
+        id: number;
+        result: { success: boolean; symbols: Array<{ name: string }> };
+      };
+      expect(result.id).toBe(71);
+      expect(result.result.success).toBe(true);
+      expect(result.result.symbols).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({ name: "myFunction" }),
+        ]),
+      );
+    });
+
+    it("parses struct definitions", async () => {
+      const response = await sendRequest({
+        id: 72,
+        method: "parseCHeader",
+        params: {
+          source: "typedef struct { int x; int y; } Point;",
+          filePath: "/tmp/types.h",
+        },
+      });
+
+      const result = response as {
+        id: number;
+        result: { success: boolean; symbols: Array<{ name: string }> };
+      };
+      expect(result.id).toBe(72);
+      expect(result.result.success).toBe(true);
+      expect(result.result.symbols).toEqual(
+        expect.arrayContaining([expect.objectContaining({ name: "Point" })]),
+      );
+    });
+
+    it("returns error for missing source param", async () => {
+      const response = await sendRequest({
+        id: 73,
+        method: "parseCHeader",
+        params: {},
+      });
+
+      expect(response).toMatchObject({
+        id: 73,
+        error: {
+          code: JsonRpcHandler.ERROR_INVALID_PARAMS,
+          message: "Missing required param: source",
+        },
+      });
+    });
+
+    it("returns error for missing params", async () => {
+      const response = await sendRequest({
+        id: 74,
+        method: "parseCHeader",
+      });
+
+      expect(response).toMatchObject({
+        id: 74,
+        error: {
+          code: JsonRpcHandler.ERROR_INVALID_PARAMS,
+          message: "Missing required param: source",
+        },
+      });
+    });
   });
 
   describe("shutdown", () => {
@@ -197,11 +388,44 @@ describe("ServeCommand", () => {
       handleLine("");
       handleLine("   ");
 
+      // Wait a tick to ensure any async work would have started
+      await new Promise((r) => setTimeout(r, 10));
+
       // No response should be written for empty lines
       expect(stdoutWriteSpy).not.toHaveBeenCalled();
     });
   });
 
+  describe("debug logging", () => {
+    it("writes debug messages to stderr when debug mode is enabled", async () => {
+      const stderrWriteSpy = vi
+        .spyOn(process.stderr, "write")
+        .mockImplementation(() => true);
+
+      // Enable debug mode via private field
+      (ServeCommand as unknown as { debugMode: boolean }).debugMode = true;
+
+      const response = await sendRequest({
+        id: 80,
+        method: "getVersion",
+      });
+
+      expect(response).toMatchObject({
+        id: 80,
+        result: { version: expect.any(String) },
+      });
+
+      // Debug logs should have been written to stderr
+      expect(stderrWriteSpy).toHaveBeenCalled();
+      const debugOutput = stderrWriteSpy.mock.calls.map((c) => c[0]).join("");
+      expect(debugOutput).toContain("[serve]");
+
+      // Clean up
+      (ServeCommand as unknown as { debugMode: boolean }).debugMode = false;
+      stderrWriteSpy.mockRestore();
+    });
+  });
+
   describe("invalid JSON", () => {
     it("returns parse error", async () => {
       const handleLine = (