vex-ast 0.1.0__py3-none-any.whl

vex_ast/ast/vex_nodes.py

@@ -0,0 +1,241 @@
+"""VEX V5-specific AST nodes with registry integration."""
+
+from typing import Dict, List, Optional, cast, Tuple, Any
+from enum import Enum, auto
+
+from .interfaces import IAstNode, IExpression, IVisitor, T_VisitorResult, IFunctionCall
+from .expressions import FunctionCall, KeywordArgument
+from ..utils.source_location import SourceLocation
+from ..registry.api import registry_api
+from ..registry.signature import VexFunctionSignature, SimulationCategory
+
+class VexAPICallType(Enum):
+    """Types of VEX API calls for classification"""
+    MOTOR_CONTROL = auto()
+    SENSOR_READING = auto()
+    TIMING_CONTROL = auto()
+    DISPLAY_OUTPUT = auto()
+    BRAIN_FUNCTION = auto()
+    CONTROLLER_FUNCTION = auto()
+    COMPETITION = auto()
+    OTHER = auto()
+
+class VexAPICall(FunctionCall):
+    """Base class for VEX API function calls."""
+    
+    def __init__(self, function: IExpression, args: List[IExpression],
+                 keywords: List[KeywordArgument] = None,
+                 location: Optional[SourceLocation] = None,
+                 call_type: VexAPICallType = VexAPICallType.OTHER):
+        super().__init__(function, args, keywords, location)
+        self.call_type = call_type
+        self._signature: Optional[VexFunctionSignature] = None
+        self._validation_error: Optional[str] = None
+    
+    def get_function_name(self) -> Optional[str]:
+        """Get the function name if available"""
+        if hasattr(self.function, 'name'):
+            return self.function.name
+        
+        # Try to handle attribute access (e.g., motor.spin)
+        if hasattr(self.function, 'attribute') and hasattr(self.function, 'object'):
+            obj = self.function.object
+            attr = self.function.attribute
+            if hasattr(obj, 'name'):
+                return f"{obj.name}.{attr}"
+        
+        return None
+    
+    def resolve_signature(self) -> Optional[VexFunctionSignature]:
+        """Resolve the function signature from the registry"""
+        if self._signature:
+            return self._signature
+        
+        function_name = self.get_function_name()
+        if not function_name:
+            return None
+        
+        # Try to get signature from registry API
+        if '.' in function_name:
+            # For method calls like "motor1.spin", extract the method name
+            obj_name, method_name = function_name.split('.', 1)
+            self._signature = registry_api.get_function(method_name)
+        else:
+            # For direct function calls
+            self._signature = registry_api.get_function(function_name)
+            
+        return self._signature
+    
+    def validate(self) -> Tuple[bool, Optional[str]]:
+        """Validate this function call against the registry"""
+        if self._validation_error:
+            return False, self._validation_error
+        
+        signature = self.resolve_signature()
+        if not signature:
+            function_name = self.get_function_name() or "<unknown>"
+            self._validation_error = f"Unknown VEX function: {function_name}"
+            return False, self._validation_error
+        
+        # Convert args and kwargs to appropriate format
+        arg_values = [arg for arg in self.args]
+        kwarg_values = {kw.name: kw.value for kw in self.keywords or []}
+        
+        # Validate against the signature
+        valid, error = signature.validate_arguments(arg_values, kwarg_values)
+        if not valid:
+            self._validation_error = error
+        
+        return valid, error
+    
+    def get_simulation_category(self) -> Optional[SimulationCategory]:
+        """Get the simulation category for this function call"""
+        signature = self.resolve_signature()
+        if signature:
+            return signature.category
+        return None
+    
+    def get_call_type(self) -> VexAPICallType:
+        """Get the call type of this VEX API call."""
+        return self.call_type
+    
+    def get_signature(self) -> Optional[VexFunctionSignature]:
+        """Get the function signature if resolved."""
+        return self._signature
+    
+    def get_validation_error(self) -> Optional[str]:
+        """Get the validation error if any."""
+        return self._validation_error
+    
+    def accept(self, visitor: IVisitor[T_VisitorResult]) -> T_VisitorResult:
+        return visitor.visit_vexapicall(self)
+
+class MotorControl(VexAPICall):
+    """A VEX motor control function call."""
+    
+    def __init__(self, function: IExpression, args: List[IExpression],
+                 keywords: List[KeywordArgument] = None,
+                 location: Optional[SourceLocation] = None):
+        super().__init__(function, args, keywords, location, VexAPICallType.MOTOR_CONTROL)
+    
+    def accept(self, visitor: IVisitor[T_VisitorResult]) -> T_VisitorResult:
+        return visitor.visit_motorcontrol(self)
+    
+    def get_motor_name(self) -> Optional[str]:
+        """Get the motor name if this is a method call on a motor object."""
+        function_name = self.get_function_name()
+        if function_name and '.' in function_name:
+            return function_name.split('.', 1)[0]
+        return None
+
+class SensorReading(VexAPICall):
+    """A VEX sensor reading function call."""
+    
+    def __init__(self, function: IExpression, args: List[IExpression],
+                 keywords: List[KeywordArgument] = None,
+                 location: Optional[SourceLocation] = None):
+        super().__init__(function, args, keywords, location, VexAPICallType.SENSOR_READING)
+    
+    def accept(self, visitor: IVisitor[T_VisitorResult]) -> T_VisitorResult:
+        return visitor.visit_sensorreading(self)
+    
+    def get_sensor_name(self) -> Optional[str]:
+        """Get the sensor name if this is a method call on a sensor object."""
+        function_name = self.get_function_name()
+        if function_name and '.' in function_name:
+            return function_name.split('.', 1)[0]
+        return None
+
+class TimingControl(VexAPICall):
+    """A VEX timing control function call."""
+    
+    def __init__(self, function: IExpression, args: List[IExpression],
+                 keywords: List[KeywordArgument] = None,
+                 location: Optional[SourceLocation] = None):
+        super().__init__(function, args, keywords, location, VexAPICallType.TIMING_CONTROL)
+    
+    def accept(self, visitor: IVisitor[T_VisitorResult]) -> T_VisitorResult:
+        return visitor.visit_timingcontrol(self)
+    
+    def get_timing_method(self) -> Optional[str]:
+        """Get the timing method name."""
+        function_name = self.get_function_name()
+        if function_name and '.' in function_name:
+            return function_name.split('.', 1)[1]
+        return function_name
+
+class DisplayOutput(VexAPICall):
+    """A VEX display output function call."""
+    
+    def __init__(self, function: IExpression, args: List[IExpression],
+                 keywords: List[KeywordArgument] = None,
+                 location: Optional[SourceLocation] = None):
+        super().__init__(function, args, keywords, location, VexAPICallType.DISPLAY_OUTPUT)
+    
+    def accept(self, visitor: IVisitor[T_VisitorResult]) -> T_VisitorResult:
+        return visitor.visit_displayoutput(self)
+    
+    def get_display_method(self) -> Optional[str]:
+        """Get the display method name."""
+        function_name = self.get_function_name()
+        if function_name and '.' in function_name:
+            return function_name.split('.', 1)[1]
+        return function_name
+
+def create_vex_api_call(function: IExpression, args: List[IExpression],
+                       keywords: List[KeywordArgument] = None,
+                       location: Optional[SourceLocation] = None) -> VexAPICall:
+    """Factory function to create the appropriate VEX API call node"""
+    # Determine the function name
+    function_name = None
+    if hasattr(function, 'name'):
+        function_name = function.name
+    elif hasattr(function, 'attribute') and hasattr(function, 'object'):
+        obj = function.object
+        attr = function.attribute
+        if hasattr(obj, 'name'):
+            function_name = f"{obj.name}.{attr}"
+    
+    # If we can't determine the function name, return a generic VexAPICall
+    if not function_name:
+        return VexAPICall(function, args, keywords, location)
+    
+    # Look up in the registry API to get the function category
+    signature = None
+    if '.' in function_name:
+        # For method calls like "motor1.spin", extract the method name
+        obj_name, method_name = function_name.split('.', 1)
+        signature = registry_api.get_function(method_name)
+    else:
+        # For direct function calls
+        signature = registry_api.get_function(function_name)
+        
+    if not signature:
+        return VexAPICall(function, args, keywords, location)
+    
+    # Create the appropriate node type based on the simulation category
+    if signature.category == SimulationCategory.MOTOR_CONTROL:
+        return MotorControl(function, args, keywords, location)
+    elif signature.category == SimulationCategory.SENSOR_READING:
+        return SensorReading(function, args, keywords, location)
+    elif signature.category == SimulationCategory.TIMING_CONTROL:
+        return TimingControl(function, args, keywords, location)
+    elif signature.category == SimulationCategory.DISPLAY_OUTPUT:
+        return DisplayOutput(function, args, keywords, location)
+    
+    # Default case
+    return VexAPICall(function, args, keywords, location)
+
+# Factory function to create VEX API calls from interfaces
+def create_vex_api_call_from_interface(function_expr: IExpression, 
+                                      args: List[IExpression],
+                                      kwargs: Dict[str, IExpression] = None,
+                                      location: Optional[SourceLocation] = None) -> VexAPICall:
+    """Create a VEX API call from interface types."""
+    # Convert kwargs to KeywordArgument objects
+    keywords = []
+    if kwargs:
+        for name, value in kwargs.items():
+            keywords.append(KeywordArgument(name, value))
+    
+    return create_vex_api_call(function_expr, args, keywords, location)

