Implémentation des traits à états en Java

Implémentation des traits
à états en Java
Pierre Alexis
Mémoire présenté sous la direction des Professeurs Raymond Devillers et Roel Wuyts
en vue de l’obtention du grade de Licencié en Informatique
Année académique 2006–2007
MEMBRE DE L’ACADÉMIE UNIVERSITAIRE WALLONIE-BRUXELLES ET DU PÔLE UNIVERSITAIRE EUROPÉEN BRUXELLES WALLONIE
Faculté des sciences
département d’inFormatique

ii
Remerciements
Je tiens à remercier vivement Roel Wuyts, promoteur de ce mémoire, à la fois pour son suivi
soutenu, ses conseils, ses nombreuses relectures et son éternel optimisme.
Je tiens également à remercier Raymond Devillers sans qui ce mémoire n’aurait jamais pu
voir le jour.
Je remercie également les membres de mon Jury pour le temps qu’ils passeront à lire ce
travail : Raymond Devillers, Thierry Massart et Yves Roggeman.
Mes remerciements vont également à Yann-Gaël Guéhéneuc pour ses conseils.
Je tiens également à exprimer toute ma gratitude envers mes parents pour leurs nombreuses
relectures de ce document et pour leur soutien durant toutes mes études.
Aboutissement de mes études, ce mémoire est l’occasion de remercier également toutes celles
et ceux qui m’ont accompagné durant ces années en offrant soutien et amitié, que ce soit au
niveau des études où dans mes tâches de délégué étudiant. Alessandro, Andy, Anne, Jérémy,
Julien, Laurent, Markus, Renaud, Sébastien, Yannick, soyez remerciés. Enfin, je tiens à adresser
des remerciements tout particuliers à Xavier pour son amitié et son soutien.

TABLE DES MATIÈRES iii
Table des matières
1 Introduction 1
1.1 Objectifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Organisation du document . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2 Programmation orientée objet et réutilisation de code 5
2.1 Concepts de la programmation orientée objet . . . . . . . . . . . . . . . . . . . . 5
2.1.1 Les objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.1.2 Messages et interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.3 Les classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 L’héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.1 Une hiérarchie de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.2 Classes abstraites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2.3 Method lookup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2.4 Destinations particulières pour l’envoi de messages . . . . . . . . . . . . . 11
2.2.5 Multiplicité de l’héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.3 Les mixins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.4 Problèmes et limitations des méthodes existantes . . . . . . . . . . . . . . . . . . 15
2.4.1 Critique de l’héritage simple . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.4.2 Critique de l’héritage multiple . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.4.3 Critique des mixins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.4.4 Les classes comme unités de réutilisation . . . . . . . . . . . . . . . . . . . 22
3 Les traits 24
3.1 Les traits sans état . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.1.1 Composition de classes à partir de traits . . . . . . . . . . . . . . . . . . . 25
3.1.2 Composition de traits composites à partir de traits . . . . . . . . . . . . . 28
3.1.3 Résolution de conflits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.1.4 Autres utilisations des opérateurs de composition . . . . . . . . . . . . . . 32
3.1.5 Évaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.2 Les traits à états . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.2.1 Limitations des traits sans état . . . . . . . . . . . . . . . . . . . . . . . . 39
3.2.2 Définition des traits à états . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.2.3 Conflits d’attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.2.4 Levée des limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.2.5 Propriété d’aplatissement . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.2.6 Le problème du diamant revisité . . . . . . . . . . . . . . . . . . . . . . . 45

TABLE DES MATIÈRES iv
3.3 Traits et typage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.3.1 Notions de typage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.3.2 Les traits comme type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.3.3 Ajout du typage aux traits . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.3.4 Typage au sein d’un trait . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3.4 Travaux actuels et futurs sur les traits . . . . . . . . . . . . . . . . . . . . . . . . 55
3.4.1 Langages supportant les traits . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.4.2 Recherches actuelles ou futures . . . . . . . . . . . . . . . . . . . . . . . . 56
3.5 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4 Ajout des traits à états à Java 58
4.1 Le langage de programmation Java . . . . . . . . . . . . . . . . . . . . . . . . . . 58
4.1.1 Classes et objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.1.2 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
4.1.3 Typage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.1.4 Indépendance de plateforme . . . . . . . . . . . . . . . . . . . . . . . . . . 60
4.2 Émulation des traits à l’aide de la programmation orientée aspect . . . . . . . . . 61
4.2.1 Concepts de la programmation orientée aspect . . . . . . . . . . . . . . . 61
4.2.2 AspectJ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.2.3 Émulation des traits à l’aide d’AspectJ . . . . . . . . . . . . . . . . . . . . 63
4.2.4 Règles de précédence et résolution de conflits . . . . . . . . . . . . . . . . 64
4.2.5 En conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.3 Un nouveau langage : tJava . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4.3.1 Une nouvelle syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4.3.2 Extension de la grammaire de Java . . . . . . . . . . . . . . . . . . . . . . 69
4.4 Implémentation de tJava . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
4.4.1 En modifiant les mécanismes du langage Java . . . . . . . . . . . . . . . . 72
4.4.2 En utilisant la propriété d’aplatissement . . . . . . . . . . . . . . . . . . . 73
5 Les Rewritable Reference Attributed Grammars 80
5.1 Les canonical attributed grammars . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5.1.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
5.1.2 Problèmes et limitations des canonical attributed grammars . . . . . . . . 82
5.2 Les Reference Attributed Grammars . . . . . . . . . . . . . . . . . . . . . . . . . 83
5.2.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
5.2.2 Object-Oriented RAGs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
5.3 Les Rewritable Reference Attributed Grammars . . . . . . . . . . . . . . . . . . . 88
5.3.1 Un exemple d’application . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.4 Les ReRAGs pour implémenter les traits . . . . . . . . . . . . . . . . . . . . . . . 89
6 Choix des outils 91
6.1 Critères de choix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
6.1.1 Capacité de production de l’AST Java . . . . . . . . . . . . . . . . . . . . 91
6.1.2 Capacité de modification de l’AST Java . . . . . . . . . . . . . . . . . . . 92
6.1.3 Capacité de dériver l’outil . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
6.2 Outils analysés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
6.2.1 Eclipse Java Development Tools (JDT) . . . . . . . . . . . . . . . . . . . . 92

TABLE DES MATIÈRES v
6.2.2 OpenJava . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
6.2.3 JavaCC et JJTree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
6.2.4 Le Java programming language compiler (javac) . . . . . . . . . . . . . . . 93
6.2.5 JastAdd II et le JastAdd Extensible Java Compiler . . . . . . . . . . . . . 94
6.3 Récapitulatif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
7 Validation 97
7.1 JastAdd II . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.1.1 Une hiérarchie de classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.1.2 Construction de l’AST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
7.1.3 Aspects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
7.1.4 Attributs et équations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
7.1.5 Règles de réécriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
7.1.6 Récapitulatif de l’architecture . . . . . . . . . . . . . . . . . . . . . . . . . 101
7.2 Modification du JastAdd Extensible Java Compiler . . . . . . . . . . . . . . . . . 102
7.2.1 Front-end et Back-end . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
7.2.2 Analyse syntaxique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
7.2.3 Analyse sémantique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.2.4 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
8 Conclusion 106
Bibliographie 109
Webographie 112