vex-ast 0.1.0__py3-none-any.whl

vex_ast/parser/python_parser.py

@@ -0,0 +1,725 @@
+"""Python code parser implementation."""
+
+import ast
+import textwrap
+from typing import Any, Dict, List, Optional, Type, Union, cast
+
+from .interfaces import BaseParser
+from .factory import NodeFactory
+
+from ..ast.core import Expression, Program, Statement
+from ..ast.expressions import (
+    AttributeAccess, BinaryOperation, FunctionCall, Identifier, KeywordArgument, 
+    UnaryOperation, VariableReference
+)
+
+from ..ast.interfaces import IExpression, IStatement
+from ..ast.literals import (
+    BooleanLiteral, NoneLiteral, NumberLiteral, StringLiteral
+)
+
+from ..ast.operators import Operator, PYTHON_BINARY_OP_MAP, PYTHON_UNARY_OP_MAP, PYTHON_COMP_OP_MAP
+from ..ast.statements import (
+    Argument, Assignment, BreakStatement, ContinueStatement, ExpressionStatement,
+    ForLoop, FunctionDefinition, IfStatement, ReturnStatement, WhileLoop
+)
+from ..ast.vex_nodes import create_vex_api_call, VexAPICall
+from ..registry.registry import registry
+
+from ..utils.errors import ErrorHandler, ErrorType, VexSyntaxError
+from ..utils.source_location import SourceLocation
+
+class PythonParser(BaseParser):
+    """Parser for Python code using the built-in ast module (Python 3.8+)."""
+    
+    def __init__(self, source: str, filename: str = "<string>", 
+                 error_handler: Optional[ErrorHandler] = None):
+        super().__init__(error_handler)
+        self.source = source
+        self.filename = filename
+        self.factory = NodeFactory(error_handler)
+        self._py_ast: Optional[ast.Module] = None
+    
+    def _get_location(self, node: ast.AST) -> Optional[SourceLocation]:
+        """Extract source location from a Python AST node."""
+        if hasattr(node, 'lineno'):
+            loc = SourceLocation(
+                line=node.lineno,
+                column=node.col_offset + 1,  # ast is 0-indexed
+                filename=self.filename
+            )
+            
+            # Add end position if available (Python 3.8+)
+            if hasattr(node, 'end_lineno') and node.end_lineno is not None and \
+               hasattr(node, 'end_col_offset') and node.end_col_offset is not None:
+                loc.end_line = node.end_lineno
+                loc.end_column = node.end_col_offset + 1
+            
+            return loc
+        return None
+    
+    def _convert_expression(self, node: ast.expr) -> Expression:
+        """Convert a Python expression node to a VEX AST expression."""
+        # Handle literal values - using modern Constant node (Python 3.8+)
+        if isinstance(node, ast.Constant):
+            value = node.value
+            loc = self._get_location(node)
+            
+            if isinstance(value, (int, float)):
+                return self.factory.create_number_literal(value, loc)
+            elif isinstance(value, str):
+                return self.factory.create_string_literal(value, loc)
+            elif isinstance(value, bool):
+                return self.factory.create_boolean_literal(value, loc)
+            elif value is None:
+                return self.factory.create_none_literal(loc)
+            else:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    f"Unsupported constant type: {type(value).__name__}",
+                    loc
+                )
+                # Fallback - treat as string
+                return self.factory.create_string_literal(str(value), loc)
+        
+        # Variables
+        elif isinstance(node, ast.Name):
+            loc = self._get_location(node)
+            ident = self.factory.create_identifier(node.id, loc)
+            # In a load context, create a variable reference
+            if isinstance(node.ctx, ast.Load):
+                return self.factory.create_variable_reference(ident, loc)
+            # For store and del contexts, just return the identifier
+            # These will be handled by parent nodes (e.g., Assignment)
+            return ident
+        
+        # Attribute access (e.g., left_motor.set_velocity)
+        elif isinstance(node, ast.Attribute):
+            value = self._convert_expression(node.value)
+            loc = self._get_location(node)
+            
+            # Create a proper AttributeAccess node
+            return self.factory.create_attribute_access(value, node.attr, loc)
+        
+        # Binary operations
+        elif isinstance(node, ast.BinOp):
+            left = self._convert_expression(node.left)
+            right = self._convert_expression(node.right)
+            loc = self._get_location(node)
+            
+            # Map Python operator to VEX operator
+            op_type = type(node.op)
+            op_name = op_type.__name__
+            
+            op_map = {
+                'Add': '+', 'Sub': '-', 'Mult': '*', 'Div': '/', 
+                'FloorDiv': '//', 'Mod': '%', 'Pow': '**', 
+                'LShift': '<<', 'RShift': '>>', 
+                'BitOr': '|', 'BitXor': '^', 'BitAnd': '&',
+                'MatMult': '@'
+            }
+            
+            if op_name in op_map:
+                op_str = op_map[op_name]
+                op = PYTHON_BINARY_OP_MAP.get(op_str)
+                if op:
+                    return self.factory.create_binary_operation(left, op, right, loc)
+            
+            # Fallback for unknown operators
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                f"Unsupported binary operator: {op_name}",
+                loc
+            )
+            # Create a basic operation with the operator as a string
+            return self.factory.create_binary_operation(
+                left, Operator.ADD, right, loc
+            )
+        
+        # Unary operations
+        elif isinstance(node, ast.UnaryOp):
+            operand = self._convert_expression(node.operand)
+            loc = self._get_location(node)
+            
+            # Map Python unary operator to VEX operator
+            op_type = type(node.op)
+            op_name = op_type.__name__
+            
+            op_map = {
+                'UAdd': '+', 'USub': '-', 'Not': 'not', 'Invert': '~'
+            }
+            
+            if op_name in op_map:
+                op_str = op_map[op_name]
+                op = PYTHON_UNARY_OP_MAP.get(op_str)
+                if op:
+                    return self.factory.create_unary_operation(op, operand, loc)
+            
+            # Fallback for unknown operators
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                f"Unsupported unary operator: {op_name}",
+                loc
+            )
+            # Create a basic operation with a default operator
+            return self.factory.create_unary_operation(
+                Operator.UNARY_PLUS, operand, loc
+            )
+        
+        # Function calls
+        elif isinstance(node, ast.Call):
+            func = self._convert_expression(node.func)
+            args = [self._convert_expression(arg) for arg in node.args]
+            keywords = []
+            loc = self._get_location(node)
+            
+            for kw in node.keywords:
+                if kw.arg is None:  # **kwargs
+                    self.error_handler.add_error(
+                        ErrorType.PARSER_ERROR,
+                        "Keyword argument unpacking (**kwargs) is not supported",
+                        self._get_location(kw)
+                    )
+                    continue
+                
+                value = self._convert_expression(kw.value)
+                keyword = self.factory.create_keyword_argument(
+                    kw.arg, value, self._get_location(kw)
+                )
+                keywords.append(keyword)
+            
+            # Check if this is a VEX API call
+            function_name = None
+            if hasattr(func, 'name'):
+                function_name = func.name
+            elif hasattr(func, 'attribute') and hasattr(func, 'object'):
+                obj = func.object
+                attr = func.attribute
+                if hasattr(obj, 'name'):
+                    function_name = f"{obj.name}.{attr}"
+            
+            # For debugging
+            # print(f"Function call: {function_name}")
+            # print(f"Registry has function: {registry.get_function(function_name) is not None}")
+            
+            if function_name:
+                # Check if this is a method call on a known object type
+                if '.' in function_name:
+                    obj_name, method_name = function_name.split('.', 1)
+                    # For method calls, we need to check if the method exists for any object type
+                    # since we don't know the actual type of the object at parse time
+                    # Just check if the method name exists in the registry
+                    if registry.get_function(method_name):
+                        return create_vex_api_call(func, args, keywords, loc)
+                # Or check if it's a direct function
+                elif registry.get_function(function_name):
+                    return create_vex_api_call(func, args, keywords, loc)
+            
+            # Regular function call
+            return self.factory.create_function_call(func, args, keywords, loc)
+    
+        
+        # Comparison operations (e.g., a < b, x == y)
+        elif isinstance(node, ast.Compare):
+            # Handle the first comparison
+            left = self._convert_expression(node.left)
+            loc = self._get_location(node)
+            
+            if not node.ops or not node.comparators:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "Invalid comparison with no operators or comparators",
+                    loc
+                )
+                # Return a placeholder expression
+                return left
+            
+            # Process each comparison operator and right operand
+            result = left
+            for i, (op, comparator) in enumerate(zip(node.ops, node.comparators)):
+                right = self._convert_expression(comparator)
+                
+                # Map Python comparison operator to VEX operator
+                op_type = type(op)
+                op_name = op_type.__name__
+                
+                op_map = {
+                    'Eq': '==', 'NotEq': '!=', 
+                    'Lt': '<', 'LtE': '<=',
+                    'Gt': '>', 'GtE': '>=',
+                    'Is': 'is', 'IsNot': 'is not',
+                    'In': 'in', 'NotIn': 'not in'
+                }
+                
+                if op_name in op_map:
+                    op_str = op_map[op_name]
+                    vex_op = PYTHON_COMP_OP_MAP.get(op_str)
+                    
+                    if vex_op:
+                        # For the first comparison, use left and right
+                        # For subsequent comparisons, use previous result and right
+                        result = self.factory.create_binary_operation(
+                            result, vex_op, right, loc
+                        )
+                    else:
+                        self.error_handler.add_error(
+                            ErrorType.PARSER_ERROR,
+                            f"Unsupported comparison operator: {op_name}",
+                            loc
+                        )
+                else:
+                    self.error_handler.add_error(
+                        ErrorType.PARSER_ERROR,
+                        f"Unknown comparison operator: {op_name}",
+                        loc
+                    )
+            
+            return result
+        
+        # Boolean operations (and, or)
+        elif isinstance(node, ast.BoolOp):
+            loc = self._get_location(node)
+            
+            if not node.values:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "Boolean operation with no values",
+                    loc
+                )
+                # Return a placeholder expression
+                return self.factory.create_boolean_literal(False, loc)
+            
+            # Get the operator
+            op_type = type(node.op)
+            op_name = op_type.__name__
+            
+            op_map = {
+                'And': 'and',
+                'Or': 'or'
+            }
+            
+            if op_name in op_map:
+                op_str = op_map[op_name]
+                vex_op = PYTHON_COMP_OP_MAP.get(op_str)
+                
+                if not vex_op:
+                    self.error_handler.add_error(
+                        ErrorType.PARSER_ERROR,
+                        f"Unsupported boolean operator: {op_name}",
+                        loc
+                    )
+                    vex_op = Operator.LOGICAL_AND  # Fallback
+            else:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    f"Unknown boolean operator: {op_name}",
+                    loc
+                )
+                vex_op = Operator.LOGICAL_AND  # Fallback
+            
+            # Process all values from left to right
+            values = [self._convert_expression(val) for val in node.values]
+            
+            # Build the expression tree from left to right
+            result = values[0]
+            for right in values[1:]:
+                result = self.factory.create_binary_operation(
+                    result, vex_op, right, loc
+                )
+            
+            return result
+        
+        # List literals
+        elif isinstance(node, ast.List) or isinstance(node, ast.Tuple):
+            # We don't have a dedicated list/tuple node, so use function call
+            # with a special identifier for now
+            loc = self._get_location(node)
+            elements = [self._convert_expression(elt) for elt in node.elts]
+            list_name = "list" if isinstance(node, ast.List) else "tuple"
+            list_func = self.factory.create_identifier(list_name, loc)
+            
+            return self.factory.create_function_call(list_func, elements, [], loc)
+        
+        # Subscript (indexing) expressions like a[b]
+        elif isinstance(node, ast.Subscript):
+            loc = self._get_location(node)
+            value = self._convert_expression(node.value)
+            
+            # Convert the slice/index
+            if isinstance(node.slice, ast.Index):  # Python < 3.9
+                index = self._convert_expression(node.slice.value)
+            else:  # Python 3.9+
+                index = self._convert_expression(node.slice)
+            
+            # Create a function call to represent subscripting for now
+            # In the future, a dedicated SubscriptExpression node might be better
+            subscript_func = self.factory.create_identifier("__getitem__", loc)
+            return self.factory.create_function_call(
+                self.factory.create_attribute_access(value, "__getitem__", loc),
+                [index], [], loc
+            )
+        
+        # Lambda expressions
+        elif isinstance(node, ast.Lambda):
+            loc = self._get_location(node)
+            # We don't have a dedicated lambda node, so warn and create a placeholder
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                "Lambda expressions are not fully supported",
+                loc
+            )
+            
+            # Create a placeholder function call
+            lambda_func = self.factory.create_identifier("lambda", loc)
+            return self.factory.create_function_call(lambda_func, [], [], loc)
+        
+        # Dictionary literals
+        elif isinstance(node, ast.Dict):
+            loc = self._get_location(node)
+            # We don't have a dedicated dict node, so create a function call
+            dict_func = self.factory.create_identifier("dict", loc)
+            
+            keywords = []
+            for i, (key, value) in enumerate(zip(node.keys, node.values)):
+                if key is None:  # dict unpacking (**d)
+                    self.error_handler.add_error(
+                        ErrorType.PARSER_ERROR,
+                        "Dictionary unpacking is not supported",
+                        loc
+                    )
+                    continue
+                
+                # For string keys, use them as keyword arguments
+                if isinstance(key, ast.Constant) and isinstance(key.value, str):
+                    key_str = key.value
+                    value_expr = self._convert_expression(value)
+                    keywords.append(self.factory.create_keyword_argument(
+                        key_str, value_expr, loc
+                    ))
+                else:
+                    # For non-string keys, we need a different approach
+                    self.error_handler.add_error(
+                        ErrorType.PARSER_ERROR,
+                        "Only string keys in dictionaries are fully supported",
+                        loc
+                    )
+            
+            return self.factory.create_function_call(dict_func, [], keywords, loc)
+        
+        # Fallback for unsupported nodes
+        self.error_handler.add_error(
+            ErrorType.PARSER_ERROR,
+            f"Unsupported expression type: {type(node).__name__}",
+            self._get_location(node)
+        )
+        # Return a simple identifier as fallback
+        return self.factory.create_identifier(
+            f"<unsupported:{type(node).__name__}>",
+            self._get_location(node)
+        )
+    
+    def _convert_statement(self, node: ast.stmt) -> Statement:
+        """Convert a Python statement node to a VEX AST statement."""
+        # Expression statements
+        if isinstance(node, ast.Expr):
+            expr = self._convert_expression(node.value)
+            return self.factory.create_expression_statement(
+                expr, self._get_location(node)
+            )
+        
+        # Assignment statements
+        elif isinstance(node, ast.Assign):
+            # For simplicity, we'll only handle the first target
+            # (Python allows multiple targets like a = b = 1)
+            if not node.targets:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "Assignment with no targets",
+                    self._get_location(node)
+                )
+                # Fallback - create a dummy assignment
+                return self.factory.create_assignment(
+                    self.factory.create_identifier("_dummy"),
+                    self.factory.create_none_literal(),
+                    self._get_location(node)
+                )
+            
+            target = self._convert_expression(node.targets[0])
+            value = self._convert_expression(node.value)
+            return self.factory.create_assignment(
+                target, value, self._get_location(node)
+            )
+        
+        # Augmented assignments (e.g., a += 1)
+        elif isinstance(node, ast.AugAssign):
+            loc = self._get_location(node)
+            target = self._convert_expression(node.target)
+            value = self._convert_expression(node.value)
+            
+            # Map Python operator to VEX operator
+            op_type = type(node.op)
+            op_name = op_type.__name__
+            
+            op_map = {
+                'Add': '+', 'Sub': '-', 'Mult': '*', 'Div': '/', 
+                'FloorDiv': '//', 'Mod': '%', 'Pow': '**', 
+                'LShift': '<<', 'RShift': '>>', 
+                'BitOr': '|', 'BitXor': '^', 'BitAnd': '&',
+                'MatMult': '@'
+            }
+            
+            if op_name in op_map:
+                op_str = op_map[op_name]
+                op = PYTHON_BINARY_OP_MAP.get(op_str)
+                
+                if op:
+                    # Create a binary operation (target op value)
+                    bin_op = self.factory.create_binary_operation(
+                        target, op, value, loc
+                    )
+                    
+                    # Create an assignment (target = bin_op)
+                    return self.factory.create_assignment(
+                        target, bin_op, loc
+                    )
+            
+            # Fallback for unknown operators
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                f"Unsupported augmented assignment operator: {op_name}",
+                loc
+            )
+            # Create a basic assignment as fallback
+            return self.factory.create_assignment(target, value, loc)
+        
+        # If statements
+        elif isinstance(node, ast.If):
+            test = self._convert_expression(node.test)
+            body = [self._convert_statement(stmt) for stmt in node.body]
+            loc = self._get_location(node)
+            
+            # Handle else branch
+            orelse = None
+            if node.orelse:
+                # Check if it's an elif (a single If statement)
+                if len(node.orelse) == 1 and isinstance(node.orelse[0], ast.If):
+                    orelse = self._convert_statement(node.orelse[0])
+                else:
+                    # Regular else block
+                    orelse = [self._convert_statement(stmt) for stmt in node.orelse]
+            
+            return self.factory.create_if_statement(test, body, orelse, loc)
+        
+        # While loops
+        elif isinstance(node, ast.While):
+            test = self._convert_expression(node.test)
+            body = [self._convert_statement(stmt) for stmt in node.body]
+            loc = self._get_location(node)
+            
+            # Note: We're ignoring the else clause for now
+            if node.orelse:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "While-else clauses are not supported",
+                    loc
+                )
+            
+            return self.factory.create_while_loop(test, body, loc)
+        
+        # For loops
+        elif isinstance(node, ast.For):
+            target = self._convert_expression(node.target)
+            iter_expr = self._convert_expression(node.iter)
+            body = [self._convert_statement(stmt) for stmt in node.body]
+            loc = self._get_location(node)
+            
+            # Note: We're ignoring the else clause for now
+            if node.orelse:
+                self.error_handler.add_error(
+                    ErrorType.PARSER_ERROR,
+                    "For-else clauses are not supported",
+                    loc
+                )
+            
+            return self.factory.create_for_loop(target, iter_expr, body, loc)
+        
+        # Function definitions
+        elif isinstance(node, ast.FunctionDef):
+            loc = self._get_location(node)
+            
+            # Convert arguments
+            args = []
+            for arg in node.args.args:
+                # Get annotation if present
+                annotation = None
+                if arg.annotation:
+                    annotation = self._convert_expression(arg.annotation)
+                
+                # Get default value if this argument has one
+                default = None
+                arg_idx = node.args.args.index(arg)
+                defaults_offset = len(node.args.args) - len(node.args.defaults)
+                if arg_idx >= defaults_offset and node.args.defaults:
+                    default_idx = arg_idx - defaults_offset
+                    if default_idx < len(node.args.defaults):
+                        default_value = node.args.defaults[default_idx]
+                        default = self._convert_expression(default_value)
+                
+                args.append(Argument(arg.arg, annotation, default))
+            
+            # Convert body
+            body = [self._convert_statement(stmt) for stmt in node.body]
+            
+            # Convert return annotation if present
+            return_annotation = None
+            if node.returns:
+                return_annotation = self._convert_expression(node.returns)
+            
+            return self.factory.create_function_definition(
+                node.name, args, body, return_annotation, loc
+            )
+        
+        # Return statements
+        elif isinstance(node, ast.Return):
+            value = None
+            if node.value:
+                value = self._convert_expression(node.value)
+            return self.factory.create_return_statement(
+                value, self._get_location(node)
+            )
+        
+        # Break statements
+        elif isinstance(node, ast.Break):
+            return self.factory.create_break_statement(
+                self._get_location(node)
+            )
+        
+        # Continue statements
+        elif isinstance(node, ast.Continue):
+            return self.factory.create_continue_statement(
+                self._get_location(node)
+            )
+        
+        # Pass statements - convert to empty expression statement
+        elif isinstance(node, ast.Pass):
+            return self.factory.create_expression_statement(
+                self.factory.create_none_literal(),
+                self._get_location(node)
+            )
+        
+        # Import statements - not fully supported yet
+        elif isinstance(node, (ast.Import, ast.ImportFrom)):
+            loc = self._get_location(node)
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                "Import statements are not fully supported",
+                loc
+            )
+            # Create a placeholder expression statement
+            return self.factory.create_expression_statement(
+                self.factory.create_identifier(
+                    f"<import:{getattr(node, 'names', [])}>",
+                    loc
+                ),
+                loc
+            )
+        
+        # Class definitions - not supported yet
+        elif isinstance(node, ast.ClassDef):
+            loc = self._get_location(node)
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                "Class definitions are not supported",
+                loc
+            )
+            # Create a placeholder expression statement
+            return self.factory.create_expression_statement(
+                self.factory.create_identifier(
+                    f"<class:{node.name}>",
+                    loc
+                ),
+                loc
+            )
+        
+        # Fallback for unsupported nodes
+        self.error_handler.add_error(
+            ErrorType.PARSER_ERROR,
+            f"Unsupported statement type: {type(node).__name__}",
+            self._get_location(node)
+        )
+        # Return a simple expression statement as fallback
+        return self.factory.create_expression_statement(
+            self.factory.create_identifier(
+                f"<unsupported:{type(node).__name__}>",
+                self._get_location(node)
+            ),
+            self._get_location(node)
+        )
+    
+    def parse(self) -> Program:
+        """Parse the Python source code and return a VEX AST."""
+        try:
+            # Dedent the source code to remove whitespace
+            dedented_source = textwrap.dedent(self.source)
+
+            # Parse the Python code with modern features
+            self._py_ast = ast.parse(
+                dedented_source, 
+                filename=self.filename, 
+                feature_version=(3, 8)  # Explicitly use Python 3.8+ features
+            )
+            
+            # Convert the module body to VEX statements
+            body = [self._convert_statement(stmt) for stmt in self._py_ast.body]
+            
+            # Create and return the program node
+            return self.factory.create_program(body)
+            
+        except SyntaxError as e:
+            # Convert Python SyntaxError to VexSyntaxError
+            loc = SourceLocation(
+                line=e.lineno or 1,
+                column=e.offset or 1,
+                filename=e.filename or self.filename
+            )
+            if hasattr(e, 'end_lineno') and e.end_lineno is not None and \
+               hasattr(e, 'end_offset') and e.end_offset is not None:
+                loc.end_line = e.end_lineno
+                loc.end_column = e.end_offset
+            
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                f"Syntax error: {e.msg}",
+                loc
+            )
+            raise VexSyntaxError(f"Syntax error: {e.msg}", loc) from e
+            
+        except Exception as e:
+            # Handle other parsing errors
+            self.error_handler.add_error(
+                ErrorType.PARSER_ERROR,
+                f"Failed to parse Python code: {str(e)}",
+                SourceLocation(1, 1, self.filename)
+            )
+            raise VexSyntaxError(
+                f"Failed to parse Python code: {str(e)}",
+                SourceLocation(1, 1, self.filename)
+            ) from e
+
+# Convenience functions
+def parse_string(source: str, filename: str = "<string>", 
+               error_handler: Optional[ErrorHandler] = None) -> Program:
+    """Parse Python code from a string."""
+    parser = PythonParser(source, filename, error_handler)
+    return parser.parse()
+
+def parse_file(filepath: str, error_handler: Optional[ErrorHandler] = None) -> Program:
+    """Parse Python code from a file."""
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            source = f.read()
+        return parse_string(source, filepath, error_handler)
+    except FileNotFoundError:
+        raise
+    except IOError as e:
+        raise IOError(f"Error reading file {filepath}: {e}")