bonescript-compiler 0.2.0

package/src/parse_expr.ts

@@ -0,0 +1,197 @@
+/**
+ * BoneScript Expression Parser — Pratt-style precedence climbing.
+ */
+
+import { TokenKind } from "./lexer";
+import { TokenStream, ParseError } from "./parser_base";
+import * as AST from "./ast";
+
+export function parseExpr(s: TokenStream): AST.ExprNode {
+  return parseLogicalOr(s);
+}
+
+export function parseExprList(s: TokenStream): AST.ExprNode[] {
+  const exprs: AST.ExprNode[] = [];
+  if (s.check(TokenKind.RBracket)) return exprs;
+  do {
+    exprs.push(parseExpr(s));
+  } while (s.match(TokenKind.Comma));
+  return exprs;
+}
+
+function parseLogicalOr(s: TokenStream): AST.ExprNode {
+  let left = parseLogicalAnd(s);
+  while (s.check(TokenKind.KwOr)) {
+    const loc = s.peek().loc;
+    s.advance();
+    const right = parseLogicalAnd(s);
+    left = { kind: "BinaryExpr", loc, op: "or", left, right };
+  }
+  return left;
+}
+
+function parseLogicalAnd(s: TokenStream): AST.ExprNode {
+  let left = parseComparison(s);
+  while (s.check(TokenKind.KwAnd)) {
+    const loc = s.peek().loc;
+    s.advance();
+    const right = parseComparison(s);
+    left = { kind: "BinaryExpr", loc, op: "and", left, right };
+  }
+  return left;
+}
+
+function parseComparison(s: TokenStream): AST.ExprNode {
+  let left = parseAdditive(s);
+  const compOps = [
+    TokenKind.EqEq, TokenKind.NotEq, TokenKind.LAngle, TokenKind.RAngle,
+    TokenKind.LtEq, TokenKind.GtEq, TokenKind.KwIn, TokenKind.KwContains,
+  ];
+  if (compOps.includes(s.peek().kind)) {
+    const loc = s.peek().loc;
+    const op = s.advance().value;
+    const right = parseAdditive(s);
+    // Check for range: expr in expr..expr
+    if (op === "in" && s.check(TokenKind.DotDot)) {
+      const dotLoc = s.peek().loc;
+      s.advance(); // consume ..
+      const upper = parseAdditive(s);
+      // Desugar "x in low..high" into BinaryExpr with op "in_range"
+      const range: AST.BinaryExprNode = { kind: "BinaryExpr", loc: dotLoc, op: "..", left: right, right: upper };
+      left = { kind: "BinaryExpr", loc, op: "in", left, right: range };
+    } else {
+      left = { kind: "BinaryExpr", loc, op, left, right };
+    }
+  }
+  return left;
+}
+
+function parseAdditive(s: TokenStream): AST.ExprNode {
+  let left = parseMultiplicative(s);
+  while (s.check(TokenKind.Plus) || s.check(TokenKind.Minus)) {
+    const loc = s.peek().loc;
+    const op = s.advance().value;
+    const right = parseMultiplicative(s);
+    left = { kind: "BinaryExpr", loc, op, left, right };
+  }
+  return left;
+}
+
+function parseMultiplicative(s: TokenStream): AST.ExprNode {
+  let left = parseUnary(s);
+  while (s.check(TokenKind.Star) || s.check(TokenKind.Slash) || s.check(TokenKind.Percent)) {
+    const loc = s.peek().loc;
+    const op = s.advance().value;
+    const right = parseUnary(s);
+    left = { kind: "BinaryExpr", loc, op, left, right };
+  }
+  return left;
+}
+
+function parseUnary(s: TokenStream): AST.ExprNode {
+  if (s.check(TokenKind.KwNot)) {
+    const loc = s.peek().loc;
+    s.advance();
+    const operand = parseUnary(s);
+    return { kind: "UnaryExpr", loc, op: "not", operand };
+  }
+  if (s.check(TokenKind.Minus)) {
+    const loc = s.peek().loc;
+    s.advance();
+    const operand = parseUnary(s);
+    return { kind: "UnaryExpr", loc, op: "-", operand };
+  }
+  return parsePrimary(s);
+}
+
+function parsePrimary(s: TokenStream): AST.ExprNode {
+  const tok = s.peek();
+  const loc = tok.loc;
+
+  // Parenthesized expression
+  if (tok.kind === TokenKind.LParen) {
+    s.advance();
+    const expr = parseExpr(s);
+    s.expect(TokenKind.RParen, "parenthesized expression");
+    return expr;
+  }
+
+  // List literal
+  if (tok.kind === TokenKind.LBracket) {
+    s.advance();
+    const elements: AST.ExprNode[] = [];
+    if (!s.check(TokenKind.RBracket)) {
+      do { elements.push(parseExpr(s)); } while (s.match(TokenKind.Comma));
+    }
+    s.expect(TokenKind.RBracket, "list literal close");
+    return { kind: "Literal", loc, type: "list", value: elements };
+  }
+
+  // String literal
+  if (tok.kind === TokenKind.StringLiteral) {
+    s.advance();
+    return { kind: "Literal", loc, type: "string", value: tok.value };
+  }
+
+  // Int literal
+  if (tok.kind === TokenKind.IntLiteral) {
+    s.advance();
+    return { kind: "Literal", loc, type: "int", value: parseInt(tok.value, 10) };
+  }
+
+  // Float literal
+  if (tok.kind === TokenKind.FloatLiteral) {
+    s.advance();
+    return { kind: "Literal", loc, type: "float", value: parseFloat(tok.value) };
+  }
+
+  // Boolean
+  if (tok.kind === TokenKind.KwTrue) { s.advance(); return { kind: "Literal", loc, type: "bool", value: true }; }
+  if (tok.kind === TokenKind.KwFalse) { s.advance(); return { kind: "Literal", loc, type: "bool", value: false }; }
+
+  // None
+  if (tok.kind === TokenKind.KwNone) { s.advance(); return { kind: "Literal", loc, type: "none", value: null }; }
+
+  // now()
+  if (tok.kind === TokenKind.KwNow) {
+    s.advance();
+    if (s.match(TokenKind.LParen)) { s.expect(TokenKind.RParen, "now()"); }
+    return { kind: "CallExpr", loc, name: "now", args: [] };
+  }
+
+  // Identifier — field ref or function call
+  if (tok.kind === TokenKind.Identifier || isKeywordIdentifier(tok)) {
+    const path: string[] = [];
+    path.push(s.advance().value);
+
+    // Function call
+    if (s.check(TokenKind.LParen)) {
+      s.advance();
+      const args: AST.ExprNode[] = [];
+      if (!s.check(TokenKind.RParen)) {
+        do { args.push(parseExpr(s)); } while (s.match(TokenKind.Comma));
+      }
+      s.expect(TokenKind.RParen, "function call close");
+      return { kind: "CallExpr", loc, name: path[0], args };
+    }
+
+    // Dotted field reference
+    while (s.match(TokenKind.Dot)) {
+      const next = s.peek();
+      if (next.kind === TokenKind.Identifier || next.kind === TokenKind.KwUnique || isKeywordIdentifier(next)) {
+        path.push(s.advance().value);
+      } else {
+        break;
+      }
+    }
+    return { kind: "FieldRef", loc, path };
+  }
+
+  throw new ParseError(`Expected expression, got ${tok.kind} ('${tok.value}')`, tok.loc);
+}
+
+/** Check if a token is a keyword that can also serve as an identifier */
+function isKeywordIdentifier(tok: { kind: TokenKind; value: string }): boolean {
+  // Keywords that are commonly used as variable/field names
+  return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tok.value) && tok.kind !== TokenKind.EOF;
+}

