ปลั๊กอิน IDE Flowistry ที่ช่วยให้โฟกัสเฉพาะโค้ดที่เกี่ยวข้องใน Rust

• Flowistry เป็นปลั๊กอิน IDE สำหรับภาษา Rust ที่ให้ความสามารถในการแสดงเฉพาะส่วนที่เกี่ยวข้องกับ โค้ดที่ต้องการโฟกัสอยู่ในตอนนี้
• ปลั๊กอินนี้วิเคราะห์ การไหลของข้อมูล ภายในโค้ด Rust และเน้นโค้ดที่เชื่อมโยงโดยตรงกับตัวแปรหรือ expression ที่กำลังดูอยู่
• ติดตั้งได้ง่ายในรูปแบบ ปลั๊กอิน VSCode และจะไฮไลต์เฉพาะโค้ดที่ให้ผลกระทบต่อหรือตัวแปรนั้นได้รับผลกระทบ
• ผ่านฟังก์ชันต่าง ๆ เช่น "Focus mode", "การตั้งค่า mark" ช่วยเพิ่มความเข้าใจในฟังก์ชันขนาดใหญ่หรือโค้ดที่ซับซ้อน
• แม้จะมีข้อจำกัดเช่น การรองรับ Interior Mutability ที่ยังไม่ครบถ้วน และ ขอบเขตการวิเคราะห์ที่จำกัด แต่ยังมีการพัฒนาอย่างต่อเนื่อง และเป็นเครื่องมือที่แยกจาก Rust Analyzer

---

ภาพรวมและความสำคัญของ Flowistry

Flowistry เป็นปลั๊กอิน IDE สำหรับนักพัฒนา Rust ที่เน้นแสดงเฉพาะโค้ดที่เกี่ยวข้องกับส่วนที่คุณกำลังโฟกัสในโค้ด ช่วยให้เข้าใจจุดสำคัญได้รวดเร็วและชัดเจนในฟังก์ชันขนาดใหญ่หรือกระบวนการโค้ดที่ซับซ้อน ทำให้มีคุณค่าการใช้งานเชิงปฏิบัติที่ต่างจากเครื่องมือวิเคราะห์แบบสแตติกอื่น ๆ เทคโนโลยีหลักคือ การวิเคราะห์การไหลของข้อมูล ซึ่งเป็นการวิเคราะห์เส้นทางการไหลของข้อมูลในโปรแกรมเพื่อระบุว่าบางส่วนของโค้ดสามารถส่งผลกระทบต่อโค้ดอื่นได้ Flowistry ให้การวิเคราะห์ประเภทนี้ตามลักษณะของภาษา Rust โดยอาศัยระบบ ownership/lifetime และ Rust MIR (Mid-level Intermediate Representation) เป็นต้น

คุณสมบัติหลักและวิธีทำงาน

• เมื่อคลิกตัวแปรหรือ expression เฉพาะในโค้ด Rust ระบบจะทำให้โค้ดที่ ไม่ส่งผลต่อหรือไม่ได้รับผลกระทบจาก ส่วนนั้นดูจางลง
• เน้นเฉพาะ โค้ดที่เกี่ยวข้อง แบบเป็นธรรมชาติ ลดการอ่านโค้ดที่ไม่จำเป็น และช่วยให้มองเห็นเส้นทางหลักของโค้ดได้เร็วขึ้น
• ในฟังก์ชันขนาดใหญ่หรือโค้ดยุ่งยาก เช่น ฟังก์ชันจริงของ Rust compiler สามารถเห็นได้ทันทีว่าพารามิเตอร์เฉพาะมีบทบาทอย่างไร
• อัลกอริทึมพื้นฐานใช้จากงานวิจัย 'Modular Information Flow through Ownership' ที่ตีพิมพ์ในการประชุม PLDI 2022

การติดตั้งและการรองรับสภาพแวดล้อม

การติดตั้งปลั๊กอิน IDE

• Flowistry สามารถติดตั้งได้เป็น ปลั๊กอิน VSCode ผ่าน Visual Studio Marketplace หรือ Open VSX Registry
• หลังจากเปิด Rust workspace แล้ว ระบบจะเริ่มขั้นตอนการติดตั้งและตั้งค่าอัตโนมัติ
• ไม่รองรับ NixOS และบนแพลตฟอร์ม ARM (เช่น M1 Mac ฯลฯ) ต้องคอมไพล์จากโค้ดต้นฉบับด้วยตัวเอง

