c-next 0.1.30 → 0.1.31

package/grammar/CNext.g4

@@ -84,6 +84,7 @@ scopeMember
     | visibilityModifier? enumDeclaration
     | visibilityModifier? bitmapDeclaration
     | visibilityModifier? registerDeclaration
+    | visibilityModifier? structDeclaration
     ;
 
 visibilityModifier
@@ -193,6 +194,12 @@ arrayDimension
 // ----------------------------------------------------------------------------
 variableDeclaration
     : atomicModifier? volatileModifier? constModifier? overflowModifier? type IDENTIFIER arrayDimension* ('<-' expression)? ';'
+    | type IDENTIFIER '(' constructorArgumentList ')' ';'   // Issue #375: C++ constructor
+    ;
+
+// Issue #375: Constructor argument list - identifiers only (must be const variables)
+constructorArgumentList
+    : IDENTIFIER (',' IDENTIFIER)*
     ;
 
 // ----------------------------------------------------------------------------
@@ -264,7 +271,8 @@ thisMemberAccess
 
 // ADR-016: this.member[idx] or this.member.member[idx] for scope-local array/bit access
 thisArrayAccess
-    : 'this' '.' IDENTIFIER '[' expression ']'                           // this.arr[i]
+    : 'this' '.' IDENTIFIER '[' expression ']' ('.' IDENTIFIER)+         // this.arr[i].field.field2...
+    | 'this' '.' IDENTIFIER '[' expression ']'                           // this.arr[i]
     | 'this' '.' IDENTIFIER '[' expression ',' expression ']'            // this.reg[offset, width]
     | 'this' '.' IDENTIFIER ('.' IDENTIFIER)+ '[' expression ']'         // this.GPIO7.DR_SET[i]
     | 'this' '.' IDENTIFIER ('.' IDENTIFIER)+ '[' expression ',' expression ']'  // this.GPIO7.ICR1[6, 2]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.30",
