cobolx-2 1.2.3

package/compiler/src/lexer/lexer.ts

@@ -0,0 +1,274 @@
+import type { SourceLocation, SourceRange } from "../ast/types.js";
+import { CobolxError } from "../diagnostics.js";
+import type { Token, TokenType } from "./tokens.js";
+import { KEYWORDS } from "./tokens.js";
+
+function cloneLocation(location: SourceLocation): SourceLocation {
+  return { ...location };
+}
+
+export class Lexer {
+  private index = 0;
+  private location: SourceLocation = { line: 1, column: 1, offset: 0 };
+
+  constructor(private readonly source: string) {}
+
+  tokenize(): Token[] {
+    const tokens: Token[] = [];
+
+    while (!this.isAtEnd()) {
+      const char = this.peek();
+
+      if (char === " " || char === "\t" || char === "\r") {
+        this.advance();
+        continue;
+      }
+
+      if (char === "\n") {
+        tokens.push(this.simpleToken("NEWLINE", this.advance()));
+        continue;
+      }
+
+      if (char === "/" && this.peekNext() === "/" && this.peekThird() === "/") {
+        tokens.push(this.docComment());
+        continue;
+      }
+
+      if (char === "*" && this.peekNext() === ">") {
+        this.consumeLineComment();
+        continue;
+      }
+
+      if (this.isAlpha(char)) {
+        tokens.push(this.identifier());
+        continue;
+      }
+
+      if (this.isDigit(char)) {
+        tokens.push(this.number());
+        continue;
+      }
+
+      if (char === "\"") {
+        tokens.push(this.string());
+        continue;
+      }
+
+      tokens.push(this.symbol());
+    }
+
+    const eofRange: SourceRange = {
+      start: cloneLocation(this.location),
+      end: cloneLocation(this.location)
+    };
+    tokens.push({ type: "EOF", lexeme: "", range: eofRange });
+    return tokens;
+  }
+
+  private docComment(): Token {
+    const start = cloneLocation(this.location);
+    this.advance();
+    this.advance();
+    this.advance();
+    let value = "";
+    while (!this.isAtEnd() && this.peek() !== "\n") {
+      value += this.advance();
+    }
+    return {
+      type: "DOC_COMMENT",
+      lexeme: value.trim(),
+      range: { start, end: cloneLocation(this.location) }
+    };
+  }
+
+  private consumeLineComment(): void {
+    while (!this.isAtEnd() && this.peek() !== "\n") {
+      this.advance();
+    }
+  }
+
+  private identifier(): Token {
+    const start = cloneLocation(this.location);
+    let value = "";
+    while (!this.isAtEnd() && (this.isAlphaNumeric(this.peek()) || this.peek() === "-" || this.peek() === "_")) {
+      value += this.advance();
+    }
+    const upper = value.toUpperCase();
+    const type = KEYWORDS[upper] ?? "IDENTIFIER";
+    return {
+      type,
+      lexeme: type === "IDENTIFIER" ? value : upper,
+      range: { start, end: cloneLocation(this.location) }
+    };
+  }
+
+  private number(): Token {
+    const start = cloneLocation(this.location);
+    let value = "";
+    while (!this.isAtEnd() && this.isDigit(this.peek())) {
+      value += this.advance();
+    }
+    if (!this.isAtEnd() && this.peek() === "." && this.isDigit(this.peekNext())) {
+      value += this.advance();
+      while (!this.isAtEnd() && this.isDigit(this.peek())) {
+        value += this.advance();
+      }
+    }
+    return {
+      type: "NUMBER",
+      lexeme: value,
+      range: { start, end: cloneLocation(this.location) }
+    };
+  }
+
+  private string(): Token {
+    const start = cloneLocation(this.location);
+    this.advance();
+    let value = "";
+    while (!this.isAtEnd() && this.peek() !== "\"") {
+      if (this.peek() === "\n") {
+        throw new CobolxError({
+          message: "Unterminated string literal",
+          range: { start, end: cloneLocation(this.location) },
+          severity: "error"
+        });
+      }
+      value += this.advance();
+    }
+    if (this.isAtEnd()) {
+      throw new CobolxError({
+        message: "Unterminated string literal",
+        range: { start, end: cloneLocation(this.location) },
+        severity: "error"
+      });
+    }
+    this.advance();
+    return {
+      type: "STRING",
+      lexeme: value,
+      range: { start, end: cloneLocation(this.location) }
+    };
+  }
+
+  private symbol(): Token {
+    const start = cloneLocation(this.location);
+    const char = this.advance();
+    const emit = (type: TokenType, lexeme: string): Token => ({
+      type,
+      lexeme,
+      range: { start, end: cloneLocation(this.location) }
+    });
+
+    switch (char) {
+      case "+":
+        return emit("PLUS", char);
+      case "-":
+        if (this.peek() === ">") {
+          this.advance();
+          return emit("ARROW", "->");
+        }
+        return emit("MINUS", char);
+      case "*":
+        return emit("STAR", char);
+      case "/":
+        return emit("SLASH", char);
+      case "%":
+        return emit("PERCENT", char);
+      case "!":
+        if (this.peek() === "=") {
+          this.advance();
+          return emit("NOT_EQUAL", "!=");
+        }
+        return emit("BANG", char);
+      case "?":
+        return emit("QUESTION", char);
+      case "(":
+        return emit("LPAREN", char);
+      case ")":
+        return emit("RPAREN", char);
+      case "[":
+        return emit("LBRACKET", char);
+      case "]":
+        return emit("RBRACKET", char);
+      case ",":
+        return emit("COMMA", char);
+      case ":":
+        return emit("COLON", char);
+      case ".":
+        return emit("DOT", char);
+      case "=":
+        return emit("ASSIGN", char);
+      case "<":
+        if (this.peek() === "=") {
+          this.advance();
+          return emit("LESS_EQUAL", "<=");
+        }
+        return emit("LESS", char);
+      case ">":
+        if (this.peek() === "=") {
+          this.advance();
+          return emit("GREATER_EQUAL", ">=");
+        }
+        return emit("GREATER", char);
+      case "&":
+        return emit("AMPERSAND", char);
+    }
+
+    throw new CobolxError({
+      message: `Unexpected character '${char}'`,
+      range: { start, end: cloneLocation(this.location) },
+      severity: "error"
+    });
+  }
+
+  private simpleToken(type: TokenType, lexeme: string): Token {
+    const end = cloneLocation(this.location);
+    const start = {
+      line: end.line,
+      column: end.column - lexeme.length,
+      offset: end.offset - lexeme.length
+    };
+    return { type, lexeme, range: { start, end } };
+  }
+
+  private advance(): string {
+    const char = this.source[this.index] ?? "\0";
+    this.index += 1;
+    this.location.offset += 1;
+    if (char === "\n") {
+      this.location.line += 1;
+      this.location.column = 1;
+    } else {
+      this.location.column += 1;
+    }
+    return char;
+  }
+
+  private peek(): string {
+    return this.source[this.index] ?? "\0";
+  }
+
+  private peekNext(): string {
+    return this.source[this.index + 1] ?? "\0";
+  }
+
+  private peekThird(): string {
+    return this.source[this.index + 2] ?? "\0";
+  }
+
+  private isAtEnd(): boolean {
+    return this.index >= this.source.length;
+  }
+
+  private isAlpha(char: string): boolean {
+    return /[A-Za-z_]/.test(char);
+  }
+
+  private isDigit(char: string): boolean {
+    return /[0-9]/.test(char);
+  }
+
+  private isAlphaNumeric(char: string): boolean {
+    return this.isAlpha(char) || this.isDigit(char);
+  }
+}

