kopscript 0.12.0 → 0.14.0

package/LLM.md

@@ -303,9 +303,10 @@ class Pair<K, V> {
 Pair<number, string> p = new Pair<number, string>(1, "a");
 ```
 
-One or more unconstrained, invariant type parameters per class/interface (real *or*
-`extern` — see the `extern` section below), comma-separated: `<T>`, `<K, V>`, `<A, B, C>`,
-however many the declaration needs.
+One or more invariant type parameters per class/interface (real *or* `extern` — see the
+`extern` section below), comma-separated: `<T>`, `<K, V>`, `<A, B, C>`, however many the
+declaration needs — each optionally constrained to a single interface: `<T : IComparable>`,
+`<K : IHashable, V>` (mixing constrained and unconstrained params is fine).
 Erased at codegen (JS has no generics either; `Box<number>` and `Box<string>` both
 compile to the exact same plain `class Box`), so there's no runtime cost and no way to
 inspect a type parameter at runtime.
@@ -322,21 +323,53 @@ inspect a type parameter at runtime.
 - Nesting works: `Box<Box<number>>`, `Box<number[]>`, `Box<number>?`, `Box<number>?[]`,
   `Pair<number, Pair<string, bool>>`.
 - Inside the class/interface's own body, each type parameter is fully abstract — you can
-  store it, return it, pass it around, but (unconstrained) you **cannot call any member on
-  a bare type-parameter value** (`this.value.Foo()` where `value: T` is a compile error:
-  "Cannot access member 'Foo' on type 'T'"). This is correct, not a bug — same as an
-  unconstrained type parameter in C#/Java/TypeScript.
+  store it, return it, pass it around, but an **unconstrained** parameter (no `: IFoo`)
+  means you **cannot call any member on a bare type-parameter value** (`this.value.Foo()`
+  where `value: T` is a compile error: "Cannot access member 'Foo' on type 'T'"). This is
+  correct, not a bug — same as an unconstrained type parameter in C#/Java/TypeScript.
+
+**Constraints**: `<T : IComparable>` lifts the "no member calls" restriction — a member
+call on a constrained `T` resolves against the constraint interface's own signature:
+```ks
+interface IComparable { number CompareTo(); }
+class Box<T : IComparable> {
+  public T Value;
+  constructor(T v) { this.Value = v; }
+  public number Compare() { return this.Value.CompareTo(); } // legal — T : IComparable
+}
+Box<Money> b = new Box<Money>(new Money(5));   // Money must implement IComparable
+```
+A type argument satisfies a constraint by implementing the interface directly, through an
+ancestor (`classImplementsInterface` walks the whole superclass chain), or — inside another
+generic body — by already being an equally- or more-constrained type parameter of its own
+(`class Wrapper<T : IComparable> { Box<T> MakeBox(T v) { return new Box<T>(v); } }` is
+legal without ever naming a concrete type). Checked everywhere a type argument is bound: on
+`new`, on a bare generic type reference, and on a generic base in a base list.
+**v1 limit**: at most one constraint per parameter (`T : IFoo, IBar` isn't supported), and
+the constraint must be an interface, never a class.
+
+**Generic inheritance**: a class/interface base list CAN name a generic base, with its own
+type arguments, in either direction:
+```ks
+class IntBox : Box<number> { }        // concrete — threads a fixed type through
+class Container<T> : Box<T> {          // generic — threads its OWN T through
+  public T GetAgain() { return this.Get(); }
+}
+interface INumberContainer : IContainer<number> { }   // interfaces work the same way
+```
+Member resolution (fields, methods, an inherited constructor via `base(...)` or an implicit
+default) composes substitutions correctly however many generic-base links up the chain a
+member was actually declared — `Container<number>.Get()` (declared on `Box<T>`, two links
+away in a longer chain) resolves to `number`, not the abstract `T`. **v1 limit**: at most
+one generic entry across a class/interface's *whole* base list (its superclass, or one
+implemented/extended interface — never more than one) — `class Foo<T> : Box<T>,
+IContainer<T>` is a compile error ("has more than one generic entry in its base list") even
+though either half alone would work.
 
 **Does not exist (v1 scope cuts, each deliberate)**:
 - **Generic functions.** `T Identity<T>(T x)` doesn't parse — only classes and interfaces
   take type parameters, not free functions/methods themselves (a method *inside* a
   generic class can use that class's own type parameters freely, same as any other member).
-- **Constraints.** No `T : IComparable` — a type parameter is always fully unconstrained,
-  which is why you can't call members on a bare one (see above).
-- **Generic inheritance.** A class/interface's base list can only name a *non-generic*
-  type — `class Foo : Box<number>` and even `class Foo<T> : SomeGenericBase<T>` are both
-  compile errors ("cannot extend/implement generic type '...' — not supported in v1"). A
-  generic class/interface can still extend/implement ordinary non-generic bases normally.
 - **Variance.** No `out`/`in`/covariance/contravariance — see invariance above.
 
 ## Nullable types — `T?`
@@ -414,11 +447,14 @@ KopScript-declared name exactly. Extern class members use real JS member names v
 (camelCase, no rename mechanism). No inheritance modeling between two `extern class`
 declarations — each stands alone.
 
-`extern class` can carry `<T>` (`extern class Box<T> { constructor(T v); T Value { get; } }
-from "some-package";`) — identical rules to a real generic class (see "Generics" above:
-one unconstrained invariant parameter, erased, no base-list generics), so a generic type
-from another package instantiates and type-checks exactly like a local one
-(`Box<number>`, arity/invariance errors included).
+`extern class` can carry type parameters, optionally constrained (`extern class Box<T :
+IComparable> { constructor(T v); T Value { get; } } from "some-package";`) — identical
+rules to a real generic class (see "Generics" above: invariant, erased, generic
+inheritance and constraints both included), so a generic type from another package
+instantiates and type-checks exactly like a local one (`Box<number>`, arity/invariance/
+constraint errors included) — and a real KopScript class can extend a generic `extern
+class` with a concrete or threaded-through type argument, same as extending a real generic
+base.
 
 **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();`).
@@ -505,9 +541,10 @@ Locals/params: **camelCase**. This is convention, not enforced by the compiler.
 
 ## Does not exist (don't reach for these)
 
