inscript-lang 1.8.2__tar.gz → 1.8.4__tar.gz

{inscript_lang-1.8.2 → inscript_lang-1.8.4}/PKG-INFO

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

{inscript_lang-1.8.2 → inscript_lang-1.8.4}/analyzer.py

@@ -64,10 +64,13 @@ T_TRANSFORM2D = InScriptType("Transform2D")
 T_TRANSFORM3D = InScriptType("Transform3D")
 T_TEXTURE = InScriptType("Texture")
 
+T_NEVER  = InScriptType("never")   # v1.8.3: bottom type — function never returns normally
+
 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
     # common aliases
     "str": T_STRING, "boolean": T_BOOL, "number": T_FLOAT,
     "nil": T_NULL, "object": T_ANY, "auto": T_ANY,
@@ -141,6 +144,8 @@ def types_compatible(expected: InScriptType, got: InScriptType) -> bool:
     """True if `got` can be used where `expected` is required."""
     if expected == T_ANY or got == T_ANY: return True
     if expected == got: return True
+    # v1.8.3: `never` is the bottom type — compatible with any expected type
+    if got == T_NEVER: return True
     # int can widen to float
     if expected == T_FLOAT and got == T_INT: return True
     # null/nil can be assigned to any nullable or union containing nil
@@ -266,7 +271,8 @@ class Analyzer(Visitor):
         self._in_scene:    bool = False
         self._in_match_arm: bool = False
         self._struct_defs: Dict[str, StructDecl] = {}
-        self._type_aliases: Dict[str, "InScriptType"] = {}  # v1.8.2: registered aliases
+        self._type_aliases: Dict[str, "InScriptType"] = {}  # v1.8.2
+        self._interfaces:   Dict[str, dict] = {}             # v1.8.3: name → {method: (params, ret)}
 
         # Pre-register built-in global functions
         self._register_builtins()
@@ -521,8 +527,8 @@ class Analyzer(Visitor):
 
     def _hoist_top_level(self, program: Program):
         """Register structs, scenes, top-level functions, and type aliases before checking bodies."""
-        from ast_nodes import TypeAliasDecl
-        # First sub-pass: register type aliases and structs (order-independent)
+        from ast_nodes import TypeAliasDecl, InterfaceDecl
+        # First sub-pass: register type aliases, structs, and interfaces
         for node in program.body:
             if isinstance(node, StructDecl):
                 self._struct_defs[node.name] = node
@@ -532,7 +538,6 @@ class Analyzer(Visitor):
                     line=node.line, col=node.col
                 )
             elif isinstance(node, TypeAliasDecl):
-                # v1.8.2: register alias immediately so functions can use it
                 type_ann = getattr(node, 'type_ann', None)
                 if type_ann is not None:
                     resolved = self._resolve_type_ann(type_ann)
@@ -543,6 +548,19 @@ class Analyzer(Visitor):
                     node.name, resolved, kind="type",
                     line=node.line, col=node.col
                 )
+            elif isinstance(node, InterfaceDecl):
+                # v1.8.3: register interface so structs can reference it
+                iface_methods = {}
+                for m in getattr(node, 'methods', []):
+                    ret    = self._resolve_type_ann(getattr(m, 'return_type', None))
+                    params = [self._resolve_type_ann(getattr(p, 'type_ann', None))
+                              for p in getattr(m, 'params', [])]
+                    iface_methods[m.name] = (params, ret)
+                self._interfaces[node.name] = iface_methods
+                self._scope.symbols[node.name] = Symbol(
+                    node.name, T_ANY, kind="interface",
+                    line=node.line, col=node.col
+                )
         # Second sub-pass: hoist functions, scenes, enums (can now reference aliases)
         for node in program.body:
             if isinstance(node, FunctionDecl):
