vex-ast 0.2.4__py3-none-any.whl → 0.2.6__py3-none-any.whl

vex_ast/types/README.md

@@ -1,26 +1,78 @@
-# VEX AST Types Package (vex_ast.types)
-
-This package defines the type system used for the VEX V5 Robot Python language.
-
-Purpose
-
-The type system provides a way to represent and reason about the types of values in VEX code. This information is used for type checking, code optimization, and other purposes.
-
-Structure
-
-The package is organized into several modules:
-
-*   `base.py`: Defines base classes for types.
-*   `enums.py`: Defines enums for different type categories.
-*   `objects.py`: Defines classes for representing objects.
-*   `primitives.py`: Defines classes for representing primitive types (e.g., int, float, string, boolean).
-*   `type_checker.py`: Implements the type checking logic.
-
-Key Concepts
-
-*   Types: Represent the kind of value that a variable or expression can have.
-*   Type checking: The process of verifying that the types in a program are consistent.
-
-Usage
-
-The type system is used internally by the VEX AST parser, type checker, and other tools. It is not typically accessed directly by users.
+# VEX AST Types Package (vex_ast.types)
+
+This package defines the type system used for the VEX V5 Robot Python language.
+
+## Purpose
+
+The type system provides a way to represent and reason about the types of values in VEX code. This information is used for type checking, code optimization, and other purposes.
+
+## Structure
+
+The package is organized into several modules:
+
+*   `base.py`: Defines base classes for types.
+*   `enums.py`: Defines enums for different type categories.
+*   `objects.py`: Defines classes for representing objects.
+*   `primitives.py`: Defines classes for representing primitive types (e.g., int, float, string, boolean).
+*   `type_checker.py`: Implements the type checking logic.
+
+## Key Concepts
+
+*   **Types**: Represent the kind of value that a variable or expression can have.
+*   **Type checking**: The process of verifying that the types in a program are consistent.
+
+## Integration with Registry
+
+The type system integrates seamlessly with the registry's category system:
+
+- Object types (MOTOR, BRAIN, etc.) correspond to VexCategory entries
+- Enum types map to valid parameter values
+- Type validation works with function signatures
+
+## Recent Updates
+
+- Support for new VEX object types (Brain, Controller)
+- Enhanced compatibility checking with category system
+- Improved enum type validation
+- Better integration with registry validation
+
+## Usage
+
+The type system is used internally by the VEX AST parser, type checker, and other tools. It is not typically accessed directly by users.
+
+### Example Internal Usage
+
+```python
+from vex_ast.types import MOTOR, DIRECTION_TYPE, VELOCITY_UNITS
+from vex_ast.types.type_checker import type_checker
+
+# Validate parameter types
+if type_checker.is_compatible(arg_type, MOTOR):
+    # Process motor argument
+
+# Check enum values
+if value in DIRECTION_TYPE.values:
+    # Valid direction value
+```
+
+## Type Hierarchy
+
+```
+VexType (base)
+├── PrimitiveType
+│   ├── NumericType
+│   │   ├── IntegerType
+│   │   └── FloatType
+│   ├── BooleanType
+│   └── StringType
+├── ObjectType (MOTOR, BRAIN, etc.)
+├── EnumType (DIRECTION_TYPE, etc.)
+└── VoidType
+```
+
+## Future Extensions
+
+- Support for custom object methods
+- Advanced type inference
+- Generic types for containers
+- Union types for flexible parameters

vex_ast/types/__init__.py

