kopscript 0.17.0 → 0.19.0

package/LLM.md

@@ -167,13 +167,51 @@ string Classify(string input) {
   return match input {
     "cat", "dog" => "animal",     // comma = OR within one arm
     r"^[0-9]+$" => "number",      // regex pattern, r"..."
-    _ => "unknown"                // wildcard REQUIRED — exhaustiveness-checked
+    _ => "unknown"                // wildcard REQUIRED for a string subject
   };
 }
 ```
 
-`match` is an expression (has a value), matches on literal/regex patterns only (not
-type patterns, not destructuring), and always requires a trailing `_` arm.
+`match` is an expression (has a value) over one of two kinds of subject:
+
+- **`string`** — literal/regex patterns only (not type patterns, not destructuring),
+  and always requires a trailing `_` arm, exactly as above.
+- **an `enum`** — patterns name a member of that same enum (`EnumName.Member`, comma
+  for OR within one arm, same as a string match); no regex patterns (there's nothing
+  to run a regex against). **Real exhaustiveness**: covering every declared member
+  lets the trailing `_` be omitted entirely — there's nothing left for it to catch —
+  and a member missing from BOTH the arms and a trailing wildcard is a compile error
+  naming exactly which member(s) are missing:
+
+```ks
+enum OrderState { Pending, Shipped, Delivered, Cancelled }
+
+string Describe(OrderState s) {
+  return match s {
+    OrderState.Pending => "placed",
+    OrderState.Shipped => "shipped",
+    OrderState.Delivered => "delivered",
+    OrderState.Cancelled => "cancelled"
+    // no `_` needed — every member is covered; add a 5th enum member later
+    // without updating this match, and this stops compiling.
+  };
+}
+```
+
+A partial enum match still works exactly like a string match — cover the cases you
+care about and fall back with `_`:
+
+```ks
+string UrgencyOf(OrderState s) {
+  return match s {
+    OrderState.Cancelled => "none",
+    _ => "normal"
+  };
+}
+```
+
+`match` still doesn't support type patterns or destructuring for either subject kind
+— an enum match's patterns are exactly its own members, nothing more general.
 
 ## Statements
 
@@ -233,6 +271,18 @@ literal in the language, which do interpret `\n`/`\t`/`\\`/etc.
 lambda's own first parameter cannot itself be a function type (a rare v1 parser
 limitation, not a semantic one).
 
+**An expression-bodied lambda may discard a non-`void` result where `() => void` is
+expected** — the fire-and-forget shape a `setTimeout`/`setInterval` callback needs:
+```ks
+public async task DoWork() { ... }
+SetTimeout(() => this.DoWork(), 300);   // () => task discarded into () => void — fine
+```
+This is narrower than "anything is assignable to `void`": a `void`-returning
+function's own `return expr;` is still a real error, checked separately — this only
+relaxes a lambda's own trailing expression value when nothing will ever read it,
+matching the same allowance TypeScript gives a `Promise`-returning function passed
+where `() => void` is expected.
+
 ### Arrays
 
 ```ks
@@ -403,6 +453,16 @@ parameter, not a syntax feature to reach for. A constrained type parameter (`T :
 IComparable`) works exactly like it does on a class — the inferred type must satisfy it,
 checked after inference succeeds.
 
+**Extern generic free functions**: an `extern` free function can carry its own type
+parameter list too, re-describing a real generic free function from another package
+(the same shape `extern class Name<T> { ... }` already gives a generic class):
+```ks
+extern (T) => string? CombineValidators2<T>((T) => string? v1, (T) => string? v2) from "kopular/forms";
+(string) => string? combined = CombineValidators2(Required, TooLong);
+```
+Inference, constraints, and arity all work exactly the same as a real generic
+function's — the extern boundary doesn't lose any of it.
+
 **Does not exist (v1 scope cuts, each deliberate)**:
 - **Generic methods.** A class method can't introduce its own new type parameter beyond
   its enclosing class's (generic functions are free-function-only — see above).
