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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: inscript-lang
-Version: 1.9.5
+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.5 → 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.5 → inscript_lang-1.9.7}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "1.9.5"
+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"
@@ -276,7 +276,8 @@ def _compat_files(path: str) -> int:
             print(f"[InScript compat] Cannot read '{fpath}': {e}", file=sys.stderr)
             return issues
         for lineno, line in enumerate(src.splitlines(), 1):
-            if line.lstrip().startswith("//"):
+            stripped = line.lstrip()
+            if stripped.startswith("//") or stripped.startswith("#"):
                 continue
             for pat, msg in CHECKS:
                 if pat.search(line):
@@ -333,9 +334,20 @@ def _migrate_files(path: str) -> int:
             with open(fpath, encoding="utf-8") as f:
                 original = f.read()
             src = original
+            # v1.9.6: // line comments → # line comments  (MUST run before div→// rewrite)
+            # Rule 1: standalone comment lines — optional whitespace then //
+            src = re.sub(r'^(\s*)//', r'\1#', src, flags=re.MULTILINE)
+            # Rule 2: inline word comment — ` // word` → ` # word`
+            # Fires only when identifier/word follows, not digit (digits are floor-div)
+            src = re.sub(r'(\s)//(\s+[A-Za-z_])', r'\1#\2', src)
+            # Rule 3: warn about ambiguous ` // <digit>` patterns (may be comment or floor-div)
+            ambiguous = re.findall(r'(\s)//(\s+\d)', src)
+            if ambiguous:
+                print(f"  WARNING   {fpath}: {len(ambiguous)} ambiguous ' // <digit>' pattern(s) — "
+                      f"check manually: floor-div or comment? Change to '#' if comment.")
             # null → nil
             src = re.sub(r'\bnull\b', 'nil', src)
-            # x div y → x // y  (only bare `div` between expressions)
+            # x div y → x // y  (only bare `div` between expressions, safe after comment rules)
             src = re.sub(r'\bdiv\b', '//', src)
             # bare [] type annotation → array  (e.g. `: []` → `: array`)
             src = re.sub(r':\s*\[\]', ': array', src)
@@ -1154,7 +1166,7 @@ LANGUAGE_SPEC = """# InScript Language Specification
 ## 1. Lexical Structure
 
 ### 1.1 Comments
-- Line comments: `// text`
+- Line comments: `# text`  (v1.9.6: was `// text`)
 - Block comments: `/* text */` (nestable)
 - Doc comments: `/// text` (parsed by `inscript doc`)
 

{inscript_lang-1.9.5 → 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.5
+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.5 → 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.5 → inscript_lang-1.9.7}/lexer.py

@@ -292,26 +292,12 @@ class Lexer:
         if ch in (" ", "\t", "\r", "\n"):
             return
 
-        # // — floor-division operator or line comment
-        # v1.7.1: `//` is now the integer division operator (10 // 3 → 3)
-        # Line comment: `let x = 5   // this is a comment` — space before //
-        # Floor division: `10 // 3`, `x//2`, `(a+b) // c`
-        # Rule: if the character BEFORE // was a digit, ), ], or identifier char → floor div
-        #        otherwise → line comment
+        # // — floor-division operator (v1.9.6: ALWAYS floor division, no exceptions)
+        # v1.9.6: `#` is the new line-comment character.
+        # `//` with or without spaces is always integer floor division: 10 // 3 → 3
         if ch == "/" and self.current == "/":
             self.advance()  # consume second /
-            # Determine: floor-div or line comment?
-            # Rule: the character IMMEDIATELY before first '/' (no whitespace allowed)
-            # must be digit/identifier/closing bracket to be floor-div.
-            # Any space/tab before the // → line comment.
-            first_slash_pos = self.pos - 2
-            prev = self.source[first_slash_pos - 1] if first_slash_pos > 0 else ''
-            if prev and (prev.isdigit() or prev.isalpha() or prev in ')]}'):
-                # `10//3`, `x//2`, `(a+b)//c` — no space → floor division
-                self._emit(TT.SLASH_SLASH, "//", sl, sc)
-            else:
-                # `10 // 3` with spaces, `5 // comment`, `// standalone` → comment
-                self._skip_line_comment()
+            self._emit(TT.SLASH_SLASH, "//", sl, sc)
             return
         if ch == "/" and self.current == "*":
             self._skip_block_comment(sl, sc); return
@@ -586,7 +572,9 @@ class Lexer:
             if self.match("?"):  emit(TT.NULLISH,       "??")
             elif self.match("."): emit(TT.QUESTION_DOT, "?.")
             else:                emit(TT.QUESTION,       "?")
-        elif ch == "#":         emit(TT.HASH,         "#")
+        elif ch == "#":
+            # v1.9.6: # is the line-comment character (was: HASH annotation token)
+            self._skip_line_comment(); return
         elif ch == "@":         emit(TT.AT,           "@")
         elif ch == "(":         emit(TT.LPAREN)
         elif ch == ")":         emit(TT.RPAREN)

{inscript_lang-1.9.5 → inscript_lang-1.9.7}/pyproject.toml

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

{inscript_lang-1.9.5 → 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]):