Implements AST transformations for refactoring tools and linters. Builds IR-level optimizations such as constant folding and dead code elimination. Writes comprehensive test suites for tree manipulation correctness.

Independently designs benchmark suites for compiler and language tool performance evaluation. Implements regression detection benchmarks integrated into CI pipelines. Applies statistical methods to distinguish real performance changes from measurement noise in compiler optimization passes.

Implements code generators targeting multiple output formats (source code, bytecode). Builds peephole optimizations and handles platform-specific code emission. Writes property-based tests for generated output validation.

Independently profiles compiler and language runtime performance using perf, pprof, and VTune. Identifies CPU bottlenecks in parsing, type checking, and code generation stages. Understands trade-offs between sampling and instrumentation profiling for tooling workloads.

Designs and implements domain-specific languages with custom parsers and semantic analysis. Builds error reporting and IDE integration for DSL tooling. Writes comprehensive test suites covering DSL edge cases and error handling.

Implements bytecode interpreters with proper scope management and closure support. Builds garbage collectors and memory management for interpreted languages. Writes comprehensive test suites covering control flow, error handling, and edge cases.

Implements LSP features including go-to-definition, references, hover info, and diagnostics. Builds incremental document parsing for responsive editor feedback with efficient change tracking.

Implements recursive descent and PEG parsers for DSLs. Builds error-recovery mechanisms for partial parsing to support IDE features. Generates syntax-highlighted token streams from lexer output.

Independently profiles memory usage in compiler pipelines and language server processes using Valgrind massif, AddressSanitizer, and heaptrack. Understands trade-offs between sampling-based and instrumentation-based profiling for AST/IR data structures. Diagnoses memory bloat in parser allocators and optimizes arena allocation strategies for typical compilation workloads.

Independently designs property tests for compiler passes and code transformations. Builds custom generators for complex AST structures. Integrates property-based test suites into CI/CD pipelines to catch semantic regressions.

Applies TDD for language tool development: test-driven parser rule implementation, comprehensive grammar test suites with edge cases, and BDD scenarios for language feature specifications. Uses snapshot testing for AST/IR outputs. Implements test fixtures for complex language constructs. Integrates language conformance tests into CI.

Implements type inference passes and integrates them with IR transformations. Writes comprehensive test suites for type checker correctness including edge cases with generics and variance.

Independently applies graph algorithms (DFS, BFS, topological sort) for AST traversal, dependency resolution, and symbol table construction. Understands trade-offs between adjacency list and matrix representations for compiler IR. Explains graph coloring for register allocation and cycle detection in code reviews.

Implements generic type resolution in language tooling: builds type parameter substitution maps during type checking, handles generic method inference and constraint solving. Understands generic instantiation strategies (monomorphization vs type erasure) and their impact on tooling — code completion, refactoring, and type display in IDE features.

Implements docs-as-code for language tooling: auto-generated API docs from source, interactive grammar playground documentation, and versioned language specification. Uses documentation generators (TypeDoc, rustdoc, godoc) as part of build pipeline. Maintains changelog automation from commit history.

Independently applies immutability patterns in language tool development including red-green syntax trees, immutable rope data structures for text editing, and persistent type environments for incremental type checking. Writes analysis passes that operate on immutable snapshots enabling safe concurrent diagnostics and code action computation. Understands memory management strategies for immutable tree structures in long-running language server processes.

Applies FP principles when building compiler passes and language tools: pure transformations on ASTs, immutable intermediate representations, and referential transparency in analysis phases. Understands algebraic data types for modeling syntax trees and uses pattern matching for tree traversal.