kopscript 0.4.0 → 0.4.1

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

package/dist/checker.js

@@ -856,6 +856,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/package.json

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