IncludeCPP 3.8.9__py3-none-any.whl → 4.0.2__py3-none-any.whl

includecpp/core/cssl/cssl_parser.py

@@ -144,16 +144,25 @@ KEYWORDS = {
     'structure',    # Advanced C++/Py Class
     'openquote',    # SQL openquote container
     # CSSL Function Modifiers
+    'const',        # Immutable function (like C++)
     'meta',         # Source function (must return)
     'super',        # Force execution (no exceptions)
     'closed',       # Protect from external injection
     'private',      # Disable all injections
     'virtual',      # Import cycle safe
     'sqlbased',     # SQL-based function
+    'public',       # Explicitly public (default)
+    'static',       # Static method/function
     # CSSL Include Keywords
     'include', 'get',
 }
 
+# Function modifiers that can appear in any order before function name
+FUNCTION_MODIFIERS = {
+    'undefined', 'open', 'meta', 'super', 'closed', 'private', 'virtual',
+    'sqlbased', 'const', 'public', 'static', 'global', 'shuffled'
+}
+
 # Type literals that create empty instances
 TYPE_LITERALS = {'list', 'dict'}
 
@@ -719,7 +728,7 @@ class CSSLParser:
 
     def _is_function_modifier(self, value: str) -> bool:
         """Check if a keyword is a function modifier"""
-        return value in ('undefined', 'open', 'meta', 'super', 'closed', 'private', 'virtual', 'sqlbased')
+        return value in FUNCTION_MODIFIERS
 
     def _is_type_keyword(self, value: str) -> bool:
         """Check if a keyword is a type declaration"""
@@ -730,53 +739,98 @@ class CSSLParser:
     def _looks_like_function_declaration(self) -> bool:
         """Check if current position looks like a C-style function declaration.
 
+        Supports flexible ordering of modifiers, types, non-null (*), and global (@):
+
         Patterns:
         - int funcName(...)
         - undefined int funcName(...)
         - vector<string> funcName(...)
         - undefined void funcName(...)
-        - private super virtual meta FuncName(...)  <- modifiers without return type
+        - private super virtual meta FuncName(...)
+        - private string *@Myfunc(...)
+        - const define myFunc(...)
+        - global private const void @Func(...)
+        - shuffled *[string] getNumbers(...)
+        - datastruct<dynamic> HelloCode(...)
+        - datastruct<dynamic> HelloCode() : extends @MyFunc { }
+
+        Distinguishes functions from variables:
+        - datastruct<dynamic> MyVar;           <- variable (no () { })
+        - datastruct<dynamic> HelloCode() { }  <- function (has () { })
         """
         saved_pos = self.pos
         has_modifiers = False
+        has_type = 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
+        try:
+            # Skip modifiers in any order (global, private, const, undefined, etc.)
+            while self._check(TokenType.KEYWORD) and self._is_function_modifier(self._current().value):
+                self._advance()
+                has_modifiers = True
 
-        # Check for type keyword (optional if modifiers present)
-        if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
-            self._advance()
+            # Check for 'define' keyword (special case: const define myFunc())
+            if self._check(TokenType.KEYWORD) and self._current().value == 'define':
+                self.pos = saved_pos
+                return False  # Let _parse_define handle this
 
-            # Skip generic type parameters <T>
-            if self._check(TokenType.COMPARE_LT):
-                depth = 1
+            # Check for type keyword (int, string, void, vector, datastruct, etc.)
+            if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
                 self._advance()
-                while depth > 0 and not self._is_at_end():
-                    if self._check(TokenType.COMPARE_LT):
-                        depth += 1
-                    elif self._check(TokenType.COMPARE_GT):
-                        depth -= 1
+                has_type = True
+
+                # Skip generic type parameters <T> or <T, U>
+                if self._check(TokenType.COMPARE_LT):
+                    depth = 1
                     self._advance()
+                    while depth > 0 and not self._is_at_end():
+                        if self._check(TokenType.COMPARE_LT):
+                            depth += 1
+                        elif self._check(TokenType.COMPARE_GT):
+                            depth -= 1
+                        self._advance()
+
+            # Check for * prefix (non-null) or *[type] (type exclusion)
+            if self._check(TokenType.MULTIPLY):
+                self._advance()
+                # Check for type exclusion: *[string], *[int], etc.
+                if self._check(TokenType.BRACKET_START):
+                    self._advance()  # [
+                    while not self._check(TokenType.BRACKET_END) and not self._is_at_end():
+                        self._advance()
+                    if self._check(TokenType.BRACKET_END):
+                        self._advance()  # ]
 
