beautifulsoups.dev
Published on

Rust E0502·E0499 소유권 오류 5분 해결법

Authors

Rust를 처음(혹은 오랜만에) 쓰면 가장 빨리 마주치는 벽이 빌림 검사기(borrow checker)입니다. 그중에서도 E0502(불변 빌림과 가변 빌림 충돌), E0499(가변 빌림이 동시에 두 번 발생)만 잡아도 체감 난이도가 확 내려갑니다.

이 글은 “왜 안 되는지”를 길게 설명하기보다, 에러를 5분 안에 해결하는 사고 순서와 코드 패턴을 제공합니다. 아래 예제는 모두 바로 복붙해서 cargo run 혹은 cargo test로 확인할 수 있게 구성했습니다.

참고로 이런 류의 문제는 원인이 명확한데도 로그/에러 메시지 때문에 길을 잃기 쉽습니다. CI에서 재현이 어려울 때는 캐시/동시성 같은 환경 요인도 함께 정리해두면 좋습니다. 예: GitHub Actions 캐시로 Node.js CI 2배 빠르게, 실패 디버깅

1) E0502·E0499 한 줄 정의(해석부터)

E0502: immutable borrow + mutable borrow가 겹침

  • 이미 어떤 값이 불변으로 빌려진 상태에서
  • 같은 값에 대해 가변 빌림을 시도할 때
  • 혹은 그 반대 순서로도 동일하게 발생

에러 메시지에서 핵심은 보통 이런 문장입니다.

  • cannot borrow ... as mutable because it is also borrowed as immutable

E0499: mutable borrow가 동시에 2개

  • 어떤 값에 대해 가변 빌림은 동시에 하나만 허용
  • 두 번째 &mut가 생기는 순간 E0499

에러 메시지에서 핵심은 보통 이런 문장입니다.

  • cannot borrow ... as mutable more than once at a time

2) 5분 해결 체크리스트(순서대로 보면 대부분 끝)

  1. 빌림의 “수명”이 어디까지 이어지는지 먼저 찾기
    • Rust는 “변수 스코프 끝”이 아니라 “마지막 사용 지점”까지 빌림이 이어질 수 있습니다(특히 NLL 이전 감각으로 보면 헷갈림).
  2. 충돌하는 참조가 있다면, 둘 중 하나를 스코프 밖으로 밀어내기
    • { ... } 블록으로 참조를 빨리 끝내기
  3. 참조 대신 값을 쓰도록 복사/클론/추출
    • Copy 타입이면 값 복사로 끝
    • 아니면 clone() 혹은 to_owned()로 소유권 있는 값 만들기
  4. 컨테이너를 동시에 만지면, 인덱싱을 줄이고 API를 바꾸기
    • Vec는 split_at_mut 같은 안전한 분할 API 사용
    • HashMap은 get_mut/entry로 한 번에 처리
  5. 정말로 “동시 가변 접근”이 필요하면, 내부 가변성(RefCell/Mutex/RwLock) 고려
    • 단, 이건 마지막 카드(런타임 비용/패닉/락 비용)

3) E0502 대표 패턴 4가지와 즉시 해결법

패턴 A: 불변 참조를 잡아둔 채로 수정

문제 코드

fn main() {
    let mut s = String::from("hello");

    let r = &s;        // 불변 빌림
    s.push('!');       // 가변 빌림 시도 -> E0502

    println!("{}", r);
}

해결 1: 불변 참조를 더 빨리 끝내기(스코프 분리)

fn main() {
    let mut s = String::from("hello");

    {
        let r = &s;
        println!("{}", r);
    } // 여기서 r의 빌림이 끝남

    s.push('!');
    println!("{}", s);
}

해결 2: 필요한 값만 복사/복제해서 참조를 없애기

fn main() {
    let mut s = String::from("hello");

    let snapshot = s.clone();
    s.push('!');

    println!("before: {}, after: {}", snapshot, s);
}