package/compiler/src/lexer/tokens.d.ts

@@ -0,0 +1,8 @@
+import type { SourceRange } from "../ast/types.js";
+export type TokenType = "PROGRAM" | "BEGIN" | "END" | "SET" | "DISPLAY" | "INPUT" | "IF" | "THEN" | "ELSE" | "END-IF" | "FUNCTION" | "RETURN" | "END-FUNCTION" | "TRUE" | "FALSE" | "IDENTIFIER" | "NUMBER" | "STRING" | "PLUS" | "MINUS" | "STAR" | "SLASH" | "EQUAL" | "NOT_EQUAL" | "LESS" | "LESS_EQUAL" | "GREATER" | "GREATER_EQUAL" | "ASSIGN" | "LPAREN" | "RPAREN" | "COMMA" | "NEWLINE" | "EOF";
+export interface Token {
+    type: TokenType;
+    lexeme: string;
+    range: SourceRange;
+}
+export declare const KEYWORDS: Record<string, TokenType>;

package/compiler/src/lexer/tokens.js

@@ -0,0 +1,18 @@
+export const KEYWORDS = {
+    PROGRAM: "PROGRAM",
+    BEGIN: "BEGIN",
+    END: "END",
+    SET: "SET",
+    DISPLAY: "DISPLAY",
+    INPUT: "INPUT",
+    IF: "IF",
+    THEN: "THEN",
+    ELSE: "ELSE",
+    "END-IF": "END-IF",
+    FUNCTION: "FUNCTION",
+    RETURN: "RETURN",
+    "END-FUNCTION": "END-FUNCTION",
+    TRUE: "TRUE",
+    FALSE: "FALSE"
+};
+//# sourceMappingURL=tokens.js.map

