@malloydata/malloy 0.0.384 → 0.0.386

package/dist/lang/prettify/pick-case.js

@@ -0,0 +1,222 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * RULE: PICK — formatPickStatement / formatPickAligned / formatPick
+ *
+ *   pickStatement: pick+ (ELSE pickElse=fieldExpr)?
+ *
+ * Inline if the whole thing fits. Otherwise:
+ *   - each pick on its own line at +1 indent
+ *   - column-align WHEN across picks (pad shorter values)
+ *   - else aligns with `pick` (no value padding for else)
+ *   - if a single pick still doesn't fit when aligned, break that pick at WHEN
+ *     onto two lines.
+ *
+ * RULE: CASE — formatCaseStatement / formatCaseWhen
+ *
+ *   caseStatement: CASE valueExpr? (caseWhen)+ (ELSE caseElse)? END
+ *
+ * Inline if it fits. Otherwise:
+ *   case [valueExpr]
+ *     when COND_A   then RESULT_A
+ *     when LONGCOND then RESULT_B
+ *     else FALLBACK
+ *   end
+ * THEN keyword column-aligns across whens (pad shorter conditions). ELSE/END
+ * live at the case's own indent. If an aligned when still overflows, break it
+ * at THEN onto two lines.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatPickStatement = formatPickStatement;
+exports.formatPick = formatPick;
+exports.formatCaseStatement = formatCaseStatement;
+const tree_1 = require("antlr4ts/tree");
+const parser = __importStar(require("../lib/Malloy/MalloyParser"));
+const tokens_1 = require("./tokens");
+const leaf_1 = require("./leaf");
+const inline_renderer_1 = require("./inline-renderer");
+function formatPickStatement(f, ctx) {
+    const startIdx = ctx._start.tokenIndex;
+    const stopIdx = ctx._stop.tokenIndex;
+    const inlineLen = (0, leaf_1.approxInlineSpan)(f, startIdx, stopIdx);
+    const hasComments = (0, leaf_1.hasCommentsInRange)(f, startIdx, stopIdx);
+    if (!hasComments && f.o.lineLengthSoFar() + 1 + inlineLen <= tokens_1.LINE_BUDGET) {
+        for (let i = 0; i < ctx.childCount; i++)
+            f.format(ctx.getChild(i));
+        return;
+    }
+    const picks = ctx.pick();
+    const elseTok = ctx.ELSE();
+    const elseExpr = ctx.fieldExpr();
+    const valueStrs = picks.map(p => p._pickValue ? (0, inline_renderer_1.renderItemInline)(f, p._pickValue) : '');
+    const maxValueLen = valueStrs.reduce((m, s) => Math.max(m, s.length), 0);
+    // Use flushHiddenBefore (the leaf walker's emitter) to flush gap comments
+    // between picks. Critical: it advances f.lastEmittedIdx, so when the next
+    // pick takes the broken-at-WHEN form (which goes through f.format → emit-
+    // VisibleToken → flushHiddenBefore), the gap won't be re-emitted.
+    f.o.indent++;
+    for (let i = 0; i < picks.length; i++) {
+        (0, leaf_1.flushHiddenBefore)(f, picks[i]._start.tokenIndex);
+        f.o.nl();
+        formatPickAligned(f, picks[i], maxValueLen);
+    }
+    if (elseTok && elseExpr) {
+        (0, leaf_1.flushHiddenBefore)(f, elseTok.symbol.tokenIndex);
+        f.o.nl();
+        f.format(elseTok);
+        f.format(elseExpr);
+    }
+    f.o.indent--;
+}
+function formatPickAligned(f, pick, maxValueLen) {
+    const valueStr = pick._pickValue ? (0, inline_renderer_1.renderItemInline)(f, pick._pickValue) : '';
+    const condStr = (0, inline_renderer_1.renderItemInline)(f, pick._pickWhen);
+    const padding = ' '.repeat(maxValueLen - valueStr.length);
+    const aligned = valueStr
+        ? `pick ${valueStr}${padding} when ${condStr}`
+        : `pick${padding ? ' ' + padding : ''} when ${condStr}`;
+    // Aligned form drops comments (renderItemInline skips them). If this pick
+    // has internal comments, fall through to the broken-at-WHEN form which uses
+    // f.format() and preserves them.
+    const hasComments = (0, leaf_1.hasCommentsInRange)(f, pick._start.tokenIndex, pick._stop.tokenIndex);
+    if (!hasComments && f.o.lineLengthSoFar() + aligned.length <= tokens_1.LINE_BUDGET) {
+        // Aligned form: emit as a single pre-rendered string so the spacing
+        // between value and `when` is exact regardless of padding width.
+        f.o.text(aligned);
+        (0, leaf_1.note)(f, pick._stop.type, pick._stop.tokenIndex, pick._stop);
+        return;
+    }
+    // Doesn't fit even aligned — break at WHEN, no padding.
+    f.format(pick.PICK());
+    if (pick._pickValue)
+        f.format(pick._pickValue);
+    // Flush hidden tokens between value and WHEN BEFORE the line break, so
+    // same-line comments stay attached to the value's line and the formatted
+    // output is idempotent on a re-parse.
+    (0, leaf_1.flushHiddenBefore)(f, pick.WHEN().symbol.tokenIndex);
+    f.o.nl();
+    f.format(pick.WHEN());
+    f.format(pick._pickWhen);
+}
+// pick: PICK pickValue? WHEN pickWhen
+// Inline if fits; otherwise break at WHEN. (Used when this pick is dispatched
+// outside of a pickStatement context, which is rare but possible.)
+function formatPick(f, ctx) {
+    const inlineLen = (0, leaf_1.approxInlineSpan)(f, ctx._start.tokenIndex, ctx._stop.tokenIndex);
+    if (f.o.lineLengthSoFar() + 1 + inlineLen <= tokens_1.LINE_BUDGET) {
+        for (let i = 0; i < ctx.childCount; i++)
+            f.format(ctx.getChild(i));
+        return;
+    }
+    for (let i = 0; i < ctx.childCount; i++) {
+        const c = ctx.getChild(i);
+        if (c instanceof tree_1.TerminalNode && c.symbol.type === tokens_1.L.WHEN) {
+            // Flush any hidden tokens between the previous child and WHEN before
+            // the line break, so same-line comments stay attached.
+            (0, leaf_1.flushHiddenBefore)(f, c.symbol.tokenIndex);
+            f.o.nl();
+        }
+        f.format(c);
+    }
+}
+function formatCaseStatement(f, ctx) {
+    const startIdx = ctx._start.tokenIndex;
+    const stopIdx = ctx._stop.tokenIndex;
+    const inlineLen = (0, leaf_1.approxInlineSpan)(f, startIdx, stopIdx);
+    const hasComments = (0, leaf_1.hasCommentsInRange)(f, startIdx, stopIdx);
+    if (!hasComments && f.o.lineLengthSoFar() + 1 + inlineLen <= tokens_1.LINE_BUDGET) {
+        for (let i = 0; i < ctx.childCount; i++)
+            f.format(ctx.getChild(i));
+        return;
+    }
+    const whens = ctx.caseWhen();
+    const condStrs = whens.map(w => (0, inline_renderer_1.renderItemInline)(f, w._condition));
+    const maxCondLen = condStrs.reduce((m, s) => Math.max(m, s.length), 0);
+    f.o.indent++;
+    for (let i = 0; i < ctx.childCount; i++) {
+        const c = ctx.getChild(i);
+        if (c instanceof parser.CaseWhenContext) {
+            (0, leaf_1.flushHiddenBefore)(f, c._start.tokenIndex);
+            f.o.nl();
+            formatCaseWhen(f, c, maxCondLen);
+            continue;
+        }
+        if (c instanceof tree_1.TerminalNode && c.symbol.type === tokens_1.L.ELSE) {
+            (0, leaf_1.flushHiddenBefore)(f, c.symbol.tokenIndex);
+            f.o.nl();
+            f.format(c);
+            // emit the else expression on the same line
+            i++;
+            if (i < ctx.childCount)
+                f.format(ctx.getChild(i));
+            continue;
+        }
+        if (c instanceof tree_1.TerminalNode && c.symbol.type === tokens_1.L.END) {
+            (0, leaf_1.flushHiddenBefore)(f, c.symbol.tokenIndex);
+            f.o.indent--;
+            f.o.nl();
+            f.format(c);
+            f.o.indent++;
+            continue;
+        }
+        // CASE keyword and optional valueExpr stay on the head line.
+        f.format(c);
+    }
+    f.o.indent--;
+}
+function formatCaseWhen(f, ctx, maxCondLen) {
+    const condStr = (0, inline_renderer_1.renderItemInline)(f, ctx._condition);
+    const resultStr = (0, inline_renderer_1.renderItemInline)(f, ctx._result);
+    const padding = ' '.repeat(maxCondLen - condStr.length);
+    const aligned = `when ${condStr}${padding} then ${resultStr}`;
+    const hasComments = (0, leaf_1.hasCommentsInRange)(f, ctx._start.tokenIndex, ctx._stop.tokenIndex);
+    if (!hasComments && f.o.lineLengthSoFar() + aligned.length <= tokens_1.LINE_BUDGET) {
+        f.o.text(aligned);
+        (0, leaf_1.note)(f, ctx._stop.type, ctx._stop.tokenIndex, ctx._stop);
+        return;
+    }
+    // Doesn't fit aligned — break at THEN. Flush comments between condition
+    // and THEN before the break for same-line attachment.
+    f.format(ctx.WHEN());
+    f.format(ctx._condition);
+    (0, leaf_1.flushHiddenBefore)(f, ctx.THEN().symbol.tokenIndex);
+    f.o.nl();
+    f.format(ctx.THEN());
+    f.format(ctx._result);
+}
+//# sourceMappingURL=pick-case.js.map