Rustc plugin

• ฟังก์ชันการวิเคราะห์การไหลของข้อมูลถูกเผยแพร่เป็น crate แยก พร้อมเอกสารและ API โดยตรง

วิธีใช้และรายละเอียดฟีเจอร์

การเริ่มต้นใช้งาน

• เมื่อเปิดใช้งานปลั๊กอินใน VSCode จะมีการตรวจสอบชนิดข้อมูลของโค้ดทั้ง codebase ก่อน
• ผลลัพธ์ดังกล่าวถูกแคชไว้ที่โฟลเดอร์ target/flowistry

เข้าสู่โหมดโฟกัส

• ใช้คำสั่ง "Toggle focus mode" ของปลั๊กอิน (เช่น Ctrl+R Ctrl+A) เพื่อเข้าสู่โหมดโฟกัส
• เมื่อวางเคอร์เซอร์อยู่ในฟังก์ชัน การวิเคราะห์การไหลของข้อมูลในฟังก์ชันนั้นจะเริ่มทำงานอัตโนมัติ
• เมื่อปลั๊กอินวิเคราะห์เสร็จแล้ว จะเน้นเฉพาะโค้ดที่เกี่ยวข้องเท่านั้น (การวิเคราะห์อาจใช้เวลาถึงประมาณ 15 วินาที)

การตั้งค่า Mark

• เมื่อต้องการตรึงโซนที่โฟกัสค้างไว้และตรวจสอบโค้ดอื่น ใช้แนวคิด "Mark" เพื่อคงโซนปัจจุบันไว้ได้
• สามารถติดตั้ง/ยกเลิก mark ด้วย "Set mark" (Ctrl+R Ctrl+S), "Unset mark" (Ctrl+R Ctrl+D) เป็นต้น

เลือกโซนโฟกัส

• ใช้คำสั่ง "Select focused region" เพื่อเลือกบล็อกโค้ดที่ถูกเน้นทั้งหมดในครั้งเดียว แล้วคัดลอก ใส่คอมเมนต์ หรือแก้ไขได้

ข้อจำกัดและข้อควรระวัง

• ไม่รองรับ Interior Mutability อย่างเต็มที่
  • ตัวอย่างเช่น สำหรับโครงสร้างอย่าง Arc, Mutex เป็นต้น ความต่างของ lifetime ระหว่างการอ้างอิงทำให้ไม่สามารถติดตามได้อย่างครบถ้วน
• โซนโฟกัสอาจกว้างเกินกว่าที่คาดหวังในบางครั้ง
  • เพราะไม่สามารถวิเคราะห์ภายในฟังก์ชันที่ถูกเรียกได้จริง
• มีโค้ดที่เลือกไม่ได้บางส่วน
  • เนื่องจากข้อจำกัดของการแมประหว่างระดับ MIR กับ source code ทำให้เลือกโค้ดทั้งหมดไม่ได้
• ไม่สามารถวิเคราะห์ function nesting, closure, async ร่วมกันได้
  • การวิเคราะห์จะทำเฉพาะหน่วยฟังก์ชันที่เล็กที่สุดที่มีเคอร์เซอร์อยู่ในปัจจุบันเท่านั้น

FAQ และข้อมูลอื่นๆ

• กรณีติดตั้ง rustup ล้มเหลว: ควรติดตั้ง rustup ด้วยคำสั่งด้วยตนเองก่อน แล้วทำต่อใน VSCode ได้
• เหตุผลที่ไม่ได้ผสานกับ Rust Analyzer: Rust Analyzer ไม่รองรับการวิเคราะห์ MIR และ borrow checker จึงเป็นปลั๊กอินรูปแบบแยก
• ปัญหาเกี่ยวกับการไฮไลต์โค้ด: ดูเอกสารข้อจำกัด และสามารถติดต่อสอบถามเพิ่มเติมผ่าน GitHub Issues, Discord และ Twitter

ข้อมูลลิซอนซ์และโอเพ่นซอร์ส

• เผยแพร่ภายใต้ MIT License
• ภาษาโปรแกรมหลักคือ Rust, TypeScript นอกเหนือจากนั้นยังมี Python, HTML, JavaScript เป็นต้น
• ณ กุมภาพันธ์ 2025 2.6k stars, 61 forks และยังมีการพัฒนาและดูแลอย่างต่อเนื่อง

