kopscript 0.7.1 → 0.7.2

package/LLM.md

@@ -504,6 +504,41 @@ signature, use different names, not overloading. (Nested function/class/interfac
 declarations, by contrast, *are* a clean compile error: "Nested ... declarations are not
 supported".)
 
+## Common mistakes (seeded from real generation failures)
+
+Real, observed cases where a plausible-looking guess was wrong — not hypothetical gotchas:
+
+- **No implicit `this`.** Every reference to a member of the enclosing class — a field, a
+  property, a method call — must be `this.X`, always, everywhere, including inside a lambda.
+  `Increment()` inside a method body does **not** resolve to `this.Increment()` the way it
+  would in Java/C#/Python; it's an undefined-identifier error unless `Increment` is a real
+  free function. (Discovered building the template compiler above — templates need a
+  dedicated rewriter, `qualifyThis`, specifically because this isn't automatic.)
+- **No `let`/`var`, ever.** Every local is `Type name = value;` — writing `let x = 5;` or a
+  bare `const x = 5;` (missing the type) is a parse error, not a lenient inferred form.
+- **No generic functions.** `T Identity<T>(T x) { return x; }` doesn't parse — only classes
+  and interfaces take `<T>`. Don't reach for this even though every mainstream generic
+  language supports it.
+- **Early-return doesn't narrow a nullable type.** `if (x == null) { return; } print(x.Length);`
+  still errors on `x.Length` — narrowing is scope-based (an `if`/`else` block), not
+  control-flow/reachability-based. Wrap the rest of the logic in the `if (x != null) { ... }`
+  block instead of guard-clause-and-continue.
+- **Never write `async` on an `extern` signature.** `async task<string> text();` inside an
+  `extern class` is a parse error — declare the return type as `task<string> text();`
+  directly; `async` only means something for a body the checker validates, and an `extern`
+  signature has no body.
+- **No object-literal syntax, anywhere, ever.** Reaching for `{ method: "POST", body: x }` to
+  call a JS API that expects one (a `fetch`-style options argument) doesn't compile — there's
+  no way to construct that value in KopScript at all. See the `extern`/`raw string` sections
+  above and Kopular's `http_runtime.js` for the actual workaround (a small hand-written JS
+  shim), not a language feature to reach for.
+- **No ternary expression.** `cond ? a : b` doesn't parse. Use `match` on a `bool`, or an
+  `if`/`else` assigning to a local declared above it.
+- **Two methods with the same name in one class don't error** — the second silently replaces
+  the first (see "Sharp edge" above). If a generated program seems to call the wrong
+  implementation of something, check for an accidental duplicate name before assuming a
+  compiler bug.
+
 ## Diagnostics
 
 Every compiler error/warning is `{ severity, message, line, col }` (1-based). CLI output

package/package.json

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