Le plugin IDE Flowistry qui aide à se concentrer sur le code pertinent en Rust

 (github.com/willcrichton)
3 points par GN⁺ 2025-10-20 | 1 commentaires | Partager sur WhatsApp
  • Flowistry est un plugin IDE pour le langage Rust qui offre la possibilité d'afficher uniquement les parties liées au code sur lequel on souhaite se concentrer.
  • Ce plugin analyse le flux d'informations du code Rust et met visuellement en évidence uniquement le code directement connecté à la variable ou à l'expression actuellement consultée.
  • Il peut être installé facilement sous forme de plugin VSCode et n'affiche en surbrillance que le code qui affecte ou est affecté par la variable sélectionnée.
  • Grâce à diverses fonctionnalités comme le "Focus mode" et la configuration de mark, il améliore la compréhension des fonctions volumineuses et du code complexe.
  • Bien qu'il présente des limites (prise en charge imparfaite de l'Interior Mutability, portée d'analyse restreinte), il est en évolution continue et reste un outil distinct de Rust Analyzer.

Aperçu et pertinence de Flowistry

Flowistry est un plugin IDE pour les développeurs Rust, qui met en évidence uniquement le code lié à la partie du code sur laquelle on souhaite se concentrer. Dans des fonctions volumineuses ou des flux de code complexes, il permet d'identifier rapidement et clairement les parties utiles, et offre ainsi une valeur pratique distincte des autres outils d'analyse statique. La technologie centrale est l'analyse de flux d'informations, une forme d'analyse de flux de données qui repère les chemins par lesquels un segment de code peut influencer un autre. Flowistry propose cette analyse de flux d'informations en tirant parti des spécificités du langage Rust, de son système de possession et de durée de vie, ainsi que de Rust MIR (Mid-level Intermediate Representation).

Principales fonctionnalités et mode de fonctionnement

  • En cliquant sur une variable ou une expression dans le code Rust, Flowistry assombrit le code qui ne l'affecte pas et celui qui n'est pas affecté par ce point.
  • Il met en évidence de manière intuitive uniquement le code pertinent, réduisant ainsi la lecture inutile et permettant de repérer rapidement le flux principal du code.
  • Dans des fonctions volumineuses, ou dans du code complexe comme des fonctions réelles du compilateur Rust, il est possible de voir d'un seul coup d'œil le rôle joué par un argument donné.
  • L'algorithme sous-jacent s'appuie sur l'article de recherche de PLDI 2022 intitulé "Modular Information Flow through Ownership".

Installation et prise en charge de l'environnement

Installation du plugin IDE

  • Flowistry est un plugin VSCode qui peut être installé depuis Visual Studio Marketplace ou Open VSX Registry.
  • Après ouverture d'un workspace Rust, l'installation et l'initialisation sont lancées automatiquement.
  • NixOS n'est pas pris en charge et, sur les plateformes ARM (M1 Mac, etc.), la compilation doit être faite à partir des sources.

Plugin Rustc

  • La fonctionnalité d'analyse de flux d'informations est publiée séparément sous forme de crate, avec une documentation détaillée et une API directement accessibles.

Utilisation et détails des fonctionnalités

Lancement initial

  • Lors du lancement du plugin dans VSCode, la vérification de type de l'ensemble du codebase est effectuée en amont.
  • Le résultat est mis en cache dans le dossier target/flowistry.

Entrée en Focus Mode

  • Utilisez la commande du plugin "Toggle focus mode" (par ex. Ctrl+R Ctrl+A) pour entrer en mode focus.
  • Une fois le curseur placé dans une fonction, une analyse de flux d'informations s'exécute automatiquement dans cette fonction.
  • Une fois l'analyse terminée, seul le code pertinent est mis en évidence (cela peut prendre jusqu'à environ 15 secondes).

