IncludeCPP 3.3.11__py3-none-any.whl → 3.4.2__py3-none-any.whl

includecpp/core/cppy_converter.py

@@ -25,6 +25,65 @@ def _safe_get(lst: List[Any], index: int, default: Any = None) -> Any:
     return default
 
 
+# v3.3.22: Python reserved keywords - names that need escaping when used as identifiers
+PYTHON_KEYWORDS = {
+    'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await',
+    'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except',
+    'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
+    'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try',
+    'while', 'with', 'yield'
+}
+
+# v3.4.1: C++ reserved words that need escaping when used as Python identifiers
+# These are C++ types/keywords that are valid Python identifiers but confusing
+CPP_RESERVED_WORDS = {
+    # Primitive types
+    'int', 'float', 'double', 'char', 'bool', 'void', 'auto',
+    'short', 'long', 'signed', 'unsigned', 'wchar_t',
+    # Type modifiers
+    'const', 'static', 'virtual', 'volatile', 'mutable', 'extern',
+    'register', 'inline', 'explicit', 'constexpr', 'consteval',
+    # Access modifiers
+    'public', 'private', 'protected',
+    # Other keywords
+    'template', 'typename', 'namespace', 'using', 'typedef',
+    'struct', 'union', 'enum', 'sizeof', 'alignof', 'decltype',
+    'new', 'delete', 'operator', 'friend', 'this',
+    'throw', 'catch', 'noexcept', 'final', 'override',
+}
+
+
+def _escape_python_keyword(name: str) -> str:
+    """Escape Python reserved keywords by adding underscore suffix.
+
+    Example: 'class' -> 'class_', 'def' -> 'def_', 'import' -> 'import_'
+    """
+    if name in PYTHON_KEYWORDS:
+        return name + '_'
+    return name
+
+
+def _escape_cpp_reserved(name: str) -> str:
+    """Escape C++ reserved words when used as Python identifiers.
+
+    Example: 'double' -> 'double_', 'int' -> 'int_', 'void' -> 'void_'
+    v3.4.1: Prevents C++ type names from being used as Python function/variable names.
+    """
+    if name in CPP_RESERVED_WORDS:
+        return name + '_'
+    return name
+
+
+def _escape_identifier(name: str) -> str:
+    """Escape both Python keywords and C++ reserved words.
+
+    Combines both escaping functions for comprehensive identifier safety.
+    """
+    name = _escape_python_keyword(name)
+    name = _escape_cpp_reserved(name)
+    return name
+
+
 # Python type to C++ type mapping
 PY_TO_CPP_TYPES = {
     'int': 'int',
@@ -260,6 +319,52 @@ class StructInfo:
 
 
 class PythonToCppConverter:
+    # Common parameter name patterns to infer types
+    PARAM_TYPE_HINTS = {
+        # Integer-like names
+        'n': 'int', 'k': 'int', 'i': 'int', 'j': 'int', 'count': 'int', 'num': 'int',
+        'index': 'int', 'idx': 'int', 'size': 'size_t', 'length': 'size_t', 'len': 'size_t',
+        'start': 'int', 'end': 'int', 'begin': 'int', 'stop': 'int', 'step': 'int',
+        'seed': 'int', 'limit': 'int', 'offset': 'int', 'position': 'int', 'pos': 'int',
+        'width': 'int', 'height': 'int', 'depth': 'int', 'x': 'int', 'y': 'int', 'z': 'int',
+        'row': 'int', 'col': 'int', 'rows': 'int', 'cols': 'int', 'port': 'int',
+        # Float-like names
+        'alpha': 'double', 'beta': 'double', 'gamma': 'double', 'delta': 'double',
+        'mu': 'double', 'sigma': 'double', 'lambd': 'double', 'lambda_': 'double',
+        'rate': 'double', 'ratio': 'double', 'scale': 'double', 'weight': 'double',
+        'probability': 'double', 'prob': 'double', 'threshold': 'double',
+        'min_val': 'double', 'max_val': 'double',
+        'temperature': 'double', 'temp': 'double', 'factor': 'double',
+        # Template-matching parameters (for generic functions with T_CONTAINER)
+        # These will be T when used with a T_CONTAINER parameter
+        'value': 'T_ELEMENT', 'val': 'T_ELEMENT', 'item': 'T_ELEMENT', 'element': 'T_ELEMENT',
+        'target': 'T_ELEMENT', 'needle': 'T_ELEMENT', 'search': 'T_ELEMENT',
+        # String-like names
+        'name': 'std::string', 'text': 'std::string', 'msg': 'std::string', 'message': 'std::string',
+        'path': 'std::string', 'filename': 'std::string', 'file': 'std::string', 'dir': 'std::string',
+        'url': 'std::string', 'key': 'std::string', 'prefix': 'std::string', 'suffix': 'std::string',
+        'pattern': 'std::string', 'format': 'std::string', 'fmt': 'std::string',
+        'title': 'std::string', 'label': 'std::string', 'description': 'std::string', 'desc': 'std::string',
+        'content': 'std::string', 'data': 'std::string', 'input': 'std::string', 'output': 'std::string',
+        's': 'std::string', 'str': 'std::string', 'string': 'std::string', 'line': 'std::string',
+        'sep': 'std::string', 'delimiter': 'std::string', 'delim': 'std::string',
+        # Boolean-like names
+        'flag': 'bool', 'enabled': 'bool', 'disabled': 'bool', 'active': 'bool',
+        'is_valid': 'bool', 'is_empty': 'bool', 'success': 'bool', 'ok': 'bool',
+        'verbose': 'bool', 'quiet': 'bool', 'force': 'bool', 'recursive': 'bool',
+        # Container-like names - use T as template parameter marker
+        # These will trigger template generation for the containing function
+        'items': 'T_CONTAINER', 'elements': 'T_CONTAINER', 'values': 'T_CONTAINER',
+        'list': 'T_CONTAINER', 'lst': 'T_CONTAINER', 'array': 'T_CONTAINER',
+        'choices': 'T_CONTAINER', 'options': 'T_CONTAINER',
+        'population': 'T_CONTAINER', 'sample': 'T_CONTAINER',
+        'weights': 'std::vector<double>',
+    }
+
+    # Template parameter markers - functions with these params become templates
+    TEMPLATE_MARKER = 'T_CONTAINER'
+    TEMPLATE_ELEMENT = 'T_ELEMENT'  # For parameters that match container element type
+
     def __init__(self):
         self.imports: Set[str] = set()
         self.forward_decls: Set[str] = set()
@@ -267,6 +372,7 @@ class PythonToCppConverter:
         self.warnings: List[str] = []
         self.python_imports: Set[str] = set()
         self.seeded_rngs: Dict[str, str] = {}  # var_name -> seed expression
+        self.var_types: Dict[str, str] = {}  # Variable name -> C++ type tracking
 
     def convert(self, source: str, module_name: str) -> Tuple[str, str]:
         """Convert Python source to C++ (.cpp and .h content)."""
@@ -276,6 +382,7 @@ class PythonToCppConverter:
         self.warnings = []
         self.python_imports = set()
         self.seeded_rngs = {}
+        self.var_types = {}
 
         try:
             tree = ast.parse(source)
@@ -392,6 +499,78 @@ class PythonToCppConverter:
             constructors=constructors
         )
 
