quantum-framework 0.9.0__py3-none-any.whl

quantum/compiler/base_generator.py

@@ -0,0 +1,367 @@
+"""
+Base Code Generator
+===================
+
+Abstract base class for all code generators (Python, JavaScript, etc.)
+Uses visitor pattern to traverse AST and generate code.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Set
+from dataclasses import dataclass, field
+import sys
+from pathlib import Path
+
+# Add parent to path for imports
+
+from quantum.core.ast_nodes import (
+    QuantumNode, ComponentNode, ApplicationNode, SetNode, LoopNode,
+    IfNode, FunctionNode, HTMLNode, TextNode, QueryNode, ActionNode,
+    ImportNode, SlotNode, ComponentCallNode, PythonNode, PyImportNode,
+    RedirectNode, FlashNode, DocTypeNode, CommentNode, QueryParamNode
+)
+
+
+@dataclass
+class Scope:
+    """Represents a variable scope."""
+    variables: Dict[str, str] = field(default_factory=dict)  # name -> type hint
+    parent: Optional['Scope'] = None
+
+    def declare(self, name: str, type_hint: str = 'Any'):
+        """Declare a variable in this scope."""
+        self.variables[name] = type_hint
+
+    def lookup(self, name: str) -> Optional[str]:
+        """Look up a variable, checking parent scopes."""
+        if name in self.variables:
+            return self.variables[name]
+        if self.parent:
+            return self.parent.lookup(name)
+        return None
+
+    def is_declared(self, name: str) -> bool:
+        """Check if variable is declared in any scope."""
+        return self.lookup(name) is not None
+
+
+@dataclass
+class GeneratorContext:
+    """Context for code generation."""
+    component_name: str = ''
+    function_name: str = ''
+    in_loop: bool = False
+    in_conditional: bool = False
+    in_html: bool = False
+    imports: Set[str] = field(default_factory=set)
+    functions: List[str] = field(default_factory=list)
+    html_var: str = '_html'
+
+
+class CodeGenerator(ABC):
+    """
+    Abstract base class for code generators.
+
+    Implements visitor pattern for AST traversal and provides
+    common utilities for code emission and scope management.
+    """
+
+    def __init__(self):
+        self.indent_level: int = 0
+        self.indent_str: str = "    "
+        self.output_lines: List[str] = []
+        self.scope: Scope = Scope()
+        self.context: GeneratorContext = GeneratorContext()
+        self._visitor_cache: Dict[str, callable] = {}
+
+    # =========================================================================
+    # Abstract methods - must be implemented by subclasses
+    # =========================================================================
+
+    @abstractmethod
+    def file_extension(self) -> str:
+        """Return the file extension for this generator."""
+        pass
+
+    @abstractmethod
+    def generate_header(self) -> str:
+        """Generate file header (imports, comments, etc.)"""
+        pass
+
+    @abstractmethod
+    def generate_footer(self) -> str:
+        """Generate file footer."""
+        pass
+
+    @abstractmethod
+    def transpile_expression(self, expr: str) -> str:
+        """Transpile a Quantum expression to target language."""
+        pass
+
+    # =========================================================================
+    # Core generation methods
+    # =========================================================================
+
+    def generate(self, node: QuantumNode) -> str:
+        """
+        Generate code for an AST node and return the complete output.
+
+        Args:
+            node: The root AST node to generate code for
+
+        Returns:
+            Complete generated source code as a string
+        """
+        self.output_lines = []
+        self.indent_level = 0
+        self.scope = Scope()
+        self.context = GeneratorContext()
+
+        # Generate header
+        header = self.generate_header()
+        if header:
+            self.output_lines.append(header)
+
+        # Visit the AST
+        self.visit(node)
+
+        # Generate footer
+        footer = self.generate_footer()
+        if footer:
+            self.output_lines.append(footer)
+
+        return '\n'.join(self.output_lines)
+
+    def visit(self, node: QuantumNode) -> Optional[str]:
+        """
+        Visit an AST node using the visitor pattern.
+
+        Dispatches to visit_NodeType method based on node class.
+
+        Args:
+            node: The AST node to visit
+
+        Returns:
+            Optional string result from the visitor
+        """
+        if node is None:
+            return None
+
+        node_type = type(node).__name__
+
+        # Check cache first
+        if node_type not in self._visitor_cache:
+            method_name = f'visit_{node_type}'
+            visitor = getattr(self, method_name, None)
+            self._visitor_cache[node_type] = visitor
+
+        visitor = self._visitor_cache[node_type]
+
+        if visitor:
+            return visitor(node)
+        else:
+            return self.generic_visit(node)
+
+    def generic_visit(self, node: QuantumNode) -> Optional[str]:
+        """
+        Fallback visitor for unhandled node types.
+
+        Override in subclass to provide custom fallback behavior.
+        """
+        node_type = type(node).__name__
+        self.emit_comment(f"TODO: Unhandled node type: {node_type}")
+
+        # Try to visit children if they exist
+        if hasattr(node, 'children') and node.children:
+            for child in node.children:
+                self.visit(child)
+
+        return None
+
+    def visit_children(self, node: QuantumNode) -> List[Optional[str]]:
+        """Visit all children of a node."""
+        results = []
+        if hasattr(node, 'children') and node.children:
+            for child in node.children:
+                result = self.visit(child)
+                results.append(result)
+        return results
+
+    # =========================================================================
+    # Code emission utilities
+    # =========================================================================
+
+    def emit(self, code: str):
+        """
+        Emit a line of code with proper indentation.
+
+        Args:
+            code: The code to emit (without leading indentation)
+        """
+        if code:
+            indent = self.indent_str * self.indent_level
+            self.output_lines.append(f"{indent}{code}")
+        else:
+            self.output_lines.append('')
+
+    def emit_raw(self, code: str):
+        """Emit code without any indentation."""
+        self.output_lines.append(code)
+
+    def emit_blank(self):
+        """Emit a blank line."""
+        self.output_lines.append('')
+
+    def emit_comment(self, comment: str):
+        """Emit a comment (format depends on target language)."""
+        # Default to Python-style comments
+        self.emit(f"# {comment}")
+
+    def emit_block(self, lines: List[str]):
+        """Emit multiple lines with current indentation."""
+        for line in lines:
+            self.emit(line)
+
+    # =========================================================================
+    # Indentation management
+    # =========================================================================
+
+    def indent(self):
+        """Increase indentation level."""
+        self.indent_level += 1
+
+    def dedent(self):
+        """Decrease indentation level."""
+        self.indent_level = max(0, self.indent_level - 1)
+
+    class indented:
+        """Context manager for indented blocks."""
+
+        def __init__(self, generator: 'CodeGenerator'):
+            self.generator = generator
+
+        def __enter__(self):
+            self.generator.indent()
+            return self
+
+        def __exit__(self, *args):
+            self.generator.dedent()
+
+    # =========================================================================
+    # Scope management
+    # =========================================================================
+
+    def push_scope(self):
+        """Enter a new variable scope."""
+        self.scope = Scope(parent=self.scope)
+
+    def pop_scope(self):
+        """Exit current scope and return to parent."""
+        if self.scope.parent:
+            self.scope = self.scope.parent
+
+    def declare_var(self, name: str, type_hint: str = 'Any'):
+        """Declare a variable in current scope."""
+        self.scope.declare(name, type_hint)
+
+    def is_declared(self, name: str) -> bool:
+        """Check if variable is declared in any visible scope."""
+        return self.scope.is_declared(name)
+
+    class scoped:
+        """Context manager for scoped blocks."""
+
+        def __init__(self, generator: 'CodeGenerator'):
+            self.generator = generator
+
+        def __enter__(self):
+            self.generator.push_scope()
+            return self
+
+        def __exit__(self, *args):
+            self.generator.pop_scope()
+
+    # =========================================================================
+    # Expression utilities
+    # =========================================================================
+
+    def extract_expression(self, value: str) -> str:
+        """
+        Extract expression from Quantum {expr} format.
+
+        Args:
+            value: Value that may contain {expression}
+
+        Returns:
+            The expression without braces, or original if no braces
+        """
+        if not value:
+            return ''
+
+        value = str(value).strip()
+
+        if value.startswith('{') and value.endswith('}'):
+            return value[1:-1].strip()
+
+        return value
+
+    def is_expression(self, value: str) -> bool:
+        """Check if value is a Quantum expression {expr}."""
+        if not value:
+            return False
+        value = str(value).strip()
+        return value.startswith('{') and value.endswith('}')
+
+    def is_literal(self, value: str) -> bool:
+        """Check if value is a literal (number, string, boolean)."""
+        if not value:
+            return False
+
+        value = str(value).strip()
+
+        # Check for numeric
+        try:
+            float(value)
+            return True
+        except ValueError:
+            pass
+
+        # Check for boolean
+        if value.lower() in ('true', 'false'):
+            return True
+
+        # Check for quoted string
+        if (value.startswith('"') and value.endswith('"')) or \
+           (value.startswith("'") and value.endswith("'")):
+            return True
+
+        return False
+
+    # =========================================================================
+    # Helper methods
+    # =========================================================================
+
+    def sanitize_identifier(self, name: str) -> str:
+        """
+        Sanitize a name to be a valid identifier.
+
+        Args:
+            name: The name to sanitize
+
+        Returns:
+            A valid identifier string
+        """
+        import re
+        # Replace invalid characters with underscore
+        sanitized = re.sub(r'[^a-zA-Z0-9_]', '_', name)
+        # Ensure doesn't start with number
+        if sanitized and sanitized[0].isdigit():
+            sanitized = '_' + sanitized
+        return sanitized or '_unnamed'
+
+    def generate_temp_var(self, prefix: str = '_temp') -> str:
+        """Generate a unique temporary variable name."""
+        if not hasattr(self, '_temp_counter'):
+            self._temp_counter = 0
+        self._temp_counter += 1
+        return f"{prefix}_{self._temp_counter}"

quantum/compiler/cli.py

@@ -0,0 +1,295 @@
+#!/usr/bin/env python
+"""
+Quantum Transpiler CLI
+======================
+
+Command-line interface for compiling Quantum files.
+
+Usage:
+    quantum compile app.q -o app.py
+    quantum compile app.q --target=javascript -o app.js
+    quantum compile src/ -o dist/ --watch
+"""
+
+import sys
+import os
+import time
+import argparse
+from pathlib import Path
+from typing import Optional
+
+# Add src to path
+
+from quantum.compiler.transpiler import Transpiler, CompilationResult
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create argument parser."""
+    parser = argparse.ArgumentParser(
+        prog='quantum compile',
+        description='Quantum Transpiler - Compile .q files to Python/JavaScript'
+    )
+
+    parser.add_argument(
+        'source',
+        help='Source file or directory'
+    )
+
+    parser.add_argument(
+        '-o', '--output',
+        help='Output file or directory'
+    )
+
+    parser.add_argument(
+        '--target',
+        choices=['python', 'javascript', 'js'],
+        default='python',
+        help='Target language (default: python)'
+    )
+
+    parser.add_argument(
+        '--watch', '-w',
+        action='store_true',
+        help='Watch for file changes'
+    )
+
+    parser.add_argument(
+        '--optimize',
+        action='store_true',
+        help='Enable optimizations'
+    )
+
+    parser.add_argument(
+        '--sourcemap',
+        action='store_true',
+        help='Generate source maps'
+    )
+
+    parser.add_argument(
+        '--strict',
+        action='store_true',
+        help='Treat warnings as errors'
+    )
+
+    parser.add_argument(
+        '--check',
+        action='store_true',
+        help='Check only, do not generate output'
+    )
+
+    parser.add_argument(
+        '--quiet', '-q',
+        action='store_true',
+        help='Minimal output'
+    )
+
+    parser.add_argument(
+        '--verbose', '-v',
+        action='store_true',
+        help='Verbose output'
+    )
+
+    return parser
+
+
+def compile_file(
+    source: Path,
+    output: Optional[Path],
+    transpiler: Transpiler,
+    check_only: bool = False,
+    quiet: bool = False,
+    verbose: bool = False
+) -> bool:
+    """
+    Compile a single file.
+
+    Returns:
+        True if successful
+    """
+    result = transpiler.compile_file(str(source))
+
+    if not result.success:
+        if not quiet:
+            print(f"ERROR: {source}")
+            for error in result.errors:
+                print(f"  {error}")
+        return False
+
+    if check_only:
+        if not quiet:
+            print(f"OK: {source}")
+        return True
+
+    # Determine output path
+    if output is None:
+        ext = transpiler._get_generator().file_extension()
+        output = source.with_suffix(ext)
+
+    # Write output
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(result.code, encoding='utf-8')
+
+    if not quiet:
+        stats = result.stats or {}
+        time_ms = stats.get('compile_time_ms', 0)
+        print(f"OK: {source} -> {output} ({time_ms:.1f}ms)")
+
+    if verbose:
+        print(f"  Lines: {stats.get('source_lines', 0)} -> {stats.get('output_lines', 0)}")
+
+    # Write source map
+    if result.sourcemap and transpiler.sourcemap:
+        map_path = output.with_suffix(output.suffix + '.map')
+        map_path.write_text(result.sourcemap, encoding='utf-8')
+        if verbose:
+            print(f"  Source map: {map_path}")
+
+    # Warnings
+    if result.warnings and not quiet:
+        for warning in result.warnings:
+            print(f"  WARNING: {warning}")
+
+    return True
+
+
+def compile_directory(
+    source_dir: Path,
+    output_dir: Path,
+    transpiler: Transpiler,
+    check_only: bool = False,
+    quiet: bool = False,
+    verbose: bool = False
+) -> int:
+    """
+    Compile all .q files in a directory.
+
+    Returns:
+        Number of errors
+    """
+    errors = 0
+    compiled = 0
+
+    for q_file in source_dir.rglob('*.q'):
+        rel_path = q_file.relative_to(source_dir)
+        ext = transpiler._get_generator().file_extension()
+        output_file = output_dir / rel_path.with_suffix(ext)
+
+        if compile_file(q_file, output_file, transpiler, check_only, quiet, verbose):
+            compiled += 1
+        else:
+            errors += 1
+
+    if not quiet:
+        print(f"\nCompiled {compiled} file(s), {errors} error(s)")
+
+    return errors
+
+
+def watch_directory(
+    source_dir: Path,
+    output_dir: Path,
+    transpiler: Transpiler,
+    quiet: bool = False,
+    verbose: bool = False
+):
+    """Watch directory for changes and recompile."""
+    try:
+        from watchdog.observers import Observer
+        from watchdog.events import FileSystemEventHandler, FileModifiedEvent, FileCreatedEvent
+    except ImportError:
+        print("ERROR: watchdog package required for --watch")
+        print("  Install: pip install watchdog")
+        sys.exit(1)
+
+    class QuantumHandler(FileSystemEventHandler):
+        def on_modified(self, event):
+            if event.is_directory:
+                return
+            if event.src_path.endswith('.q'):
+                self._compile(Path(event.src_path))
+
+        def on_created(self, event):
+            if event.is_directory:
+                return
+            if event.src_path.endswith('.q'):
+                self._compile(Path(event.src_path))
+
+        def _compile(self, q_file: Path):
+            rel_path = q_file.relative_to(source_dir)
+            ext = transpiler._get_generator().file_extension()
+            output_file = output_dir / rel_path.with_suffix(ext)
+            compile_file(q_file, output_file, transpiler, False, quiet, verbose)
+
+    # Initial compile
+    print("Initial compilation...")
+    compile_directory(source_dir, output_dir, transpiler, False, quiet, verbose)
+
+    # Start watching
+    print(f"\nWatching {source_dir} for changes... (Ctrl+C to stop)")
+
+    observer = Observer()
+    observer.schedule(QuantumHandler(), str(source_dir), recursive=True)
+    observer.start()
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        observer.stop()
+        print("\nStopped.")
+
+    observer.join()
+
+
+def main(argv=None):
+    """Main entry point."""
+    parser = create_parser()
+    args = parser.parse_args(argv)
+
+    # Normalize target
+    target = args.target
+    if target == 'js':
+        target = 'javascript'
+
+    # Create transpiler
+    transpiler = Transpiler(
+        target=target,
+        optimize=args.optimize,
+        sourcemap=args.sourcemap,
+        strict=args.strict
+    )
+
+    source = Path(args.source)
+
+    if not source.exists():
+        print(f"ERROR: Source not found: {source}")
+        sys.exit(1)
+
+    if source.is_file():
+        # Single file
+        output = Path(args.output) if args.output else None
+        success = compile_file(
+            source, output, transpiler,
+            args.check, args.quiet, args.verbose
+        )
+        sys.exit(0 if success else 1)
+
+    elif source.is_dir():
+        # Directory
+        if not args.output:
+            output_dir = source.parent / (source.name + '_compiled')
+        else:
+            output_dir = Path(args.output)
+
+        if args.watch:
+            watch_directory(source, output_dir, transpiler, args.quiet, args.verbose)
+        else:
+            errors = compile_directory(
+                source, output_dir, transpiler,
+                args.check, args.quiet, args.verbose
+            )
+            sys.exit(1 if errors > 0 else 0)
+
+
+if __name__ == '__main__':
+    main()