@rcrsr/rill 0.1.0

package/dist/parser/helpers.js

@@ -0,0 +1,225 @@
+/**
+ * Parser Helpers
+ * Lookahead predicates and utility parsing functions
+ * @internal This module contains internal parser utilities
+ */
+import { ParseError, TOKEN_TYPES } from '../types.js';
+import { check, peek, expect } from './state.js';
+// ============================================================
+// VALID TYPE NAMES
+// ============================================================
+/** @internal */
+export const VALID_TYPE_NAMES = [
+    'string',
+    'number',
+    'bool',
+    'closure',
+    'list',
+    'dict',
+    'tuple',
+];
+/** @internal */
+export const FUNC_PARAM_TYPES = ['string', 'number', 'bool'];
+// ============================================================
+// LOOKAHEAD PREDICATES
+// ============================================================
+/**
+ * Check for function call: identifier( or namespace::func(
+ * Supports: func(), ns::func(), ns::sub::func()
+ * @internal
+ */
+export function isHostCall(state) {
+    if (!check(state, TOKEN_TYPES.IDENTIFIER)) {
+        return false;
+    }
+    // Simple case: identifier(
+    if (peek(state, 1).type === TOKEN_TYPES.LPAREN) {
+        return true;
+    }
+    // Namespaced case: identifier::identifier(
+    // Scan ahead for pattern: IDENT (:: IDENT)* (
+    let offset = 1;
+    while (peek(state, offset).type === TOKEN_TYPES.DOUBLE_COLON) {
+        offset++; // skip ::
+        if (peek(state, offset).type !== TOKEN_TYPES.IDENTIFIER) {
+            return false; // :: must be followed by identifier
+        }
+        offset++; // skip identifier
+    }
+    // If we consumed at least one ::, check for (
+    return offset > 1 && peek(state, offset).type === TOKEN_TYPES.LPAREN;
+}
+/**
+ * Check for simple closure call: $name(
+ * Used in expression context where $var.method() should be parsed as Variable + MethodCall
+ * @internal
+ */
+export function isClosureCall(state) {
+    return (check(state, TOKEN_TYPES.DOLLAR) &&
+        peek(state, 1).type === TOKEN_TYPES.IDENTIFIER &&
+        peek(state, 2).type === TOKEN_TYPES.LPAREN);
+}
+/**
+ * Check for closure call with property access: $name( or $name.prop...(
+ * Used in pipe target context where $dict.closure() should invoke the closure
+ * @internal
+ */
+export function isClosureCallWithAccess(state) {
+    if (!check(state, TOKEN_TYPES.DOLLAR))
+        return false;
+    if (peek(state, 1).type !== TOKEN_TYPES.IDENTIFIER)
+        return false;
+    // Scan through .identifier chains to find terminal (
+    let offset = 2;
+    while (peek(state, offset).type === TOKEN_TYPES.DOT) {
+        offset++; // skip .
+        if (peek(state, offset).type !== TOKEN_TYPES.IDENTIFIER)
+            return false;
+        offset++; // skip identifier
+    }
+    return peek(state, offset).type === TOKEN_TYPES.LPAREN;
+}
+/**
+ * Check for pipe invoke: $( (invoke pipe value as closure)
+ * @internal
+ */
+export function canStartPipeInvoke(state) {
+    return (check(state, TOKEN_TYPES.PIPE_VAR) &&
+        peek(state, 1).type === TOKEN_TYPES.LPAREN);
+}
+/**
+ * Check for method call: .identifier
+ * @internal
+ */
+export function isMethodCall(state) {
+    return (check(state, TOKEN_TYPES.DOT) &&
+        peek(state, 1).type === TOKEN_TYPES.IDENTIFIER);
+}
+/**
+ * Check for sequential spread target: @$ or @[ (not @{ which is for-loop)
+ * @internal
+ */
+export function isClosureChainTarget(state) {
+    return (check(state, TOKEN_TYPES.AT) &&
+        (peek(state, 1).type === TOKEN_TYPES.DOLLAR ||
+            peek(state, 1).type === TOKEN_TYPES.LBRACKET));
+}
+/**
+ * Check for negative number: -42
+ * @internal
+ */
+export function isNegativeNumber(state) {
+    return (check(state, TOKEN_TYPES.MINUS) &&
+        peek(state, 1).type === TOKEN_TYPES.NUMBER);
+}
+/**
+ * Check for dict start: identifier followed by colon
+ * @internal
+ */
+export function isDictStart(state) {
+    return (check(state, TOKEN_TYPES.IDENTIFIER) &&
+        peek(state, 1).type === TOKEN_TYPES.COLON);
+}
+/**
+ * Check for method call with args (for field access termination): .identifier(
+ * @internal
+ */
+export function isMethodCallWithArgs(state) {
+    return (peek(state, 1).type === TOKEN_TYPES.IDENTIFIER &&
+        peek(state, 2).type === TOKEN_TYPES.LPAREN);
+}
+/**
+ * Check for literal start (not LPAREN - that's now grouping)
+ * @internal
+ */
+export function isLiteralStart(state) {
+    return check(state, TOKEN_TYPES.STRING, TOKEN_TYPES.NUMBER, TOKEN_TYPES.TRUE, TOKEN_TYPES.FALSE, TOKEN_TYPES.LBRACKET);
+}
+/**
+ * Check if current token can start an expression (for bare spread detection)
+ * @internal
+ */
+export function canStartExpression(state) {
+    return (isLiteralStart(state) ||
+        isClosureStart(state) ||
+        check(state, TOKEN_TYPES.DOLLAR, TOKEN_TYPES.PIPE_VAR, TOKEN_TYPES.IDENTIFIER, TOKEN_TYPES.DOT, TOKEN_TYPES.LPAREN, TOKEN_TYPES.LBRACE, TOKEN_TYPES.AT, TOKEN_TYPES.QUESTION, TOKEN_TYPES.BANG, TOKEN_TYPES.STAR, TOKEN_TYPES.MINUS));
+}
+/**
+ * Check for closure start: | or ||
+ * - |params| body
+ * - || body (no-param closure)
+ * @internal
+ */
+export function isClosureStart(state) {
+    return check(state, TOKEN_TYPES.PIPE_BAR, TOKEN_TYPES.OR);
+}
+// ============================================================
+// UTILITY PARSING FUNCTIONS
+// ============================================================
+/**
+ * Parse and validate a type name from an identifier token.
+ * Throws ParseError if the type is not in the allowed list.
+ * @internal
+ */
+export function parseTypeName(state, validTypes) {
+    const typeToken = expect(state, TOKEN_TYPES.IDENTIFIER, 'Expected type name');
+    if (!validTypes.includes(typeToken.value)) {
+        throw new ParseError(`Invalid type: ${typeToken.value} (expected: ${validTypes.join(', ')})`, typeToken.span.start);
+    }
+    return typeToken.value;
+}
+/**
+ * Create a block containing a single boolean literal statement
+ * @internal
+ */
+export function makeBoolLiteralBlock(value, span) {
+    return {
+        type: 'Block',
+        statements: [
+            {
+                type: 'Statement',
+                expression: {
+                    type: 'PipeChain',
+                    head: {
+                        type: 'PostfixExpr',
+                        primary: { type: 'BoolLiteral', value, span },
+                        methods: [],
+                        span,
+                    },
+                    pipes: [],
+                    terminator: null,
+                    span,
+                },
+                span,
+            },
+        ],
+        span,
+    };
+}
+// Note: parseArgumentList is defined in expressions.ts to avoid circular dependencies
+// since it depends on parseExpression
+// ============================================================
+// BARE HOST CALL PARSING
+// ============================================================
+/**
+ * Parse a bare function name (no parens): `func` or `ns::func` or `ns::sub::func`
+ * Returns a HostCallNode with empty args.
+ * @internal
+ */
+export function parseBareHostCall(state) {
+    const start = state.tokens[state.pos].span.start;
+    let name = expect(state, TOKEN_TYPES.IDENTIFIER, 'Expected identifier').value;
+    // Collect namespaced name: ident::ident::...
+    while (check(state, TOKEN_TYPES.DOUBLE_COLON)) {
+        state.pos++; // consume ::
+        const next = expect(state, TOKEN_TYPES.IDENTIFIER, 'Expected identifier after ::');
+        name += '::' + next.value;
+    }
+    return {
+        type: 'HostCall',
+        name,
+        args: [],
+        span: { start, end: state.tokens[state.pos - 1].span.end },
+    };
+}
+//# sourceMappingURL=helpers.js.map