+    def _infer_param_type(self, param_name: str, func_node) -> str:
+        """Infer C++ type from parameter name and usage patterns."""
+        # Check direct name hints
+        if param_name in self.PARAM_TYPE_HINTS:
+            return self.PARAM_TYPE_HINTS[param_name]
+
+        # Check partial matches (e.g., 'file_name' contains 'name')
+        param_lower = param_name.lower()
+        for hint_name, hint_type in self.PARAM_TYPE_HINTS.items():
+            if hint_name in param_lower or param_lower.endswith('_' + hint_name):
+                return hint_type
+
+        # Analyze how the parameter is used in the function body
+        inferred = self._analyze_param_usage(param_name, func_node)
+        if inferred and inferred != 'auto':
+            return inferred
+
+        # Default: use auto (will become template)
+        return 'auto'
+
+    def _analyze_param_usage(self, param_name: str, func_node) -> str:
+        """Analyze how a parameter is used to infer its type."""
+        for node in ast.walk(func_node):
+            # Check if used in comparison with numeric literal
+            if isinstance(node, ast.Compare):
+                left = node.left
+                if isinstance(left, ast.Name) and left.id == param_name:
+                    for comp in node.comparators:
+                        if isinstance(comp, ast.Constant):
+                            if isinstance(comp.value, int):
+                                return 'int'
+                            elif isinstance(comp.value, float):
+                                return 'double'
+
+            # Check if used in arithmetic operations
+            if isinstance(node, ast.BinOp):
+                left = node.left
+                right = node.right
+                if (isinstance(left, ast.Name) and left.id == param_name) or \
+                   (isinstance(right, ast.Name) and right.id == param_name):
+                    if isinstance(node.op, (ast.Add, ast.Sub, ast.Mult, ast.Div, ast.Mod)):
+                        # Check if other operand hints at type
+                        other = right if isinstance(left, ast.Name) and left.id == param_name else left
+                        if isinstance(other, ast.Constant):
+                            if isinstance(other.value, float):
+                                return 'double'
+                            elif isinstance(other.value, int):
+                                return 'int'
+
+            # Check if used in string operations
+            if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
+                left = node.left
+                right = node.right
+                if isinstance(left, ast.Name) and left.id == param_name:
+                    if isinstance(right, ast.Constant) and isinstance(right.value, str):
+                        return 'std::string'
+                if isinstance(right, ast.Name) and right.id == param_name:
+                    if isinstance(left, ast.Constant) and isinstance(left.value, str):
+                        return 'std::string'
+
+            # Check if used in subscript (likely a container)
+            if isinstance(node, ast.Subscript):
+                if isinstance(node.value, ast.Name) and node.value.id == param_name:
+                    return 'auto'  # Container, will become template
+
+            # Check if used in for loop iteration
+            if isinstance(node, ast.For):
+                if isinstance(node.iter, ast.Name) and node.iter.id == param_name:
+                    return 'auto'  # Iterable, will become template
+
+        return 'auto'
+
     def _convert_function(self, node, is_method: bool = False) -> FunctionInfo:
         decorators = []
         is_static = False
@@ -414,8 +593,11 @@ class PythonToCppConverter:
             if arg.annotation:
                 param_type = self._convert_type_annotation(arg.annotation)
             else:
