旋武社区

Rust 的软件工程技术进展与语言演进：全面综述

作者：冯洋、陈渝、王冬

作者简介

冯洋，南京大学计算机学院副教授，研究方向为软件质量保障，具体研究课题包括复杂软件系统的质量保障技术，基于Rust语言的软件质量保障等，email: fengyang@nju.edu.cn 陈渝，清华大学计算机系副教授，博士生导师，主要研究方向为操作系统，并以操作系统为核心，介入普适计算、并行计算、计算机体系结构、虚拟机、嵌入式系统、无线传感器网络等研究领域，email: yuchen@tsinghua.edu.cn 王冬，河南大学教授 ，研究领域:智能化软件工程，软件性能分析测试，程序设计语言研究，email: juliawdd@henu.edu.cn

摘要 ​

Rust 已成为一种强大的系统编程语言, 兼具高性能和内存安全的保证. 本文系统地调查了五个相互关联的研究领域, 这些领域支撑着Rust 的发展与成熟: (1) 语言分析与扩展, 包括形式语义学、类型系统改进和领域特定语言(DSL);(2) 程序质量保障, 涵盖高级测试、模糊测试、静态与动态分析以及形式化验证技术; (3)跨语言编程, 包括外部函数接口(FFI) 集成和转译策略; (4) 编译器构建与优化, 涉及基于MIR 和LLVM 支持的优化传递、类型级安全增强以及硬件辅助内存保护; (5) 开源生态系统发展, 重点讨论库、工具和应用框架的快速增长。对于每个领域, 我们综合了关键进展, 如基于所有权的验证、通过LLM 进行自动重构、适应性编译器架构和基于保护区的隔离, 并批判性地审视了在可扩展性、可用性和互操作性方面的局限性。最后, 我们总结了新兴趋势, 包括AI 增强的证明合成、统一的安全框架和动态优化技术, 并提出了一条路线图, 以解决当前的空白, 指导未来工作朝着更加稳健、高效和广泛可用的Rust 解决方案发展。

关键词 ​

Rust, 文献综述, 编程语言, 软件工程

1. Rust 编程语言概述和历史 ​

Rust 编程语言是一种系统级语言，旨在在不影响底层控制的情况下实现内存安全、并发和高性能。与依赖垃圾收集的传统语言不同，Rust 采用复杂的所有权系统并结合生命周期等概念来确保内存安全，而无需运行时开销[1]。这种设计确保诸如空指针解引用、缓冲区溢出以及数据竞争等内存问题在编译阶段即被消除，从而使其成为性能关键型和并发系统的理想选择。

近年来，Rust 在编程社区中获得了巨大的关注，其采用率和语言特性都在快速演进。根据2024 年StackOverflow 开发者调查，Rust 连续第八年被评为“最受喜爱”的语言，这不仅凸显了其不断壮大的社区，也反映了开发者对其的高度热情[2].。与此同时，Rust 已被多家重要机构和大型企业采纳，进一步巩固了其作为一种可靠且高效的编程语言的声誉。值得注意的是，白宫国家网络主任办公室最近强调了使用内存安全漏洞较少的编程语言的必要性[3]。此外，Google 也在Android 13 操作系统中大幅从C/C++ 转向Rust，以提升系统的安全性和可靠性[4]。Rust 在微软的Windows 内核中也得到了越来越多的采用[5]，进一步证了它对关键系统级软件的适用性。Rust 在这些高知名度项目中的应用，突显了其在应对复杂底层编程挑战方面的多样性与强大能力。从构建安全高效的数据库系统到保障操作系统的安全，Rust 在解决现代软件开发难题中的作用日益凸显。这不仅展示了其广泛的潜力，也反映了业界对其能力日益增长的信心[6∼10].。

作为一种相对较新的系统编程语言，Rust 引发了软件工程和编程语言等领域越来越多的研究。研究人员探索了与Rust 相关的各种主题，特别是在它与更传统语言的区别领域。值得注意的重点领域包括研究安全与不安全Rust [11∼16]，研究Rust 的内存安全保证与不安全代码块提供的灵活性之间的界限和权衡。此外，大量研究致力于分析和测试Rust 程序，重点是静态分析工具[17∼19]、错误检测[17,20∼22]，以及提高Rust 编译器(rustc) 的可靠性[23, 24]。另一个重要的研究方向涉及翻译和互操作性，例如Rust 与其他语言的集成，或者开发用于将Rust 代码编译到不同平台的工具[25∼28]。这些研究工作反映出人们对充分了解Rust 的潜力、解决其挑战以及优化其在实际应用中的使用越来越感兴趣。

尽管与Rust 相关的研究主题不断增多，研究方向也日益拓展，但目前仍缺乏对现有Rust 研究的全面综述和系统性分析。这一缺失使研究者难以准确识别尚待解决的关键问题，从而减缓了针对性创新的进程。此外，在缺乏统一框架来整合分散研究成果的情况下，社区面临知识碎片化的风险，不仅阻碍跨学科合作，也不利于Rust 生态的连贯发展与演进。

为了弥补这一空白，本文概述了该语言的发展历史及其核心特征。这样的综述不仅有助于巩固现有知识体系，也为未来研究者理解Rust 相关研究的最新进展提供重要参考。通过梳理Rust 研究的发展脉络，本工作能够为持续进行的研究与新兴研究提供方向指引，包括解决开放问题、改进现有工具，以及优化Rust 在各类应用场景中的实践。在本文中，我们系统总结并分类了过去十年中所有主要的Rust 相关研究论文，将其组织为语言分析、程序分析、跨语言研究、编译器研究以及工具链等关键领域。通过描绘这些不同研究方向的整体版图，本文揭示了当前Rust 研究中存在的挑战与难点。最后，我们对潜在的未来研究方向进行了分析，为推动Rust 语言本身的发展及其生态系统的进一步演进提供了见解。

1.1 Rust 简史 ​

Rust 编程语言专注于安全性、高效和并发性，自诞生以来经历了一段非凡的历程。图1描述了Rust 编程语言的时间演变，简要说明了其重要的里程碑和版本。

加载中...

Rust 的第一个稳定版本是2015 版，于2015 年5 月发布，为语言奠定了核心原则的基础，包括所有权、借用和生命周期，这些特性使其区别于其他系统级语言。尽管该版本确立了关键的语法与语义，但尚未包含许多更高级的功能。2018 版于2018 年底发布，标志着Rust 的一次重大飞跃，显著改善了开发体验并简化了复杂任务。该版本的亮点包括引入非词法生命周期（NLL），进一步提升内存安全性；引入async/await 语法，大幅简化异步编程。此外，工具链生态（尤其是cargo 和错误信息）得到了强化，模块系统也经过重组以优化代码管理。进入2021 版（于2021 年10 月发布）后，该版本进一步聚焦于语言的精炼与性能改进，包括更可预测的const 泛型、针对异步代码的更完善错误处理机制，以及对闭包引入“分离捕获”（disjoint capture）能力，从而使闭包的使用更加灵活。该版本还改进了let 绑定，使其支持更具表达力的解构模式。最新的2024版于2024 年12 月发放预览版（撰写本文时正式版尚未发布）。预计该版将继续推动Rust 的演进，重点改善语言易用性、编译器性能和错误处理工具。此外，该版预计将增强与其他语言的互操作性，特别是在嵌入式系统和日益发展的机器学习领域，这将进一步促进Rust 在更广泛的软件生态中的深度融合。总体而言，每一版Rust 都体现了其在创新与稳定性之间的谨慎平衡，确保新增特性持续强化其在安全性、并发性与性能方面的核心优势。

事实上，自2006 年诞生以来，Rust 一直在稳步发展和完善其设计与特性。Rust 的最初原型由GraydonHoare 提出[29]，旨在解决现有语言在安全且高效地处理并发任务方面的不足。2009 年，Rust 的潜力引起了Mozilla 的关注并获得其赞助，这一支持显著加速了Rust 的发展进程。2012 年1 月20 日，第一个可用版本Rust 0.1 发布，奠定了语言的基本概念和设计目标。同年发布的Rust 0.2 和Rust 0.3 带来了大量变更，包括文档工具、编译模型以及代码编写便利性的全面改进。例如2012 年3 月29 日发布的Rust 0.2 包含超过1500个变更，并新增对FreeBSD 的支持；Rust 0.3 提供了对切片（slices）和固定大小向量（fixed-size vectors）的实验性支持。到2012 年10 月15 日发布的Rust 0.4 时，语言已发生显著变化，包括更严格的关键字使用规则、以结构体替代类、增强traits 实现能力，以及改进并发特性。Rust 0.5 标志着向稳定版迈进的重要节点，其包含约900 项变更，移除了move 操作符、扩展了macro 功能，并引入全新的条件处理系统。Rust 0.6 则继续更新语法与语义，并增加了对大整数（big integers）的支持。2015 年5 月15 日，Rust 1.0 正式发布，这是一个里程碑事件，标志着大部分标准库的稳定化，同时在debug 构建中开始进行整数算术溢出检查Rust1.0 也开启了Rust 2015 时代。随后发布的Rust 1.03 与Rust 1.06 引入了新的对象生命周期默认规则、Cargo的默认增量编译，以及编译器与标准库的进一步优化。Rust 1.08 则继续改进Cargo 并新增多项稳定API。总体来看，每个版本都在不断完善与稳定语言特性，逐步增强Rust 的能力与开发体验，为其成为现代系统编程的重要力量奠定了坚实基础。

多年来，多个版本引入了关键特性，塑造了Rust 的发展格局。Rust 1.15 稳定了基本的procedural macros，支持自定义的 #[derive]，并支持空元组结构体（empty tuple structs）。Rust 1.26 改进了closures 和inclusiverange 语法，稳定了impl Trait 和128 位整数（128-bit integers）。Rust 1.31 标志着Rust 2018 的发布，引入了多个以提升生产力为主题的特性。Rust 1.31 不仅引入了新的生命周期省略（lifetime elision）规则，还支持const 函数（const functions）和工具lint。Rust 1.39 引入了async 编程，这是对异步应用开发的一项重要增强。在近期版本中，Rust 继续演进，带来了重要新增功能。Rust 1.54 支持内置属性中的for 宏、多重泛型生命周期（multiple generic lifetimes），并允许在const fn 中进行无大小切片类型（unsized slice types）转换。Rust 1.56（标志Rust 2021 Edition）增强了closure 捕获（closure capture）和原始指针（rawpointer）功能。Rust 2021 为Rust 带来了新能力，使语言更加一致，并为未来扩展提供了空间。Rust 1.65 稳定了如let else、GATs 和带标签的block break（labeled block breaks）等特性，同时引入了新的lint，将未初始化的整数/指针定义为立即UB（undefined behavior），体现了对创新与安全的承诺。Rust 1.70 进一步放宽了asm! 操作数规则，允许在format args 中捕获（captures），并增加了新的调试信息选项。随后版本，如Rust 1.74 和Rust1.79，澄清了生命周期规则，稳定了inline const 表达式和API，并防止不透明类型（opaque types）重复实例化，以提升代码质量。最近的更新，如Rust 1.81 和Rust 1.83，聚焦于增强安全性和功能性，包括在extern”C” 函数中对未捕获panic 进行abort、引入新的const 能力，以及稳定raw lifetimes 和labels。随着Rust1.83 在master 分支上完成Rust 2024 的稳定化，Rust 2024 版将随Rust 1.85.0 于2025 年2 月20 日正式发布，延续Rust 在创新与安全上的发展传统。

1.2 Rust 语言特性 ​

作为一种旨在平衡安全性和性能的语言，Rust 引入了创新的功能和原则，从本质上确保内存安全而不牺牲效率。Rust 本质上将所有权、借用和生命周期等机制集成到其类型系统和编译过程中。这些机制旨在提供内存安全的编译时保证，消除悬空指针、数据争用和内存泄漏等常见问题。本节探讨Rust 的核心设计元素，包括其编译过程、所有权模型、类型系统和其他定义特征，这些特征共同有助于其强大的安全保证。

所有权机制。Rust 的所有权机制遵循基于所有权的资源管理原则（Ownership-Based Resource Manage- ment, OBRM）。该原则要求: 内存中的每个值都必须有且只有一个所有者，即持有该值的变量。当所有者离开其作用域时，相应的值会被自动释放，这与C++ 中的RAII（Resource Acquisition Is Initialization）原则相一致。Rust 采用自动化的内存管理方式，有效规避了手动内存管理中常见的大量安全问题，例如双重释放、释放后使用等漏洞。通过在编译阶段强制执行严格的所有权规则，Rust 在无需垃圾回收器的情况下杜绝了这些常见的内存安全缺陷。此外，这一机制也避免了垃圾回收带来的运行时开销，从而实现更高效的性能表现。

借用。 此外，在所有权机制的基础上，Rust 引入了借用的概念，它允许在不影响安全性的情况下更灵活、更高效地访问数据。借用允许函数在不获取所有权的情况下访问值。这是通过引用来实现的，引用可以是不可变的(&T) 或可变的(&mut T)。不可变引用允许代码的多个部分同时读取一个值而不修改它，而可变引用允许修改该值但强制执行独占访问，确保任何时候只存在一个可变引用。基于这一概念，Rust 要求引用满足以下借用规则: (1) 在任何给定时间，每个拥有的值可以有一个可变引用或任意数量的不可变引用；(2) 引用必须始终有效。第一条规则通过保证可变访问的独占性防止数据竞争，第二条规则通过确保引用不超过其指向数据的生命周期来消除悬垂指针的可能性。为了执行这些规则，Rust 编译器内置了借用检查器（borrow checker），在编译时验证引用的正确使用，确保其在有效生命周期内。

生命周期 为了有效地执行借用规则，Rust 引入了生命周期（lifetime）的概念，它定义了引用有效的作用域。通过生命周期标注，借用规则得以具体实现，其基本原则包括:(1) 在任意时刻，具有特定生命周期的可变引用不得与指向同一值的其他引用重叠；(2) 每个引用的生命周期不得超过其所指向值的作用域。为遵循这些规则，Rust 的借用检查器会利用生命周期来确保在同一时间对单个值，要么存在一个可变引用，要么存在多个不可变引用，并且引用不会超过其指向数据的生命周期。通常，生命周期会在函数签名中进行标注，以明确参数与返回值之间的生命周期关系。虽然Rust 通常能够自动推断生命周期，但在复杂场景下，显式标注有助于确保内存安全。

1.3 编译过程 ​

加载中...

如图 2 所示，Rust 的编译过程是一个多阶段流水线，将源代码转换为可执行二进制文件，同时保证安全性、性能和正确性。从词法分析（lexing）、语法分析（parsing），到抽象语法树（AST）和中级中间表示（MIR,middle-level intermediate representation）降级，最终到代码生成，每一个阶段都在整合Rust 独特语言特性（如所有权、借用、宏以及强类型系统）和生成高质量机器码方面发挥着关键作用。在这一过程中，使用诸如高级中间表示（HIR, high-level intermediate representation）和MIR 等中间表示，有助于进行细致的分析与优化，最终生成高质量的机器码。本节将介绍Rust 的编译流程，以及各个阶段如何处理这些语言特性。

Rustc 调用。 Rust 的编译过程从用户编写Rust 源程序并调用rustc 编译器开始。编译器执行的具体任 务由命令行选项决定，这些选项可以启用nightly 功能、仅进行语法检查（check-only build），或生成LLVM中间表示（LLVM-IR）而非可执行机器码。通常，rustc 的调用是通过Rust 的包管理器Cargo 间接管理的。

词法分析与语法分析。一旦调用rustc，源代码首先由低级词法分析器（lexer）处理，将文本转换为一系列标记（tokens）。这些标记是源代码的最小单位，如关键字、标识符、运算符和字面量，lexer 支持Unicode字符编码。随后，高级词法分析器对标记流进行预处理，包括验证和将字符串转换为interned 符号，以提高字符串存储和比较效率。解析器（parser）使用递归下降方法将标记流翻译为抽象语法树（AST），AST 表示源代码的语法结构。在此阶段，还会进行宏展开（macro expansion）、AST 校验、名称解析（name resolution）和早期lint 检查。此外，解析器尝试通过解析Rust 语法的超集来从错误中恢复，并输出适当的错误信息。

AST 降级与分析 。AST 会被转换为高级中间表示（HIR, High-level Intermediate Representation），一种更适合编译器处理的表示形式。该过程称为“降级（lowering）”，包括对语法结构如循环和异步函数进行糖衣语法去除（desugaring）。HIR 用于类型推断（type inference）、特征解析（trait resolution）和类型检查（type checking）。类型推断自动确定表达式的类型，特征解析将特征引用与其实现进行匹配，而类型检查通过将用户定义类型转换为编译器内部表示来确保类型安全和正确性。

MIR 降级与分析。 HIR 进一步降级为中级中间表示MIR（MIR, Mid-level Intermediate Representation），用于执行借用检查，这是Rust 所有权模型的核心部分。在转换为MIR 之前，还会构建一种更去糖的表示形式，即类型化高级中间表示（THIR, Typed High-level Intermediate Representation），用于模式匹配和穷尽性检查。MIR 阶段会应用多种优化，以提升代码生成效率和编译速度。MIR 也是Rust 代码单态化（monomorphization）的阶段，即将泛型代码实例化为具体类型以生成实际实现。

代码生成 。最后阶段是将MIR 转换为LLVM-IR 的代码生成阶段。在此阶段，MIR 会被单态化（monomor-phized），生成的LLVM-IR 会传递给LLVM 进行进一步优化。LLVM 随后生成机器码，本质上是带有附加注释的汇编代码。不同的库和二进制文件会被链接在一起，生成最终的可执行文件。在整个编译过程中，集成了几个关键的Rust 语言特性:（1）所有权和借用。这些功能在MIR 阶段强制执行，借用检查可确保安全的内存访问模式。(2) 宏。宏扩展发生在解析阶段，提供强大的元编程功能。(3) 类型系统。Rust 强大的静态类型系统在HIR 和MIR 阶段用于类型推断、检查和特征解析。(4) 并发性。Rust 的并发模型在代码生成过程中进行了优化，以确保高效、安全的多线程。这一分层编译流水线体现了Rust 在保证关键安全性前提下保持高性能的能力，使其能够生成健壮、跨平台的可执行文件，同时坚持安全性、高效和并发的核心原则，而不牺牲开发者的生产力。

论文结构。本文的结构如下: 第3 节介绍语言分析与扩展技术的概览，重点讨论现有的Rust 语言扩展方法；第4 节探讨提升Rust 程序质量的综合方法，包括性能优化、安全性和调试技术；第5 节研究跨语言编程，特别是Rust 与其他编程语言集成的挑战与解决方案；第6 节深入探讨Rust 编译器的构建与优化，回顾编译器效率和优化技术的进展；第7 节介绍Rust 生态系统中开源库、工具和应用的开发及其影响；第8 节讨论围绕Rust 编程语言的挑战与研究趋势。

2 调查方法 ​

在本次文献综述中，我们对相关研究期刊和国际会议进行了广泛调研。所检索的数据库包括IEEE Xplore、ACM Digital Library、Springer Link 和DBLP。我们在数据库中搜索标题或关键词中包含“Rust”的论文，然后通过人工筛选剔除不相关的文献。

加载中...

我们将筛选出的论文根据主要研究方向分为五大类，并进一步细分为共17 个专题。图 3 展示了Rust 相关论文的年度发表数量及其在各主题中的分布。从2015 年到2024 年，Rust 相关论文呈上升趋势。正如前文所述，Rust 1.0 于2015 年发布，标志着其标准库大部分功能的稳定。彼时，Rust 作为一门相对较新的语言，在学术界尚未获得广泛认可与应用，因此2015–2017 年间的相关研究较少。早期Rust 研究主要集中在性能优化与系统编程、领域工具与扩展、核心工具与开发基础设施、应用开发框架，以及库与语言扩展等方面，这表明学术界对Rust 的实际应用及其跨领域潜力表现出显著兴趣。随着Rust 的发展，其因独特的安全设计和较高性能而受到越来越多关注。Rust 在实际领域的应用逐渐增多，社区快速增长，更多开发者为语言及其生态贡献力量。同时，研究和实际应用需求推动了大量相关库和工具的出现，这些因素促使2018–2023 年间Rust相关论文数量增加。研究主题也逐渐多样化，除之前提及的方向外，分析、验证、优化、FFI 编程及代码转译成为受关注的热点，表明研究者不仅关注Rust 的应用，也开始重视Rust 代码质量。此外，随着Rust 的广泛使用，其在跨语言互操作场景中的需求增加，使跨语言编程成为日益热门的研究主题。由于所选论文未覆盖2024 年全部研究，因此该年的相关研究数量相对较少。我们的调研结果概览如图4所示。

3 语言分析与扩展 ​

Rust 因其在内存安全和并发控制方面的创新方法而在编程社区获得了广泛认可，成功解决了低级系统编程中长期存在的漏洞。这一基础性创新推动了大量对Rust 设计的严格分析与扩展工作，形成了逐步发展的语言分析方法学，从而在设计和应用上不断提升Rust。通过对相关文献的详细梳理，我们总结了语言分析技术的演进历程，从早期的静态分析工具到增强Rust 功能的复杂编译器扩展。本节内容分为五大类: 形式建模与验证、语言扩展、语言比较、unsafe 分析以及实证研究。通过综合这些学术贡献，本节旨在提供对Rust 语言分析与扩展的全面概览，揭示其发展轨迹及其在编程语言领域日益增长的影响力。

加载中...

3.1 形式化建模和验证 ​

