c-next 0.1.33 → 0.1.34

package/README.md

@@ -1,5 +1,12 @@
 # C-Next
 
+[![CI](https://github.com/jlaustill/c-next/actions/workflows/pr-checks.yml/badge.svg)](https://github.com/jlaustill/c-next/actions/workflows/pr-checks.yml)
+[![npm version](https://img.shields.io/npm/v/c-next)](https://www.npmjs.com/package/c-next)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=jlaustill_c-next&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=jlaustill_c-next)
+[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=jlaustill_c-next&metric=coverage)](https://sonarcloud.io/summary/new_code?id=jlaustill_c-next)
+[![Maintainability Rating](https://sonarcloud.io/api/project_badges/measure?project=jlaustill_c-next&metric=sqale_rating)](https://sonarcloud.io/summary/new_code?id=jlaustill_c-next)
+
 A safer C for embedded systems development. Transpiles to clean, readable C.
 
 **Status: Working Transpiler** — Verified on Teensy MicroMod hardware.

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "c-next",
-  "version": "0.1.33",
+  "version": "0.1.34",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {
     "cnext": "./bin/cnext.js"
   },
   "scripts": {
-    "antlr": "antlr4ng -Dlanguage=TypeScript -visitor -listener -o src/parser grammar/CNext.g4",
-    "antlr:c": "antlr4ng -Dlanguage=TypeScript -visitor -listener -o src/parser/c grammar/C.g4",
-    "antlr:cpp:lexer": "antlr4ng -Dlanguage=TypeScript -o src/parser/cpp grammar/CPP14Lexer.g4",
-    "antlr:cpp:parser": "antlr4ng -Dlanguage=TypeScript -visitor -listener -o src/parser/cpp -lib src/parser/cpp/grammar grammar/CPP14Parser.g4",
+    "antlr": "antlr4ng -Dlanguage=TypeScript -visitor -listener -o src/antlr_parser grammar/CNext.g4",
+    "antlr:c": "antlr4ng -Dlanguage=TypeScript -visitor -listener -o src/antlr_parser/c grammar/C.g4",
+    "antlr:cpp:lexer": "antlr4ng -Dlanguage=TypeScript -o src/antlr_parser/cpp grammar/CPP14Lexer.g4",
+    "antlr:cpp:parser": "antlr4ng -Dlanguage=TypeScript -visitor -listener -o src/antlr_parser/cpp -lib src/antlr_parser/cpp/grammar grammar/CPP14Parser.g4",
     "antlr:cpp": "npm run antlr:cpp:lexer && npm run antlr:cpp:parser",
     "antlr:all": "npm run antlr && npm run antlr:c && npm run antlr:cpp",
     "start": "tsx src/index.ts",
@@ -21,7 +21,7 @@
     "test:q": "tsx scripts/test.ts -q",
     "test:update": "tsx scripts/test.ts --update",
     "analyze": "./scripts/static-analysis.sh",
-    "clean": "rm -rf src/parser",
+    "clean": "rm -rf src/antlr_parser",
     "prettier:check": "prettier --check .",
     "prettier:fix": "prettier --write .",
     "oxlint:check": "oxlint src/",
@@ -73,6 +73,7 @@
     "@vitest/coverage-v8": "^3.2.4",
     "antlr4ng-cli": "^2.0.0",
     "husky": "^9.1.7",
+    "knip": "^5.82.1",
     "lint-staged": "^16.2.7",
     "oxlint": "^1.39.0",
     "prettier": "^3.7.4",

package/src/analysis/DivisionByZeroAnalyzer.test.ts

@@ -4,8 +4,8 @@
  */
 import { describe, it, expect } from "vitest";
 import { CharStream, CommonTokenStream } from "antlr4ng";
-import { CNextLexer } from "../parser/grammar/CNextLexer";
-import { CNextParser } from "../parser/grammar/CNextParser";
+import { CNextLexer } from "../antlr_parser/grammar/CNextLexer";
+import { CNextParser } from "../antlr_parser/grammar/CNextParser";
 import DivisionByZeroAnalyzer from "./DivisionByZeroAnalyzer";
 
 /**

package/src/analysis/DivisionByZeroAnalyzer.ts

@@ -11,9 +11,12 @@
  */
 
 import { ParseTreeWalker } from "antlr4ng";
-import { CNextListener } from "../parser/grammar/CNextListener";
-import * as Parser from "../parser/grammar/CNextParser";
+import { CNextListener } from "../antlr_parser/grammar/CNextListener";
+import * as Parser from "../antlr_parser/grammar/CNextParser";
 import IDivisionByZeroError from "./types/IDivisionByZeroError";
+import LiteralUtils from "../utils/LiteralUtils";
+import ExpressionUtils from "../utils/ExpressionUtils";
+import ParserUtils from "../utils/ParserUtils";
 
 /**
  * First pass: Collect const declarations that are zero
@@ -49,147 +52,11 @@ class ConstZeroCollector extends CNextListener {
     }
 
     // Check if the expression is a literal zero
-    if (this.isExpressionZero(expr)) {
+    const literal = ExpressionUtils.extractLiteral(expr);
+    if (literal && LiteralUtils.isZero(literal)) {
       this.constZeros.add(name);
     }
   };
-
-  /**
-   * Check if an expression evaluates to literal zero
-   * Navigate: expression -> ternaryExpression -> orExpression -> ... -> literal
-   */
-  private isExpressionZero(ctx: Parser.ExpressionContext): boolean {
-    // expression -> ternaryExpression
-    const ternary = ctx.ternaryExpression();
-    if (!ternary) return false;
-
-    // ternaryExpression -> orExpression
-    const orExprs = ternary.orExpression();
-    if (!orExprs || orExprs.length === 0) return false;
-
-    const orExpr = orExprs[0];
-
-    // orExpression -> andExpression
-    const andExprs = orExpr.andExpression();
-    if (!andExprs || andExprs.length === 0) return false;
-
-    const andExpr = andExprs[0];
-
-    // andExpression -> equalityExpression
-    const eqExprs = andExpr.equalityExpression();
-    if (!eqExprs || eqExprs.length === 0) return false;
-
-    const eqExpr = eqExprs[0];
-
-    // equalityExpression -> relationalExpression
-    const relExprs = eqExpr.relationalExpression();
-    if (!relExprs || relExprs.length === 0) return false;
-
-    const relExpr = relExprs[0];
-
-    // relationalExpression -> bitwiseOrExpression
-    const bitorExprs = relExpr.bitwiseOrExpression();
-    if (!bitorExprs || bitorExprs.length === 0) return false;
-
-    const bitorExpr = bitorExprs[0];
-
-    // bitwiseOrExpression -> bitwiseXorExpression
-    const bitxorExprs = bitorExpr.bitwiseXorExpression();
-    if (!bitxorExprs || bitxorExprs.length === 0) return false;
-
-    const bitxorExpr = bitxorExprs[0];
-
-    // bitwiseXorExpression -> bitwiseAndExpression
-    const bitandExprs = bitxorExpr.bitwiseAndExpression();
-    if (!bitandExprs || bitandExprs.length === 0) return false;
-
-    const bitandExpr = bitandExprs[0];
-
-    // bitwiseAndExpression -> shiftExpression
-    const shiftExprs = bitandExpr.shiftExpression();
-    if (!shiftExprs || shiftExprs.length === 0) return false;
-
-    const shiftExpr = shiftExprs[0];
-
-    // shiftExpression -> additiveExpression
-    const addExprs = shiftExpr.additiveExpression();
-    if (!addExprs || addExprs.length === 0) return false;
-
-    const addExpr = addExprs[0];
-
-    // additiveExpression -> multiplicativeExpression
-    const multExprs = addExpr.multiplicativeExpression();
-    if (!multExprs || multExprs.length === 0) return false;
-
-    const multExpr = multExprs[0];
-
-    // multiplicativeExpression -> unaryExpression
-    const unaryExprs = multExpr.unaryExpression();
-    if (!unaryExprs || unaryExprs.length === 0) return false;
-
-    const unary = unaryExprs[0];
-
-    // unaryExpression -> postfixExpression
-    const postfix = unary.postfixExpression();
-    if (!postfix) return false;
-
-    // postfixExpression -> primaryExpression
-    const primary = postfix.primaryExpression();
-    if (!primary) return false;
-
-    // primaryExpression -> literal
-    const literal = primary.literal();
-    if (!literal) return false;
-
-    return this.isLiteralZero(literal);
-  }
-
-  /**
-   * Check if a literal is zero
-   */
-  private isLiteralZero(ctx: Parser.LiteralContext): boolean {
-    const text = ctx.getText();
-
-    // Check integer literals
-    if (ctx.INTEGER_LITERAL()) {
-      return text === "0";
-    }
-
-    // Check hex literals
-    if (ctx.HEX_LITERAL()) {
-      return text === "0x0" || text === "0X0";
-    }
-
-    // Check binary literals
-    if (ctx.BINARY_LITERAL()) {
-      return text === "0b0" || text === "0B0";
-    }
-
-    // Check suffixed literals
-    if (ctx.SUFFIXED_DECIMAL()) {
-      return text.startsWith("0u") || text.startsWith("0i");
-    }
-
-    if (ctx.SUFFIXED_HEX()) {
-      return (
-        text.startsWith("0x0u") ||
-        text.startsWith("0x0i") ||
-        text.startsWith("0X0u") ||
-        text.startsWith("0X0i")
-      );
-    }
-
-    if (ctx.SUFFIXED_BINARY()) {
-      return (
-        text.startsWith("0b0u") ||
-        text.startsWith("0b0i") ||
-        text.startsWith("0B0u") ||
-        text.startsWith("0B0i")
-      );
-    }
-
-    return false;
-  }
 }
 
 /**
@@ -230,8 +97,7 @@ class DivisionByZeroListener extends CNextListener {
       }
 
       const rightOperand = operands[i + 1];
-      const line = rightOperand.start?.line ?? 0;
-      const column = rightOperand.start?.column ?? 0;
+      const { line, column } = ParserUtils.getPosition(rightOperand);
 
       // Check if right operand is zero
       if (this.isZero(rightOperand)) {
@@ -259,7 +125,7 @@ class DivisionByZeroListener extends CNextListener {
     // Check if it's a literal
     const literal = primaryExpr.literal();
     if (literal) {
-      return this.isLiteralZero(literal);
+      return LiteralUtils.isZero(literal);
     }
 
     // Check if it's a const identifier that evaluates to zero
@@ -271,53 +137,6 @@ class DivisionByZeroListener extends CNextListener {
 
     return false;
   }
-
-  /**
-   * Check if a literal is zero
-   */
-  private isLiteralZero(ctx: Parser.LiteralContext): boolean {
-    const text = ctx.getText();
-
-    // Check integer literals
-    if (ctx.INTEGER_LITERAL()) {
-      return text === "0";
-    }
-
-    // Check hex literals
-    if (ctx.HEX_LITERAL()) {
-      return text === "0x0" || text === "0X0";
-    }
-
-    // Check binary literals
-    if (ctx.BINARY_LITERAL()) {
-      return text === "0b0" || text === "0B0";
-    }
-
-    // Check suffixed literals
-    if (ctx.SUFFIXED_DECIMAL()) {
-      return text.startsWith("0u") || text.startsWith("0i");
-    }
-
-    if (ctx.SUFFIXED_HEX()) {
-      return (
-        text.startsWith("0x0u") ||
-        text.startsWith("0x0i") ||
-        text.startsWith("0X0u") ||
-        text.startsWith("0X0i")
-      );
-    }
-
-    if (ctx.SUFFIXED_BINARY()) {
-      return (
-        text.startsWith("0b0u") ||
-        text.startsWith("0b0i") ||
-        text.startsWith("0B0u") ||
-        text.startsWith("0B0i")
-      );
-    }
-
-    return false;
-  }
 }
 
 /**

package/src/analysis/FloatModuloAnalyzer.test.ts

@@ -4,8 +4,8 @@
  */
 import { describe, it, expect } from "vitest";
 import { CharStream, CommonTokenStream } from "antlr4ng";
-import { CNextLexer } from "../parser/grammar/CNextLexer";
-import { CNextParser } from "../parser/grammar/CNextParser";
+import { CNextLexer } from "../antlr_parser/grammar/CNextLexer";
+import { CNextParser } from "../antlr_parser/grammar/CNextParser";
 import FloatModuloAnalyzer from "./FloatModuloAnalyzer";
 
 /**

package/src/analysis/FloatModuloAnalyzer.ts

@@ -11,11 +11,12 @@
  */
 
 import { ParseTreeWalker } from "antlr4ng";
-import { CNextListener } from "../parser/grammar/CNextListener";
-import * as Parser from "../parser/grammar/CNextParser";
+import { CNextListener } from "../antlr_parser/grammar/CNextListener";
+import * as Parser from "../antlr_parser/grammar/CNextParser";
 import IFloatModuloError from "./types/IFloatModuloError";
-
-const FLOAT_TYPES = ["f32", "f64", "float", "double"];
+import LiteralUtils from "../utils/LiteralUtils";
+import ParserUtils from "../utils/ParserUtils";
+import TypeConstants from "../constants/TypeConstants";
 
 /**
  * First pass: Collect variable declarations with float types
@@ -37,7 +38,7 @@ class FloatVariableCollector extends CNextListener {
     if (!typeCtx) return;
 
     const typeName = typeCtx.getText();
-    if (!FLOAT_TYPES.includes(typeName)) return;
+    if (!TypeConstants.FLOAT_TYPES.includes(typeName)) return;
 
     const identifier = ctx.IDENTIFIER();
     if (!identifier) return;
@@ -53,7 +54,7 @@ class FloatVariableCollector extends CNextListener {
     if (!typeCtx) return;
 
     const typeName = typeCtx.getText();
-    if (!FLOAT_TYPES.includes(typeName)) return;
+    if (!TypeConstants.FLOAT_TYPES.includes(typeName)) return;
 
     const identifier = ctx.IDENTIFIER();
     if (!identifier) return;
@@ -102,8 +103,7 @@ class FloatModuloListener extends CNextListener {
       const rightIsFloat = this.isFloatOperand(rightOperand);
 
       if (leftIsFloat || rightIsFloat) {
-        const line = leftOperand.start?.line ?? 0;
-        const column = leftOperand.start?.column ?? 0;
+        const { line, column } = ParserUtils.getPosition(leftOperand);
         this.analyzer.addError(line, column);
       }
     }
@@ -122,7 +122,7 @@ class FloatModuloListener extends CNextListener {
     // Check for float literal
     const literal = primaryExpr.literal();
     if (literal) {
-      return this.isFloatLiteral(literal);
+      return LiteralUtils.isFloat(literal);
     }
 
     // Check for identifier that's a float variable
@@ -133,18 +133,6 @@ class FloatModuloListener extends CNextListener {
 
     return false;
   }
-
-  /**
-   * Check if a literal is a floating-point number
-   */
-  private isFloatLiteral(ctx: Parser.LiteralContext): boolean {
-    // Check for FLOAT_LITERAL token
-    if (ctx.FLOAT_LITERAL()) return true;
-
-    // Check text for decimal point (fallback)
-    const text = ctx.getText();
-    return text.includes(".") && !text.startsWith('"');
-  }
 }
 
 /**

package/src/analysis/FunctionCallAnalyzer.test.ts

@@ -4,10 +4,10 @@
  */
 import { describe, it, expect } from "vitest";
 import { CharStream, CommonTokenStream } from "antlr4ng";
-import { CNextLexer } from "../parser/grammar/CNextLexer";
-import { CNextParser } from "../parser/grammar/CNextParser";
+import { CNextLexer } from "../antlr_parser/grammar/CNextLexer";
+import { CNextParser } from "../antlr_parser/grammar/CNextParser";
 import FunctionCallAnalyzer from "./FunctionCallAnalyzer";
-import SymbolTable from "../symbols/SymbolTable";
+import SymbolTable from "../symbol_resolution/SymbolTable";
 import ESourceLanguage from "../types/ESourceLanguage";
 import ESymbolKind from "../types/ESymbolKind";
 
@@ -156,6 +156,108 @@ describe("FunctionCallAnalyzer", () => {
       expect(errors).toHaveLength(1);
       expect(errors[0].code).toBe("E0422");
     });
+
+    it("should allow this.name() qualified calls within scope", () => {
+      const code = `
+        scope Test {
+          void helper() {
+            u32 x <- 1;
+          }
+
+          public void callsHelper() {
+            this.helper();
+          }
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should detect undefined method via this.methodName()", () => {
+      const code = `
+        scope Test {
+          void helper() {
+            u32 x <- 1;
+          }
+
+          public void callsUndefined() {
+            this.undefinedMethod();
+          }
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0422");
+      expect(errors[0].message).toContain("called before definition");
+    });
+
+    it("should suggest this.name() for unqualified scope calls", () => {
+      const code = `
+        scope Test {
+          void helper() {
+            u32 x <- 1;
+          }
+
+          public void callsHelper() {
+            helper();
+          }
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0422");
+      expect(errors[0].functionName).toBe("helper");
+      expect(errors[0].message).toContain("scope");
+      expect(errors[0].message).toContain("this.helper()");
+    });
+
+    it("should not suggest this. for truly undefined in scope", () => {
+      const code = `
+        scope Test {
+          public void callsUnknown() {
+            unknownFunc();
+          }
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0422");
+      expect(errors[0].message).toContain("called before definition");
+      expect(errors[0].message).not.toContain("this.");
+    });
+
+    it("should not suggest this. for calls outside scope", () => {
+      const code = `
+        scope Test {
+          public void helper() {
+            u32 x <- 1;
+          }
+        }
+
+        void main() {
+          helper();
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].message).toContain("called before definition");
+      expect(errors[0].message).not.toContain("this.");
+    });
   });
 
   // ========================================================================

package/src/analysis/FunctionCallAnalyzer.ts

@@ -8,12 +8,13 @@
  */
 
 import { ParseTreeWalker } from "antlr4ng";
-import { CNextListener } from "../parser/grammar/CNextListener";
-import * as Parser from "../parser/grammar/CNextParser";
-import SymbolTable from "../symbols/SymbolTable";
+import { CNextListener } from "../antlr_parser/grammar/CNextListener";
+import * as Parser from "../antlr_parser/grammar/CNextParser";
+import SymbolTable from "../symbol_resolution/SymbolTable";
 import ESourceLanguage from "../types/ESourceLanguage";
 import ESymbolKind from "../types/ESymbolKind";
 import IFunctionCallError from "./types/IFunctionCallError";
+import ParserUtils from "../utils/ParserUtils";
 
 /**
  * C-Next built-in functions
@@ -326,11 +327,17 @@ class FunctionCallListener extends CNextListener {
     // 3. Method-style call: obj.method() - not a C-Next function
 
     const primary = ctx.primaryExpression();
-    if (!primary.IDENTIFIER()) {
-      return; // Not a simple identifier-based call
+
+    // Determine the base name: could be an identifier or 'this'
+    let baseName: string;
+    if (primary.IDENTIFIER()) {
+      baseName = primary.IDENTIFIER()!.getText();
+    } else if (primary.THIS()) {
+      baseName = "this";
+    } else {
+      return; // Not a simple identifier-based or this-based call
     }
 
-    const baseName = primary.IDENTIFIER()!.getText();
     let resolvedName = baseName;
     let callOpIndex = -1;
 
@@ -338,12 +345,16 @@ class FunctionCallListener extends CNextListener {
     for (let i = 0; i < ops.length; i++) {
       const op = ops[i];
 
-      // Member access: check if it's Scope.member pattern
+      // Member access: check if it's Scope.member or this.member pattern
       if (op.IDENTIFIER()) {
         const memberName = op.IDENTIFIER()!.getText();
 
+        // Handle this.member -> CurrentScope_member (when inside a scope)
+        if (resolvedName === "this" && this.currentScope) {
+          resolvedName = `${this.currentScope}_${memberName}`;
+        }
         // Check if base is a known scope
-        if (this.analyzer.isScope(resolvedName)) {
+        else if (this.analyzer.isScope(resolvedName)) {
           // Scope.member -> Scope_member
           resolvedName = `${resolvedName}_${memberName}`;
         } else {
@@ -365,9 +376,13 @@ class FunctionCallListener extends CNextListener {
 
     // If we found a call, check if the function is defined
     if (callOpIndex >= 0) {
-      const line = ctx.start?.line ?? 0;
-      const column = ctx.start?.column ?? 0;
-      this.analyzer.checkFunctionCall(resolvedName, line, column);
+      const { line, column } = ParserUtils.getPosition(ctx);
+      this.analyzer.checkFunctionCall(
+        resolvedName,
+        line,
+        column,
+        this.currentScope,
+      );
     }
   };
 }
@@ -449,7 +464,7 @@ class FunctionCallAnalyzer {
     for (const include of tree.includeDirective()) {
       // Extract header name from #include <header.h> or #include "header.h"
       const text = include.getText();
-      const match = text.match(/#include\s*[<"]([^>"]+)[>"]/);
+      const match = /#include\s*[<"]([^>"]+)[>"]/.exec(text);
       if (match) {
         this.includedHeaders.add(match[1]);
       }
@@ -526,8 +541,17 @@ class FunctionCallAnalyzer {
 
   /**
    * Check if a function call is valid (function is defined or external)
+   * @param name The function name being called
+   * @param line Source line number
+   * @param column Source column number
+   * @param currentScope The current scope name (if inside a scope)
    */
-  public checkFunctionCall(name: string, line: number, column: number): void {
+  public checkFunctionCall(
+    name: string,
+    line: number,
+    column: number,
+    currentScope: string | null,
+  ): void {
     // Check for self-recursion (MISRA C:2012 Rule 17.2)
     if (this.currentFunctionName && name === this.currentFunctionName) {
       this.errors.push({
@@ -565,6 +589,22 @@ class FunctionCallAnalyzer {
       return; // OK - invoking a function pointer variable
     }
 
+    // Check if this is an unqualified call to a scope function
+    // e.g., calling helper() instead of this.helper() inside a scope
+    if (currentScope) {
+      const qualifiedName = `${currentScope}_${name}`;
+      if (this.definedFunctions.has(qualifiedName)) {
+        this.errors.push({
+          code: "E0422",
+          functionName: name,
+          line,
+          column,
+          message: `'${name}' is a scope function - use 'this.${name}()' to call it`,
+        });
+        return;
+      }
+    }
+
     // Not defined - report error
     this.errors.push({
       code: "E0422",