IncludeCPP 3.7.25__py3-none-any.whl → 3.8.8__py3-none-any.whl

includecpp/core/cssl/cssl_parser.py

@@ -114,7 +114,7 @@ class TokenType(Enum):
 
 KEYWORDS = {
     # Service structure
-    'service-init', 'service-run', 'service-include', 'struct', 'define', 'main', 'class', 'new', 'this',
+    'service-init', 'service-run', 'service-include', 'struct', 'define', 'main', 'class', 'constr', 'extends', 'overwrites', 'new', 'this', 'super',
     # Control flow
     'if', 'else', 'elif', 'while', 'for', 'foreach', 'in', 'range',
     'switch', 'case', 'default', 'break', 'continue', 'return',
@@ -716,7 +716,7 @@ class CSSLParser:
     def _is_type_keyword(self, value: str) -> bool:
         """Check if a keyword is a type declaration"""
         return value in ('int', 'string', 'float', 'bool', 'void', 'json', 'array', 'vector', 'stack',
-                        'list', 'dictionary', 'dict', 'instance', 'map',
+                        'list', 'dictionary', 'dict', 'instance', 'map', 'openquote', 'parameter',
                         'dynamic', 'datastruct', 'dataspace', 'shuffled', 'iterator', 'combo', 'structure')
 
     def _looks_like_function_declaration(self) -> bool:
@@ -727,14 +727,17 @@ class CSSLParser:
         - undefined int funcName(...)
         - vector<string> funcName(...)
         - undefined void funcName(...)
+        - private super virtual meta FuncName(...)  <- modifiers without return type
         """
         saved_pos = self.pos
+        has_modifiers = False
 
         # Skip modifiers (undefined, open, meta, super, closed, private, virtual)
         while self._check(TokenType.KEYWORD) and self._is_function_modifier(self._current().value):
             self._advance()
+            has_modifiers = True
 
-        # Check for type keyword
+        # Check for type keyword (optional if modifiers present)
         if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
             self._advance()
 
@@ -756,6 +759,14 @@ class CSSLParser:
                 self.pos = saved_pos
                 return is_func
 
+        # If we have modifiers and the next token is an identifier followed by (
+        # This handles: private super virtual meta FuncName()
+        elif has_modifiers and self._check(TokenType.IDENTIFIER):
+            self._advance()
+            is_func = self._check(TokenType.PAREN_START)
+            self.pos = saved_pos
+            return is_func
+
         self.pos = saved_pos
         return False
 
@@ -1014,7 +1025,11 @@ class CSSLParser:
         return result
 
     def _parse_typed_variable(self) -> Optional[ASTNode]:
-        """Parse a typed variable declaration: type varName; or type<T> varName = value;"""
+        """Parse a typed variable declaration: type varName; or type<T> *varName = value;
+
+        The * prefix indicates a non-nullable variable (can never be None/null).
+        Example: vector<dynamic> *MyVector - can never contain None values.
+        """
         # Get type name
         type_name = self._advance().value  # Consume type keyword
 
@@ -1028,6 +1043,11 @@ class CSSLParser:
                 element_type = self._advance().value
             self._expect(TokenType.COMPARE_GT)
 
+        # Check for * prefix (non-nullable indicator)
+        non_null = False
+        if self._match(TokenType.MULTIPLY):
+            non_null = True
+
         # Get variable name
         if not self._check(TokenType.IDENTIFIER):
             return None
@@ -1045,14 +1065,16 @@ class CSSLParser:
             return ASTNode('instance_declaration', value={
                 'instance_name': element_type,
                 'name': var_name,
-                'value': value
+                'value': value,
+                'non_null': non_null
             })
 
         return ASTNode('typed_declaration', value={
             'type': type_name,
             'element_type': element_type,
             'name': var_name,
-            'value': value
+            'value': value,
+            'non_null': non_null
         })
 
     def parse_program(self) -> ASTNode:
@@ -1350,10 +1372,79 @@ class CSSLParser:
                     printl("Hello " + this->name);
                 }
             }
+
+        Non-null class (all methods return non-null):
+            class *MyClass { ... }
         """
+        # Check for * prefix (non-null class - all methods return non-null)
+        non_null = False
+        if self._match(TokenType.MULTIPLY):
+            non_null = True
+
         class_name = self._advance().value
 
-        node = ASTNode('class', value={'name': class_name}, children=[])
+        # Check for class-level constructor parameters: class MyClass (int x, string y) { ... }
+        class_params = []
+        if self._match(TokenType.PAREN_START):
+            class_params = self._parse_parameter_list()
+            self._expect(TokenType.PAREN_END)
+
+        # Check for inheritance and overwrites:
+        # class Child : extends Parent { ... }
+        # class Child : extends $PythonObject { ... }
+        # class Child : extends Parent : overwrites Parent { ... }
+        # class Child : extends Parent (param1, param2) { ... }  <- constructor args for parent
+        extends_class = None
+        extends_is_python = False
+        extends_args = []
+        overwrites_class = None
+        overwrites_is_python = False
+
+        if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
+            # Parse extends and/or overwrites (can be chained with : or ::)
+            while True:
+                if self._match_keyword('extends'):
+                    if self._check(TokenType.IDENTIFIER):
+                        extends_class = self._advance().value
+                    elif self._check(TokenType.SHARED_REF):
+                        extends_class = self._advance().value
+                        extends_is_python = True
+                    else:
+                        raise CSSLSyntaxError("Expected parent class name after 'extends'")
+                    # Check for constructor arguments: extends Parent (arg1, arg2)
+                    if self._match(TokenType.PAREN_START):
+                        while not self._check(TokenType.PAREN_END):
+                            arg = self._parse_expression()
+                            extends_args.append(arg)
+                            self._match(TokenType.COMMA)
+                        self._expect(TokenType.PAREN_END)
+                elif self._match_keyword('overwrites'):
+                    if self._check(TokenType.IDENTIFIER):
+                        overwrites_class = self._advance().value
+                    elif self._check(TokenType.SHARED_REF):
+                        overwrites_class = self._advance().value
+                        overwrites_is_python = True
+                    else:
+                        raise CSSLSyntaxError("Expected class name after 'overwrites'")
+                    # Skip optional () after class name
+                    if self._match(TokenType.PAREN_START):
+                        self._expect(TokenType.PAREN_END)
+                else:
+                    raise CSSLSyntaxError("Expected 'extends' or 'overwrites' after ':' or '::' in class declaration")
+                # Check for another : or :: for chaining
+                if not (self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON)):
+                    break
+
+        node = ASTNode('class', value={
+            'name': class_name,
+            'non_null': non_null,
+            'class_params': class_params,
+            'extends': extends_class,
+            'extends_is_python': extends_is_python,
+            'extends_args': extends_args,
+            'overwrites': overwrites_class,
+            'overwrites_is_python': overwrites_is_python
+        }, children=[])
         self._expect(TokenType.BLOCK_START)
 
         while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