Rust 的类型系统是其设计的核心，它在无需垃圾回收的情况下促进了安全且高效的内存管理。针对Rust类型系统的建模与验证研究，有助于发现潜在弱点[30]、改进语言特性[31] 并确保Rust 的类型健全性[30,32, 33]。形式化模型定义了Rust 的规则与行为，从而保证正确性并辅助验证。例如，Kan 等人[34] 提出了RustSEM，一种可执行的Rust 操作语义，并通过700 个测试评估其正确性；Wang 等人[30] 提出了KRust，为Rust 的一个子集构建形式语义，识别编译器错误并提供验证工具；Weiss 等人[35] 为所有权与借用开发了形式化模型，并提供类型健全性证明；Jung 等人[31] 引入Stacked Borrows 来管理内存访问并优化Rust 编译器性能。此外，还出现了新的形式化模型:Weiss 等人[33] 创建了类似Rust 的类型安全语言Oxide，证明其借用检查器的类型安全性；Pearce 等人[36] 提出了两阶段类型检查形式化方法，通过证明验证Rust 并揭示潜在的编译器问题；Ho 等人[32] 改进了LLBC 模型，通过低级指针语言对比证明其健全性。通过开发严格的操作语义和类型检查框架，研究者不仅验证了Rust 的核心原则，还暴露了细微的编译器漏洞和优化机会。这些形式化工作为扩展Rust 功能提供了可靠基础，确保新语言特性遵循其安全不变量。

3.2 语言扩展 ​

随着Rust 的发展，引入了一些扩展来增强其功能[37, 38]，实现更广泛的应用程序[39∼44] 或提高基于Rust 的系统的安全性和性能[45∼47]。

语言增强。 一些扩展旨在提升Rust 的安全性和正确性，研究重点逐渐集中在形式化验证框架和类型系统优化上。Jung 等人[45] 开发了针对Rust 实际子集的首个形式化、机器可验证安全性证明，使得对unsafe 库进行安全性验证成为可能；Payet 等人[46] 在Featherweight Rust 中处理循环类型环境，确保终止性并提高语言可靠性；Headley 等人[37] 探索Rust 的宏系统和类型级语言，开发了与Rust 类型检查器集成的领域特定语言（eDSL）；Yanovski 等人[38] 提出GhostCell，通过将权限与数据分离实现安全的数据访问同步，并使用RustBelt 证明其健全性；Lehmann 等人[47] 提出Flux，将逻辑细化与Rust 的所有权系统结合，简化基于类型的验证；Gäher [48] 引入RefinedRust，一个用于验证安全与不安全Rust 代码功能正确性的精化类型系统，并实现基于Coq 的验证工具。这些扩展通过形式化方法和类型系统改进，为Rust 的安全性和功能验证提供了坚实基础。

特定领域扩展。Rust 的安全特性推动了其在嵌入式系统和消息传递等多领域的应用。Levy 等人[39] 分析了Rust 在嵌入式操作系统开发中的应用，提出扩展以优化事件驱动平台的内存安全；Lagaillardie 等人[40]将Rust 的二进制会话类型扩展至多方会话类型（MPST），应用于Amazon Prime Video 协议，提高分布式系统的安全性；Blesel 等人[41] 开发了基于Rust 的消息传递库Heimdallr，提升MPI 应用的正确性；Chen 等人[42] 推出Ferrite，扩展Rust 会话类型以支持线性与共享会话，解决传统库的局限；Ma 等人[43] 针对软实时嵌入式操作系统优化Rust，提高无人机应用的panic 恢复效率且开销极小；Magnani 等人[44] 将TAFFO精度调优工具移植到Rust，实现高达15 倍加速，同时保持Rust 的安全特性。

跨语言集成。Rust 的安全特性还影响了其他语言，提升了混合语言项目的安全性。Bagnara [49] 提出了“C-rusted”技术，将Rust 的所有权和类型安全原则引入C，通过对资源管理和类型的部分注解，实现静态分析验证，提高C 的安全性与性能。这些扩展不仅强化了Rust 的核心原则，还拓宽了其在系统编程、分布式计算和实时嵌入式环境中的适用性。同时，Rust 的影响力也开始扩展到自身生态之外，为其他编程语言的安全性改进提供参考。基于这一趋势，下一节将探讨Rust 与其他语言在安全性、性能及可用性方面的比较，揭示其在更广泛编程领域中日益增长的作用。

3.3 语言对比 ​

Rust 在无需传统垃圾回收的情况下提供内存安全，同时声称在性能上可与C 和C++ 相媲美，并支持现 代语言特性。随着Rust 在系统编程和高性能应用领域的日益流行[50,51]，了解其相对于C、C++ 和Python等语言的优势与劣势变得尤为重要。本节回顾了一些关于语言比较的研究，并根据比较指标将其分为三类: 性能、安全性及其他方面分析。

性能比较。 尽管Rust 的安全特性可能引入一定开销，多项研究仍凸显了其相较于C 和C++ 的优势与挑战。Costanzo 等人[50] 发现Rust 在N 体模拟中能够降低编程工作量，同时性能与C 相当，表明Rust在简化开发的同时不牺牲计算效率，但研究仅聚焦单一计算问题，难以推广到更广泛的实际应用；Ivanov 等人[52] 报告Rust 性能与C++ 相当，在某些领域仅略有劣势；Rotter 等人[53] 显示Rust 在大规模N 体模拟中优于C 和C++，表明其适合计算密集型任务，但单一领域的研究限制了其广泛适用性；Diehl [51] 展示了Rust 在高性能科学计算中的强劲表现，对比Chapel、Go 和Python 均具有优势；Rooney 等人[54] 发现在Raspberry Pi 平台上，Rust 的FFT 实现比C 在能效上高45%、速度快37%，凸显其在嵌入式系统中的潜力，但硬件特定性限制了跨平台推广；Zhang 等人[55] 指出Rust 的平均性能开销比C 慢1.77 倍，主要由于运行时检查和设计限制。总体来看，尽管Rust 在受控基准测试中常与或优于C/C++，但研究方法的局限性（如算法选择单一、硬件依赖性强）凸显了跨领域性能评估的必要性。

安全性比较。Rust 在内存安全方面表现突出，通过所有权（ownership）和借用（borrowing）系统实现安全保障，而传统语言如C 和C++ 的安全性保证相对有限。Suchert 等人[56] 发现，尽管Rust 实现的STAMP 基准测试比C 稍慢，但显著提升了内存安全性和代码质量，有力证明了Rust 能减少常见编程错误；Van 等人[57] 比较了Java 与Rust 的内存错误，强调Rust 的类型系统在不依赖垃圾回收的情况下增强了内存控制并减少错误；Jaloyan 等人[58] 探讨了Rust 的借用检查器（borrow-checker）和仿射类型（affine types）如何启发其他语言（如SPARK）开发更安全的软件验证方法，提高关键任务应用的可靠性。这些研究共同凸显了Rust 在编译期强制内存安全方面的独特能力。然而，也揭示了潜在的权衡，例如在某些基准测试中性能较慢，以及尚缺乏对Rust 安全性在真实软件可靠性中体现的充分探索。

其他方面分析。除了性能与安全性，评估Rust 的可用性和可维护性对于全面理解其特点至关重要。Ardito等人[59] 将Rust 与C、C++、Python、JavaScript 和TypeScript 进行比较，发现Rust 在可维护性、复杂度控制以及结构化源码组织方面表现优异，尽管其冗长性一般。此外，Rust 在研究的语言中具有最低的认知复杂度；Chakraborty 等人[60] 分析了Stack Overflow 和GitHub 上关于Rust、Swift 和Go 的讨论，识别了迁移、数据处理和结构方面的挑战，同时指出各语言的资源可用性和未回答问题数量存在差异，这与语言的发展轨迹相关。

总体来看，语言比较研究表明Rust 是一门独特平衡的系统语言，通常在计算密集型基准测试中可与 C/C++ 匹配或超越，如N 体模拟、热方程求解器及FFT 等。然而，大多数研究仍局限于狭窄算法、特 定硬件或公开论坛分析，因此仍需开展更多多样化、大规模、面向工业的评估。

3.4 Unsafe 分析 ​

Rust 类型系统施加的严格限制允许编译器防止各种常见错误。然而，这些限制使得某些设计的实施变得困难或不可能。Unsafe Rust 使开发人员能够绕过Rust 严格的安全保证。本节回顾了一些针对Unsafe Rust的研究，分为两部分:Unsafe Rust 的使用和Unsafe Rust 的安全问题。

使用模式与动机。由于unsafe 代码可能带来安全问题，Rust 中的unsafe 使用需谨慎，以维持语言的强安全性。理解Rust 开发者使用unsafe 的方式对于保障Rust 的安全性至关重要。Höltervennhoff 等人[13] 发现，许多开发者因误解或缺乏安全策略而使用unsafe，可能导致安全问题；McCormack 等人[14] 指出，开发者常因不了解更安全的替代方案以及缺乏工具支持而使用unsafe；Astrauskas 等人[11] 表明unsafe 主要用于语言互操作性；Evans 等人[12] 发现Servo 项目中的unsafe 代码挑战了Rust 的内存安全保障。这些研究显示，unsafe 的使用往往出于必要性或缺乏更安全的替代方案，但误解和知识不足会加剧其滥用。虽然存在合法使用场景（如跨语言互操作），但通过开发者教育和生态改进，可以显著减少对unsafe 构造的非必要依赖。

Unsafe Rust 的安全问题。由于unsafe 块绕过了Rust 的严格安全保障，使用Unsafe Rust 可能引入潜在安全问题。一些研究针对这些问题进行了分析，以帮助识别因使用unsafe 导致的问题、改进文档和工具，并增强安全框架。Zheng 等人[15] 分析了七年间的433 个漏洞，凸显了Rust 安全特性在现实应用中的挑战；Cui 等人[16] 调查了unsafe API 文档，分类了CVE，并强调改进文档的重要性，以强化Rust 的安全性。

3.5 实证研究 ​

随着Rust 因其在解决并发和内存安全等常见问题上的新颖方法而受到广泛关注，研究人员已经开展了全面的实证研究，以理解Rust 的核心特性[61∼64]、其在软件开发中的采用情况[65,66]，以及其对更广泛编程生态系统的影响[67]。

语言特性与机制。对 Rust 语言特性的研究对于理解其机制、提升性能以及增强安全性至关重要。关键研究聚焦于Rust 的核心特性，如内存安全、并发与类型系统: Balasubramanian 等人[61] 分析了Rust 的高级功能，包括零拷贝故障隔离和静态数据流分析，从而提升系统软件的安全性与性能；Saligrama 等人[68] 强调Rust 类型系统在安全处理并发数据结构（如无锁哈希表）方面的作用；Xu 等人[63] 指出Rust 在内存安全性上优于其他语言；Ferdowsi 等人[64] 回顾Rust 的所有权与生命周期规则，并提出改进可用性的建议；Williams 等人[69] 研究Rust 对Web 服务的影响，关注其并发机制及陡峭的学习曲线；Hu 等人[62] 提出基于全面性（Comprehensiveness）、自动化（Automation）和生命周期（Lifecycle, CAL）的Rust 安全基础设施愿景；Bugden 等人[70] 确认Rust 在性能、安全性与可靠性上的优势，使其成为未来优化的有力候选语言。

生态系统与工具。Rust 的生态系统和工具在语言的可用性与可靠性中发挥着关键作用: Li 等人[71] 分析了Rust 的“yank”机制，发现9.6% 的包至少有一次被yank 的版本，影响了46% 的包，并导致1.4% 的生态系统出现未解决依赖，带来可靠性挑战；Kyriakou 等人[67] 提出一个结合Rust、JavaScript 和WebAssembly的框架，用于提升开源软件（尤其是C/C++ 库）的可发现性。该框架通过指标支持改进可见性，同时浏览器厂商对WebAssembly 的优化进一步增强了分发潜力。对 Rust 生态系统和工具有效性的研究为未来探索提供了有希望的方向，但仍需对各种开源生态系统进行更全面的评估，以验证其适应性和可扩展性。

采纳挑战与可用性。尽管Rust 的受欢迎程度持续增长，新用户仍可能因其复杂性而面临挑战。关于Rust采纳挑战和可用性的研究有助于识别程序员面临的困难，并探索应对方法:Fulton 等人[65] 通过对16 位资深开发者的访谈和对178 名Rust 社区成员的调查，揭示了采用Rust 的优势与挑战，尤其是其复杂性；Zhu 等人[66] 分析了Stack Overflow 上100 个与Rust 相关的问题，并调查了101 名开发者，为Rust 的学习曲线提供洞察，并提出改进可用性的建议。研究表明，Rust 的复杂性仍是的主要障碍。改进文档、工具和学习资源对于降低入门门槛尤其重要，尤其针对经验较少的开发者。

对Rust 的实证研究提供了关于其语言特性、生态系统、应用及采纳挑战的宝贵见解。未来研究应聚焦于大规模实证验证、增强生态系统可靠性，以及解决可用性障碍，以确保Rust 的持续发展和在各行业的更广泛应用。

4.项目质量保证 ​

Rust 对内存安全和并发的关注，依托其所有权系统，支持程序的测试、分析和验证，从而保证正确性和可靠性。随着软件系统日益复杂，这些技术有助于识别并解决内存安全与并发问题，使开发者在开发与维护过程中实现更高的安全性和正确性。

4.1 程序测试 ​

测试是软件开发的重要组成部分，可确保应用程序的正确性、稳健性和性能。在Rust 的背景下，测试技术主要集中在两个关键领域: 测试目标生成和编译器测试。测试目标生成涉及创建有效验证程序不同部分的特定测试用例，而编译器测试旨在确保Rust 编译器本身正确且高效地运行。由于其所有权模型、严格的类型系统和内存安全保证，测试Rust 程序面临着独特的挑战。

自动化单元测试生成。由于Rust 的严格所有权规则和多态类型系统，自动化测试生成面临固有挑战。RustyUnit [72]: 开创性地采用基于搜索的测试生成方法，通过遗传算法和编译器包装器进行静态分析。该方法在生成六个开源库的测试用例方面表现有效，但在处理复杂类型层次结构和深层所有权转移场景时，遗传算法表现受限。SyRust [73]: 利用语义感知的程序综合生成类型正确的Rust 程序，显式建模所有权生命周期和多态约束。通过综合有效的API 交互序列，SyRust 在常用库（如regex 和http）中发现了新缺陷，显示出对Rust 类型系统的高度适应性，相较于进化方法表现更优。然而，这两种工具在大规模处理基于trait 的泛型时仍存在局限，表明需要与Rust 的trait 解析引擎进行更紧密的集成。

模糊测试。现代Rust 的模糊测试研究主要分为输入变异策略和API 交互综合两类，分别针对内存安全验证的不同方面。基础研究:Xu [74] 提出，由于Rust 编译器固有的安全检查，模糊测试优于符号执行，但 Crump 等[75] 提出的CrabSandwich 框架通过libAFL 用Rust 原生生成器替代不安全的C 生成器，降低了内存违规检测的误报。API 驱动方法:RULF [76] 通过静态API 调用图指导模糊目标生成，而RPG [77] 采用基于动态池的搜索优先处理unsafe 代码序列。RULF 在静态分析中高效识别入口点，RPG 通过运行时反馈显著提高了bug 发现率。Zhang 等[78] 将这些方法扩展至泛型API，通过单态实例化综合生成，但在处理高阶trait 边界时类型推断仍有挑战。生态系统指导生成:FRIES [79] 利用加权依赖图和所有权感知的变异操作符，在跨crate 测试场景中实现了比以往工具更高的覆盖率。

尽管Rust 模糊测试在适应语言特性方面取得了显著进展，但在大规模项目中扩展方法、捕捉所有权和类型系统细节仍具挑战。未来研究应关注模糊目标生成的自动化提升及语义感知的集成。

编译器测试。编译器测试对于确保Rust 的类型系统和内存安全功能正确实现至关重要。杜威等人[80] 首先通过约束逻辑编程（CLP）演示了类型检查器模糊测试，生成对Rust 的类型推断边缘情况进行压力测试的程序。他们基于CLP 的方法发现了生命周期省略规则中微妙的健全性错误，但其约束解决方法无法扩展到特征一致性检查。Sharma 等人的RustSmith [23] 为Rust 编译器引入了随机差异测试，生成遵循Rust 类型系统和借用规则的程序。此方法允许比较编译器版本和优化级别，识别已知和未知的错误。Xia [81] 分析了Rustc和Rust-GCC 的历史bug，指出大多数Rustc bug 发生在核心编译器(src/librustc) 中，而Rust-GCC bug 在清理过程中更常见。Xia 在编译器开发中利用Rust 并发原语的提议尚未经过测试，但理论上与RustSmith 的并行测试生成架构一致。在测试编译器与不安全代码的交互方面仍然存在一个关键差距, 所调查的方法都没有在编译器模糊测试期间系统地对不安全块语义进行建模。

当前的Rust 测试方法在自动化测试生成（SyRust、RustyUnit）、将模糊测试扩展到复杂API 交互（FRIES、RPG）以及验证编译器正确性（RustSmith）方面取得了显著进展。然而，在处理trait 系统边界情况、建模unsafe 代码语义以及合成反映真实使用模式的并发测试场景方面仍存在根本性挑战。所综述的研究表明，相较于不安全内存语言，Rust 的类型系统为测试生成提供了更复杂的静态指导，但这一优势也伴随着生成有效所有权模式的复杂性增加。未来的研究必须弥合应用级测试工具与编译器验证工作之间的差距，尤其是在验证编译器与库边界处的unsafe 代码交互时。

4.2 程序分析 ​

Rust 的所有权模型和不安全代码功能带来的独特挑战和机遇推动了程序分析技术的重大创新，我们将其分为三个相互关联的研究轨迹:（1）内存安全验证，（2）并发缺陷和死锁检测，以及（3）开发和维护支持工具。

内存安全和运行时错误检测。虽然Rust 在编译时消除了许多内存错误，但unsafe 代码块和FFI 交互仍会重新引入诸如缓冲区溢出、使用后释放（use-after-free）以及内存泄漏等风险。当前的研究通过静态与动态相结合的方法来应对这些挑战。Rupta [19] 在MIR 上构建上下文敏感指针分析以推进静态分析，使得生成的调用图更精确，从而在漏洞检测覆盖率上优于基于LLVM 的方法。然而，其依赖MIR 限制了分析范围，仅适用于单态化（post-monomorphization）后的代码，对宏生成代码分析不足。类似工具如MirChecker [17] 展示了基于MIR 的符号执行在检测运行时崩溃中的价值，但其污点追踪方法在大规模代码库中存在可扩展性成本。RUDRA [82] 则通过基于模式的unsafe 代码审计，在43,000 个crate 中发现264 个新漏洞，凸显了内存安全问题在生态系统中的广泛影响。尽管有效，但其启发式方法在复杂unsafe 模式下可能产生漏报。范围更窄的工具如RusBox [83] 和Rupair [20] 展示了领域特定静态分析（如针对缓冲区溢出的沙箱分析）可实现高精度，但针对单一漏洞类型的关注导致工具链数量增加。SafeDrop [21] 和OOM-Guard [84] 则体现了可组合分析的趋势——SafeDrop 使用跨过程的数据流分析来处理use-after-free 和double-free 错误，而OOM-Guard的基于预留的内存管理引入了约10% 的开销。这些工具通过处理unsafe 代码或运行时产生的问题，进一步提升了Rust 的内存安全性；然而，仍然存在关键空白，即缺乏能够整合多种技术以提供整体安全分析的统一框架。

并发缺陷与死锁检测。尽管Rust 提供了内存安全和并发保证，死锁仍可能发生，尤其是在具有多线程的复杂系统中。这类问题会影响应用的可靠性和性能，但相关研究较少。Stuck-me-not [18] 是一个静态死锁检测器，专注于双重锁（double-lock）死锁，在流行的区块链项目中发现了许多未知漏洞。然而，其对互斥锁获取顺序的狭窄关注限制了对优先级反转或条件变量误用的检测。此外，Zhang 等[85] 扩展了静态检测方法，可识别多种类型的死锁，通过指针与变量依赖分析实现比现有技术更高的精度。这种泛化提高了方法的通用性，但其计算成本仍然是大规模系统采用的障碍。

程序开发与维护支持。除了缺陷检测，近期研究还关注提升开发生命周期内的代码质量。VRLifeTime [86]和Yuga [22] 通过IDE 集成的数据流分析实现生命周期可视化与错误检测，在用户研究中将并发错误减少了40%，但其对显式生命周期注解的依赖导致闭包捕获的生命周期分析不足。Byrnes 等[87] 展示了如何通过形式化验证（使用Kani）强制trait 属性，通过自动定理证明发现PROST 库中的错误——这代表了从测试到验证的范式转变，但仅限于可用一阶逻辑表达的属性。面向维护的工具揭示了系统性的文档问题:’R [88] 和RustC4 [89] 利用NLP 与大模型检测代码与文档的不一致，在热门crate 中暴露出23% 的不匹配率。rust-code-analysis [90] 提供可操作的度量（如圈复杂度），但缺乏语义理解限制了其洞察力。Cargo-call-stack [91] 通过分析ARM Cortex-M 平台的调用栈保证嵌入式系统内存安全，为资源受限环境提供了关键贡献。Mutest-rs [92]通过静态分析启用并行化，提高Rust 突变测试效率，弥补了测试套件评估中的关键空白。

Rust 中的程序分析侧重于增强内存安全、解决并发挑战以及通过静态和动态技术改进软件开发和维护。虽然调用图精度和基于MIR 的分析可以实现更深入的漏洞检测，但它们通常会牺牲可扩展性。未来的研究应该集中于将这些分散的工作统一到综合框架中，集成运行时和静态分析，解决大型系统的可扩展性，并提供开发人员友好的界面以实现无缝采用。

4.3 程序验证 ​

Rust 的验证环境不断发展，以解决其独特的安全保证，同时应对不安全代码块和系统级编程带来的挑战。符号执行、模型检查和演绎验证等方法通过正式分析程序路径和状态来帮助识别错误、内存错误和未定义的行为。这些自动化方法减少了手动工作并提高了可靠性。人工智能辅助验证的集成进一步提高了这些技术的效率和准确性，使其对于高保证、性能敏感的应用程序至关重要。