package/dist/parser/helpers.js.map

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

package/dist/parser/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Rill Parser
+ * Main entry point and re-exports
+ */
+import type { ParseResult, ScriptNode } from '../types.js';
+import './parser-script.js';
+import './parser-expr.js';
+import './parser-literals.js';
+import './parser-variables.js';
+import './parser-control.js';
+import './parser-functions.js';
+import './parser-collect.js';
+import './parser-extract.js';
+/**
+ * Parse rill source code into an AST.
+ *
+ * Throws ParseError on first syntax error.
+ *
+ * @param source - The source code to parse
+ * @returns The parsed AST (ScriptNode)
+ *
+ * @example
+ * ```typescript
+ * const ast = parse(source);
+ * ```
+ */
+export declare function parse(source: string): ScriptNode;
+/**
+ * Parse rill source code with error recovery for IDE/tooling scenarios.
+ *
+ * Instead of throwing on first error, collects errors and returns
+ * a partial AST with ErrorNode entries where parsing failed.
+ *
+ * @param source - The source code to parse
+ * @returns ParseResult with AST, errors array, and success flag
+ *
+ * @example
+ * ```typescript
+ * const result = parseWithRecovery(source);
+ * if (!result.success) {
+ *   console.log('Errors:', result.errors);
+ * }
+ * // AST may contain ErrorNode entries in statements
+ * ```
+ */
+export declare function parseWithRecovery(source: string): ParseResult;
+export { createParserState, type ParserState } from './state.js';
+export { Parser } from './parser.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/parser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/parser/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAK3D,OAAO,oBAAoB,CAAC;AAC5B,OAAO,kBAAkB,CAAC;AAC1B,OAAO,sBAAsB,CAAC;AAC9B,OAAO,uBAAuB,CAAC;AAC/B,OAAO,qBAAqB,CAAC;AAC7B,OAAO,uBAAuB,CAAC;AAC/B,OAAO,qBAAqB,CAAC;AAC7B,OAAO,qBAAqB,CAAC;AAM7B;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,CAIhD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAU7D;AAOD,OAAO,EAAE,iBAAiB,EAAE,KAAK,WAAW,EAAE,MAAM,YAAY,CAAC;AAGjE,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/dist/parser/index.js

