Rust Programming Language / rustc lecture series

No description provided.

Niko and Jack Huey walking through how caching of trait evaluation works. The context is explaining PR #85186.

Discussed how the current borrow checker tracks moves and initialization and how to move that logic to polonius.

Dropbox paper link:

https://paper.dropbox.com/doc/Polonius-and-initialization--AeKw2KzJcfEftnZDZ5C9cV8iAg-mNvR4jqITCdsJDUMEhFbv

This discussion covers how types are represented in rustc. It discusses the `Ty` type, generics and substitution, and type folding.

The Dropbox paper document that is being shared in the video can be found here:

https://paper.dropbox.com/doc/Ty-lecture--Ab8REO0WfNUvsZSb3L~DliFvAg-8hOUpAEhOvoBQC5EYXKJM

A discussion of how the chalk-engine crate works.

cramertj and nikomatsakis discuss changes to the region inferencer to try and overcome some of the limitations from https://github.com/rust-lang/rust/issues/56238. In the process, we uncover some strangeness.

Paper doc:

https://paper.dropbox.com/doc/Multiple-Unrelated-Lifetimes-in-Existential-Types--AbbZKR~LigYmDVvXErd4OO0~Ag-AuCQq4Ewy39j8Hnj3n9Qg

A pragmatic discussion about how to proceed integrating name resolution with Salsa and RLS 2.0.

An overview of the plans for rustc-chalk integration and some brief coverage of how it works in the code itself.

A walk through the rustc and Polonius code bases, showing how the two are connected.

Paper doc is viewable here: https://paper.dropbox.com/doc/Polonius-Walkthrough-2--AZVdfdGwg3j9xs693~KyChtnAg-Wr90dk3V5DQQem9duos4P

We discuss the overall strategy for implementing RFC #2229, pulling together a rough roadmap including a number of refactorings, and identifying some bits of work that can be done independently.

miri is an interpreter for MIR, Rust's internal representation. miri is the foundation for Rust's compile-time evaluation capabilities. Its design enables it to simulate the workings of the machine at a low-level, meaning that it can interpret not only "safe Rust" but also a lot of unsafe Rust code, including complex and highly optimized libraries like the stdlib hashmap. In this talk, compiler team member oli-obk will dig into how miri works, giving us some insight into its architecture, the way that it represents and reasons about memory, and what kinds of capabilities it offers for Rust itself.

flodiebold introduces how the rust-analyzer type checker works, and we discuss various possible next steps towards integrating chalk with RLS 2.0.

Meeting to discuss impl strategies for various outstanding async-await bugs.

The Dropbox Paper doc that we were using is available here:

https://paper.dropbox.com/doc/2019.02.26-impl-discussion-notes--AYcSQHRnxOOCEjqwYjqmcUjmAg-5v4Q2n9cRn2KYgVyWMphQ

@matklad walks us through how syntax trees are implemented in rust-analyzer.

Recorded 2019.02.26.

An overview of how higher-ranked types/trait-bounds (`for<'a> fn(&'a u32)` or `for<'a> T: Foo<'a>`) are implemented in rustc. Focuses on the idea of universes and placeholders and how those are used in subtyping.

The paper doc used in the video is readable here:

https://paper.dropbox.com/doc/Universes-and-57639--AXjnSUh91ZmbD0dDMwTTfFHfAg-vVrMCkndUoXzyrHCOQdq8

Or in gist form:

https://gist.github.com/nikomatsakis/848f6bd0db706b1f0596e7e559588128

Dan Gohman explains the basic idea of the Cranelift code generator, covering the setup of the IR, the overall philosophy of its design, and some details of how it could be integrated with rustc.

The Dropbox Paper has been converted to a gist here:

https://gist.github.com/nikomatsakis/0bd497f157a40776216f37d8bbec25cd

Or, if you prefer, you can view the original document here (but it will record your e-mail, I believe):

https://paper.dropbox.com/doc/How-Salsa-Works-2019.01--AWnkDrrWoSyv0yfTleFeyGElAg-u8rQGbebYIxSA8r23muiN

You can view the DropBox paper document anonymously here:

https://gist.github.com/nikomatsakis/5b119a71465549b61743e8739a369b5e

Or you can view the original here:

https://paper.dropbox.com/doc/Salsa-In-More-Depth-2019.01--AWnTZTDJPJ_dsuLU7gIzZeHKAg-wYaiL8t72BdGGPFrnmt7h

Walk through the steps to convert the internal representation of closures to use a tuple for the upvar types. In the process, explain a lot about how closures work in rustc itself.

The talk gives a high-level overview of how Rust integration with gdb, lldb, and so forth work. It discusses some of the steps that are needed to add extensions to the DWARF standard for Rust-specific features.

Speaker: Tom Tromey, who added Rust support to gdb, and implemented the rust-lldb debugger.

A walk-through of the rust-analyzer implementation, which talks about implementing compiler-driven completion for IDEs.

rust-analyzer: https://github.com/rust-analyzer/rust-analyzer
transcript of the talk: https://github.com/rust-analyzer/rust-analyzer/pull/578

Discussing how to refactor the way closure upvar types are represented with @blitzerr.

Discussing how closure desugaring and upvar inference works in rustc today with blitzerr on 2018-10-30

This video was recorded during the Bay Area Rust Meetup in San Francisco, CA, USA on June 28, 2018.

https://www.meetup.com/Rust-Bay-Area/events/251073767/

Sunjay Varma presented an overview of his work on Chalk, the new trait-solving implementation in the Rust Compiler. He talked about the concept of coherence in the Rust language, described how it is implemented in rustc today, and then covered how he has implemented it in Chalk using logic programming.

Talk written and presented by:
Sunjay Varma (https://twitter.com/sunjay03)