scope.py

"""
Scope analysis for Eva compiler
"""

from opcodes import OP_GET_LOCAL, OP_SET_LOCAL, OP_GET_CELL, OP_SET_CELL, OP_GET_GLOBAL, OP_SET_GLOBAL

# Scope types
SCOPE_GLOBAL = 'GLOBAL'
SCOPE_FUNCTION = 'FUNCTION'
SCOPE_BLOCK = 'BLOCK'
SCOPE_CLASS = 'CLASS'

# Allocation types
ALLOC_GLOBAL = 'GLOBAL'
ALLOC_LOCAL = 'LOCAL'
ALLOC_CELL = 'CELL'

def make_scope(scope_type, parent=None):
    """Create a new scope"""
    return {
        'type': scope_type,
        'parent': parent,
        'alloc_info': {},  # name -> allocation type
        'free': set(),      # free variables
        'cells': set()      # cell variables
    }

def scope_add_local(scope, name):
    """Add a local variable to scope"""
    alloc_type = ALLOC_GLOBAL if scope['type'] == SCOPE_GLOBAL else ALLOC_LOCAL
    scope['alloc_info'][name] = alloc_type

def scope_add_cell(scope, name):
    """Add a cell variable to scope"""
    scope['cells'].add(name)
    scope['alloc_info'][name] = ALLOC_CELL

def scope_add_free(scope, name):
    """Add a free variable to scope"""
    scope['free'].add(name)
    scope['alloc_info'][name] = ALLOC_CELL

def scope_resolve(scope, name, alloc_type):
    """Resolve a variable in the scope chain"""
    # Found in current scope
    if name in scope['alloc_info']:
        return scope, alloc_type
    
    # Crossed function boundary - becomes free variable
    if scope['type'] == SCOPE_FUNCTION:
        alloc_type = ALLOC_CELL
    
    # No parent - error
    if scope['parent'] is None:
        raise Exception(f"Reference error: {name} is not defined")
    
    # Resolve in global scope as global
    if scope['parent']['type'] == SCOPE_GLOBAL:
        alloc_type = ALLOC_GLOBAL
    
    return scope_resolve(scope['parent'], name, alloc_type)

def scope_promote(scope, name, owner_scope):
    """Promote a variable from local to cell"""
    # Mark as cell in owner scope
    scope_add_cell(owner_scope, name)
    
    # Mark as free in all intermediate scopes
    current = scope
    while current is not owner_scope:
        scope_add_free(current, name)
        current = current['parent']

def scope_maybe_promote(scope, name):
    """Potentially promote a variable from local to cell"""
    init_alloc_type = ALLOC_GLOBAL if scope['type'] == SCOPE_GLOBAL else ALLOC_LOCAL
    
    if name in scope['alloc_info']:
        init_alloc_type = scope['alloc_info'][name]
    
    # Already promoted
    if init_alloc_type == ALLOC_CELL:
        return
    
    # Resolve the variable
    owner_scope, alloc_type = scope_resolve(scope, name, init_alloc_type)
    
    # Update allocation type
    scope['alloc_info'][name] = alloc_type
    
    # Promote if it's a cell
    if alloc_type == ALLOC_CELL:
        scope_promote(scope, name, owner_scope)

def scope_get_name_getter(scope, name):
    """Get the opcode for getting a variable"""
    alloc_type = scope['alloc_info'][name]
    if alloc_type == ALLOC_LOCAL:
        return OP_GET_LOCAL
    elif alloc_type == ALLOC_CELL:
        return OP_GET_CELL
    else:
        return OP_GET_GLOBAL

def scope_get_name_setter(scope, name):
    """Get the opcode for setting a variable"""
    alloc_type = scope['alloc_info'][name]
    if alloc_type == ALLOC_LOCAL:
        return OP_SET_LOCAL
    elif alloc_type == ALLOC_CELL:
        return OP_SET_CELL
    else:
        return OP_SET_GLOBAL