c-next 0.1.69 → 0.1.71

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

@@ -9,7 +9,9 @@ import { CNextParser } from "../../parser/grammar/CNextParser";
 import FunctionCallAnalyzer from "../FunctionCallAnalyzer";
 import SymbolTable from "../../symbols/SymbolTable";
 import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
+import TestScopeUtils from "../../symbols/cnext/__tests__/testUtils";
+import TTypeUtils from "../../../../utils/TTypeUtils";
+import type IFunctionSymbol from "../../../types/symbols/IFunctionSymbol";
 
 /**
  * Helper to parse C-Next code and return the AST
@@ -367,9 +369,9 @@ describe("FunctionCallAnalyzer", () => {
       `;
       const tree = parse(code);
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addCSymbol({
         name: "myExternalFunc",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceLanguage: ESourceLanguage.C,
         sourceFile: "external.h",
         sourceLine: 1,
@@ -391,9 +393,9 @@ describe("FunctionCallAnalyzer", () => {
       `;
       const tree = parse(code);
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addCppSymbol({
         name: "cppHelper",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceLanguage: ESourceLanguage.Cpp,
         sourceFile: "helper.hpp",
         sourceLine: 1,
@@ -486,6 +488,88 @@ describe("FunctionCallAnalyzer", () => {
     });
   });
 
+  // ========================================================================
+  // Global Prefix Hints (Issue #787)
+  // ========================================================================
+
+  describe("global prefix hints", () => {
+    it("should suggest global. for stdlib function without direct include", () => {
+      // isnan is in math.h but header not included - suggest global.isnan()
+      const code = `
+        void main() {
+          f32 x <- 1.0;
+          bool result <- isnan(x);
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0422");
+      expect(errors[0].message).toContain("global.isnan()");
+    });
+
+    it("should suggest global. for external func in symbol table", () => {
+      // External func exists in symbol table but not directly accessible
+      const code = `
+        void main() {
+          customExternalFunc();
+        }
+      `;
+      const tree = parse(code);
+      const symbolTable = new SymbolTable();
+      symbolTable.addCppSymbol({
+        name: "customExternalFunc",
+        kind: "function",
+        sourceLanguage: ESourceLanguage.Cpp,
+        sourceFile: "custom.hpp",
+        sourceLine: 1,
+        isExported: true,
+        type: "void",
+      });
+
+      const analyzer = new FunctionCallAnalyzer();
+      // Pass symbolTable but func requires global. prefix
+      const errors = analyzer.analyze(tree, symbolTable);
+
+      // With symbol table, external funcs are allowed (no error)
+      // This test documents current behavior - external funcs work without global.
+      expect(errors).toHaveLength(0);
+    });
+
+    it("should not suggest global. for truly unknown functions", () => {
+      const code = `
+        void main() {
+          completelyUnknownFunc();
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0422");
+      expect(errors[0].message).not.toContain("global.");
+    });
+
+    it("should mention header name when stdlib function found", () => {
+      const code = `
+        void main() {
+          f64 x <- sqrt(4.0);
+        }
+      `;
+      const tree = parse(code);
+      const analyzer = new FunctionCallAnalyzer();
+      const errors = analyzer.analyze(tree);
+
+      expect(errors).toHaveLength(1);
+      expect(errors[0].code).toBe("E0422");
+      expect(errors[0].message).toContain("math.h");
+      expect(errors[0].message).toContain("global.sqrt()");
+    });
+  });
+
   // ========================================================================
   // Edge Cases
   // ========================================================================
@@ -536,7 +620,7 @@ describe("FunctionCallAnalyzer", () => {
       expect(doSomethingErrors).toHaveLength(0);
     });
 
-    it("should still flag E0422 for C-Next functions in symbol table", () => {
+    it("allows cross-file C-Next functions from SymbolTable (Issue #786)", () => {
       const code = `
         void main() {
           cnextFunc();
@@ -544,23 +628,26 @@ describe("FunctionCallAnalyzer", () => {
       `;
       const tree = parse(code);
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addTSymbol({
+        kind: "function",
         name: "cnextFunc",
-        kind: ESymbolKind.Function,
-        sourceLanguage: ESourceLanguage.CNext,
         sourceFile: "module.cnx",
         sourceLine: 1,
+        sourceLanguage: ESourceLanguage.CNext,
         isExported: true,
-        type: "void",
-      });
+        returnType: TTypeUtils.createPrimitive("void"),
+        parameters: [],
+        scope: TestScopeUtils.createMockGlobalScope(),
+        visibility: "public",
+        body: null,
+      } as IFunctionSymbol);
 
       const analyzer = new FunctionCallAnalyzer();
       const errors = analyzer.analyze(tree, symbolTable);
 
-      // C-Next function in symbol table is not treated as external C/C++
-      // so it still gets E0422
-      expect(errors).toHaveLength(1);
-      expect(errors[0].code).toBe("E0422");
+      // Issue #786: Cross-file C-Next functions from includes are now allowed
+      // without E0422 since they're defined in an included file
+      expect(errors).toHaveLength(0);
     });
   });
 });

package/src/transpiler/logic/analysis/__tests__/InitializationAnalyzer.test.ts

@@ -10,7 +10,6 @@ import { CNextParser } from "../../parser/grammar/CNextParser";
 import InitializationAnalyzer from "../InitializationAnalyzer";
 import SymbolTable from "../../symbols/SymbolTable";
 import CodeGenState from "../../../state/CodeGenState";
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
 
 /**
@@ -46,9 +45,9 @@ describe("InitializationAnalyzer", () => {
       const tree = parse(code);
 
       // Set up CodeGenState with C++ class
-      CodeGenState.symbolTable.addSymbol({
+      CodeGenState.symbolTable.addCppSymbol({
         name: "CppMessage",
-        kind: ESymbolKind.Class,
+        kind: "class",
         sourceLanguage: ESourceLanguage.Cpp,
         sourceFile: "CppMessage.hpp",
         sourceLine: 1,
@@ -101,9 +100,9 @@ describe("InitializationAnalyzer", () => {
       const tree = parse(code);
 
       // Set up CodeGenState with C++ struct (not class)
-      CodeGenState.symbolTable.addSymbol({
+      CodeGenState.symbolTable.addCppSymbol({
         name: "CppStruct",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceLanguage: ESourceLanguage.Cpp,
         sourceFile: "types.hpp",
         sourceLine: 1,
@@ -131,13 +130,14 @@ describe("InitializationAnalyzer", () => {
       const tree = parse(code);
 
       // Set up CodeGenState with C struct (not C++)
-      CodeGenState.symbolTable.addSymbol({
+      CodeGenState.symbolTable.addCSymbol({
         name: "CStruct",
-        kind: ESymbolKind.Struct,
+        kind: "struct",
         sourceLanguage: ESourceLanguage.C,
         sourceFile: "types.h",
         sourceLine: 1,
         isExported: true,
+        isUnion: false,
       });
       CodeGenState.symbolTable.addStructField("CStruct", "value", "u32");
 
@@ -836,9 +836,9 @@ describe("InitializationAnalyzer", () => {
       const tree = parse(code);
 
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addCppSymbol({
         name: "CppEnum",
-        kind: ESymbolKind.Enum,
+        kind: "enum",
         sourceLanguage: ESourceLanguage.Cpp,
         sourceFile: "types.hpp",
         sourceLine: 1,

package/src/transpiler/logic/analysis/__tests__/runAnalyzers.test.ts

@@ -9,7 +9,6 @@ import { CNextParser } from "../../parser/grammar/CNextParser";
 import runAnalyzers from "../runAnalyzers";
 import SymbolTable from "../../symbols/SymbolTable";
 import CodeGenState from "../../../state/CodeGenState";
-import ESymbolKind from "../../../../utils/types/ESymbolKind";
 import ESourceLanguage from "../../../../utils/types/ESourceLanguage";
 
 /**
@@ -251,13 +250,14 @@ describe("runAnalyzers", () => {
       `);
 
       const symbolTable = new SymbolTable();
-      symbolTable.addSymbol({
+      symbolTable.addCSymbol({
         name: "ExternalFunc",
-        kind: ESymbolKind.Function,
+        kind: "function",
         sourceLanguage: ESourceLanguage.C,
         sourceFile: "external.h",
         sourceLine: 1,
         isExported: true,
+        type: "void",
       });
 
       const errors = runAnalyzers(tree, tokenStream, { symbolTable });
@@ -272,9 +272,9 @@ describe("runAnalyzers", () => {
       `);
 
       // Set up C++ class in CodeGenState.symbolTable
-      CodeGenState.symbolTable.addSymbol({
+      CodeGenState.symbolTable.addCppSymbol({
         name: "CppMessage",
-        kind: ESymbolKind.Class,
+        kind: "class",
         sourceLanguage: ESourceLanguage.Cpp,
         sourceFile: "CppMessage.hpp",
         sourceLine: 1,

package/src/transpiler/{output/codegen → logic/analysis}/helpers/AssignmentTargetExtractor.ts

@@ -2,7 +2,7 @@
  * Helper for extracting base identifier from assignment targets.
  * SonarCloud S3776: Extracted from walkStatementForModifications().
  */
