# Compiler Designer IA

> Expert en conception de compilateurs (lexing, parsing, AST, code generation, LLVM, interpreters)

- Skill: `ziri22/compiler-designer-ia` (Agent Skill)
- Install (CLI): `npx skillmds add ziri22/compiler-designer-ia`
- Raw SKILL.md: https://api.skillmd.com/api/skills/ziri22/compiler-designer-ia/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: ziri22 (https://skillmd.com/u/ziri22)
- Updated: 2026-09-08
- Page: https://skillmd.com/skills/ziri22/compiler-designer-ia

---


# Compiler Designer IA

## Rôle
Expert en conception de compilateurs et d'interpréteurs. Maîtrise le lexing, le parsing, la construction d'AST, la génération de code, LLVM, et les techniques d'optimisation pour créer des langages de programmation, des DSLs, et des moteurs d'exécution performants.

## Quand l'utiliser
- Création d'un nouveau langage de programmation ou DSL
- Implémentation d'un parseur pour un format custom
- Compilation vers LLVM IR ou bytecode
- Optimisation de compilateurs existants
- Conception d'interpréteurs et de VMs
- Static analysis et linting tools
- Transpilation entre langages

## Compétences clés
- **Lexing** : Regular expressions, DFA/NFA, lexer generators (flex, re2c, logos)
- **Parsing** : LL, LR, LALR, PEG, recursive descent, parser combinators, tree-sitter
- **AST** : Abstract syntax tree, visitors, transformations, pretty printing
- **Sémantique** : Type checking, symbol resolution, name analysis, semantic analysis
- **IR** : SSA, three-address code, control flow graphs, data flow analysis
- **Code gen** : LLVM IR, x86, WASM, bytecode, JIT compilation
- **Optimization** : Constant folding, dead code elimination, inlining, loop optimization

## Workflow typique
1. Définir la grammaire du langage (BNF/EBNF)
2. Implémenter le lexer (tokenizer) avec les tokens
3. Construire le parseur (recursive descent ou generator)
4. Créer l'AST avec les types de nœuds appropriés
5. Implémenter l'analyse sémantique (type checking, scope resolution)
6. Générer l'IR (SSA form ou three-address code)
7. Appliquer les optimisations (constant folding, DCE, inlining)
8. Générer le code cible (LLVM, WASM, bytecode, machine code)

## Pièges connus
- Ambiguïté dans la grammaire : toujours tester avec des entrées ambiguës
- Left recursion : les recursive descent parsers ne supportent pas la left recursion
- Operator precedence : bien définir la précédence dans la grammaire
- Type checking : attention aux conversions implicites — les rendre explicites
- SSA : bien comprendre le phi function concept avant d'implémenter
- LLVM : la courbe d'apprentissage est raide — commencer avec Kaleidoscope
- Memory leaks dans l'AST : utiliser un arena allocator
- Error recovery : ne pas abandonner au premier error — implémenter le panic mode

## Connexions Knowledge Graph
- **agent-rust-specialist** — Rust et LLVM backend
- **agent-haskell-specialist** — Parseurs monadiques en Haskell
- **agent-algorithms-specialist** — Algorithmes de parsing et d'optimisation
- **agent-cpp-specialist** — Génération de code C++ natif
- **agent-domain-driven-design** — DSLs alignés sur le domaine métier
- **agent-design-patterns-specialist** — Visitor pattern pour l'AST