符号执行。Rust 程序的自动化验证工具旨在通过最小化开发者注解来提高可访问性，重点检查unsafe 代码中的内存安全和未定义行为。Lindner 等[93,94] 通过KLEE 展示了符号执行的实用性，在嵌入式Rust 中消除了数组边界检查，并且开销几乎可以忽略。然而，其依赖LLVM-IR 导致对所有权模型的分析受限，这一缺口由Baranowski 等[94] 通过将SMACK 与Rust 的MIR 结合以验证并发不变量得以弥补。尽管这些方法可在几秒内实现小程序的全路径覆盖[94]，但在具有复杂trait 层次或宏的代码库中可扩展性下降。Toman等提出的Crust [95] 引入了一种模块化符号执行算法，用于验证unsafe 代码块的正确性，独特地解决了确保unsafe Rust 正确性的挑战，这是一个关键但研究不足的领域。VanHattum 等[96] 推出的Kani Rust Verifier通过分析MIR 中的动态trait 对象弥补了这一缺口，相较传统模型检测器实现了15× 的加速，但其对动态调度的关注导致借用检查器不变量验证不足。这些工具共同揭示了一个权衡: 自动化提高了采用度，但验证能力仅限于浅层属性，因此对于关键系统仍需更深入的形式化方法。Rust 的符号执行工具在保证内存安全和程序正确性方面表现出色，但其可扩展性和可用性仍需进一步优化。未来研究可关注将符号执行与其他技术（如静态分析或人工智能）结合，以提升效率并减少开发者负担。

演绎验证与形式化证明。演绎验证框架利用Rust 的类型系统，通过注解和形式逻辑证明程序的正确性。RustHorn [97] 和RustHornBelt [98] 展示了不同的验证理念——前者将Rust 简化为受限Horn 子句以验证指针安全，后者则结合RustBelt 的语义类型以验证unsafe 代码。两者都面临注解负担，而Prusti [99] 通过SMT 求解器推断循环不变式，将用户研究中的注解工作量降低了约40%。Lattuada 等[128] 提出Verus，进一步引入线性幽灵类型（linear ghost types），无需垃圾回收即可进行并发证明，但手动指定幽灵状态增加了使用难度。Creusot [100] 使用预言变量（prophecy variables）对高阶Rust 迭代器进行建模和验证，采用一阶逻辑，而Wolff 等[101] 扩展Prusti 以通过一阶逻辑验证闭包生命周期。尽管这些方法在理论上严谨，但在处理Rust 宏系统时存在困难，这一局限在Aeneas [102] 中得到体现，该方法将Rust 转换为纯 演算以进行函数正确性证明。Astrauskas 等[103] 展示了基于分离逻辑的模块化验证，在隔离环境中验证系统软件组件，但依赖手动引理开发，突显了一个关键障碍: 即便是高级框架也需要大量验证专业知识，从而限制了其广泛应用。

针对Rust 在安全关键领域的应用，存在专门的验证工作。Ijaz 等[104] 使用混合类型检查验证Theseus OS的内存子系统，证明数据竞争不存在，但未考虑中断处理的并发性。Dai 等[105] 利用MIR 语义形式化TEE虚拟机的空间隔离，确保页表完整性——这是安全可信执行环境的里程碑，但仅限于x86 架构。Hardin [106]使用ACL2 在受限算法Rust（RAR）中验证Knuth 的Dancing Links 算法，实现软硬件联合保障，但牺牲了Rust 的表达能力（如禁止动态调度）。这些工作凸显了Rust 在关键系统中的潜力，同时也揭示了针对特定场景的权衡: 领域专用方法提升了验证精度，但降低了通用性，而形式化工具链往往滞后于语言的发展（例如Rust 的异步生态）。

新兴趋势和人工智能集成。人工智能（AI）的兴起引发了将AI 技术用于自动化和增强形式化验证流程的兴趣。AI 可以自动化证明合成并优化静态分析，从而减少人工干预、提高Rust 验证的效率。一项近期研究[107] 探讨了将大型语言模型（LLM）与静态分析结合，以在Rust 中自动生成证明代码。这种方法显著降低了手动编写证明代码的工作量，凸显了AI 在提升验证生产力方面的潜力。对Rust 形式化验证的研究表明，其在内存安全、并发正确性和功能可靠性方面取得了显著进展。这些进展体现了Rust 对高保障软件开发的承诺，同时也揭示了在可扩展性、可用性和开发者易用性方面的挑战。未来的研究应着重于将这些分散的工作整合为统一框架，利用AI 自动化验证流程，并扩展工具支持以覆盖实际系统，从而最大化Rust 在构建可靠、安全且高性能软件方面的潜力。

4.4 程序优化 ​

Rust 开发中的优化旨在提升软件的效率、性能和可维护性，同时保持安全性保证。其重点包括提高执行速度、优化内存管理和增强可扩展性，尤其是在资源受限的环境中。相关研究主要关注开发工作流中的优化挑战、二进制级别的安全性、程序重构，以及针对安全性的实证评估。

开发与可维护性增强。优化Rust 的开发生命周期需要兼顾安全性与不断演进的语言特性。Nowak 等人[108] 提出通过语义版本管理工具解决依赖管理问题，帮助开发者遵循语义版本规则，从而防止意外的不兼容版本发布。该工具针对大型Rust 项目中的关键挑战提供了解决方案，但其在Rust 工具链中的集成及对更大生态系统的可扩展性尚未探讨。Gülmez 等人[109] 提出在进程内隔离的内存保护键（Memory ProtectionKeys），为安全Rust 代码提供高效的保护机制，同时兼顾性能与安全，但引入了硬件依赖，限制了在资源受限环境中的适用性。McCormack 等人[110] 聚焦Rust 与其他语言的互操作性，使用MiriLLI 执行多语言程序并检测外部函数边界的未定义行为。尽管该方法在识别安全违规方面有效，但对LLVM 解释器的依赖可能影响其可移植性。Yu 等人[111] 评估了Rust 的并发编程安全性，分析了编译器如何促进安全并行性。虽然该研究提供了有价值的洞察，但未进一步提出增强并发安全性的实际调试或工具方案。

二进制分析与验证。二进制分析通过验证内存操作并检测可能绕过编译时防护的漏洞，确保运行时安全。Park 等人[112] 提出Trustspot，一种基于机器学习的工具，用于反向工程Rust 二进制文件以检测不安全点。Trustspot 在分析仅16.79% 的二进制代码的情况下，实现了92.92% 的内存安全漏洞召回率，大幅提升了模糊测试效率。然而，其对机器学习模型的依赖引发了在多样化二进制文件上的泛化能力担忧。Louka 等人[113]提出Binary Validator，通过验证Rust 二进制文件中的空间和时间检查来确保运行时内存安全。该工具有效地补充了编译时防护，但忽略了可以在开发生命周期早期解决的源代码级漏洞。

程序重构与自动修复。自动化重构和修复对于提升代码质量、减轻开发者管理Rust 复杂的所有权和生命周期规则的负担至关重要。Thy 等人[114] 提出REM，一种自动化的“提取方法”（Extract Method）重构工具，集成Rust 生命周期检查器以处理所有权复杂性，同时确保类型安全。其交互式功能对开发者尤其有用，但尚未验证其在大型深度嵌套项目中的可扩展性。Deligiannis 等人[115] 提出RustAssistant，利用大语言模型（LLMs）为实际Rust 编译错误提供修复建议，准确率达到74%。虽然RustAssistant 展示了AI 在程序修复中的潜力，但其依赖于开源仓库训练数据，可能限制在专有或特定领域代码库中的有效性。Shirzad 和Lam [116] 识别了Rust 中20 种常见的错误修复模式，为自动修复策略提供了基础。尽管研究具有启发性，但侧重于高层模式，并未提供可用于自动化工具的具体实现。

实证研究。实证研究为Rust 的实际优势和局限性提供了宝贵洞见，特别是在内存安全和安全性方面。Hua等人[117] 提出CAL（Comprehensiveness, Automation, and Lifecycle）框架，用于评估Rust 安全性，识别漏洞预防、检测与修复中的不足。Qin 等人[118] 系统研究了unsafe 代码，发现850 处unsafe 使用和170个漏洞，并引入两种静态缺陷检测器以发现先前未知的漏洞。这些研究强调了unsafe 代码带来的风险，但未扩展至运行时行为分析。Xu 等人[119] 回顾186 条漏洞报告和CVE，将内存安全问题分类为自动内存回收、unsafe 函数和unsafe 代码，并提出API 使用最佳实践以降低风险; Zheng 等人[120] 对与unsafe 关键字相关的第三方Rust 包中的433 个漏洞进行了分析，进一步呼应了该主题。Xu 等人[121] 分析Rust 的所有权模型，突出其在防止内存错误方面的有效性; Oey 等人[122] 比较了Rust 与C++ 的内存安全策略，得出Rust的所有权模型在防止漏洞方面更优，但其陡峭的学习曲线可能阻碍经验不足团队的采用。这些研究全面揭示了Rust 在内存安全和安全性上的表现，同时凸显了unsafe 代码和第三方包漏洞的持续挑战，强调了改进工具和教育以降低风险的必要性。

Rust 的优化工作涵盖开发流程、二进制分析、程序修复和实证研究等多个领域。然而，工具集成仍存在关键空白，例如版本管理、重构和二进制分析的统一; AI 对所有权的语义理解; 以及传递性unsafe 依赖管理。未来工作可以探索将实证研究成果与工具开发结合，例如将[118] 的漏洞模式集成到编译器lint 中，或将[114]的重构方法扩展至宏。随着Rust 在关键基础设施中的广泛应用，优化需从以性能为中心的指标扩展到安全性、可维护性和供应链完整性的整体衡量，确保理论保证能够转化为实际的系统韧性。

5 跨语言编程 ​

Rust 通过外部函数接口(FFI) 和代码转译实现了与其他语言的互操作, 使得开发者能够将Rust 的安全性和性能与现有代码库及多样化生态系统的优势结合起来. FFIS 实现了Rust 与C、C++ 等语言的无缝交互, 从而促进了遗留系统与外部库的集成. 与此同时, 代码转译技术为Rust 代码与其他编程语言代码之间的相互转换开辟了途径, 这不仅促进了代码复用, 还拓展了Rust 在各类平台与环境下的适用性. 本节将探讨这两种方法, 分类讨论它们的实现和优点, 展示Rust 如何在多语言编程环境中高效运作.

5.1 基于外部函数接口的编程 ​

FFI 对于实现Rust 与其他编程语言交互至关重要, 它有效扩展了Rust 的功能, 并增强了其在既有软件系统中的集成能力. 借助FFI, Rust 代码能够调用C 和C++ 等语言编写的函数与库, 从而便于集成遗留代码并增强其互操作性. 另外, 在技术实现上, 该过程涉及将Rust 与外部代码进行链接、确保数据类型的兼容性以及跨语言边界的内存管理等机制. 当前的研究与工具主要聚焦于优化跨语言集成、解决安全问题, 并发展相应的漏洞检测方法.

基于FFI 的高效集成。FFI 实现了Rust 与其他语言之间的无缝互操作, 从而促进了各应用领域内的高效交互. Shin 等[25] 比较了三种Intel SGX 框架, Rust SGX SDK、Occlum 与Fortanix EDP, 着重阐述了在云环境中, FFI 如何促进了Rust 与C/C++ 之间安全且高性能的通信. 例如, Rust SGX SDK 使用unsafe 包装器来转换ECALL 与OCALL, 以在性能与内存安全之间取得平衡. 类似地, Császár 和Slavescu [123] 展示了在逆向工程工具中使用FFI 的例子, 通过集成Rust 与Frida 的C 核心库, 实现了类型安全的二进制分析. 这些实例突显了FFI 在扩展Rust 功能的同时, 又能维系其核心的安全保障.

在系统级集成中, FFI 使Rust 能够增强遗留组件. rOOM 模块[27] 将Rust 组件嵌入到Linux 基于C语言的OOM Killer（内存不足终止机制）中, 通过Rust 的编译时检查来缓解内存泄漏问题. 尽管成效显著,但这类集成通常需要细致的手动绑定, 正如Maiga 等[124] 所述, 他们将Rust 与SPARK 结合用于嵌入式系统. 他们在BBQueue 库中的研究展示了FFI 如何在跨语言交互中保持内存安全, 但也强调将Rust 的生命周期与SPARK 的形式化契约对齐的复杂性. 与此同时, 像RustProcessMine [125] 和extendr [126] 等项目展示了FFI 在高性能多语言工具链中的重要作用. 这些工具通过将Rust 分别与Python/Java 以及R 语言进行绑定, 在充分发挥Rust 性能优势的同时, 也实现了与特定领域生态系统的无缝对接. 然而, 此类绑定工作多由社区驱动, 这暴露了针对非C 语言缺乏标准化FFI 工具支持的现实困境. Kyriakou 等[26] 和Josephine [127]进一步印证示了FFI 的适应性. 通过将C/C++ 转译为Rust/Node.js 模块, 并将JavaScript 的垃圾回收器与Rust 的生命周期进行集成, 从而实现了在不同环境之间的代码重用. 然而, 这些方法也可能带来抽象开销或生命周期不匹配的风险, 在长周期运行的应用程序中尤为突出. 总体来看, 这些研究研究虽彰显了FFI 在拓展Rust 应用边界方面的实用价值, 但也揭示了其对unsafe 代码和临时性绑定策略的系统性依赖, 而这种依赖恰恰削弱了Rust 的安全性保障。

FFI 安全性的实证研究。 FFI 的灵活性伴随着代价: 实证研究表明, 不安全的 FFI 使用仍然是内存安全漏洞的一个关键途径. McCormack 等 [128] 通过 MIRILLI 工具对 30 个 Rust 库进行动态分析, 发现由于不正确的 FFI 边界管理所导致的广泛未定义行为, 包括悬垂指针和别名违规. 这一发现挑战了 “Rust 所有权模型能在跨语言环境中彻底消除内存风险” 这一假设, 研究者进而主张采用更精细的别名模型, 如 Tree Borrows [31].类似地, Xu 等 [129] 通过分析所有 Rust 的 CVE, 指出与 FFI 相关的释放后使用和双重释放错误是主要问题,这些问题往往因不正确的生命周期注解而在不安全代码块中加剧. 这些结果突显了一个悖论: 尽管 FFI 实现了 Rust 与遗留系统的集成, 但它也重新引入了 Rust 核心设计原本致力于消除的漏洞. 嵌入式系统放大了这些挑战. Sharma 等 [130] 指出, 在由 C/C++ 工具链占据主导地位的资源受限环境中, FFI 互操作性是阻碍 Rust 广泛应用的关键因素. 他们的研究揭示了嵌入式 FFI 绑定通常缺乏完备的静态应用安全测试（SAST）支持, 导致漏洞在运行时才能被发现. 这一缺陷在汽车或物联网等安全敏感领域尤为严峻, 在这些领域, 内存损坏可能会引发严重的物理后果. 这些研究表明, 尽管 Rust 提供了安全保障, 但 FFI 的使用引入了新的漏洞, 这些漏洞需要制定更严格的开发规范和研发更先进的检测工具来解决. 解决这些挑战对于 Rust 在安全型应用中的普及至关重要.

消除 FFI 漏洞的工具。 为提升多语言环境下的安全性和可靠性, 现已有多种先进工具与框架, 旨在检测并消除 Rust FFI 集成过程中存在的漏洞. Hu 等 [131] 提出了统一分析框架 CRUST, 它将 Rust 与 C 语言融合为一种统一的规约语言, 用以检测诸如释放后使用等内存安全问题. Li 等 [132] 介绍了自动化静态分析工 FFIChecker, 专门用于识别 Rust FFI 中的内存管理问题. 在 987 个分析过的 Rust 软件包中, 该工具从 12 个包中检测出 34 个以前未发现的漏洞, 充分证明了其有效性. Schuermann 等 [133] 提出了 “封装函数” 来加强 Rust 在嵌入式系统中 FFI 的安全性, 确保其与外部代码交互的安全. Bang 等 [134] 则提出了编译框架 TRUST, 该框架将安全的 Rust 代码与不受信代码进行隔离, 有效防范了 FFI 集成过程中漏洞的产生. 跨语言编程是 Rust 具备多功能性的基石, 它不仅赋予了 Rust 与多种编程语言及生态系统互操作的能力, 同时还保留了其在内存安全与性能方面的核心保障. 关于基于 FFI 的集成的研究, 展示了 Rust 在数据处理、系统级效率和嵌入式系统中的强大适应性. 聚焦安全性的研究揭示了因 FFI 使用不当所引入的潜在漏洞, 而 CRUST 和 FFIChecker 等先进工具旨在消除此类风险. 尽管已取得上述进展, 但在实现 FFI 绑定自动化、管理安全关键型交互以及简化漏洞检测工具等方面, 挑战依然存在. 未来的研究应着重于开发能够最小化 unsafe 代码、简化 FFI 集成, 并在保持安全性保证的前提下, 扩展Rust 在不同领域的适用性的框架.

5.2 代码转译 ​

代码转译是将现有代码库迁移至 Rust 的一项关键策略, 它使开发者无需进行完全重写, 便能采纳并利用 Rust 在安全与性能方面的优势. 转译的目标在于将代码从源语言转换为 Rust, 从而推动系统的逐步迁移, 在保持现有功能的同时, 提高代码质量和可靠性. 此外, 转译也支持领域特定的转换, 使得 Rust 能够被应用于各类专用的编程任务中. 其主要技术组成部分包括自动化转换工具、对特定语言结构的处理, 以及确保源代码与目标代码之间的语义等价性. 针对 Rust 双向转译（即转入与转出 Rust）所设计的工具与方法, 主要侧重于准确性、效率以及对特定领域转换的支持, 从而拓宽了 Rust 在不同编程领域的适用性.

C 转译为 Rust 的挑战。 将 C 语言转译为 Rust 的过程充斥着语义层面的不匹配, 这一点在内存管理与并发机制上表现得尤为突出. Emre 等 [135] 将指针别名问题视为一个关键障碍, 他们的研究展示了仅有 12%的 C 指针能够在不违反所有权规则的前提下, 直接转换为 Rust 的安全引用. 尽管他们提出的伪安全框架利用污点分析技术来对指针的使用进行增量验证, 但该方法仍受限于 C 语言固有的灵活性, 在处理边界情况时依然需要人工干预. 类似地,Crown [136] 采用静态所有权分析来推断与 Rust 兼容的指针类型, 但由于其依赖诸如 mut 标注等保守型修饰符, 往往会生成限制性过强的代码, 从而阻碍了其在实际中的应用. Emre 等 [137] 与 Tripuramallu 等 [138] 的实证研究揭示了现有工具存在的系统性局限. 自动化转译工具生成的 Rust 代码常常包含大量的 unsafe 代码块, 在某些情况下比例高达 40%, 这主要是由于裸指针的使用以及手动内存管理模式未能得到有效解决所致. 为解决这些问题, 他们开发了一种新技术, 利用 Rust 的借用检查器自动将这些不安全元素优化为安全引用, 从而使转译后的代码更符合 Rust 的安全保证. Larsen [139] 的研究证实了这一点, 并指出尽管 C2Rust 等工具提供了一个起点, 但它们未能捕捉 C 语言的隐性不变式 (如数据结构的所有权), 迫使开发者手动重构代码. 这些发现突显了一个悖论: 代码转译旨在减少人工投入, 但要获得地道的 Rust 代码, 往往需要进行大量的译后优化, 这在一定程度上削弱了其对于提升效率的承诺.

安全转译的进展。 近期的研究致力于通过静态-动态混合分析及领域感知的转换技术, 来减少对 unsafe 代码的依赖. CRUSTS [140] 应用了 220 条转换规则以消除转译代码中不必要的 unsafe 关键字, 从而将安全函数比例提升至与标准的 Rust 项目相当的水平. 类似地, Han 等 [141] 开发了 RUSTY, 它采用了一种基于控制流图的新策略, 通过 C 语言风格的语法糖将转译后的代码体积减少了 16%. 尽管效率很高, 但其对结构等价性的侧重忽略了语义安全性, 转译后的代码可能仍残留隐蔽的竞争条件或迭代器失效等缺陷. Hong 与 Ryu 提出了针对并发问题 Concrat [142], 通过数据流分析实现了 C 到 Rust 的锁 API 的自动转换. 尽管它能成功转换 74% 的实际并发代码, 但其静态摘要机制无法处理动态初始化的互斥锁, 从而限制了其扩展性. 此外, 他们提出了基于 LLM 驱动的类型迁移方法以解决这些不足 [143], 利用生成模型从 C 语言松散的规范中推断出 Rust 类型. 初步结果显示出潜力, 但 LLM 在复杂场景 (如嵌套联合体) 中可能会产生类型映射错误, 因此需要进行严格的后续验证. 这些工具共同揭示了一个趋势: 结合静态分析与启发式或机器学习组件的混合方法能够逐步提高安全性, 但尚缺乏端到端的安全保障.

Rust 与其他语言之间的代码转译。 从 C 到 Rust 的转译是现代化遗留系统的关键, 且相关工作已扩展到其他语言, 以实现更广泛的集成. Ecore2Rust [144] 实现了 Ecore 语言元模型向 Rust 的自动化转换, 使得基 Rust 的领域特定语言 (DSLs) 可以编译为 WebAssembly, 用于 Web 应用。Takano 等 [28] 开发了一款将 Rust 转换为 RTL 代码的转译器, 通过编码规范警告来提升硬件描述语言 (HDL) 的设计质量. Lunnikivi 等 [145] 通过将 Python 代码转译为 Rust 来实现性能优化, 实现了最高 12 倍的速度提升和 1.5 倍的内存减少。