package/compiler/src/lexer/tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.js","sourceRoot":"","sources":["tokens.ts"],"names":[],"mappings":"AA4CA,MAAM,CAAC,MAAM,QAAQ,GAA8B;IACjD,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,OAAO;IACd,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,OAAO,EAAE,SAAS;IAClB,KAAK,EAAE,OAAO;IACd,EAAE,EAAE,IAAI;IACR,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,QAAQ,EAAE,QAAQ;IAClB,QAAQ,EAAE,UAAU;IACpB,MAAM,EAAE,QAAQ;IAChB,cAAc,EAAE,cAAc;IAC9B,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;CACf,CAAC"}

package/compiler/src/lexer/tokens.ts

@@ -0,0 +1,126 @@
+import type { SourceRange } from "../ast/types.js";
+
+export type TokenType =
+  | "PROGRAM"
+  | "BEGIN"
+  | "END"
+  | "SET"
+  | "LET"
+  | "MUT"
+  | "DISPLAY"
+  | "INPUT"
+  | "IF"
+  | "THEN"
+  | "ELSE"
+  | "END-IF"
+  | "MATCH"
+  | "END-MATCH"
+  | "FUNCTION"
+  | "ASYNC"
+  | "CONST"
+  | "RETURN"
+  | "END-FUNCTION"
+  | "TRAIT"
+  | "END-TRAIT"
+  | "IMPL"
+  | "FOR"
+  | "END-IMPL"
+  | "ENUM"
+  | "MODULE"
+  | "END-MODULE"
+  | "IMPORT"
+  | "EXPORT"
+  | "FROM"
+  | "AS"
+  | "PLUGIN"
+  | "MACRO"
+  | "END-MACRO"
+  | "TEST"
+  | "END-TEST"
+  | "ASSERT"
+  | "UNSAFE"
+  | "END-UNSAFE"
+  | "SPAWN"
+  | "PUBLIC"
+  | "TRUE"
+  | "FALSE"
+  | "IDENTIFIER"
+  | "NUMBER"
+  | "STRING"
+  | "DOC_COMMENT"
+  | "PLUS"
+  | "MINUS"
+  | "STAR"
+  | "SLASH"
+  | "PERCENT"
+  | "BANG"
+  | "QUESTION"
+  | "LESS"
+  | "LESS_EQUAL"
+  | "GREATER"
+  | "GREATER_EQUAL"
+  | "ASSIGN"
+  | "NOT_EQUAL"
+  | "LPAREN"
+  | "RPAREN"
+  | "LBRACKET"
+  | "RBRACKET"
+  | "COMMA"
+  | "COLON"
+  | "DOT"
+  | "ARROW"
+  | "AMPERSAND"
+  | "NEWLINE"
+  | "EOF";
+
+export interface Token {
+  type: TokenType;
+  lexeme: string;
+  range: SourceRange;
+}
+
+export const KEYWORDS: Record<string, TokenType> = {
+  PROGRAM: "PROGRAM",
+  BEGIN: "BEGIN",
+  END: "END",
+  SET: "SET",
+  LET: "LET",
+  MUT: "MUT",
+  DISPLAY: "DISPLAY",
+  INPUT: "INPUT",
+  IF: "IF",
+  THEN: "THEN",
+  ELSE: "ELSE",
+  "END-IF": "END-IF",
+  MATCH: "MATCH",
+  "END-MATCH": "END-MATCH",
+  FUNCTION: "FUNCTION",
+  ASYNC: "ASYNC",
+  CONST: "CONST",
+  RETURN: "RETURN",
+  "END-FUNCTION": "END-FUNCTION",
+  TRAIT: "TRAIT",
+  "END-TRAIT": "END-TRAIT",
+  IMPL: "IMPL",
+  FOR: "FOR",
+  "END-IMPL": "END-IMPL",
+  ENUM: "ENUM",
+  MODULE: "MODULE",
+  "END-MODULE": "END-MODULE",
+  IMPORT: "IMPORT",
+  EXPORT: "EXPORT",
+  FROM: "FROM",
+  AS: "AS",
+  PLUGIN: "PLUGIN",
+  MACRO: "MACRO",
+  "END-MACRO": "END-MACRO",
+  TEST: "TEST",
+  "END-TEST": "END-TEST",
+  ASSERT: "ASSERT",
+  UNSAFE: "UNSAFE",
+  "END-UNSAFE": "END-UNSAFE",
+  SPAWN: "SPAWN",
+  PUBLIC: "PUBLIC",
+  TRUE: "TRUE",
+  FALSE: "FALSE"
+};

