@syncular/typegen 0.6.0 → 0.8.0

package/dist/syql-semantics.js

@@ -6,6 +6,12 @@
  * `when` dominance, and produces a backend-neutral logical template.
  */
 import { SyqlFrontendError, } from './syql-lexer.js';
+export function syqlRangeStartBind(name) {
+    return `__syqlRangeStart_${name}`;
+}
+export function syqlRangeEndBind(name) {
+    return `__syqlRangeEnd_${name}`;
+}
 function predicateId(file, name) {
     return `${file}\0${name}`;
 }
@@ -69,7 +75,9 @@ class SemanticAnalyzer {
             for (const node of predicate.declaration.body.tree.nodes) {
                 if (node.kind !== 'predicate-call')
                     continue;
-                const target = this.#resolveCall(predicate.module, node.name, node.span);
+                const target = this.#lookupCall(predicate.module, node.name);
+                if (target === undefined)
+                    continue;
                 this.#checkArity(node.arguments.length, target, node.span);
                 calls.push(target);
             }
@@ -112,11 +120,14 @@ class SemanticAnalyzer {
                     }
                 }
                 else if (node.kind === 'predicate-call') {
+                    const target = this.#lookupCall(predicate.module, node.name);
                     for (const argument of node.arguments) {
                         if (!declared.has(argument.name)) {
                             this.#fail('SYQL5004_CLOSED_PREDICATE', argument.span, `predicate ${predicate.declaration.name} passes undeclared bind :${argument.name}`);
                         }
                     }
+                    if (target === undefined)
+                        continue;
                 }
             }
         }