转译研究突显了 Rust 作为现代化工具的潜力, 但也揭示了自动化与安全性之间尚未解决的矛盾。尽管 Crown 和 CRUSTS 等工具能够缓解 C 语言的内存风险, 但它们无法完全将 C 语言的语义与 Rust 的严格安全保证对接, 致使 unsafe 代码的问题依然残留。LLM、混合分析器和领域特定转译器这些新兴方法, 提供了渐进的进展, 但在应对边缘情况时缺乏稳健性。未来的工作应优先关注上下文感知的翻译、与形式化验证的深度集成, 以及对非 C 语言生态系统的扩展支持, 以实现代码转译所承诺的安全、高效的遗留系统现代化。

6 Rust 编译器的构建与优化 ​

关于 Rust 编译器构建与优化的研究, 主要致力于扩展编译器功能、增强运行时性能、提升内存安全以及解决潜在漏洞. 本节将围绕四个相互关联的主题综合探讨相关研究: 编译器基础设施优化、类型系统创新、硬件感知编译, 以及关于编译器可靠性的实证研究. 通过对这些工作的分析, 我们识别出了性能提升、安全保障与实际可用性之间存在的协同效应与矛盾.

6.1 用于优化的编译器扩展 ​

编译器扩展对于提升 Rust 程序的性能与效率至关重要, 尤其是在高性能计算及资源受限的环境中. 这类扩展通过利用 LLVM 优化、自定义编译器传递以及硬件特定调整, 来实现精细化调优的执行性能.

基于 MIR 的优化与静态分析。 Lafrance 等 [146] 提出了一种零拷贝通信机制, 通过减少数据交换过程中的开销, 显著提升了系统性能. 他们采用的静态分析确保了共享堆上所有权更新的正确性, 从而促进了内存的高效使用. Li 等 [147] 分析了 Clippy 代码检查提示在实际 Rust 应用中的有效性, 并开发了自动化重构技术,将每千行代码（KLOC) 的警告密度从 195 降至 18. 然而, 误报及自动修复能力有限等挑战依然存在, 这表明此类工具仍有进一步完善的空间.

基于 LLVM 的特定硬件优化扩展。 Lin 等 [148] 通过 LLVM 增强功能及专用的 SIMD 库启用了单指令多数据指令, 从而提升了 Rust 在 RISC-V 架构上的性能. 这项工作展示了面向特定硬件的编译器扩展的潜力,但也突显了在更多异构架构上提供更广泛支持的需求. 此外, Coblenz 等 [149] 提出了 Bronze, 这是一个基于库的垃圾收集器, 旨在简化 Rust 中的内存管理. Bronze 显著降低了初学者的学习门槛, 使开发过程中更快地完成任务. 然而, 由于依赖垃圾回收机制, 它会带来一定的性能开销, 这可能并不适用于所有用例.诸如面向 RISC-V 和 MIR 的编译器扩展, 充分体现了 Rust 对专用硬件的适应性及其在提升运行时效率方面的能力. 然而, 需要慎重权衡性能开销与可用性提升之间的取舍, 性能开销与易用性增强之间的权衡, 尤其是像 Bronze 这样的工具.

6.2 安全性与安全增强 ​

除了 Rust 固有的安全保障之外, 各类编译器扩展和工具还旨在在对漏洞防护有更高要求的环境中, 进一步增强安全性与可靠性. 这些创新主要聚焦于静态分析、类型系统扩展以及硬件辅助的安全机制上。

面向划分与隔离的静态分析。 静态分析工具通过在 Rust 编译器器中自动化执行代码分区、内存管理和隔离, 有效增强了安全性、内存安全与可靠性。Cadote [150] 引入了一种编译器辅助框架, 用于将 Rust 代码划分为面向 Intel SGX 的可信执行环境, 通过隔离敏感函数来提升安全性。TRUST [134] 过将安全的 Rust 代码与不受信任的代码 (包括 unsafe 代码块和外部库) 隔离, 对这一方向作了补充. TRUST 在实现极低性能开销（运行时开销 7.55%, 内存开销 13.30%）的同时, 性能表现优于现有的隔离技术, 这使其成为增强进程内安全性的实用解决方案。

用于编译期安全性的类型系统扩展。 Rust 中的类型系统扩展通过在编译期增强安全性、减少缺陷, 从而提升语言的健壮性。Lehmann 等 [151] 提出了 Flux, 将逻辑细化与 Rust 的所有权模型相结合, 以简化对底层程序的验证。通过减少注解开销和验证时间, Flux 使得对复杂系统进行验证变得可行. Duarte 和 Ravara [152]通过引入类型状态扩展了 Rust 的类型系统, 使得在编译期即可进行状态管理, 减少了与状态相关的缺陷。类似地, Liu 等 [153] 提出了 XRust, 在类型系统中集成运行时检查, 将堆空间划分为安全和不安全区域, 以防止内存安全违规。这些工具强化了 Rust 的编译期安全保证, 但往往要求开发者接受新的编程范式, 从而在一定程度上提高了学习门槛.

面向特定体系结构的安全扩展。 体系结构扩展使 Rust 能够利用硬件来进一步提升内存安全性和整体安全性。Harris 等 [154] 将 Rust 编译器扩展为面向 Morello 体系结构, 将硬件级内存保护机制与 Rust 的类型系统相集成。尽管带来了 39% 的性能开销, 但 Morello 的硬件辅助检查在代码中即便是 unsafe 片段也能提供强有力的内存安全保障。尽管安全性较高, 但由于依赖专用硬件, 这类面向特定体系结构的扩展目前尚难以得到广泛应用。

6.3 编译器可靠性的实证研究 ​

实证研究为 Rust 编译器的性能、稳定性和安全性提供了重要启示。这些研究指明了亟待改进的领域, 并为设计更健壮的编译器特性提供了指导。Li 等 [155] 分析了 Rust 不稳定特性 (RUF) 对编译失败和安全漏洞的影。他们的研究结果揭示了使用实验性特性所带来的风险, 并提出了用于识别 RUF 使用情况的工具, 以改进错误恢复机制和整体稳定性。Xia 等 [24] 考察了 Rustc 和 Rust-GCC 编译器中的缺陷, 发现 Rustc 的缺陷主要集中在核心组件, 而 Rust-GCC 的缺陷则多源于清理过程。他们建议在测试用例中充分利用 Rust 的并发特性, 以提高缺陷发现与修复的效果。这些研究强调了严格测试和特性管理对于提升编译器可靠性的重要性。

实证研究揭示了 Rust 编译器在稳定性和可靠性方面仍存在关键缺口。解决这些问题需要更完善的测试框架, 以及对实验性特性的更严格管控, 以确保整 Rust 编译器生态中的性能表现保持一致。

7 开源库、工具与应用 ​

作为一门以安全性和高性能著称的系统编程语言, Rust 的快速发展离不开开源社区所起的关键作用. Rust被广泛应用于操作系统、游戏开发、算法设计和科学计算等多个领域, 支持构建各类创新性解决方案. 为探讨 Rust 在不同应用场景中的发展前景, 我们调研了 Rust 的主要开源库、工具和应用, 并按其主要功能在表中进行了归纳和分类. 本节将对上述开源库、工具和应用作简要介绍.

7.1 核心工具与基础开发设施 ​

在现代 Rust 开发中, 各类工具和开发基础设施在应对一系列挑战方面发挥着关键作用, 这些挑战包括保障内存安全、管理复杂生命周期, 以及在日益复杂的软件系统中保持较高的代码质量. 这些方案旨在增强语言本身的安全保障能力, 简化开发过程, 并促进高效的跨语言互操作. 关键技术涵盖了用于隔离不安全交互的沙箱解决方案、用于降低学习门槛和调试成本的生命周期可视化工具, 以及用于保证程序正确性的形式化验证系统. 借助这些工具, Rust 开发者可以在提升生产力和可靠性的同时, 进一步拓展安全高效编程的边界.

安全性与互操作性。 支持安全与互操作性的工具助益 Rust 在实现与其他语言集成的同时, 维系其安全保障。Sandcrust [156] 通过将 C 代码隔离于独立进程中, 从而防止在与不安全 C 库交互时发生内存破坏。Josephine [127] 确保了 Rust 能够与 JavaScript 等采用垃圾回收机制的语言安全集成, 将 Rust 的手动内存管理与 JavaScript 的垃圾回收相结合, 实现了性能的提升。

可视化工具。 可视化工具协助开发者理解 Rust 中保障内存安全的所有权、借用和生命周期规则。RustViz [157]提供交互可视化功能, 简化了所有权和借用等概念. VRLifeTime [158] 帮助开发者在 Visual Studio Code 中可视化变量的生命周期, 从而有效预防并发和内存相关问题。REVIS [159] 提供生命周期可视化与错误高亮功能,简化错误排查的同时, 改善了 Rust 的学习体验。

代码质量与重构。 专注于代码质量与重构的工具通过自动化代码转换和验证 Rust 程序的正确性来提升开发者的生产力. Sam 等 [160] 提出了一种自动重构工具, 利用 Rust 的所有权与借用系统执行代码转换, 如变量重命名、本地变量内联以及生命周期参数处理. 这款工具通过减少手动操作和潜在错误, 帮助开发者保持代码质量并提升开发效率. Astrauskas 等 [161] 提出了 Prusti, 这是一款形式化验证工具, 通过直接从 Rust 代码中提取信息来验证内存安全性和数据不变式, 帮助开发者以最少的注解确保程序正确性. Ardito 等 [162] 评估了代码质量指标, 如复杂度和可维护性, 帮助开发者在无需执行程序的情况下识别并解决质量问题. Nowak 等 [163] 提出了一款工具, 确保 Rust 库遵循语义版本控制, 减少在发布新版本时 API 发生破坏性变更的风险.最后, Li 等 [164] 结合分析、开发者反馈和自动重构评估了 Clippy 的有效性, 并显著降低了警告密度。

7.2 应用开发框架与库 ​

Rust 的应用开发框架与库生态系统满足了对安全、高效且通用的软件工具的需求。这些技术通过解决并发通信、结构化数据处理和安全加密等挑战, 简化了应用程序的创建过程。借助 Rust 在强类型、编译时保证和内存安全等方面的优势, 这些工具提供了创新性的解决方案。从会话管理到高性能解析和加密, 这些工具在提升生产力与维系代码质量的同时, 拓宽了 Rust 在各类领域中的应用范围。

会话管理。 会话管理在确保 Rust 并发进程间实现安全且高效的通信方面, 扮演着至关重要的角色.La gaillardie [165] 介绍了一种专为开发安全定时协议而设计的 Rust 工具链. 该工具链利用泛型与时间库, 以极低的开销处理定时通信, 并为实现从简单的双边交互到复杂的多方交互等各类协议提供了循序渐进的指导。Jesperson 等 [166] 开发的库实现了会话类型, 在编译时保证协议安全, 从而避免了运行时的检查开销。Rusty Variation [167] 对此做了进一步推进, 它利用 Rust 的错误处理机制来确保协议遵循性并消除竞争条件, 实现了无死锁的会话类型化通信. 最后, Rumpsteak [168] 引入了面向异步通信的多方会话类型, 允许在不牺牲安全性的情况下高效地重新排序消息, 从而在 async/await 上下文中实现了显著的性能提升。

解析与处理。 Rust 中的解析与处理库致力于在处理结构化数据时实现安全性与高性能。Nom [169] 利用 Rust 的内存安全特性, 通过零拷贝操作与解析器组合子, 彻底变革了解析任务, 实现了高效且安全的数据处理。IOQP [170] 作为一款查询处理器, 侧重于基于影响度排序的稀疏检索模型（impact-ordered sparse retrievalmodels）, 它在支持传统与现代信息检索方法的同时, 证明了 Rust 具备提供媲美 C++ 级性能的能力。Kusters等 [171] 贡献了一个高性能的过程挖掘库, 将 Rust 的内存安全性与 Java 和 Python 绑定结合起来, 提供了在数据密集型应用中的多样性。Raphtory [172] 是一个时序图引擎, 通过提供用于分析时序数据演化、构建可扩展网络结构以及利用 Python 和 Rust 绑定部署应用程序的工具, 将上述能力拓展到了动态网络领域。

流处理。 Rust 中的流处理利用结构化的并行抽象, 确保在多核系统上实现高性能. Pieper 等 [173] 引入了一个包含 Map 和 Pipeline 等并行模式的库, 旨在优化流处理过程. 在此基础上, Rust-SSP [174] 简化了并行应用开发, 并在实际基准测试中实现了卓越的性能. hdt-rs 库 [175] 支持 RDF 压缩与查询, 通过降低内存占用,有效提升了数据处理效率. 最后, PPL 库 [176] 将 Rust 的并发模型与结构化抽象相结合, 使开发者能够以最小的复杂度构建健壮的并行系统。

密码学。 Rust 的密码学库侧重于安全性与易用性. Mindermann 等 [177] 评估了主流 Rust 密码学工具的用户友好性与抗误用性, 并提出了切实可行的改进建议. 2023 年, Barchi 等 [178] 展示了通过将 Rust 与 PULP 架构相集成来实现高效流加密的方法, 从而解决了信息物理系统（CPS）在性能与安全性方面面临的双重挑战。

专业化应用。 Rust 的多功能性扩展到了多个领域中的专业化应用之中. da Silva 等 [179] 为 Amethyst 游戏引擎开发了一款脚本模块, 使开发者能够利用 Python 等外部语言编写游戏逻辑, 从而简化了快速原型设计流程. FEM 2D [180] 支持高级有限元方法（FEM）计算, 通过融合分层细化技术与鲁棒求解器, 有效服务于各类工程任务. 最后, RSESS [181] 提供了枚举球面整形算法的 Rust 实现, 通过创新的调制符号分布, 提升了通信系统的能效. Blinowski 等 [182] 推出的模糊测试框架, 通过实现针对可信执行环境的 API 规范自动化探索,并在 OP-TEE 可信操作系统上进行了验证, 进一步拓展了 Rust 在安全计算领域的应用.

7.3 性能优化与系统编程 ​

Rust 在性能优化与系统编程领域的进展, 得益于其在内存安全、并发性及效率方面的固有优势。这些特性使得 Rust 成为构建诸如 Web 浏览器、嵌入式系统、内核模块、安全关键型软件及实时优化工具等对可靠性与高性能有严格要求应用的理想之选。通过有效应对内存漏洞、数据竞争条件以及低延迟需求等挑战, Rust 促成了诸多创新解决方案的开发。它在 Servo、Unikernel（单内核）、内核模块及高性能数据处理等项目中的应用, 充分展示了其在管理复杂系统方面的通用性, 即在不牺牲效率的前提下, 同时确保了安全性与性能。

Web 浏览器。 Anderson 等 [183, 184] 通过 Servo 项目, 利用 Rust 彻底变革了 Web 浏览器的开发. Servo基于 Rust 的安全性与并发特性设计, 不仅最大限度地减少了内存漏洞, 还确保了可靠的性能. 该项目展示了Rust 在管理复杂并发系统方面的能力, 同时维系了安全且高效的运行时环境。

嵌入式系统。 Rust 在嵌入式系统领域的集成, 已催生出众多鲁棒且安全的应用程序. Uzlu 和 Saykol [185]展示了利用 Rust 进行的基于 EFI 的引导加载程序设计, 并重点强调了其内存安全性. Levy 等 [186] 突显 Rust 在嵌入式内核方面的适用性, 指出其能在不造成显著性能损失的前提下提供安全保障. 近期,Sharma 等[130] 对 Rust 在嵌入式环境中的潜力进行了评估, 并指出了其优势与面临的挑战. 面向嵌入式系统的单内核 Unishyper [187], 进一步例证了 Rust 在开发具备 Intel-MPK 支持的内存安全、低延迟应用中的重要作用。

内核模块。 Rust 在内核模块开发中的应用, 显著增强了安全性与可靠性. Chen 和 Wu [188] 将 Rust 集成到了 Linux 内核模块中, 而 Li 等 [189] 则开发了一种基于 Rust 的内存溢出（OOM）模块, 以提升内核安全性. Ma 等 [43] 贡献了一种用于嵌入式系统恐慌恢复的栈展开实现. 进一步的进展包括 Atmosphere [190], 一个经过 Verus 验证的基于 Rust 的微内核, 以及 Gonzalez 等 [191] 设计的基于 Rust 的 UDP 隧道驱动程序.rOOM 项目 [192] 将 Rust 的优势扩展至 Linux OOM 内核组件, 从而确保了更安全的 FFI 接口。

安全增强。 Rust 的安全特性促成了创新的内存及数据隔离技术。Fidelius Charm [193] 引入了针对不安全Rust 代码块（特别是在 FFI 场景下）的内存隔离机制。单内核 RustyHermit [194] 展示了如何通过 Rust 的编译时保障来提升安全性。类似地, HarSaRK-RS [195] 提供了一种基于 Rust 的硬实时内核, 该内核优先考虑数据竞争防护, 并确保了安全关键型性能。

优化工具。 Rust 在实时系统优化方面发挥了关键作用。Culic 等 [196] 利用 eBPF 技术增强了实时操作系统的性能, 实现了低中断延迟. 作为一款嵌入式虚拟机监控器（Hypervisor）, Rust-Shyper [197] 促进了高效的虚拟机在线迁移与容错操作, 进一步证实了 Rust 在高要求环境下的可行性。

高性能数据处理。 Thistle 等 [198] 通过开发向量数据库, 探索了 Rust 在高性能数据处理方面的能力. 通过利用基于神经网络的嵌入技术进行文本搜索, Thistle 展示了 Rust 在可扩展、延迟敏感型应用中的潜力, 从而在系统编程与现代 AI 驱动任务之间架起了桥梁.

7.4 领域工具与扩展 ​

Rust 的通用性与鲁棒性, 使其确立了作为跨多元领域开发特定领域解决方案之关键工具的地位。Rust 凭借其在性能、内存安全及并发性方面的优势, 实现了高效且可靠的软件开发。通过仿真与建模、安全飞地开发、验证以及更多手段, Rust 持续以创新方法应对各类复杂问题。

仿真与建模。 仿真与建模领域利用计算机程序来预测和分析复杂系统. Blanco [199] 探讨了 Rust 在天体物理学中的优势, 特别是在重实现用于模拟多行星系统的 Mercury-T 时, 重点关注了内存安全与可靠性. 开源库 Rust-AB [200] 通过融入内存安全与并发特性, 促进了高性能的基于代理的建模（Agent-Based Modeling）。SyncRim [201] 是一款基于 Rust 的同步电路模拟器, 具备适用于 CPU、MCU 及系统级电路的模块化设计, 并支持 RISC-V 代码生成, 旨在教育与研究场景中替代基于 Java 的 SyncSim. RustSim [202] 专为离散事件、面向过程的仿真而设计, 它利用 Rust 的生成器来实现仿真原语, 并提供了易于扩展与定制的模块化设计。

对比研究。 对比研究涉及考察各种工具、语言或框架之间的差异与相似之处, 以确定它们的相对优劣. Cimler [203] 针对大规模基于代理的仿真, 对 Rust 与 C# 进行了比较, 强调了 Rust 的效率与 C# 的易用性.Shin [204] 对基于 Rust 的 SGX 框架进行了分析, 讨论了内存安全与性能之间的权衡. Bitar [205] 在科学计算背景下对比了 Rust 与 Julia, 强调了 Julia 的动态性能以及 Rust 的可靠性与内存安全性. Praveen [206] 探讨了 Rust 在恶意软件开发中呈现的新兴趋势, 并强调了为应对这一威胁需进行进一步研究的必要性. 这些研究为理解不同技术的比较性能与应用提供了宝贵的见解.

安全飞地开发。 安全飞地开发专注于创建安全执行环境（或称飞地）, 以保护代码与数据. Ding 等 [207]推出了 POSTER, 这是一个 Rust SGX SDK, 它将 Intel SGX 的可信执行环境与 Rust 的内存安全特性相结合, 相比 C/C++ 实现了更高的性能与更少的漏洞. Wang [208] 展示了一个库, 旨在减少 SGX 应用程序中的内存漏洞. Dreissig [150] 引入了 Cadote, 该工具利用 LLVM 优化技术将 Rust 程序划分为面向 SGX 飞地的可信与不可信组件. Julku [209] 探讨了一种用于 Keystone 飞地应用的 Rust SDK, 旨在增强安全性与并发能力. Shin [204] 比较了三种基于 Rust 的 SGX 框架, Rust SGX SDK、Fortanix EDP 以及 Occlum, 它们各自具备不同的优势. 这些努力突显了 Rust 在安全飞地开发中日益重要的作用。

性能与优化。 性能与优化领域专注于在维持代码质量的同时, 提升计算效率与速度. Rinaldi 等 [210] 在用于并行模式的 FastFlow 库中探索了 Rust 的应用, 证明了 Rust 在提供更佳内存安全性的同时, 能够匹配 C++的性能. Fazio [211] 研究了 A* 算法在 Rust 中的并行化实现, 利用多线程技术提升了性能. Michinaka[212]展示了 Rumpfr, 这是 GNU MPFR 库的 Rust 绑定, 实现了高精度浮点计算. 这些研究突显了 Rust 在性能优化与并行计算方面的优势。

语言互操作性。 在软件开发中, 实现语言间的无缝交互是发挥它们各自优势的关键. Langlands 等 [213] 推出了 cppmm, 这是一种自动化 Rust-C++ 绑定的工具, 它使 Rust 更易于集成到基于 C++ 的视觉特效（VFX）软件中, 从而兼顾了性能与安全性. Dahl [214] 展示了一种利用 Rust 开发 R 包的框架, 该框架支持创建符合CRAN 标准且具备 Rust API 的软件包. Csaszar [215] 利用 Rust 改进了 Frida 逆向工程框架, 通过增强性能与类型安全性, 提供了更优的安全性与恶意软件分析工具. 这些成果提升了跨语言的协同工作能力与性能。