package/src/parse_types.ts

@@ -0,0 +1,54 @@
+/**
+ * BoneScript Type Expression Parser
+ */
+
+import { TokenKind } from "./lexer";
+import { TokenStream, ParseError } from "./parser_base";
+import * as AST from "./ast";
+
+export function parseTypeExpr(s: TokenStream): AST.TypeExprNode {
+  const loc = s.peek().loc;
+  const tok = s.peek();
+
+  // Generic types
+  const generics = [TokenKind.KwSet, TokenKind.KwList, TokenKind.KwOptional, TokenKind.KwResult, TokenKind.KwMap];
+  if (generics.includes(tok.kind)) {
+    const name = s.advance().value;
+    s.expect(TokenKind.LAngle, "generic type arg");
+    const typeArgs: AST.TypeExprNode[] = [];
+    typeArgs.push(parseTypeExpr(s));
+    while (s.match(TokenKind.Comma)) {
+      typeArgs.push(parseTypeExpr(s));
+    }
+    s.expect(TokenKind.RAngle, "generic type arg close");
+    return { kind: "GenericType", loc, name, typeArgs };
+  }
+
+  // Primitive types
+  const primitives = [
+    TokenKind.KwString, TokenKind.KwUint, TokenKind.KwInt, TokenKind.KwFloat,
+    TokenKind.KwBool, TokenKind.KwTimestamp, TokenKind.KwUuid, TokenKind.KwBytes, TokenKind.KwJson,
+  ];
+  if (primitives.includes(tok.kind)) {
+    return { kind: "PrimitiveType", loc, name: s.advance().value };
+  }
+
+  // Tuple type
+  if (tok.kind === TokenKind.LParen) {
+    s.advance();
+    const elements: AST.TypeExprNode[] = [];
+    elements.push(parseTypeExpr(s));
+    while (s.match(TokenKind.Comma)) {
+      elements.push(parseTypeExpr(s));
+    }
+    s.expect(TokenKind.RParen, "tuple type close");
+    return { kind: "TupleType", loc, elements };
+  }
+
+  // Entity reference
+  if (tok.kind === TokenKind.Identifier) {
+    return { kind: "EntityRefType", loc, name: s.advance().value };
+  }
+
+  throw new ParseError(`Expected type expression, got ${tok.kind}`, tok.loc);
+}