package/dist/lang/prettify/rules.d.ts

@@ -0,0 +1,13 @@
+import type { ParserRuleContext } from 'antlr4ts';
+export type ItemKind = 'fieldEntry' | 'nestEntry' | 'fieldDef' | 'fieldName' | 'collectionMember' | 'orderBySpec' | 'fieldExpr';
+export interface SectionRule {
+    ctxClass: new (...args: never[]) => ParserRuleContext;
+    keywordTypes: number[];
+    list: (ctx: ParserRuleContext) => ParserRuleContext | undefined;
+    itemKind: ItemKind;
+}
+export declare const SECTION_STATEMENT_RULES: SectionRule[];
+export declare const STATEMENT_KIND_BY_CTX: Array<{
+    ctxClass: new (...args: never[]) => ParserRuleContext;
+    kind: string;
+}>;

package/dist/lang/prettify/rules.js

@@ -0,0 +1,103 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * Section-statement dispatch table and statement-kind labels.
+ *
+ * SECTION_STATEMENT_RULES is the table of `keyword: items` rules that need
+ * flow-fill, column alignment, or annotation-aware item handling. Section
+ * keywords NOT in this table fall through to the leaf walker, which produces
+ * correct-but-plain output. Add a row here only when the default isn't good
+ * enough.
+ *
+ * STATEMENT_KIND_BY_CTX is the coarse grouping used by the block-body rule
+ * to decide whether two adjacent statements should preserve a user-supplied
+ * blank line (different kinds: yes; same kind: no).
+ *
+ * A maintainer adding a new section-statement lands here first.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATEMENT_KIND_BY_CTX = exports.SECTION_STATEMENT_RULES = void 0;
+const parser = __importStar(require("../lib/Malloy/MalloyParser"));
+const tokens_1 = require("./tokens");
+// Constructs a SectionRule with the list-accessor closure typed against the
+// concrete context class. The single internal narrowing is justified: the
+// dispatcher only invokes `rule.list(node)` after `node instanceof
+// rule.ctxClass`, so at runtime the parameter really is of type `C`.
+function rule(ctxClass, keywordTypes, list, itemKind) {
+    return {
+        ctxClass,
+        keywordTypes,
+        list: ctx => list(ctx),
+        itemKind,
+    };
+}
+exports.SECTION_STATEMENT_RULES = [
+    rule(parser.AggregateStatementContext, [tokens_1.L.AGGREGATE], c => c.queryFieldList(), 'fieldEntry'),
+    rule(parser.GroupByStatementContext, [tokens_1.L.GROUP_BY], c => c.queryFieldList(), 'fieldEntry'),
+    rule(parser.CalculateStatementContext, [tokens_1.L.CALCULATE], c => c.queryFieldList(), 'fieldEntry'),
+    rule(parser.NestStatementContext, [tokens_1.L.NEST], c => c.nestedQueryList(), 'nestEntry'),
+    rule(parser.DeclareStatementContext, [tokens_1.L.DECLARE], c => c.defList(), 'fieldDef'),
+    rule(parser.DefMeasuresContext, [tokens_1.L.MEASURE], c => c.defList(), 'fieldDef'),
+    rule(parser.DefDimensionsContext, [tokens_1.L.DIMENSION], c => c.defList(), 'fieldDef'),
+    rule(parser.DefExploreEditFieldContext, [tokens_1.L.ACCEPT, tokens_1.L.EXCEPT], c => c.fieldNameList(), 'fieldName'),
+    rule(parser.ProjectStatementContext, [tokens_1.L.SELECT], c => c.fieldCollection(), 'collectionMember'),
+    rule(parser.OrderByStatementContext, [tokens_1.L.ORDER_BY], c => c.ordering(), 'orderBySpec'),
+    rule(parser.WhereStatementContext, [tokens_1.L.WHERE], c => c.filterClauseList(), 'fieldExpr'),
+    rule(parser.HavingStatementContext, [tokens_1.L.HAVING], c => c.filterClauseList(), 'fieldExpr'),
+];
+// Coarse statement-kind labels for the same-kind-no-blank rule in block
+// bodies. Different kinds preserve a single user-supplied blank line.
+exports.STATEMENT_KIND_BY_CTX = [
+    { ctxClass: parser.JoinStatementContext, kind: 'join' },
+    { ctxClass: parser.QueryJoinStatementContext, kind: 'join' },
+    { ctxClass: parser.DefMeasuresContext, kind: 'measure' },
+    { ctxClass: parser.DefDimensionsContext, kind: 'dimension' },
+    { ctxClass: parser.DeclareStatementContext, kind: 'declare' },
+    { ctxClass: parser.AggregateStatementContext, kind: 'aggregate' },
+    { ctxClass: parser.GroupByStatementContext, kind: 'group_by' },
+    { ctxClass: parser.CalculateStatementContext, kind: 'calculate' },
+    { ctxClass: parser.NestStatementContext, kind: 'nest' },
+    { ctxClass: parser.WhereStatementContext, kind: 'where' },
+    { ctxClass: parser.HavingStatementContext, kind: 'having' },
+    { ctxClass: parser.OrderByStatementContext, kind: 'order_by' },
+    { ctxClass: parser.ProjectStatementContext, kind: 'select' },
+    { ctxClass: parser.DefExploreEditFieldContext, kind: 'edit_field' },
+    { ctxClass: parser.DefExploreRenameContext, kind: 'rename' },
+    { ctxClass: parser.DefExploreQueryContext, kind: 'view' },
+];
+//# sourceMappingURL=rules.js.map

