@rcrsr/rill 0.1.0

package/dist/parser/control-flow.js

@@ -0,0 +1,167 @@
+/**
+ * Control Flow Parsing
+ * Conditionals, loops, and blocks
+ *
+ * New loop syntax (v0.0.2):
+ *   loop = [ simple-body ] , "@" , simple-body , [ "?" , simple-body ]
+ *
+ * Semantics (determined at runtime):
+ *   - If input is bool and no trailing "?": while loop
+ *   - If input is list and no trailing "?": for-each
+ *   - If no input and no trailing "?": for-each over $
+ *   - If trailing "? cond": do-while
+ */
+import { ParseError, TOKEN_TYPES } from '../types.js';
+import { check, advance, expect, current, isAtEnd, skipNewlines, makeSpan, } from './state.js';
+import { parseBody } from './literals.js';
+// Forward declarations - will be set to break circular dependencies
+let parseStatementFn;
+export function setParseStatement(fn) {
+    parseStatementFn = fn;
+}
+// ============================================================
+// CONDITIONALS
+// ============================================================
+/**
+ * Parse piped conditional: ? then_body [! else_body]
+ * Called when bare `?` is seen (condition is implicit $).
+ */
+export function parsePipedConditional(state) {
+    const start = current(state).span.start;
+    expect(state, TOKEN_TYPES.QUESTION, 'Expected ?');
+    return parseConditionalRest(state, null, start);
+}
+/**
+ * Parse conditional after condition is already parsed: ? then_body [! else_body]
+ * Called when we've parsed an expression and see `?` following it.
+ */
+export function parseConditionalWithCondition(state, conditionBody) {
+    const start = conditionBody.span.start;
+    expect(state, TOKEN_TYPES.QUESTION, 'Expected ?');
+    return parseConditionalRest(state, conditionBody, start);
+}
+/**
+ * Parse the rest of a conditional after `?` is consumed.
+ * Grammar: then_body [! (conditional | else_body)]
+ */
+export function parseConditionalRest(state, condition, start) {
+    // Parse then branch - can be block, grouped, or postfix-expr
+    const thenBranch = parseBody(state);
+    // Optional else clause with `!` (not `:`)
+    let elseBranch = null;
+    if (check(state, TOKEN_TYPES.BANG)) {
+        advance(state);
+        // Check if this is else-if (another condition followed by ?)
+        // We need to parse a simple-body first, then check for ?
+        const elseBody = parseBody(state);
+        // If followed by ?, this is else-if chaining
+        if (check(state, TOKEN_TYPES.QUESTION)) {
+            elseBranch = parseConditionalWithCondition(state, elseBody);
+        }
+        else {
+            elseBranch = elseBody;
+        }
+    }
+    return {
+        type: 'Conditional',
+        input: null,
+        condition,
+        thenBranch,
+        elseBranch,
+        span: makeSpan(start, current(state).span.end),
+    };
+}
+// ============================================================
+// LOOPS
+// ============================================================
+/**
+ * Parse loop starting with @: @ body [? cond]
+ *
+ * New syntax:
+ *   @ body           - for-each over $
+ *   @ body ? cond    - do-while (body first, then check)
+ *
+ * Called when bare `@` is seen (no input expression).
+ */
+export function parseLoop(state, input) {
+    const start = input ? input.span.start : current(state).span.start;
+    expect(state, TOKEN_TYPES.AT, 'Expected @');
+    // Parse body - can be block, grouped, or postfix-expr
+    const body = parseBody(state);
+    // Check for do-while post-condition: @ body ? cond
+    if (check(state, TOKEN_TYPES.QUESTION)) {
+        advance(state); // consume ?
+        const condition = parseBody(state);
+        return {
+            type: 'DoWhileLoop',
+            input,
+            body,
+            condition,
+            span: makeSpan(start, current(state).span.end),
+        };
+    }
+    // Regular loop (for-each or while, determined at runtime)
+    return {
+        type: 'ForLoop',
+        input,
+        body,
+        span: makeSpan(start, current(state).span.end),
+    };
+}
+/**
+ * Parse loop with input: input @ body
+ *
+ * New syntax:
+ *   input @ body     - while (if input is bool) or for-each (if input is list)
+ *
+ * Called when we've parsed an expression and see `@` following it.
+ */
+export function parseLoopWithInput(state, input) {
+    // Convert BodyNode to ExpressionNode (wrap if needed)
+    let inputExpr;
+    if (input.type === 'PipeChain') {
+        inputExpr = input;
+    }
+    else {
+        // Wrap in PipeChain
+        inputExpr = {
+            type: 'PipeChain',
+            head: input.type === 'PostfixExpr'
+                ? input
+                : {
+                    type: 'PostfixExpr',
+                    primary: input,
+                    methods: [],
+                    span: input.span,
+                },
+            pipes: [],
+            terminator: null,
+            span: input.span,
+        };
+    }
+    return parseLoop(state, inputExpr);
+}
+// ============================================================
+// BLOCKS
+// ============================================================
+export function parseBlock(state) {
+    const start = current(state).span.start;
+    expect(state, TOKEN_TYPES.LBRACE, 'Expected {');
+    skipNewlines(state);
+    const statements = [];
+    while (!check(state, TOKEN_TYPES.RBRACE) && !isAtEnd(state)) {
+        statements.push(parseStatementFn(state));
+        skipNewlines(state);
+    }
+    // Empty blocks are not allowed - blocks must contain at least one statement
+    if (statements.length === 0) {
+        throw new ParseError('Empty blocks are not allowed', start);
+    }
+    expect(state, TOKEN_TYPES.RBRACE, 'Expected }');
+    return {
+        type: 'Block',
+        statements,
+        span: makeSpan(start, current(state).span.end),
+    };
+}
+//# sourceMappingURL=control-flow.js.map