package/src/parser.ts

@@ -0,0 +1,64 @@
+import { Token, TokenKind } from "./lexer";
+import { TokenStream, ParseError } from "./parser_base";
+import * as AST from "./ast";
+import { parseEntityDecl, parseCapabilityDecl } from "./parse_decls";
+import { parseChannelDecl, parseStoreDecl, parseEventDecl, parseConstraintDecl, parsePolicyDecl, parseFlowDecl, parseImportDecl, parseExtensionPointDecl } from "./parse_decls2";
+
+export { ParseError } from "./parser_base";
+
+export class Parser {
+  private s: TokenStream;
+
+  constructor(tokens: Token[]) {
+    this.s = new TokenStream(tokens);
+  }
+
+  parse(): AST.ProgramNode {
+    const loc = this.s.peek().loc;
+    const systems: AST.SystemDeclNode[] = [];
+    while (!this.s.check(TokenKind.EOF)) {
+      systems.push(this.parseSystemDecl());
+    }
+    if (systems.length === 0) {
+      throw new ParseError("Program must contain at least one system declaration", loc);
+    }
+    return { kind: "Program", loc, systems };
+  }
+
+  private parseSystemDecl(): AST.SystemDeclNode {
+    const loc = this.s.peek().loc;
+    this.s.expect(TokenKind.KwSystem, "system declaration");
+    const name = this.s.expect(TokenKind.Identifier, "system name").value;
+    this.s.expect(TokenKind.LBrace, "system body");
+    let domain: string | null = null;
+    if (this.s.check(TokenKind.KwDomain)) {
+      this.s.advance();
+      this.s.expect(TokenKind.Colon, "domain");
+      domain = this.s.expect(TokenKind.Identifier, "domain name").value;
+    }
+    const declarations: AST.DeclarationNode[] = [];
+    while (!this.s.check(TokenKind.RBrace) && !this.s.check(TokenKind.EOF)) {
+      declarations.push(this.parseDeclaration());
+    }
+    this.s.expect(TokenKind.RBrace, "system body close");
+    return { kind: "SystemDecl", loc, name, domain, declarations };
+  }
+
+  private parseDeclaration(): AST.DeclarationNode {
+    const tok = this.s.peek();
+    switch (tok.kind) {
+      case TokenKind.KwEntity: return parseEntityDecl(this.s);
+      case TokenKind.KwCapability: return parseCapabilityDecl(this.s);
+      case TokenKind.KwChannel: return parseChannelDecl(this.s);
+      case TokenKind.KwStore: return parseStoreDecl(this.s);
+      case TokenKind.KwEvent: return parseEventDecl(this.s);
+      case TokenKind.KwConstraint: return parseConstraintDecl(this.s);
+      case TokenKind.KwPolicy: return parsePolicyDecl(this.s);
+      case TokenKind.KwFlow: return parseFlowDecl(this.s);
+      case TokenKind.KwImport: return parseImportDecl(this.s);
+      case TokenKind.KwExtensionPoint: return parseExtensionPointDecl(this.s);
+      default:
+        throw new ParseError("Expected declaration, got " + tok.kind, tok.loc);
+    }
+  }
+}

