Flowistry: una extensión de IDE para enfocarte en el código relacionado en Rust

• Flowistry es una extensión de IDE para el lenguaje Rust que ofrece una función para mostrar solo las partes relacionadas con el código en el que quieres enfocarte.
• Este plugin analiza el flujo de información del código Rust y destaca visualmente solo el código directamente conectado con la variable o expresión que estás viendo.
• Se puede instalar fácilmente como una extensión de VSCode, y resalta de forma destacada únicamente el código que afecta o es afectado por la variable seleccionada.
• A través de funciones como "Focus mode" y "configuración de marca" ayuda a mejorar la comprensión de funciones grandes o código complejo.
• Aunque tiene limitaciones, como el manejo incompleto de mutabilidad interna y restricciones del alcance del análisis, sigue mejorando y es una herramienta separada de Rust Analyzer.

---

Visión general y relevancia de Flowistry

Flowistry es una extensión de IDE para desarrolladores de Rust que resalta y muestra solo el código relacionado con la parte actual en la que deseas concentrarte. Esto permite identificar rápidamente la porción necesaria dentro de funciones grandes o flujos de código complejos, y por eso aporta un valor práctico que lo diferencia de otras herramientas de análisis estático. La técnica central es el análisis de flujo de información, que consiste en identificar las rutas mediante las cuales un fragmento de código puede influir en otro dentro de un programa. Flowistry implementa este análisis aprovechando las características de Rust, su sistema de propiedad y vida útil (ownership/lifetime), y el IR de nivel medio de Rust (Rust MIR, Mid-level Intermediate Representation).

Funciones principales y forma de funcionamiento

• Al hacer clic en una variable o expresión específica dentro de código Rust, se difuminan las partes del código que no influyen o no son influenciadas por ella.
• De forma intuitiva, se destacan únicamente los códigos relacionados, reduciendo la lectura innecesaria y permitiendo entender rápidamente el flujo central del código.
• En código complejo, como una función real del compilador de Rust o funciones de gran tamaño, puedes ver de un vistazo qué papel desempeña un argumento específico.
• El algoritmo base del análisis se fundamenta en el artículo 'Modular Information Flow through Ownership', publicado en PLDI 2022.

Instalación y soporte de entorno

Instalación del complemento de IDE

• Flowistry está disponible como extensión de VSCode y se puede instalar desde Visual Studio Marketplace o el registro Open VSX.
• Después de abrir un workspace de Rust, la instalación y configuración inicial se realizan automáticamente.
• NixOS no es compatible, y en plataformas ARM (como Macs con M1) debes compilar desde el código fuente.

Complemento de Rustc

• La funcionalidad de análisis de flujo de información también se publica como una crate independiente, y se incluyen documentación y API detalladas.

Uso y detalles de funciones

Ejecución inicial

• Al ejecutar el plugin en VSCode, primero se realiza la verificación de tipos de toda la base de código.
• El resultado se guarda en caché en la carpeta target/flowistry.

Acceso al modo Focus

• Entra al modo de enfoque con el comando "Toggle focus mode" del plugin (Ctrl+R Ctrl+A, entre otros).
• Cuando colocas el cursor dentro de una función, el análisis de flujo de información se ejecuta automáticamente para esa función.
• Cuando el plugin completa el análisis, se resaltan solo los códigos relacionados (el análisis puede tardar hasta unos 15 segundos).

Configuración de marca

• Para mantener una región de enfoque fija mientras revisas otro código, puedes usar el concepto de "Mark" para conservar la zona actual.
• Puedes fijar y quitar la marca con "Set mark" (Ctrl+R Ctrl+S) y "Unset mark" (Ctrl+R Ctrl+D).

Selección de la región en foco

• Con el comando "Select focused region" puedes seleccionar en un solo paso todo el bloque de código resaltado, y luego copiar, comentar, etc.

Limitaciones y observaciones importantes

• No soporta completamente la mutabilidad interior (Interior Mutability)
  • Ejemplo: en estructuras como Arc, Mutex, no se puede trazar por completo debido a diferencias de lifetime entre referencias.
• El área de foco puede volverse a veces más amplia de lo esperado
  • Esto ocurre porque no analiza internamente las funciones llamadas.
• Hay código que no se puede seleccionar
  • Debido a límites de mapeo entre el nivel MIR y el código fuente, no todo el código es seleccionable.
• No analiza juntas funciones anidadas, cierres (closures) y async
  • El análisis siempre se realiza únicamente sobre la unidad de la función más pequeña que contiene el cursor actual.

Preguntas frecuentes y otros puntos

• Si falla la instalación de rustup: instala rustup manualmente por línea de comandos y luego continúa desde VSCode.
• Motivo por el que no se integra con Rust Analyzer: Rust Analyzer no admite análisis MIR ni soporta el borrow checker como parte de esta función, por lo que se mantiene como plugin separado.
• Sobre problemas de resaltado de código: consulta la documentación de limitaciones; también puedes plantear preguntas adicionales en GitHub Issues, Discord o Twitter.

Licencia e información de código abierto

• Publicado bajo licencia MIT.
• Los lenguajes principales son Rust y TypeScript, además de Python, HTML, JavaScript, entre otros.
• Al 9/2025, cuenta con 2.6k stars y 61 forks, y se mantiene en desarrollo activo.

