@rcrsr/rill 0.1.0 → 0.2.0

package/dist/check/rules/collections.js

@@ -0,0 +1,373 @@
+/**
+ * Collection Operator Rules
+ * Enforces conventions for each, map, fold, and filter operators.
+ */
+import { extractContextLine } from './helpers.js';
+// ============================================================
+// HELPER FUNCTIONS
+// ============================================================
+/**
+ * Check if an AST subtree contains a Break node.
+ * Recursively traverses all node types.
+ */
+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 'Tuple':
+            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;
+    }
+}
+/**
+ * Check if a body is a simple method shorthand.
+ * Body structure for .method shorthand is PostfixExpr with MethodCall as primary.
+ * Examples: .upper, .len, .trim
+ */
+function isMethodShorthand(body) {
+    if (body.type !== 'PostfixExpr')
+        return false;
+    return body.primary.type === 'MethodCall';
+}
+/**
+ * Check if a body is a block wrapping a single method call on $.
+ * Example: { $.upper() } when it could be .upper
+ * Structure: Block -> Statement -> PipeChain -> PostfixExpr($) with methods
+ */
+function isBlockWrappingMethod(body) {
+    if (body.type !== 'Block')
+        return false;
+    if (body.statements.length !== 1)
+        return false;
+    const stmt = body.statements[0];
+    if (!stmt || stmt.type !== 'Statement')
+        return false;
+    const expr = stmt.expression;
+    if (expr.type !== 'PipeChain')
+        return false;
+    // Should have no pipes (direct method call on head)
+    if (expr.pipes.length !== 0)
+        return false;
+    const head = expr.head;
+    if (head.type !== 'PostfixExpr')
+        return false;
+    // Primary should be pipe variable ($)
+    if (head.primary.type !== 'Variable')
+        return false;
+    const variable = head.primary;
+    if (!('isPipeVar' in variable) || !variable.isPipeVar)
+        return false;
+    // Should have exactly one method in the methods array
+    if (head.methods.length !== 1)
+        return false;
+    if (head.methods[0]?.type !== 'MethodCall')
+        return false;
+    return true;
+}
+/**
+ * Get method name from iterator body.
+ * Handles both PostfixExpr (shorthand) and BlockNode (wrapped) forms.
+ */
+function getMethodName(body) {
+    // Shorthand form: PostfixExpr with MethodCall primary
+    if (body.type === 'PostfixExpr' && body.primary.type === 'MethodCall') {
+        return body.primary.name;
+    }
+    // Block form: $.method()
+    if (isBlockWrappingMethod(body)) {
+        const stmt = body.statements[0];
+        if (!stmt || stmt.type !== 'Statement')
+            return null;
+        const expr = stmt.expression;
+        if (expr.type !== 'PipeChain')
+            return null;
+        const head = expr.head;
+        if (head.type !== 'PostfixExpr')
+            return null;
+        const method = head.methods[0];
+        if (method && method.type === 'MethodCall') {
+            return method.name;
+        }
+    }
+    return null;
+}
+// ============================================================
+// BREAK_IN_PARALLEL RULE
+// ============================================================
+/**
+ * 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 const BREAK_IN_PARALLEL = {
+    code: 'BREAK_IN_PARALLEL',
+    category: 'collections',
+    severity: 'error',
+    nodeTypes: ['MapExpr', 'FilterExpr'],
+    validate(node, context) {
+        const collectionExpr = node;
+        const operatorName = node.type === 'MapExpr' ? 'map' : 'filter';
+        if (containsBreak(collectionExpr.body)) {
+            return [
+                {
+                    location: node.span.start,
+                    severity: 'error',
+                    code: 'BREAK_IN_PARALLEL',
+                    message: `Break not allowed in '${operatorName}' (parallel operator). Use 'each' for sequential iteration with break.`,
+                    context: extractContextLine(node.span.start.line, context.source),
+                    fix: null, // Cannot auto-fix operator replacement
+                },
+            ];
+        }
+        return [];
+    },
+};
+// ============================================================
+// PREFER_MAP RULE
+// ============================================================
+/**
+ * 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 const PREFER_MAP = {
+    code: 'PREFER_MAP',
+    category: 'collections',
+    severity: 'info',
+    nodeTypes: ['EachExpr'],
+    validate(node, context) {
+        const eachExpr = node;
+        // If accumulator is present, each is correct choice
+        if (eachExpr.accumulator !== null) {
+            return [];
+        }
+        // Check if body is a closure with accumulator parameter
+        if (eachExpr.body.type === 'Closure') {
+            const closure = eachExpr.body;
+            const hasAccumulator = closure.params.length > 1;
+            if (hasAccumulator) {
+                return [];
+            }
+        }
+        // Simple heuristic: if body is pure (no side effects), suggest map
+        // For now, suggest map for simple transformations
+        // Full implementation would check for host calls, logging, etc.
+        return [
+            {
+                location: node.span.start,
+                severity: 'info',
+                code: 'PREFER_MAP',
+                message: "Consider using 'map' instead of 'each' for pure transformations (no side effects)",
+                context: extractContextLine(node.span.start.line, context.source),
+                fix: null, // Could generate fix by replacing 'each' with 'map'
+            },
+        ];
+    },
+};
+// ============================================================
+// FOLD_INTERMEDIATES RULE
+// ============================================================
+/**
+ * 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 const FOLD_INTERMEDIATES = {
+    code: 'FOLD_INTERMEDIATES',
+    category: 'collections',
+    severity: 'info',
+    nodeTypes: ['EachExpr', 'FoldExpr'],
+    validate(_node, _context) {
+        // This rule is informational and would require flow analysis
+        // to detect whether intermediate values are used.
+        // Placeholder for future implementation.
+        return [];
+    },
+};
+// ============================================================
+// FILTER_NEGATION RULE
+// ============================================================
+/**
+ * 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 const FILTER_NEGATION = {
+    code: 'FILTER_NEGATION',
+    category: 'collections',
+    severity: 'warning',
+    nodeTypes: ['FilterExpr'],
+    validate(node, context) {
+        const filterExpr = node;
+        const body = filterExpr.body;
+        // Check if body is a simple method call (ungrouped)
+        if (isMethodShorthand(body)) {
+            const methodName = getMethodName(body);
+            // Check if method is likely a negation-intended method
+            // Common methods that might indicate user wants to negate:
+            // .empty, .is_match, etc.
+            if (methodName === 'empty') {
+                return [
+                    {
+                        location: node.span.start,
+                        severity: 'warning',
+                        code: 'FILTER_NEGATION',
+                        message: `Filter with '.${methodName}' likely unintended. Use grouped negation: 'filter (!.${methodName})' to filter non-${methodName} elements`,
+                        context: extractContextLine(node.span.start.line, context.source),
+                        fix: null, // Could generate fix wrapping in (!...)
+                    },
+                ];
+            }
+        }
+        return [];
+    },
+};
+// ============================================================
+// METHOD_SHORTHAND RULE
+// ============================================================
+/**
+ * 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 const METHOD_SHORTHAND = {
+    code: 'METHOD_SHORTHAND',
+    category: 'collections',
+    severity: 'info',
+    nodeTypes: ['EachExpr', 'MapExpr', 'FoldExpr', 'FilterExpr'],
+    validate(node, context) {
+        const collectionNode = node;
+        const body = collectionNode.body;
+        if (isBlockWrappingMethod(body)) {
+            const methodName = getMethodName(body);
+            if (methodName) {
+                return [
+                    {
+                        location: node.span.start,
+                        severity: 'info',
+                        code: 'METHOD_SHORTHAND',
+                        message: `Prefer method shorthand '.${methodName}' over block form '{ $.${methodName}() }'`,
+                        context: extractContextLine(node.span.start.line, context.source),
+                        fix: null, // Could generate fix replacing block with .method
+                    },
+                ];
+            }
+        }
+        return [];
+    },
+};
+//# sourceMappingURL=collections.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collections.js","sourceRoot":"","sources":["../../../src/check/rules/collections.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAgBH,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD,+DAA+D;AAC/D,mBAAmB;AACnB,+DAA+D;AAE/D;;;GAGG;AACH,SAAS,aAAa,CAAC,IAAa;IAClC,IAAI,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,gDAAgD;IAChD,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,OAAO;YACV,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC;QAE7D,KAAK,WAAW;YACd,OAAO,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAExC,KAAK,oBAAoB;YACvB,OAAO,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAEvC,KAAK,WAAW;YACd,IAAI,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC;gBAAE,OAAO,IAAI,CAAC;YAC1C,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,aAAa,CAAC,IAAe,CAAC,CAAC;gBAC3D,OAAO,IAAI,CAAC;YACd,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,KAAK,OAAO;gBAAE,OAAO,IAAI,CAAC;YACrE,OAAO,KAAK,CAAC;QAEf,KAAK,aAAa;YAChB,IAAI,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC;gBAAE,OAAO,IAAI,CAAC;YAC7C,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;QAE9D,KAAK,YAAY;YACf,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE/D,KAAK,WAAW;YACd,OAAO,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAErC,KAAK,aAAa;YAChB,OAAO,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAExC,KAAK,aAAa;YAChB,IAAI,IAAI,CAAC,KAAK,IAAI,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC;gBAAE,OAAO,IAAI,CAAC;YACzD,IAAI,IAAI,CAAC,SAAS,IAAI,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC;gBAAE,OAAO,IAAI,CAAC;YACjE,IAAI,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC;gBAAE,OAAO,IAAI,CAAC;YAChD,IAAI,IAAI,CAAC,UAAU,IAAI,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC;gBAAE,OAAO,IAAI,CAAC;YACnE,OAAO,KAAK,CAAC;QAEf,KAAK,WAAW,CAAC;QACjB,KAAK,aAAa;YAChB,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAElC,KAAK,SAAS;YACZ,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAElC,KAAK,UAAU,CAAC;QAChB,KAAK,SAAS,CAAC;QACf,KAAK,UAAU,CAAC;QAChB,KAAK,YAAY;YACf,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAElC,KAAK,UAAU,CAAC;QAChB,KAAK,aAAa,CAAC;QACnB,KAAK,YAAY,CAAC;QAClB,KAAK,QAAQ,CAAC;QACd,KAAK,YAAY;YACf,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC;QAErD,KAAK,eAAe;YAClB,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CACpB,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,IAAI,KAAK,QAAQ,IAAI,aAAa,CAAC,IAAI,CAAC,CAC1D,CAAC;QAEJ,KAAK,OAAO;YACV,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC,CAAC;QAE3D,KAAK,MAAM;YACT,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;QAE5D,KAAK,WAAW;YACd,OAAO,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAEnC;YACE,kDAAkD;YAClD,OAAO,KAAK,CAAC;IACjB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,SAAS,iBAAiB,CAAC,IAAkB;IAC3C,IAAI,IAAI,CAAC,IAAI,KAAK,aAAa;QAAE,OAAO,KAAK,CAAC;IAC9C,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,YAAY,CAAC;AAC5C,CAAC;AAED;;;;GAIG;AACH,SAAS,qBAAqB,CAC5B,IAAkB;IAElB,IAAI,IAAI,CAAC,IAAI,KAAK,OAAO;QAAE,OAAO,KAAK,CAAC;IACxC,IAAI,IAAI,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAE/C,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAChC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW;QAAE,OAAO,KAAK,CAAC;IAErD,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC;IAC7B,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW;QAAE,OAAO,KAAK,CAAC;IAE5C,oDAAoD;IACpD,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAE1C,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IACvB,IAAI,IAAI,CAAC,IAAI,KAAK,aAAa;QAAE,OAAO,KAAK,CAAC;IAE9C,sCAAsC;IACtC,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,UAAU;QAAE,OAAO,KAAK,CAAC;IACnD,MAAM,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC;IAC9B,IAAI,CAAC,CAAC,WAAW,IAAI,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS;QAAE,OAAO,KAAK,CAAC;IAEpE,sDAAsD;IACtD,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,KAAK,CAAC;IAC5C,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,KAAK,YAAY;QAAE,OAAO,KAAK,CAAC;IAEzD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,SAAS,aAAa,CAAC,IAAkB;IACvC,sDAAsD;IACtD,IAAI,IAAI,CAAC,IAAI,KAAK,aAAa,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;QACtE,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC;IAC3B,CAAC;IAED,yBAAyB;IACzB,IAAI,qBAAqB,CAAC,IAAI,CAAC,EAAE,CAAC;QAChC,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;QAChC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW;YAAE,OAAO,IAAI,CAAC;QAEpD,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC;QAC7B,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW;YAAE,OAAO,IAAI,CAAC;QAE3C,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACvB,IAAI,IAAI,CAAC,IAAI,KAAK,aAAa;YAAE,OAAO,IAAI,CAAC;QAE7C,MAAM,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QAC/B,IAAI,MAAM,IAAI,MAAM,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;YAC3C,OAAO,MAAM,CAAC,IAAI,CAAC;QACrB,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,+DAA+D;AAC/D,yBAAyB;AACzB,+DAA+D;AAE/D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAmB;IAC/C,IAAI,EAAE,mBAAmB;IACzB,QAAQ,EAAE,aAAa;IACvB,QAAQ,EAAE,OAAO;IACjB,SAAS,EAAE,CAAC,SAAS,EAAE,YAAY,CAAC;IAEpC,QAAQ,CAAC,IAAa,EAAE,OAA0B;QAChD,MAAM,cAAc,GAAG,IAAoC,CAAC;QAC5D,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC;QAEhE,IAAI,aAAa,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,CAAC;YACvC,OAAO;gBACL;oBACE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK;oBACzB,QAAQ,EAAE,OAAO;oBACjB,IAAI,EAAE,mBAAmB;oBACzB,OAAO,EAAE,yBAAyB,YAAY,wEAAwE;oBACtH,OAAO,EAAE,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC;oBACjE,GAAG,EAAE,IAAI,EAAE,uCAAuC;iBACnD;aACF,CAAC;QACJ,CAAC;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;CACF,CAAC;AAEF,+DAA+D;AAC/D,kBAAkB;AAClB,+DAA+D;AAE/D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,UAAU,GAAmB;IACxC,IAAI,EAAE,YAAY;IAClB,QAAQ,EAAE,aAAa;IACvB,QAAQ,EAAE,MAAM;IAChB,SAAS,EAAE,CAAC,UAAU,CAAC;IAEvB,QAAQ,CAAC,IAAa,EAAE,OAA0B;QAChD,MAAM,QAAQ,GAAG,IAAoB,CAAC;QAEtC,oDAAoD;QACpD,IAAI,QAAQ,CAAC,WAAW,KAAK,IAAI,EAAE,CAAC;YAClC,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,wDAAwD;QACxD,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YACrC,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,CAAC;YAC9B,MAAM,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;YACjD,IAAI,cAAc,EAAE,CAAC;gBACnB,OAAO,EAAE,CAAC;YACZ,CAAC;QACH,CAAC;QAED,mEAAmE;QACnE,kDAAkD;QAClD,gEAAgE;QAEhE,OAAO;YACL;gBACE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK;gBACzB,QAAQ,EAAE,MAAM;gBAChB,IAAI,EAAE,YAAY;gBAClB,OAAO,EACL,mFAAmF;gBACrF,OAAO,EAAE,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC;gBACjE,GAAG,EAAE,IAAI,EAAE,oDAAoD;aAChE;SACF,CAAC;IACJ,CAAC;CACF,CAAC;AAEF,+DAA+D;AAC/D,0BAA0B;AAC1B,+DAA+D;AAE/D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAmB;IAChD,IAAI,EAAE,oBAAoB;IAC1B,QAAQ,EAAE,aAAa;IACvB,QAAQ,EAAE,MAAM;IAChB,SAAS,EAAE,CAAC,UAAU,EAAE,UAAU,CAAC;IAEnC,QAAQ,CAAC,KAAc,EAAE,QAA2B;QAClD,6DAA6D;QAC7D,kDAAkD;QAClD,yCAAyC;QACzC,OAAO,EAAE,CAAC;IACZ,CAAC;CACF,CAAC;AAEF,+DAA+D;AAC/D,uBAAuB;AACvB,+DAA+D;AAE/D;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,eAAe,GAAmB;IAC7C,IAAI,EAAE,iBAAiB;IACvB,QAAQ,EAAE,aAAa;IACvB,QAAQ,EAAE,SAAS;IACnB,SAAS,EAAE,CAAC,YAAY,CAAC;IAEzB,QAAQ,CAAC,IAAa,EAAE,OAA0B;QAChD,MAAM,UAAU,GAAG,IAAsB,CAAC;QAC1C,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;QAE7B,oDAAoD;QACpD,IAAI,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC;YAC5B,MAAM,UAAU,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;YAEvC,uDAAuD;YACvD,2DAA2D;YAC3D,0BAA0B;YAC1B,IAAI,UAAU,KAAK,OAAO,EAAE,CAAC;gBAC3B,OAAO;oBACL;wBACE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK;wBACzB,QAAQ,EAAE,SAAS;wBACnB,IAAI,EAAE,iBAAiB;wBACvB,OAAO,EAAE,iBAAiB,UAAU,yDAAyD,UAAU,oBAAoB,UAAU,WAAW;wBAChJ,OAAO,EAAE,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC;wBACjE,GAAG,EAAE,IAAI,EAAE,wCAAwC;qBACpD;iBACF,CAAC;YACJ,CAAC;QACH,CAAC;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;CACF,CAAC;AAEF,+DAA+D;AAC/D,wBAAwB;AACxB,+DAA+D;AAE/D;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAmB;IAC9C,IAAI,EAAE,kBAAkB;IACxB,QAAQ,EAAE,aAAa;IACvB,QAAQ,EAAE,MAAM;IAChB,SAAS,EAAE,CAAC,UAAU,EAAE,SAAS,EAAE,UAAU,EAAE,YAAY,CAAC;IAE5D,QAAQ,CAAC,IAAa,EAAE,OAA0B;QAChD,MAAM,cAAc,GAAG,IAIL,CAAC;QACnB,MAAM,IAAI,GAAG,cAAc,CAAC,IAAI,CAAC;QAEjC,IAAI,qBAAqB,CAAC,IAAI,CAAC,EAAE,CAAC;YAChC,MAAM,UAAU,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;YAEvC,IAAI,UAAU,EAAE,CAAC;gBACf,OAAO;oBACL;wBACE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK;wBACzB,QAAQ,EAAE,MAAM;wBAChB,IAAI,EAAE,kBAAkB;wBACxB,OAAO,EAAE,6BAA6B,UAAU,0BAA0B,UAAU,OAAO;wBAC3F,OAAO,EAAE,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC;wBACjE,GAAG,EAAE,IAAI,EAAE,kDAAkD;qBAC9D;iBACF,CAAC;YACJ,CAAC;QACH,CAAC;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;CACF,CAAC"}

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

@@ -0,0 +1,41 @@
+/**
+ * Conditional Convention Rules
+ * Enforces conventions for conditional expressions.
+ */
+import type { ValidationRule } from '../types.js';
+/**
+ * Suggests using ?? for defaults instead of verbose conditionals.
+ *
+ * The ?? operator is more concise for providing default values:
+ *
+ * Good (concise default):
+ *   $dict.field ?? "default"
+ *
+ * Avoid (verbose conditional):
+ *   $dict.?field ? $dict.field ! "default"
+ *
+ * This is informational - both patterns work identically.
+ *
+ * References:
+ * - docs/16_conventions.md:219-234
+ */
+export declare const USE_DEFAULT_OPERATOR: ValidationRule;
+/**
+ * Validates that conditional conditions evaluate to boolean.
+ *
+ * Rill requires explicit boolean conditions in conditionals.
+ * The condition in `cond ? then ! else` must evaluate to boolean.
+ *
+ * Correct (boolean condition):
+ *   "hello" -> .contains("ell") ? "found" ! "not found"
+ *
+ * Incorrect (non-boolean):
+ *   "hello" ? "has value" ! "empty"  # strings don't auto-convert to boolean
+ *
+ * This is a warning because it's likely a bug, not just stylistic.
+ *
+ * References:
+ * - docs/16_conventions.md:199-215
+ */
+export declare const CONDITION_TYPE: ValidationRule;
+//# sourceMappingURL=conditionals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conditionals.d.ts","sourceRoot":"","sources":["../../../src/check/rules/conditionals.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,cAAc,EAGf,MAAM,aAAa,CAAC;AAiCrB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB,EAAE,cA0BlC,CAAC;AAMF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,cAAc,EAAE,cAkB5B,CAAC"}

