Clear collection reassignment by yash-kumarx · Pull Request #16549 · rust-lang/rust-clippy

yash-kumarx · 2026-02-10T09:16:44Z

Add clear_instead_of_new lint

What does this PR do?

Adds a new perf lint that detects when a collection is reassigned to a new empty collection instead of calling .clear().

Why?

Reassigning a collection with collection = CollectionType::new() is inefficient because it:-

Deallocates the existing collection
Loses any pre-allocated capacity
Allocates a new collection from scratch

Advantage

Using .clear() is more efficient as it:-

Keeps the existing allocation and capacity
Only removes the elements
Avoids unnecessary deallocation/reallocation overhead

This can lead to significant performance improvements in loops or many paths where collections are frequently reset.

What collections are supported?

Vec
HashMap
HashSet
VecDeque
BTreeMap
BTreeSet
BinaryHeap
LinkedList

Example
Before:

rustlet mut v = Vec::new();
v.push(1);
v = Vec::new(); // Inefficient: deallocates and reallocates

After:

rustlet mut v = Vec::new();
v.push(1);
v.clear(); // Efficient: reuses existing allocation

Fixes #16520

changelog: [clear_instead_of_new]: new lint to suggest using .clear() instead of reassigning empty collections

rustbot · 2026-02-10T09:16:50Z

r? @dswij

rustbot has assigned @dswij.
They will have a look at your PR within the next two weeks and either review your PR or reassign to another reviewer.

Use r? to explicitly pick a reviewer

Why was this reviewer chosen?

The reviewer was selected based on:

Owners of files modified in this PR: 7 candidates
7 candidates expanded to 7 candidates
Random selection from Jarcho, dswij, llogiq, samueltardieu

github-actions · 2026-02-10T09:26:49Z

Lintcheck changes for 47b2444

Lint	Added	Removed	Changed
`clippy::new_instead_of_clear`	4	0	0

This comment will be updated if you push new changes

samueltardieu

This is a good first step, but this requires changes:

Since this lint only triggers on call to something::new(), it should probably be part of the clippy_lints::methods module.
You should add tests showing that the lint will not trigger if the code belongs to a macro (this will probably be taken care of automatically once integrated into the methods module).
You should also add more complex tests such as *v = Vec::new();, as it should be replaced by (*v).clear(); or, even better, v.clear(); instead.

We usually avoid comparing strings in Clippy. Method names are compared using symbols (sym::new()), and types names usually use diagnostic items.

r? samueltardieu
@rustbot author

View changes since this review

samueltardieu · 2026-02-10T09:55:29Z

+fn is_collection_new_call(cx: &LateContext<'_>, func: &Expr<'_>) -> bool {
+    if let ExprKind::Path(QPath::TypeRelative(ty, method)) = func.kind
+        && method.ident.name.as_str() == "new"
+    {
+        let ty = cx.typeck_results().node_type(ty.hir_id);
+        let type_name = ty.to_string();
+
+        // Check if it's one of the standard collections
+        // Type names come in the format "std::vec::Vec<T>" or "std::collections::HashMap<K, V>"
+        type_name.contains("::Vec<")
+            || type_name.contains("::HashMap<")
+            || type_name.contains("::HashSet<")
+            || type_name.contains("::VecDeque<")
+            || type_name.contains("::BTreeMap<")
+            || type_name.contains("::BTreeSet<")
+            || type_name.contains("::BinaryHeap<")
+            || type_name.contains("::LinkedList<")
+    } else {
+        false
+    }
+}


This is not the proper way of checking for the type, we don't use string matching in Clippy as this is not robust. You should look at the diagnostic items page in the compiler dev guide, and use functions from clippy_utils to check for them.

samueltardieu · 2026-02-10T09:59:45Z

+    /// vec.push(1);
+    /// vec.clear();
+    /// ```
+    #[clippy::version = "1.XX.0"]


Suggested change

#[clippy::version = "1.XX.0"]

#[clippy::version = "1.95.0"]

samueltardieu · 2026-02-10T10:00:33Z

+    /// ```no_run
+    /// let mut vec = Vec::new();
+    /// vec.push(1);
+    /// vec = Vec::new();


You should insert a f(&vec) in the middle, otherwise it makes little sense to push an element and erase the collection afterwards without using it.

rustbot · 2026-02-10T10:00:59Z

Reminder, once the PR becomes ready for a review, use @rustbot ready.