@@ -492,6 +552,13 @@ constraint errors included) — and a real KopScript class can extend a generic
 class` with a concrete or threaded-through type argument, same as extending a real generic
 base.
 
+An extern *free function* (the first form above) can carry its own type parameter list
+too, the same place a real generic free function's goes — right after the name:
+`extern (T) => string? CombineValidators2<T>((T) => string? v1, (T) => string? v2) from
+"kopular/forms";`. Inference/constraints/arity all work identically to a real generic
+function (see "Generics" above) — only an extern *value* declaration (the second form)
+can never have one, since there's no call site for a type argument to attach to.
+
 **Never write `async` on an extern function/method signature** — declare its return type
 as `task`/`task<T>` directly (`task<string> text();`, not `async task<string> text();`).
 `async` only means something for a *body* the checker validates (legalizing `await`
@@ -550,6 +617,12 @@ class Counter : Component {
   `[prop]="expr"` (→ a plain field assignment for `id`/`className`/`value`, or
   `VElement.SetAttr("prop", expr)` for anything else), static `attr="..."` (`class` aliases
   to `className`).
+- **Two-way binding**: `[(value)]="Field"` → `[value]="Field"` + an auto-generated
+  `(input)="Field = e.target.value"`. `value` only (`KS5017` otherwise — no other
+  `VElement` field has an equivalent "user just changed this" event); `Field` must resolve
+  to a bare name or `this.Field` (`KS5018` otherwise — anything else has nothing sensible
+  to assign back into). A hand-written `Render()` has no equivalent shorthand — it already
+  has direct field/handler access, so there's nothing to desugar.
 - Structural directives: `*if="expr"` (→ real `if`), `*for="Type varName of expr"` (→ real
   `for..in`; the element type is explicit — no inference, same stance as Generics).
   At most one structural directive per element.
@@ -558,7 +631,7 @@ class Counter : Component {
   manual `Subscribe` needed for that field. State reached indirectly (through a method call,
   or `this.SomeService.Count`) still needs a manual `Subscribe`, unchanged from before.
 - Exactly one top-level element per template (no auto-wrap — hard error). No mixing text and
-  element children under one element. No two-way binding, no pipes, no stacked directives.
+  element children under one element. No pipes, no stacked directives.
 - `ks watch` tracks the referenced `.html` file as well as `.ks` dependencies.
 - Layering note: `template from` is kopscript grammar, but what it desugars *to*
   (`VElement.Create`/`.AppendChild`/`.TextContent`/`.SetAttr`/the named `On*` event fields)

package/README.md

@@ -330,6 +330,12 @@ if (c == Color.Green) { print("It's green"); }
 
 Members are numbered from `0` in declaration order, compiling to a frozen JS object.
 
+An enum is also a valid `match` subject (`match c { Color.Red => ..., Color.Green =>
+..., Color.Blue => ..., _ => ... }`, patterns naming its own members) — covering
+every member lets the trailing `_` be omitted, with a real compile error if one is
+missing and there's no `_` to fall back on. See LLM.md's "`match` expression" section
+for the full exhaustiveness rules.
+
 ### Modules
 
 `using "./shapes";` brings every `public` top-level declaration from that file (resolved
@@ -432,6 +438,11 @@ extern class Box<T> {
 Box<number> nb = new Box<number>(5);
 ```
 
+An extern *free function* can be generic the same way — `extern (T) => string?
+CombineValidators2<T>((T) => string? v1, (T) => string? v2) from "kopular/forms";`
+re-describes a real generic free function from another package, with the same
+inference/constraints a local one gets.
+
 Now that KopScript has `async`/`await` and `task<T>` (see below), a Promise-based JS API is
 describable too — `extern task<string> Fetch(...) from "..." as "fetch";` is legitimate,
 and `await`ing it works exactly like awaiting any other KopScript task. What's still not cleanly