@@ -135,6 +146,11 @@ class SemanticAnalyzer {
                 }
                 else if (node.kind === 'predicate-call') {
                     const target = scope.get(node.name);
+                    if (target === undefined) {
+                        for (const argument of node.arguments)
+                            used.add(argument.name);
+                        continue;
+                    }
                     const targetUsed = computeUsed(target);
                     target.declaration.parameters.forEach((formal, index) => {
                         if (targetUsed.has(formal.name)) {
@@ -174,6 +190,8 @@ class SemanticAnalyzer {
                 if (node.kind !== 'predicate-call')
                     continue;
                 const target = scope.get(node.name);
+                if (target === undefined)
+                    continue;
                 const targetConstraints = constraintsFor(target);
                 target.declaration.parameters.forEach((formal, index) => {
                     const actual = node.arguments[index];
@@ -212,8 +230,11 @@ class SemanticAnalyzer {
     }
     #analyzeQuery(module, query) {
         const bindSymbols = this.#queryBindSymbols(query);
+        const ranges = new Map(query.parameters.flatMap((parameter) => parameter.kind === 'range'
+            ? [[parameter.name, parameter]]
+            : []));
         const requirements = new Map();
-        const template = this.#expandTemplate(module, query.sql.body.tree, new Map(), { queryBinds: bindSymbols, requirements });
+        const template = this.#expandTemplate(module, query.statement.tree, new Map(), { queryBinds: bindSymbols, ranges, requirements });
         const conditions = [];
         this.#collectConditions(template, conditions);
         this.#validateControls(query, conditions);
@@ -234,9 +255,21 @@ class SemanticAnalyzer {
     #queryBindSymbols(query) {
         const symbols = new Map();
         for (const parameter of query.parameters) {
-            if (parameter.kind === 'switch')
-                continue;
-            if (parameter.kind === 'group') {
+            if (parameter.kind === 'range') {
+                for (const name of [
+                    syqlRangeStartBind(parameter.name),
+                    syqlRangeEndBind(parameter.name),
+                ]) {
+                    symbols.set(name, {
+                        name,
+                        parameter,
+                        ...(parameter.optional ? { controller: parameter.name } : {}),
+                        ...(parameter.type === undefined ? {} : { type: parameter.type }),
+                        span: parameter.nameSpan,
+                    });
+                }
+            }
+            else if (parameter.kind === 'group') {
                 for (const member of parameter.members) {
                     symbols.set(member.name, {
                         name: member.name,
@@ -264,48 +297,31 @@ class SemanticAnalyzer {
     }
     #expandNode(module, node, substitution, context) {
         if (node.kind === 'raw') {
-            const parts = [];
-            for (const token of node.tokens) {
-                if (token.kind !== 'bind') {
-                    const previous = parts[parts.length - 1];
-                    if (previous?.kind === 'text') {
-                        parts[parts.length - 1] = {
-                            kind: 'text',
-                            text: previous.text + token.text,
-                        };
-                    }
-                    else {
-                        parts.push({ kind: 'text', text: token.text });
-                    }
-                    continue;
-                }
-                const authored = bindName(token);
-                const substituted = substitution.get(authored);
-                parts.push({
-                    kind: 'bind',
-                    name: substituted?.name ?? authored,
-                    span: token.span,
-                    origins: substituted === undefined
-                        ? [token.span]
-                        : [...substituted.origins, token.span],
-                });
-            }
-            return { kind: 'sql', parts, span: node.span };
+            return {
+                kind: 'sql',
+                parts: this.#expandSqlTokens(node.tokens, substitution, context),
+                span: node.span,
+            };
         }
         if (node.kind === 'when') {
             return {
                 kind: 'when',
                 controls: node.controls,
+                explicitPresence: node.explicitPresence,
                 controlSpans: node.controlSpans,
                 body: this.#expandTemplate(module, node.body, substitution, context),
                 span: node.span,
             };
         }
-        if (node.kind === 'scope' || node.kind === 'cover') {
-            return { kind: node.kind, directive: node, span: node.span };
-        }
         const call = node;
-        const target = this.#resolveCall(module, call.name, call.span);
+        const target = this.#lookupCall(module, call.name);
+        if (target === undefined) {
+            return {
+                kind: 'sql',
+                parts: this.#expandSqlTokens(call.tokens, substitution, context),
+                span: call.span,
+            };
+        }
         this.#checkArity(call.arguments.length, target, call.span);
         const targetSubstitution = new Map();
         target.declaration.parameters.forEach((formal, index) => {
@@ -330,6 +346,46 @@ class SemanticAnalyzer {
             span: call.span,
         };
     }
+    #expandSqlTokens(tokens, substitution, context) {
+        const parts = [];
+        const pushText = (text) => {
+            const previous = parts[parts.length - 1];
+            if (previous?.kind === 'text') {
+                parts[parts.length - 1] = { kind: 'text', text: previous.text + text };
+            }
+            else
+                parts.push({ kind: 'text', text });
+        };
+        const pushBind = (name, token, origins) => {
+            parts.push({ kind: 'bind', name, span: token.span, origins });
+        };
+        for (const token of tokens) {
+            if (token.kind !== 'bind') {
+                pushText(token.text);
+                continue;
+            }
+            const authored = bindName(token);
+            const substituted = substitution.get(authored);
+            if (substituted !== undefined) {
+                const parameter = context.ranges?.get(substituted.name);
+                if (parameter !== undefined) {
+                    this.#fail('SYQL5011_TYPE_CONFLICT', token.span, `range input ${parameter.name} cannot be passed to a predicate`);
+                }
+                pushBind(substituted.name, token, [...substituted.origins, token.span]);
+                continue;
+            }
+            const range = context.ranges?.get(authored);
+            if (range !== undefined) {
+                pushBind(syqlRangeStartBind(range.name), token, [token.span]);
+                pushText(' and ');
+                pushBind(syqlRangeEndBind(range.name), token, [token.span]);
+            }
+            else {
+                pushBind(authored, token, [token.span]);
+            }
+        }
+        return parts;
+    }
     #collectConditions(nodes, out) {
         for (const node of nodes) {
             if (node.kind === 'when')
@@ -346,8 +402,14 @@ class SemanticAnalyzer {
                 if (parameter === undefined) {
                     this.#fail('SYQL5008_INVALID_CONTROL', condition.controlSpans[index], `unknown when control ${JSON.stringify(name)}`);
                 }
-                if (parameter.kind === 'value' && !parameter.optional) {
-                    this.#fail('SYQL5008_INVALID_CONTROL', condition.controlSpans[index], `required scalar ${name} cannot control when; only optional values, groups, and switches can`);
+                if (condition.explicitPresence[index] && !parameter.optional) {
+                    this.#fail('SYQL5008_INVALID_CONTROL', condition.controlSpans[index], `present(${name}) requires an optional input`);
+                }
+                if (!parameter.optional &&
+                    !(parameter.kind === 'value' &&
+                        parameter.type?.base === 'boolean' &&
+                        parameter.default === false)) {
+                    this.#fail('SYQL5008_INVALID_CONTROL', condition.controlSpans[index], `required input ${name} cannot control when; use an optional input or a bool defaulted to false`);
                 }
             });
         }
@@ -392,18 +454,6 @@ class SemanticAnalyzer {
                     }
                     walk(node.body, next);
                 }
-                else {
-                    for (const binding of node.directive.bindings) {
-                        for (const value of binding.values) {
-                            record({
-                                kind: 'bind',
-                                name: value.name,
-                                span: value.span,
-                                origins: [value.span],
-                            }, active);
-                        }
-                    }
-                }
             }
         };
         walk(template, new Set());
@@ -424,18 +474,29 @@ class SemanticAnalyzer {
             collect(condition.body);
             condition.controls.forEach((control, index) => {
                 const parameter = query.parameters.find((item) => item.name === control);
-                if (parameter?.kind === 'value' && !conditionUses.has(control)) {
+                if (parameter?.kind === 'value' &&
+                    parameter.default === undefined &&
+                    !conditionUses.has(control)) {
                     this.#fail('SYQL5010_UNUSED_CONTROL', condition.controlSpans[index], `when(${control}) does not use :${control} in its body`);
                 }
                 if (parameter?.kind === 'group' &&
                     !parameter.members.some((member) => conditionUses.has(member.name))) {
                     this.#fail('SYQL5010_UNUSED_CONTROL', condition.controlSpans[index], `when(${control}) does not use a member of group ${control}`);
                 }
+                if (parameter?.kind === 'range' &&
+                    !conditionUses.has(syqlRangeStartBind(parameter.name))) {
+                    this.#fail('SYQL5010_UNUSED_CONTROL', condition.controlSpans[index], `when(${control}) does not use range :${control}`);
+                }
             });
         }
         for (const parameter of query.parameters) {
-            if (parameter.kind === 'switch') {
-                if (!usedControls.has(parameter.name)) {
+            if (parameter.kind === 'range') {
+                if (parameter.optional && !usedControls.has(parameter.name)) {
+                    this.#unusedInput(parameter.nameSpan, parameter.name);
+                }
+                const start = syqlRangeStartBind(parameter.name);
+                const end = syqlRangeEndBind(parameter.name);
+                if (!allUses.has(start) || !allUses.has(end)) {
                     this.#unusedInput(parameter.nameSpan, parameter.name);
                 }
             }
@@ -454,7 +515,8 @@ class SemanticAnalyzer {
                     this.#unusedInput(parameter.nameSpan, parameter.name);
                 }
             }
-            else if (!allUses.has(parameter.name)) {
+            else if (!allUses.has(parameter.name) &&
+                !(parameter.default !== undefined && usedControls.has(parameter.name))) {
                 this.#unusedInput(parameter.nameSpan, parameter.name);
             }
         }
@@ -497,26 +559,20 @@ class SemanticAnalyzer {
         return resolved;
     }
     #parameterType(parameter, resolved) {
-        if (parameter.kind === 'switch')
-            return undefined;
-        if (parameter.kind === 'group') {
+        if (parameter.kind === 'range' || parameter.kind === 'group') {
             // Group members carry their own types; the logical input itself has no
             // scalar type. L3 consumes the per-member resolved map directly.
             return undefined;
         }
         return parameter.type ?? resolved.get(parameter.name);
     }
-    #resolveCall(module, name, span) {
-        const target = this.#scopes.get(module.file)?.get(name);
-        if (target === undefined) {
-            this.#fail('SYQL5001_UNKNOWN_PREDICATE', span, `unknown predicate @${name} in ${module.file}`);
-        }
-        return target;
+    #lookupCall(module, name) {
+        return this.#scopes.get(module.file)?.get(name);
     }
     #checkArity(actual, target, span) {
         const expected = target.declaration.parameters.length;
         if (actual !== expected) {
-            this.#fail('SYQL5003_PREDICATE_ARITY', span, `@${target.declaration.name} expects ${expected} argument(s), got ${actual}`);
+            this.#fail('SYQL5003_PREDICATE_ARITY', span, `${target.declaration.name} expects ${expected} argument(s), got ${actual}`);
         }
     }
     #unusedInput(span, name) {
@@ -545,7 +601,7 @@ export function renderSyqlLogicalTemplate(nodes) {
         if (node.kind === 'when') {
             return `when(${node.controls.join(', ')}) {${renderSyqlLogicalTemplate(node.body)}}`;
         }
-        return node.directive.tokens.map((token) => token.text).join('');
+        throw new Error('unknown SYQL logical template node');
     })
         .join('');
 }

package/dist/syql-template-parser.d.ts

@@ -23,30 +23,15 @@ export interface SyqlPredicateCall {
 export interface SyqlWhenExpression {
     readonly kind: 'when';
     readonly controls: readonly string[];
+    /** True when the author wrote present(control); bare optional controls have
+     * the same semantics and therefore normally keep this false. */
+    readonly explicitPresence: readonly boolean[];
     readonly controlSpans: readonly SyqlSourceSpan[];
     readonly body: SyqlEmbeddedTemplate;
     readonly tokens: readonly SyqlToken[];
     readonly span: SyqlSourceSpan;
 }
-export interface SyqlQualifiedColumn {
-    readonly qualifier: string;
-    readonly name: string;
-    readonly span: SyqlSourceSpan;
-}
-export interface SyqlScopeBinding {
-    readonly kind: 'scope-binding';
-    readonly column: SyqlQualifiedColumn;
-    readonly operator: 'equal' | 'in';
-    readonly values: readonly SyqlBindReference[];
-    readonly span: SyqlSourceSpan;
-}
-export interface SyqlReactiveDirective {
-    readonly kind: 'scope' | 'cover';
-    readonly bindings: readonly SyqlScopeBinding[];
-    readonly tokens: readonly SyqlToken[];
-    readonly span: SyqlSourceSpan;
-}
-export type SyqlEmbeddedNode = SyqlRawTemplateNode | SyqlPredicateCall | SyqlWhenExpression | SyqlReactiveDirective;
+export type SyqlEmbeddedNode = SyqlRawTemplateNode | SyqlPredicateCall | SyqlWhenExpression;
 export interface SyqlEmbeddedTemplate {
     readonly kind: 'template';
     readonly mode: SyqlTemplateMode;
@@ -55,4 +40,4 @@ export interface SyqlEmbeddedTemplate {
 }
 export type SyqlTemplateParseErrorCode = 'SYQL3001_EXPECTED_EMBEDDED_TOKEN' | 'SYQL3002_INVALID_BIND' | 'SYQL3003_INVALID_PREDICATE_CALL' | 'SYQL3004_INVALID_WHEN' | 'SYQL3005_INVALID_REACTIVE_DIRECTIVE' | 'SYQL3006_FORBIDDEN_TEMPLATE_NODE' | 'SYQL3007_UNEXPECTED_BRACE' | 'SYQL3008_FORBIDDEN_PARAMETER_FORM';
 /** Parse embedded nodes from one already-delimited lossless template. */
-export declare function parseSyqlEmbeddedTemplate(file: string, tokens: readonly SyqlToken[], span: SyqlSourceSpan, mode: SyqlTemplateMode): SyqlEmbeddedTemplate;
+export declare function parseSyqlEmbeddedTemplate(file: string, tokens: readonly SyqlToken[], span: SyqlSourceSpan, mode: SyqlTemplateMode, rangeNames?: ReadonlySet<string>): SyqlEmbeddedTemplate;