@@ -617,6 +635,17 @@ class Analyzer(Visitor):
     def visit_FunctionDecl(self, node: FunctionDecl) -> InScriptType:
         ret_type = self._resolve_type_ann(node.return_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:
+            inferred = self._infer_fn_return_type(node)
+            if inferred not in (T_ANY, T_VOID, T_NULL):
+                ret_type = inferred
+                # 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
+
         # Register in current scope (if not already hoisted)
         if not self._scope.lookup_local(node.name):
             self._define(Symbol(
@@ -637,12 +666,20 @@ class Analyzer(Visitor):
                 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):
-                self._warn(
-                    "missing-return",
-                    f"Function '{node.name}' declares return type '{ret_type.name}' "
-                    f"but not all code paths return a value",
-                    node.line
-                )
+                if ret_type == T_NEVER:
+                    # v1.8.3: `-> never` functions MUST always throw / diverge
+                    self._error(
+                        f"Function '{node.name}' is declared '-> never' "
+                        f"but not all code paths throw or diverge",
+                        node.line
+                    )
+                else:
+                    self._warn(
+                        "missing-return",
+                        f"Function '{node.name}' declares return type '{ret_type.name}' "
+                        f"but not all code paths return a value",
+                        node.line
+                    )
 
         # Analyze body in a new scope
         self._push_scope("fn")
@@ -713,6 +750,26 @@ class Analyzer(Visitor):
         for method in node.methods:
             self.visit_FunctionDecl(method)
 
+        # v1.8.3: interface enforcement — check every declared interface is satisfied
+        struct_method_names = {m.name for m in node.methods}
+        # Also include methods from static_methods
+        struct_method_names |= {m.name for m in (node.static_methods or [])}
+        for iface_name in (node.interfaces or []):
+            required = self._interfaces.get(iface_name)
+            if required is None:
+                self._error(
+                    f"Struct '{node.name}' implements unknown interface '{iface_name}'",
+                    node.line
+                )
+                continue
+            missing_methods = sorted(required.keys() - struct_method_names)
+            if missing_methods:
+                self._error(
+                    f"Struct '{node.name}' implements '{iface_name}' "
+                    f"but is missing method(s): {missing_methods}",
+                    node.line
+                )
+
         self._pop_scope()
         return struct_type
 
@@ -757,6 +814,21 @@ class Analyzer(Visitor):
             )
         return enum_type
 
+    def visit_InterfaceDecl(self, node) -> InScriptType:
+        """v1.8.3: Register interface method signatures for implementation checking."""
+        iface_methods = {}
+        for m in getattr(node, 'methods', []):
+            ret  = self._resolve_type_ann(getattr(m, 'return_type', None))
+            params = [self._resolve_type_ann(getattr(p, 'type_ann', None))
+                      for p in getattr(m, 'params', [])]
+            iface_methods[m.name] = (params, ret)
+        self._interfaces[node.name] = iface_methods
+        self._scope.symbols[node.name] = Symbol(
+            node.name, T_ANY, kind="interface",
+            line=node.line, col=node.col
+        )
+        return T_VOID
+
     def visit_TypeAliasDecl(self, node) -> InScriptType:
         """v1.8.2: Register a type alias so annotations can reference it by name."""
         if hasattr(node, 'type_ann') and node.type_ann is not None:
@@ -965,47 +1037,56 @@ class Analyzer(Visitor):
 
     def _check_match_exhaustiveness(self, node: MatchStmt) -> None:
         """
-        If the match subject is a typed variable whose type is a known enum,
-        warn when not all variants are covered and there is no wildcard arm.
+        v1.8.3: Enum exhaustiveness is now a SemanticError (not a warning).
+        If the match subject is a variable typed as a known enum and no wildcard
+        is present, every variant must be explicitly covered.
         """
-        subject = node.subject
+        subject  = node.subject
         enum_name = None
 
         if isinstance(subject, IdentExpr):
             sym = self._scope.lookup(subject.name)
-            if sym and sym.type_ and sym.type_.name in self._scope.symbols:
-                candidate = self._scope.symbols[sym.type_.name]
-                if candidate.kind == "enum":
-                    enum_name = sym.type_.name
+            if sym and sym.type_:
+                t = sym.type_
+                # Resolve via the full scope chain, not just current scope
+                cand = self._scope.lookup(t.name)
+                if cand and cand.kind == "enum":
+                    enum_name = t.name
 
         if enum_name is None:
-            return  # can't determine enum — skip
+            return  # subject is not a typed enum variable — skip
 
-        enum_sym = self._scope.symbols.get(enum_name)
+        enum_sym = self._scope.lookup(enum_name)
         if not enum_sym or enum_sym.fn_node is None:
             return
-        enum_decl = enum_sym.fn_node
+        enum_decl  = enum_sym.fn_node
         all_variants = {v.name for v in getattr(enum_decl, 'variants', [])}
         if not all_variants:
             return
 
-        # Collect explicitly covered variants: case EnumName.Variant
+        # Collect explicitly covered variants
+        # `case Dir::Left` → NamespaceAccessExpr(namespace="Dir", member="Left")
+        # `case Dir.Left`  → GetAttrExpr(obj=IdentExpr("Dir"), attr="Left")  (legacy)
         covered = set()
         for arm in node.arms:
             p = arm.pattern
             if p is None:
-                return  # wildcard — exhaustive
-            if (isinstance(p, GetAttrExpr)
+                return  # wildcard — exhaustive by definition
+            # Primary form: Dir::Variant
+            if (hasattr(p, 'namespace') and hasattr(p, 'member')
+                    and p.namespace == enum_name):
+                covered.add(p.member)
+            # Legacy form: Dir.Variant
+            elif (isinstance(p, GetAttrExpr)
                     and isinstance(p.obj, IdentExpr)
                     and p.obj.name == enum_name):
                 covered.add(p.attr)
 
         missing = sorted(all_variants - covered)
         if missing:
-            self._warn(
-                "exhaustive_match",
+            self._error(
                 f"Non-exhaustive match on '{enum_name}': "
-                f"variants {missing} not covered. Add missing cases or a wildcard 'case _'",
+                f"missing variant(s) {missing}. Add the missing cases or a wildcard arm 'case _'",
                 node.line
             )
 
@@ -1220,8 +1301,288 @@ class Analyzer(Visitor):
                 return sym.type_
 
         if isinstance(node.callee, GetAttrExpr):
+            # v1.8.4: infer return types of array method chains
+            obj_type = self.visit(node.callee.obj)
+            # v1.8.2 literal_type("hello") → dispatch as T_STRING
+            if is_literal_type(obj_type):
+                obj_type = T_STRING
+            method   = node.callee.attr
+            return self._infer_method_call_type(obj_type, method, node)
+
+        return T_ANY
+
+    def _infer_method_call_type(self, obj_type: InScriptType,
+                                 method: str, call_node) -> InScriptType:
+        """
+        v1.8.4: Infer the return type of a method call based on the receiver's type.
+
+        Array methods:
+          .map(fn)      → Array<T> where T = inferred return type of fn
+          .filter(fn)   → Array<elem>  (same element type, just fewer items)
+          .flatMap(fn)  → Array<T>
+          .take(n)      → Array<elem>
+          .skip(n)      → Array<elem>
+          .slice(a,b)   → Array<elem>
+          .sorted()     → Array<elem>
+          .reversed()   → Array<elem>
+          .unique()     → Array<elem>
+          .len()        → int
+          .count()      → int
+          .sum()        → int | float
+          .first()      → elem?   (optional)
+          .last()       → elem?
+          .find(fn)     → elem?
+          .any(fn)      → bool
+          .all(fn)      → bool
+          .reduce(fn,i) → any (can't infer accumulator type without annotation)
+          .join(sep)    → string
+          .push(v)      → void
+          .pop()        → elem?
+          .contains(v)  → bool
+          .index_of(v)  → int?
+
+        String methods:
+          .split(sep)   → Array<string>
+          .trim()       → string
+          .upper()      → string
+          .lower()      → string
+          .replace(...) → string
+          .starts_with()→ bool
+          .ends_with()  → bool
+          .contains()   → bool
+          .len()        → int
+          .chars()      → Array<string>
+        """
+        # ── Array method inference ────────────────────────────────────────────
+        if obj_type.name == "Array":
+            elem = obj_type.params[0] if obj_type.params else T_ANY
+
+            # Methods that return Array<same-elem>
+            if method in ("filter", "take", "skip", "slice", "sorted",
+                          "reversed", "unique", "shuffle", "concat"):
+                return array_type(elem)
+
+            # .map(fn) / .flatMap(fn) → infer fn return type
+            if method in ("map", "flatMap"):
+                fn_ret = self._infer_fn_arg_return(call_node, arg_index=0, param_type=elem)
+                inner  = fn_ret if fn_ret != T_ANY else T_ANY
+                if method == "flatMap" and inner.name == "Array":
+                    inner = inner.params[0] if inner.params else T_ANY
+                return array_type(inner)
+
+            # Scalar reductions
+            if method in ("len", "count", "index_of"):
+                return T_INT
+            if method == "sum":
+                return elem if elem in (T_INT, T_FLOAT) else T_INT
+            if method in ("any", "all", "contains", "is_empty"):
+                return T_BOOL
+            if method == "join":
+                return T_STRING
+            if method in ("push", "append", "extend", "clear", "insert",
+                          "remove", "remove_at"):
+                return T_VOID
+
+            # Optional-returning methods
+            if method in ("first", "last", "pop", "find", "get"):
+                return optional_type(elem)
+
+            # .reduce → T_ANY (accumulator type unknown without annotation)
+            if method == "reduce":
+                return T_ANY
+
+            # .each(fn) → void (side-effect traversal)
+            if method in ("each", "for_each"):
+                return T_VOID
+
+        # ── String method inference ───────────────────────────────────────────
+        if obj_type == T_STRING:
+            if method in ("trim", "upper", "lower", "replace", "strip",
+                          "lstrip", "rstrip", "pad_left", "pad_right",
+                          "repeat", "reverse", "slice"):
+                return T_STRING
+            if method in ("len", "count", "index_of", "find"):
+                return T_INT
+            if method in ("starts_with", "ends_with", "contains", "is_empty",
+                          "matches"):
+                return T_BOOL
+            if method == "split":
+                return array_type(T_STRING)
+            if method == "chars":
+                return array_type(T_STRING)
+            if method == "to_int":
+                return optional_type(T_INT)
+            if method == "to_float":
+                return optional_type(T_FLOAT)
+
+        # ── Int / Float methods ───────────────────────────────────────────────
+        if obj_type in (T_INT, T_FLOAT):
+            if method in ("abs", "floor", "ceil", "round", "sqrt",
+                          "clamp", "min", "max"):
+                return obj_type
+            if method == "to_string":
+                return T_STRING
+
+        # ── Struct method return type ─────────────────────────────────────────
+        if obj_type.name in self._struct_defs:
+            struct = self._struct_defs[obj_type.name]
+            for m in (struct.methods or []):
+                if m.name == method:
+                    return self._resolve_type_ann(m.return_type)
+
+        return T_ANY
+
+    def _infer_fn_return_type(self, node) -> InScriptType:
+        """
+        v1.8.4: Infer a function's return type from its body when no annotation exists.
+        Only infers when ALL return paths agree on the same concrete type.
+        Falls back to T_ANY if ambiguous.
+        NOTE: errors are suppressed — inference is best-effort, never raises.
+        """
+        from ast_nodes import ReturnStmt, BlockStmt
+
+        if not node.body:
+            return T_VOID
+
+        # Stash and suppress the real error list — inference must never pollute it
+        saved_errors = self._errors
+        self._errors  = []
+
+        try:
+            # Push a temporary scope with params typed per their annotations
+            self._push_scope("infer-fn")
+            for p in (node.params or []):
+                p_type = self._resolve_type_ann(getattr(p, 'type_ann', None))
+                pname  = getattr(p, 'name', None)
+                if pname:
+                    self._scope.symbols[pname] = Symbol(
+                        pname, p_type, kind="var",
+                        line=getattr(p, 'line', 0), col=getattr(p, 'col', 0)
+                    )
+                    self._scope.symbols[pname].used = True
+
+            # Collect return types from first-level stmts + if/else branches
+            types_seen = set()
+            stmts = node.body.body if isinstance(node.body, BlockStmt) else [node.body]
+            for stmt in stmts:
+                if isinstance(stmt, ReturnStmt) and stmt.value is not None:
+                    try:
+                        t = self.visit(stmt.value)
+                        if is_literal_type(t): t = T_STRING
+                        types_seen.add(t)
+                    except Exception:
+                        types_seen.add(T_ANY)
+                for branch_attr in ('then_branch', 'else_branch'):
+                    branch = getattr(stmt, branch_attr, None)
+                    if branch is None:
+                        continue
+                    inner = getattr(branch, 'body', [branch])
+                    if not isinstance(inner, list):
+                        inner = [inner]
+                    for s in inner:
+                        if isinstance(s, ReturnStmt) and s.value is not None:
+                            try:
+                                t = self.visit(s.value)
+                                if is_literal_type(t): t = T_STRING
+                                types_seen.add(t)
+                            except Exception:
+                                types_seen.add(T_ANY)
+
+            self._pop_scope()
+
+            if not types_seen:
+                return T_VOID
+            non_any = {t for t in types_seen if t != T_ANY}
+            if len(non_any) == 1:
+                return next(iter(non_any))
+            if non_any == {T_INT, T_FLOAT}:
+                return T_FLOAT
             return T_ANY
 
+        except Exception:
+            return T_ANY
+        finally:
+            # Always restore the real error list
+            self._errors = saved_errors
+
+    def _infer_fn_arg_return(self, call_node, arg_index: int,
+                              param_type: InScriptType) -> InScriptType:
+        """
+        v1.8.4: Given a CallExpr and an argument position that expects a fn,
+        try to infer that fn's return type by visiting its body with a temporary
+        scope that binds the param to param_type.
+        Returns T_ANY if inference fails.
+        """
+        from ast_nodes import FunctionDecl, LambdaExpr
+        if arg_index >= len(call_node.args):
+            return T_ANY
+        fn_arg = call_node.args[arg_index].value
+
+        # Handle both lambda `fn(x) { return x * 2 }` and named refs
+        params = None; body = None
+        if isinstance(fn_arg, FunctionDecl) or isinstance(fn_arg, LambdaExpr):
+            params = getattr(fn_arg, 'params', [])
+            body   = getattr(fn_arg, 'body', None)
+        else:
+            return T_ANY
+
+        # Stash and suppress the real error list
+        saved_errors  = self._errors
+        self._errors   = []
+
+        try:
+            # Push a temporary scope, bind first param to elem type
+            self._push_scope("infer")
+            if params:
+                p0 = params[0]
+                p_name = getattr(p0, 'name', None)
+                if p_name:
+                    self._scope.symbols[p_name] = Symbol(
+                        p_name, param_type, kind="var",
+                        line=getattr(p0, 'line', 0), col=getattr(p0, 'col', 0)
+                    )
+                    self._scope.symbols[p_name].used = True
+
+            inferred = T_ANY
+            if body is not None:
+                inferred = self._infer_block_return_type(body)
+
+            self._pop_scope()
+            return inferred
+        except Exception:
+            return T_ANY
+        finally:
+            self._errors = saved_errors
+
+    def _infer_block_return_type(self, block) -> InScriptType:
+        """
+        v1.8.4: Walk a block/expression to find the first return statement's type.
+        Also handles single-expression lambdas.
+        """
+        from ast_nodes import BlockStmt, ReturnStmt
+        stmts = []
+        if isinstance(block, BlockStmt):
+            stmts = block.body
+        elif hasattr(block, '__iter__'):
+            stmts = list(block)
+        else:
+            # Single expression (arrow lambda)
+            try:
+                return self.visit(block)
+            except Exception:
+                return T_ANY
+
+        for stmt in stmts:
+            if isinstance(stmt, ReturnStmt) and stmt.value is not None:
+                try:
+                    return self.visit(stmt.value)
+                except Exception:
+                    return T_ANY
+            # Recurse into if/while bodies for early returns
+            if hasattr(stmt, 'then_branch'):
+                t = self._infer_block_return_type(stmt.then_branch)
+                if t != T_ANY:
+                    return t
         return T_ANY
 
     def visit_NamespaceAccessExpr(self, node: NamespaceAccessExpr) -> InScriptType:

{inscript_lang-1.8.2 → inscript_lang-1.8.4}/inscript.py

@@ -24,7 +24,7 @@ from errors   import (InScriptError, LexerError, ParseError,
                        SemanticError, InScriptRuntimeError,
                        MultiError, InScriptWarning)
 
-VERSION = "1.8.2"
+VERSION = "1.8.4"
 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.8.2 → inscript_lang-1.8.4}/inscript_lang.egg-info/PKG-INFO

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

{inscript_lang-1.8.2 → inscript_lang-1.8.4}/pyproject.toml

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

{inscript_lang-1.8.2 → inscript_lang-1.8.4}/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.8.2"
+VERSION = "1.8.4"
 
 # ── ANSI colours ──────────────────────────────────────────────────────────────
 def _c(code, text):