Symbol Table Internals — Missing Scope Pop Breaks Assembly

package io.thecodeforge.compiler;

import java.util.*;

public class SymbolTable {
    private final Stack<Map<String, Symbol>> scopeStack = new Stack<>();

    public void enterScope() {
        scopeStack.push(new HashMap<>());
    }

    public void exitScope() {
        scopeStack.pop();
    }

    public void insert(String name, Symbol sym) {\n        if (scopeStack.isEmpty()) {\n            throw new IllegalStateException(\"No active scope\");\n        }\n        Map<String, Symbol> current = scopeStack.peek();\n        if (current.containsKey(name)) {\n            throw new IllegalArgumentException(\"Duplicate symbol: \" + name);\n        }\n        current.put(name, sym);\n    }\n\n    public Symbol lookup(String name) {\n        for (int i = scopeStack.size() - 1; i >= 0; i--) {\n            Map<String, Symbol> scope = scopeStack.get(i);\n            Symbol sym = scope.get(name);\n            if (sym != null) return sym;\n        }\n        return null;\n    }\n\n    public Symbol lookupCurrentScope(String name) {\n        if (scopeStack.isEmpty()) return null;\n        return scopeStack.peek().get(name);\n    }\n\n    public void dumpAll() {\n        System.out.println(\"=== Symbol Table Dump ===\");\n        for (int i = scopeStack.size() - 1; i >= 0; i--) {\n            System.out.println(\"Scope \" + i + \": \" + scopeStack.get(i));\n        }\n    }\n\n    public static class Symbol {\n        public final String name;\n        public final String type;\n        public final int offset;\n\n        public Symbol(String name, String type, int offset) {\n            this.name = name;\n            this.type = type;\n            this.offset = offset;\n        }\n\n        @Override\n        public String toString() {\n            return name + \":\" + type + \"@\" + offset;\n        }\n    }\n}",
        "output": ""
      }

package io.thecodeforge.compiler;

import java.util.*;

public class LinkedScopeSymbolTable {
    // Each symbol has a chain of entries (one per scope)
    private final HashMap<String, LinkedList<Symbol>> globalTable = new HashMap<>();
    private final Stack<HashMap<String, Symbol>> scopeStack = new Stack<>();

    public void enterScope() {
        scopeStack.push(new HashMap<>());
    }

    public void exitScope() {
        HashMap<String, Symbol> exiting = scopeStack.pop();
        for (Map.Entry<String, Symbol> e : exiting.entrySet()) {
            LinkedList<Symbol> chain = globalTable.get(e.getKey());
            if (chain != null && !chain.isEmpty()) {
                chain.removeLast();
                if (chain.isEmpty()) {
                    globalTable.remove(e.getKey());
                }
            }
        }
    }

    public void insert(String name, Symbol sym) {\n        if (scopeStack.isEmpty()) throw new IllegalStateException(\"No scope\");\n        scopeStack.peek().put(name, sym);\n        globalTable.computeIfAbsent(name, k -> new LinkedList<>()).addLast(sym);\n    }\n\n    public Symbol lookup(String name) {\n        LinkedList<Symbol> chain = globalTable.get(name);\n        if (chain == null || chain.isEmpty()) return null;\n        return chain.getLast(); // most recent scope's entry\n    }\n\n    public void dump() {\n        System.out.println(\"Linked scope table dump:\");\n        globalTable.forEach((name, chain) -> {\n            System.out.println(name + \" -> \" + chain);\n        });\n    }\n}",
        "output": ""
      }

package io.thecodeforge.compiler;

import java.util.*;

public class SymbolTypes {
    // Base symbol entry
    public static class Symbol {
        public final String name;
        public final int scopeDepth;
        public final ASTNode node;

        public Symbol(String name, int scopeDepth, ASTNode node) {\n            this.name = name;\n            this.scopeDepth = scopeDepth;\n            this.node = node;\n        }
    }

    public static class VariableSymbol extends Symbol {
        public final String type;
        public final int offset;
        public final boolean isConst;

        public VariableSymbol(String name, int scopeDepth, ASTNode node, String type, int offset, boolean isConst) {\n            super(name, scopeDepth, node);\n            this.type = type;\n            this.offset = offset;\n            this.isConst = isConst;\n        }
    }

    public static class FunctionSymbol extends Symbol {
        public final String returnType;
        public final List<VariableSymbol> parameters;
        public final String label;

        public FunctionSymbol(String name, int scopeDepth, ASTNode node, String returnType, List<VariableSymbol> parameters, String label) {\n            super(name, scopeDepth, node);\n            this.returnType = returnType;\n            this.parameters = Collections.unmodifiableList(parameters);\n            this.label = label;\n        }
    }

    public static class ClassSymbol extends Symbol {
        public final Map<String, VariableSymbol> fields;
        public final Map<String, FunctionSymbol> methods;
        public final String parentClassName;

        public ClassSymbol(String name, int scopeDepth, ASTNode node, Map<String, VariableSymbol> fields, Map<String, FunctionSymbol> methods, String parentClassName) {
            super(name, scopeDepth, node);
            this.fields = Collections.unmodifiableMap(fields);
            this.methods = Collections.unmodifiableMap(methods);
            this.parentClassName = parentClassName;
        }
    }

    // Placeholder for ASTNode
    public static class ASTNode {
        // ... real AST node fields
    }
}

package io.thecodeforge.compiler;

import java.util.*;

public class HashSymbolTable<K, V> {\n    private static class Entry<K, V> {\n        K key;\n        V value;\n        Entry<K, V> next;\n    }

    private Entry<K, V>[] buckets;
    private int size = 0;
    private final double loadFactor;

    @SuppressWarnings("unchecked")
    public HashSymbolTable(int initialCapacity, double loadFactor) {\n        this.buckets = (Entry<K, V>[]) new Entry[initialCapacity];\n        this.loadFactor = loadFactor;\n    }

    public HashSymbolTable() {
        this(16, 0.75);
    }

    private int hash(K key) {
        return (key.hashCode() & 0x7FFFFFFF) % buckets.length;
    }

    public V put(K key, V value) {\n        int idx = hash(key);\n        Entry<K, V> existing = buckets[idx];\n        while (existing != null) {\n            if (existing.key.equals(key)) {\n                V old = existing.value;\n                existing.value = value;\n                return old;\n            }
            existing = existing.next;
        }
        // No collision: insert at front
        Entry<K, V> newEntry = new Entry<>();
        newEntry.key = key;
        newEntry.value = value;
        newEntry.next = buckets[idx];
        buckets[idx] = newEntry;
        size++;
        if (size > loadFactor * buckets.length) {
            rehash();
        }
        return null;
    }

    public V get(K key) {
        int idx = hash(key);
        Entry<K, V> entry = buckets[idx];
        while (entry != null) {
            if (entry.key.equals(key)) {
                return entry.value;
            }
            entry = entry.next;
        }
        return null;
    }

    public V remove(K key) {
        int idx = hash(key);
        Entry<K, V> prev = null;
        Entry<K, V> entry = buckets[idx];
        while (entry != null) {
            if (entry.key.equals(key)) {
                if (prev == null) {
                    buckets[idx] = entry.next;
                } else {
                    prev.next = entry.next;
                }
                size--;
                return entry.value;
            }
            prev = entry;
            entry = entry.next;
        }
        return null;
    }

    @SuppressWarnings("unchecked")
    private void rehash() {
        int newCap = buckets.length * 2;
        Entry<K, V>[] newBuckets = (Entry<K, V>[]) new Entry[newCap];
        for (Entry<K, V> e : buckets) {\n            while (e != null) {\n                int newIdx = (e.key.hashCode() & 0x7FFFFFFF) % newCap;\n                Entry<K, V> next = e.next;\n                e.next = newBuckets[newIdx];\n                newBuckets[newIdx] = e;\n                e = next;\n            }
        }
        buckets = newBuckets;
    }
}

#ifndef IO_THECODEFORGE_COMPILER_SIMPLE_SYMBOLTABLE_H
#define IO_THECODEFORGE_COMPILER_SIMPLE_SYMBOLTABLE_H

#include <string>
#include <vector>
#include <algorithm>

namespace io_thecodeforge_compiler {

struct Symbol {
    std::string name;
    std::string type;
    int offset;
};

class SimpleSymbolTable {
public:
    // Binary search based table, sorted by name
    void insert(const Symbol& sym) {
        // Linear search to check duplicate, then insert sorted
        for (auto& s : symbols) {
            if (s.name == sym.name) return; // duplicate
        }
        symbols.push_back(sym);
        std::sort(symbols.begin(), symbols.end(), [](const Symbol& a, const Symbol& b) {\n            return a.name < b.name;\n        });
    }

    Symbol* lookup(const std::string& name) {
        auto it = std::lower_bound(symbols.begin(), symbols.end(), name,
            [](const Symbol& sym, const std::string& n) {\n                return sym.name < n;\n            });
        if (it != symbols.end() && it->name == name) {
            return &(*it);
        }
        return nullptr;
    }

private:
    std::vector<Symbol> symbols;
};

} // namespace

#endif

class SymbolTable:
    def __init__(self):
        self._scopes = [{}]  # current scope first

    def insert(self, name, attributes):
        self._scopes[-1][name] = attributes

    def lookup(self, name):
        for scope in reversed(self._scopes):
            if name in scope:
                return scope[name]
        return None

    def push_scope(self):
        self._scopes.append({})

    def pop_scope(self):
        self._scopes.pop()

    def modify(self, name, key, value):
        entry = self.lookup(name)
        if entry is None:
            raise KeyError(f"Undeclared identifier: {name}")
        if entry.get('readonly'):
            raise PermissionError(f"Cannot modify read-only: {name}")
        entry[key] = value

# Example: type inference modifies type attribute
st = SymbolTable()
st.insert('x', {'type': None, 'readonly': False})
st.modify('x', 'type', 'int')

class NestedSymbolTable:
    def __init__(self):
        self._scopes = [{}]
        self._depth = 0

    def enter_scope(self):
        self._scopes.append({})
        self._depth += 1

    def exit_scope(self):
        self._scopes.pop()
        self._depth -= 1

    def insert(self, name, attributes):
        attributes['scope_depth'] = self._depth
        self._scopes[-1][name] = attributes

    def lookup(self, name):
        for scope in reversed(self._scopes):
            if name in scope:
                return scope[name]
        return None

# Simulating nested functions
st = NestedSymbolTable()
st.insert('x', {'type': 'int'})  # global x
st.enter_scope()  # function A
st.insert('x', {'type': 'float'})  # shadows global
print(st.lookup('x')['type'])  # 'float'
st.exit_scope()
print(st.lookup('x')['type'])  # 'int'

class TypeChecker:
    def __init__(self):
        self.symbols = {}
        self.type_ids = {}

    def check_assignment(self, var_name, expr_type):
        entry = self.symbols.get(var_name)
        if not entry:
            raise NameError(f"Undeclared: {var_name}")
        var_type_id = entry['type_id']
        if var_type_id != expr_type:
            raise TypeError(f"Cannot assign {expr_type} to {var_name} (type {var_type_id})")

# Example usage
tc = TypeChecker()
tc.symbols['x'] = {'type_id': 'int'}

try:
    tc.check_assignment('x', 'float')
except TypeError as e:
    print(f"Caught: {e}")

# Output: Caught: Cannot assign float to x (type int)