IncludeCPP 3.7.9__py3-none-any.whl → 3.8.0__py3-none-any.whl

includecpp/core/cssl/cssl_parser.py

@@ -1,5 +1,5 @@
 """
-CSSL Parser - Lexer and Parser for CSO Service Script Language
+CSSL Parser - Lexer and Parser for CSSL Language
 
 Features:
 - Complete tokenization of CSSL syntax
@@ -252,8 +252,15 @@ class CSSLLexer:
                 # $<name> shared object reference
                 self._read_shared_ref()
             elif char == '%':
-                # %<name> captured reference (for infusion)
-                self._read_captured_ref()
+                # Check if this is %<name> captured reference or % modulo operator
+                next_char = self._peek(1)
+                if next_char and (next_char.isalpha() or next_char == '_'):
+                    # %<name> captured reference (for infusion)
+                    self._read_captured_ref()
+                else:
+                    # % modulo operator
+                    self._add_token(TokenType.MODULO, '%')
+                    self._advance()
             elif char == '&':
                 # & for references
                 if self._peek(1) == '&':
@@ -321,9 +328,6 @@ class CSSLLexer:
                 else:
                     # Already handled by // comment check above, but just in case
                     self._skip_comment()
-            elif char == '%':
-                self._add_token(TokenType.MODULO, '%')
-                self._advance()
             elif char == '<':
                 self._read_less_than()
             elif char == '>':
@@ -712,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:
@@ -723,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()
 
@@ -752,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
 
@@ -848,7 +863,7 @@ class CSSLParser:
             if self._match_keyword('open'):
                 param_info['open'] = True
 
-            # Handle type annotations
+            # Handle type annotations (builtin types like int, string, etc.)
             if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
                 param_info['type'] = self._advance().value
 
@@ -872,6 +887,39 @@ class CSSLParser:
                         self._advance()
                     param_info['generic'] = ''.join(generic_parts)
 
+            # Handle custom class types (identifier followed by another identifier = type + name)
+            elif self._check(TokenType.IDENTIFIER):
+                # Look ahead: if next token is also an identifier, current is the type
+                saved_pos = self.pos
+                potential_type = self._advance().value
+
+                # Check for generic type parameter <T> on custom type
+                if self._check(TokenType.COMPARE_LT):
+                    self._advance()
+                    generic_parts = []
+                    depth = 1
+                    while depth > 0 and not self._is_at_end():
+                        if self._check(TokenType.COMPARE_LT):
+                            depth += 1
+                            generic_parts.append('<')
+                        elif self._check(TokenType.COMPARE_GT):
+                            depth -= 1
+                            if depth > 0:
+                                generic_parts.append('>')
+                        elif self._check(TokenType.COMMA):
+                            generic_parts.append(',')
+                        else:
+                            generic_parts.append(self._current().value)
+                        self._advance()
+                    param_info['generic'] = ''.join(generic_parts)
+
+                # If followed by identifier, this is "Type name" pattern
+                if self._check(TokenType.IDENTIFIER):
+                    param_info['type'] = potential_type
+                else:
+                    # Not a type, restore position - this is just a param name
+                    self.pos = saved_pos
+
             # Handle reference operator &
             if self._match(TokenType.AMPERSAND):
                 param_info['ref'] = True
@@ -914,6 +962,27 @@ class CSSLParser:
         self._expect(TokenType.BLOCK_END)
         return node
 
+    def _looks_like_namespace_call(self) -> bool:
+        """Check if current position looks like a namespace function call.
+
+        Pattern: keyword::identifier(...) like json::write(), string::cut()
+        This allows type keywords to be used as namespace prefixes for function calls.
+        """
+        if not self._check(TokenType.KEYWORD):
+            return False
+
+        # Save position
+        saved_pos = self.pos
+
+        self._advance()  # Skip keyword
+
+        # Must be followed by ::
+        result = self._check(TokenType.DOUBLE_COLON)
+
+        # Restore position
+        self.pos = saved_pos
+        return result
+
     def _looks_like_typed_variable(self) -> bool:
         """Check if current position looks like a typed variable declaration:
         type_name varName; or type_name<T> varName; or type_name varName = value;
