Borrow and Ownership Error Code Catalog

fn consume(v: Vec<u32>) -> usize { v.len() }

fn main() {
    let v = vec![1, 2, 3];
    let n = consume(v);        // value moved here
    println!("{n} {}", v.len()); // E0382: borrow of moved value: `v`
}

fn count(v: &[u32]) -> usize { v.len() }       // 1. borrow: the callee does not need ownership

fn main() {
    let v = vec![1, 2, 3];
    let n = count(&v);
    println!("{n} {}", v.len());
}

fn main() {
    let mut s = String::from("a");
    let r1 = &mut s;
    let r2 = &mut s;   // E0499
    r1.push('b');
    r2.push('c');
}

fn main() {
    let mut s = String::from("a");
    let r1 = &mut s;
    r1.push('b');      // last use of r1
    let r2 = &mut s;
    r2.push('c');
}

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];
    v.push(4);                // E0502: push may reallocate and dangle `first`
    println!("{first}");
}

fn main() {
    let mut v = vec![1, 2, 3];
    let first = v[0];         // i32 is Copy: copy it out, no borrow kept
    v.push(4);
    println!("{first}");
}

fn main() {
    let mut value = 3;
    let borrow = &mut value;
    let sum = value + 1;      // E0503: reading `value` while `borrow` is live
    *borrow += sum;
}

fn main() {
    let mut value = 3;
    let sum = value + 1;
    let borrow = &mut value;
    *borrow += sum;
}

#[derive(Debug)]
struct Report { title: String, body: String }

fn publish(r: Report) { println!("{r:?}"); }

fn main() {
    let report = Report { title: "Q3".into(), body: "ok".into() };
    let title = &report.title;
    publish(report);          // E0505
    println!("published {title}");
}

#[derive(Debug)]
struct Report { title: String, body: String }

fn publish(r: Report) { println!("{r:?}"); }

fn main() {
    let report = Report { title: "Q3".into(), body: "ok".into() };
    let title = report.title.clone();  // small owned copy; or log before publishing
    publish(report);
    println!("published {title}");
}

fn main() {
    let mut best = String::from("a");
    let view = &best;
    best = String::from("b");   // E0506
    println!("{view}");
}

struct User { name: String, nickname: Option<String> }

fn display_name(u: &User) -> String {
    match u.nickname {           // E0507: cannot move out of `u.nickname` ... behind a shared reference
        Some(n) => n,
        None => u.name.clone(),
    }
}

struct User { name: String, nickname: Option<String> }

fn display_name(u: &User) -> &str {
    u.nickname.as_deref().unwrap_or(&u.name)   // borrow both: no allocation
}

fn take_nickname(u: &mut User) -> Option<String> {
    u.nickname.take()                          // through &mut: take and leave None
}

fn main() {
    let names = [String::from("a"), String::from("b")];
    // let first = names[0];          // E0508
    let first = &names[0];            // 1. borrow the element
    println!("{first}");
    let [a, b] = names;               // 2. or destructure to own every element (after the borrow ends)
    println!("{a} {b}");
}

struct Conn { addr: String }
impl Drop for Conn { fn drop(&mut self) { println!("closing {}", self.addr); } }

fn into_addr(mut c: Conn) -> String {
    // let Conn { addr } = c;            // E0509: Drop needs the whole value
    std::mem::take(&mut c.addr)          // leaves an empty String for drop() to see
}

fn label(id: u32) -> &'static str {
    let s = format!("order-{id}");
    &s                                  // E0515: cannot return reference to local variable `s`
}

use std::borrow::Cow;

fn label(id: u32) -> String { format!("order-{id}") }     // 1. return the owned value

fn trimmed(input: &str) -> &str { input.trim() }           // 2. borrow from an input instead

fn normalised(input: &str) -> Cow<'_, str> {               // 3. borrow when possible, allocate when needed
    if input.contains(' ') { Cow::Owned(input.replace(' ', "_")) } else { Cow::Borrowed(input) }
}

fn render(id: u32, out: &mut String) {                     // 4. caller owns the buffer
    use std::fmt::Write;
    write!(out, "order-{id}").unwrap();
}

fn main() {
    let r;
    {
        let s = String::from("hi");
        r = &s;                // E0597
    }                          // `s` dropped here while still borrowed
    println!("{r}");
}

use std::cell::RefCell;

fn len_2021() -> usize {
    let cell = RefCell::new(vec![1, 2, 3]);
    let n = cell.borrow().len();   // bind first: compiles in every edition
    n
    // `cell.borrow().len()` as the tail expression is E0597 in edition 2021 (the temporary `Ref`
    // lives until after `cell` is dropped) and compiles in edition 2024.
}

fn main() {
    let words: Vec<&str> = String::from("a b c").split(' ').collect(); // E0716
    println!("{words:?}");
}

use std::sync::Mutex;

fn main() {
    let text = String::from("a b c");                  // owner lives as long as `words`
    let words: Vec<&str> = text.split(' ').collect();
    println!("{words:?}");

    let names = Mutex::new(vec![String::from("x")]);
    let guard = names.lock().unwrap();                 // bind the guard, borrow from it
    let first: &str = &guard[0];
    println!("{first}");
}

use std::thread;

fn main() {
    let names = vec![String::from("a")];
    let h = thread::spawn(|| println!("{names:?}"));   // E0373
    h.join().unwrap();
}

struct Config { name: String }

fn start(cfg: &Config) {
    std::thread::spawn(move || println!("{}", cfg.name));   // E0521
}

use std::rc::Rc;

fn main() {
    let mut shared = Rc::new(vec![1, 2, 3]);
    let other = Rc::clone(&shared);
    Rc::make_mut(&mut shared).push(4);   // clones the Vec because `other` still shares it
    assert_eq!(*other, vec![1, 2, 3]);
    assert_eq!(*shared, vec![1, 2, 3, 4]);
}

fn parse(flag: bool) -> u32 {
    let port: u32;
    if flag { port = 8080; }
    port                       // E0381: possibly-uninitialized
}

fn parse(flag: bool) -> u32 {
    let port = if flag { 8080 } else { 80 };
    port
}

fn parse_opt(input: Option<&str>) -> Result<u32, String> {
    let Some(text) = input else { return Err("missing".into()) };   // let-else, 1.65+
    text.parse().map_err(|e| format!("{e}"))
}

pub struct Guard<'a> { data: &'a mut String }

impl Drop for Guard<'_> {
    fn drop(&mut self) { self.data.push_str(" (released)"); }
}

pub fn inner<'a>(g: Guard<'a>) -> &'a mut String {
    &mut *g.data                // E0713: drop(g) at the end needs exclusive access to *g.data
}

fn main() {
    let mut count = 0;
    let mut inc = || count += 1;
    // println!("{count}");      // E0502 here: `inc` holds a unique borrow until its last call
    inc();
    inc();
    println!("{count}");          // fine: `inc` is no longer used
}

fn bump(n: &mut u32) { *n += 1; }

fn main() {
    let mut n = 0;
    // bump(&n);            // E0308: expected `&mut u32`, found `&u32` (types differ in mutability)
    bump(&mut n);
    println!("{n}");
}

struct Store { items: Vec<String> }

impl Store {
    // fn find(&self, key: &str) -> &str { key }     // lifetime may not live long enough:
    //                                               // elision ties the output to &self, but we return `key`
    fn find<'k>(&self, key: &'k str) -> &'k str { key }
    fn first(&self) -> &str { &self.items[0] }       // borrowing from self: elision is right
}