@@ -1,140 +1,140 @@
-"""
-Types package for VEX AST.
-
-This package provides type definitions and type checking functionality for VEX AST.
-"""
-
-from .base import (
-    VexType,
-    VoidType,
-    AnyType,
-    TypeRegistry,
-    VOID,
-    ANY,
-    type_registry
-)
-
-from .primitives import (
-    PrimitiveType,
-    IntegerType,
-    FloatType,
-    BooleanType,
-    StringType,
-    INT,
-    FLOAT,
-    BOOL,
-    STRING
-)
-
-from .objects import (
-    ObjectType,
-    MOTOR,
-    MOTOR_GROUP,
-    DRIVETRAIN,
-    BRAIN,
-    CONTROLLER,
-    INERTIAL,
-    DISTANCE,
-    ROTATION,
-    OPTICAL,
-    GPS,
-    ELECTROMAGNETIC,
-    BRAIN_BATTERY,
-    BRAIN_SCREEN,
-    BRAIN_LCD,
-    COMPETITION,
-    TIMER,
-    BUMPER,
-    LIMIT_SWITCH,
-    ENCODER,
-    SONAR,
-    GYRO,
-    PNEUMATIC,
-    VISION
-)
-
-from .enums import (
-    EnumType,
-    DIRECTION_TYPE,
-    TURN_TYPE,
-    BRAKE_TYPE,
-    VELOCITY_UNITS,
-    ROTATION_UNITS,
-    TIME_UNITS,
-    DISTANCE_UNITS,
-    CURRENT_UNITS,
-    TORQUE_UNITS,
-    TEMPERATURE_UNITS,
-    ANALOG_UNITS
-)
-
-from .type_checker import (
-    TypeChecker,
-    type_checker as check_type_compatibility
-)
-
-__all__ = [
-    # Base types
-    "VexType",
-    "VoidType",
-    "AnyType",
-    "TypeRegistry",
-    "VOID",
-    "ANY",
-    "type_registry",
-    
-    # Primitive types
-    "PrimitiveType",
-    "IntegerType",
-    "FloatType",
-    "BooleanType",
-    "StringType",
-    "INT",
-    "FLOAT",
-    "BOOL",
-    "STRING",
-    
-    # Object types
-    "ObjectType",
-    "MOTOR",
-    "MOTOR_GROUP",
-    "DRIVETRAIN",
-    "BRAIN",
-    "CONTROLLER",
-    "INERTIAL",
-    "DISTANCE",
-    "ROTATION",
-    "OPTICAL",
-    "GPS",
-    "ELECTROMAGNETIC",
-    "BRAIN_BATTERY",
-    "BRAIN_SCREEN",
-    "BRAIN_LCD",
-    "COMPETITION",
-    "TIMER",
-    "BUMPER",
-    "LIMIT_SWITCH",
-    "ENCODER",
-    "SONAR",
-    "GYRO",
-    "PNEUMATIC",
-    "VISION",
-    
-    # Enum types
-    "EnumType",
-    "DIRECTION_TYPE",
-    "TURN_TYPE",
-    "BRAKE_TYPE",
-    "VELOCITY_UNITS",
-    "ROTATION_UNITS",
-    "TIME_UNITS",
-    "DISTANCE_UNITS",
-    "CURRENT_UNITS",
-    "TORQUE_UNITS",
-    "TEMPERATURE_UNITS",
-    "ANALOG_UNITS",
-    
-    # Type checking
-    "TypeChecker",
-    "check_type_compatibility"
-]
+"""
+Types package for VEX AST.
+
+This package provides type definitions and type checking functionality for VEX AST.
+"""
+
+from .base import (
+    VexType,
+    VoidType,
+    AnyType,
+    TypeRegistry,
+    VOID,
+    ANY,
+    type_registry
+)
+
+from .primitives import (
+    PrimitiveType,
+    IntegerType,
+    FloatType,
+    BooleanType,
+    StringType,
+    INT,
+    FLOAT,
+    BOOL,
+    STRING
+)
+
+from .objects import (
+    ObjectType,
+    MOTOR,
+    MOTOR_GROUP,
+    DRIVETRAIN,
+    BRAIN,
+    CONTROLLER,
+    INERTIAL,
+    DISTANCE,
+    ROTATION,
+    OPTICAL,
+    GPS,
+    ELECTROMAGNETIC,
+    BRAIN_BATTERY,
+    BRAIN_SCREEN,
+    BRAIN_LCD,
+    COMPETITION,
+    TIMER,
+    BUMPER,
+    LIMIT_SWITCH,
+    ENCODER,
+    SONAR,
+    GYRO,
+    PNEUMATIC,
+    VISION
+)
+
+from .enums import (
+    EnumType,
+    DIRECTION_TYPE,
+    TURN_TYPE,
+    BRAKE_TYPE,
+    VELOCITY_UNITS,
+    ROTATION_UNITS,
+    TIME_UNITS,
+    DISTANCE_UNITS,
+    CURRENT_UNITS,
+    TORQUE_UNITS,
+    TEMPERATURE_UNITS,
+    ANALOG_UNITS
+)
+
+from .type_checker import (
+    TypeChecker,
+    type_checker as check_type_compatibility
+)
+
+__all__ = [
+    # Base types
+    "VexType",
+    "VoidType",
+    "AnyType",
+    "TypeRegistry",
+    "VOID",
+    "ANY",
+    "type_registry",
+    
+    # Primitive types
+    "PrimitiveType",
+    "IntegerType",
+    "FloatType",
+    "BooleanType",
+    "StringType",
+    "INT",
+    "FLOAT",
+    "BOOL",
+    "STRING",
+    
+    # Object types
+    "ObjectType",
+    "MOTOR",
+    "MOTOR_GROUP",
+    "DRIVETRAIN",
+    "BRAIN",
+    "CONTROLLER",
+    "INERTIAL",
+    "DISTANCE",
+    "ROTATION",
+    "OPTICAL",
+    "GPS",
+    "ELECTROMAGNETIC",
+    "BRAIN_BATTERY",
+    "BRAIN_SCREEN",
+    "BRAIN_LCD",
+    "COMPETITION",
+    "TIMER",
+    "BUMPER",
+    "LIMIT_SWITCH",
+    "ENCODER",
+    "SONAR",
+    "GYRO",
+    "PNEUMATIC",
+    "VISION",
+    
+    # Enum types
+    "EnumType",
+    "DIRECTION_TYPE",
+    "TURN_TYPE",
+    "BRAKE_TYPE",
+    "VELOCITY_UNITS",
+    "ROTATION_UNITS",
+    "TIME_UNITS",
+    "DISTANCE_UNITS",
+    "CURRENT_UNITS",
+    "TORQUE_UNITS",
+    "TEMPERATURE_UNITS",
+    "ANALOG_UNITS",
+    
+    # Type checking
+    "TypeChecker",
+    "check_type_compatibility"
+]

