samlang 0.1.0__py3-none-any.whl

samlang/__init__.py

@@ -0,0 +1,6 @@
+"""
+SamLang - A modern, high-performance programming language.
+Created by Samrane Ahmed.
+"""
+
+__version__ = "0.1.0"

samlang/__main__.py

@@ -0,0 +1,8 @@
+"""
+Module entry point for `python -m samlang`.
+Author: Samrane Ahmed
+"""
+from samlang.cli import main
+
+if __name__ == "__main__":
+    main()

samlang/ast_nodes.py

@@ -0,0 +1,641 @@
+"""
+Abstract Syntax Tree (AST) Nodes for SamLang.
+Author: Samrane Ahmed
+"""
+
+from typing import List, Optional, Tuple
+from samlang.tokens import Token, Position
+
+
+class ASTNode:
+    """Base class for all Abstract Syntax Tree nodes in SamLang."""
+    def __init__(self, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        self.pos_start: Optional[Position] = pos_start
+        self.pos_end: Optional[Position] = pos_end
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}()"
+
+
+class NumberNode(ASTNode):
+    """Represents numeric literals (integers and floats)."""
+    def __init__(self, tok: Token):
+        super().__init__(tok.pos_start, tok.pos_end)
+        self.tok: Token = tok
+        self.value: float = tok.value
+
+    def __repr__(self) -> str:
+        return f"NumberNode({self.value})"
+
+
+class StringNode(ASTNode):
+    """Represents string literals."""
+    def __init__(self, tok: Token):
+        super().__init__(tok.pos_start, tok.pos_end)
+        self.tok: Token = tok
+        self.value: str = tok.value
+
+    def __repr__(self) -> str:
+        return f"StringNode({repr(self.value)})"
+
+
+class VarAccessNode(ASTNode):
+    """Represents reading a variable value."""
+    def __init__(self, var_name_tok: Token):
+        super().__init__(var_name_tok.pos_start, var_name_tok.pos_end)
+        self.var_name_tok: Token = var_name_tok
+        self.var_name: str = var_name_tok.value
+
+    def __repr__(self) -> str:
+        return f"VarAccessNode({self.var_name})"
+
+
+class VarAssignNode(ASTNode):
+    """Represents assigning a value to a variable (let x = expr or x = expr)."""
+    def __init__(self, var_name_tok: Token, value_node: ASTNode):
+        super().__init__(var_name_tok.pos_start, value_node.pos_end)
+        self.var_name_tok: Token = var_name_tok
+        self.var_name: str = var_name_tok.value
+        self.value_node: ASTNode = value_node
+
+    def __repr__(self) -> str:
+        return f"VarAssignNode({self.var_name} = {self.value_node})"
+
+
+class BinOpNode(ASTNode):
+    """Represents binary operations (e.g. left + right, left * right)."""
+    def __init__(self, left_node: ASTNode, op_tok: Token, right_node: ASTNode):
+        super().__init__(left_node.pos_start, right_node.pos_end)
+        self.left_node: ASTNode = left_node
+        self.op_tok: Token = op_tok
+        self.right_node: ASTNode = right_node
+
+    def __repr__(self) -> str:
+        return f"BinOpNode({self.left_node} {self.op_tok.type} {self.right_node})"
+
+
+class UnaryOpNode(ASTNode):
+    """Represents unary operations (e.g. -x, +x)."""
+    def __init__(self, op_tok: Token, node: ASTNode):
+        super().__init__(op_tok.pos_start, node.pos_end)
+        self.op_tok: Token = op_tok
+        self.node: ASTNode = node
+
+    def __repr__(self) -> str:
+        return f"UnaryOpNode({self.op_tok.type} {self.node})"
+
+
+class PrintNode(ASTNode):
+    """Represents the built-in print, println, and echo statements."""
+    def __init__(self, expr_nodes: List[ASTNode], newline: bool = True, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end)
+        self.expr_nodes: List[ASTNode] = expr_nodes
+        self.newline: bool = newline
+
+    def __repr__(self) -> str:
+        return f"PrintNode({self.expr_nodes}, newline={self.newline})"
+
+
+class BooleanNode(ASTNode):
+    """Represents boolean literals (true and false)."""
+    def __init__(self, tok: Token):
+        super().__init__(tok.pos_start, tok.pos_end)
+        self.tok: Token = tok
+        self.value: bool = bool(tok.value)
+
+    def __repr__(self) -> str:
+        return f"BooleanNode({self.value})"
+
+
+class NullNode(ASTNode):
+    """Represents the null / nil literal."""
+    def __init__(self, tok: Token):
+        super().__init__(tok.pos_start, tok.pos_end)
+        self.tok: Token = tok
+        self.value = None
+
+    def __repr__(self) -> str:
+        return "NullNode()"
+
+
+class BlockNode(ASTNode):
+    """Represents a scoped block of statements { ... }."""
+    def __init__(self, statements: List[ASTNode], pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end)
+        self.statements: List[ASTNode] = statements
+
+    def __repr__(self) -> str:
+        return f"BlockNode({len(self.statements)} stmts)"
+
+
+class FuncDefNode(ASTNode):
+    """Represents a function definition: func name(arg1, arg2) { body }."""
+    def __init__(self, func_name_tok: Token, arg_name_toks: List[Token], body_node: ASTNode):
+        super().__init__(func_name_tok.pos_start, body_node.pos_end)
+        self.func_name_tok: Token = func_name_tok
+        self.func_name: str = func_name_tok.value
+        self.arg_name_toks: List[Token] = arg_name_toks
+        self.arg_names: List[str] = [tok.value for tok in arg_name_toks]
+        self.body_node: ASTNode = body_node
+
+    def __repr__(self) -> str:
+        return f"FuncDefNode({self.func_name}({', '.join(self.arg_names)}))"
+
+
+class FuncCallNode(ASTNode):
+    """Represents a function call: func_name(expr1, expr2)."""
+    def __init__(self, call_node: ASTNode, arg_nodes: List[ASTNode], pos_end: Optional[Position] = None):
+        super().__init__(call_node.pos_start, pos_end or call_node.pos_end)
+        self.call_node: ASTNode = call_node
+        self.arg_nodes: List[ASTNode] = arg_nodes
+
+    def __repr__(self) -> str:
+        return f"FuncCallNode({self.call_node}({len(self.arg_nodes)} args))"
+
+
+class ReturnNode(ASTNode):
+    """Represents a return statement: return expr;."""
+    def __init__(self, value_node: Optional[ASTNode], pos_start: Position, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end or (value_node.pos_end if value_node else pos_start))
+        self.value_node: Optional[ASTNode] = value_node
+
+    def __repr__(self) -> str:
+        return f"ReturnNode({self.value_node})"
+
+
+class IfNode(ASTNode):
+    """Represents conditional branching: if cond { } elif cond { } else { }."""
+    def __init__(self, cases: List[Tuple[ASTNode, ASTNode]], else_case: Optional[ASTNode] = None, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end)
+        self.cases: List[Tuple[ASTNode, ASTNode]] = cases
+        self.else_case: Optional[ASTNode] = else_case
+
+    def __repr__(self) -> str:
+        return f"IfNode({len(self.cases)} cases, has_else={self.else_case is not None})"
+
+
+class WhileNode(ASTNode):
+    """Represents while loops: while cond { body }."""
+    def __init__(self, condition_node: ASTNode, body_node: ASTNode, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end or body_node.pos_end)
+        self.condition_node: ASTNode = condition_node
+        self.body_node: ASTNode = body_node
+
+    def __repr__(self) -> str:
+        return f"WhileNode({self.condition_node})"
+
+
+class ForNode(ASTNode):
+    """Represents a C-style for loop: for (init; cond; step) { body }."""
+    def __init__(self, init_node: Optional[ASTNode], cond_node: Optional[ASTNode], step_node: Optional[ASTNode], body_node: ASTNode, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end or body_node.pos_end)
+        self.init_node: Optional[ASTNode] = init_node
+        self.cond_node: Optional[ASTNode] = cond_node
+        self.step_node: Optional[ASTNode] = step_node
+        self.body_node: ASTNode = body_node
+
+    def __repr__(self) -> str:
+        return f"ForNode({self.init_node}; {self.cond_node}; {self.step_node})"
+
+
+class ForRangeNode(ASTNode):
+    """Represents a range-based for loop: for var in range(...) { body }."""
+    def __init__(self, var_name_tok: Token, start_node: ASTNode, stop_node: ASTNode, step_node: ASTNode, body_node: ASTNode, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end or body_node.pos_end)
+        self.var_name_tok: Token = var_name_tok
+        self.var_name: str = var_name_tok.value
+        self.start_node: ASTNode = start_node
+        self.stop_node: ASTNode = stop_node
+        self.step_node: ASTNode = step_node
+        self.body_node: ASTNode = body_node
+
+    def __repr__(self) -> str:
+        return f"ForRangeNode({self.var_name} in range({self.start_node}, {self.stop_node}, {self.step_node}))"
+
+
+class DoWhileNode(ASTNode):
+    """Represents a do-while loop: do { body } while (cond);."""
+    def __init__(self, body_node: ASTNode, condition_node: ASTNode, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end or condition_node.pos_end)
+        self.body_node: ASTNode = body_node
+        self.condition_node: ASTNode = condition_node
+
+    def __repr__(self) -> str:
+        return f"DoWhileNode(while {self.condition_node})"
+
+
+class ConstAssignNode(ASTNode):
+    """Represents constant definition: const NAME = expr;."""
+    def __init__(self, var_name_tok: Token, value_node: ASTNode):
+        super().__init__(var_name_tok.pos_start, value_node.pos_end)
+        self.var_name_tok: Token = var_name_tok
+        self.var_name: str = var_name_tok.value
+        self.value_node: ASTNode = value_node
+
+    def __repr__(self) -> str:
+        return f"ConstAssignNode(const {self.var_name} = {self.value_node})"
+
+
+class IncDecNode(ASTNode):
+    """Represents increment or decrement: x++, x--, ++x, --x."""
+    def __init__(self, var_name_tok: Token, op_tok: Token, is_prefix: bool = False):
+        pos_start = op_tok.pos_start if is_prefix else var_name_tok.pos_start
+        pos_end = var_name_tok.pos_end if is_prefix else op_tok.pos_end
+        super().__init__(pos_start, pos_end)
+        self.var_name_tok: Token = var_name_tok
+        self.var_name: str = var_name_tok.value
+        self.op_tok: Token = op_tok
+        self.is_prefix: bool = is_prefix
+
+    def __repr__(self) -> str:
+        prefix = "prefix" if self.is_prefix else "postfix"
+        return f"IncDecNode({prefix} {self.var_name}{self.op_tok.type})"
+
+
+class CompoundAssignNode(ASTNode):
+    """Represents compound assignment: x += 5, x -= 2, x *= 3, etc."""
+    def __init__(self, var_name_tok: Token, op_tok: Token, value_node: ASTNode):
+        super().__init__(var_name_tok.pos_start, value_node.pos_end)
+        self.var_name_tok: Token = var_name_tok
+        self.var_name: str = var_name_tok.value
+        self.op_tok: Token = op_tok
+        self.value_node: ASTNode = value_node
+
+    def __repr__(self) -> str:
+        return f"CompoundAssignNode({self.var_name} {self.op_tok.type} {self.value_node})"
+
+
+class RepeatNode(ASTNode):
+    """Represents a repeat loop: repeat count { body }."""
+    def __init__(self, count_node: ASTNode, body_node: ASTNode, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end or body_node.pos_end)
+        self.count_node: ASTNode = count_node
+        self.body_node: ASTNode = body_node
+
+    def __repr__(self) -> str:
+        return f"RepeatNode({self.count_node})"
+
+
+class ListNode(ASTNode):
+    """Represents a list literal: [elem1, elem2, ...]."""
+    def __init__(self, element_nodes: List[ASTNode], pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end)
+        self.element_nodes: List[ASTNode] = element_nodes
+
+    def __repr__(self) -> str:
+        return f"ListNode({self.element_nodes})"
+
+
+class IndexAccessNode(ASTNode):
+    """Represents indexing into a collection: target[index]."""
+    def __init__(self, target_node: ASTNode, index_node: ASTNode, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start or target_node.pos_start, pos_end or index_node.pos_end)
+        self.target_node: ASTNode = target_node
+        self.index_node: ASTNode = index_node
+
+    def __repr__(self) -> str:
+        return f"IndexAccessNode({self.target_node}[{self.index_node}])"
+
+
+class IndexAssignNode(ASTNode):
+    """Represents assigning to an index: target[index] = val or target[index] += val."""
+    def __init__(self, target_node: ASTNode, index_node: ASTNode, op_tok: Token, value_node: ASTNode, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start or target_node.pos_start, pos_end or value_node.pos_end)
+        self.target_node: ASTNode = target_node
+        self.index_node: ASTNode = index_node
+        self.op_tok: Token = op_tok
+        self.value_node: ASTNode = value_node
+
+    def __repr__(self) -> str:
+        return f"IndexAssignNode({self.target_node}[{self.index_node}] {self.op_tok.type} {self.value_node})"
+
+
+class ForInNode(ASTNode):
+    """Represents for-in collection loop: for item in list { } or for i, item in list { }."""
+    def __init__(self, item_var_tok: Token, index_var_tok: Optional[Token], iterable_node: ASTNode, body_node: ASTNode, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end or body_node.pos_end)
+        self.item_var_tok: Token = item_var_tok
+        self.item_var: str = item_var_tok.value
+        self.index_var_tok: Optional[Token] = index_var_tok
+        self.index_var: Optional[str] = index_var_tok.value if index_var_tok else None
+        self.iterable_node: ASTNode = iterable_node
+        self.body_node: ASTNode = body_node
+
+    def __repr__(self) -> str:
+        idx_str = f"{self.index_var}, " if self.index_var else ""
+        return f"ForInNode({idx_str}{self.item_var} in {self.iterable_node})"
+
+
+class TernaryNode(ASTNode):
+    """Represents ternary conditional operator: cond ? true_expr : false_expr."""
+    def __init__(self, condition_node: ASTNode, true_node: ASTNode, false_node: ASTNode, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start or condition_node.pos_start, pos_end or false_node.pos_end)
+        self.condition_node: ASTNode = condition_node
+        self.true_node: ASTNode = true_node
+        self.false_node: ASTNode = false_node
+
+    def __repr__(self) -> str:
+        return f"TernaryNode({self.condition_node} ? {self.true_node} : {self.false_node})"
+
+
+class DictNode(ASTNode):
+    """Represents a dictionary / hashmap literal: { key: value, ... }."""
+    def __init__(self, key_value_pairs: List[Tuple[ASTNode, ASTNode]], pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end)
+        self.key_value_pairs: List[Tuple[ASTNode, ASTNode]] = key_value_pairs
+
+    def __repr__(self) -> str:
+        return f"DictNode({len(self.key_value_pairs)} pairs)"
+
+
+class StatementsNode(ASTNode):
+    """Represents a list of sequential statements in a script."""
+    def __init__(self, statements: List[ASTNode], pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end)
+        self.statements: List[ASTNode] = statements
+
+    def __repr__(self) -> str:
+        return f"StatementsNode({len(self.statements)} stmts)"
+
+
+class ImportNode(ASTNode):
+    """
+    Represents an import statement:
+      - import "path/file.sl" [as alias]
+      - import module_name [as alias]
+      - import { item1, item2 as alias2 } from "path/file.sl"
+      - import item1, item2 from "path/file.sl"
+      - import * from "path/file.sl"
+      - from "path/file.sl" import item1, item2
+      - from "path/file.sl" import *
+    """
+    def __init__(
+        self,
+        module_path: str,
+        alias: Optional[str] = None,
+        items: Optional[List[Tuple[str, Optional[str]]]] = None,
+        is_wildcard: bool = False,
+        pos_start: Optional[Position] = None,
+        pos_end: Optional[Position] = None
+    ):
+        super().__init__(pos_start, pos_end)
+        self.module_path: str = module_path
+        self.alias: Optional[str] = alias
+        self.items: Optional[List[Tuple[str, Optional[str]]]] = items
+        self.is_wildcard: bool = is_wildcard
+
+    def __repr__(self) -> str:
+        if self.is_wildcard:
+            return f"ImportNode(* from {self.module_path})"
+        if self.items:
+            items_str = ", ".join(f"{orig} as {al}" if al else orig for orig, al in self.items)
+            return f"ImportNode({{{items_str}}} from {self.module_path})"
+        if self.alias:
+            return f"ImportNode({self.module_path} as {self.alias})"
+        return f"ImportNode({self.module_path})"
+
+
+class ExportNode(ASTNode):
+    """Represents an export statement: export func foo() ... or export const X = 1;"""
+    def __init__(self, statement_node: ASTNode, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start or statement_node.pos_start, pos_end or statement_node.pos_end)
+        self.statement_node: ASTNode = statement_node
+
+    def __repr__(self) -> str:
+        return f"ExportNode({self.statement_node})"
+
+
+class BreakNode(ASTNode):
+    """Represents a break statement inside loops."""
+    def __init__(self, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end)
+
+    def __repr__(self) -> str:
+        return "BreakNode()"
+
+
+class ContinueNode(ASTNode):
+    """Represents a continue statement inside loops."""
+    def __init__(self, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end)
+
+    def __repr__(self) -> str:
+        return "ContinueNode()"
+
+
+class TryCatchNode(ASTNode):
+    """Represents try-catch error handling: try { ... } catch (err) { ... } [finally { ... }]"""
+    def __init__(
+        self,
+        try_body: ASTNode,
+        catch_var_tok: Optional[Token],
+        catch_body: ASTNode,
+        finally_body: Optional[ASTNode] = None,
+        pos_start: Optional[Position] = None,
+        pos_end: Optional[Position] = None
+    ):
+        super().__init__(pos_start, pos_end)
+        self.try_body: ASTNode = try_body
+        self.catch_var: Optional[str] = catch_var_tok.value if catch_var_tok else None
+        self.catch_body: ASTNode = catch_body
+        self.finally_body: Optional[ASTNode] = finally_body
+
+    def __repr__(self) -> str:
+        var_str = f"({self.catch_var})" if self.catch_var else ""
+        return f"TryCatchNode(try {self.try_body} catch{var_str} {self.catch_body})"
+
+
+class LambdaNode(ASTNode):
+    """Represents an anonymous / arrow function: (x, y) => expr or (x) => { ... }."""
+    def __init__(self, arg_names: List[str], body_node: ASTNode, pos_start: Optional[Position] = None, pos_end: Optional[Position] = None):
+        super().__init__(pos_start, pos_end)
+        self.arg_names: List[str] = arg_names
+        self.body_node: ASTNode = body_node
+
+    def __repr__(self) -> str:
+        return f"LambdaNode(({', '.join(self.arg_names)}) => {self.body_node})"
+
+
+class PropertyDefNode(ASTNode):
+    """Represents a property: let Name { get; set; } [= default]."""
+    def __init__(
+        self,
+        name_tok: Token,
+        has_get: bool = True,
+        has_set: bool = True,
+        default_node: Optional[ASTNode] = None,
+        pos_start: Optional[Position] = None,
+        pos_end: Optional[Position] = None
+    ):
+        super().__init__(pos_start or name_tok.pos_start, pos_end or (default_node.pos_end if default_node else name_tok.pos_end))
+        self.name_tok: Token = name_tok
+        self.name: str = name_tok.value
+        self.has_get: bool = has_get
+        self.has_set: bool = has_set
+        self.default_node: Optional[ASTNode] = default_node
+
+    def __repr__(self) -> str:
+        gs = f"{{ {'get; ' if self.has_get else ''}{'set; ' if self.has_set else ''}}}"
+        return f"PropertyDefNode({self.name} {gs})"
+
+
+class MethodDefNode(ASTNode):
+    """Represents a class method or constructor with virtual/override/static modifiers."""
+    def __init__(
+        self,
+        name_tok: Token,
+        arg_name_toks: List[Token],
+        body_node: ASTNode,
+        is_virtual: bool = False,
+        is_override: bool = False,
+        is_static: bool = False,
+        pos_start: Optional[Position] = None,
+        pos_end: Optional[Position] = None
+    ):
+        super().__init__(pos_start or name_tok.pos_start, pos_end or body_node.pos_end)
+        self.name_tok: Token = name_tok
+        self.name: str = name_tok.value
+        self.arg_name_toks: List[Token] = arg_name_toks
+        self.body_node: ASTNode = body_node
+        self.is_virtual: bool = is_virtual
+        self.is_override: bool = is_override
+        self.is_static: bool = is_static
+
+    def __repr__(self) -> str:
+        mods = []
+        if self.is_virtual: mods.append("virtuel")
+        if self.is_override: mods.append("override")
+        if self.is_static: mods.append("static")
+        mod_str = (" " + " ".join(mods)) if mods else ""
+        return f"MethodDefNode(func{mod_str} {self.name}(...))"
+
+
+class ClassDefNode(ASTNode):
+    """Represents a class definition: class Name [: Parent] { ... }."""
+    def __init__(
+        self,
+        name_tok: Token,
+        parent_tok: Optional[Token],
+        properties: List[PropertyDefNode],
+        methods: List[MethodDefNode],
+        constructor: Optional[MethodDefNode] = None,
+        pos_start: Optional[Position] = None,
+        pos_end: Optional[Position] = None
+    ):
+        super().__init__(pos_start or name_tok.pos_start, pos_end or name_tok.pos_end)
+        self.name_tok: Token = name_tok
+        self.name: str = name_tok.value
+        self.parent_tok: Optional[Token] = parent_tok
+        self.parent_name: Optional[str] = parent_tok.value if parent_tok else None
+        self.properties: List[PropertyDefNode] = properties
+        self.methods: List[MethodDefNode] = methods
+        self.constructor: Optional[MethodDefNode] = constructor
+
+    def __repr__(self) -> str:
+        parent_str = f" : {self.parent_name}" if self.parent_name else ""
+        return f"ClassDefNode({self.name}{parent_str})"
+
+
+class NewNode(ASTNode):
+    """Represents object instantiation: new ClassName(args)."""
+    def __init__(
+        self,
+        class_node: ASTNode,
+        arg_nodes: List[ASTNode],
+        pos_start: Optional[Position] = None,
+        pos_end: Optional[Position] = None
+    ):
+        super().__init__(pos_start or class_node.pos_start, pos_end or class_node.pos_end)
+        self.class_node: ASTNode = class_node
+        self.arg_nodes: List[ASTNode] = arg_nodes
+
+    def __repr__(self) -> str:
+        return f"NewNode(new {self.class_node}({len(self.arg_nodes)} args))"
+
+
+class BaseCallNode(ASTNode):
+    """Represents calling parent constructor: base(args)."""
+    def __init__(
+        self,
+        arg_nodes: List[ASTNode],
+        pos_start: Optional[Position] = None,
+        pos_end: Optional[Position] = None
+    ):
+        super().__init__(pos_start, pos_end)
+        self.arg_nodes: List[ASTNode] = arg_nodes
+
+    def __repr__(self) -> str:
+        return f"BaseCallNode(base({len(self.arg_nodes)} args))"
+
+
+class BaseAccessNode(ASTNode):
+    """Represents accessing parent member: base.member."""
+    def __init__(
+        self,
+        member_tok: Token,
+        pos_start: Optional[Position] = None,
+        pos_end: Optional[Position] = None
+    ):
+        super().__init__(pos_start, pos_end or member_tok.pos_end)
+        self.member_tok: Token = member_tok
+        self.member_name: str = member_tok.value
+
+    def __repr__(self) -> str:
+        return f"BaseAccessNode(base.{self.member_name})"
+
+
+class ThisNode(ASTNode):
+    """Represents 'this' or 'self' reference to current instance."""
+    def __init__(self, tok: Token):
+        super().__init__(tok.pos_start, tok.pos_end)
+        self.tok: Token = tok
+        self.name: str = tok.value
+
+    def __repr__(self) -> str:
+        return f"ThisNode({self.name})"
+
+
+class TypedVarAssignNode(ASTNode):
+    """Represents explicit typed variable declaration: Person s = new Student()."""
+    def __init__(
+        self,
+        type_tok: Token,
+        var_name_tok: Token,
+        value_node: ASTNode,
+        pos_start: Optional[Position] = None,
+        pos_end: Optional[Position] = None
+    ):
+        super().__init__(pos_start or type_tok.pos_start, pos_end or value_node.pos_end)
+        self.type_tok: Token = type_tok
+        self.type_name: str = type_tok.value
+        self.var_name_tok: Token = var_name_tok
+        self.var_name: str = var_name_tok.value
+        self.value_node: ASTNode = value_node
+
+    def __repr__(self) -> str:
+        return f"TypedVarAssignNode({self.type_name} {self.var_name} = {self.value_node})"
+
+
+class MemberAssignNode(ASTNode):
+    """Represents assignment to an object property: obj.prop = value."""
+    def __init__(
+        self,
+        target_node: ASTNode,
+        member_tok: Token,
+        value_node: ASTNode,
+        pos_start: Optional[Position] = None,
+        pos_end: Optional[Position] = None
+    ):
+        super().__init__(pos_start or target_node.pos_start, pos_end or value_node.pos_end)
+        self.target_node: ASTNode = target_node
+        self.member_tok: Token = member_tok
+        self.member_name: str = member_tok.value
+        self.value_node: ASTNode = value_node
+
+    def __repr__(self) -> str:
+        return f"MemberAssignNode({self.target_node}.{self.member_name} = {self.value_node})"
+
+
+
+
+