cobolx-2 1.2.3

package/compiler/src/plugins/api.ts

@@ -0,0 +1,8 @@
+import type { Diagnostic } from "../diagnostics.js";
+import type { ProgramNode } from "../ast/types.js";
+
+export interface CompilerPlugin {
+  name: string;
+  transformProgram?(program: ProgramNode): ProgramNode | Promise<ProgramNode>;
+  lintProgram?(program: ProgramNode): Diagnostic[] | Promise<Diagnostic[]>;
+}

package/compiler/src/plugins/loader.ts

@@ -0,0 +1,21 @@
+import path from "node:path";
+import { createRequire } from "node:module";
+import type { Diagnostic } from "../diagnostics.js";
+import type { ProgramNode } from "../ast/types.js";
+import type { CompilerPlugin } from "./api.js";
+
+export function applyCompilerPlugins(program: ProgramNode, baseDir: string): { program: ProgramNode; diagnostics: Diagnostic[] } {
+  let current = program;
+  const diagnostics: Diagnostic[] = [];
+  const require = createRequire(import.meta.url);
+
+  for (const pluginRef of program.plugins) {
+    const pluginPath = path.isAbsolute(pluginRef.pluginPath) ? pluginRef.pluginPath : path.resolve(baseDir, pluginRef.pluginPath);
+    const module = require(pluginPath);
+    const plugin = (module.default ?? module.plugin) as CompilerPlugin;
+    if (plugin.transformProgram) current = plugin.transformProgram(current) as ProgramNode;
+    if (plugin.lintProgram) diagnostics.push(...(plugin.lintProgram(current) as Diagnostic[]));
+  }
+
+  return { program: current, diagnostics };
+}

package/compiler/src/semantic/analyzer.d.ts

@@ -0,0 +1,12 @@
+import type { ProgramNode } from "../ast/types.js";
+import type { Diagnostic } from "../diagnostics.js";
+export declare class SemanticAnalyzer {
+    analyze(program: ProgramNode): Diagnostic[];
+    private analyzeStatements;
+    private analyzeIfStatement;
+    private analyzeExpression;
+    private analyzeIdentifier;
+    private analyzeCallExpression;
+    private isStdlibSymbol;
+    private isStdlibCall;
+}

package/compiler/src/semantic/analyzer.js