领域特定语言。 定制化的编程语言或环境对于优化效率至关重要. Olivier 等 [216] 提出了一种在 Rust 中创建 DSL 的工具辅助方法, 该方法利用 Ecore 中的元模型来生成 Rust 代码, 并通过 Petri 网与有限状态机进行了演示. Lafage 等 [217] 推出了 Egobox, 这是一个用于全局优化的 Rust 工具箱, 它利用高斯过程回归来实现高性能计算. Olivier 等 [218] 进一步探索了基于 Rust 的 DSL 开发方法, 通过行为树 DSL 展示了 Rust 在元模型操作中的性能与安全性. 这些工作突显了 Rust 在构建侧重性能与安全性的领域特定语言方面的潜力。

验证与安全性。 确保软件的正确性与安全性至关重要, 尤其是在高风险系统中. Wan 等 [219] 推出了开发环境 RusTEE, 它利用 Rust 的内存安全特性, 提升了 ARM TrustZone 中可信应用的安全性. Park 等 [220]展示了 Rustspot, 这是一种用于识别 Rust 二进制文件中不安全函数的机器学习工具, 可增强了二进制分析能力. Hardin [106] 将形式化验证应用于 Rust 中的舞蹈链（Dancing Links）优化, 从而提升了系统可靠性.Duarte [221] 引入了 #[typestate] 宏, 以确保对有状态 API 的使用进行编译时检查. Schubert 等 [222] 提供了一个Rust crate, 用于针对非欧几里得数据实现高效的 k-中心点（k-medoids）聚类. Dang 等 [223] 更新了 RustBelt, 以支持松散内存模型下的安全并发. Matsui [224] 在基于 FPGA 平台的自动驾驶机器人中应用 Rust, 以实现内存安全与高效通信. 这些创新成果展示了 Rust 在提升软件安全性、验证及安防方面的作用。Carneiro 等 [225] 介绍了 mizar-rs, 这是对 Mizar 证明系统核心组件的 Rust 开源重实现版本. 该项目提升了性能, 揭露了潜在缺陷, 并实现了对 Mizar 数学库（MML）的验证, 旨在促进证明导出并支持 Mizar 语言的进一步发展。

硬件与协同设计。 Hardin 等 [226] 探讨了 Rust 在高层次综合（HLS）中的应用, 重点关注软硬件协同保障（co-assurance）。他们推出了受限算法 Rust（RAR）, 这是一种受受限算法 C（RAC）启发、具备类型安全与内存安全的 Rust 子集, 专用于自动驾驶汽车等高保障系统. 通过将 RAR 转译为 RAC 并利用 ACL2 定理证明器集成形式化验证, 作者在密码学及 JSON 解析等实现的验证中展示了 RAR 的有效性, 突显了其在增强软硬件可靠性方面的潜力。

8 讨论 ​

本节分析了源于本研究的结论与主要发现. 我们首先探讨了与 Rust 相关的研究挑战, 进而论述了潜在的未来研究方向.

8.1 自其他语言的经验 ​

本节探讨了源于对其他语言研究的见解与策略, 重点阐述了如何利用这些语言的特性来增进对 Rust 的理解与应用. 通过审视这些语言中的成功实践与面临的挑战, 我们旨在识别出可迁移的经验, 从而为更具成效的研究方向提供助力。

▶ 研究主题 1: 程序修复 ​

程序修复是一个备受关注的研究领域, 特别是在自动化检测与修正软件缺陷（Bug）的背景下. 近年来,学界提出了多种用于自动修复 Java、C++ 和 Python 等语言代码的技术, 这些技术主要依赖于模板、搜索算法及机器学习方法来生成补丁. 诸如 GenProg、PAR、SimFix 和 DeepFix 等工具为该领域做出了重大贡献.GenProg [227] 利用遗传算法, 通过比较代码的故障版本与正确版本来演化补丁; 而 PAR 则采用基于重构的方法, 利用抽象语法树（AST）来指导修复工作. 另一方面, SimFix [228] 基于从过往已修复 Bug 中提取的模式来生成修复方案, 从而提供了一种更具针对性的缺陷修正方法. 尽管这些工具在 Java 和 C++ 等语言中取得了成功, 但针对 Rust 的程序修复领域仍处于欠发达状态. Rust 独特的所有权模型与编译时检查, 已消除了诸多在其他语言中频发的常见 Bug, 如空指针解引用和数据竞争。

然而, Rust 仍易受逻辑错误、Panic 缺陷、性能低效以及运行时出现的并发问题的影响, 而目前的修复工具并未解决这些问题. 此外, Rust 的独特特性, 如借用检查器与生命周期系统为开发专用修复工具既带来了挑战, 也提供了机遇. 虽然这些特性有助于消除内存安全问题, 但它们也引入了新的错误类别, 如生命周期不匹配或不当借用, 这些错误往往难以自动修复. 目前, Rust 生态系统缺乏能够自动解决这些问题的专用修复工具,尤其是针对复杂的运行时缺陷. 因此, Rust 自动化修复工具的开发存在明显空白, 未来的研究可以侧重于利用 Rust 的静态分析能力（如借用检查器）, 或集成机器学习技术来生成专门针对 Rust 相关问题的补丁。

研究方向： (1) 一个潜在的方向是探索如何利用 Rust 强大的静态分析能力来指导程序修复过程. 借用检查器通过所有权规则确保内存安全, 它可被用于识别因违反所有权或借用规则而引发逻辑错误的情况. 修复工具可以实现对这些错误的自动化识别, 并提出补丁以解决与所有权、借用或生命周期相关的问题. (2) 另一个具有前景的研究方向在于将机器学习技术集成到 Rust 的程序修复中. 机器学习模型, 特别是那些在大规模代码库上训练的模型, 可用于基于在先前 Bug 修复中观察到的模式, 为特定 Bug 预测可能的修复方案. 这些方法在其他编程语言中已获成功, 将其适配至 Rust 可以提升修复过程的自动化程度. 例如, 模型可以从历史 Bug数据集中学习, 并生成符合 Rust 最佳实践的补丁, 从而确保代码质量与正确性。

▶ 研究主题 2: 程序验证 ​

程序验证是一个关键的研究方向, 专注于确保程序满足特定的正确性属性, 特别是在功能行为、安全性和性能方面. 在更广泛的软件开发社区中,Java 和 C++ 生态系统已经涌现出许多旨在提高软件可靠性和安全性的形式化验证工具. 像 Java PathFinder (JPF) 和 Frama-C 这样的工具广泛用于这些语言的模型检测和形式化验证. 例如, 基于 Java 的验证工具 JPF [229] , 它能够对程序行为进行详尽分析, 以检测死锁、竞争条件和断言违规等错误. 同样,Frama-C [230] 提供了一个用于 C 程序形式化验证的框架, 融合了抽象解释、最弱前置条件和分离逻辑等技术, 以确保内存安全、功能正确性和无运行时错误等正确性属性. 这些工具代表了在确保程序正确性方面的重大进展, 但它们在 Rust 中的应用仍然是一个开放性挑战. Rust 凭借其严格的内存安全特性, 特别是其所有权和借用模型, 已经针对空指针解引用和缓冲区溢出等底层内存错误提供了强有力的保障.然而, Rust 仍然需要验证工具来处理更复杂的属性, 例如确保并发正确性、逻辑一致性和性能保障. 尽管 Rust的内存模型为线程安全和数据竞争提供了一定的保障, 但在多线程应用中, 死锁、非数据竞争类和数据不一致等并发缺陷仍然难以进行形式化证明。

人们对 Rust 的形式化验证表现出了浓厚兴趣, 这主要是因为其独特的安全与并发模型, 但验证工具的开发仍处于早期阶段. 目前正在研究的一些杰出工具包括 Prusti 和 RustBelt. Prusti [99] 是一款形式化验证工具, 旨在结合符号执行和基于契约的推理来验证 Rust 程序. 它的目标是证明 Rust 代码的内存安全和功能正确性等属性, 但其适用性仍然有限, 主要集中于简单程序的验证. 另一方面, RustBelt [45] 是一个用于推理 Rust所有权和类型系统正确性的框架, 特别是针对 Rust 的 unsafe 代码. Rust 中的 unsafe 代码允许开发者绕过某些安全保障, 这使得它特别容易出错. RustBelt 旨在为与 unsafe 代码的安全交互提供形式化保障, 确保即使在这些场景下, 程序也能遵守内存安全和逻辑一致性. 然而,Prusti 和 RustBelt 仍然主要作为研究工具, 由于在可扩展性和复杂性处理方面的局限性, 两者尚未被工业界采用.

研究方向： (1) 一个有前景的方向是开发更全面的形式化验证工具, 使其能够处理复杂的属性, 例如并发程序的正确性. Rust 的并发模型虽然设计用于防止像数据竞争这样的常见并发问题, 但仍然需要形式化方法来确保多线程环境中更精细的正确性属性, 如无死锁、原子性和一致性. 将 Rust 的所有权系统与现有的形式化验证技术（如霍尔逻辑）相结合, 后者提供了一个通过前置条件和后置条件来推理程序正确性的框架, 将有助于验证具有更复杂交互的程序. 此外, 可以采用模型检测技术来系统地探索 Rust 程序的状态空间, 以识别潜在的错误.(2) 另一个关键的研究领域是探索专门为 unsafe 代码设计的验证方法, 这类代码有意允许绕过编译器严格安全检查的操作. 开发用于推理不安全代码交互的形式化方法, 例如确保安全内存访问及防止未定义行为,将极大地增强 Rust 在高保障系统中的可靠性. 此外, 开发更易用的验证工具并与 Rust 生态系统集成（例如集成在 Cargo 构建系统或 IDE 中）, 将有助于把这些技术引入实用的工业级应用中, 从而促进形式化验证实践在 Rust 社区中的更广泛采用.

▶ 研究主题 3: 静态分析与符号执行 ​

静态分析与符号执行是识别软件缺陷的基础技术, 其应用在 Java 和 C++ 等语言中已得到广泛发展. 这些技术有助于在编译时或测试期间检测多种问题, 从而提高软件系统的整体质量和安全性. 在 Java 生态系统中,FindBugs 和 Checkmarx 等工具已被广泛采用, 用于识别空指针解引用、安全漏洞和内存泄漏等问题. 例如,FindBugs [231] 利用静态代码分析, 通过检查 Java 程序的字节码来识别常见的编码错误和潜在的 Bug. 它能够检测未初始化变量、不当异常处理以及潜在并发问题等, 而在常规测试中这些问题可能会被忽略. 另一方面,Checkmarx [232] 专注于安全漏洞, 利用静态分析来识别 SQL 注入、跨站脚本攻击 (XSS) 和缓冲区溢出等漏洞. 同样, 在 C++ 生态系统中,Clang Static Analyzer 和 Cppcheck 等工具为开发者提供了强大的能力, 用于识别代码中的内存管理问题未定义行为和逻辑错误. Clang 与 LLVM 框架集成以提供对 C++ 程序的深度分析, 而 Cppcheck 则专注于检测各类编程错误, 如内存泄漏、空指针解引用和数组越界访问. 这些工具对于确保用 Java 和 C++ 编写的大规模系统的可靠性、性能和安全性已变得不可或缺, 特别是在 Bug 可能导致严重后果的安全关键型应用中。

相比之下, 虽然 Rust 的借用检查器为内存安全提供了强大的静态分析, 但在检测更广泛的缺陷方面, 该语言目前的静态分析工具套件仍相对有限. 借用检查器通过在编译时静态强制执行所有权和借用规则, 确保Rust 程序免受空指针解引用、悬垂引用和缓冲区溢出等常见内存安全问题的影响. 然而, 借用检查器的主要关注点是内存安全, 这使得其他类型的缺陷, 如逻辑错误、性能瓶颈和并发问题未能得到充分解决. 例如, 与程序流、数据不一致或算法实现错误相关的逻辑错误, 通常只能在运行时或通过手动测试发现, 而 Rust 中的静态分析工具在检测此类问题方面尚不全面. 此外, 与性能相关的问题, 如资源使用效率低下或算法次优需要超越基础静态分析的工具, 这可能涉及性能剖析和更深层次的代码理解, 而 Rust 在这些领域的工具仍有待开发。

研究方向： (1) 一个有前景的方向是增强现有的静态分析工具, 以检测因程序流程错误、假设有误或数据结构使用不当而产生的逻辑错误. 开发更先进的分析技术, 如控制流分析和数据流分析, 有助于在开发过程的早期阶段捕捉此类问题. 此外, Rust 现有的工具可以通过识别代码中的低效模式（如过度的内存分配或冗余计算）来扩展以解决性能瓶颈, 这对大规模系统的性能具有重大影响. (2) 另一个关键的研究领域是将符号执行与 Rust 的 MIR（中级中间表示）集成, 以构建更强大的验证工具. 通过将符号执行与 Rust 的中间表示相结合, 研究人员可以探索 Rust 程序的更复杂行为, 特别是那些涉及复杂控制流或有状态系统的行为. 这有助于识别传统静态分析工具可能遗漏的 Bug, 例如数据处理中的逻辑不一致或并发相关问题. 此外, 符号执行可以扩展以处理 unsafe 代码, 这些代码绕过了 Rust 的安全保障, 是潜在漏洞的来源. 确保符号执行工具能够对 unsafe 代码进行推理, 对于提高 Rust 的整体可靠性至关重要, 特别是在安全关键和高保障系统中. (3) 为了进一步增强 Rust 的静态分析生态系统, 像 Clippy 这样已经提供 Linting 和改进建议的工具, 可以扩展以包含针对逻辑正确性和性能的更高级检查. 通过将这些技术与现有的 Cargo 构建系统集成, 并为用户提供关于其代码的更详细反馈, Rust 有望在静态分析成熟度上进一步缩小与 Java 和 C++ 等语言的差距.

▶ 研究主题 4: 并发与并行分析 ​

并发正确性分析是一个关键的研究领域, 特别是在确保依赖并发执行的程序的正确性方面. 在 Java 和 C++ 等语言中, 在开发有助于识别和缓解数据竞争、死锁及原子性违反等常见并发问题的工具方面, 已取得了显著进展. ThreadSanitizer 和 Java PathFinder 等工具已成为软件开发社区中不可或缺的一部分. 例如, ThreadSanitizer [233] 是一款动态分析工具, 用于检测多线程程序中的数据竞争. 它通过在运行时对程序进行插桩并监控线程间的交互来运作, 使其能够标记诸如对共享内存的非同步访问等潜在问题. ThreadSanitizer 在C++ 及其他支持 LLVM 的语言中被广泛使用, 以帮助开发者确保其多线程程序免受常见并发缺陷的影响. 同样, Java PathFinder (JPF) [229] 作为 Java 程序的模型检测工具, 专注于检测死锁和竞争条件等并发相关的Bug. 它系统地探索多线程程序的执行路径以检测对安全属性的违反, 并可用于验证复杂的并发场景. 这些工具对于确保并发与并行系统的安全性与可靠性至关重要, 特别是在大规模应用中, 因为即便微小的并发问题也可能导致显著的性能退化甚至灾难性故障。

相比之下, Rust 受益于其所有权与借用系统, 该系统针对包括数据竞争在内的最常见并发问题提供了固有保障. 通过强制执行严格的所有权规则并确保没有两个线程能够同时访问可变数据, Rust 使得在其他语言中困扰开发者的典型数据竞争难以发生. 这一设计决策赋予了 Rust 在处理并发程序时在内存安全方面的明显优势. 然而, Rust 的并发模型并不能完全消除其他类型的并发问题, 例如死锁或并发程序流中的逻辑错误. 虽然Rust 编译器对内存访问的检查在编译时防止了数据竞争, 但该语言并未提供原生机制来预防或检测线程同步中的逻辑错误, 例如可能导致死锁的条件或线程间的不当资源分配. 此外, Rust 缺乏用于验证并发操作原子性的内置工具, 这意味着与操作原子执行相关的问题可能仍会被忽视, 尤其是在多线程与共享数据交互的复杂系统中。

研究方向： (1)Rust 并发分析的未来研究应侧重于开发更先进的工具, 这些工具应超越数据竞争的检测, 并能识别其他类型的并发缺陷, 如死锁、原子性违反和逻辑错误. 一个有前景的研究领域可能涉及将现有的形式化方法（如模型检测或事务内存）与 Rust 的并发模型相结合, 以在更高层次上确保正确性. 例如, 可以开发工具来验证并发 Rust 程序中的临界区是否得到了适当的同步, 以及资源的获取与释放是否始终以安全、无死锁的方式进行. 此外, 能够检测多线程代码中逻辑错误（如线程间的不当协调或锁与信号量的错误使用）的工具将极具价值. 目标是开发针对 Rust 的分析工具, 这些工具能够推理并发程序的控制流, 并确保它们在并发存在的情况下遵守安全属性. (2) 另一个关键的研究方向是开发用于验证 Rust 异步编程模型正确性的工具, 特别是在分布式系统的背景下. 异步 Rust 在构建依赖非阻塞 I/O 操作的可扩展、高性能系统（如 Web 服务器和网络应用程序）方面正变得日益流行. 然而, 确保这些系统正确性的挑战是巨大的, 因为它们涉及多个任务与外部资源之间的复杂交互. 研究可以侧重于调整现有的符号执行技术（如符号并发分析中使用的技术）, 以处理 Rust 异步任务的非阻塞、事件驱动特性. 集成此类分析的工具有助于确保异步代码免受竞争条件、死锁和任务调度错误的影响.

▶ 研究主题 5: 性能分析与优化 ​

性能分析是一个关键的研究领域, 特别是在 Java 和 C++ 等语言中, 用于性能剖析与优化的工具已非常成熟且被广泛采用. 在 Java 生态系统中, 像 JProfiler [234] 这样的工具常被用于识别性能瓶颈、内存泄漏以及垃圾回收中的低效问题. JProfiler 为开发者提供了关于内存使用模式、线程活动及 CPU 使用率的详细视图, 从而使优化 Java 应用程序变得更为容易. 同样, 在 C++ 生态系统中,Valgrind [235] 是一套强大的工具集,用于分析内存使用、检测内存泄漏以及识别诸如竞争条件或死锁等线程问题. 例如,Valgrind 的 Cachegrind 工具专注于分析缓存使用情况, 能够帮助开发者识别可能影响大型应用程序性能的低效内存访问模式. 此外, 由 Google 开发的 gperftools [236] 提供了一套性能分析工具, 包含高性能剖析器与堆剖析器, 用于监控内存使用并优化 CPU 密集型应用程序. 这些工具在确保性能关键型系统的效率与可靠性方面已变得不可或缺, 它们通过提供有关 CPU 周期、内存及磁盘 I/O 等资源利用情况的深入见解, 使开发者能够对应用程序进行微调。

相比之下, 尽管 Rust 常因其运行时效率而备受赞誉, 通常归功于其零成本抽象与对硬件的底层控制, 使其性能优于 Java, 但其性能分析工具相比 C++ 仍显稚嫩. Rust 的设计优先考虑性能, 专注于在无需垃圾回收器的情况下实现内存安全, 从而允许对资源管理进行细粒度控制. 然而, 尽管拥有这些优势, Rust 的性能分析工具仍然严重依赖于通用的剖析工具, 如 perf 和火焰图（Flamegraph）, 而这些工具并非专门针对 Rust 的独特特性构建. 例如,perf 这一强大的 Linux 剖析工具, 常被用于收集包括 Rust 程序在内的各类应用程序的性能数据. 它提供了关于 CPU 使用率、缓存未命中及上下文切换的深入信息, 但并未与 Rust 的所有权模型或借用检查器进行深度集成. 因此, 虽然 perf 对识别通用性能瓶颈很有用, 但它无法提供关于 Rust 的所有权与借用机制如何影响性能的详细信息, 例如管理内存分配的开销或在多线程上下文中追踪所有权的代价。

研究方向：（1）未来研究的一个有前景的领域是开发专门针对 Rust 内存管理模型的性能剖析器. 此类工具将提供关于所有权转移、借用检查以及在 Rust 生命周期系统内进行内存管理等操作成本的深入见解. 此外,分析异步代码性能的工具也将极具价值, 因为异步代码在 Rust 高并发应用中正变得日益流行. 异步模型引入了与调度、任务执行及资源争用相关的新性能挑战, 而现有的工具并未能很好地处理这些情况. 针对 Rust 的专用工具可以深入洞察异步运行时的性能表现、资源管理方式, 以及在任务调度或内存访问模式中是否存在瓶颈或低效之处. （2）此外, 进一步的研究可以集中在改进 Rust 与 LLVM 的集成上, 以便为开发者提供更好的工具来分析编译器优化. 增强对 unsafe 代码的调试与性能剖析支持也是一个重点关注领域, 因为 unsafe 代码允许开发者绕过 Rust 的安全检查, 从而带来安全代码中无法实现的潜在性能优化. 在确保安全性的同时优化此类底层代码的运行时性能, 将是一个重要的研究领域. 还可以开发追踪内存分配模式并检测 Rust 中低效内存访问的动态分析工具. 此类工具有助于开发者识别诸如过度内存分配或糟糕的缓存局部性等问题, 这些问题在高性能应用中可能导致性能瓶颈。

▶ 研究主题 6: 语言互操作性 ​

语言互操作性对于需要与以不同编程语言编写的组件或服务进行交互的软件系统而言, 是一项关键特性.Java 和 C++ 均拥有成熟的机制, 用以实现与其他语言的无缝互操作. 例如,Java 提供了 Java 本地接口（JNI）[237], 它促进了 Java 与 C/C++ 代码之间的通信. JNI 允许 Java 应用程序调用 C/C++ 函数并访问系统级资源, 从而实现了与遗留系统或性能关键型模块的高效集成. 同样,C++ 通过 FFI 支持互操作性, 该框架使 C++ 能够与包括 Python、Ruby 和 JavaScript 在内的多种其他语言进行交互. FFI 允许 C++ 代码调用这些语言的函数, 反之亦然, 这不仅提供了灵活性, 还减少了开发者将大型代码库重写为单一语言的需求. 这些机制显著增强了构建多语言系统的能力, 使得以不同语言编写的组件能够无缝协作并共享资源。

