@user-synax/synax 0.0.1

package/dist/index.js

@@ -0,0 +1,684 @@
+// @bun
+// src/codegen.ts
+var INDENT = "  ";
+var PRECEDENCE = {
+  "==": 1,
+  "!=": 1,
+  ">": 1,
+  "<": 1,
+  ">=": 1,
+  "<=": 1,
+  "+": 2,
+  "-": 2,
+  "*": 3,
+  "/": 3
+};
+function generate(program) {
+  return new Generator().program(program);
+}
+
+class Generator {
+  indentLevel = 0;
+  scope = new Set;
+  program(node) {
+    return node.body.map((statement) => this.statement(statement)).join(`
+`);
+  }
+  statement(node) {
+    switch (node.kind) {
+      case "VarDecl":
+        return this.varDecl(node);
+      case "PrintStmt":
+        return this.printStmt(node);
+      case "IfStmt":
+        return this.ifStmt(node);
+      case "FnDecl":
+        return this.fnDecl(node);
+      case "ForStmt":
+        return this.forStmt(node);
+      case "ExprStmt":
+        return `${this.indent()}${this.expression(node.expression)};`;
+    }
+  }
+  varDecl(node) {
+    const value = this.expression(node.value);
+    if (this.scope.has(node.name)) {
+      return `${this.indent()}${node.name} = ${value};`;
+    }
+    this.scope.add(node.name);
+    return `${this.indent()}let ${node.name} = ${value};`;
+  }
+  printStmt(node) {
+    return `${this.indent()}console.log(${this.expression(node.argument)});`;
+  }
+  ifStmt(node) {
+    const header = `${this.indent()}if (${this.expression(node.condition)}) `;
+    let output = header + this.block(node.thenBranch);
+    if (node.elseBranch !== null) {
+      output += ` else ` + this.block(node.elseBranch);
+    }
+    return output;
+  }
+  fnDecl(node) {
+    const header = `${this.indent()}function ${node.name}(${node.params.join(", ")}) `;
+    const outer = this.scope;
+    this.scope = new Set(node.params);
+    const body = this.block(node.body);
+    this.scope = outer;
+    return header + body;
+  }
+  forStmt(node) {
+    const { variable } = node;
+    const start = this.expression(node.start);
+    const end = this.expression(node.end);
+    const header = `${this.indent()}for (let ${variable} = ${start}; ${variable} <= ${end}; ${variable}++) `;
+    return header + this.block(node.body);
+  }
+  expression(node) {
+    switch (node.kind) {
+      case "NumberLiteral":
+        return String(node.value);
+      case "StringLiteral":
+        return JSON.stringify(node.value);
+      case "Identifier":
+        return node.name;
+      case "BinaryExpr":
+        return this.binary(node, 0, false);
+      case "FunctionCall":
+        return `${node.callee}(${node.args.map((argument) => this.expression(argument)).join(", ")})`;
+    }
+  }
+  binary(node, parentPrecedence, isRightChild) {
+    const precedence = PRECEDENCE[node.operator];
+    const left = this.operand(node.left, precedence, false);
+    const right = this.operand(node.right, precedence, true);
+    const text = `${left} ${node.operator} ${right}`;
+    const needsParens = precedence < parentPrecedence || precedence === parentPrecedence && isRightChild;
+    return needsParens ? `(${text})` : text;
+  }
+  operand(node, parentPrecedence, isRightChild) {
+    if (node.kind === "BinaryExpr") {
+      return this.binary(node, parentPrecedence, isRightChild);
+    }
+    return this.expression(node);
+  }
+  block(statements) {
+    if (statements.length === 0)
+      return "{}";
+    this.indentLevel++;
+    const body = statements.map((statement) => this.statement(statement)).join(`
+`);
+    this.indentLevel--;
+    return `{
+${body}
+${this.indent()}}`;
+  }
+  indent() {
+    return INDENT.repeat(this.indentLevel);
+  }
+}
+// src/diagnostics.ts
+var LEAD = "  ";
+function formatDiagnostic(diagnostic, source) {
+  const { file, line, column, length, reason } = diagnostic;
+  const header = `${file}:${line}:${column}: error: ${reason}`;
+  const sourceLine = source.split(/\r?\n/)[line - 1];
+  if (sourceLine === undefined || sourceLine.trim() === "")
+    return header;
+  const start = Math.max(0, Math.min(column - 1, sourceLine.length));
+  const span = Math.max(1, Math.min(length, sourceLine.length - start));
+  const number = String(line);
+  const gutter = " ".repeat(number.length);
+  const padding = sourceLine.slice(0, start).replace(/[^\t]/g, " ");
+  const rendered = `${LEAD}${number} | ${sourceLine}`;
+  const caretLine = `${LEAD}${gutter} | ${padding}${"^".repeat(span)}`;
+  return `${header}
+${rendered}
+${caretLine}`;
+}
+// src/lexer.ts
+var TokenType = {
+  SET: "SET",
+  PRINT: "PRINT",
+  IF: "IF",
+  ELSE: "ELSE",
+  END: "END",
+  FN: "FN",
+  FOR: "FOR",
+  IN: "IN",
+  NUMBER: "NUMBER",
+  STRING: "STRING",
+  IDENT: "IDENT",
+  EQUALS: "EQUALS",
+  PLUS: "PLUS",
+  MINUS: "MINUS",
+  STAR: "STAR",
+  SLASH: "SLASH",
+  EQEQ: "EQEQ",
+  BANGEQ: "BANGEQ",
+  GT: "GT",
+  LT: "LT",
+  GTEQ: "GTEQ",
+  LTEQ: "LTEQ",
+  DOTDOT: "DOTDOT",
+  LPAREN: "LPAREN",
+  RPAREN: "RPAREN",
+  COMMA: "COMMA",
+  NEWLINE: "NEWLINE",
+  EOF: "EOF"
+};
+
+class LexerError extends Error {
+  line;
+  column;
+  length;
+  reason;
+  constructor(reason, line, column, length = 1) {
+    super(`${reason} (line ${line})`);
+    this.name = "LexerError";
+    this.reason = reason;
+    this.line = line;
+    this.column = column;
+    this.length = length;
+  }
+}
+var KEYWORDS = new Map([
+  ["set", TokenType.SET],
+  ["print", TokenType.PRINT],
+  ["if", TokenType.IF],
+  ["else", TokenType.ELSE],
+  ["end", TokenType.END],
+  ["fn", TokenType.FN],
+  ["for", TokenType.FOR],
+  ["in", TokenType.IN]
+]);
+var TWO_CHAR_OPERATORS = new Map([
+  ["==", TokenType.EQEQ],
+  ["!=", TokenType.BANGEQ],
+  [">=", TokenType.GTEQ],
+  ["<=", TokenType.LTEQ],
+  ["..", TokenType.DOTDOT]
+]);
+var ONE_CHAR_TOKENS = new Map([
+  ["=", TokenType.EQUALS],
+  ["+", TokenType.PLUS],
+  ["-", TokenType.MINUS],
+  ["*", TokenType.STAR],
+  ["/", TokenType.SLASH],
+  [">", TokenType.GT],
+  ["<", TokenType.LT],
+  ["(", TokenType.LPAREN],
+  [")", TokenType.RPAREN],
+  [",", TokenType.COMMA]
+]);
+var ESCAPES = new Map([
+  ["n", `
+`],
+  ["t", "\t"],
+  ['"', '"'],
+  ["\\", "\\"]
+]);
+function isDigit(char) {
+  return char !== undefined && char >= "0" && char <= "9";
+}
+function isLetter(char) {
+  return char !== undefined && (char >= "a" && char <= "z" || char >= "A" && char <= "Z");
+}
+function isIdentifierStart(char) {
+  return isLetter(char) || char === "_";
+}
+function isIdentifierPart(char) {
+  return isIdentifierStart(char) || isDigit(char);
+}
+
+class Lexer {
+  source;
+  index = 0;
+  line = 1;
+  lineStart = 0;
+  constructor(source) {
+    this.source = source;
+  }
+  get column() {
+    return this.index - this.lineStart + 1;
+  }
+  tokenize() {
+    this.index = 0;
+    this.line = 1;
+    this.lineStart = 0;
+    const tokens = [];
+    while (true) {
+      const char = this.source[this.index];
+      if (char === undefined)
+        break;
+      if (char === " " || char === "\t" || char === "\r") {
+        this.index++;
+        continue;
+      }
+      if (char === `
+`) {
+        tokens.push({
+          type: TokenType.NEWLINE,
+          lexeme: `
+`,
+          line: this.line,
+          column: this.column
+        });
+        this.index++;
+        this.line++;
+        this.lineStart = this.index;
+        continue;
+      }
+      if (char === "#") {
+        this.skipLineComment();
+        continue;
+      }
+      if (char === "/" && this.source[this.index + 1] === "#") {
+        this.skipBlockComment();
+        continue;
+      }
+      if (char === '"') {
+        tokens.push(this.readString());
+        continue;
+      }
+      if (isDigit(char)) {
+        tokens.push(this.readNumber());
+        continue;
+      }
+      if (isIdentifierStart(char)) {
+        tokens.push(this.readIdentifier());
+        continue;
+      }
+      const operator = this.readOperator();
+      if (operator !== undefined) {
+        tokens.push(operator);
+        continue;
+      }
+      throw new LexerError(`Unexpected character ${JSON.stringify(char)}`, this.line, this.column);
+    }
+    tokens.push({
+      type: TokenType.EOF,
+      lexeme: "",
+      line: this.line,
+      column: this.column
+    });
+    return tokens;
+  }
+  skipLineComment() {
+    this.index++;
+    while (true) {
+      const char = this.source[this.index];
+      if (char === undefined || char === `
+`)
+        return;
+      this.index++;
+    }
+  }
+  skipBlockComment() {
+    const startLine = this.line;
+    const startColumn = this.column;
+    this.index += 2;
+    while (true) {
+      const char = this.source[this.index];
+      if (char === undefined) {
+        throw new LexerError("Unterminated multi-line comment", startLine, startColumn, 2);
+      }
+      if (char === "#" && this.source[this.index + 1] === "/") {
+        this.index += 2;
+        return;
+      }
+      if (char === `
+`) {
+        this.line++;
+        this.index++;
+        this.lineStart = this.index;
+        continue;
+      }
+      this.index++;
+    }
+  }
+  readString() {
+    const line = this.line;
+    const column = this.column;
+    const start = this.index;
+    this.index++;
+    let value = "";
+    while (true) {
+      const char = this.source[this.index];
+      if (char === undefined || char === `
+`) {
+        throw new LexerError("Unterminated string", line, column);
+      }
+      if (char === '"') {
+        this.index++;
+        const lexeme = this.source.slice(start, this.index);
+        return { type: TokenType.STRING, lexeme, value, line, column };
+      }
+      if (char === "\\") {
+        const escaped = this.source[this.index + 1];
+        const decoded = escaped === undefined ? undefined : ESCAPES.get(escaped);
+        if (decoded === undefined) {
+          throw new LexerError(`Invalid escape sequence \\${escaped ?? ""}`, this.line, this.column, 2);
+        }
+        value += decoded;
+        this.index += 2;
+        continue;
+      }
+      value += char;
+      this.index++;
+    }
+  }
+  readNumber() {
+    const line = this.line;
+    const column = this.column;
+    const start = this.index;
+    while (isDigit(this.source[this.index]))
+      this.index++;
+    if (this.source[this.index] === "." && isDigit(this.source[this.index + 1])) {
+      this.index++;
+      while (isDigit(this.source[this.index]))
+        this.index++;
+    }
+    const lexeme = this.source.slice(start, this.index);
+    return {
+      type: TokenType.NUMBER,
+      lexeme,
+      value: Number(lexeme),
+      line,
+      column
+    };
+  }
+  readIdentifier() {
+    const line = this.line;
+    const column = this.column;
+    const start = this.index;
+    while (isIdentifierPart(this.source[this.index]))
+      this.index++;
+    const lexeme = this.source.slice(start, this.index);
+    return {
+      type: KEYWORDS.get(lexeme) ?? TokenType.IDENT,
+      lexeme,
+      line,
+      column
+    };
+  }
+  readOperator() {
+    const line = this.line;
+    const column = this.column;
+    const two = this.source.slice(this.index, this.index + 2);
+    const twoType = TWO_CHAR_OPERATORS.get(two);
+    if (twoType !== undefined) {
+      this.index += 2;
+      return { type: twoType, lexeme: two, line, column };
+    }
+    const one = this.source[this.index];
+    if (one === undefined)
+      return;
+    const oneType = ONE_CHAR_TOKENS.get(one);
+    if (oneType === undefined)
+      return;
+    this.index += 1;
+    return { type: oneType, lexeme: one, line, column };
+  }
+}
+// src/parser.ts
+class ParserError extends Error {
+  line;
+  column;
+  length;
+  reason;
+  constructor(reason, line, column, length = 1) {
+    super(`${reason} (line ${line})`);
+    this.name = "ParserError";
+    this.reason = reason;
+    this.line = line;
+    this.column = column;
+    this.length = length;
+  }
+}
+var COMPARISON_OPERATORS = new Map([
+  [TokenType.GTEQ, ">="],
+  [TokenType.LTEQ, "<="],
+  [TokenType.GT, ">"],
+  [TokenType.LT, "<"],
+  [TokenType.EQEQ, "=="],
+  [TokenType.BANGEQ, "!="]
+]);
+var ADDITIVE_OPERATORS = new Map([
+  [TokenType.PLUS, "+"],
+  [TokenType.MINUS, "-"]
+]);
+var MULTIPLICATIVE_OPERATORS = new Map([
+  [TokenType.STAR, "*"],
+  [TokenType.SLASH, "/"]
+]);
+var END = [TokenType.END];
+var ELSE_OR_END = [TokenType.ELSE, TokenType.END];
+function describe(token) {
+  switch (token.type) {
+    case TokenType.EOF:
+      return "end of input";
+    case TokenType.NEWLINE:
+      return "end of line";
+    default:
+      return `'${token.lexeme}'`;
+  }
+}
+
+class Parser {
+  tokens;
+  index = 0;
+  constructor(tokens = []) {
+    this.tokens = tokens;
+  }
+  parse() {
+    this.index = 0;
+    const first = this.peek();
+    const body = this.parseStatements([]);
+    const token = this.peek();
+    if (token.type !== TokenType.EOF) {
+      throw this.error(token, `Unexpected ${describe(token)} after program`);
+    }
+    return { kind: "Program", body, line: first.line };
+  }
+  parseStatements(terminators) {
+    const statements = [];
+    while (true) {
+      this.skipNewlines();
+      const token = this.peek();
+      if (token.type === TokenType.EOF || terminators.includes(token.type)) {
+        return statements;
+      }
+      statements.push(this.parseStatement());
+      const next = this.peek();
+      if (next.type !== TokenType.NEWLINE && next.type !== TokenType.EOF && !terminators.includes(next.type)) {
+        throw this.error(next, `Expected end of statement but found ${describe(next)}`);
+      }
+    }
+  }
+  parseStatement() {
+    switch (this.peek().type) {
+      case TokenType.SET:
+        return this.parseVarDecl();
+      case TokenType.PRINT:
+        return this.parsePrintStmt();
+      case TokenType.IF:
+        return this.parseIfStmt();
+      case TokenType.FN:
+        return this.parseFnDecl();
+      case TokenType.FOR:
+        return this.parseForStmt();
+      default:
+        return this.parseExprStmt();
+    }
+  }
+  parseVarDecl() {
+    const keyword = this.expect(TokenType.SET, "'set'");
+    const name = this.expect(TokenType.IDENT, "a variable name after 'set'");
+    this.expect(TokenType.EQUALS, "'=' after the variable name");
+    const value = this.parseExpression();
+    return { kind: "VarDecl", name: name.lexeme, value, line: keyword.line };
+  }
+  parsePrintStmt() {
+    const keyword = this.expect(TokenType.PRINT, "'print'");
+    const argument = this.parseExpression();
+    return { kind: "PrintStmt", argument, line: keyword.line };
+  }
+  parseIfStmt() {
+    const keyword = this.expect(TokenType.IF, "'if'");
+    const condition = this.parseExpression();
+    const thenBranch = this.parseStatements(ELSE_OR_END);
+    let elseBranch = null;
+    if (this.peek().type === TokenType.ELSE) {
+      this.advance();
+      elseBranch = this.parseStatements(END);
+    }
+    this.expect(TokenType.END, "'end' to close the 'if'");
+    return { kind: "IfStmt", condition, thenBranch, elseBranch, line: keyword.line };
+  }
+  parseFnDecl() {
+    const keyword = this.expect(TokenType.FN, "'fn'");
+    const name = this.expect(TokenType.IDENT, "a function name after 'fn'");
+    this.expect(TokenType.LPAREN, "'(' after the function name");
+    const params = [];
+    if (this.peek().type !== TokenType.RPAREN) {
+      params.push(this.expect(TokenType.IDENT, "a parameter name").lexeme);
+      while (this.peek().type === TokenType.COMMA) {
+        this.advance();
+        params.push(this.expect(TokenType.IDENT, "a parameter name").lexeme);
+      }
+    }
+    this.expect(TokenType.RPAREN, "')' after the parameter list");
+    const body = this.parseStatements(END);
+    this.expect(TokenType.END, "'end' to close the function body");
+    return { kind: "FnDecl", name: name.lexeme, params, body, line: keyword.line };
+  }
+  parseForStmt() {
+    const keyword = this.expect(TokenType.FOR, "'for'");
+    const variable = this.expect(TokenType.IDENT, "a loop variable after 'for'");
+    this.expect(TokenType.IN, "'in' after the loop variable");
+    const start = this.parseExpression();
+    this.expect(TokenType.DOTDOT, "'..' between the range bounds");
+    const end = this.parseExpression();
+    const body = this.parseStatements(END);
+    this.expect(TokenType.END, "'end' to close the 'for' loop");
+    return {
+      kind: "ForStmt",
+      variable: variable.lexeme,
+      start,
+      end,
+      body,
+      line: keyword.line
+    };
+  }
+  parseExprStmt() {
+    const expression = this.parseExpression();
+    return { kind: "ExprStmt", expression, line: expression.line };
+  }
+  parseExpression() {
+    return this.parseComparison();
+  }
+  parseComparison() {
+    return this.parseBinary(() => this.parseTerm(), COMPARISON_OPERATORS);
+  }
+  parseTerm() {
+    return this.parseBinary(() => this.parseFactor(), ADDITIVE_OPERATORS);
+  }
+  parseFactor() {
+    return this.parseBinary(() => this.parsePrimary(), MULTIPLICATIVE_OPERATORS);
+  }
+  parseBinary(operand, operators) {
+    let left = operand();
+    while (true) {
+      const operator = operators.get(this.peek().type);
+      if (operator === undefined)
+        return left;
+      this.advance();
+      const right = operand();
+      left = { kind: "BinaryExpr", operator, left, right, line: left.line };
+    }
+  }
+  parsePrimary() {
+    const token = this.peek();
+    switch (token.type) {
+      case TokenType.NUMBER: {
+        this.advance();
+        const value = typeof token.value === "number" ? token.value : Number(token.lexeme);
+        return { kind: "NumberLiteral", value, line: token.line };
+      }
+      case TokenType.STRING: {
+        this.advance();
+        const value = typeof token.value === "string" ? token.value : token.lexeme.slice(1, -1);
+        return { kind: "StringLiteral", value, line: token.line };
+      }
+      case TokenType.IDENT: {
+        this.advance();
+        if (this.peek().type === TokenType.LPAREN) {
+          return this.finishFunctionCall(token);
+        }
+        return { kind: "Identifier", name: token.lexeme, line: token.line };
+      }
+      case TokenType.LPAREN: {
+        this.advance();
+        const expression = this.parseExpression();
+        this.expect(TokenType.RPAREN, "')' to close the group");
+        return expression;
+      }
+      default:
+        throw this.error(token, `Expected an expression but found ${describe(token)}`);
+    }
+  }
+  finishFunctionCall(callee) {
+    this.expect(TokenType.LPAREN, "'('");
+    const args = [];
+    if (this.peek().type !== TokenType.RPAREN) {
+      args.push(this.parseExpression());
+      while (this.peek().type === TokenType.COMMA) {
+        this.advance();
+        args.push(this.parseExpression());
+      }
+    }
+    this.expect(TokenType.RPAREN, "')' to close the argument list");
+    return {
+      kind: "FunctionCall",
+      callee: callee.lexeme,
+      args,
+      line: callee.line
+    };
+  }
+  peek(offset = 0) {
+    const token = this.tokens[this.index + offset];
+    if (token === undefined) {
+      throw new Error("Parser ran past the end of the token stream");
+    }
+    return token;
+  }
+  advance() {
+    const token = this.peek();
+    this.index++;
+    return token;
+  }
+  expect(type, description) {
+    const token = this.peek();
+    if (token.type !== type) {
+      throw this.error(token, `Expected ${description} but found ${describe(token)}`);
+    }
+    this.index++;
+    return token;
+  }
+  skipNewlines() {
+    while (this.peek().type === TokenType.NEWLINE)
+      this.advance();
+  }
+  error(token, message) {
+    return new ParserError(message, token.line, token.column, Math.max(token.lexeme.length, 1));
+  }
+}
+export {
+  generate,
+  formatDiagnostic,
+  ParserError,
+  Parser,
+  LexerError,
+  Lexer
+};

package/examples/fibonacci.snx

@@ -0,0 +1,14 @@
+# The first 10 Fibonacci numbers.
+#
+# Synax has no `return`, so a function cannot hand back a value. This version
+# instead carries the running pair (a, b) through recursive parameters and
+# prints each term as it goes, using `n` as the countdown.
+
+fn fib(a, b, n)
+    if n > 0
+        print a
+        fib(b, a + b, n - 1)
+    end
+end
+
+fib(0, 1, 10)