package/compiler/src/macros/expand.ts

@@ -0,0 +1,75 @@
+import type {
+  CallExpressionNode,
+  ExpressionNode,
+  MacroInvocationNode,
+  ProgramNode,
+  StatementNode
+} from "../ast/types.js";
+
+function rewriteExpression(expression: ExpressionNode): ExpressionNode {
+  switch (expression.kind) {
+    case "BinaryExpression":
+      return { ...expression, left: rewriteExpression(expression.left), right: rewriteExpression(expression.right) };
+    case "UnaryExpression":
+      return { ...expression, operand: rewriteExpression(expression.operand) };
+    case "TryExpression":
+      return { ...expression, expression: rewriteExpression(expression.expression) };
+    case "MemberExpression":
+      return { ...expression, object: rewriteExpression(expression.object) };
+    case "CallExpression":
+      return { ...expression, callee: rewriteExpression(expression.callee), args: expression.args.map(rewriteExpression) };
+    case "MacroInvocation":
+      return macroToCall(expression);
+    case "EnumConstructorExpression":
+      return { ...expression, fields: expression.fields.map(rewriteExpression) };
+    case "ArrayLiteral":
+      return { ...expression, items: expression.items.map(rewriteExpression) };
+    default:
+      return expression;
+  }
+}
+
+function rewriteStatement(statement: StatementNode): StatementNode {
+  switch (statement.kind) {
+    case "LetStatement":
+      return { ...statement, expression: rewriteExpression(statement.expression) };
+    case "SetStatement":
+    case "DisplayStatement":
+    case "ReturnStatement":
+    case "ExpressionStatement":
+    case "AssertStatement":
+    case "SpawnStatement":
+      return { ...statement, expression: rewriteExpression(statement.expression) };
+    case "InputStatement":
+      return { ...statement, prompt: statement.prompt ? rewriteExpression(statement.prompt) : undefined };
+    case "IfStatement":
+      return { ...statement, condition: rewriteExpression(statement.condition), thenBranch: statement.thenBranch.map(rewriteStatement), elseBranch: statement.elseBranch.map(rewriteStatement) };
+    case "MatchStatement":
+      return { ...statement, expression: rewriteExpression(statement.expression), arms: statement.arms.map((arm) => ({ ...arm, body: arm.body.map(rewriteStatement) })) };
+    case "UnsafeBlock":
+    case "BlockStatement":
+      return { ...statement, body: statement.body.map(rewriteStatement) };
+  }
+}
+
+function macroToCall(expression: MacroInvocationNode): CallExpressionNode {
+  return {
+    kind: "CallExpression",
+    callee: { kind: "Identifier", name: `__macro_${expression.name}`, range: expression.range },
+    args: expression.args.map(rewriteExpression),
+    range: expression.range
+  };
+}
+
+export function expandMacros(program: ProgramNode): ProgramNode {
+  return {
+    ...program,
+    functions: program.functions.map((fn) => ({ ...fn, body: fn.body.map(rewriteStatement) })),
+    macros: program.macros.map((macro) => ({
+      ...macro,
+      name: `__macro_${macro.name}`,
+      body: macro.body.map(rewriteStatement)
+    })),
+    body: program.body.map(rewriteStatement)
+  };
+}

package/compiler/src/main.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { runCompilerCli } from "./index.js";
+
+process.exit(runCompilerCli(process.argv.slice(2)));

package/compiler/src/mir/lower.d.ts

@@ -0,0 +1,3 @@
+import type { HIRProgram } from "../hir/types.js";
+import type { MIRProgram } from "./types.js";
+export declare function lowerToMIR(hir: HIRProgram): MIRProgram;

package/compiler/src/mir/lower.js

@@ -0,0 +1,10 @@
+export function lowerToMIR(hir) {
+    return {
+        functions: hir.functions.map((fn) => ({
+            name: fn.name,
+            instructions: fn.body.map(({ statement }) => ({ op: "statement", statement }))
+        })),
+        body: hir.body.map(({ statement }) => ({ op: "statement", statement }))
+    };
+}
+//# sourceMappingURL=lower.js.map

