kopscript 0.11.1 → 0.13.0

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,24 +243,44 @@ export class Parser {
         this.consume(TokenKind.RParen, "Expected ')' after parameters");
         return params;
     }
-    // `<T>` right after a class/interface name — a single, unconstrained type
-    // parameter (v1 has no `Map<K, V>`, no `T : IFoo` constraints). Null if
-    // absent, the overwhelmingly common case.
-    parseOptionalTypeParam() {
+    // `<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).
+    parseTypeParamList() {
         if (!this.match(TokenKind.Lt))
-            return null;
-        const name = this.consume(TokenKind.Identifier, "Expected a type parameter name").lexeme;
-        this.consume(TokenKind.Gt, "Expected '>' after type parameter");
-        return name;
+            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 });
+        } 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;
-        const typeParam = this.parseOptionalTypeParam();
+        const typeParams = this.parseTypeParamList();
         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");
@@ -412,16 +432,16 @@ export class Parser {
             }
         }
         this.consume(TokenKind.RBrace, "Expected '}' after class body");
-        return { kind: "ClassDecl", isExported, name, typeParam, baseList, fields, properties, constructor: ctor, methods, template, line: start.line, col: start.col };
+        return { kind: "ClassDecl", isExported, name, typeParams, baseList, fields, properties, constructor: ctor, methods, template, line: start.line, col: start.col };
     }
     parseInterfaceDecl(isExported) {
         const start = this.advance(); // 'interface'
         const name = this.consume(TokenKind.Identifier, "Expected interface name").lexeme;
-        const typeParam = this.parseOptionalTypeParam();
+        const typeParams = this.parseTypeParamList();
         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");
@@ -443,7 +463,7 @@ export class Parser {
             });
         }
         this.consume(TokenKind.RBrace, "Expected '}' after interface body");
