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

includecpp/core/cssl/cssl_parser.py

@@ -101,17 +101,20 @@ class TokenType(Enum):
     SELF_REF = auto()    # s@<name> self-reference to global struct
     SHARED_REF = auto()  # $<name> shared object reference
     CAPTURED_REF = auto()  # %<name> captured reference (for infusion)
+    THIS_REF = auto()      # this-><name> class member reference
     PACKAGE = auto()
     PACKAGE_INCLUDES = auto()
     AS = auto()
     COMMENT = auto()
     NEWLINE = auto()
     EOF = auto()
+    # Super-functions for .cssl-pl payload files (v3.8.0)
+    SUPER_FUNC = auto()    # #$run(), #$exec(), #$printl() - pre-execution hooks
 
 
 KEYWORDS = {
     # Service structure
-    'service-init', 'service-run', 'service-include', 'struct', 'define', 'main',
+    'service-init', 'service-run', 'service-include', 'struct', 'define', 'main', 'class', 'new', 'this',
     # Control flow
     'if', 'else', 'elif', 'while', 'for', 'foreach', 'in', 'range',
     'switch', 'case', 'default', 'break', 'continue', 'return',
@@ -126,7 +129,7 @@ KEYWORDS = {
     'package', 'package-includes', 'exec', 'as', 'global',
     # CSSL Type Keywords
     'int', 'string', 'float', 'bool', 'void', 'json', 'array', 'vector', 'stack',
-    'list', 'dictionary', 'dict',  # Python-like types
+    'list', 'dictionary', 'dict', 'instance', 'map',  # Python-like types
     'dynamic',      # No type declaration (slow but flexible)
     'undefined',    # Function errors ignored
     'open',         # Accept any parameter type
@@ -154,7 +157,7 @@ TYPE_LITERALS = {'list', 'dict'}
 # Generic type keywords that use <T> syntax
 TYPE_GENERICS = {
     'datastruct', 'dataspace', 'shuffled', 'iterator', 'combo',
-    'vector', 'stack', 'array', 'openquote', 'list', 'dictionary'
+    'vector', 'stack', 'array', 'openquote', 'list', 'dictionary', 'map'
 }
 
 # Functions that accept type parameters: FuncName<type>(args)
@@ -211,9 +214,14 @@ class CSSLLexer:
 
             char = self.source[self.pos]
 
-            # Comments: both # and // style
+            # Super-functions (#$) or Comments (# and // style)
             if char == '#':
-                self._skip_comment()
+                if self._peek(1) == '$':
+                    # Super-function: #$run(), #$exec(), #$printl()
+                    self._read_super_function()
+                else:
+                    # Regular comment
+                    self._skip_comment()
             elif char == '/' and self._peek(1) == '/':
                 # C-style // comment - NEW
                 self._skip_comment()
@@ -445,6 +453,31 @@ class CSSLLexer:
         else:
             self._add_token(TokenType.IDENTIFIER, value)
 
+    def _read_super_function(self):
+        """Read #$<name>(...) super-function call for .cssl-pl payloads.
+
+        Super-functions are pre-execution hooks that run when a payload is loaded.
+        Valid super-functions: #$run(), #$exec(), #$printl()
+
+        Syntax:
+            #$run(initFunction);        // Call a function at load time
+            #$exec(setup());            // Execute expression at load time
+            #$printl("Payload loaded"); // Print at load time
+        """
+        start = self.pos
+        self._advance()  # skip '#'
+        self._advance()  # skip '$'
+
+        # Read the super-function name (run, exec, printl, etc.)
+        name_start = self.pos
+        while self.pos < len(self.source) and (self.source[self.pos].isalnum() or self.source[self.pos] == '_'):
+            self._advance()
+        func_name = self.source[name_start:self.pos]
+
+        # Store as #$<name> token value
+        value = f'#${func_name}'
+        self._add_token(TokenType.SUPER_FUNC, value)
+
     def _read_self_ref(self):
         """Read s@<name> or s@<name>.<member>... self-reference"""
         start = self.pos
@@ -679,7 +712,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',
+                        'list', 'dictionary', 'dict', 'instance', 'map',
                         'dynamic', 'datastruct', 'dataspace', 'shuffled', 'iterator', 'combo', 'structure')
 
     def _looks_like_function_declaration(self) -> bool:
@@ -898,7 +931,7 @@ class CSSLParser:
         type_keywords = {'int', 'string', 'float', 'bool', 'dynamic', 'void',
                         'stack', 'vector', 'datastruct', 'dataspace', 'shuffled',
                         'iterator', 'combo', 'array', 'openquote', 'json',
-                        'list', 'dictionary', 'dict'}
+                        'list', 'dictionary', 'dict', 'instance', 'map'}
         if type_name not in type_keywords:
             return False
 