相比之下, Rust 的互操作性生态较为有限, 特别是在与 Java 和 Python 等高级语言进行交互时. Rust 通过其自身的 FFI 为与 C 语言的互操作性提供了强有力的支持, 允许 Rust 代码调用 C 函数, 反之亦然. 然而,在与其他语言集成方面, Rust 目前仍严重依赖手动绑定与外部工具. bindgen 便是此类工具之一, 它能自动为 Rust 生成 C 绑定, 从而简化了与 C 库交互的过程. 尽管取得了这些进展, 但与 Java 和 Python 等语言的交互仍非易事. 开发者往往需要编写大量的“胶水代码”, 以弥合 Rust 与这些高级语言之间的鸿沟. 这种手动方式不仅繁琐且易出错, 阻碍了 Rust 在那些对多语言集成有关键需求的环境中的广泛应用。

研究方向：（1）一个有前景的方向是开发能够自动生成 Rust 与 Java、Python 等高级语言之间绑定的先进工具. 此类工具能够简化将 Rust 集成至多语言系统的流程, 减少开发者所需编写的样板代码量. 另一个重点关注领域是提升跨语言调用的无缝性, 特别是在分布式系统与微服务架构的背景下, 因为在这些架构中,以不同语言编写的组件经常需要通过网络进行通信. 通过优化 Rust 在这些领域的互操作性, 研究人员可以使其成为构建依赖于多样化组件间高效通信的现代多语言应用程序的更优选择. （2）此外, 随着 WebAssembly(WASM) 等新兴技术的日益普及, 我们有机会探索 Rust 在基于浏览器的应用程序及无服务器计算环境中的互操作性. Rust 对 WASM 的原生支持允许开发者编译 Rust 代码并在浏览器中运行, 但进一步的研究可以改善其与 JavaScript 和 TypeScript 等 Web 开发常用语言的交互能力. 增强 Rust 与这些语言的互操作性, 不仅能提高其在 Web 开发生态系统中的普及率, 还能助推在浏览器内利用 Rust 构建性能关键型应用这一日益增长的趋势。

8.2 研究挑战 ​

尽管 Rust 编程领域已取得了显著进展, 但该语言仍处于演进之中, 且在程序分析、测试及工具支持等领域, 依旧存在诸多未解的挑战. 在本节中, 我们将总结未来工作可能需要解决的一些关键挑战.

(1) 测试与分析平台。Rust 研究面临的主要挑战之一, 是缺乏一个全面且标准化的测试与分析平台. 尽管近年来 Rust 的工具生态系统取得了显著进步, 但开发与 Rust 严格安全保障相契合的鲁棒且成熟的测试框架,仍处于起步阶段. 如第 4 节所述, 许多研究 [73, 77, 78] 强调了在 Rust 生态系统中对各类测试提供更好支持的必要性, 这包括单元测试、基于属性的测试以及模糊测试. 此外, 特别是那些专注于并发、内存安全及数据竞争检测的静态与动态分析工具, 开发仍然不足. 完善这些工具, 对于确保 Rust 的安全保障在现实应用（尤其是在高度复杂或对性能敏感的环境）中得到持续落实, 具有至关重要的意义。

(2) 稳定的中间表示 (IR)。尽管 Rust 编译器 rustc 目前使用一种内部中间表示（IR）, 但它缺乏在编译器研究与工具开发中广泛应用所需的稳定性与标准化水平. 许多现有的研究工作依赖 rustc 的内部 IR 来执行优化与分析等任务, 但这些方法往往依赖于特定的 rustc 版本, 导致在更新编译器或其相关库时面临挑战. 因此, 正如大多数现有工具 [76∼79] 中所指出的, 所提出的工具依赖于特定的 rustc 版本, 且无法在更新后的编译器版本上运行, 这迫使开发者必须进行大量重工以维持对新版本的兼容性. 一个稳定的 IR 将为构建优化器、分析器及其他能够在不同编译器版本间运行的工具, 提供一致的基础. 若缺乏这种稳定性, 许多研究工作将受阻于 Rust 编译器内部表示不断演进的特性, 这使得各类基于编译器的项目之间的复现性与互操作性变得复杂。

(3)Rust 互操作性中的跨平台挑战。尽管 Rust 的受欢迎程度日益增长, 但在现有编程生态系统中, 尤其是与 C/C++ 及遗留系统实现真正的跨平台互操作性, 仍是一项重大挑战. 每个平台都可能拥有其独特的约束条件与预期, 确保 Rust 在不同的操作系统与架构间无缝运行并非易事. 虽然 Rust 在支持多种平台方面已取得进展, 但这同时也引入了与特定平台优化、兼容性问题及运行时环境差异相关的复杂性. 克服这些挑战, 对于提升 Rust 在多样化生态系统（特别是嵌入式系统与大规模企业级应用）中的可行性至关重要。

(4) FFI 集成面临的测试挑战。Rust 与外部语言的集成, 特别是通过外部函数接口（FFI）进行的集成, 带来了一系列新的挑战. 尽管 Rust 在为 C 库创建 FFI 绑定方面取得了显著进展, 但这种方法仍可能破坏 Rust 严格的所有权与安全保障. 当 Rust 与非 Rust 代码交互时, 所有权模型会被绕过, 这可能会导致内存安全违规、数据竞争或其他难以检测的缺陷 [128,132,133]. 这些问题使得在与来自其他语言的代码混合使用时, 更难确保 Rust 安全特性的完整性. 因此, 需要新的测试方法来应对这些特定挑战, 特别是要确保内存安全与所有权完整性在跨语言边界处仍能得到保持。

(5) 工具链成熟度与自动化程序分析。Rust 面临的一个关键挑战是其工具链相对不成熟, 尤其是与像 C 这样受益于 Clang 等完善工具的语言相比（例如 [238∼240]）. 虽然 Rust 的编译器和包管理器很稳健, 但它缺乏用于自动化程序生成、静态分析、变异测试及其他高级任务的全面工具. 缺乏健壮的程序分析 API 和程序变异工具, 限制了 Rust 支持复杂测试与验证工作流的能力. 通过研究与工具开发来填补这些空白, 将增强 Rust 生态系统, 使其在程序优化和形式化验证等领域与其他语言相比更具竞争力。

(6) 高级用例中的内存管理与安全保障。尽管 Rust 在内存安全方面提供了强有力的保障, 但在某些高级用例, 尤其是底层系统编程与并发应用程序中的挑战依然存在. 虽然 Rust 的所有权模型显著降低了内存相关 Bug 的风险, 但在并发或多线程环境中处理复杂的所有权模式, 仍是一项研究挑战. 此外, 在需要复杂内存分配与释放策略的场景中, Rust 的借用与生命周期系统可能会变得繁琐. 未来需要进一步研究以简化这些流程, 使内存管理在不牺牲安全性的前提下更加直观。

(7) 编译器优化算法。Rust 编译器的性能往往成为瓶颈, 特别是随着代码库变得越来越大且日益复杂 [146, 148]. 尽管增量编译的引入有助于缓解这一问题, 但在优化编译器算法（如改进内联、循环优化及代码生成策略）方面进行进一步研究, 可能会显著缩短编译时间. 在追求快速编译与维持 Rust 所提供的安全及性能保障之间取得平衡, 仍是一项持续的挑战, 同时也为未来的研究提供了广阔的机遇。

(8) 二进制文件体积缩减。除了设计更高效的优化算法外, Rust 编译器优化的另一个关键方面是生成二进制文件的大小. 关于二进制文件大小, Rust 社区中已经进行了大量的讨论 [241, 242]. 尽管 Rust 团队非常重视这一问题 [243, 244], 但目前关于该主题仍缺乏深入的研究. 在许多应用场景中, 特别是在嵌入式系统和资源受限的环境中, Rust 输出二进制文件的大小可能成为一个制约因素. 研究缩减二进制文件大小的技术（例如更高效的死代码消除、感知大小的优化以及其他代码尺寸缩减策略）, 对于使 Rust 更适用于更广泛的应用领域至关重要. 在不牺牲运行时性能或安全保障的前提下缩减二进制文件大小, 为 Rust 社区提出了一个令人兴奋的挑战.

8.3 研究趋势 ​

目前, Rust 编程领域的研究集中在若干具有前景的趋势上, 旨在解决现有挑战并扩展该语言在各类领域中的适用性. 在本节中, 我们将探讨有望推动未来发展的潜在研究方向与新兴主题.

(1) 跨语言编程中的安全问题。随着 Rust 越来越多地与其他编程语言集成, 解决跨语言编程中的安全问题已成为一个关键的研究重点. 外部函数接口（FFI）为 Rust 提供了与 C 和 C++ 等语言进行交互的机制,但在这些交互中确保安全性仍然是一个重大挑战. 当前的研究正在探索防止未定义行为（如内存破坏或数据竞争）的方法, 这些行为可能是由于语言语义的差异而引发的. 人们正在开发工具和框架, 以验证并强制执行 Rust 与其他语言共用时的安全保障, 确保即使在异构代码库中也能维持其内存安全的核心承诺。

(2) 代码翻译: 从 C 到 Rust 及其他。自动代码翻译, 特别是从 C 等遗留语言到 Rust 的翻译, 作为一种在继承 Rust 安全与性能优势的同时实现软件系统现代化的手段, 已引起了广泛关注. 针对这一翻译过程, 学界已提出了多种工具与方法, 重点在于将 C 语言的构造映射到 Rust 的所有权模型与类型系统上. 然而, 诸如处理不安全代码、特定平台行为以及复杂的指针操作等挑战, 仍是尚未解决的问题. 该领域的研究旨在提高自动翻译工具的可靠性, 使以最少的人工干预将大规模遗留系统转换为 Rust 成为可能。

(3) Rust 的形式化验证与证明。Rust 中的形式化方法研究正蓄势待发, 其目标是验证程序的正确性, 并确保在所有可能的执行场景下安全保障均能成立. 将形式化验证工具与 Rust 的类型系统及借用检查器相结合, 为自动化证明生成及关键软件属性的验证提供了机遇. 近期的趋势侧重于将验证能力扩展至异步与并发 Rust 程序, 由于其复杂的执行语义, 这类程序极具挑战性. 该领域的进展有潜力使 Rust 成为安全关键领域中高保障系统的首选语言。

(4) 面向安全的研究与应用。Rust 对内存安全的强调, 使其成为安全关键型应用研究的天然候选者. 近期的趋势包括利用 Rust 进行安全软件开发、漏洞缓解以及沙盒技术的研究. 相关研究正在探索如何利用 Rust 来实现安全系统架构、加密协议以及 Web 服务. 此外, 关于将 Rust 与形式化安全模型及审计框架集成的研究, 正为其在高安全环境中的更广泛采用铺平道路.

(5) 系统编程中的性能优化. Rust 在嵌入式与系统编程中的应用, 激发了针对资源受限环境优化其性能的兴趣. 研究人员正在探索在保持 Rust 安全保障的同时, 最小化运行时开销、缩减二进制文件大小以及提升嵌入式设备能效的方法. 新兴趋势包括开发轻量级运行时库、面向嵌入式目标的专用编译器, 以及优化基于 Rust实现的实时系统的技术. 这些努力旨在巩固 Rust 在操作系统开发等领域作为可靠系统编程语言的声誉。

(6) Rust 与大语言模型（LLMs）的结合。大语言模型的兴起为增强软件开发流程（包括涉及 Rust 的开发流程）开辟了新的可能性. 关于利用 LLM 执行自动化 Rust 代码生成、文档编写及错误修复等任务的研究正在兴起. 由 LLM 驱动的工具正被开发出来, 以协助开发者编写地道的 Rust 代码、理解复杂的类型与所有权系统, 并高效地调试错误. 此外, 利用 LLM 自动将自然语言规范转化为安全且高效的 Rust 实现, 也引起了越来越多的兴趣. 反之, 研究人员也在探索如何利用 Rust 来优化 LLM 背后的基础设施（如训练流水线与推理系统）, 通过在分布式计算环境中提供内存安全与高性能来发挥作用. Rust 与 LLM 技术的这种交叉融合,凸显了这两个领域令人兴奋的前沿发展方向。

9 结论 ​

本文系统回顾了过去十余年的 Rust 研究工作, 并围绕五大核心领域进行了结构化整理: 语言分析与扩展、程序质量保障、跨语言编程、编译器构建与优化, 以及开源库与工具的发展. 通过综合分析 250 余项主要研究,我们展示了 Rust 的形式语义、先进类型系统与领域专用 DSL 如何深化语言在安全性与表达力上的理解；多样化的测试、模糊测试、静态-动态分析与形式化验证技术如何持续提升程序可靠性；FFI 与转译技术如何帮助 Rust 与现有生态无缝衔接；自定义 MIR passes、基于 LLVM 的后端、硬件辅助检测与类型层级增强如何在不牺牲安全性的前提下推动编译器性能；同时, 一个蓬勃发展的库、框架与工具生态如何加速 Rust 在多领域的采用。

通过本次综述, 我们识别出多个长期存在的挑战: 分析与验证工具的碎片化、将编译器测试与程序分析技术扩展到大型代码库的复杂性、手工 FFI 绑定的脆弱性以及对更具易用性的跨语言桥接方案的需求、硬件支持的动态检查与运行时性能之间的权衡、以及缺乏大规模真实世界的实证基准来验证 Rust 的实际优势. 在第 8 节中, 我们进一步总结了新兴趋势, 包括 AI 增强的证明生成、融合静态、动态与概率分析的统一安全框架、可在运行时自适应切换优化策略的编译器管线、以及面向供应链安全的系统性防护措施. 通过解决这些挑战, Rust 社区不仅能够巩固语言在安全性与并发性方面的核心承诺, 还将使 Rust 能够更加从容地应对未来高性能、高安全应用的需求, 确保其在现代软件系统中的持续发展与广泛应用。