package/dist/lang/prettify/sections.d.ts

@@ -0,0 +1,4 @@
+import { ParserRuleContext } from 'antlr4ts';
+import type { Formatter } from './formatter';
+import type { SectionRule } from './rules';
+export declare function formatSectionStatement(f: Formatter, stmt: ParserRuleContext, rule: SectionRule): void;

package/dist/lang/prettify/sections.js

@@ -0,0 +1,261 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * RULE: SECTION-STATEMENT — formatSectionStatement / formatSectionList
+ *
+ * A `keyword: items` block. The statement context wraps:
+ *   <tags?> <ACCESS_LABEL?> <KEYWORD> <listCtx>
+ * We walk children: tags + access-label go through the normal dispatcher
+ * (so annotations are preserved); the KEYWORD is emitted manually; the
+ * list context dispatches to formatSectionList.
+ *
+ * formatSectionList rule (locked in with the user):
+ *   - All bare items + total fits ≤ LINE_BUDGET → inline `kw: a, b, c`.
+ *   - Single item that fits (even if it has `is`) → inline.
+ *   - Otherwise → wrapped: keyword on its own line; items at +1 indent;
+ *       bare items flow-fill ≤ LINE_BUDGET, comma-separated intra-line,
+ *       no trailing commas; `is` items each on own line; annotated items
+ *       each on own line, annotation on the line above.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSectionStatement = formatSectionStatement;
+const antlr4ts_1 = require("antlr4ts");
+const tree_1 = require("antlr4ts/tree");
+const parser = __importStar(require("../lib/Malloy/MalloyParser"));
+const tokens_1 = require("./tokens");
+const leaf_1 = require("./leaf");
+const inline_renderer_1 = require("./inline-renderer");
+function formatSectionStatement(f, stmt, rule) {
+    var _a;
+    const keywordTok = findKeyword(stmt, rule.keywordTypes);
+    const listCtx = rule.list(stmt);
+    if (!keywordTok || !listCtx) {
+        (0, leaf_1.formatTokenRange)(f, stmt._start.tokenIndex, stmt._stop.tokenIndex);
+        return;
+    }
+    for (let i = 0; i < stmt.childCount; i++) {
+        const c = stmt.getChild(i);
+        if (c instanceof tree_1.TerminalNode && c.symbol === keywordTok) {
+            (0, leaf_1.flushHiddenBefore)(f, keywordTok.tokenIndex);
+            if (f.o.indent > 0)
+                f.o.nl();
+            else
+                (0, leaf_1.startStatementLine)(f);
+            f.o.text(((_a = keywordTok.text) !== null && _a !== void 0 ? _a : '').replace(/\s+/g, ''));
+            (0, leaf_1.note)(f, keywordTok.type, keywordTok.tokenIndex, keywordTok);
+            continue;
+        }
+        if (c === listCtx) {
+            const items = listItems(listCtx, rule.itemKind);
+            if (items.length > 0)
+                formatSectionList(f, items);
+            continue;
+        }
+        f.format(c);
+    }
+}
+function findKeyword(node, types) {
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.getChild(i);
+        if (c instanceof tree_1.TerminalNode && types.includes(c.symbol.type))
+            return c.symbol;
+    }
+    return undefined;
+}
+function listItems(listCtx, itemKind) {
+    // Type predicate (`c is ParserRuleContext`) so callers don't need a cast.
+    const matches = (c) => {
+        if (!(c instanceof antlr4ts_1.ParserRuleContext))
+            return false;
+        switch (itemKind) {
+            case 'fieldEntry':
+                return c instanceof parser.QueryFieldEntryContext;
+            case 'nestEntry':
+                return c instanceof parser.NestEntryContext;
+            case 'fieldDef':
+                return c instanceof parser.FieldDefContext;
+            case 'fieldName':
+                return c instanceof parser.FieldNameContext;
+            case 'collectionMember':
+                return c instanceof parser.CollectionMemberContext;
+            case 'orderBySpec':
+                return c instanceof parser.OrderBySpecContext;
+            case 'fieldExpr':
+                return c instanceof parser.FieldExprContext;
+        }
+    };
+    const out = [];
+    for (let i = 0; i < listCtx.childCount; i++) {
+        const c = listCtx.getChild(i);
+        if (matches(c))
+            out.push(c);
+    }
+    return out;
+}
+function classifyItem(f, ctx) {
+    let hasIs = false;
+    let hasAnnotation = false;
+    for (let i = ctx._start.tokenIndex; i <= ctx._stop.tokenIndex; i++) {
+        const t = f.tokens[i];
+        if (t.type === tokens_1.L.IS)
+            hasIs = true;
+        if (t.type === tokens_1.L.ANNOTATION ||
+            t.type === tokens_1.L.DOC_ANNOTATION ||
+            t.type === tokens_1.L.BLOCK_ANNOTATION_BEGIN ||
+            t.type === tokens_1.L.DOC_BLOCK_ANNOTATION_BEGIN)
+            hasAnnotation = true;
+    }
+    return { ctx, hasIs, hasAnnotation };
+}
+function formatSectionList(f, items) {
+    const itemInfos = items.map(it => classifyItem(f, it));
+    const noAnnotations = itemInfos.every(info => !info.hasAnnotation);
+    const allBare = itemInfos.every(info => !info.hasIs && !info.hasAnnotation);
+    const firstItem = items[0];
+    const lastItem = items[items.length - 1];
+    // Inline candidate: no annotations, no hidden-channel comments anywhere in
+    // the items' span (renderItemInline drops them), AND either all bare or
+    // exactly one item.
+    const itemsHaveComments = (0, leaf_1.hasCommentsInRange)(f, firstItem._start.tokenIndex, lastItem._stop.tokenIndex);
+    const inlineEligible = noAnnotations && !itemsHaveComments && (allBare || items.length === 1);
+    if (inlineEligible) {
+        const renderedItems = itemInfos.map(info => (0, inline_renderer_1.renderItemInline)(f, info.ctx));
+        const inlineBody = renderedItems.join(', ');
+        const candidateLen = f.o.lineLengthSoFar() + 1 /* space */ + inlineBody.length;
+        if (candidateLen <= tokens_1.LINE_BUDGET) {
+            f.o.text(' ');
+            f.o.text(inlineBody);
+            (0, leaf_1.note)(f, lastItem._stop.type, lastItem._stop.tokenIndex, lastItem._stop);
+            return;
+        }
+    }
+    // Wrapped form. Two paths:
+    //   - No comments anywhere: original flow-fill — bare items pack into lines
+    //     at LINE_BUDGET, `is`/annotated items each get their own line.
+    //   - Comments anywhere in the items' span: every item emits on its own
+    //     line via f.format(), which goes through emitVisibleToken /
+    //     flushHiddenBefore and handles trailing-vs-leading attachment for
+    //     hidden-channel tokens correctly. Flow-fill density is sacrificed for
+    //     comment correctness.
+    f.o.indent++;
+    f.o.nl();
+    if (itemsHaveComments) {
+        f.lastEmittedIdx = firstItem._start.tokenIndex - 1;
+        for (let k = 0; k < itemInfos.length; k++) {
+            const info = itemInfos[k];
+            // flushHiddenBefore handles between-item comments and advances
+            // lastEmittedIdx so they aren't re-emitted by f.format(item)'s own first
+            // emit.
+            (0, leaf_1.flushHiddenBefore)(f, info.ctx._start.tokenIndex);
+            f.o.nl();
+            f.format(info.ctx);
+        }
+        flushSameLineTail(f, lastItem._stop);
+        f.o.indent--;
+        // Update lastEmittedType for leading-action decisions, but DO NOT reset
+        // lastEmittedIdx — flushSameLineTail may have advanced it past tail
+        // comments, and rolling it back would let the parent re-emit them.
+        f.lastEmittedType = lastItem._stop.type;
+        return;
+    }
+    // No-comments fast path: flow-fill packing as before.
+    let curBare = '';
+    const flushBare = () => {
+        if (curBare.length > 0) {
+            f.o.text(curBare);
+            f.o.nl();
+            curBare = '';
+        }
+    };
+    for (const info of itemInfos) {
+        if (info.hasIs || info.hasAnnotation) {
+            flushBare();
+            (0, leaf_1.flushHiddenBefore)(f, info.ctx._start.tokenIndex);
+            f.format(info.ctx);
+            f.o.nl();
+        }
+        else {
+            const itemText = (0, inline_renderer_1.renderItemInline)(f, info.ctx);
+            const indentChars = f.o.indent * tokens_1.INDENT_STR.length;
+            const sepLen = curBare.length > 0 ? 2 : 0; // ", "
+            const projected = indentChars + curBare.length + sepLen + itemText.length;
+            if (curBare.length > 0 && projected > tokens_1.LINE_BUDGET) {
+                flushBare();
+                curBare = itemText;
+            }
+            else {
+                curBare = curBare.length > 0 ? curBare + ', ' + itemText : itemText;
+            }
+        }
+    }
+    flushBare();
+    flushSameLineTail(f, lastItem._stop);
+    f.o.indent--;
+    // See comment in the with-comments branch: keep the advanced
+    // lastEmittedIdx so tail comments aren't re-emitted by the parent.
+    f.lastEmittedType = lastItem._stop.type;
+}
+// After the last item of a wrapped section list, flush any trailing comments
+// on the SAME source line as the last item — those are tail comments belong-
+// ing to the last item and should emit at the section's inner indent.
+// Different-line comments are leading comments for the next statement; leave
+// them for the parent context to emit at the outer indent.
+function flushSameLineTail(f, lastTok) {
+    const lastEndLine = (0, tokens_1.endLineOf)(lastTok);
+    let j = lastTok.tokenIndex + 1;
+    while (j < f.tokens.length) {
+        const t = f.tokens[j];
+        if (t.channel !== antlr4ts_1.Token.HIDDEN_CHANNEL)
+            break;
+        if (t.line !== lastEndLine)
+            break;
+        j++;
+    }
+    if (j > lastTok.tokenIndex + 1) {
+        // The wrapping loop emitted a per-item newline after the last item, but
+        // a same-line tail comment should attach to that item's line — not float
+        // on a fresh one. Drop the trailing newline so emitHiddenToken's
+        // same-line branch reattaches the comment correctly (and adds a trailing
+        // newline back for EOL comments). Without this, the comment lands on a
+        // new line, and a re-parse sees it as a different-line comment, breaking
+        // idempotence.
+        f.o.trimTrailingNewlines();
+        (0, leaf_1.flushHiddenBefore)(f, j);
+    }
+}
+//# sourceMappingURL=sections.js.map

package/dist/lang/prettify/tokens.d.ts

@@ -0,0 +1,13 @@
+import type { Token } from 'antlr4ts';
+import { MalloyLexer } from '../lib/Malloy/MalloyLexer';
+export declare const L: typeof MalloyLexer;
+export declare const LINE_BUDGET = 100;
+export declare const INDENT_STR = "  ";
+export declare const SECTION_TOKENS: Set<number>;
+export declare const TOP_LEVEL_STARTERS: Set<number>;
+export declare const CALL_HUG_AFTER: Set<number>;
+export declare const BINARY_OPS: Set<number>;
+export type LeadingAction = 'glue' | 'hug' | 'space';
+export declare function leadingAction(prevType: number | null, nextType: number): LeadingAction;
+export declare function endLineOf(t: Token): number;
+export declare function findMatching(tokens: Token[], startIdx: number, beginType: number, endType: number): number;