samueltardieu · 2026-02-10T10:03:53Z

Note that you can run the tests including the internal ones by using cargo test -F internal before pushing the PR.

yash-kumarx · 2026-02-11T12:57:22Z

@samueltardieu Thanks for the review. I will work on these changes:

Moving the lint to the methods module
Use diagnostic items instead of string matching
Add macro and dereference test cases
Update version number

I will need a bit of time to study the methods module structure
and diagnostic items. Should have updates in a few days.

- Use diagnostic items instead of string matching for type checking - Move lint to methods module as requested - Add macro handling via in_external_macro check - Support dereference patterns (*v = Vec::new() → v.clear()) - Change applicability to MaybeIncorrect - Add comprehensive tests for all collection types - Fix version to 1.95.0 Addresses all review comments from samueltardieu on PR rust-lang#16549

samueltardieu · 2026-02-15T11:41:34Z


 # Remove jujutsu directory from search tools
 .jj
+.DS_Store


This doesn't belong to this PR.

samueltardieu · 2026-02-15T11:41:52Z

This file should not have been added

samueltardieu

After applying those changes, could you also please:

squash your commits so that you only have two commits, one which applies the lint to only_used_in_recursion.rs and one which implements the lint;
remove the issue number from the commit message

View changes since this review

samueltardieu · 2026-02-15T11:44:07Z

@@ -0,0 +1,152 @@
+#![warn(clippy::clear_instead_of_new)]
+#![allow(unused)]


This should not be needed:

Suggested change

#![allow(unused)]

samueltardieu · 2026-02-15T11:44:49Z

+#![allow(clippy::clear_instead_of_new)]
 #![allow(unused, clippy::useless_vec)]


Suggested change

#![allow(clippy::clear_instead_of_new)]

#![allow(unused, clippy::useless_vec)]

#![allow(clippy::clear_instead_of_new, clippy::useless_vec)]

samueltardieu · 2026-02-15T11:45:26Z

@@ -1,3 +1,4 @@
+#![allow(clippy::clear_instead_of_new)]


Move it after the #![warn(…)]

samueltardieu · 2026-02-15T11:45:41Z

+#![allow(clippy::clear_instead_of_new)]
 #![allow(clippy::useless_vec, clippy::manual_repeat_n)]


Fuse the lines

samueltardieu · 2026-02-15T11:46:00Z

    }
 }

+#[allow(clippy::clear_instead_of_new)]


Please use #[expect] instead.

samueltardieu · 2026-02-15T11:52:36Z

+        let is_new_call = if let ExprKind::Call(func, args) = value.kind
+            && args.is_empty()
+            && let ExprKind::Path(QPath::TypeRelative(ty_path, method)) = func.kind
+            && method.ident.name == sym::new


This will have been checked in the methods module check_expr() function already.

samueltardieu · 2026-02-15T11:57:18Z

+    // Get the type definition, peeling any references
+    let ty = ty.peel_refs();
+
+    // Check if it's one of the standard library collections
+    // We check for types that have a .clear() method
+    if let ty::Adt(adt, _) = ty.kind() {
+        let def_id = adt.did();
+
+        // Use diagnostic items to identify the type
+        // This is the proper way to check types in Clippy, not string matching
+        cx.tcx.is_diagnostic_item(sym::Vec, def_id)
+            || cx.tcx.is_diagnostic_item(sym::HashMap, def_id)
+            || cx.tcx.is_diagnostic_item(sym::HashSet, def_id)
+            || cx.tcx.is_diagnostic_item(sym::VecDeque, def_id)
+            || cx.tcx.is_diagnostic_item(sym::BTreeMap, def_id)
+            || cx.tcx.is_diagnostic_item(sym::BTreeSet, def_id)
+            || cx.tcx.is_diagnostic_item(sym::BinaryHeap, def_id)
+            || cx.tcx.is_diagnostic_item(sym::LinkedList, def_id)
+    } else {
+        false
+    }


You can do this more efficiently with something like:

Suggested change

// Get the type definition, peeling any references

let ty = ty.peel_refs();

// Check if it's one of the standard library collections

// We check for types that have a .clear() method

