Phase 11.1a: Namespace function support (TMath, ROOT.Math, etc.)

Implement namespace function calls in DSL expressions:
- TMath.Pi(), TMath.Sin(x), TMath.Sqrt(x)
- ROOT.Math.VectorUtil.DeltaPhi(v1, v2)
- Support both Python (.) and C++ (::) syntax

Components:
- dsl_compiler.py: Preprocess :: to . for AST parsing
  - Preserves :: inside strings and brackets (slice syntax)
- ir_builder.py: Namespace detection and CallNode building
  - _extract_namespace_chain(): Identify namespace vs method calls
  - _build_namespace_call(): Create CallNode with namespace info
  - Correctly disambiguates track.Pt() (method) vs TMath.Pi() (namespace)
- backend_cpp.py: Generate qualified C++ names and headers
  - TMath::Sqrt, ROOT::Math::VectorUtil::DeltaPhi
  - Adds appropriate headers (<TMath.h>, etc.)
- constants.py: KNOWN_NAMESPACES, NAMESPACE_HEADERS, NAMESPACE_FUNCTION_TYPES

LIMITATION: Scalar functions on vectors not yet supported.
TMath.Sqrt(RVec<double>) fails - requires Phase 11.1b.
Use sqrt(pt) with ADL for vectorized operations until then.

Tests: 722 passed, 1 skipped

Author: miranov25

UTILS/dfextensions/RDataFrameDSL/RDataFrameDSL/backend_cpp.py

@@ -64,6 +64,7 @@
     SubscriptNode, SliceNode, UnaryOp, BinaryOp, RVecSliceNode, SliceKind
 )
 from .ir_errors import IRError, IRErrorKind
+from .constants import NAMESPACE_HEADERS  # Phase 11.1
 
 __all__ = [
     'CppCodeGenerator',
@@ -1201,8 +1202,21 @@ def _cpp_function_name(self, node: CallNode) -> str:
         # === PHASE 9: For RVec operations, use unqualified names to enable ADL ===
         # ROOT provides vectorized functions like sqrt, sin, cos via ROOT::VecOps
         # ADL (Argument Dependent Lookup) finds them when arguments are ROOT::RVec
+        # Note: This applies to std:: functions but NOT TMath:: (which need explicit namespace)
         if node.rank > 0:
-            # Use unqualified name for ADL with RVec
+            # Phase 11.1: For non-std namespace functions (like TMath::Sin), preserve the namespace
+            # cpp_name contains full qualified name for namespace functions
+            is_std_function = (node.namespace == "std" or 
+                              (node.cpp_name and node.cpp_name.startswith("std::")))
+            
+            if not is_std_function and (node.namespace or node.cpp_name):
+                # Non-std namespace function - use cpp_name which has proper qualification
+                if node.cpp_name:
+                    return node.cpp_name
+                if node.namespace:
+                    return f"{node.namespace}::{node.func}"
+            
+            # Standard math functions - use unqualified name for ADL
             func_name = node.func
             if "." in func_name:
                 func_name = func_name.replace(".", "::")
@@ -1211,8 +1225,7 @@ def _cpp_function_name(self, node: CallNode) -> str:
 
         # Check custom cpp_name first - it takes priority
         if node.cpp_name:
-            # cpp_name already contains full qualified name (e.g., "std::sqrt")
-            # Don't add namespace again even if node.namespace is set
+            # cpp_name already contains full qualified name (e.g., "std::sqrt", "TMath::Sin")
             return node.cpp_name
 
         # Check if it's a namespaced function (e.g., TMath.Gaus)
@@ -1256,6 +1269,20 @@ def _collect_headers(self, ir: IRNode) -> List[str]:
                 # Add headers from node itself
                 if node.headers:
                     headers.update(node.headers)
+                
+                # Phase 11.1: Add namespace headers
+                if node.namespace:
+                    # Convert C++ namespace back to dot notation for lookup
+                    ns_dot = node.namespace.replace("::", ".")
+                    if ns_dot in NAMESPACE_HEADERS:
+                        headers.add(NAMESPACE_HEADERS[ns_dot])
+                    # Check parent namespaces
+                    parts = ns_dot.split(".")
+                    for i in range(len(parts), 0, -1):
+                        parent = ".".join(parts[:i])
+                        if parent in NAMESPACE_HEADERS:
+                            headers.add(NAMESPACE_HEADERS[parent])
+                            break
 
             elif isinstance(node, BinaryOpNode):
                 if node.op == BinaryOp.POW:

UTILS/dfextensions/RDataFrameDSL/RDataFrameDSL/constants.py

@@ -20,6 +20,10 @@
     'FUNCTION_CPP_NAMES',
     'CLASS_HEADERS',
     'SCALAR_TYPES',
+    # Phase 11.1: Namespace support
+    'KNOWN_NAMESPACES',
+    'NAMESPACE_HEADERS',
+    'NAMESPACE_FUNCTION_TYPES',
 ]
 
 