@@ -1382,14 +1473,265 @@ class CSSLParser:
                 method = self._parse_define()
                 node.children.append(method)
 
+            # Check for constr keyword (constructor declaration)
+            # Syntax: constr ConstructorName() { ... }
+            # or: constr ConstructorName() : extends Parent::ConstructorName { ... }
+            elif self._match_keyword('constr'):
+                constructor = self._parse_constructor(class_name)
+                node.children.append(constructor)
+
             else:
                 self._advance()
 
         self._expect(TokenType.BLOCK_END)
         return node
 
+    def _parse_constructor(self, class_name: str) -> ASTNode:
+        """Parse constructor declaration inside a class.
+
+        Syntax:
+            constr ConstructorName() { ... }
+            constr ConstructorName() : extends ParentClass::ConstructorName { ... }
+            constr ConstructorName() : extends ParentClass::ConstructorName : overwrites ParentClass::ConstructorName { ... }
+
+        Multiple constructors are allowed and executed in order.
+        Constructors can access parent constructor via super().
+        """
+        # Get constructor name
+        if not self._check(TokenType.IDENTIFIER):
+            raise CSSLSyntaxError("Expected constructor name after 'constr'")
+        constr_name = self._advance().value
+
+        # Parse method-level extends/overwrites with :: syntax
+        # constr Name() :: extends Parent::Name :: overwrites Parent::Name { ... }
+        extends_target = None
+        extends_class_ref = None
+        extends_method_ref = None
+        overwrites_target = None
+        overwrites_class_ref = None
+        overwrites_method_ref = None
+
+        # Parse parameters
+        params = []
+        if self._match(TokenType.PAREN_START):
+            params = self._parse_parameter_list()
+            self._expect(TokenType.PAREN_END)
+
+        # Check for method-level extends/overwrites with :: or :
+        if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
+            while True:
+                if self._match_keyword('extends'):
+                    # Parse Parent::method or just method
+                    extends_target = self._parse_qualified_method_ref()
+                    if '::' in extends_target:
+                        parts = extends_target.split('::')
+                        extends_class_ref = parts[0]
+                        extends_method_ref = parts[1]
+                    else:
+                        extends_method_ref = extends_target
+                elif self._match_keyword('overwrites'):
+                    # Parse Parent::method or just method
+                    overwrites_target = self._parse_qualified_method_ref()
+                    if '::' in overwrites_target:
+                        parts = overwrites_target.split('::')
+                        overwrites_class_ref = parts[0]
+                        overwrites_method_ref = parts[1]
+                    else:
+                        overwrites_method_ref = overwrites_target
+                else:
+                    break
+                # Check for another :: or : for chaining
+                if not (self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON)):
+                    break
+
+        # Parse constructor body
+        self._expect(TokenType.BLOCK_START)
+        body = []
+        while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+            stmt = self._parse_statement()
+            if stmt:
+                body.append(stmt)
+        self._expect(TokenType.BLOCK_END)
+
+        return ASTNode('constructor', value={
+            'name': constr_name,
+            'class_name': class_name,
+            'params': params,
+            'is_constructor': True,
+            'extends_target': extends_target,
+            'extends_class': extends_class_ref,
+            'extends_method': extends_method_ref,
+            'overwrites_target': overwrites_target,
+            'overwrites_class': overwrites_class_ref,
+            'overwrites_method': overwrites_method_ref
+        }, children=body)
+
+    def _parse_qualified_method_ref(self) -> str:
+        """Parse a qualified method reference like 'ParentClass::methodName' or just 'methodName'.
+
+        Returns the qualified name as a string (e.g., 'Parent::init' or just 'init').
+        """
+        # Check for $PythonObject
+        if self._check(TokenType.SHARED_REF):
+            class_ref = self._advance().value  # Gets the name without $
+            class_ref = f'${class_ref}'
+        elif self._check(TokenType.IDENTIFIER):
+            class_ref = self._advance().value
+        else:
+            raise CSSLSyntaxError("Expected class or method name in extends/overwrites")
+
+        # Check for :: to get method part
+        if self._match(TokenType.DOUBLE_COLON):
+            if self._check(TokenType.IDENTIFIER):
+                method_ref = self._advance().value
+                return f'{class_ref}::{method_ref}'
+            else:
+                raise CSSLSyntaxError("Expected method name after '::'")
+
+        # Just method name, no class qualifier
+        return class_ref
+
+    def _parse_parameter_list(self) -> list:
+        """Parse a list of parameters (without the surrounding parentheses).
+
+        Returns a list of parameter definitions, each can be:
+        - Simple string name: "paramName"
+        - Dict with type info: {'name': 'paramName', 'type': 'string', 'ref': True, ...}
+        """
+        params = []
+        while not self._check(TokenType.PAREN_END) and not self._is_at_end():
+            param_info = {}
+
+            # Handle 'open' keyword for open parameters
+            if self._match_keyword('open'):
+                param_info['open'] = True
+
+            # Handle type annotations (e.g., string, int, dynamic, etc.)
+            if self._check(TokenType.KEYWORD):
+                param_info['type'] = self._advance().value
+
+            # Handle reference operator &
+            if self._match(TokenType.AMPERSAND):
+                param_info['ref'] = True
+
+            # Handle * prefix for non-null parameters
+            if self._match(TokenType.MULTIPLY):
+                param_info['non_null'] = True
+
+            # Get parameter name
+            if self._check(TokenType.IDENTIFIER):
+                param_name = self._advance().value
+                if param_info:
+                    params.append({'name': param_name, **param_info})
+                else:
+                    params.append(param_name)
+                self._match(TokenType.COMMA)
+            elif self._check(TokenType.KEYWORD):
+                # Parameter name could be a keyword like 'Params'
+                param_name = self._advance().value
+                if param_info:
+                    params.append({'name': param_name, **param_info})
+                else:
+                    params.append(param_name)
+                self._match(TokenType.COMMA)
+            else:
+                break
+
+        return params
+
     def _parse_define(self) -> ASTNode:
