c-next 0.2.6 → 0.2.7

package/src/transpiler/output/codegen/generators/expressions/AccessExprGenerator.ts

@@ -1,337 +1,19 @@
 /**
  * Access Expression Generator (ADR-053 A2 Phase 6)
  *
- * Generates C code for property access expressions:
- * - .length property for arrays, strings, and integers
- * - .capacity property for strings
- * - .size property for strings (buffer size = capacity + 1)
+ * Generates C code for string buffer property access:
+ * - .capacity → compile-time max string length (excluding null terminator)
+ * - .size → compile-time buffer size (capacity + 1, for null terminator)
  *
  * Also provides helper for bitmap field access.
+ *
+ * Note: Explicit length properties (.bit_length, .byte_length, .element_count,
+ * .char_count) are handled in PostfixExpressionGenerator.ts, not here.
+ * The deprecated .length property was removed per ADR-058.
  */
 import IGeneratorOutput from "../IGeneratorOutput";
-import TGeneratorEffect from "../TGeneratorEffect";
 import TTypeInfo from "../../types/TTypeInfo";
 
-// Type width mappings - C-Next integer types to their bit widths
-const TYPE_WIDTH: Record<string, number> = {
-  u8: 8,
-  u16: 16,
-  u32: 32,
-  u64: 64,
-  i8: 8,
-  i16: 16,
-  i32: 32,
-  i64: 64,
-  f32: 32,
-  f64: 64,
-  bool: 1,
-};
-
-// C type widths for header-defined types
-const C_TYPE_WIDTH: Record<string, number> = {
-  uint8_t: 8,
-  uint16_t: 16,
-  uint32_t: 32,
-  uint64_t: 64,
-  int8_t: 8,
-  int16_t: 16,
-  int32_t: 32,
-  int64_t: 64,
-  float: 32,
-  double: 64,
-};
-
-/**
- * Context passed to property generators.
- * Contains the current expression state needed for property resolution.
- */
-interface PropertyContext {
-  /** Current result string being built */
-  result: string;
-  /** Primary identifier (if any) */
-  primaryId: string | undefined;
-  /** Current resolved identifier (for type lookups) */
-  currentIdentifier: string | undefined;
-  /** How many array dimensions have been subscripted */
-  subscriptDepth: number;
-  /** Previous struct type in chain (for struct member .length) */
-  previousStructType: string | undefined;
-  /** Previous member name in chain (for struct member .length) */
-  previousMemberName: string | undefined;
-  /** Type info from type registry */
-  typeInfo: TTypeInfo | undefined;
-  /** Main function args parameter name (for args.length -> argc) */
-  mainArgsName: string | undefined;
-  /** Length cache for string lengths */
-  lengthCache: ReadonlyMap<string, string> | undefined;
-  /** Struct field info lookup function */
-  getStructFieldInfo: (
-    structType: string,
-    fieldName: string,
-  ) => { type: string; dimensions?: number[] } | undefined;
-  /** Issue #201: Bitmap bit width lookup function */
-  getBitmapBitWidth?: (bitmapTypeName: string) => number | undefined;
-}
-
-/**
- * Result of property generation.
- */
-interface PropertyResult {
-  /** Generated code (or null if property wasn't handled) */
-  code: string | null;
-  /** Effects to apply */
-  effects: TGeneratorEffect[];
-  /** Whether to skip further processing in the loop */
-  skipContinue: boolean;
-}
-
-/**
- * Get bit width for a type, checking both C-Next and C types.
- */
-function getTypeBitWidth(typeName: string): number {
-  return TYPE_WIDTH[typeName] || C_TYPE_WIDTH[typeName] || 0;
-}
-
-/**
- * Create a PropertyResult with strlen effect.
- */
-function makeStrlenResult(expr: string, skipContinue: boolean): PropertyResult {
-  return {
-    code: `strlen(${expr})`,
-    effects: [{ type: "include", header: "string" }],
-    skipContinue,
-  };
-}
-
-/**
- * Create a PropertyResult for bit width (or unsupported type comment).
- * @param isElement - true for array element types (uses "element type" in error)
- */
-function makeBitWidthResult(
-  typeName: string,
-  skipContinue: boolean,
-  isElement: boolean = false,
-): PropertyResult {
-  const bitWidth = getTypeBitWidth(typeName);
-  if (bitWidth > 0) {
-    return { code: String(bitWidth), effects: [], skipContinue };
-  }
-  const typeLabel = isElement ? "element type" : "type";
-  return {
-    code: `/* .length: unsupported ${typeLabel} ${typeName} */0`,
-    effects: [],
-    skipContinue,
-  };
-}
-
-/**
- * Handle .length for struct member access (cfg.field.length).
- */
-function handleStructMemberLength(ctx: PropertyContext): PropertyResult | null {
-  if (!ctx.previousStructType || !ctx.previousMemberName) {
-    return null;
-  }
-
-  const fieldInfo = ctx.getStructFieldInfo(
-    ctx.previousStructType,
-    ctx.previousMemberName,
-  );
-  if (!fieldInfo) {
-    return null;
-  }
-
-  const { type: memberType, dimensions } = fieldInfo;
-  const isStringField = memberType.startsWith("string<");
-
-  // String array field: string<64> arr[4]
-  if (dimensions && dimensions.length > 1 && isStringField) {
-    if (ctx.subscriptDepth === 0) {
-      return { code: String(dimensions[0]), effects: [], skipContinue: true };
-    }
-    return makeStrlenResult(ctx.result, true);
-  }
-
-  // Single string field: string<64> str
-  if (dimensions?.length === 1 && isStringField) {
-    return makeStrlenResult(ctx.result, true);
-  }
-
-  // Multi-dim array member with partial subscript
-  if (
-    dimensions &&
-    dimensions.length > 0 &&
-    ctx.subscriptDepth < dimensions.length
-  ) {
-    return {
-      code: String(dimensions[ctx.subscriptDepth]),
-      effects: [],
-      skipContinue: true,
-    };
-  }
-
-  // Array member fully subscripted -> return element bit width
-  if (
-    dimensions &&
-    dimensions.length > 0 &&
-    ctx.subscriptDepth >= dimensions.length
-  ) {
-    return makeBitWidthResult(memberType, true, true); // isElement=true
-  }
-
-  // Non-array member -> return bit width
-  return makeBitWidthResult(memberType, true, false); // isElement=false
-}
-
-/**
- * Handle .length for string types.
- */
-function handleStringLength(
-  ctx: PropertyContext,
-  typeInfo: TTypeInfo,
-): PropertyResult {
-  // String array: arrayDimensions: [4, 65]
-  if (typeInfo.arrayDimensions && typeInfo.arrayDimensions.length > 1) {
-    if (ctx.subscriptDepth === 0) {
-      return {
-        code: String(typeInfo.arrayDimensions[0]),
-        effects: [],
-        skipContinue: false,
-      };
-    }
-    return makeStrlenResult(ctx.result, false);
-  }
-
-  // Single string with cached length
-  if (ctx.currentIdentifier && ctx.lengthCache?.has(ctx.currentIdentifier)) {
-    return {
-      code: ctx.lengthCache.get(ctx.currentIdentifier)!,
-      effects: [],
-      skipContinue: false,
-    };
-  }
-
-  // Single string: strlen(str)
-  const target = ctx.currentIdentifier ?? ctx.result;
-  return makeStrlenResult(target, false);
-}
-
-/**
- * Handle .length for fully subscripted array (getting element bit width).
- */
-function handleFullySubscriptedArrayLength(
-  ctx: PropertyContext,
-  typeInfo: TTypeInfo,
-): PropertyResult {
-  // ADR-017: Enum array element .length returns 32
-  if (typeInfo.isEnum) {
-    return { code: "32", effects: [], skipContinue: false };
-  }
-
-  // ADR-045/Issue #136: String array element .length -> strlen
-  if (typeInfo.baseType.startsWith("string<") || typeInfo.isString) {
-    return makeStrlenResult(ctx.result, false);
-  }
-
-  // Try primitive type first
-  let elementBitWidth = getTypeBitWidth(typeInfo.baseType);
-
-  // Issue #201: Also check bitmap types
-  if (
-    elementBitWidth === 0 &&
-    typeInfo.isBitmap &&
-    typeInfo.bitmapTypeName &&
-    ctx.getBitmapBitWidth
-  ) {
-    elementBitWidth = ctx.getBitmapBitWidth(typeInfo.bitmapTypeName) || 0;
-  }
-
-  if (elementBitWidth > 0) {
-    return { code: String(elementBitWidth), effects: [], skipContinue: false };
-  }
-
-  return {
-    code: `/* .length: unsupported element type ${typeInfo.baseType} */0`,
-    effects: [],
-    skipContinue: false,
-  };
-}
-
-/**
- * Generate code for .length property access.
- *
- * Handles:
- * - Arrays: returns dimension at current subscript depth
- * - Strings: returns strlen() call
- * - Integers: returns bit width
- * - Enums: returns 32 (default enum size)
- * - main args.length: returns argc
- */
-const generateLengthProperty = (ctx: PropertyContext): PropertyResult => {
-  // Special case: main function's args.length -> argc
-  if (ctx.mainArgsName && ctx.primaryId === ctx.mainArgsName) {
-    return { code: "argc", effects: [], skipContinue: false };
-  }
-
-  // Check if we're accessing a struct member (cfg.magic.length)
-  const structResult = handleStructMemberLength(ctx);
-  if (structResult) {
-    return structResult;
-  }
-
-  // Fall back to checking the current resolved identifier's type
-  const typeInfo = ctx.typeInfo;
-
-  if (!typeInfo) {
-    return {
-      code: `/* .length: unknown type for ${ctx.result} */0`,
-      effects: [],
-      skipContinue: false,
-    };
-  }
-
-  // ADR-045: String type handling
-  if (typeInfo.isString) {
-    return handleStringLength(ctx, typeInfo);
-  }
-
-  // Check for array with dimensions
-  const hasDimensions =
-    typeInfo.isArray &&
-    typeInfo.arrayDimensions &&
-    typeInfo.arrayDimensions.length > 0;
-
-  if (hasDimensions && ctx.subscriptDepth < typeInfo.arrayDimensions!.length) {
-    // ADR-036: Multi-dimensional array length (partial subscript)
-    return {
-      code: String(typeInfo.arrayDimensions![ctx.subscriptDepth]),
-      effects: [],
-      skipContinue: false,
-    };
-  }
-
-  if (hasDimensions && ctx.subscriptDepth >= typeInfo.arrayDimensions!.length) {
-    // Array fully subscripted -> return element bit width
-    return handleFullySubscriptedArrayLength(ctx, typeInfo);
-  }
-
-  if (typeInfo.isArray) {
-    // Unknown length for array type
-    return {
-      code: `/* .length unknown for ${ctx.currentIdentifier} */0`,
-      effects: [],
-      skipContinue: false,
-    };
-  }
-
-  if (typeInfo.isEnum) {
-    // ADR-017: Enum types default to 32-bit width
-    return { code: "32", effects: [], skipContinue: false };
-  }
-
-  // Integer bit width - return the compile-time constant
-  return { code: String(typeInfo.bitWidth), effects: [], skipContinue: false };
-};
-
 /**
  * Generate code for .capacity property access.
  *
@@ -394,7 +76,6 @@ const generateBitmapFieldAccess = (
 
 // Export all generators
 const accessGenerators = {
-  generateLengthProperty,
   generateCapacityProperty,
   generateSizeProperty,
   generateBitmapFieldAccess,

package/src/transpiler/output/codegen/generators/expressions/PostfixExpressionGenerator.ts

@@ -386,7 +386,7 @@ const handleGlobalPrefix = (
 const handleThisScopeLength = (
   memberName: string,
   tracking: ITrackingState,
-  input: IGeneratorInput,
+  _input: IGeneratorInput,
   state: IGeneratorState,
   orchestrator: IOrchestrator,
 ): boolean => {
@@ -531,8 +531,10 @@ const tryExplicitLengthProperty = (
 };
 
 /**
- * Try handling property access (.length, .capacity, .size, .bit_length, .byte_length, .element_count, .char_count).
+ * Try handling property access (.capacity, .size, .bit_length, .byte_length, .element_count, .char_count).
  * Returns true if handled.
+ *
+ * Note: .length was removed in favor of explicit properties (ADR-058).
  */
 const tryPropertyAccess = (
   memberName: string,
@@ -543,20 +545,13 @@ const tryPropertyAccess = (
   orchestrator: IOrchestrator,
   effects: TGeneratorEffect[],
 ): boolean => {
+  // ADR-058: .length is deprecated - use explicit properties instead
   if (memberName === "length") {
-    const ctx = createExplicitLengthContext(tracking, rootIdentifier);
-    const lengthResult = generateLengthProperty(
-      ctx,
-      input,
-      state,
-      orchestrator,
-      effects,
+    throw new Error(
+      `Error: '.length' on '${tracking.result}' is deprecated. Use explicit properties: ` +
+        `.bit_length (bit width), .byte_length (byte size), ` +
+        `.element_count (array size), or .char_count (string length)`,
     );
-    if (lengthResult !== null) {
-      applyPropertyResult(tracking, lengthResult);
-      return true;
-    }
-    return false;
   }
 
   // ADR-058: Explicit length properties
@@ -607,264 +602,6 @@ const tryPropertyAccess = (
   return false;
 };
 
-// ========================================================================
-// Length Property
-// ========================================================================
-
-/**
- * Context for .length property generation.
- */
-interface ILengthContext {
-  result: string;
-  rootIdentifier: string | undefined;
-  resolvedIdentifier: string | undefined;
-  previousStructType: string | undefined;
-  previousMemberName: string | undefined;
-  subscriptDepth: number;
-}
-
-/**
- * Generate .length property access.
- * Returns null if not applicable (falls through to member access).
- */
-const generateLengthProperty = (
-  ctx: ILengthContext,
-  input: IGeneratorInput,
-  state: IGeneratorState,
-  orchestrator: IOrchestrator,
-  effects: TGeneratorEffect[],
-): string | null => {
-  // Special case: main function's args.length -> argc
-  if (state.mainArgsName && ctx.rootIdentifier === state.mainArgsName) {
-    return "argc";
-  }
-
-  // Check if we're accessing a struct member (cfg.magic.length)
-  if (ctx.previousStructType && ctx.previousMemberName) {
-    const fieldInfo = orchestrator.getStructFieldInfo(
-      ctx.previousStructType,
-      ctx.previousMemberName,
-    );
-    if (fieldInfo) {
-      return generateStructFieldLength(
-        ctx.result,
-        fieldInfo,
-        ctx.subscriptDepth,
-        input,
-        orchestrator,
-        effects,
-      );
-    }
-  }
-
-  // Fall back to checking the current resolved identifier's type
-  const typeInfo = ctx.resolvedIdentifier
-    ? CodeGenState.getVariableTypeInfo(ctx.resolvedIdentifier)
-    : undefined;
-
-  if (!typeInfo) {
-    return `/* .length: unknown type for ${ctx.result} */0`;
-  }
-
-  return generateTypeInfoLength(
-    ctx.result,
-    typeInfo,
-    ctx.subscriptDepth,
-    ctx.resolvedIdentifier,
-    input,
-    state,
-    effects,
-  );
-};
-
-/**
- * Generate .length for a struct field.
- */
-const generateStructFieldLength = (
-  result: string,
-  fieldInfo: { type: string; dimensions?: (number | string)[] },
-  subscriptDepth: number,
-  input: IGeneratorInput,
-  orchestrator: IOrchestrator,
-  effects: TGeneratorEffect[],
-): string => {
-  const memberType = fieldInfo.type;
-  const dimensions = fieldInfo.dimensions;
-  const isStringField = TypeCheckUtils.isString(memberType);
-
-  if (dimensions?.length && dimensions.length > 1 && isStringField) {
-    if (subscriptDepth === 0) {
-      return String(dimensions[0]);
-    } else {
-      effects.push({ type: "include", header: "string" });
-      return `strlen(${result})`;
-    }
-  } else if (dimensions?.length === 1 && isStringField) {
-    effects.push({ type: "include", header: "string" });
-    return `strlen(${result})`;
-  } else if (
-    dimensions?.length &&
-    dimensions.length > 0 &&
-    subscriptDepth < dimensions.length
-  ) {
-    return String(dimensions[subscriptDepth]);
-  } else if (
-    dimensions?.length &&
-    dimensions.length > 0 &&
-    subscriptDepth >= dimensions.length
-  ) {
-    return getTypeBitWidth(memberType, input);
-  } else {
-    return getTypeBitWidth(memberType, input);
-  }
-};
-
-/**
- * Generate .length from type info.
- */
-const generateTypeInfoLength = (
-  result: string,
-  typeInfo: {
-    isString?: boolean;
-    isArray?: boolean;
-    isEnum?: boolean;
-    arrayDimensions?: (number | string)[];
-    baseType: string;
-    bitWidth?: number;
-    isBitmap?: boolean;
-    bitmapTypeName?: string;
-  },
-  subscriptDepth: number,
-  resolvedIdentifier: string | undefined,
-  input: IGeneratorInput,
-  state: IGeneratorState,
-  effects: TGeneratorEffect[],
-): string => {
-  // ADR-045: String type handling
-  if (typeInfo.isString) {
-    return generateStringLength(
-      result,
-      typeInfo,
-      subscriptDepth,
-      resolvedIdentifier,
-      state,
-    );
-  }
-
-  // Non-string enum - always 32 bits
-  if (typeInfo.isEnum && !typeInfo.isArray) {
-    return "32";
-  }
-
-  // Non-string, non-enum, non-array - use bitWidth
-  if (!typeInfo.isArray) {
-    return String(typeInfo.bitWidth || 0);
-  }
-
-  // Array without dimensions - unknown length
-  const dims = typeInfo.arrayDimensions;
-  if (!dims || dims.length === 0) {
-    return `/* .length unknown for ${resolvedIdentifier} */0`;
-  }
-
-  // Array with subscript within bounds - return that dimension
-  if (subscriptDepth < dims.length) {
-    return String(dims[subscriptDepth]);
-  }
-
-  // Subscript past array bounds - return element type's length
-  return generateElementTypeLength(result, typeInfo, input, effects);
-};
-
-/**
- * Generate .length for string types.
- */
-const generateStringLength = (
-  result: string,
-  typeInfo: {
-    arrayDimensions?: (number | string)[];
-  },
-  subscriptDepth: number,
-  resolvedIdentifier: string | undefined,
-  state: IGeneratorState,
-): string => {
-  const dims = typeInfo.arrayDimensions;
-
-  // String array (2D): first dimension is array size, second is string capacity
-  if (dims && dims.length > 1) {
-    return subscriptDepth === 0 ? String(dims[0]) : `strlen(${result})`;
-  }
-
-  // String array with subscript - use result which contains arr[index]
-  // This handles string<32>[5] parameters where subscriptDepth=1 after arr[index]
-  if (subscriptDepth > 0) {
-    return `strlen(${result})`;
-  }
-
-  // Simple string: check length cache first, then use strlen
-  if (resolvedIdentifier && state.lengthCache?.has(resolvedIdentifier)) {
-    return state.lengthCache.get(resolvedIdentifier)!;
-  }
-  return resolvedIdentifier
-    ? `strlen(${resolvedIdentifier})`
-    : `strlen(${result})`;
-};
-
-/**
- * Generate .length for array element types (subscript past bounds).
- */
-const generateElementTypeLength = (
-  result: string,
-  typeInfo: {
-    isEnum?: boolean;
-    isString?: boolean;
-    baseType: string;
-    isBitmap?: boolean;
-    bitmapTypeName?: string;
-  },
-  input: IGeneratorInput,
-  effects: TGeneratorEffect[],
-): string => {
-  // Enum element
-  if (typeInfo.isEnum) {
-    return "32";
-  }
-
-  // String element
-  if (TypeCheckUtils.isString(typeInfo.baseType) || typeInfo.isString) {
-    effects.push({ type: "include", header: "string" });
-    return `strlen(${result})`;
-  }
-
-  // Numeric/bitmap element - get bit width
-  let elementBitWidth = TYPE_WIDTH[typeInfo.baseType] || 0;
-  if (elementBitWidth === 0 && typeInfo.isBitmap && typeInfo.bitmapTypeName) {
-    elementBitWidth =
-      input.symbols!.bitmapBitWidth.get(typeInfo.bitmapTypeName) || 0;
-  }
-
-  if (elementBitWidth > 0) {
-    return String(elementBitWidth);
-  }
-  return `/* .length: unsupported element type ${typeInfo.baseType} */0`;
-};
-
-/**
- * Get bit width for a type.
- */
-const getTypeBitWidth = (typeName: string, input: IGeneratorInput): string => {
-  let bitWidth = TYPE_WIDTH[typeName] || C_TYPE_WIDTH[typeName] || 0;
-  if (bitWidth === 0 && input.symbolTable) {
-    const enumWidth = input.symbolTable.getEnumBitWidth(typeName);
-    if (enumWidth) bitWidth = enumWidth;
-  }
-  if (bitWidth > 0) {
-    return String(bitWidth);
-  } else {
-    return `/* .length: unsupported type ${typeName} */0`;
-  }
-};
-
 // ========================================================================
 // ADR-058: Explicit Length Properties
 // ========================================================================
@@ -1377,16 +1114,18 @@ const generateCharCountProperty = (
 
   effects.push({ type: "include", header: "string" });
 
-  // Check length cache first
+  // Check length cache first (only for simple variable access, not indexed)
   if (
+    ctx.subscriptDepth === 0 &&
     ctx.resolvedIdentifier &&
     state.lengthCache?.has(ctx.resolvedIdentifier)
   ) {
     return state.lengthCache.get(ctx.resolvedIdentifier)!;
   }
 
-  const target = ctx.resolvedIdentifier ?? ctx.result;
-  return `strlen(${target})`;
+  // Use ctx.result which contains the full expression including any subscripts
+  // e.g., for arr[0].char_count, ctx.result is "arr[0]" not "arr"
+  return `strlen(${ctx.result})`;
 };
 
 // ========================================================================

package/src/transpiler/output/codegen/generators/expressions/UnaryExprGenerator.ts

@@ -11,6 +11,9 @@ import IGeneratorOutput from "../IGeneratorOutput";
 import IGeneratorInput from "../IGeneratorInput";
 import IGeneratorState from "../IGeneratorState";
 import IOrchestrator from "../IOrchestrator";
+import TypeResolver from "../../TypeResolver";
+import TYPE_MAP from "../../types/TYPE_MAP";
+import CppModeHelper from "../../helpers/CppModeHelper";
 
 /**
  * Generate C code for a unary expression.
@@ -43,7 +46,16 @@ const generateUnaryExpr = (
   // Determine the operator and generate output
   if (text.startsWith("!")) return { code: `!${inner}`, effects: [] };
   if (text.startsWith("-")) return { code: `-${inner}`, effects: [] };
-  if (text.startsWith("~")) return { code: `~${inner}`, effects: [] };
+  if (text.startsWith("~")) {
+    const innerType = TypeResolver.getUnaryExpressionType(
+      node.unaryExpression()!,
+    );
+    if (innerType && TypeResolver.isUnsignedType(innerType)) {
+      const cType = TYPE_MAP[innerType] ?? innerType;
+      return { code: CppModeHelper.cast(cType, `~${inner}`), effects: [] };
+    }
+    return { code: `~${inner}`, effects: [] };
+  }
   if (text.startsWith("&")) return { code: `&${inner}`, effects: [] };
 
   // Fallback (shouldn't happen with valid grammar)