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

includecpp/core/cssl/cssl_runtime.py

@@ -99,6 +99,89 @@ ERROR_HINTS = {
 }
 
 
+def _find_similar_names(name: str, candidates: list, max_distance: int = 2) -> list:
+    """Find similar names for 'did you mean' suggestions using Levenshtein distance."""
+    if not candidates:
+        return []
+
+    def levenshtein(s1: str, s2: str) -> int:
+        if len(s1) < len(s2):
+            s1, s2 = s2, s1
+        if len(s2) == 0:
+            return len(s1)
+        prev_row = range(len(s2) + 1)
+        for i, c1 in enumerate(s1):
+            curr_row = [i + 1]
+            for j, c2 in enumerate(s2):
+                insertions = prev_row[j + 1] + 1
+                deletions = curr_row[j] + 1
+                substitutions = prev_row[j] + (c1.lower() != c2.lower())
+                curr_row.append(min(insertions, deletions, substitutions))
+            prev_row = curr_row
+        return prev_row[-1]
+
+    similar = []
+    name_lower = name.lower()
+    for candidate in candidates:
+        if candidate.startswith('_'):
+            continue
+        dist = levenshtein(name, candidate)
+        # Also check case-insensitive exact match
+        if name_lower == candidate.lower() and name != candidate:
+            similar.insert(0, candidate)  # Exact case mismatch goes first
+        elif dist <= max_distance:
+            similar.append(candidate)
+
+    return similar[:3]  # Return top 3 suggestions
+
+
+def _get_available_classes(scope: 'Scope', global_scope: 'Scope', promoted_globals: dict) -> list:
+    """Get list of all available class names."""
+    classes = []
+    # Check current scope chain
+    current = scope
+    while current:
+        for name, val in current.variables.items():
+            if isinstance(val, CSSLClass) and name not in classes:
+                classes.append(name)
+        current = current.parent
+    # Check global scope
+    for name, val in global_scope.variables.items():
+        if isinstance(val, CSSLClass) and name not in classes:
+            classes.append(name)
+    # Check promoted globals
+    for name, val in promoted_globals.items():
+        if isinstance(val, CSSLClass) and name not in classes:
+            classes.append(name)
+    return classes
+
+
+def _get_available_functions(scope: 'Scope', global_scope: 'Scope', builtins) -> list:
+    """Get list of all available function names."""
+    functions = []
+    # Check current scope chain
+    current = scope
+    while current:
+        for name, val in current.variables.items():
+            if callable(val) or (isinstance(val, ASTNode) and val.type == 'function'):
+                if name not in functions:
+                    functions.append(name)
+        current = current.parent
+    # Check global scope
+    for name, val in global_scope.variables.items():
+        if callable(val) or (isinstance(val, ASTNode) and val.type == 'function'):
+            if name not in functions:
+                functions.append(name)
+    # Check builtins
+    if builtins:
+        for name in dir(builtins):
+            if name.startswith('builtin_'):
+                func_name = name[8:]  # Remove 'builtin_' prefix
+                if func_name not in functions:
+                    functions.append(func_name)
+    return functions
+
+
 class CSSLBreak(Exception):
     """Break statement"""
     pass
@@ -716,9 +799,12 @@ class CSSLRuntime:
         Parses class members and methods, creating a CSSLClass object
         that can be instantiated with 'new'.
         Supports inheritance via 'extends' keyword and method overwriting via 'overwrites'.