-            # Check for identifier followed by (
+            # Check for @ prefix (global function)
+            if self._check(TokenType.AT):
+                self._advance()
+
+            # Now we should be at the function name (identifier)
             if self._check(TokenType.IDENTIFIER):
                 self._advance()
-                is_func = self._check(TokenType.PAREN_START)
-                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)
+                # Check if followed by (
+                # IMPORTANT: Only a function declaration if we have modifiers OR type
+                # Plain identifier() is a function CALL, not a declaration
+                if self._check(TokenType.PAREN_START):
+                    if has_modifiers or has_type:
+                        self.pos = saved_pos
+                        return True
+                    else:
+                        # No modifiers/type = function call, not declaration
+                        self.pos = saved_pos
+                        return False
+
+                # If we have a type and identifier but no (, it's a variable
+                if has_type and not self._check(TokenType.PAREN_START):
+                    self.pos = saved_pos
+                    return False
+
             self.pos = saved_pos
-            return is_func
+            return False
 
-        self.pos = saved_pos
-        return False
+        except Exception:
+            self.pos = saved_pos
+            return False
 
     def _looks_like_typed_variable(self) -> bool:
         """Check if current position looks like a typed variable declaration.
@@ -816,51 +870,110 @@ class CSSLParser:
         self.pos = saved_pos
         return False
 
-    def _parse_typed_function(self) -> ASTNode:
-        """Parse C-style typed function declaration.
+    def _parse_typed_function(self, is_global: bool = False) -> ASTNode:
+        """Parse C-style typed function declaration with flexible modifier ordering.
+
+        Supports any order of modifiers, types, non-null (*), and global (@):
 
         Patterns:
         - int Add(int a, int b) { }
+        - global int Add(int a, int b) { }
+        - int @Add(int a, int b) { }
         - undefined int Func() { }
         - open void Handler(open Params) { }
         - vector<string> GetNames() { }
+        - private string *@Myfunc() { }
+        - const define myFunc() { }
+        - global private const void @Func() { }
+        - shuffled *[string] getNumbers() { }
+        - datastruct<dynamic> HelloCode() { }
+        - meta datastruct<string> MyData() { }  // meta allows any returns
+        - datastruct<dynamic> HelloCode() : extends @MyFunc { }
+
+        Typed functions (with return type like int, string, void) MUST return that type.
+        Functions with 'meta' modifier can return any type regardless of declaration.
+        Functions with 'define' are dynamic (any return type allowed).
         """
         modifiers = []
         return_type = None
         generic_type = None
+        non_null = False
+        exclude_type = None
+        is_const = False
+
+        # Phase 1: Collect all modifiers, type, non-null, and global indicators
+        # These can appear in any order before the function name
+
+        parsing_prefix = True
+        while parsing_prefix and not self._is_at_end():
+            # Check for modifiers (global, private, const, undefined, etc.)
+            if self._check(TokenType.KEYWORD) and self._is_function_modifier(self._current().value):
+                mod = self._advance().value
+                if mod == 'global':
+                    is_global = True
+                elif mod == 'const':
+                    is_const = True
+                    modifiers.append(mod)
+                else:
+                    modifiers.append(mod)
+                continue
 
-        # Collect modifiers (undefined, open, meta, super, closed, private, virtual)
-        while self._check(TokenType.KEYWORD) and self._is_function_modifier(self._current().value):
-            modifiers.append(self._advance().value)
+            # Check for type keyword (int, string, void, vector, datastruct, etc.)
+            if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value) and return_type is None:
+                return_type = self._advance().value
 
-        # Get return type
-        if self._check(TokenType.KEYWORD) and self._is_type_keyword(self._current().value):
-            return_type = self._advance().value
+                # Check for generic type <T> or <T, U>
+                if self._check(TokenType.COMPARE_LT):
+                    self._advance()  # skip <
+                    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(str(self._current().value))
+                        self._advance()
+                    generic_type = ''.join(generic_parts)
+                continue
 
-            # Check for generic type <T>
-            if self._check(TokenType.COMPARE_LT):
-                self._advance()  # skip <
-                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()
-                generic_type = ''.join(generic_parts)
+            # Check for * prefix (non-null) or *[type] (type exclusion)
+            if self._check(TokenType.MULTIPLY):
+                self._advance()
+                # Check for type exclusion filter: *[string], *[int], etc.
+                if self._check(TokenType.BRACKET_START):
+                    self._advance()  # consume [
+                    exclude_type = self._advance().value  # get type name
+                    self._expect(TokenType.BRACKET_END)
+                else:
+                    non_null = True
+                continue
+
+            # Check for @ prefix (global function)
+            if self._check(TokenType.AT):
+                self._advance()
+                is_global = True
+                continue
+
+            # If we've reached an identifier, we're at the function name
+            if self._check(TokenType.IDENTIFIER):
+                parsing_prefix = False
+            else:
+                # Unknown token in prefix, break out
+                parsing_prefix = False
 