package/src/parser_base.ts

@@ -0,0 +1,57 @@
+/**
+ * bone parser Base — Token stream utilities.
+ */
+
+import { Token, TokenKind, SourceLocation } from "./lexer";
+
+export class ParseError extends Error {
+  constructor(message: string, public loc: SourceLocation) {
+    super(`Parse error at ${loc.line}:${loc.column}: ${message}`);
+    this.name = "ParseError";
+  }
+}
+
+export class TokenStream {
+  private tokens: Token[];
+  private pos: number = 0;
+
+  constructor(tokens: Token[]) {
+    this.tokens = tokens;
+  }
+
+  peek(offset: number = 0): Token {
+    return this.tokens[this.pos + offset] ?? this.tokens[this.tokens.length - 1];
+  }
+
+  check(kind: TokenKind): boolean {
+    return this.peek().kind === kind;
+  }
+
+  checkAny(...kinds: TokenKind[]): boolean {
+    return kinds.includes(this.peek().kind);
+  }
+
+  advance(): Token {
+    const t = this.tokens[this.pos];
+    if (this.pos < this.tokens.length - 1) this.pos++;
+    return t;
+  }
+
+  expect(kind: TokenKind, context: string): Token {
+    if (!this.check(kind)) {
+      throw new ParseError(
+        `Expected ${kind} in ${context}, got ${this.peek().kind} ('${this.peek().value}')`,
+        this.peek().loc
+      );
+    }
+    return this.advance();
+  }
+
+  match(kind: TokenKind): boolean {
+    if (this.check(kind)) {
+      this.advance();
+      return true;
+    }
+    return false;
+  }
+}

package/src/parser_recovery.ts