@@ -927,11 +960,13 @@ class CSSLParser:
         # Get type name
         type_name = self._advance().value  # Consume type keyword
 
-        # Check for generic type <T>
+        # Check for generic type <T> or instance<"name">
         element_type = None
         if self._match(TokenType.COMPARE_LT):
-            # Get element type
-            if self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
+            # For instance<"name">, element_type can be a string literal
+            if type_name == 'instance' and self._check(TokenType.STRING):
+                element_type = self._advance().value
+            elif self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
                 element_type = self._advance().value
             self._expect(TokenType.COMPARE_GT)
 
@@ -947,6 +982,14 @@ class CSSLParser:
 
         self._match(TokenType.SEMICOLON)
 
+        # For instance<"name">, create a special node type
+        if type_name == 'instance':
+            return ASTNode('instance_declaration', value={
+                'instance_name': element_type,
+                'name': var_name,
+                'value': value
+            })
+
         return ASTNode('typed_declaration', value={
             'type': type_name,
             'element_type': element_type,
@@ -961,6 +1004,8 @@ class CSSLParser:
         while not self._is_at_end():
             if self._match_keyword('struct'):
                 root.children.append(self._parse_struct())
+            elif self._match_keyword('class'):
+                root.children.append(self._parse_class())
             elif self._match_keyword('define'):
                 root.children.append(self._parse_define())
             # Check for C-style typed function declarations
@@ -1233,6 +1278,58 @@ class CSSLParser:
         self._expect(TokenType.BLOCK_END)
         return node
 
+    def _parse_class(self) -> ASTNode:
+        """Parse class declaration with members and methods.
+
+        Syntax:
+            class ClassName {
+                string name;
+                int age;
+
+                void ClassName(string n) { this->name = n; }
+
+                void sayHello() {
+                    printl("Hello " + this->name);
+                }
+            }
+        """
+        class_name = self._advance().value
+
+        node = ASTNode('class', value={'name': class_name}, children=[])
+        self._expect(TokenType.BLOCK_START)
+
+        while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+            # Check for typed function (method) declaration
+            if self._looks_like_function_declaration():
+                method = self._parse_typed_function()
+                method_info = method.value
+                method_name = method_info.get('name')
+
+                # Mark constructor (same name as class or __init__)
+                if method_name == class_name or method_name == '__init__':
+                    method.value['is_constructor'] = True
+
+                node.children.append(method)
+
+            # Check for typed member variable declaration
+            elif self._looks_like_typed_variable():
+                member = self._parse_typed_variable()
+                if member:
+                    # Mark as class member
+                    member.value['is_member'] = True
+                    node.children.append(member)
+
+            # Check for define-style method
+            elif self._match_keyword('define'):
+                method = self._parse_define()
+                node.children.append(method)
+
+            else:
+                self._advance()
+
+        self._expect(TokenType.BLOCK_END)
+        return node
+
     def _parse_define(self) -> ASTNode:
         name = self._advance().value
         params = []
@@ -1312,9 +1409,13 @@ class CSSLParser:
         elif self._looks_like_function_declaration():
             # Nested typed function (e.g., void Level2() { ... })
             return self._parse_typed_function()
+        elif self._check(TokenType.SUPER_FUNC):
+            # Super-function for .cssl-pl payload files
+            return self._parse_super_function()
         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)):
+              self._check(TokenType.GLOBAL_REF) or self._check(TokenType.SELF_REF) or
+              (self._check(TokenType.KEYWORD) and self._current().value in ('this', 'new'))):
             return self._parse_expression_statement()
         else:
             self._advance()
@@ -1528,23 +1629,42 @@ class CSSLParser:
         return ASTNode('c_for_update', value={'var': var_name, 'op': 'none'})
 
     def _parse_python_style_for(self) -> ASTNode:
-        """Parse Python-style for loop: for (i in range(...)) { }
+        """Parse Python-style for loop: for (i in range(...)) { } or for (item in collection) { }
 
         Supports:
             for (i in range(n)) { }           - 0 to n-1
             for (i in range(start, end)) { }  - start to end-1
             for (i in range(start, end, step)) { }