-                param_type = 'auto'
+                # Use smart type inference
+                param_type = self._infer_param_type(arg.arg, node)
             params.append((arg.arg, param_type))
+            # Track parameter types for use in body conversion
+            self.var_types[arg.arg] = param_type
 
         if node.returns:
             return_type = self._convert_type_annotation(node.returns)
@@ -590,6 +772,82 @@ class PythonToCppConverter:
                 return self._infer_type(stmt.value)
         return 'void'
 
+    def _track_for_loop_var_type(self, var_name: str, iter_node) -> None:
+        """Track the type of a for loop variable based on the iterable."""
+        iter_type = self._infer_type(iter_node)
+
+        # Extract element type from container types
+        if '<' in iter_type and '>' in iter_type:
+            element_type = iter_type[iter_type.find('<')+1:iter_type.rfind('>')]
+            self.var_types[var_name] = element_type
+        elif 'string' in iter_type.lower():
+            # Iterating over string gives char
+            self.var_types[var_name] = 'char'
+        elif isinstance(iter_node, ast.Name):
+            # Check if iterable is a known variable
+            known_type = self.var_types.get(iter_node.id, '')
+            if '<' in known_type and '>' in known_type:
+                element_type = known_type[known_type.find('<')+1:known_type.rfind('>')]
+                self.var_types[var_name] = element_type
+            elif 'string' in known_type.lower():
+                self.var_types[var_name] = 'std::string'
+            else:
+                self.var_types[var_name] = 'auto'
+        else:
+            self.var_types[var_name] = 'auto'
+
+    def _is_string_expr(self, node, expr: str) -> bool:
+        """Check if an expression evaluates to a string type.
+
+        This prevents wrapping string values in std::to_string() in f-strings.
+        """
+        # Check obvious string indicators in converted expression
+        if any(x in expr for x in ['"', '.c_str()', 'std::string', '_str']):
+            return True
+
+        # Check if it's a string literal constant
+        if isinstance(node, ast.Constant) and isinstance(node.value, str):
+            return True
+
+        # Check if it's a variable we know is a string
+        if isinstance(node, ast.Name):
+            var_name = node.id
+            var_type = self.var_types.get(var_name, '')
+            if 'string' in var_type.lower() or var_type == 'std::string':
+                return True
+            # Check if variable name suggests string type
+            if var_name in self.PARAM_TYPE_HINTS:
+                if 'string' in self.PARAM_TYPE_HINTS[var_name].lower():
+                    return True
+            # Common string variable names
+            string_names = {'name', 'text', 'msg', 'message', 'path', 'url', 'title',
+                           'label', 'description', 'content', 'data', 'line', 's', 'str',
+                           'item', 'key', 'value', 'word', 'char', 'prefix', 'suffix',
+                           'filename', 'file', 'dir', 'result', 'output', 'input'}
+            if var_name.lower() in string_names or any(var_name.lower().endswith('_' + n) for n in string_names):
+                return True
+
+        # Check string method calls like .upper(), .strip(), etc.
+        if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute):
+            string_methods = {'upper', 'lower', 'strip', 'lstrip', 'rstrip', 'title',
+                             'capitalize', 'replace', 'format', 'join', 'split',
+                             'encode', 'decode', 'center', 'ljust', 'rjust'}
+            if node.func.attr in string_methods:
+                return True
+
+        # Check attribute access that returns string (like .name, .path)
+        if isinstance(node, ast.Attribute):
+            string_attrs = {'name', 'path', 'filename', 'text', 'message', 'value'}
+            if node.attr in string_attrs:
+                return True
+
+        # Check inferred type
+        inferred_type = self._infer_type(node)
+        if 'string' in inferred_type.lower():
+            return True
+
+        return False
+
     def _convert_body(self, stmts: List, indent: int = 1) -> str:
         lines = []
         ind = '    ' * indent
@@ -637,6 +895,8 @@ class PythonToCppConverter:
                     value_str = self._convert_expr(stmt.value)
                     var_type = self._infer_type(stmt.value)
                     if isinstance(target, ast.Name):
+                        # Track this variable's type
+                        self.var_types[target.id] = var_type
                         lines.append(f'{ind}{var_type} {target_str} = {value_str};')
                     else:
                         lines.append(f'{ind}{target_str} = {value_str};')
@@ -644,6 +904,9 @@ class PythonToCppConverter:
         elif isinstance(stmt, ast.AnnAssign):
             target_str = self._convert_expr(stmt.target)
             var_type = self._convert_type_annotation(stmt.annotation)
+            # Track annotated variable types
+            if isinstance(stmt.target, ast.Name):
+                self.var_types[stmt.target.id] = var_type
             if stmt.value:
                 value_str = self._convert_expr(stmt.value)
                 lines.append(f'{ind}{var_type} {target_str} = {value_str};')
@@ -657,8 +920,17 @@ class PythonToCppConverter:
             lines.append(f'{ind}{target_str} {op}= {value_str};')
 
         elif isinstance(stmt, ast.Expr):
-            expr_str = self._convert_expr(stmt.value)
-            lines.append(f'{ind}{expr_str};')
+            # Check if this is a docstring (string literal expression) - convert to comment
+            if isinstance(stmt.value, ast.Constant) and isinstance(stmt.value.value, str):
+                docstring = stmt.value.value.strip()
+                if docstring:
+                    # Convert to C++ comment (take first line only for brevity)
+                    first_line = docstring.split('\n')[0].strip()
+                    if first_line:
+                        lines.append(f'{ind}// {first_line}')
+            else:
+                expr_str = self._convert_expr(stmt.value)
+                lines.append(f'{ind}{expr_str};')
 
         elif isinstance(stmt, ast.If):
             test = self._convert_expr(stmt.test)
