Where is Oli?

About me: nikomatsakis

About me: I am evil

I plan to mercilessly show you his private notes, at least when they're endearing.

About you

Hopefully you are not here to play Rust the game…

About you

You're here because you

• want to analyze Rust code
• are analyzing Rust code

Oli's notes to himself

"oh boy, let me tell you about my PhD thesis which is just about that topic"

• So you should ask him! But in a few weeks, once the baby is grown up and functional and the parents' lives have more or less gone back to normal.

Effects of DRY

• compiler and tool are in sync
• the compiler does parsing, type checking, etc.
• the compiler's APIs get improved

Example error message

via GIPHY

get rustc as a lib

rustup component add rustc-dev llvm-tools-preview

Unstable stuff

#![feature(rustc_private)]
#![deny(rustc::internal)]
extern crate rustc_driver;
extern crate rustc_interface;
extern crate rustc_errors;
extern crate rustc_lint;

At present, the API is forever unstable, use at your own risk

fn main() -> Result<(), rustc_errors::ErrorReported> {
    
    
    
}

fn main() -> Result<(), rustc_errors::ErrorReported> {
    let args: Vec<_> = std::env::args().collect();
    
    
}

fn main() -> Result<(), rustc_errors::ErrorReported> {
    let args: Vec<_> = std::env::args().collect();
    let mut my_cb = MyCallbacks;
    
}

fn main() -> Result<(), rustc_errors::ErrorReported> {
    let args: Vec<_> = std::env::args().collect();
    let mut my_cb = MyCallbacks;
    rustc_driver::RunCompiler::new(&args, &mut my_cb).run()
}

You have now reproduced rustc. You rock!

Too bad people could already run rustc.

Callbacks

impl rustc_driver::Callbacks for MyCallbacks {
    fn config(&mut self, config: &mut Config) {
    
    
    
    
    
    }
}

Callbacks

impl rustc_driver::Callbacks for MyCallbacks {
    fn config(&mut self, config: &mut Config) {
        config.register_lints = Some(Box::new(|_, ls| {
        
        
        
        }));
    }
}

Callbacks

impl rustc_driver::Callbacks for MyCallbacks {
    fn config(&mut self, config: &mut Config) {
        config.register_lints = Some(Box::new(|_, ls| {
            lint_store.register_late_pass(|| {
            
            })
        }));
    }
}

Callbacks

impl rustc_driver::Callbacks for MyCallbacks {
    fn config(&mut self, config: &mut Config) {
        config.register_lints = Some(Box::new(|_, ls| {
            lint_store.register_late_pass(|| {
                Box::new(MyLint)
            })
        }));
    }
}

A (very) brief tour of rustc's IRs

graph LR

.rs --> AST;
AST --Macro expansion--> AST;
AST --> HIR;
HIR --Type checking--> HIR;
HIR --> MIR;
MIR --Optimization--> MIR;
MIR --> LLVM;
LLVM --Dear god who knows--> LLVM;
LLVM --> .exe;

• AST, pre-expansion: Just what the user wrote
• AST, post-expansion: Macros expanded
• HIR: High-level IR, an AST but with names resolved etc
  • Type-checking stores the info in "side tables"
• MIR: kind of like JVM byte-code for Rust
• LLVM: very low-level

LintPass(es)

impl<'tcx> rustc_lint::LateLintPass<'tcx> for MyLint {
    fn check_expr(
        &mut self,
        cx: &rustc_lint::LateContext<'tcx>,
        expr: &rustc_hir::Expr<'tcx>,
    ) {
        // Static analysis goes here
    }
}

An actual lint

if let rustc_hir::ExprKind::Binary(op, l, r) = expr {
    if l.kind == r.kind {
        // Complain loudly
    }
}

Not the code you really want, but gives you the idea:

• == compares too strictly
• maybe want to consider types
• needs diagnostics – check the rustc-dev-guide

Check the clippy version for something more realistic.

file_loader

• completely work on a VFS
• manipulate files before passing them to rustc

22 second introduction to queries

digraph {
    mir_built -> compute_hir
    layout_of -> typeck
    optimized_mir -> analyzed_mir -> mir_built
    const_eval -> mir_for_ctfe -> analyzed_mir
    codegen -> optimized_mir -> layout_of
    codegen -> const_eval -> layout_of
    late_lints -> compute_hir
    typeck -> compute_hir
}

override_queries

• access to original query
• insert new query
  • modify input
  • modify output
  • completely replace

Examples of queries to override

• modify layout computation: layout_of
• inject MIR optimizations: optimized_mir
• access MIR before borrowck: mir_built
• inject additional items for codegen

miri

• a driver
• heavily manipulates command line args
• uses after-analysis callback
  • finds __start symbol
  • starts evaluation at that symbol
• uses rustc_mir::interpret
  • also used by CTFE
  • generic MIR interpretation system

cranelift

• a codegen backend
• calls compiler queries
• independent codegen framework

Library-ification

• split parts of the compiler out into crates.io
  • allow them to be reused for many purposes
• example crates:
  • chalk – handles trait solving
  • polonius – handles borrow checker
• rust-analyzer uses chalk, for example
• working towards a generic definition of Rust types that includes full Rust static analysis
  • you can help!

Summary

• rustc is a library
• we want to make it more of a library
• incrementally create your own compiler
• mentoring available for contributing