Définition de mark

  • Pour figer une zone de focus et la conserver pendant l'examen d'autres parties du code, utilisez le concept de "Mark".
  • Le marquage peut être posé ou retiré avec "Set mark" (Ctrl+R Ctrl+S) et "Unset mark" (Ctrl+R Ctrl+D).

Sélection de la zone focus

  • La commande "Select focused region" permet de sélectionner en une seule opération l'ensemble du bloc de code mis en évidence, puis de le copier, le commenter, etc.

Limites et points d'attention

  • La prise en charge de l'Interior Mutability n'est pas complète
    • Par exemple, pour des structures comme Arc, Mutex, les différences de lifetime entre références empêchent un suivi exhaustif.
  • La zone de focus peut parfois devenir plus large que prévu
    • car l'analyse interne des fonctions appelées n'est pas réellement effectuée.
  • Il existe du code qui ne peut pas être sélectionné
    • en raison des limites de mapping entre le niveau MIR et le code source, tous les segments ne sont pas sélectionnables.
  • L'analyse conjointe des fonctions imbriquées, closures, async, etc. n'est pas possible
    • l'analyse se fait toujours uniquement à l'échelle de la plus petite fonction contenant le curseur actuel.

FAQ et divers

  • En cas d'échec d'installation de rustup : il faut l'installer manuellement via une commande, puis poursuivre depuis VSCode.
  • Raison de la non-intégration avec Rust Analyzer : Rust Analyzer ne prend pas en charge l'analyse MIR ni le borrow checker, il existe donc sous forme de plugin distinct.
  • Problème de mise en évidence du code : consultez la documentation des limites ci-dessus ; pour toute question supplémentaire, utilisez GitHub Issues, Discord ou Twitter.

Licence et informations open source

  • Publié sous licence MIT.
  • Les principaux langages de programmation sont Rust et TypeScript, ainsi que Python, HTML, JavaScript, etc.
  • Au 9 septembre 2025, il compte 2.6k stars et 61 forks, tout en étant activement développé et maintenu.

Conclusion

Flowistry est un outil open source qui apporte un avantage pratique important pour améliorer la compréhension contextuelle et la concentration dans les environnements de développement Rust. Il se distingue des autres outils d'analyse statique ou de Rust Analyzer en intégrant directement l'analyse de flux d'informations dans l'IDE de manière visuelle et en temps réel. Son utilité et son efficacité sont particulièrement attendues dans de nombreux contextes, notamment l'apprentissage de Rust, le refactoring et la revue de code.

À lire aussi

