@rcrsr/rill-cli 0.17.0 → 0.18.0

package/dist/check/rules/anti-patterns.d.ts

@@ -62,3 +62,23 @@ export declare const COMPLEX_CONDITION: ValidationRule;
  * - docs/topic-variables.md (Scope Rules)
  */
 export declare const LOOP_OUTER_CAPTURE: ValidationRule;
+/**
+ * Warns when a stream variable is invoked before any iteration consumes it.
+ * Invoking a stream closure ($s()) before iterating ($s -> each { ... })
+ * consumes chunks internally, leaving no data for iteration.
+ *
+ * Detection:
+ * - Tracks variables captured from stream closures (returnTypeTarget = stream)
+ *   or captured with explicit :stream type annotation
+ * - Records first invocation (ClosureCall) and first iteration (each/map/filter/fold)
+ * - Warns when invocation precedes iteration in source order
+ *
+ * No warning if:
+ * - Iteration appears before invocation
+ * - Variable is only iterated (never invoked before iteration)
+ * - Variable is only invoked (no iteration to conflict)
+ *
+ * References:
+ * - IR-15: Lint Warning for Pre-Iteration Invocation
+ */
+export declare const STREAM_PRE_ITERATION: ValidationRule;

package/dist/check/rules/anti-patterns.js

@@ -3,6 +3,7 @@
  * Enforces best practices from docs/guide-conventions.md:411-462.
  */
 import { extractContextLine } from './helpers.js';
+import { visitNode } from '../visitor.js';
 // ============================================================
 // AVOID_REASSIGNMENT RULE
 // ============================================================