@@ -697,6 +969,7 @@ class PythonToCppConverter:
                 elif iter_expr.func.id == 'enumerate':
                     # Handle enumerate(items, start=N)
                     args = iter_expr.args
+                    iterable_node = args[0] if args else None
                     iterable = self._convert_expr(args[0]) if args else 'items'
                     start_idx = '0'
                     # Check for start keyword arg
@@ -709,6 +982,32 @@ class PythonToCppConverter:
                     if isinstance(stmt.target, ast.Tuple) and len(stmt.target.elts) == 2:
                         idx_name = self._convert_expr(stmt.target.elts[0])
                         item_name = self._convert_expr(stmt.target.elts[1])
+
+                        # Track variable types for the loop variables
+                        self.var_types[idx_name] = 'size_t'
+
+                        # Infer item type from the iterable
+                        if iterable_node:
+                            iterable_type = self._infer_type(iterable_node)
+                            # Extract element type from container (e.g., std::vector<std::string> -> std::string)
+                            if '<' in iterable_type and '>' in iterable_type:
+                                element_type = iterable_type[iterable_type.find('<')+1:iterable_type.rfind('>')]
+                                self.var_types[item_name] = element_type
+                            else:
+                                # Check if the iterable is a known variable
+                                if isinstance(iterable_node, ast.Name):
+                                    var_type = self.var_types.get(iterable_node.id, '')
+                                    if 'string' in var_type.lower():
+                                        self.var_types[item_name] = 'std::string'
+                                    elif var_type == self.TEMPLATE_MARKER or 'std::vector' in var_type:
+                                        self.var_types[item_name] = 'auto'
+                                    else:
+                                        self.var_types[item_name] = 'auto'
+                                else:
+                                    self.var_types[item_name] = 'auto'
+                        else:
+                            self.var_types[item_name] = 'auto'
+
                         lines.append(f'{ind}size_t {idx_name} = {start_idx};')
                         lines.append(f'{ind}for (auto& {item_name} : {iterable}) {{')
                         # Add index increment at end of loop body
@@ -720,12 +1019,21 @@ class PythonToCppConverter:
                     else:
                         # Fallback: just iterate
                         iter_str = self._convert_expr(iter_expr)
+                        # Track loop variable type from iterable
+                        if isinstance(stmt.target, ast.Name):
+                            self._track_for_loop_var_type(stmt.target.id, iter_expr)
                         lines.append(f'{ind}for (auto& {target} : {iter_str}) {{')
                 else:
                     iter_str = self._convert_expr(iter_expr)
+                    # Track loop variable type from iterable
+                    if isinstance(stmt.target, ast.Name):
+                        self._track_for_loop_var_type(stmt.target.id, iter_expr)
                     lines.append(f'{ind}for (auto& {target} : {iter_str}) {{')
             else:
                 iter_str = self._convert_expr(iter_expr)
+                # Track loop variable type from iterable
+                if isinstance(stmt.target, ast.Name):
+                    self._track_for_loop_var_type(stmt.target.id, iter_expr)
                 lines.append(f'{ind}for (auto& {target} : {iter_str}) {{')
 
             lines.extend(self._convert_stmt_list(stmt.body, indent + 1))
@@ -962,14 +1270,24 @@ class PythonToCppConverter:
             elif func == 'abs':
                 return f'std::abs({_safe_arg(args, 0)})'
             elif func == 'min':
+                self.imports.add('<algorithm>')
                 if len(args) == 2:
                     return f'std::min({_safe_arg(args, 0)}, {_safe_arg(args, 1)})'
+                elif len(args) == 1:
+                    # Single container argument - use min_element
+                    arg0 = _safe_arg(args, 0)
+                    return f'*std::min_element({arg0}.begin(), {arg0}.end())'
                 elif args:
                     return f'std::min({{{", ".join(args)}}})'
                 return '0 /* min() requires arguments */'
             elif func == 'max':
+                self.imports.add('<algorithm>')
                 if len(args) == 2:
                     return f'std::max({_safe_arg(args, 0)}, {_safe_arg(args, 1)})'
+                elif len(args) == 1:
+                    # Single container argument - use max_element
+                    arg0 = _safe_arg(args, 0)
+                    return f'*std::max_element({arg0}.begin(), {arg0}.end())'
                 elif args:
                     return f'std::max({{{", ".join(args)}}})'
                 return '0 /* max() requires arguments */'
@@ -1239,8 +1557,9 @@ class PythonToCppConverter:
                 elif isinstance(value, ast.FormattedValue):
                     # {expr} part - convert to std::to_string or direct if already string
                     expr = self._convert_expr(value.value)
-                    # Check if it's likely a string already
-                    if any(x in expr for x in ['\"', '.c_str()', 'std::string']):
+                    # Check if it's a string type (no std::to_string needed)
+                    is_string_type = self._is_string_expr(value.value, expr)
+                    if is_string_type:
                         parts.append(expr)
                     else:
                         parts.append(f'std::to_string({expr})')
