c-next 0.1.5 → 0.1.6

package/README.md

@@ -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
@@ -558,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)
     ;
 
 // ============================================================================
@@ -639,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
 
@@ -751,7 +751,6 @@ RBRACKET    : ']';
 SEMI        : ';';
 COMMA       : ',';
 DOT         : '.';
-DOTDOT      : '..';
 AT          : '@';
 COLON       : ':';
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.5",
+  "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",
@@ -30,7 +31,10 @@
     "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: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/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
     };
 

package/src/analysis/types/IGrammarCoverageReport.ts

@@ -0,0 +1,29 @@
+/**
+ * Grammar rule coverage report aggregating statistics across parsed files
+ */
+interface IGrammarCoverageReport {
+  /** Total number of parser rules in the grammar */
+  totalParserRules: number;
+  /** Total number of lexer rules in the grammar */
+  totalLexerRules: number;
+  /** Number of parser rules that were visited at least once */
+  visitedParserRules: number;
+  /** Number of lexer rules (token types) that were matched at least once */
+  visitedLexerRules: number;
+  /** Parser rules that were never visited */
+  neverVisitedParserRules: string[];
+  /** Lexer rules that were never matched */
+  neverVisitedLexerRules: string[];
+  /** Visit counts for each parser rule */
+  parserRuleVisits: Map<string, number>;
+  /** Match counts for each lexer rule (token type) */
+  lexerRuleVisits: Map<string, number>;
+  /** Coverage percentage for parser rules (0-100) */
+  parserCoveragePercentage: number;
+  /** Coverage percentage for lexer rules (0-100) */
+  lexerCoveragePercentage: number;
+  /** Combined coverage percentage (0-100) */
+  combinedCoveragePercentage: number;
+}
+
+export default IGrammarCoverageReport;