@malloydata/malloy 0.0.386 → 0.0.387

package/dist/lang/prettify/block-body.js

@@ -6,9 +6,13 @@
  * RULE: BLOCK BODY
  *
  * A `{ … }` body containing statements (extend body, view body, etc.). Walks
- * children; between adjacent statements, preserves a single user-supplied
- * blank line *only if the kinds differ*. Same-kind adjacent statements never
- * get a blank.
+ * children; between adjacent statements:
+ *   - `view:` definitions always get a blank line before them (and after
+ *     the previous one), regardless of whether the source had a blank or
+ *     what kind preceded — view definitions read as their own sections.
+ *   - For other kinds: preserve a single user-supplied blank line only if
+ *     the kinds differ. Same-kind adjacent statements (consecutive
+ *     dimensions, measures, etc.) never get a blank.
  *
  * Also: top-level body — forces a blank line before each statement after the
  * first, regardless of source spacing (top-level statements should breathe).
@@ -61,9 +65,18 @@ function formatBlockBody(f, ctx) {
         if (c instanceof antlr4ts_1.ParserRuleContext) {
             if (lastChild !== null) {
                 const userHadBlank = c._start.line - lastChildEndLine > 1;
-                const sameKind = statementKind(lastChild) === statementKind(c);
-                if (userHadBlank && !sameKind)
+                const lastKind = statementKind(lastChild);
+                const curKind = statementKind(c);
+                const sameKind = lastKind === curKind;
+                // `view:` definitions always breathe — blank line above each one
+                // (and after the previous one) regardless of the user's source
+                // spacing or what kind preceded.
+                if (curKind === 'view' || lastKind === 'view') {
                     f.o.blank();
+                }
+                else if (userHadBlank && !sameKind) {
+                    f.o.blank();
+                }
             }
             f.format(c);
             lastChild = c;

package/dist/lang/prettify/formatter.js

@@ -60,6 +60,7 @@ const sections_1 = require("./sections");
 const field_properties_1 = require("./field-properties");
 const pick_case_1 = require("./pick-case");
 const binary_chain_1 = require("./binary-chain");
+const import_select_1 = require("./import-select");
 class Formatter {
     constructor(src, tokens) {
         this.src = src;
@@ -123,6 +124,10 @@ class Formatter {
                 return (0, sections_1.formatSectionStatement)(this, node, rule);
             }
         }
+        // RULE: IMPORT SELECT — `import {a, b} from 'x'` stays compact.
+        if (node instanceof parser.ImportSelectContext) {
+            return (0, import_select_1.formatImportSelect)(this, node);
+        }
         // RULE: PICK / CASE / BINARY CHAIN.
         if (node instanceof parser.PickStatementContext)
             return (0, pick_case_1.formatPickStatement)(this, node);

package/dist/lang/prettify/import-select.d.ts

@@ -0,0 +1,3 @@
+import type * as parser from '../lib/Malloy/MalloyParser';
+import type { Formatter } from './formatter';
+export declare function formatImportSelect(f: Formatter, ctx: parser.ImportSelectContext): void;

package/dist/lang/prettify/import-select.js

@@ -0,0 +1,88 @@
+"use strict";
+/*
+ * Copyright Contributors to the Malloy project
+ * SPDX-License-Identifier: MIT
+ *
+ * RULE: IMPORT SELECT — `import {a, b, c} from 'url'`
+ *
+ * The selection list is `{ id (IS id)? (, id (IS id)?)* }`. Inline if the
+ * whole brace-and-contents fits on the current line. Otherwise wrap with
+ * each item on its own line at +1 indent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatImportSelect = formatImportSelect;
+const tokens_1 = require("./tokens");
+const leaf_1 = require("./leaf");
+const inline_renderer_1 = require("./inline-renderer");
+function formatImportSelect(f, ctx) {
+    // Flush hidden tokens between the previous emit (IMPORT) and our opener
+    // so a comment like `import /* tag */ {a} from 'x'` is preserved.
+    (0, leaf_1.flushHiddenBefore)(f, ctx._start.tokenIndex);
+    const items = ctx.importItem();
+    // Grammar puts FROM as the last token of importSelect: emit it ourselves
+    // so the trailing space and lastEmittedIdx land correctly.
+    const fromTok = ctx.FROM().symbol;
+    const fromIdx = fromTok.tokenIndex;
+    if (items.length === 0) {
+        f.o.space();
+        f.o.text('{} from');
+        (0, leaf_1.note)(f, tokens_1.L.FROM, fromIdx, fromTok);
+        return;
+    }
+    const firstItem = items[0];
+    const lastItem = items[items.length - 1];
+    // Comments anywhere in the items' span (between items, inside an `as is`
+    // form, etc.) get stripped by renderItemInline. Fall back to a comment-
+    // safe wrap that emits each item via f.format — the leaf walker handles
+    // hidden-channel placement.
+    const itemsHaveComments = (0, leaf_1.hasCommentsInRange)(f, firstItem._start.tokenIndex, lastItem._stop.tokenIndex);
+    if (!itemsHaveComments) {
+        const itemStrs = items.map(it => (0, inline_renderer_1.renderItemInline)(f, it));
+        const inlineBody = '{' + itemStrs.join(', ') + '} from';
+        if (f.o.lineLengthSoFar() + 1 + inlineBody.length <= tokens_1.LINE_BUDGET) {
+            f.o.space();
+            f.o.text(inlineBody);
+            (0, leaf_1.note)(f, tokens_1.L.FROM, fromIdx, fromTok);
+            return;
+        }
+        // Wrap form (no comments): one item per line at +1 indent. Pre-rendered
+        // text is fine because renderItemInline saw no comments to drop.
+        f.o.space();
+        f.o.text('{');
+        f.o.indent++;
+        for (let i = 0; i < itemStrs.length; i++) {
+            f.o.nl();
+            f.o.text(itemStrs[i]);
+            if (i < itemStrs.length - 1)
+                f.o.text(',');
+        }
+        f.o.indent--;
+        f.o.nl();
+        f.o.text('} from');
+        (0, leaf_1.note)(f, tokens_1.L.FROM, fromIdx, fromTok);
+        return;
+    }
+    // Comment-safe wrap: each item emits via f.format so flushHiddenBefore
+    // can place its leading/inter-item comments correctly. Trailing `,` after
+    // each non-last item, leaf walker turns it into a newline at indent.
+    f.o.space();
+    f.o.text('{');
+    f.o.indent++;
+    // Advance past the OCURLY we just emitted manually so the first item's
+    // flushHiddenBefore doesn't try to re-emit it.
+    f.lastEmittedIdx = ctx._start.tokenIndex;
+    for (let i = 0; i < items.length; i++) {
+        (0, leaf_1.flushHiddenBefore)(f, items[i]._start.tokenIndex);
+        f.o.nl();
+        f.format(items[i]);
+        if (i < items.length - 1)
+            f.o.text(',');
+    }
+    // Catch any tail comments between the last item and the closing `}`.
+    (0, leaf_1.flushHiddenBefore)(f, fromIdx);
+    f.o.indent--;
+    f.o.nl();
+    f.o.text('} from');
+    (0, leaf_1.note)(f, tokens_1.L.FROM, fromIdx, fromTok);
+}
+//# sourceMappingURL=import-select.js.map

package/dist/lang/prettify/index.js

@@ -57,6 +57,30 @@
  *   - Single-arg function calls don't wrap (no point — nowhere useful to break).
  *   - `(` hugs only after a known-callable token (CALL_HUG_AFTER); after `is`,
  *     `as`, `extend`, `on`, `when`, etc. the `(` is grouping and gets a space.
+ *     CALL_HUG_AFTER includes the keyword-named built-ins that are commonly
+ *     used as functions: ALL, EXCLUDE, the timeframe truncation keywords
+ *     (YEAR/MONTH/DAY/…), and the cast-target type names
+ *     (TIMESTAMP/DATE/NUMBER/STRING/BOOLEAN/JSON).
+ *   - `!` is the cast operator (`epoch_ms!timestamp(x)`); it glues to both
+ *     sides like `.` does.
+ *   - Empty `{}` collapses inline (`extend {}`, not `extend {\n}`).
+ *   - `import {a, b, c} from 'x'` formats as a flat list when it fits on the
+ *     line; otherwise one item per line at +1 indent.
+ *   - `view:` definitions in a block body always have a blank line before
+ *     each one (after the first), even when no blank was in the source. The
+ *     same-kind-no-blank rule still applies to other statement kinds.
+ *   - `{...}` bodies that contain more than one section statement never
+ *     collapse onto a single line, even when they would fit. Reading two
+ *     `group_by:` clauses jammed on one line is hostile.
+ *   - Single is-item section lists keep the keyword and item on the same
+ *     line (`nest: name is { … }`), so the body wraps naturally instead of
+ *     forcing a `nest:\n  name is {` opener split.
+ *   - join_one / join_many / join_cross multi-item lists always wrap one
+ *     item per line — items use `with`/`on` instead of `is` but are
+ *     structurally is-like.
+ *   - Trailing comments between the last item of a section list and the
+ *     enclosing `}` are emitted at the section's inner indent, so they
+ *     stay associated with the section the user wrote them in.
  *
  * Adding a new section-statement
  * ------------------------------

package/dist/lang/prettify/leaf.js

@@ -127,6 +127,18 @@ function hasCommentsInRange(f, fromIdx, toIdx) {
     }
     return false;
 }
+// Index of the next non-hidden, non-EOF token strictly after `idx`, or -1.
+function nextVisibleAfter(f, idx) {
+    for (let j = idx + 1; j < f.tokens.length; j++) {
+        const t = f.tokens[j];
+        if (t.channel === antlr4ts_1.Token.HIDDEN_CHANNEL)
+            continue;
+        if (t.type === antlr4ts_1.Token.EOF)
+            return -1;
+        return j;
+    }
+    return -1;
+}
 // Does the paren-pair at [openIdx, closeIdx] have any COMMA at its own depth?
 // (Used to distinguish "function call with multiple args" from "single-arg
 // call" / "empty parens".)
@@ -190,6 +202,21 @@ function emitVisibleToken(f, t, idx) {
     if (t.type === tokens_1.L.OCURLY) {
         f.o.space();
         f.o.text('{');
+        // Empty `{}`: peek the next visible token. If it's the matching close
+        // AND nothing hidden sits between them (no comments to preserve), emit
+        // inline so we get `extend {}` not `extend {\n}`. With a comment in the
+        // gap (`extend { /* keep */ }`), fall through to the wrapping form so
+        // the leaf walker's comment placement runs.
+        const nextVisible = nextVisibleAfter(f, idx);
+        if (nextVisible !== -1 &&
+            f.tokens[nextVisible].type === tokens_1.L.CCURLY &&
+            !hasCommentsInRange(f, idx + 1, nextVisible - 1)) {
+            f.o.text('}');
+            if (f.o.indent === 0)
+                f.needBlank = true;
+            note(f, tokens_1.L.CCURLY, nextVisible, f.tokens[nextVisible]);
+            return;
+        }
         f.o.indent++;
         f.o.nl();
         note(f, t.type, idx, t);

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

@@ -1,5 +1,5 @@
 import type { ParserRuleContext } from 'antlr4ts';
-export type ItemKind = 'fieldEntry' | 'nestEntry' | 'fieldDef' | 'fieldName' | 'collectionMember' | 'orderBySpec' | 'fieldExpr';
+export type ItemKind = 'fieldEntry' | 'nestEntry' | 'fieldDef' | 'fieldName' | 'collectionMember' | 'orderBySpec' | 'fieldExpr' | 'joinDef' | 'includeField' | 'indexElement';
 export interface SectionRule {
     ctxClass: new (...args: never[]) => ParserRuleContext;
     keywordTypes: number[];

package/dist/lang/prettify/rules.js

@@ -79,6 +79,14 @@ exports.SECTION_STATEMENT_RULES = [
     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'),
+    rule(parser.DefJoinOneContext, [tokens_1.L.JOIN_ONE], c => c.joinList(), 'joinDef'),
+    rule(parser.DefJoinManyContext, [tokens_1.L.JOIN_MANY], c => c.joinList(), 'joinDef'),
+    rule(parser.DefJoinCrossContext, [tokens_1.L.JOIN_CROSS], c => c.joinList(), 'joinDef'),
+    // include block items: `public: a, b`, `internal: x, y, z`. The keyword
+    // (PUBLIC/PRIVATE/INTERNAL) lives one level down inside accessLabelProp;
+    // findKeyword in ./sections handles that nested case.
+    rule(parser.IncludeItemContext, [tokens_1.L.PUBLIC, tokens_1.L.PRIVATE, tokens_1.L.INTERNAL], c => c.includeList(), 'includeField'),
+    rule(parser.IndexStatementContext, [tokens_1.L.INDEX], c => c.indexFields(), 'indexElement'),
 ];
 // Coarse statement-kind labels for the same-kind-no-blank rule in block
 // bodies. Different kinds preserve a single user-supplied blank line.

package/dist/lang/prettify/sections.js

@@ -13,11 +13,21 @@
  *
  * 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.
+ *   - Single item that fits (even if it has `is`) → inline. Items containing
+ *     a `{...}` body with more than one section statement are excluded —
+ *     view bodies don't read on one line regardless of length.
+ *   - Single is-item that doesn't fit inline → keep keyword and item on the
+ *     same line (`nest: name is { …wrapped body… }`); the body's `{...}`
+ *     wraps internally. Annotated items still take the keyword-on-own-line
+ *     form so the annotation lands above its item.
  *   - 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.
+ *
+ * After the last item, trailing comments that sit between the section and
+ * the enclosing `}` are also emitted at the inner indent — they belong to
+ * the section the user just wrote, not the parent block.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -70,7 +80,9 @@ function formatSectionStatement(f, stmt, rule) {
     }
     for (let i = 0; i < stmt.childCount; i++) {
         const c = stmt.getChild(i);
-        if (c instanceof tree_1.TerminalNode && c.symbol === keywordTok) {
+        const isKeywordChild = (c instanceof tree_1.TerminalNode && c.symbol === keywordTok) ||
+            (c instanceof antlr4ts_1.ParserRuleContext && childContainsToken(c, keywordTok));
+        if (isKeywordChild) {
             (0, leaf_1.flushHiddenBefore)(f, keywordTok.tokenIndex);
             if (f.o.indent > 0)
                 f.o.nl();
@@ -83,18 +95,39 @@ function formatSectionStatement(f, stmt, rule) {
         if (c === listCtx) {
             const items = listItems(listCtx, rule.itemKind);
             if (items.length > 0)
-                formatSectionList(f, items);
+                formatSectionList(f, items, rule.itemKind);
             continue;
         }
         f.format(c);
     }
 }
+function childContainsToken(node, tok) {
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.getChild(i);
+        if (c instanceof tree_1.TerminalNode && c.symbol === tok)
+            return true;
+    }
+    return false;
+}
 function findKeyword(node, types) {
+    // Direct terminal children — fast path, the common case.
     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;
     }
+    // Fallback: descend one level. Some rules wrap the keyword in a small
+    // nested rule (e.g. includeItem → accessLabelProp → INTERNAL).
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.getChild(i);
+        if (c instanceof antlr4ts_1.ParserRuleContext) {
+            for (let j = 0; j < c.childCount; j++) {
+                const g = c.getChild(j);
+                if (g instanceof tree_1.TerminalNode && types.includes(g.symbol.type))
+                    return g.symbol;
+            }
+        }
+    }
     return undefined;
 }
 function listItems(listCtx, itemKind) {
@@ -117,6 +150,12 @@ function listItems(listCtx, itemKind) {
                 return c instanceof parser.OrderBySpecContext;
             case 'fieldExpr':
                 return c instanceof parser.FieldExprContext;
+            case 'joinDef':
+                return c instanceof parser.JoinDefContext;
+            case 'includeField':
+                return c instanceof parser.IncludeFieldContext;
+            case 'indexElement':
+                return c instanceof parser.IndexElementContext;
         }
     };
     const out = [];
@@ -127,8 +166,10 @@ function listItems(listCtx, itemKind) {
     }
     return out;
 }
-function classifyItem(f, ctx) {
-    let hasIs = false;
+function classifyItem(f, ctx, itemKind) {
+    // joinDef items always wrap onto their own line. They use `with` / `on`
+    // instead of `is`, but they're structurally one-per-line like is-items.
+    let hasIs = itemKind === 'joinDef';
     let hasAnnotation = false;
     for (let i = ctx._start.tokenIndex; i <= ctx._stop.tokenIndex; i++) {
         const t = f.tokens[i];
@@ -142,17 +183,23 @@ function classifyItem(f, ctx) {
     }
     return { ctx, hasIs, hasAnnotation };
 }
-function formatSectionList(f, items) {
-    const itemInfos = items.map(it => classifyItem(f, it));
+function formatSectionList(f, items, itemKind) {
+    const itemInfos = items.map(it => classifyItem(f, it, itemKind));
     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.
+    // exactly one item. Items containing a `{...}` body with multiple inner
+    // statements are also excluded — collapsing a view body onto one line is
+    // hostile to read regardless of length.
     const itemsHaveComments = (0, leaf_1.hasCommentsInRange)(f, firstItem._start.tokenIndex, lastItem._stop.tokenIndex);
-    const inlineEligible = noAnnotations && !itemsHaveComments && (allBare || items.length === 1);
+    const itemsHaveMultiStatementBody = itemInfos.some(info => hasMultiStatementCurlyBody(f, info.ctx));
+    const inlineEligible = noAnnotations &&
+        !itemsHaveComments &&
+        !itemsHaveMultiStatementBody &&
+        (allBare || items.length === 1);
     if (inlineEligible) {
         const renderedItems = itemInfos.map(info => (0, inline_renderer_1.renderItemInline)(f, info.ctx));
         const inlineBody = renderedItems.join(', ');
@@ -164,6 +211,20 @@ function formatSectionList(f, items) {
             return;
         }
     }
+    // Single is-item that doesn't fit inline: keep the keyword on the same
+    // line as the item (`nest: name is { …wrapped body… }`) instead of
+    // breaking before the name. The body's `{...}` will wrap on its own.
+    // Annotated items still need the keyword-on-own-line form so the
+    // annotation can land between them.
+    if (items.length === 1 &&
+        itemInfos[0].hasIs &&
+        !itemInfos[0].hasAnnotation &&
+        !itemsHaveComments) {
+        f.o.text(' ');
+        f.format(itemInfos[0].ctx);
+        f.lastEmittedType = lastItem._stop.type;
+        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.
@@ -230,14 +291,56 @@ function formatSectionList(f, items) {
     // 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.
+// Does any `{...}` block inside this item contain more than one section
+// keyword (group_by:, aggregate:, where:, …) at its top level? Used to gate
+// the section-list inline form: a view body with multiple statements never
+// reads well on a single line, even when it fits. Single-statement bodies
+// like `{ where: x = 1 }` may still inline.
+function hasMultiStatementCurlyBody(f, ctx) {
+    const fromIdx = ctx._start.tokenIndex;
+    const toIdx = ctx._stop.tokenIndex;
+    for (let i = fromIdx; i <= toIdx; i++) {
+        if (f.tokens[i].type !== tokens_1.L.OCURLY)
+            continue;
+        const close = (0, tokens_1.findMatching)(f.tokens, i, tokens_1.L.OCURLY, tokens_1.L.CCURLY);
+        let count = 0;
+        let depth = 0;
+        for (let j = i + 1; j < close; j++) {
+            const t = f.tokens[j];
+            if (t.type === tokens_1.L.OCURLY || t.type === tokens_1.L.OPAREN || t.type === tokens_1.L.OBRACK) {
+                depth++;
+            }
+            else if (t.type === tokens_1.L.CCURLY ||
+                t.type === tokens_1.L.CPAREN ||
+                t.type === tokens_1.L.CBRACK) {
+                depth--;
+            }
+            else if (depth === 0 && tokens_1.SECTION_TOKENS.has(t.type)) {
+                count++;
+                if (count > 1)
+                    return true;
+            }
+        }
+        i = close;
+    }
+    return false;
+}
+// After the last item of a wrapped section list, flush trailing comments
+// belonging to the section. There are two cases:
+//
+//   1. Same-line tail: a comment on the SAME source line as the last item.
+//      Always belongs to the last item; emit at the section's inner indent.
+//
+//   2. Different-line trailing comments that sit between the last item and
+//      the closing `}` of the enclosing block (no other statement follows).
+//      These visually belong to the section the user just wrote, not the
+//      block. Emit them at the inner indent so they stay associated with
+//      the section. If a real statement follows the comments, leave them
+//      for the parent — they're leading comments for that statement.
 function flushSameLineTail(f, lastTok) {
     const lastEndLine = (0, tokens_1.endLineOf)(lastTok);
     let j = lastTok.tokenIndex + 1;
+    // Phase 1: same-line tail comments.
     while (j < f.tokens.length) {
         const t = f.tokens[j];
         if (t.channel !== antlr4ts_1.Token.HIDDEN_CHANNEL)
@@ -247,15 +350,31 @@ function flushSameLineTail(f, lastTok) {
         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.
+        // Same-line comments: drop the wrapping loop's per-item newline so
+        // emitHiddenToken's same-line branch reattaches the comment correctly
+        // (and adds a trailing newline back for EOL comments). Otherwise a
+        // re-parse sees a different-line comment, breaking idempotence.
         f.o.trimTrailingNewlines();
         (0, leaf_1.flushHiddenBefore)(f, j);
     }
+    // Phase 2: own-line comments before the next visible token. If the next
+    // visible token is a closing `}`, the comments visually belong to this
+    // section — emit them at the inner indent. Otherwise leave them for the
+    // parent (they're leading comments for whatever follows).
+    let k = j;
+    let trailingHidden = 0;
+    while (k < f.tokens.length) {
+        const t = f.tokens[k];
+        if (t.channel !== antlr4ts_1.Token.HIDDEN_CHANNEL)
+            break;
+        trailingHidden++;
+        k++;
+    }
+    if (trailingHidden > 0 && k < f.tokens.length) {
+        const next = f.tokens[k];
+        if (next.type === tokens_1.L.CCURLY) {
+            (0, leaf_1.flushHiddenBefore)(f, k);
+        }
+    }
 }
 //# sourceMappingURL=sections.js.map

package/dist/lang/prettify/tokens.js

@@ -87,6 +87,26 @@ exports.CALL_HUG_AFTER = new Set([
     exports.L.CAST,
     exports.L.NOW,
     exports.L.LAST,
+    // Ungrouped / level-modifier function-style calls.
+    exports.L.ALL,
+    exports.L.EXCLUDE,
+    // Timeframe truncation keywords used as functions: year(x), month(x), …
+    exports.L.YEAR,
+    exports.L.QUARTER,
+    exports.L.MONTH,
+    exports.L.WEEK,
+    exports.L.DAY,
+    exports.L.HOUR,
+    exports.L.MINUTE,
+    exports.L.SECOND,
+    // Type-cast keyword names: timestamp(x), date(x), number(x), string(x), …
+    exports.L.TIMESTAMP,
+    exports.L.TIMESTAMPTZ,
+    exports.L.DATE,
+    exports.L.NUMBER,
+    exports.L.STRING,
+    exports.L.BOOLEAN,
+    exports.L.JSON,
 ]);
 // Binary operators that get spaces on both sides at the leaf level.
 // (Chain wrapping for and/or/??/+/- happens at parse-tree level — see
@@ -119,10 +139,15 @@ function leadingAction(prevType, nextType) {
         nextType === exports.L.SEMI ||
         nextType === exports.L.COLON ||
         nextType === exports.L.TRIPLECOLON ||
+        nextType === exports.L.EXCLAM ||
         nextType === exports.L.CPAREN ||
         nextType === exports.L.CBRACK) {
         return 'glue';
     }
+    // After the `!` cast operator (`epoch_ms!timestamp(x)`), the next token
+    // glues to it like the `.` operator does.
+    if (prevType === exports.L.EXCLAM)
+        return 'glue';
     if ((nextType === exports.L.OPAREN || nextType === exports.L.OBRACK) &&
         prevType !== null &&
         exports.CALL_HUG_AFTER.has(prevType)) {

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const MALLOY_VERSION = "0.0.386";
+export declare const MALLOY_VERSION = "0.0.387";

package/dist/version.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MALLOY_VERSION = void 0;
 // generated with 'generate-version-file' script; do not edit manually
-exports.MALLOY_VERSION = '0.0.386';
+exports.MALLOY_VERSION = '0.0.387';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/malloy",
-  "version": "0.0.386",
+  "version": "0.0.387",
   "license": "MIT",
   "exports": {
     ".": "./dist/index.js",
@@ -51,9 +51,9 @@
     "generate-version-file": "VERSION=$(npm pkg get version --workspaces=false | tr -d \\\")\necho \"// generated with 'generate-version-file' script; do not edit manually\\nexport const MALLOY_VERSION = '$VERSION';\" > src/version.ts"
   },
   "dependencies": {
-    "@malloydata/malloy-filter": "0.0.386",
-    "@malloydata/malloy-interfaces": "0.0.386",
-    "@malloydata/malloy-tag": "0.0.386",
+    "@malloydata/malloy-filter": "0.0.387",
+    "@malloydata/malloy-interfaces": "0.0.387",
+    "@malloydata/malloy-tag": "0.0.387",
     "@noble/hashes": "^1.8.0",
     "antlr4ts": "^0.5.0-alpha.4",
     "assert": "^2.0.0",