package/compiler/src/mir/lower.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lower.js","sourceRoot":"","sources":["lower.ts"],"names":[],"mappings":"AAGA,MAAM,UAAU,UAAU,CAAC,GAAe;IACxC,OAAO;QACL,SAAS,EAAE,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC;YACpC,IAAI,EAAE,EAAE,CAAC,IAAI;YACb,YAAY,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC,CAAC;SAC/E,CAAC,CAAC;QACH,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE,CAAC,CAAC;KACxE,CAAC;AACJ,CAAC"}

package/compiler/src/mir/lower.ts

@@ -0,0 +1,12 @@
+import type { HIRProgram } from "../hir/types.js";
+import type { MIRProgram } from "./types.js";
+
+export function lowerToMIR(hir: HIRProgram): MIRProgram {
+  return {
+    functions: hir.functions.map((fn) => ({
+      name: fn.name,
+      instructions: fn.body.map(({ statement }) => ({ op: "statement", statement }))
+    })),
+    body: hir.body.map(({ statement }) => ({ op: "statement", statement }))
+  };
+}

package/compiler/src/mir/types.d.ts

@@ -0,0 +1,13 @@
+import type { StatementNode } from "../ast/types.js";
+export interface MIRInstruction {
+    op: "statement";
+    statement: StatementNode;
+}
+export interface MIRFunction {
+    name: string;
+    instructions: MIRInstruction[];
+}
+export interface MIRProgram {
+    functions: MIRFunction[];
+    body: MIRInstruction[];
+}

package/compiler/src/mir/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/compiler/src/mir/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":""}

package/compiler/src/mir/types.ts

@@ -0,0 +1,16 @@
+import type { StatementNode } from "../ast/types.js";
+
+export interface MIRInstruction {
+  op: "statement";
+  statement: StatementNode;
+}
+
+export interface MIRFunction {
+  name: string;
+  instructions: MIRInstruction[];
+}
+
+export interface MIRProgram {
+  functions: MIRFunction[];
+  body: MIRInstruction[];
+}

package/compiler/src/optimizer/constantFold.d.ts

@@ -0,0 +1,2 @@
+import type { MIRProgram } from "../mir/types.js";
+export declare function optimizeMIR(mir: MIRProgram): MIRProgram;

package/compiler/src/optimizer/constantFold.js

@@ -0,0 +1,61 @@
+function foldExpression(expression) {
+    if (expression.kind === "BinaryExpression") {
+        const left = foldExpression(expression.left);
+        const right = foldExpression(expression.right);
+        if (left.kind === "NumberLiteral" && right.kind === "NumberLiteral") {
+            switch (expression.operator) {
+                case "+":
+                    return { ...expression, kind: "NumberLiteral", value: left.value + right.value };
+                case "-":
+                    return { ...expression, kind: "NumberLiteral", value: left.value - right.value };
+                case "*":
+                    return { ...expression, kind: "NumberLiteral", value: left.value * right.value };
+                case "/":
+                    return { ...expression, kind: "NumberLiteral", value: left.value / right.value };
+            }
+        }
+        return { ...expression, left, right };
+    }
+    if (expression.kind === "UnaryExpression") {
+        return { ...expression, operand: foldExpression(expression.operand) };
+    }
+    if (expression.kind === "CallExpression") {
+        return { ...expression, args: expression.args.map(foldExpression) };
+    }
+    return expression;
+}
+function foldStatement(statement) {
+    switch (statement.kind) {
+        case "SetStatement":
+            return { ...statement, expression: foldExpression(statement.expression) };
+        case "DisplayStatement":
+        case "ReturnStatement":
+        case "ExpressionStatement":
+            return { ...statement, expression: foldExpression(statement.expression) };
+        case "InputStatement":
+            return { ...statement, prompt: statement.prompt ? foldExpression(statement.prompt) : undefined };
+        case "IfStatement":
+            return {
+                ...statement,
+                condition: foldExpression(statement.condition),
+                thenBranch: statement.thenBranch.map(foldStatement),
+                elseBranch: statement.elseBranch.map(foldStatement)
+            };
+    }
+}
+function foldInstruction(instruction) {
+    return {
+        ...instruction,
+        statement: foldStatement(instruction.statement)
+    };
+}
+export function optimizeMIR(mir) {
+    return {
+        functions: mir.functions.map((fn) => ({
+            ...fn,
+            instructions: fn.instructions.map(foldInstruction)
+        })),
+        body: mir.body.map(foldInstruction)
+    };
+}
+//# sourceMappingURL=constantFold.js.map

package/compiler/src/optimizer/constantFold.js.map

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