-import * as Parser from "../../../logic/parser/grammar/CNextParser";
+import * as Parser from "../../parser/grammar/CNextParser";
 
 /**
  * Result from extracting assignment target base identifier.

package/src/transpiler/{output/codegen → logic/analysis}/helpers/ChildStatementCollector.ts

@@ -7,7 +7,7 @@
  * Issue #566: Extracted from CodeGenerator for improved testability.
  */
 
-import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
+import * as Parser from "../../parser/grammar/CNextParser.js";
 
 /**
  * Result of collecting child statements and blocks from a statement.

package/src/transpiler/{output/codegen → logic/analysis}/helpers/StatementExpressionCollector.ts

@@ -8,7 +8,7 @@
  * Issue #566: Extracted from CodeGenerator for improved testability.
  */
 
-import * as Parser from "../../../logic/parser/grammar/CNextParser.js";
+import * as Parser from "../../parser/grammar/CNextParser.js";
 
 class StatementExpressionCollector {
   /**

package/src/transpiler/{output/codegen → logic/analysis}/helpers/__tests__/AssignmentTargetExtractor.test.ts

@@ -4,9 +4,9 @@
  */
 
 import { describe, it, expect } from "vitest";
-import CNextSourceParser from "../../../../logic/parser/CNextSourceParser.js";
+import CNextSourceParser from "../../../parser/CNextSourceParser.js";
 import AssignmentTargetExtractor from "../AssignmentTargetExtractor.js";
-import * as Parser from "../../../../logic/parser/grammar/CNextParser.js";
+import * as Parser from "../../../parser/grammar/CNextParser.js";
 
 describe("AssignmentTargetExtractor", () => {
   /**

package/src/transpiler/{output/codegen → logic/analysis}/helpers/__tests__/ChildStatementCollector.test.ts

@@ -4,9 +4,9 @@
  */
 
 import { describe, it, expect } from "vitest";
-import CNextSourceParser from "../../../../logic/parser/CNextSourceParser.js";
+import CNextSourceParser from "../../../parser/CNextSourceParser.js";
 import ChildStatementCollector from "../ChildStatementCollector.js";
-import * as Parser from "../../../../logic/parser/grammar/CNextParser.js";
+import * as Parser from "../../../parser/grammar/CNextParser.js";
 
 describe("ChildStatementCollector", () => {
   /**

package/src/transpiler/{output/codegen → logic/analysis}/helpers/__tests__/StatementExpressionCollector.test.ts

@@ -4,9 +4,9 @@
  */
 
 import { describe, it, expect } from "vitest";
-import CNextSourceParser from "../../../../logic/parser/CNextSourceParser.js";
+import CNextSourceParser from "../../../parser/CNextSourceParser.js";
 import StatementExpressionCollector from "../StatementExpressionCollector.js";
-import * as Parser from "../../../../logic/parser/grammar/CNextParser.js";
+import * as Parser from "../../../parser/grammar/CNextParser.js";
 
 describe("StatementExpressionCollector", () => {
   /**