@@ -1304,10 +1623,83 @@ class PythonToCppConverter:
     def _format_params(self, params: List[Tuple[str, str]]) -> str:
         return ', '.join(f'{ptype} {pname}' for pname, ptype in params)
 
-    def _format_params_with_const_ref(self, params: List[Tuple[str, str]]) -> str:
+    def _needs_template(self, params: List[Tuple[str, str]]) -> bool:
+        """Check if any parameter requires a template (has T_CONTAINER or T_ELEMENT type)."""
+        return any(ptype in (self.TEMPLATE_MARKER, self.TEMPLATE_ELEMENT) for _, ptype in params)
+
+    def _has_container_param(self, params: List[Tuple[str, str]]) -> bool:
+        """Check if params include a T_CONTAINER (useful for element type matching)."""
+        return any(ptype == self.TEMPLATE_MARKER for _, ptype in params)
+
+    def _get_template_return_type(self, return_type: str, body: str, params: List[Tuple[str, str]]) -> str:
+        """Determine the proper return type for a template function."""
+        # If return type is already explicit, use it
+        if return_type not in ('auto', 'void'):
+            return return_type
+        if return_type == 'void':
+            return 'void'
+
+        # Get container parameter names
+        container_params = [pname for pname, ptype in params if ptype == self.TEMPLATE_MARKER]
+
+        # Check if body returns one of the container parameters (e.g., shuffle_list returns items)
+        # Look for patterns like "return items" where items is a container param
+        for pname in container_params:
+            if re.search(rf'\breturn\s+{re.escape(pname)}\b', body):
+                return 'std::vector<T>'
+
+        # Default to T for functions that return an element
+        return 'T'
+
+    def _generate_explicit_instantiation(self, func_name: str, params: List[Tuple[str, str]],
+                                          return_type: str, class_name: str = None,
+                                          const: str = '') -> List[str]:
+        """Generate explicit template instantiations for common types."""
+        lines = ['// Explicit instantiations']
+
+        has_element_param = any(ptype == self.TEMPLATE_ELEMENT for _, ptype in params)
+
+        for cpp_type in ['int', 'double', 'std::string']:
+            # Build parameter list for instantiation
+            inst_params = []
+            for pname, ptype in params:
+                if ptype == self.TEMPLATE_MARKER:
+                    inst_params.append(f'const std::vector<{cpp_type}>&')
+                elif ptype == self.TEMPLATE_ELEMENT:
+                    inst_params.append(f'const {cpp_type}&')
+                # Skip non-template params in explicit instantiation signature
+
+            params_str = ', '.join(inst_params)
+
+            # Determine return type for instantiation
+            if return_type == 'std::vector<T>':
+                inst_ret = f'std::vector<{cpp_type}>'
+            elif return_type == 'T':
+                inst_ret = cpp_type
+            else:
+                inst_ret = return_type
+
+            if class_name:
+                lines.append(f'template {inst_ret} {class_name}::{func_name}<{cpp_type}>({params_str}){const};')
+            else:
+                lines.append(f'template {inst_ret} {func_name}<{cpp_type}>({params_str});')
+
+        return lines
+
+    def _format_params_with_const_ref(self, params: List[Tuple[str, str]], use_template: bool = False) -> str:
+        has_container = self._has_container_param(params)
         result = []
         for pname, ptype in params:
-            if ptype in ('std::string', 'std::vector', 'std::unordered_map', 'std::unordered_set') or ptype.startswith('std::'):
+            # Handle template container marker
+            if ptype == self.TEMPLATE_MARKER:
+                result.append(f'const std::vector<T>& {pname}')
+            # Handle template element marker - only becomes T if there's also a container param
+            elif ptype == self.TEMPLATE_ELEMENT:
+                if has_container:
+                    result.append(f'const T& {pname}')
+                else:
+                    result.append(f'double {pname}')  # Fallback to double if no container context
+            elif ptype in ('std::string', 'std::vector', 'std::unordered_map', 'std::unordered_set') or ptype.startswith('std::'):
                 result.append(f'const {ptype}& {pname}')
             else:
                 result.append(f'{ptype} {pname}')
@@ -1346,7 +1738,25 @@ class PythonToCppConverter:
                 lines.append(f'class {cls.name} {{')
             lines.append('public:')
 
-            for fname, ftype, _ in cls.fields:
+            for fname, ftype, fval in cls.fields:
+                # 'auto' is invalid for class members - infer from value or use default
+                if ftype == 'auto':
+                    if fval:
+                        # Try to infer from the default value expression
+                        if fval.startswith('"') or fval.startswith("'"):
+                            ftype = 'std::string'
+                        elif fval in ('true', 'false'):
+                            ftype = 'bool'
+                        elif '.' in fval and fval.replace('.', '').replace('-', '').isdigit():
+                            ftype = 'double'
+                        elif fval.lstrip('-').isdigit():
+                            ftype = 'int'
+                        elif fval.startswith('{') or fval.startswith('std::vector'):
+                            ftype = 'std::vector<int>'
+                        else:
+                            ftype = 'int'  # Default fallback
+                    else:
+                        ftype = 'int'  # Default for uninitialized
                 lines.append(f'    {ftype} {fname};')
 
             if cls.fields:
@@ -1360,14 +1770,26 @@ class PythonToCppConverter:
                 params = self._format_params_with_const_ref(method.params)
                 static = 'static ' if method.is_static else ''
                 const = ' const' if method.is_const else ''
