inscript-lang 1.8.1__tar.gz → 1.8.3__tar.gz

{inscript_lang-1.8.1 → inscript_lang-1.8.3}/PKG-INFO

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

{inscript_lang-1.8.1 → inscript_lang-1.8.3}/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,
@@ -112,6 +115,20 @@ def union_members(t: InScriptType) -> list:
     """v1.8.1: Return list of member types (works on non-unions too)."""
     return t.params if t.name == "Union" else [t]
 
+def literal_type(value: str) -> InScriptType:
+    """v1.8.2: A string-literal type like `"left"` or `"right"`."""
+    return InScriptType("__literal__", [value])   # params[0] is the string value
+
+def fn_type(param_types: list, return_type: InScriptType) -> InScriptType:
+    """v1.8.2: A function type `fn(int,string)->bool`."""
+    return InScriptType("__fn__", param_types + [return_type])
+
+def is_literal_type(t: InScriptType) -> bool:
+    return t.name == "__literal__"
+
+def literal_value(t: InScriptType) -> str:
+    return t.params[0] if t.params else ""
+
 def is_numeric(t: InScriptType) -> bool:
     return t in (T_INT, T_FLOAT)
 
@@ -127,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
@@ -140,6 +159,25 @@ def types_compatible(expected: InScriptType, got: InScriptType) -> bool:
     # v1.8.1: if got is a Union, every member must be compatible with expected
     if got.name == "Union":
         return all(types_compatible(expected, m) for m in got.params)
+    # v1.8.2: string literal type — `"left"` is compatible with string
+    if is_literal_type(expected):
+        # Expected a specific literal: got must be the same literal
+        if is_literal_type(got):
+            return literal_value(expected) == literal_value(got)
+        # A plain string variable can fill a literal slot (runtime check)
+        return got == T_STRING
+    if is_literal_type(got):
+        # A literal can always fill a plain string slot
+        if expected == T_STRING: return True
+        # A literal can fill a Union<string, ...> slot
+        if expected.name == "Union":
+            return any(types_compatible(m, got) for m in expected.params)
+        return False
+    # v1.8.2: fn types — compatible if same signature, or got is T_ANY/Function (lambda)
+    if expected.name == "__fn__":
+        if got == T_ANY: return True
+        if got.name in ("Function", "__fn__"): return True
+        return False
     # Array<X> compatible with Array<any> and vice versa
     if expected.name == "Array" and got.name == "Array": return True
     # Dict<K,V> compatible with Dict<any,any>
@@ -233,6 +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
+        self._interfaces:   Dict[str, dict] = {}             # v1.8.3: name → {method: (params, ret)}
 
         # Pre-register built-in global functions
         self._register_builtins()
@@ -325,21 +365,33 @@ class Analyzer(Visitor):
             v = self._resolve_type_ann(ann.generics[0]) if ann.generics else T_ANY
             return dict_type(k, v)
 
-        # v1.8.1: `T?` — nullable shorthand, parsed as TypeAnnotation(name="Optional",
-        # is_nullable=True, generics=[T])
+        # v1.8.1: `T?` — nullable shorthand
         if ann.is_nullable or ann.name == "Optional":
             inner = self._resolve_type_ann(ann.generics[0]) if ann.generics else T_ANY
             return optional_type(inner)
 
-        # v1.8.1: `A | B | C` — union type, parsed as TypeAnnotation(name="Union",
-        # generics=[A, B, C])
+        # v1.8.1: `A | B | C` — union type
         if ann.name == "Union":
             members = [self._resolve_type_ann(g) for g in ann.generics]
             return union_type(*members)
 
+        # v1.8.2: string literal type — `"left"`
+        if ann.name == "__literal__":
+            return literal_type(ann.literal_value or "")
+
+        # v1.8.2: fn type — `fn(int) -> bool`
+        if ann.name == "__fn__":
+            params = [self._resolve_type_ann(p) for p in (ann.fn_params or [])]
+            ret    = self._resolve_type_ann(ann.fn_return) if ann.fn_return else T_ANY
+            return fn_type(params, ret)
+
         if ann.name in BUILTIN_TYPES:
             return BUILTIN_TYPES[ann.name]
 
+        # v1.8.2: registered type aliases
+        if ann.name in self._type_aliases:
+            return self._type_aliases[ann.name]
+
         # Check user-defined structs
         if ann.name in self._struct_defs:
             return InScriptType(ann.name)