参考文献 ​

  1. Klabnik S, Nichols C. The Rust programming language. No Starch Press, 2023
  2. Overflow S. 2024 developer survey, 2024. Stack Overflow annual report
  3. White house urges developers to dump c and c++ | infoworld. https://www.infoworld.com/article/3713203/white-house-urges-developers-to-dump-c-and-c.html, 2023. (Accessed on 03/17/2024)
  4. Google online security blog: Memory safe languages in android 13. [Online; accessed 2025-01-02]
  5. 0928 A. Replacing c++! microsoft’ s win11 kernel rewritten in rust is here! | by aaron 0928 | medium, 5 2023. [Online; accessed 2025-01-02]
  6. Servo, the embeddable, independent, memory-safe, modular, parallel web rendering engine. https://servo.org/, 2023. (Accessed on 12/06/2023)
  7. Redox - your next(gen) os - redox - your next(gen) os. https://www.redox-os.org/, 2023. (Accessed on 12/06/2023)
  8. Tikv is a highly scalable, low latency, and easy to use key-value database. https://tikv.org/, 2023. (Accessed on 12/06/2023)
  9. Stratis storage. https://stratis-storage.github.io/, 2023. (Accessed on 12/06/2023)
  10. Cloudflare. Cloudflare - the web performance & security company. https://www.cloudflare.com/, 2023. (Accessed on 12/06/2023)
  11. Astrauskas V, Matheja C, Poli F, et al. How do programmers use unsafe rust? Proc. ACM Program. Lang., 2020, URL https://doi.org/10.1145/3428204
  12. Evans A N, Campbell B, Soffa M L. Is rust used safely by software developers? In: Proceedings of Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering, New York, NY, USA: Association for Computing Machinery, 2020. 246–257
  13. Höltervennhoff S, Klostermeyer P, Wöhler N, et al. “I wouldn’t want my unsafe code to run my pacemaker”: An interview study on the use, comprehension, and perceived risks of unsafe rust. In: Proceedings of 32nd USENIX Security Symposium (USENIX Security 23), Anaheim, CA: USENIX Association, 2023. 2509–2525
  14. McCormack I, Dougan T, Estep S, et al. ” against the void”: An interview and survey study on how rust developers use unsafe code. arXiv preprint arXiv:2404.02230, 2024
  15. Zheng X, Wan Z, Zhang Y, et al. A closer look at the security risks in the rust ecosystem. ACM Trans. Softw. Eng. Methodol., 2023, URL https://doi.org/10.1145/3624738
  16. Cui M, Sun S, Xu H, et al. Is unsafe an achilles’ heel? a comprehensive study of safety requirements in unsafe rust programming. In: Proceedings of Proceedings of the IEEE/ACM 46th International Conference on Software Engineering, New York, NY, USA: Association for Computing Machinery, 2024
  17. Li Z, Wang J, Sun M, et al. Mirchecker: Detecting bugs in rust programs via static analysis. In: Proceedings of Proceedings of the 2021 ACM SIGSAC Conference on Computer and Communications Security, New York, NY, USA: Association for Computing Machinery, 2021. 2183–2196
  18. Ning P, Qin B. Stuck-me-not: A deadlock detector on blockchain software in rust. Procedia Computer Science, 2020, URL https://www.sciencedirect.com/science/article/pii/S1877050920323565. The 11th International Conference on Emerging Ubiquitous Systems and Pervasive Networks (EUSPN 2020) / The 10th International Conference on Current and Future Trends of Information and Communication Technologies in Healthcare (ICTH 2020) / Affliated Workshops
  19. Li W, He D, Gui Y, et al. A context-sensitive pointer analysis framework for rust and its application to call graph construction. In: Proceedings of Proceedings of the 33rd ACM SIGPLAN International Conference on Compiler Construction, New York, NY, USA: Association for Computing Machinery, 2024. 60–72
  20. Hua B, Ouyang W, Jiang C, et al. Rupair: Towards automatic buffer overflow detection and rectification for rust. In: Proceedings of Proceedings of the 37th Annual Computer Security Applications Conference, New York, NY, USA: Association for Computing Machinery, 2021. 812–823
  21. Cui M, Chen C, Xu H, et al. Safedrop: Detecting memory deallocation bugs of rust programs via static data-flow analysis. ACM Trans. Softw. Eng. Methodol., 2023, URL https://doi.org/10.1145/3542948
  22. Nitin V, Mulhern A, Arora S, et al. Yuga: Automatically detecting lifetime annotation bugs in the rust language, 2023
  23. Sharma M, Yu P, Donaldson A F. Rustsmith: Random differential compiler testing for rust. In: Proceedings of Proceedings of the 32nd ACM SIGSOFT International Symposium on Software Testing and Analysis, New York, NY, USA: Association for Computing Machinery, 2023. 1483–1486
  24. Xia X, Feng Y, Shi Q. Understanding bugs in rust compilers. In: Proceedings of 2023 IEEE 23rd International Conference on Software Quality, Reliability, and Security (QRS), 2023. 138-149
  25. Shin H, Ock J, No H, et al. A comparative analysis of rust-based SGX frameworks: Implications for building SGX applications. In: Proceedings of Seo H, Kim S, editors, Information Security and Cryptology –ICISC 2023. Springer Nature. 3–19
  26. Kyriakou K I D, Tselikas N D, Kapitsaki G M. Improving c/c++ open source software discoverability by utilizing rust and node.js ecosystems. In: Proceedings of Stamelos I, Gonzalez-Barahoña J M, Varlamis I, et al., editors, Open Source Systems: Enterprise31 Software and Solutions. Springer International Publishing. 181–192
  27. Li L, Zhang Q, Zhao S, et al. Design and implementation of oom module based on rust. In: Proceedings of 2022 IEEE 22nd International Conference on Software Quality, Reliability, and Security Companion (QRS-C), 2022. 774-775
  28. Takano K, Oda T, Kohata M. Approach of a coding conventions for warning and suggestion in transpiler for rust convert to rtl. In: Proceedings of 2020 IEEE 9th Global Conference on Consumer Electronics (GCCE). 789–790. ISSN: 2378-8143
  29. Thompson C. How rust went from a side project to the world’s most-loved programming language | mit technology review, 2 2023. [Online; accessed 2024-12-24]
  30. Wang F, Song F, Zhang M, et al. Krust: A formal executable semantics of rust. In: Proceedings of 2018 International Symposium on Theoretical Aspects of Software Engineering (TASE), 2018. 44-51
  31. Jung R, Dang H H, Kang J, et al. Stacked borrows: an aliasing model for rust. Proc. ACM Program. Lang., 2019, URL https://doi.org/10.1145/3371109
  32. Ho S, Fromherz A, Protzenko J. Sound borrow-checking for rust via symbolic semantics. Proceedings of the ACM on Programming Languages, 2024, 8: 426–454
  33. Weiss A, Gierczak O, Patterson D, et al. Oxide: The essence of rust. arXiv preprint arXiv:1903.00982, 2019
  34. Kan S, Chen Z, Sanan D, et al. An executable operational semantics for rust with the formalization of ownership and borrowing. arXiv preprint arXiv:1804.07608, 2018
  35. Weiss A, Patterson D, Ahmed A. Rust distilled: An expressive tower of languages. arXiv preprint arXiv:1806.02693, 2018
  36. Pearce D J. A lightweight formalism for reference lifetimes and borrowing in rust. ACM Trans. Program. Lang. Syst., 2021, URL https://doi.org/10.1145/3443420
  37. Headley K. A dsl embedded in rust. In: Proceedings of Proceedings of the 30th Symposium on Implementation and Application of Functional Languages, New York, NY, USA: Association for Computing Machinery, 2018. 119–126
  38. Yanovski J, Dang H H, Jung R, et al. Ghostcell: separating permissions from data in rust. Proc. ACM Program. Lang., 2021, URL https://doi.org/10.1145/3473597
  39. Levy A, Andersen M P, Campbell B, et al. Ownership is theft: experiences building an embedded os in rust. In: Proceedings of Proceedings of the 8th Workshop on Programming Languages and Operating Systems, New York, NY, USA: Association for Computing Machinery, 2015. 21–26
  40. Lagaillardie N, Neykova R, Yoshida N. Implementing multiparty session types in rust. In: Proceedings of International Conference on Coordination Languages and Models. Springer, 2020. 127–136
  41. Blesel M, Kuhn M, Squar J. heimdallr: Improving compile time correctness checking for message passing with rust. In: Proceedings of High Performance Computing: ISC High Performance Digital 2021 International Workshops, Frankfurt Am Main, Germany, June 24 –July 2, 2021, Revised Selected Papers, Berlin, Heidelberg: Springer-Verlag, 2021. 199–211
  42. Chen R F, Balzer S, Toninho B. Ferrite: A Judgmental Embedding of Session Types in Rust. In: Proceedings of Ali K, Vitek J, editors, 36th European Conference on Object-Oriented Programming (ECOOP 2022), Dagstuhl, Germany: Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2022. 22:1–22:28
  43. Ma Z, Chen G, Zhong L. Panic recovery in rust-based embedded systems. In: Proceedings of Proceedings of the 12th Workshop on Programming Languages and Operating Systems, New York, NY, USA: Association for Computing Machinery, 2023. 66–73
  44. Magnani G, Denisov L, Cattaneo D, et al. Precision tuning the rust memory-safe programming language. 2024
  45. Jung R, Jourdan J H, Krebbers R, et al. Rustbelt: securing the foundations of the rust programming language. Proc. ACM Program. Lang., 2017, URL https://doi.org/10.1145/3158154
  46. Payet É, Pearce D J, Spoto F. On the termination of borrow checking in featherweight rust. In: Proceedings of NASA Formal Methods Symposium. Springer, 2022. 411–430
  47. Lehmann N, Geller A T, Vazou N, et al. Flux: Liquid types for rust. Proc. ACM Program. Lang., 2023, URL https://doi.org/10.1145/3591283
  48. Gäher L, Sammler M, Jung R, et al. Refinedrust: A type system for high-assurance verification of rust programs. Proc. ACM Program.Lang., 2024, URL https://doi.org/10.1145/3656422
  49. Bagnara R, Bagnara A, Serafini F. C-rusted: The advantages of rust, in c, without the disadvantages. arXiv preprint arXiv:2302.05331, 2023
  50. Costanzo M, Rucci E, Naiouf M, et al. Performance vs programming effort between rust and c on multicore architectures: Case study inn-body. In: Proceedings of 2021 XLVII Latin American Computing Conference (CLEI). IEEE, 2021. 1–10
  51. Diehl P, Morris M, Brandt S R, et al. Benchmarking the parallel 1d heat equation solver in chapel, charm++, c++, hpx, go, julia, python, rust, swift, and java. In: Proceedings of European Conference on Parallel Processing. Springer, 2023. 127–138
  52. Ivanov N. Is rust c++-fast? benchmarking system languages on everyday routines. arXiv preprint arXiv:2209.09127, 2022
  53. Rotter J, Lewis M C. N-body performance with a kd-tree: Comparing rust to other languages. In: Proceedings of 2022 International Conference on Computational Science and Computational Intelligence (CSCI), 2022. 457-462
  54. Rooney M P, Matthews S J. Evaluating fft performance of the c and rust languages on raspberry pi platforms. In: Proceedings of 2023 57th Annual Conference on Information Sciences and Systems (CISS), 2023. 1-632
  55. Zhang Y, Zhang Y, Portokalidis G, et al. Towards understanding the runtime performance of rust. In: Proceedings of Proceedings of the 37th IEEE/ACM International Conference on Automated Software Engineering, New York, NY, USA: Association for Computing Machinery, 2023
  56. Suchert F, Castrillon J. Stamp-rust: Language and performance comparison to c on transactional benchmarks. In: Proceedings of International Symposium on Benchmarking, Measuring and Optimization. Springer, 2022. 160–175
  57. van Oorschot P C. Memory errors and memory safety: A look at java and rust. IEEE Security & Privacy, 2023, 21: 62–68
  58. Jaloyan G A, Moy Y, Paskevich A. Borrowing safe pointers from rust in spark. arXiv preprint arXiv:1805.05576, 2018
  59. Ardito L, Barbato L, Coppola R, et al. Evaluation of rust code verbosity, understandability and complexity. PeerJ Computer Science, 2021, 7: e406
  60. Chakraborty P, Shahriyar R, Iqbal A, et al. How do developers discuss and support new programming languages in technical q&a site? an empirical study of go, swift, and rust in stack overflow. Information and Software Technology, 2021, 137: 106603
  61. Balasubramanian A, Baranowski M S, Burtsev A, et al. System programming in rust: Beyond safety. In: Proceedings of Proceedings of the 16th Workshop on Hot Topics in Operating Systems, New York, NY, USA: Association for Computing Machinery, 2017. 156–161
  62. Hu S, Hua B, Wang Y. Comprehensiveness, automation and lifecycle: A new perspective for rust security. In: Proceedings of 2022 IEEE 22nd International Conference on Software Quality, Reliability and Security (QRS). IEEE, 2022. 982–991
  63. Xu B, Chu B, Fan H, et al. An analysis of the rust programming practice for memory safety assurance. In: Proceedings of International Conference on Web Information Systems and Applications. Springer, 2023. 440–451
  64. Ferdowsi K. The usability of advanced type systems: Rust as a case study. arXiv preprint arXiv:2301.02308, 2023
  65. Fulton K R, Chan A, Votipka D, et al. Benefits and drawbacks of adopting a secure programming language: rust as a case study. In: Proceedings of Proceedings of the Seventeenth USENIX Conference on Usable Privacy and Security, USA: USENIX Association, 2021
  66. Zhu S, Zhang Z, Qin B, et al. Learning and programming challenges of rust: a mixed-methods study. In: Proceedings of Proceedings of the 44th International Conference on Software Engineering, New York, NY, USA: Association for Computing Machinery, 2022. 1269–1281
  67. Kyriakou K I D, Tselikas N D, Kapitsaki G M. Enhancing c/c++ based oss development and discoverability with cbrjs: A rust/node. js/webassembly framework for repackaging legacy codebases. Journal of Systems and Software, 2019, 157: 110395
  68. Saligrama A, Shen A, Gjengset J. A practical analysis of rust’s concurrency story. arXiv preprint arXiv:1904.12210, 2019
  69. Williams A. Improving memory management, performance with rust: Why rust is becoming the programming language of choice for many high-level developers. Commun. ACM, 2024, URL https://doi.org/10.1145/3673648
  70. Bugden W, Alahmar A. Rust: The programming language for safety and performance. arXiv preprint arXiv:2206.05503, 2022
  71. Li H, Cogo F R, Bezemer C P. An empirical study of yanked releases in the rust package registry. IEEE Transactions on Software Engineering, 2022, 49: 437–449
  72. Tymofyeyev V, Fraser G. Search-based test suite generation for rust. In: Proceedings of Search-Based Software Engineering: 14th International Symposium, SSBSE 2022, Singapore, November 17–18, 2022, Proceedings, Berlin, Heidelberg: Springer-Verlag, 2022. 3–18
  73. Takashima Y, Martins R, Jia L, et al. Syrust: automatic testing of rust libraries with semantic-aware program synthesis. In: Proceedings of Proceedings of the 42nd ACM SIGPLAN International Conference on Programming Language Design and Implementation, New York, NY, USA: Association for Computing Machinery, 2021. 899–913
  74. Xu H. Rust library fuzzing. IEEE Software, 2022, 39: 105–108
  75. Crump A, Zhang D, Asif S M, et al. Crabsandwich: Fuzzing rust with rust (registered report). In: Proceedings of Proceedings of the 2nd International Fuzzing Workshop, New York, NY, USA: Association for Computing Machinery, 2023. 39–46
  76. Jiang J, Xu H, Zhou Y. Rulf: rust library fuzzing via api dependency graph traversal. In: Proceedings of Proceedings of the 36th IEEE/ACM International Conference on Automated Software Engineering. IEEE Press, 2022. 581–592
  77. Xu Z, Wu B, Wen C, et al. Rpg: Rust library fuzzing with pool-based fuzz target generation and generic support. In: Proceedings of Proceedings of the IEEE/ACM 46th International Conference on Software Engineering, New York, NY, USA: Association for Computing Machinery, 2024
  78. Zhang Y, Wu J, Xu H. Fuzz driver synthesis for rust generic apis, 2023
  79. Yin X, Feng Y, Shi Q, et al. Fries: Fuzzing rust library interactions via effcient ecosystem-guided target generation. In: Proceedings of Proceedings of the 33rd ACM SIGSOFT International Symposium on Software Testing and Analysis, 2024. 1137–1148
  80. Dewey K, Roesch J, Hardekopf B. Fuzzing the rust typechecker using clp. In: Proceedings of Proceedings of the 30th IEEE/ACM International Conference on Automated Software Engineering. IEEE Press, 2015. 482–493
  81. Xia X, Feng Y, Shi Q. Understanding bugs in rust compilers. In: Proceedings of 2023 IEEE 23rd International Conference on Software Quality, Reliability, and Security (QRS), 2023. 138-149
  82. Bae Y, Kim Y, Askar A, et al. Rudra: Finding memory safety bugs in rust at the ecosystem scale. In: Proceedings of Proceedings of the ACM SIGOPS 28th Symposium on Operating Systems Principles, New York, NY, USA: Association for Computing Machinery, 2021. 84–99
  83. Ouyang W, Hua B. Rusbox: Towards effcient and adaptive sandboxing for rust. In: Proceedings of 2021 IEEE International Symposium on Software Reliability Engineering Workshops (ISSREW), 2021. 1-233
  84. Chen C, Zhang Z, Tian H, et al. Oom-guard: Towards improving the ergonomics of rust oom handling via a reservation-based approach. In: Proceedings of Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium on the Foundations of Software Engineering, New York, NY, USA: Association for Computing Machinery, 2023. 733–744
  85. Zhang Y, Zhang K, Liu G. Static deadlock detection for rust programs, 2024
  86. Zhang Z, Qin B, Chen Y, et al. Vrlifetime – an ide tool to avoid concurrency and memory bugs in rust. In: Proceedings of Proceedings of the 2020 ACM SIGSAC Conference on Computer and Communications Security, New York, NY, USA: Association for Computing Machinery, 2020. 2085–2087
  87. Byrnes T, Takashima Y, Jia L. Automatically enforcing rust trait properties. In: Proceedings of Dimitrova R, Lahav O, Wolff S, editors, Verification, Model Checking, and Abstract Interpretation, Cham: Springer Nature Switzerland, 2024. 210–223
  88. Ouyang W, Hua B. ′R: Towards detecting and understanding code-document violations in rust. In: Proceedings of 2021 IEEE International Symposium on Software Reliability Engineering Workshops (ISSREW), 2021. 189-197
  89. Zhang Y, Liu Z, Feng Y, et al. Leveraging large language model to assist detecting rust code comment inconsistency. In: Proceedings of Proceedings of the 39th IEEE/ACM International Conference on Automated Software Engineering, New York, NY, USA: Association for Computing Machinery, 2024. 356–366
  90. Ardito L, Barbato L, Castelluccio M, et al. rust-code-analysis: A rust library to analyze and extract maintainability information from source codes. SoftwareX, 2020, URL https://www.sciencedirect.com/science/article/pii/S2352711020303484
  91. Lindgren P, Fitinghoff N, Aparicio J. Cargo-call-stack static call-stack analysis for rust. In: Proceedings of 2019 IEEE 17th International Conference on Industrial Informatics (INDIN), 2019. 1169-1176
  92. Lévai Z, McMinn P. Batching non-conflicting mutations for effcient, safe, parallel mutation analysis in rust. 2023. 49-59
  93. Lindner M, Aparicius J, Lindgren P. No panic! verification of rust programs by symbolic execution. In: Proceedings of 2018 IEEE 16th International Conference on Industrial Informatics (INDIN), 2018. 108-114
  94. Lindner M, Fitinghoff N, Eriksson J, et al. Verification of safety functions implemented in rust-a symbolic execution based approach. In: Proceedings of 2019 IEEE 17th International Conference on Industrial Informatics (INDIN). IEEE, 2019. 432–439
  95. Foroushaani N R, Jacobs B. Modular formal verification of rust programs with unsafe blocks, 2022
  96. VanHattum A, Schwartz-Narbonne D, Chong N, et al. Verifying dynamic trait objects in rust. In: Proceedings of Proceedings of the 44th International Conference on Software Engineering: Software Engineering in Practice, New York, NY, USA: Association for Computing Machinery, 2022. 321–330
  97. Matsushita Y, Tsukada T, Kobayashi N. Rusthorn: Chc-based verification for rust programs. ACM Trans. Program. Lang. Syst., 2021, URL https://doi.org/10.1145/3462205
  98. Matsushita Y, Denis X, Jourdan J H, et al. Rusthornbelt: a semantic foundation for functional verification of rust programs with unsafe code. In: Proceedings of Proceedings of the 43rd ACM SIGPLAN International Conference on Programming Language Design and Implementation, New York, NY, USA: Association for Computing Machinery, 2022. 841–856
  99. Astrauskas V, Bílý A, Fiala J, et al. The prusti project: Formal verification for rust. In: Proceedings of NASA Formal Methods: 14th International Symposium, NFM 2022, Pasadena, CA, USA, May 24–27, 2022, Proceedings, Berlin, Heidelberg: Springer-Verlag, 2022. 88–108
  100. Denis X, Jourdan J H, Marché C. Creusot: A foundry for the deductive verification of rust programs. In: Proceedings of Formal Methods and Software Engineering: 23rd International Conference on Formal Engineering Methods, ICFEM 2022, Madrid, Spain, October 24–27, 2022, Proceedings, Berlin, Heidelberg: Springer-Verlag, 2022. 90–105
  101. Wolff F, Bílý A, Matheja C, et al. Modular specification and verification of closures in rust. Proc. ACM Program. Lang., 2021, URL https://doi.org/10.1145/3485522
  102. Ho S, Protzenko J. Aeneas: Rust verification by functional translation. Proceedings of the ACM on Programming Languages, 2022, URL http://dx.doi.org/10.1145/3547647
  103. Astrauskas V, Müller P, Poli F, et al. Leveraging rust types for modular specification and verification. Proc. ACM Program. Lang., 2019, URL https://doi.org/10.1145/3360573
  104. Ijaz R, Boos K, Zhong L. Leveraging rust for lightweight os correctness. In: Proceedings of Proceedings of the 1st Workshop on Kernel Isolation, Safety and Verification, New York, NY, USA: Association for Computing Machinery, 2023. 1–8
  105. Dai Z, Liu S, Sjoberg V, et al. Verifying rust implementation of page tables in a software enclave hypervisor. In: Proceedings of Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 2, New York, NY, USA: Association for Computing Machinery, 2024. 1218–1232
  106. Hardin D S. Verification of a rust implementation of knuth’s dancing links using acl2. arXiv preprint arXiv:2311.08862, 2023
  107. Yao J, Zhou Z, Chen W, et al. Leveraging large language models for automated proof synthesis in rust, 2023
  108. Nowak T, Staniewski M, Grodzicki M, et al. Accelerating package expansion in rust through development of a semantic versioning tool, 2023
  109. Gülmez M, Nyman T, Baumann C, et al. Friend or foe inside? exploring in-process isolation to maintain memory safety for unsafe rust, 2023
  110. McCormack I, Sunshine J, Aldrich J. A study of undefined behavior across foreign function boundaries in rust libraries, 202434
  111. Yu Z, Song L, Zhang Y. Fearless concurrency? understanding concurrent programming safety in real-world rust software, 2019
  112. Park S, Cheng X, Kim T. Unsafe’s betrayal: Abusing unsafe rust in binary reverse engineering via machine learning, 2022
  113. Louka A, Dionysiou A, Athanasopoulos E. Validating memory safety in rust binaries. In: Proceedings of Proceedings of the 17th European Workshop on Systems Security, New York, NY, USA: Association for Computing Machinery, 2024. 8–14
  114. Thy S, Costea A, Gopinathan K, et al. Adventure of a lifetime: Extract method refactoring for rust. Proc. ACM Program. Lang., 2023, URL https://doi.org/10.1145/3622821
  115. Deligiannis P, Lal A, Mehrotra N, et al. Fixing rust compilation errors using llms, 2023
  116. Robati Shirzad M, Lam P. A study of common bug fix patterns in rust. Empirical Softw. Engg., 2024, URL https://doi.org/10.1007/s10664-023-10437-1
  117. Hu S, Hua B, Wang Y. Comprehensiveness, automation and lifecycle: A new perspective for rust security. In: Proceedings of 2022 IEEE 22nd International Conference on Software Quality, Reliability and Security (QRS), 2022. 982-991
  118. Qin B, Chen Y, Yu Z, et al. Understanding memory and thread safety practices and issues in real-world rust programs. In: Proceedings of Proceedings of the 41st ACM SIGPLAN Conference on Programming Language Design and Implementation, 2020. 763–779
  119. Xu H, Chen Z, Sun M, et al. Memory-safety challenge considered solved? an in-depth study with all rust cves. ACM Trans. Softw. Eng.Methodol., 2021, URL https://doi.org/10.1145/3466642
  120. Zheng X, Wan Z, Zhang Y, et al. A closer look at the security risks in the rust ecosystem, 2023
  121. Xu B, Chu B, Fan H, et al. An analysis of the rust programming practice for memory safety assurance. In: Proceedings of Yuan L, Yang S, Li R, et al., editors, Web Information Systems and Applications, Singapore: Springer Nature Singapore, 2023. 440–451
  122. Kevin Andrian Santoso O, Kwee C, Chua W, et al. Rust’s memory safety model: An evaluation of its effectiveness in preventing common vulnerabilities. Procedia Computer Science, 2023, URL https://www.sciencedirect.com/science/article/pii/S1877050923016757. 8th International Conference on Computer Science and Computational Intelligence (ICCSCI 2023)
  123. Császár I A, Slavescu R R. Building fast and reliable reverse engineering tools with frida and rust. In: Proceedings of 2022 IEEE 18th International Conference on Intelligent Computer Communication and Processing (ICCP). IEEE. 289–294. ISSN: 2766-8495
  124. Maiga A, Artho C, Gilcher F, et al. Does rust SPARK joy? safe bindings from rust to SPARK, applied to the BBQueue library.In: Proceedings of Proceedings of the 9th ACM SIGPLAN International Workshop on Formal Techniques for Safety-Critical Systems. Association for Computing Machinery. 37–47
  125. Küsters A, van der Aalst W M P. Developing a high-performance process mining library with java and python bindings in rust
  126. Reimert M M, Parry J D, Denwood M, et al. extendr: Frictionless bindings for R and rust. J. Open Source Softw., 2024, URL https://doi.org/10.21105/joss.06394
  127. Jeffrey A. Josephine: Using javascript to safely manage the lifetimes of rust data. arXiv preprint arXiv:1807.00067, 2018
  128. McCormack I, Sunshine J, Aldrich J. A study of undefined behavior across foreign function boundaries in rust libraries
  129. Xu H, Chen Z, Sun M, et al. Memory-safety challenge considered solved? an in-depth study with all rust CVEs
  130. Sharma A, Sharma S, Torres-Arias S, et al. Rust for embedded systems: Current state, challenges and open problems. arXiv preprint arXiv:2311.05063, 2023
  131. Hu S, Hua B, Xia L, et al. CRUST: Towards a unified cross-language program analysis framework for rust. In: Proceedings of 2022 IEEE 22nd International Conference on Software Quality, Reliability and Security (QRS). IEEE. 970–981
  132. Li Z, Wang J, Sun M, et al. Detecting cross-language memory management issues in rust. In: Proceedings of Atluri V, Di Pietro R, Jensen C D, et al., editors, Computer Security –ESORICS 2022. Springer Nature Switzerland. 680–700
  133. Schuermann L, Thomas A, Levy A. Encapsulated functions: Fortifying rust’s FFI in embedded systems. In: Proceedings of Proceedings of the 1st Workshop on Kernel Isolation, Safety and Verification. Association for Computing Machinery. 41–48
  134. Bang I, Kayondo M, Moon H, et al. {TRust}: A compilation framework for in-process isolation to protect safe rust against untrusted code. 6947–6964
  135. Emre M, Boyland P, Parekh A, et al. Aliasing limits on translating c to safe rust. Proc. ACM Program. Lang., 2023, URLhttps://doi.org/10.1145/3586046
  136. Zhang H, David C, Yu Y, et al. Ownership guided c to rust translation
  137. Emre M, Schroeder R, Dewey K, et al. Translating c to safer rust. URL https://dl.acm.org/doi/10.1145/3485498
  138. Tripuramallu D, Singh S, Deshmukh S, et al. Towards a transpiler for c/c++ to safer rust
  139. Larsen P. Migrating C to rust for memory safety. IEEE Secur. Priv., 2024, URL https://doi.org/10.1109/MSEC.2024.3385357
  140. Ling M, Yu Y, Wu H, et al. In rust we trust –a transpiler from unsafe c to safer rust. In: Proceedings of 2022 IEEE/ACM 44th International Conference on Software Engineering: Companion Proceedings (ICSE-Companion). IEEE. 354–355
  141. Han X, Hua B, Wang Y, et al. RUSTY: Effective c to rust conversion via unstructured control specialization. In: Proceedings of 2022 IEEE 22nd International Conference on Software Quality, Reliability, and Security Companion (QRS-C). 760–761. ISSN: 2693-9371
  142. Hong J, Ryu S. Concrat: An automatic c-to-rust lock API translator for concurrent programs
  143. Hong J, Ryu S. Type-migrating c-to-rust translation using a large language model. Empir. Softw. Eng., 2025, URL https://doi.org/10.1007/s10664-024-10573-2
  144. Olivier L, Sauvětre L A, Bousse E, et al. A tool-assisted approach to engineer domain-specific languages (DSLs) using rust. In:35 Proceedings of Proceedings of the 25th International Conference on Model Driven Engineering Languages and Systems: Companion Proceedings. Association for Computing Machinery. 712–721
  145. Lunnikivi H, Jylkkä K, Hämäläinen T. Transpiling python to rust for optimized performance. In: Proceedings of Orailoglu A, Jung M, Reichenbach M, editors, Embedded Computer Systems: Architectures, Modeling, and Simulation. Springer International Publishing. 127–138
  146. Lafrance A, Detweiler D, Li Z, et al. Extending rust with support for zero copy communication. In: Proceedings of Proceedings of the 12th Workshop on Programming Languages and Operating Systems, 2023. 74–82
  147. Li C, Yu Y, Wu H, et al. Unleashing the power of clippy in real-world rust projects. In: Proceedings of Proceedings of the 2024 IEEE/ACM 46th International Conference on Software Engineering: Companion Proceedings, New York, NY, USA: Association for Computing Machinery, 2024. 318–319
  148. Lin H, Chen P, Hwang Y S, et al. Devise rust compiler optimizations on risc-v architectures with simd instructions. In: Proceedings of Workshop Proceedings of the 48th International Conference on Parallel Processing, 2019. 1–7
  149. Coblenz M, Mazurek M L, Hicks M. Garbage collection makes rust easier to use: a randomized controlled trial of the bronze garbage collector. In: Proceedings of Proceedings of the 44th International Conference on Software Engineering, New York, NY, USA: Association for Computing Machinery, 2022. 1021–1032
  150. Dreissig F, Röckl J, Müller T. Compiler-aided development of trusted enclaves with rust. In: Proceedings of Proceedings of the 17th International Conference on Availability, Reliability and Security, 2022. 1–10
  151. Lehmann N, Geller A T, Vazou N, et al. Flux: Liquid types for rust. Proc. ACM Program. Lang., 2023, URL https://doi.org/10.1145/3591283
  152. Duarte J, Ravara A. Retrofitting typestates into rust. In: Proceedings of Proceedings of the 25th Brazilian Symposium on Programming Languages, New York, NY, USA: Association for Computing Machinery, 2021. 83–91
  153. Liu P, Zhao G, Huang J. Securing unsafe rust programs with xrust. In: Proceedings of Proceedings of the ACM/IEEE 42nd International Conference on Software Engineering, New York, NY, USA: Association for Computing Machinery, 2020. 234–245
  154. Harris S, Cooksey S, Vollmer M, et al. Rust for Morello: Always-On Memory Safety, Even in Unsafe Code. In: Proceedings of AliK, Salvaneschi G, editors, 37th European Conference on Object-Oriented Programming (ECOOP 2023), Dagstuhl, Germany: Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 2023. 39:1–39:27
  155. Li C, Wu Y, Shen W, et al. Demystifying compiler unstable feature usage and impacts in the rust ecosystem. In: Proceedings of Proceedings of the 46th IEEE/ACM International Conference on Software Engineering, 2024. 1–13
  156. Lamowski B, Weinhold C, Lackorzynski A, et al. Sandcrust: Automatic sandboxing of unsafe components in rust. In: Proceedings of Proceedings of the 9th Workshop on Programming Languages and Operating Systems, 2017. 51–57
  157. Luo G, Reddy V, Almeida M, et al. Rustviz: Interactively visualizing ownership and borrowing. arXiv preprint arXiv:2011.09012, 2020
  158. Zhang Z, Qin B, Chen Y, et al. Vrlifetime–an ide tool to avoid concurrency and memory bugs in rust. In: Proceedings of Proceedings of the 2020 ACM SIGSAC Conference on Computer and Communications Security, 2020. 2085–2087
  159. Wang R, Maclaren M, Coblenz M. Revis: An error visualization tool for rust. arXiv preprint arXiv:2309.06640, 2023
  160. Sam G, Cameron N, Potanin A. Automated refactoring of rust programs. In: Proceedings of Proceedings of the Australasian Computer Science Week Multiconference, 2017. 1–9
  161. Astrauskas V, Bílỳ A, Fiala J, et al. The prusti project: Formal verification for rust. In: Proceedings of NASA Formal Methods Symposium. Springer, 2022. 88–108
  162. Ardito L, Ballario M, Valsesia M. Research, implementation and analysis of source code metrics in rust-code-analysis. In: Proceedings of 2023 IEEE 23rd International Conference on Software Quality, Reliability, and Security (QRS). IEEE, 2023. 497–506
  163. Nowak T, Staniewski M, Grodzicki M, et al. Accelerating package expansion in rust through development of a semantic versioning tool. arXiv preprint arXiv:2308.14623, 2023
  164. Li C, Yu Y, Wu H, et al. Unleashing the power of clippy in real-world rust projects. In: Proceedings of Proceedings of the 2024 IEEE/ACM 46th International Conference on Software Engineering: Companion Proceedings, 2024. 318–319
  165. Lagaillardie N, Hou P, Yoshida N. Fearless asynchronous communications with timed session types in rust (artifact). 2024
  166. Jespersen T B L, Munksgaard P, Larsen K F. Session types for rust. In: Proceedings of Proceedings of the 11th acm sigplan workshop on generic programming, 2015. 13–22
  167. Kokke W. Rusty variation: deadlock-free sessions with failure in rust. arXiv preprint arXiv:1909.05970, 2019
  168. Cutner Z, Yoshida N, Vassor M. Deadlock-free asynchronous message reordering in rust with multiparty session types. In: Proceedings of Proceedings of the 27th ACM SIGPLAN Symposium on Principles and Practice of Parallel Programming, 2022. 246–261
  169. Couprie G. Nom, a byte oriented, streaming, zero copy, parser combinators library in rust. In: Proceedings of 2015 IEEE Security and Privacy Workshops. IEEE, 2015. 142–148
  170. Mackenzie J, Petri M, Gallagher L. Ioqp: A simple impact-ordered query processor written in rust. In: Proceedings of CEUR Workshop Proceedings. Rheinisch-Westfaelische Technische Hochschule Aachen, 2022. 22–34
  171. Küsters A, van der Aalst W M. Developing a high-performance process mining library with java and python bindings in rust. arXiv preprint arXiv:2401.14149, 202436
  172. Steer B, Arnold N, Ba C T, et al. Raphtory: The temporal graph engine for rust and python. arXiv preprint arXiv:2306.16309, 2023
  173. Pieper R, Griebler D, Fernandes L G. Structured stream parallelism for rust. In: Proceedings of Proceedings of the XXIII Brazilian Symposium on Programming Languages, 2019. 54–61
  174. Pieper R, Löff J, Hoffmann R B, et al. High-level and effcient structured stream parallelism for rust on multi-cores. Journal of Computer Languages, 2021, 65: 101054
  175. Höffner K, Baccaert T. hdt-rs: A rust library for the header dictionary triples binary rdf compression format. Journal of Open Source Software, 2023, 8: 5114
  176. Besozzi V. Ppl: Structured parallel programming meets rust. In: Proceedings of 2024 32nd Euromicro International Conference on Parallel, Distributed and Network-Based Processing (PDP). IEEE, 2024. 78–87
  177. Mindermann K, Keck P, Wagner S. How usable are rust cryptography apis? In: Proceedings of 2018 IEEE International Conference on Software Quality, Reliability and Security (QRS). IEEE, 2018. 143–154
  178. Barchi F, Pasini G, Parisi E, et al. Rust-encoded stream ciphers on a risc-v parallel ultra-low-power processor. In: Proceedings of 14th Workshop on Parallel Programming and Run-Time Management Techniques for Many-Core Architectures and 12th Workshop on Design Tools and Architectures for Multicore Embedded Computing Platforms (PARMA-DITAM 2023). Schloss-Dagstuhl-Leibniz Zentrum für Informatik, 2023
  179. da Silva P D S, Campos R O, Rocha C. Oss scripting system for game development in rust. In: Proceedings of Open Source Systems: 17th IFIP WG 2.13 International Conference, OSS 2021, Virtual Event, May 12–13, 2021, Proceedings 17. Springer, 2021. 51–58
  180. Corrado J, Harmon J J, Ilic M M, et al. Fem_2d: A rust package for 2d finite element method computations with extensive support for hp-refinement. Journal of Open Source Software, 2023, 8: 4172
  181. Ritter F, Rode A, Schmalen L. Introducing rsess: An open source enumerative sphere shaping implementation coded in rust. arXiv preprint arXiv:2402.08771, 2024
  182. Blinowski G, Szaknis M. Fuzzing trusted execution environments with rust. Computers & Security, 2024, page 104196
  183. Anderson B, Bergstrom L, Herman D, et al. Experience report: Developing the servo web browser engine using rust. arXiv preprint arXiv:1505.07383, 2015
  184. Anderson B, Bergstrom L, Goregaokar M, et al. Engineering the servo web browser engine using rust. In: Proceedings of Proceedings of the 38th International Conference on Software Engineering Companion, 2016. 81–89
  185. Uzlu T, Saykol E. Utilizing rust programming language for efi-based bootloader design. In: Proceedings of RTA-CSIT, 2016. 100–106
  186. Levy A, Campbell B, Ghena B, et al. The case for writing a kernel in rust. In: Proceedings of Proceedings of the 8th Asia-Pacific Workshop on Systems, 2017. 1–7
  187. Hu K, Wang L, Mo C, et al. Work-in-progress: Unishyper, a reliable rust-based unikernel for embedded scenarios. In: Proceedings of Proceedings of the International Conference on Embedded Software, 2023. 13–14
  188. Chen S F, Wu Y S. Linux kernel module development with rust. In: Proceedings of 2022 IEEE Conference on Dependable and Secure Computing (DSC). IEEE, 2022. 1–2
  189. Li L, Zhang Q, Zhao S, et al. Design and implementation of oom module based on rust. In: Proceedings of 2022 IEEE 22nd International Conference on Software Quality, Reliability, and Security Companion (QRS-C). IEEE, 2022. 774–775
  190. Chen X, Li Z, Mesicek L, et al. Atmosphere: Towards practical verified kernels in rust. In: Proceedings of Proceedings of the 1st Workshop on Kernel Isolation, Safety and Verification, 2023. 9–17
  191. Gonzalez A, Mvondo D, Bromberg Y D. Takeaways of implementing a native rust udp tunneling network driver in the linux kernel. In: Proceedings of Proceedings of the 12th Workshop on Programming Languages and Operating Systems, 2023. 18–25
  192. Li L, Zhang Q, Xu Z, et al. room: A rust-based linux out of memory kernel component. IEICE TRANSACTIONS on Information and Systems, 2024, 107: 245–256
  193. Almohri H M, Evans D. Fidelius charm: Isolating unsafe rust code. In: Proceedings of Proceedings of the Eighth ACM Conference on Data and Application Security and Privacy, 2018. 248–255
  194. Lankes S, Breitbart J, Pickartz S. Exploring rust for unikernel development. In: Proceedings of Proceedings of the 10th Workshop on Programming Languages and Operating Systems, 2019. 8–15
  195. Jothibasu K, Banda G. Harsark-rs: hard safe real-time kernel in rust. In: Proceedings of Intelligent Environments 2020, pages 62–71. IOS Press, 2020
  196. Culic I, Vochescu A, Radovici A. A low-latency optimization of a rust-based secure operating system for embedded devices. Sensors, 2022, 22: 8700
  197. Mo C, Wang L, Li S, et al. Rust-shyper: A reliable embedded hypervisor supporting vm migration and hypervisor live-update. Journal of Systems Architecture, 2023, 142: 102948
  198. Windsor B, Choi K. Thistle: A vector database in rust. arXiv preprint arXiv:2303.16780, 2023
  199. Blanco-Cuaresma S, Bolmont E. What can the programming language rust do for astrophysics? Proceedings of the International Astronomical Union, 2016, 12: 341–344
  200. Antelmi A, Cordasco G, D’ Auria M, et al. On evaluating rust as a programming language for the future of massive agent-based simulations. In: Proceedings of Methods and Applications for Modeling and Simulation of Complex Systems: 19th Asia Simulation37 Conference, AsiaSim 2019, Singapore, October 30–November 1, 2019, Proceedings 19. Springer, 2019. 15–28
  201. Dzialo P, Boom E V, Lindgren P. Syncrim-a modern simulator for synchronous circuits implemented in rust. In: Proceedings of 2023 IEEE Nordic Circuits and Systems Conference (NorCAS). IEEE, 2023. 1–6
  202. Frez K, Oyarzún M, Inostrosa-Psijas A, et al. Rustsim: A process-oriented simulation framework for the rust language. In: Proceedings of 2023 Winter Simulation Conference (WSC). IEEE, 2023. 3118–3129
  203. Cimler R, Doležal O, Pscheidl P. Comparison of rust and c# as a tool for creation of a large agent-based simulation for population prediction of patients with alzheimer’ s disease in eu. In: Proceedings of Computational Collective Intelligence: 8th International Conference, ICCCI 2016, Halkidiki, Greece, September 28-30, 2016. Proceedings, Part II 8. Springer, 2016. 252–261
  204. Shin H, Ock J, No H, et al. A comparative analysis of rust-based sgx frameworks: Implications for building sgx applications. In: Proceedings of International Conference on Information Security and Cryptology. Springer, 2023. 3–19
  205. Bitar M. Rust and julia for scientific computing. Computing in Science & Engineering, 2024, 26: 72–76
  206. Praveen M, Almobaideen W. The current state of research on malware written in the rust programming language. In: Proceedings of 2023 International Conference on Information Technology (ICIT). IEEE, 2023. 266–270
  207. Ding Y, Duan R, Li L, et al. Poster: Rust sgx sdk: Towards memory safety in intel sgx enclave. In: Proceedings of Proceedings of the 2017 ACM SIGSAC Conference on Computer and Communications Security, 2017. 2491–2493
  208. Wang H, Wang P, Ding Y, et al. Towards memory safe enclave programming with rust-sgx. In: Proceedings of Proceedings of the 2019 ACM SIGSAC Conference on Computer and Communications Security, 2019. 2333–2350
  209. Julku J, Kylänpää M. Towards a rust sdk for keystone enclave application development. In: Proceedings of ICISSP, 2023. 29–37
  210. Rinaldi L, Torquati M, Danelutto M. Enforcing reference capability in fastflow with rust. In: Proceedings of Parallel Computing: Technology Trends, pages 396–405. IOS Press, 2020
  211. Fazio B, Kozlowski E, Ochoa D, et al. Survey of parallel a* in rust. arXiv preprint arXiv:2105.03573, 2021
  212. Michinaka T, Kawabata H, Hironaka T. Rumpfr: A fast and memory leak-free rust binding to the gnu mpfr library. Journal of Information Processing, 2021, 29: 676–684
  213. Langlands A, Titley L, Nelson O. Rust for visual effects. In: Proceedings of The Digital Production Symposium, 2021. 1–6
  214. Dahl D B. Writing r extensions in rust. arXiv preprint arXiv:2108.07179, 2021
  215. Császár I A, Slavescu R R. Building fast and reliable reverse engineering tools with frida and rust. In: Proceedings of 2022 IEEE 18th International Conference on Intelligent Computer Communication and Processing (ICCP). IEEE, 2022. 289–294
  216. Olivier L, Sauvětre L A, Bousse E, et al. A tool-assisted approach to engineer domain-specific languages (dsls) using rust. In: Proceedings of Proceedings of the 25th International Conference on Model Driven Engineering Languages and Systems: Companion Proceedings, 2022. 712–721
  217. Lafage R. egobox, a rust toolbox for effcient global optimization. Journal of Open Source Software, 2022, 7: 4737
  218. Olivier L, Del Fabro M D, Mraidha C, et al. Towards an end-to-end metamodeling approach using rust. In: Proceedings of 2023 ACM/IEEE International Conference on Model Driven Engineering Languages and Systems Companion (MODELS-C). IEEE, 2023. 381–390
  219. Wan S, Sun M, Sun K, et al. Rustee: developing memory-safe arm trustzone applications. In: Proceedings of Proceedings of the 36th Annual Computer Security Applications Conference, 2020. 442–453
  220. Park S, Cheng X, Kim T. Unsafe’s betrayal: Abusing unsafe rust in binary reverse engineering via machine learning. arXiv preprint arXiv:2211.00111, 2022
  221. Duarte J, Ravara A. Taming stateful computations in rust with typestates. Journal of Computer Languages, 2022, 72: 101154
  222. Schubert E, Lenssen L. Fast k-medoids clustering in rust and python. Journal of Open Source Software, 2022, 7: 4183
  223. Dang H H, Jourdan J H, Kaiser J O, et al. Rustbelt meets relaxed memory. Proceedings of the ACM on Programming Languages, 2019, 4: 1–29
  224. Matsui S, Kamimae K, Ikehara H, et al. Rust-based memory-safe design of soc fpga unmanned mobile vehicles. In: Proceedings of 2024 IEEE International Conference on Consumer Electronics (ICCE). IEEE, 2024. 1–2
  225. Carneiro M. Reimplementing mizar in rust. arXiv preprint arXiv:2304.08391, 2023
  226. Hardin D. Hardware/software co-assurance using the rust programming language and acl2. arXiv preprint arXiv:2205.11709, 2022
  227. Le Goues C, Nguyen T, Forrest S, et al. Genprog: A generic method for automatic software repair. IEEE Transactions on Software Engineering, 2012, 38: 54–72
  228. Jiang J, Xiong Y, Zhang H, et al. Shaping program repair space with existing patches and similar code. 2018
  229. javapathfinder/jpf-core: Jpf is an extensible software analysis framework for java bytecode. jpf-core is the basis for all jpf projects; you always need to install it. it contains the basic vm and model checking infrastructure, and can be used to check for concurrency defects like deadlocks, and unhandled exceptions like nullpointerexceptions and assertionerrors. [Online; accessed 2025-02-24]
  230. Correnson L, Cuoq P, Kirchner F, et al. Frama-C User Manual
  231. Hovemeyer D, Pugh W. Finding more null pointer bugs, but not too many. In: Proceedings of Proceedings of the 7th ACM SIGPLANSIGSOFT Workshop on Program Analysis for Software Tools and Engineering, New York, NY, USA: Association for Computing Machinery, 2007. 9–1438
  232. to Wikimedia projects C. Checkmarx - wikipedia, 9 2020. [Online; accessed 2025-02-24]
  233. Threadsanitizer —clang 21.0.0git documentation. [Online; accessed 2025-02-24]
  234. ej-technologies. [Online; accessed 2025-02-24]
  235. Drewry W, Ormandy T. Flayer: Exposing application internals. In: Proceedings of First USENIX Workshop on Offensive Technologies (WOOT 07), Boston, MA: USENIX Association, 2007
  236. gperftools/gperftools: Main gperftools repository. [Online; accessed 2025-02-24]
  237. Tan G, Appel A W, Chakradhar S, et al. Safe java native interface. In: Proceedings of ISSSE. Citeseer, 2006
  238. Sun C, Le V, Su Z. Finding compiler bugs via live code mutation. SIGPLAN Not., 2016, URL https://doi.org/10.1145/3022671.2984038
  239. Li S, Su Z. Ubfuzz: Finding bugs in sanitizer implementations. In: Proceedings of Proceedings of the 29th ACM International Conference on Architectural Support for Programming Languages and Operating Systems, Volume 1, New York, NY, USA: Association for Computing Machinery, 2024. 435–449
  240. Ou X, Li C, Jiang Y, et al. The mutators reloaded: Fuzzing compilers with large language model generated mutation operators. ASPLOS, 2024
  241. Rust hello world binary file size is huge - help - the rust programming language forum, 1 2021. [Online; accessed 2024-12-30]
  242. BitTickler. Why are rust executables so huge? - stack overflow, 3 2015. [Online; accessed 2024-12-30]
  243. Codegen options - the rustc book. [Online; accessed 2024-12-30]
  244. johnthagen/min-sized-rust: How to minimize rust binary size. [Online; accessed 2024-12-30]

