c-next 0.1.69 → 0.1.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "c-next",
-  "version": "0.1.69",
+  "version": "0.1.70",
   "description": "A safer C for embedded systems development. Transpiles to clean, readable C.",
   "packageManager": "npm@11.9.0",
   "type": "module",

package/src/transpiler/logic/analysis/FunctionCallAnalyzer.ts

@@ -11,7 +11,6 @@ import { ParseTreeWalker } from "antlr4ng";
 import { CNextListener } from "../parser/grammar/CNextListener";
 import * as Parser from "../parser/grammar/CNextParser";
 import SymbolTable from "../symbols/SymbolTable";
-import ESourceLanguage from "../../../utils/types/ESourceLanguage";
 import ESymbolKind from "../../../utils/types/ESymbolKind";
 import IFunctionCallError from "./types/IFunctionCallError";
 import ParserUtils from "../../../utils/ParserUtils";
@@ -26,195 +25,178 @@ const CNEXT_BUILTINS: Set<string> = new Set([
 ]);
 
 /**
- * Standard library functions from common C headers
- * These are considered "external" and don't need to be defined in C-Next
+ * Standard library functions mapped to their header files.
+ * Flat structure: function name → header file.
+ * These are considered "external" and don't need to be defined in C-Next.
  */
-const STDLIB_FUNCTIONS: Map<string, Set<string>> = new Map([
-  [
-    "stdio.h",
-    new Set([
-      "printf",
-      "fprintf",
-      "sprintf",
-      "snprintf",
-      "scanf",
-      "fscanf",
-      "sscanf",
-      "fopen",
-      "fclose",
-      "fread",
-      "fwrite",
-      "fgets",
-      "fputs",
-      "fgetc",
-      "fputc",
-      "puts",
-      "putchar",
-      "getchar",
-      "gets",
-      "perror",
-      "fflush",
-      "fseek",
-      "ftell",
-      "rewind",
-      "feof",
-      "ferror",
-      "clearerr",
-      "remove",
-      "rename",
-      "tmpfile",
-      "tmpnam",
-      "setbuf",
-      "setvbuf",
-    ]),
-  ],
-  [
-    "stdlib.h",
-    new Set([
-      "malloc",
-      "calloc",
-      "realloc",
-      "free",
-      "atoi",
-      "atof",
-      "atol",
-      "atoll",
-      "strtol",
-      "strtoul",
-      "strtoll",
-      "strtoull",
-      "strtof",
-      "strtod",
-      "strtold",
-      "rand",
-      "srand",
-      "exit",
-      "abort",
-      "atexit",
-      "system",
-      "getenv",
-      "abs",
-      "labs",
-      "llabs",
-      "div",
-      "ldiv",
-      "lldiv",
-      "qsort",
-      "bsearch",
-    ]),
-  ],
-  [
-    "string.h",
-    new Set([
-      "strlen",
-      "strcpy",
-      "strncpy",
-      "strcat",
-      "strncat",
-      "strcmp",
-      "strncmp",
-      "strchr",
-      "strrchr",
-      "strstr",
-      "strtok",
-      "memcpy",
-      "memmove",
-      "memset",
-      "memcmp",
-      "memchr",
-    ]),
-  ],
-  [
-    "math.h",
-    new Set([
-      "sin",
-      "cos",
-      "tan",
-      "asin",
-      "acos",
-      "atan",
-      "atan2",
-      "sinh",
-      "cosh",
-      "tanh",
-      "exp",
-      "log",
-      "log10",
-      "log2",
-      "pow",
-      "sqrt",
-      "cbrt",
-      "ceil",
-      "floor",
-      "round",
-      "trunc",
-      "fabs",
-      "fmod",
-      "remainder",
-      "fmax",
-      "fmin",
-      "hypot",
-      "ldexp",
-      "frexp",
-      "modf",
-    ]),
-  ],
-  [
-    "ctype.h",
-    new Set([
-      "isalnum",
-      "isalpha",
-      "isdigit",
-      "isxdigit",
-      "islower",
-      "isupper",
-      "isspace",
-      "ispunct",
-      "isprint",
-      "isgraph",
-      "iscntrl",
-      "tolower",
-      "toupper",
-    ]),
-  ],
-  [
-    "time.h",
-    new Set([
-      "time",
-      "clock",
-      "difftime",
-      "mktime",
-      "strftime",
-      "localtime",
-      "gmtime",
-      "asctime",
-      "ctime",
-    ]),
-  ],
-  ["assert.h", new Set(["assert"])],
+const STDLIB_FUNCTION_HEADERS: Record<string, string> = {
+  // stdio.h
+  printf: "stdio.h",
+  fprintf: "stdio.h",
+  sprintf: "stdio.h",
+  snprintf: "stdio.h",
+  scanf: "stdio.h",
+  fscanf: "stdio.h",
+  sscanf: "stdio.h",
+  fopen: "stdio.h",
+  fclose: "stdio.h",
+  fread: "stdio.h",
+  fwrite: "stdio.h",
+  fgets: "stdio.h",
+  fputs: "stdio.h",
+  fgetc: "stdio.h",
+  fputc: "stdio.h",
+  puts: "stdio.h",
+  putchar: "stdio.h",
+  getchar: "stdio.h",
+  gets: "stdio.h",
+  perror: "stdio.h",
+  fflush: "stdio.h",
+  fseek: "stdio.h",
+  ftell: "stdio.h",
+  rewind: "stdio.h",
+  feof: "stdio.h",
+  ferror: "stdio.h",
+  clearerr: "stdio.h",
+  remove: "stdio.h",
+  rename: "stdio.h",
+  tmpfile: "stdio.h",
+  tmpnam: "stdio.h",
+  setbuf: "stdio.h",
+  setvbuf: "stdio.h",
+  // stdlib.h
+  malloc: "stdlib.h",
+  calloc: "stdlib.h",
+  realloc: "stdlib.h",
+  free: "stdlib.h",
+  atoi: "stdlib.h",
+  atof: "stdlib.h",
+  atol: "stdlib.h",
+  atoll: "stdlib.h",
+  strtol: "stdlib.h",
+  strtoul: "stdlib.h",
+  strtoll: "stdlib.h",
+  strtoull: "stdlib.h",
+  strtof: "stdlib.h",
+  strtod: "stdlib.h",
+  strtold: "stdlib.h",
+  rand: "stdlib.h",
+  srand: "stdlib.h",
+  exit: "stdlib.h",
+  abort: "stdlib.h",
+  atexit: "stdlib.h",
+  system: "stdlib.h",
+  getenv: "stdlib.h",
+  abs: "stdlib.h",
+  labs: "stdlib.h",
+  llabs: "stdlib.h",
+  div: "stdlib.h",
+  ldiv: "stdlib.h",
+  lldiv: "stdlib.h",
+  qsort: "stdlib.h",
+  bsearch: "stdlib.h",
+  // string.h
+  strlen: "string.h",
+  strcpy: "string.h",
+  strncpy: "string.h",
+  strcat: "string.h",
+  strncat: "string.h",
+  strcmp: "string.h",
+  strncmp: "string.h",
+  strchr: "string.h",
+  strrchr: "string.h",
+  strstr: "string.h",
+  strtok: "string.h",
+  memcpy: "string.h",
+  memmove: "string.h",
+  memset: "string.h",
+  memcmp: "string.h",
+  memchr: "string.h",
+  // math.h
+  sin: "math.h",
+  cos: "math.h",
+  tan: "math.h",
+  asin: "math.h",
+  acos: "math.h",
+  atan: "math.h",
+  atan2: "math.h",
+  sinh: "math.h",
+  cosh: "math.h",
+  tanh: "math.h",
+  exp: "math.h",
+  log: "math.h",
+  log10: "math.h",
+  log2: "math.h",
+  pow: "math.h",
+  sqrt: "math.h",
+  cbrt: "math.h",
+  ceil: "math.h",
+  floor: "math.h",
+  round: "math.h",
+  trunc: "math.h",
+  fabs: "math.h",
+  fmod: "math.h",
+  remainder: "math.h",
+  fmax: "math.h",
+  fmin: "math.h",
+  hypot: "math.h",
+  ldexp: "math.h",
+  frexp: "math.h",
+  modf: "math.h",
+  // C99 classification macros (also functions in C++)
+  isnan: "math.h",
+  isinf: "math.h",
+  isfinite: "math.h",
+  isnormal: "math.h",
+  signbit: "math.h",
+  fpclassify: "math.h",
+  nan: "math.h",
+  nanf: "math.h",
+  nanl: "math.h",
+  // ctype.h
+  isalnum: "ctype.h",
+  isalpha: "ctype.h",
+  isdigit: "ctype.h",
+  isxdigit: "ctype.h",
+  islower: "ctype.h",
+  isupper: "ctype.h",
+  isspace: "ctype.h",
+  ispunct: "ctype.h",
+  isprint: "ctype.h",
+  isgraph: "ctype.h",
+  iscntrl: "ctype.h",
+  tolower: "ctype.h",
+  toupper: "ctype.h",
+  // time.h
+  time: "time.h",
+  clock: "time.h",
+  difftime: "time.h",
+  mktime: "time.h",
+  strftime: "time.h",
+  localtime: "time.h",
+  gmtime: "time.h",
+  asctime: "time.h",
+  ctime: "time.h",
+  // assert.h
+  assert: "assert.h",
   // Arduino framework
-  [
-    "Arduino.h",
-    new Set([
-      "pinMode",
-      "digitalWrite",
-      "digitalRead",
-      "analogRead",
-      "analogWrite",
-      "delay",
-      "delayMicroseconds",
-      "millis",
-      "micros",
-      "attachInterrupt",
-      "detachInterrupt",
-      "noInterrupts",
-      "interrupts",
-      "Serial",
-      "Wire",
-      "SPI",
-    ]),
-  ],
-]);
+  pinMode: "Arduino.h",
+  digitalWrite: "Arduino.h",
+  digitalRead: "Arduino.h",
+  analogRead: "Arduino.h",
+  analogWrite: "Arduino.h",
+  delay: "Arduino.h",
+  delayMicroseconds: "Arduino.h",
+  millis: "Arduino.h",
+  micros: "Arduino.h",
+  attachInterrupt: "Arduino.h",
+  detachInterrupt: "Arduino.h",
+  noInterrupts: "Arduino.h",
+  interrupts: "Arduino.h",
+  Serial: "Arduino.h",
+  Wire: "Arduino.h",
+  SPI: "Arduino.h",
+};
 
 /**
  * Listener that walks the parse tree and checks function calls
@@ -424,6 +406,9 @@ class FunctionCallAnalyzer {
   /** Functions that have been defined (in order of appearance) */
   private definedFunctions: Set<string> = new Set();
 