@@ -0,0 +1,144 @@
+class Scope {
+    parent;
+    values = new Set();
+    constructor(parent) {
+        this.parent = parent;
+    }
+    declare(name) {
+        this.values.add(name);
+    }
+    has(name) {
+        if (this.values.has(name)) {
+            return true;
+        }
+        return this.parent?.has(name) ?? false;
+    }
+}
+export class SemanticAnalyzer {
+    analyze(program) {
+        const diagnostics = [];
+        const functions = new Map();
+        for (const fn of program.functions) {
+            if (functions.has(fn.name)) {
+                diagnostics.push({
+                    message: `Function '${fn.name}' is already declared`,
+                    range: fn.range,
+                    severity: "error"
+                });
+            }
+            else {
+                functions.set(fn.name, { params: fn.params, declaration: fn });
+            }
+        }
+        for (const fn of program.functions) {
+            const scope = new Scope();
+            for (const param of fn.params) {
+                scope.declare(param);
+            }
+            this.analyzeStatements(fn.body, scope, functions, diagnostics, true);
+        }
+        this.analyzeStatements(program.body, new Scope(), functions, diagnostics, false);
+        return diagnostics;
+    }
+    analyzeStatements(statements, scope, functions, diagnostics, insideFunction) {
+        for (const statement of statements) {
+            switch (statement.kind) {
+                case "SetStatement":
+                    this.analyzeExpression(statement.expression, scope, functions, diagnostics);
+                    scope.declare(statement.name);
+                    break;
+                case "DisplayStatement":
+                    this.analyzeExpression(statement.expression, scope, functions, diagnostics);
+                    break;
+                case "InputStatement":
+                    if (statement.prompt) {
+                        this.analyzeExpression(statement.prompt, scope, functions, diagnostics);
+                    }
+                    scope.declare(statement.name);
+                    break;
+                case "IfStatement":
+                    this.analyzeIfStatement(statement, scope, functions, diagnostics, insideFunction);
+                    break;
+                case "ReturnStatement":
+                    if (!insideFunction) {
+                        diagnostics.push({
+                            message: "RETURN can only be used inside a FUNCTION",
+                            range: statement.range,
+                            severity: "error"
+                        });
+                    }
+                    this.analyzeExpression(statement.expression, scope, functions, diagnostics);
+                    break;
+                case "ExpressionStatement":
+                    this.analyzeExpression(statement.expression, scope, functions, diagnostics);
+                    break;
+            }
+        }
+    }
+    analyzeIfStatement(statement, scope, functions, diagnostics, insideFunction) {
+        this.analyzeExpression(statement.condition, scope, functions, diagnostics);
+        this.analyzeStatements(statement.thenBranch, new Scope(scope), functions, diagnostics, insideFunction);
+        this.analyzeStatements(statement.elseBranch, new Scope(scope), functions, diagnostics, insideFunction);
+    }
+    analyzeExpression(expression, scope, functions, diagnostics) {
+        switch (expression.kind) {
+            case "Identifier":
+                this.analyzeIdentifier(expression, scope, diagnostics);
+                break;
+            case "BinaryExpression":
+                this.analyzeExpression(expression.left, scope, functions, diagnostics);
+                this.analyzeExpression(expression.right, scope, functions, diagnostics);
+                break;
+            case "UnaryExpression":
+                this.analyzeExpression(expression.operand, scope, functions, diagnostics);
+                break;
+            case "CallExpression":
+                this.analyzeCallExpression(expression, scope, functions, diagnostics);
+                break;
+            case "NumberLiteral":
+            case "StringLiteral":
+            case "BooleanLiteral":
+                break;
+        }
+    }
+    analyzeIdentifier(expression, scope, diagnostics) {
+        if (!scope.has(expression.name) && !this.isStdlibSymbol(expression.name)) {
+            diagnostics.push({
+                message: `Variable '${expression.name}' is not defined`,
+                range: expression.range,
+                severity: "error"
+            });
+        }
+    }
+    analyzeCallExpression(expression, scope, functions, diagnostics) {
+        for (const arg of expression.args) {
+            this.analyzeExpression(arg, scope, functions, diagnostics);
+        }
+        if (this.isStdlibCall(expression.callee)) {
+            return;
+        }
+        const fn = functions.get(expression.callee);
+        if (!fn) {
+            diagnostics.push({
+                message: `Function '${expression.callee}' is not defined`,
+                range: expression.range,
+                severity: "error"
+            });
+            return;
+        }
+        if (fn.params.length !== expression.args.length) {
+            diagnostics.push({
+                message: `Function '${expression.callee}' expects ${fn.params.length} argument(s) but received ${expression.args.length}`,
+                range: expression.range,
+                severity: "error"
+            });
+        }
+    }
+    isStdlibSymbol(name) {
+        return name === "math" || name === "strings";
+    }
+    isStdlibCall(name) {
+        return name === "display" || name === "input";
+    }
+}
+//# sourceMappingURL=analyzer.js.map

package/compiler/src/semantic/analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.js","sourceRoot":"","sources":["analyzer.ts"],"names":[],"mappings":"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"}

package/compiler/src/semantic/analyzer.ts

