inscript-lang 1.0.23__tar.gz → 1.6.0__tar.gz

inscript_lang-1.6.0/PKG-INFO

@@ -0,0 +1,210 @@
+Metadata-Version: 2.4
+Name: inscript-lang
+Version: 1.6.0
+Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
+Author: Shreyasi Sarkar
+License: MIT
+Project-URL: Homepage, https://github.com/authorss81/inscript
+Project-URL: Repository, https://github.com/authorss81/inscript
+Project-URL: Bug Tracker, https://github.com/authorss81/inscript/issues
+Project-URL: Documentation, https://authorss81.github.io/inscript/docs/
+Keywords: game,scripting,language,gamedev,gdscript
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Software Development :: Interpreters
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Provides-Extra: game
+Requires-Dist: pygame>=2.0; extra == "game"
+Provides-Extra: lsp
+Requires-Dist: pygls>=1.0; extra == "lsp"
+Provides-Extra: all
+Requires-Dist: pygame>=2.0; extra == "all"
+Requires-Dist: pygls>=1.0; extra == "all"
+Dynamic: requires-python
+
+# InScript v1.1.0 — First Stable Release
+
+> **839 tests passing** · **59 stdlib modules** · **Python 3.10+** · **Audit 9.5/10**  
+> `pip install inscript-lang` · **v1.1.0 is the first production-ready release**
+
+InScript is a statically-typed scripting language for 2D games — a readable, safe alternative to GDScript with 59 built-in game modules and a complete bytecode VM.
+
+---
+
+## Install
+
+```bash
+pip install inscript-lang                  # core
+pip install "inscript-lang[game]"          # with pygame
+pip install "inscript-lang[all]"           # pygame + LSP
+inscript --version                         # InScript 1.1.0
+```
+
+---
+
+## Quick Start
+
+```bash
+inscript --repl               # interactive shell
+inscript game.ins             # run a file
+inscript --watch game.ins     # auto-rerun on save
+inscript --fmt game.ins       # format code
+inscript --test               # run test_*.ins files
+inscript --check game.ins     # static analysis only
+```
+
+---
+
+## Language
+
+```inscript
+// Arrow functions
+let evens = [1,2,3,4,5].filter(fn(x) => x % 2 == 0)
+let names = users.map(fn(u) => u.name).sorted()
+
+// ADT enums + exhaustive pattern matching
+enum Shape { Circle(r: float)  Rect(w: float, h: float) }
+
+fn area(s: Shape) -> float {
+    return match s {
+        case Shape.Circle(r) if r > 10.0 { "large" }
+        case Shape.Circle(r)             { 3.14159 * r * r }
+        case Shape.Rect(w, h)            { w * h }
+        case 0..=5                       { 0.0 }
+    }
+}
+
+// Structs with priv, super, decorators
+struct Entity {
+    priv id: int = 0
+    name: string
+    fn update(dt: float) { }
+}
+struct Player extends Entity {
+    fn update(dt: float) {
+        super.update(dt)
+        self.move(dt)
+    }
+}
+
+// Result type chaining
+fn divide(a: float, b: float) -> Result {
+    if b == 0.0 { return Err("zero") }
+    return Ok(a / b)
+}
+let r = divide(10.0, 2.0)
+    .map(fn(v) => v * 3.0)
+    .unwrap_or(0.0)
+
+// Type aliases + nullable + union
+type PlayerID = int
+fn find(id: PlayerID?) -> string|nil { ... }
+
+// Rest destructuring
+let [first, ...rest] = [1,2,3,4,5]
+print(rest)   // [2, 3, 4, 5]
+```
+
+---
+
+## Developer Tools
+
+| Tool | Command |
+|------|---------|
+| Format | `inscript --fmt file.ins` · `--fmt-check` for CI |
+| Watch | `inscript --watch file.ins` (auto-rerun on save) |
+| Test | `inscript --test` (discovers `test_*.ins`) |
+| REPL | `inscript --repl` · `.doc math` for live module docs |
+| Check | `inscript --check file.ins` (static analysis) |
+| LSP | `inscript --lsp` (VS Code extension available) |
+| Playground | [authorss81.github.io/inscript/playground.html](https://authorss81.github.io/inscript/playground.html) |
+
+---
+
+## 59 Game Modules
+
+```inscript
+import "physics2d" as P  // RigidBody, World, collision callbacks
+import "ecs"       as E  // Entity-Component-System
+import "pathfind"  as N  // A*, Dijkstra, flow fields
+import "tilemap"   as T  // load Tiled maps
+import "camera2d"  as C  // follow, shake, zoom
+import "particle"  as FX // emitter, burst, continuous
+import "fsm"       as SM // state machine with guards
+import "save"      as S  // save slots
+import "audio"     as A  // load/play/stop/volume
+import "localize"  as L  // multi-language strings
+// + 49 more: animation, ecs, net_game, image, atlas, shader, ...
+```
+
+---
+
+## Testing Your Code
+
+```inscript
+// test_game.ins
+test "player moves right" {
+    let p = Player{x: 0.0, y: 0.0}
+    p.move(1.0, 0.0)
+    assert(p.x == 5.0, "moved right")
+}
+
+test "score increases" {
+    let g = Game{}
+    g.add_score(100)
+    assert(g.score == 100, "score added")
+}
+```
+
+```bash
+inscript --test              # ✅ 2/2 tests passed  12ms
+inscript --test --verbose    # shows each test name
+```
+
+---
+
+## GitHub Actions (auto-publish)
+
+The `.github/workflows/publish.yml` workflow automatically publishes to PyPI when you push a version tag:
+
+```bash
+git tag -a v1.2.0 -m "InScript v1.2.0"
+git push origin v1.2.0
+# → tests run, then auto-uploads to PyPI
+```
+
+Setup: add `PYPI_API_TOKEN` to GitHub repo secrets.
+
+---
+
+## Upgrading
+
+```bash
+pip install --upgrade inscript-lang   # from v1.0.x
+```
+
+All v1.0.x syntax is fully backward compatible. No changes needed.
+
+---
+
+## Roadmap
+
+| Version | Focus |
+|---------|-------|
+| **v1.1.0** ← you are here | First stable — all tooling complete |
+| v1.2.0 | Type safety — generic enforcement, type narrowing |
+| v1.3.0 | Performance — C extension (5-15× speedup) |
+| v2.0.0 | Ecosystem — package registry, Studio IDE, WASM |
+
+[ROADMAP.md](ROADMAP.md) · [Audit (9.5/10)](InScript_Language_Audit.md) · [Docs](https://authorss81.github.io/inscript/docs/)
+
+---
+
+MIT License · [GitHub](https://github.com/authorss81/inscript) · [PyPI](https://pypi.org/project/inscript-lang/)

inscript_lang-1.6.0/README.md

@@ -0,0 +1,179 @@
+# InScript v1.1.0 — First Stable Release
+
+> **839 tests passing** · **59 stdlib modules** · **Python 3.10+** · **Audit 9.5/10**  
+> `pip install inscript-lang` · **v1.1.0 is the first production-ready release**
+
+InScript is a statically-typed scripting language for 2D games — a readable, safe alternative to GDScript with 59 built-in game modules and a complete bytecode VM.
+
+---
+
+## Install
+
+```bash
+pip install inscript-lang                  # core
+pip install "inscript-lang[game]"          # with pygame
+pip install "inscript-lang[all]"           # pygame + LSP
+inscript --version                         # InScript 1.1.0
+```
+
+---
+
+## Quick Start
+
+```bash
+inscript --repl               # interactive shell
+inscript game.ins             # run a file
+inscript --watch game.ins     # auto-rerun on save
+inscript --fmt game.ins       # format code
+inscript --test               # run test_*.ins files
+inscript --check game.ins     # static analysis only
+```
+
+---
+
+## Language
+
+```inscript
+// Arrow functions
+let evens = [1,2,3,4,5].filter(fn(x) => x % 2 == 0)
+let names = users.map(fn(u) => u.name).sorted()
+
+// ADT enums + exhaustive pattern matching
+enum Shape { Circle(r: float)  Rect(w: float, h: float) }
+
+fn area(s: Shape) -> float {
+    return match s {
+        case Shape.Circle(r) if r > 10.0 { "large" }
+        case Shape.Circle(r)             { 3.14159 * r * r }
+        case Shape.Rect(w, h)            { w * h }
+        case 0..=5                       { 0.0 }
+    }
+}
+
+// Structs with priv, super, decorators
+struct Entity {
+    priv id: int = 0
+    name: string
+    fn update(dt: float) { }
+}
+struct Player extends Entity {
+    fn update(dt: float) {
+        super.update(dt)
+        self.move(dt)
+    }
+}
+
+// Result type chaining
+fn divide(a: float, b: float) -> Result {
+    if b == 0.0 { return Err("zero") }
+    return Ok(a / b)
+}
+let r = divide(10.0, 2.0)
+    .map(fn(v) => v * 3.0)
+    .unwrap_or(0.0)
+
+// Type aliases + nullable + union
+type PlayerID = int
+fn find(id: PlayerID?) -> string|nil { ... }
+
+// Rest destructuring
+let [first, ...rest] = [1,2,3,4,5]
+print(rest)   // [2, 3, 4, 5]
+```
+
+---
+
+## Developer Tools
+
+| Tool | Command |
+|------|---------|
+| Format | `inscript --fmt file.ins` · `--fmt-check` for CI |
+| Watch | `inscript --watch file.ins` (auto-rerun on save) |
+| Test | `inscript --test` (discovers `test_*.ins`) |
+| REPL | `inscript --repl` · `.doc math` for live module docs |
+| Check | `inscript --check file.ins` (static analysis) |
+| LSP | `inscript --lsp` (VS Code extension available) |
+| Playground | [authorss81.github.io/inscript/playground.html](https://authorss81.github.io/inscript/playground.html) |
+
+---
+
+## 59 Game Modules
+
+```inscript
+import "physics2d" as P  // RigidBody, World, collision callbacks
+import "ecs"       as E  // Entity-Component-System
+import "pathfind"  as N  // A*, Dijkstra, flow fields
+import "tilemap"   as T  // load Tiled maps
+import "camera2d"  as C  // follow, shake, zoom
+import "particle"  as FX // emitter, burst, continuous
+import "fsm"       as SM // state machine with guards
+import "save"      as S  // save slots
+import "audio"     as A  // load/play/stop/volume
+import "localize"  as L  // multi-language strings
+// + 49 more: animation, ecs, net_game, image, atlas, shader, ...
+```
+
+---
+
+## Testing Your Code
+
+```inscript
+// test_game.ins
+test "player moves right" {
+    let p = Player{x: 0.0, y: 0.0}
+    p.move(1.0, 0.0)
+    assert(p.x == 5.0, "moved right")
+}
+
+test "score increases" {
+    let g = Game{}
+    g.add_score(100)
+    assert(g.score == 100, "score added")
+}
+```
+
+```bash
+inscript --test              # ✅ 2/2 tests passed  12ms
+inscript --test --verbose    # shows each test name
+```
+
+---
+
+## GitHub Actions (auto-publish)
+
+The `.github/workflows/publish.yml` workflow automatically publishes to PyPI when you push a version tag:
+
+```bash
+git tag -a v1.2.0 -m "InScript v1.2.0"
+git push origin v1.2.0
+# → tests run, then auto-uploads to PyPI
+```
+
+Setup: add `PYPI_API_TOKEN` to GitHub repo secrets.
+
+---
+
+## Upgrading
+
+```bash
+pip install --upgrade inscript-lang   # from v1.0.x
+```
+
+All v1.0.x syntax is fully backward compatible. No changes needed.
+
+---
+
+## Roadmap
+
+| Version | Focus |
+|---------|-------|
+| **v1.1.0** ← you are here | First stable — all tooling complete |
+| v1.2.0 | Type safety — generic enforcement, type narrowing |
+| v1.3.0 | Performance — C extension (5-15× speedup) |
+| v2.0.0 | Ecosystem — package registry, Studio IDE, WASM |
+
+[ROADMAP.md](ROADMAP.md) · [Audit (9.5/10)](InScript_Language_Audit.md) · [Docs](https://authorss81.github.io/inscript/docs/)
+
+---
+
+MIT License · [GitHub](https://github.com/authorss81/inscript) · [PyPI](https://pypi.org/project/inscript-lang/)

{inscript_lang-1.0.23 → inscript_lang-1.6.0}/analyzer.py

@@ -133,6 +133,7 @@ class Symbol:
         self.struct_node = struct_node   # for structs: the AST node
         self.line        = line
         self.col         = col
+        self.used        = False         # v1.2.0: unused-variable tracking
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -180,7 +181,8 @@ class Analyzer(Visitor):
     def __init__(self, source_lines: List[str] = None,
                  multi_error: bool = True,
                  warn_as_error: bool = False,
-                 no_warn: bool = False):
+                 no_warn: bool = False,
+                 no_warn_unused: bool = False):
         self._src         = source_lines or []
         self._scope       = Scope(kind="global")
         self._errors:   List[SemanticError]    = []   # collected (multi-error)
@@ -188,6 +190,8 @@ class Analyzer(Visitor):
         self._multi_error  = multi_error
         self._warn_as_error = warn_as_error
         self._no_warn      = no_warn
+        self._no_warn_unused = no_warn_unused
+        self._dispatch: dict = {}   # v1.3.0: cached dispatch
 
         # State for context-sensitive checks
         self._current_fn_return_type: Optional[InScriptType] = None
@@ -261,6 +265,7 @@ class Analyzer(Visitor):
             candidates = list(self._all_visible_names())
             self._error(f"Undefined name: '{name}'", line, col, candidates)
             return Symbol(name, T_ANY, kind="var")   # dummy to continue analysis
+        sym.used = True   # v1.2.0: mark as used
         return sym
 
     def _all_visible_names(self) -> List[str]:
@@ -307,6 +312,19 @@ class Analyzer(Visitor):
 
     def _pop_scope(self) -> Scope:
         old = self._scope
+        # v1.2.0: warn about unused locals in fn/block scopes
+        if (not self._no_warn and not self._no_warn_unused
+                and old.kind in ("fn", "block", "match_arm")):
+            for sym in old.symbols.values():
+                if (sym.kind in ("var", "const")
+                        and not sym.used
+                        and not sym.name.startswith("_")):
+                    self._warn(
+                        "unused",
+                        f"Variable '{sym.name}' is defined but never used "
+                        f"(prefix with '_' to suppress)",
+                        sym.line,
+                    )
         self._scope = self._scope.parent
         return old
 
@@ -523,13 +541,15 @@ class Analyzer(Visitor):
         prev_ret = self._current_fn_return_type
         self._current_fn_return_type = ret_type
 
-        # Register parameters
+        # Register parameters — mark used=True so we never warn about unused params
         for param in node.params:
             p_type = self._resolve_type_ann(param.type_ann)
-            self._define(Symbol(
+            sym = Symbol(
                 param.name, p_type, kind="var",
                 line=param.line, col=param.col
-            ))
+            )
+            sym.used = True   # params are always "used" by the caller
+            self._define(sym)
 
         # Analyze body
         self.visit(node.body)
@@ -657,17 +677,18 @@ class Analyzer(Visitor):
 
     def visit_BlockStmt(self, node: BlockStmt) -> InScriptType:
         self._push_scope("block")
-        returned = False
+        terminated = False   # True after return/break/continue/throw
         for stmt in node.body:
-            if returned:
-                # 3.6: warn about unreachable code after return/break/continue
+            if terminated and not self._no_warn:
                 line = getattr(stmt, "line", 0)
                 self._warn("unreachable",
-                           "Unreachable code after return/break/continue", line)
-                break
+                           "Unreachable code after return/break/continue/throw",
+                           line)
+                # Still visit so inner undefined-name errors are caught
             self.visit(stmt)
-            if isinstance(stmt, (ReturnStmt, BreakStmt, ContinueStmt)):
-                returned = True
+            from ast_nodes import ThrowStmt as ThrowStmt_
+            if isinstance(stmt, (ReturnStmt, BreakStmt, ContinueStmt, ThrowStmt_)):
+                terminated = True
         self._pop_scope()
         return T_VOID
 

{inscript_lang-1.0.23 → inscript_lang-1.6.0}/ast_nodes.py

@@ -344,6 +344,12 @@ class MatchArm(Node):
     guard:       Optional[Node] = None    # if condition: case x if x > 0 { ... }
     binding:     Optional[str]  = None   # case h if h <= 0 { ... } — 'h' bound to subject
 
+@dataclass
+class TypePattern(Node):
+    """v1.4.0: type-narrowing match pattern — case int x { } or case Vec2 v { }"""
+    type_name: str          # "int", "float", "string", "bool", or struct name
+    var_name:  str          # variable bound to the narrowed value
+
 @dataclass
 class MatchStmt(Node):
     subject: Node
@@ -429,8 +435,14 @@ class Visitor:
     """
 
     def visit(self, node: Node) -> Any:
-        method = getattr(self, f"visit_{type(node).__name__}", self.generic_visit)
-        return method(node)
+        # v1.3.0: cache dispatch table per visitor class to avoid getattr on every call
+        cls = type(node)
+        try:
+            return self._dispatch[cls](node)
+        except KeyError:
+            method = getattr(self, f"visit_{cls.__name__}", self.generic_visit)
+            self._dispatch[cls] = method
+            return method(node)
 
     def generic_visit(self, node: Node) -> Any:
         raise NotImplementedError(
@@ -447,6 +459,17 @@ class ThrowStmt(Node):
     """throw ErrorExpr"""
     value: Node
 
+@dataclass
+class DeferStmt(Node):
+    """v1.4.0: defer expr_or_call — runs at end of enclosing function/block"""
+    expr: Node
+
+@dataclass
+class RepeatUntilStmt(Node):
+    """v1.4.0: repeat { body } until condition — do-while equivalent"""
+    body:      "BlockStmt"
+    condition: Node
+
 @dataclass
 class TryCatchStmt(Node):
     """try { body } catch(e: T) { ... } catch e { ... } — multiple catch clauses supported"""

{inscript_lang-1.0.23 → inscript_lang-1.6.0}/compiler.py

@@ -217,12 +217,113 @@ class Compiler:
     def _patch_a(self, idx): self._scope.proto.code[idx].a = len(self._scope.proto.code)-idx-1
     def _patch_c(self, idx, val): self._scope.proto.code[idx].c = val
 
+    # v1.3.0: constant folding helpers ─────────────────────────────────────────
+    def _try_fold_literal(self, node):
+        """Return (node_type, python_value) if node is a compile-time constant, else None."""
+        from ast_nodes import (IntLiteralExpr, FloatLiteralExpr, StringLiteralExpr,
+                               BoolLiteralExpr, NullLiteralExpr, UnaryExpr)
+        if isinstance(node, IntLiteralExpr):   return ('int',   node.value)
+        if isinstance(node, FloatLiteralExpr): return ('float', node.value)
+        if isinstance(node, StringLiteralExpr):return ('str',   node.value)
+        if isinstance(node, BoolLiteralExpr):  return ('bool',  node.value)
+        if isinstance(node, NullLiteralExpr):  return ('nil',   None)
+        # Fold unary minus on literals: -5 → -5
+        if isinstance(node, UnaryExpr) and node.op == '-':
+            inner = self._try_fold_literal(node.operand)
+            if inner and inner[0] in ('int', 'float'):
+                return (inner[0], -inner[1])
+        return None
+
+    def _fold_op(self, left, op, right):
+        """Fold a binary operation on Python literals. Returns result or None if unsafe."""
+        try:
+            if op == '+':
+                if isinstance(left, str) or isinstance(right, str):
+                    return str(left) + str(right)
+                return left + right
+            if op == '-':  return left - right
+            if op == '*':  return left * right
+            if op == '/':
+                if right == 0: return None   # keep runtime div-by-zero error
+                return left / right
+            if op == '//':
+                if right == 0: return None
+                return int(left // right)
+            if op == '%':
+                if right == 0: return None
+                return left % right
+            if op == '**':
+                # guard against huge exponents
+                if isinstance(right, (int, float)) and right > 64: return None
+                return left ** right
+            if op == '==': return left == right
+            if op == '!=': return left != right
+            if op == '<':  return left <  right
+            if op == '>':  return left >  right
+            if op == '<=': return left <= right
+            if op == '>=': return left >= right
+            if op == '++':
+                return str(left) + str(right)
+        except Exception:
+            pass
+        return None
+
     # ── compile entry ─────────────────────────────────────────────────────────
     def compile(self, prog):
         for node in prog.body: self._stmt(node)
         self._e(Op.RETURN, NIL_REG)
+        self._eliminate_dead_code(self._proto)
         return self._proto
 
+    def _eliminate_dead_code(self, proto):
+        """v1.3.0: remove unreachable instructions after unconditional JUMP/RETURN."""
+        code = proto.code
+        reachable = set()
+        worklist = [0]
+        while worklist:
+            pc = worklist.pop()
+            if pc < 0 or pc >= len(code) or pc in reachable:
+                continue
+            reachable.add(pc)
+            ins = code[pc]
+
+            if ins.op == Op.RETURN:
+                continue  # terminal
+
+            if ins.op == Op.JUMP:
+                target = pc + 1 + ins.b
+                worklist.append(target)
+                continue   # unconditional — don't fall through
+
+            if ins.op in (Op.JUMP_IF_FALSE, Op.JUMP_IF_TRUE, Op.JUMP_IF_NIL):
+                worklist.append(pc + 1)          # fall-through
+                worklist.append(pc + 1 + ins.b)  # branch target
+                continue
+
+            # PUSH_HANDLER: exception can jump to (pc + 1 + a) at any time
+            if ins.op == Op.PUSH_HANDLER:
+                worklist.append(pc + 1)          # normal path continues
+                worklist.append(pc + 1 + ins.a)  # catch handler target
+                continue
+
+            # ITER_NEXT: on exhaustion jumps forward by c; otherwise falls through
+            if ins.op == Op.ITER_NEXT:
+                worklist.append(pc + 1)          # loop body
+                worklist.append(pc + 1 + ins.c)  # past the loop
+                continue
+
+            worklist.append(pc + 1)   # normal fall-through
+
+        # Replace unreachable instructions with NOP (MOVE r0,r0)
+        for i, ins in enumerate(code):
+            if i not in reachable:
+                ins.op = Op.MOVE; ins.a = 0; ins.b = 0; ins.c = 0
+
+        # Recurse into nested function protos
+        for c in proto.consts:
+            if hasattr(c, 'code'):   # it's a FnProto
+                self._eliminate_dead_code(c)
+
     # ── statements ────────────────────────────────────────────────────────────
     def _stmt(self, node):
         if node is None: return
@@ -902,6 +1003,18 @@ class Compiler:
     # ── binary ────────────────────────────────────────────────────────────────
     def _binary(self, node):
         op  = node.op; dst = self._alloc()
+
+        # v1.3.0: constant folding — evaluate at compile time if both operands are literals
+        if op not in ('&&', '||') and not op.endswith('='):
+            lv_node, rv_node = node.left, node.right
+            lv_lit = self._try_fold_literal(lv_node)
+            rv_lit = self._try_fold_literal(rv_node)
+            if lv_lit is not None and rv_lit is not None:
+                folded = self._fold_op(lv_lit[1], op, rv_lit[1])
+                if folded is not None:
+                    self._load_lit(folded, dst)
+                    return dst
+
         if op == '&&':
             l = self._expr(node.left); self._e(Op.MOVE, dst, l); self._free(l)
             jf = self._e(Op.JUMP_IF_FALSE, dst, 0)

{inscript_lang-1.0.23 → inscript_lang-1.6.0}/errors.py

@@ -349,3 +349,9 @@ class YieldSignal(Exception):
 class PropagateSignal(Exception):
     def __init__(self, err_val):
         self.err_val = err_val
+
+class TailCallSignal(Exception):
+    """v1.3.0: raised by a self-recursive tail call to trampoline in _call_function."""
+    __slots__ = ("arg_vals",)
+    def __init__(self, arg_vals):
+        self.arg_vals = arg_vals