+        """Parse define function declaration.
+
+        Syntax:
+            define MyFunc(args) { }
+            define *MyFunc(args) { }  // Non-null: must never return None
+            define MyFunc : extends OtherFunc() { }  // Inherit local vars
+            define MyFunc : overwrites OtherFunc() { }  // Replace OtherFunc
+            define MyFunc :: extends Parent::Method :: overwrites Parent::Method() { }  // Method-level inheritance
+        """
+        # Check for * prefix (non-null function - must return non-null)
+        non_null = False
+        if self._match(TokenType.MULTIPLY):
+            non_null = True
+
         name = self._advance().value
+
+        # Check for extends/overwrites: define func : extends/overwrites target() { }
+        # Also supports method-level :: syntax: define func :: extends Parent::method
+        extends_func = None
+        overwrites_func = None
+        extends_is_python = False
+        overwrites_is_python = False
+        extends_class_ref = None
+        extends_method_ref = None
+        overwrites_class_ref = None
+        overwrites_method_ref = None
+
+        if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
+            # Parse extends and/or overwrites (supports :: method-level syntax)
+            while True:
+                if self._match_keyword('extends'):
+                    # Check for qualified reference: Parent::method
+                    if self._check(TokenType.SHARED_REF):
+                        extends_is_python = True
+                        extends_func = self._advance().value
+                        # Check for ::method
+                        if self._match(TokenType.DOUBLE_COLON):
+                            extends_class_ref = f'${extends_func}'
+                            if self._check(TokenType.IDENTIFIER):
+                                extends_method_ref = self._advance().value
+                            else:
+                                raise CSSLSyntaxError("Expected method name after '::'")
+                    elif self._check(TokenType.IDENTIFIER):
+                        first_part = self._advance().value
+                        # Check for ::method (qualified reference)
+                        if self._match(TokenType.DOUBLE_COLON):
+                            extends_class_ref = first_part
+                            if self._check(TokenType.IDENTIFIER):
+                                extends_method_ref = self._advance().value
+                            else:
+                                raise CSSLSyntaxError("Expected method name after '::'")
+                        else:
+                            extends_func = first_part
+                    else:
+                        raise CSSLSyntaxError("Expected function name after 'extends'")
+                    # Skip optional () after function/method name
+                    if self._match(TokenType.PAREN_START):
+                        self._expect(TokenType.PAREN_END)
+                elif self._match_keyword('overwrites'):
+                    # Check for qualified reference: Parent::method
+                    if self._check(TokenType.SHARED_REF):
+                        overwrites_is_python = True
+                        overwrites_func = self._advance().value
+                        # Check for ::method
+                        if self._match(TokenType.DOUBLE_COLON):
+                            overwrites_class_ref = f'${overwrites_func}'
+                            if self._check(TokenType.IDENTIFIER):
+                                overwrites_method_ref = self._advance().value
+                            else:
+                                raise CSSLSyntaxError("Expected method name after '::'")
+                    elif self._check(TokenType.IDENTIFIER):
+                        first_part = self._advance().value
+                        # Check for ::method (qualified reference)
+                        if self._match(TokenType.DOUBLE_COLON):
+                            overwrites_class_ref = first_part
+                            if self._check(TokenType.IDENTIFIER):
+                                overwrites_method_ref = self._advance().value
+                            else:
+                                raise CSSLSyntaxError("Expected method name after '::'")
+                        else:
+                            overwrites_func = first_part
+                    else:
+                        raise CSSLSyntaxError("Expected function name after 'overwrites'")
+                    # Skip optional () after function/method name
+                    if self._match(TokenType.PAREN_START):
+                        self._expect(TokenType.PAREN_END)
+                else:
+                    break
+                # Check for another :: or : for chaining extends/overwrites
+                if not (self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON)):
+                    break
+
         params = []
 
         if self._match(TokenType.PAREN_START):