@@ -0,0 +1,73 @@
+/**
+ * Rill Parser
+ * Main entry point and re-exports
+ */
+import { tokenize } from '../lexer/index.js';
+import { Parser } from './parser.js';
+// Import extension modules to register prototype methods on Parser.
+// These must be imported AFTER parser.js to ensure the class is defined.
+import './parser-script.js';
+import './parser-expr.js';
+import './parser-literals.js';
+import './parser-variables.js';
+import './parser-control.js';
+import './parser-functions.js';
+import './parser-collect.js';
+import './parser-extract.js';
+// ============================================================
+// MAIN ENTRY POINT
+// ============================================================
+/**
+ * Parse rill source code into an AST.
+ *
+ * Throws ParseError on first syntax error.
+ *
+ * @param source - The source code to parse
+ * @returns The parsed AST (ScriptNode)
+ *
+ * @example
+ * ```typescript
+ * const ast = parse(source);
+ * ```
+ */
+export function parse(source) {
+    const tokens = tokenize(source);
+    const parser = new Parser(tokens, { recoveryMode: false, source: '' });
+    return parser.parse();
+}
+/**
+ * Parse rill source code with error recovery for IDE/tooling scenarios.
+ *
+ * Instead of throwing on first error, collects errors and returns
+ * a partial AST with ErrorNode entries where parsing failed.
+ *
+ * @param source - The source code to parse
+ * @returns ParseResult with AST, errors array, and success flag
+ *
+ * @example
+ * ```typescript
+ * const result = parseWithRecovery(source);
+ * if (!result.success) {
+ *   console.log('Errors:', result.errors);
+ * }
+ * // AST may contain ErrorNode entries in statements
+ * ```
+ */
+export function parseWithRecovery(source) {
+    const tokens = tokenize(source);
+    const parser = new Parser(tokens, { recoveryMode: true, source });
+    const ast = parser.parse();
+    return {
+        ast,
+        errors: parser.errors,
+        success: parser.errors.length === 0,
+    };
+}
+// ============================================================
+// RE-EXPORTS
+// ============================================================
+// State (for advanced usage)
+export { createParserState } from './state.js';
+// Parser class (for advanced usage)
+export { Parser } from './parser.js';
+//# sourceMappingURL=index.js.map