-Generics beyond one or more unconstrained type parameters (no `T : IFoo` constraints, no
-generic functions, no generic inheritance, no variance — see Generics above for what *is*
-supported) · `any`/`unknown` annotations ·
+Generics beyond one or more type parameters (each with at most one interface constraint)
+and single-generic-base inheritance (no `T : IFoo, IBar` multi-constraints, no generic
+functions, no variance, no more than one generic entry per base list — see Generics above
+for what *is* supported) · `any`/`unknown` annotations ·
 a `let`/`var` keyword (locals are just `Type name = value;`) · decorators/annotations ·
 reflection · type inference on declarations · ternary expression · union/tuple types ·
 **object-literal syntax** (`{ key: value }` as a value — this doesn't exist *anywhere* in

package/README.md

@@ -22,9 +22,11 @@ LLM's context, as opposed to this README's narrative explanation.
   explicit `virtual`/`override` dispatch (methods are sealed unless marked `virtual`), and a full
   `public`/`protected`/`private` access model enforced at compile time.
 - **Strongly typed**: every declaration is explicitly typed and checked at compile time.
-- **Generics**: one or more unconstrained, invariant type parameters on classes and
-  interfaces (`class Box<T> { public T Value; }`, `class Pair<K, V> { ... }`) — erased at
-  codegen with zero runtime cost, the same way `task<T>`/`state<T>` already are.
+- **Generics**: one or more invariant type parameters on classes and interfaces
+  (`class Box<T> { public T Value; }`, `class Pair<K, V> { ... }`), each optionally
+  constrained to an interface (`class Box<T : IComparable> { ... }`), plus generic
+  inheritance (`class IntBox : Box<number> { }`) — erased at codegen with zero runtime
+  cost, the same way `task<T>`/`state<T>` already are.
 - **Nullable types with compiler-enforced null-checking**: `T?` (`string?`, `Dog?`,
   `number[]?`) — a `T?` can't be used where a `T` is expected without an `if (x != null)`
   check first (checked statically, not just at runtime), and comparing a value that can
@@ -253,20 +255,49 @@ compile to the identical plain `class Box`, so there's no runtime cost.
 Still a deliberately small slice of generics, not a scaled-down promise of more later
 inside v1:
 
-- **Invariant, unconstrained.** No `T : ISomething` (constraints) — and because a type
-  parameter is fully unconstrained, you can't call any member on a bare `T`/`K`/`V` value
-  inside the generic class's own body (that's correct behavior, the same restriction
-  C#/Java/TypeScript put on an unconstrained parameter, not a bug). Invariant means
-  `Box<Dog>` is **not** assignable to `Box<Animal>` even though `Dog : Animal`, and
-  `Pair<number, string>` is not assignable to `Pair<string, number>` — every slot must
-  match exactly, in order.
+- **Invariant.** `Box<Dog>` is **not** assignable to `Box<Animal>` even though `Dog :
+  Animal`, and `Pair<number, string>` is not assignable to `Pair<string, number>` — every
+  slot must match exactly, in order.
 - **No generic functions.** `T Identity<T>(T x)` isn't supported — only classes and
   interfaces take type parameters. A method *inside* a generic class can still use that
   class's own type parameters freely; it's just not introducing one of its own.
-- **No generic inheritance.** A class or interface's base list can only name a
-  *non-generic* type. `class Foo : Box<number>` and `class Foo<T> : SomeBase<T>` are both
-  compile errors — a generic class can still extend/implement ordinary non-generic bases
-  normally, it just can't be the one on either side of a generic base relationship.
+
+By default a type parameter is fully unconstrained, so you can't call any member on a bare
+`T`/`K`/`V` value inside the generic class's own body — the same restriction C#/Java/
+TypeScript put on an unconstrained parameter, not a bug. A single optional `: IFoo`
+constraint per parameter lifts that:
+
+```ks
+interface IComparable { number CompareTo(); }
+class Box<T : IComparable> {
+  public T Value;
+  constructor(T v) { this.Value = v; }
+  public number Compare() { return this.Value.CompareTo(); } // legal — T is constrained
+}
+Box<Money> b = new Box<Money>(new Money(5));   // Money must implement IComparable
+```
+
+The constraint must be an interface (never a class), and a type argument satisfies it by
+implementing it directly, through an ancestor, or (inside another generic body) by already
+being an equally-or-more-constrained type parameter of its own. **v1 limit**: at most one
+constraint per parameter — `T : IFoo, IBar` isn't supported.
+
+A class or interface *can* extend/implement a generic base, type arguments and all:
+
+```ks
+class IntBox : Box<number> { }                   // concrete: threads a fixed type through
+class Container<T> : Box<T> {                     // generic: threads its OWN T through
+  public T GetAgain() { return this.Get(); }
+}
+Container<number> c = new Container<number>(5);
+print(c.GetAgain());                               // 5, and c.Value/c.Get() work too
+```
+
+Member lookup (fields, methods, an inherited constructor) resolves correctly however many
+generic-base links up the chain a member was actually declared, substituting all the way
+down. **v1 limit**: at most one generic entry across a whole base list (the superclass, or
+one implemented interface — not several at once) — `class Foo<T> : Box<T>, IContainer<T>`
+is a compile error even though each half would work alone.
 
 See `LLM.md`'s "Generics" section for the exhaustive rules if you're generating code
 against this — nested generics (`Box<Box<number>>`, `Box<number>?[]`, `Pair<number,
@@ -370,10 +401,11 @@ consumes `Component`/`Router` themselves via `extern class ... from "kopular/...
 proving `extern` works as a real cross-*package* boundary, not just for describing DOM
 globals within a single project.
 
-An `extern class` can carry its own type parameter(s), `extern class Box<T> { ... }` or
-`extern class Pair<K, V> { ... }` — exactly the same rules as a real generic class (see
-"Generics" above: invariant, unconstrained, erased, can't appear in a base list), so a
-generic type from another package (e.g. Kopular's `FormField<T>`) can be described and
+An `extern class` can carry its own type parameter(s), optionally constrained —
+`extern class Box<T> { ... }`, `extern class Pair<K, V> { ... }`, `extern class Box<T :
+IComparable> { ... }` — exactly the same rules as a real generic class (see "Generics"
+above: invariant, erased, and a real class can extend it as a generic base), so a generic
+type from another package (e.g. Kopular's `FormField<T>`) can be described and
 instantiated generically, not just per concrete type:
 
 ```ks

package/dist/checker.js

@@ -64,6 +64,19 @@ export class Checker {
         // doubles as the arity table (its length is how many type arguments a
         // reference to that name must supply). See resolveType/validateGenericArity.
         this.genericTypeParams = new Map();
+        // Same shape/population sites as genericTypeParams, but each entry is a
+        // parallel array of that generic's per-parameter constraint interface
+        // name (or null if unconstrained) — e.g. "Pair" -> [null, "IHashable"]
+        // for `class Pair<K, V : IHashable>`. See resolveBaseTypeArgs/checkNew/
+        // checkConstraintSatisfied.
+        this.genericTypeParamConstraints = new Map();
+        // The constraint interface (or null) for every type parameter *currently
+        // in scope* while checking a generic declaration's own body — set/
+        // restored by withTypeParamsInScope alongside namedTypes, so a bare `T`
+        // value's member access (`this.value.Foo()`) can resolve Foo against the
+        // constraint's own signature instead of always erroring (see
+        // checkMemberInner's "typeParam" branch).
+        this.activeConstraints = new Map();
         this.importedNames = new Set();
         this.rawContents = new Map();
         this.hoverEntries = [];
@@ -75,13 +88,17 @@ export class Checker {
         }
         for (const [name, info] of this.imports.classes) {
             this.classes.set(name, info);
-            if (info.typeParams.length > 0)
+            if (info.typeParams.length > 0) {
                 this.genericTypeParams.set(name, info.typeParams);
+                this.genericTypeParamConstraints.set(name, info.typeParamConstraints);
+            }
         }
         for (const [name, info] of this.imports.interfaces) {
             this.interfaces.set(name, info);
-            if (info.typeParams.length > 0)
+            if (info.typeParams.length > 0) {
                 this.genericTypeParams.set(name, info.typeParams);
+                this.genericTypeParamConstraints.set(name, info.typeParamConstraints);
+            }
         }
         for (const [name, info] of this.imports.enums)
             this.enums.set(name, info);
@@ -110,15 +127,24 @@ export class Checker {
             this.namedTypes.set(e.name, "enum");
         for (const c of externClassDecls)
             this.namedTypes.set(c.name, "class");
-        for (const c of classDecls)
-            if (c.typeParams.length > 0)
-                this.genericTypeParams.set(c.name, c.typeParams.map((p) => p.name));
-        for (const i of interfaceDecls)
-            if (i.typeParams.length > 0)
-                this.genericTypeParams.set(i.name, i.typeParams.map((p) => p.name));
-        for (const c of externClassDecls)
-            if (c.typeParams.length > 0)
-                this.genericTypeParams.set(c.name, c.typeParams.map((p) => p.name));
+        for (const c of classDecls) {
+            if (c.typeParams.length === 0)
+                continue;
+            this.genericTypeParams.set(c.name, c.typeParams.map((p) => p.name));
+            this.genericTypeParamConstraints.set(c.name, c.typeParams.map((p) => p.constraint));
+        }
+        for (const i of interfaceDecls) {
+            if (i.typeParams.length === 0)
+                continue;
+            this.genericTypeParams.set(i.name, i.typeParams.map((p) => p.name));
+            this.genericTypeParamConstraints.set(i.name, i.typeParams.map((p) => p.constraint));
+        }
+        for (const c of externClassDecls) {
+            if (c.typeParams.length === 0)
+                continue;
+            this.genericTypeParams.set(c.name, c.typeParams.map((p) => p.name));
+            this.genericTypeParamConstraints.set(c.name, c.typeParams.map((p) => p.constraint));
+        }
         for (const e of enumDecls)
             this.registerEnum(e);
         for (const i of interfaceDecls)
@@ -203,8 +229,11 @@ export class Checker {
         this.classes.set(decl.name, {
             name: decl.name,
             typeParams: decl.typeParams.map((p) => p.name),
+            typeParamConstraints: decl.typeParams.map((p) => p.constraint),
             superclass: null,
+            superclassTypeArgs: null,
             interfaces: [],
+            interfaceTypeArgs: new Map(),
             fields,
             methods,
             staticFields,
@@ -392,6 +421,14 @@ export class Checker {
                 else if (declaredParams && suppliedCount > 0 && suppliedCount !== declaredParams.length) {
                     this.diagnostics.error("KS4090", `Type '${type.name}' expects ${this.describeArity(declaredParams)}, got ${suppliedCount}`, line, col);
                 }
+                else if (declaredParams && suppliedCount === declaredParams.length) {
+                    const constraints = this.genericTypeParamConstraints.get(type.name);
+                    type.typeArgs.forEach((arg, i) => {
+                        const constraint = constraints?.[i];
+                        if (constraint)
+                            this.checkConstraintSatisfied(arg, constraint, declaredParams[i], line, col);
+                    });
+                }
                 type.typeArgs?.forEach((a) => this.validateGenericArity(a, line, col));
                 return;
             }
@@ -413,8 +450,11 @@ export class Checker {
         if (typeParams.length === 0)
             return fn();
         const previous = typeParams.map((p) => this.namedTypes.get(p.name));
-        for (const p of typeParams)
+        const previousConstraints = typeParams.map((p) => this.activeConstraints.get(p.name));
+        for (const p of typeParams) {
             this.namedTypes.set(p.name, "typeParam");
+            this.activeConstraints.set(p.name, p.constraint);
+        }
         try {
             return fn();
         }
@@ -425,6 +465,11 @@ export class Checker {
                     this.namedTypes.delete(p.name);
                 else
                     this.namedTypes.set(p.name, prev);
+                const prevConstraint = previousConstraints[i];
+                if (prevConstraint === undefined)
+                    this.activeConstraints.delete(p.name);
+                else
+                    this.activeConstraints.set(p.name, prevConstraint);
             });
         }
     }
@@ -459,6 +504,59 @@ export class Checker {
                 return type;
         }
     }
+    // Builds the bindings map for a generic reference (a `ClassType`/
+    // `InterfaceType`'s own `typeArgs`, zipped against its declared
+    // `typeParams`) — the "own bindings" every member-lookup/conformance
+    // check starts from. Null when the reference isn't actually generic
+    // (no declared params) or carries no type arguments (an arity error
+    // already diagnosed elsewhere — see validateGenericArity).
+    ownBindings(typeParams, typeArgs) {
+        if (typeParams.length === 0 || !typeArgs)
+            return null;
+        return new Map(typeParams.map((name, i) => [name, typeArgs[i]]));
+    }
+    // Maps `typeParams` to themselves, as abstract TypeParamTypes — used when
+    // resolving a base-list/interface type argument that may reference the
+    // *declaring* class/interface's own (still-abstract) type parameter,
+    // rather than a concrete instantiation (see checkInterfaceConformance and
+    // the base(...) call check in checkClassBodyInner).
+    identityBindings(typeParams) {
+        return new Map(typeParams.map((name) => [name, T.typeParamType(name)]));
+    }
+    // One step of substitution composition, walking from a class/interface
+    // ("owner") to one of its own generic base-list entries. `baseArgs` are
+    // the type arguments `owner` supplied to `baseName` in its own base list
+    // — still in `owner`'s own type-param-name space (may reference `owner`'s
+    // own type parameters, not yet concrete). `ownerBindings` is `owner`'s
+    // current bindings at the point of this lookup. Returns `baseName`'s own
+    // bindings map (its declared type-param names -> resolved types), ready
+    // for the next composition step or a final substituteTypeParams call.
+    composeBaseBindings(baseName, baseArgs, ownerBindings) {
+        const baseParams = this.genericTypeParams.get(baseName) ?? [];
+        const resolvedArgs = baseArgs.map((t) => this.substituteTypeParams(t, ownerBindings));
+        return new Map(baseParams.map((name, i) => [name, resolvedArgs[i]]));
+    }
+    // Starting from `className` with its own bindings (from ownBindings,
+    // above — empty if non-generic or no type arguments), walks up the
+    // superclass chain composing each generic link's stored
+    // superclassTypeArgs, until it reaches `targetOwner` (the ancestor that
+    // actually declared the member being resolved — see lookupField/
+    // lookupMethod/etc.'s `owner` result). Returns the bindings in
+    // `targetOwner`'s own type-param-name space. A non-generic link along the
+    // way (superclassTypeArgs null) resets to empty bindings, same as today's
+    // behavior of never substituting through a non-generic ancestor.
+    bindingsAtAncestor(className, ownBindings, targetOwner) {
+        let current = className;
+        let bindings = ownBindings;
+        while (current !== targetOwner) {
+            const info = this.classes.get(current);
+            if (!info || !info.superclass)
+                return bindings;
+            bindings = info.superclassTypeArgs ? this.composeBaseBindings(info.superclass, info.superclassTypeArgs, bindings) : new Map();
+            current = info.superclass;
+        }
+        return bindings;
+    }
     registerEnum(decl) {
         const members = new Map();
         decl.members.forEach((name, index) => {
@@ -472,28 +570,38 @@ export class Checker {
         this.recordHover(decl.line, decl.col, `enum ${decl.name}`);
     }
     registerInterface(decl) {
-        const methods = this.withTypeParamsInScope(decl.typeParams, () => decl.methods.map((m) => {
-            const params = m.params.map((p) => this.resolveType(p.type, m.line, m.col));
-            const returnType = this.resolveType(m.returnType, m.line, m.col);
-            this.recordHover(m.nameLine, m.nameCol, `${m.name}(${params.map(T.typeToString).join(", ")}): ${T.typeToString(returnType)}`);
-            return { name: m.name, params, returnType };
-        }));
-        const bases = [];
-        for (const baseName of decl.baseList) {
-            if (this.namedTypes.get(baseName) !== "interface") {
-                this.diagnostics.error("KS4012", `Interface '${decl.name}' can only extend other interfaces (unknown interface '${baseName}')`, decl.line, decl.col);
-                continue;
-            }
-            // v1 generics can't appear in a base list at all — only as a
-            // standalone type (field/param/return/local, `new Box<T>()`). A
-            // class/interface always implements/extends a *bare* name.
-            if (this.genericTypeParams.has(baseName)) {
-                this.diagnostics.error("KS4013", `Interface '${decl.name}' cannot extend generic interface '${baseName}' — not supported in v1`, decl.line, decl.col);
-                continue;
+        const genericBaseCount = { count: 0 };
+        const { methods, bases, baseTypeArgs } = this.withTypeParamsInScope(decl.typeParams, () => {
+            const methods = decl.methods.map((m) => {
+                const params = m.params.map((p) => this.resolveType(p.type, m.line, m.col));
+                const returnType = this.resolveType(m.returnType, m.line, m.col);
+                this.recordHover(m.nameLine, m.nameCol, `${m.name}(${params.map(T.typeToString).join(", ")}): ${T.typeToString(returnType)}`);
+                return { name: m.name, params, returnType };
+            });
+            const bases = [];
+            const baseTypeArgs = new Map();
+            for (const entry of decl.baseList) {
+                if (this.namedTypes.get(entry.name) !== "interface") {
+                    this.diagnostics.error("KS4012", `Interface '${decl.name}' can only extend other interfaces (unknown interface '${entry.name}')`, decl.line, decl.col);
+                    continue;
+                }
+                bases.push(entry.name);
+                if (entry.typeArgs || this.genericTypeParams.has(entry.name)) {
+                    const resolved = this.resolveBaseTypeArgs(decl.name, entry.name, entry.typeArgs, decl.line, decl.col, genericBaseCount);
+                    if (resolved)
+                        baseTypeArgs.set(entry.name, resolved);
+                }
             }
-            bases.push(baseName);
-        }
-        this.interfaces.set(decl.name, { name: decl.name, typeParams: decl.typeParams.map((p) => p.name), bases, methods });
+            return { methods, bases, baseTypeArgs };
+        });
+        this.interfaces.set(decl.name, {
+            name: decl.name,
+            typeParams: decl.typeParams.map((p) => p.name),
+            typeParamConstraints: decl.typeParams.map((p) => p.constraint),
+            bases,
+            baseTypeArgs,
+            methods,
+        });
         this.recordHover(decl.line, decl.col, decl.typeParams.length > 0 ? `interface ${decl.name}<${decl.typeParams.map((p) => p.name).join(", ")}>` : `interface ${decl.name}`);
     }
     checkInterfaceHierarchy(decl) {
@@ -517,16 +625,31 @@ export class Checker {
         }
     }
     // All methods required to satisfy an interface: its own plus every
-    // transitively-inherited parent interface's (cycle-safe).
-    collectInterfaceMethods(interfaceName, seen = new Set()) {
+    // transitively-inherited parent interface's (cycle-safe). `bindings` maps
+    // `interfaceName`'s own type-param names to resolved types (from
+    // ownBindings, at the root call — see its two call sites) — every
+    // returned signature is substituted through it, and a generic base link
+    // along the way (`interface IDerived<T> : IBase<T>`) composes its own
+    // stored baseTypeArgs through `bindings` before recursing, so a signature
+    // inherited from several generic-base links up still resolves correctly.
+    collectInterfaceMethods(interfaceName, bindings = new Map(), seen = new Set()) {
         if (seen.has(interfaceName))
             return [];
         seen.add(interfaceName);
         const info = this.interfaces.get(interfaceName);
         if (!info)
             return [];
-        const inherited = info.bases.flatMap((b) => this.collectInterfaceMethods(b, seen));
-        return [...inherited, ...info.methods];
+        const inherited = info.bases.flatMap((b) => {
+            const baseArgs = info.baseTypeArgs.get(b);
+            const baseBindings = baseArgs ? this.composeBaseBindings(b, baseArgs, bindings) : new Map();
+            return this.collectInterfaceMethods(b, baseBindings, seen);
+        });
+        const ownMethods = info.methods.map((m) => ({
+            name: m.name,
+            params: m.params.map((p) => this.substituteTypeParams(p, bindings)),
+            returnType: this.substituteTypeParams(m.returnType, bindings),
+        }));
+        return [...inherited, ...ownMethods];
     }
     interfaceExtends(sub, sup) {
         if (sub === sup)
@@ -538,7 +661,8 @@ export class Checker {
     }
     registerClass(decl) {
         this.recordHover(decl.line, decl.col, decl.typeParams.length > 0 ? `class ${decl.name}<${decl.typeParams.map((p) => p.name).join(", ")}>` : `class ${decl.name}`);
-        const { fields, staticFields, methods, staticMethods, ownCtorParams } = this.withTypeParamsInScope(decl.typeParams, () => {
+        const genericBaseCount = { count: 0 };
+        const { fields, staticFields, methods, staticMethods, ownCtorParams, superclass, superclassTypeArgs, interfaces, interfaceTypeArgs } = this.withTypeParamsInScope(decl.typeParams, () => {
             const fields = new Map();
             const staticFields = new Map();
             for (const f of decl.fields) {
@@ -567,39 +691,47 @@ export class Checker {
             const ownCtorParams = decl.constructor
                 ? decl.constructor.params.map((p) => this.resolveType(p.type, decl.constructor.line, decl.constructor.col))
                 : null;
-            return { fields, staticFields, methods, staticMethods, ownCtorParams };
-        });
-        let superclass = null;
-        const interfaces = [];
-        for (const baseName of decl.baseList) {
-            // v1 generics can't appear in a base list at all — only as a
-            // standalone type (field/param/return/local, `new Box<T>()`). A
-            // class always extends/implements a *bare* name.
-            if (this.genericTypeParams.has(baseName)) {
-                this.diagnostics.error("KS4015", `Class '${decl.name}' cannot extend/implement generic type '${baseName}' — not supported in v1`, decl.line, decl.col);
-                continue;
-            }
-            const kind = this.namedTypes.get(baseName);
-            if (kind === "class") {
-                if (superclass !== null) {
-                    this.diagnostics.error("KS4016", `Class '${decl.name}' cannot extend multiple classes ('${superclass}' and '${baseName}')`, decl.line, decl.col);
+            // Base-list resolution runs in this same scope — so `Box<T>` in
+            // `class Container<T> : Box<T>` resolves its inner `T` as
+            // Container's own type parameter, exactly like a field type would.
+            let superclass = null;
+            let superclassTypeArgs = null;
+            const interfaces = [];
+            const interfaceTypeArgs = new Map();
+            for (const entry of decl.baseList) {
+                const kind = this.namedTypes.get(entry.name);
+                if (kind === "class") {
+                    if (superclass !== null) {
+                        this.diagnostics.error("KS4016", `Class '${decl.name}' cannot extend multiple classes ('${superclass}' and '${entry.name}')`, decl.line, decl.col);
+                        continue;
+                    }
+                    superclass = entry.name;
+                    if (entry.typeArgs || this.genericTypeParams.has(entry.name)) {
+                        superclassTypeArgs = this.resolveBaseTypeArgs(decl.name, entry.name, entry.typeArgs, decl.line, decl.col, genericBaseCount);
+                    }
+                }
+                else if (kind === "interface") {
+                    interfaces.push(entry.name);
+                    if (entry.typeArgs || this.genericTypeParams.has(entry.name)) {
+                        const resolved = this.resolveBaseTypeArgs(decl.name, entry.name, entry.typeArgs, decl.line, decl.col, genericBaseCount);
+                        if (resolved)
+                            interfaceTypeArgs.set(entry.name, resolved);
+                    }
                 }
                 else {
-                    superclass = baseName;
+                    this.diagnostics.error("KS4017", `Unknown base class or interface '${entry.name}'`, decl.line, decl.col);
                 }
             }
-            else if (kind === "interface") {
-                interfaces.push(baseName);
-            }
-            else {
-                this.diagnostics.error("KS4017", `Unknown base class or interface '${baseName}'`, decl.line, decl.col);
-            }
-        }
+            return { fields, staticFields, methods, staticMethods, ownCtorParams, superclass, superclassTypeArgs, interfaces, interfaceTypeArgs };
+        });
         this.classes.set(decl.name, {
             name: decl.name,
             typeParams: decl.typeParams.map((p) => p.name),
+            typeParamConstraints: decl.typeParams.map((p) => p.constraint),
             superclass,
+            superclassTypeArgs,
             interfaces,
+            interfaceTypeArgs,
             fields,
             methods,
             staticFields,
@@ -607,6 +739,43 @@ export class Checker {
             ownCtorParams,
         });
     }
+    // Resolves a base-list entry's own type arguments against `baseName`'s
+    // declared arity — `typeArgNodes` is null when the entry was written bare
+    // (`: Box`, not `: Box<number>`). Must be called from inside the
+    // declaring class/interface's own withTypeParamsInScope, so a type
+    // argument that references the declaring type's own parameter (`Box<T>`
+    // in `class Container<T> : Box<T>`) resolves correctly. `genericBaseCount`
+    // is a shared mutable counter across one declaration's whole base list,
+    // enforcing v1's "at most one generic entry per base list" cut.
+    resolveBaseTypeArgs(declName, baseName, typeArgNodes, declLine, declCol, genericBaseCount) {
+        const declaredParams = this.genericTypeParams.get(baseName);
+        if (!declaredParams) {
+            if (typeArgNodes)
+                this.diagnostics.error("KS4092", `'${baseName}' is not generic — it doesn't take a type argument`, declLine, declCol);
+            return null;
+        }
+        if (!typeArgNodes) {
+            this.diagnostics.error("KS4093", `Generic base '${baseName}' requires ${this.describeArity(declaredParams)} (e.g. '${baseName}<${declaredParams.join(", ")}>')`, declLine, declCol);
+            return null;
+        }
+        if (typeArgNodes.length !== declaredParams.length) {
+            this.diagnostics.error("KS4094", `Generic base '${baseName}' expects ${this.describeArity(declaredParams)}, got ${typeArgNodes.length}`, declLine, declCol);
+            return null;
+        }
+        genericBaseCount.count++;
+        if (genericBaseCount.count > 1) {
+            this.diagnostics.error("KS4095", `'${declName}' has more than one generic entry in its base list — v1 supports at most one`, declLine, declCol);
+        }
+        const resolvedArgs = typeArgNodes.map((a) => this.resolveType(a, declLine, declCol));
+        const constraints = this.genericTypeParamConstraints.get(baseName);
+        const declaredParamNames = this.genericTypeParams.get(baseName);
+        resolvedArgs.forEach((arg, i) => {
+            const constraint = constraints?.[i];
+            if (constraint)
+                this.checkConstraintSatisfied(arg, constraint, declaredParamNames[i], declLine, declCol);
+        });
+        return resolvedArgs;
+    }
     checkClassHierarchy(decl) {
         const info = this.classes.get(decl.name);
         this.checkBaseCall(decl, info);
@@ -684,10 +853,19 @@ export class Checker {
     }
     checkInterfaceConformance(decl) {
         const classInfo = this.classes.get(decl.name);
+        // This is a conformance check against the class's own *declared*
+        // (still-abstract) signatures, not an instantiated use site, so a
+        // generic interface arg that references the class's own type param
+        // (`IContainer<T>` in `class Container<T> : IContainer<T>`) should
+        // compose down to that same abstract TypeParamType, matching how the
+        // class's own methods are stored — see identityBindings.
+        const selfBindings = this.identityBindings(classInfo.typeParams);
         for (const ifaceName of classInfo.interfaces) {
             if (!this.interfaces.has(ifaceName))
                 continue; // already reported as an unknown base type
-            for (const sig of this.collectInterfaceMethods(ifaceName)) {
+            const ifaceArgs = classInfo.interfaceTypeArgs.get(ifaceName);
+            const bindings = ifaceArgs ? this.composeBaseBindings(ifaceName, ifaceArgs, selfBindings) : new Map();
+            for (const sig of this.collectInterfaceMethods(ifaceName, bindings)) {
                 const found = this.lookupMethod(decl.name, sig.name);
                 if (!found) {
                     this.diagnostics.error("KS4026", `Class '${decl.name}' does not implement method '${sig.name}' required by interface '${ifaceName}'`, decl.line, decl.col);
@@ -727,6 +905,38 @@ export class Checker {
         }
         return false;
     }
+    // Checks that `argType` (bound to type parameter `paramName`, declared
+    // `paramName : constraintInterfaceName`) actually satisfies the
+    // constraint: a class implementing the interface (possibly via an
+    // ancestor — classImplementsInterface already walks the chain), the
+    // interface itself (or one extending it), or a currently-in-scope type
+    // parameter whose own constraint already extends this one (so a
+    // constrained T can be threaded into another equally-constrained slot,
+    // e.g. `class Wrapper<T : IComparable> { void F(Box<T> b) { ... } }`
+    // passing Wrapper's own T to a `Box<T : IComparable>`). Anything else —
+    // a primitive, an array, an unconstrained type parameter, an unrelated
+    // class — is a compile error.
+    checkConstraintSatisfied(argType, constraintInterfaceName, paramName, line, col) {
+        if (argType.kind === "unknown")
+            return; // an earlier error already reported; don't cascade
+        let satisfied;
+        if (argType.kind === "class") {
+            satisfied = this.classImplementsInterface(argType.name, constraintInterfaceName);
+        }
+        else if (argType.kind === "interface") {
+            satisfied = this.interfaceExtends(argType.name, constraintInterfaceName);
+        }
+        else if (argType.kind === "typeParam") {
+            const ownConstraint = this.activeConstraints.get(argType.name);
+            satisfied = !!ownConstraint && this.interfaceExtends(ownConstraint, constraintInterfaceName);
+        }
+        else {
+            satisfied = false;
+        }
+        if (!satisfied) {
+            this.diagnostics.error("KS4096", `Type argument '${T.typeToString(argType)}' does not satisfy constraint '${constraintInterfaceName}' for type parameter '${paramName}'`, line, col);
+        }
+    }
     lookupField(className, fieldName) {
         let current = className;
         while (current) {
@@ -896,7 +1106,18 @@ export class Checker {
             // params but no `this` — matching real base()/super() semantics,
             // which must run before `this` becomes available.
             if (decl.constructor.baseArgs && info.superclass) {
-                const baseCtorParams = this.lookupCtorParams(info.superclass);
+                // One step from `decl` to its immediate superclass (Container's own
+                // type params, still abstract, composed through whatever it
+                // supplied Box in its base list — see identityBindings), then
+                // however many further steps lookupCtorParams' own `owner` implies
+                // (Box itself has no constructor of its own, inherits its
+                // superclass's) via bindingsAtAncestor.
+                const superBindings = info.superclassTypeArgs
+                    ? this.composeBaseBindings(info.superclass, info.superclassTypeArgs, this.identityBindings(info.typeParams))
+                    : new Map();
+                const { params: rawBaseCtorParams, owner: baseCtorOwner } = this.lookupCtorParams(info.superclass);
+                const baseCtorBindings = this.bindingsAtAncestor(info.superclass, superBindings, baseCtorOwner);
+                const baseCtorParams = rawBaseCtorParams.map((p) => this.substituteTypeParams(p, baseCtorBindings));
                 const baseCtx = { returnType: T.VOID, currentClass: info, inConstructor: false, loopDepth: 0, isAsync: false };
                 if (decl.constructor.baseArgs.length !== baseCtorParams.length) {
                     this.diagnostics.error("KS4032", `Expected ${baseCtorParams.length} base constructor argument(s), got ${decl.constructor.baseArgs.length}`, decl.constructor.line, decl.constructor.col);
@@ -1496,13 +1717,24 @@ export class Checker {
                 return T.UNKNOWN;
             }
             typeArgs = expr.typeArgs.map((a) => this.resolveType(a, expr.line, expr.col));
+            const constraints = this.genericTypeParamConstraints.get(expr.className);
+            typeArgs.forEach((arg, i) => {
+                const constraint = constraints?.[i];
+                if (constraint)
+                    this.checkConstraintSatisfied(arg, constraint, info.typeParams[i], expr.line, expr.col);
+            });
         }
         this.recordHover(expr.line, expr.col, typeArgs ? `class ${expr.className}<${typeArgs.map(T.typeToString).join(", ")}>` : `class ${expr.className}`);
-        let ctorParams = this.lookupCtorParams(expr.className);
-        if (info.typeParams.length > 0 && typeArgs) {
-            const bindings = new Map(info.typeParams.map((name, i) => [name, typeArgs[i]]));
-            ctorParams = ctorParams.map((p) => this.substituteTypeParams(p, bindings));
-        }
+        // The constructor being called may be inherited from a generic
+        // ancestor several base-list links up (e.g. `new NumberBox(5)` where
+        // `NumberBox : Box<number>` has no constructor of its own) — compose
+        // bindings all the way to whichever class's own constructor
+        // lookupCtorParams actually found (bindingsAtAncestor is a no-op single
+        // step when it's expr.className's own, the common case).
+        const { params: rawCtorParams, owner: ctorOwner } = this.lookupCtorParams(expr.className);
+        const ownCtorBindings = this.ownBindings(info.typeParams, typeArgs) ?? new Map();
+        const ctorBindings = this.bindingsAtAncestor(expr.className, ownCtorBindings, ctorOwner);
+        const ctorParams = rawCtorParams.map((p) => this.substituteTypeParams(p, ctorBindings));
         if (expr.args.length !== ctorParams.length) {
             this.diagnostics.error("KS4071", `Expected ${ctorParams.length} constructor argument(s), got ${expr.args.length}`, expr.line, expr.col);
         }
@@ -1515,17 +1747,23 @@ export class Checker {
         });
         return T.classType(expr.className, typeArgs);
     }
+    // `owner` is which class up the chain actually declared the constructor
+    // being inherited (itself, or the nearest ancestor with one) — needed so
+    // a caller can compose the right type-parameter bindings when that
+    // ancestor is a generic base (see bindingsAtAncestor). `params` is stored
+    // abstractly in `owner`'s own type-param-name space, same as a field or
+    // method's type would be.
     lookupCtorParams(className) {
         let current = className;
         while (current) {
             const info = this.classes.get(current);
             if (!info)
-                return [];
+                return { params: [], owner: className };
             if (info.ownCtorParams !== null)
-                return info.ownCtorParams;
+                return { params: info.ownCtorParams, owner: current };
             current = info.superclass;
         }
-        return [];
+        return { params: [], owner: className };
     }
     // Array stdlib with a fixed (non-polymorphic) signature, given the
     // array's own element type — everything except Map, which checkCall
@@ -1663,13 +1901,14 @@ export class Checker {
             return { type: T.UNKNOWN, methodInfo: null };
         }
         if (objectType.kind === "class") {
-            // v1 has no generic inheritance (a generic class's base list can only
-            // name non-generic types), so a member found on a generic instance
-            // was always declared directly on that same class — substituting by
-            // its own type parameters, not some ancestor's, is always correct.
-            const declaredParams = objectType.typeArgs ? this.genericTypeParams.get(objectType.name) : undefined;
-            const bindings = declaredParams && objectType.typeArgs ? new Map(declaredParams.map((name, i) => [name, objectType.typeArgs[i]])) : null;
-            const substitute = (type) => (bindings ? this.substituteTypeParams(type, bindings) : type);
+            // A member found on an *ancestor* (owner !== objectType.name — v1 now
+            // supports a generic superclass, see registerClass/
+            // bindingsAtAncestor) needs bindings composed through however many
+            // generic base links separate objectType from that ancestor, not just
+            // objectType's own type arguments — bindingsAtAncestor does that walk
+            // (a no-op single step when owner IS objectType.name, the common
+            // case, same result as before this existed).
+            const ownBindings = this.ownBindings(this.genericTypeParams.get(objectType.name) ?? [], objectType.typeArgs) ?? new Map();
             const field = this.lookupField(objectType.name, expr.property);
             if (field) {
                 this.checkAccessibility(field.info.visibility, field.owner, ctx, expr.property, expr.line, expr.col);
@@ -1679,33 +1918,52 @@ export class Checker {
                         this.diagnostics.error("KS4082", `'${expr.property}' has no setter and can only be assigned within ${field.owner}'s constructor`, expr.line, expr.col);
                     }
                 }
-                return { type: substitute(field.info.type), methodInfo: null };
+                const bindings = this.bindingsAtAncestor(objectType.name, ownBindings, field.owner);
+                return { type: this.substituteTypeParams(field.info.type, bindings), methodInfo: null };
             }
             const method = this.lookupMethod(objectType.name, expr.property);
             if (method) {
                 this.checkAccessibility(method.info.visibility, method.owner, ctx, expr.property, expr.line, expr.col);
-                const info = bindings ? { ...method.info, params: method.info.params.map(substitute), returnType: substitute(method.info.returnType) } : method.info;
+                const bindings = this.bindingsAtAncestor(objectType.name, ownBindings, method.owner);
+                const info = {
+                    ...method.info,
+                    params: method.info.params.map((p) => this.substituteTypeParams(p, bindings)),
+                    returnType: this.substituteTypeParams(method.info.returnType, bindings),
+                };
                 return { type: info.returnType, methodInfo: info };
             }
             this.diagnostics.error("KS4083", `Class '${objectType.name}' has no member '${expr.property}'`, expr.line, expr.col);
             return { type: T.UNKNOWN, methodInfo: null };
         }
         if (objectType.kind === "interface") {
-            const sig = this.collectInterfaceMethods(objectType.name).find((m) => m.name === expr.property);
+            // collectInterfaceMethods itself now substitutes through `bindings` —
+            // including across a generic base-interface link — so passing
+            // objectType's own bindings once at the root is enough; no separate
+            // re-substitution needed here (see its own header comment).
+            const ownBindings = this.ownBindings(this.genericTypeParams.get(objectType.name) ?? [], objectType.typeArgs) ?? new Map();
+            const sig = this.collectInterfaceMethods(objectType.name, ownBindings).find((m) => m.name === expr.property);
             if (sig) {
-                // v1 has no generic interface inheritance either (same restriction
-                // as classes — see registerInterface), so a signature found here
-                // was always declared directly on this same interface.
-                const declaredParams = objectType.typeArgs ? this.genericTypeParams.get(objectType.name) : undefined;
-                const bindings = declaredParams && objectType.typeArgs ? new Map(declaredParams.map((name, i) => [name, objectType.typeArgs[i]])) : null;
-                const substitute = (type) => (bindings ? this.substituteTypeParams(type, bindings) : type);
-                const params = sig.params.map(substitute);
-                const returnType = substitute(sig.returnType);
-                return { type: returnType, methodInfo: { params, returnType, visibility: "public", isVirtual: false, isOverride: false } };
+                return { type: sig.returnType, methodInfo: { params: sig.params, returnType: sig.returnType, visibility: "public", isVirtual: false, isOverride: false } };
             }
             this.diagnostics.error("KS4084", `Interface '${objectType.name}' has no member '${expr.property}'`, expr.line, expr.col);
             return { type: T.UNKNOWN, methodInfo: null };
         }
+        // A bare type-parameter receiver (`this.value.Foo()` where `value: T`)
+        // — resolves against the constraint interface's own signature if `T`
+        // is constrained; an unconstrained `T` falls through to the generic
+        // "cannot access member" error below, unchanged from before constraints
+        // existed (see README/LLM.md's own documented restriction).
+        if (objectType.kind === "typeParam") {
+            const constraintName = this.activeConstraints.get(objectType.name);
+            if (constraintName) {
+                const sig = this.collectInterfaceMethods(constraintName).find((m) => m.name === expr.property);
+                if (sig) {
+                    return { type: sig.returnType, methodInfo: { params: sig.params, returnType: sig.returnType, visibility: "public", isVirtual: false, isOverride: false } };
+                }
+                this.diagnostics.error("KS4097", `Interface '${constraintName}' (the constraint on type parameter '${objectType.name}') has no member '${expr.property}'`, expr.line, expr.col);
+                return { type: T.UNKNOWN, methodInfo: null };
+            }
+        }
         if (objectType.kind !== "unknown") {
             this.diagnostics.error("KS4085", `Cannot access member '${expr.property}' on type '${T.typeToString(objectType)}'`, expr.line, expr.col);
         }

package/dist/codegen.js

@@ -286,7 +286,7 @@ export class CodeGenerator {
         const pad = this.indentStr(indent);
         // The base list mixes an optional superclass with interface names (checker-validated);
         // only the non-interface entry, if any, becomes a JS `extends` clause.
-        const superclass = decl.baseList.find((n) => !this.interfaceNames.has(n)) ?? null;
+        const superclass = decl.baseList.find((b) => !this.interfaceNames.has(b.name))?.name ?? null;
         const header = superclass ? `class ${decl.name} extends ${superclass} {` : `class ${decl.name} {`;
         const memberPad = this.indentStr(indent + 1);
         const memberCol = memberPad.length;

package/dist/parser.js

@@ -243,21 +243,40 @@ export class Parser {
         this.consume(TokenKind.RParen, "Expected ')' after parameters");
         return params;
     }
-    // `<K, V>` right after a class/interface name — one or more type
-    // parameters, comma-separated. Empty array if absent, the overwhelmingly
-    // common case. Constraint syntax (`<T : IFoo>`) isn't parsed yet — every
-    // entry's `constraint` is always null for now (see AST.TypeParamDecl).
+    // `<K : IHashable, V>` right after a class/interface/function name — one
+    // or more type parameters, comma-separated, each with an optional
+    // `: InterfaceName` constraint. Empty array if absent, the overwhelmingly
+    // common case.
     parseTypeParamList() {
         if (!this.match(TokenKind.Lt))
             return [];
         const params = [];
         do {
             const nameTok = this.consume(TokenKind.Identifier, "Expected a type parameter name");
-            params.push({ name: nameTok.lexeme, constraint: null, line: nameTok.line, col: nameTok.col });
+            let constraint = null;
+            if (this.match(TokenKind.Colon)) {
+                constraint = this.consume(TokenKind.Identifier, "Expected a constraint interface name after ':'").lexeme;
+            }
+            params.push({ name: nameTok.lexeme, constraint, line: nameTok.line, col: nameTok.col });
         } while (this.match(TokenKind.Comma));
         this.consume(TokenKind.Gt, "Expected '>' after type parameter list");
         return params;
     }
+    // `Bar<T>` or `IBaz` — one base-list entry, with or without its own type
+    // arguments. Used by both class and interface base lists.
+    parseBaseListEntry() {
+        const name = this.consume(TokenKind.Identifier, "Expected base class or interface name").lexeme;
+        let typeArgs = null;
+        if (this.check(TokenKind.Lt)) {
+            this.advance();
+            typeArgs = [this.parseType()];
+            while (this.match(TokenKind.Comma)) {
+                typeArgs.push(this.parseType());
+            }
+            this.consume(TokenKind.Gt, "Expected '>' after type argument list");
+        }
+        return { name, typeArgs };
+    }
     parseClassDecl(isExported) {
         const start = this.advance(); // 'class'
         const name = this.consume(TokenKind.Identifier, "Expected class name").lexeme;
@@ -265,7 +284,7 @@ export class Parser {
         const baseList = [];
         if (this.match(TokenKind.Colon)) {
             do {
-                baseList.push(this.consume(TokenKind.Identifier, "Expected base class or interface name").lexeme);
+                baseList.push(this.parseBaseListEntry());
             } while (this.match(TokenKind.Comma));
         }
         this.consume(TokenKind.LBrace, "Expected '{' before class body");
@@ -426,7 +445,7 @@ export class Parser {
         const baseList = [];
         if (this.match(TokenKind.Colon)) {
             do {
-                baseList.push(this.consume(TokenKind.Identifier, "Expected base interface name").lexeme);
+                baseList.push(this.parseBaseListEntry());
             } while (this.match(TokenKind.Comma));
         }
         this.consume(TokenKind.LBrace, "Expected '{' before interface body");

package/dist/printer.js

@@ -118,6 +118,15 @@ export class Printer {
     printParams(params) {
         return params.map((p) => `${this.printType(p.type)} ${p.name}`).join(", ");
     }
+    printBaseListEntry(entry) {
+        return entry.typeArgs ? `${entry.name}<${entry.typeArgs.map((t) => this.printType(t)).join(", ")}>` : entry.name;
+    }
+    printTypeParamName(decl) {
+        if (decl.typeParams.length === 0)
+            return decl.name;
+        const params = decl.typeParams.map((p) => (p.constraint ? `${p.name} : ${p.constraint}` : p.name)).join(", ");
+        return `${decl.name}<${params}>`;
+    }
     // ---------- top-level declarations ----------
     printStatement(stmt, indent) {
         const pad = indentStr(indent);
@@ -212,8 +221,8 @@ export class Printer {
     printClass(decl, indent) {
         const pad = indentStr(indent);
         const memberPad = indentStr(indent + 1);
-        const nameWithTypeParam = decl.typeParams.length > 0 ? `${decl.name}<${decl.typeParams.map((p) => p.name).join(", ")}>` : decl.name;
-        const header = decl.baseList.length > 0 ? `class ${nameWithTypeParam} : ${decl.baseList.join(", ")} {` : `class ${nameWithTypeParam} {`;
+        const nameWithTypeParam = this.printTypeParamName(decl);
+        const header = decl.baseList.length > 0 ? `class ${nameWithTypeParam} : ${decl.baseList.map((b) => this.printBaseListEntry(b)).join(", ")} {` : `class ${nameWithTypeParam} {`;
         const prefix = decl.isExported ? "" : "private ";
         const memberParts = [];
         const pushMember = (node, text) => {
@@ -250,8 +259,8 @@ export class Printer {
     printInterface(decl, indent) {
         const pad = indentStr(indent);
         const memberPad = indentStr(indent + 1);
-        const nameWithTypeParam = decl.typeParams.length > 0 ? `${decl.name}<${decl.typeParams.map((p) => p.name).join(", ")}>` : decl.name;
-        const header = decl.baseList.length > 0 ? `interface ${nameWithTypeParam} : ${decl.baseList.join(", ")} {` : `interface ${nameWithTypeParam} {`;
+        const nameWithTypeParam = this.printTypeParamName(decl);
+        const header = decl.baseList.length > 0 ? `interface ${nameWithTypeParam} : ${decl.baseList.map((b) => this.printBaseListEntry(b)).join(", ")} {` : `interface ${nameWithTypeParam} {`;
         const prefix = decl.isExported ? "" : "private ";
         if (decl.methods.length === 0)
             return `${pad}${prefix}${header}\n${pad}}`;
@@ -279,7 +288,7 @@ export class Printer {
         const pad = indentStr(indent);
         const memberPad = indentStr(indent + 1);
         const prefix = decl.isExported ? "" : "private ";
-        const nameWithTypeParam = decl.typeParams.length > 0 ? `${decl.name}<${decl.typeParams.map((p) => p.name).join(", ")}>` : decl.name;
+        const nameWithTypeParam = this.printTypeParamName(decl);
         const lines = [];
         if (decl.hasConstructor)
             lines.push(`${memberPad}constructor(${this.printParams(decl.ctorParams)});`);

package/package.json

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