패턴 B: 불변 참조를 만든 뒤 같은 변수에 &mut를 만듦

문제 코드

fn main() {
    let mut v = vec![1, 2, 3];

    let a = &v[0];     // 불변 빌림
    let b = &mut v[1]; // 가변 빌림 -> E0502

    *b += 10;
    println!("{}", a);
}

해결: 인덱싱 대신 “분할” API 사용

Vec에서 서로 다른 원소를 동시에 가변/불변으로 다루려면, 슬라이스를 분리해 서로 다른 영역임을 컴파일러가 알게 해야 합니다.

fn main() {
    let mut v = vec![1, 2, 3];

    let (left, right) = v.split_at_mut(1);
    let a = left[0];        // 값 복사(i32는 Copy)
    let b = &mut right[0];  // 원래 v[1]

    *b += 10;
    println!("{}", a);
    println!("{:?}", v);
}

패턴 C: println!/로그 때문에 빌림이 길어짐

로그가 참조를 잡고 있는 동안, 아래에서 가변 접근을 하면 E0502가 납니다.

문제 코드

fn main() {
    let mut s = String::from("hello");

    let r = &s;
    // 디버깅하다가 아래에서 수정하려고 하면 충돌
    // println!("debug: {}", r);

    s.push_str(" world");
    println!("{}", r);
}

해결: 로그를 먼저 찍고 참조 사용을 끝내기

fn main() {
    let mut s = String::from("hello");

    {
        let r = &s;
        println!("debug: {}", r);
    }

    s.push_str(" world");
    println!("{}", s);
}

패턴 D: HashMap에서 get과 get_mut를 섞음

문제 코드

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::from([(String::from("a"), 1)]);

    let cur = m.get("a");        // 불변 빌림
    let cur_mut = m.get_mut("a"); // 가변 빌림 -> E0502

    if let Some(v) = cur_mut {
        *v += 1;
    }

    println!("{:?}", cur);
}

해결: entry로 한 번에 처리(가장 깔끔)

use std::collections::HashMap;

fn main() {
    let mut m = HashMap::new();

    *m.entry(String::from("a")).or_insert(0) += 1;

    println!("{:?}", m);
}

4) E0499 대표 패턴 4가지와 즉시 해결법

패턴 A: 같은 값에 &mut를 두 번

문제 코드

fn main() {
    let mut x = 0;

    let a = &mut x;
    let b = &mut x; // E0499

    *a += 1;
    *b += 1;
}

해결: 한 번에 끝내거나, 값을 합쳐서 한 번만 빌리기

fn main() {
    let mut x = 0;

    {
        let a = &mut x;
        *a += 1;
    }

    {
        let b = &mut x;
        *b += 1;
    }

    println!("{}", x);
}

패턴 B: Vec의 두 원소를 동시에 &mut로 잡기

문제 코드

fn main() {
    let mut v = vec![10, 20, 30];

    let a = &mut v[0];
    let b = &mut v[1]; // E0499 (인덱싱은 분리 증명이 안 됨)

    *a += 1;
    *b += 1;
}

해결: split_at_mut로 안전 분할

fn main() {
    let mut v = vec![10, 20, 30];

    let (left, right) = v.split_at_mut(1);
    let a = &mut left[0];
    let b = &mut right[0];

    *a += 1;
    *b += 1;

    println!("{:?}", v);
}

패턴 C: 반복문에서 가변 참조를 오래 들고 있음

반복 중에 &mut를 잡고, 같은 컨테이너를 또 접근하려 하면 흔히 E0499가 납니다.

문제 코드

fn main() {
    let mut v = vec![1, 2, 3];

    for i in 0..v.len() {
        let x = &mut v[i];
        // 여기서 v를 또 건드리면(예: push) 충돌 가능
        // v.push(4);
        *x += 1;
    }
}

해결: 2단계로 나누기(읽기 단계/쓰기 단계)