+  "version": "0.1.31",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "main": "src/index.ts",
   "bin": {
@@ -37,6 +37,8 @@
     "coverage:grammar:console": "tsx scripts/grammar-coverage.ts console",
     "unit": "vitest run",
     "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"
   },
   "keywords": [
@@ -68,6 +70,7 @@
   ],
   "devDependencies": {
     "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^3.2.4",
     "antlr4ng-cli": "^2.0.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",

package/src/codegen/CodeGenerator.ts

@@ -1665,6 +1665,10 @@ export default class CodeGenerator implements IOrchestrator {
         const scopeDecl = decl.scopeDeclaration()!;
         const scopeName = scopeDecl.IDENTIFIER().getText();
 
+        // Set scope context for scoped type resolution (this.Type)
+        const savedScope = this.context.currentScope;
+        this.context.currentScope = scopeName;
+
         for (const member of scopeDecl.scopeMember()) {
           if (member.functionDeclaration()) {
             const funcDecl = member.functionDeclaration()!;
@@ -1682,6 +1686,9 @@ export default class CodeGenerator implements IOrchestrator {
             this.registerCallbackType(fullName, funcDecl);
           }
         }
+
+        // Restore previous scope context
+        this.context.currentScope = savedScope;
       }
 
       // ADR-029: Track callback field types in structs
@@ -3173,12 +3180,24 @@ export default class CodeGenerator implements IOrchestrator {
         // ADR-029: Check if this is a callback type
         isCallback = this.callbackTypes.has(typeName);
       } else if (typeCtx.qualifiedType()) {
-        // ADR-016: Handle qualified enum types like Scope.EnumType
+        // ADR-016: Handle qualified types like Scope.Type
         typeName = typeCtx
           .qualifiedType()!
           .IDENTIFIER()
           .map((id) => id.getText())
           .join("_");
+        // Check if this is a struct type
+        isStruct = this.isStructType(typeName);
+      } else if (typeCtx.scopedType()) {
+        // ADR-016: Handle scoped types like this.Type (inside a scope)
+        const localTypeName = typeCtx.scopedType()!.IDENTIFIER().getText();
+        if (this.context.currentScope) {
+          typeName = `${this.context.currentScope}_${localTypeName}`;
+        } else {
+          typeName = localTypeName;
+        }
+        // Check if this is a struct type
+        isStruct = this.isStructType(typeName);
       } else if (typeCtx.stringType()) {
         // ADR-045: String parameter
         isString = true;
@@ -5232,6 +5251,12 @@ export default class CodeGenerator implements IOrchestrator {
   // ========================================================================
 
   private generateVariableDecl(ctx: Parser.VariableDeclarationContext): string {
+    // Issue #375: Check for C++ constructor syntax
+    const constructorArgList = ctx.constructorArgumentList();
+    if (constructorArgList) {
+      return this._generateConstructorDecl(ctx, constructorArgList);
+    }
+
     const constMod = ctx.constModifier() ? "const " : "";
     // ADR-049: Add volatile for atomic variables
     const atomicMod = ctx.atomicModifier() ? "volatile " : "";
@@ -5647,6 +5672,75 @@ export default class CodeGenerator implements IOrchestrator {
     return decl + ";";
   }
 
+  /**
+   * Issue #375: Generate C++ constructor-style declaration
+   * Validates that all arguments are const variables.
+   * Example: `Adafruit_MAX31856 thermocouple(pinConst);` -> `Adafruit_MAX31856 thermocouple(pinConst);`
+   */
+  private _generateConstructorDecl(
+    ctx: Parser.VariableDeclarationContext,
+    argListCtx: Parser.ConstructorArgumentListContext,
+  ): string {
+    const type = this._generateType(ctx.type());
+    const name = ctx.IDENTIFIER().getText();
+    const line = ctx.start?.line ?? 0;
+
+    // Collect and validate all arguments
+    const argIdentifiers = argListCtx.IDENTIFIER();
+    const resolvedArgs: string[] = [];
+
+    for (const argNode of argIdentifiers) {
+      const argName = argNode.getText();
+
+      // Check if it exists in type registry
+      const typeInfo = this.context.typeRegistry.get(argName);
+
+      // Also check scoped variables if inside a scope
+      let scopedArgName = argName;
+      let scopedTypeInfo = typeInfo;
+      if (!typeInfo && this.context.currentScope) {
+        scopedArgName = `${this.context.currentScope}_${argName}`;
+        scopedTypeInfo = this.context.typeRegistry.get(scopedArgName);
+      }
+
+      if (!typeInfo && !scopedTypeInfo) {
+        throw new Error(
+          `Error at line ${line}: Constructor argument '${argName}' is not declared`,
+        );
+      }
+
+      const finalTypeInfo = typeInfo ?? scopedTypeInfo!;
+      const finalArgName = typeInfo ? argName : scopedArgName;
+
+      // Check if it's const
+      if (!finalTypeInfo.isConst) {
+        throw new Error(
+          `Error at line ${line}: Constructor argument '${argName}' must be const. ` +
+            `C++ constructors in C-Next only accept const variables.`,
+        );
+      }
+
+      resolvedArgs.push(finalArgName);
+    }
+
+    // Track the variable in type registry (as an external C++ type)
+    this.context.typeRegistry.set(name, {
+      baseType: type,
+      bitWidth: 0, // Unknown for C++ types
+      isArray: false,
+      arrayDimensions: [],
+      isConst: false,
+      isExternalCppType: true,
+    });
+
+    // Track as local variable if inside function body
+    if (this.context.inFunctionBody) {
+      this.context.localVariables.add(name);
+    }
+
+    return `${type} ${name}(${resolvedArgs.join(", ")});`;
+  }
+
   /**
    * ADR-015: Get the appropriate zero initializer for a type
    * ADR-017: Handle enum types by initializing to first member
@@ -5660,6 +5754,64 @@ export default class CodeGenerator implements IOrchestrator {
       return "{0}";
     }
 
+    // ADR-016: Check for scoped types (this.Type)
+    // These are always struct/enum types defined in a scope
+    if (typeCtx.scopedType()) {
+      const localTypeName = typeCtx.scopedType()!.IDENTIFIER().getText();
+      const fullTypeName = this.context.currentScope
+        ? `${this.context.currentScope}_${localTypeName}`
+        : localTypeName;
+
+      // Check if it's an enum
+      if (this.symbols!.knownEnums.has(fullTypeName)) {
+        const members = this.symbols!.enumMembers.get(fullTypeName);
+        if (members) {
+          for (const [memberName, value] of members.entries()) {
+            if (value === 0) {
+              return `${fullTypeName}_${memberName}`;
+            }
+          }
+          const firstMember = members.keys().next().value;
+          if (firstMember) {
+            return `${fullTypeName}_${firstMember}`;
+          }
+        }
+        return `(${fullTypeName})0`;
+      }
+
+      // Otherwise it's a struct - use {0}
+      return "{0}";
+    }
+
+    // ADR-016: Check for qualified types (Scope.Type)
+    if (typeCtx.qualifiedType()) {
+      const qualifiedCtx = typeCtx.qualifiedType()!;
+      const parts = qualifiedCtx.IDENTIFIER();
+      const scopeName = parts[0].getText();
+      const localTypeName = parts[1].getText();
+      const fullTypeName = `${scopeName}_${localTypeName}`;
+
+      // Check if it's an enum
+      if (this.symbols!.knownEnums.has(fullTypeName)) {
+        const members = this.symbols!.enumMembers.get(fullTypeName);
+        if (members) {
+          for (const [memberName, value] of members.entries()) {
+            if (value === 0) {
+              return `${fullTypeName}_${memberName}`;
+            }
+          }
+          const firstMember = members.keys().next().value;
+          if (firstMember) {
+            return `${fullTypeName}_${firstMember}`;
+          }
+        }
+        return `(${fullTypeName})0`;
+      }
+
+      // Otherwise it's a struct - use {0}
+      return "{0}";
+    }
+
     // Check for user-defined types (structs/classes/enums)
     if (typeCtx.userType()) {
       const typeName = typeCtx.userType()!.getText();
@@ -6839,6 +6991,18 @@ export default class CodeGenerator implements IOrchestrator {
         if (parts.length === 1) {
           return `${scopeName}_${parts[0]}[${expr}] ${cOp} ${value};`;
         }
+
+        // Check if this is array-then-field (this.arr[i].field) vs field-then-array (this.a.b[i])
+        // by examining the context text - if '[' comes right after first identifier, it's array-first
+        const ctxText = thisArrayAccessCtx.getText();
+        const firstIdEnd = ctxText.indexOf(parts[0]) + parts[0].length;
+
+        if (ctxText.charAt(firstIdEnd) === "[") {
+          // Array access comes first: this.buffer[i].field -> Scope_buffer[i].field
+          return `${scopeName}_${parts[0]}[${expr}].${parts.slice(1).join(".")} ${cOp} ${value};`;
+        }
+
+        // Field access comes first: this.GPIO7.DR_SET[i] -> Scope_GPIO7.DR_SET[i]
         return `${scopeName}_${parts[0]}.${parts.slice(1).join(".")}[${expr}] ${cOp} ${value};`;
       }
     }
@@ -7530,6 +7694,19 @@ export default class CodeGenerator implements IOrchestrator {
       // ADR-016: Validate visibility before allowing cross-scope access
       const memberName = parts[1];
       this.validateCrossScopeVisibility(firstId, memberName);
+
+      // Check if the scope variable is a struct type - if so, remaining parts
+      // are struct field access and should use '.' not '_'
+      // e.g., global.Motor.current.speed -> Motor_current.speed
+      if (parts.length > 2) {
+        const scopeVarName = `${firstId}_${memberName}`;
+        const scopeVarType = this.context.typeRegistry.get(scopeVarName);
+        if (scopeVarType && this._isKnownStruct(scopeVarType.baseType)) {
+          // Scope variable is a struct - use '.' for field access
+          return `${scopeVarName}.${parts.slice(2).join(".")}`;
+        }
+      }
+
       // Issue #304: Use :: for C++ namespaces, _ for C-Next scopes
       return parts.join(this.getScopeSeparator(isCppAccess));
     }
@@ -7655,6 +7832,19 @@ export default class CodeGenerator implements IOrchestrator {
     if (parts.length === 1) {
       return `${scopeName}_${parts[0]}[${expr}]`;
     }
+
+    // Check if this is array-then-field (this.arr[i].field) vs field-then-array (this.a.b[i])
+    // by examining the context text - if '[' comes right after first identifier, it's array-first
+    const ctxText = ctx.getText();
+    const firstIdEnd = ctxText.indexOf(parts[0]) + parts[0].length;
+    const bracketPos = ctxText.indexOf("[");
+
+    if (bracketPos === firstIdEnd + 1 || ctxText.charAt(firstIdEnd) === "[") {
+      // Array access comes first: this.buffer[i].field -> Scope_buffer[i].field
+      return `${scopeName}_${parts[0]}[${expr}].${parts.slice(1).join(".")}`;
+    }
+
+    // Field access comes first: this.GPIO7.DR_SET[i] -> Scope_GPIO7.DR_SET[i]
     return `${scopeName}_${parts[0]}.${parts.slice(1).join(".")}[${expr}]`;
   }
 
@@ -9589,6 +9779,18 @@ export default class CodeGenerator implements IOrchestrator {
       // ADR-016: Validate visibility before allowing cross-scope access
       const memberName = parts[1];
       this.validateCrossScopeVisibility(firstPart, memberName);
+
+      // Check if the scope variable is a struct type - if so, remaining parts
+      // are struct field access and should use '.' not '_'
+      // e.g., Motor.current.speed -> Motor_current.speed (not Motor_current_speed)
+      if (parts.length > 2) {
+        const scopeVarName = `${firstPart}_${memberName}`;
+        const scopeVarType = this.context.typeRegistry.get(scopeVarName);
+        if (scopeVarType && this._isKnownStruct(scopeVarType.baseType)) {
+          // Scope variable is a struct - use '.' for field access
+          return `${scopeVarName}.${parts.slice(2).join(".")}`;
+        }
+      }
       return parts.join("_");
     }
 
@@ -9737,6 +9939,10 @@ export default class CodeGenerator implements IOrchestrator {
       const identifiers = ctx.qualifiedType()!.IDENTIFIER();
       const scopeName = identifiers[0].getText();
       const typeName = identifiers[1].getText();
+
+      // Check visibility for scoped types (structs, enums, bitmaps)
+      this._validateCrossScopeVisibility(scopeName, typeName);
+
       return `${scopeName}_${typeName}`;
     }
     if (ctx.userType()) {

package/src/codegen/SymbolCollector.ts

@@ -240,7 +240,7 @@ class SymbolCollector {
       if (decl.bitmapDeclaration()) {
         this.collectBitmap(decl.bitmapDeclaration()!);
       }
-      // Also collect bitmaps inside scopes first
+      // Also collect bitmaps and structs inside scopes first
       if (decl.scopeDeclaration()) {
         const scopeDecl = decl.scopeDeclaration()!;
         const scopeName = scopeDecl.IDENTIFIER().getText();
@@ -248,6 +248,10 @@ class SymbolCollector {
           if (member.bitmapDeclaration()) {
             this.collectBitmap(member.bitmapDeclaration()!, scopeName);
           }
+          // Collect scoped structs early so they're available as types
+          if (member.structDeclaration()) {
+            this.collectStruct(member.structDeclaration()!, scopeName);
+          }
         }
       }
     }
@@ -378,6 +382,17 @@ class SymbolCollector {
           }
         }
       }
+
+      // Handle struct declarations inside scopes
+      // Note: Struct collection happens in first pass for early availability,
+      // but we still need to add to scope members and visibility here
+      if (member.structDeclaration()) {
+        const structDecl = member.structDeclaration()!;
+        const structName = structDecl.IDENTIFIER().getText();
+        members.add(structName);
+        memberVisibility.set(structName, visibility);
+        // Note: collectStruct already called in first pass
+      }
     }
 
     this._scopeMembers.set(name, members);
@@ -523,10 +538,16 @@ class SymbolCollector {
 
   /**
    * Collect struct declarations and track field types
+   * @param structDecl The struct declaration context
+   * @param scopeName Optional scope name for scoped struct declarations
    */
-  private collectStruct(structDecl: Parser.StructDeclarationContext): void {
+  private collectStruct(
+    structDecl: Parser.StructDeclarationContext,
+    scopeName?: string,
+  ): void {
     const name = structDecl.IDENTIFIER().getText();
-    this._knownStructs.add(name);
+    const fullName = scopeName ? `${scopeName}_${name}` : name;
+    this._knownStructs.add(fullName);
 
     const fields = new Map<string, string>();
     const arrayFields = new Set<string>();
@@ -584,9 +605,9 @@ class SymbolCollector {
       }
     }
 
-    this._structFields.set(name, fields);
-    this._structFieldArrays.set(name, arrayFields);
-    this._structFieldDimensions.set(name, fieldDimensions);
+    this._structFields.set(fullName, fields);
+    this._structFieldArrays.set(fullName, arrayFields);
+    this._structFieldDimensions.set(fullName, fieldDimensions);
   }
 
   /**

package/src/codegen/generators/declarationGenerators/ScopeGenerator.ts

@@ -53,6 +53,39 @@ const generateScope: TGeneratorFn<Parser.ScopeDeclarationContext> = (
       const varDecl = member.variableDeclaration()!;
       const varName = varDecl.IDENTIFIER().getText();
 
+      // Issue #375: Check for constructor syntax
+      const constructorArgList = varDecl.constructorArgumentList();
+      if (constructorArgList) {
+        // ADR-016: All scope variables are emitted at file scope
+        const type = orchestrator.generateType(varDecl.type());
+        const fullName = `${name}_${varName}`;
+        const prefix = isPrivate ? "static " : "";
+
+        // Validate and resolve constructor arguments
+        const argIdentifiers = constructorArgList.IDENTIFIER();
+        const resolvedArgs: string[] = [];
+        const line = varDecl.start?.line ?? 0;
+
+        for (const argNode of argIdentifiers) {
+          const argName = argNode.getText();
+          // Arguments must be resolved with scope prefix
+          const scopedArgName = `${name}_${argName}`;
+
+          // Check if it's const using orchestrator
+          if (!orchestrator.isConstValue(scopedArgName)) {
+            throw new Error(
+              `Error at line ${line}: Constructor argument '${argName}' must be const. ` +
+                `C++ constructors in C-Next only accept const variables.`,
+            );
+          }
+
+          resolvedArgs.push(scopedArgName);
+        }
+
+        lines.push(`${prefix}${type} ${fullName}(${resolvedArgs.join(", ")});`);
+        continue;
+      }
+
       // Issue #282: Check if this is a const variable - const values should be inlined
       const isConst = varDecl.constModifier() !== null;
 
@@ -170,6 +203,16 @@ const generateScope: TGeneratorFn<Parser.ScopeDeclarationContext> = (
       );
       lines.push(result.code);
     }
+
+    // Handle struct declarations inside scopes
+    // Issue #369: Skip struct definition if self-include was added (it will be in the header)
+    if (member.structDeclaration() && !state.selfIncludeAdded) {
+      const structDecl = member.structDeclaration()!;
+      lines.push("");
+      lines.push(
+        generateScopedStructInline(structDecl, name, input, orchestrator),
+      );
+    }
   }
 
   lines.push("");
@@ -320,4 +363,51 @@ function generateScopedBitmapInline(
   return lines.join("\n");
 }
 
+/**
+ * Generate struct inside a scope with proper prefixing.
+ * Struct fields maintain their original types.
+ */
+function generateScopedStructInline(
+  node: Parser.StructDeclarationContext,
+  scopeName: string,
+  input: IGeneratorInput,
+  orchestrator: IOrchestrator,
+): string {
+  const name = node.IDENTIFIER().getText();
+  const fullName = `${scopeName}_${name}`;
+
+  const lines: string[] = [];
+  lines.push(`typedef struct ${fullName} {`);
+
+  // Process struct members
+  for (const member of node.structMember()) {
+    const fieldName = member.IDENTIFIER().getText();
+    const fieldType = orchestrator.generateType(member.type());
+
+    // Handle array dimensions if present
+    const arrayDims = member.arrayDimension();
+    let dimStr = "";
+    if (arrayDims.length > 0) {
+      dimStr = orchestrator.generateArrayDimensions(arrayDims);
+    }
+
+    // Handle string capacity for string fields
+    if (member.type().stringType()) {
+      const stringCtx = member.type().stringType()!;
+      const intLiteral = stringCtx.INTEGER_LITERAL();
+      if (intLiteral) {
+        const capacity = parseInt(intLiteral.getText(), 10);
+        dimStr += `[${capacity + 1}]`;
+      }
+    }
+
+    lines.push(`    ${fieldType} ${fieldName}${dimStr};`);
+  }
+
+  lines.push(`} ${fullName};`);
+  lines.push("");
+
+  return lines.join("\n");
+}
+
 export default generateScope;

package/src/codegen/types/TTypeInfo.ts

@@ -17,6 +17,7 @@ type TTypeInfo = {
   isString?: boolean;
   stringCapacity?: number;
   isAtomic?: boolean;
+  isExternalCppType?: boolean; // Issue #375: C++ types instantiated via constructor
 };
 
 export default TTypeInfo;