c-next 0.1.4 → 0.1.6

package/README.md

@@ -187,8 +187,8 @@ Your `.cnx` files and generated `.c` files remain untouched.
 If you prefer manual control, you can also run the transpiler explicitly:
 
 ```bash
-# Transpile all .cnx files in src/
-cnext --project src
+# Transpile all .cnx files in a directory (recursive)
+cnext src/
 
 # Or transpile specific files
 cnext src/ConfigStorage.cnx
@@ -661,43 +661,44 @@ 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-047](docs/decisions/adr-047-nullable-types.md)                  | NULL for C Interop      | `NULL` keyword for C stream function comparisons             |
-| [ADR-052](docs/decisions/adr-052-safe-numeric-literal-generation.md) | Safe Numeric Literals   | `type_MIN`/`type_MAX` constants + safe hex conversion        |
+| 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-047](docs/decisions/adr-047-nullable-types.md)                   | NULL for C Interop      | `NULL` keyword for C stream function comparisons             |
+| [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    |
 
 ### Research (v1 Roadmap)
 
@@ -763,6 +764,11 @@ npm test -- tests/enum/my.test.cnx    # Run single test file
 # Code quality (auto-run by pre-commit hooks)
 npm run prettier:fix   # Format all code
 npm run eslint:check   # Check for lint errors
+
+# Coverage tracking
+npm run coverage:check           # Feature coverage report
+npm run coverage:grammar         # Grammar rule coverage (generates GRAMMAR-COVERAGE.md)
+npm run coverage:grammar:check   # Grammar coverage with threshold check (CI)
 ```
 
 **Note:** C-Next runs directly via `tsx` without a build step. The `typecheck` command validates types only and does not generate any output files.

package/grammar/CNext.g4

@@ -281,7 +281,9 @@ globalMemberAccess
 
 globalArrayAccess
     : 'global' '.' IDENTIFIER '[' expression ']'                           // global.arr[i]
+    | 'global' '.' IDENTIFIER '[' expression ',' expression ']'            // global.arr[start, width]
     | 'global' '.' IDENTIFIER ('.' IDENTIFIER)+ '[' expression ']'         // global.GPIO7.DR_SET[i]
+    | 'global' '.' IDENTIFIER ('.' IDENTIFIER)+ '[' expression ',' expression ']'  // global.GPIO7.REG[start, width]
     ;
 
 expressionStatement
@@ -505,7 +507,6 @@ type
     | qualifiedType                           // ADR-016: Scope.Type from outside scope
     | userType
     | arrayType
-    | genericType
     | 'void'
     ;
 
@@ -543,15 +544,6 @@ arrayType
     | userType '[' expression ']'
     ;
 
-genericType
-    : IDENTIFIER '<' typeArgument (',' typeArgument)* '>'
-    ;
-
-typeArgument
-    : type
-    | expression    // For numeric type parameters like buffer sizes
-    ;
-
 // ----------------------------------------------------------------------------
 // Literals (ADR-024: Type suffixes OPTIONAL, validated against target type)
 // ----------------------------------------------------------------------------
@@ -568,8 +560,7 @@ literal
     | CHAR_LITERAL
     | 'true'
     | 'false'
-    | 'null'
-    | 'NULL'      // ADR-047: C library NULL for interop
+    | 'NULL'      // ADR-047: C library NULL for interop (no lowercase 'null' - ADR-039)
     ;
 
 // ============================================================================
@@ -649,8 +640,7 @@ DEFAULT     : 'default';
 RETURN      : 'return';
 TRUE        : 'true';
 FALSE       : 'false';
-NULL        : 'null';
-C_NULL      : 'NULL';     // ADR-047: C library NULL for interop
+C_NULL      : 'NULL';     // ADR-047: C library NULL for interop (no lowercase 'null' - ADR-039)
 STRING      : 'string';   // ADR-045: Bounded string type
 SIZEOF      : 'sizeof';   // ADR-023: Sizeof operator
 
@@ -761,7 +751,6 @@ RBRACKET    : ']';
 SEMI        : ';';
 COMMA       : ',';
 DOT         : '.';