-                lines.append(f'    {static}{method.return_type} {method.name}({params}){const};')
+                # Add template prefix if method uses generic containers
+                if self._needs_template(method.params):
+                    lines.append(f'    template<typename T>')
+                    ret_type = self._get_template_return_type(method.return_type, method.body, method.params)
+                    lines.append(f'    {static}{ret_type} {method.name}({params}){const};')
+                else:
+                    lines.append(f'    {static}{method.return_type} {method.name}({params}){const};')
 
             lines.append('};')
             lines.append('')
 
         for func in functions:
             params = self._format_params_with_const_ref(func.params)
-            lines.append(f'{func.return_type} {func.name}({params});')
+            # Add template prefix if function uses generic containers
+            if self._needs_template(func.params):
+                lines.append('template<typename T>')
+                ret_type = self._get_template_return_type(func.return_type, func.body, func.params)
+                lines.append(f'{ret_type} {func.name}({params});')
+            else:
+                lines.append(f'{func.return_type} {func.name}({params});')
 
         lines.append('')
         lines.append('} // namespace includecpp')
@@ -1588,16 +2010,39 @@ class PythonToCppConverter:
             for method in cls.methods:
                 params = self._format_params_with_const_ref(method.params)
                 const = ' const' if method.is_const else ''
-                lines.append(f'{method.return_type} {cls.name}::{method.name}({params}){const} {{')
+                # Add template prefix if method uses generic containers
+                if self._needs_template(method.params):
+                    lines.append('template<typename T>')
+                    ret_type = self._get_template_return_type(method.return_type, method.body, method.params)
+                    lines.append(f'{ret_type} {cls.name}::{method.name}({params}){const} {{')
+                else:
+                    lines.append(f'{method.return_type} {cls.name}::{method.name}({params}){const} {{')
                 lines.append(method.body)
                 lines.append('}')
+                # Add explicit template instantiations for common types
+                if self._needs_template(method.params):
+                    ret_type = self._get_template_return_type(method.return_type, method.body, method.params)
+                    inst_lines = self._generate_explicit_instantiation(
+                        method.name, method.params, ret_type, cls.name, const)
+                    lines.extend(inst_lines)
                 lines.append('')
 
         for func in functions:
             params = self._format_params_with_const_ref(func.params)
-            lines.append(f'{func.return_type} {func.name}({params}) {{')
+            # Add template prefix if function uses generic containers
+            if self._needs_template(func.params):
+                lines.append('template<typename T>')
+                ret_type = self._get_template_return_type(func.return_type, func.body, func.params)
+                lines.append(f'{ret_type} {func.name}({params}) {{')
+            else:
+                lines.append(f'{func.return_type} {func.name}({params}) {{')
             lines.append(func.body)
             lines.append('}')
+            # Add explicit template instantiations for common types
+            if self._needs_template(func.params):
+                ret_type = self._get_template_return_type(func.return_type, func.body, func.params)
+                inst_lines = self._generate_explicit_instantiation(func.name, func.params, ret_type)
+                lines.extend(inst_lines)
             lines.append('')
 
         lines.append('} // namespace includecpp')
@@ -1608,6 +2053,7 @@ class PythonToCppConverter:
 class CppToPythonConverter:
     def __init__(self):
         self.indent = '    '
+        self._current_class_fields = set()  # Track fields for self. prefix
 
     def convert(self, source: str, module_name: str) -> str:
         """Convert C++ source to Python."""
@@ -1737,8 +2183,9 @@ class CppToPythonConverter:
             body = match.group(3)
 
             fields = self._parse_class_fields(body)
-            methods = self._parse_class_methods(body, name)
-            constructors = self._parse_constructors(body, name)
+            field_names = {f[0] for f in fields}  # Extract field names for self. prefix
+            methods = self._parse_class_methods(body, name, field_names)
+            constructors = self._parse_constructors(body, name, field_names)
 
             classes.append(ClassInfo(
                 name=name,
@@ -1748,6 +2195,9 @@ class CppToPythonConverter:
                 constructors=constructors
             ))
 
+            # Clear class fields after processing this class
+            self._current_class_fields = set()
+
         return classes
 
     def _parse_structs(self, source: str) -> List[StructInfo]:
@@ -1814,11 +2264,31 @@ class CppToPythonConverter:
 
     def _parse_class_fields(self, body: str) -> List[Tuple[str, str, Optional[str]]]:
         fields = []
+        all_field_names = set()  # v3.4.1: Track ALL fields for self. prefix
 
+        # v3.4.1: Parse fields from ALL sections (public, private, protected)
+        # for self. prefix detection, but only return public fields for dataclass
         sections = re.split(r'(?:public|private|protected)\s*:', body)
-        public_section = sections[1] if len(sections) > 1 else body
 
         field_pattern = r'(\w+(?:<[^>]+>)?)\s+(\w+)\s*(?:=\s*([^;]+))?\s*;'
+
+        # First pass: collect ALL field names from all sections
+        for section in sections:
+            for match in re.finditer(field_pattern, section):
+                field_type = match.group(1)
+                field_name = match.group(2)
+
+                if '(' in field_type or field_type in ('return', 'if', 'for', 'while'):
+                    continue
+
+                all_field_names.add(field_name)
+
+        # Store all field names for self. prefix detection
+        self._current_class_fields = all_field_names
+
+        # Second pass: return only public fields for the Python class definition
+        public_section = sections[1] if len(sections) > 1 else body
+
         for match in re.finditer(field_pattern, public_section):
             field_type = match.group(1)
             field_name = match.group(2)