vex_ast/parser/factory.py

@@ -0,0 +1,179 @@
+"""Node factory for creating AST nodes (Factory Pattern)."""
+
+from typing import Any, Dict, Optional, Type, Union, cast, List
+
+from ..ast.core import Expression, Program, Statement
+from ..ast.expressions import (
+    AttributeAccess, BinaryOperation, FunctionCall, Identifier, KeywordArgument, 
+    UnaryOperation, VariableReference
+)
+from ..ast.literals import (
+    BooleanLiteral, NoneLiteral, NumberLiteral, StringLiteral
+)
+from ..ast.operators import Operator
+from ..ast.statements import (
+    Assignment, BreakStatement, ContinueStatement, ExpressionStatement,
+    ForLoop, FunctionDefinition, IfStatement, ReturnStatement, WhileLoop, Argument
+)
+from ..ast.vex_nodes import (
+    DisplayOutput, MotorControl, SensorReading, TimingControl, VexAPICall
+)
+from ..utils.errors import ErrorHandler
+from ..utils.source_location import SourceLocation
+
+class NodeFactory:
+    """Factory for creating AST nodes."""
+    
+    def __init__(self, error_handler: Optional[ErrorHandler] = None):
+        """Initialize with an optional error handler."""
+        self.error_handler = error_handler
+    
+    # --- Literals ---
+    
+    def create_number_literal(self, value: Union[int, float], 
+                              location: Optional[SourceLocation] = None) -> NumberLiteral:
+        """Create a number literal node."""
+        return NumberLiteral(value, location)
+    
+    def create_string_literal(self, value: str,
+                              location: Optional[SourceLocation] = None) -> StringLiteral:
+        """Create a string literal node."""
+        return StringLiteral(value, location)
+    
+    def create_boolean_literal(self, value: bool,
+                               location: Optional[SourceLocation] = None) -> BooleanLiteral:
+        """Create a boolean literal node."""
+        return BooleanLiteral(value, location)
+    
+    def create_none_literal(self, 
+                            location: Optional[SourceLocation] = None) -> NoneLiteral:
+        """Create a None literal node."""
+        return NoneLiteral(location)
+    
+    # --- Expressions ---
+    
+    def create_identifier(self, name: str,
+                          location: Optional[SourceLocation] = None) -> Identifier:
+        """Create an identifier node."""
+        return Identifier(name, location)
+    
+    def create_variable_reference(self, identifier: Identifier,
+                                  location: Optional[SourceLocation] = None) -> VariableReference:
+        """Create a variable reference node."""
+        return VariableReference(identifier, location)
+    
+    def create_attribute_access(self, object_expr: Expression, attribute: str,
+                                location: Optional[SourceLocation] = None) -> AttributeAccess:
+        """Create an attribute access node."""
+        return AttributeAccess(object_expr, attribute, location)
+    
+    def create_binary_operation(self, left: Expression, op: Operator, right: Expression,
+                                location: Optional[SourceLocation] = None) -> BinaryOperation:
+        """Create a binary operation node."""
+        return BinaryOperation(left, op, right, location)
+    
+    def create_unary_operation(self, op: Operator, operand: Expression,
+                               location: Optional[SourceLocation] = None) -> UnaryOperation:
+        """Create a unary operation node."""
+        return UnaryOperation(op, operand, location)
+    
+    def create_function_call(self, function: Expression, args: List[Expression] = None,
+                             keywords: List[KeywordArgument] = None,
+                             location: Optional[SourceLocation] = None) -> FunctionCall:
+        """Create a function call node."""
+        return FunctionCall(function, args or [], keywords or [], location)
+    
+    def create_keyword_argument(self, name: str, value: Expression,
+                                location: Optional[SourceLocation] = None) -> KeywordArgument:
+        """Create a keyword argument node."""
+        return KeywordArgument(name, value, location)
+    
+    # --- Statements ---
+    
+    def create_expression_statement(self, expression: Expression,
+                                   location: Optional[SourceLocation] = None) -> ExpressionStatement:
+        """Create an expression statement node."""
+        return ExpressionStatement(expression, location)
+    
+    def create_assignment(self, target: Expression, value: Expression,
+                          location: Optional[SourceLocation] = None) -> Assignment:
+        """Create an assignment statement node."""
+        return Assignment(target, value, location)
+    
+    def create_if_statement(self, test: Expression, body: List[Statement],
+                           orelse: Optional[Union[List[Statement], IfStatement]] = None,
+                           location: Optional[SourceLocation] = None) -> IfStatement:
+        """Create an if statement node."""
+        return IfStatement(test, body, orelse, location)
+    
+    def create_while_loop(self, test: Expression, body: List[Statement],
+                         location: Optional[SourceLocation] = None) -> WhileLoop:
+        """Create a while loop node."""
+        return WhileLoop(test, body, location)
+    
+    def create_for_loop(self, target: Expression, iterable: Expression, 
+                       body: List[Statement],
+                       location: Optional[SourceLocation] = None) -> ForLoop:
+        """Create a for loop node."""
+        return ForLoop(target, iterable, body, location)
+    
+    def create_function_definition(self, name: str, args: List[Argument], body: List[Statement],
+                                  return_annotation: Optional[Expression] = None,
+                                  location: Optional[SourceLocation] = None) -> FunctionDefinition:
+        """Create a function definition node."""
+        return FunctionDefinition(name, args, body, return_annotation, location)
+    
+    def create_return_statement(self, value: Optional[Expression] = None,
+                               location: Optional[SourceLocation] = None) -> ReturnStatement:
+        """Create a return statement node."""
+        return ReturnStatement(value, location)
+    
+    def create_break_statement(self, 
+                              location: Optional[SourceLocation] = None) -> BreakStatement:
+        """Create a break statement node."""
+        return BreakStatement(location)
+    
+    def create_continue_statement(self,
+                                 location: Optional[SourceLocation] = None) -> ContinueStatement:
+        """Create a continue statement node."""
+        return ContinueStatement(location)
+    
+    # --- VEX-specific Nodes ---
+    
+    def create_vex_api_call(self, function: Expression, args: List[Expression],
+                           keywords: List[KeywordArgument] = None,
+                           location: Optional[SourceLocation] = None) -> VexAPICall:
+        """Create a VEX API call node."""
+        return VexAPICall(function, args, keywords or [], location)
+    
+    def create_motor_control(self, function: Expression, args: List[Expression],
+                            keywords: List[KeywordArgument] = None,
+                            location: Optional[SourceLocation] = None) -> MotorControl:
+        """Create a motor control node."""
+        return MotorControl(function, args, keywords or [], location)
+    
+    def create_sensor_reading(self, function: Expression, args: List[Expression],
+                             keywords: List[KeywordArgument] = None,
+                             location: Optional[SourceLocation] = None) -> SensorReading:
+        """Create a sensor reading node."""
+        return SensorReading(function, args, keywords or [], location)
+    
+    def create_timing_control(self, function: Expression, args: List[Expression],
+                             keywords: List[KeywordArgument] = None,
+                             location: Optional[SourceLocation] = None) -> TimingControl:
+        """Create a timing control node."""
+        return TimingControl(function, args, keywords or [], location)
+    
+    def create_display_output(self, function: Expression, args: List[Expression],
+                             keywords: List[KeywordArgument] = None,
+                             location: Optional[SourceLocation] = None) -> DisplayOutput:
+        """Create a display output node."""
+        return DisplayOutput(function, args, keywords or [], location)
+    
+    def create_program(self, body: List[Statement],
+                      location: Optional[SourceLocation] = None) -> Program:
+        """Create a program node."""
+        return Program(body, location)
+
+# Global factory instance for simple use cases
+default_factory = NodeFactory()

vex_ast/parser/interfaces.py

@@ -0,0 +1,35 @@
+"""Parser interfaces and protocols."""
+
+from abc import ABC, abstractmethod
+from typing import Protocol, Optional
+
+from ..ast.core import Program
+from ..utils.errors import ErrorHandler
+
+class IParser(Protocol):
+    """Protocol for parser implementations."""
+    
+    def parse(self) -> Program:
+        """Parse the input and return an AST."""
+        ...
+    
+    @property
+    def error_handler(self) -> Optional[ErrorHandler]:
+        """Get the parser's error handler."""
+        ...
+
+class BaseParser(ABC):
+    """Abstract base class for parsers."""
+    
+    def __init__(self, error_handler: Optional[ErrorHandler] = None):
+        self._error_handler = error_handler or ErrorHandler()
+    
+    @property
+    def error_handler(self) -> ErrorHandler:
+        """Get the parser's error handler."""
+        return self._error_handler
+    
+    @abstractmethod
+    def parse(self) -> Program:
+        """Parse the input and return an AST."""
+        pass