inscript-lang 1.9.6__tar.gz → 1.9.8__tar.gz

{inscript_lang-1.9.6 → inscript_lang-1.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 1.9.6
+Version: 1.9.8
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-1.9.6 → inscript_lang-1.9.8}/analyzer.py

@@ -65,12 +65,14 @@ T_TRANSFORM3D = InScriptType("Transform3D")
 T_TEXTURE = InScriptType("Texture")
 
 T_NEVER  = InScriptType("never")   # v1.8.3: bottom type — function never returns normally
+T_PROMISE = InScriptType("Promise") # v1.9.7: async fn return type
 
 BUILTIN_TYPES: Dict[str, InScriptType] = {
     # canonical names
     "int": T_INT, "float": T_FLOAT, "bool": T_BOOL,
     "string": T_STRING, "void": T_VOID, "null": T_NULL, "any": T_ANY,
     "never": T_NEVER,                                   # v1.8.3
+    "Promise": T_PROMISE,                               # v1.9.7: async fn return type
     # common aliases
     "str": T_STRING, "boolean": T_BOOL, "number": T_FLOAT,
     "nil": T_NULL, "object": T_ANY, "auto": T_ANY,
@@ -648,21 +650,36 @@ class Analyzer(Visitor):
     def visit_FunctionDecl(self, node: FunctionDecl) -> InScriptType:
         ret_type = self._resolve_type_ann(node.return_type)
 
+        # v1.9.7: async fn — external return type is Promise<T>, but the body
+        # is checked against the inner type T (what the fn actually returns).
+        # E.g.: `async fn f() -> string` → body checked vs `string`, external type = Promise<string>
+        is_async = getattr(node, 'is_async', False)
+        if is_async:
+            inner_ret_type = ret_type if ret_type not in (T_ANY, T_VOID) else T_ANY
+            external_ret_type = InScriptType("Promise", [inner_ret_type])
+        else:
+            inner_ret_type    = ret_type
+            external_ret_type = ret_type
+
         # v1.8.4: return type inference — if no annotation and body has a single
-        # unambiguous return type, infer it automatically
-        if node.return_type is None and ret_type == T_ANY and node.body:
+        # unambiguous return type, infer it automatically (use inner type for async)
+        if node.return_type is None and inner_ret_type == T_ANY and node.body:
             inferred = self._infer_fn_return_type(node)
             if inferred not in (T_ANY, T_VOID, T_NULL):
-                ret_type = inferred
+                inner_ret_type = inferred
+                if is_async:
+                    external_ret_type = InScriptType("Promise", [inner_ret_type])
+                else:
+                    external_ret_type = inner_ret_type
                 # Update the hoisted symbol's type to the inferred one
                 existing = self._scope.lookup(node.name)
                 if existing and existing.kind == "fn":
-                    existing.type_ = ret_type
+                    existing.type_ = external_ret_type
 
-        # Register in current scope (if not already hoisted)
+        # Register in current scope using external type (Promise<T> for async)
         if not self._scope.lookup_local(node.name):
             self._define(Symbol(
-                node.name, ret_type, kind="fn",
+                node.name, external_ret_type, kind="fn",
                 fn_node=node, line=node.line, col=node.col
             ))
 
@@ -676,10 +693,10 @@ class Analyzer(Visitor):
 
         # Warn if function declares a non-void return type but body may not return
         if (node.return_type is not None and
-                ret_type.name not in ("void", "nil", "any", "") and
+                inner_ret_type.name not in ("void", "nil", "any", "") and
                 not node.is_native if hasattr(node, 'is_native') else True):
             if node.body and not self._body_always_returns(node.body):
-                if ret_type == T_NEVER:
+                if inner_ret_type == T_NEVER:
                     # v1.8.3: `-> never` functions MUST always throw / diverge
                     self._error(
                         f"Function '{node.name}' is declared '-> never' "
@@ -689,15 +706,15 @@ class Analyzer(Visitor):
                 else:
                     self._warn(
                         "missing-return",
-                        f"Function '{node.name}' declares return type '{ret_type.name}' "
+                        f"Function '{node.name}' declares return type '{inner_ret_type.name}' "
                         f"but not all code paths return a value",
                         node.line
                     )
 
-        # Analyze body in a new scope
+        # Analyze body in a new scope — body return type is inner (not Promise<T>)
         self._push_scope("fn")
         prev_ret = self._current_fn_return_type
-        self._current_fn_return_type = ret_type
+        self._current_fn_return_type = inner_ret_type
 
         # Register parameters — mark used=True so we never warn about unused params
         for param in node.params:
@@ -714,7 +731,7 @@ class Analyzer(Visitor):
 
         self._current_fn_return_type = prev_ret
         self._pop_scope()
-        return ret_type
+        return external_ret_type
 
     def _body_always_returns(self, block) -> bool:
         """Return True if every code path through block ends with a return/throw."""
@@ -1134,13 +1151,21 @@ class Analyzer(Visitor):
     def visit_ArrayLiteralExpr(self, node: ArrayLiteralExpr) -> InScriptType:
         if not node.elements:
             return array_type(T_ANY)
+        # v1.9.8: infer element type; fall back to Array<any> on mixed types
         first_type = self.visit(node.elements[0])
+        # Normalise literal string types to T_STRING for array inference
+        if is_literal_type(first_type):
+            first_type = T_STRING
+        mixed = False
         for elem in node.elements[1:]:
             et = self.visit(elem)
-            if not types_compatible(first_type, et):
-                self._warn(f"Mixed types in array literal: '{first_type}' and '{et}'",
-                           node.line)
-        return array_type(first_type)
+            if is_literal_type(et):
+                et = T_STRING
+            if not types_compatible(first_type, et) and not types_compatible(et, first_type):
+                mixed = True
+        if mixed:
+            return array_type(T_ANY)   # [1, "a", true] → Array<any>
+        return array_type(first_type)  # [1, 2, 3] → Array<int>
 
     def visit_DictLiteralExpr(self, node: DictLiteralExpr) -> InScriptType:
         if not node.pairs:

{inscript_lang-1.9.6 → inscript_lang-1.9.8}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "1.9.6"
+VERSION = "1.9.8"
 LANG    = "InScript"
 PACKAGES_DIR = os.path.join(os.path.expanduser("~"), ".inscript", "packages")
 REGISTRY_URL = "https://raw.githubusercontent.com/authorss81/inscript-packages/main/registry.json"
@@ -315,6 +315,81 @@ def _compat_files(path: str) -> int:
     return 1
 
 
+def _infer_types_file(path: str) -> int:
+    """
+    v1.9.8: `inscript --infer-types FILE`
+    Parse and type-check FILE, then print the inferred type for every
+    let/const declaration. Useful for understanding what the analyzer infers.
+    Returns 0 on success, 1 if file not found or parse error.
+    """
+    import os
+    if not os.path.isfile(path):
+        print(f"[InScript infer-types] File not found: '{path}'", file=sys.stderr)
+        return 1
+    try:
+        with open(path, encoding="utf-8") as f:
+            src = f.read()
+    except OSError as e:
+        print(f"[InScript infer-types] Cannot read '{path}': {e}", file=sys.stderr)
+        return 1
+
+    from lexer import Lexer
+    from parser import Parser
+    from analyzer import Analyzer
+    from ast_nodes import VarDecl
+
+    try:
+        tokens = Lexer(src).tokenize()
+        tree   = Parser(tokens).parse()
+    except Exception as e:
+        print(f"[InScript infer-types] Parse error: {e}", file=sys.stderr)
+        return 1
+
+    analyzer = Analyzer()
+    try:
+        analyzer.analyze(tree)
+    except Exception:
+        pass   # best-effort — show what we have even if there are errors
+
+    # Walk all VarDecl / ConstDecl nodes and report inferred types
+    results = []
+    def _walk(node):
+        if node is None:
+            return
+        if isinstance(node, (VarDecl,)):
+            sym = analyzer._scope.lookup(node.name) if hasattr(analyzer, '_scope') else None
+            typ = sym.type_ if sym else None
+            type_str = str(typ) if typ else "any"
+            results.append((node.line, "let" if not node.is_const else "const",
+                             node.name, type_str))
+        # Recurse into body of blocks, fns etc.
+        for attr in ("body", "then_branch", "else_branch", "value",
+                     "initializer", "statements"):
+            child = getattr(node, attr, None)
+            if child is None:
+                continue
+            if hasattr(child, "__iter__") and not isinstance(child, str):
+                for c in child:
+                    if hasattr(c, "__class__") and hasattr(c, "line"):
+                        _walk(c)
+            elif hasattr(child, "line"):
+                _walk(child)
+
+    if hasattr(tree, "body"):
+        for stmt in tree.body:
+            _walk(stmt)
+
+    if not results:
+        print(f"[InScript infer-types] No let/const declarations found in '{path}'")
+        return 0
+
+    print(f"[InScript infer-types] Inferred types in '{path}':\n")
+    for line, kw, name, typ in results:
+        print(f"  Line {line:3d}:  {kw} {name:<20s}  →  {typ}")
+    print()
+    return 0
+
+
 def _migrate_files(path: str) -> int:
     """v1.7.4: Auto-migrate deprecated InScript syntax in-place."""
     import re, os
@@ -1573,6 +1648,8 @@ Examples:
     parser.add_argument("--check",  action="store_true", help="Type-check only, don't run")
     parser.add_argument("--check-all", metavar="DIR",
                         help="v1.6.0: Check all .ins files in DIR recursively, exit 1 if any errors")
+    parser.add_argument("--infer-types", metavar="FILE",
+                        help="v1.9.8: Print inferred type for every let/const declaration in FILE")
     parser.add_argument("--migrate", metavar="DIR_OR_FILE",
                         help="v1.7.4: Auto-migrate deprecated syntax (null→nil, div→//)")
     parser.add_argument("--compat", metavar="DIR_OR_FILE",
@@ -1754,6 +1831,8 @@ Examples:
         return _fmt_all_files(args.fmt_all)
     if getattr(args, 'migrate', None):
         return _migrate_files(args.migrate)
+    if getattr(args, 'infer_types', None):
+        return _infer_types_file(args.infer_types)
     if getattr(args, 'compat', None):
         return _compat_files(args.compat)
     if getattr(args, 'init', None) is not None:

{inscript_lang-1.9.6 → inscript_lang-1.9.8}/inscript_lang.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 1.9.6
+Version: 1.9.8
 Summary: InScript — a game-focused scripting language with 59 game modules and a bytecode VM
 Author: Shreyasi Sarkar
 License: MIT

{inscript_lang-1.9.6 → inscript_lang-1.9.8}/interpreter.py

@@ -5,14 +5,15 @@
 # After Lexer → Parser → Analyzer pass, this is what runs InScript programs.
 
 from __future__ import annotations
-import math, random, time
+import math, random, time, asyncio
 from typing import Any, Dict, List, Optional
 
 from ast_nodes import *
 from environment import Environment
 from stdlib_values import (
     Vec2, Vec3, Color, Rect,
-    InScriptFunction, InScriptInstance, InScriptRange, InScriptGenerator
+    InScriptFunction, InScriptInstance, InScriptRange, InScriptGenerator,
+    InScriptCoroutine,
 )
 import stdlib as _stdlib  # loads all built-in modules
 from errors import (
@@ -526,6 +527,8 @@ class Interpreter(Visitor):
         # v1.4.0: preserve generic metadata for constraint checking at call time
         fn.type_params  = getattr(node, 'type_params',  [])
         fn.constraints  = getattr(node, 'constraints',  {})
+        # v1.9.7: mark async functions
+        fn.is_async     = getattr(node, 'is_async', False)
         self._env.define(node.name, fn)
         return fn
 
@@ -2319,6 +2322,33 @@ class Interpreter(Visitor):
 
         _bind_args(call_env, arg_vals, arg_names)
 
+        # v1.9.7: async fn — wrap body execution in a Python coroutine
+        if getattr(fn, 'is_async', False):
+            async def _async_body():
+                nonlocal result
+                prev_fn2     = self._current_fn
+                prev_def2    = getattr(self, '_deferred', None)
+                self._deferred   = []
+                self._current_fn = fn
+                try:
+                    for stmt in fn.body.body:
+                        self.visit(stmt)
+                except ReturnSignal as r:
+                    result = r.value
+                except PropagateSignal as sig:
+                    result = sig.err_val
+                finally:
+                    for deferred_expr in reversed(self._deferred):
+                        try: self.visit(deferred_expr)
+                        except Exception: pass
+                    self._deferred    = prev_def2 if prev_def2 is not None else []
+                    self._current_fn  = prev_fn2
+                    self._env         = prev_env
+                    self._call_depth -= 1
+                    self._call_stack.pop()
+                return result
+            return InScriptCoroutine(_async_body(), fn_name=fn.name or "<async>")
+
         # v1.3.0: TCO trampoline — self-recursive tail calls loop instead of recurse
         result = None
         prev_fn     = self._current_fn
@@ -2443,7 +2473,24 @@ class Interpreter(Visitor):
         return InScriptRange(start, end, inclusive=node.inclusive)
 
     def visit_AwaitExpr(self, node: AwaitExpr) -> Any:
-        return self.visit(node.expr)   # synchronous in Phase 4
+        """
+        v1.9.7: True async/await.
+        - InScriptCoroutine → drive via Python coroutine protocol (sync driver).
+        - Plain value → passthrough (backwards compatible).
+
+        We use a synchronous driver (coro.send(None)) rather than asyncio.run()
+        because InScript coroutine bodies contain no real Python await points —
+        they are synchronous interpreter execution wrapped in `async def`.
+        This also safely handles nested async calls without event-loop conflicts.
+        """
+        val = self.visit(node.expr)
+        if isinstance(val, InScriptCoroutine):
+            try:
+                val.coro.send(None)
+                return None   # coroutine yielded unexpectedly — shouldn't happen
+            except StopIteration as e:
+                return e.value
+        return val   # plain value: passthrough
 
     def visit_SpawnExpr(self, node: SpawnExpr) -> Any:
         return None   # Phase 6 (ECS)

{inscript_lang-1.9.6 → inscript_lang-1.9.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "inscript-lang"
-version = "1.9.6"
+version = "1.9.8"
 description = "InScript — a game-focused scripting language with 59 game modules and a bytecode VM"
 readme = "README.md"
 license = { text = "MIT" }

{inscript_lang-1.9.6 → inscript_lang-1.9.8}/repl.py

@@ -40,7 +40,7 @@ sys.path.insert(0, str(Path(__file__).parent))
 
 HISTORY_FILE = Path.home() / ".inscript" / "history"
 HISTORY_FILE.parent.mkdir(parents=True, exist_ok=True)
-VERSION = "1.9.6"
+VERSION = "1.9.8"
 
 # ── ANSI colours ──────────────────────────────────────────────────────────────
 def _c(code, text):

{inscript_lang-1.9.6 → inscript_lang-1.9.8}/stdlib_values.py

@@ -220,7 +220,7 @@ class Rect:
 
 class InScriptFunction:
     """A user-defined function or lambda at runtime."""
-    def __init__(self, name, params, body, closure, is_native=False, native_fn=None, return_type=None):
+    def __init__(self, name, params, body, closure, is_native=False, native_fn=None, return_type=None, is_async=False):
         self.name        = name
         self.params      = params       # List[Param]  AST nodes
         self.body        = body         # BlockStmt AST node
@@ -228,6 +228,7 @@ class InScriptFunction:
         self.is_native   = is_native
         self.native_fn   = native_fn    # Python callable for native fns
         self.return_type = return_type  # Optional type annotation
+        self.is_async    = is_async     # v1.9.7: true for `async fn`
         self._interp     = None         # Set by interpreter so stdlib can call us
 
     def __repr__(self): return f"<fn {self.name}>"
@@ -239,6 +240,21 @@ class InScriptFunction:
         raise TypeError(f"InScriptFunction '{self.name}' cannot be called without an interpreter context")
 
 
+class InScriptCoroutine:
+    """
+    v1.9.7: Wraps the result of calling an `async fn`.
+    Holds a Python coroutine that runs the function body.
+    Driven to completion by `await` via asyncio.
+    """
+    def __init__(self, coro, fn_name: str = "<async>"):
+        self.coro     = coro       # Python coroutine object
+        self.fn_name  = fn_name    # for repr / error messages
+
+    def __repr__(self):
+        return f"<coroutine {self.fn_name}>"
+
+
+
 class InScriptInstance:
     """An instance of a user-defined struct at runtime."""
     def __init__(self, struct_name: str, fields: Dict[str, Any]):