@@ -342,77 +343,30 @@ function isVariableInParentScope(variableScope, currentClosureScope, scopeStack)
     return variableIndex < currentIndex;
 }
 /**
- * Recursively find all Capture nodes in a loop body.
+ * Find all Capture nodes in a loop body, excluding closures.
+ * Uses visitNode for full AST traversal with closure depth tracking
+ * to skip captures inside nested closures (they have their own scope).
  */
 function findCapturesInBody(node) {
     const captures = [];
-    function traverse(n) {
-        if (n.type === 'Capture') {
-            captures.push(n);
-            return;
-        }
-        // Traverse children based on node type
-        switch (n.type) {
-            case 'Block':
-                for (const stmt of n.statements)
-                    traverse(stmt);
-                break;
-            case 'Statement':
-                traverse(n.expression);
-                break;
-            case 'AnnotatedStatement':
-                traverse(n.statement);
-                break;
-            case 'PipeChain':
-                traverse(n.head);
-                for (const pipe of n.pipes)
-                    traverse(pipe);
-                if (n.terminator)
-                    traverse(n.terminator);
-                break;
-            case 'PostfixExpr':
-                traverse(n.primary);
-                for (const method of n.methods)
-                    traverse(method);
-                break;
-            case 'BinaryExpr':
-                traverse(n.left);
-                traverse(n.right);
-                break;
-            case 'UnaryExpr':
-                traverse(n.operand);
-                break;
-            case 'GroupedExpr':
-                traverse(n.expression);
-                break;
-            case 'Conditional':
-                if (n.input)
-                    traverse(n.input);
-                if (n.condition)
-                    traverse(n.condition);
-                traverse(n.thenBranch);
-                if (n.elseBranch)
-                    traverse(n.elseBranch);
-                break;
-            case 'Closure':
-                // Don't traverse into closures - they have their own scope
-                break;
-            // Nested loops - traverse their bodies too
-            case 'WhileLoop':
-                traverse(n.body);
-                break;
-            case 'DoWhileLoop':
-                traverse(n.body);
-                break;
-            case 'EachExpr':
-            case 'MapExpr':
-            case 'FilterExpr':
-            case 'FoldExpr':
-                traverse(n.body);
-                break;
-        }
-    }
-    traverse(node);
+    let closureDepth = 0;
+    const ctx = {};
+    visitNode(node, ctx, {
+        enter(n) {
+            if (n.type === 'Closure') {
+                closureDepth++;
+                return;
+            }
+            if (n.type === 'Capture' && closureDepth === 0) {
+                captures.push(n);
+            }
+        },
+        exit(n) {
+            if (n.type === 'Closure') {
+                closureDepth--;
+            }
+        },
+    });
     return captures;
 }
 /**
@@ -478,3 +432,206 @@ function getParenNestingDepth(node) {
     traverse(node, 0);
     return maxDepth;
 }
+// ============================================================
+// STREAM_PRE_ITERATION RULE
+// ============================================================
+/** Collection operator node types that consume a stream via iteration */
+const ITERATION_NODE_TYPES = new Set([
+    'EachExpr',
+    'MapExpr',
+    'FilterExpr',
+    'FoldExpr',
+]);
+/**
+ * Warns when a stream variable is invoked before any iteration consumes it.
+ * Invoking a stream closure ($s()) before iterating ($s -> each { ... })
+ * consumes chunks internally, leaving no data for iteration.
+ *
+ * Detection:
+ * - Tracks variables captured from stream closures (returnTypeTarget = stream)
+ *   or captured with explicit :stream type annotation
+ * - Records first invocation (ClosureCall) and first iteration (each/map/filter/fold)
+ * - Warns when invocation precedes iteration in source order
+ *
+ * No warning if:
+ * - Iteration appears before invocation
+ * - Variable is only iterated (never invoked before iteration)
+ * - Variable is only invoked (no iteration to conflict)
+ *
+ * References:
+ * - IR-15: Lint Warning for Pre-Iteration Invocation
+ */
+export const STREAM_PRE_ITERATION = {
+    code: 'STREAM_PRE_ITERATION',
+    category: 'anti-patterns',
+    severity: 'warning',
+    nodeTypes: ['Script'],
+    validate(node, context) {
+        const scriptNode = node;
+        const diagnostics = [];
+        // Phase 1: Collect stream variable names from capture sites
+        const streamVars = new Set();
+        collectStreamVariables(scriptNode, streamVars);
+        if (streamVars.size === 0) {
+            return diagnostics;
+        }
+        // Phase 2: Find first invocation and first iteration for each stream variable
+        const firstInvocation = new Map();
+        const firstIteration = new Map();
+        collectStreamUsages(scriptNode, streamVars, firstInvocation, firstIteration);
+        // Phase 3: Emit warning for each variable invoked before iteration
+        for (const varName of streamVars) {
+            const invocation = firstInvocation.get(varName);
+            const iteration = firstIteration.get(varName);
+            if (!invocation) {
+                continue;
+            }
+            // Warn if invoked and no iteration exists, or invocation precedes iteration
+            const invokedBeforeIteration = !iteration ||
+                invocation.span.start.line < iteration.span.start.line ||
+                (invocation.span.start.line === iteration.span.start.line &&
+                    invocation.span.start.column < iteration.span.start.column);
+            if (invokedBeforeIteration) {
+                diagnostics.push({
+                    location: invocation.span.start,
+                    severity: 'warning',
+                    code: 'STREAM_PRE_ITERATION',
+                    message: `Stream invoked before iteration; chunks consumed internally. '$${varName}' at line ${invocation.span.start.line}`,
+                    context: extractContextLine(invocation.span.start.line, context.source),
+                    fix: null,
+                });
+            }
+        }
+        return diagnostics;
+    },
+};
+/**
+ * Collect variable names captured from stream closures or with :stream type.
+ * Traverses AST to find PipeChains containing a Capture in their pipes where:
+ * - The capture has typeRef with typeName 'stream'
+ * - The PipeChain head is a stream-returning closure
+ *
+ * Note: Capture nodes appear in PipeChain.pipes (not .terminator).
+ * Only Break/Return/Yield use the terminator slot.
+ */
+function collectStreamVariables(node, streamVars) {
+    const ctx = {};
+    visitNode(node, ctx, {
+        enter(n) {
+            if (n.type !== 'PipeChain')
+                return;
+            const chain = n;
+            // Find the last Capture in the pipes array
+            const capture = findTrailingCapture(chain);
+            if (!capture)
+                return;
+            const varName = capture.name;
+            // Check 1: Capture with explicit :stream type annotation
+            if (capture.typeRef &&
+                capture.typeRef.kind === 'static' &&
+                capture.typeRef.typeName === 'stream') {
+                streamVars.add(varName);
+                return;
+            }
+            // Check 2: Head is a closure with stream return type
+            if (isStreamClosure(chain)) {
+                streamVars.add(varName);
+            }
+        },
+        exit() { },
+    });
+}
+/**
+ * Find the trailing Capture node in a PipeChain's pipes array.
+ * Returns null if the last pipe element is not a Capture.
+ */
+function findTrailingCapture(chain) {
+    const lastPipe = chain.pipes[chain.pipes.length - 1];
+    if (lastPipe && lastPipe.type === 'Capture') {
+        return lastPipe;
+    }
+    return null;
+}
+/**
+ * Check if a PipeChain's head (or piped result) is a stream-returning closure.
+ * Detects closures with returnTypeTarget of stream type.
+ */
+function isStreamClosure(chain) {
+    const head = chain.head;
+    if (head.type !== 'PostfixExpr')
+        return false;
+    const postfix = head;
+    if (postfix.primary.type !== 'Closure')
+        return false;
+    const closure = postfix.primary;
+    const returnType = closure.returnTypeTarget;
+    if (!returnType)
+        return false;
+    // TypeConstructorNode: :stream(), :stream(number), :stream(number):string
+    if ('type' in returnType && returnType.type === 'TypeConstructor') {
+        return returnType.constructorName === 'stream';
+    }
+    // TypeRef: :stream (simple form)
+    if ('kind' in returnType && returnType.kind === 'static') {
+        return returnType.typeName === 'stream';
+    }
+    return false;
+}
+/**
+ * Collect first invocation and first iteration sites for stream variables.
+ * Traverses AST in source order, recording only the first occurrence of each.
+ */
+function collectStreamUsages(node, streamVars, firstInvocation, firstIteration) {
+    const ctx = {};
+    visitNode(node, ctx, {
+        enter(n) {
+            // Detect invocation: $s() as ClosureCall
+            if (n.type === 'ClosureCall') {
+                const call = n;
+                if (streamVars.has(call.name) &&
+                    call.accessChain.length === 0 &&
+                    !firstInvocation.has(call.name)) {
+                    firstInvocation.set(call.name, call);
+                }
+                return;
+            }
+            // Detect iteration: $s -> each/map/filter/fold
+            if (n.type === 'PipeChain') {
+                const chain = n;
+                const varName = getPipeHeadVariableName(chain);
+                if (varName !== null &&
+                    streamVars.has(varName) &&
+                    !firstIteration.has(varName)) {
+                    // Check if any pipe target is an iteration operator
+                    for (const pipe of chain.pipes) {
+                        if (ITERATION_NODE_TYPES.has(pipe.type)) {
+                            firstIteration.set(varName, pipe);
+                            break;
+                        }
+                    }
+                }
+            }
+        },
+        exit() { },
+    });
+}
+/**
+ * Extract the variable name from a PipeChain head if it's a simple variable reference.
+ * Returns null for complex heads (binary expressions, host calls, etc.).
+ */
+function getPipeHeadVariableName(chain) {
+    const head = chain.head;
+    if (head.type !== 'PostfixExpr')
+        return null;
+    const postfix = head;
+    if (postfix.primary.type !== 'Variable')
+        return null;
+    if (postfix.methods.length > 0)
+        return null;
+    const variable = postfix.primary;
+    if (variable.isPipeVar || variable.name === null)
+        return null;
+    if (variable.accessChain.length > 0)
+        return null;
+    return variable.name;
+}