+
+        Classes are local by default. Use 'global class' or 'class @Name' for global classes.
         """
         class_info = node.value
         class_name = class_info.get('name')
+        is_global = class_info.get('is_global', False)
         extends_class_name = class_info.get('extends')
         extends_is_python = class_info.get('extends_is_python', False)
         overwrites_class_name = class_info.get('overwrites')
@@ -745,7 +831,22 @@ class CSSLRuntime:
                     parent_class = self.global_scope.get(extends_class_name)
 
             if parent_class is None:
-                raise ValueError(f"Cannot extend unknown class '{extends_class_name}'")
+                # Build detailed error for extends
+                available_classes = _get_available_classes(self.scope, self.global_scope, self._promoted_globals)
+                similar = _find_similar_names(extends_class_name, available_classes)
+
+                if similar:
+                    hint = f"Did you mean: {', '.join(similar)}?"
+                elif extends_is_python:
+                    hint = f"Python object '${extends_class_name}' not found. Use share() to share Python objects first."
+                else:
+                    hint = f"Define class '{extends_class_name}' before this class, or use 'extends $PyObject' for Python objects"
+
+                raise self._format_error(
+                    node.line,
+                    f"Cannot extend unknown class '{extends_class_name}'",
+                    hint
+                )
 
             # Auto-wrap Python objects for inheritance
             from .cssl_builtins import CSSLizedPythonObject
@@ -803,9 +904,11 @@ class CSSLRuntime:
         class_def.class_params = class_params  # Class-level constructor parameters
         class_def.extends_args = extends_args  # Arguments to pass to parent constructor
 
-        # Register class in scope
+        # Register class in scope (local by default, global if marked)
         self.scope.set(class_name, class_def)
-        self.global_scope.set(class_name, class_def)
+        if is_global:
+            self.global_scope.set(class_name, class_def)
+            self._promoted_globals[class_name] = class_def
 
         # Handle class overwrites - replace methods in target class
         if overwrites_class_name:
@@ -888,12 +991,15 @@ class CSSLRuntime:
         """Execute function definition - registers it and handles extends/overwrites.
 
         Syntax:
