zexus 1.6.6 → 1.6.8

package/README.md

@@ -2,7 +2,7 @@
 
 <div align="center">
 
-![Zexus Logo](https://img.shields.io/badge/Zexus-v1.6.6-FF6B35?style=for-the-badge)
+![Zexus Logo](https://img.shields.io/badge/Zexus-v1.6.8-FF6B35?style=for-the-badge)
 [![License](https://img.shields.io/badge/License-MIT-blue.svg?style=for-the-badge)](LICENSE)
 [![Python](https://img.shields.io/badge/Python-3.8+-3776AB?style=for-the-badge&logo=python)](https://python.org)
 [![GitHub](https://img.shields.io/badge/GitHub-Zaidux/zexus--interpreter-181717?style=for-the-badge&logo=github)](https://github.com/Zaidux/zexus-interpreter)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zexus",
-  "version": "1.6.6",
+  "version": "1.6.8",
   "description": "A modern, security-first programming language with blockchain support",
   "main": "index.js",
   "bin": {

package/src/zexus/__init__.py

@@ -4,7 +4,7 @@ Zexus Programming Language
 A declarative, intent-based programming language for modern applications.
 """
 
-__version__ = "1.6.6"
+__version__ = "1.6.8"
 __author__ = "Ziver Labs"
 __email__ = "ziverofficial567@gmail.com"
 

package/src/zexus/cli/main.py

@@ -20,6 +20,9 @@ from ..hybrid_orchestrator import orchestrator
 from ..config import config
 # Import error handling
 from ..error_reporter import get_error_reporter, ZexusError, print_error
+# VM and Compiler for high-performance execution
+from ..vm.vm import VM, VMMode
+from ..vm.compiler import compile_ast_to_bytecode
 
 console = Console()
 
@@ -91,7 +94,7 @@ def show_all_commands():
     console.print("\n[bold green]💡 Tip:[/bold green] Use 'zx <command> --help' for detailed command options\n")
 
 @click.group(invoke_without_command=True)
-@click.version_option(version="1.6.6", prog_name="Zexus")
+@click.version_option(version="1.6.8", prog_name="Zexus")
 @click.option('--syntax-style', type=click.Choice(['universal', 'tolerable', 'auto']),
               default='auto', help='Syntax style to use (universal=strict, tolerable=flexible)')
 @click.option('--advanced-parsing', is_flag=True, default=True,
@@ -133,8 +136,12 @@ def cli(ctx, syntax_style, advanced_parsing, execution_mode, debug, zexus):
 @cli.command()
 @click.argument('file', type=click.Path(exists=True))
 @click.argument('args', nargs=-1)  # Accept any number of additional arguments
+@click.option('--use-vm', is_flag=True, default=True, help='Use VM for execution (default: enabled for performance)')
+@click.option('--vm-mode', type=click.Choice(['auto', 'stack', 'register', 'parallel']),
+              default='auto', help='VM execution mode (auto=best performance)')
+@click.option('--no-optimize', is_flag=True, default=False, help='Disable bytecode optimizations')
 @click.pass_context
-def run(ctx, file, args):
+def run(ctx, file, args, use_vm, vm_mode, no_optimize):
     """Run a Zexus program with hybrid execution"""
     # Register source for error reporting
     error_reporter = get_error_reporter()
@@ -155,6 +162,8 @@ def run(ctx, file, args):
         console.print(f"🔧 [bold blue]Execution mode:[/bold blue] {execution_mode}")
         console.print(f"📝 [bold blue]Syntax style:[/bold blue] {syntax_style}")
         console.print(f"🎯 [bold blue]Advanced parsing:[/bold blue] {'Enabled' if advanced_parsing else 'Disabled'}")
+        if use_vm:
+            console.print(f"⚡ [bold magenta]VM Mode:[/bold magenta] {vm_mode.upper()} | Optimizations: {'OFF' if no_optimize else 'ON'}")
         
         # Auto-detect syntax style if needed
         if syntax_style == 'auto':
@@ -221,8 +230,52 @@ def run(ctx, file, args):
             pass  # Unable to determine package name
         env.set("__PACKAGE__", package_name)
         
-        # UPDATED: Use the evaluate function from the evaluator package
-        result = evaluate(program, env, debug_mode=ctx.obj['DEBUG'])
+        # Execute based on mode
+        if use_vm:
+            # VM EXECUTION PATH (High Performance)
+            console.print("[dim]Compiling to bytecode...[/dim]", end="")
+            try:
+                bytecode = compile_ast_to_bytecode(program, optimize=not no_optimize)
+                console.print(" [green]done[/green]")
+                console.print(f"[dim]Bytecode: {len(bytecode.instructions)} instructions, {len(bytecode.constants)} constants[/dim]")
+            except Exception as e:
+                console.print(f" [red]failed[/red]")
+                console.print(f"[bold red]Bytecode compilation error:[/bold red] {str(e)}")
+                if ctx.obj.get('DEBUG'):
+                    import traceback
+                    traceback.print_exc()
+                sys.exit(1)
+            
+            # Initialize VM
+            vm_mode_enum = {
+                'auto': VMMode.AUTO,
+                'stack': VMMode.STACK,
+                'register': VMMode.REGISTER,
+                'parallel': VMMode.PARALLEL
+            }[vm_mode]
+            
+            console.print(f"[dim]Initializing VM ({vm_mode} mode)...[/dim]", end="")
+            vm = VM(
+                mode=vm_mode_enum,
+                use_jit=not no_optimize,
+                max_heap_mb=1000,  # 1GB heap limit
+                debug=ctx.obj.get('DEBUG', False)
+            )
+            console.print(" [green]done[/green]")
+            
+            # Execute on VM
+            console.print("[dim]Executing on VM...[/dim]")
+            try:
+                result = vm.execute(bytecode, debug=ctx.obj.get('DEBUG', False))
+            except Exception as e:
+                console.print(f"[bold red]VM Execution error:[/bold red] {str(e)}")
+                if ctx.obj.get('DEBUG'):
+                    import traceback
+                    traceback.print_exc()
+                sys.exit(1)
+        else:
+            # INTERPRETER EXECUTION PATH (Standard)
+            result = evaluate(program, env, debug_mode=ctx.obj['DEBUG'])
         
         if result and hasattr(result, 'inspect') and result.inspect() != 'null':
             console.print(f"\n✅ [bold green]Result:[/bold green] {result.inspect()}")

package/src/zexus/cli/zpm.py

@@ -18,7 +18,7 @@ console = Console()
 
 
 @click.group()
-@click.version_option(version="1.6.6", prog_name="ZPM")
+@click.version_option(version="1.6.8", prog_name="ZPM")
 def cli():
     """ZPM - Zexus Package Manager
     

package/src/zexus/evaluator/bytecode_compiler.py

@@ -4,6 +4,7 @@ Bytecode Compiler for Evaluator
 This module allows the evaluator to compile AST nodes to bytecode
 for VM execution when performance is critical.
 """
+import os
 from typing import Dict, List, Optional
 from .. import zexus_ast
 from ..vm.bytecode import Bytecode, BytecodeBuilder
@@ -145,13 +146,15 @@ class EvaluatorBytecodeCompiler:
         # Compile the value expression
         self._compile_node(node.value)
         # Store it
-        self.builder.emit_store(node.name.value)
+        name = str(node.name.value).strip()
+        self.builder.emit_store(name)
     
     def _compile_ConstStatement(self, node: zexus_ast.ConstStatement):
         """Compile const statement"""
         # Similar to let for now
         self._compile_node(node.value)
-        self.builder.emit_store(node.name.value)
+        name = str(node.name.value).strip()
+        self.builder.emit_store(name)
     
     def _compile_ReturnStatement(self, node: zexus_ast.ReturnStatement):
         """Compile return statement"""
@@ -314,7 +317,7 @@ class EvaluatorBytecodeCompiler:
         
         # Store function descriptor
         func_const_idx = self.builder.bytecode.add_constant(func_desc)
-        name_idx = self.builder.bytecode.add_constant(node.name.value)
+        name_idx = self.builder.bytecode.add_constant(str(node.name.value).strip())
         self.builder.emit("STORE_FUNC", (name_idx, func_const_idx))
     
     def _compile_FunctionStatement(self, node: zexus_ast.FunctionStatement):
@@ -426,7 +429,15 @@ class EvaluatorBytecodeCompiler:
     
     def _compile_Identifier(self, node: zexus_ast.Identifier):
         """Compile identifier (variable load)"""
-        self.builder.emit_load(node.value)
+        name = str(node.value).strip()
+        profile_flag = os.environ.get("ZEXUS_VM_PROFILE_OPS")
+        verbose_flag = os.environ.get("ZEXUS_VM_PROFILE_VERBOSE")
+        if (
+            profile_flag and profile_flag.lower() not in ("0", "false", "off")
+            and verbose_flag and verbose_flag.lower() not in ("0", "false", "off")
+        ):
+            print(f"[VM DEBUG] compile identifier raw={node.value!r} normalized={name!r}")
+        self.builder.emit_load(name)
     
     def _compile_IntegerLiteral(self, node: zexus_ast.IntegerLiteral):
         """Compile integer literal"""
@@ -558,6 +569,21 @@ class EvaluatorBytecodeCompiler:
         self._compile_node(node.expression)
         # Emit await
         self.builder.emit("AWAIT")
+
+    def _compile_MethodCallExpression(self, node: zexus_ast.MethodCallExpression):
+        """Compile method call (object.method(...))"""
+        if self.builder is None:
+            return
+
+        # Load object first so it sits below the arguments on the stack
+        self._compile_node(node.object)
+
+        # Compile arguments in order
+        for arg in node.arguments:
+            self._compile_node(arg)
+
+        method_name = node.method.value if hasattr(node.method, 'value') else str(node.method)
+        self.builder.emit_call_method(method_name, len(node.arguments))
     
     def _compile_SpawnExpression(self, node):
         """Compile spawn expression"""
@@ -573,7 +599,8 @@ class EvaluatorBytecodeCompiler:
         # Store to name
         if isinstance(node.name, zexus_ast.Identifier):
             self.builder.emit("DUP")  # Keep value on stack
-            self.builder.emit_store(node.name.value)
+            name = str(node.name.value).strip()
+            self.builder.emit_store(name)
         else:
             self.errors.append(
                 "Complex assignment targets not yet supported in bytecode")
@@ -587,6 +614,53 @@ class EvaluatorBytecodeCompiler:
         # Emit index operation
         self.builder.emit("INDEX")
     
+    def _compile_PropertyAccessExpression(self, node):
+        """Compile property access (obj.property or obj[property])"""
+        # Compile the object
+        self._compile_node(node.object)
+        
+        # Check if computed (obj[expr]) or literal (obj.prop)
+        if hasattr(node, 'computed') and node.computed:
+            # Computed property - evaluate the expression
+            self._compile_node(node.property)
+            self.builder.emit("INDEX")
+        else:
+            # Literal property - emit as constant string and use GET_ATTR
+            if hasattr(node.property, 'value'):
+                prop_name = node.property.value
+            else:
+                # Fallback - evaluate it
+                self._compile_node(node.property)
+                self.builder.emit("INDEX")
+                return
+            
+            # Emit property name as constant
+            self.builder.emit_constant(prop_name)
+            self.builder.emit("GET_ATTR")
+    
+    def _compile_LambdaExpression(self, node):
+        """Compile lambda/anonymous function"""
+        # Create nested bytecode for lambda body
+        inner_compiler = EvaluatorBytecodeCompiler()
+        func_bytecode = inner_compiler.compile(node.body, optimize=False)
+        
+        if inner_compiler.errors:
+            self.errors.extend(inner_compiler.errors)
+            self.builder.emit_constant(None)
+            return
+        
+        # Build lambda descriptor
+        params = [p.value if hasattr(p, 'value') else str(p) for p in node.parameters] if hasattr(node, 'parameters') else []
+        lambda_desc = {
+            "bytecode": func_bytecode,
+            "params": params,
+            "is_lambda": True
+        }
+        
+        # Push lambda descriptor as constant
+        self.builder.emit_constant(lambda_desc)
+        self.builder.emit("BUILD_LAMBDA")
+    
     # === Optimization ===
     
     def _optimize(self, bytecode: Bytecode) -> Bytecode:
@@ -595,12 +669,218 @@ class EvaluatorBytecodeCompiler:
         
         Optimizations:
         - Remove unnecessary POP instructions
-        - Constant folding
-        - Dead code elimination
+        - Constant folding (compile-time evaluation)
+        - Dead code elimination  
+        - Algebraic simplifications
+        - Redundant operation removal
         """
-        # For now, return as-is
-        # Future: implement optimization passes
-        return bytecode
+        from zexus.vm.bytecode import Bytecode, Opcode
+        
+        instructions = bytecode.instructions
+        if not instructions:
+            return bytecode
+        
+        # Multiple optimization passes for better results
+        optimized = instructions
+        optimized = self._constant_folding(optimized, bytecode.constants)
+        optimized = self._dead_code_elimination(optimized)
+        optimized = self._peephole_patterns(optimized)
+        optimized = self._remove_redundant_jumps(optimized)
+        
+        # Create new bytecode with optimized instructions
+        new_bytecode = Bytecode()
+        new_bytecode.instructions = optimized
+        new_bytecode.constants = bytecode.constants.copy()
+        new_bytecode.names = bytecode.names.copy()
+        new_bytecode.labels = bytecode.labels.copy()
+        
+        return new_bytecode
+    
+    def _constant_folding(self, instructions, constants):
+        """
+        Fold constant expressions at compile time.
+        Example: LOAD_CONST 2, LOAD_CONST 3, ADD → LOAD_CONST 5
+        """
+        optimized = []
+        i = 0
+        
+        while i < len(instructions):
+            inst = instructions[i]
+            
+            # Look for pattern: LOAD_CONST, LOAD_CONST, <BINARY_OP>
+            if (i + 2 < len(instructions) and
+                inst[0] == 'LOAD_CONST' and
+                instructions[i+1][0] == 'LOAD_CONST'):
+                
+                op = instructions[i+2][0]
+                
+                # Get constant values
+                const1 = constants[inst[1]] if inst[1] < len(constants) else None
+                const2 = constants[instructions[i+1][1]] if instructions[i+1][1] < len(constants) else None
+                
+                if const1 is not None and const2 is not None:
+                    result = self._try_constant_operation(const1, const2, op)
+                    
+                    if result is not None:
+                        # Add result as new constant
+                        const_idx = len(constants)
+                        constants.append(result)
+                        
+                        # Replace three instructions with one
+                        optimized.append(('LOAD_CONST', const_idx))
+                        i += 3
+                        continue
+            
+            # No optimization possible, keep instruction
+            optimized.append(inst)
+            i += 1
+        
+        return optimized
+    
+    def _try_constant_operation(self, val1, val2, op):
+        """Try to evaluate constant operation, return None if not possible"""
+        try:
+            # Import Zexus object types
+            from zexus.objects import Integer, Float, String, Boolean as BooleanObj
+            
+            # Extract Python values
+            v1 = val1.value if hasattr(val1, 'value') else val1
+            v2 = val2.value if hasattr(val2, 'value') else val2
+            
+            # Arithmetic operations
+            if op == 'ADD':
+                if isinstance(v1, str) or isinstance(v2, str):
+                    return String(str(v1) + str(v2))
+                return Integer(v1 + v2) if isinstance(v1, int) and isinstance(v2, int) else Float(v1 + v2)
+            elif op == 'SUB':
+                return Integer(v1 - v2) if isinstance(v1, int) and isinstance(v2, int) else Float(v1 - v2)
+            elif op == 'MUL':
+                return Integer(v1 * v2) if isinstance(v1, int) and isinstance(v2, int) else Float(v1 * v2)
+            elif op == 'DIV':
+                if v2 == 0:
+                    return None  # Don't fold division by zero
+                result = v1 / v2
+                return Integer(int(result)) if result == int(result) else Float(result)
+            
+            # Comparison operations
+            elif op == 'EQ':
+                return BooleanObj(v1 == v2)
+            elif op == 'NE':
+                return BooleanObj(v1 != v2)
+            elif op == 'LT':
+                return BooleanObj(v1 < v2)
+            elif op == 'GT':
+                return BooleanObj(v1 > v2)
+            elif op == 'LTE':
+                return BooleanObj(v1 <= v2)
+            elif op == 'GTE':
+                return BooleanObj(v1 >= v2)
+            
+            # Logical operations
+            elif op == 'AND':
+                return BooleanObj(bool(v1) and bool(v2))
+            elif op == 'OR':
+                return BooleanObj(bool(v1) or bool(v2))
+            
+        except:
+            pass
+        
+        return None
+    
+    def _dead_code_elimination(self, instructions):
+        """Remove unreachable code (code after RETURN, unconditional jumps to next instruction, etc.)"""
+        optimized = []
+        skip_until_label = False
+        
+        for i, inst in enumerate(instructions):
+            # If we're skipping dead code, only stop at labels
+            if skip_until_label:
+                if inst[0] == 'LABEL':
+                    skip_until_label = False
+                else:
+                    continue  # Skip this instruction
+            
+            # After a RETURN or unconditional JUMP, skip until next label
+            if inst[0] == 'RETURN' or inst[0] == 'JUMP':
+                optimized.append(inst)
+                skip_until_label = True
+                continue
+            
+            optimized.append(inst)
+        
+        return optimized
+    
+    def _peephole_patterns(self, instructions):
+        """Match and optimize common instruction patterns"""
+        optimized = []
+        i = 0
+        
+        while i < len(instructions):
+            inst = instructions[i]
+            
+            # Pattern: LOAD_CONST x, POP → (remove both)
+            if (i + 1 < len(instructions) and
+                inst[0] == 'LOAD_CONST' and
+                instructions[i+1][0] == 'POP'):
+                i += 2  # Skip both instructions
+                continue
+            
+            # Pattern: LOAD_NAME x, STORE_NAME x → (remove both - noop)
+            if (i + 1 < len(instructions) and
+                inst[0] == 'LOAD_NAME' and
+                instructions[i+1][0] == 'STORE_NAME' and
+                inst[1] == instructions[i+1][1]):  # Same variable
+                i += 2  # Skip both instructions
+                continue
+            
+            # Pattern: DUP, POP → (remove both)
+            if (i + 1 < len(instructions) and
+                inst[0] == 'DUP' and
+                instructions[i+1][0] == 'POP'):
+                i += 2
+                continue
+            
+            # Algebraic simplifications with LOAD_CONST
+            # Pattern: LOAD_NAME x, LOAD_CONST 0, ADD → LOAD_NAME x (adding 0 is noop)
+            if (i + 2 < len(instructions) and
+                inst[0] == 'LOAD_NAME' and
+                instructions[i+1][0] == 'LOAD_CONST' and
+                instructions[i+2][0] == 'ADD'):
+                
+                const_val = instructions[i+1][1]
+                # Check if constant is 0 (would need to look up in constants array, skip for now)
+                # This is a more complex optimization
+                pass
+            
+            # Pattern: LOAD_NAME x, LOAD_CONST 1, MUL → LOAD_NAME x (multiplying by 1 is noop)
+            # Similar to above, needs constant value lookup
+            
+            # No optimization, keep instruction
+            optimized.append(inst)
+            i += 1
+        
+        return optimized
+    
+    def _remove_redundant_jumps(self, instructions):
+        """Remove jumps to the immediately next instruction"""
+        optimized = []
+        
+        for i, inst in enumerate(instructions):
+            # Check if this is a JUMP instruction
+            if inst[0] in ('JUMP', 'JUMP_IF_TRUE', 'JUMP_IF_FALSE'):
+                # Check if it jumps to the next instruction
+                target = inst[1]
+                
+                # Look ahead to see if next instruction is the target label
+                if i + 1 < len(instructions):
+                    next_inst = instructions[i+1]
+                    if next_inst[0] == 'LABEL' and next_inst[1] == target:
+                        # Skip this jump, it's redundant
+                        continue
+            
+            optimized.append(inst)
+        
+        return optimized
     
     def can_compile(self, node) -> bool:
         """
@@ -618,9 +898,13 @@ class EvaluatorBytecodeCompiler:
             'ReturnStatement', 'ContinueStatement', 'IfStatement', 'WhileStatement', 'ForEachStatement',
             'BlockStatement', 'ActionStatement', 'FunctionStatement', 'PrintStatement',
             'Identifier', 'IntegerLiteral', 'FloatLiteral',
-            'StringLiteral', 'Boolean', 'ListLiteral', 'MapLiteral',
+            'StringLiteral', 'Boolean', 'ListLiteral', 'MapLiteral', 'NullLiteral',
             'InfixExpression', 'PrefixExpression', 'CallExpression',
-            'AwaitExpression', 'AssignmentExpression', 'IndexExpression'
+            'AwaitExpression', 'SpawnExpression', 'AssignmentExpression', 'IndexExpression',
+            'PropertyAccessExpression', 'LambdaExpression',
+            # Blockchain nodes
+            'TxStatement', 'RevertStatement', 'RequireStatement',
+            'StateAccessExpression', 'LedgerAppendStatement', 'GasChargeStatement'
         }
         
         return node_type in supported