@@ -1415,7 +1484,8 @@ class CSSLParser:
         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
-              (self._check(TokenType.KEYWORD) and self._current().value in ('this', 'new'))):
+              (self._check(TokenType.KEYWORD) and self._current().value in ('this', 'new')) or
+              self._looks_like_namespace_call()):
             return self._parse_expression_statement()
         else:
             self._advance()
@@ -1882,32 +1952,42 @@ class CSSLParser:
         self._expect(TokenType.BLOCK_END)
         return node
 
-    def _parse_injection_filter(self) -> Optional[dict]:
-        """Parse injection filter: [type::helper=value]"""
-        if not self._match(TokenType.BRACKET_START):
+    def _parse_injection_filter(self) -> Optional[list]:
+        """Parse injection filter(s): [type::helper=value] or [f1][f2][f3]...
+
+        Returns a list of filter dictionaries to support chained filters.
+        """
+        if not self._check(TokenType.BRACKET_START):
             return None
 
-        filter_info = {}
-        # Parse type::helper=value patterns
-        while not self._check(TokenType.BRACKET_END) and not self._is_at_end():
-            if self._check(TokenType.IDENTIFIER) or self._check(TokenType.KEYWORD):
-                filter_type = self._advance().value
-                if self._match(TokenType.DOUBLE_COLON):
-                    helper = self._advance().value
-                    if self._match(TokenType.EQUALS):
-                        value = self._parse_expression()
-                        filter_info[f'{filter_type}::{helper}'] = value
+        filters = []
+
+        # Parse multiple consecutive filter brackets
+        while self._match(TokenType.BRACKET_START):
+            filter_info = {}
+            # Parse type::helper=value patterns within this bracket
+            while not self._check(TokenType.BRACKET_END) and not self._is_at_end():
+                if self._check(TokenType.IDENTIFIER) or self._check(TokenType.KEYWORD):
+                    filter_type = self._advance().value
+                    if self._match(TokenType.DOUBLE_COLON):
+                        helper = self._advance().value
+                        if self._match(TokenType.EQUALS):
+                            value = self._parse_expression()
+                            filter_info[f'{filter_type}::{helper}'] = value
+                        else:
+                            filter_info[f'{filter_type}::{helper}'] = True
                     else:
-                        filter_info[f'{filter_type}::{helper}'] = True
+                        filter_info['type'] = filter_type
+                elif self._check(TokenType.COMMA):
+                    self._advance()
                 else:
-                    filter_info['type'] = filter_type
-            elif self._check(TokenType.COMMA):
-                self._advance()
-            else:
-                break
+                    break
 
-        self._expect(TokenType.BRACKET_END)
-        return filter_info if filter_info else None
+            self._expect(TokenType.BRACKET_END)
+            if filter_info:
+                filters.append(filter_info)
+
+        return filters if filters else None
 
     def _parse_expression_statement(self) -> Optional[ASTNode]:
         expr = self._parse_expression()
@@ -2118,6 +2198,11 @@ class CSSLParser:
             elif self._match(TokenType.COMPARE_GE):
                 right = self._parse_term()
                 left = ASTNode('binary', value={'op': '>=', 'left': left, 'right': right})
+            elif self._check(TokenType.KEYWORD) and self._peek().value == 'in':
+                # 'in' operator for containment: item in list
+                self._advance()  # consume 'in'
+                right = self._parse_term()
+                left = ASTNode('binary', value={'op': 'in', 'left': left, 'right': right})
             else:
                 break
 
@@ -2504,6 +2589,20 @@ class CSSLParser:
 
                 self._expect(TokenType.BLOCK_END)  # consume }
 
+            # Check for array-style initialization: vector<int>[1, 2, 3], array<string>["a", "b"]
+            elif self._check(TokenType.BRACKET_START):
+                self._advance()  # consume [
+                init_values = []
+
+                while not self._check(TokenType.BRACKET_END) and not self._is_at_end():
+                    init_values.append(self._parse_expression())
+
+                    # Optional comma
+                    if self._check(TokenType.COMMA):
+                        self._advance()
+
+                self._expect(TokenType.BRACKET_END)  # consume ]
+
             return ASTNode('type_instantiation', value={
                 'type': name,
                 'element_type': element_type,