RÉFÉRENCE VITTE / Langage

Expressions et opérateurs

Cette page résume les expressions reconnues par la grammaire et l’ordre dans lequel elles se regroupent.

Niveau de garantieOpérateurs natifs vérifiés pour le sous-ensemble des fixtures ; la grammaire décrit aussi des formes non compilées.

Source de référence : grammar/vitte.ebnf

Priorité des opérateurs

Le tableau va du niveau le moins prioritaire au plus prioritaire. Les opérateurs d’un même niveau se regroupent de gauche à droite, sauf l’affectation et ??, définis récursivement vers la droite.

Niveau	Opérateurs	Exemple ou rôle
Affectation	`= += -= *= /= %= &= \|= ^= <<= >>=`	Modifie une cible ; l’assignation composée combine calcul et affectation.
Coalescence	`??`	Valeur de repli associée vers la droite.
OU logique	`or \|\|`	Combine des conditions.
ET logique	`and &&`	Combine des conditions.
OU binaire	`\|`	Opération bit à bit.
OU exclusif	`^`	Opération bit à bit.
ET binaire	`&`	Opération bit à bit.
Égalité	`== !=`	Compare l’égalité ou la différence.
Comparaison	`< <= > >=`	Compare un ordre.
Décalage	`<< >>`	Décale les bits d’une valeur entière.
Addition	`+ -`	Addition et soustraction.
Multiplication	`* / %`	Multiplication, division et reste.
Plages	`.. ..=`	Construit une plage ouverte ou incluant la borne finale.
Préfixe unaire	`+ - ! ~ * & not move ref await`	Signe, négation, bits, déréférence, référence ou opération de contexte.
Postfixe	Appel, `[indice]`, `.champ`, `?`	Appel, indexation, accès de champ ou suffixe optionnel.

Associativité et parenthèses

Les expressions arithmétiques et logiques forment des chaînes de gauche à droite. L’affectation s’associe vers la droite. Les parenthèses forcent le regroupement voulu et restent utiles même quand la priorité du langage suffirait :

let a: i64 = 2 + 3 * 4;      // multiplication d'abord
let b: i64 = (2 + 3) * 4;    // addition d'abord

La grammaire n’énonce pas à elle seule tous les effets d’évaluation ni toutes les règles de typage. Pour des opérandes qui modifient l’état, découpe l’expression en plusieurs instructions afin d’éviter une dépendance implicite à l’ordre d’évaluation.

Familles d’expressions

Expressions primaires : littéraux, chemins, self, listes de valeurs entre crochets, parenthèses et blocs.
Postfixes : appels, accès indexé, champs et suffixe ?.
Unaires : signes, négation logique/bit à bit, déréférence, emprunt, move, ref, await.
Binaires : arithmétique, plages, décalages, bits, comparaisons et logique.
Affectations : expression simple et formes composées définies dans la grammaire.

Écarts syntaxe / compilation à connaître

as Type apparaît dans les sources et les tests compilés, mais pas dans la production expression du fichier EBNF canonique. Les gardes de motifs et les formes avancées de match ont le même écart : le frontend natif les accepte dans ses tests, alors que cette production EBNF ne décrit qu’un bras simple expression => ....

Vérification par famille d’expressions

Construction	EBNF	Analyseur	Compilation constatée
Arithmétique, bits, comparaisons et logique	Décrits avec les niveaux de priorité du tableau.	Acceptés ; cas de types incompatibles rejetés avec diagnostic testé.	Oui : calcul arithmétique, comparaisons et logique compilés et exécutés avec le frontend natif.
Affectations `=`, `+=`, etc.	Décrites.	Acceptées ; l’affectation à une liaison immuable est rejetée par le test sémantique.	Oui : `+=` et `-=` compilés et exécutés par le backend natif.
Appels, accès de champ et indexation	Décrits dans les formes postfixes.	Acceptés dans les fixtures d’agrégats et de tableaux.	Oui : appels, champs imbriqués et index de tableaux en IR/C17/exécution.
Cast `as Type`	Non décrit dans l’EBNF.	Accepté dans les cas natifs vers `u8` et `f64`.	Oui pour ces exemples testés en runtime.
Plages `..` / `..=`	Décrites.	Le test ciblé du `for` sur tableau confirme un diagnostic de codegen, pas le comportement de toutes les plages.	Exécution d’une boucle `for` sur plage non établie par les 11 fixtures runtime.
Coalescence `??`, suffixe `?`, `await`, `move`	Décrits par l’EBNF.	Pas de fixture ciblée passée pour chacune de ces formes.	Non prouvé au backend et à l’exécution.
Gardes, variantes qualifiées et charges utiles de `match`	Les variantes simples de bras sont décrites ; gardes et motifs de charge utile ne le sont pas complètement.	Acceptés par les cas du frontend natif.	Oui : variantes simples et charges utiles passent IR, C17 et exécution.

Grammaire canonique · Tests du frontend natif · État du support.