package/dist/check/rules/conditionals.js

@@ -0,0 +1,106 @@
+/**
+ * Conditional Convention Rules
+ * Enforces conventions for conditional expressions.
+ */
+import { extractContextLine } from './helpers.js';
+// ============================================================
+// HELPER FUNCTIONS
+// ============================================================
+/**
+ * Check if a conditional is using the ?? pattern with .? check.
+ * Pattern: $dict.?field ? $dict.field ! "default"
+ * This should be simplified to: $dict.field ?? "default"
+ */
+function isVerboseDefaultPattern(node) {
+    // Check if condition is an existence check (.?field)
+    if (!node.condition)
+        return false;
+    // Simple heuristic: check if condition contains existence check
+    const conditionStr = JSON.stringify(node.condition);
+    if (!conditionStr.includes('"existenceCheck"')) {
+        return false;
+    }
+    // Check if there's an else branch (required for default pattern)
+    if (!node.elseBranch)
+        return false;
+    return true;
+}
+// ============================================================
+// USE_DEFAULT_OPERATOR RULE
+// ============================================================
+/**
+ * Suggests using ?? for defaults instead of verbose conditionals.
+ *
+ * The ?? operator is more concise for providing default values:
+ *
+ * Good (concise default):
+ *   $dict.field ?? "default"
+ *
+ * Avoid (verbose conditional):
+ *   $dict.?field ? $dict.field ! "default"
+ *
+ * This is informational - both patterns work identically.
+ *
+ * References:
+ * - docs/16_conventions.md:219-234
+ */
+export const USE_DEFAULT_OPERATOR = {
+    code: 'USE_DEFAULT_OPERATOR',
+    category: 'conditionals',
+    severity: 'info',
+    nodeTypes: ['Conditional'],
+    validate(node, context) {
+        const conditional = node;
+        // Check for verbose default pattern
+        if (isVerboseDefaultPattern(conditional)) {
+            return [
+                {
+                    location: node.span.start,
+                    severity: 'info',
+                    code: 'USE_DEFAULT_OPERATOR',
+                    message: 'Use ?? for defaults instead of conditionals: $dict.field ?? "default"',
+                    context: extractContextLine(node.span.start.line, context.source),
+                    fix: null, // Complex fix - requires AST restructuring
+                },
+            ];
+        }
+        return [];
+    },
+};
+// ============================================================
+// CONDITION_TYPE RULE
+// ============================================================
+/**
+ * Validates that conditional conditions evaluate to boolean.
+ *
+ * Rill requires explicit boolean conditions in conditionals.
+ * The condition in `cond ? then ! else` must evaluate to boolean.
+ *
+ * Correct (boolean condition):
+ *   "hello" -> .contains("ell") ? "found" ! "not found"
+ *
+ * Incorrect (non-boolean):
+ *   "hello" ? "has value" ! "empty"  # strings don't auto-convert to boolean
+ *
+ * This is a warning because it's likely a bug, not just stylistic.
+ *
+ * References:
+ * - docs/16_conventions.md:199-215
+ */
+export const CONDITION_TYPE = {
+    code: 'CONDITION_TYPE',
+    category: 'conditionals',
+    severity: 'warning',
+    nodeTypes: ['Conditional'],
+    validate(_node, _context) {
+        // Rill conditionals don't enforce boolean type checking at the static analysis level
+        // The language allows truthy/falsy semantics, and runtime will handle type errors
+        // This rule is disabled for now - the convention is informational only
+        // Note: If we wanted to enforce this, we would need to check:
+        // - When condition is null: input is the tested value (truthy check)
+        // - When condition exists: condition body must evaluate to boolean
+        // For now, return no diagnostics
+        return [];
+    },
+};
+//# sourceMappingURL=conditionals.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conditionals.js","sourceRoot":"","sources":["../../../src/check/rules/conditionals.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAQH,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AAElD,+DAA+D;AAC/D,mBAAmB;AACnB,+DAA+D;AAE/D;;;;GAIG;AACH,SAAS,uBAAuB,CAAC,IAAqB;IACpD,qDAAqD;IACrD,IAAI,CAAC,IAAI,CAAC,SAAS;QAAE,OAAO,KAAK,CAAC;IAElC,gEAAgE;IAChE,MAAM,YAAY,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IACpD,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;QAC/C,OAAO,KAAK,CAAC;IACf,CAAC;IAED,iEAAiE;IACjE,IAAI,CAAC,IAAI,CAAC,UAAU;QAAE,OAAO,KAAK,CAAC;IAEnC,OAAO,IAAI,CAAC;AACd,CAAC;AAED,+DAA+D;AAC/D,4BAA4B;AAC5B,+DAA+D;AAE/D;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAmB;IAClD,IAAI,EAAE,sBAAsB;IAC5B,QAAQ,EAAE,cAAc;IACxB,QAAQ,EAAE,MAAM;IAChB,SAAS,EAAE,CAAC,aAAa,CAAC;IAE1B,QAAQ,CAAC,IAAa,EAAE,OAA0B;QAChD,MAAM,WAAW,GAAG,IAAuB,CAAC;QAE5C,oCAAoC;QACpC,IAAI,uBAAuB,CAAC,WAAW,CAAC,EAAE,CAAC;YACzC,OAAO;gBACL;oBACE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,KAAK;oBACzB,QAAQ,EAAE,MAAM;oBAChB,IAAI,EAAE,sBAAsB;oBAC5B,OAAO,EACL,uEAAuE;oBACzE,OAAO,EAAE,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC;oBACjE,GAAG,EAAE,IAAI,EAAE,2CAA2C;iBACvD;aACF,CAAC;QACJ,CAAC;QAED,OAAO,EAAE,CAAC;IACZ,CAAC;CACF,CAAC;AAEF,+DAA+D;AAC/D,sBAAsB;AACtB,+DAA+D;AAE/D;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAmB;IAC5C,IAAI,EAAE,gBAAgB;IACtB,QAAQ,EAAE,cAAc;IACxB,QAAQ,EAAE,SAAS;IACnB,SAAS,EAAE,CAAC,aAAa,CAAC;IAE1B,QAAQ,CAAC,KAAc,EAAE,QAA2B;QAClD,qFAAqF;QACrF,kFAAkF;QAClF,uEAAuE;QAEvE,8DAA8D;QAC9D,qEAAqE;QACrE,mEAAmE;QAEnE,iCAAiC;QACjC,OAAO,EAAE,CAAC;IACZ,CAAC;CACF,CAAC"}

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