@@ -1832,9 +2302,13 @@ class CppToPythonConverter:
 
         return fields
 
-    def _parse_class_methods(self, body: str, class_name: str) -> List[FunctionInfo]:
+    def _parse_class_methods(self, body: str, class_name: str, field_names: set = None) -> List[FunctionInfo]:
         methods = []
 
+        # Set current class fields for self. prefix during body conversion
+        if field_names:
+            self._current_class_fields = field_names
+
         pattern = r'(?:(static|virtual)\s+)?(\w+(?:<[^>]+>)?(?:\s*[*&])?)\s+(\w+)\s*\(([^)]*)\)\s*(const)?\s*(?:\{([^{}]*(?:\{[^{}]*\}[^{}]*)*)\}|;)'
 
         for match in re.finditer(pattern, body):
@@ -1863,9 +2337,13 @@ class CppToPythonConverter:
 
         return methods
 
-    def _parse_constructors(self, body: str, class_name: str) -> List[FunctionInfo]:
+    def _parse_constructors(self, body: str, class_name: str, field_names: set = None) -> List[FunctionInfo]:
         constructors = []
 
+        # Set current class fields for self. prefix during body conversion
+        if field_names:
+            self._current_class_fields = field_names
+
         pattern = rf'{class_name}\s*\(([^)]*)\)\s*(?::\s*[^{{]+)?\s*\{{([^{{}}]*(?:\{{[^{{}}]*\}}[^{{}}]*)*)\}}'
 
         for match in re.finditer(pattern, body):
@@ -2101,18 +2579,20 @@ class CppToPythonConverter:
             if var_name not in ('if', 'for', 'while', 'return'):
                 return f'{var_name} = {self._get_default_value(var_type)}'
 
-        # Assignment
-        assign_match = re.match(r'(\w+(?:\.\w+)*(?:\[[^\]]+\])?)\s*=\s*(.+)$', stmt)
+        # Assignment - v3.3.22: Expanded pattern to capture -> and ::
+        assign_match = re.match(r'([a-zA-Z_][\w:>-]*(?:->|\.)?[a-zA-Z_][\w]*(?:\[[^\]]+\])?)\s*=\s*(.+)$', stmt)
         if assign_match:
             target = assign_match.group(1)
-            target = target.replace('this->', 'self.')
+            # v3.3.22: Apply full expression conversion to target as well
+            target = self._convert_cpp_expr(target)
             value = self._convert_cpp_expr(assign_match.group(2))
             return f'{target} = {value}'
 
         # Augmented assignment
         aug_match = re.match(r'(\w+(?:\.\w+)*)\s*(\+\+|--|\+=|-=|\*=|/=)', stmt)
         if aug_match:
-            target = aug_match.group(1).replace('this->', 'self.')
+            # v3.3.22: Apply full expression conversion to target
+            target = self._convert_cpp_expr(aug_match.group(1))
             op = aug_match.group(2)
             if op == '++':
                 return f'{target} += 1'
@@ -2172,6 +2652,32 @@ class CppToPythonConverter:
         expr = re.sub(r'std::min\(([^,]+),\s*([^)]+)\)', r'min(\1, \2)', expr)
         expr = re.sub(r'std::max\(([^,]+),\s*([^)]+)\)', r'max(\1, \2)', expr)
 
+        # Handle std::accumulate(container.begin(), container.end(), init) -> sum(container) [+ init]
+        # v3.4.1: Also handle accumulate without std:: prefix
+        def _accumulate_to_sum(m):
+            container = m.group(1)
+            init_val = m.group(2).strip()
+            if init_val == '0' or init_val == '0.0':
+                return f'sum({container})'
+            return f'sum({container}) + {init_val}'
+        expr = re.sub(r'(?:std::)?accumulate\((\w+)\.begin\(\),\s*\1\.end\(\),\s*([^)]+)\)', _accumulate_to_sum, expr)
+
+        # v3.4.1: Handle std::find, std::count, std::sort with .begin()/.end()
+        # std::find(vec.begin(), vec.end(), val) -> val in vec
+        expr = re.sub(r'(?:std::)?find\((\w+)\.begin\(\),\s*\1\.end\(\),\s*([^)]+)\)\s*!=\s*\1\.end\(\)', r'\2 in \1', expr)
+        # std::count(vec.begin(), vec.end(), val) -> vec.count(val)
+        expr = re.sub(r'(?:std::)?count\((\w+)\.begin\(\),\s*\1\.end\(\),\s*([^)]+)\)', r'\1.count(\2)', expr)
+        # std::sort(vec.begin(), vec.end()) -> vec.sort()
+        expr = re.sub(r'(?:std::)?sort\((\w+)\.begin\(\),\s*\1\.end\(\)\)', r'\1.sort()', expr)
+        # std::reverse(vec.begin(), vec.end()) -> vec.reverse()
+        expr = re.sub(r'(?:std::)?reverse\((\w+)\.begin\(\),\s*\1\.end\(\)\)', r'\1.reverse()', expr)
+
+        # v3.4.1: Clean up any remaining .begin()/.end() that couldn't be converted
+        # container.begin() -> iter(container) for iteration context
+        # But typically these are errors - flag as comment if they remain
+        expr = re.sub(r'(\w+)\.begin\(\)', r'\1[0]', expr)  # Approximate as first element
+        expr = re.sub(r'(\w+)\.end\(\)', r'len(\1)', expr)  # Approximate as length
+
         # Handle .size() -> len()
         expr = re.sub(r'(\w+)\.size\(\)', r'len(\1)', expr)
 