package/dist/check/rules/closures.js

@@ -3,6 +3,7 @@
  * Enforces closure best practices from docs/guide-conventions.md:237-286.
  */
 import { extractContextLine } from './helpers.js';
+import { visitNode } from '../visitor.js';
 // ============================================================
 // CLOSURE_BARE_DOLLAR RULE
 // ============================================================
@@ -54,118 +55,20 @@ export const CLOSURE_BARE_DOLLAR = {
 };
 /**
  * Check if a node tree contains bare $ variable references.
- * Recursively walks the AST looking for VariableNode with isPipeVar=true.
+ * Uses visitNode for full AST traversal, detecting VariableNode with isPipeVar=true.
  */
 function containsBareReference(node) {
-    if (node.type === 'Variable') {
-        const varNode = node;
-        // $ is represented as isPipeVar: true with name: null
-        if (varNode.isPipeVar) {
-            return true;
-        }
-    }
-    // Recursively check child nodes based on node type
-    switch (node.type) {
-        case 'Block': {
-            const blockNode = node;
-            for (const stmt of blockNode.statements) {
-                if (containsBareReference(stmt))
-                    return true;
-            }
-            break;
-        }
-        case 'Statement': {
-            const stmtNode = node;
-            if (stmtNode.expression && containsBareReference(stmtNode.expression))
-                return true;
-            break;
-        }
-        case 'PipeChain': {
-            const pipeNode = node;
-            if (pipeNode.head && containsBareReference(pipeNode.head))
-                return true;
-            if (pipeNode.pipes) {
-                for (const pipe of pipeNode.pipes) {
-                    if (containsBareReference(pipe))
-                        return true;
-                }
-            }
-            break;
-        }
-        case 'PostfixExpr': {
-            const postfixNode = node;
-            if (postfixNode.primary && containsBareReference(postfixNode.primary))
-                return true;
-            if (postfixNode.methods) {
-                for (const method of postfixNode.methods) {
-                    if (containsBareReference(method))
-                        return true;
-                }
-            }
-            break;
-        }
-        case 'BinaryExpr': {
-            const binaryNode = node;
-            if (binaryNode.left && containsBareReference(binaryNode.left))
-                return true;
-            if (binaryNode.right && containsBareReference(binaryNode.right))
-                return true;
-            break;
-        }
-        case 'UnaryExpr': {
-            const unaryNode = node;
-            if (unaryNode.operand && containsBareReference(unaryNode.operand))
-                return true;
-            break;
-        }
-        case 'GroupedExpr': {
-            const groupedNode = node;
-            if (groupedNode.expression &&
-                containsBareReference(groupedNode.expression))
-                return true;
-            break;
-        }
-        case 'StringLiteral': {
-            const stringNode = node;
-            if (stringNode.parts) {
-                for (const part of stringNode.parts) {
-                    if (typeof part === 'object' && containsBareReference(part))
-                        return true;
-                }
-            }
-            break;
-        }
-        case 'Interpolation': {
-            const interpNode = node;
-            if (interpNode.expression && containsBareReference(interpNode.expression))
-                return true;
-            break;
-        }
-        case 'Conditional': {
-            const condNode = node;
-            if (condNode.condition && containsBareReference(condNode.condition))
-                return true;
-            if (condNode.thenBranch && containsBareReference(condNode.thenBranch))
-                return true;
-            if (condNode.elseBranch && containsBareReference(condNode.elseBranch))
-                return true;
-            break;
-        }
-        case 'MethodCall':
-        case 'HostCall':
-        case 'ClosureCall':
-        case 'Invoke': {
-            const callNode = node;
-            if (callNode.args) {
-                for (const arg of callNode.args) {
-                    if (containsBareReference(arg))
-                        return true;
-                }
+    let found = false;
+    const ctx = {};
+    visitNode(node, ctx, {
+        enter(n) {
+            if (n.type === 'Variable' && n.isPipeVar) {
+                found = true;
             }
-            break;
-        }
-    }
-    return false;
+        },
+        exit() { },
+    });
+    return found;
 }
 // ============================================================
 // CLOSURE_BRACES RULE
@@ -288,82 +191,63 @@ export const CLOSURE_LATE_BINDING = {
 };
 /**
  * Check if a node contains a closure creation (Closure node).
+ * Uses visitNode for full AST traversal.
  */
 function containsClosureCreation(node) {
-    if (node.type === 'Closure') {
-        return true;
-    }
-    // Recursively check child nodes
-    switch (node.type) {
-        case 'Block': {
-            const blockNode = node;
-            for (const stmt of blockNode.statements) {
-                if (containsClosureCreation(stmt))
-                    return true;
+    let found = false;
+    const ctx = {};
+    visitNode(node, ctx, {
+        enter(n) {
+            if (n.type === 'Closure') {
+                found = true;
             }
-            break;
-        }
-        case 'Statement': {
-            const stmtNode = node;
-            if (stmtNode.expression && containsClosureCreation(stmtNode.expression))
-                return true;
-            break;
-        }
-        case 'PipeChain': {
-            const pipeNode = node;
-            if (pipeNode.head && containsClosureCreation(pipeNode.head))
-                return true;
-            if (pipeNode.pipes) {
-                for (const pipe of pipeNode.pipes) {
-                    if (containsClosureCreation(pipe))
-                        return true;
-                }
-            }
-            break;
-        }
-        case 'PostfixExpr': {
-            const postfixNode = node;
-            if (postfixNode.primary && containsClosureCreation(postfixNode.primary))
-                return true;
-            break;
-        }
-    }
-    return false;
+        },
+        exit() { },
+    });
+    return found;
 }
 /**
- * Check if a Block node contains an explicit capture statement ($ => $name).
+ * Check if a Block node contains an explicit capture statement ($ => $name)
+ * at the top level (closureDepth === 0). Captures inside nested closures
+ * are scoped to that closure and do not fix late binding for the each body.
  */
 function containsExplicitCapture(node) {
     if (node.type !== 'Block') {
         return false;
     }
-    const blockNode = node;
-    const statements = blockNode.statements;
-    // Look for capture of $ into a named variable
-    for (const stmt of statements) {
-        if (stmt.type === 'Statement' &&
-            stmt.expression &&
-            stmt.expression.type === 'PipeChain') {
-            const chain = stmt.expression;
-            // Check if any pipe is a Capture
-            if (chain.pipes && Array.isArray(chain.pipes)) {
-                for (const pipe of chain.pipes) {
-                    if (pipe.type === 'Capture') {
-                        // Check if the head is bare $
-                        const head = chain.head;
-                        if (head && head.type === 'PostfixExpr') {
-                            const postfix = head;
-                            if (postfix.primary && postfix.primary.type === 'Variable') {
-                                const varNode = postfix.primary;
-                                if (varNode.isPipeVar) {
-                                    return true;
-                                }
-                            }
-                        }
-                    }
+    let found = false;
+    let closureDepth = 0;
+    const ctx = {};
+    visitNode(node, ctx, {
+        enter(n) {
+            if (n.type === 'Closure') {
+                closureDepth++;
+                return;
+            }
+            if (closureDepth > 0)
+                return;
+            if (n.type !== 'PipeChain')
+                return;
+            const chain = n;
+            const head = chain.head;
+            if (!head || head.type !== 'PostfixExpr')
+                return;
+            const postfix = head;
+            if (!postfix.primary || postfix.primary.type !== 'Variable')
+                return;
+            if (!postfix.primary.isPipeVar)
+                return;
+            for (const pipe of chain.pipes) {
+                if (pipe.type === 'Capture') {
+                    found = true;
                 }
             }
-        }
-    }
-    return false;
+        },
+        exit(n) {
+            if (n.type === 'Closure') {
+                closureDepth--;
+            }
+        },
+    });
+    return found;
 }

package/dist/check/rules/collections.js

@@ -3,81 +3,26 @@
  * Enforces conventions for each, map, fold, and filter operators.
  */
 import { extractContextLine } from './helpers.js';
+import { visitNode } from '../visitor.js';
 // ============================================================
 // HELPER FUNCTIONS
 // ============================================================
 /**
  * Check if an AST subtree contains a Break node.
- * Recursively traverses all node types.
+ * Uses visitNode for full AST traversal.
  */
 function containsBreak(node) {
-    if (node.type === 'Break') {
-        return true;
-    }
-    // Recursively check children based on node type
-    switch (node.type) {
-        case 'Block':
-            return node.statements.some((stmt) => containsBreak(stmt));
-        case 'Statement':
-            return containsBreak(node.expression);
-        case 'AnnotatedStatement':
-            return containsBreak(node.statement);
-        case 'PipeChain':
-            if (containsBreak(node.head))
-                return true;
-            if (node.pipes.some((pipe) => containsBreak(pipe)))
-                return true;
-            if (node.terminator && node.terminator.type === 'Break')
-                return true;
-            return false;
-        case 'PostfixExpr':
-            if (containsBreak(node.primary))
-                return true;
-            return node.methods.some((method) => containsBreak(method));
-        case 'BinaryExpr':
-            return containsBreak(node.left) || containsBreak(node.right);
-        case 'UnaryExpr':
-            return containsBreak(node.operand);
-        case 'GroupedExpr':
-            return containsBreak(node.expression);
-        case 'Conditional':
-            if (node.input && containsBreak(node.input))
-                return true;
-            if (node.condition && containsBreak(node.condition))
-                return true;
-            if (containsBreak(node.thenBranch))
-                return true;
-            if (node.elseBranch && containsBreak(node.elseBranch))
-                return true;
-            return false;
-        case 'WhileLoop':
-        case 'DoWhileLoop':
-            return containsBreak(node.body);
-        case 'Closure':
-            return containsBreak(node.body);
-        case 'EachExpr':
-        case 'MapExpr':
-        case 'FoldExpr':
-        case 'FilterExpr':
-            return containsBreak(node.body);
-        case 'HostCall':
-        case 'ClosureCall':
-        case 'MethodCall':
-        case 'Invoke':
-        case 'PipeInvoke':
-            return node.args.some((arg) => containsBreak(arg));
-        case 'StringLiteral':
-            return node.parts.some((part) => typeof part !== 'string' && containsBreak(part));
-        case 'TupleLiteral':
-            return node.elements.some((elem) => containsBreak(elem));
-        case 'Dict':
-            return node.entries.some((entry) => containsBreak(entry));
-        case 'DictEntry':
-            return containsBreak(node.value);
-        default:
-            // Leaf nodes and other types don't contain breaks
-            return false;
-    }
+    let found = false;
+    const ctx = {};
+    visitNode(node, ctx, {
+        enter(n) {
+            if (n.type === 'Break') {
+                found = true;
+            }
+        },
+        exit() { },
+    });
+    return found;
 }
 /**
  * Check if a body is a simple method shorthand.

package/dist/check/rules/index.d.ts

@@ -11,7 +11,7 @@ export { USE_DEFAULT_OPERATOR, CONDITION_TYPE } from './conditionals.js';
 export { CLOSURE_BARE_DOLLAR, CLOSURE_BRACES, CLOSURE_LATE_BINDING, } from './closures.js';
 export { UNNECESSARY_ASSERTION, VALIDATE_EXTERNAL } from './types.js';
 export { USE_EMPTY_METHOD } from './strings.js';
-export { AVOID_REASSIGNMENT, COMPLEX_CONDITION, LOOP_OUTER_CAPTURE, } from './anti-patterns.js';
+export { AVOID_REASSIGNMENT, COMPLEX_CONDITION, LOOP_OUTER_CAPTURE, STREAM_PRE_ITERATION, } from './anti-patterns.js';
 export { SPACING_OPERATOR, SPACING_BRACES, SPACING_BRACKETS, SPACING_CLOSURE, INDENT_CONTINUATION, IMPLICIT_DOLLAR_METHOD, IMPLICIT_DOLLAR_FUNCTION, IMPLICIT_DOLLAR_CLOSURE, THROWAWAY_CAPTURE, } from './formatting.js';
 export { USE_DYNAMIC_IDENTIFIER, USE_UNTYPED_HOST_REF, } from './use-expressions.js';
 /**

package/dist/check/rules/index.js

@@ -10,7 +10,7 @@ import { USE_DEFAULT_OPERATOR, CONDITION_TYPE } from './conditionals.js';
 import { CLOSURE_BARE_DOLLAR, CLOSURE_BRACES, CLOSURE_LATE_BINDING, } from './closures.js';
 import { UNNECESSARY_ASSERTION, VALIDATE_EXTERNAL } from './types.js';
 import { USE_EMPTY_METHOD } from './strings.js';
-import { AVOID_REASSIGNMENT, COMPLEX_CONDITION, LOOP_OUTER_CAPTURE, } from './anti-patterns.js';
+import { AVOID_REASSIGNMENT, COMPLEX_CONDITION, LOOP_OUTER_CAPTURE, STREAM_PRE_ITERATION, } from './anti-patterns.js';
 import { SPACING_OPERATOR, SPACING_BRACES, SPACING_BRACKETS, SPACING_CLOSURE, INDENT_CONTINUATION, IMPLICIT_DOLLAR_METHOD, IMPLICIT_DOLLAR_FUNCTION, IMPLICIT_DOLLAR_CLOSURE, THROWAWAY_CAPTURE, } from './formatting.js';
 import { USE_DYNAMIC_IDENTIFIER, USE_UNTYPED_HOST_REF, } from './use-expressions.js';
 // ============================================================
@@ -24,7 +24,7 @@ export { USE_DEFAULT_OPERATOR, CONDITION_TYPE } from './conditionals.js';
 export { CLOSURE_BARE_DOLLAR, CLOSURE_BRACES, CLOSURE_LATE_BINDING, } from './closures.js';
 export { UNNECESSARY_ASSERTION, VALIDATE_EXTERNAL } from './types.js';
 export { USE_EMPTY_METHOD } from './strings.js';
-export { AVOID_REASSIGNMENT, COMPLEX_CONDITION, LOOP_OUTER_CAPTURE, } from './anti-patterns.js';
+export { AVOID_REASSIGNMENT, COMPLEX_CONDITION, LOOP_OUTER_CAPTURE, STREAM_PRE_ITERATION, } from './anti-patterns.js';
 export { SPACING_OPERATOR, SPACING_BRACES, SPACING_BRACKETS, SPACING_CLOSURE, INDENT_CONTINUATION, IMPLICIT_DOLLAR_METHOD, IMPLICIT_DOLLAR_FUNCTION, IMPLICIT_DOLLAR_CLOSURE, THROWAWAY_CAPTURE, } from './formatting.js';
 export { USE_DYNAMIC_IDENTIFIER, USE_UNTYPED_HOST_REF, } from './use-expressions.js';
 // ============================================================
@@ -66,6 +66,7 @@ export const VALIDATION_RULES = [
     AVOID_REASSIGNMENT,
     COMPLEX_CONDITION,
     LOOP_OUTER_CAPTURE,
+    STREAM_PRE_ITERATION,
     // Formatting
     SPACING_OPERATOR,
     SPACING_BRACES,

package/dist/check/visitor.js

@@ -257,6 +257,7 @@ export function visitNode(node, context, visitor) {
         case 'Break':
         case 'Return':
         case 'Pass':
+        case 'Yield':
             // Leaf nodes - no children
             break;
         case 'RecoveryError':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rcrsr/rill-cli",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "CLI tools for the rill scripting language",
   "license": "MIT",
   "author": "Andre Bremer",
@@ -21,8 +21,8 @@
   "dependencies": {
     "dotenv": "^16.0.0",
     "yaml": "^2.8.2",
-    "@rcrsr/rill": "^0.17.0",
-    "@rcrsr/rill-config": "^0.17.0"
+    "@rcrsr/rill": "^0.18.0",
+    "@rcrsr/rill-config": "^0.18.0"
   },
   "files": [
     "dist"