@@ -273,3 +277,71 @@
     "<TClass.h>",
     "<TDataMember.h>",
 ]
+
+
+# =============================================================================
+# Phase 11.1: Namespace Support
+# =============================================================================
+
+# Known ROOT/C++ namespaces (builtins)
+KNOWN_NAMESPACES: Set[str] = {
+    "TMath",
+    "ROOT",
+    "ROOT.Math",
+    "ROOT.Math.VectorUtil",
+    "ROOT.VecOps",
+    "std",
+}
+
+# Headers required for namespaces
+NAMESPACE_HEADERS: Dict[str, str] = {
+    "TMath": "<TMath.h>",
+    "ROOT.Math": "<Math/Vector4D.h>",
+    "ROOT.Math.VectorUtil": "<Math/VectorUtil.h>",
+    "ROOT.VecOps": "<ROOT/RVec.hxx>",
+    "std": "<cmath>",
+}
+
+# Return types for common namespace functions (explicit, no guessing)
+NAMESPACE_FUNCTION_TYPES: Dict[str, Dict[str, str]] = {
+    "TMath": {
+        "Pi": "double",
+        "E": "double",
+        "Sin": "double",
+        "Cos": "double",
+        "Tan": "double",
+        "ASin": "double",
+        "ACos": "double",
+        "ATan": "double",
+        "ATan2": "double",
+        "Sqrt": "double",
+        "Exp": "double",
+        "Log": "double",
+        "Log10": "double",
+        "Abs": "double",
+        "Power": "double",
+        "Min": "double",
+        "Max": "double",
+        "Sign": "double",
+        "Gaus": "double",
+        "BreitWigner": "double",
+        "Landau": "double",
+        "TwoPi": "double",
+        "PiOver2": "double",
+        "PiOver4": "double",
+        "DegToRad": "double",
+        "RadToDeg": "double",
+        "Hypot": "double",
+        "Range": "double",
+        "Floor": "double",
+        "Ceil": "double",
+        "Nint": "int",
+    },
+    "ROOT.Math.VectorUtil": {
+        "DeltaPhi": "double",
+        "DeltaR": "double",
+        "CosTheta": "double",
+        "Angle": "double",
+        "InvariantMass": "double",
+    },
+}

UTILS/dfextensions/RDataFrameDSL/RDataFrameDSL/dsl_compiler.py

@@ -158,6 +158,62 @@ def __init__(self, schema: Dict[str, str], safe_indexing: bool = True):
         self._functions: Dict[str, GeneratedFunction] = {}
         self.library = FunctionLibrary()
 
+    def _preprocess_expression(self, expr: str) -> str:
+        """
+        Convert C++ :: notation to Python dot notation.
+        
+        Phase 11.1: Handles namespace syntax preprocessing before AST parsing.
+        
+        Handles:
+        - TMath::Pi() -> TMath.Pi()
+        - ROOT::Math::VectorUtil::DeltaPhi() -> ROOT.Math.VectorUtil.DeltaPhi()
+        
+        Skips:
+        - String literals to avoid corrupting "Error::Message"
+        - Square brackets to preserve slice syntax like pt[::-1]
+        
+        Args:
+            expr: DSL expression potentially with C++ :: notation
+            
+        Returns:
+            Expression with :: replaced by . (except in strings and brackets)
+        """
+        result = []
+        i = 0
+        in_string = False
+        string_char = None
+        bracket_depth = 0  # Track [] nesting for slice syntax
+        
+        while i < len(expr):
+            char = expr[i]
+            
+            # Track string literals
+            if char in ('"', "'") and (i == 0 or expr[i-1] != '\\'):
+                if not in_string:
+                    in_string = True
+                    string_char = char
+                elif char == string_char:
+                    in_string = False
+                    string_char = None
+            
+            # Track square brackets (for slice syntax like [::-1])
+            if not in_string:
+                if char == '[':
+                    bracket_depth += 1
+                elif char == ']':
+                    bracket_depth -= 1
+            
+            # Replace :: with . only outside strings AND outside brackets
+            if not in_string and bracket_depth == 0 and expr[i:i+2] == '::':
+                result.append('.')
+                i += 2
+                continue
+            
+            result.append(char)
+            i += 1
+        
+        return ''.join(result)
+    
     def define(self, name: str, expression: str) -> 'DSLCompiler':
         """
         Define a new column from a DSL expression.
@@ -198,9 +254,12 @@ def define(self, name: str, expression: str) -> 'DSLCompiler':
                 suggestions=["Each column name must be unique"]
             )
 
+        # Phase 11.1: Preprocess C++ :: syntax to Python dot syntax
+        preprocessed = self._preprocess_expression(expression)
+        
         # Parse and generate
         builder = IRBuilder(self._inferrer)
-        ir = builder.build(expression)
+        ir = builder.build(preprocessed)
 
         # Use unique suffix to avoid collisions in parallel execution
         unique_name = f"{name}_{self._unique_id}"