สรุป

Flowistry เป็นเครื่องมือโอเพ่นซอร์สที่ช่วยเพิ่มประโยชน์เชิงใช้งานจริงในการทำความเข้าใจบริบทและเพิ่มสมาธิในสภาพแวดล้อมการพัฒนา Rust โดยเฉพาะการผสานการวิเคราะห์การไหลของข้อมูลเข้าใน IDE แบบเรียลไทม์และนำเสนอแบบภาพ ทำให้ได้ประสบการณ์ที่ต่างจากเครื่องมือวิเคราะห์แบบสแตติกหรือ Rust Analyzer และคาดหวังการใช้งานได้อย่างมีประสิทธิภาพสูงในหลายสถานการณ์ เช่น การเรียนรู้ภาษา Rust การรีแฟกเตอร์โค้ด และ code review

[GN⁺]

ความคิดเห็นบน Hacker News

• ตัวบทความวิจัยจริงอยู่ที่นี่, กำลังคิดเรื่อง back-reference ที่ตรวจสอบแบบสแตติกได้ใน Rust มานานมาก, หนึ่งในเหตุผลใหญ่ที่ผู้ใช้ C/C++ ไม่พอใจกับ Rust คือเมื่อ A อ้างอิง B ก็ทำให้ B ถือพอยน์เตอร์กลับไปหา A ได้ยาก, เลยทำให้ส่วนใหญ่ต้องใช้วิธีอ้อมที่ไม่ปลอดภัย
  ใน Rust สามารถทำได้อย่างปลอดภัยด้วย Rc, RefCell, Weak, borrow(), borrow_mut(), upgrade(), downgrade() ฯลฯ แต่โค้ดจะยืดยาวขึ้นและมี runtime overhead อีกทั้งบางครั้งก็เกิด panic จากการ borrow ซ้อนกันได้ ถึงอย่างนั้นก็ยังมี expressive power เพียงพอ, ได้สรุปโน้ตไว้กับงานที่กำลังทำอยู่
  ส่วนที่ตรวจสอบแบบสแตติกได้ยากคือการยืนยันว่าช่วงของการยืม (borrowed) ไม่ทับซ้อนกัน ถ้า lifetime scope ไม่ซ้อนกันก็จะไม่ชนกัน, แต่การเช็ก scope จะยากขึ้นเมื่อมีการเรียกฟังก์ชันหรือ generic function, แนวทางของ Flowistry อาจช่วยได้
  กังวลอยู่ว่า Flowistry ยังจัดการ interior mutability (การเปลี่ยนแปลงภายในอย่าง RefCell เป็นต้น) ได้ไม่ครบถ้วน
  ในงานจริง ประเด็นสำคัญคือการหาข้อจำกัดที่ตอบโจทย์เงื่อนไขอย่าง 1) sound, 2) ตรวจสอบได้โดยมีต้นทุนต่ำใน compile time, 3) ใช้ back pointer ที่คนส่วนใหญ่ต้องการได้ เช่น การอ้างอิง parent node ของต้นไม้, 4) ให้ข้อความวินิจฉัยที่มีประโยชน์เมื่อเกิดปัญหา

• สงสัยว่ามีภาษาอื่นที่มีความสามารถในการตรวจสอบ dependency ภายใน function body ที่ใหญ่กว่าหรือไม่เป็นทางการกว่านี้ไหม
  เช่น ถ้าไฮไลต์พารามิเตอร์หรือ ตัวแปร foo จะเห็นได้ในครั้งเดียวไม่ใช่แค่การใช้งาน foo เอง แต่รวมถึงการใช้งานตัวแปรทั้งหมดที่สร้างมาจาก foo ด้วยหรือไม่
  การใช้ borrow ของ Rust ติดตามเรื่องลักษณะนี้ได้อย่างสมบูรณ์แบบ แต่การทำ visualization แบบนี้ก็น่าจะมีประโยชน์มากกับโค้ดภาษาอื่นด้วย
  คิดว่า Flowistry จำเป็นมากกับไฟล์ในโค้ดเบสสมัยใหม่ที่ดูแลรักษายาก เช่น โค้ดเลย์เอาต์ flexbox ของ servo, อ้างอิงไว้ว่า function นี้ยาวเกิน 400 บรรทัดและเป็นหนึ่งในไฟล์โค้ดที่ชวนปวดหัวที่สุด

  • (ผมอาจจะเข้าใจผิด) โดยทั่วไปสิ่งนี้เรียกว่า "flow analysis" และ TypeScript ก็รันสิ่งนี้อยู่เบื้องหลังเพื่อทำ type narrowing
    แต่ไม่มีฟีเจอร์ visualization

  • โดยทั่วไปฟีเจอร์แบบนี้เรียกว่า "program slicing"