-            define func() { ... }
-            define func : extends otherFunc() { ... }  - Inherit local vars
-            define func : overwrites otherFunc() { ... }  - Replace otherFunc
+            define func() { ... }                           - Local function
+            global define func() { ... }                    - Global function
+            define @func() { ... }                          - Global function (alternative)
+            define func : extends otherFunc() { ... }       - Inherit local vars
+            define func : overwrites otherFunc() { ... }    - Replace otherFunc
         """
         func_info = node.value
         func_name = func_info.get('name')
+        is_global = func_info.get('is_global', False)
         extends_func = func_info.get('extends')
         extends_is_python = func_info.get('extends_is_python', False)
         overwrites_func = func_info.get('overwrites')
@@ -922,8 +1028,11 @@ class CSSLRuntime:
                     self.scope.set(overwrites_func, node)
                     self.global_scope.set(overwrites_func, node)
 
-        # Register the function
+        # Register the function (local by default, global if marked)
         self.scope.set(func_name, node)
+        if is_global:
+            self.global_scope.set(func_name, node)
+            self._promoted_globals[func_name] = node
         return None
 
     def _resolve_function_target(self, name: str, is_python: bool) -> Any:
@@ -1290,13 +1399,97 @@ class CSSLRuntime:
         self.scope = new_scope
 
         try:
+            # Handle append mode (++) - execute referenced function first
+            append_mode = func_info.get('append_mode', False)
+            append_ref_class = func_info.get('append_ref_class')
+            append_ref_member = func_info.get('append_ref_member')
+
+            if append_mode and append_ref_class:
+                self._execute_append_reference(
+                    None, append_ref_class, append_ref_member,
+                    args, kwargs, {}, is_constructor=False
+                )
+
             for child in func_node.children:
                 # Check if exit() was called
                 if not self._running:
                     break
                 self._execute_node(child)
         except CSSLReturn as ret:
-            return ret.value
+            return_value = ret.value
+
+            # Check exclude_type: *[type] - must NOT return excluded type
+            exclude_type = func_info.get('exclude_type')
+            if exclude_type:
+                type_map = {
+                    'string': str, 'int': int, 'float': float, 'bool': bool,
+                    'null': type(None), 'none': type(None),
+                    'list': list, 'array': list, 'dict': dict, 'json': dict,
+                }
+                excluded_py_type = type_map.get(exclude_type.lower())
+                # For shuffled returns (tuples), check each element
+                if isinstance(return_value, tuple):
+                    for val in return_value:
+                        if excluded_py_type and isinstance(val, excluded_py_type):
+                            raise CSSLRuntimeError(f"Type exclusion: function must NOT return '{exclude_type}' values")
+                elif excluded_py_type and isinstance(return_value, excluded_py_type):
+                    raise CSSLRuntimeError(f"Type exclusion: function must NOT return '{exclude_type}'")
+
+            # Enforce return type for typed functions (like C++)
+            # Typed functions MUST return the declared type
+            # Exception: 'meta' modifier allows any return type
+            enforce_return_type = func_info.get('enforce_return_type', False)
+            return_type = func_info.get('return_type')
+
+            if enforce_return_type and return_type and return_type != 'void':
+                # Type mapping from CSSL types to Python types
+                type_validate_map = {
+                    'string': str, 'int': int, 'float': (int, float), 'bool': bool,
+                    'list': list, 'array': list, 'dict': dict, 'json': dict,
+                    'dynamic': object,  # Any type
+                    'void': type(None),
+                }
+
+                # Generic container types - accept lists/tuples
+                container_types = {
+                    'vector', 'stack', 'datastruct', 'dataspace',
+                    'shuffled', 'iterator', 'combo', 'openquote', 'map'
+                }
+
+                if return_type in container_types:
+                    # Container types accept list, tuple, dict depending on type
+                    if return_type == 'map':
+                        expected = dict
+                    elif return_type == 'shuffled':
+                        expected = (list, tuple)
+                    else:
+                        expected = (list, tuple, object)
+
+                    if not isinstance(return_value, expected):
+                        func_name = func_info.get('name', 'unknown')
+                        actual_type = type(return_value).__name__
+                        raise CSSLRuntimeError(
+                            f"Type error in '{func_name}': declared return type '{return_type}' "
+                            f"but returned '{actual_type}'. Typed functions must return declared type."
+                        )
+                elif return_type in type_validate_map:
+                    expected = type_validate_map[return_type]
+                    if expected != object and return_value is not None:
+                        if not isinstance(return_value, expected):
+                            func_name = func_info.get('name', 'unknown')
+                            actual_type = type(return_value).__name__
+                            raise CSSLRuntimeError(
+                                f"Type error in '{func_name}': declared return type '{return_type}' "
+                                f"but returned '{actual_type}'. Typed functions must return declared type."
+                            )
+
+            # Check non_null: function must return a value (not None)
+            non_null = func_info.get('non_null', False)
+            if non_null and return_value is None:
+                func_name = func_info.get('name', 'unknown')
+                raise CSSLRuntimeError(f"Non-null function '{func_name}' returned null/None")
+
+            return return_value
         except Exception as e:
             # If undefined modifier, suppress all errors
             if is_undefined:
@@ -2704,7 +2897,21 @@ class CSSLRuntime:
             scoped_val = self.global_scope.get(f'${name}')
             if scoped_val is not None:
                 return scoped_val
-            raise CSSLRuntimeError(f"Shared object '${name}' not found. Use share() to share objects.")
+            # List available shared objects for helpful error
+            available_shared = list(_live_objects.keys())
+            similar = _find_similar_names(name, available_shared)
+            if similar:
+                hint = f"Did you mean: ${', $'.join(similar)}?"
+            elif available_shared:
+                hint = f"Available shared objects: ${', $'.join(available_shared[:5])}"
+            else:
+                hint = "Use share(name, object) from Python to share objects first."
+
+            raise self._format_error(
+                node.line if hasattr(node, 'line') else 0,
+                f"Shared object '${name}' not found",
+                hint
+            )
 
         if node.type == 'captured_ref':
             # %<name> captured reference - use value captured at infusion registration time
@@ -2731,7 +2938,13 @@ class CSSLRuntime:
                 value = self._original_functions.get(name)
             if value is not None:
                 return value
-            raise CSSLRuntimeError(f"Captured reference '%{name}' not found.")
+            # Build helpful error for captured reference
+            hint = f"Variable '{name}' must exist when the infusion is registered. Check that '%{name}' is defined before the <<== operator."
+            raise self._format_error(
+                node.line if hasattr(node, 'line') else 0,
+                f"Captured reference '%{name}' not found",
+                hint
+            )
 
         if node.type == 'instance_ref':
             # instance<"name"> - get shared instance by name
@@ -2820,6 +3033,58 @@ class CSSLRuntime:
         if node.type == 'unary':
             return self._eval_unary(node)
 
+        if node.type == 'non_null_assert':
+            # *$var, *@module, *identifier - assert value is not null/None
+            operand = node.value.get('operand')
+            value = self._evaluate(operand)
+            if value is None:
+                # Get name of the operand for better error message
+                operand_name = "unknown"
+                if isinstance(operand, ASTNode):
+                    if operand.type == 'identifier':
+                        operand_name = operand.value
+                    elif operand.type == 'shared_ref':
+                        operand_name = f"${operand.value}"
+                    elif operand.type == 'module_ref':
+                        operand_name = f"@{operand.value}"
+                    elif operand.type == 'global_ref':
+                        operand_name = f"r@{operand.value}"
+                raise self._format_error(
+                    node.line if hasattr(node, 'line') else 0,
+                    f"Non-null assertion failed: '{operand_name}' is null/None",
+                    f"The value accessed via '*{operand_name}' must not be null. Check that it is defined and initialized."
+                )
+            return value
+
+        if node.type == 'type_exclude_assert':
+            # *[type]expr - assert value is NOT of excluded type
+            exclude_type = node.value.get('exclude_type')
+            operand = node.value.get('operand')
+            value = self._evaluate(operand)
+
+            # Map CSSL types to Python types
+            type_map = {
+                'string': str,
+                'int': int,
+                'float': float,
+                'bool': bool,
+                'null': type(None),
+                'none': type(None),
+                'list': list,
+                'array': list,
+                'dict': dict,
+                'json': dict,
+            }
+
+            excluded_py_type = type_map.get(exclude_type.lower())
+            if excluded_py_type and isinstance(value, excluded_py_type):
+                raise self._format_error(
+                    node.line if hasattr(node, 'line') else 0,
+                    f"Type exclusion assertion failed: value is of excluded type '{exclude_type}'",
+                    f"The expression was marked *[{exclude_type}] meaning it must NOT return {exclude_type}, but it did."
+                )
+            return value
+
         if node.type == 'call':
             return self._eval_call(node)
 
@@ -3097,12 +3362,33 @@ class CSSLRuntime:
             return self._call_function(callee, args, kwargs)
 
         callee_name = callee_node.value if isinstance(callee_node, ASTNode) and hasattr(callee_node, 'value') else str(callee_node)
-        raise CSSLRuntimeError(
-            f"Cannot call '{callee_name}' - it is not a function",
-            node.line,
-            context=f"Type: {type(callee).__name__}",
-            hint=ERROR_HINTS['undefined_function']
-        )
+
+        # Build detailed error with suggestions
+        available_funcs = _get_available_functions(self.scope, self.global_scope, self.builtins)
+        similar = _find_similar_names(callee_name, available_funcs)
+
+        if callee is None:
+            # Function not found at all
+            if similar:
+                hint = f"Did you mean: {', '.join(similar)}?"
+            else:
+                hint = f"Function '{callee_name}' is not defined. Define it with: define {callee_name}() {{ }}"
+            raise self._format_error(
+                node.line,
+                f"Function '{callee_name}' not found",
+                hint
+            )
+        else:
+            # Found something but it's not callable
+            if similar:
+                hint = f"'{callee_name}' is a {type(callee).__name__}, not a function. Did you mean: {', '.join(similar)}?"
+            else:
+                hint = f"'{callee_name}' is a {type(callee).__name__}. Functions must be defined with 'define' keyword."
+            raise self._format_error(
+                node.line,
+                f"Cannot call '{callee_name}' - it is not a function",
+                hint
+            )
 
     def _eval_typed_call(self, node: ASTNode) -> Any:
         """Evaluate typed function call like OpenFind<string>(0) or OpenFind<dynamic, "name">"""
@@ -3168,26 +3454,53 @@ class CSSLRuntime:
         )
 
     def _eval_new(self, node: ASTNode) -> CSSLInstance:
-        """Evaluate 'new ClassName(args)' expression.
+        """Evaluate 'new ClassName(args)' or 'new @ClassName(args)' expression.
 
         Creates a new instance of a CSSL class and calls its constructor.
         Supports multiple constructors (constr keyword), class parameters,
         and automatic parent constructor calling.
+
+        With '@' prefix (new @ClassName), looks only in global scope.
         """
         class_name = node.value.get('class')