@@ -606,10 +617,22 @@ Supported bindings and directives:
 | `{{ expr }}` (in text)       | `el.TextContent = $"...{expr}...";` (an `InterpolatedStringLiteral`, same as `$"..."`) |
 | `(event)="stmt"`             | `el.OnEvent = (Event e) => { stmt };` — `event` must be one of `click`/`input`/`blur`/`change`, `VElement`'s own fixed set of named event fields |
 | `[prop]="expr"`              | `el.Prop = expr;` for `id`/`className`/`value` (`VElement`'s own named fields); `el.SetAttr("prop", expr);` for anything else |
+| `[(value)]="Field"`          | sugar for `[value]="Field"` + `(input)="Field = e.target.value"` — see below |
 | `class="..."` (static)       | `el.ClassName = "...";` (aliased, since `class` is a KopScript keyword) |
 | `*if="expr"`                 | a real `if (expr) { ... }` around the element's creation |
 | `*for="Type var of expr"`    | a real `for (Type var in expr) { ... }` — the element type is explicit, matching KopScript's no-inference stance elsewhere (Generics, Nullable types) |
 
+**Two-way binding**: `[(value)]="Field"` (a template-only sugar — there's no equivalent
+shorthand for a hand-written `Render()`, which already has direct field/handler access)
+desugars to exactly the pair you'd otherwise write by hand: a `[value]` property binding
+plus an auto-generated `(input)` handler assigning back. Restricted to `value`
+specifically — the one `VElement` field a user can change through direct interaction
+(typing, picking an option); `[(id)]`/`[(className)]` are compile errors (`KS5017`), since
+neither has an equivalent "user just changed this" event. The bound expression must be a
+simple field reference (a bare name or `this.Field`, resolving the same way any other
+binding does) — `[(value)]="Field.Trim()"` is a compile error (`KS5018`), since there's
+nothing sensible to assign back into.
+
 **Auto-subscribe**: a `state<T>` field declared directly on the component and referenced
 directly in its template (like `Count` above) gets its `Subscribe((v) => this.Update())`
 wired up automatically — no manual `Subscribe` call needed in the constructor. This is a
@@ -620,8 +643,8 @@ templates existed.
 
 v1 cuts, same discipline as generics and nullable types: exactly one top-level element per
 template (no auto-wrapping — a clear error instead); no mixing text and element children
-under one element (Kopular's DOM surface has no text-node type, only `.textContent`); no
-two-way binding, no pipes, no stacking two structural directives on one element.
+under one element (`VElement` has no text-node concept, only `.TextContent`); no pipes, no
+stacking two structural directives on one element.
 
 **A deliberate layering note**: the `template from` syntax lives in kopscript's own
 grammar (Kopular can't extend a language it doesn't own), but what it desugars *to* —

package/dist/checker.js

@@ -194,14 +194,21 @@ export class Checker {
             this.checkClassBody(c);
     }
     registerExternFunction(decl) {
-        // extern functions never take a type parameter of their own in v1 —
-        // generic functions (see registerFunction) are a real-function-only
-        // feature; an extern binding always describes a concrete signature.
-        this.functions.set(decl.name, {
-            typeParams: [],
-            typeParamConstraints: [],
+        // Same withTypeParamsInScope treatment registerFunction gives a real
+        // generic function's own signature — an extern free function can be
+        // generic too (re-describing a real generic free function from another
+        // package, e.g. Kopular's own `CombineValidators2<T>`), resolved the
+        // same way so `T` inside `decl.params`/`decl.returnType` resolves
+        // correctly instead of erroring as an unknown type.
+        const { params, returnType } = this.withTypeParamsInScope(decl.typeParams, () => ({
             params: decl.params.map((p) => this.resolveType(p.type, decl.line, decl.col)),
             returnType: this.resolveType(decl.returnType, decl.line, decl.col),
+        }));
+        this.functions.set(decl.name, {
+            typeParams: decl.typeParams.map((p) => p.name),
+            typeParamConstraints: decl.typeParams.map((p) => p.constraint),
+            params,
+            returnType,
         });
     }
     registerExternClass(decl) {
@@ -1644,6 +1651,19 @@ export class Checker {
             return expectedReturnType;
         }
         const actual = this.checkExpressionExpecting(expr.body, expectedReturnType, scope, lambdaCtx);
+        // An expression-bodied lambda whose expected type is `() => void` may
+        // still have a body that naturally evaluates to something non-void
+        // (`() => this.SubmitTask()` where SubmitTask is `async task`, the
+        // fire-and-forget shape `setTimeout`/`setInterval` callbacks need) —
+        // discarding that value is always safe, the same allowance TypeScript
+        // gives a `Promise`-returning function passed where `() => void` is
+        // expected. This is narrower than "anything is assignable to void": a
+        // `void`-returning FUNCTION's own `return expr;` is still checked
+        // separately and is still a real error — this only relaxes a lambda's
+        // own trailing expression value when nothing will ever read it.
+        if (expectedReturnType.kind === "void") {
+            return T.VOID;
+        }
         if (expectedReturnType.kind !== "unknown" && !this.isAssignableType(actual, expectedReturnType)) {
             this.diagnostics.error("KS4059", `Lambda body has type '${T.typeToString(actual)}', expected '${T.typeToString(expectedReturnType)}'`, expr.line, expr.col);
         }
@@ -2176,30 +2196,69 @@ export class Checker {
         }
         return { type: T.UNKNOWN, methodInfo: null };
     }
+    // `match` accepts two kinds of subject: `string` (the original, matching
+    // literal/regex patterns — unchanged below) and, as of this check, an
+    // `enum` (matching `EnumName.Member` patterns, with real exhaustiveness:
+    // every member covered lets the trailing `_` be omitted entirely, since
+    // there's nothing left for it to catch). Nothing else is valid — a
+    // `match` over a class/number/etc. was never supported and still isn't.
     checkMatch(expr, scope, ctx) {
         const subjectType = this.checkExpression(expr.subject, scope, ctx);
-        this.expectType(subjectType, T.STRING, expr.line, expr.col, "match subject");
+        const isEnumSubject = subjectType.kind === "enum";
+        // Still routed through the shared expectType helper (one literal
+        // KS4046 emission site for the whole checker — see diagnostics.test.ts's
+        // "codes are unique across every emission site"), so the message loses
+        // the "...or an enum" alternative when the subject is neither — an
+        // acceptable trade against introducing a second call site for what's
+        // still fundamentally "wrong type here."
+        if (!isEnumSubject) {
+            this.expectType(subjectType, T.STRING, expr.line, expr.col, "match subject");
+        }
+        const enumName = isEnumSubject ? subjectType.name : null;
         if (expr.arms.length === 0) {
             this.diagnostics.error("KS4086", `match expression must have at least one arm`, expr.line, expr.col);
             return T.UNKNOWN;
         }
         const lastArm = expr.arms[expr.arms.length - 1];
-        if (lastArm.pattern.kind !== "WildcardPattern") {
+        const hasTrailingWildcard = lastArm.pattern.kind === "WildcardPattern";
+        // A plain string match still always requires it (unchanged from
+        // before enums were supported) — only an enum subject can skip it, and
+        // only by covering every member explicitly instead (checked below,
+        // once every arm's patterns have been walked).
+        if (!hasTrailingWildcard && !isEnumSubject) {
             this.diagnostics.error("KS4087", `match expression must end with a wildcard '_' arm`, lastArm.line, lastArm.col);
         }
+        const coveredEnumMembers = new Set();
         let resultType = null;
         for (const arm of expr.arms) {
             if (arm.pattern.kind === "LiteralPattern") {
                 for (const value of arm.pattern.values) {
-                    if (value.kind !== "StringLiteral") {
-                        this.diagnostics.error("KS4088", `match patterns must be string literals`, value.line, value.col);
+                    if (isEnumSubject) {
+                        const valueType = this.checkExpression(value, scope, ctx);
+                        const isSameEnumMember = value.kind === "MemberExpr" && valueType.kind === "enum" && valueType.name === enumName;
+                        if (isSameEnumMember) {
+                            coveredEnumMembers.add(value.property);
+                        }
+                        else if (valueType.kind !== "unknown") {
+                            // valueType === "unknown" means checkExpression already
+                            // reported its own error (e.g. "Enum has no member X") —
+                            // don't pile a second, less specific one on top of it.
+                            this.reportInvalidMatchPattern(`match pattern must be a member of enum '${enumName}' (e.g. '${enumName}.SomeMember')`, value.line, value.col);
+                        }
+                    }
+                    else if (value.kind !== "StringLiteral") {
+                        this.reportInvalidMatchPattern(`match patterns must be string literals`, value.line, value.col);
                     }
                     else {
                         this.checkExpression(value, scope, ctx);
                     }
                 }
             }
-            // RegexPattern and WildcardPattern need no further checking here.
+            else if (arm.pattern.kind === "RegexPattern" && isEnumSubject) {
+                this.reportInvalidMatchPattern(`a regex pattern is not valid for a match over enum '${enumName}' — enum patterns must name a member`, arm.line, arm.col);
+            }
+            // WildcardPattern (and RegexPattern against a string subject) need no
+            // further checking here.
             const armResultType = this.checkExpression(arm.result, scope, ctx);
             if (resultType === null) {
                 resultType = armResultType;
@@ -2208,6 +2267,22 @@ export class Checker {
                 this.diagnostics.error("KS4089", `match arm result type '${T.typeToString(armResultType)}' does not match preceding arms' type '${T.typeToString(resultType)}'`, arm.line, arm.col);
             }
         }
+        if (isEnumSubject && enumName && !hasTrailingWildcard) {
+            const allMembers = [...(this.enums.get(enumName)?.members.keys() ?? [])];
+            const missing = allMembers.filter((m) => !coveredEnumMembers.has(m));
+            if (missing.length > 0) {
+                this.diagnostics.error("KS4105", `match over enum '${enumName}' is not exhaustive — missing case(s) for: ${missing.join(", ")} (add a case for each, or a trailing '_' arm)`, expr.line, expr.col);
+            }
+        }
         return resultType ?? T.UNKNOWN;
     }
+    // The one literal KS4088 emission site (three call sites in checkMatch
+    // route through it — see diagnostics.test.ts's "codes are unique across
+    // every emission site"): a match pattern that isn't valid for its
+    // subject's kind (not a string literal against a string subject, not a
+    // same-enum member reference against an enum subject, or a regex pattern
+    // against an enum subject at all).
+    reportInvalidMatchPattern(message, line, col) {
+        this.diagnostics.error("KS4088", message, line, col);
+    }
 }

package/dist/parser.js

@@ -214,7 +214,7 @@ export class Parser {
             this.diagnostics.error("KS2006", "'async' cannot modify a variable declaration", start.line, start.col);
         }
         if (typeParams.length > 0) {
-            this.diagnostics.error("KS2023", "A type parameter list is only allowed on a function declaration", start.line, start.col);
+            this.reportStrayTypeParamList(start.line, start.col);
         }
         this.consume(TokenKind.Assign, "Expected '=' in variable declaration");
         const init = this.parseExpression();
@@ -503,16 +503,33 @@ export class Parser {
         }
         const type = this.parseType();
         const name = this.consume(TokenKind.Identifier, "Expected name").lexeme;
+        // `extern (T) => string? CombineValidators2<T>(...) from "...";` — same
+        // type-param-list-right-after-the-name shape a real generic free
+        // function uses (see parseDeclaration); harmless to try unconditionally
+        // here too, since parseTypeParamList consumes nothing when `<` isn't
+        // next.
+        const typeParams = this.parseTypeParamList();
         if (this.check(TokenKind.LParen)) {
             const params = this.parseParamList();
             const { modulePath, jsName } = this.parseExternTail(name);
             this.consume(TokenKind.Semicolon, "Expected ';' after extern function declaration");
-            return { kind: "ExternFunctionDecl", isExported, name, jsName, params, returnType: type, modulePath, line: start.line, col: start.col };
+            return { kind: "ExternFunctionDecl", isExported, name, typeParams, jsName, params, returnType: type, modulePath, line: start.line, col: start.col };
+        }
+        if (typeParams.length > 0) {
+            this.reportStrayTypeParamList(start.line, start.col);
         }
         const { modulePath, jsName } = this.parseExternTail(name);
         this.consume(TokenKind.Semicolon, "Expected ';' after extern declaration");
         return { kind: "ExternValueDecl", isExported, name, jsName, type, modulePath, line: start.line, col: start.col };
     }
+    // The one literal KS2023 emission site (both parseDeclaration's plain
+    // VarDecl case and parseExternDecl's ExternValueDecl case route through
+    // it — see diagnostics.test.ts's "codes are unique across every emission
+    // site"): a type-parameter list appeared somewhere only a function
+    // declaration (real or extern) may have one.
+    reportStrayTypeParamList(line, col) {
+        this.diagnostics.error("KS2023", "A type parameter list is only allowed on a function declaration", line, col);
+    }
     // Optional `from "<path>"` (omit for an ambient global) and optional
     // `as "<jsName>"` (omit when the JS-side name matches the KopScript-declared one).
     parseExternTail(defaultJsName) {

package/dist/printer.js

@@ -276,7 +276,8 @@ export class Printer {
         const prefix = decl.isExported ? "" : "private ";
         const as = decl.jsName !== decl.name ? ` as "${decl.jsName}"` : "";
         const from = decl.modulePath ? ` from "${decl.modulePath}"` : "";
-        return `${pad}${prefix}extern ${this.printType(decl.returnType)} ${decl.name}(${this.printParams(decl.params)})${from}${as};`;
+        const nameWithTypeParams = this.printTypeParamName(decl);
+        return `${pad}${prefix}extern ${this.printType(decl.returnType)} ${nameWithTypeParams}(${this.printParams(decl.params)})${from}${as};`;
     }
     printExternValue(decl, indent) {
         const pad = indentStr(indent);

package/dist/template_compiler.js

@@ -234,6 +234,8 @@ export class TemplateCompiler {
             };
             statements.push(assign(member(self, fieldName, bind), lambda, bind));
         }
+        for (const bind of node.twoWayBindings)
+            statements.push(...this.buildTwoWayBinding(self, bind, localScope));
         const elementChildren = node.children.filter((c) => c.kind === "element");
         const textChildren = node.children.filter((c) => c.kind === "text");
         if (textChildren.length > 0 && elementChildren.length > 0) {
@@ -301,4 +303,34 @@ export class TemplateCompiler {
         }
         return exprStatement(call(member(self, "SetAttr", at), [stringLiteral(name, at), value], at), at);
     }
+    // `[(value)]="Field"` desugars to exactly the two-piece pattern you'd
+    // otherwise write by hand — `[value]="Field"` (a plain property binding)
+    // plus `(input)="Field = e.target.value"` (an auto-generated handler
+    // assigning back). Restricted to `value` specifically: it's the one
+    // VElement field a user can change through direct interaction (typing,
+    // picking an option) with no event of Kopular's own in between — `id`/
+    // `className` have no equivalent "user just changed this" event, so
+    // there's nothing for a two-way binding to mean for them.
+    buildTwoWayBinding(self, bind, localScope) {
+        if (bind.name !== "value") {
+            this.diagnostics.error("KS5017", `Unsupported two-way binding '[(${bind.name})]' — only [(value)] is supported, the one VElement field a user can change through direct interaction`, bind.line, bind.col);
+            return [];
+        }
+        const target = this.resolve(bind.target, localScope);
+        if (target.kind !== "Identifier" && target.kind !== "MemberExpr") {
+            this.diagnostics.error("KS5018", `A two-way binding target must be a simple field reference (a bare name or 'this.Field'), not a complex expression`, bind.line, bind.col);
+            return [];
+        }
+        const propAssign = this.buildAttrAssignment(self, bind.name, target, bind);
+        const assignBack = assign(target, member(member(ident("e", bind), "target", bind), "value", bind), bind);
+        const lambda = {
+            kind: "LambdaExpr",
+            params: [{ name: "e", type: EVENT_TYPE }],
+            body: block([assignBack], bind),
+            line: bind.line,
+            col: bind.col,
+        };
+        const eventAssign = assign(member(self, "OnInput", bind), lambda, bind);
+        return [propAssign, eventAssign];
+    }
 }

package/dist/template_parser.js

@@ -162,6 +162,7 @@ export class TemplateParser {
         const staticAttrs = [];
         const propBindings = [];
         const eventBindings = [];
+        const twoWayBindings = [];
         let ifCondition = null;
         let forBinding = null;
         while (this.check(TemplateTokenKind.AttrName)) {
@@ -171,7 +172,15 @@ export class TemplateParser {
             if (!valueTok)
                 continue;
             const name = nameTok.lexeme;
-            if (name.startsWith("(") && name.endsWith(")")) {
+            // Checked before the plain `[prop]` case below — `[(value)]` also
+            // starts with `[` and ends with `]`, so it would otherwise be
+            // mistaken for a property binding named literally "(value)".
+            if (name.startsWith("[(") && name.endsWith(")]")) {
+                const propName = name.slice(2, -2);
+                const target = this.parseEmbeddedExpression(valueTok.lexeme, valueTok.line, valueTok.col);
+                twoWayBindings.push({ name: propName, target, line: nameTok.line, col: nameTok.col });
+            }
+            else if (name.startsWith("(") && name.endsWith(")")) {
                 const eventName = name.slice(1, -1);
                 const handler = this.parseEmbeddedExpression(valueTok.lexeme, valueTok.line, valueTok.col);
                 eventBindings.push({ name: eventName, handler, line: nameTok.line, col: nameTok.col });
@@ -226,7 +235,7 @@ export class TemplateParser {
                 this.diagnostics.error("KS5012", `Expected closing tag '</${tag}>'`, tagTok.line, tagTok.col);
             }
         }
-        return { kind: "element", tag, staticAttrs, propBindings, eventBindings, ifCondition, forBinding, children, line: tagTok.line, col: tagTok.col };
+        return { kind: "element", tag, staticAttrs, propBindings, eventBindings, twoWayBindings, ifCondition, forBinding, children, line: tagTok.line, col: tagTok.col };
     }
     consumeEquals(attrNameTok) {
         this.consume(TemplateTokenKind.Equals, attrNameTok, `Expected '=' after attribute '${attrNameTok.lexeme}'`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kopscript",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "description": "KopScript: a small OOP, strongly-typed language that transpiles to JavaScript, with generics and nullable types",
   "type": "module",
   "license": "MIT",