kopscript 0.4.1 → 0.5.0

package/LLM.md

@@ -281,7 +281,8 @@ Box<string> sb = new Box<string>("hi");
 print(nb.Get());                        // 5
 ```
 
-One unconstrained, invariant type parameter per class/interface — the whole feature.
+One unconstrained, invariant type parameter per class/interface (real *or* `extern` — see
+the `extern` section below) — the whole feature.
 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 `T` at runtime.
@@ -387,6 +388,12 @@ 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).
+
 **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`

package/README.md

@@ -347,6 +347,21 @@ 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, `extern class Box<T> { ... }` —
+exactly the same single-type-parameter 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 instantiated
+generically, not just per concrete type:
+
+```ks
+extern class Box<T> {
+  constructor(T v);
+  T Value { get; }
+} from "some-package";
+
+Box<number> nb = new Box<number>(5);
+```
+
 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

package/dist/checker.js

@@ -114,6 +114,9 @@ export class Checker {
         for (const i of interfaceDecls)
             if (i.typeParam)
                 this.genericTypeParams.set(i.name, i.typeParam);
+        for (const c of externClassDecls)
+            if (c.typeParam)
+                this.genericTypeParams.set(c.name, c.typeParam);
         for (const e of enumDecls)
             this.registerEnum(e);
         for (const i of interfaceDecls)
@@ -169,28 +172,35 @@ export class Checker {
         });
     }
     registerExternClass(decl) {
-        const fields = new Map();
-        const staticFields = new Map();
-        for (const p of decl.properties) {
-            const info = { type: this.resolveType(p.type, decl.line, decl.col), visibility: "public", hasSetter: p.hasSetter };
-            (p.isStatic ? staticFields : fields).set(p.name, info);
-        }
-        const methods = new Map();
-        const staticMethods = new Map();
-        for (const m of decl.methods) {
-            const info = {
-                params: m.params.map((p) => this.resolveType(p.type, decl.line, decl.col)),
-                returnType: this.resolveType(m.returnType, decl.line, decl.col),
-                visibility: "public",
-                isVirtual: m.isVirtual,
-                isOverride: false,
-            };
-            (m.isStatic ? staticMethods : methods).set(m.name, info);
-        }
-        const ownCtorParams = decl.hasConstructor ? decl.ctorParams.map((p) => this.resolveType(p.type, decl.line, decl.col)) : null;
+        // Same withTypeParamInScope treatment registerClass gives a real class's
+        // signature (fields/methods/ctor params) — an extern class's own `T`
+        // needs to resolve the same way while its declared members are being
+        // resolved, e.g. `state<T> Value;` in an `extern class FormField<T>`.
+        const { fields, staticFields, methods, staticMethods, ownCtorParams } = this.withTypeParamInScope(decl.typeParam, () => {
+            const fields = new Map();
+            const staticFields = new Map();
+            for (const p of decl.properties) {
+                const info = { type: this.resolveType(p.type, decl.line, decl.col), visibility: "public", hasSetter: p.hasSetter };
+                (p.isStatic ? staticFields : fields).set(p.name, info);
+            }
+            const methods = new Map();
+            const staticMethods = new Map();
+            for (const m of decl.methods) {
+                const info = {
+                    params: m.params.map((p) => this.resolveType(p.type, decl.line, decl.col)),
+                    returnType: this.resolveType(m.returnType, decl.line, decl.col),
+                    visibility: "public",
+                    isVirtual: m.isVirtual,
+                    isOverride: false,
+                };
+                (m.isStatic ? staticMethods : methods).set(m.name, info);
+            }
+            const ownCtorParams = decl.hasConstructor ? decl.ctorParams.map((p) => this.resolveType(p.type, decl.line, decl.col)) : null;
+            return { fields, staticFields, methods, staticMethods, ownCtorParams };
+        });
         this.classes.set(decl.name, {
             name: decl.name,
-            typeParam: null,
+            typeParam: decl.typeParam,
             superclass: null,
             interfaces: [],
             fields,

package/dist/parser.js

@@ -455,6 +455,7 @@ export class Parser {
     }
     parseExternClassBody(start, isExported) {
         const name = this.consume(TokenKind.Identifier, "Expected class name").lexeme;
+        const typeParam = this.parseOptionalTypeParam();
         this.consume(TokenKind.LBrace, "Expected '{' before extern class body");
         let hasConstructor = false;
         let ctorParams = [];
@@ -519,7 +520,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, jsName, hasConstructor, ctorParams, properties, methods, modulePath, line: start.line, col: start.col };
+        return { kind: "ExternClassDecl", isExported, name, typeParam, jsName, hasConstructor, ctorParams, properties, methods, modulePath, line: start.line, col: start.col };
     }
     parseBlock() {
         const start = this.consume(TokenKind.LBrace, "Expected '{'");

package/package.json

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