@@ -0,0 +1,46 @@
+/**
+ * Flow and Capture Rules
+ * Enforces conventions for capture placement and flow patterns.
+ */
+import type { ValidationRule } from '../types.js';
+/**
+ * Validates that captures use inline syntax when continuing the chain.
+ *
+ * Detects separate capture followed by variable usage:
+ *   prompt("Read file") :> $raw
+ *   $raw -> log
+ *
+ * Suggests inline capture:
+ *   prompt("Read file") :> $raw -> log
+ *
+ * This is an informational rule - both patterns work, but inline is clearer.
+ *
+ * References:
+ * - docs/16_conventions.md:56-74
+ */
+export declare const CAPTURE_INLINE_CHAIN: ValidationRule;
+/**
+ * Validates that values used in multiple branches are captured before the conditional.
+ *
+ * Detects conditionals where a function call or expression appears in multiple branches:
+ *   checkStatus() -> .contains("OK") ? {
+ *     "Success: {checkStatus()}"
+ *   } ! {
+ *     "Failed: {checkStatus()}"
+ *   }
+ *
+ * Suggests capturing before branching:
+ *   checkStatus() :> $result
+ *   $result -> .contains("OK") ? {
+ *     "Success: {$result}"
+ *   } ! {
+ *     "Failed: {$result}"
+ *   }
+ *
+ * This is an informational rule - detects potential inefficiency and clarity issues.
+ *
+ * References:
+ * - docs/16_conventions.md:76-88
+ */
+export declare const CAPTURE_BEFORE_BRANCH: ValidationRule;
+//# sourceMappingURL=flow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flow.d.ts","sourceRoot":"","sources":["../../../src/check/rules/flow.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EACV,cAAc,EAGf,MAAM,aAAa,CAAC;AAsErB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,oBAAoB,EAAE,cA0ElC,CAAC;AAMF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAgEnC,CAAC"}