1 commentaires

 
GN⁺ 2025-10-20
Avis Hacker News

  • L’article scientifique proprement dit est ici, je réfléchis depuis longtemps aux back-references vérifiées statiquement en Rust, l’un des grands motifs d’insatisfaction des utilisateurs C/C++ vis-à-vis de Rust étant qu’il est difficile, lorsque A référence B, d’avoir à nouveau un pointeur de B vers A, ce qui conduit souvent à utiliser des contournements dangereux
    En Rust, on peut l’implémenter de façon sûre avec Rc, RefCell, Weak, borrow(), borrow_mut(), upgrade(), downgrade(), etc., mais le code devient verbeux, il y a un surcoût à l’exécution, et des paniques peuvent aussi survenir en cas de double borrow, même si l’expressivité est suffisante, j’ai rassemblé des notes sur le travail en cours
    La difficulté de la vérification statique consiste à confirmer que les portées empruntées (borrowed) ne se recouvrent pas, s’il n’y a pas de chevauchement entre les scopes de lifetime, il n’y a pas de conflit, mais la vérification des scopes devient plus délicate lors d’appels de fonctions ou d’appels à des fonctions génériques, l’approche de Flowistry pourrait aider
    Le fait que Flowistry ne traite pas complètement l’interior mutability (modification interne via RefCell, etc.) me gêne un peu
    En pratique, le cœur du sujet est de trouver des contraintes qui satisfont des conditions telles que 1) être sound, 2) être vérifiables à faible coût au moment de la compilation, 3) permettre l’usage des back pointers dont la plupart des gens ont besoin, comme les références vers le nœud parent d’un arbre, 4) fournir des messages de diagnostic utiles quand un problème survient

  • Je me demande s’il existe, dans d’autres langages, des fonctionnalités qui vérifient des dépendances un peu plus larges ou informelles à l’intérieur du corps d’une fonction
    Par exemple, quand on surligne un paramètre ou une variable foo, peut-on voir en une fois non seulement les usages de foo lui-même, mais aussi ceux de toutes les variables créées à partir de foo ?
    L’usage des borrows en Rust réalise parfaitement ce type de suivi, mais ce genre de visualisation semblerait aussi très utile dans du code écrit dans d’autres langages
    Je pense que Flowistry serait très utile sur des fichiers de code de bases modernes difficiles à maintenir, comme le code de layout flexbox de servo, cette fonction étant au passage l’un des fichiers de code les plus pénibles, avec plus de 400 lignes

    • (Je peux me tromper, mais) en général on appelle ça de la "flow analysis", et TypeScript l’exécute en arrière-plan pour affiner les types
      Mais il n’y a pas de fonctionnalité de visualisation

    • Ce type de fonctionnalité est généralement appelé "program slicing"

  • Je pense que c’est un outil très utile pour compenser le fait qu’on ne code pas toujours dans un style optimisé pour la lecture humaine
    Comme le code de base n’est pas toujours écrit pour être facilement lisible, j’ai l’impression que ce genre d’outil aide énormément

  • L’auteur a présenté à Rust East Coast une vidéo de conférence qui traite en profondeur du plugin et de la recherche sur les routines

  • Je trouve cette fonctionnalité vraiment géniale, la raison pour laquelle Rust se prête bien à ce genre de chose est que son système d’ownership limite les effets de bord
    Même si on greffait ça sur Python ou autre, on ne pourrait pas lui faire confiance à 100 %, puisqu’à l’exécution il est toujours possible de remonter la pile d’appels et de manipuler la mémoire à tout moment
    Malgré tout, c’est correct dans la plupart des cas, donc j’espère voir ce genre de fonctionnalité ajouté

    • (C’est l’auteur) C’est pour cela que je l’ai conçu en Rust, et la raison pour laquelle il est difficile d’implémenter cela ainsi dans d’autres langages

  • Je me demande s’il existe un outil similaire en TypeScript ou en JavaScript

  • Ça a l’air sympa, mais j’aurais préféré qu’on ne parle pas d’"IDE" et qu’on dise simplement plugin VSCode

    • C’est probablement parce que "Visual Studio Code" est une marque de Microsoft, le plugin fonctionne dans l’ensemble des IDE basés sur l’open source, comme VSCodium, Cursor, etc.

    • C’est aussi indiqué comme plugin d’IDE dans la documentation

  • L’idée de se concentrer sur les parties importantes du code me paraît vraiment excellente
    Je me demande s’il existe quelque chose de comparable en JS/TS

  • Je me demande comment cela s’est passé pour contribuer à la méthode LSP documentHighlight de rust-analyzer
    Cela fonctionne de manière assez similaire à ce que montre le GIF
    Ça semble être une fonctionnalité trop spécifique pour en faire un plugin
    Lien vers la spécification LSP correspondante

    • C’est expliqué dans le README, plus de détails ici

    • Il faut le MIR (Mid-level Intermediate Representation)

  • J’ai toujours rêvé d’une fonctionnalité comme celle-ci, et j’aurais aimé qu’elle montre aussi les chemins par lesquels les données arrivent depuis l’extérieur d’une fonction (qui appelle cette fonction)
    Je me demande s’il ne serait pas possible de réutiliser les données du compilateur pour aider à faire ça

    • D’après ce que j’ai entendu dans une présentation liée, on dirait qu’ils utilisent déjà les données du compilateur