• Corpus ID: 67855475

Oxide: The Essence of Rust

@article{Weiss2019OxideTE,
  title={Oxide: The Essence of Rust},
  author={Aaron Weiss and Daniel Patterson and Nicholas D. Matsakis and Amal Ahmed},
  journal={ArXiv},
  year={2019},
  volume={abs/1903.00982}
}
Rust is a major advancement in industrial programming languages due in large part to its success in bridging the gap between low-level systems programming and high-level application programming. [] Key Method This presentation takes a new view of lifetimes as approximate provenances of references, and our type system is able to automatically compute this information through a flow-sensitive substructural typing judgment for which we prove syntactic type safety using progress and preservation. The result is a…

Figures from this paper

Is Rust Used Safely by Software Developers?
TLDR
A large-scale empirical study to explore how software developers are using Unsafe Rust in real-world Rust libraries and applications concludes that although the use of the keyword unsafe is limited, the propagation of unsafeness offers a challenge to the claim of Rust as a memory-safe language.
Translating C to safer Rust
TLDR
This paper presents the first empirical study of unsafety in translated Rust programs (as opposed to programs originally written in Rust) and also the first technique for automatically removing causes of uns safety in translatedRust programs.
A Lightweight Formalism for Reference Lifetimes and Borrowing in Rust
TLDR
This article presents a lightweight formalism that captures many aspects of Rust, including copy- and move-semantics, mutable borrowing, reborrowing, partial moves, and lifetimes, and provides a soundness proof to verify the key claims of the calculus.
Seamless deductive inference via macros
TLDR
This work uses Rust’s trait system to extend Datalog semantics with non-powerset lattices, much like Flix, and with user-defined data types much like Formulog and Souffle, and uses this extension to re-implement the Rust borrow checker.
Towards a Formalization of Implicit Parallelism in Rust
TLDR
This thesis verifies the transformation of a subset of Rust to Ohua’s first intermediate representation and shows that the transformation preserves semantics for any correct Rust program.
The Move Borrow Checker
TLDR
The static analysis of the borrow checker is formalized and it is proved that it enjoys three desirable properties: absence of dangling references, referential transparency for immutable references, and absence of memory leaks.
SyRust: automatic testing of Rust libraries with semantic-aware program synthesis
TLDR
SyRust is implemented, a testing framework for Rust libraries that automatically synthesizes semantically valid test cases and develops a program synthesis technique for Rust library API testing, which relies on a novel logical encoding of typing constraints from Rust’s ownership type system.
Verifying Dynamic Trait Objects in Rust
TLDR
This paper focuses on the challenges in reasoning about Rust’s dynamic trait objects, a feature that provides dynamic dispatch for function abstractions and is the first symbolic modeling checking tool for Rust that can verify correctness while supporting the breadth of dynamic traits, including dynamically dispatched closures.
Safe, Flexible Aliasing with Deferred Borrows
In recent years, programming-language support for static memory safety has developed significantly. In particular, borrowing and ownership systems, such as the one pioneered by the Rust language,
Linear Promises: Towards Safer Concurrent Programming
TLDR
A new type system based on linear typing is introduced, and it is shown how it can be incorporated in a concurrent programming language to track ownership of promises to guarantee exactly one write operation is ever performed on any given promise.
...
1
2
3
...

References

SHOWING 1-10 OF 63 REFERENCES
Rust Distilled: An Expressive Tower of Languages
TLDR
This work on designing a formal semantics for Rust that captures ownership and borrowing without the details of lifetime analysis is described, which models a high-level understanding of ownership and as a result is close to source-level Rust (but with full type annotations) which differs from the recent RustBelt effort.
KRust: A Formal Executable Semantics of Rust
TLDR
A formal executable operational semantics of a subset of Rust, called KRust, which yields automatically a formal interpreter and verification tools for Rust programs and has been validated by testing with 182 tests.
RustBelt: securing the foundations of the Rust programming language
TLDR
This paper gives the first formal (and machine-checked) safety proof for a language representing a realistic subset of Rust, and is extensible in the sense that, for each new Rust library that uses unsafe features, it can say what verification condition it must satisfy in order to be deemed a safe extension to the language.
Patina : A Formalization of the Rust Programming Language
TLDR
This model provides a syntactic version of the Borrow Checker, which may be more understandable than the non-syntactic version in Rust, and uses this model to prove the soudness of some core operations and justify the conjecture that the model, as a whole, is sound.
Short Paper: Rusty Types for Solid Safety
TLDR
This paper formally describes a small subset of the syntax, semantics, and type system of Metal, the authors' Rust-based language that enjoys Rusty Types, and presents Rusty Types and an accompanying type system, inspired by the Rust language, that enable memory-safe and race-free references through ownership and restricted aliasing in the type system.
Leveraging rust types for modular specification and verification
TLDR
This paper presents a novel verification technique that leverages Rust's type system to greatly simplify the specification and verification of system software written in Rust, and enables a new kind of verification tool, with the potential to impact a wide audience and allow the Rust community to benefit from state-of-the-art verification techniques.
Resource Polymorphism
TLDR
A resource-management model for ML-style programming languages, designed to be compatible with the OCaml philosophy and runtime model, and suggests that the Rust model for eliminating data-races applies.
Safe & Efficient Gradual Typing for TypeScript
TLDR
It is concluded that, at least during development and testing, subjecting JavaScript/TypeScript programs to safe gradual typing adds significant value to source type annotations at a modest cost.
K-Rust: An Executable Formal Semantics for Rust
TLDR
Through the construction of K-Rust, an executable formal semantics of Rust is introduced using K-Framework, which detected inconsistencies of the ownership mechanism between the Rust compiler and the specification in The Rust Programming Language.
Typed memory management in a calculus of capabilities
TLDR
A compiler intermediate language, called the Capability Calculus, is presented that supports region-based memory management, enjoys a provably safe type system, and is straightforward to compile to a typed assembly language.
...
1
2
3
4
5
...