rooklang 0.4.2 → 0.5.0

package/dist/parser/declarations.js

@@ -65,15 +65,38 @@ export class DeclarationParser extends ParamParser {
         if (!this.context.topLevel) {
             this.error('"export" is only allowed at the top level of a module', start, this.span(start).end);
         }
+        if (this.check('{') || this.check('*'))
+            return this.parseExportFrom(start);
         return (this.parseDeclaration(start, true) ??
             this.fail(`expected a declaration after "export", found ${describe(this.peek())}`));
     }
+    /** `export { Row, Rows as Table } from "./rows.rk"` or `export * from "./rows.rk"`. */
+    parseExportFrom(start) {
+        let specifiers = null;
+        if (!this.accept('*')) {
+            this.expect('{');
+            specifiers = this.parseList('}', () => this.parseImportSpecifier());
+        }
+        if (!this.checkWord('from')) {
+            this.fail('a module exports its own names where they are declared, e.g. export func f(); export { ... } needs from "./module.rk"');
+        }
+        this.next();
+        const source = this.parseStringLiteral('module path');
+        const declaration = {
+            kind: 'ExportFromDeclaration',
+            specifiers,
+            source,
+            ...this.span(start),
+        };
+        this.endStatement();
+        return declaration;
+    }
     parseFuncDeclaration(start, exported) {
         const async = this.accept('async');
         this.expect('func');
         const name = this.parseIdentifier('function name');
         const typeParams = this.parseTypeParams();
-        const params = this.parseParams(false);
+        const params = this.parseParams(false, { defaults: true, rest: 'typed' });
         const results = this.parseResults();
         const body = this.parseFunctionBody(async);
         return {
@@ -131,7 +154,7 @@ export class DeclarationParser extends ParamParser {
         if (!htmlTag && !/^[A-Z]/.test(name.name)) {
             this.error(`component names start with a capital letter, as in <${name.name.charAt(0).toUpperCase()}${name.name.slice(1)} />`, name.start, name.end);
         }
-        const params = this.parseParams(false, true, true);
+        const params = this.parseParams(false, { defaults: true, rest: 'attrs' });
         const body = this.withContext({ ...FUNCTION_BODY, inComponent: true }, () => this.parseComponentBody());
         return {
             kind: 'ComponentDeclaration',

package/dist/parser/decorators.js

@@ -15,7 +15,7 @@ export class DecoratorParser extends DeclarationParser {
             this.error('decorators can only be declared at the top level of a module', keyword.start, keyword.end);
         }
         const name = this.parseIdentifier('decorator name');
-        const params = this.parseParams(false, true);
+        const params = this.parseParams(false, { defaults: true });
         const needs = this.parseNeeds();
         const includes = this.parseIncludes();
         const body = this.withContext({ ...FUNCTION_BODY, inComponent: true }, () => this.parseDecoratorBody());

package/dist/parser/expressions.js

@@ -35,6 +35,12 @@ export class ExpressionParser extends TypeParser {
             const precedence = BINARY_PRECEDENCE[operator];
             if (precedence < minPrecedence)
                 return left;
+            // `await load<number>(1)` reads `await load` first.
+            const callee = left.kind === 'UnaryExpression' && left.operator === 'await' ? left.argument : left;
+            if (operator === '<' &&
+                (callee.kind === 'Identifier' || callee.kind === 'MemberExpression')) {
+                this.rejectTypeArguments();
+            }
             this.next();
             // `**` is right-associative, all other binary operators are left-associative.
             const right = this.parseBinary(operator === '**' ? precedence : precedence + 1);

package/dist/parser/literals.d.ts

@@ -1,7 +1,7 @@
 import type * as ast from '../ast.ts';
 import { type StringToken, type TokenKind } from '../lexer/token.ts';
-import { ExpressionParser } from './expressions.ts';
-export declare abstract class LiteralParser extends ExpressionParser {
+import { ObjectParser } from './objects.ts';
+export declare abstract class LiteralParser extends ObjectParser {
     /** Whether the `(` at the current position opens arrow function parameters: `(...) =>`. */
     protected isArrowFunctionAhead(): boolean;
     protected parseArrowFunction(async?: boolean): ast.ArrowFunction;
@@ -32,8 +32,6 @@ export declare abstract class LiteralParser extends ExpressionParser {
     protected parseStreamChan(start: number): ast.StreamChanExpression;
     /** `[]byte("text")`: a type, then its value in parentheses. */
     protected parseConversion(): ast.ConversionExpression;
-    protected parseObjectLiteral(): ast.ObjectLiteral;
-    protected parseProperty(): ast.Property | ast.SpreadElement;
     protected parseTemplate(first: StringToken): ast.TemplateLiteral;
     /** Parses `item, item, ...` up to `close`, which is consumed. A trailing comma is allowed. */
     protected parseList<T>(close: TokenKind, parseItem: () => T): T[];

package/dist/parser/literals.js

@@ -1,8 +1,8 @@
 import { isKeyword } from "../lexer/token.js";
-import { ExpressionParser } from "./expressions.js";
+import { ObjectParser } from "./objects.js";
 import { FUNCTION_BODY, ParseError, describe, templateElement } from "./syntax.js";
 // Functions, `new`, literals of arrays, objects and templates, names.
-export class LiteralParser extends ExpressionParser {
+export class LiteralParser extends ObjectParser {
     /** Whether the `(` at the current position opens arrow function parameters: `(...) =>`. */
     isArrowFunctionAhead() {
         let depth = 0;
@@ -39,7 +39,7 @@ export class LiteralParser extends ExpressionParser {
             ];
         }
         else {
-            params = this.parseParams(true);
+            params = this.parseParams(true, { defaults: true, rest: 'typed' });
         }
         this.expect('=>');
         const body = this.withContext({ ...FUNCTION_BODY, inAsync: async }, () => this.check('{') ? this.parseBlock() : this.parseExpression());
@@ -60,7 +60,7 @@ export class LiteralParser extends ExpressionParser {
     }
     parseFuncExpression(async = false) {
         const start = this.expect('func').start;
-        const params = this.parseParams(false);
+        const params = this.parseParams(false, { defaults: true, rest: 'typed' });
         const results = this.parseResults();
         const body = this.parseFunctionBody(async);
         return {
@@ -86,6 +86,9 @@ export class LiteralParser extends ExpressionParser {
                 ...this.span(callee.start),
             };
         }
+        // `new Promise<void>(...)`: the type arguments are inferred, as in calls.
+        if (this.check('<'))
+            this.rejectTypeArguments();
         const args = this.check('(') ? this.parseArguments() : [];
         return { kind: 'NewExpression', callee, arguments: args, ...this.span(start) };
     }
@@ -220,26 +223,6 @@ export class LiteralParser extends ExpressionParser {
         this.expect(')');
         return { kind: 'ConversionExpression', type, argument, ...this.span(start) };
     }
-    parseObjectLiteral() {
-        const start = this.expect('{').start;
-        const properties = this.nested(() => this.parseList('}', () => this.parseProperty()));
-        return { kind: 'ObjectLiteral', properties, ...this.span(start) };
-    }
-    parseProperty() {
-        const token = this.peek();
-        if (token.kind === '...')
-            return this.parseElement();
-        const key = token.kind === 'String' ? this.parseStringLiteral() : this.parsePropertyName();
-        if (this.accept(':')) {
-            const value = this.parseExpression();
-            return { kind: 'Property', key, value, shorthand: false, ...this.span(token.start) };
-        }
-        // Shorthand `{ name }` means `{ name: name }`, so the key must be a plain name.
-        if (key.kind !== 'Identifier' || token.kind !== 'Identifier') {
-            this.fail(`expected ":" after property name, found ${describe(this.peek())}`);
-        }
-        return { kind: 'Property', key, value: { ...key }, shorthand: true, ...this.span(token.start) };
-    }
     parseTemplate(first) {
         this.next();
         const quasis = [templateElement(first)];
@@ -248,6 +231,11 @@ export class LiteralParser extends ExpressionParser {
             while (true) {
                 expressions.push(this.nested(() => this.parseExpression()));
                 const part = this.peek();
+                if ((part.kind === '++' || part.kind === '--') &&
+                    expressions.at(-1)?.kind === 'Identifier') {
+                    const name = expressions.at(-1).name;
+                    this.fail(`"${part.kind}" is a statement and cannot be used inside a template: use ${name} here and write ${name}${part.kind} on a line of its own`);
+                }
                 if (part.kind !== 'TemplateMiddle' && part.kind !== 'TemplateTail') {
                     this.fail(`expected "}" to close the template substitution, found ${describe(part)}`);
                 }

package/dist/parser/objects.d.ts

@@ -0,0 +1,8 @@
+import type * as ast from '../ast.ts';
+import { PostfixParser } from './postfix.ts';
+export declare abstract class ObjectParser extends PostfixParser {
+    protected parseObjectLiteral(): ast.ObjectLiteral;
+    protected parseProperty(): ast.Property | ast.SpreadElement;
+    /** `fetch(req Request) Response { ... }`: typed parameters, as those of a `func` literal. */
+    private parseObjectMethod;
+}

package/dist/parser/objects.js

@@ -0,0 +1,51 @@
+import { PostfixParser } from "./postfix.js";
+import { describe } from "./syntax.js";
+// Object literals: `{ name: value }`, `{ name }`, `{ ...other }`, and methods written as in a
+// class, `{ fetch(req Request) Response { ... } }`.
+export class ObjectParser extends PostfixParser {
+    parseObjectLiteral() {
+        const start = this.expect('{').start;
+        const properties = this.nested(() => this.parseList('}', () => this.parseProperty()));
+        return { kind: 'ObjectLiteral', properties, ...this.span(start) };
+    }
+    parseProperty() {
+        const token = this.peek();
+        if (token.kind === '...') {
+            this.next();
+            const argument = this.parseExpression();
+            return { kind: 'SpreadElement', argument, ...this.span(token.start) };
+        }
+        // `async load() T { ... }`: `async` before the name of a method.
+        const async = token.kind === 'async' && this.peek(2).kind === '(';
+        if (async)
+            this.next();
+        const key = this.check('String') ? this.parseStringLiteral() : this.parsePropertyName();
+        if (this.check('('))
+            return this.parseObjectMethod(key, token.start, async);
+        if (this.accept(':')) {
+            const value = this.parseExpression();
+            return { kind: 'Property', key, value, shorthand: false, ...this.span(token.start) };
+        }
+        // Shorthand `{ name }` means `{ name: name }`, so the key must be a plain name.
+        if (key.kind !== 'Identifier' || token.kind !== 'Identifier') {
+            this.fail(`expected ":" after property name, found ${describe(this.peek())}`);
+        }
+        return { kind: 'Property', key, value: { ...key }, shorthand: true, ...this.span(token.start) };
+    }
+    /** `fetch(req Request) Response { ... }`: typed parameters, as those of a `func` literal. */
+    parseObjectMethod(key, start, async) {
+        const funcStart = this.peek().start;
+        const params = this.parseParams(false, { defaults: true, rest: 'typed' });
+        const results = this.parseResults();
+        const body = this.parseFunctionBody(async);
+        const value = {
+            kind: 'FuncExpression',
+            ...(async ? { async } : {}),
+            params,
+            results,
+            body,
+            ...this.span(funcStart),
+        };
+        return { kind: 'Property', key, value, shorthand: false, method: true, ...this.span(start) };
+    }
+}

package/dist/parser/params.d.ts

@@ -4,9 +4,14 @@ export declare abstract class ParamParser extends JumpParser {
     /**
      * `(a, b number, c string)`. Names without a type take the type of the next typed name, as in
      * Go; only arrow functions may leave types out entirely. The parameters of a constructor can be
-     * properties: `(private name string)`.
+     * properties: `(private name string)`. Functions take `...parts []any` last, and components
+     * `...attrs`, the attributes of an element; both may have default values, `times = 1`.
      */
-    protected parseParams(typesOptional: boolean, allowDefaults?: boolean, allowRest?: boolean, allowProperties?: boolean): ast.Parameter[];
+    protected parseParams(typesOptional: boolean, options?: {
+        defaults?: boolean;
+        rest?: 'typed' | 'attrs';
+        properties?: boolean;
+    }): ast.Parameter[];
     /** `private`, `readonly` or both before a parameter that is a property of its class. */
     private parsePropertyModifiers;
     /**
@@ -14,8 +19,36 @@ export declare abstract class ParamParser extends JumpParser {
      * not by `,` or `)`, so a parameter named bind, `(bind Mode)`, stays one.
      */
     private parseBindModifier;
+    /** `...parts []any`: the arguments after the others, in an array, as in JS. */
+    private parseTypedRest;
     /** `...attrs`: the attributes that a component passes on to one of its elements. */
     private parseRestParam;
-    /** Result types after a parameter list: nothing, `T`, or `(T1, T2)`. */
-    protected parseResults(): ast.TypeNode[];
+    /**
+     * Result types after a parameter list: nothing, `T`, or `(T1, T2)`. A `{` may start the body
+     * instead: it starts an object type when the body follows that type,
+     * `func names() { [string]: string } { ... }`, or a value does, `f func() { [string]: T } = g`.
+     * A method of an interface has no body, so there `{` is always a type.
+     */
+    protected parseResults(method?: boolean): ast.TypeNode[];
+    /** Whether the `{ ... }` here is followed by a body, `{`, or by a value, `=`. */
+    private objectTypeBeforeBody;
+    /**
+     * The type of a parameter of a function type, after its name if it has one, kept in `names`;
+     * `...` before the rest parameter is kept there too, `...parts`.
+     */
+    protected parseParamType(names: string[]): ast.TypeNode;
+    /** `func(string, ...[]any)`: the last parameter, taken out of `params`, if it is the rest. */
+    protected restOf(params: ast.TypeNode[], names: string[]): ast.TypeNode | null;
+    /**
+     * `func(a, b number)`: as in Go, if a parameter has a name, all have, so `a` alone is a name that
+     * shares the type of the next one. Without names, `func(A, B)` is a list of types.
+     */
+    protected groupParams(params: ast.TypeNode[], names: string[]): ast.TypeNode[];
+    /** `paths []string` in `(paths []string) => Shape`: a name before the type of a parameter. */
+    private startsNamedParam;
+    /**
+     * `load<number>(1)` would be two comparisons, `(load < number) > (1)`: a call takes no type
+     * arguments, which are inferred, so the likely mistake is reported as one.
+     */
+    protected rejectTypeArguments(): void;
 }

package/dist/parser/params.js

@@ -6,15 +6,20 @@ export class ParamParser extends JumpParser {
     /**
      * `(a, b number, c string)`. Names without a type take the type of the next typed name, as in
      * Go; only arrow functions may leave types out entirely. The parameters of a constructor can be
-     * properties: `(private name string)`.
+     * properties: `(private name string)`. Functions take `...parts []any` last, and components
+     * `...attrs`, the attributes of an element; both may have default values, `times = 1`.
      */
-    parseParams(typesOptional, allowDefaults = false, allowRest = false, allowProperties = false) {
+    parseParams(typesOptional, options = {}) {
+        const { defaults: allowDefaults = false, properties: allowProperties = false } = options;
+        const allowRest = options.rest === 'attrs';
         this.expect('(');
         const params = [];
         let untyped = 0;
         while (!this.check(')')) {
             if (this.check('...')) {
-                params.push(this.parseRestParam(allowRest));
+                params.push(options.rest === 'typed'
+                    ? this.parseTypedRest(typesOptional)
+                    : this.parseRestParam(allowRest));
                 break;
             }
             const paramStart = this.peek().start;
@@ -35,7 +40,11 @@ export class ParamParser extends JumpParser {
                 ...(bind ? { bind: true } : {}),
                 ...this.span(paramStart),
             });
-            if (type === null) {
+            // `times = 1` has the type of its value.
+            if (type === null && defaultValue !== null) {
+                untyped = 0;
+            }
+            else if (type === null) {
                 untyped++;
             }
             else {
@@ -100,12 +109,30 @@ export class ParamParser extends JumpParser {
         }
         return true;
     }
+    /** `...parts []any`: the arguments after the others, in an array, as in JS. */
+    parseTypedRest(typesOptional) {
+        const start = this.next().start;
+        const name = this.parseIdentifier('parameter name');
+        const type = this.canStartType() ? this.parseType() : null;
+        if (type === null && !typesOptional) {
+            this.error(`...${name.name} needs the type of its array, e.g. ...${name.name} []any`, start, name.end);
+        }
+        // After the error, the rest of the list is skipped up to the `)`.
+        if (this.check(',')) {
+            this.error(`...${name.name} is the last parameter`, start, name.end);
+            while (!this.check(')') && !this.check('EOF'))
+                this.next();
+        }
+        if (this.check('='))
+            this.error(`...${name.name} has no default value: it is [] without arguments`, start, name.end);
+        return { kind: 'Parameter', name, type, defaultValue: null, rest: true, ...this.span(start) };
+    }
     /** `...attrs`: the attributes that a component passes on to one of its elements. */
     parseRestParam(allowed) {
         const start = this.next().start;
         const name = this.parseIdentifier('parameter name');
         if (!allowed) {
-            this.error(`...${name.name} is only for components: it takes the attributes of an element`, start, name.end);
+            this.error(`...${name.name} needs the type of its array, e.g. ...${name.name} []any`, start, name.end);
         }
         if (this.canStartType() || this.check('=')) {
             const at = this.peek().start;
@@ -131,13 +158,120 @@ export class ParamParser extends JumpParser {
             ...this.span(start),
         };
     }
-    /** Result types after a parameter list: nothing, `T`, or `(T1, T2)`. */
-    parseResults() {
+    /**
+     * Result types after a parameter list: nothing, `T`, or `(T1, T2)`. A `{` may start the body
+     * instead: it starts an object type when the body follows that type,
+     * `func names() { [string]: string } { ... }`, or a value does, `f func() { [string]: T } = g`.
+     * A method of an interface has no body, so there `{` is always a type.
+     */
+    parseResults(method = false) {
         if (this.accept('('))
             return this.parseList(')', () => this.parseType());
-        // `{` after the parameters starts the body, so an object result type needs parentheses.
-        if (this.canStartType() && !this.check('{'))
+        if (this.check('{') && !method && !this.objectTypeBeforeBody())
+            return [];
+        if (this.canStartType())
             return [this.parseType()];
         return [];
     }
+    /** Whether the `{ ... }` here is followed by a body, `{`, or by a value, `=`. */
+    objectTypeBeforeBody() {
+        let depth = 0;
+        for (let offset = 0;; offset++) {
+            const { kind } = this.peek(offset);
+            if (kind === 'EOF')
+                return false;
+            if (kind === '{')
+                depth++;
+            else if (kind === '}' && --depth === 0) {
+                const next = this.peek(offset + 1).kind;
+                return next === '{' || next === '=';
+            }
+        }
+    }
+    /**
+     * The type of a parameter of a function type, after its name if it has one, kept in `names`;
+     * `...` before the rest parameter is kept there too, `...parts`.
+     */
+    parseParamType(names) {
+        const rest = this.accept('...') ? '...' : '';
+        names.push(rest + (this.check('Identifier') && this.startsNamedParam() ? this.next().text : ''));
+        return this.parseType();
+    }
+    /** `func(string, ...[]any)`: the last parameter, taken out of `params`, if it is the rest. */
+    restOf(params, names) {
+        const at = names.findIndex((name) => name.startsWith('...'));
+        if (at === -1)
+            return null;
+        if (at !== params.length - 1) {
+            this.error('the rest parameter is the last one, e.g. func(string, ...[]any)', params[at].start, params[at].end);
+        }
+        names.splice(at, 1);
+        return params.splice(at, 1)[0];
+    }
+    /**
+     * `func(a, b number)`: as in Go, if a parameter has a name, all have, so `a` alone is a name that
+     * shares the type of the next one. Without names, `func(A, B)` is a list of types.
+     */
+    groupParams(params, names) {
+        // `...` alone, an unnamed rest parameter, gives no name.
+        const named = (name) => name.replace(/^\.\.\./, '') !== '';
+        if (!names.some(named))
+            return params;
+        return params.map((param, i) => {
+            if (names[i] !== '' || param.kind !== 'TypeReference' || param.typeArgs.length > 0) {
+                return param;
+            }
+            const shared = names.findIndex((name, j) => j > i && named(name));
+            if (shared === -1) {
+                this.error(`parameter "${param.name.name}" has no type: write it after the name, e.g. func(a, b number)`, param.start, param.end);
+                return param;
+            }
+            names[i] = param.name.name;
+            return params[shared];
+        });
+    }
+    /** `paths []string` in `(paths []string) => Shape`: a name before the type of a parameter. */
+    startsNamedParam() {
+        const next = this.peek(1);
+        switch (next.kind) {
+            case 'Identifier':
+            case '?':
+            case '{':
+            case '(':
+            case 'func':
+            case 'chan':
+            case '<-':
+            case 'String':
+            case 'Number':
+                return true;
+            // `x []number` is named.
+            case '[':
+                return this.peek(2).kind === ']';
+            default:
+                return false;
+        }
+    }
+    /**
+     * `load<number>(1)` would be two comparisons, `(load < number) > (1)`: a call takes no type
+     * arguments, which are inferred, so the likely mistake is reported as one.
+     */
+    rejectTypeArguments() {
+        const TYPE_TOKENS = new Set(['Identifier', ',', '[', ']', '?', '.', '|', 'chan']);
+        let depth = 0;
+        for (let offset = 0;; offset++) {
+            const { kind } = this.peek(offset);
+            if (kind === '<')
+                depth++;
+            else if (kind === '>')
+                depth--;
+            else if (!TYPE_TOKENS.has(kind))
+                return;
+            if (depth === 0) {
+                if (this.peek(offset + 1).kind !== '(')
+                    return;
+                break;
+            }
+        }
+        this.fail('a call takes no type arguments: they are inferred from the arguments and the expected type; give the variable a type instead, e.g. const done Promise<void> = new Promise(...)');
+    }
 }

package/dist/parser/postfix.d.ts

@@ -0,0 +1,5 @@
+import type * as ast from '../ast.ts';
+import { ExpressionParser } from './expressions.ts';
+export declare abstract class PostfixParser extends ExpressionParser {
+    protected parsePostfix(expression: ast.Expression): ast.Expression;
+}

package/dist/parser/postfix.js

@@ -0,0 +1,36 @@
+import { ExpressionParser } from "./expressions.js";
+// What may follow a value besides members, indexes and calls: `user!`, which takes it not to be
+// null, and a template right after it, sql`select ... ${id}`, which calls it with its parts.
+export class PostfixParser extends ExpressionParser {
+    parsePostfix(expression) {
+        let result = super.parsePostfix(expression);
+        while (true) {
+            const token = this.peek();
+            // `user!.name`: the `!` right after the value, so that `!` before a value stays a negation.
+            if (token.kind === '!' && token.start === result.end) {
+                this.next();
+                result = {
+                    kind: 'NonNullExpression',
+                    expression: result,
+                    start: result.start,
+                    end: token.end,
+                };
+            }
+            else if ((token.kind === 'Template' || token.kind === 'TemplateHead') &&
+                !token.newlineBefore) {
+                const quasi = this.parseTemplate(token);
+                result = {
+                    kind: 'TaggedTemplateExpression',
+                    tag: result,
+                    quasi,
+                    start: result.start,
+                    end: quasi.end,
+                };
+            }
+            else {
+                return result;
+            }
+            result = super.parsePostfix(result);
+        }
+    }
+}

package/dist/parser/simple-statements.d.ts

@@ -19,5 +19,7 @@ export declare abstract class SimpleStatementParser extends ParserBase {
     /** `ref input` is one name, and the markup gives its element. */
     private checkRef;
     private parseDerivedBlock;
+    /** `const { name, size: bytes, ...rest } = file`: fields of an object, one level deep. */
+    private parseDestructuring;
     protected parseVariableDeclaration(start: number, exported: boolean): ast.VariableDeclaration;
 }

package/dist/parser/simple-statements.js

@@ -96,6 +96,10 @@ export class SimpleStatementParser extends ParserBase {
         // `data, err = try JSON.parse(text)`: the value and the error, as from a call.
         if (values.length === 1 && value?.kind === 'TryExpression')
             return;
+        if (values.length === 1 && value?.kind === 'ConditionalExpression') {
+            this.error('a conditional expression gives one value, not the results of a call: unpack them in the branches of if/else, e.g. if ok { a, err = two() } else { a, err = other() }', start, this.span(start).end);
+            return;
+        }
         this.error(`assignment mismatch: ${plural(targets, 'variable')} but ${plural(values.length, 'value')}`, start, this.span(start).end);
     }
     /** `delete scores[name]`: removes a field, so the target is one. */
@@ -135,6 +139,49 @@ export class SimpleStatementParser extends ParserBase {
             end: body.end,
         };
     }
+    /** `const { name, size: bytes, ...rest } = file`: fields of an object, one level deep. */
+    parseDestructuring(start, exported, keyword) {
+        const names = [];
+        const keys = [];
+        let rest = false;
+        this.expect('{');
+        this.parseList('}', () => {
+            if (rest)
+                this.fail('...rest is the last name: it gets the other fields');
+            if (this.accept('...')) {
+                rest = true;
+                names.push(this.parseIdentifier('variable name'));
+                return;
+            }
+            const token = this.peek();
+            const key = this.check('String') ? this.parseStringLiteral() : this.parsePropertyName();
+            if (this.accept(':')) {
+                names.push(this.parseIdentifier('variable name'));
+            }
+            else if (key.kind === 'Identifier' && token.kind === 'Identifier') {
+                names.push({ ...key });
+            }
+            else {
+                const shown = token.kind === 'String' ? token.text : `"${token.text}"`;
+                this.fail(`${shown} needs a name to take its value, e.g. { ${token.text}: name }`);
+            }
+            keys.push(key);
+        });
+        this.expect('=', '"=" and the object: a pattern takes its fields from a value');
+        const value = this.parseExpression();
+        return {
+            kind: 'VariableDeclaration',
+            exported,
+            keyword,
+            isPublic: false,
+            names,
+            type: null,
+            values: [value],
+            body: null,
+            pattern: { keys, rest },
+            ...this.span(start),
+        };
+    }
     parseVariableDeclaration(start, exported) {
         const token = this.next();
         const keyword = token.kind === 'const'
@@ -142,6 +189,9 @@ export class SimpleStatementParser extends ParserBase {
             : token.text === 'state' || token.text === 'derived' || token.text === 'ref'
                 ? token.text
                 : 'let';
+        if (this.check('{') && (keyword === 'const' || keyword === 'let')) {
+            return this.parseDestructuring(start, exported, keyword);
+        }
         const names = [this.parseIdentifier('variable name')];
         while (this.accept(','))
             names.push(this.parseIdentifier('variable name'));

package/dist/parser/statements.js

@@ -158,14 +158,15 @@ export class StatementParser extends SimpleStatementParser {
                 return this.parseDecorated(start, exported);
             case 'interface':
                 return this.parseInterface(start, exported);
-            case 'type': {
-                const declaration = this.parseTypeAlias(start, exported);
-                this.endStatement();
-                return declaration;
-            }
             default: {
                 if (this.isDecoratorDeclaration())
                     return this.parseDecoratorDeclaration(start, exported);
+                // `type` is a keyword only before the name of a type: `const type = blob.type` is a name.
+                if (this.checkWord('type') && this.peek(1).kind === 'Identifier') {
+                    const declaration = this.parseTypeAlias(start, exported);
+                    this.endStatement();
+                    return declaration;
+                }
                 // `data` and `abstract` are keywords only before `class`: elsewhere they are names.
                 let words = this.checkWord('abstract') ? 1 : 0;
                 if (this.peek(words).text === 'data')
@@ -178,8 +179,9 @@ export class StatementParser extends SimpleStatementParser {
     }
     /** A statement ends with a newline or `;`, or right before the `}` that closes its block. */
     endStatement() {
-        if (this.accept(';') || this.check('}') || this.check('EOF'))
+        if (this.accept(';') || this.check('}') || this.check('EOF') || this.afterTypeArguments()) {
             return;
+        }
         const token = this.peek();
         if (token.kind === '++' || token.kind === '--') {
             this.fail(`"${token.kind}" is a statement and cannot be used inside an expression`);

package/dist/parser/syntax.js

@@ -83,7 +83,6 @@ export const STATEMENT_KEYWORDS = new Set([
     'const',
     'class',
     'interface',
-    'type',
     'return',
     'if',
     'for',

package/dist/parser/types.d.ts

@@ -13,10 +13,6 @@ export declare abstract class TypeParser extends ClassParser {
      * names, which only document them.
      */
     protected parseParenthesizedType(): ast.TypeNode;
-    /** The type of a parameter of a function type, after its name if it has one, kept in `names`. */
-    private parseParamType;
-    /** `paths []string` in `(paths []string) => Shape`: a name before the type of a parameter. */
-    private startsNamedParam;
     /** `{ name string; x, y number; area() number }`, separated by newlines, `;` or `,`. */
     protected parseTypeMembers(): ast.TypeMember[];
     protected parseTypeMember(): ast.TypeMember[];