@@ -0,0 +1,277 @@
+import type {
+  CallExpressionNode,
+  ExpressionNode,
+  FunctionDeclarationNode,
+  FunctionSignatureNode,
+  IdentifierNode,
+  MatchStatementNode,
+  ProgramNode,
+  StatementNode
+} from "../ast/types.js";
+import type { Diagnostic } from "../diagnostics.js";
+
+interface FunctionInfo {
+  params: string[];
+  declaration: FunctionDeclarationNode;
+}
+
+class Scope {
+  private readonly values = new Set<string>();
+
+  constructor(private readonly parent?: Scope) {}
+
+  declare(name: string): void {
+    this.values.add(name);
+  }
+
+  has(name: string): boolean {
+    if (this.values.has(name)) return true;
+    return this.parent?.has(name) ?? false;
+  }
+}
+
+export class SemanticAnalyzer {
+  analyze(program: ProgramNode): Diagnostic[] {
+    const diagnostics: Diagnostic[] = [];
+    const functions = new Map<string, FunctionInfo>();
+    const traits = new Map(program.traits.map((trait) => [trait.name, trait]));
+    const macros = new Set<string>();
+
+    for (const value of [...program.consts.map((item) => item.name), ...program.enums.map((item) => item.name), ...program.modules.map((item) => item.name)]) {
+      if (functions.has(value)) {
+        diagnostics.push({ message: `Duplicate top-level symbol '${value}'`, range: program.range, severity: "error" });
+      }
+    }
+
+    for (const fn of program.functions) {
+      const name = fn.signature.name;
+      if (functions.has(name)) diagnostics.push({ message: `Function '${name}' is already declared`, range: fn.range, severity: "error" });
+      else functions.set(name, { params: fn.signature.params.map((param) => param.name), declaration: fn });
+      this.validateLifetimeSignature(fn.signature, diagnostics);
+    }
+
+    for (const macro of program.macros) {
+      if (macros.has(macro.name)) diagnostics.push({ message: `Macro '${macro.name}' is already declared`, range: macro.range, severity: "error" });
+      macros.add(macro.name);
+      if (!functions.has(macro.name)) {
+        functions.set(macro.name, { params: macro.params, declaration: { kind: "FunctionDeclaration", signature: { kind: "FunctionSignature", name: macro.name, genericParams: [], params: macro.params.map((param) => ({ name: param })), range: macro.range }, body: macro.body, range: macro.range } });
+      }
+    }
+
+    for (const implNode of program.impls) {
+      if (!implNode.traitName) continue;
+      const trait = traits.get(implNode.traitName);
+      if (!trait) {
+        diagnostics.push({ message: `Trait '${implNode.traitName}' is not defined`, range: implNode.range, severity: "error" });
+        continue;
+      }
+      const implemented = new Set(implNode.methods.map((method) => method.signature.name));
+      for (const traitMethod of trait.methods) {
+        if (!implemented.has(traitMethod.signature.name)) {
+          diagnostics.push({
+            message: `Impl for '${implNode.targetType}' is missing trait method '${traitMethod.signature.name}'`,
+            range: implNode.range,
+            severity: "error"
+          });
+        }
+      }
+    }
+
+    for (const fn of program.functions) {
+      const scope = new Scope();
+      for (const constant of program.consts) scope.declare(constant.name);
+      for (const param of fn.signature.params) scope.declare(param.name);
+      this.analyzeStatements(fn.body, scope, functions, macros, diagnostics, true);
+    }
+
+    const rootScope = new Scope();
+    for (const constant of program.consts) rootScope.declare(constant.name);
+    for (const importDecl of program.imports) rootScope.declare(importDecl.alias ?? importDecl.importedName);
+    this.analyzeStatements(program.body, rootScope, functions, macros, diagnostics, false);
+    return diagnostics;
+  }
+
+  private validateLifetimeSignature(signature: FunctionSignatureNode, diagnostics: Diagnostic[]): void {
+    if (!signature.returnLifetime) return;
+    const knownLifetimes = new Set(signature.params.map((param) => param.lifetime).filter(Boolean));
+    const declaredLifetimes = new Set(signature.genericParams.map((param) => param.lifetime).filter(Boolean));
+    if (!knownLifetimes.has(signature.returnLifetime) && !declaredLifetimes.has(signature.returnLifetime)) {
+      diagnostics.push({
+        message: `Unknown lifetime '${signature.returnLifetime}' in return type of '${signature.name}'`,
+        range: signature.range,
+        severity: "error"
+      });
+    }
+  }
+
+  private analyzeStatements(
+    statements: StatementNode[],
+    scope: Scope,
+    functions: Map<string, FunctionInfo>,
+    macros: Set<string>,
+    diagnostics: Diagnostic[],
+    insideFunction: boolean
+  ): void {
+    for (const statement of statements) {
+      switch (statement.kind) {
+        case "LetStatement":
+          this.analyzeExpression(statement.expression, scope, functions, macros, diagnostics);
+          scope.declare(statement.binding.name);
+          break;
+        case "SetStatement":
+          this.analyzeExpression(statement.expression, scope, functions, macros, diagnostics);
+          scope.declare(statement.name);
+          break;
+        case "DisplayStatement":
+        case "AssertStatement":
+        case "SpawnStatement":
+        case "ExpressionStatement":
+          this.analyzeExpression(statement.expression, scope, functions, macros, diagnostics);
+          break;
+        case "InputStatement":
+          if (statement.prompt) this.analyzeExpression(statement.prompt, scope, functions, macros, diagnostics);
+          scope.declare(statement.name);
+          break;
+        case "IfStatement":
+          this.analyzeExpression(statement.condition, scope, functions, macros, diagnostics);
+          this.analyzeStatements(statement.thenBranch, new Scope(scope), functions, macros, diagnostics, insideFunction);
+          this.analyzeStatements(statement.elseBranch, new Scope(scope), functions, macros, diagnostics, insideFunction);
+          break;
+        case "MatchStatement":
+          this.analyzeMatchStatement(statement, scope, functions, macros, diagnostics, insideFunction);
+          break;
+        case "ReturnStatement":
+          if (!insideFunction) diagnostics.push({ message: "RETURN can only be used inside a FUNCTION", range: statement.range, severity: "error" });
+          this.analyzeExpression(statement.expression, scope, functions, macros, diagnostics);
+          break;
+        case "UnsafeBlock":
+        case "BlockStatement":
+          this.analyzeStatements(statement.body, new Scope(scope), functions, macros, diagnostics, insideFunction);
+          break;
+      }
+    }
+  }
+
+  private analyzeMatchStatement(
+    statement: MatchStatementNode,
+    scope: Scope,
+    functions: Map<string, FunctionInfo>,
+    macros: Set<string>,
+    diagnostics: Diagnostic[],
+    insideFunction: boolean
+  ): void {
+    this.analyzeExpression(statement.expression, scope, functions, macros, diagnostics);
+    const variantPatterns = new Set<string>();
+    for (const arm of statement.arms) {
+      if (arm.pattern.kind === "VariantPattern") variantPatterns.add(arm.pattern.variantName);
+      const armScope = new Scope(scope);
+      if (arm.pattern.kind === "IdentifierPattern") armScope.declare(arm.pattern.name);
+      if (arm.pattern.kind === "VariantPattern") for (const binding of arm.pattern.bindings) armScope.declare(binding);
+      this.analyzeStatements(arm.body, armScope, functions, macros, diagnostics, insideFunction);
+    }
+    if (statement.arms.length === 0) diagnostics.push({ message: "MATCH must contain at least one arm", range: statement.range, severity: "error" });
+    const hasWildcard = statement.arms.some((arm) => arm.pattern.kind === "WildcardPattern" || arm.pattern.kind === "IdentifierPattern");
+    if (!hasWildcard && variantPatterns.size < 2) {
+      diagnostics.push({ message: "MATCH should include exhaustive patterns or a wildcard arm", range: statement.range, severity: "warning" });
+    }
+  }
+
+  private analyzeExpression(
+    expression: ExpressionNode,
+    scope: Scope,
+    functions: Map<string, FunctionInfo>,
+    macros: Set<string>,
+    diagnostics: Diagnostic[]
+  ): void {
+    switch (expression.kind) {
+      case "Identifier":
+        this.analyzeIdentifier(expression, scope, diagnostics);
+        break;
+      case "BinaryExpression":
+        this.analyzeExpression(expression.left, scope, functions, macros, diagnostics);
+        this.analyzeExpression(expression.right, scope, functions, macros, diagnostics);
+        break;
+      case "UnaryExpression":
+        this.analyzeExpression(expression.operand, scope, functions, macros, diagnostics);
+        break;
+      case "TryExpression":
+        this.analyzeExpression(expression.expression, scope, functions, macros, diagnostics);
+        break;
+      case "CallExpression":
+        this.analyzeCallExpression(expression, scope, functions, macros, diagnostics);
+        break;
+      case "MacroInvocation":
+        if (!macros.has(expression.name)) diagnostics.push({ message: `Macro '${expression.name}' is not defined`, range: expression.range, severity: "error" });
+        for (const arg of expression.args) this.analyzeExpression(arg, scope, functions, macros, diagnostics);
+        break;
+      case "MemberExpression":
+        this.analyzeExpression(expression.object, scope, functions, macros, diagnostics);
+        break;
+      case "EnumConstructorExpression":
+        for (const field of expression.fields) this.analyzeExpression(field, scope, functions, macros, diagnostics);
+        break;
+      case "ArrayLiteral":
+        for (const item of expression.items) this.analyzeExpression(item, scope, functions, macros, diagnostics);
+        break;
+      case "NumberLiteral":
+      case "StringLiteral":
+      case "BooleanLiteral":
+        break;
+    }
+  }
+
+  private analyzeIdentifier(expression: IdentifierNode, scope: Scope, diagnostics: Diagnostic[]): void {
+    if (!scope.has(expression.name) && !this.isBuiltinSymbol(expression.name)) {
+      diagnostics.push({ message: `Variable '${expression.name}' is not defined`, range: expression.range, severity: "error" });
+    }
+  }
+
+  private analyzeCallExpression(
+    expression: CallExpressionNode,
+    scope: Scope,
+    functions: Map<string, FunctionInfo>,
+    macros: Set<string>,
+    diagnostics: Diagnostic[]
+  ): void {
+    if (expression.callee.kind !== "Identifier") this.analyzeExpression(expression.callee, scope, functions, macros, diagnostics);
+    for (const arg of expression.args) this.analyzeExpression(arg, scope, functions, macros, diagnostics);
+
+    if (expression.callee.kind !== "Identifier") return;
+    const callee = expression.callee.name;
+    if (this.isBuiltinCall(callee)) return;
+    const fn = functions.get(callee);
+    if (!fn) {
+      diagnostics.push({ message: `Function '${callee}' is not defined`, range: expression.range, severity: "error" });
+      return;
+    }
+    if (fn.params.length !== expression.args.length) {
+      diagnostics.push({
+        message: `Function '${callee}' expects ${fn.params.length} argument(s) but received ${expression.args.length}`,
+        range: expression.range,
+        severity: "error"
+      });
+    }
+  }
+
+  private isBuiltinSymbol(name: string): boolean {
+    return ["math", "strings", "iter", "Result", "Option"].includes(name);
+  }
+
+  private isBuiltinCall(name: string): boolean {
+    return [
+      "display",
+      "input",
+      "OK",
+      "ERR",
+      "SOME",
+      "NONE",
+      "spawn",
+      "channel",
+      "iter",
+      "collect",
+      "map",
+      "filter",
+      "reduce"
+    ].includes(name);
+  }
+}