vex_ast/types/base.py

@@ -1,84 +1,84 @@
-from abc import ABC, abstractmethod
-from typing import Any, Optional, Union, List, Type, Set, TypeVar, Generic
-
-class VexType(ABC):
-    """Base abstract class for all VEX types"""
-    
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        """Return the canonical name of this type"""
-        pass
-    
-    @abstractmethod
-    def is_compatible_with(self, other: 'VexType') -> bool:
-        """Check if this type is compatible with another type"""
-        pass
-    
-    @abstractmethod
-    def __str__(self) -> str:
-        """String representation of the type"""
-        pass
-    
-    def __eq__(self, other) -> bool:
-        if not isinstance(other, VexType):
-            return False
-        return self.name == other.name
-
-class VoidType(VexType):
-    """Represents the void type (no return value)"""
-    
-    @property
-    def name(self) -> str:
-        return "void"
-    
-    def is_compatible_with(self, other: VexType) -> bool:
-        return isinstance(other, VoidType)
-    
-    def __str__(self) -> str:
-        return "void"
-
-class AnyType(VexType):
-    """Represents any type (for generic functions)"""
-    
-    @property
-    def name(self) -> str:
-        return "any"
-    
-    def is_compatible_with(self, other: VexType) -> bool:
-        return True  # Any type is compatible with all types
-    
-    def __str__(self) -> str:
-        return "any"
-
-class TypeRegistry:
-    """Global registry of types to ensure type uniqueness"""
-    
-    _instance = None
-    
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super(TypeRegistry, cls).__new__(cls)
-            cls._instance._types = {}
-        return cls._instance
-    
-    def register_type(self, type_: VexType) -> None:
-        """Register a type in the registry"""
-        self._types[type_.name] = type_
-    
-    def get_type(self, name: str) -> Optional[VexType]:
-        """Get a type by name"""
-        return self._types.get(name)
-    
-    def get_all_types(self) -> List[VexType]:
-        """Get all registered types"""
-        return list(self._types.values())
-
-# Singleton instances
-VOID = VoidType()
-ANY = AnyType()
-
-# Global registry
-type_registry = TypeRegistry()
-type_registry.register_type(VOID)
+from abc import ABC, abstractmethod
+from typing import Any, Optional, Union, List, Type, Set, TypeVar, Generic
+
+class VexType(ABC):
+    """Base abstract class for all VEX types"""
+    
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Return the canonical name of this type"""
+        pass
+    
+    @abstractmethod
+    def is_compatible_with(self, other: 'VexType') -> bool:
+        """Check if this type is compatible with another type"""
+        pass
+    
+    @abstractmethod
+    def __str__(self) -> str:
+        """String representation of the type"""
+        pass
+    
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, VexType):
+            return False
+        return self.name == other.name
+
+class VoidType(VexType):
+    """Represents the void type (no return value)"""
+    
+    @property
+    def name(self) -> str:
+        return "void"
+    
+    def is_compatible_with(self, other: VexType) -> bool:
+        return isinstance(other, VoidType)
+    
+    def __str__(self) -> str:
+        return "void"
+
+class AnyType(VexType):
+    """Represents any type (for generic functions)"""
+    
+    @property
+    def name(self) -> str:
+        return "any"
+    
+    def is_compatible_with(self, other: VexType) -> bool:
+        return True  # Any type is compatible with all types
+    
+    def __str__(self) -> str:
+        return "any"
+
+class TypeRegistry:
+    """Global registry of types to ensure type uniqueness"""
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(TypeRegistry, cls).__new__(cls)
+            cls._instance._types = {}
+        return cls._instance
+    
+    def register_type(self, type_: VexType) -> None:
+        """Register a type in the registry"""
+        self._types[type_.name] = type_
+    
+    def get_type(self, name: str) -> Optional[VexType]:
+        """Get a type by name"""
+        return self._types.get(name)
+    
+    def get_all_types(self) -> List[VexType]:
+        """Get all registered types"""
+        return list(self._types.values())
+
+# Singleton instances
+VOID = VoidType()
+ANY = AnyType()
+
+# Global registry
+type_registry = TypeRegistry()
+type_registry.register_type(VOID)
 type_registry.register_type(ANY)