Symbol Tracker: Track Declaration and Usage of Symbols Across a Codebase

Question

## Problem

Implement a symbol tracker for a simple programming language. Given a list of events (declarations and usages), answer queries about symbol visibility and usage.

Events: `DECLARE(scope, name, type)`, `USE(scope, name)`, `ENTER_SCOPE(scope_id)`, `EXIT_SCOPE(scope_id)`.

Scopes are nested; inner scopes can see outer scope symbols. A symbol declared in an inner scope shadows an outer one.

```python
class SymbolTracker:
    def declare(self, scope: str, name: str, sym_type: str) -> None: ...
    def use(self, scope: str, name: str) -> str | None:
        """Return type of visible symbol, or None if undeclared."""
        ...
    def get_unused_symbols(self) -> list[str]:
        """Return names declared but never used."""
        ...
    def get_shadowed_symbols(self) -> list[str]:
        """Return names that shadow an outer declaration."""
        ...
```

```
ENTER outer
DECLARE outer x int
ENTER inner
DECLARE inner x str   <- shadows outer x
USE inner x           -> "str"
EXIT inner
USE outer x           -> "int"
get_shadowed_symbols() -> ["x"]
```

## Follow-ups

1. How do you implement scope lookup (walk up the scope chain)? What data structure represents the chain?
2. What if a symbol can be declared after it's used in the same scope (hoisting, like JS `var`)? How does this change your tracker?
3. How would you extend this to report the exact file/line of each declaration and usage?
4. Describe how a real compiler's symbol table differs from your implementation.

Symbol Tracker: Track Declaration and Usage of Symbols Across a Codebase

Question Details

Full Details

About This Question

Topics

More Jump Trading Interview Questions