@rcrsr/rill 0.1.0 → 0.2.0

package/dist/check/rules/closures.js

@@ -0,0 +1,373 @@
+/**
+ * Closure Convention Rules
+ * Enforces closure best practices from docs/16_conventions.md:237-286.
+ */
+import { extractContextLine } from './helpers.js';
+// ============================================================
+// CLOSURE_BARE_DOLLAR RULE
+// ============================================================
+/**
+ * Warns on bare $ in stored closures without parameters.
+ * Bare $ in stored closures has ambiguous binding - it refers to the
+ * pipe value at closure invocation time, not definition time.
+ *
+ * Detection:
+ * - Zero-parameter closures (|| { }) used outside dict context
+ * - Body contains bare $ references (VariableNode with name '$')
+ *
+ * Valid patterns:
+ * - Dict closures: [count: ||{ $.items -> .len }]  ($ binds to dict)
+ * - Parameterized closures: |x|{ $x }  (explicit params)
+ * - Inline blocks: -> { $ * 2 }  (immediate evaluation)
+ *
+ * References:
+ * - docs/16_conventions.md:251-261
+ * - docs/06_closures.md: Late binding section
+ */
+export const CLOSURE_BARE_DOLLAR = {
+    code: 'CLOSURE_BARE_DOLLAR',
+    category: 'closures',
+    severity: 'warning',
+    nodeTypes: ['Closure'],
+    validate(node, context) {
+        const closureNode = node;
+        // Only check zero-parameter closures (|| { })
+        if (closureNode.params.length > 0) {
+            return [];
+        }
+        // Check if closure body contains bare $ references
+        const hasBareReference = containsBareReference(closureNode.body);
+        if (hasBareReference) {
+            return [
+                {
+                    location: closureNode.span.start,
+                    severity: 'warning',
+                    code: 'CLOSURE_BARE_DOLLAR',
+                    message: 'Bare $ in stored closure has ambiguous binding. Use explicit capture: $ :> $item',
+                    context: extractContextLine(closureNode.span.start.line, context.source),
+                    fix: null, // Cannot auto-fix safely - requires context understanding
+                },
+            ];
+        }
+        return [];
+    },
+};
+/**
+ * Check if a node tree contains bare $ variable references.
+ * Recursively walks the AST looking for 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 && Array.isArray(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 && Array.isArray(callNode.args)) {
+                for (const arg of callNode.args) {
+                    if (containsBareReference(arg))
+                        return true;
+                }
+            }
+            break;
+        }
+    }
+    return false;
+}
+// ============================================================
+// CLOSURE_BRACES RULE
+// ============================================================
+/**
+ * Enforces braces for complex closure bodies.
+ * Simple expressions can use parentheses, but complex bodies need braces.
+ *
+ * Complex body criteria:
+ * - Contains Block (multiple statements)
+ * - Contains Conditional
+ * - Contains loop constructs
+ *
+ * Simple bodies (parentheses OK):
+ * - Single expression: |x|($x * 2)
+ * - Single method chain: |s|($s.trim.lower)
+ *
+ * Complex bodies (braces required):
+ * - Conditionals: |n| { ($n < 1) ? 1 ! ($n * $fact($n - 1)) }
+ * - Multiple statements: |x| { $x :> $y; $y * 2 }
+ *
+ * References:
+ * - docs/16_conventions.md:239-249
+ */
+export const CLOSURE_BRACES = {
+    code: 'CLOSURE_BRACES',
+    category: 'closures',
+    severity: 'info',
+    nodeTypes: ['Closure'],
+    validate(node, context) {
+        const closureNode = node;
+        const body = closureNode.body;
+        // Check if body is GroupedExpr containing complex content
+        if (body.type === 'GroupedExpr') {
+            const grouped = body;
+            const innerExpr = grouped.expression;
+            // Navigate through PipeChain to find the actual content
+            let content = innerExpr;
+            if (innerExpr && innerExpr.type === 'PipeChain') {
+                const head = innerExpr.head;
+                // Check if head is PostfixExpr
+                if (head && head.type === 'PostfixExpr') {
+                    content = head.primary;
+                }
+                else {
+                    content = head;
+                }
+            }
+            // Check if the content is a conditional or loop
+            const isComplex = content &&
+                (content.type === 'Conditional' ||
+                    content.type === 'WhileLoop' ||
+                    content.type === 'DoWhileLoop');
+            if (isComplex) {
+                return [
+                    {
+                        location: closureNode.span.start,
+                        severity: 'info',
+                        code: 'CLOSURE_BRACES',
+                        message: 'Use braces for complex closure bodies (conditionals, loops)',
+                        context: extractContextLine(closureNode.span.start.line, context.source),
+                        fix: null, // Auto-fix would require AST reconstruction
+                    },
+                ];
+            }
+        }
+        return [];
+    },
+};
+// ============================================================
+// CLOSURE_LATE_BINDING RULE
+// ============================================================
+/**
+ * Detects closures created in loops that may suffer from late binding issues.
+ * When creating closures inside loops, variables are captured by reference,
+ * not by value. This causes all closures to share the final loop value.
+ *
+ * Detection:
+ * - Each loop body creates a Closure node
+ * - Closure references loop variable ($) without explicit capture
+ *
+ * Solution: Explicit capture per iteration:
+ *   [1, 2, 3] -> each {
+ *     $ :> $item
+ *     || { $item }
+ *   }
+ *
+ * References:
+ * - docs/16_conventions.md:251-261
+ * - docs/06_closures.md: Late binding section
+ */
+export const CLOSURE_LATE_BINDING = {
+    code: 'CLOSURE_LATE_BINDING',
+    category: 'closures',
+    severity: 'warning',
+    nodeTypes: ['EachExpr'],
+    validate(node, context) {
+        const eachNode = node;
+        const body = eachNode.body;
+        // Check if body contains a closure creation
+        const hasClosureCreation = containsClosureCreation(body);
+        if (hasClosureCreation) {
+            // Check if there's an explicit capture before the closure
+            const hasExplicitCapture = containsExplicitCapture(body);
+            if (!hasExplicitCapture) {
+                return [
+                    {
+                        location: eachNode.span.start,
+                        severity: 'warning',
+                        code: 'CLOSURE_LATE_BINDING',
+                        message: 'Capture loop variable explicitly for deferred closures: $ :> $item',
+                        context: extractContextLine(eachNode.span.start.line, context.source),
+                        fix: null, // Auto-fix would require AST reconstruction
+                    },
+                ];
+            }
+        }
+        return [];
+    },
+};
+/**
+ * Check if a node contains a closure creation (Closure node).
+ */
+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;
+            }
+            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;
+}
+/**
+ * Check if a Block node contains an explicit capture statement ($ :> $name).
+ */
+function containsExplicitCapture(node) {
+    if (node.type !== 'Block') {
+        return false;
+    }
+    const blockNode = node;
+    const statements = blockNode.statements;
+    if (!Array.isArray(statements)) {
+        return false;
+    }
+    // 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;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=closures.js.map

package/dist/check/rules/closures.js.map

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

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

@@ -0,0 +1,90 @@
+/**
+ * Collection Operator Rules
+ * Enforces conventions for each, map, fold, and filter operators.
+ */
+import type { ValidationRule } from '../types.js';
+/**
+ * Validates that break is not used in parallel operators (map, filter).
+ *
+ * Break is semantically invalid in parallel execution contexts:
+ * - map: executes in parallel, no iteration order
+ * - filter: parallel predicate evaluation
+ *
+ * Break is valid in sequential operators:
+ * - each: sequential iteration with early termination
+ * - fold: sequential reduction (though uncommon)
+ *
+ * Error severity because this is semantically wrong, not just stylistic.
+ *
+ * References:
+ * - docs/16_conventions.md:90-149
+ * - docs/07_collections.md
+ */
+export declare const BREAK_IN_PARALLEL: ValidationRule;
+/**
+ * Suggests using map over each when no side effects are present.
+ *
+ * Map is semantically clearer for pure transformations:
+ * - Signals no side effects (parallel execution)
+ * - Better performance potential
+ * - More functional style
+ *
+ * Detects each expressions where:
+ * - Body doesn't reference accumulator ($@)
+ * - No accumulator initialization
+ * - Body doesn't contain side-effecting operations (host calls, logging)
+ *
+ * This is informational - both work, but map is clearer for pure transforms.
+ *
+ * References:
+ * - docs/16_conventions.md:90-149
+ */
+export declare const PREFER_MAP: ValidationRule;
+/**
+ * Suggests using fold for final-only results, each(init) for running totals.
+ *
+ * Semantic distinction:
+ * - fold: returns final accumulated value only
+ * - each(init): returns list of all intermediate results
+ *
+ * Detects patterns that might benefit from one or the other:
+ * - fold used when intermediate results might be needed
+ * - each(init) used when only final result matters
+ *
+ * This is informational - helps users choose the right operator.
+ *
+ * References:
+ * - docs/16_conventions.md:90-149
+ * - docs/07_collections.md
+ */
+export declare const FOLD_INTERMEDIATES: ValidationRule;
+/**
+ * Validates that negation in filter uses grouped form.
+ *
+ * Grouped negation is clearer and prevents bugs:
+ * - Correct: filter (!.empty)  -- grouped negation
+ * - Wrong:   filter .empty     -- filters for empty elements (likely bug)
+ *
+ * The ungrouped form .empty would return truthy elements,
+ * which is likely not intended when filtering.
+ *
+ * References:
+ * - docs/16_conventions.md:90-149
+ */
+export declare const FILTER_NEGATION: ValidationRule;
+/**
+ * Suggests using method shorthand over block form in collection operators.
+ *
+ * Method shorthand is more concise and clearer:
+ * - Preferred: map .upper
+ * - Verbose:   map { $.upper() }
+ *
+ * Detects block forms that wrap a single method call and suggests shorthand.
+ *
+ * This is informational - both forms work identically.
+ *
+ * References:
+ * - docs/16_conventions.md:90-149
+ */
+export declare const METHOD_SHORTHAND: ValidationRule;
+//# sourceMappingURL=collections.d.ts.map

package/dist/check/rules/collections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../../src/check/rules/collections.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,cAAc,EAGf,MAAM,aAAa,CAAC;AAsLrB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAyB/B,CAAC;AAMF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,UAAU,EAAE,cAuCxB,CAAC;AAMF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAYhC,CAAC;AAMF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,EAAE,cAiC7B,CAAC;AAMF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAiC9B,CAAC"}