bonescript-compiler 0.5.2 → 0.5.4

package/src/parse_expr.ts

@@ -1,197 +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;
-}
+/**
+ * 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.d.ts

@@ -0,0 +1,6 @@
+/**
+ * BoneScript Type Expression Parser
+ */
+import { TokenStream } from "./parser_base";
+import * as AST from "./ast";
+export declare function parseTypeExpr(s: TokenStream): AST.TypeExprNode;

package/src/parse_types.ts

@@ -1,54 +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);
-}
+/**
+ * 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.d.ts

@@ -0,0 +1,10 @@
+import { Token } from "./lexer";
+import * as AST from "./ast";
+export { ParseError } from "./parser_base";
+export declare class Parser {
+    private s;
+    constructor(tokens: Token[]);
+    parse(): AST.ProgramNode;
+    private parseSystemDecl;
+    private parseDeclaration;
+}

package/src/parser.ts

@@ -61,4 +61,4 @@ export class Parser {
         throw new ParseError("Expected declaration, got " + tok.kind, tok.loc);
     }
   }
-}
+}

package/src/parser_base.d.ts

@@ -0,0 +1,19 @@
+/**
+ * bone parser Base — Token stream utilities.
+ */
+import { Token, TokenKind, SourceLocation } from "./lexer";
+export declare class ParseError extends Error {
+    loc: SourceLocation;
+    constructor(message: string, loc: SourceLocation);
+}
+export declare class TokenStream {
+    private tokens;
+    private pos;
+    constructor(tokens: Token[]);
+    peek(offset?: number): Token;
+    check(kind: TokenKind): boolean;
+    checkAny(...kinds: TokenKind[]): boolean;
+    advance(): Token;
+    expect(kind: TokenKind, context: string): Token;
+    match(kind: TokenKind): boolean;
+}

package/src/parser_base.ts

@@ -1,57 +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;
-  }
-}
+/**
+ * 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;
+  }
+}