@@ -474,7 +526,9 @@ class Analyzer(Visitor):
         return self._scope.symbols
 
     def _hoist_top_level(self, program: Program):
-        """Register structs, scenes, and top-level functions before checking bodies."""
+        """Register structs, scenes, top-level functions, and type aliases before checking bodies."""
+        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
@@ -483,7 +537,33 @@ class Analyzer(Visitor):
                     kind="struct", struct_node=node,
                     line=node.line, col=node.col
                 )
-            elif isinstance(node, FunctionDecl):
+            elif isinstance(node, TypeAliasDecl):
+                type_ann = getattr(node, 'type_ann', None)
+                if type_ann is not None:
+                    resolved = self._resolve_type_ann(type_ann)
+                else:
+                    resolved = BUILTIN_TYPES.get(node.target, InScriptType(node.target))
+                self._type_aliases[node.name] = resolved
+                self._scope.symbols[node.name] = Symbol(
+                    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):
                 ret  = self._resolve_type_ann(node.return_type)
                 self._scope.symbols[node.name] = Symbol(
                     node.name, ret, kind="fn", fn_node=node,
@@ -497,7 +577,7 @@ class Analyzer(Visitor):
             elif isinstance(node, EnumDecl):
                 self._scope.symbols[node.name] = Symbol(
                     node.name, InScriptType(node.name), kind="enum",
-                    fn_node=node,  # store EnumDecl for exhaustiveness checks
+                    fn_node=node,
                     line=node.line, col=node.col
                 )
 
@@ -575,12 +655,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")
@@ -651,6 +739,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
 
@@ -695,6 +803,34 @@ 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:
+            resolved = self._resolve_type_ann(node.type_ann)
+        else:
+            # Legacy alias with only a target string
+            resolved = BUILTIN_TYPES.get(node.target, InScriptType(node.target))
+        self._type_aliases[node.name] = resolved
+        # Also register in scope so the name is "used" and not flagged undefined
+        self._scope.symbols[node.name] = Symbol(node.name, resolved, kind="type",
+                                                 line=node.line, col=node.col)
+        return T_VOID
+
     def visit_ImportDecl(self, node: ImportDecl) -> InScriptType:
         """Register imported symbols so the type checker knows about them."""
         try:
@@ -890,47 +1026,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
             )
 
@@ -952,7 +1097,9 @@ class Analyzer(Visitor):
 
     def visit_IntLiteralExpr(self, node: IntLiteralExpr)   -> InScriptType: return T_INT
     def visit_FloatLiteralExpr(self, node: FloatLiteralExpr) -> InScriptType: return T_FLOAT
-    def visit_StringLiteralExpr(self, node: StringLiteralExpr) -> InScriptType: return T_STRING
+    def visit_StringLiteralExpr(self, node: StringLiteralExpr) -> InScriptType:
+        # v1.8.2: return a specific literal type so union-of-literals is enforced
+        return literal_type(node.value)
     def visit_BoolLiteralExpr(self, node: BoolLiteralExpr) -> InScriptType: return T_BOOL
     def visit_NullLiteralExpr(self, node: NullLiteralExpr) -> InScriptType: return T_NULL
 

{inscript_lang-1.8.1 → inscript_lang-1.8.3}/ast_nodes.py

@@ -49,6 +49,11 @@ class TypeAnnotation(Node):
     is_nullable: bool = False
     key_type:  Optional["TypeAnnotation"] = None
     nullable:  bool = False
+    # v1.8.2: for string literal types `"left"` in unions / params
+    literal_value: Optional[str] = None   # set when name == "__literal__"
+    # v1.8.2: for fn type aliases `fn(int) -> bool`
+    fn_params:     Optional[list] = None  # list of TypeAnnotation
+    fn_return:     Optional["TypeAnnotation"] = None
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -717,9 +722,10 @@ class DecoratedDecl(Node):
 
 @dataclass
 class TypeAliasDecl(Node):
-    """type ID = ExistingType — type alias (annotation only at runtime)."""
-    name:   str
-    target: str
+    """type ID = ExistingType | fn(...)->T | "lit1"|"lit2" — type alias."""
+    name:        str
+    target:      str          # kept for backwards compat with interpreter
+    type_ann:    object = None  # TypeAnnotation (None for legacy string-only aliases)
 
 @dataclass
 class SelectStmt(Node):

{inscript_lang-1.8.1 → inscript_lang-1.8.3}/inscript.py

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

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