package/dist/parser/control-flow.js.map

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

package/dist/parser/expressions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Expression Parsing
+ * Primary expressions, postfix expressions, pipe chains, and pipe targets
+ */
+import type { CaptureNode, ExpressionNode, GroupedExprNode, PipeChainNode, PipeTargetNode, PostfixExprNode, PrimaryNode, SourceLocation } from '../types.js';
+import { type ParserState } from './state.js';
+export declare function parseExpression(state: ParserState): ExpressionNode;
+export declare function parsePipeChain(state: ParserState): PipeChainNode;
+export declare function parsePostfixExpr(state: ParserState): PostfixExprNode;
+export declare function parsePrimary(state: ParserState): PrimaryNode;
+export declare function parsePipeTarget(state: ParserState): PipeTargetNode;
+export declare function parseCapture(state: ParserState): CaptureNode;
+export declare function makePipeChain(primary: PrimaryNode, start: SourceLocation): PipeChainNode;
+/**
+ * Grouped expression: ( expression )
+ * Single-expression block with () delimiters.
+ * Provides scoping — captures inside are local.
+ *
+ * Note: Boolean operators (&&, ||, !) are only supported in while loop
+ * conditions @(condition), not in general grouped expressions.
+ */
+export declare function parseGrouped(state: ParserState): GroupedExprNode;
+//# sourceMappingURL=expressions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"expressions.d.ts","sourceRoot":"","sources":["../../src/parser/expressions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAIV,WAAW,EAMX,cAAc,EAId,eAAe,EAIf,aAAa,EACb,cAAc,EACd,eAAe,EACf,WAAW,EACX,cAAc,EAMf,MAAM,aAAa,CAAC;AAErB,OAAO,EACL,KAAK,WAAW,EAOjB,MAAM,YAAY,CAAC;AAsKpB,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,cAAc,CAElE;AA4BD,wBAAgB,cAAc,CAAC,KAAK,EAAE,WAAW,GAAG,aAAa,CAyIhE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,WAAW,GAAG,eAAe,CAYpE;AAoHD,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CAwD5D;AAMD,wBAAgB,eAAe,CAAC,KAAK,EAAE,WAAW,GAAG,cAAc,CAkHlE;AAMD,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW,CAsB5D;AAMD,wBAAgB,aAAa,CAC3B,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,cAAc,GACpB,aAAa,CAaf;AAMD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,eAAe,CAUhE"}