fn main() {
    let mut v = vec![1, 2, 3];

    // 쓰기만 필요하면 iter_mut가 가장 단순
    for x in v.iter_mut() {
        *x += 1;
    }

    println!("{:?}", v);
}

패턴 D: 구조체 메서드에서 self를 두 번 가변 대여

문제 코드

struct App {
    a: i32,
    b: i32,
}

impl App {
    fn bump_both(&mut self) {
        let x = &mut self.a;
        let y = &mut self.b; // E0499 (self가 이미 가변 대여됨)
        *x += 1;
        *y += 1;
    }
}

fn main() {
    let mut app = App { a: 0, b: 0 };
    app.bump_both();
}

해결: 한 번에 구조 분해로 필드를 분리

struct App {
    a: i32,
    b: i32,
}

impl App {
    fn bump_both(&mut self) {
        let App { a, b } = self;
        *a += 1;
        *b += 1;
    }
}

fn main() {
    let mut app = App { a: 0, b: 0 };
    app.bump_both();
    println!("{} {}", app.a, app.b);
}

5) 그래도 안 풀릴 때: “소유권 설계”를 바꾸는 3가지 옵션

옵션 1: 값을 함수 밖으로 빼서 반환으로 합치기

&mut를 여기저기 전달하기보다, 변경 결과를 반환해 합치는 방식이 더 Rust스럽고 안전합니다.

fn add_suffix(mut s: String) -> String {
    s.push_str("!");
    s
}

fn main() {
    let s = String::from("hello");
    let s = add_suffix(s);
    println!("{}", s);
}

옵션 2: 내부 가변성 RefCell (단일 스레드)

컴파일 타임이 아니라 런타임에 빌림 규칙을 검사합니다. 규칙을 깨면 패닉이 나므로, “정말 필요한 경우만” 쓰는 게 좋습니다.

use std::cell::RefCell;

fn main() {
    let v = RefCell::new(vec![1, 2, 3]);

    {
        let mut r = v.borrow_mut();
        r.push(4);
    }

    println!("{:?}", v.borrow());
}

옵션 3: Mutex/RwLock (멀티 스레드)

공유 상태가 필요하면 락이 정답인 경우도 많습니다. 다만 성능/데드락 설계가 과제가 됩니다.

6) 에러 메시지에서 “딱 여기만” 보면 빨리 끝난다

  • first borrowed here / borrowed here 라인이 첫 빌림 시작점
  • second borrow occurs here 라인이 충돌 지점
  • borrow later used here 라인이 빌림이 끝나지 않는 이유(마지막 사용)

즉, 해결은 보통 아래 셋 중 하나입니다.

  • 마지막 사용을 앞당긴다(로그/출력/참조 사용을 먼저 끝냄)
  • 스코프를 쪼갠다(블록으로 참조 수명 단축)
  • 동시에 접근하지 않게 API/자료구조 사용법을 바꾼다(split_at_mut, entry 등)

7) 마무리: E0502·E0499는 “버그”가 아니라 설계 힌트

E0502/E0499는 Rust가 괴롭히는 게 아니라, 데이터 경쟁/유효하지 않은 참조로 이어질 수 있는 코드를 미리 차단하는 신호입니다. 위 패턴(스코프 분리, 값 스냅샷, 컨테이너 분할, entry 활용)만 익혀도 대부분의 소유권 오류는 5분 안에 정리됩니다.

성능 튜닝이나 빌드/배포 파이프라인에서 문제를 줄이는 것도 결국 같은 결입니다. 작은 규칙을 자동화하고, 충돌 지점을 줄이면 전체 개발 속도가 올라갑니다. CI 최적화가 필요하다면 GitHub Actions 동시 실행 막힘 해결 - concurrency·cancel-in-progress 같은 글도 함께 참고해두면 도움이 됩니다.

Discuss on Twitter • View on GitHub