kopscript 0.19.0 → 0.19.1

package/dist/codegen.js

@@ -98,8 +98,27 @@ export class CodeGenerator {
     // `public` into scope without naming it explicitly. `sourceFileName`/
     // `sourceText` are for the emitted source map only (both optional so every
     // existing test call site keeps compiling unchanged).
-    generate(program, usingExports = new Map(), rawContents = new Map(), sourceFileName = "source.ks", sourceText = "") {
-        this.interfaceNames = new Set(program.statements.filter((s) => s.kind === "InterfaceDecl").map((s) => s.name));
+    generate(program, usingExports = new Map(), rawContents = new Map(), sourceFileName = "source.ks", sourceText = "", 
+    // Interface names visible via a `using` this module doesn't declare
+    // itself — separate from `usingExports` above, which deliberately
+    // excludes interfaces (they're compile-time only and never produce a
+    // JS import). Without this, a class implementing an interface declared
+    // in a DIFFERENT file (e.g. `class Component : Flushable` where
+    // `Flushable` lives in vdom.ks) has that interface name missing from
+    // `interfaceNames` entirely, so genClass's own "only a non-interface
+    // base list entry becomes `extends`" check can't tell it apart from a
+    // real (missing) superclass — it gets emitted as `extends Flushable`,
+    // a real runtime reference to a name nothing ever imports, throwing
+    // `ReferenceError: Flushable is not defined` the moment the class is
+    // ever loaded. Found for real building Kopular's own event-batching
+    // fix — the checker already resolves a cross-module interface's base
+    // list entry correctly (it type-checks fine); only codegen's own,
+    // separate, same-file-only interfaceNames set didn't know about it.
+    importedInterfaceNames = new Set()) {
+        this.interfaceNames = new Set([
+            ...program.statements.filter((s) => s.kind === "InterfaceDecl").map((s) => s.name),
+            ...importedInterfaceNames,
+        ]);
         this.outputLine = 1;
         const outFileName = sourceFileName.replace(/\.ks$/, ".js");
         this.sourceMap = new SourceMapBuilder(outFileName, sourceFileName, sourceText);

package/dist/modules.js

@@ -226,6 +226,13 @@ export function compileGraph(entryAbsPath, fileOverrides) {
     for (const absPath of order) {
         const mod = modules.get(absPath);
         const usingExports = new Map();
+        // Separate from usingExports (interfaces are excluded there — see its
+        // own comment below) — this is what tells codegen's own interfaceNames
+        // set about an interface declared in a DIFFERENT file this module
+        // `using`s, so a class implementing one doesn't get miscompiled into a
+        // real `extends <InterfaceName>` runtime reference (see
+        // CodeGenerator.generate's own comment on importedInterfaceNames).
+        const importedInterfaceNames = new Set();
         for (const u of mod.program.usings) {
             const depPath = resolve(dirname(absPath), u.path) + ".ks";
             const depExports = exportsByModule.get(depPath);
@@ -234,13 +241,17 @@ export function compileGraph(entryAbsPath, fileOverrides) {
                 // they'd make an invalid import specifier if listed here.
                 const importableTypeNames = [...depExports.namedTypes.entries()].filter(([, kind]) => kind !== "interface").map(([name]) => name);
                 usingExports.set(u.path, [...importableTypeNames, ...depExports.functions.keys(), ...depExports.externValues.keys()]);
+                for (const [name, kind] of depExports.namedTypes) {
+                    if (kind === "interface")
+                        importedInterfaceNames.add(name);
+                }
             }
         }
         // Just the basename, not a cwd-relative path — the .js.map file always
         // lands right next to its .ks/.js siblings (ks build writes output in
         // place), so "sources" has to resolve relative to *that* directory, not
         // wherever the compiler happened to be invoked from.
-        const { code, map } = new CodeGenerator().generate(mod.program, usingExports, rawContentsByModule.get(absPath) ?? new Map(), basename(absPath), mod.source);
+        const { code, map } = new CodeGenerator().generate(mod.program, usingExports, rawContentsByModule.get(absPath) ?? new Map(), basename(absPath), mod.source, importedInterfaceNames);
         outputs.set(absPath, code);
         sourceMaps.set(absPath, map);
     }

package/package.json

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