@@ -1404,6 +1746,9 @@ class CSSLParser:
                 # Handle reference operator &
                 if self._match(TokenType.AMPERSAND):
                     param_info['ref'] = True
+                # Handle * prefix for non-null parameters
+                if self._match(TokenType.MULTIPLY):
+                    param_info['non_null'] = True
                 # Get parameter name
                 if self._check(TokenType.IDENTIFIER):
                     param_name = self._advance().value
@@ -1424,7 +1769,20 @@ class CSSLParser:
                     break
             self._expect(TokenType.PAREN_END)
 
-        node = ASTNode('function', value={'name': name, 'params': params}, children=[])
+        node = ASTNode('function', value={
+            'name': name,
+            'params': params,
+            'non_null': non_null,
+            'extends': extends_func,
+            'extends_is_python': extends_is_python,
+            'overwrites': overwrites_func,
+            'overwrites_is_python': overwrites_is_python,
+            # Method-level inheritance (Parent::method syntax)
+            'extends_class': extends_class_ref,
+            'extends_method': extends_method_ref,
+            'overwrites_class': overwrites_class_ref,
+            'overwrites_method': overwrites_method_ref
+        }, children=[])
         self._expect(TokenType.BLOCK_START)
 
         while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
@@ -1470,6 +1828,11 @@ class CSSLParser:
         elif self._check(TokenType.SUPER_FUNC):
             # Super-function for .cssl-pl payload files
             return self._parse_super_function()
