kopscript 0.4.1 → 0.5.1

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/codegen.js

@@ -147,10 +147,10 @@ export class CodeGenerator {
                 const init = stmt.init
                     ? stmt.init.kind === "VarDecl"
                         ? `${stmt.init.isConst ? "const" : "let"} ${stmt.init.name} = ${this.genExpr(stmt.init.init)}`
-                        : this.genExpr(stmt.init.expression)
+                        : this.genExprAtStatementLevel(stmt.init.expression)
                     : "";
                 const cond = stmt.condition ? this.genExpr(stmt.condition) : "";
-                const update = stmt.update ? this.genExpr(stmt.update) : "";
+                const update = stmt.update ? this.genExprAtStatementLevel(stmt.update) : "";
                 return `${pad}for (${init}; ${cond}; ${update}) ${this.genBlock(stmt.body, indent).trimStart()}`;
             }
             case "ForInStatement":
@@ -162,7 +162,7 @@ export class CodeGenerator {
             case "ContinueStatement":
                 return `${pad}continue;`;
             case "ExpressionStatement":
-                return `${pad}${this.genExpr(stmt.expression)};`;
+                return `${pad}${this.genExprAtStatementLevel(stmt.expression)};`;
             case "TryStatement":
                 return this.genTry(stmt, indent);
             case "ThrowStatement":
@@ -245,6 +245,22 @@ export class CodeGenerator {
         return `${pad}constructor(${params}) ${bodyStr}`;
     }
     // ---------- expressions ----------
+    // genExpr wraps an assignment in parens unconditionally (`(x = y)`), since
+    // it has to stay safely embeddable wherever an expression can appear —
+    // inside a binary expression, a call argument, anywhere precedence could
+    // matter. At true statement level (an expression-statement, or a for
+    // loop's own init/update clause) nothing surrounds it that parens could
+    // ever matter for, so they're pure noise there — `(this.Count = 0);`
+    // reads like defensive generated code, not something a person would
+    // write by hand. Used at exactly those three call sites, not inside
+    // genExpr itself, since every other embedding context still needs the
+    // defensive parens.
+    genExprAtStatementLevel(expr) {
+        if (expr.kind === "AssignExpr") {
+            return `${this.genExpr(expr.target)} = ${this.genExpr(expr.value)}`;
+        }
+        return this.genExpr(expr);
+    }
     genExpr(expr) {
         switch (expr.kind) {
             case "NumberLiteral":

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.1",
   "description": "KopScript: a small OOP, strongly-typed language that transpiles to JavaScript, with generics and nullable types",
   "type": "module",
   "license": "MIT",