+        is_global_ref = node.value.get('is_global_ref', False)
         args = [self._evaluate(arg) for arg in node.value.get('args', [])]
         kwargs = {k: self._evaluate(v) for k, v in node.value.get('kwargs', {}).items()}
 
         # Get class definition from scope
-        class_def = self.scope.get(class_name)
-        if class_def is None:
-            class_def = self.global_scope.get(class_name)
+        if is_global_ref:
+            # With @ prefix, only look in global scope
+            class_def = self._promoted_globals.get(class_name)
+            if class_def is None:
+                class_def = self.global_scope.get(class_name)
+        else:
+            # Normal lookup: local scope first, then global
+            class_def = self.scope.get(class_name)
+            if class_def is None:
+                class_def = self.global_scope.get(class_name)
 
         if class_def is None:
-            raise CSSLRuntimeError(
-                f"Class '{class_name}' not found",
+            # Build detailed error with suggestions
+            source_line = self._get_source_line(node.line)
+            available_classes = _get_available_classes(self.scope, self.global_scope, self._promoted_globals)
+            similar = _find_similar_names(class_name, available_classes)
+
+            # Check if class exists in global scope (user forgot @)
+            global_class = self._promoted_globals.get(class_name) or self.global_scope.get(class_name)
+            if global_class and isinstance(global_class, CSSLClass) and not is_global_ref:
+                hint = f"Class '{class_name}' exists in global scope. Use: new @{class_name}()"
+            elif similar:
+                hint = f"Did you mean: {', '.join(similar)}?"
+            elif available_classes:
+                hint = f"Available classes: {', '.join(available_classes[:5])}"
+            else:
+                hint = "Define the class before instantiation, or use 'global class' / 'class @Name' for global classes"
+
+            context = f"in expression: {source_line.strip()}" if source_line else None
+            raise self._format_error(
                 node.line,
-                hint="Make sure the class is defined before instantiation"
+                f"Class '{class_name}' not found",
+                hint
             )
 
         if not isinstance(class_def, CSSLClass):
@@ -3271,17 +3584,122 @@ class CSSLRuntime:
             except TypeError:
                 pass
 
+    def _execute_append_reference(self, instance: CSSLInstance, ref_class: str, ref_member: str,
+                                   args: list, kwargs: dict, param_values: dict, is_constructor: bool = True):
+        """Execute referenced parent constructor/method for append mode (++).
+
+        Resolves the class/instance reference and executes the specified member.
+        Supports:
+        - Static class references: &ClassName::member
+        - Dynamic instance references: &$instanceVar::member
+        - Direct function references: &FunctionName (for define functions)
+
+        Args:
+            instance: Current class instance (can be None for standalone functions)
+            ref_class: Referenced class name, $instanceVar, or function name
+            ref_member: Member name (constructor name, 'constructors', or method name) - can be None
+            args: Arguments to pass
+            kwargs: Keyword arguments to pass
+            param_values: Parameter values from class params
+            is_constructor: True if looking for constructor, False for method
+        """
+        from .cssl_builtins import CSSLizedPythonObject
+
+        # Handle direct function reference: &FunctionName ++ (no ::member part)
+        if ref_member is None and not is_constructor:
+            # ref_class is actually a function name
+            func_name = ref_class
+            if func_name.startswith('$'):
+                func_name = func_name[1:]
+
+            # Look for the function in scope
+            func = self.scope.get(func_name) or self.global_scope.get(func_name)
+            if func is not None:
+                if isinstance(func, ASTNode) and func.type in ('function', 'FUNCTION'):
+                    # Execute the referenced function
+                    if instance:
+                        self._call_method(instance, func, args, kwargs)
+                    else:
+                        self._call_function(func, args, kwargs)
+                elif callable(func):
+                    # It's a callable (Python function or lambda)
+                    func(*args, **kwargs)
+            return
+
+        # Resolve the class/instance reference
+        if ref_class.startswith('$'):
+            # Dynamic instance reference: &$instanceVar::member
+            var_name = ref_class[1:]
+            ref_obj = self.scope.get(var_name) or self.global_scope.get(var_name)
+            if ref_obj is None:
+                return  # Instance not found, skip silently
+
+            if isinstance(ref_obj, CSSLInstance):
+                # Get the class definition from the instance
+                target_class = ref_obj.class_def
+            elif isinstance(ref_obj, CSSLClass):
+                target_class = ref_obj
+            else:
+                return  # Not a valid reference
+        else:
+            # Static class reference: &ClassName::member
+            target_class = self.scope.get(ref_class) or self.global_scope.get(ref_class)
+
+        if target_class is None:
+            return  # Class not found, skip silently
+
+        # Handle different target types
+        if isinstance(target_class, CSSLInstance):
+            # Referenced an instance variable directly
+            target_class = target_class.class_def
+
+        if not isinstance(target_class, CSSLClass):
+            return  # Not a CSSL class
+
+        # Find and execute the referenced member
+        if is_constructor:
+            # Looking for a constructor
+            if ref_member == 'constructors' or ref_member is None:
+                # Execute all constructors from the referenced class
+                for constr in getattr(target_class, 'constructors', []):
+                    self._call_constructor(instance, constr, args, kwargs, param_values)
+            else:
+                # Execute specific constructor by name
+                for constr in getattr(target_class, 'constructors', []):
+                    if constr.value.get('name') == ref_member:
+                        self._call_constructor(instance, constr, args, kwargs, param_values)
+                        break
+        else:
+            # Looking for a method (define function)
+            if ref_member:
+                # Find method in class
+                for member in getattr(target_class, 'members', []):
+                    if member.type in ('function', 'FUNCTION') and member.value.get('name') == ref_member:
+                        self._call_method(instance, member, args, kwargs)
+                        break
+                # Also check in methods dict if available
+                methods = getattr(target_class, 'methods', {})
+                if ref_member in methods:
+                    method_node = methods[ref_member]
+                    self._call_method(instance, method_node, args, kwargs)
+
     def _call_constructor(self, instance: CSSLInstance, constr_node: ASTNode,
                           args: list, kwargs: dict, param_values: dict):
         """Call a constructor defined with 'constr' keyword.
 
         Handles constructor extends/overwrites and sets up the instance scope.
+        Supports append mode (++) for keeping parent code and adding new code.
         """
         constr_info = constr_node.value
         constr_params = constr_info.get('params', [])
         extends_class = constr_info.get('extends_class')
         extends_method = constr_info.get('extends_method')
 
+        # Append mode: ++ operator for keeping parent code + adding new
+        append_mode = constr_info.get('append_mode', False)
+        append_ref_class = constr_info.get('append_ref_class')  # &ClassName or &$instanceVar
+        append_ref_member = constr_info.get('append_ref_member')  # ::constructorName or ::methodName
+
         # Save previous instance context
         prev_instance = self._current_instance
         self._current_instance = instance
@@ -3313,6 +3731,13 @@ class CSSLRuntime:
                         self._call_constructor(instance, constr, args, kwargs, param_values)
                         break
 
+        # Handle append mode (++) - execute referenced parent member first
+        if append_mode and append_ref_class:
+            self._execute_append_reference(
+                instance, append_ref_class, append_ref_member,
+                args, kwargs, param_values, is_constructor=True
+            )
+
         # Execute constructor body
         prev_scope = self.scope
         self.scope = new_scope
@@ -3367,21 +3792,42 @@ class CSSLRuntime:
                 return lambda *args, **kwargs: python_method(*args, **kwargs)
             return lambda *args, **kwargs: self._call_method(instance, method_node, list(args), kwargs)
 
-        raise CSSLRuntimeError(
-            f"'{instance._class.name}' has no member or method '{member}'",
-            node.line if hasattr(node, 'line') else 0
+        # Build helpful error with available members
+        class_name = instance._class.name
+        available_members = list(instance._members.keys()) if hasattr(instance, '_members') else []
+        available_methods = list(instance._methods.keys()) if hasattr(instance, '_methods') else []
+        all_available = available_members + available_methods
+        similar = _find_similar_names(member, all_available)
+
+        if similar:
+            hint = f"Did you mean: {', '.join(similar)}?"
+        elif all_available:
+            hint = f"Available: {', '.join(all_available[:5])}"
+        else:
+            hint = f"Class '{class_name}' has no accessible members. Check class definition."
+
+        raise self._format_error(
+            node.line if hasattr(node, 'line') else 0,
+            f"'{class_name}' has no member or method '{member}'",
+            hint
         )
 
     def _call_method(self, instance: CSSLInstance, method_node: ASTNode, args: list, kwargs: dict = None) -> Any:
         """Call a method on an instance with 'this' context.
 
         Sets up the instance as the current 'this' context and executes the method.
+        Supports append mode (++) for keeping parent code and adding new code.
         """
         kwargs = kwargs or {}
         func_info = method_node.value
         params = func_info.get('params', [])
         modifiers = func_info.get('modifiers', [])
 
+        # Append mode: ++ operator for keeping parent code + adding new
+        append_mode = func_info.get('append_mode', False)
+        append_ref_class = func_info.get('append_ref_class')  # &ClassName or &$instanceVar
+        append_ref_member = func_info.get('append_ref_member')  # ::methodName
+
         # Check for undefined modifier
         is_undefined = 'undefined' in modifiers
 
@@ -3408,6 +3854,13 @@ class CSSLRuntime:
         self._current_instance = instance
 
         try:
+            # Handle append mode (++) - execute referenced parent method first
+            if append_mode and append_ref_class:
+                self._execute_append_reference(
+                    instance, append_ref_class, append_ref_member,
+                    args, kwargs, {}, is_constructor=False
+                )
+
             for child in method_node.children:
                 if not self._running:
                     break
@@ -3451,7 +3904,25 @@ class CSSLRuntime:
                     python_method = method_node[1]
                     return lambda *args, **kwargs: python_method(*args, **kwargs)
                 return lambda *args, **kwargs: self._call_method(obj, method_node, list(args), kwargs)
-            raise CSSLRuntimeError(f"'{obj._class.name}' has no member or method '{member}'")
+            # Build helpful error with available members
+            class_name = obj._class.name
+            available_members = list(obj._members.keys()) if hasattr(obj, '_members') else []
+            available_methods = list(obj._methods.keys()) if hasattr(obj, '_methods') else []
+            all_available = available_members + available_methods
+            similar = _find_similar_names(member, all_available)
+
+            if similar:
+                hint = f"Did you mean: {', '.join(similar)}?"
+            elif all_available:
+                hint = f"Available: {', '.join(all_available[:5])}"
+            else:
+                hint = f"Class '{class_name}' has no accessible members."
+
+            raise self._format_error(
+                node.line,
+                f"'{class_name}' has no member or method '{member}'",
+                hint
+            )
 
         # === STRING METHODS ===
         if isinstance(obj, str):