@@ -2209,27 +2715,53 @@ class CppToPythonConverter:
         # Handle negation !
         expr = re.sub(r'!(\w)', r'not \1', expr)
 
+        # v3.3.22: Add self. prefix for class member access (when not already prefixed)
+        if self._current_class_fields:
+            for field in self._current_class_fields:
+                # Match field name that's not already prefixed with self. or another identifier
+                # Fixed lookahead to be more permissive - match non-word chars or end
+                expr = re.sub(rf'(?<![.\w])(?<!self\.){re.escape(field)}(?=\W|$)', f'self.{field}', expr)
+
+        # v3.4.1: Handle common C++ member naming conventions
+        # Convert m_name to self.name when in class context
+        if self._current_class_fields:
+            # Convert m_xxx to self.xxx
+            expr = re.sub(r'(?<![.\w])m_(\w+)(?=\W|$)', r'self.\1', expr)
+            # Convert _xxx to self.xxx (leading underscore)
+            expr = re.sub(r'(?<![.\w])_(\w+)(?=\W|$)', r'self.\1', expr)
+            # v3.4.1: Convert xxx_ to self.xxx_ (trailing underscore - Google style)
+            # Only if it's a known field or matches the pattern
+            for field in self._current_class_fields:
+                if field.endswith('_') and field not in ('self_',):
+                    expr = re.sub(rf'(?<![.\w]){re.escape(field)}(?=\W|$)', f'self.{field}', expr)
+
         return expr
 
     def _generate_struct(self, struct: StructInfo) -> List[str]:
         lines = ['@dataclass']
-        lines.append(f'class {struct.name}:')
+        # v3.4.1: Escape Python keywords and C++ reserved words in struct/class names
+        struct_name = _escape_identifier(struct.name)
+        lines.append(f'class {struct_name}:')
 
         if not struct.fields:
             lines.append(f'{self.indent}pass')
         else:
             for fname, ftype in struct.fields:
-                lines.append(f'{self.indent}{fname}: {ftype}')
+                # v3.4.1: Escape Python keywords and C++ reserved words in field names
+                escaped_fname = _escape_identifier(fname)
+                lines.append(f'{self.indent}{escaped_fname}: {ftype}')
 
         return lines
 
     def _generate_class(self, cls: ClassInfo) -> List[str]:
         lines = []
 
+        # v3.4.1: Escape Python keywords and C++ reserved words in class names
+        class_name = _escape_identifier(cls.name)
         if cls.bases:
-            lines.append(f'class {cls.name}({", ".join(cls.bases)}):')
+            lines.append(f'class {class_name}({", ".join(cls.bases)}):')
         else:
-            lines.append(f'class {cls.name}:')
+            lines.append(f'class {class_name}:')
 
         if not cls.fields and not cls.methods and not cls.constructors:
             lines.append(f'{self.indent}pass')
@@ -2251,16 +2783,19 @@ class CppToPythonConverter:
 
         params = ['self'] if not method.is_static else []
         for pname, ptype in method.params:
+            # v3.4.1: Escape Python keywords and C++ reserved words in parameter names
+            escaped_pname = _escape_identifier(pname)
             if ptype and ptype != 'Any':
-                params.append(f'{pname}: {ptype}')
+                params.append(f'{escaped_pname}: {ptype}')
             else:
-                params.append(pname)
+                params.append(escaped_pname)
 
         ret_type = ''
         if not is_init and method.return_type and method.return_type != 'None':
             ret_type = f' -> {method.return_type}'
 
-        method_name = '__init__' if is_init else method.name
+        # v3.4.1: Escape Python keywords and C++ reserved words in method names
+        method_name = '__init__' if is_init else _escape_identifier(method.name)
         lines.append(f'{self.indent}def {method_name}({", ".join(params)}){ret_type}:')
 
         body_lines = method.body.split('\n')
@@ -2277,16 +2812,20 @@ class CppToPythonConverter:
 
         params = []
         for pname, ptype in func.params:
+            # v3.4.1: Escape Python keywords and C++ reserved words in parameter names
+            escaped_pname = _escape_identifier(pname)
             if ptype and ptype != 'Any':
-                params.append(f'{pname}: {ptype}')
+                params.append(f'{escaped_pname}: {ptype}')
             else:
-                params.append(pname)
+                params.append(escaped_pname)
 
         ret_type = ''
         if func.return_type and func.return_type != 'None':
             ret_type = f' -> {func.return_type}'
 
-        lines.append(f'def {func.name}({", ".join(params)}){ret_type}:')
+        # v3.4.1: Escape Python keywords and C++ reserved words in function names
+        func_name = _escape_identifier(func.name)
+        lines.append(f'def {func_name}({", ".join(params)}){ret_type}:')
 
         body_lines = func.body.split('\n')
         if body_lines and body_lines[0].strip():