+            for (item in collection) { }      - iterate over list/vector
+            for (item in @global_collection) { } - iterate over global
         """
         var_name = self._advance().value
         self._expect(TokenType.KEYWORD)  # 'in'
 
-        # 'range' can be keyword or identifier
+        # Check if this is range() or collection iteration
+        is_range = False
         if self._check(TokenType.KEYWORD) and self._peek().value == 'range':
             self._advance()  # consume 'range' keyword
+            is_range = True
         elif self._check(TokenType.IDENTIFIER) and self._peek().value == 'range':
             self._advance()  # consume 'range' identifier
-        else:
-            self.error(f"Expected 'range', got {self._peek().value}")
+            is_range = True
+
+        # If not range, parse as collection iteration
+        if not is_range:
+            iterable = self._parse_expression()
+            self._expect(TokenType.PAREN_END)
+
+            node = ASTNode('foreach', value={'var': var_name, 'iterable': iterable}, children=[])
+            self._expect(TokenType.BLOCK_START)
+
+            while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+                stmt = self._parse_statement()
+                if stmt:
+                    node.children.append(stmt)
+
+            self._expect(TokenType.BLOCK_END)
+            return node
 
         self._expect(TokenType.PAREN_START)
         first_arg = self._parse_expression()
@@ -1656,11 +1776,56 @@ class CSSLParser:
         return node
 
     def _parse_return(self) -> ASTNode:
-        value = None
+        """Parse return statement, supporting multiple values for shuffled functions.
+
+        Syntax:
+            return;                    // Return None
+            return value;              // Return single value
+            return a, b, c;            // Return multiple values (for shuffled)
+        """
+        values = []
         if not self._check(TokenType.SEMICOLON) and not self._check(TokenType.BLOCK_END):
-            value = self._parse_expression()
+            values.append(self._parse_expression())
+
+            # Check for comma-separated return values (shuffled return)
+            while self._check(TokenType.COMMA):
+                self._advance()  # consume comma
+                values.append(self._parse_expression())
+
         self._match(TokenType.SEMICOLON)
-        return ASTNode('return', value=value)
+
+        if len(values) == 0:
+            return ASTNode('return', value=None)
+        elif len(values) == 1:
+            return ASTNode('return', value=values[0])
+        else:
+            # Multiple return values - create tuple return
+            return ASTNode('return', value={'multiple': True, 'values': values})
+
+    def _parse_super_function(self) -> ASTNode:
+        """Parse super-function for .cssl-pl payload files.
+
+        Syntax:
+            #$run(initFunction);           // Call function at load time
+            #$exec(setup());               // Execute expression at load time
+            #$printl("Payload loaded");    // Print at load time
+
+        These are pre-execution hooks that run when payload() loads the file.
+        """
+        token = self._advance()  # Get the SUPER_FUNC token
+        super_name = token.value  # e.g., "#$run", "#$exec", "#$printl"
+
+        # Parse the arguments
+        self._expect(TokenType.PAREN_START)
+        args = []
+        if not self._check(TokenType.PAREN_END):
+            args.append(self._parse_expression())
+            while self._match(TokenType.COMMA):
+                args.append(self._parse_expression())
+        self._expect(TokenType.PAREN_END)
+        self._match(TokenType.SEMICOLON)
+
+        return ASTNode('super_func', value={'name': super_name, 'args': args})
 
     def _parse_try(self) -> ASTNode:
         node = ASTNode('try', children=[])
@@ -1747,6 +1912,25 @@ class CSSLParser:
     def _parse_expression_statement(self) -> Optional[ASTNode]:
         expr = self._parse_expression()
 
+        # === TUPLE UNPACKING: a, b, c = shuffled_func() ===
+        # Check if we have comma-separated identifiers before =
+        if expr.type == 'identifier' and self._check(TokenType.COMMA):
+            targets = [expr]
+            while self._match(TokenType.COMMA):
+                next_expr = self._parse_expression()
+                if next_expr.type == 'identifier':
+                    targets.append(next_expr)
+                else:
+                    # Not a simple identifier list, this is something else
+                    # Restore and fall through to normal parsing
+                    break
+
+            # Check if followed by =
+            if self._match(TokenType.EQUALS):
+                value = self._parse_expression()
+                self._match(TokenType.SEMICOLON)
+                return ASTNode('tuple_assignment', value={'targets': targets, 'value': value})
+
         # === BASIC INJECTION: <== (replace target with source) ===
         if self._match(TokenType.INJECT_LEFT):
             # Check if this is a createcmd injection with a code block
@@ -1782,14 +1966,14 @@ class CSSLParser:
             if self._check(TokenType.BRACKET_START):
                 # Peek ahead to see if this is an index [n] or a filter [type::helper=...]
                 # Only consume if it's a simple number index
-                saved_pos = self._current
+                saved_pos = self.pos
                 self._advance()  # consume [
                 if self._check(TokenType.NUMBER):
                     remove_index = int(self._advance().value)
                     self._expect(TokenType.BRACKET_END)
                 else:
                     # Not a number - restore position for filter parsing
-                    self._current = saved_pos
+                    self.pos = saved_pos
 
             filter_info = self._parse_injection_filter()
             source = self._parse_expression()
@@ -1824,14 +2008,14 @@ class CSSLParser:
             remove_index = None
             if self._check(TokenType.BRACKET_START):
                 # Peek ahead to see if this is an index [n] or something else
-                saved_pos = self._current
+                saved_pos = self.pos
                 self._advance()  # consume [
                 if self._check(TokenType.NUMBER):
                     remove_index = int(self._advance().value)
                     self._expect(TokenType.BRACKET_END)
                 else:
                     # Not a number - restore position
-                    self._current = saved_pos
+                    self.pos = saved_pos
 
             if self._check(TokenType.BLOCK_START):
                 code_block = self._parse_action_block()
@@ -1987,19 +2171,75 @@ class CSSLParser:
         return self._parse_primary()
 
     def _parse_primary(self) -> ASTNode:
+        # Handle 'this->' member access
+        if self._check(TokenType.KEYWORD) and self._current().value == 'this':
+            self._advance()  # consume 'this'
+            if self._match(TokenType.FLOW_RIGHT):  # ->
+                member = self._advance().value
+                node = ASTNode('this_access', value={'member': member})
+                # Continue to check for calls, member access, indexing
+                while True:
+                    if self._match(TokenType.PAREN_START):
+                        # Method call: this->method()
+                        args, kwargs = self._parse_call_arguments()
+                        self._expect(TokenType.PAREN_END)
+                        node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
+                    elif self._match(TokenType.DOT):
+                        # Chained access: this->obj.method
+                        member = self._advance().value
+                        node = ASTNode('member_access', value={'object': node, 'member': member})
+                    elif self._match(TokenType.BRACKET_START):
+                        # Index access: this->arr[0]
+                        index = self._parse_expression()
+                        self._expect(TokenType.BRACKET_END)
+                        node = ASTNode('index_access', value={'object': node, 'index': index})
+                    elif self._match(TokenType.FLOW_RIGHT):
+                        # Chained this->a->b style access
+                        member = self._advance().value
+                        node = ASTNode('this_access', value={'member': member, 'object': node})
+                    else:
+                        break
+                return node
+            else:
+                # Just 'this' keyword alone - return as identifier for now
+                return ASTNode('identifier', value='this')
+
+        # Handle 'new ClassName(args)' instantiation
+        if self._check(TokenType.KEYWORD) and self._current().value == 'new':
+            self._advance()  # consume 'new'
+            class_name = self._advance().value  # get class name
+            args = []
+            kwargs = {}
+            if self._match(TokenType.PAREN_START):
+                args, kwargs = self._parse_call_arguments()
+                self._expect(TokenType.PAREN_END)
+            node = ASTNode('new', value={'class': class_name, 'args': args, 'kwargs': kwargs})
+            # Continue to check for member access, calls on the new object
+            while True:
+                if self._match(TokenType.DOT):
+                    member = self._advance().value
+                    node = ASTNode('member_access', value={'object': node, 'member': member})
+                    if self._match(TokenType.PAREN_START):
+                        args, kwargs = self._parse_call_arguments()
+                        self._expect(TokenType.PAREN_END)
+                        node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
+                elif self._match(TokenType.BRACKET_START):
+                    index = self._parse_expression()
+                    self._expect(TokenType.BRACKET_END)
+                    node = ASTNode('index_access', value={'object': node, 'index': index})
+                else:
+                    break
+            return node
+
         if self._match(TokenType.AT):
             node = self._parse_module_reference()
             # Continue to check for calls, indexing, member access on module refs
             while True:
                 if self._match(TokenType.PAREN_START):
-                    # Function call on module ref: @Module.method()
-                    args = []
-                    while not self._check(TokenType.PAREN_END) and not self._is_at_end():
-                        args.append(self._parse_expression())
-                        if not self._check(TokenType.PAREN_END):
-                            self._expect(TokenType.COMMA)
+                    # Function call on module ref: @Module.method() - with kwargs support
+                    args, kwargs = self._parse_call_arguments()
                     self._expect(TokenType.PAREN_END)
-                    node = ASTNode('call', value={'callee': node, 'args': args})
+                    node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
                 elif self._match(TokenType.DOT):
                     # Member access: @Module.property
                     member = self._advance().value
@@ -2017,31 +2257,23 @@ class CSSLParser:
             # s@<name> self-reference to global struct
             token = self._advance()
             node = ASTNode('self_ref', value=token.value, line=token.line, column=token.column)
-            # Check for function call: s@Backend.Loop.Start()
+            # Check for function call: s@Backend.Loop.Start() - with kwargs support
             if self._match(TokenType.PAREN_START):
-                args = []
-                while not self._check(TokenType.PAREN_END):
-                    args.append(self._parse_expression())
-                    if not self._check(TokenType.PAREN_END):
-                        self._expect(TokenType.COMMA)
+                args, kwargs = self._parse_call_arguments()
                 self._expect(TokenType.PAREN_END)
-                node = ASTNode('call', value={'callee': node, 'args': args})
+                node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
             return node
 
         if self._check(TokenType.GLOBAL_REF):
             # r@<name> global variable reference/declaration
             token = self._advance()
             node = ASTNode('global_ref', value=token.value, line=token.line, column=token.column)
-            # Check for member access, calls, indexing
+            # Check for member access, calls, indexing - with kwargs support
             while True:
                 if self._match(TokenType.PAREN_START):
-                    args = []
-                    while not self._check(TokenType.PAREN_END):
-                        args.append(self._parse_expression())
-                        if not self._check(TokenType.PAREN_END):
-                            self._expect(TokenType.COMMA)
+                    args, kwargs = self._parse_call_arguments()
                     self._expect(TokenType.PAREN_END)
-                    node = ASTNode('call', value={'callee': node, 'args': args})
+                    node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
                 elif self._match(TokenType.DOT):
                     member = self._advance().value
                     node = ASTNode('member_access', value={'object': node, 'member': member})
@@ -2057,16 +2289,12 @@ class CSSLParser:
             # $<name> shared object reference
             token = self._advance()
             node = ASTNode('shared_ref', value=token.value, line=token.line, column=token.column)
-            # Check for member access, calls, indexing
+            # Check for member access, calls, indexing - with kwargs support
             while True:
                 if self._match(TokenType.PAREN_START):
-                    args = []
-                    while not self._check(TokenType.PAREN_END):
-                        args.append(self._parse_expression())
-                        if not self._check(TokenType.PAREN_END):
-                            self._expect(TokenType.COMMA)
+                    args, kwargs = self._parse_call_arguments()
                     self._expect(TokenType.PAREN_END)
-                    node = ASTNode('call', value={'callee': node, 'args': args})
+                    node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
                 elif self._match(TokenType.DOT):
                     member = self._advance().value
                     node = ASTNode('member_access', value={'object': node, 'member': member})
@@ -2082,16 +2310,12 @@ class CSSLParser:
             # %<name> captured reference (captures value at infusion registration time)
             token = self._advance()
             node = ASTNode('captured_ref', value=token.value, line=token.line, column=token.column)
-            # Check for member access, calls, indexing
+            # Check for member access, calls, indexing - with kwargs support
             while True:
                 if self._match(TokenType.PAREN_START):
-                    args = []
-                    while not self._check(TokenType.PAREN_END):
-                        args.append(self._parse_expression())
-                        if not self._check(TokenType.PAREN_END):
-                            self._expect(TokenType.COMMA)
+                    args, kwargs = self._parse_call_arguments()
                     self._expect(TokenType.PAREN_END)
-                    node = ASTNode('call', value={'callee': node, 'args': args})
+                    node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
                 elif self._match(TokenType.DOT):
                     member = self._advance().value
                     node = ASTNode('member_access', value={'object': node, 'member': member})
@@ -2160,14 +2384,10 @@ class CSSLParser:
                 member = self._advance().value
                 node = ASTNode('member_access', value={'object': node, 'member': member})
             elif self._match(TokenType.PAREN_START):
-                # Function call
-                args = []
-                while not self._check(TokenType.PAREN_END):
-                    args.append(self._parse_expression())
-                    if not self._check(TokenType.PAREN_END):
-                        self._expect(TokenType.COMMA)
+                # Function call - use _parse_call_arguments for kwargs support
+                args, kwargs = self._parse_call_arguments()
                 self._expect(TokenType.PAREN_END)
-                node = ASTNode('call', value={'callee': node, 'args': args})
+                node = ASTNode('call', value={'callee': node, 'args': args, 'kwargs': kwargs})
             elif self._match(TokenType.BRACKET_START):
                 # Index access
                 index = self._parse_expression()
@@ -2191,7 +2411,7 @@ class CSSLParser:
         while not self._check(TokenType.PAREN_END) and not self._is_at_end():
             # Check for named argument: identifier = expression
             if self._check(TokenType.IDENTIFIER):
-                saved_pos = self._current
+                saved_pos = self.pos  # Save token position
                 name_token = self._advance()
 
                 if self._check(TokenType.EQUALS):
@@ -2201,7 +2421,7 @@ class CSSLParser:
                     kwargs[name_token.value] = value
                 else:
                     # Not named, restore and parse as expression
-                    self._current = saved_pos
+                    self.pos = saved_pos  # Restore token position
                     args.append(self._parse_expression())
             else:
                 args.append(self._parse_expression())
@@ -2220,17 +2440,75 @@ class CSSLParser:
                 namespace_member = self._advance().value
                 name = f"{name}::{namespace_member}"
 
-        # Check for type generic instantiation: stack<string>, vector<int>, etc.
+        # Check for instance<"name"> syntax - gets/creates shared instance
+        if name == 'instance' and self._check(TokenType.COMPARE_LT):
+            self._advance()  # consume <
+            # Expect string literal for instance name
+            if self._check(TokenType.STRING):
+                instance_name = self._advance().value
+            elif self._check(TokenType.IDENTIFIER):
+                instance_name = self._advance().value
+            else:
+                raise CSSLParserError("Expected instance name (string or identifier)", self._current_line())
+            self._expect(TokenType.COMPARE_GT)  # consume >
+            return ASTNode('instance_ref', value=instance_name)
+
+        # Check for type generic instantiation: stack<string>, vector<int>, map<string, int>, etc.
         # This creates a new instance of the type with the specified element type
         if name in TYPE_GENERICS and self._check(TokenType.COMPARE_LT):
             self._advance()  # consume <
             element_type = 'dynamic'
+            value_type = None  # For map<K, V>
+
             if self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
                 element_type = self._advance().value
+
+            # Check for second type parameter (map<K, V>)
+            if name == 'map' and self._check(TokenType.COMMA):
+                self._advance()  # consume ,
+                if self._check(TokenType.KEYWORD) or self._check(TokenType.IDENTIFIER):
+                    value_type = self._advance().value
+                else:
+                    value_type = 'dynamic'
+
             self._expect(TokenType.COMPARE_GT)  # consume >
+
+            # Check for inline initialization: map<K,V>{"key": "value", ...}
+            init_values = None
+            if self._check(TokenType.BLOCK_START):
+                self._advance()  # consume {
+                init_values = {}
+
+                while not self._check(TokenType.BLOCK_END) and not self._is_at_end():
+                    # Parse key
+                    if self._check(TokenType.STRING):
+                        key = self._advance().value
+                    elif self._check(TokenType.IDENTIFIER):
+                        key = self._advance().value
+                    else:
+                        key = str(self._parse_expression().value) if hasattr(self._parse_expression(), 'value') else 'key'
+
+                    # Expect : or =
+                    if self._check(TokenType.COLON):
+                        self._advance()
+                    elif self._check(TokenType.EQUALS):
+                        self._advance()
+
+                    # Parse value
+                    value = self._parse_expression()
+                    init_values[key] = value
+
+                    # Optional comma
+                    if self._check(TokenType.COMMA):
+                        self._advance()
+
+                self._expect(TokenType.BLOCK_END)  # consume }
+
             return ASTNode('type_instantiation', value={
                 'type': name,
-                'element_type': element_type
+                'element_type': element_type,
+                'value_type': value_type,
+                'init_values': init_values
             })
 
         # Check for type-parameterized function call: OpenFind<string>(0)
@@ -2288,7 +2566,7 @@ class CSSLParser:
             return False
 
         # Save position for lookahead
-        saved_pos = self._current
+        saved_pos = self.pos
 
         # Check if it looks like key = value pattern
         is_object = False
@@ -2299,7 +2577,7 @@ class CSSLParser:
                 is_object = True
 
         # Restore position
-        self._current = saved_pos
+        self.pos = saved_pos
         return is_object
 
     def _parse_action_block_expression(self) -> ASTNode: