c-next 0.1.46 → 0.1.48

package/README.md

@@ -654,6 +654,14 @@ pio run -t upload
 
 See `examples/blink.cnx` for the complete LED blink example.
 
+## Projects Using C-Next
+
+| Project                                   | Description                                                                |
+| ----------------------------------------- | -------------------------------------------------------------------------- |
+| [OSSM](https://github.com/jlaustill/ossm) | Open-source stroke machine firmware using C-Next for safe embedded control |
+
+_Using C-Next in your project? Open an issue to get listed!_
+
 ## Project Structure
 
 ```
@@ -676,45 +684,46 @@ Decisions are documented in `/docs/decisions/`:
 
 ### Implemented
 
-| ADR                                                                   | Title                   | Description                                                   |
-| --------------------------------------------------------------------- | ----------------------- | ------------------------------------------------------------- |
-| [ADR-001](docs/decisions/adr-001-assignment-operator.md)              | Assignment Operator     | `<-` for assignment, `=` for comparison                       |
-| [ADR-003](docs/decisions/adr-003-static-allocation.md)                | Static Allocation       | No dynamic memory after init                                  |
-| [ADR-004](docs/decisions/adr-004-register-bindings.md)                | Register Bindings       | Type-safe hardware access                                     |
-| [ADR-006](docs/decisions/adr-006-simplified-references.md)            | Simplified References   | Pass by reference, no pointer syntax                          |
-| [ADR-007](docs/decisions/adr-007-type-aware-bit-indexing.md)          | Type-Aware Bit Indexing | Integers as bit arrays, `.length` property                    |
-| [ADR-010](docs/decisions/adr-010-c-interoperability.md)               | C Interoperability      | Unified ANTLR parser architecture                             |
-| [ADR-011](docs/decisions/adr-011-vscode-extension.md)                 | VS Code Extension       | Live C preview with syntax highlighting                       |
-| [ADR-012](docs/decisions/adr-012-static-analysis.md)                  | Static Analysis         | cppcheck integration for generated C                          |
-| [ADR-013](docs/decisions/adr-013-const-qualifier.md)                  | Const Qualifier         | Compile-time const enforcement                                |
-| [ADR-014](docs/decisions/adr-014-structs.md)                          | Structs                 | Data containers without methods                               |
-| [ADR-015](docs/decisions/adr-015-null-state.md)                       | Null State              | Zero initialization for all variables                         |
-| [ADR-016](docs/decisions/adr-016-scope.md)                            | Scope                   | `this.`/`global.` explicit qualification                      |
-| [ADR-017](docs/decisions/adr-017-enums.md)                            | Enums                   | Type-safe enums with C-style casting                          |
-| [ADR-030](docs/decisions/adr-030-forward-declarations.md)             | Define-Before-Use       | Functions must be defined before called                       |
-| [ADR-037](docs/decisions/adr-037-preprocessor.md)                     | Preprocessor            | Flag-only defines, const for values                           |
-| [ADR-043](docs/decisions/adr-043-comments.md)                         | Comments                | Comment preservation with MISRA compliance                    |
-| [ADR-044](docs/decisions/adr-044-primitive-types.md)                  | Primitive Types         | Fixed-width types with `clamp`/`wrap` overflow                |
-| [ADR-024](docs/decisions/adr-024-type-casting.md)                     | Type Casting            | Widening implicit, narrowing uses bit indexing                |
-| [ADR-022](docs/decisions/adr-022-conditional-expressions.md)          | Conditional Expressions | Ternary with required parens, boolean condition, no nesting   |
-| [ADR-025](docs/decisions/adr-025-switch-statements.md)                | Switch Statements       | Safe switch with braces, `\|\|` syntax, counted `default(n)`  |
-| [ADR-029](docs/decisions/adr-029-function-pointers.md)                | Callbacks               | Function-as-Type pattern with nominal typing                  |
-| [ADR-045](docs/decisions/adr-045-string-type.md)                      | Bounded Strings         | `string<N>` with compile-time safety                          |
-| [ADR-023](docs/decisions/adr-023-sizeof.md)                           | Sizeof                  | Type/value size queries with safety checks                    |
-| [ADR-027](docs/decisions/adr-027-do-while.md)                         | Do-While                | `do { } while ()` with boolean condition (E0701)              |
-| [ADR-032](docs/decisions/adr-032-nested-structs.md)                   | Nested Structs          | Named nested structs only (no anonymous)                      |
-| [ADR-035](docs/decisions/adr-035-array-initializers.md)               | Array Initializers      | `[1, 2, 3]` syntax with `[0*]` fill-all                       |
-| [ADR-036](docs/decisions/adr-036-multidimensional-arrays.md)          | Multi-dim Arrays        | `arr[i][j]` with compile-time bounds enforcement              |
-| [ADR-040](docs/decisions/adr-040-isr-declaration.md)                  | ISR Type                | Built-in `ISR` type for `void(void)` function pointers        |
-| [ADR-034](docs/decisions/adr-034-bit-fields.md)                       | Bitmap Types            | `bitmap8`/`bitmap16`/`bitmap32` for portable bit-packed data  |
-| [ADR-048](docs/decisions/adr-048-cli-executable.md)                   | CLI Executable          | `cnext` command with smart defaults                           |
-| [ADR-049](docs/decisions/adr-049-atomic-types.md)                     | Atomic Types            | `atomic` keyword with LDREX/STREX or PRIMASK fallback         |
-| [ADR-050](docs/decisions/adr-050-critical-sections.md)                | Critical Sections       | `critical { }` blocks with PRIMASK save/restore               |
-| [ADR-108](docs/decisions/adr-108-volatile-keyword.md)                 | Volatile Variables      | `volatile` keyword prevents compiler optimization             |
-| [ADR-046](docs/decisions/adr-046-nullable-c-interop.md)               | Nullable C Interop      | `c_` prefix for nullable C pointer types (supersedes ADR-047) |
-| [ADR-047](docs/decisions/adr-047-nullable-types.md)                   | NULL for C Interop      | `NULL` keyword for C stream functions (superseded by ADR-046) |
-| [ADR-052](docs/decisions/adr-052-safe-numeric-literal-generation.md)  | Safe Numeric Literals   | `type_MIN`/`type_MAX` constants + safe hex conversion         |
-| [ADR-053](docs/decisions/adr-053-transpiler-pipeline-architecture.md) | Transpiler Pipeline     | Unified multi-pass pipeline with header symbol extraction     |
+| ADR                                                                   | Title                     | Description                                                   |
+| --------------------------------------------------------------------- | ------------------------- | ------------------------------------------------------------- |
+| [ADR-001](docs/decisions/adr-001-assignment-operator.md)              | Assignment Operator       | `<-` for assignment, `=` for comparison                       |
+| [ADR-003](docs/decisions/adr-003-static-allocation.md)                | Static Allocation         | No dynamic memory after init                                  |
+| [ADR-004](docs/decisions/adr-004-register-bindings.md)                | Register Bindings         | Type-safe hardware access                                     |
+| [ADR-006](docs/decisions/adr-006-simplified-references.md)            | Simplified References     | Pass by reference, no pointer syntax                          |
+| [ADR-007](docs/decisions/adr-007-type-aware-bit-indexing.md)          | Type-Aware Bit Indexing   | Integers as bit arrays, `.length` property                    |
+| [ADR-010](docs/decisions/adr-010-c-interoperability.md)               | C Interoperability        | Unified ANTLR parser architecture                             |
+| [ADR-011](docs/decisions/adr-011-vscode-extension.md)                 | VS Code Extension         | Live C preview with syntax highlighting                       |
+| [ADR-012](docs/decisions/adr-012-static-analysis.md)                  | Static Analysis           | cppcheck integration for generated C                          |
+| [ADR-013](docs/decisions/adr-013-const-qualifier.md)                  | Const Qualifier           | Compile-time const enforcement                                |
+| [ADR-014](docs/decisions/adr-014-structs.md)                          | Structs                   | Data containers without methods                               |
+| [ADR-015](docs/decisions/adr-015-null-state.md)                       | Null State                | Zero initialization for all variables                         |
+| [ADR-016](docs/decisions/adr-016-scope.md)                            | Scope                     | `this.`/`global.` explicit qualification                      |
+| [ADR-017](docs/decisions/adr-017-enums.md)                            | Enums                     | Type-safe enums with C-style casting                          |
+| [ADR-030](docs/decisions/adr-030-forward-declarations.md)             | Define-Before-Use         | Functions must be defined before called                       |
+| [ADR-037](docs/decisions/adr-037-preprocessor.md)                     | Preprocessor              | Flag-only defines, const for values                           |
+| [ADR-043](docs/decisions/adr-043-comments.md)                         | Comments                  | Comment preservation with MISRA compliance                    |
+| [ADR-044](docs/decisions/adr-044-primitive-types.md)                  | Primitive Types           | Fixed-width types with `clamp`/`wrap` overflow                |
+| [ADR-024](docs/decisions/adr-024-type-casting.md)                     | Type Casting              | Widening implicit, narrowing uses bit indexing                |
+| [ADR-022](docs/decisions/adr-022-conditional-expressions.md)          | Conditional Expressions   | Ternary with required parens, boolean condition, no nesting   |
+| [ADR-025](docs/decisions/adr-025-switch-statements.md)                | Switch Statements         | Safe switch with braces, `\|\|` syntax, counted `default(n)`  |
+| [ADR-029](docs/decisions/adr-029-function-pointers.md)                | Callbacks                 | Function-as-Type pattern with nominal typing                  |
+| [ADR-045](docs/decisions/adr-045-string-type.md)                      | Bounded Strings           | `string<N>` with compile-time safety                          |
+| [ADR-023](docs/decisions/adr-023-sizeof.md)                           | Sizeof                    | Type/value size queries with safety checks                    |
+| [ADR-027](docs/decisions/adr-027-do-while.md)                         | Do-While                  | `do { } while ()` with boolean condition (E0701)              |
+| [ADR-032](docs/decisions/adr-032-nested-structs.md)                   | Nested Structs            | Named nested structs only (no anonymous)                      |
+| [ADR-035](docs/decisions/adr-035-array-initializers.md)               | Array Initializers        | `[1, 2, 3]` syntax with `[0*]` fill-all                       |
+| [ADR-036](docs/decisions/adr-036-multidimensional-arrays.md)          | Multi-dim Arrays          | `arr[i][j]` with compile-time bounds enforcement              |
+| [ADR-040](docs/decisions/adr-040-isr-declaration.md)                  | ISR Type                  | Built-in `ISR` type for `void(void)` function pointers        |
+| [ADR-034](docs/decisions/adr-034-bit-fields.md)                       | Bitmap Types              | `bitmap8`/`bitmap16`/`bitmap32` for portable bit-packed data  |
+| [ADR-048](docs/decisions/adr-048-cli-executable.md)                   | CLI Executable            | `cnext` command with smart defaults                           |
+| [ADR-049](docs/decisions/adr-049-atomic-types.md)                     | Atomic Types              | `atomic` keyword with LDREX/STREX or PRIMASK fallback         |
+| [ADR-050](docs/decisions/adr-050-critical-sections.md)                | Critical Sections         | `critical { }` blocks with PRIMASK save/restore               |
+| [ADR-108](docs/decisions/adr-108-volatile-keyword.md)                 | Volatile Variables        | `volatile` keyword prevents compiler optimization             |
+| [ADR-046](docs/decisions/adr-046-nullable-c-interop.md)               | Nullable C Interop        | `c_` prefix for nullable C pointer types (supersedes ADR-047) |
+| [ADR-047](docs/decisions/adr-047-nullable-types.md)                   | NULL for C Interop        | `NULL` keyword for C stream functions (superseded by ADR-046) |
+| [ADR-052](docs/decisions/adr-052-safe-numeric-literal-generation.md)  | Safe Numeric Literals     | `type_MIN`/`type_MAX` constants + safe hex conversion         |
+| [ADR-053](docs/decisions/adr-053-transpiler-pipeline-architecture.md) | Transpiler Pipeline       | Unified multi-pass pipeline with header symbol extraction     |
+| [ADR-057](docs/decisions/adr-057-implicit-scope-resolution.md)        | Implicit Scope Resolution | Bare identifiers resolve local → scope → global               |
 
 ### Research (v1 Roadmap)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {
@@ -39,7 +39,11 @@
     "unit:watch": "vitest",
     "unit:coverage": "vitest run --coverage",
     "unit:coverage:html": "vitest run --coverage && echo 'Coverage report: coverage/index.html'",
-    "test:all": "npm run unit && npm run test:q"
+    "test:all": "npm run unit && npm run test:q",
+    "duplication": "npx jscpd src/ scripts/ --reporters console",
+    "duplication:json": "npx jscpd src/ scripts/ --reporters json --output .jscpd",
+    "duplication:sonar": "curl -s 'https://sonarcloud.io/api/measures/component_tree?component=jlaustill_c-next&metricKeys=duplicated_blocks,duplicated_lines&s=metric&metricSort=duplicated_blocks&metricSortFilter=withMeasuresOnly&asc=false&ps=20' | jq -r '.components[] | \"\\(.path)\\t\\(.measures[0].value) blocks\\t\\(.measures[1].value) lines\"'",
+    "duplication:all": "echo '=== Local (jscpd) ===' && npm run duplication && echo '\n=== SonarCloud ===' && npm run duplication:sonar"
   },
   "keywords": [
     "c",

package/src/analysis/DivisionByZeroAnalyzer.ts

@@ -22,7 +22,7 @@ import ParserUtils from "../utils/ParserUtils";
  * First pass: Collect const declarations that are zero
  */
 class ConstZeroCollector extends CNextListener {
-  private constZeros: Set<string> = new Set();
+  private readonly constZeros: Set<string> = new Set();
 
   public getConstZeros(): Set<string> {
     return this.constZeros;
@@ -63,9 +63,9 @@ class ConstZeroCollector extends CNextListener {
  * Second pass: Detect division by zero (including const identifiers)
  */
 class DivisionByZeroListener extends CNextListener {
-  private analyzer: DivisionByZeroAnalyzer;
+  private readonly analyzer: DivisionByZeroAnalyzer;
   // eslint-disable-next-line @typescript-eslint/lines-between-class-members
-  private constZeros: Set<string>;
+  private readonly constZeros: Set<string>;
 
   constructor(analyzer: DivisionByZeroAnalyzer, constZeros: Set<string>) {
     super();

package/src/analysis/FloatModuloAnalyzer.ts

@@ -22,7 +22,7 @@ import TypeConstants from "../constants/TypeConstants";
  * First pass: Collect variable declarations with float types
  */
 class FloatVariableCollector extends CNextListener {
-  private floatVars: Set<string> = new Set();
+  private readonly floatVars: Set<string> = new Set();
 
   public getFloatVars(): Set<string> {
     return this.floatVars;
@@ -67,10 +67,10 @@ class FloatVariableCollector extends CNextListener {
  * Second pass: Detect modulo operations with float operands
  */
 class FloatModuloListener extends CNextListener {
-  private analyzer: FloatModuloAnalyzer;
+  private readonly analyzer: FloatModuloAnalyzer;
 
   // eslint-disable-next-line @typescript-eslint/lines-between-class-members
-  private floatVars: Set<string>;
+  private readonly floatVars: Set<string>;
 
   constructor(analyzer: FloatModuloAnalyzer, floatVars: Set<string>) {
     super();

package/src/analysis/FunctionCallAnalyzer.test.ts

@@ -197,7 +197,9 @@ describe("FunctionCallAnalyzer", () => {
       expect(errors[0].message).toContain("called before definition");
     });
 
-    it("should suggest this.name() for unqualified scope calls", () => {
+    // ADR-057: With implicit scope resolution, bare function calls to scope functions
+    // are now allowed (resolve automatically). This test verifies no error is thrown.
+    it("should allow unqualified scope function calls (ADR-057 implicit resolution)", () => {
       const code = `
         scope Test {
           void helper() {
@@ -213,11 +215,8 @@ describe("FunctionCallAnalyzer", () => {
       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()");
+      // ADR-057: Implicit resolution allows bare scope function calls
+      expect(errors).toHaveLength(0);
     });
 
     it("should not suggest this. for truly undefined in scope", () => {

package/src/analysis/FunctionCallAnalyzer.ts

@@ -220,7 +220,7 @@ const STDLIB_FUNCTIONS: Map<string, Set<string>> = new Map([
  * Listener that walks the parse tree and checks function calls
  */
 class FunctionCallListener extends CNextListener {
-  private analyzer: FunctionCallAnalyzer;
+  private readonly analyzer: FunctionCallAnalyzer;
 
   /** Current scope name (for member function resolution) */
   private currentScope: string | null = null;
@@ -477,7 +477,7 @@ class FunctionCallAnalyzer {
   private isStdlibFunction(name: string): boolean {
     for (const header of this.includedHeaders) {
       const funcs = STDLIB_FUNCTIONS.get(header);
-      if (funcs && funcs.has(name)) {
+      if (funcs?.has(name)) {
         return true;
       }
     }
@@ -589,19 +589,13 @@ class FunctionCallAnalyzer {
       return; // OK - invoking a function pointer variable
     }
 
+    // ADR-057: Allow implicit scope function calls without this. prefix
     // 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;
+        return; // OK - implicit resolution will handle it
       }
     }
 

package/src/analysis/GrammarCoverageListener.ts

@@ -18,8 +18,8 @@ import {
 import IGrammarCoverageReport from "./types/IGrammarCoverageReport";
 
 class GrammarCoverageListener implements ParseTreeListener {
-  private parserRuleVisits: Map<string, number> = new Map();
-  private lexerRuleVisits: Map<string, number> = new Map();
+  private readonly parserRuleVisits: Map<string, number> = new Map();
+  private readonly lexerRuleVisits: Map<string, number> = new Map();
   private readonly parserRuleNames: string[];
   private readonly lexerRuleNames: string[];
 

package/src/analysis/InitializationAnalyzer.test.ts

@@ -0,0 +1,238 @@
+/**
+ * Unit tests for InitializationAnalyzer
+ * Issue #503: Tests for C++ class initialization handling
+ */
+
+import { CharStream, CommonTokenStream } from "antlr4ng";
+import { describe, expect, it } from "vitest";
+import { CNextLexer } from "../antlr_parser/grammar/CNextLexer";
+import { CNextParser } from "../antlr_parser/grammar/CNextParser";
+import InitializationAnalyzer from "./InitializationAnalyzer";
+import SymbolTable from "../symbol_resolution/SymbolTable";
+import ESymbolKind from "../types/ESymbolKind";
+import ESourceLanguage from "../types/ESourceLanguage";
+
+/**
+ * Parse C-Next source code into an AST
+ */
+function parse(source: string) {
+  const charStream = CharStream.fromString(source);
+  const lexer = new CNextLexer(charStream);
+  const tokenStream = new CommonTokenStream(lexer);
+  const parser = new CNextParser(tokenStream);
+  return parser.program();
+}
+
+describe("InitializationAnalyzer", () => {
+  // ========================================================================
+  // Issue #503: C++ Class Initialization
+  // ========================================================================
+
+  describe("C++ class initialization (Issue #503)", () => {
+    it("should not flag C++ class variables as uninitialized", () => {
+      const code = `
+        void main() {
+          CppMessage msg;
+          u16 pgn <- msg.pgn;
+        }
+      `;
+      const tree = parse(code);
+
+      // Create symbol table with C++ class
+      const symbolTable = new SymbolTable();
+      symbolTable.addSymbol({
+        name: "CppMessage",
+        kind: ESymbolKind.Class,
+        sourceLanguage: ESourceLanguage.Cpp,
+        sourceFile: "CppMessage.hpp",
+        sourceLine: 1,
+        isExported: true,
+      });
+      // Add the field so the analyzer knows about it
+      symbolTable.addStructField("CppMessage", "pgn", "u16");
+
+      const analyzer = new InitializationAnalyzer();
+      analyzer.registerExternalStructFields(
+        new Map([["CppMessage", new Set(["pgn"])]]),
+      );
+
+      const errors = analyzer.analyze(tree, symbolTable);
+
+      // Should have NO errors - C++ class is initialized by constructor
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should still flag C-Next structs as uninitialized", () => {
+      const code = `
+        struct MyStruct {
+          u16 value;
+        }
+        void main() {
+          MyStruct s;
+          u16 v <- s.value;
+        }
+      `;
+      const tree = parse(code);
+
+      // No C++ symbols in symbol table - MyStruct is a C-Next struct
+      const symbolTable = new SymbolTable();
+
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree, symbolTable);
+
+      // SHOULD have an error - C-Next struct is NOT initialized
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].code).toBe("E0381");
+      expect(errors[0].variable).toContain("value");
+    });
+
+    it("should not flag C++ struct variables as uninitialized", () => {
+      const code = `
+        void main() {
+          CppStruct data;
+          u32 val <- data.value;
+        }
+      `;
+      const tree = parse(code);
+
+      // Create symbol table with C++ struct (not class)
+      const symbolTable = new SymbolTable();
+      symbolTable.addSymbol({
+        name: "CppStruct",
+        kind: ESymbolKind.Struct,
+        sourceLanguage: ESourceLanguage.Cpp,
+        sourceFile: "types.hpp",
+        sourceLine: 1,
+        isExported: true,
+      });
+      symbolTable.addStructField("CppStruct", "value", "u32");
+
+      const analyzer = new InitializationAnalyzer();
+      analyzer.registerExternalStructFields(
+        new Map([["CppStruct", new Set(["value"])]]),
+      );
+
+      const errors = analyzer.analyze(tree, symbolTable);
+
+      // Should have NO errors - C++ structs also have default constructors
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should still flag C struct variables as uninitialized", () => {
+      const code = `
+        void main() {
+          CStruct data;
+          u32 val <- data.value;
+        }
+      `;
+      const tree = parse(code);
+
+      // Create symbol table with C struct (not C++)
+      const symbolTable = new SymbolTable();
+      symbolTable.addSymbol({
+        name: "CStruct",
+        kind: ESymbolKind.Struct,
+        sourceLanguage: ESourceLanguage.C,
+        sourceFile: "types.h",
+        sourceLine: 1,
+        isExported: true,
+      });
+      symbolTable.addStructField("CStruct", "value", "u32");
+
+      const analyzer = new InitializationAnalyzer();
+      analyzer.registerExternalStructFields(
+        new Map([["CStruct", new Set(["value"])]]),
+      );
+
+      const errors = analyzer.analyze(tree, symbolTable);
+
+      // SHOULD have an error - C structs don't have constructors
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].code).toBe("E0381");
+    });
+
+    it("should work without symbol table (backward compatibility)", () => {
+      const code = `
+        struct LocalStruct {
+          u16 field;
+        }
+        void main() {
+          LocalStruct s;
+          u16 f <- s.field;
+        }
+      `;
+      const tree = parse(code);
+
+      // No symbol table passed - should still work
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      // Should have an error for uninitialized local struct
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].code).toBe("E0381");
+    });
+  });
+
+  // ========================================================================
+  // Basic Initialization Checks
+  // ========================================================================
+
+  describe("basic initialization", () => {
+    it("should not flag initialized variables", () => {
+      const code = `
+        void main() {
+          u32 x <- 5;
+          u32 y <- x;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should flag uninitialized primitive variables", () => {
+      const code = `
+        void main() {
+          u32 x;
+          u32 y <- x;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors.length).toBeGreaterThan(0);
+      expect(errors[0].code).toBe("E0381");
+      expect(errors[0].variable).toBe("x");
+    });
+
+    it("should not flag global variables (zero-initialized)", () => {
+      const code = `
+        u32 globalVar;
+        void main() {
+          u32 x <- globalVar;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should not flag function parameters", () => {
+      const code = `
+        void process(u32 param) {
+          u32 x <- param;
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new InitializationAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(0);
+    });
+  });
+});

package/src/analysis/InitializationAnalyzer.ts

@@ -19,6 +19,9 @@ import IDeclarationInfo from "./types/IDeclarationInfo";
 import ScopeStack from "./ScopeStack";
 import ExpressionUtils from "../utils/ExpressionUtils";
 import ParserUtils from "../utils/ParserUtils";
+import SymbolTable from "../symbol_resolution/SymbolTable";
+import ESourceLanguage from "../types/ESourceLanguage";
+import ESymbolKind from "../types/ESymbolKind";
 
 /**
  * Tracks the initialization state of a variable
@@ -42,10 +45,10 @@ interface IVariableState {
  * Listener that walks the parse tree and tracks initialization
  */
 class InitializationListener extends CNextListener {
-  private analyzer: InitializationAnalyzer;
+  private readonly analyzer: InitializationAnalyzer;
 
   /** Stack of saved states before each if statement */
-  private savedStates: Map<string, IVariableState>[] = [];
+  private readonly savedStates: Map<string, IVariableState>[] = [];
 
   /** Track when we're inside a function call's argument list */
   private inFunctionCallArgs: number = 0;
@@ -420,11 +423,14 @@ class InitializationAnalyzer {
   private scopeStack: ScopeStack<IVariableState> = new ScopeStack();
 
   /** Known struct types and their fields */
-  private structFields: Map<string, Set<string>> = new Map();
+  private readonly structFields: Map<string, Set<string>> = new Map();
 
   /** Track if we're processing a write target (left side of assignment) */
   private inWriteContext: boolean = false;
 
+  /** Symbol table for checking C++ types (Issue #503) */
+  private symbolTable: SymbolTable | null = null;
+
   /**
    * Register external struct fields from C/C++ headers
    * This allows the analyzer to recognize types defined in headers
@@ -439,14 +445,44 @@ class InitializationAnalyzer {
     }
   }
 
+  /**
+   * Issue #503: Check if a type name is a C++ class/struct
+   * C++ classes with default constructors are automatically initialized.
+   *
+   * @param typeName The type name to check
+   * @returns true if the type is from C++ (has constructor-based init)
+   */
+  private isCppClass(typeName: string): boolean {
+    if (!this.symbolTable) {
+      return false;
+    }
+
+    const symbols = this.symbolTable.getOverloads(typeName);
+    for (const sym of symbols) {
+      if (sym.sourceLanguage === ESourceLanguage.Cpp) {
+        // C++ classes and structs have default constructors
+        if (sym.kind === ESymbolKind.Struct || sym.kind === ESymbolKind.Class) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
   /**
    * Analyze a parsed program for initialization errors
    * @param tree The parsed program AST
+   * @param symbolTable Optional symbol table for C++ type detection
    * @returns Array of initialization errors
    */
-  public analyze(tree: Parser.ProgramContext): IInitializationError[] {
+  public analyze(
+    tree: Parser.ProgramContext,
+    symbolTable?: SymbolTable,
+  ): IInitializationError[] {
     this.errors = [];
     this.scopeStack = new ScopeStack();
+    this.symbolTable = symbolTable ?? null;
     // Don't clear structFields - external fields may have been registered
 
     // First pass: collect struct definitions
@@ -576,14 +612,18 @@ class InitializationAnalyzer {
       ? this.structFields.get(typeName)!
       : new Set<string>();
 
+    // Issue #503: C++ classes with default constructors are automatically initialized
+    const isCppClassType = typeName !== null && this.isCppClass(typeName);
+    const isInitialized = hasInitializer || isCppClassType;
+
     const state: IVariableState = {
       declaration: { name, line, column },
-      initialized: hasInitializer,
+      initialized: isInitialized,
       typeName,
       isStruct,
       isStringType,
-      // If initialized with full struct initializer, all fields are initialized
-      initializedFields: hasInitializer ? new Set(fields) : new Set(),
+      // If initialized with full struct initializer or C++ class, all fields are initialized
+      initializedFields: isInitialized ? new Set(fields) : new Set(),
     };
 
     this.scopeStack.declare(name, state);
@@ -648,7 +688,7 @@ class InitializationAnalyzer {
       if (state.isStruct && state.typeName) {
         // Struct type: check if this is a real field
         const structFields = this.structFields.get(state.typeName);
-        if (structFields && structFields.has(field)) {
+        if (structFields?.has(field)) {
           // This is a real struct field - check initialization
           if (!state.initializedFields.has(field)) {
             this.addError(

package/src/analysis/NullCheckAnalyzer.ts

@@ -201,7 +201,7 @@ interface INullCheckScope {
  * Listener that walks the parse tree and checks NULL usage
  */
 class NullCheckListener extends CNextListener {
-  private analyzer: NullCheckAnalyzer;
+  private readonly analyzer: NullCheckAnalyzer;
 
   /** Whether we're currently inside an equality comparison (= or !=) */
   private inEqualityComparison = false;
@@ -226,20 +226,20 @@ class NullCheckListener extends CNextListener {
   private currentScope: INullCheckScope | null = null;
 
   /** Stack of if-statement info for tracking nested conditions */
-  private ifStack: Array<{
+  private readonly ifStack: Array<{
     varName: string | null;
     isNullCheck: boolean;
     hasReturn: boolean;
   }> = [];
 
   /** Track if we're in the body of an if statement (first statement) */
-  private inIfBody = false;
+  private readonly inIfBody = false;
 
   /** Track the current if-statement context for body detection */
   private currentIfCtx: Parser.IfStatementContext | null = null;
 
   /** Stack of while-statement info for tracking nested while conditions */
-  private whileStack: Array<{
+  private readonly whileStack: Array<{
     varName: string | null;
     isNotNullCheck: boolean;
   }> = [];
@@ -629,7 +629,7 @@ class NullCheckListener extends CNextListener {
         // Check if argument is a simple c_ prefixed variable
         if (/^c_[a-zA-Z_]\w*$/.test(argText)) {
           const varState = this.lookupVariable(argText);
-          if (varState && varState.state === NullCheckState.Unchecked) {
+          if (varState?.state === NullCheckState.Unchecked) {
             const argLine = arg.start?.line ?? line;
             const argColumn = arg.start?.column ?? 0;
             this.analyzer.reportMissingNullCheckBeforeUse(

package/src/analysis/ParameterNamingAnalyzer.ts

@@ -47,7 +47,7 @@ function formatParameterNamingError(
  * Listener that walks the parse tree to find parameter naming violations
  */
 class ParameterNamingListener extends CNextListener {
-  private analyzer: ParameterNamingAnalyzer;
+  private readonly analyzer: ParameterNamingAnalyzer;
 
   constructor(analyzer: ParameterNamingAnalyzer) {
     super();