-        # Get function name
+        # Phase 2: Get function name
+        if not self._check(TokenType.IDENTIFIER):
+            self.error(f"Expected function name, got {self._current().type.name}")
         name = self._advance().value
 
-        # Parse parameters
+        # Phase 3: Parse parameters
         params = []
         self._expect(TokenType.PAREN_START)
 
@@ -871,6 +984,10 @@ class CSSLParser:
             if self._match_keyword('open'):
                 param_info['open'] = True
 
+            # Handle const parameters
+            if self._match_keyword('const'):
+                param_info['const'] = True
+
             # 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
@@ -891,13 +1008,12 @@ class CSSLParser:
                         elif self._check(TokenType.COMMA):
                             generic_parts.append(',')
                         else:
-                            generic_parts.append(self._current().value)
+                            generic_parts.append(str(self._current().value))
                         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
 
@@ -917,7 +1033,7 @@ class CSSLParser:
                         elif self._check(TokenType.COMMA):
                             generic_parts.append(',')
                         else:
-                            generic_parts.append(self._current().value)
+                            generic_parts.append(str(self._current().value))
                         self._advance()
                     param_info['generic'] = ''.join(generic_parts)
 
@@ -928,6 +1044,10 @@ class CSSLParser:
                     # Not a type, restore position - this is just a param name
                     self.pos = saved_pos
 
+            # Handle * prefix for non-null parameters
+            if self._match(TokenType.MULTIPLY):
+                param_info['non_null'] = True
+
             # Handle reference operator &
             if self._match(TokenType.AMPERSAND):
                 param_info['ref'] = True
@@ -940,7 +1060,7 @@ class CSSLParser:
                 else:
                     params.append(param_name)
             elif self._check(TokenType.KEYWORD):
-                # Parameter name could be a keyword
+                # Parameter name could be a keyword like 'Params'
                 param_name = self._advance().value
                 if param_info:
                     params.append({'name': param_name, **param_info})
@@ -951,13 +1071,106 @@ class CSSLParser:
 
         self._expect(TokenType.PAREN_END)
 
-        # Parse function body
+        # Phase 4: Check for extends/overwrites and append mode
+        extends_func = None
+        extends_is_python = False
+        extends_class_ref = None
+        extends_method_ref = None
+        overwrites_func = None
+        overwrites_is_python = False
+        overwrites_class_ref = None
+        overwrites_method_ref = None
+        append_mode = False
+        append_ref_class = None
+        append_ref_member = None
+
+        # Check for &ClassName::member or &ClassName.member or &function reference
+        if self._match(TokenType.AMPERSAND):
+            if self._check(TokenType.IDENTIFIER):
+                append_ref_class = self._advance().value
+            elif self._check(TokenType.AT):
+                self._advance()
+                if self._check(TokenType.IDENTIFIER):
+                    append_ref_class = '@' + self._advance().value
+            elif self._check(TokenType.SHARED_REF):
+                append_ref_class = f'${self._advance().value}'
+
+            # Check for ::member or .member (support both syntaxes)
+            if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.DOT):
+                if self._check(TokenType.IDENTIFIER) or self._check(TokenType.KEYWORD):
+                    append_ref_member = self._advance().value
+
+        # Check for ++ append operator
+        if self._match(TokenType.PLUS_PLUS):
+            append_mode = True
+
+        # Check for : or :: extends/overwrites
+        if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON):
+            while True:
+                if self._match_keyword('extends'):
+                    # Parse target: @ModuleName, $PythonObject, Parent::method, Parent.method
+                    if self._check(TokenType.AT):
+                        self._advance()
+                        extends_func = '@' + self._advance().value
+                    elif self._check(TokenType.SHARED_REF):
+                        extends_is_python = True
+                        extends_func = self._advance().value
+                    elif self._check(TokenType.IDENTIFIER):
+                        first_part = self._advance().value
+                        # Support both :: and . for class method access
+                        if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.DOT):
+                            extends_class_ref = first_part
+                            extends_method_ref = self._advance().value
+                        else:
+                            extends_func = first_part
+                    # Skip optional ()
+                    if self._match(TokenType.PAREN_START):
+                        self._expect(TokenType.PAREN_END)
+                elif self._match_keyword('overwrites'):
+                    if self._check(TokenType.AT):
+                        self._advance()
+                        overwrites_func = '@' + self._advance().value
+                    elif self._check(TokenType.SHARED_REF):
+                        overwrites_is_python = True
+                        overwrites_func = self._advance().value
+                    elif self._check(TokenType.IDENTIFIER):
+                        first_part = self._advance().value
+                        # Support both :: and . for class method access
+                        if self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.DOT):
+                            overwrites_class_ref = first_part
+                            overwrites_method_ref = self._advance().value
+                        else:
+                            overwrites_func = first_part
+                    if self._match(TokenType.PAREN_START):
+                        self._expect(TokenType.PAREN_END)
+                else:
+                    break
+                if not (self._match(TokenType.DOUBLE_COLON) or self._match(TokenType.COLON)):
+                    break
+
+        # Phase 5: Parse function body
         node = ASTNode('function', value={
             'name': name,
+            'is_global': is_global,
+            'is_const': is_const,
             'params': params,
             'return_type': return_type,
             'generic_type': generic_type,
-            'modifiers': modifiers
+            'modifiers': modifiers,
+            'non_null': non_null,
+            'exclude_type': exclude_type,
+            'extends': extends_func,
+            'extends_is_python': extends_is_python,
+            'extends_class': extends_class_ref,
+            'extends_method': extends_method_ref,
+            'overwrites': overwrites_func,
+            'overwrites_is_python': overwrites_is_python,
+            'overwrites_class': overwrites_class_ref,
+            'overwrites_method': overwrites_method_ref,
+            'append_mode': append_mode,
+            'append_ref_class': append_ref_class,
+            'append_ref_member': append_ref_member,
+            'enforce_return_type': return_type is not None and 'meta' not in modifiers
         }, children=[])
 
         self._expect(TokenType.BLOCK_START)