if let ty::Adt(adt, _) = ty.kind() {

let def_id = adt.did();

// Use diagnostic items to identify the type

// This is the proper way to check types in Clippy, not string matching

cx.tcx.is_diagnostic_item(sym::Vec, def_id)

|| cx.tcx.is_diagnostic_item(sym::HashMap, def_id)

|| cx.tcx.is_diagnostic_item(sym::HashSet, def_id)

|| cx.tcx.is_diagnostic_item(sym::VecDeque, def_id)

|| cx.tcx.is_diagnostic_item(sym::BTreeMap, def_id)

|| cx.tcx.is_diagnostic_item(sym::BTreeSet, def_id)

|| cx.tcx.is_diagnostic_item(sym::BinaryHeap, def_id)

|| cx.tcx.is_diagnostic_item(sym::LinkedList, def_id)

} else {

false

}

matches!(ty.peel_refs().opt_diag_name(), Some(sym::HashMap | sym::HashSet | …))

samueltardieu · 2026-02-15T11:58:11Z

Changes to this file don't seem to belong to this PR.

samueltardieu · 2026-02-15T12:01:13Z

@@ -1,3 +1,4 @@
+#![allow(clippy::clear_instead_of_new)]


Fuse with line 3.

- Use diagnostic items instead of string matching for type checking - Move lint to methods module as requested - Add macro handling via in_external_macro check - Support dereference patterns (*v = Vec::new() → v.clear()) - Use get_diagnostic_name for efficient compiler query - Change applicability to MaybeIncorrect - Add comprehensive tests for all collection types Addresses all review comments from samueltardieu on PR rust-lang#16549

yash-kumarx · 2026-02-15T12:26:22Z

All the requested changes have been addressed:

Moved to methods module
Using diagnostic items instead of string matching
Added macro handling
Dereference patterns supported (*v = Vec::new() → v.clear())
Changed to MaybeIncorrect applicability
Comprehensive tests added
Version fixed to 1.95.0
All tests passing

@rustbot ready

yash-kumarx · 2026-02-15T12:50:29Z

@samueltardieu Thank you for the review. I'll make the changes accordingly

samueltardieu · 2026-02-15T13:07:01Z

Changed to MaybeIncorrect applicability

In which case can the applicability be incorrect?

yash-kumarx · 2026-02-15T13:25:07Z

Changed to MaybeIncorrect applicability

In which case can the applicability be incorrect?

The applicability can be incorrect in uninitialized variables, different capacity semantics

For eg:-

let mut v: Vec<i32>;
v = Vec::new();

Lint suggests: v.clear()
But v.clear() would fail since v is uninitialized.

let mut v = vec![1, 2, 3, 4, 5];
v = Vec::new();
v.clear();

Vec::new() drops old vec, creates new one with capacity 0
But v.clear() keeps existing capacity (5)
If we want to free memory, Vec::new() is correct.

samueltardieu · 2026-02-15T13:52:13Z

The applicability can be incorrect in uninitialized variables

It would be best for the lint not to trigger at all in this case (see clippy_utils::is_initialized().

different capacity semantics

This is a real one. Maybe an extra note could be added to the diagnostic saying that using .clear() will keep the collection capacity as-is.

samueltardieu

Please remove all .DS_Store files from the second commit.

View changes since this review

yash-kumarx · 2026-03-21T10:32:10Z

@rustbot ready

samueltardieu · 2026-03-22T15:32:56Z

+fn peel_derefs<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {
+    let mut e = expr;
+    while let ExprKind::Unary(UnOp::Deref, inner) = e.kind {
+        e = inner;
+    }
+    e
+}


You don't need to use an extra variable:

Suggested change

fn peel_derefs<'tcx>(expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {

let mut e = expr;

while let ExprKind::Unary(UnOp::Deref, inner) = e.kind {

e = inner;

}

e

}

fn peel_derefs<'tcx>(mut expr: &'tcx Expr<'tcx>) -> &'tcx Expr<'tcx> {

while let ExprKind::Unary(UnOp::Deref, inner) = expr.kind {

expr = inner;

}

expr

}

samueltardieu · 2026-03-22T15:35:40Z

