cpyte 4.2.7__tar.gz → 4.3.0__tar.gz

{cpyte-4.2.7/source/cpyte.egg-info → cpyte-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cpyte
-Version: 4.2.7
+Version: 4.3.0
 Summary: The Cpyte programming language compiler
 Author: Hoang Duy Tung
 License: MIT

{cpyte-4.2.7 → cpyte-4.3.0}/source/cpyte/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "4.2.7"
+__version__ = "4.3.0"
 
 # ---------------------------------------------------------------------------
 # Public library API.

{cpyte-4.2.7 → cpyte-4.3.0}/source/cpyte/astparse.py

@@ -187,7 +187,14 @@ class Index(Node):
 
 class Attr(Node):
     inferred_type: str | None
-    __slots__ = ("_enum_member_value", "_token", "inferred_type", "name", "obj")
+    __slots__ = (
+        "_enum_member_value",
+        "_token",
+        "inferred_type",
+        "meta",
+        "name",
+        "obj",
+    )
 
     def __init__(self, obj, name: str, token=None):
         self.obj = obj
@@ -195,6 +202,7 @@ class Attr(Node):
         self._token = token
         self._enum_member_value = None
         self.inferred_type = None
+        self.meta = None
 
     def __repr__(self):
         return f"Attr({self.obj}, {self.name})"
@@ -828,13 +836,27 @@ def _parse_call_args(tokens: list[Token], pos: int, callee):
 
 
 def _parse_postfix(tokens: list[Token], pos: int, node):
-    while pos < len(tokens) and tokens[pos].type in (
-        TokenType.LPAREN,
-        TokenType.LBRACKET,
-        TokenType.DOT,
+    while pos < len(tokens) and (
+        tokens[pos].type in (
+            TokenType.LPAREN,
+            TokenType.LBRACKET,
+            TokenType.DOT,
+        )
+        or (tokens[pos].type == TokenType.KEYWORD and tokens[pos].value == "as")
     ):
         tok = tokens[pos]
-        if tok.type == TokenType.LPAREN:
+        if tok.type == TokenType.KEYWORD and tok.value == "as":
+            pos += 1
+            if pos >= len(tokens) or tokens[pos].type != TokenType.IDENTIFIER:
+                raise ParseError(
+                    "Expected a class name after 'as'",
+                    tokens[pos] if pos < len(tokens) else None,
+                )
+            name = tokens[pos].value
+            assert name is not None
+            pos += 1
+            node = AsExpr(name, node, token=tok)
+        elif tok.type == TokenType.LPAREN:
             node, pos = _parse_call_args(tokens, pos, node)
         elif tok.type == TokenType.LBRACKET:
             pos += 1
@@ -1039,13 +1061,27 @@ def _parse_expr_iterative(tokens: list[Token], pos: int, min_prec: int):
         elif kind == "postfix":
             prefixes = frame[1]
             node = vals.pop()
-            while pos < len(tokens) and tokens[pos].type in (
-                TokenType.LPAREN,
-                TokenType.LBRACKET,
-                TokenType.DOT,
+            while pos < len(tokens) and (
+                tokens[pos].type in (
+                    TokenType.LPAREN,
+                    TokenType.LBRACKET,
+                    TokenType.DOT,
+                )
+                or (tokens[pos].type == TokenType.KEYWORD and tokens[pos].value == "as")
             ):
                 ptok = tokens[pos]
-                if ptok.type == TokenType.LPAREN:
+                if ptok.type == TokenType.KEYWORD and ptok.value == "as":
+                    pos += 1
+                    if pos >= len(tokens) or tokens[pos].type != TokenType.IDENTIFIER:
+                        raise ParseError(
+                            "Expected a class name after 'as'",
+                            tokens[pos] if pos < len(tokens) else None,
+                        )
+                    name = tokens[pos].value
+                    assert name is not None
+                    pos += 1
+                    node = AsExpr(name, node, token=ptok)
+                elif ptok.type == TokenType.LPAREN:
                     pos += 1
                     frames.append(("call_done", prefixes))
                     frames.append(("callargs", node, [], ptok))
@@ -1210,14 +1246,10 @@ def _parse_standard_statement(tokens: list[Token], pos: int):
         node, pos = parse_decorated_def(tokens, pos)
     elif tok.type == TokenType.KEYWORD and tok.value == "sealed":
         # `sealed class X:` — a closed, monomorphic class (no vtable).
-        pos += 1
-        if pos >= len(tokens) or (
-            tokens[pos].type != TokenType.KEYWORD or tokens[pos].value != "class"
-        ):
-            raise ParseError(
-                'Expected "class" after "sealed"', tokens[pos] if pos < len(tokens) else None
-            )
-        node, pos = parse_class(tokens, pos, sealed=True)
+        node, pos = parse_sealed_class(tokens, pos)
+    elif tok.type == TokenType.KEYWORD and tok.value == "dataclass":
+        # `dataclass class X:` — auto-synthesized `__init__`/`__eq__`/`__str__`.
+        node, pos = parse_dataclass_class(tokens, pos)
     elif tok.type == TokenType.KEYWORD and tok.value == "class":
         node, pos = parse_class(tokens, pos)
     elif tok.type == TokenType.KEYWORD and tok.value == "struct":
@@ -1383,7 +1415,7 @@ def parse_decorated_def(tokens: list[Token], pos: int):
     return _parse_func_with_visibility(tokens, pos, visibility, tok)
 
 
-def parse_class(tokens: list[Token], pos: int, sealed: bool = False):
+def parse_class(tokens: list[Token], pos: int, sealed: bool = False, dataclass: bool = False):
     tok = tokens[pos]
     pos += 1
     if pos >= len(tokens) or tokens[pos].type != TokenType.IDENTIFIER:
@@ -1409,25 +1441,182 @@ def parse_class(tokens: list[Token], pos: int, sealed: bool = False):
                 tokens[pos] if pos < len(tokens) else None,
             )
         pos += 1
-    body, pos = parse_suite(tokens, pos)
+    body, pos = parse_class_suite(tokens, pos)
     fields = []
     methods = []
+    properties = []
     for stmt in body:
         if isinstance(stmt, FuncDef):
             methods.append(stmt)
         elif isinstance(stmt, VarDecl):
             fields.append(Field(stmt.name, stmt.var_type, token=stmt._token))
+        elif isinstance(stmt, PropertyDef):
+            properties.append(stmt)
     return ClassDef(
         name,
         base=base,
         fields=fields,
         methods=methods,
+        properties=properties,
         generic_params=generic_params,
         sealed=sealed,
+        dataclass=dataclass,
         token=tok,
     ), pos
 
 
+def parse_class_suite(tokens: list[Token], pos: int):
+    """Parse a class body suite, intercepting `property name:` blocks."""
+    if pos >= len(tokens) or tokens[pos].type != TokenType.COLON:
+        raise ParseError('Expected ":"', tokens[pos] if pos < len(tokens) else None)
+    pos += 1
+
+    if pos >= len(tokens) or tokens[pos].type != TokenType.NEWLINE:
+        raise ParseError(
+            'Expected newline after ":"', tokens[pos] if pos < len(tokens) else None
+        )
+    pos += 1
+
+    if pos >= len(tokens) or tokens[pos].type != TokenType.INDENT:
+        raise ParseError(
+            "Expected indented block", tokens[pos] if pos < len(tokens) else None
+        )
+    pos += 1
+
+    stmts = []
+    while pos < len(tokens) and tokens[pos].type not in (
+        TokenType.DEDENT,
+        TokenType.EOF,
+    ):
+        if (
+            tokens[pos].type == TokenType.IDENTIFIER
+            and tokens[pos].value == "property"
+        ):
+            pnode, pos = parse_property(tokens, pos)
+            stmts.append(pnode)
+            while pos < len(tokens) and tokens[pos].type == TokenType.NEWLINE:
+                pos += 1
+            continue
+        stmt, pos = parse_statement(tokens, pos)
+        if stmt is not None:
+            stmts.append(stmt)
+        while pos < len(tokens) and tokens[pos].type == TokenType.NEWLINE:
+            pos += 1
+    if pos < len(tokens) and tokens[pos].type == TokenType.DEDENT:
+        pos += 1
+    return stmts, pos
+
+
+def parse_sealed_class(tokens: list[Token], pos: int):
+    """Parse `sealed class X:` (or `sealed dataclass class X:`) — a closed,
+    monomorphic class (no vtable)."""
+    pos += 1
+    dataclass = False
+    if (
+        pos < len(tokens)
+        and tokens[pos].type == TokenType.KEYWORD
+        and tokens[pos].value == "dataclass"
+    ):
+        dataclass = True
+        pos += 1
+    if pos >= len(tokens) or (
+        tokens[pos].type != TokenType.KEYWORD or tokens[pos].value != "class"
+    ):
+        raise ParseError(
+            'Expected "class" after "sealed"',
+            tokens[pos] if pos < len(tokens) else None,
+        )
+    return parse_class(tokens, pos, sealed=True, dataclass=dataclass)
+
+
+def parse_dataclass_class(tokens: list[Token], pos: int):
+    """Parse `dataclass class X:` (or `sealed dataclass class X:`) — a class
+    that auto-synthesizes `__init__`/`__eq__`/`__str__` from its fields
+    (Python-style dataclass)."""
+    pos += 1
+    sealed = False
+    if (
+        pos < len(tokens)
+        and tokens[pos].type == TokenType.KEYWORD
+        and tokens[pos].value == "sealed"
+    ):
+        sealed = True
+        pos += 1
+    if pos >= len(tokens) or (
+        tokens[pos].type != TokenType.KEYWORD or tokens[pos].value != "class"
+    ):
+        raise ParseError(
+            'Expected "class" after "dataclass"',
+            tokens[pos] if pos < len(tokens) else None,
+        )
+    return parse_class(tokens, pos, sealed=sealed, dataclass=True)
+
+
+def parse_property(tokens: list[Token], pos: int):
+    """Parse a `property name:` block with `get`/`set` accessor bodies."""
+    tok = tokens[pos]
+    pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.IDENTIFIER:
+        raise ParseError(
+            "Expected property name after `property`",
+            tokens[pos] if pos < len(tokens) else None,
+        )
+    name = tokens[pos].value
+    assert name is not None
+    pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.COLON:
+        raise ParseError(
+            'Expected ":" after property name',
+            tokens[pos] if pos < len(tokens) else None,
+        )
+    pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.NEWLINE:
+        raise ParseError(
+            'Expected newline after ":"', tokens[pos] if pos < len(tokens) else None
+        )
+    pos += 1
+    if pos >= len(tokens) or tokens[pos].type != TokenType.INDENT:
+        raise ParseError(
+            "Expected indented block", tokens[pos] if pos < len(tokens) else None
+        )
+    pos += 1
+
+    get = None
+    setm = None
+    while pos < len(tokens) and tokens[pos].type not in (
+        TokenType.DEDENT,
+        TokenType.EOF,
+    ):
+        if (
+            tokens[pos].type == TokenType.IDENTIFIER
+            and tokens[pos].value in ("get", "set")
+            and pos + 1 < len(tokens)
+            and tokens[pos + 1].type == TokenType.COLON
+        ):
+            atok = tokens[pos]
+            aname = tokens[pos].value
+            abody, pos = parse_suite(tokens, pos + 1)
+            accessor = FuncDef(aname, {}, abody, "auto", token=atok)
+            if aname == "get":
+                get = accessor
+            else:
+                setm = accessor
+        else:
+            stmt, pos = parse_statement(tokens, pos)
+            if isinstance(stmt, FuncDef):
+                if stmt.name == "get":
+                    get = stmt
+                elif stmt.name == "set":
+                    setm = stmt
+        while pos < len(tokens) and tokens[pos].type == TokenType.NEWLINE:
+            pos += 1
+    if pos < len(tokens) and tokens[pos].type == TokenType.DEDENT:
+        pos += 1
+    if get is None:
+        raise ParseError("Expected a `get` accessor in property block", tok)
+    return PropertyDef(name, get, setm, token=tok), pos
+
+
 def parse_try(tokens: list[Token], pos: int):
     tok = tokens[pos]
     pos += 1
@@ -1706,6 +1895,7 @@ class FuncDef(Node):
         "const_params",
         "decorators",
         "generic_params",
+        "meta",
         "name",
         "params",
         "rettype",
@@ -1732,6 +1922,7 @@ class FuncDef(Node):
         self.generic_params = generic_params or []
         self.const_params = const_params or []
         self.decorators = decorators or []
+        self.meta = None
         self._token = token
 
     def __repr__(self):
@@ -1928,7 +2119,7 @@ class Raise(Node):
 
 
 class NewExpr(Node):
-    __slots__ = ("_token", "size", "type_expr", "args")
+    __slots__ = ("_token", "size", "type_expr", "args", "inferred_type")
 
     def __init__(self, type_expr, size=None, token=None, args=None):
         self.type_expr = type_expr
@@ -1993,6 +2184,27 @@ class CastExpr(Node):
         return f"CastExpr({self.type_expr}, {self.expr})"
 
 
+class AsExpr(Node):
+    """`expr as T` — safe runtime downcast (C#/Kotlin style).
+
+    `x as T` returns `x` re-typed as `T*` when the runtime class of `x` is a
+    descendant-or-equal of `T` (checked through the class-id RTTI ancestor
+    grid), and `null` otherwise. Unlike a parenthesized `(T)x` hard cast, an
+    `as` that fails yields null rather than silently re-typing the pointer.
+    """
+
+    __slots__ = ("_token", "inferred_type", "type_expr", "expr", "meta")
+
+    def __init__(self, type_expr: str, expr, token=None):
+        self.type_expr = type_expr
+        self.expr = expr
+        self._token = token
+        self.inferred_type = None
+
+    def __repr__(self):
+        return f"AsExpr({self.expr} as {self.type_expr})"
+
+
 class BorrowExpr(Node):
     """`borrow x` or `borrow mut x` — create a reference to x.
 
@@ -2123,10 +2335,12 @@ class ClassDef(Node):
     __slots__ = (
         "_token",
         "base",
+        "dataclass",
         "fields",
         "generic_params",
         "methods",
         "name",
+        "properties",
         "sealed",
     )
 
@@ -2138,6 +2352,8 @@ class ClassDef(Node):
         methods: list | None = None,
         generic_params: list | None = None,
         sealed: bool = False,
+        dataclass: bool = False,
+        properties: list | None = None,
         token=None,
     ):
         self.name = name
@@ -2146,11 +2362,30 @@ class ClassDef(Node):
         self.methods = methods or []
         self.generic_params = generic_params or []
         self.sealed = sealed
+        self.dataclass = dataclass
+        self.properties = properties or []
         self._token = token
 
     def __repr__(self):
         seal = "sealed " if self.sealed else ""
-        return f"ClassDef({seal}{self.name}, base={self.base}, fields={self.fields}, methods={self.methods})"
+        dc = "dataclass " if self.dataclass else ""
+        return f"ClassDef({seal}{dc}{self.name}, base={self.base}, fields={self.fields}, properties={self.properties}, methods={self.methods})"
+
+
+class PropertyDef(Node):
+    """A `property name:` block holding paired `get`/`set` accessor bodies."""
+
+    __slots__ = ("_token", "name", "get", "set", "_ptype")
+
+    def __init__(self, name: str, get, set=None, token=None):
+        self.name = name
+        self.get = get
+        self.set = set
+        self._ptype = None
+        self._token = token
+
+    def __repr__(self):
+        return f"PropertyDef({self.name}, get={self.get and self.get.name}, set={self.set and self.set.name})"
 
 
 def parse_ccode(tokens: list[Token], pos: int):
@@ -2649,6 +2884,8 @@ def parse_statement(tokens: list[Token], pos: int):
         "import",
         "enum",
         "type",
+        "sealed",
+        "dataclass",
     ):
         handler = {
             "while": parse_while,
@@ -2658,6 +2895,8 @@ def parse_statement(tokens: list[Token], pos: int):
             "import": parse_import,
             "enum": parse_enum,
             "type": parse_type_alias,
+            "sealed": parse_sealed_class,
+            "dataclass": parse_dataclass_class,
         }[tok.value]
         return handler(tokens, pos)