+        elif (self._check(TokenType.KEYWORD) and self._current().value == 'super' and
+              (self._peek(1).type == TokenType.PAREN_START or
+               self._peek(1).type == TokenType.DOUBLE_COLON)):
+            # super() or super::method() call - calls parent constructor/method
+            return self._parse_super_call()
         elif (self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or
               self._check(TokenType.CAPTURED_REF) or self._check(TokenType.SHARED_REF) or
               self._check(TokenType.GLOBAL_REF) or self._check(TokenType.SELF_REF) or
@@ -1480,6 +1843,43 @@ class CSSLParser:
             self._advance()
             return None
 
+    def _parse_super_call(self) -> ASTNode:
+        """Parse super() call to invoke parent constructor or method.
+
+        Syntax:
+            super()              - Call parent constructor with no args
+            super(arg1, arg2)    - Call parent constructor with args
+            super::method()      - Call specific parent method
+            super::method(args)  - Call specific parent method with args
+
+        Used inside constructors (constr) and methods to call parent implementations.
+        """
+        # Consume 'super' keyword
+        self._advance()
+
+        # Check for ::method syntax
+        target_method = None
+        if self._match(TokenType.DOUBLE_COLON):
+            if not self._check(TokenType.IDENTIFIER):
+                raise CSSLSyntaxError("Expected method name after 'super::'")
+            target_method = self._advance().value
+
+        # Parse arguments
+        args = []
+        self._expect(TokenType.PAREN_START)
+        while not self._check(TokenType.PAREN_END):
+            arg = self._parse_expression()
+            args.append(arg)
+            if not self._match(TokenType.COMMA):
+                break
+        self._expect(TokenType.PAREN_END)
+        self._match(TokenType.SEMICOLON)
+
+        return ASTNode('super_call', value={
+            'method': target_method,  # None for constructor, method name for specific method
+            'args': args
+        })
+
     def _parse_if(self) -> ASTNode:
         """Parse if statement with support for else if AND elif syntax."""
         self._expect(TokenType.PAREN_START)
@@ -2599,12 +2999,24 @@ class CSSLParser:
                 'init_values': init_values
             })
 
-        # Check for type-parameterized function call: OpenFind<string>(0)
+        # Check for type-parameterized function call: OpenFind<string>(0) or OpenFind<dynamic, "name">
         if name in TYPE_PARAM_FUNCTIONS and self._check(TokenType.COMPARE_LT):
             self._advance()  # consume <
             type_param = 'dynamic'
+            param_name = None  # Optional: named parameter search
+
             if self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
                 type_param = self._advance().value
+
+            # Check for second parameter: OpenFind<type, "name">
+            if self._check(TokenType.COMMA):
+                self._advance()  # consume comma
+                # Expect a string literal for the parameter name
+                if self._check(TokenType.STRING):
+                    param_name = self._advance().value
+                elif self._check(TokenType.IDENTIFIER):
+                    param_name = self._advance().value
+
             self._expect(TokenType.COMPARE_GT)  # consume >
 
             # Must be followed by ()
@@ -2621,6 +3033,7 @@ class CSSLParser:
                 return ASTNode('typed_call', value={
                     'name': name,
                     'type_param': type_param,
+                    'param_name': param_name,  # Named parameter for OpenFind
                     'args': args
                 })