Clippy lint · Restriction · checked with Clippy 0.1.99

clippy::rc_buffer: Checks for Rc<T> and Arc<T> when T is a mutable buffer type such as String or Vec

What it meansChecks for Rc<T> and Arc<T> when T is a mutable buffer type such as String or Vec. It is in the restriction group and off by default.

Does it matter?

Expressions such as Rc<String> usually have no advantage over Rc<str>, since it is larger and involves an extra level of indirection, and doesn’t implement Borrow<str>. While mutating a buffer type would still be possible with Rc::get_mut(), it only works if there are no additional references yet, which usually defeats the purpose of enclosing it in a shared ownership type. Instead, additionally wrapping the inner type with an interior mutable container (such as RefCell or Mutex) would normally be used.

Lints that forbid language features for specific codebases (no unwrap, no indexing...). Off by default; pick them one by one, never the whole group.

How to fix it

Clippy does not fix this one automatically. Change the code by hand:

Flagged

fn foo(interned: Rc<String>) { ... }

Write this instead

fn foo(interned: Rc<str>) { ... }

Turn it off, or on

It is off by default. To use it, set it to warn or deny:

Whole crate (Cargo.toml)

[lints.clippy]
rc_buffer = "warn"

In code

#![warn(clippy::rc_buffer)]

One run

cargo clippy -- -W clippy::rc-buffer

The [lints] table needs Rust 1.74 or newer. In a workspace, put it under [workspace.lints.clippy] and add [lints] workspace = true to each member.

Settings in clippy.toml

avoid-breaking-exported-api: Suppress lints whenever the suggested change would cause breakage for other crates.

Restrictiongroup

allowdefault level

nofixed by cargo clippy --fix

1.48.0added in Rust

Clippy's own documentation

What it does

Checks for Rc<T> and Arc<T> when T is a mutable buffer type such as String or Vec.

Why restrict this?

Expressions such as Rc<String> usually have no advantage over Rc<str>, since it is larger and involves an extra level of indirection, and doesn’t implement Borrow<str>.

While mutating a buffer type would still be possible with Rc::get_mut(), it only works if there are no additional references yet, which usually defeats the purpose of enclosing it in a shared ownership type. Instead, additionally wrapping the inner type with an interior mutable container (such as RefCell or Mutex) would normally be used.

Known problems

This pattern can be desirable to avoid the overhead of a RefCell or Mutex for cases where mutation only happens before there are any additional references.

Example

fn foo(interned: Rc<String>) { ... }

Better:

fn foo(interned: Rc<str>) { ... }

Configuration

avoid-breaking-exported-api: Suppress lints whenever the suggested change would cause breakage for other crates.

(default: true)

From the Clippy lint list (0.1.99), part of the Rust project, MIT or Apache-2.0. Official entry.

Up next

Also worth your time

Did this answer your question?