-        return { kind: "InterfaceDecl", isExported, name, typeParam, baseList, methods, line: start.line, col: start.col };
+        return { kind: "InterfaceDecl", isExported, name, typeParams, baseList, methods, line: start.line, col: start.col };
     }
     parseEnumDecl(isExported) {
         const start = this.advance(); // 'enum'
@@ -510,7 +530,7 @@ export class Parser {
     }
     parseExternClassBody(start, isExported) {
         const name = this.consume(TokenKind.Identifier, "Expected class name").lexeme;
-        const typeParam = this.parseOptionalTypeParam();
+        const typeParams = this.parseTypeParamList();
         this.consume(TokenKind.LBrace, "Expected '{' before extern class body");
         let hasConstructor = false;
         let ctorParams = [];
@@ -575,7 +595,7 @@ export class Parser {
         this.consume(TokenKind.RBrace, "Expected '}' after extern class body");
         const { modulePath, jsName } = this.parseExternTail(name);
         this.consume(TokenKind.Semicolon, "Expected ';' after extern class declaration");
-        return { kind: "ExternClassDecl", isExported, name, typeParam, jsName, hasConstructor, ctorParams, properties, methods, modulePath, line: start.line, col: start.col };
+        return { kind: "ExternClassDecl", isExported, name, typeParams, jsName, hasConstructor, ctorParams, properties, methods, modulePath, line: start.line, col: start.col };
     }
     parseBlock() {
         const start = this.consume(TokenKind.LBrace, "Expected '{'");
@@ -705,15 +725,18 @@ export class Parser {
         }
         else {
             const nameToken = this.check(TokenKind.Void) ? this.advance() : this.consume(TokenKind.Identifier, "Expected type name");
-            // `Box<number>` — a generic type reference. At most one type argument
-            // in v1 (matching ClassDecl/InterfaceDecl's single type parameter);
-            // whether `name` actually refers to a declared generic type is a
+            // `Pair<number, string>` — a generic type reference, comma-separated
+            // type arguments. Whether `name` actually refers to a declared
+            // generic type (and whether the count matches its arity) is a
             // semantic question the checker answers, not the parser.
             let typeArgs = null;
             if (this.check(TokenKind.Lt)) {
                 this.advance();
                 typeArgs = [this.parseType()];
-                this.consume(TokenKind.Gt, "Expected '>' after type argument");
+                while (this.match(TokenKind.Comma)) {
+                    typeArgs.push(this.parseType());
+                }
+                this.consume(TokenKind.Gt, "Expected '>' after type argument list");
             }
             type = { kind: "NamedType", name: nameToken.lexeme, typeArgs, line: nameToken.line, col: nameToken.col };
         }
@@ -893,14 +916,18 @@ export class Parser {
         if (this.check(TokenKind.New)) {
             this.advance();
             const className = this.consume(TokenKind.Identifier, "Expected class name after 'new'").lexeme;
-            // `new Box<number>(...)` — unambiguous here: `new <Identifier>` is
-            // always followed by `(`, generic type args or not, so seeing `<`
-            // instead can only mean a type argument list, never a comparison.
+            // `new Pair<number, string>(...)` — unambiguous here: `new
+            // <Identifier>` is always followed by `(`, generic type args or not,
+            // so seeing `<` instead can only mean a type argument list, never a
+            // comparison.
             let typeArgs = null;
             if (this.check(TokenKind.Lt)) {
                 this.advance();
                 typeArgs = [this.parseType()];
-                this.consume(TokenKind.Gt, "Expected '>' after type argument");
+                while (this.match(TokenKind.Comma)) {
+                    typeArgs.push(this.parseType());
+                }
+                this.consume(TokenKind.Gt, "Expected '>' after type argument list");
             }
             this.consume(TokenKind.LParen, "Expected '(' after class name");
             const args = [];

package/dist/printer.js

@@ -118,6 +118,9 @@ 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;
+    }
     // ---------- top-level declarations ----------
     printStatement(stmt, indent) {
         const pad = indentStr(indent);
@@ -212,8 +215,8 @@ export class Printer {
     printClass(decl, indent) {
         const pad = indentStr(indent);
         const memberPad = indentStr(indent + 1);
-        const nameWithTypeParam = decl.typeParam ? `${decl.name}<${decl.typeParam}>` : decl.name;
-        const header = decl.baseList.length > 0 ? `class ${nameWithTypeParam} : ${decl.baseList.join(", ")} {` : `class ${nameWithTypeParam} {`;
+        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.map((b) => this.printBaseListEntry(b)).join(", ")} {` : `class ${nameWithTypeParam} {`;
         const prefix = decl.isExported ? "" : "private ";
         const memberParts = [];
         const pushMember = (node, text) => {
@@ -250,8 +253,8 @@ export class Printer {
     printInterface(decl, indent) {
         const pad = indentStr(indent);
         const memberPad = indentStr(indent + 1);
-        const nameWithTypeParam = decl.typeParam ? `${decl.name}<${decl.typeParam}>` : decl.name;
-        const header = decl.baseList.length > 0 ? `interface ${nameWithTypeParam} : ${decl.baseList.join(", ")} {` : `interface ${nameWithTypeParam} {`;
+        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.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 +282,7 @@ export class Printer {
         const pad = indentStr(indent);
         const memberPad = indentStr(indent + 1);
         const prefix = decl.isExported ? "" : "private ";
-        const nameWithTypeParam = decl.typeParam ? `${decl.name}<${decl.typeParam}>` : decl.name;
+        const nameWithTypeParam = decl.typeParams.length > 0 ? `${decl.name}<${decl.typeParams.map((p) => p.name).join(", ")}>` : decl.name;
         const lines = [];
         if (decl.hasConstructor)
             lines.push(`${memberPad}constructor(${this.printParams(decl.ctorParams)});`);

package/dist/types.js

@@ -6,11 +6,11 @@ export const UNKNOWN = { kind: "unknown" };
 export function arrayOf(element) {
     return { kind: "array", element };
 }
-export function classType(name, typeArg) {
-    return typeArg ? { kind: "class", name, typeArg } : { kind: "class", name };
+export function classType(name, typeArgs) {
+    return typeArgs && typeArgs.length > 0 ? { kind: "class", name, typeArgs } : { kind: "class", name };
 }
-export function interfaceType(name, typeArg) {
-    return typeArg ? { kind: "interface", name, typeArg } : { kind: "interface", name };
+export function interfaceType(name, typeArgs) {
+    return typeArgs && typeArgs.length > 0 ? { kind: "interface", name, typeArgs } : { kind: "interface", name };
 }
 export function typeParamType(name) {
     return { kind: "typeParam", name };
@@ -44,7 +44,7 @@ export function typeToString(t) {
             return t.name;
         case "class":
         case "interface":
-            return t.typeArg ? `${t.name}<${typeToString(t.typeArg)}>` : t.name;
+            return t.typeArgs && t.typeArgs.length > 0 ? `${t.name}<${t.typeArgs.map(typeToString).join(", ")}>` : t.name;
         case "function":
             return `(${t.params.map(typeToString).join(", ")}) => ${typeToString(t.returnType)}`;
         case "task":
@@ -91,31 +91,36 @@ export function resolveTypeNode(node, namedTypes, onNamedType) {
         const inner = resolveTypeNode(node.inner, namedTypes, onNamedType);
         return inner ? nullableOf(inner) : null;
     }
-    // At most one type argument in v1 — resolve it once, up front; a
-    // primitive/enum/type-param name below never accepts one (arity error,
-    // caught as a plain resolution failure here — a class/interface's own
-    // required-vs-supplied arity mismatch is a separate check the caller
-    // makes, since only it knows which names are actually declared generic).
-    let typeArg = null;
+    // Resolve every type argument given, in order — a primitive/enum/
+    // type-param name below never accepts any (arity error, caught as a plain
+    // resolution failure here). Arity *against a class/interface's own
+    // declared parameter count* is a separate check the caller makes, since
+    // only it knows which names are actually declared generic and with how
+    // many parameters (see Checker.validateGenericArity).
+    let typeArgs = null;
     if (node.typeArgs) {
-        typeArg = resolveTypeNode(node.typeArgs[0], namedTypes, onNamedType);
-        if (!typeArg)
-            return null;
+        typeArgs = [];
+        for (const argNode of node.typeArgs) {
+            const resolvedArg = resolveTypeNode(argNode, namedTypes, onNamedType);
+            if (!resolvedArg)
+                return null;
+            typeArgs.push(resolvedArg);
+        }
     }
     let resolved;
     if (PRIMITIVE_NAMES.has(node.name)) {
-        resolved = typeArg ? null : { kind: node.name };
+        resolved = typeArgs ? null : { kind: node.name };
     }
     else {
         const kind = namedTypes.get(node.name);
         if (kind === "class")
-            resolved = classType(node.name, typeArg ?? undefined);
+            resolved = classType(node.name, typeArgs ?? undefined);
         else if (kind === "interface")
-            resolved = interfaceType(node.name, typeArg ?? undefined);
+            resolved = interfaceType(node.name, typeArgs ?? undefined);
         else if (kind === "enum")
-            resolved = typeArg ? null : enumType(node.name);
+            resolved = typeArgs ? null : enumType(node.name);
         else if (kind === "typeParam")
-            resolved = typeArg ? null : typeParamType(node.name);
+            resolved = typeArgs ? null : typeParamType(node.name);
         else
             resolved = null;
     }
@@ -153,12 +158,12 @@ export function typesEqual(a, b) {
         const other = b;
         if (a.name !== other.name)
             return false;
-        if ("typeArg" in a || "typeArg" in other) {
-            const aArg = a.typeArg;
-            const bArg = other.typeArg;
-            if (!aArg || !bArg)
+        if ("typeArgs" in a || "typeArgs" in other) {
+            const aArgs = a.typeArgs;
+            const bArgs = other.typeArgs;
+            if (!aArgs || !bArgs || aArgs.length !== bArgs.length)
                 return false;
-            return typesEqual(aArg, bArg);
+            return aArgs.every((t, i) => typesEqual(t, bArgs[i]));
         }
         return true;
     }

package/package.json

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