squiid/rust
1
0
Fork 0
Code Issues Pull requests Projects Activity

Address feedback

Browse source
This commit is contained in:
mejrs 2022-09-27 13:06:31 +02:00
parent c4c9415132
commit f3ac328d58
10 changed files with 113 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

61
compiler/rustc_hir_analysis/src/check/method/suggest.rs
View file

@ -1428,7 +1428,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
item_name,
field_ty,
call_expr,
ProbeScope::AllTraits,
ProbeScope::TraitsInScope,
)
.ok()
.map(|pick| (variant, field, pick))
@ -1500,59 +1500,88 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
item_name,
ty,
call_expr,
ProbeScope::AllTraits,
ProbeScope::TraitsInScope,
) else { return; };
let name = self.ty_to_value_string(actual);
let inner_id = kind.did();
let mutable = if let Some(AutorefOrPtrAdjustment::Autoref { mutbl, .. }) =
pick.autoref_or_ptr_adjustment
{
Some(mutbl)
} else {
None
};
if tcx.is_diagnostic_item(sym::LocalKey, inner_id) {
err.help("use `with` or `try_with` to access the contents of threadlocals");
err.help("use `with` or `try_with` to access thread local storage");
} else if Some(kind.did()) == tcx.lang_items().maybe_uninit() {
err.help(format!(
"if this `{name}` has been initialized, \
use one of the `assume_init` methods to access the inner value"
));
} else if tcx.is_diagnostic_item(sym::RefCell, inner_id) {
match pick.autoref_or_ptr_adjustment {
Some(AutorefOrPtrAdjustment::Autoref {
mutbl: Mutability::Not, ..
}) => {
match mutable {
Some(Mutability::Not) => {
err.span_suggestion_verbose(
expr.span.shrink_to_hi(),
format!(
"use `.borrow()` to borrow the {ty}, \
panicking if any outstanding mutable borrows exist."
"use `.borrow()` to borrow the `{ty}`, \
panicking if any outstanding mutable borrows exist."
),
".borrow()",
Applicability::MaybeIncorrect,
);
}
Some(AutorefOrPtrAdjustment::Autoref {
mutbl: Mutability::Mut, ..
}) => {
Some(Mutability::Mut) => {
err.span_suggestion_verbose(
expr.span.shrink_to_hi(),
format!(
"use `.borrow_mut()` to mutably borrow the {ty}, \
panicking if any outstanding borrows exist."
"use `.borrow_mut()` to mutably borrow the `{ty}`, \
panicking if any outstanding borrows exist."
),
".borrow_mut()",
Applicability::MaybeIncorrect,
);
}
_ => return,
None => return,
}
} else if tcx.is_diagnostic_item(sym::Mutex, inner_id) {
err.span_suggestion_verbose(
expr.span.shrink_to_hi(),
format!(
"use `.lock()` to borrow the {ty}, \
"use `.lock()` to borrow the `{ty}`, \
blocking the current thread until it can be acquired"
),
".lock().unwrap()",
Applicability::MaybeIncorrect,
);
} else if tcx.is_diagnostic_item(sym::RwLock, inner_id) {
match mutable {
Some(Mutability::Not) => {
err.span_suggestion_verbose(
expr.span.shrink_to_hi(),
format!(
"use `.read()` to borrow the `{ty}`, \
blocking the current thread until it can be acquired"
),
".read().unwrap()",
Applicability::MaybeIncorrect,
);
}
Some(Mutability::Mut) => {
err.span_suggestion_verbose(
expr.span.shrink_to_hi(),
format!(
"use `.write()` to mutably borrow the `{ty}`, \
blocking the current thread until it can be acquired"
),
".write().unwrap()",
Applicability::MaybeIncorrect,
);
}
None => return,
}
} else {
return;
};

1
compiler/rustc_span/src/symbol.rs
View file

@ -276,6 +276,7 @@ symbols! {
Rust,
RustcDecodable,
RustcEncodable,
RwLock,
RwLockReadGuard,
RwLockWriteGuard,
Send,

2
library/core/src/cell.rs
View file

@ -614,7 +614,7 @@ impl<T, const N: usize> Cell<[T; N]> {
/// A mutable memory location with dynamically checked borrow rules
///
/// See the [module-level documentation](self) for more.
#[rustc_diagnostic_item = "RefCell"]
#[cfg_attr(not(test), rustc_diagnostic_item = "RefCell")]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct RefCell<T: ?Sized> {
borrow: Cell<BorrowFlag>,

1
library/std/src/sync/rwlock.rs
View file

@ -76,6 +76,7 @@ use crate::sys_common::rwlock as sys;
///
/// [`Mutex`]: super::Mutex
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "RwLock")]
pub struct RwLock<T: ?Sized> {
inner: sys::MovableRwLock,
poison: poison::Flag,

2
library/std/src/thread/local.rs
View file

@ -95,7 +95,7 @@ use crate::fmt;
/// [loader lock]: https://docs.microsoft.com/en-us/windows/win32/dlls/dynamic-link-library-best-practices
/// [`JoinHandle::join`]: crate::thread::JoinHandle::join
/// [`with`]: LocalKey::with
#[rustc_diagnostic_item = "LocalKey"]
#[cfg_attr(not(test), rustc_diagnostic_item = "LocalKey")]
#[stable(feature = "rust1", since = "1.0.0")]
pub struct LocalKey<T: 'static> {
// This outer `LocalKey<T>` type is what's going to be stored in statics,

16
src/test/ui/suggestions/inner_type.fixed
View file

@ -16,15 +16,25 @@ fn main() {
other_item.borrow().method();
//~^ ERROR no method named `method` found for struct `RefCell` in the current scope [E0599]
//~| HELP use `.borrow()` to borrow the Struct<u32>, panicking if any outstanding mutable borrows exist.
//~| HELP use `.borrow()` to borrow the `Struct<u32>`, panicking if any outstanding mutable borrows exist.
other_item.borrow_mut().some_mutable_method();
//~^ ERROR no method named `some_mutable_method` found for struct `RefCell` in the current scope [E0599]
//~| HELP use `.borrow_mut()` to mutably borrow the Struct<u32>, panicking if any outstanding borrows exist.
//~| HELP use `.borrow_mut()` to mutably borrow the `Struct<u32>`, panicking if any outstanding borrows exist.
let another_item = std::sync::Mutex::new(Struct { p: 42_u32 });
another_item.lock().unwrap().method();
//~^ ERROR no method named `method` found for struct `Mutex` in the current scope [E0599]
//~| HELP use `.lock()` to borrow the Struct<u32>, blocking the current thread until it can be acquired
//~| HELP use `.lock()` to borrow the `Struct<u32>`, blocking the current thread until it can be acquired
let another_item = std::sync::RwLock::new(Struct { p: 42_u32 });
another_item.read().unwrap().method();
//~^ ERROR no method named `method` found for struct `RwLock` in the current scope [E0599]
//~| HELP use `.read()` to borrow the `Struct<u32>`, blocking the current thread until it can be acquired
another_item.write().unwrap().some_mutable_method();
//~^ ERROR no method named `some_mutable_method` found for struct `RwLock` in the current scope [E0599]
//~| HELP use `.write()` to mutably borrow the `Struct<u32>`, blocking the current thread until it can be acquired
}

16
src/test/ui/suggestions/inner_type.rs
View file

@ -16,15 +16,25 @@ fn main() {
other_item.method();
//~^ ERROR no method named `method` found for struct `RefCell` in the current scope [E0599]
//~| HELP use `.borrow()` to borrow the Struct<u32>, panicking if any outstanding mutable borrows exist.
//~| HELP use `.borrow()` to borrow the `Struct<u32>`, panicking if any outstanding mutable borrows exist.
other_item.some_mutable_method();
//~^ ERROR no method named `some_mutable_method` found for struct `RefCell` in the current scope [E0599]
//~| HELP use `.borrow_mut()` to mutably borrow the Struct<u32>, panicking if any outstanding borrows exist.
//~| HELP use `.borrow_mut()` to mutably borrow the `Struct<u32>`, panicking if any outstanding borrows exist.
let another_item = std::sync::Mutex::new(Struct { p: 42_u32 });
another_item.method();
//~^ ERROR no method named `method` found for struct `Mutex` in the current scope [E0599]
//~| HELP use `.lock()` to borrow the Struct<u32>, blocking the current thread until it can be acquired
//~| HELP use `.lock()` to borrow the `Struct<u32>`, blocking the current thread until it can be acquired
let another_item = std::sync::RwLock::new(Struct { p: 42_u32 });
another_item.method();
//~^ ERROR no method named `method` found for struct `RwLock` in the current scope [E0599]
//~| HELP use `.read()` to borrow the `Struct<u32>`, blocking the current thread until it can be acquired
another_item.some_mutable_method();
//~^ ERROR no method named `some_mutable_method` found for struct `RwLock` in the current scope [E0599]
//~| HELP use `.write()` to mutably borrow the `Struct<u32>`, blocking the current thread until it can be acquired
}

40
src/test/ui/suggestions/inner_type.stderr
View file

@ -9,7 +9,7 @@ note: the method `method` exists on the type `Struct<u32>`
|
LL | pub fn method(&self) {}
| ^^^^^^^^^^^^^^^^^^^^
help: use `.borrow()` to borrow the Struct<u32>, panicking if any outstanding mutable borrows exist.
help: use `.borrow()` to borrow the `Struct<u32>`, panicking if any outstanding mutable borrows exist.
|
LL | other_item.borrow().method();
| +++++++++
@ -25,7 +25,7 @@ note: the method `some_mutable_method` exists on the type `Struct<u32>`
|
LL | pub fn some_mutable_method(&mut self) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: use `.borrow_mut()` to mutably borrow the Struct<u32>, panicking if any outstanding borrows exist.
help: use `.borrow_mut()` to mutably borrow the `Struct<u32>`, panicking if any outstanding borrows exist.
|
LL | other_item.borrow_mut().some_mutable_method();
| +++++++++++++
@ -41,11 +41,43 @@ note: the method `method` exists on the type `Struct<u32>`
|
LL | pub fn method(&self) {}
| ^^^^^^^^^^^^^^^^^^^^
help: use `.lock()` to borrow the Struct<u32>, blocking the current thread until it can be acquired
help: use `.lock()` to borrow the `Struct<u32>`, blocking the current thread until it can be acquired
|
LL | another_item.lock().unwrap().method();
| ++++++++++++++++
error: aborting due to 3 previous errors
error[E0599]: no method named `method` found for struct `RwLock` in the current scope
--> $DIR/inner_type.rs:33:18
|
LL | another_item.method();
| ^^^^^^ method not found in `RwLock<Struct<u32>>`
|
note: the method `method` exists on the type `Struct<u32>`
--> $DIR/inner_type.rs:9:5
|
LL | pub fn method(&self) {}
| ^^^^^^^^^^^^^^^^^^^^
help: use `.read()` to borrow the `Struct<u32>`, blocking the current thread until it can be acquired
|
LL | another_item.read().unwrap().method();
| ++++++++++++++++
error[E0599]: no method named `some_mutable_method` found for struct `RwLock` in the current scope
--> $DIR/inner_type.rs:37:18
|
LL | another_item.some_mutable_method();
| ^^^^^^^^^^^^^^^^^^^ method not found in `RwLock<Struct<u32>>`
|
note: the method `some_mutable_method` exists on the type `Struct<u32>`
--> $DIR/inner_type.rs:11:5
|
LL | pub fn some_mutable_method(&mut self) {}
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: use `.write()` to mutably borrow the `Struct<u32>`, blocking the current thread until it can be acquired
|
LL | another_item.write().unwrap().some_mutable_method();
| +++++++++++++++++
error: aborting due to 5 previous errors
For more information about this error, try `rustc --explain E0599`.

2
src/test/ui/suggestions/inner_type2.rs
View file

@ -17,7 +17,7 @@ thread_local! {
fn main() {
STRUCT.method();
//~^ ERROR no method named `method` found for struct `LocalKey` in the current scope [E0599]
//~| HELP use `with` or `try_with` to access the contents of threadlocals
//~| HELP use `with` or `try_with` to access thread local storage
let item = std::mem::MaybeUninit::new(Struct { p: 42_u32 });
item.method();

2
src/test/ui/suggestions/inner_type2.stderr
View file

@ -4,7 +4,7 @@ error[E0599]: no method named `method` found for struct `LocalKey` in the curren
LL | STRUCT.method();
| ^^^^^^ method not found in `LocalKey<Struct<u32>>`
|
= help: use `with` or `try_with` to access the contents of threadlocals
= help: use `with` or `try_with` to access thread local storage
note: the method `method` exists on the type `Struct<u32>`
--> $DIR/inner_type2.rs:6:5
|