Conclusión

Flowistry es una herramienta de código abierto que aporta ventajas prácticas significativas para mejorar la comprensión del contexto y la concentración en entornos de desarrollo de Rust. En particular, al integrar el análisis de flujo de información en tiempo real dentro del IDE y mostrarlo visualmente, ofrece una experiencia diferenciada respecto a otras herramientas de análisis estático o a Rust Analyzer. Puede ser muy útil y eficiente en múltiples escenarios, como aprender Rust, hacer refactorizaciones o realizar revisiones de código.

[GN⁺]

Opinión de Hacker News

• El paper real está aquí; desde hace mucho tiempo he estado pensando en back-references verificadas estáticamente en Rust. Una de las grandes razones por las que usuarios de C/C++ se quejan de Rust es que, cuando A referencia a B, es difícil que B vuelva a tener un puntero hacia A, así que normalmente se terminan usando atajos inseguros.
  En Rust se puede implementar de forma segura usando Rc, RefCell, Weak, borrow(), borrow_mut(), upgrade(), downgrade(), etc., pero el código se vuelve verboso, hay sobrecarga en tiempo de ejecución y a veces ocurren pánicos por doble borrow. Aun así, la expresividad es suficiente; he ido dejando notas sobre el trabajo en curso aquí.
  La parte difícil de verificar estáticamente es confirmar que los rangos prestados (borrowed) no se solapen; si los scopes de lifetime no se superponen, no hay conflicto. Al llamar funciones o funciones genéricas, revisar los scopes se vuelve más complicado. El enfoque de Flowistry podría ayudar.
  Me preocupa que Flowistry no maneje por completo la interior mutability (cambios internos como RefCell).
  En la práctica, la clave es encontrar restricciones que cumplan condiciones como: 1) que sea sound, 2) que pueda verificarse con poco costo en tiempo de compilación, 3) que permita usar back pointers que la mayoría necesita, como referencias al nodo padre de un árbol, y 4) que ofrezca mensajes de diagnóstico útiles cuando haya problemas.

• Me pregunto si en otros lenguajes existe una función para revisar dependencias un poco más amplias o informales dentro del cuerpo de una función.
  Por ejemplo, si resaltas el parámetro o variable foo, ¿puedes ver de una vez no solo los usos de foo, sino también los usos de todas las variables creadas a partir de foo?
  El uso de borrow en Rust hace perfectamente este tipo de seguimiento, pero una visualización así también sería muy útil en código de otros lenguajes.
  Creo que Flowistry sería muy necesario en archivos de codebases modernas difíciles de mantener, como el código de layout flexbox de servo; por cierto, esa función tiene más de 400 líneas y es uno de los archivos de código más incómodos que he visto.

  • (Puedo estar equivocado, pero) por lo general a esto se le llama "flow analysis", y TypeScript la ejecuta en segundo plano para refinar tipos.
    Pero no tiene funciones de visualización.

  • A este tipo de función normalmente se le llama "program slicing".

• Me parece una herramienta muy útil para compensar cuando no se programa con un estilo optimizado para que humanos lo lean fácilmente.
  Como el código base no siempre está escrito de forma legible, siento que este tipo de herramienta ayuda muchísimo.

• El autor presentó un video de charla en Rust East Coast donde profundiza bastante en el plugin y la investigación sobre rutinas.

• Me parece una función realmente genial; la razón por la que Rust encaja tan bien con esto es que su sistema de ownership limita los efectos secundarios.
  Aunque se le agregara algo así a Python o similares, en runtime siempre se puede subir por el call stack y manipular memoria, así que no sería 100% confiable.
  Aun así, en la mayoría de los casos sería correcto, así que ojalá agreguen una función así.

  • (Soy el autor) Por eso elegí Rust para construirlo, y esa es la razón de que sea difícil implementarlo así en otros lenguajes.

• Me pregunto si existe una herramienta parecida para TypeScript o JavaScript.

• Se ve genial, pero habría sido mejor no llamarlo "IDE" y decir simplemente que es un plugin de VSCode.

  • Probablemente porque "Visual Studio Code" es una marca registrada de Microsoft; el plugin funciona en IDEs basados en código abierto en general, como VSCodium, Cursor, etc.

  • En la documentación también se indica explícitamente como plugin de IDE.

• La idea de enfocar la atención en las partes importantes del código me parece realmente buena.
  Me pregunto si hay algo parecido también para JS/TS.

• Me pregunto cómo fue contribuir al método documentHighlight de LSP en rust-analyzer.
  Funciona de forma bastante parecida a la función que muestran en el GIF.
  Parece una función demasiado específica como para hacerla como plugin.
  Enlace a la especificación LSP relacionada

  • Se explica en el README; puedes ver más detalles aquí.

  • Se necesita MIR (Mid-level Intermediate Representation).

• Siempre soñé con una función así, y quería que también mostrara la ruta por la que fluyen los datos desde fuera de la función (quién llama a esta función).
  Pienso que quizá se podría reutilizar la información del compilador para ayudar con eso.

  • Según escuché en la charla relacionada, parece que ya están usando datos del compilador.