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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 1.9.6
+Version: 1.9.7
 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.7}/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."""

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

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "1.9.6"
+VERSION = "1.9.7"
 LANG    = "InScript"
 PACKAGES_DIR = os.path.join(os.path.expanduser("~"), ".inscript", "packages")
 REGISTRY_URL = "https://raw.githubusercontent.com/authorss81/inscript-packages/main/registry.json"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 1.9.6
+Version: 1.9.7
 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.7}/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.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "inscript-lang"
-version = "1.9.6"
+version = "1.9.7"
 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.7}/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.7"
 
 # ── ANSI colours ──────────────────────────────────────────────────────────────
 def _c(code, text):

{inscript_lang-1.9.6 → inscript_lang-1.9.7}/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]):