@@ -0,0 +1,153 @@
+/**
+ * bone parser with Error Recovery
+ * Wraps the strict parser to collect multiple errors per file.
+ *
+ * Strategy:
+ * - On error, skip tokens until we hit a synchronization point
+ * - Synchronization points: declaration keywords (entity, capability, etc.) and closing braces
+ * - Each error is recorded with location, but parsing continues
+ */
+
+import { Token, TokenKind } from "./lexer";
+import { TokenStream, ParseError } from "./parser_base";
+import * as AST from "./ast";
+import { parseEntityDecl, parseCapabilityDecl } from "./parse_decls";
+import {
+  parseChannelDecl, parseStoreDecl, parseEventDecl,
+  parseConstraintDecl, parsePolicyDecl, parseFlowDecl, parseImportDecl,
+  parseExtensionPointDecl,
+} from "./parse_decls2";
+
+export interface RecoveredParseResult {
+  ast: AST.ProgramNode | null;
+  errors: ParseError[];
+}
+
+const SYNC_POINTS = new Set([
+  TokenKind.KwSystem,
+  TokenKind.KwEntity,
+  TokenKind.KwCapability,
+  TokenKind.KwChannel,
+  TokenKind.KwStore,
+  TokenKind.KwEvent,
+  TokenKind.KwConstraint,
+  TokenKind.KwPolicy,
+  TokenKind.KwFlow,
+  TokenKind.KwImport,
+  TokenKind.KwExtensionPoint,
+  TokenKind.RBrace,
+]);
+
+export class RecoveringParser {
+  private s: TokenStream;
+  private errors: ParseError[] = [];
+
+  constructor(tokens: Token[]) {
+    this.s = new TokenStream(tokens);
+  }
+
+  parse(): RecoveredParseResult {
+    const loc = this.s.peek().loc;
+    const systems: AST.SystemDeclNode[] = [];
+
+    while (!this.s.check(TokenKind.EOF)) {
+      try {
+        systems.push(this.parseSystemDecl());
+      } catch (e) {
+        if (e instanceof ParseError) {
+          this.errors.push(e);
+          this.synchronize();
+        } else {
+          throw e;
+        }
+      }
+    }
+
+    if (systems.length === 0 && this.errors.length === 0) {
+      this.errors.push(new ParseError("Program must contain at least one system declaration", loc));
+    }
+
+    return {
+      ast: systems.length > 0 ? { kind: "Program", loc, systems } : null,
+      errors: this.errors,
+    };
+  }
+
+  private synchronize() {
+    // Skip tokens until we find a synchronization point
+    while (!this.s.check(TokenKind.EOF)) {
+      const tok = this.s.peek();
+      if (SYNC_POINTS.has(tok.kind)) {
+        // Found sync point — if it's a closing brace, consume it; otherwise leave it for next parse
+        if (tok.kind === TokenKind.RBrace) this.s.advance();
+        return;
+      }
+      this.s.advance();
+    }
+  }
+
+  private parseSystemDecl(): AST.SystemDeclNode {
+    const loc = this.s.peek().loc;
+    this.s.expect(TokenKind.KwSystem, "system declaration");
+    const name = this.s.expect(TokenKind.Identifier, "system name").value;
+    this.s.expect(TokenKind.LBrace, "system body");
+
+    let domain: string | null = null;
+    if (this.s.check(TokenKind.KwDomain)) {
+      this.s.advance();
+      this.s.expect(TokenKind.Colon, "domain");
+      domain = this.s.expect(TokenKind.Identifier, "domain name").value;
+    }
+
+    const declarations: AST.DeclarationNode[] = [];
+    while (!this.s.check(TokenKind.RBrace) && !this.s.check(TokenKind.EOF)) {
+      try {
+        declarations.push(this.parseDeclaration());
+      } catch (e) {
+        if (e instanceof ParseError) {
+          this.errors.push(e);
+          this.synchronizeInBody();
+        } else {
+          throw e;
+        }
+      }
+    }
+
+    this.s.expect(TokenKind.RBrace, "system body close");
+    return { kind: "SystemDecl", loc, name, domain, declarations };
+  }
+
+  private synchronizeInBody() {
+    let depth = 0;
+    while (!this.s.check(TokenKind.EOF)) {
+      const tok = this.s.peek();
+      if (tok.kind === TokenKind.LBrace) depth++;
+      if (tok.kind === TokenKind.RBrace) {
+        if (depth === 0) return; // hit system close
+        depth--;
+        this.s.advance();
+        continue;
+      }
+      if (depth === 0 && SYNC_POINTS.has(tok.kind)) return;
+      this.s.advance();
+    }
+  }
+
+  private parseDeclaration(): AST.DeclarationNode {
+    const tok = this.s.peek();
+    switch (tok.kind) {
+      case TokenKind.KwEntity: return parseEntityDecl(this.s);
+      case TokenKind.KwCapability: return parseCapabilityDecl(this.s);
+      case TokenKind.KwChannel: return parseChannelDecl(this.s);
+      case TokenKind.KwStore: return parseStoreDecl(this.s);
+      case TokenKind.KwEvent: return parseEventDecl(this.s);
+      case TokenKind.KwConstraint: return parseConstraintDecl(this.s);
+      case TokenKind.KwPolicy: return parsePolicyDecl(this.s);
+      case TokenKind.KwFlow: return parseFlowDecl(this.s);
+      case TokenKind.KwImport: return parseImportDecl(this.s);
+      case TokenKind.KwExtensionPoint: return parseExtensionPointDecl(this.s);
+      default:
+        throw new ParseError(`Expected declaration, got ${tok.kind} ('${tok.value}')`, tok.loc);
+    }
+  }
+}