{inscript_lang-1.8.1 → inscript_lang-1.8.3}/interpreter.py

@@ -937,9 +937,13 @@ class Interpreter(Visitor):
         return iface
 
     def visit_TypeAliasDecl(self, node) -> Any:
-        """type ID = ExistingType — store alias so type annotations can reference it."""
-        # Runtime effect: register the alias name so it can be used in is/as checks
-        self._env.define(node.name, {"__type_alias__": True, "__target__": node.target})
+        """v1.8.2: Register alias so it can be used in typeof/is checks at runtime."""
+        type_ann = getattr(node, 'type_ann', None)
+        self._env.define(node.name, {
+            "__type_alias__": True,
+            "__target__":     node.target,
+            "__type_ann__":   type_ann,
+        })
         return None
 
     def visit_ImplDecl(self, node) -> Any:

{inscript_lang-1.8.1 → inscript_lang-1.8.3}/parser.py

@@ -216,23 +216,17 @@ class Parser:
     # ─────────────────────────────────────────────
 
     def parse_type_alias(self):
-        """type ID = ExistingType — type alias declaration (annotation only)."""
+        """type ID = TypeAnnotation — supports simple, union, literal union, fn types."""
         line, col = self.current.line, self.current.col
         self.advance()  # consume 'type'
         name = self.expect(TT.IDENT, "Expected alias name after 'type'").value
         self.expect(TT.ASSIGN, "Expected '=' in type alias")
-        # Consume the type expression (could be int, string, ident, etc.)
-        target_tok = self.current
-        target_name = target_tok.value or target_tok.type.name
-        self.advance()
-        # Handle qualified names like MyModule.MyType
-        while self.check(TT.DOT):
-            self.advance()
-            target_name += "." + (self.current.value or "")
-            self.advance()
-        # Return a simple VarDecl so the interpreter stores name in env as a type tag
+        # v1.8.2: parse a full type annotation (including string literal unions, fn types)
+        type_ann = self.parse_type_annotation()
+        # target: for backwards compat with interpreter, derive a string name
+        target = type_ann.name if type_ann.name not in ("__literal__", "__fn__", "Union") else name
         from ast_nodes import TypeAliasDecl
-        return TypeAliasDecl(name=name, target=target_name, line=line, col=col)
+        return TypeAliasDecl(name=name, target=target, type_ann=type_ann, line=line, col=col)
 
     def parse_import(self) -> ImportDecl:
         """
@@ -447,6 +441,40 @@ class Parser:
             elif tok.type == TT.NIL:   # v1.7.2: nil as type annotation
                 name = "nil"
                 self.advance()
+            # v1.8.2: string literal type — `"left"` in union / param
+            elif tok.type == TT.STRING:
+                lit = tok.value
+                self.advance()
+                ann = TypeAnnotation(name="__literal__", literal_value=lit,
+                                     line=line, col=col)
+                # Union suffix handled below — return early for nullable/union
+                if self.current.type == TT.QUESTION:
+                    self.advance()
+                    ann = TypeAnnotation(name="Optional", is_nullable=True,
+                                        generics=[ann], line=line, col=col)
+                if self.current.type == TT.BIT_OR:
+                    union_types = [ann]
+                    while self.current.type == TT.BIT_OR:
+                        self.advance()
+                        union_types.append(self.parse_type_annotation())
+                    ann = TypeAnnotation(name="Union", generics=union_types, line=line, col=col)
+                return ann
+            # v1.8.2: fn type alias — `fn(int, string) -> bool`
+            elif tok.type == TT.FN:
+                self.advance()   # consume 'fn'
+                self.expect(TT.LPAREN, "Expected '(' in fn type")
+                fn_params = []
+                if not self.check(TT.RPAREN):
+                    fn_params.append(self.parse_type_annotation())
+                    while self.match(TT.COMMA):
+                        fn_params.append(self.parse_type_annotation())
+                self.expect(TT.RPAREN, "Expected ')' in fn type")
+                fn_return = None
+                if self.match(TT.ARROW):
+                    fn_return = self.parse_type_annotation()
+                ann = TypeAnnotation(name="__fn__", fn_params=fn_params,
+                                     fn_return=fn_return, line=line, col=col)
+                return ann
             else:
                 self._error(f"Expected type name, got '{tok.value}'")
             ann = TypeAnnotation(name=name, line=line, col=col)

{inscript_lang-1.8.1 → inscript_lang-1.8.3}/pyproject.toml

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