-DOTDOT      : '..';
 AT          : '@';
 COLON       : ':';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {
@@ -18,6 +18,7 @@
     "typecheck": "tsc --noEmit",
     "test": "tsx scripts/test.ts",
     "test:cli": "node scripts/test-cli.js",
+    "test:q": "tsx scripts/test.ts -q",
     "test:update": "tsx scripts/test.ts --update",
     "analyze": "./scripts/static-analysis.sh",
     "clean": "rm -rf src/parser",
@@ -26,7 +27,14 @@
     "oxlint:check": "oxlint src/",
     "oxlint:fix": "oxlint src/ --fix",
     "prepare": "husky",
-    "prepublishOnly": "npm run prettier:check && npm run oxlint:check && npm test"
+    "prepublishOnly": "npm run prettier:check && npm run oxlint:check && npm test",
+    "coverage:check": "tsx scripts/coverage-checker.ts check",
+    "coverage:report": "tsx scripts/coverage-checker.ts report",
+    "coverage:gaps": "tsx scripts/coverage-checker.ts gaps",
+    "coverage:ids": "tsx scripts/coverage-checker.ts ids",
+    "coverage:grammar": "tsx scripts/grammar-coverage.ts report",
+    "coverage:grammar:check": "tsx scripts/grammar-coverage.ts check",
+    "coverage:grammar:console": "tsx scripts/grammar-coverage.ts console"
   },
   "keywords": [
     "c",

package/src/analysis/FunctionCallAnalyzer.ts

@@ -229,6 +229,42 @@ class FunctionCallListener extends CNextListener {
     this.analyzer = analyzer;
   }
 
+  // ========================================================================
+  // ISR/Callback Variable Tracking (ADR-040)
+  // ========================================================================
+
+  /**
+   * Track ISR-typed variables from variable declarations
+   * e.g., `ISR handler <- myFunction;`
+   */
+  override enterVariableDeclaration = (
+    ctx: Parser.VariableDeclarationContext,
+  ): void => {
+    const typeCtx = ctx.type();
+    const typeName = typeCtx.getText();
+
+    // Check if this is an ISR type or a callback type (function-as-type)
+    if (typeName === "ISR" || this.analyzer.isCallbackType(typeName)) {
+      const varName = ctx.IDENTIFIER().getText();
+      this.analyzer.defineCallableVariable(varName);
+    }
+  };
+
+  /**
+   * Track ISR-typed parameters in function declarations
+   * e.g., `void execute(ISR handler) { handler(); }`
+   */
+  override enterParameter = (ctx: Parser.ParameterContext): void => {
+    const typeCtx = ctx.type();
+    const typeName = typeCtx.getText();
+
+    // Check if this is an ISR type or a callback type (function-as-type)
+    if (typeName === "ISR" || this.analyzer.isCallbackType(typeName)) {
+      const paramName = ctx.IDENTIFIER().getText();
+      this.analyzer.defineCallableVariable(paramName);
+    }
+  };
+
   // ========================================================================
   // Function Definitions
   // ========================================================================
@@ -357,6 +393,12 @@ class FunctionCallAnalyzer {
   /** Current function being defined (for self-recursion detection) */
   private currentFunctionName: string | null = null;
 
+  /** ADR-040: Variables of type ISR or callback types that can be invoked */
+  private callableVariables: Set<string> = new Set();
+
+  /** ADR-029: Callback types (function-as-type pattern) */
+  private callbackTypes: Set<string> = new Set();
+
   /**
    * Analyze a parsed program for function call errors
    * @param tree The parsed program AST
@@ -373,10 +415,13 @@ class FunctionCallAnalyzer {
     this.includedHeaders = new Set();
     this.symbolTable = symbolTable ?? null;
     this.currentFunctionName = null;
+    this.callableVariables = new Set();
+    this.callbackTypes = new Set();
 
-    // First pass: collect scope names and included headers
+    // First pass: collect scope names, includes, and callback types
     this.collectScopes(tree);
     this.collectIncludes(tree);
+    this.collectCallbackTypes(tree);
 
     // Second pass: walk tree in order, tracking definitions and checking calls
     const listener = new FunctionCallListener(this);
@@ -424,6 +469,33 @@ class FunctionCallAnalyzer {
     return false;
   }
 
+  /**
+   * ADR-029: Collect callback types (function-as-type pattern)
+   * Any function definition creates a type that can be used for callback fields/parameters
+   */
+  private collectCallbackTypes(tree: Parser.ProgramContext): void {
+    for (const decl of tree.declaration()) {
+      if (decl.functionDeclaration()) {
+        const name = decl.functionDeclaration()!.IDENTIFIER().getText();
+        this.callbackTypes.add(name);
+      }
+    }
+  }
+
+  /**
+   * ADR-029: Check if a type name is a callback type (function-as-type)
+   */
+  public isCallbackType(name: string): boolean {
+    return this.callbackTypes.has(name);
+  }
+
+  /**
+   * ADR-040: Register a variable that holds a callable (ISR or callback)
+   */
+  public defineCallableVariable(name: string): void {
+    this.callableVariables.add(name);
+  }
+
   /**
    * Register a function as defined
    */
@@ -488,6 +560,11 @@ class FunctionCallAnalyzer {
       return; // OK - external C/C++ function
     }
 
+    // ADR-040: Check if this is an ISR or callback variable being invoked
+    if (this.callableVariables.has(name)) {
+      return; // OK - invoking a function pointer variable
+    }
+
     // Not defined - report error
     this.errors.push({
       code: "E0422",

package/src/analysis/GrammarCoverageListener.ts

@@ -0,0 +1,150 @@
+/**
+ * Grammar Coverage Listener
+ * Tracks which ANTLR grammar rules are executed during parsing
+ *
+ * This listener attaches to the parser and records:
+ * - Parser rules visited (e.g., program, expression, statement)
+ * - Lexer rules matched (e.g., IDENTIFIER, INTEGER_LITERAL)
+ *
+ * Used to identify dead grammar code and untested language constructs.
+ */
+
+import {
+  ErrorNode,
+  ParserRuleContext,
+  ParseTreeListener,
+  TerminalNode,
+} from "antlr4ng";
+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 parserRuleNames: string[];
+  private readonly lexerRuleNames: string[];
+
+  constructor(parserRuleNames: string[], lexerRuleNames: string[]) {
+    this.parserRuleNames = parserRuleNames;
+    this.lexerRuleNames = lexerRuleNames;
+  }
+
+  /**
+   * Called when entering every parser rule
+   */
+  enterEveryRule(ctx: ParserRuleContext): void {
+    const ruleName = this.parserRuleNames[ctx.ruleIndex];
+    if (ruleName) {
+      const count = this.parserRuleVisits.get(ruleName) || 0;
+      this.parserRuleVisits.set(ruleName, count + 1);
+    }
+  }
+
+  /**
+   * Called when exiting every parser rule
+   */
+  exitEveryRule(_ctx: ParserRuleContext): void {
+    // Not needed for coverage tracking
+  }
+
+  /**
+   * Called when visiting a terminal node (token)
+   */
+  visitTerminal(node: TerminalNode): void {
+    const tokenType = node.symbol.type;
+    // Token type -1 is EOF, skip it
+    if (tokenType < 0) return;
+
+    // Token types are 1-indexed in ANTLR, but the array is 0-indexed
+    // The first element (index 0) corresponds to token type 1
+    const ruleName = this.lexerRuleNames[tokenType - 1];
+    if (ruleName) {
+      const count = this.lexerRuleVisits.get(ruleName) || 0;
+      this.lexerRuleVisits.set(ruleName, count + 1);
+    }
+  }
+
+  /**
+   * Called when visiting an error node
+   */
+  visitErrorNode(_node: ErrorNode): void {
+    // Track error nodes if needed in the future
+  }
+
+  /**
+   * Merge coverage from another listener (for aggregating across files)
+   */
+  merge(other: GrammarCoverageListener): void {
+    for (const [rule, count] of other.parserRuleVisits) {
+      const current = this.parserRuleVisits.get(rule) || 0;
+      this.parserRuleVisits.set(rule, current + count);
+    }
+    for (const [rule, count] of other.lexerRuleVisits) {
+      const current = this.lexerRuleVisits.get(rule) || 0;
+      this.lexerRuleVisits.set(rule, current + count);
+    }
+  }
+
+  /**
+   * Reset all coverage counters
+   */
+  reset(): void {
+    this.parserRuleVisits.clear();
+    this.lexerRuleVisits.clear();
+  }
+
+  /**
+   * Get the current parser rule visit counts
+   */
+  getParserRuleVisits(): Map<string, number> {
+    return new Map(this.parserRuleVisits);
+  }
+
+  /**
+   * Get the current lexer rule visit counts
+   */
+  getLexerRuleVisits(): Map<string, number> {
+    return new Map(this.lexerRuleVisits);
+  }
+
+  /**
+   * Generate a coverage report
+   */
+  getReport(): IGrammarCoverageReport {
+    const totalParserRules = this.parserRuleNames.length;
+    const totalLexerRules = this.lexerRuleNames.length;
+    const visitedParserRules = this.parserRuleVisits.size;
+    const visitedLexerRules = this.lexerRuleVisits.size;
+
+    const neverVisitedParserRules = this.parserRuleNames.filter(
+      (name) => !this.parserRuleVisits.has(name),
+    );
+    const neverVisitedLexerRules = this.lexerRuleNames.filter(
+      (name) => !this.lexerRuleVisits.has(name),
+    );
+
+    const parserCoveragePercentage =
+      totalParserRules > 0 ? (visitedParserRules / totalParserRules) * 100 : 0;
+    const lexerCoveragePercentage =
+      totalLexerRules > 0 ? (visitedLexerRules / totalLexerRules) * 100 : 0;
+    const combinedTotal = totalParserRules + totalLexerRules;
+    const combinedVisited = visitedParserRules + visitedLexerRules;
+    const combinedCoveragePercentage =
+      combinedTotal > 0 ? (combinedVisited / combinedTotal) * 100 : 0;
+
+    return {
+      totalParserRules,
+      totalLexerRules,
+      visitedParserRules,
+      visitedLexerRules,
+      neverVisitedParserRules,
+      neverVisitedLexerRules,
+      parserRuleVisits: new Map(this.parserRuleVisits),
+      lexerRuleVisits: new Map(this.lexerRuleVisits),
+      parserCoveragePercentage,
+      lexerCoveragePercentage,
+      combinedCoveragePercentage,
+    };
+  }
+}
+
+export default GrammarCoverageListener;

package/src/analysis/InitializationAnalyzer.ts

@@ -31,6 +31,8 @@ interface IVariableState {
   initializedFields: Set<string>;
   /** Is this a struct type? */
   isStruct: boolean;
+  /** Is this a string type? (string<N> or string) */
+  isStringType: boolean;
 }
 
 /**
@@ -132,7 +134,17 @@ class InitializationListener extends CNextListener {
       typeName = typeCtx.userType()!.IDENTIFIER().getText();
     }
 
-    this.analyzer.declareVariable(name, line, column, hasInitializer, typeName);
+    // Check if this is a string type (string<N> or string)
+    const isStringType = typeCtx.stringType() !== null;
+
+    this.analyzer.declareVariable(
+      name,
+      line,
+      column,
+      hasInitializer,
+      typeName,
+      isStringType,
+    );
   };
 
   // ========================================================================
@@ -266,6 +278,47 @@ class InitializationListener extends CNextListener {
       const line = ctx.start?.line ?? 0;
       const column = ctx.start?.column ?? 0;
 
+      // Check if this is part of a postfixExpression with member access
+      const parent = ctx.parent as Parser.PostfixExpressionContext | undefined;
+      if (parent?.postfixOp && parent.postfixOp().length > 0) {
+        const ops = parent.postfixOp();
+        const firstOp = ops[0];
+        const opText = firstOp.getText();
+
+        // Issue #196 Bug 2: Skip init check for .length on non-string types
+        // .length is a compile-time type property that doesn't read runtime values
+        // BUT: struct.field.length where field is a string DOES need init check
+        const varState = this.analyzer.lookupVariableState(name);
+        const isStringType = varState?.isStringType ?? false;
+
+        // Check if chain ends with .length on non-string type
+        if (!isStringType) {
+          const lastOp = ops[ops.length - 1].getText();
+          if (lastOp === ".length") {
+            const firstOpText = ops[0].getText();
+            // Only skip if:
+            // 1. Direct .length access on non-string variable (ops = [".length"])
+            // 2. Array element .length access (ops = ["[...]", ".length"])
+            // Do NOT skip for struct member access (ops = [".field", ".length"])
+            // because the field might be a string type that needs init check
+            if (ops.length === 1 || firstOpText.startsWith("[")) {
+              // .length on non-string base or array element - compile-time, skip
+              return;
+            }
+            // Fall through for struct member access - the member might be a string
+          }
+        }
+
+        // If the first postfixOp is a member access (has '.'), check the field
+        if (opText.startsWith(".")) {
+          // Extract field name (remove the leading '.')
+          const fieldName = opText.slice(1);
+          // Check field-level initialization instead of whole variable
+          this.analyzer.checkRead(name, line, column, fieldName);
+          return;
+        }
+      }
+
       this.analyzer.checkRead(name, line, column);
     }
   };
@@ -415,6 +468,20 @@ class InitializationAnalyzer {
   /** Track if we're processing a write target (left side of assignment) */
   private inWriteContext: boolean = false;
 
+  /**
+   * Register external struct fields from C/C++ headers
+   * This allows the analyzer to recognize types defined in headers
+   *
+   * @param externalFields Map of struct name -> Set of field names
+   */
+  public registerExternalStructFields(
+    externalFields: Map<string, Set<string>>,
+  ): void {
+    for (const [structName, fields] of externalFields) {
+      this.structFields.set(structName, fields);
+    }
+  }
+
   /**
    * Analyze a parsed program for initialization errors
    * @param tree The parsed program AST
@@ -423,7 +490,7 @@ class InitializationAnalyzer {
   public analyze(tree: Parser.ProgramContext): IInitializationError[] {
     this.errors = [];
     this.currentScope = null;
-    this.structFields.clear();
+    // Don't clear structFields - external fields may have been registered
 
     // First pass: collect struct definitions
     this.collectStructDefinitions(tree);
@@ -548,6 +615,7 @@ class InitializationAnalyzer {
     column: number,
     hasInitializer: boolean,
     typeName: string | null,
+    isStringType: boolean = false,
   ): void {
     if (!this.currentScope) {
       // Global scope - create implicit scope
@@ -564,6 +632,7 @@ class InitializationAnalyzer {
       initialized: hasInitializer,
       typeName,
       isStruct,
+      isStringType,
       // If initialized with full struct initializer, all fields are initialized
       initializedFields: hasInitializer ? new Set(fields) : new Set(),
     };
@@ -624,16 +693,41 @@ class InitializationAnalyzer {
     }
 
     if (field) {
-      // Reading a specific field
-      if (!state.initializedFields.has(field)) {
-        this.addError(
-          `${name}.${field}`,
-          line,
-          column,
-          state.declaration,
-          false, // Definitely uninitialized
-        );
+      // Reading a specific field/property
+      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)) {
+          // This is a real struct field - check initialization
+          if (!state.initializedFields.has(field)) {
+            this.addError(
+              `${name}.${field}`,
+              line,
+              column,
+              state.declaration,
+              false, // Definitely uninitialized
+            );
+          }
+        }
+        // else: field doesn't exist in struct, could be a type property like .length
+        // Skip check - let code generator handle unknown field errors
+      } else if (state.isStringType) {
+        // String type: .length, .capacity, and .size are runtime properties that require initialization
+        if (
+          (field === "length" || field === "capacity" || field === "size") &&
+          !state.initialized
+        ) {
+          this.addError(
+            name,
+            line,
+            column,
+            state.declaration,
+            false, // Definitely uninitialized
+          );
+        }
       }
+      // Other types (primitives): .field access is a type property (like .length for bit width)
+      // which is always available at compile time, no init check needed
     } else if (!state.initialized) {
       // Reading the whole variable
       this.addError(
@@ -660,6 +754,14 @@ class InitializationAnalyzer {
     return null;
   }
 
+  /**
+   * Public method to look up variable state
+   * Issue #196 Bug 2: Used by visitor to check if variable is string type
+   */
+  public lookupVariableState(name: string): IVariableState | null {
+    return this.lookupVariable(name);
+  }
+
   // ========================================================================
   // Control Flow
   // ========================================================================
@@ -787,6 +889,7 @@ class InitializationAnalyzer {
       initialized: true, // Parameters are always initialized by caller
       typeName,
       isStruct,
+      isStringType: false, // Not tracked for parameters since they're always initialized
       initializedFields: new Set(fields), // All fields initialized
     };