@@ -1117,19 +1330,30 @@ class CSSLParser:
                 root.children.append(self._parse_package_includes())
             # Handle global declarations
             elif self._match_keyword('global'):
-                stmt = self._parse_expression_statement()
-                if stmt:
-                    # Wrap in global_assignment to mark as global variable
-                    global_stmt = ASTNode('global_assignment', value=stmt)
-                    root.children.append(global_stmt)
+                # Check if followed by class or define (global class/function)
+                if self._match_keyword('class'):
+                    root.children.append(self._parse_class(is_global=True))
+                elif self._match_keyword('define'):
+                    root.children.append(self._parse_define(is_global=True))
+                elif self._looks_like_function_declaration():
+                    # global void MyFunc() { } or global int MyFunc() { }
+                    root.children.append(self._parse_typed_function(is_global=True))
+                else:
+                    stmt = self._parse_expression_statement()
+                    if stmt:
+                        # Wrap in global_assignment to mark as global variable
+                        global_stmt = ASTNode('global_assignment', value=stmt)
+                        root.children.append(global_stmt)
             elif self._check(TokenType.GLOBAL_REF):
                 stmt = self._parse_expression_statement()
                 if stmt:
                     # Wrap in global_assignment to mark as global variable (same as 'global' keyword)
                     global_stmt = ASTNode('global_assignment', value=stmt)
                     root.children.append(global_stmt)
-            # Handle statements
-            elif self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or self._check(TokenType.SELF_REF) or self._check(TokenType.SHARED_REF):
+            # Handle statements - keywords like 'instance', 'list', 'map' can be variable names
+            elif (self._check(TokenType.IDENTIFIER) or self._check(TokenType.AT) or
+                  self._check(TokenType.SELF_REF) or self._check(TokenType.SHARED_REF) or
+                  self._check(TokenType.KEYWORD)):
                 stmt = self._parse_expression_statement()
                 if stmt:
                     root.children.append(stmt)
@@ -1366,20 +1590,14 @@ class CSSLParser:
         self._expect(TokenType.BLOCK_END)
         return node
 
-    def _parse_class(self) -> ASTNode:
+    def _parse_class(self, is_global: bool = False) -> 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 ClassName { ... }           // Local class
+            global class ClassName { ... }    // Global class
+            class @ClassName { ... }          // Global class (alternative)
+            class *ClassName { ... }          // Non-null class
 
         Non-null class (all methods return non-null):
             class *MyClass { ... }
@@ -1389,6 +1607,11 @@ class CSSLParser:
         if self._match(TokenType.MULTIPLY):
             non_null = True
 
+        # Check for @ prefix (global class): class @ClassName
+        if self._check(TokenType.AT):
+            self._advance()  # consume @
+            is_global = True
+
         class_name = self._advance().value
 
         # Check for class-level constructor parameters: class MyClass (int x, string y) { ... }