+  /** All functions that will be defined in this file (for distinguishing local vs cross-file) */
+  private allLocalFunctions: Set<string> = new Set();
+
   /** Known scopes (for Scope.member -> Scope_member resolution) */
   private knownScopes: Set<string> = new Set();
 
@@ -454,6 +439,7 @@ class FunctionCallAnalyzer {
   ): IFunctionCallError[] {
     this.errors = [];
     this.definedFunctions = new Set();
+    this.allLocalFunctions = new Set();
     this.knownScopes = new Set();
     this.includedHeaders = new Set();
     this.symbolTable = symbolTable ?? null;
@@ -461,10 +447,11 @@ class FunctionCallAnalyzer {
     this.callableVariables = new Set();
     this.callbackTypes = new Set();
 
-    // First pass: collect scope names, includes, and callback types
+    // First pass: collect scope names, includes, callback types, and all local functions
     this.collectScopes(tree);
     this.collectIncludes(tree);
     this.collectCallbackTypes(tree);
+    this.collectAllLocalFunctions(tree);
 
     // Second pass: walk tree in order, tracking definitions and checking calls
     const listener = new FunctionCallListener(this);
@@ -503,13 +490,17 @@ class FunctionCallAnalyzer {
    * Check if a function is from an included standard library header
    */
   private isStdlibFunction(name: string): boolean {
-    for (const header of this.includedHeaders) {
-      const funcs = STDLIB_FUNCTIONS.get(header);
-      if (funcs?.has(name)) {
-        return true;
-      }
-    }
-    return false;
+    const header = STDLIB_FUNCTION_HEADERS[name];
+    return header !== undefined && this.includedHeaders.has(header);
+  }
+
+  /**
+   * Issue #787: Find which header a stdlib function belongs to (if any).
+   * Returns the header name if found, or null if not a known stdlib function.
+   * Checks ALL stdlib functions, not just from included headers.
+   */
+  private findStdlibHeader(name: string): string | null {
+    return STDLIB_FUNCTION_HEADERS[name] ?? null;
   }
 
   /**
@@ -525,6 +516,35 @@ class FunctionCallAnalyzer {
     }
   }
 
+  /**
+   * Issue #786: Pre-collect all function names defined in this file.
+   * Used to distinguish between local functions (subject to define-before-use)
+   * and cross-file functions from includes (allowed without local definition).
+   */
+  private collectAllLocalFunctions(tree: Parser.ProgramContext): void {
+    for (const decl of tree.declaration()) {
+      // Standalone functions
+      if (decl.functionDeclaration()) {
+        const name = decl.functionDeclaration()!.IDENTIFIER().getText();
+        this.allLocalFunctions.add(name);
+      }
+      // Scope member functions
+      if (decl.scopeDeclaration()) {
+        const scopeDecl = decl.scopeDeclaration()!;
+        const scopeName = scopeDecl.IDENTIFIER().getText();
+        for (const member of scopeDecl.scopeMember()) {
+          if (member.functionDeclaration()) {
+            const funcName = member
+              .functionDeclaration()!
+              .IDENTIFIER()
+              .getText();
+            this.allLocalFunctions.add(`${scopeName}_${funcName}`);
+          }
+        }
+      }
+    }
+  }
+
   /**
    * ADR-029: Check if a type name is a callback type (function-as-type)
    */
@@ -627,31 +647,47 @@ class FunctionCallAnalyzer {
       }
     }
 
-    // Not defined - report error
+    // Not defined - report error with optional hint
+    const header = this.findStdlibHeader(name);
+    let message = `function '${name}' called before definition`;
+    if (header) {
+      message += `; hint: '${name}' is available from ${header} — try global.${name}()`;
+    }
+
     this.errors.push({
       code: "E0422",
       functionName: name,
       line,
       column,
-      message: `function '${name}' called before definition`,
+      message,
     });
   }
 
   /**
-   * Check if a function is defined externally (C/C++ interop)
+   * Check if a function is defined externally (from included files)
+   * This includes C/C++ headers AND C-Next includes.
+   *
+   * Issue #786: Only considers a function "external" if it's NOT defined
+   * in the current file. Functions defined locally are subject to
+   * define-before-use checking, even if they exist in the SymbolTable.
    */
   private isExternalFunction(name: string): boolean {
+    // If the function is defined in this file, it's not external
+    // (even if it's also in the SymbolTable from symbol collection)
+    if (this.allLocalFunctions.has(name)) {
+      return false;
+    }
+
     if (!this.symbolTable) {
       return false;
     }
 
     const symbols = this.symbolTable.getOverloads(name);
     for (const sym of symbols) {
-      if (
-        (sym.sourceLanguage === ESourceLanguage.C ||
-          sym.sourceLanguage === ESourceLanguage.Cpp) &&
-        sym.kind === ESymbolKind.Function
-      ) {
+      // Accept functions from any source language:
+      // - C/C++ functions from header includes
+      // - C-Next functions from .cnx file includes
+      if (sym.kind === ESymbolKind.Function) {
         return true;
       }
     }