package/dist/parser/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/parser/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,oEAAoE;AACpE,yEAAyE;AACzE,OAAO,oBAAoB,CAAC;AAC5B,OAAO,kBAAkB,CAAC;AAC1B,OAAO,sBAAsB,CAAC;AAC9B,OAAO,uBAAuB,CAAC;AAC/B,OAAO,qBAAqB,CAAC;AAC7B,OAAO,uBAAuB,CAAC;AAC/B,OAAO,qBAAqB,CAAC;AAC7B,OAAO,qBAAqB,CAAC;AAE7B,+DAA+D;AAC/D,mBAAmB;AACnB,+DAA+D;AAE/D;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,KAAK,CAAC,MAAc;IAClC,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IAChC,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC;IACvE,OAAO,MAAM,CAAC,KAAK,EAAE,CAAC;AACxB,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAc;IAC9C,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IAChC,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,MAAM,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAC;IAClE,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,EAAE,CAAC;IAE3B,OAAO;QACL,GAAG;QACH,MAAM,EAAE,MAAM,CAAC,MAAM;QACrB,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC;KACpC,CAAC;AACJ,CAAC;AAED,+DAA+D;AAC/D,aAAa;AACb,+DAA+D;AAE/D,6BAA6B;AAC7B,OAAO,EAAE,iBAAiB,EAAoB,MAAM,YAAY,CAAC;AAEjE,oCAAoC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/dist/parser/literals.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Literal Parsing
+ * Strings, numbers, booleans, tuples, dicts, and closures
+ */
+import type { BlockNode, DictNode, ExpressionNode, ClosureNode, GroupedExprNode, LiteralNode, PipeChainNode, PostfixExprNode, BodyNode, StringLiteralNode, TupleNode } from '../types.js';
+import { type ParserState } from './state.js';
+export declare function setParseExpression(fn: (state: ParserState) => ExpressionNode): void;
+export declare function setParseBlock(fn: (state: ParserState) => BlockNode): void;
+export declare function setParseGrouped(fn: (state: ParserState) => GroupedExprNode): void;
+export declare function setParsePostfixExpr(fn: (state: ParserState) => PostfixExprNode): void;
+export declare function setLiteralsParsePipeChain(fn: (state: ParserState) => PipeChainNode): void;
+export declare function parseLiteral(state: ParserState): LiteralNode;
+/**
+ * Parse a string literal, handling interpolation expressions.
+ * Interpolation uses {expr} syntax where expr is any valid expression.
+ * Escaped braces \{ and \} produce literal braces.
+ */
+export declare function parseString(state: ParserState): StringLiteralNode;
+export declare function parseTupleOrDict(state: ParserState): TupleNode | DictNode;
+/**
+ * Parse closure: |params| body or || body
+ * Params can be: |x|, |x: string|, |x: string = "default"|
+ *
+ * Body can be:
+ * - Simple: |x| $x (postfix-expr)
+ * - Grouped: |x| ($x * 2) (compound expression)
+ * - Block: |x| { $a ↵ $b } (multiple statements)
+ */
+export declare function parseClosure(state: ParserState): ClosureNode;
+/**
+ * Parse simple-body: block, grouped, or postfix-expr
+ * No naked compound expressions — arithmetic/pipes/booleans must be grouped.
+ *
+ * Used by: closures, conditionals, loops
+ */
+export declare function parseBody(state: ParserState): BodyNode;
+//# sourceMappingURL=literals.d.ts.map

package/dist/parser/literals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"literals.d.ts","sourceRoot":"","sources":["../../src/parser/literals.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,SAAS,EAET,QAAQ,EACR,cAAc,EAEd,WAAW,EACX,eAAe,EAEf,WAAW,EACX,aAAa,EACb,eAAe,EACf,QAAQ,EAER,iBAAiB,EACjB,SAAS,EACV,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,KAAK,WAAW,EAQjB,MAAM,YAAY,CAAC;AAUpB,wBAAgB,kBAAkB,CAChC,EAAE,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,cAAc,GACzC,IAAI,CAEN;AAED,wBAAgB,aAAa,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,SAAS,GAAG,IAAI,CAEzE;AAED,wBAAgB,eAAe,CAC7B,EAAE,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,eAAe,GAC1C,IAAI,CAEN;AAED,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,eAAe,GAC1C,IAAI,CAEN;AAED,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,aAAa,GACxC,IAAI,CAEN;AAMD,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CA2C5D;AAMD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,WAAW,GAAG,iBAAiB,CAajE;AAwID,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,SAAS,GAAG,QAAQ,CAoCzE;AA8DD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CAsC5D;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,WAAW,GAAG,QAAQ,CAmBtD"}