• ถ้าไม่ได้เขียนโค้ดในสไตล์ที่ปรับให้มนุษย์อ่านง่าย ก็คิดว่านี่เป็นเครื่องมือที่มีประโยชน์มากในการชดเชยจุดนั้น
  เพราะโค้ดต้นทางไม่ได้ถูกเขียนให้อ่านง่ายเสมอไป เลยรู้สึกว่าเครื่องมือแบบนี้ช่วยได้มาก

• ผู้เขียนได้โชว์วิดีโองานนำเสนอที่ Rust East Coast ซึ่งลงลึกมากเกี่ยวกับปลั๊กอินและงานวิจัยเรื่อง routines

• คิดว่าเป็นฟีเจอร์ที่เจ๋งมาก และเหตุผลที่ Rust เหมาะกับฟีเจอร์แบบนี้ก็เพราะระบบ ownership ของมันทำให้ side effect ถูกจำกัด
  ถ้าเอาแบบนี้ไปใส่ใน Python หรือภาษาอื่น ๆ ก็จะเชื่อถือได้ไม่ 100% เพราะตอนรันไทม์สามารถไล่ขึ้น call stack ไปแก้หน่วยความจำได้ตลอด
  ถึงอย่างนั้นส่วนใหญ่ก็มักจะถูกต้อง เลยหวังว่าจะมีฟีเจอร์แบบนี้เพิ่มเข้ามา

  • (ผู้เขียนเอง) นั่นจึงเป็นเหตุผลที่เลือก Rust มาสร้าง และเป็นเหตุผลว่าทำไมถึงทำแบบนี้ในภาษาอื่นได้ยาก

• สงสัยว่ามีเครื่องมือคล้ายกันนี้ใน TypeScript หรือ JavaScript ไหม

• ดูเจ๋งดี แต่รู้สึกว่าไม่ควรเรียกว่า 'IDE' น่าจะเรียกตรง ๆ ว่าเป็นปลั๊กอินของ VSCode จะดีกว่า

  • น่าจะเป็นเพราะ "Visual Studio Code" เป็นเครื่องหมายการค้าของ Microsoft, ปลั๊กอินนี้ทำงานได้กับ IDE ที่อิงโอเพนซอร์สโดยรวม เช่น VSCodium, Cursor เป็นต้น

  • ในเอกสารก็ระบุไว้ว่าเป็น IDE plugin

• ไอเดียเรื่องการโฟกัสไปที่ส่วนสำคัญของโค้ดดูดีมากจริง ๆ
  สงสัยว่ามีอะไรคล้ายกันนี้ใน JS/TS ไหม

• อยากรู้ว่าการไปมีส่วนร่วมกับเมธอด documentHighlight ของ LSP ใน rust-analyzer เป็นอย่างไรบ้าง
  มันทำงานคล้ายกับฟีเจอร์ที่เห็นใน GIF มากพอสมควร
  ดูเป็นฟีเจอร์ที่เฉพาะทางเกินไปถ้าจะทำเป็นปลั๊กอิน
  ลิงก์สเปก LSP ที่เกี่ยวข้อง

  • อธิบายไว้ใน README, ดูรายละเอียดได้ที่นี่

  • ต้องใช้ MIR(Mid-level Intermediate Representation)

• ฝันถึงฟีเจอร์แบบนี้มาตลอด และอยากให้มีความสามารถแสดงเส้นทางที่ข้อมูลไหลเข้ามาจากภายนอกฟังก์ชันด้วย (ว่าใครเป็นคนเรียกฟังก์ชันนี้)
  คิดว่าน่าจะช่วยได้ถ้าเอาข้อมูลของคอมไพเลอร์มาใช้ซ้ำเพื่อสนับสนุนเรื่องนี้

  • จากที่ได้ยินในงานบรรยายที่เกี่ยวข้อง ดูเหมือนว่าจะใช้ข้อมูลของคอมไพเลอร์อยู่แล้ว