kopscript 0.4.0 → 0.5.0

package/LLM.md

@@ -201,6 +201,11 @@ $"Hello {name}, you are {age} years old"   // interpolated string
 r"^[a-z]+$"               // regex literal (only meaningful as a match pattern)
 ```
 
+A regex literal's contents pass to the real `RegExp` unprocessed — `\s`, `\d`, `\w`, `\.`,
+etc. all mean real regex syntax, not string escapes (only `\"` is special, letting a
+literal `"` appear before the closing quote). This differs from every other string-like
+literal in the language, which do interpret `\n`/`\t`/`\\`/etc.
+
 ### Lambdas
 
 ```ks
@@ -276,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.
@@ -382,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,
@@ -856,6 +866,15 @@ export class Checker {
         this.checkBlock(decl.body, scope, { returnType, currentClass: null, inConstructor: false, loopDepth: 0, isAsync: decl.isAsync });
     }
     checkClassBody(decl) {
+        // Constructor/method *bodies* run in this same scope registerClass used
+        // for the *signatures* (see withTypeParamInScope) — without it, `T`
+        // resolves everywhere in a generic class's declared field/param/return
+        // types but not inside a method body itself (a local `T x = ...;`, or a
+        // lambda parameter typed `T`), which would make the type parameter
+        // usable only at the class's boundary and not inside its own logic.
+        this.withTypeParamInScope(decl.typeParam, () => this.checkClassBodyInner(decl));
+    }
+    checkClassBodyInner(decl) {
         const info = this.classes.get(decl.name);
         if (decl.constructor) {
             const paramScope = new Scope();

package/dist/lexer.js

@@ -133,12 +133,27 @@ export class Lexer {
         }
         return this.make(TokenKind.InterpolatedString, raw, line, col);
     }
+    // Deliberately its own reader, not `readStringChar` — a regex literal's
+    // backslash escapes (`\s`, `\d`, `\.`, ...) are regex syntax, meant to
+    // reach the real `RegExp` constructor unchanged, not string escapes to be
+    // interpreted here. `readStringChar` turns any unrecognized `\x` into a
+    // bare `x` (dropping the backslash), which silently corrupts almost every
+    // realistic pattern. Only `\"` gets special handling, so a literal quote
+    // can appear inside a pattern without ending the literal early; every
+    // other `\` + character (including `\\` itself) passes through verbatim.
     readRegexLiteral(line, col) {
         this.advance(); // 'r'
         this.advance(); // opening quote
         let value = "";
         while (!this.isAtEnd() && this.peek() !== '"') {
-            value += this.readStringChar();
+            const c = this.advance();
+            if (c === "\\" && !this.isAtEnd()) {
+                const next = this.advance();
+                value += next === '"' ? '"' : "\\" + next;
+            }
+            else {
+                value += c;
+            }
         }
         if (this.isAtEnd()) {
             this.diagnostics.error("Unterminated regex literal", line, col);

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.0",
+  "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",