+    false
+}
+
+fn local_snippet<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<String> {


This function doesn't do what its name implies, as it also checks that the local is initialized. At least, it should include a /// docstring.

samueltardieu · 2026-03-22T15:36:36Z

+// turbofish on the type (e.g. `Vec::<i32>::new()`) changes type inference,
+// so replacing with `.clear()` could be wrong


This comment doesn't explain what the function does. It should be placed at the calling place.

samueltardieu · 2026-03-22T15:37:41Z

+    }
+}
+
+fn emit_lint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, sugg: &str) {


Suggested change

fn emit_lint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, sugg: &str) {

fn emit_lint(cx: &LateContext<'_>, expr: &Expr<'_>, sugg: &str) {

samueltardieu · 2026-03-22T15:38:48Z

+    false
+}
+
+fn local_snippet<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<String> {


Suggested change

fn local_snippet<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<String> {

fn local_snippet(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {

samueltardieu · 2026-03-22T15:39:47Z

+    }
+}
+
+fn check_vec_macro<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, lhs: &'tcx Expr<'tcx>, rhs: &'tcx Expr<'tcx>) {


Suggested change

fn check_vec_macro<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, lhs: &'tcx Expr<'tcx>, rhs: &'tcx Expr<'tcx>) {

fn check_vec_macro(cx: &LateContext<'_>, expr: &Expr<'_>, lhs: &Expr<'_>, rhs: &Expr<'_>) {

samueltardieu · 2026-03-22T15:40:40Z

+fn check_collection_new<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    lhs: &'tcx Expr<'tcx>,
+    rhs: &'tcx Expr<'tcx>,
+) {


Suggested change

fn check_collection_new<'tcx>(

cx: &LateContext<'tcx>,

expr: &'tcx Expr<'tcx>,

lhs: &'tcx Expr<'tcx>,

rhs: &'tcx Expr<'tcx>,

) {

fn check_collection_new(cx: &LateContext<'_>, expr: &Expr<'_>, lhs: &Expr<'_>, rhs: &Expr<'_>) {

samueltardieu · 2026-03-22T15:41:15Z

+
+use super::NEW_INSTEAD_OF_CLEAR;
+
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {


Suggested change

pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {

pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {

samueltardieu · 2026-03-22T15:42:32Z

+    #[clippy::version = "1.96.0"]
+    pub NEW_INSTEAD_OF_CLEAR,
+    perf,
+    "assigning `Collection::new()` or `vec![]` instead of calling `.clear()`"


Suggested change

"assigning `Collection::new()` or `vec![]` instead of calling `.clear()`"

"creating a new collection instead of calling `.clear()`"

rustbot · 2026-06-15T16:49:23Z

This PR was rebased onto a different master commit. Here's a range-diff highlighting what actually changed.

Rebasing is a normal part of keeping PRs up to date, so no action is needed—this note is just to help reviewers.

yash-kumarx · 2026-06-15T17:24:57Z

@samueltardieu Thanks for taking the time to go through this so thoroughly 🙏

I ended up reworking a good chunk of it. The lint's now called new_instead_of_clear and lives in operators/ — you were right, it's matching on an assignment of a type-relative ::new(), not an actual method call, so that's where it belongs.

I also cleaned out all the stuff that shouldn't have been in here in the first place — the .gitignore change, that stray .swp file I accidentally committed, and the write/mod.rs / only_used_in_recursion.rs edits.

On the lint itself: it now checks the type via opt_diag_name instead of comparing strings, I pulled the duplicated emit code into one place, simplified the lifetimes to '_, added a doc comment to local_snippet, and moved the turbofish explanation up to where it's actually used. Tests use the plain //~^ new_instead_of_clear markers now, and the doc example has a f(&v) in the middle like you suggested.

Two small places I went a different way than the inline comments, just so it's not a surprise:

I set the version to 1.98.0 instead of 1.96.0 — master moved on to the 1.98 cycle in the meantime.
For swap_with_temporary I kept #![allow(...)] rather than #![expect(...)]. The lint only fires on the fixed output (***v1 = vec![]), not in the source, so expect ends up as an unfulfilled expectation there.
Let me know if there's anything else you'd like changed!

samueltardieu · 2026-06-15T20:51:23Z

+    {
+        let rhs_ty = cx.typeck_results().node_type(ty.hir_id);
+        if matches!(
+            rhs_ty.peel_refs().opt_diag_name(cx),


What ref could need peeling here?

Suggested change

rhs_ty.peel_refs().opt_diag_name(cx),

rhs_ty.opt_diag_name(cx),

View changes since the review

samueltardieu · 2026-06-15T21:01:06Z

+fn local_snippet(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
+    let inner = peel_derefs(expr);
+    if let ExprKind::Path(QPath::Resolved(None, path)) = inner.kind
+        && let Res::Local(hir_id) = path.res
+        && local_is_initialized(cx, hir_id)
+    {
+        Some(snippet(cx, inner.span, "..").into_owned())
+    } else {
+        None
+    }
+}


You should manipulate a Symbol instead of building an owned string.

Suggested change

fn local_snippet(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {

let inner = peel_derefs(expr);

if let ExprKind::Path(QPath::Resolved(None, path)) = inner.kind

&& let Res::Local(hir_id) = path.res

&& local_is_initialized(cx, hir_id)

{

Some(snippet(cx, inner.span, "..").into_owned())

} else {

None

}

}

fn local_snippet(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Symbol> {

peel_ref_operators(cx, expr)

.res_local_id_and_ident()

.filter(|(hir_id, _)| local_is_initialized(cx, *hir_id))

.map(|(_, ident)| ident.name)

}

Note that peel_ref_operators() is more conservative than your peel_derefs(), and that's a good thing: even if we will not lint the Box<Vec<_>> case, we will not risk having another smart pointer misbehave. What if the smartpointer S in S<Vec<_>> has its own clear() method which does something completely different? That one would be called instead.

View changes since the review

samueltardieu · 2026-06-15T21:08:46Z

+                format!("{sugg}.clear()"),
+                Applicability::MaybeIncorrect,
+            );
+            diag.note("`.clear()` retains the allocated memory for reuse");


This is not true for BTreeMap, BTreeSet, or LinkedList. The note should not be issued for those types, as they don't preallocate memory.

Maybe you could distinguish types that will clear from others, and detect String as well, by doing something like (note that emit_lint() has not two extra parameters, will_clear and may_have_side_effect for the vec![init; 0] case):

fn check_collection_new(cx: &LateContext<'_>, expr: &Expr<'_>, lhs: &Expr<'_>, rhs: &Expr<'_>) { // skip macro expansions (e.g. vec![] is handled separately) if !rhs.span.from_expansion() && let ExprKind::Call(func, []) = rhs.kind && let ExprKind::Path(QPath::TypeRelative(ty, method)) = func.kind && method.ident.name == sym::new // turbofish on the type (e.g. `Vec::<i32>::new()`) changes type inference, // so replacing with `.clear()` could be wrong && !has_type_args(ty) && let rhs_ty = cx.typeck_results().node_type(ty.hir_id) && let will_clear = match rhs_ty.opt_diag_name(cx) { Some(sym::Vec | sym::HashMap | sym::HashSet | sym::VecDeque | sym::BinaryHeap) => true, Some(sym::BTreeMap | sym::BTreeSet | sym::LinkedList) => false, None if rhs_ty.opt_def_id().is_some_and(|def_id| cx.tcx.is_lang_item(def_id, LangItem::String)) => true, _ => return, } && let Some(sugg) = local_snippet(cx, lhs) { emit_lint(cx, expr, sugg, will_clear, None); } }

View changes since the review

samueltardieu · 2026-06-15T21:09:12Z

+                    | sym::BTreeSet
+                    | sym::BinaryHeap
+                    | sym::LinkedList
+            )


Shouldn't String be also considered? (it is a lang item, not a diagnostic item)

View changes since the review

samueltardieu · 2026-06-15T21:29:31Z

+    if matching_root_macro_call(cx, rhs.span, sym::vec_macro).is_some()
+        && matches!(VecArgs::hir(cx, rhs), Some(VecArgs::Vec([])))
+        && let Some(sugg) = local_snippet(cx, lhs)
+    {
+        emit_lint(cx, expr, &sugg);
+    }


Doesn't VecArgs::hir() also check that the vec![] macro is used?

You could also check for vec![init; 0], and pass the initialization function to emit_lint():

Suggested change

if matching_root_macro_call(cx, rhs.span, sym::vec_macro).is_some()

&& matches!(VecArgs::hir(cx, rhs), Some(VecArgs::Vec([])))

&& let Some(sugg) = local_snippet(cx, lhs)

{

emit_lint(cx, expr, &sugg);

}

if let may_have_side_effect = match VecArgs::hir(cx, rhs) {

Some(VecArgs::Vec([])) => None,

Some(VecArgs::Repeat(init, count)) if is_integer_literal(count, 0) => Some(init),

_ => return,

}

&& let Some(sugg) = local_snippet(cx, lhs)

{

emit_lint(cx, expr, sugg, may_have_side_effect);

}

This way, emit_lint() could add a note if there is a risk of behavior change because side effects would no longer be executed, with something like:

if let Some(init) = may_have_side_effect && !eq_expr_value(cx, expr.span.ctxt(), init, init) { diag.span_note( init.span, "side effects of this expression will no longer be executed", ); }

View changes since the review

samueltardieu · 2026-06-15T21:31:47Z

+    {
+        let rhs_ty = cx.typeck_results().node_type(ty.hir_id);


No need to interrupt the if let chain here:

Suggested change

{

let rhs_ty = cx.typeck_results().node_type(ty.hir_id);

&& let rhs_ty = cx.typeck_results().node_type(ty.hir_id)

View changes since the review

Add a `perf` lint that detects reassigning an already-initialized collection with `Collection::new()` or `vec![]` instead of calling `.clear()`, which needlessly discards the existing allocation. Covers `Vec`, `VecDeque`, `HashMap`, `HashSet`, `BinaryHeap`, `String`, `BTreeMap`, `BTreeSet` and `LinkedList`. The memory-reuse note is only shown for types that retain their allocation on `.clear()`. The lint fires only when the variable is already initialized, peels reference operators but not smart-pointer derefs, and skips macro expansions and turbofish types where switching to `.clear()` could change behavior.

The new lint fires on collection reassignments present in unrelated test files that run with -D warnings. Add #![allow(clippy::new_instead_of_clear)] to keep each test focused on its own lint, and re-bless the affected snapshots.

rustbot assigned dswij Feb 10, 2026

rustbot added needs-fcp PRs that add, remove, or rename lints and need an FCP S-waiting-on-review Status: Awaiting review from the assignee but also interested parties labels Feb 10, 2026

This comment has been minimized.

Sign in to view

samueltardieu requested changes Feb 10, 2026

View reviewed changes

rustbot assigned samueltardieu and unassigned dswij Feb 10, 2026

rustbot added S-waiting-on-author Status: This is awaiting some action from the author. (Use `@rustbot ready` to update this status) and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties labels Feb 10, 2026

This comment has been minimized.

Sign in to view

samueltardieu reviewed Feb 15, 2026

View reviewed changes

Comment thread tests/ui/.clear_instead_of_new.rs.swp Outdated

samueltardieu Feb 15, 2026

Copy link
Copy Markdown

Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This file should not have been added

samueltardieu requested changes Feb 15, 2026

View reviewed changes

This comment has been minimized.

Sign in to view

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties and removed S-waiting-on-author Status: This is awaiting some action from the author. (Use `@rustbot ready` to update this status) labels Feb 15, 2026

samueltardieu added S-waiting-on-author Status: This is awaiting some action from the author. (Use `@rustbot ready` to update this status) and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties labels Feb 15, 2026

yash-kumarx requested a review from samueltardieu March 18, 2026 03:08

samueltardieu requested changes Mar 19, 2026

View reviewed changes

rustbot added S-waiting-on-author Status: This is awaiting some action from the author. (Use `@rustbot ready` to update this status) and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties labels Mar 19, 2026

yash-kumarx force-pushed the clear-collection-reassignment branch from 1227981 to 3ba4e8f Compare March 21, 2026 09:48

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties and removed S-waiting-on-author Status: This is awaiting some action from the author. (Use `@rustbot ready` to update this status) labels Mar 21, 2026

yash-kumarx requested a review from samueltardieu March 21, 2026 10:32

samueltardieu requested changes Mar 22, 2026

View reviewed changes

rustbot added S-waiting-on-author Status: This is awaiting some action from the author. (Use `@rustbot ready` to update this status) and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties labels Mar 22, 2026

yash-kumarx force-pushed the clear-collection-reassignment branch from 3ba4e8f to c6da352 Compare April 4, 2026 04:32

This comment has been minimized.

Sign in to view

yash-kumarx force-pushed the clear-collection-reassignment branch from 47f42c0 to a0264f3 Compare May 4, 2026 18:09

yash-kumarx force-pushed the clear-collection-reassignment branch from 6f08e27 to 4e4f9db Compare May 24, 2026 18:28

This comment has been minimized.

Sign in to view

yash-kumarx force-pushed the clear-collection-reassignment branch from 56feac5 to ffbd0e2 Compare June 15, 2026 16:49

yash-kumarx force-pushed the clear-collection-reassignment branch from ffbd0e2 to 78bfc5c Compare June 15, 2026 17:16

samueltardieu requested changes Jun 15, 2026

View reviewed changes

yash-kumarx added 2 commits June 17, 2026 05:12

Allow new_instead_of_clear in other lints' UI tests

47b2444

The new lint fires on collection reassignments present in unrelated test files that run with -D warnings. Add #![allow(clippy::new_instead_of_clear)] to keep each test focused on its own lint, and re-bless the affected snapshots.

yash-kumarx force-pushed the clear-collection-reassignment branch from 78bfc5c to 47b2444 Compare June 16, 2026 23:43

yash-kumarx requested a review from samueltardieu June 17, 2026 18:25

rustbot added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties and removed S-waiting-on-author Status: This is awaiting some action from the author. (Use `@rustbot ready` to update this status) labels Jun 17, 2026

		@@ -0,0 +1,152 @@
		#![warn(clippy::clear_instead_of_new)]
		#![allow(unused)]

		#![allow(clippy::clear_instead_of_new)]
		#![allow(unused, clippy::useless_vec)]

	#![allow(clippy::clear_instead_of_new)]
	#![allow(unused, clippy::useless_vec)]
	#![allow(clippy::clear_instead_of_new, clippy::useless_vec)]

		#![allow(clippy::clear_instead_of_new)]
		#![allow(clippy::useless_vec, clippy::manual_repeat_n)]

		// turbofish on the type (e.g. `Vec::<i32>::new()`) changes type inference,
		// so replacing with `.clear()` could be wrong

	fn emit_lint<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, sugg: &str) {
	fn emit_lint(cx: &LateContext<'_>, expr: &Expr<'_>, sugg: &str) {

	fn local_snippet<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<String> {
	fn local_snippet(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {

	fn check_vec_macro<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, lhs: &'tcx Expr<'tcx>, rhs: &'tcx Expr<'tcx>) {
	fn check_vec_macro(cx: &LateContext<'_>, expr: &Expr<'_>, lhs: &Expr<'_>, rhs: &Expr<'_>) {


		use super::NEW_INSTEAD_OF_CLEAR;

		pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {

	pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
	pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>) {

	"assigning `Collection::new()` or `vec![]` instead of calling `.clear()`"
	"creating a new collection instead of calling `.clear()`"

	rhs_ty.peel_refs().opt_diag_name(cx),
	rhs_ty.opt_diag_name(cx),

	{
	let rhs_ty = cx.typeck_results().node_type(ty.hir_id);
	&& let rhs_ty = cx.typeck_results().node_type(ty.hir_id)

Uh oh!

Uh oh!

Conversation

yash-kumarx commented Feb 10, 2026 • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Add clear_instead_of_new lint

What does this PR do?

Why?

Advantage

What collections are supported?

Uh oh!

rustbot commented Feb 10, 2026

Uh oh!

This comment has been minimized.

github-actions Bot commented Feb 10, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

samueltardieu left a comment • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

rustbot commented Feb 10, 2026

Uh oh!

samueltardieu commented Feb 10, 2026

Uh oh!

yash-kumarx commented Feb 11, 2026

Uh oh!

This comment has been minimized.

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

samueltardieu left a comment • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

samueltardieu Feb 15, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

This comment has been minimized.

yash-kumarx commented Feb 15, 2026

Uh oh!

yash-kumarx commented Feb 15, 2026

Uh oh!

samueltardieu commented Feb 15, 2026

Uh oh!

yash-kumarx commented Feb 15, 2026

Uh oh!

samueltardieu commented Feb 15, 2026

Uh oh!

samueltardieu left a comment • edited by rustbot Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

yash-kumarx commented Mar 21, 2026

Uh oh!

yash-kumarx commented Feb 10, 2026 •

edited by rustbot

Loading

github-actions Bot commented Feb 10, 2026 •

edited

Loading

samueltardieu left a comment •

edited by rustbot

Loading

samueltardieu left a comment •

edited by rustbot

Loading

samueltardieu Feb 15, 2026 •

edited

Loading

samueltardieu left a comment •

edited by rustbot

Loading

samueltardieu Jun 15, 2026 •

edited by rustbot

Loading

samueltardieu Jun 15, 2026 •

edited by rustbot

Loading

samueltardieu Jun 15, 2026 •

edited by rustbot

Loading

samueltardieu Jun 15, 2026 •

edited by rustbot

Loading