package/compiler/src/type_system/checker.d.ts

@@ -0,0 +1,7 @@
+import type { ProgramNode } from "../ast/types.js";
+import type { Diagnostic } from "../diagnostics.js";
+import type { CobolxType } from "../hir/types.js";
+export declare function inferProgramTypes(program: ProgramNode): {
+    symbolTypes: Record<string, CobolxType>;
+    diagnostics: Diagnostic[];
+};

package/compiler/src/type_system/checker.js

@@ -0,0 +1,84 @@
+function lookup(scope, name) {
+    return scope.values.get(name) ?? (scope.parent ? lookup(scope.parent, name) : undefined);
+}
+function inferExpression(expression, scope, diagnostics) {
+    switch (expression.kind) {
+        case "NumberLiteral":
+            return "number";
+        case "StringLiteral":
+            return "string";
+        case "BooleanLiteral":
+            return "boolean";
+        case "Identifier":
+            return lookup(scope, expression.name) ?? "unknown";
+        case "UnaryExpression":
+            return inferExpression(expression.operand, scope, diagnostics);
+        case "CallExpression":
+            for (const arg of expression.args) {
+                inferExpression(arg, scope, diagnostics);
+            }
+            return "unknown";
+        case "BinaryExpression":
+            return inferBinaryExpression(expression, scope, diagnostics);
+    }
+}
+function inferBinaryExpression(expression, scope, diagnostics) {
+    const left = inferExpression(expression.left, scope, diagnostics);
+    const right = inferExpression(expression.right, scope, diagnostics);
+    if (["+", "-", "*", "/"].includes(expression.operator)) {
+        if (left !== "number" || right !== "number") {
+            diagnostics.push({
+                message: `Arithmetic operator '${expression.operator}' expects number operands`,
+                severity: "warning",
+                range: expression.range
+            });
+        }
+        return "number";
+    }
+    if (["==", "!=", "<", "<=", ">", ">="].includes(expression.operator)) {
+        return "boolean";
+    }
+    return "unknown";
+}
+export function inferProgramTypes(program) {
+    const diagnostics = [];
+    const scope = { values: new Map() };
+    const visitStatements = (statements, localScope) => {
+        for (const statement of statements) {
+            switch (statement.kind) {
+                case "SetStatement":
+                    localScope.values.set(statement.name, inferExpression(statement.expression, localScope, diagnostics));
+                    break;
+                case "InputStatement":
+                    localScope.values.set(statement.name, "string");
+                    if (statement.prompt) {
+                        inferExpression(statement.prompt, localScope, diagnostics);
+                    }
+                    break;
+                case "DisplayStatement":
+                case "ExpressionStatement":
+                case "ReturnStatement":
+                    inferExpression(statement.expression, localScope, diagnostics);
+                    break;
+                case "IfStatement":
+                    inferExpression(statement.condition, localScope, diagnostics);
+                    visitStatements(statement.thenBranch, { values: new Map(localScope.values), parent: localScope.parent });
+                    visitStatements(statement.elseBranch, { values: new Map(localScope.values), parent: localScope.parent });
+                    break;
+            }
+        }
+    };
+    for (const fn of program.functions) {
+        const fnScope = { values: new Map(), parent: scope };
+        for (const param of fn.params) {
+            fnScope.values.set(param, "unknown");
+        }
+        visitStatements(fn.body, fnScope);
+    }
+    visitStatements(program.body, scope);
+    return {
+        symbolTypes: Object.fromEntries(scope.values.entries()),
+        diagnostics
+    };
+}
+//# sourceMappingURL=checker.js.map

package/compiler/src/type_system/checker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checker.js","sourceRoot":"","sources":["checker.ts"],"names":[],"mappings":"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"}