@@ -1445,6 +1668,7 @@ class CSSLParser:
 
         node = ASTNode('class', value={
             'name': class_name,
+            'is_global': is_global,
             'non_null': non_null,
             'class_params': class_params,
             'extends': extends_class,
@@ -1679,20 +1903,35 @@ class CSSLParser:
 
         return params
 
-    def _parse_define(self) -> ASTNode:
+    def _parse_define(self, is_global: bool = False) -> ASTNode:
         """Parse define function declaration.
 
         Syntax:
-            define MyFunc(args) { }
-            define *MyFunc(args) { }  // Non-null: must never return None
+            define MyFunc(args) { }           // Local function
+            global define MyFunc(args) { }    // Global function
+            define @MyFunc(args) { }          // Global function (alternative)
+            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)
+        # Also *[type] for type exclusion (must NOT return that type)
         non_null = False
+        exclude_type = None
         if self._match(TokenType.MULTIPLY):
-            non_null = True
+            # Check for type exclusion filter: *[string], *[int], etc.
+            if self._check(TokenType.BRACKET_START):
+                self._advance()  # consume [
+                exclude_type = self._advance().value  # get type name
+                self._expect(TokenType.BRACKET_END)
+            else:
+                non_null = True
+
+        # Check for @ prefix (global function): define @FuncName
+        if self._check(TokenType.AT):
+            self._advance()  # consume @
+            is_global = True
 
         name = self._advance().value
 
@@ -1837,8 +2076,10 @@ class CSSLParser:
 
         node = ASTNode('function', value={
             'name': name,
+            'is_global': is_global,
             'params': params,
             'non_null': non_null,
+            'exclude_type': exclude_type,  # *[type] - must NOT return this type
             'extends': extends_func,
             'extends_is_python': extends_is_python,
             'overwrites': overwrites_func,
@@ -2712,6 +2953,26 @@ class CSSLParser:
             operand = self._parse_unary()
             return ASTNode('reference', value=operand)
 
+        # Non-null assertion: *$var, *@module, *identifier
+        # Also type exclusion filter: *[type]expr - exclude type from return
+        if self._check(TokenType.MULTIPLY):
+            next_token = self._peek(1)
+
+            # Check for type exclusion filter: *[string], *[int], etc.
+            if next_token and next_token.type == TokenType.BRACKET_START:
+                self._advance()  # consume *
+                self._advance()  # consume [
+                exclude_type = self._advance().value  # get type name
+                self._expect(TokenType.BRACKET_END)
+                operand = self._parse_unary()
+                return ASTNode('type_exclude_assert', value={'exclude_type': exclude_type, 'operand': operand})
+
+            # Non-null assertion when followed by $ (shared ref), @ (global), or identifier
+            if next_token and next_token.type in (TokenType.SHARED_REF, TokenType.AT, TokenType.IDENTIFIER):
+                self._advance()  # consume *
+                operand = self._parse_unary()
+                return ASTNode('non_null_assert', value={'operand': operand})
+
         return self._parse_primary()
 
     def _parse_primary(self) -> ASTNode:
@@ -2748,16 +3009,21 @@ class CSSLParser:
                 # Just 'this' keyword alone - return as identifier for now
                 return ASTNode('identifier', value='this')
 
-        # Handle 'new ClassName(args)' instantiation
+        # Handle 'new ClassName(args)' or 'new @ClassName(args)' instantiation
         if self._check(TokenType.KEYWORD) and self._current().value == 'new':
             self._advance()  # consume 'new'
+            # Check for @ prefix (global class reference)
+            is_global_ref = False
+            if self._check(TokenType.AT):
+                self._advance()  # consume @
+                is_global_ref = True
             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})
+            node = ASTNode('new', value={'class': class_name, 'args': args, 'kwargs': kwargs, 'is_global_ref': is_global_ref})
             # Continue to check for member access, calls on the new object
             while True:
                 if self._match(TokenType.DOT):
@@ -2776,7 +3042,18 @@ class CSSLParser:
             return node
 
         if self._match(TokenType.AT):
+            # Check for @* (global non-null reference): @*name
+            is_non_null = False
+            if self._check(TokenType.MULTIPLY):
+                self._advance()  # consume *
+                is_non_null = True
+
             node = self._parse_module_reference()
+
+            # Wrap in non_null_assert if @* was used
+            if is_non_null:
+                node = ASTNode('non_null_assert', value={'operand': node, 'is_global': True})
+
             # Continue to check for calls, indexing, member access on module refs
             while True:
                 if self._match(TokenType.PAREN_START):