Advancements in Software Engineering Techniques and Language Evolution in Rust: A Comprehensive Review ​

Author: Feng Yang, Associate Professor and Doctoral Supervisor at the School of Computer Science, Nanjing University

Address: State Key Laboratory for Novel Software Technology, Nanjing University, Nanjing 210023, China

Abstract ​

Rust has emerged as a powerful systems programming language, combining performance with guarantees of memory safety. This review systematically surveys five interrelated research domains that underpin Rust’ s growth and maturity: (1) language analysis and extension, including formal semantics, type-system refinements, and domain-specific DSLs; (2) program quality assurance, covering advanced testing, fuzzing, static and dynamic analysis, and formal verification techniques; (3) cross-language programming, encompassing Foreign Function Interface (FFI) integration and transpilation strategies; (4) compiler construction and optimization, with MIR-based and LLVM-backed passes, type-level safety enhancements, and hardware-assisted memory protections; and (5) open-source ecosystem development, highlighting the proliferation of libraries, tooling, and application frameworks. For each area, we synthesize key advancements—such as ownership-driven verification, automated refactoring via LLMs, adaptive compiler architectures, and enclave-based isolation—while critically examining limitations in scalability, usability, and interoperability. We conclude by identifying emerging trends, including AI-augmented proof synthesis, unified safety frameworks, and dynamic optimization techniques, and propose a roadmap to address current gaps, guiding future efforts toward more robust, effcient, and broadly adoptable Rust solutions.

Keywords ​

Rust, literature review, programming language, software engineering