Un programme peut être bien écrit et pourtant absurde. L'analyse sémantique attrape ces erreurs avant l'exécution.
⏱️ Durée : environ 90 minutes · 🎓 Niveau : intermédiaire · 🏅 Badge : Inspecteur de sens
🎬 L'histoire
Un formateur de HashBox écrit : print compteur; sans avoir jamais déclaré compteur, puis let x = true + 1;. Le parser dit « syntaxe correcte ». Le programme plante à l'exécution, au milieu d'une démonstration.
« La syntaxe dit si la phrase est bien construite, dit Sam. Pas si elle a du sens. Une deuxième passe doit vérifier : les noms existent-ils ? Les types sont-ils compatibles ? »
Tu écris l'analyseur sémantique de HashScript : table des symboles, portées, vérification de types, avertissements.
🎯 Ta mission
À la fin, je serai capable de :
- expliquer ce que vérifie l'analyse sémantique
- construire une table des symboles avec des portées imbriquées
- détecter variables non déclarées, redéclarations, types incompatibles
- produire erreurs et avertissements positionnés
- distinguer typage statique et dynamique
🧩 Défi d'échauffement (5 XP)
Voici trois phrases françaises syntaxiquement correctes : « Le triangle dort sous la racine carrée. », « Marie a mangé son sandwich. », « Il l'a donnée à elle. » Laquelle est bien formée et sensée ? Pour la dernière, que faut-il savoir pour la comprendre ? Transpose en programmation : x + 1 est-elle toujours correcte ? Que dois-tu connaître de x ?
💡 Le concept
Ce que vérifie l'analyse sémantique
Après le parsing, on dispose d'un AST bien formé. L'analyse sémantique contrôle les règles qui ne peuvent pas s'écrire dans une grammaire hors-contexte :
| Contrôle | Exemple d'erreur |
|---|---|
| Résolution de noms | utiliser une variable non déclarée |
| Déclarations | déclarer deux fois le même nom dans la même portée |
| Types | additionner un booléen et un nombre |
| Appels | appeler une fonction avec le mauvais nombre d'arguments |
| Contrôle de flot | return hors d'une fonction ; code inatteignable |
| Initialisation | lire une variable avant de lui avoir donné une valeur |
La table des symboles
La table des symboles associe chaque nom à ses informations (type, portée, position de déclaration, utilisée ou non). On l'organise en portées imbriquées : une pile de dictionnaires, un par bloc.
portée globale : {x: nombre, f: fonction}
└─ bloc if : {y: booléen}
└─ bloc : {x: booléen} ← masque (shadowing) le x global
- Déclaration : ajoute un nom dans la portée courante.
- Recherche : du plus interne vers le plus externe (portée lexicale).
- Sortie d'un bloc : on dépile ; c'est le moment de détecter les variables jamais utilisées (avertissement).
Types
Typage statique : les types sont vérifiés avant l'exécution (Rust, Java, TypeScript). Typage dynamique : vérifiés pendant (Python, JavaScript). Un analyseur peut ajouter un contrôle statique à un langage dynamique (comme mypy pour Python).
Pour HashScript, on distingue deux types simples : nombre et booleen, plus ? (inconnu, pour les fonctions que l'on ne suit pas).
| Opération | Opérandes | Résultat |
|---|---|---|
+ - * / | nombre, nombre | nombre |
< > <= >= | nombre, nombre | booleen |
== != | même type des deux côtés | booleen |
- unaire | nombre | nombre |
condition if / while | booleen | : |
L'analyse sémantique peut être plus stricte que l'exécution : l'interpréteur accepterait if 1 { … }, l'analyseur le signale quand même (c'est un choix de conception du langage).
Erreurs et avertissements
- Erreur : le programme est invalide, on ne l'exécute pas.
- Avertissement : le programme est valide mais suspect (variable jamais lue, code mort).
Un bon analyseur ne s'arrête pas à la première erreur : il continue pour en signaler plusieurs (en considérant le type d'une expression erronée comme ? pour éviter les erreurs en cascade).
Un analyseur en Python
from dataclasses import dataclass
@dataclass
class Info:
type: str
utilisee: bool
ligne: int
col: int
class Analyseur:
def __init__(self):
self.portees = [{}]
self.erreurs, self.avertissements = [], []
def ouvrir(self):
self.portees.append({})
def fermer(self):
for nom, info in self.portees.pop().items():
if not info.utilisee:
self.avertissements.append((info.ligne, info.col, f"variable {nom!r} jamais utilisée"))
def declarer(self, nom, type_, ligne, col):
if nom in self.portees[-1]:
self.erreurs.append((ligne, col, f"{nom!r} est déjà déclarée dans cette portée"))
self.portees[-1][nom] = Info(type_, , ligne, col)
():
portee (.portees):
nom portee:
portee[nom]
🧠 Astuce : l'analyse sémantique est ce qui fait que les messages d'erreur de ton langage semblent « intelligents ». Les meilleurs compilateurs y investissent beaucoup.
🔍 Exemple pas à pas
Problème : analyser des programmes HashScript et rapporter erreurs et avertissements positionnés.
from dataclasses import dataclass
from hashscript import parser, Let, Assign, Print, Si, TantQue, Num, Bool, Var, Bin, Neg, Fun, Appel, Retour
@dataclass
class Info:
type: str
utilisee: bool
ligne: int
col: int
class Analyseur:
def __init__(self):
self.portees = [{}]
self.erreurs, self.avertissements = [], []
def ouvrir(self): self.portees.append({})
def fermer(self):
for nom, info in self.portees.pop().items():
if not info.utilisee:
self.avertissements.append((info.ligne, info.col, f"variable {nom!r} jamais utilisée"))
def chercher(self, nom):
for p in reversed(self.portees):
if nom in p: return p[nom]
def ():
.erreurs.append(((n, , ), (n, , ), message))
():
(n, Num):
(n, Bool):
(n, Var):
info = .chercher(n.nom)
info :
.erreur(n, )
info.utilisee =
info.
(n, Neg):
t = .type_de(n.expr)
t (, ): .erreur(n, )
(n, Bin):
g, d = .type_de(n.gauche), .type_de(n.droite)
(g, d):
n.op (, , , , , ) n.op
n.op :
(g, d) != (, ): .erreur(n, )
n.op (, , , ):
(g, d) != (, ): .erreur(n, )
g != d: .erreur(n, )
():
(n, Let):
t = .type_de(n.expr)
n.nom .portees[-]:
.erreur(n, )
.portees[-][n.nom] = Info(t, , n.ligne, n.col)
(n, Assign):
info = .chercher(n.nom)
t = .type_de(n.expr)
info : .erreur(n, )
(t, info.) t != info.:
.erreur(n, )
(n, Print):
.type_de(n.expr)
(n, (Si, TantQue)):
t = .type_de(n.cond)
t (, ): .erreur(n.cond, )
bloc ([n.alors, n.sinon] (n, Si) [n.corps]):
.ouvrir()
i bloc: .instr(i)
.fermer()
():
i programme: .instr(i)
.fermer()
(.erreurs), (.avertissements)
source =
erreurs, avertissements = Analyseur().analyser(parser(source))
l, c, m erreurs: ()
l, c, m avertissements: ()
Lecture : l'analyseur signale plusieurs problèmes d'un coup : redéclaration, variable inconnue, types incompatibles, condition non booléenne, affectation de type incorrect. Il signale aussi inutile comme jamais utilisée. Le type ? évite des erreurs en cascade quand une sous-expression est déjà fausse.
✍️ À toi, avec aide (10 XP)
Ajoute à l'analyseur une règle : une variable utilisée avant d'avoir reçu une valeur n'existe pas ici (toutes les variables sont initialisées à la déclaration), mais on veut signaler les variables déclarées dans un bloc et utilisées après ce bloc.
Écris deux programmes de test :
if true { let x = 1; }
print x;
et un programme valide où x est déclaré avant le bloc. Vérifie que le premier produit « variable inconnue 'x' » et le second aucune erreur.
💡 Indice 1
La sortie du bloc dépile la portée : x n'existe plus après.
💡 Indice 2
La fermeture de portée est déjà gérée par fermer() dans instr.
💡 Indice 3
Utilise l'analyseur de l'exemple tel quel.
✅ Réponse
# (Analyseur de l'exemple)
erreurs, _ = Analyseur().analyser(parser("if true { let x = 1; }\nprint x;"))
print(erreurs) # [(2, 7, "variable inconnue 'x'")]
erreurs, _ = Analyseur().analyser(parser("let x = 1;\nif true { print x; }"))
print(erreurs) # []
La portée du bloc if est ouverte puis fermée : le x déclaré dedans disparaît à la sortie. C'est la portée lexicale : un nom n'existe que dans le bloc où il est déclaré (et ses blocs internes).
🚀 À toi, en solo (20 XP)
Contrôle des fonctions. Étends l'analyseur pour les fonctions :
fun nom(params) { … }: déclarenom(typefonction, avec son nombre de paramètres) dans la portée courante ; les paramètres sont déclarés dans la portée de la fonction ;- un appel
f(a, b)doit viser une fonction connue avec le bon nombre d'arguments, sinon erreur positionnée ; returnhors d'une fonction est une erreur ;- un avertissement si une fonction n'a pas de
returnsur son chemin principal (simplification : aucunRetourau premier niveau du corps).
Teste avec 6 programmes.
✅ Pistes de correction
Idée de réalisation (code abrégé) :
# Dans Analyseur :
# self.fonctions = [] # pile de fonctions en cours (pour 'return')
# Info reçoit un champ 'arite' (None si ce n'est pas une fonction)
#
# instr(Fun) :
# declarer(n.nom, "fonction", arite=len(n.params)) (erreur si déjà déclarée)
# ouvrir(); declarer chaque paramètre (type "?") ; self.fonctions.append(n)
# analyser le corps ; self.fonctions.pop() ; fermer()
# si aucun Retour au premier niveau : avertissement "fonction sans return"
# instr(Retour) : si not self.fonctions : erreur "return en dehors d'une fonction"
# type_de(Appel) :
# si la cible est une Var inconnue -> erreur "fonction inconnue"
# si info.type != "fonction" -> erreur "ce n'est pas une fonction"
# si len(args) != info.arite -> erreur "attend N arguments, reçu M"
# analyser aussi chaque argument (variables inconnues, etc.) ; type de retour "?"
Les tests couvrent : appel correct, mauvais nombre d'arguments, appel d'une variable non fonction, return global, fonction inconnue, récursion (la fonction doit être déclarée avant d'analyser son corps pour pouvoir s'appeler elle-même).
⚠️ Pièges classiques
| Piège | Pourquoi c'est un problème | Comment l'éviter |
|---|---|---|
| S'arrêter à la première erreur | L'utilisateur corrige une erreur à la fois | Collecter plusieurs erreurs |
| Erreurs en cascade | Une faute en produit dix | Type ? pour les sous-expressions invalides |
| Oublier de dépiler la portée | Fuite de variables entre blocs | Ouvrir/fermer à chaque bloc |
| Mélanger erreurs et avertissements | On bloque pour rien ou on laisse passer le grave | Deux niveaux de gravité |
🐉 Mini-boss (40 XP)
Le contrôleur de qualité de HashScript. Complète l'analyseur pour qu'il détecte, avec positions :
- variables inconnues, redéclarations, types incompatibles, conditions non booléennes ;
- appels de fonctions (existence, nombre d'arguments) et
returnhors fonction ; - code mort : instructions après un
returndans le même bloc ; - variables jamais utilisées et paramètres inutilisés (avertissements) ;
- division par zéro constante (
x / 0) détectée statiquement.
Écris une suite d'au moins 20 programmes de test (valides et invalides) avec les messages attendus, puis exécute l'analyseur sur les programmes de la mission 10 du module pour montrer qu'ils n'ont aucune erreur.
✅ Pistes de correction
Un bon travail : une classe Analyseur avec erreurs et avertissements triés par position; la détection du code mort parcourt chaque bloc et signale la première instruction suivant un Retour; la division par zéro constante regarde si le diviseur (après pliage de constantes) est Num(0); les tests utilisent un tableau (source, erreurs_attendues, avertissements_attendus). L'exécution sur les programmes du capstone (factorielle, Fibonacci, fermetures) ne doit produire aucune erreur; si elle en produit, c'est généralement une portée de fonction mal gérée (la fonction doit voir ses propres paramètres et la fonction englobante).
⚡ Quiz éclair (15 XP si 4/5 ou plus)
1. L'analyse sémantique vérifie :
- A. uniquement les parenthèses
- B. la vitesse d'exécution
- C. noms, déclarations et types
2. Une table des symboles associe :
- A. chaque nom à ses informations (type, portée, position)
- B. chaque jeton à sa position
- C. chaque ligne à son numéro
3. Le typage statique vérifie les types :
- A. pendant l'exécution seulement
- B. avant l'exécution
- C. jamais
4. 🔁 Révision mission 04 : L'AST garde :
- A. tous les espaces et commentaires
- B. seulement les nombres
- C. la structure essentielle, sans le bruit syntaxique
5. 🔁 Révision mission 04 : Une optimisation doit toujours :
- A. préserver le sens du programme
- B. réduire le nombre de lignes
- C. utiliser plus de mémoire
✅ Réponses
- C.
- A.
- B.
- C.
- A.
🪞 Je réfléchis (10 XP)
- Quelle règle « de bon sens » (et non de forme) as-tu dû vérifier récemment dans ton travail ?
- Pourquoi signaler plusieurs erreurs d'un coup est-il plus agréable pour l'utilisateur ?
🎒 À retenir
- La sémantique vérifie noms, types, appels, contrôle de flot.
- Table des symboles en portées imbriquées.
- Erreurs (bloquantes) et avertissements (suspects).
- Type inconnu
?pour éviter les cascades. - Typage statique = avant l'exécution.
flowchart LR
T(["L'analyse sémantique"])
T --> R1["1. La sémantique vérifie noms, types, appels, contrôle de flot."]
T --> R2["2. Table des symboles en portées imbriquées."]
T --> R3["3. Erreurs bloquantes et avertissements suspects."]
T --> R4["4. Type inconnu ? pour éviter les cascades."]
T --> R5["5. Typage statique = avant l'exécution."]
Description du schéma : la mission au centre, reliée aux cinq idées à retenir.
🏅 Récompenses
Total possible : 100 XP · 🏅 Badge Inspecteur de sens
← Mission 04 — L'arbre syntaxique abstrait (AST) · Mission 06 — L'interpréteur : faire vivre l'arbre →
HEF-090 — Compilateurs et langages

