From 1d08b1b0421cc287218196e5fdd144b3e82a482a Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Thu, 18 Jun 2020 13:10:22 +0200
Subject: [PATCH 01/15] Clean up E0689 explanation
---
src/librustc_error_codes/error_codes/E0689.md | 19 +++++++++++--------
1 file changed, 11 insertions(+), 8 deletions(-)
diff --git a/src/librustc_error_codes/error_codes/E0689.md b/src/librustc_error_codes/error_codes/E0689.md
index 26c2c15ccfaac..a680a20421127 100644
--- a/src/librustc_error_codes/error_codes/E0689.md
+++ b/src/librustc_error_codes/error_codes/E0689.md
@@ -1,13 +1,16 @@
-This error indicates that the numeric value for the method being passed exists
-but the type of the numeric value or binding could not be identified.
+A method was called on an ambiguous numeric type.
-The error happens on numeric literals:
+Erroneous code example:
```compile_fail,E0689
-2.0.neg();
+2.0.neg(); // error!
```
-and on numeric bindings without an identified concrete type:
+This error indicates that the numeric value for the method being passed exists
+but the type of the numeric value or binding could not be identified.
+
+The error happens on numeric literals and on numeric bindings without an
+identified concrete type:
```compile_fail,E0689
let x = 2.0;
@@ -19,8 +22,8 @@ Because of this, you must give the numeric literal or binding a type:
```
use std::ops::Neg;
-let _ = 2.0_f32.neg();
+let _ = 2.0_f32.neg(); // ok!
let x: f32 = 2.0;
-let _ = x.neg();
-let _ = (2.0 as f32).neg();
+let _ = x.neg(); // ok!
+let _ = (2.0 as f32).neg(); // ok!
```
From 0624a5a063c0282811ac63b13861abb768f3f9c7 Mon Sep 17 00:00:00 2001
From: Rakshith Ravi <rakshith.ravi@gmx.com>
Date: Sat, 20 Jun 2020 13:00:16 +0530
Subject: [PATCH 02/15] Squashed all commits
---
src/librustc_typeck/astconv.rs | 73 +++++++++++++++++--
.../const-arg-type-arg-misordered.stderr | 1 +
.../ui/suggestions/suggest-move-types.stderr | 2 +
3 files changed, 70 insertions(+), 6 deletions(-)
diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
index f1dc7e5390629..1b06542871fc3 100644
--- a/src/librustc_typeck/astconv.rs
+++ b/src/librustc_typeck/astconv.rs
@@ -8,8 +8,7 @@
use crate::collect::PlaceholderHirTyCollector;
use crate::middle::resolve_lifetime as rl;
use crate::require_c_abi_if_c_variadic;
-use rustc_ast::ast::ParamKindOrd;
-use rustc_ast::util::lev_distance::find_best_match_for_name;
+use rustc_ast::{ast::ParamKindOrd, util::lev_distance::find_best_match_for_name};
use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_errors::ErrorReported;
use rustc_errors::{pluralize, struct_span_err, Applicability, DiagnosticId, FatalError};
@@ -27,7 +26,7 @@ use rustc_middle::ty::{GenericParamDef, GenericParamDefKind};
use rustc_session::lint::builtin::{AMBIGUOUS_ASSOCIATED_ITEMS, LATE_BOUND_LIFETIME_ARGUMENTS};
use rustc_session::parse::feature_err;
use rustc_session::Session;
-use rustc_span::symbol::{sym, Ident, Symbol};
+use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{MultiSpan, Span, DUMMY_SP};
use rustc_target::spec::abi;
use rustc_trait_selection::traits;
@@ -475,7 +474,12 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
/// Report an error that a generic argument did not match the generic parameter that was
/// expected.
- fn generic_arg_mismatch_err(sess: &Session, arg: &GenericArg<'_>, kind: &'static str) {
+ fn generic_arg_mismatch_err(
+ sess: &Session,
+ arg: &GenericArg<'_>,
+ kind: &'static str,
+ help: Option<&str>,
+ ) {
let mut err = struct_span_err!(
sess,
arg.span(),
@@ -503,6 +507,10 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
let (first, last) =
if kind_ord < arg_ord { (kind, arg.descr()) } else { (arg.descr(), kind) };
err.note(&format!("{} arguments must be provided before {} arguments", first, last));
+
+ if let Some(help) = help {
+ err.help(help);
+ }
err.emit();
}
@@ -648,7 +656,60 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
if arg_count.correct.is_ok()
&& arg_count.explicit_late_bound == ExplicitLateBound::No
{
- Self::generic_arg_mismatch_err(tcx.sess, arg, kind.descr());
+ // We're going to iterate over the parameters to sort them out, and
+ // show that order to the user as a possible order for the parameters
+ let mut param_types_present = defs
+ .params
+ .clone()
+ .into_iter()
+ .map(|param| {
+ (
+ match param.kind {
+ GenericParamDefKind::Lifetime => {
+ ParamKindOrd::Lifetime
+ }
+ GenericParamDefKind::Type { .. } => {
+ ParamKindOrd::Type
+ }
+ GenericParamDefKind::Const => {
+ ParamKindOrd::Const
+ }
+ },
+ param,
+ )
+ })
+ .collect::<Vec<(ParamKindOrd, GenericParamDef)>>();
+ param_types_present.sort_by_key(|(ord, _)| *ord);
+ let (mut param_types_present, ordered_params): (
+ Vec<ParamKindOrd>,
+ Vec<GenericParamDef>,
+ ) = param_types_present.into_iter().unzip();
+ param_types_present.dedup();
+
+ Self::generic_arg_mismatch_err(
+ tcx.sess,
+ arg,
+ kind.descr(),
+ Some(&format!(
+ "reorder the arguments: {}: `<{}>`",
+ param_types_present
+ .into_iter()
+ .map(|ord| format!("{}s", ord.to_string()))
+ .collect::<Vec<String>>()
+ .join(", then "),
+ ordered_params
+ .into_iter()
+ .filter_map(|param| {
+ if param.name == kw::SelfUpper {
+ None
+ } else {
+ Some(param.name.to_string())
+ }
+ })
+ .collect::<Vec<String>>()
+ .join(", ")
+ )),
+ );
}
// We've reported the error, but we want to make sure that this
@@ -680,7 +741,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o {
assert_eq!(kind, "lifetime");
let provided =
force_infer_lt.expect("lifetimes ought to have been inferred");
- Self::generic_arg_mismatch_err(tcx.sess, provided, kind);
+ Self::generic_arg_mismatch_err(tcx.sess, provided, kind, None);
}
break;
diff --git a/src/test/ui/const-generics/const-arg-type-arg-misordered.stderr b/src/test/ui/const-generics/const-arg-type-arg-misordered.stderr
index ad38b632b75f0..4a6241de1b453 100644
--- a/src/test/ui/const-generics/const-arg-type-arg-misordered.stderr
+++ b/src/test/ui/const-generics/const-arg-type-arg-misordered.stderr
@@ -14,6 +14,7 @@ LL | fn foo<const N: usize>() -> Array<N, ()> {
| ^
|
= note: type arguments must be provided before constant arguments
+ = help: reorder the arguments: types, then consts: `<T, N>`
error: aborting due to previous error; 1 warning emitted
diff --git a/src/test/ui/suggestions/suggest-move-types.stderr b/src/test/ui/suggestions/suggest-move-types.stderr
index 96f1656bae4ac..3c2226574ee9e 100644
--- a/src/test/ui/suggestions/suggest-move-types.stderr
+++ b/src/test/ui/suggestions/suggest-move-types.stderr
@@ -125,6 +125,7 @@ LL | struct Cl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<T, 'a, A=(), B=(), C=()
| ^^
|
= note: lifetime arguments must be provided before type arguments
+ = help: reorder the arguments: lifetimes, then types: `<'a, 'b, 'c, T, U, V>`
error[E0747]: lifetime provided when a type was expected
--> $DIR/suggest-move-types.rs:82:56
@@ -133,6 +134,7 @@ LL | struct Dl<'a, 'b, 'c, T, U, V, M: ThreeWithLifetime<T, 'a, A=(), B=(), U, '
| ^^
|
= note: lifetime arguments must be provided before type arguments
+ = help: reorder the arguments: lifetimes, then types: `<'a, 'b, 'c, T, U, V>`
error: aborting due to 12 previous errors
From fc60282daea83a5deff651e6c5a93dbad4437be7 Mon Sep 17 00:00:00 2001
From: Solomon Ucko <solly.ucko@gmail.com>
Date: Tue, 28 Apr 2020 22:40:18 -0400
Subject: [PATCH 03/15] impl PartialEq<Vec<B>> for &[A], &mut [A]
---
src/liballoc/tests/vec.rs | 54 +++++++++++++++++++++++++++++++++++++++
src/liballoc/vec.rs | 5 ++++
2 files changed, 59 insertions(+)
diff --git a/src/liballoc/tests/vec.rs b/src/liballoc/tests/vec.rs
index a9813a8704f30..62a252c8be2e0 100644
--- a/src/liballoc/tests/vec.rs
+++ b/src/liballoc/tests/vec.rs
@@ -1,5 +1,6 @@
use std::borrow::Cow;
use std::collections::TryReserveError::*;
+use std::fmt::Debug;
use std::mem::size_of;
use std::panic::{catch_unwind, AssertUnwindSafe};
use std::vec::{Drain, IntoIter};
@@ -1588,3 +1589,56 @@ fn test_push_growth_strategy() {
}
}
}
+
+macro_rules! generate_assert_eq_vec_and_prim {
+ ($name:ident<$B:ident>($type:ty)) => {
+ fn $name<A: PartialEq<$B> + Debug, $B: Debug>(a: Vec<A>, b: $type) {
+ assert!(a == b);
+ assert_eq!(a, b);
+ }
+ };
+}
+
+generate_assert_eq_vec_and_prim! { assert_eq_vec_and_slice <B>(&[B]) }
+generate_assert_eq_vec_and_prim! { assert_eq_vec_and_array_3<B>([B; 3]) }
+
+#[test]
+fn partialeq_vec_and_prim() {
+ assert_eq_vec_and_slice(vec![1, 2, 3], &[1, 2, 3]);
+ assert_eq_vec_and_array_3(vec![1, 2, 3], [1, 2, 3]);
+}
+
+macro_rules! assert_partial_eq_valid {
+ ($a2:ident, $a3:ident; $b2:ident, $b3: ident) => {
+ assert!($a2 == $b2);
+ assert!($a2 != $b3);
+ assert!($a3 != $b2);
+ assert!($a3 == $b3);
+ assert_eq!($a2, $b2);
+ assert_ne!($a2, $b3);
+ assert_ne!($a3, $b2);
+ assert_eq!($a3, $b3);
+ };
+}
+
+#[test]
+fn partialeq_vec_full() {
+ let vec2: Vec<_> = vec![1, 2];
+ let vec3: Vec<_> = vec![1, 2, 3];
+ let slice2: &[_] = &[1, 2];
+ let slice3: &[_] = &[1, 2, 3];
+ let slicemut2: &[_] = &mut [1, 2];
+ let slicemut3: &[_] = &mut [1, 2, 3];
+ let array2: [_; 2] = [1, 2];
+ let array3: [_; 3] = [1, 2, 3];
+ let arrayref2: &[_; 2] = &[1, 2];
+ let arrayref3: &[_; 3] = &[1, 2, 3];
+
+ assert_partial_eq_valid!(vec2,vec3; vec2,vec3);
+ assert_partial_eq_valid!(vec2,vec3; slice2,slice3);
+ assert_partial_eq_valid!(vec2,vec3; slicemut2,slicemut3);
+ assert_partial_eq_valid!(slice2,slice3; vec2,vec3);
+ assert_partial_eq_valid!(slicemut2,slicemut3; vec2,vec3);
+ assert_partial_eq_valid!(vec2,vec3; array2,array3);
+ assert_partial_eq_valid!(vec2,vec3; arrayref2,arrayref3);
+}
diff --git a/src/liballoc/vec.rs b/src/liballoc/vec.rs
index f16cac05ea039..c886fa4092752 100644
--- a/src/liballoc/vec.rs
+++ b/src/liballoc/vec.rs
@@ -2362,6 +2362,8 @@ macro_rules! __impl_slice_eq1 {
__impl_slice_eq1! { [] Vec<A>, Vec<B>, }
__impl_slice_eq1! { [] Vec<A>, &[B], }
__impl_slice_eq1! { [] Vec<A>, &mut [B], }
+__impl_slice_eq1! { [] &[A], Vec<B>, }
+__impl_slice_eq1! { [] &mut [A], Vec<B>, }
__impl_slice_eq1! { [] Cow<'_, [A]>, Vec<B>, A: Clone }
__impl_slice_eq1! { [] Cow<'_, [A]>, &[B], A: Clone }
__impl_slice_eq1! { [] Cow<'_, [A]>, &mut [B], A: Clone }
@@ -2371,6 +2373,9 @@ __impl_slice_eq1! { [const N: usize] Vec<A>, &[B; N], [B; N]: LengthAtMost32 }
// NOTE: some less important impls are omitted to reduce code bloat
// FIXME(Centril): Reconsider this?
//__impl_slice_eq1! { [const N: usize] Vec<A>, &mut [B; N], [B; N]: LengthAtMost32 }
+//__impl_slice_eq1! { [const N: usize] [A; N], Vec<B>, [A; N]: LengthAtMost32 }
+//__impl_slice_eq1! { [const N: usize] &[A; N], Vec<B>, [A; N]: LengthAtMost32 }
+//__impl_slice_eq1! { [const N: usize] &mut [A; N], Vec<B>, [A; N]: LengthAtMost32 }
//__impl_slice_eq1! { [const N: usize] Cow<'a, [A]>, [B; N], [B; N]: LengthAtMost32 }
//__impl_slice_eq1! { [const N: usize] Cow<'a, [A]>, &[B; N], [B; N]: LengthAtMost32 }
//__impl_slice_eq1! { [const N: usize] Cow<'a, [A]>, &mut [B; N], [B; N]: LengthAtMost32 }
From 4896a06667ae8d2df4b55822f98c90e6a6965fbc Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Sat, 20 Jun 2020 16:02:21 -0700
Subject: [PATCH 04/15] Update stability attribute of new Vec PartialEq impls
---
src/liballoc/vec.rs | 26 +++++++++++++-------------
1 file changed, 13 insertions(+), 13 deletions(-)
diff --git a/src/liballoc/vec.rs b/src/liballoc/vec.rs
index c886fa4092752..e245204751f0b 100644
--- a/src/liballoc/vec.rs
+++ b/src/liballoc/vec.rs
@@ -2344,12 +2344,12 @@ impl<'a, T: 'a + Copy> Extend<&'a T> for Vec<T> {
}
macro_rules! __impl_slice_eq1 {
- ([$($vars:tt)*] $lhs:ty, $rhs:ty, $($constraints:tt)*) => {
- #[stable(feature = "rust1", since = "1.0.0")]
+ ([$($vars:tt)*] $lhs:ty, $rhs:ty $(where $ty:ty: $bound:ident)?, #[$stability:meta]) => {
+ #[$stability]
impl<A, B, $($vars)*> PartialEq<$rhs> for $lhs
where
A: PartialEq<B>,
- $($constraints)*
+ $($ty: $bound)?
{
#[inline]
fn eq(&self, other: &$rhs) -> bool { self[..] == other[..] }
@@ -2359,16 +2359,16 @@ macro_rules! __impl_slice_eq1 {
}
}
-__impl_slice_eq1! { [] Vec<A>, Vec<B>, }
-__impl_slice_eq1! { [] Vec<A>, &[B], }
-__impl_slice_eq1! { [] Vec<A>, &mut [B], }
-__impl_slice_eq1! { [] &[A], Vec<B>, }
-__impl_slice_eq1! { [] &mut [A], Vec<B>, }
-__impl_slice_eq1! { [] Cow<'_, [A]>, Vec<B>, A: Clone }
-__impl_slice_eq1! { [] Cow<'_, [A]>, &[B], A: Clone }
-__impl_slice_eq1! { [] Cow<'_, [A]>, &mut [B], A: Clone }
-__impl_slice_eq1! { [const N: usize] Vec<A>, [B; N], [B; N]: LengthAtMost32 }
-__impl_slice_eq1! { [const N: usize] Vec<A>, &[B; N], [B; N]: LengthAtMost32 }
+__impl_slice_eq1! { [] Vec<A>, Vec<B>, #[stable(feature = "rust1", since = "1.0.0")] }
+__impl_slice_eq1! { [] Vec<A>, &[B], #[stable(feature = "rust1", since = "1.0.0")] }
+__impl_slice_eq1! { [] Vec<A>, &mut [B], #[stable(feature = "rust1", since = "1.0.0")] }
+__impl_slice_eq1! { [] &[A], Vec<B>, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")] }
+__impl_slice_eq1! { [] &mut [A], Vec<B>, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")] }
+__impl_slice_eq1! { [] Cow<'_, [A]>, Vec<B> where A: Clone, #[stable(feature = "rust1", since = "1.0.0")] }
+__impl_slice_eq1! { [] Cow<'_, [A]>, &[B] where A: Clone, #[stable(feature = "rust1", since = "1.0.0")] }
+__impl_slice_eq1! { [] Cow<'_, [A]>, &mut [B] where A: Clone, #[stable(feature = "rust1", since = "1.0.0")] }
+__impl_slice_eq1! { [const N: usize] Vec<A>, [B; N] where [B; N]: LengthAtMost32, #[stable(feature = "rust1", since = "1.0.0")] }
+__impl_slice_eq1! { [const N: usize] Vec<A>, &[B; N] where [B; N]: LengthAtMost32, #[stable(feature = "rust1", since = "1.0.0")] }
// NOTE: some less important impls are omitted to reduce code bloat
// FIXME(Centril): Reconsider this?
From 63740548aa8887c92d8976ccf478cfb0c44611a5 Mon Sep 17 00:00:00 2001
From: Youngsuk Kim <joseph942010@gmail.com>
Date: Sat, 20 Jun 2020 22:53:51 -0400
Subject: [PATCH 05/15] Fix typos in doc comments
This commit fixes typos in the doc comments of 'librustc_mir/monomorphize/collector.rs'
---
src/librustc_mir/monomorphize/collector.rs | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
index 36f3947d83017..448d8cdd6c6f6 100644
--- a/src/librustc_mir/monomorphize/collector.rs
+++ b/src/librustc_mir/monomorphize/collector.rs
@@ -1,7 +1,7 @@
//! Mono Item Collection
//! ====================
//!
-//! This module is responsible for discovering all items that will contribute to
+//! This module is responsible for discovering all items that will contribute
//! to code generation of the crate. The important part here is that it not only
//! needs to find syntax-level items (functions, structs, etc) but also all
//! their monomorphized instantiations. Every non-generic, non-const function
@@ -79,7 +79,7 @@
//! function or method call (represented by a CALL terminator in MIR). But
//! calls are not the only thing that might introduce a reference between two
//! function mono items, and as we will see below, they are just a
-//! specialized of the form described next, and consequently will don't get any
+//! specialized of the form described next, and consequently will not get any
//! special treatment in the algorithm.
//!
//! #### Taking a reference to a function or method
@@ -158,7 +158,7 @@
//! - Eager mode is meant to be used in conjunction with incremental compilation
//! where a stable set of mono items is more important than a minimal
//! one. Thus, eager mode will instantiate drop-glue for every drop-able type
-//! in the crate, even of no drop call for that type exists (yet). It will
+//! in the crate, even if no drop call for that type exists (yet). It will
//! also instantiate default implementations of trait methods, something that
//! otherwise is only done on demand.
//!
From e3d735dcbf3f777169c273f660b1388c521bb91c Mon Sep 17 00:00:00 2001
From: Johannes Schilling <dario@deaktualisierung.org>
Date: Sun, 21 Jun 2020 10:22:19 +0200
Subject: [PATCH 06/15] Fix typo in error_codes doc
---
src/librustc_error_codes/error_codes/E0081.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/librustc_error_codes/error_codes/E0081.md b/src/librustc_error_codes/error_codes/E0081.md
index fd5eca68e21fd..b834a734cefc4 100644
--- a/src/librustc_error_codes/error_codes/E0081.md
+++ b/src/librustc_error_codes/error_codes/E0081.md
@@ -1,4 +1,4 @@
-A discrimant value is present more than once.
+A discriminant value is present more than once.
Erroneous code example:
From 1c74ab42267d5d110fb7af5794c028849607f65d Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 21 Jun 2020 11:20:48 +0200
Subject: [PATCH 07/15] Make is_freeze and is_copy_modulo_regions take TyCtxtAt
---
src/librustc_codegen_ssa/traits/type_.rs | 2 +-
src/librustc_lint/builtin.rs | 2 +-
src/librustc_middle/ty/layout.rs | 2 +-
src/librustc_middle/ty/util.rs | 14 ++++----------
src/librustc_mir/dataflow/impls/borrowed_locals.rs | 2 +-
src/librustc_mir/interpret/eval_context.rs | 2 +-
src/librustc_mir/interpret/intern.rs | 2 +-
src/librustc_mir/shim.rs | 2 +-
src/librustc_mir/transform/check_consts/qualifs.rs | 2 +-
src/librustc_mir/transform/check_unsafety.rs | 13 ++++++-------
src/librustc_mir/transform/promote_consts.rs | 4 ++--
src/librustc_mir/transform/validate.rs | 2 +-
src/librustc_mir_build/build/expr/as_operand.rs | 2 +-
src/librustc_mir_build/hair/pattern/check_match.rs | 2 +-
src/librustc_passes/intrinsicck.rs | 2 +-
src/librustc_trait_selection/infer.rs | 2 +-
src/librustc_ty/needs_drop.rs | 2 +-
src/tools/clippy/clippy_lints/src/functions.rs | 2 +-
src/tools/clippy/clippy_lints/src/let_if_seq.rs | 3 +--
src/tools/clippy/clippy_lints/src/mut_key.rs | 2 +-
.../clippy/clippy_lints/src/non_copy_const.rs | 2 +-
src/tools/clippy/clippy_lints/src/question_mark.rs | 2 +-
src/tools/clippy/clippy_lints/src/utils/mod.rs | 2 +-
23 files changed, 32 insertions(+), 40 deletions(-)
diff --git a/src/librustc_codegen_ssa/traits/type_.rs b/src/librustc_codegen_ssa/traits/type_.rs
index 703479b74bef8..c55bf9858b972 100644
--- a/src/librustc_codegen_ssa/traits/type_.rs
+++ b/src/librustc_codegen_ssa/traits/type_.rs
@@ -74,7 +74,7 @@ pub trait DerivedTypeMethods<'tcx>: BaseTypeMethods<'tcx> + MiscMethods<'tcx> {
}
fn type_is_freeze(&self, ty: Ty<'tcx>) -> bool {
- ty.is_freeze(self.tcx(), ty::ParamEnv::reveal_all(), DUMMY_SP)
+ ty.is_freeze(self.tcx().at(DUMMY_SP), ty::ParamEnv::reveal_all())
}
fn type_has_metadata(&self, ty: Ty<'tcx>) -> bool {
diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs
index b7f728ec60cfd..e746396e4c684 100644
--- a/src/librustc_lint/builtin.rs
+++ b/src/librustc_lint/builtin.rs
@@ -562,7 +562,7 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for MissingCopyImplementations {
return;
}
let param_env = ty::ParamEnv::empty();
- if ty.is_copy_modulo_regions(cx.tcx, param_env, item.span) {
+ if ty.is_copy_modulo_regions(cx.tcx.at(item.span), param_env) {
return;
}
if can_type_implement_copy(cx.tcx, param_env, ty).is_ok() {
diff --git a/src/librustc_middle/ty/layout.rs b/src/librustc_middle/ty/layout.rs
index 68af22569e353..e4cc96dd83bfb 100644
--- a/src/librustc_middle/ty/layout.rs
+++ b/src/librustc_middle/ty/layout.rs
@@ -2159,7 +2159,7 @@ where
ty::Ref(_, ty, mt) if offset.bytes() == 0 => {
let tcx = cx.tcx();
- let is_freeze = ty.is_freeze(tcx, cx.param_env(), DUMMY_SP);
+ let is_freeze = ty.is_freeze(tcx.at(DUMMY_SP), cx.param_env());
let kind = match mt {
hir::Mutability::Not => {
if is_freeze {
diff --git a/src/librustc_middle/ty/util.rs b/src/librustc_middle/ty/util.rs
index 47110be53b252..67ad7ee708267 100644
--- a/src/librustc_middle/ty/util.rs
+++ b/src/librustc_middle/ty/util.rs
@@ -681,11 +681,10 @@ impl<'tcx> ty::TyS<'tcx> {
/// winds up being reported as an error during NLL borrow check.
pub fn is_copy_modulo_regions(
&'tcx self,
- tcx: TyCtxt<'tcx>,
+ tcx_at: TyCtxtAt<'tcx>,
param_env: ty::ParamEnv<'tcx>,
- span: Span,
) -> bool {
- tcx.at(span).is_copy_raw(param_env.and(self))
+ tcx_at.is_copy_raw(param_env.and(self))
}
/// Checks whether values of this type `T` have a size known at
@@ -706,13 +705,8 @@ impl<'tcx> ty::TyS<'tcx> {
/// that the `Freeze` trait is not exposed to end users and is
/// effectively an implementation detail.
// FIXME: use `TyCtxtAt` instead of separate `Span`.
- pub fn is_freeze(
- &'tcx self,
- tcx: TyCtxt<'tcx>,
- param_env: ty::ParamEnv<'tcx>,
- span: Span,
- ) -> bool {
- self.is_trivially_freeze() || tcx.at(span).is_freeze_raw(param_env.and(self))
+ pub fn is_freeze(&'tcx self, tcx_at: TyCtxtAt<'tcx>, param_env: ty::ParamEnv<'tcx>) -> bool {
+ self.is_trivially_freeze() || tcx_at.is_freeze_raw(param_env.and(self))
}
/// Fast path helper for testing if a type is `Freeze`.
diff --git a/src/librustc_mir/dataflow/impls/borrowed_locals.rs b/src/librustc_mir/dataflow/impls/borrowed_locals.rs
index 70c916a089270..a3fc51cad656b 100644
--- a/src/librustc_mir/dataflow/impls/borrowed_locals.rs
+++ b/src/librustc_mir/dataflow/impls/borrowed_locals.rs
@@ -233,7 +233,7 @@ impl MutBorrow<'mir, 'tcx> {
///
/// [rust-lang/unsafe-code-guidelines#134]: https://github.com/rust-lang/unsafe-code-guidelines/issues/134
fn shared_borrow_allows_mutation(&self, place: Place<'tcx>) -> bool {
- !place.ty(self.body, self.tcx).ty.is_freeze(self.tcx, self.param_env, DUMMY_SP)
+ !place.ty(self.body, self.tcx).ty.is_freeze(self.tcx.at(DUMMY_SP), self.param_env)
}
}
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
index 22f4691c22b3d..91b1ec8b3a3ad 100644
--- a/src/librustc_mir/interpret/eval_context.rs
+++ b/src/librustc_mir/interpret/eval_context.rs
@@ -391,7 +391,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
#[inline]
pub fn type_is_freeze(&self, ty: Ty<'tcx>) -> bool {
- ty.is_freeze(*self.tcx, self.param_env, self.tcx.span)
+ ty.is_freeze(self.tcx, self.param_env)
}
pub fn load_mir(
diff --git a/src/librustc_mir/interpret/intern.rs b/src/librustc_mir/interpret/intern.rs
index cab13d379a2cc..dffbc969c21b8 100644
--- a/src/librustc_mir/interpret/intern.rs
+++ b/src/librustc_mir/interpret/intern.rs
@@ -111,7 +111,7 @@ fn intern_shallow<'rt, 'mir, 'tcx, M: CompileTimeMachine<'mir, 'tcx>>(
if let InternMode::Static(mutability) = mode {
// For this, we need to take into account `UnsafeCell`. When `ty` is `None`, we assume
// no interior mutability.
- let frozen = ty.map_or(true, |ty| ty.is_freeze(*ecx.tcx, ecx.param_env, ecx.tcx.span));
+ let frozen = ty.map_or(true, |ty| ty.is_freeze(ecx.tcx, ecx.param_env));
// For statics, allocation mutability is the combination of the place mutability and
// the type mutability.
// The entire allocation needs to be mutable if it contains an `UnsafeCell` anywhere.
diff --git a/src/librustc_mir/shim.rs b/src/librustc_mir/shim.rs
index 15a2e9130a37e..8327affd982ed 100644
--- a/src/librustc_mir/shim.rs
+++ b/src/librustc_mir/shim.rs
@@ -327,7 +327,7 @@ fn build_clone_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, self_ty: Ty<'tcx>) -
let param_env = tcx.param_env(def_id);
let mut builder = CloneShimBuilder::new(tcx, def_id, self_ty);
- let is_copy = self_ty.is_copy_modulo_regions(tcx, param_env, builder.span);
+ let is_copy = self_ty.is_copy_modulo_regions(tcx.at(builder.span), param_env);
let dest = Place::return_place();
let src = tcx.mk_place_deref(Place::from(Local::new(1 + 0)));
diff --git a/src/librustc_mir/transform/check_consts/qualifs.rs b/src/librustc_mir/transform/check_consts/qualifs.rs
index 936c1a84e142e..e2893e81a2ce6 100644
--- a/src/librustc_mir/transform/check_consts/qualifs.rs
+++ b/src/librustc_mir/transform/check_consts/qualifs.rs
@@ -77,7 +77,7 @@ impl Qualif for HasMutInterior {
}
fn in_any_value_of_ty(cx: &ConstCx<'_, 'tcx>, ty: Ty<'tcx>) -> bool {
- !ty.is_freeze(cx.tcx, cx.param_env, DUMMY_SP)
+ !ty.is_freeze(cx.tcx.at(DUMMY_SP), cx.param_env)
}
fn in_adt_inherently(cx: &ConstCx<'_, 'tcx>, adt: &'tcx AdtDef, _: SubstsRef<'tcx>) -> bool {
diff --git a/src/librustc_mir/transform/check_unsafety.rs b/src/librustc_mir/transform/check_unsafety.rs
index 7dbb2ebad8b99..9898cde520778 100644
--- a/src/librustc_mir/transform/check_unsafety.rs
+++ b/src/librustc_mir/transform/check_unsafety.rs
@@ -282,9 +282,8 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsafetyChecker<'a, 'tcx> {
),
};
if !elem_ty.is_copy_modulo_regions(
- self.tcx,
+ self.tcx.at(self.source_info.span),
self.param_env,
- self.source_info.span,
) {
self.require_unsafe(
"assignment to non-`Copy` union field",
@@ -459,11 +458,11 @@ impl<'a, 'tcx> UnsafetyChecker<'a, 'tcx> {
// Check `is_freeze` as late as possible to avoid cycle errors
// with opaque types.
- } else if !place.ty(self.body, self.tcx).ty.is_freeze(
- self.tcx,
- self.param_env,
- self.source_info.span,
- ) {
+ } else if !place
+ .ty(self.body, self.tcx)
+ .ty
+ .is_freeze(self.tcx.at(self.source_info.span), self.param_env)
+ {
(
"borrow of layout constrained field with interior \
mutability",
diff --git a/src/librustc_mir/transform/promote_consts.rs b/src/librustc_mir/transform/promote_consts.rs
index 330f6c1640ff4..8bcbcd79ae60b 100644
--- a/src/librustc_mir/transform/promote_consts.rs
+++ b/src/librustc_mir/transform/promote_consts.rs
@@ -341,7 +341,7 @@ impl<'tcx> Validator<'_, 'tcx> {
Place::ty_from(place.local, proj_base, self.body, self.tcx)
.projection_ty(self.tcx, elem)
.ty;
- if ty.is_freeze(self.tcx, self.param_env, DUMMY_SP) {
+ if ty.is_freeze(self.tcx.at(DUMMY_SP), self.param_env) {
has_mut_interior = false;
break;
}
@@ -678,7 +678,7 @@ impl<'tcx> Validator<'_, 'tcx> {
let ty = Place::ty_from(place.local, proj_base, self.body, self.tcx)
.projection_ty(self.tcx, elem)
.ty;
- if ty.is_freeze(self.tcx, self.param_env, DUMMY_SP) {
+ if ty.is_freeze(self.tcx.at(DUMMY_SP), self.param_env) {
has_mut_interior = false;
break;
}
diff --git a/src/librustc_mir/transform/validate.rs b/src/librustc_mir/transform/validate.rs
index 625f40cd79206..953b335d9d798 100644
--- a/src/librustc_mir/transform/validate.rs
+++ b/src/librustc_mir/transform/validate.rs
@@ -90,7 +90,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
let ty = place.ty(&self.body.local_decls, self.tcx).ty;
let span = self.body.source_info(location).span;
- if !ty.is_copy_modulo_regions(self.tcx, self.param_env, span) {
+ if !ty.is_copy_modulo_regions(self.tcx.at(span), self.param_env) {
self.fail(location, format!("`Operand::Copy` with non-`Copy` type {}", ty));
}
}
diff --git a/src/librustc_mir_build/build/expr/as_operand.rs b/src/librustc_mir_build/build/expr/as_operand.rs
index 9a75f3afe8f08..5949fd1e22ce8 100644
--- a/src/librustc_mir_build/build/expr/as_operand.rs
+++ b/src/librustc_mir_build/build/expr/as_operand.rs
@@ -172,7 +172,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
if !ty.is_sized(tcx.at(span), param_env) {
// !sized means !copy, so this is an unsized move
- assert!(!ty.is_copy_modulo_regions(tcx, param_env, span));
+ assert!(!ty.is_copy_modulo_regions(tcx.at(span), param_env));
// As described above, detect the case where we are passing a value of unsized
// type, and that value is coming from the deref of a box.
diff --git a/src/librustc_mir_build/hair/pattern/check_match.rs b/src/librustc_mir_build/hair/pattern/check_match.rs
index 4d97a19f4086b..6fc447a87f57a 100644
--- a/src/librustc_mir_build/hair/pattern/check_match.rs
+++ b/src/librustc_mir_build/hair/pattern/check_match.rs
@@ -579,7 +579,7 @@ fn maybe_point_at_variant(ty: Ty<'_>, patterns: &[super::Pat<'_>]) -> Vec<Span>
/// Check if a by-value binding is by-value. That is, check if the binding's type is not `Copy`.
fn is_binding_by_move(cx: &MatchVisitor<'_, '_>, hir_id: HirId, span: Span) -> bool {
- !cx.tables.node_type(hir_id).is_copy_modulo_regions(cx.tcx, cx.param_env, span)
+ !cx.tables.node_type(hir_id).is_copy_modulo_regions(cx.tcx.at(span), cx.param_env)
}
/// Check the legality of legality of by-move bindings.
diff --git a/src/librustc_passes/intrinsicck.rs b/src/librustc_passes/intrinsicck.rs
index 88fb78f85e423..c8666ba1fd078 100644
--- a/src/librustc_passes/intrinsicck.rs
+++ b/src/librustc_passes/intrinsicck.rs
@@ -214,7 +214,7 @@ impl ExprVisitor<'tcx> {
// Check that the type implements Copy. The only case where this can
// possibly fail is for SIMD types which don't #[derive(Copy)].
- if !ty.is_copy_modulo_regions(self.tcx, self.param_env, DUMMY_SP) {
+ if !ty.is_copy_modulo_regions(self.tcx.at(DUMMY_SP), self.param_env) {
let msg = "arguments for inline assembly must be copyable";
let mut err = self.tcx.sess.struct_span_err(expr.span, msg);
err.note(&format!("`{}` does not implement the Copy trait", ty));
diff --git a/src/librustc_trait_selection/infer.rs b/src/librustc_trait_selection/infer.rs
index f244785b49d2f..dc895ad34a932 100644
--- a/src/librustc_trait_selection/infer.rs
+++ b/src/librustc_trait_selection/infer.rs
@@ -44,7 +44,7 @@ impl<'cx, 'tcx> InferCtxtExt<'tcx> for InferCtxt<'cx, 'tcx> {
let ty = self.resolve_vars_if_possible(&ty);
if !(param_env, ty).needs_infer() {
- return ty.is_copy_modulo_regions(self.tcx, param_env, span);
+ return ty.is_copy_modulo_regions(self.tcx.at(span), param_env);
}
let copy_def_id = self.tcx.require_lang_item(lang_items::CopyTraitLangItem, None);
diff --git a/src/librustc_ty/needs_drop.rs b/src/librustc_ty/needs_drop.rs
index 439bec1702eae..7880c09c2ad81 100644
--- a/src/librustc_ty/needs_drop.rs
+++ b/src/librustc_ty/needs_drop.rs
@@ -91,7 +91,7 @@ where
for component in components {
match component.kind {
- _ if component.is_copy_modulo_regions(tcx, self.param_env, DUMMY_SP) => (),
+ _ if component.is_copy_modulo_regions(tcx.at(DUMMY_SP), self.param_env) => (),
ty::Closure(_, substs) => {
for upvar_ty in substs.as_closure().upvar_tys() {
diff --git a/src/tools/clippy/clippy_lints/src/functions.rs b/src/tools/clippy/clippy_lints/src/functions.rs
index 991d129e8f0d6..1f9bd7a691b52 100644
--- a/src/tools/clippy/clippy_lints/src/functions.rs
+++ b/src/tools/clippy/clippy_lints/src/functions.rs
@@ -513,7 +513,7 @@ fn is_mutable_ty<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>, span: Span,
// primitive types are never mutable
ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => false,
ty::Adt(ref adt, ref substs) => {
- tys.insert(adt.did) && !ty.is_freeze(cx.tcx, cx.param_env, span)
+ tys.insert(adt.did) && !ty.is_freeze(cx.tcx.at(span), cx.param_env)
|| KNOWN_WRAPPER_TYS.iter().any(|path| match_def_path(cx, adt.did, path))
&& substs.types().any(|ty| is_mutable_ty(cx, ty, span, tys))
},
diff --git a/src/tools/clippy/clippy_lints/src/let_if_seq.rs b/src/tools/clippy/clippy_lints/src/let_if_seq.rs
index d7bf8a1476817..e097f40f87e47 100644
--- a/src/tools/clippy/clippy_lints/src/let_if_seq.rs
+++ b/src/tools/clippy/clippy_lints/src/let_if_seq.rs
@@ -74,9 +74,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for LetIfSeq {
let span = stmt.span.to(if_.span);
let has_interior_mutability = !cx.tables.node_type(canonical_id).is_freeze(
- cx.tcx,
+ cx.tcx.at(span),
cx.param_env,
- span
);
if has_interior_mutability { return; }
diff --git a/src/tools/clippy/clippy_lints/src/mut_key.rs b/src/tools/clippy/clippy_lints/src/mut_key.rs
index 0b9b7e1b8cc1b..93569a04f7a3a 100644
--- a/src/tools/clippy/clippy_lints/src/mut_key.rs
+++ b/src/tools/clippy/clippy_lints/src/mut_key.rs
@@ -118,7 +118,7 @@ fn is_mutable_type<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>, span: Spa
size.try_eval_usize(cx.tcx, cx.param_env).map_or(true, |u| u != 0) && is_mutable_type(cx, inner_ty, span)
},
Tuple(..) => ty.tuple_fields().any(|ty| is_mutable_type(cx, ty, span)),
- Adt(..) => cx.tcx.layout_of(cx.param_env.and(ty)).is_ok() && !ty.is_freeze(cx.tcx, cx.param_env, span),
+ Adt(..) => cx.tcx.layout_of(cx.param_env.and(ty)).is_ok() && !ty.is_freeze(cx.tcx.at(span), cx.param_env),
_ => false,
}
}
diff --git a/src/tools/clippy/clippy_lints/src/non_copy_const.rs b/src/tools/clippy/clippy_lints/src/non_copy_const.rs
index bb257e5a542d9..230dfd2ebf566 100644
--- a/src/tools/clippy/clippy_lints/src/non_copy_const.rs
+++ b/src/tools/clippy/clippy_lints/src/non_copy_const.rs
@@ -110,7 +110,7 @@ impl Source {
}
fn verify_ty_bound<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>, source: Source) {
- if ty.is_freeze(cx.tcx, cx.param_env, DUMMY_SP) || is_copy(cx, ty) {
+ if ty.is_freeze(cx.tcx.at(DUMMY_SP), cx.param_env) || is_copy(cx, ty) {
// An `UnsafeCell` is `!Copy`, and an `UnsafeCell` is also the only type which
// is `!Freeze`, thus if our type is `Copy` we can be sure it must be `Freeze`
// as well.
diff --git a/src/tools/clippy/clippy_lints/src/question_mark.rs b/src/tools/clippy/clippy_lints/src/question_mark.rs
index 3591972fe082f..d8a73f8054bca 100644
--- a/src/tools/clippy/clippy_lints/src/question_mark.rs
+++ b/src/tools/clippy/clippy_lints/src/question_mark.rs
@@ -137,7 +137,7 @@ impl QuestionMark {
fn moves_by_default(cx: &LateContext<'_, '_>, expression: &Expr<'_>) -> bool {
let expr_ty = cx.tables.expr_ty(expression);
- !expr_ty.is_copy_modulo_regions(cx.tcx, cx.param_env, expression.span)
+ !expr_ty.is_copy_modulo_regions(cx.tcx.at(expression.span), cx.param_env)
}
fn is_option(cx: &LateContext<'_, '_>, expression: &Expr<'_>) -> bool {
diff --git a/src/tools/clippy/clippy_lints/src/utils/mod.rs b/src/tools/clippy/clippy_lints/src/utils/mod.rs
index 60ab19e71f5e4..6d4c6c6ce1cea 100644
--- a/src/tools/clippy/clippy_lints/src/utils/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/mod.rs
@@ -891,7 +891,7 @@ pub fn type_is_unsafe_function<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx
}
pub fn is_copy<'a, 'tcx>(cx: &LateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
- ty.is_copy_modulo_regions(cx.tcx, cx.param_env, DUMMY_SP)
+ ty.is_copy_modulo_regions(cx.tcx.at(DUMMY_SP), cx.param_env)
}
/// Checks if an expression is constructing a tuple-like enum variant or struct
From 467415d50cdf8a0d15ec19dc63251443b35d4cee Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 21 Jun 2020 12:28:33 +0200
Subject: [PATCH 08/15] deprecate wrapping_offset_from
---
src/libcore/ptr/const_ptr.rs | 6 ++++++
src/libcore/ptr/mut_ptr.rs | 7 +++++++
2 files changed, 13 insertions(+)
diff --git a/src/libcore/ptr/const_ptr.rs b/src/libcore/ptr/const_ptr.rs
index e39d18d7733a2..acc09ddc014e6 100644
--- a/src/libcore/ptr/const_ptr.rs
+++ b/src/libcore/ptr/const_ptr.rs
@@ -330,6 +330,12 @@ impl<T: ?Sized> *const T {
/// assert_eq!(ptr2.wrapping_offset_from(ptr1), 2);
/// ```
#[unstable(feature = "ptr_wrapping_offset_from", issue = "41079")]
+ #[rustc_deprecated(
+ since = "1.46.0",
+ reason = "Pointer distances across allocation \
+ boundaries are not typically meaningful. \
+ Use integer subtraction if you really need this."
+ )]
#[inline]
pub fn wrapping_offset_from(self, origin: *const T) -> isize
where
diff --git a/src/libcore/ptr/mut_ptr.rs b/src/libcore/ptr/mut_ptr.rs
index 40b5e4e22340e..2bbeb95965e7e 100644
--- a/src/libcore/ptr/mut_ptr.rs
+++ b/src/libcore/ptr/mut_ptr.rs
@@ -380,11 +380,18 @@ impl<T: ?Sized> *mut T {
/// assert_eq!(ptr2.wrapping_offset_from(ptr1), 2);
/// ```
#[unstable(feature = "ptr_wrapping_offset_from", issue = "41079")]
+ #[rustc_deprecated(
+ since = "1.46.0",
+ reason = "Pointer distances across allocation \
+ boundaries are not typically meaningful. \
+ Use integer subtraction if you really need this."
+ )]
#[inline]
pub fn wrapping_offset_from(self, origin: *const T) -> isize
where
T: Sized,
{
+ #[allow(deprecated_in_future, deprecated)]
(self as *const T).wrapping_offset_from(origin)
}
From a657be42b1a7550c071bcccfc66dee22a55a96d1 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 21 Jun 2020 11:24:35 +0200
Subject: [PATCH 09/15] Create E0765 error for unterminated double quote
strings
---
src/librustc_error_codes/error_codes.rs | 1 +
src/librustc_error_codes/error_codes/E0765.md | 13 +++++++++++++
src/librustc_parse/lexer/mod.rs | 11 +++++++++--
3 files changed, 23 insertions(+), 2 deletions(-)
create mode 100644 src/librustc_error_codes/error_codes/E0765.md
diff --git a/src/librustc_error_codes/error_codes.rs b/src/librustc_error_codes/error_codes.rs
index 738b3bc7539a6..6a5e23adafa53 100644
--- a/src/librustc_error_codes/error_codes.rs
+++ b/src/librustc_error_codes/error_codes.rs
@@ -445,6 +445,7 @@ E0761: include_str!("./error_codes/E0761.md"),
E0762: include_str!("./error_codes/E0762.md"),
E0763: include_str!("./error_codes/E0763.md"),
E0764: include_str!("./error_codes/E0764.md"),
+E0765: include_str!("./error_codes/E0765.md"),
;
// E0006, // merged with E0005
// E0008, // cannot bind by-move into a pattern guard
diff --git a/src/librustc_error_codes/error_codes/E0765.md b/src/librustc_error_codes/error_codes/E0765.md
new file mode 100644
index 0000000000000..456e3f3e9e408
--- /dev/null
+++ b/src/librustc_error_codes/error_codes/E0765.md
@@ -0,0 +1,13 @@
+A double quote string (`"`) was not terminated.
+
+Erroneous code example:
+
+```compile_fail,E0765
+let s = "; // error!
+```
+
+To fix this error, add the missing double quote at the end of the string:
+
+```
+let s = ""; // ok!
+```
diff --git a/src/librustc_parse/lexer/mod.rs b/src/librustc_parse/lexer/mod.rs
index 2e3cf4e746ae9..8e74c3847bc90 100644
--- a/src/librustc_parse/lexer/mod.rs
+++ b/src/librustc_parse/lexer/mod.rs
@@ -353,8 +353,15 @@ impl<'a> StringReader<'a> {
}
rustc_lexer::LiteralKind::Str { terminated } => {
if !terminated {
- self.fatal_span_(start, suffix_start, "unterminated double quote string")
- .raise()
+ self.sess
+ .span_diagnostic
+ .struct_span_fatal_with_code(
+ self.mk_sp(start, suffix_start),
+ "unterminated double quote string",
+ error_code!(E0765),
+ )
+ .emit();
+ FatalError.raise();
}
(token::Str, Mode::Str, 1, 1) // " "
}
From 726b6f4a69a129ebf97d55f8cde1b3735b6df6aa Mon Sep 17 00:00:00 2001
From: Ralf Jung <post@ralfj.de>
Date: Sun, 21 Jun 2020 16:13:31 +0200
Subject: [PATCH 10/15] Miri: replace many bug! by span_bug!
---
src/librustc_mir/interpret/cast.rs | 36 ++++++++++++++++------
src/librustc_mir/interpret/eval_context.rs | 7 +++--
src/librustc_mir/interpret/intrinsics.rs | 7 ++++-
src/librustc_mir/interpret/operand.rs | 15 +++++----
src/librustc_mir/interpret/operator.rs | 22 ++++++++-----
src/librustc_mir/interpret/terminator.rs | 2 +-
6 files changed, 61 insertions(+), 28 deletions(-)
diff --git a/src/librustc_mir/interpret/cast.rs b/src/librustc_mir/interpret/cast.rs
index cfe856abe36dd..60cf21552e9e9 100644
--- a/src/librustc_mir/interpret/cast.rs
+++ b/src/librustc_mir/interpret/cast.rs
@@ -52,7 +52,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
}
if self.tcx.has_attr(def_id, sym::rustc_args_required_const) {
- bug!("reifying a fn ptr that requires const arguments");
+ span_bug!(
+ self.cur_span(),
+ "reifying a fn ptr that requires const arguments"
+ );
}
let instance = ty::Instance::resolve_for_fn_ptr(
@@ -66,7 +69,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));
self.write_scalar(fn_ptr, dest)?;
}
- _ => bug!("reify fn pointer on {:?}", src.layout.ty),
+ _ => span_bug!(self.cur_span(), "reify fn pointer on {:?}", src.layout.ty),
}
}
@@ -77,7 +80,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
// No change to value
self.write_immediate(*src, dest)?;
}
- _ => bug!("fn to unsafe fn cast on {:?}", cast_ty),
+ _ => span_bug!(self.cur_span(), "fn to unsafe fn cast on {:?}", cast_ty),
}
}
@@ -99,7 +102,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let fn_ptr = self.memory.create_fn_alloc(FnVal::Instance(instance));
self.write_scalar(fn_ptr, dest)?;
}
- _ => bug!("closure fn pointer on {:?}", src.layout.ty),
+ _ => span_bug!(self.cur_span(), "closure fn pointer on {:?}", src.layout.ty),
}
}
}
@@ -162,7 +165,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
assert!(src.layout.ty.is_unsafe_ptr());
return match *src {
Immediate::ScalarPair(data, _) => Ok(data.into()),
- Immediate::Scalar(..) => bug!(
+ Immediate::Scalar(..) => span_bug!(
+ self.cur_span(),
"{:?} input to a fat-to-thin cast ({:?} -> {:?})",
*src,
src.layout.ty,
@@ -216,7 +220,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
}
// Casts to bool are not permitted by rustc, no need to handle them here.
- _ => bug!("invalid int to {:?} cast", cast_ty),
+ _ => span_bug!(self.cur_span(), "invalid int to {:?} cast", cast_ty),
}
}
@@ -248,7 +252,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
// float -> f64
Float(FloatTy::F64) => Scalar::from_f64(f.convert(&mut false).value),
// That's it.
- _ => bug!("invalid float to {:?} cast", dest_ty),
+ _ => span_bug!(self.cur_span(), "invalid float to {:?} cast", dest_ty),
}
}
@@ -287,7 +291,9 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
self.write_immediate(val, dest)
}
- _ => bug!("invalid unsizing {:?} -> {:?}", src.layout.ty, cast_ty),
+ _ => {
+ span_bug!(self.cur_span(), "invalid unsizing {:?} -> {:?}", src.layout.ty, cast_ty)
+ }
}
}
@@ -307,7 +313,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
assert_eq!(def_a, def_b);
if def_a.is_box() || def_b.is_box() {
if !def_a.is_box() || !def_b.is_box() {
- bug!("invalid unsizing between {:?} -> {:?}", src.layout.ty, cast_ty.ty);
+ span_bug!(
+ self.cur_span(),
+ "invalid unsizing between {:?} -> {:?}",
+ src.layout.ty,
+ cast_ty.ty
+ );
}
return self.unsize_into_ptr(
src,
@@ -335,7 +346,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
}
Ok(())
}
- _ => bug!("unsize_into: invalid conversion: {:?} -> {:?}", src.layout, dest.layout),
+ _ => span_bug!(
+ self.cur_span(),
+ "unsize_into: invalid conversion: {:?} -> {:?}",
+ src.layout,
+ dest.layout
+ ),
}
}
}
diff --git a/src/librustc_mir/interpret/eval_context.rs b/src/librustc_mir/interpret/eval_context.rs
index 22f4691c22b3d..ceacbbe5139bf 100644
--- a/src/librustc_mir/interpret/eval_context.rs
+++ b/src/librustc_mir/interpret/eval_context.rs
@@ -536,7 +536,10 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
if sized_size == Size::ZERO {
return Ok(None);
} else {
- bug!("Fields cannot be extern types, unless they are at offset 0")
+ span_bug!(
+ self.cur_span(),
+ "Fields cannot be extern types, unless they are at offset 0"
+ )
}
}
};
@@ -584,7 +587,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
ty::Foreign(_) => Ok(None),
- _ => bug!("size_and_align_of::<{:?}> not supported", layout.ty),
+ _ => span_bug!(self.cur_span(), "size_and_align_of::<{:?}> not supported", layout.ty),
}
}
#[inline]
diff --git a/src/librustc_mir/interpret/intrinsics.rs b/src/librustc_mir/interpret/intrinsics.rs
index ac28ccd181520..31bdc45a2eab9 100644
--- a/src/librustc_mir/interpret/intrinsics.rs
+++ b/src/librustc_mir/interpret/intrinsics.rs
@@ -135,7 +135,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let bits = self.force_bits(val, layout_of.size)?;
let kind = match layout_of.abi {
Abi::Scalar(ref scalar) => scalar.value,
- _ => bug!("{} called on invalid type {:?}", intrinsic_name, ty),
+ _ => span_bug!(
+ self.cur_span(),
+ "{} called on invalid type {:?}",
+ intrinsic_name,
+ ty
+ ),
};
let (nonzero, intrinsic_name) = match intrinsic_name {
sym::cttz_nonzero => (true, sym::cttz),
diff --git a/src/librustc_mir/interpret/operand.rs b/src/librustc_mir/interpret/operand.rs
index 35e433c4bd5cd..38948ee53846a 100644
--- a/src/librustc_mir/interpret/operand.rs
+++ b/src/librustc_mir/interpret/operand.rs
@@ -311,7 +311,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
if let Ok(imm) = self.try_read_immediate(op)? {
Ok(imm)
} else {
- bug!("primitive read failed for type: {:?}", op.layout.ty);
+ span_bug!(self.cur_span(), "primitive read failed for type: {:?}", op.layout.ty);
}
}
@@ -360,9 +360,12 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let val = if offset.bytes() == 0 { a } else { b };
Immediate::from(val)
}
- Immediate::Scalar(val) => {
- bug!("field access on non aggregate {:#?}, {:#?}", val, op.layout)
- }
+ Immediate::Scalar(val) => span_bug!(
+ self.cur_span(),
+ "field access on non aggregate {:#?}, {:#?}",
+ val,
+ op.layout
+ ),
};
Ok(OpTy { op: Operand::Immediate(immediate), layout: field_layout })
}
@@ -545,7 +548,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
ty::ConstKind::Infer(..)
| ty::ConstKind::Bound(..)
| ty::ConstKind::Placeholder(..) => {
- bug!("eval_const_to_op: Unexpected ConstKind {:?}", val)
+ span_bug!(self.cur_span(), "eval_const_to_op: Unexpected ConstKind {:?}", val)
}
ty::ConstKind::Value(val_val) => val_val,
};
@@ -656,7 +659,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
.discriminants(def_id, *self.tcx)
.find(|(_, var)| var.val == discr_bits)
}
- _ => bug!("tagged layout for non-adt non-generator"),
+ _ => span_bug!(self.cur_span(), "tagged layout for non-adt non-generator"),
}
.ok_or_else(|| err_ub!(InvalidTag(tag_val.erase_tag())))?;
// Return the cast value, and the index.
diff --git a/src/librustc_mir/interpret/operator.rs b/src/librustc_mir/interpret/operator.rs
index d651267f82b79..607122935347e 100644
--- a/src/librustc_mir/interpret/operator.rs
+++ b/src/librustc_mir/interpret/operator.rs
@@ -61,7 +61,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
Le => l <= r,
Gt => l > r,
Ge => l >= r,
- _ => bug!("Invalid operation on char: {:?}", bin_op),
+ _ => span_bug!(self.cur_span(), "Invalid operation on char: {:?}", bin_op),
};
(Scalar::from_bool(res), false, self.tcx.types.bool)
}
@@ -84,7 +84,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
BitAnd => l & r,
BitOr => l | r,
BitXor => l ^ r,
- _ => bug!("Invalid operation on bool: {:?}", bin_op),
+ _ => span_bug!(self.cur_span(), "Invalid operation on bool: {:?}", bin_op),
};
(Scalar::from_bool(res), false, self.tcx.types.bool)
}
@@ -110,7 +110,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
Mul => ((l * r).value.into(), ty),
Div => ((l / r).value.into(), ty),
Rem => ((l % r).value.into(), ty),
- _ => bug!("invalid float op: `{:?}`", bin_op),
+ _ => span_bug!(self.cur_span(), "invalid float op: `{:?}`", bin_op),
};
(val, false, ty)
}
@@ -154,7 +154,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
// For the remaining ops, the types must be the same on both sides
if left_layout.ty != right_layout.ty {
- bug!(
+ span_bug!(
+ self.cur_span(),
"invalid asymmetric binary op {:?}: {:?} ({:?}), {:?} ({:?})",
bin_op,
l,
@@ -251,7 +252,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
));
}
- _ => bug!(
+ _ => span_bug!(
+ self.cur_span(),
"invalid binary op {:?}: {:?}, {:?} (both {:?})",
bin_op,
l,
@@ -333,7 +335,11 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
M::binary_ptr_op(self, bin_op, left, right)
}
- _ => bug!("Invalid MIR: bad LHS type for binop: {:?}", left.layout.ty),
+ _ => span_bug!(
+ self.cur_span(),
+ "Invalid MIR: bad LHS type for binop: {:?}",
+ left.layout.ty
+ ),
}
}
@@ -367,7 +373,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let val = val.to_bool()?;
let res = match un_op {
Not => !val,
- _ => bug!("Invalid bool op {:?}", un_op),
+ _ => span_bug!(self.cur_span(), "Invalid bool op {:?}", un_op),
};
Ok((Scalar::from_bool(res), false, self.tcx.types.bool))
}
@@ -375,7 +381,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
let res = match (un_op, fty) {
(Neg, FloatTy::F32) => Scalar::from_f32(-val.to_f32()?),
(Neg, FloatTy::F64) => Scalar::from_f64(-val.to_f64()?),
- _ => bug!("Invalid float op {:?}", un_op),
+ _ => span_bug!(self.cur_span(), "Invalid float op {:?}", un_op),
};
Ok((res, false, layout.ty))
}
diff --git a/src/librustc_mir/interpret/terminator.rs b/src/librustc_mir/interpret/terminator.rs
index 1d57fce39734e..0f3fbcf819574 100644
--- a/src/librustc_mir/interpret/terminator.rs
+++ b/src/librustc_mir/interpret/terminator.rs
@@ -232,7 +232,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
ty::FnDef(..) => instance_ty.fn_sig(*self.tcx).abi(),
ty::Closure(..) => Abi::RustCall,
ty::Generator(..) => Abi::Rust,
- _ => bug!("unexpected callee ty: {:?}", instance_ty),
+ _ => span_bug!(self.cur_span(), "unexpected callee ty: {:?}", instance_ty),
}
};
let normalize_abi = |abi| match abi {
From c14d85fd33934765fcf33122200cecca2d878061 Mon Sep 17 00:00:00 2001
From: Guillaume Gomez <guillaume1.gomez@gmail.com>
Date: Sun, 21 Jun 2020 11:24:45 +0200
Subject: [PATCH 11/15] Update UI tests
---
src/test/rustdoc-ui/test-compile-fail3.stderr | 3 ++-
src/test/rustdoc-ui/unparseable-doc-test.stdout | 3 ++-
src/test/ui/codemap_tests/tab_2.stderr | 3 ++-
src/test/ui/issues/issue-44078.stderr | 3 ++-
src/test/ui/parser/unbalanced-doublequote.stderr | 3 ++-
5 files changed, 10 insertions(+), 5 deletions(-)
diff --git a/src/test/rustdoc-ui/test-compile-fail3.stderr b/src/test/rustdoc-ui/test-compile-fail3.stderr
index 7a2f1815ed8e5..fab801b3beaea 100644
--- a/src/test/rustdoc-ui/test-compile-fail3.stderr
+++ b/src/test/rustdoc-ui/test-compile-fail3.stderr
@@ -1,4 +1,4 @@
-error: unterminated double quote string
+error[E0765]: unterminated double quote string
--> $DIR/test-compile-fail3.rs:3:1
|
3 | "fail
@@ -6,3 +6,4 @@ error: unterminated double quote string
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0765`.
diff --git a/src/test/rustdoc-ui/unparseable-doc-test.stdout b/src/test/rustdoc-ui/unparseable-doc-test.stdout
index 4ea6455d3aa4c..29cb22e2e4b09 100644
--- a/src/test/rustdoc-ui/unparseable-doc-test.stdout
+++ b/src/test/rustdoc-ui/unparseable-doc-test.stdout
@@ -5,7 +5,7 @@ test $DIR/unparseable-doc-test.rs - foo (line 6) ... FAILED
failures:
---- $DIR/unparseable-doc-test.rs - foo (line 6) stdout ----
-error: unterminated double quote string
+error[E0765]: unterminated double quote string
--> $DIR/unparseable-doc-test.rs:8:1
|
LL | "unterminated
@@ -13,6 +13,7 @@ LL | "unterminated
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0765`.
Couldn't compile the test.
failures:
diff --git a/src/test/ui/codemap_tests/tab_2.stderr b/src/test/ui/codemap_tests/tab_2.stderr
index 70414bbd953d6..0bfdc3ac2651d 100644
--- a/src/test/ui/codemap_tests/tab_2.stderr
+++ b/src/test/ui/codemap_tests/tab_2.stderr
@@ -1,4 +1,4 @@
-error: unterminated double quote string
+error[E0765]: unterminated double quote string
--> $DIR/tab_2.rs:4:7
|
LL | """;
@@ -8,3 +8,4 @@ LL | | }
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0765`.
diff --git a/src/test/ui/issues/issue-44078.stderr b/src/test/ui/issues/issue-44078.stderr
index 43b49e463128f..daf67219f4d0a 100644
--- a/src/test/ui/issues/issue-44078.stderr
+++ b/src/test/ui/issues/issue-44078.stderr
@@ -1,4 +1,4 @@
-error: unterminated double quote string
+error[E0765]: unterminated double quote string
--> $DIR/issue-44078.rs:2:8
|
LL | "😊"";
@@ -8,3 +8,4 @@ LL | | }
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0765`.
diff --git a/src/test/ui/parser/unbalanced-doublequote.stderr b/src/test/ui/parser/unbalanced-doublequote.stderr
index 4d98515c224ad..94b300a7bd765 100644
--- a/src/test/ui/parser/unbalanced-doublequote.stderr
+++ b/src/test/ui/parser/unbalanced-doublequote.stderr
@@ -1,4 +1,4 @@
-error: unterminated double quote string
+error[E0765]: unterminated double quote string
--> $DIR/unbalanced-doublequote.rs:5:5
|
LL | / "
@@ -7,3 +7,4 @@ LL | | }
error: aborting due to previous error
+For more information about this error, try `rustc --explain E0765`.
From 893077ca76eeb1ad35608872d534478d68c953c9 Mon Sep 17 00:00:00 2001
From: Youngsuk Kim <joseph942010@gmail.com>
Date: Sun, 21 Jun 2020 11:43:30 -0400
Subject: [PATCH 12/15] Update src/librustc_mir/monomorphize/collector.rs
typo fix
Co-authored-by: Jonas Schievink <jonasschievink@gmail.com>
---
src/librustc_mir/monomorphize/collector.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
index 448d8cdd6c6f6..e51d9ba9c021d 100644
--- a/src/librustc_mir/monomorphize/collector.rs
+++ b/src/librustc_mir/monomorphize/collector.rs
@@ -79,7 +79,7 @@
//! function or method call (represented by a CALL terminator in MIR). But
//! calls are not the only thing that might introduce a reference between two
//! function mono items, and as we will see below, they are just a
-//! specialized of the form described next, and consequently will not get any
+//! specialization of the form described next, and consequently will not get any
//! special treatment in the algorithm.
//!
//! #### Taking a reference to a function or method
From fea5ab12c269bd816b828d3ceea6bb90e4f72825 Mon Sep 17 00:00:00 2001
From: Dan Aloni <alonid@gmail.com>
Date: Sat, 13 Jun 2020 20:58:46 +0300
Subject: [PATCH 13/15] Prefer accessible paths in 'use' suggestions
This fixes an issue with the following sample:
mod foo {
mod inaccessible {
pub struct X;
}
pub mod avail {
pub struct X;
}
}
fn main() { X; }
Instead of suggesting both `use crate::foo::inaccessible::X;` and `use
crate::foo::avail::X;`, it should only suggest the latter.
It is done by trimming the list of suggestions from inaccessible paths
if accessible paths are present.
Visibility is checked with `is_accessible_from` now instead of being
hard-coded.
-
Some tests fixes are trivial, and others require a bit more explaining,
here are my comments:
src/test/ui/issues/issue-35675.stderr: Only needs to make the enum
public to have the suggestion make sense.
src/test/ui/issues/issue-42944.stderr: Importing the tuple struct won't
help because its constructor is not visible, so the attempted
constructor does not work. In that case, it's better not to suggest it.
The case where the constructor is public is covered in `issue-26545.rs`.
---
src/librustc_resolve/diagnostics.rs | 65 ++++++++++++++++--------
src/librustc_resolve/late/diagnostics.rs | 7 ++-
src/test/ui/hygiene/globs.stderr | 6 +--
src/test/ui/issues/issue-26545.rs | 12 +++++
src/test/ui/issues/issue-26545.stderr | 14 +++++
src/test/ui/issues/issue-35675.rs | 2 +-
src/test/ui/issues/issue-42944.rs | 12 ++---
src/test/ui/issues/issue-42944.stderr | 14 ++---
src/test/ui/issues/issue-4366-2.stderr | 4 +-
src/test/ui/issues/issue-4366.stderr | 4 +-
src/test/ui/privacy/privacy-ns1.stderr | 18 ++-----
src/test/ui/privacy/privacy-ns2.stderr | 18 ++-----
src/test/ui/resolve/issue-21221-1.stderr | 5 +-
13 files changed, 99 insertions(+), 82 deletions(-)
create mode 100644 src/test/ui/issues/issue-26545.rs
create mode 100644 src/test/ui/issues/issue-26545.stderr
diff --git a/src/librustc_resolve/diagnostics.rs b/src/librustc_resolve/diagnostics.rs
index bd2ce5a72e8d9..bb88b8191f1ad 100644
--- a/src/librustc_resolve/diagnostics.rs
+++ b/src/librustc_resolve/diagnostics.rs
@@ -49,6 +49,7 @@ crate struct ImportSuggestion {
pub did: Option<DefId>,
pub descr: &'static str,
pub path: Path,
+ pub accessible: bool,
}
/// Adjust the impl span so that just the `impl` keyword is taken by removing
@@ -640,9 +641,11 @@ impl<'a> Resolver<'a> {
let mut candidates = Vec::new();
let mut seen_modules = FxHashSet::default();
let not_local_module = crate_name.name != kw::Crate;
- let mut worklist = vec![(start_module, Vec::<ast::PathSegment>::new(), not_local_module)];
+ let mut worklist =
+ vec![(start_module, Vec::<ast::PathSegment>::new(), true, not_local_module)];
- while let Some((in_module, path_segments, in_module_is_extern)) = worklist.pop() {
+ while let Some((in_module, path_segments, accessible, in_module_is_extern)) = worklist.pop()
+ {
// We have to visit module children in deterministic order to avoid
// instabilities in reported imports (#43552).
in_module.for_each_child(self, |this, ident, ns, name_binding| {
@@ -650,11 +653,20 @@ impl<'a> Resolver<'a> {
if name_binding.is_import() && !name_binding.is_extern_crate() {
return;
}
+
// avoid non-importable candidates as well
if !name_binding.is_importable() {
return;
}
+ let child_accessible =
+ accessible && this.is_accessible_from(name_binding.vis, parent_scope.module);
+
+ // do not venture inside inaccessible items of other crates
+ if in_module_is_extern && !child_accessible {
+ return;
+ }
+
// collect results based on the filter function
// avoid suggesting anything from the same module in which we are resolving
if ident.name == lookup_ident.name
@@ -673,22 +685,29 @@ impl<'a> Resolver<'a> {
segms.push(ast::PathSegment::from_ident(ident));
let path = Path { span: name_binding.span, segments: segms };
- // the entity is accessible in the following cases:
- // 1. if it's defined in the same crate, it's always
- // accessible (since private entities can be made public)
- // 2. if it's defined in another crate, it's accessible
- // only if both the module is public and the entity is
- // declared as public (due to pruning, we don't explore
- // outside crate private modules => no need to check this)
- if !in_module_is_extern || name_binding.vis == ty::Visibility::Public {
- let did = match res {
- Res::Def(DefKind::Ctor(..), did) => this.parent(did),
- _ => res.opt_def_id(),
- };
- if candidates.iter().all(|v: &ImportSuggestion| v.did != did) {
- candidates.push(ImportSuggestion { did, descr: res.descr(), path });
+ let did = match res {
+ Res::Def(DefKind::Ctor(..), did) => this.parent(did),
+ _ => res.opt_def_id(),
+ };
+
+ if child_accessible {
+ // Remove invisible match if exists
+ if let Some(idx) = candidates
+ .iter()
+ .position(|v: &ImportSuggestion| v.did == did && !v.accessible)
+ {
+ candidates.remove(idx);
}
}
+
+ if candidates.iter().all(|v: &ImportSuggestion| v.did != did) {
+ candidates.push(ImportSuggestion {
+ did,
+ descr: res.descr(),
+ path,
+ accessible: child_accessible,
+ });
+ }
}
}
@@ -701,20 +720,22 @@ impl<'a> Resolver<'a> {
let is_extern_crate_that_also_appears_in_prelude =
name_binding.is_extern_crate() && lookup_ident.span.rust_2018();
- let is_visible_to_user =
- !in_module_is_extern || name_binding.vis == ty::Visibility::Public;
-
- if !is_extern_crate_that_also_appears_in_prelude && is_visible_to_user {
- // add the module to the lookup
+ if !is_extern_crate_that_also_appears_in_prelude {
let is_extern = in_module_is_extern || name_binding.is_extern_crate();
+ // add the module to the lookup
if seen_modules.insert(module.def_id().unwrap()) {
- worklist.push((module, path_segments, is_extern));
+ worklist.push((module, path_segments, child_accessible, is_extern));
}
}
}
})
}
+ // If only some candidates are accessible, take just them
+ if !candidates.iter().all(|v: &ImportSuggestion| !v.accessible) {
+ candidates = candidates.into_iter().filter(|x| x.accessible).collect();
+ }
+
candidates
}
diff --git a/src/librustc_resolve/late/diagnostics.rs b/src/librustc_resolve/late/diagnostics.rs
index 05ef0aa0bb689..478698ba20c70 100644
--- a/src/librustc_resolve/late/diagnostics.rs
+++ b/src/librustc_resolve/late/diagnostics.rs
@@ -887,7 +887,12 @@ impl<'a> LateResolutionVisitor<'a, '_, '_> {
let path = Path { span: name_binding.span, segments: path_segments };
result = Some((
module,
- ImportSuggestion { did: Some(def_id), descr: "module", path },
+ ImportSuggestion {
+ did: Some(def_id),
+ descr: "module",
+ path,
+ accessible: true,
+ },
));
} else {
// add the module to the lookup
diff --git a/src/test/ui/hygiene/globs.stderr b/src/test/ui/hygiene/globs.stderr
index 8f6b7aca8fda8..6dcbf055a8bb7 100644
--- a/src/test/ui/hygiene/globs.stderr
+++ b/src/test/ui/hygiene/globs.stderr
@@ -23,14 +23,10 @@ LL | | }
| |_____- in this macro invocation
|
= note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
-help: consider importing one of these items
+help: consider importing this function
|
LL | use bar::g;
|
-LL | use foo::test2::test::g;
- |
-LL | use foo::test::g;
- |
error[E0425]: cannot find function `f` in this scope
--> $DIR/globs.rs:61:12
diff --git a/src/test/ui/issues/issue-26545.rs b/src/test/ui/issues/issue-26545.rs
new file mode 100644
index 0000000000000..5652ee7470605
--- /dev/null
+++ b/src/test/ui/issues/issue-26545.rs
@@ -0,0 +1,12 @@
+mod foo {
+ pub struct B(pub ());
+}
+
+mod baz {
+ fn foo() {
+ B(());
+ //~^ ERROR cannot find function, tuple struct or tuple variant `B` in this scope [E0425]
+ }
+}
+
+fn main() {}
diff --git a/src/test/ui/issues/issue-26545.stderr b/src/test/ui/issues/issue-26545.stderr
new file mode 100644
index 0000000000000..d3c86692501d6
--- /dev/null
+++ b/src/test/ui/issues/issue-26545.stderr
@@ -0,0 +1,14 @@
+error[E0425]: cannot find function, tuple struct or tuple variant `B` in this scope
+ --> $DIR/issue-26545.rs:7:9
+ |
+LL | B(());
+ | ^ not found in this scope
+ |
+help: consider importing this tuple struct
+ |
+LL | use foo::B;
+ |
+
+error: aborting due to previous error
+
+For more information about this error, try `rustc --explain E0425`.
diff --git a/src/test/ui/issues/issue-35675.rs b/src/test/ui/issues/issue-35675.rs
index 7876811a9ac39..683761667d40a 100644
--- a/src/test/ui/issues/issue-35675.rs
+++ b/src/test/ui/issues/issue-35675.rs
@@ -33,7 +33,7 @@ fn qux() -> Some {
fn main() {}
mod x {
- enum Enum {
+ pub enum Enum {
Variant1,
Variant2(),
Variant3(usize),
diff --git a/src/test/ui/issues/issue-42944.rs b/src/test/ui/issues/issue-42944.rs
index cc365dc4c938e..a088f91554dfb 100644
--- a/src/test/ui/issues/issue-42944.rs
+++ b/src/test/ui/issues/issue-42944.rs
@@ -1,20 +1,20 @@
mod foo {
- pub struct B(());
+ pub struct Bx(());
}
mod bar {
- use foo::B;
+ use foo::Bx;
fn foo() {
- B(());
- //~^ ERROR expected function, tuple struct or tuple variant, found struct `B` [E0423]
+ Bx(());
+ //~^ ERROR expected function, tuple struct or tuple variant, found struct `Bx` [E0423]
}
}
mod baz {
fn foo() {
- B(());
- //~^ ERROR cannot find function, tuple struct or tuple variant `B` in this scope [E0425]
+ Bx(());
+ //~^ ERROR cannot find function, tuple struct or tuple variant `Bx` in this scope [E0425]
}
}
diff --git a/src/test/ui/issues/issue-42944.stderr b/src/test/ui/issues/issue-42944.stderr
index e7e251e39c04f..9fad43757ba62 100644
--- a/src/test/ui/issues/issue-42944.stderr
+++ b/src/test/ui/issues/issue-42944.stderr
@@ -1,18 +1,18 @@
-error[E0423]: expected function, tuple struct or tuple variant, found struct `B`
+error[E0423]: expected function, tuple struct or tuple variant, found struct `Bx`
--> $DIR/issue-42944.rs:9:9
|
-LL | B(());
- | ^ constructor is not visible here due to private fields
+LL | Bx(());
+ | ^^ constructor is not visible here due to private fields
-error[E0425]: cannot find function, tuple struct or tuple variant `B` in this scope
+error[E0425]: cannot find function, tuple struct or tuple variant `Bx` in this scope
--> $DIR/issue-42944.rs:16:9
|
-LL | B(());
- | ^ not found in this scope
+LL | Bx(());
+ | ^^ not found in this scope
|
help: consider importing this tuple struct
|
-LL | use foo::B;
+LL | use foo::Bx;
|
error: aborting due to 2 previous errors
diff --git a/src/test/ui/issues/issue-4366-2.stderr b/src/test/ui/issues/issue-4366-2.stderr
index ecee595d4ab6a..a86ec7fabea4b 100644
--- a/src/test/ui/issues/issue-4366-2.stderr
+++ b/src/test/ui/issues/issue-4366-2.stderr
@@ -15,12 +15,10 @@ error[E0423]: expected function, found module `foo`
LL | foo();
| ^^^ not a function
|
-help: consider importing one of these items instead
+help: consider importing this function instead
|
LL | use foo::foo;
|
-LL | use m1::foo;
- |
error: aborting due to 2 previous errors
diff --git a/src/test/ui/issues/issue-4366.stderr b/src/test/ui/issues/issue-4366.stderr
index a094180572daa..469ea93e90468 100644
--- a/src/test/ui/issues/issue-4366.stderr
+++ b/src/test/ui/issues/issue-4366.stderr
@@ -4,12 +4,10 @@ error[E0425]: cannot find function `foo` in this scope
LL | fn sub() -> isize { foo(); 1 }
| ^^^ not found in this scope
|
-help: consider importing one of these items
+help: consider importing this function
|
LL | use foo::foo;
|
-LL | use m1::foo;
- |
error: aborting due to previous error
diff --git a/src/test/ui/privacy/privacy-ns1.stderr b/src/test/ui/privacy/privacy-ns1.stderr
index 4d2af735fa6b9..eda9d4c128d81 100644
--- a/src/test/ui/privacy/privacy-ns1.stderr
+++ b/src/test/ui/privacy/privacy-ns1.stderr
@@ -11,14 +11,10 @@ help: a unit struct with a similar name exists
|
LL | Baz();
| ^^^
-help: consider importing one of these items instead
- |
-LL | use foo1::Bar;
+help: consider importing this function instead
|
LL | use foo2::Bar;
|
-LL | use foo3::Bar;
- |
error[E0425]: cannot find function, tuple struct or tuple variant `Bar` in this scope
--> $DIR/privacy-ns1.rs:51:5
@@ -33,14 +29,10 @@ help: a unit struct with a similar name exists
|
LL | Baz();
| ^^^
-help: consider importing one of these items
- |
-LL | use foo1::Bar;
+help: consider importing this function
|
LL | use foo2::Bar;
|
-LL | use foo3::Bar;
- |
error[E0412]: cannot find type `Bar` in this scope
--> $DIR/privacy-ns1.rs:52:17
@@ -55,14 +47,10 @@ help: a struct with a similar name exists
|
LL | let _x: Box<Baz>;
| ^^^
-help: consider importing one of these items
+help: consider importing this trait
|
LL | use foo1::Bar;
|
-LL | use foo2::Bar;
- |
-LL | use foo3::Bar;
- |
error[E0107]: wrong number of const arguments: expected 0, found 1
--> $DIR/privacy-ns1.rs:35:17
diff --git a/src/test/ui/privacy/privacy-ns2.stderr b/src/test/ui/privacy/privacy-ns2.stderr
index f1aa523742ae4..d7d9b83527509 100644
--- a/src/test/ui/privacy/privacy-ns2.stderr
+++ b/src/test/ui/privacy/privacy-ns2.stderr
@@ -4,14 +4,10 @@ error[E0423]: expected function, tuple struct or tuple variant, found trait `Bar
LL | Bar();
| ^^^ not a function, tuple struct or tuple variant
|
-help: consider importing one of these items instead
- |
-LL | use foo1::Bar;
+help: consider importing this function instead
|
LL | use foo2::Bar;
|
-LL | use foo3::Bar;
- |
error[E0423]: expected function, tuple struct or tuple variant, found trait `Bar`
--> $DIR/privacy-ns2.rs:26:5
@@ -26,14 +22,10 @@ help: a unit struct with a similar name exists
|
LL | Baz();
| ^^^
-help: consider importing one of these items instead
- |
-LL | use foo1::Bar;
+help: consider importing this function instead
|
LL | use foo2::Bar;
|
-LL | use foo3::Bar;
- |
error[E0573]: expected type, found function `Bar`
--> $DIR/privacy-ns2.rs:43:14
@@ -45,14 +37,10 @@ help: use `=` if you meant to assign
|
LL | let _x = Bar();
| ^
-help: consider importing one of these items instead
+help: consider importing this trait instead
|
LL | use foo1::Bar;
|
-LL | use foo2::Bar;
- |
-LL | use foo3::Bar;
- |
error[E0603]: trait `Bar` is private
--> $DIR/privacy-ns2.rs:63:15
diff --git a/src/test/ui/resolve/issue-21221-1.stderr b/src/test/ui/resolve/issue-21221-1.stderr
index d3e1953435359..538eeead9fc9d 100644
--- a/src/test/ui/resolve/issue-21221-1.stderr
+++ b/src/test/ui/resolve/issue-21221-1.stderr
@@ -25,11 +25,8 @@ LL | use mul1::Mul;
|
LL | use mul2::Mul;
|
-LL | use mul3::Mul;
- |
-LL | use mul4::Mul;
+LL | use std::ops::Mul;
|
- and 2 other candidates
error[E0405]: cannot find trait `ThisTraitReallyDoesntExistInAnyModuleReally` in this scope
--> $DIR/issue-21221-1.rs:63:6
From 20866c5cf74f0524f82f053c963bd008ff3898a9 Mon Sep 17 00:00:00 2001
From: Aaron Hill <aa1ronham@gmail.com>
Date: Sun, 21 Jun 2020 16:28:19 -0400
Subject: [PATCH 14/15] Revert "Rollup merge of #72389 -
Aaron1011:feature/move-fn-self-msg, r=nikomatsakis"
This reverts commit 372cb9b69c76a042d0b9d4b48ff6084f64c84a2c, reversing
changes made to 5c61a8dc34c3e2fc6d7f02cb288c350f0233f944.
---
src/librustc_ast_lowering/expr.rs | 24 +--
.../infer/error_reporting/need_type_info.rs | 2 +-
src/librustc_metadata/rmeta/decoder.rs | 4 +-
src/librustc_metadata/rmeta/encoder.rs | 16 +-
src/librustc_metadata/rmeta/mod.rs | 4 +-
src/librustc_middle/hir/map/mod.rs | 9 +-
src/librustc_middle/hir/mod.rs | 20 +--
src/librustc_middle/lint.rs | 4 +-
src/librustc_middle/query/mod.rs | 2 +-
.../diagnostics/conflict_errors.rs | 72 +-------
.../diagnostics/explain_borrow.rs | 2 +-
.../borrow_check/diagnostics/mod.rs | 150 +++--------------
.../borrow_check/diagnostics/move_errors.rs | 2 +-
.../diagnostics/mutability_errors.rs | 2 +-
src/librustc_mir/borrow_check/mod.rs | 6 -
src/librustc_mir/transform/const_prop.rs | 1 -
src/librustc_span/hygiene.rs | 13 +-
src/librustc_span/lib.rs | 4 +-
src/test/ui/binop/binop-consume-args.stderr | 70 ++------
src/test/ui/binop/binop-move-semantics.stderr | 21 +--
.../borrowck/borrowck-unboxed-closures.stderr | 7 +-
.../ui/closure_context/issue-42065.stderr | 7 +-
src/test/ui/codemap_tests/tab_3.stderr | 8 +-
.../ui/consts/miri_unleashed/ptr_arith.rs | 5 +-
.../ui/consts/miri_unleashed/ptr_arith.stderr | 4 +-
src/test/ui/hygiene/unpretty-debug.stdout | 4 -
src/test/ui/issues/issue-12127.stderr | 7 +-
src/test/ui/issues/issue-33941.rs | 1 -
src/test/ui/issues/issue-33941.stderr | 12 +-
src/test/ui/issues/issue-34721.stderr | 9 +-
src/test/ui/issues/issue-61108.stderr | 8 +-
src/test/ui/issues/issue-64559.stderr | 8 +-
src/test/ui/moves/move-fn-self-receiver.rs | 74 --------
.../ui/moves/move-fn-self-receiver.stderr | 158 ------------------
...moves-based-on-type-access-to-field.stderr | 8 +-
.../ui/moves/moves-based-on-type-exprs.stderr | 16 +-
.../ui/once-cant-call-twice-on-heap.stderr | 7 +-
...ed-closures-infer-fnonce-call-twice.stderr | 7 +-
...osures-infer-fnonce-move-call-twice.stderr | 7 +-
src/test/ui/unop-move-semantics.stderr | 7 +-
.../unsized-locals/borrow-after-move.stderr | 8 +-
src/test/ui/unsized-locals/double-move.stderr | 8 +-
.../use-after-move-self-based-on-type.stderr | 8 +-
src/test/ui/use/use-after-move-self.stderr | 8 +-
src/test/ui/walk-struct-literal-with.stderr | 8 +-
45 files changed, 103 insertions(+), 729 deletions(-)
delete mode 100644 src/test/ui/moves/move-fn-self-receiver.rs
delete mode 100644 src/test/ui/moves/move-fn-self-receiver.stderr
diff --git a/src/librustc_ast_lowering/expr.rs b/src/librustc_ast_lowering/expr.rs
index e59cacfffc926..b7894eb145b0a 100644
--- a/src/librustc_ast_lowering/expr.rs
+++ b/src/librustc_ast_lowering/expr.rs
@@ -9,7 +9,7 @@ use rustc_data_structures::thin_vec::ThinVec;
use rustc_errors::struct_span_err;
use rustc_hir as hir;
use rustc_hir::def::Res;
-use rustc_span::source_map::{respan, DesugaringKind, ForLoopLoc, Span, Spanned};
+use rustc_span::source_map::{respan, DesugaringKind, Span, Spanned};
use rustc_span::symbol::{sym, Ident, Symbol};
use rustc_target::asm;
use std::collections::hash_map::Entry;
@@ -25,7 +25,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
pub(super) fn lower_expr_mut(&mut self, e: &Expr) -> hir::Expr<'hir> {
- let mut span = e.span;
ensure_sufficient_stack(|| {
let kind = match e.kind {
ExprKind::Box(ref inner) => hir::ExprKind::Box(self.lower_expr(inner)),
@@ -54,7 +53,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
hir::ExprKind::MethodCall(hir_seg, seg.ident.span, args, span)
}
ExprKind::Binary(binop, ref lhs, ref rhs) => {
- span = self.mark_span_with_reason(DesugaringKind::Operator, e.span, None);
let binop = self.lower_binop(binop);
let lhs = self.lower_expr(lhs);
let rhs = self.lower_expr(rhs);
@@ -224,7 +222,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
hir::Expr {
hir_id: self.lower_node_id(e.id),
kind,
- span,
+ span: e.span,
attrs: e.attrs.iter().map(|a| self.lower_attr(a)).collect::<Vec<_>>().into(),
}
})
@@ -239,7 +237,6 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
fn lower_binop(&mut self, b: BinOp) -> hir::BinOp {
- let span = self.mark_span_with_reason(DesugaringKind::Operator, b.span, None);
Spanned {
node: match b.node {
BinOpKind::Add => hir::BinOpKind::Add,
@@ -261,7 +258,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
BinOpKind::Ge => hir::BinOpKind::Ge,
BinOpKind::Gt => hir::BinOpKind::Gt,
},
- span,
+ span: b.span,
}
}
@@ -1363,14 +1360,9 @@ impl<'hir> LoweringContext<'_, 'hir> {
body: &Block,
opt_label: Option<Label>,
) -> hir::Expr<'hir> {
- let orig_head_span = head.span;
// expand <head>
let mut head = self.lower_expr_mut(head);
- let desugared_span = self.mark_span_with_reason(
- DesugaringKind::ForLoop(ForLoopLoc::Head),
- orig_head_span,
- None,
- );
+ let desugared_span = self.mark_span_with_reason(DesugaringKind::ForLoop, head.span, None);
head.span = desugared_span;
let iter = Ident::with_dummy_span(sym::iter);
@@ -1465,16 +1457,10 @@ impl<'hir> LoweringContext<'_, 'hir> {
// `mut iter => { ... }`
let iter_arm = self.arm(iter_pat, loop_expr);
- let into_iter_span = self.mark_span_with_reason(
- DesugaringKind::ForLoop(ForLoopLoc::IntoIter),
- orig_head_span,
- None,
- );
-
// `match ::std::iter::IntoIterator::into_iter(<head>) { ... }`
let into_iter_expr = {
let into_iter_path = &[sym::iter, sym::IntoIterator, sym::into_iter];
- self.expr_call_std_path(into_iter_span, into_iter_path, arena_vec![self; head])
+ self.expr_call_std_path(desugared_span, into_iter_path, arena_vec![self; head])
};
let match_expr = self.arena.alloc(self.expr_match(
diff --git a/src/librustc_infer/infer/error_reporting/need_type_info.rs b/src/librustc_infer/infer/error_reporting/need_type_info.rs
index 1687bcc155636..04d941fb8a7c4 100644
--- a/src/librustc_infer/infer/error_reporting/need_type_info.rs
+++ b/src/librustc_infer/infer/error_reporting/need_type_info.rs
@@ -468,7 +468,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
let msg = if let Some(simple_ident) = pattern.simple_ident() {
match pattern.span.desugaring_kind() {
None => format!("consider giving `{}` {}", simple_ident, suffix),
- Some(DesugaringKind::ForLoop(_)) => {
+ Some(DesugaringKind::ForLoop) => {
"the element type for this iterator is not specified".to_string()
}
_ => format!("this needs {}", suffix),
diff --git a/src/librustc_metadata/rmeta/decoder.rs b/src/librustc_metadata/rmeta/decoder.rs
index 800f794121ab3..faa339a2bc9c4 100644
--- a/src/librustc_metadata/rmeta/decoder.rs
+++ b/src/librustc_metadata/rmeta/decoder.rs
@@ -1318,13 +1318,13 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
}
}
- fn get_fn_param_names(&self, tcx: TyCtxt<'tcx>, id: DefIndex) -> &'tcx [Ident] {
+ fn get_fn_param_names(&self, tcx: TyCtxt<'tcx>, id: DefIndex) -> &'tcx [Symbol] {
let param_names = match self.kind(id) {
EntryKind::Fn(data) | EntryKind::ForeignFn(data) => data.decode(self).param_names,
EntryKind::AssocFn(data) => data.decode(self).fn_data.param_names,
_ => Lazy::empty(),
};
- tcx.arena.alloc_from_iter(param_names.decode((self, tcx)))
+ tcx.arena.alloc_from_iter(param_names.decode(self))
}
fn exported_symbols(
diff --git a/src/librustc_metadata/rmeta/encoder.rs b/src/librustc_metadata/rmeta/encoder.rs
index 31821ea459f1b..19f7e31c6f347 100644
--- a/src/librustc_metadata/rmeta/encoder.rs
+++ b/src/librustc_metadata/rmeta/encoder.rs
@@ -30,7 +30,7 @@ use rustc_middle::ty::{self, SymbolName, Ty, TyCtxt};
use rustc_serialize::{opaque, Encodable, Encoder, SpecializedEncoder, UseSpecializedEncodable};
use rustc_session::config::CrateType;
use rustc_span::source_map::Spanned;
-use rustc_span::symbol::{sym, Ident, Symbol};
+use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{self, ExternalSource, FileName, SourceFile, Span};
use rustc_target::abi::VariantIdx;
use std::hash::Hash;
@@ -1009,12 +1009,18 @@ impl EncodeContext<'tcx> {
}
}
- fn encode_fn_param_names_for_body(&mut self, body_id: hir::BodyId) -> Lazy<[Ident]> {
- self.tcx.dep_graph.with_ignore(|| self.lazy(self.tcx.hir().body_param_names(body_id)))
+ fn encode_fn_param_names_for_body(&mut self, body_id: hir::BodyId) -> Lazy<[Symbol]> {
+ self.tcx.dep_graph.with_ignore(|| {
+ let body = self.tcx.hir().body(body_id);
+ self.lazy(body.params.iter().map(|arg| match arg.pat.kind {
+ hir::PatKind::Binding(_, _, ident, _) => ident.name,
+ _ => kw::Invalid,
+ }))
+ })
}
- fn encode_fn_param_names(&mut self, param_names: &[Ident]) -> Lazy<[Ident]> {
- self.lazy(param_names.iter())
+ fn encode_fn_param_names(&mut self, param_names: &[Ident]) -> Lazy<[Symbol]> {
+ self.lazy(param_names.iter().map(|ident| ident.name))
}
fn encode_optimized_mir(&mut self, def_id: LocalDefId) {
diff --git a/src/librustc_metadata/rmeta/mod.rs b/src/librustc_metadata/rmeta/mod.rs
index 381e7ee115e17..0edea63f922d6 100644
--- a/src/librustc_metadata/rmeta/mod.rs
+++ b/src/librustc_metadata/rmeta/mod.rs
@@ -19,7 +19,7 @@ use rustc_serialize::opaque::Encoder;
use rustc_session::config::SymbolManglingVersion;
use rustc_session::CrateDisambiguator;
use rustc_span::edition::Edition;
-use rustc_span::symbol::{Ident, Symbol};
+use rustc_span::symbol::Symbol;
use rustc_span::{self, Span};
use rustc_target::spec::{PanicStrategy, TargetTriple};
@@ -327,7 +327,7 @@ struct ModData {
struct FnData {
asyncness: hir::IsAsync,
constness: hir::Constness,
- param_names: Lazy<[Ident]>,
+ param_names: Lazy<[Symbol]>,
}
#[derive(RustcEncodable, RustcDecodable)]
diff --git a/src/librustc_middle/hir/map/mod.rs b/src/librustc_middle/hir/map/mod.rs
index e3e0856ffc52e..d1cfc4867a2fe 100644
--- a/src/librustc_middle/hir/map/mod.rs
+++ b/src/librustc_middle/hir/map/mod.rs
@@ -14,7 +14,7 @@ use rustc_hir::*;
use rustc_index::vec::IndexVec;
use rustc_span::hygiene::MacroKind;
use rustc_span::source_map::Spanned;
-use rustc_span::symbol::{kw, Ident, Symbol};
+use rustc_span::symbol::{kw, Symbol};
use rustc_span::Span;
use rustc_target::spec::abi::Abi;
@@ -374,13 +374,6 @@ impl<'hir> Map<'hir> {
})
}
- pub fn body_param_names(&self, id: BodyId) -> impl Iterator<Item = Ident> + 'hir {
- self.body(id).params.iter().map(|arg| match arg.pat.kind {
- PatKind::Binding(_, _, ident, _) => ident,
- _ => Ident::new(kw::Invalid, rustc_span::DUMMY_SP),
- })
- }
-
/// Returns the `BodyOwnerKind` of this `LocalDefId`.
///
/// Panics if `LocalDefId` does not have an associated body.
diff --git a/src/librustc_middle/hir/mod.rs b/src/librustc_middle/hir/mod.rs
index e152d11c081a1..1e3676496ce39 100644
--- a/src/librustc_middle/hir/mod.rs
+++ b/src/librustc_middle/hir/mod.rs
@@ -12,7 +12,10 @@ use rustc_data_structures::fingerprint::Fingerprint;
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_hir::def_id::{LocalDefId, LOCAL_CRATE};
-use rustc_hir::*;
+use rustc_hir::Body;
+use rustc_hir::HirId;
+use rustc_hir::ItemLocalId;
+use rustc_hir::Node;
use rustc_index::vec::IndexVec;
pub struct Owner<'tcx> {
@@ -76,20 +79,5 @@ pub fn provide(providers: &mut Providers<'_>) {
};
providers.hir_owner = |tcx, id| tcx.index_hir(LOCAL_CRATE).map[id].signature;
providers.hir_owner_nodes = |tcx, id| tcx.index_hir(LOCAL_CRATE).map[id].with_bodies.as_deref();
- providers.fn_arg_names = |tcx, id| {
- let hir = tcx.hir();
- let hir_id = hir.as_local_hir_id(id.expect_local());
- if let Some(body_id) = hir.maybe_body_owned_by(hir_id) {
- tcx.arena.alloc_from_iter(hir.body_param_names(body_id))
- } else if let Node::TraitItem(&TraitItem {
- kind: TraitItemKind::Fn(_, TraitFn::Required(idents)),
- ..
- }) = hir.get(hir_id)
- {
- tcx.arena.alloc_slice(idents)
- } else {
- span_bug!(hir.span(hir_id), "fn_arg_names: unexpected item {:?}", id);
- }
- };
map::provide(providers);
}
diff --git a/src/librustc_middle/lint.rs b/src/librustc_middle/lint.rs
index 923119e359c47..27239b4ad2e78 100644
--- a/src/librustc_middle/lint.rs
+++ b/src/librustc_middle/lint.rs
@@ -339,9 +339,7 @@ pub fn struct_lint_level<'s, 'd>(
pub fn in_external_macro(sess: &Session, span: Span) -> bool {
let expn_data = span.ctxt().outer_expn_data();
match expn_data.kind {
- ExpnKind::Root
- | ExpnKind::Desugaring(DesugaringKind::ForLoop(_))
- | ExpnKind::Desugaring(DesugaringKind::Operator) => false,
+ ExpnKind::Root | ExpnKind::Desugaring(DesugaringKind::ForLoop) => false,
ExpnKind::AstPass(_) | ExpnKind::Desugaring(_) => true, // well, it's "external"
ExpnKind::Macro(MacroKind::Bang, _) => {
// Dummy span for the `def_site` means it's an external macro.
diff --git a/src/librustc_middle/query/mod.rs b/src/librustc_middle/query/mod.rs
index ca51d5b949c06..9fd45ddf6e60e 100644
--- a/src/librustc_middle/query/mod.rs
+++ b/src/librustc_middle/query/mod.rs
@@ -723,7 +723,7 @@ rustc_queries! {
}
Other {
- query fn_arg_names(def_id: DefId) -> &'tcx [rustc_span::symbol::Ident] {
+ query fn_arg_names(def_id: DefId) -> &'tcx [Symbol] {
desc { |tcx| "looking up function parameter names for `{}`", tcx.def_path_str(def_id) }
}
/// Gets the rendered value of the specified constant or associated constant.
diff --git a/src/librustc_mir/borrow_check/diagnostics/conflict_errors.rs b/src/librustc_mir/borrow_check/diagnostics/conflict_errors.rs
index 2e897647a3beb..eb07c7e65f5c9 100644
--- a/src/librustc_mir/borrow_check/diagnostics/conflict_errors.rs
+++ b/src/librustc_mir/borrow_check/diagnostics/conflict_errors.rs
@@ -24,8 +24,7 @@ use crate::borrow_check::{
};
use super::{
- explain_borrow::BorrowExplanation, FnSelfUseKind, IncludingDowncast, RegionName,
- RegionNameSource, UseSpans,
+ explain_borrow::BorrowExplanation, IncludingDowncast, RegionName, RegionNameSource, UseSpans,
};
#[derive(Debug)]
@@ -151,70 +150,13 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
format!("value moved{} here, in previous iteration of loop", move_msg),
);
} else {
- if let UseSpans::FnSelfUse { var_span, fn_call_span, fn_span, kind } =
- move_spans
- {
- let place_name = self
- .describe_place(moved_place.as_ref())
- .map(|n| format!("`{}`", n))
- .unwrap_or_else(|| "value".to_owned());
- match kind {
- FnSelfUseKind::FnOnceCall => {
- err.span_label(
- fn_call_span,
- &format!("{} moved due to this call", place_name),
- );
- err.span_note(
- var_span,
- "this value implements `FnOnce`, which causes it to be moved when called",
- );
- }
- FnSelfUseKind::Operator { self_arg } => {
- err.span_label(
- fn_call_span,
- &format!("{} moved due to usage in operator", place_name),
- );
- if self.fn_self_span_reported.insert(fn_span) {
- err.span_note(
- self_arg.span,
- "calling this operator moves the left-hand side",
- );
- }
- }
- FnSelfUseKind::Normal { self_arg, implicit_into_iter } => {
- if implicit_into_iter {
- err.span_label(
- fn_call_span,
- &format!(
- "{} moved due to this implicit call to `.into_iter()`",
- place_name
- ),
- );
- } else {
- err.span_label(
- fn_call_span,
- &format!("{} moved due to this method call", place_name),
- );
- }
- // Avoid pointing to the same function in multiple different
- // error messages
- if self.fn_self_span_reported.insert(self_arg.span) {
- err.span_note(
- self_arg.span,
- &format!("this function consumes the receiver `self` by taking ownership of it, which moves {}", place_name)
- );
- }
- }
- }
- } else {
- err.span_label(move_span, format!("value moved{} here", move_msg));
- move_spans.var_span_label(
- &mut err,
- format!("variable moved due to use{}", move_spans.describe()),
- );
- }
+ err.span_label(move_span, format!("value moved{} here", move_msg));
+ move_spans.var_span_label(
+ &mut err,
+ format!("variable moved due to use{}", move_spans.describe()),
+ );
}
- if let Some(DesugaringKind::ForLoop(_)) = move_span.desugaring_kind() {
+ if Some(DesugaringKind::ForLoop) == move_span.desugaring_kind() {
let sess = self.infcx.tcx.sess;
if let Ok(snippet) = sess.source_map().span_to_snippet(move_span) {
err.span_suggestion(
diff --git a/src/librustc_mir/borrow_check/diagnostics/explain_borrow.rs b/src/librustc_mir/borrow_check/diagnostics/explain_borrow.rs
index d04059ff0fc7f..5253acbba7f1c 100644
--- a/src/librustc_mir/borrow_check/diagnostics/explain_borrow.rs
+++ b/src/librustc_mir/borrow_check/diagnostics/explain_borrow.rs
@@ -509,7 +509,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
// Used in a closure.
(LaterUseKind::ClosureCapture, var_span)
}
- UseSpans::OtherUse(span) | UseSpans::FnSelfUse { var_span: span, .. } => {
+ UseSpans::OtherUse(span) => {
let block = &self.body.basic_blocks()[location.block];
let kind = if let Some(&Statement {
diff --git a/src/librustc_mir/borrow_check/diagnostics/mod.rs b/src/librustc_mir/borrow_check/diagnostics/mod.rs
index 04f48cd658230..ca8e54ea28649 100644
--- a/src/librustc_mir/borrow_check/diagnostics/mod.rs
+++ b/src/librustc_mir/borrow_check/diagnostics/mod.rs
@@ -11,11 +11,7 @@ use rustc_middle::mir::{
};
use rustc_middle::ty::print::Print;
use rustc_middle::ty::{self, DefIdTree, Ty, TyCtxt};
-use rustc_span::{
- hygiene::{DesugaringKind, ForLoopLoc},
- symbol::sym,
- Span,
-};
+use rustc_span::{symbol::sym, Span};
use rustc_target::abi::VariantIdx;
use super::borrow_set::BorrowData;
@@ -37,7 +33,6 @@ crate use mutability_errors::AccessKind;
crate use outlives_suggestion::OutlivesSuggestionBuilder;
crate use region_errors::{ErrorConstraintInfo, RegionErrorKind, RegionErrors};
crate use region_name::{RegionName, RegionNameSource};
-use rustc_span::symbol::Ident;
pub(super) struct IncludingDowncast(pub(super) bool);
@@ -534,58 +529,33 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
}
}
-/// The span(s) associated to a use of a place.
+// The span(s) associated to a use of a place.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub(super) enum UseSpans {
- /// The access is caused by capturing a variable for a closure.
+ // The access is caused by capturing a variable for a closure.
ClosureUse {
- /// This is true if the captured variable was from a generator.
+ // This is true if the captured variable was from a generator.
generator_kind: Option<GeneratorKind>,
- /// The span of the args of the closure, including the `move` keyword if
- /// it's present.
+ // The span of the args of the closure, including the `move` keyword if
+ // it's present.
args_span: Span,
- /// The span of the first use of the captured variable inside the closure.
- var_span: Span,
- },
- /// The access is caused by using a variable as the receiver of a method
- /// that takes 'self'
- FnSelfUse {
- /// The span of the variable being moved
+ // The span of the first use of the captured variable inside the closure.
var_span: Span,
- /// The span of the method call on the variable
- fn_call_span: Span,
- /// The definition span of the method being called
- fn_span: Span,
- kind: FnSelfUseKind,
},
// This access has a single span associated to it: common case.
OtherUse(Span),
}
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
-pub(super) enum FnSelfUseKind {
- /// A normal method call of the form `receiver.foo(a, b, c)`
- Normal { self_arg: Ident, implicit_into_iter: bool },
- /// A call to `FnOnce::call_once`, desugared from `my_closure(a, b, c)`
- FnOnceCall,
- /// A call to an operator trait, desuraged from operator syntax (e.g. `a << b`)
- Operator { self_arg: Ident },
-}
-
impl UseSpans {
pub(super) fn args_or_use(self) -> Span {
match self {
- UseSpans::ClosureUse { args_span: span, .. }
- | UseSpans::FnSelfUse { var_span: span, .. }
- | UseSpans::OtherUse(span) => span,
+ UseSpans::ClosureUse { args_span: span, .. } | UseSpans::OtherUse(span) => span,
}
}
pub(super) fn var_or_use(self) -> Span {
match self {
- UseSpans::ClosureUse { var_span: span, .. }
- | UseSpans::FnSelfUse { var_span: span, .. }
- | UseSpans::OtherUse(span) => span,
+ UseSpans::ClosureUse { var_span: span, .. } | UseSpans::OtherUse(span) => span,
}
}
@@ -654,7 +624,6 @@ impl UseSpans {
{
match self {
closure @ UseSpans::ClosureUse { .. } => closure,
- fn_self @ UseSpans::FnSelfUse { .. } => fn_self,
UseSpans::OtherUse(_) => if_other(),
}
}
@@ -758,100 +727,21 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
debug!("move_spans: moved_place={:?} location={:?} stmt={:?}", moved_place, location, stmt);
if let StatementKind::Assign(box (_, Rvalue::Aggregate(ref kind, ref places))) = stmt.kind {
- match kind {
+ let def_id = match kind {
box AggregateKind::Closure(def_id, _)
- | box AggregateKind::Generator(def_id, _, _) => {
- debug!("move_spans: def_id={:?} places={:?}", def_id, places);
- if let Some((args_span, generator_kind, var_span)) =
- self.closure_span(*def_id, moved_place, places)
- {
- return ClosureUse { generator_kind, args_span, var_span };
- }
- }
- _ => {}
- }
- }
-
- let normal_ret = OtherUse(stmt.source_info.span);
-
- // We are trying to find MIR of the form:
- // ```
- // _temp = _moved_val;
- // ...
- // FnSelfCall(_temp, ...)
- // ```
- //
- // where `_moved_val` is the place we generated the move error for,
- // `_temp` is some other local, and `FnSelfCall` is a function
- // that has a `self` parameter.
-
- let target_temp = match stmt.kind {
- StatementKind::Assign(box (temp, _)) if temp.as_local().is_some() => {
- temp.as_local().unwrap()
- }
- _ => return normal_ret,
- };
-
- debug!("move_spans: target_temp = {:?}", target_temp);
-
- if let Some(Terminator { kind: TerminatorKind::Call { func, args, fn_span, .. }, .. }) =
- &self.body[location.block].terminator
- {
- let mut method_did = None;
- if let Operand::Constant(box Constant { literal: ty::Const { ty, .. }, .. }) = func {
- if let ty::FnDef(def_id, _) = ty.kind {
- debug!("move_spans: fn = {:?}", def_id);
- if let Some(ty::AssocItem { fn_has_self_parameter, .. }) =
- self.infcx.tcx.opt_associated_item(def_id)
- {
- if *fn_has_self_parameter {
- method_did = Some(def_id);
- }
- }
- }
- }
+ | box AggregateKind::Generator(def_id, _, _) => def_id,
+ _ => return OtherUse(stmt.source_info.span),
+ };
- let tcx = self.infcx.tcx;
- let method_did = if let Some(did) = method_did { did } else { return normal_ret };
-
- if let [Operand::Move(self_place), ..] = **args {
- if self_place.as_local() == Some(target_temp) {
- let is_fn_once = tcx.parent(method_did) == tcx.lang_items().fn_once_trait();
- let fn_call_span = *fn_span;
-
- let self_arg = tcx.fn_arg_names(method_did)[0];
-
- let kind = if is_fn_once {
- FnSelfUseKind::FnOnceCall
- } else if fn_call_span.is_desugaring(DesugaringKind::Operator) {
- FnSelfUseKind::Operator { self_arg }
- } else {
- debug!(
- "move_spans: method_did={:?}, fn_call_span={:?}",
- method_did, fn_call_span
- );
- let implicit_into_iter = matches!(
- fn_call_span.desugaring_kind(),
- Some(DesugaringKind::ForLoop(ForLoopLoc::IntoIter))
- );
- FnSelfUseKind::Normal { self_arg, implicit_into_iter }
- };
-
- return FnSelfUse {
- var_span: stmt.source_info.span,
- fn_call_span,
- fn_span: self
- .infcx
- .tcx
- .sess
- .source_map()
- .guess_head_span(self.infcx.tcx.def_span(method_did)),
- kind,
- };
- }
+ debug!("move_spans: def_id={:?} places={:?}", def_id, places);
+ if let Some((args_span, generator_kind, var_span)) =
+ self.closure_span(*def_id, moved_place, places)
+ {
+ return ClosureUse { generator_kind, args_span, var_span };
}
}
- return normal_ret;
+
+ OtherUse(stmt.source_info.span)
}
/// Finds the span of arguments of a closure (within `maybe_closure_span`)
diff --git a/src/librustc_mir/borrow_check/diagnostics/move_errors.rs b/src/librustc_mir/borrow_check/diagnostics/move_errors.rs
index 4883b08e42442..b49e4187fb810 100644
--- a/src/librustc_mir/borrow_check/diagnostics/move_errors.rs
+++ b/src/librustc_mir/borrow_check/diagnostics/move_errors.rs
@@ -408,7 +408,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
format!("{}.as_ref()", snippet),
Applicability::MaybeIncorrect,
);
- } else if matches!(span.desugaring_kind(), Some(DesugaringKind::ForLoop(_)))
+ } else if span.is_desugaring(DesugaringKind::ForLoop)
&& self.infcx.tcx.is_diagnostic_item(Symbol::intern("vec_type"), def_id)
{
// FIXME: suggest for anything that implements `IntoIterator`.
diff --git a/src/librustc_mir/borrow_check/diagnostics/mutability_errors.rs b/src/librustc_mir/borrow_check/diagnostics/mutability_errors.rs
index b4bc89e827daa..4d4b6fb9386db 100644
--- a/src/librustc_mir/borrow_check/diagnostics/mutability_errors.rs
+++ b/src/librustc_mir/borrow_check/diagnostics/mutability_errors.rs
@@ -365,7 +365,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
opt_assignment_rhs_span.and_then(|span| span.desugaring_kind());
match opt_desugaring_kind {
// on for loops, RHS points to the iterator part
- Some(DesugaringKind::ForLoop(_)) => Some((
+ Some(DesugaringKind::ForLoop) => Some((
false,
opt_assignment_rhs_span.unwrap(),
format!(
diff --git a/src/librustc_mir/borrow_check/mod.rs b/src/librustc_mir/borrow_check/mod.rs
index 83691d439eb81..03b663eb75056 100644
--- a/src/librustc_mir/borrow_check/mod.rs
+++ b/src/librustc_mir/borrow_check/mod.rs
@@ -278,7 +278,6 @@ fn do_mir_borrowck<'a, 'tcx>(
move_data: &move_data,
location_table: &LocationTable::new(promoted_body),
movable_generator,
- fn_self_span_reported: Default::default(),
locals_are_invalidated_at_exit,
access_place_error_reported: Default::default(),
reservation_error_reported: Default::default(),
@@ -312,7 +311,6 @@ fn do_mir_borrowck<'a, 'tcx>(
location_table,
movable_generator,
locals_are_invalidated_at_exit,
- fn_self_span_reported: Default::default(),
access_place_error_reported: Default::default(),
reservation_error_reported: Default::default(),
reservation_warnings: Default::default(),
@@ -489,10 +487,6 @@ crate struct MirBorrowckCtxt<'cx, 'tcx> {
// but it is currently inconvenient to track down the `BorrowIndex`
// at the time we detect and report a reservation error.
reservation_error_reported: FxHashSet<Place<'tcx>>,
- /// This fields keeps track of the `Span`s that we have
- /// used to report extra information for `FnSelfUse`, to avoid
- /// unnecessarily verbose errors.
- fn_self_span_reported: FxHashSet<Span>,
/// Migration warnings to be reported for #56254. We delay reporting these
/// so that we can suppress the warning if there's a corresponding error
/// for the activation of the borrow.
diff --git a/src/librustc_mir/transform/const_prop.rs b/src/librustc_mir/transform/const_prop.rs
index 529e63ab96791..2806d1c8949fe 100644
--- a/src/librustc_mir/transform/const_prop.rs
+++ b/src/librustc_mir/transform/const_prop.rs
@@ -505,7 +505,6 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
// This is basically `force_bits`.
let r_bits = r_bits.and_then(|r| r.to_bits_or_ptr(right_size, &self.tcx).ok());
if r_bits.map_or(false, |b| b >= left_size_bits as u128) {
- debug!("check_binary_op: reporting assert for {:?}", source_info);
self.report_assert_as_lint(
lint::builtin::ARITHMETIC_OVERFLOW,
source_info,
diff --git a/src/librustc_span/hygiene.rs b/src/librustc_span/hygiene.rs
index f2c9f8055b975..c0fb84e741f4a 100644
--- a/src/librustc_span/hygiene.rs
+++ b/src/librustc_span/hygiene.rs
@@ -822,15 +822,7 @@ pub enum DesugaringKind {
OpaqueTy,
Async,
Await,
- ForLoop(ForLoopLoc),
- Operator,
-}
-
-/// A location in the desugaring of a `for` loop
-#[derive(Clone, Copy, PartialEq, Debug, RustcEncodable, RustcDecodable, HashStable_Generic)]
-pub enum ForLoopLoc {
- Head,
- IntoIter,
+ ForLoop,
}
impl DesugaringKind {
@@ -843,8 +835,7 @@ impl DesugaringKind {
DesugaringKind::QuestionMark => "operator `?`",
DesugaringKind::TryBlock => "`try` block",
DesugaringKind::OpaqueTy => "`impl Trait`",
- DesugaringKind::ForLoop(_) => "`for` loop",
- DesugaringKind::Operator => "operator",
+ DesugaringKind::ForLoop => "`for` loop",
}
}
}
diff --git a/src/librustc_span/lib.rs b/src/librustc_span/lib.rs
index af9b5a264e313..9624006683467 100644
--- a/src/librustc_span/lib.rs
+++ b/src/librustc_span/lib.rs
@@ -31,9 +31,7 @@ pub mod edition;
use edition::Edition;
pub mod hygiene;
use hygiene::Transparency;
-pub use hygiene::{
- DesugaringKind, ExpnData, ExpnId, ExpnKind, ForLoopLoc, MacroKind, SyntaxContext,
-};
+pub use hygiene::{DesugaringKind, ExpnData, ExpnId, ExpnKind, MacroKind, SyntaxContext};
pub mod def_id;
use def_id::{CrateNum, DefId, LOCAL_CRATE};
mod span_encoding;
diff --git a/src/test/ui/binop/binop-consume-args.stderr b/src/test/ui/binop/binop-consume-args.stderr
index addc8a0efe1aa..acdc03e372638 100644
--- a/src/test/ui/binop/binop-consume-args.stderr
+++ b/src/test/ui/binop/binop-consume-args.stderr
@@ -4,15 +4,10 @@ error[E0382]: use of moved value: `lhs`
LL | fn add<A: Add<B, Output=()>, B>(lhs: A, rhs: B) {
| --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
LL | lhs + rhs;
- | --------- `lhs` moved due to usage in operator
+ | --- value moved here
LL | drop(lhs);
| ^^^ value used here after move
|
-note: calling this operator moves the left-hand side
- --> $SRC_DIR/libcore/ops/arith.rs:LL:COL
- |
-LL | fn add(self, rhs: Rhs) -> Self::Output;
- | ^^^^
help: consider further restricting this bound
|
LL | fn add<A: Add<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
@@ -40,15 +35,10 @@ error[E0382]: use of moved value: `lhs`
LL | fn sub<A: Sub<B, Output=()>, B>(lhs: A, rhs: B) {
| --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
LL | lhs - rhs;
- | --------- `lhs` moved due to usage in operator
+ | --- value moved here
LL | drop(lhs);
| ^^^ value used here after move
|
-note: calling this operator moves the left-hand side
- --> $SRC_DIR/libcore/ops/arith.rs:LL:COL
- |
-LL | fn sub(self, rhs: Rhs) -> Self::Output;
- | ^^^^
help: consider further restricting this bound
|
LL | fn sub<A: Sub<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
@@ -76,15 +66,10 @@ error[E0382]: use of moved value: `lhs`
LL | fn mul<A: Mul<B, Output=()>, B>(lhs: A, rhs: B) {
| --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
LL | lhs * rhs;
- | --------- `lhs` moved due to usage in operator
+ | --- value moved here
LL | drop(lhs);
| ^^^ value used here after move
|
-note: calling this operator moves the left-hand side
- --> $SRC_DIR/libcore/ops/arith.rs:LL:COL
- |
-LL | fn mul(self, rhs: Rhs) -> Self::Output;
- | ^^^^
help: consider further restricting this bound
|
LL | fn mul<A: Mul<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
@@ -112,15 +97,10 @@ error[E0382]: use of moved value: `lhs`
LL | fn div<A: Div<B, Output=()>, B>(lhs: A, rhs: B) {
| --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
LL | lhs / rhs;
- | --------- `lhs` moved due to usage in operator
+ | --- value moved here
LL | drop(lhs);
| ^^^ value used here after move
|
-note: calling this operator moves the left-hand side
- --> $SRC_DIR/libcore/ops/arith.rs:LL:COL
- |
-LL | fn div(self, rhs: Rhs) -> Self::Output;
- | ^^^^
help: consider further restricting this bound
|
LL | fn div<A: Div<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
@@ -148,15 +128,10 @@ error[E0382]: use of moved value: `lhs`
LL | fn rem<A: Rem<B, Output=()>, B>(lhs: A, rhs: B) {
| --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
LL | lhs % rhs;
- | --------- `lhs` moved due to usage in operator
+ | --- value moved here
LL | drop(lhs);
| ^^^ value used here after move
|
-note: calling this operator moves the left-hand side
- --> $SRC_DIR/libcore/ops/arith.rs:LL:COL
- |
-LL | fn rem(self, rhs: Rhs) -> Self::Output;
- | ^^^^
help: consider further restricting this bound
|
LL | fn rem<A: Rem<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
@@ -184,15 +159,10 @@ error[E0382]: use of moved value: `lhs`
LL | fn bitand<A: BitAnd<B, Output=()>, B>(lhs: A, rhs: B) {
| --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
LL | lhs & rhs;
- | --------- `lhs` moved due to usage in operator
+ | --- value moved here
LL | drop(lhs);
| ^^^ value used here after move
|
-note: calling this operator moves the left-hand side
- --> $SRC_DIR/libcore/ops/bit.rs:LL:COL
- |
-LL | fn bitand(self, rhs: Rhs) -> Self::Output;
- | ^^^^
help: consider further restricting this bound
|
LL | fn bitand<A: BitAnd<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
@@ -220,15 +190,10 @@ error[E0382]: use of moved value: `lhs`
LL | fn bitor<A: BitOr<B, Output=()>, B>(lhs: A, rhs: B) {
| --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
LL | lhs | rhs;
- | --------- `lhs` moved due to usage in operator
+ | --- value moved here
LL | drop(lhs);
| ^^^ value used here after move
|
-note: calling this operator moves the left-hand side
- --> $SRC_DIR/libcore/ops/bit.rs:LL:COL
- |
-LL | fn bitor(self, rhs: Rhs) -> Self::Output;
- | ^^^^
help: consider further restricting this bound
|
LL | fn bitor<A: BitOr<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
@@ -256,15 +221,10 @@ error[E0382]: use of moved value: `lhs`
LL | fn bitxor<A: BitXor<B, Output=()>, B>(lhs: A, rhs: B) {
| --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
LL | lhs ^ rhs;
- | --------- `lhs` moved due to usage in operator
+ | --- value moved here
LL | drop(lhs);
| ^^^ value used here after move
|
-note: calling this operator moves the left-hand side
- --> $SRC_DIR/libcore/ops/bit.rs:LL:COL
- |
-LL | fn bitxor(self, rhs: Rhs) -> Self::Output;
- | ^^^^
help: consider further restricting this bound
|
LL | fn bitxor<A: BitXor<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
@@ -292,15 +252,10 @@ error[E0382]: use of moved value: `lhs`
LL | fn shl<A: Shl<B, Output=()>, B>(lhs: A, rhs: B) {
| --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
LL | lhs << rhs;
- | ---------- `lhs` moved due to usage in operator
+ | --- value moved here
LL | drop(lhs);
| ^^^ value used here after move
|
-note: calling this operator moves the left-hand side
- --> $SRC_DIR/libcore/ops/bit.rs:LL:COL
- |
-LL | fn shl(self, rhs: Rhs) -> Self::Output;
- | ^^^^
help: consider further restricting this bound
|
LL | fn shl<A: Shl<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
@@ -328,15 +283,10 @@ error[E0382]: use of moved value: `lhs`
LL | fn shr<A: Shr<B, Output=()>, B>(lhs: A, rhs: B) {
| --- move occurs because `lhs` has type `A`, which does not implement the `Copy` trait
LL | lhs >> rhs;
- | ---------- `lhs` moved due to usage in operator
+ | --- value moved here
LL | drop(lhs);
| ^^^ value used here after move
|
-note: calling this operator moves the left-hand side
- --> $SRC_DIR/libcore/ops/bit.rs:LL:COL
- |
-LL | fn shr(self, rhs: Rhs) -> Self::Output;
- | ^^^^
help: consider further restricting this bound
|
LL | fn shr<A: Shr<B, Output=()> + Copy, B>(lhs: A, rhs: B) {
diff --git a/src/test/ui/binop/binop-move-semantics.stderr b/src/test/ui/binop/binop-move-semantics.stderr
index 97b70efe20e79..6d5ac9cab30c0 100644
--- a/src/test/ui/binop/binop-move-semantics.stderr
+++ b/src/test/ui/binop/binop-move-semantics.stderr
@@ -1,21 +1,14 @@
error[E0382]: use of moved value: `x`
--> $DIR/binop-move-semantics.rs:8:5
|
-LL | fn double_move<T: Add<Output=()>>(x: T) {
- | - move occurs because `x` has type `T`, which does not implement the `Copy` trait
-LL | / x
-LL | | +
-LL | | x;
- | | ^
- | | |
- | |_____value used here after move
- | `x` moved due to usage in operator
- |
-note: calling this operator moves the left-hand side
- --> $SRC_DIR/libcore/ops/arith.rs:LL:COL
+LL | fn double_move<T: Add<Output=()>>(x: T) {
+ | - move occurs because `x` has type `T`, which does not implement the `Copy` trait
+LL | x
+ | - value moved here
+LL | +
+LL | x;
+ | ^ value used here after move
|
-LL | fn add(self, rhs: Rhs) -> Self::Output;
- | ^^^^
help: consider further restricting this bound
|
LL | fn double_move<T: Add<Output=()> + Copy>(x: T) {
diff --git a/src/test/ui/borrowck/borrowck-unboxed-closures.stderr b/src/test/ui/borrowck/borrowck-unboxed-closures.stderr
index bc1721944fbbb..a51cda548efd7 100644
--- a/src/test/ui/borrowck/borrowck-unboxed-closures.stderr
+++ b/src/test/ui/borrowck/borrowck-unboxed-closures.stderr
@@ -22,15 +22,10 @@ error[E0382]: use of moved value: `f`
LL | fn c<F:FnOnce(isize, isize) -> isize>(f: F) {
| - move occurs because `f` has type `F`, which does not implement the `Copy` trait
LL | f(1, 2);
- | ------- `f` moved due to this call
+ | - value moved here
LL | f(1, 2);
| ^ value used here after move
|
-note: this value implements `FnOnce`, which causes it to be moved when called
- --> $DIR/borrowck-unboxed-closures.rs:11:5
- |
-LL | f(1, 2);
- | ^
help: consider further restricting this bound
|
LL | fn c<F:FnOnce(isize, isize) -> isize + Copy>(f: F) {
diff --git a/src/test/ui/closure_context/issue-42065.stderr b/src/test/ui/closure_context/issue-42065.stderr
index 896bb6dc6bee8..69d98654048cb 100644
--- a/src/test/ui/closure_context/issue-42065.stderr
+++ b/src/test/ui/closure_context/issue-42065.stderr
@@ -2,7 +2,7 @@ error[E0382]: use of moved value: `debug_dump_dict`
--> $DIR/issue-42065.rs:11:5
|
LL | debug_dump_dict();
- | ----------------- `debug_dump_dict` moved due to this call
+ | --------------- value moved here
LL | debug_dump_dict();
| ^^^^^^^^^^^^^^^ value used here after move
|
@@ -11,11 +11,6 @@ note: closure cannot be invoked more than once because it moves the variable `di
|
LL | for (key, value) in dict {
| ^^^^
-note: this value implements `FnOnce`, which causes it to be moved when called
- --> $DIR/issue-42065.rs:10:5
- |
-LL | debug_dump_dict();
- | ^^^^^^^^^^^^^^^
error: aborting due to previous error
diff --git a/src/test/ui/codemap_tests/tab_3.stderr b/src/test/ui/codemap_tests/tab_3.stderr
index 614e69e89f6ec..97816a76004d0 100644
--- a/src/test/ui/codemap_tests/tab_3.stderr
+++ b/src/test/ui/codemap_tests/tab_3.stderr
@@ -4,16 +4,10 @@ error[E0382]: borrow of moved value: `some_vec`
LL | let some_vec = vec!["hi"];
| -------- move occurs because `some_vec` has type `std::vec::Vec<&str>`, which does not implement the `Copy` trait
LL | some_vec.into_iter();
- | ----------- `some_vec` moved due to this method call
+ | -------- value moved here
LL | {
LL | println!("{:?}", some_vec);
| ^^^^^^^^ value borrowed here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `some_vec`
- --> $SRC_DIR/libcore/iter/traits/collect.rs:LL:COL
- |
-LL | fn into_iter(self) -> Self::IntoIter;
- | ^^^^
error: aborting due to previous error
diff --git a/src/test/ui/consts/miri_unleashed/ptr_arith.rs b/src/test/ui/consts/miri_unleashed/ptr_arith.rs
index 064dc6c262c88..65fc49c0b27a6 100644
--- a/src/test/ui/consts/miri_unleashed/ptr_arith.rs
+++ b/src/test/ui/consts/miri_unleashed/ptr_arith.rs
@@ -6,15 +6,14 @@
static CMP: () = {
let x = &0 as *const _;
- let _v = x == x; //~ NOTE in this
+ let _v = x == x;
//~^ ERROR could not evaluate static initializer
//~| NOTE pointer arithmetic or comparison
- //~| NOTE in this
};
static INT_PTR_ARITH: () = unsafe {
let x: usize = std::mem::transmute(&0);
- let _v = x + 0; //~ NOTE in this
+ let _v = x + 0;
//~^ ERROR could not evaluate static initializer
//~| NOTE pointer-to-integer cast
};
diff --git a/src/test/ui/consts/miri_unleashed/ptr_arith.stderr b/src/test/ui/consts/miri_unleashed/ptr_arith.stderr
index 4b3fe9957002e..805ba9c6b0307 100644
--- a/src/test/ui/consts/miri_unleashed/ptr_arith.stderr
+++ b/src/test/ui/consts/miri_unleashed/ptr_arith.stderr
@@ -5,7 +5,7 @@ LL | let _v = x == x;
| ^^^^^^ "pointer arithmetic or comparison" needs an rfc before being allowed inside constants
error[E0080]: could not evaluate static initializer
- --> $DIR/ptr_arith.rs:17:14
+ --> $DIR/ptr_arith.rs:16:14
|
LL | let _v = x + 0;
| ^^^^^ "pointer-to-integer cast" needs an rfc before being allowed inside constants
@@ -18,7 +18,7 @@ help: skipping check for `const_compare_raw_pointers` feature
LL | let _v = x == x;
| ^^^^^^
help: skipping check that does not even have a feature gate
- --> $DIR/ptr_arith.rs:16:20
+ --> $DIR/ptr_arith.rs:15:20
|
LL | let x: usize = std::mem::transmute(&0);
| ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/test/ui/hygiene/unpretty-debug.stdout b/src/test/ui/hygiene/unpretty-debug.stdout
index fc5ed724e3c67..acd852103cae3 100644
--- a/src/test/ui/hygiene/unpretty-debug.stdout
+++ b/src/test/ui/hygiene/unpretty-debug.stdout
@@ -18,12 +18,8 @@ fn y /* 0#0 */() { }
Expansions:
0: parent: ExpnId(0), call_site_ctxt: #0, kind: Root
1: parent: ExpnId(0), call_site_ctxt: #0, kind: Macro(Bang, "foo")
-2: parent: ExpnId(0), call_site_ctxt: #1, kind: Desugaring(Operator)
-3: parent: ExpnId(0), call_site_ctxt: #1, kind: Desugaring(Operator)
SyntaxContexts:
#0: parent: #0, outer_mark: (ExpnId(0), Opaque)
#1: parent: #0, outer_mark: (ExpnId(1), SemiTransparent)
-#2: parent: #1, outer_mark: (ExpnId(2), Transparent)
-#3: parent: #1, outer_mark: (ExpnId(3), Transparent)
*/
diff --git a/src/test/ui/issues/issue-12127.stderr b/src/test/ui/issues/issue-12127.stderr
index b759aa45e3eb7..2283b1275d018 100644
--- a/src/test/ui/issues/issue-12127.stderr
+++ b/src/test/ui/issues/issue-12127.stderr
@@ -2,15 +2,10 @@ error[E0382]: use of moved value: `f`
--> $DIR/issue-12127.rs:11:9
|
LL | f();
- | --- `f` moved due to this call
+ | - value moved here
LL | f();
| ^ value used here after move
|
-note: this value implements `FnOnce`, which causes it to be moved when called
- --> $DIR/issue-12127.rs:10:9
- |
-LL | f();
- | ^
= note: move occurs because `f` has type `[closure@$DIR/issue-12127.rs:8:24: 8:41 x:std::boxed::Box<isize>]`, which does not implement the `Copy` trait
error: aborting due to previous error
diff --git a/src/test/ui/issues/issue-33941.rs b/src/test/ui/issues/issue-33941.rs
index 4fb805b37e03f..ccaa6334856b4 100644
--- a/src/test/ui/issues/issue-33941.rs
+++ b/src/test/ui/issues/issue-33941.rs
@@ -3,5 +3,4 @@ use std::collections::HashMap;
fn main() {
for _ in HashMap::new().iter().cloned() {} //~ ERROR type mismatch
//~^ ERROR type mismatch
- //~| ERROR type mismatch
}
diff --git a/src/test/ui/issues/issue-33941.stderr b/src/test/ui/issues/issue-33941.stderr
index 20335d2cdd684..734ae78f362db 100644
--- a/src/test/ui/issues/issue-33941.stderr
+++ b/src/test/ui/issues/issue-33941.stderr
@@ -17,16 +17,6 @@ LL | for _ in HashMap::new().iter().cloned() {}
found reference `&_`
= note: required because of the requirements on the impl of `std::iter::Iterator` for `std::iter::Cloned<std::collections::hash_map::Iter<'_, _, _>>`
-error[E0271]: type mismatch resolving `<std::collections::hash_map::Iter<'_, _, _> as std::iter::Iterator>::Item == &_`
- --> $DIR/issue-33941.rs:4:14
- |
-LL | for _ in HashMap::new().iter().cloned() {}
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected tuple, found reference
- |
- = note: expected tuple `(&_, &_)`
- found reference `&_`
- = note: required because of the requirements on the impl of `std::iter::Iterator` for `std::iter::Cloned<std::collections::hash_map::Iter<'_, _, _>>`
-
-error: aborting due to 3 previous errors
+error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0271`.
diff --git a/src/test/ui/issues/issue-34721.stderr b/src/test/ui/issues/issue-34721.stderr
index b4cc1a0aa7eb2..6cfed20f43a04 100644
--- a/src/test/ui/issues/issue-34721.stderr
+++ b/src/test/ui/issues/issue-34721.stderr
@@ -5,19 +5,14 @@ LL | pub fn baz<T: Foo>(x: T) -> T {
| - move occurs because `x` has type `T`, which does not implement the `Copy` trait
LL | if 0 == 1 {
LL | bar::bar(x.zero())
- | ------ `x` moved due to this method call
+ | - value moved here
LL | } else {
LL | x.zero()
- | ------ `x` moved due to this method call
+ | - value moved here
LL | };
LL | x.zero()
| ^ value used here after move
|
-note: this function consumes the receiver `self` by taking ownership of it, which moves `x`
- --> $DIR/issue-34721.rs:4:13
- |
-LL | fn zero(self) -> Self;
- | ^^^^
help: consider further restricting this bound
|
LL | pub fn baz<T: Foo + Copy>(x: T) -> T {
diff --git a/src/test/ui/issues/issue-61108.stderr b/src/test/ui/issues/issue-61108.stderr
index ba43f2d33ee44..8523a6f6548a6 100644
--- a/src/test/ui/issues/issue-61108.stderr
+++ b/src/test/ui/issues/issue-61108.stderr
@@ -6,17 +6,11 @@ LL | let mut bad_letters = vec!['e', 't', 'o', 'i'];
LL | for l in bad_letters {
| -----------
| |
- | `bad_letters` moved due to this implicit call to `.into_iter()`
+ | value moved here
| help: consider borrowing to avoid moving into the for loop: `&bad_letters`
...
LL | bad_letters.push('s');
| ^^^^^^^^^^^ value borrowed here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `bad_letters`
- --> $SRC_DIR/libcore/iter/traits/collect.rs:LL:COL
- |
-LL | fn into_iter(self) -> Self::IntoIter;
- | ^^^^
error: aborting due to previous error
diff --git a/src/test/ui/issues/issue-64559.stderr b/src/test/ui/issues/issue-64559.stderr
index 2c337bae13017..3c685dc8d089a 100644
--- a/src/test/ui/issues/issue-64559.stderr
+++ b/src/test/ui/issues/issue-64559.stderr
@@ -6,18 +6,12 @@ LL | let orig = vec![true];
LL | for _val in orig {}
| ----
| |
- | `orig` moved due to this implicit call to `.into_iter()`
+ | value moved here
| help: consider borrowing to avoid moving into the for loop: `&orig`
LL | let _closure = || orig;
| ^^ ---- use occurs due to use in closure
| |
| value used here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `orig`
- --> $SRC_DIR/libcore/iter/traits/collect.rs:LL:COL
- |
-LL | fn into_iter(self) -> Self::IntoIter;
- | ^^^^
error: aborting due to previous error
diff --git a/src/test/ui/moves/move-fn-self-receiver.rs b/src/test/ui/moves/move-fn-self-receiver.rs
deleted file mode 100644
index 6107f53fa1960..0000000000000
--- a/src/test/ui/moves/move-fn-self-receiver.rs
+++ /dev/null
@@ -1,74 +0,0 @@
-use std::pin::Pin;
-use std::rc::Rc;
-use std::ops::Add;
-
-struct Foo;
-
-impl Add for Foo {
- type Output = ();
- fn add(self, _rhs: Self) -> () {}
-}
-
-impl Foo {
- fn use_self(self) {}
- fn use_box_self(self: Box<Self>) {}
- fn use_pin_box_self(self: Pin<Box<Self>>) {}
- fn use_rc_self(self: Rc<Self>) {}
- fn use_mut_self(&mut self) -> &mut Self { self }
-}
-
-struct Container(Vec<bool>);
-
-impl Container {
- fn custom_into_iter(self) -> impl Iterator<Item = bool> {
- self.0.into_iter()
- }
-}
-
-fn move_out(val: Container) {
- val.0.into_iter().next();
- val.0; //~ ERROR use of moved
-
- let foo = Foo;
- foo.use_self();
- foo; //~ ERROR use of moved
-
- let second_foo = Foo;
- second_foo.use_self();
- second_foo; //~ ERROR use of moved
-
- let boxed_foo = Box::new(Foo);
- boxed_foo.use_box_self();
- boxed_foo; //~ ERROR use of moved
-
- let pin_box_foo = Box::pin(Foo);
- pin_box_foo.use_pin_box_self();
- pin_box_foo; //~ ERROR use of moved
-
- let mut mut_foo = Foo;
- let ret = mut_foo.use_mut_self();
- mut_foo; //~ ERROR cannot move out
- ret;
-
- let rc_foo = Rc::new(Foo);
- rc_foo.use_rc_self();
- rc_foo; //~ ERROR use of moved
-
- let foo_add = Foo;
- foo_add + Foo;
- foo_add; //~ ERROR use of moved
-
- let implicit_into_iter = vec![true];
- for _val in implicit_into_iter {}
- implicit_into_iter; //~ ERROR use of moved
-
- let explicit_into_iter = vec![true];
- for _val in explicit_into_iter.into_iter() {}
- explicit_into_iter; //~ ERROR use of moved
-
- let container = Container(vec![]);
- for _val in container.custom_into_iter() {}
- container; //~ ERROR use of moved
-}
-
-fn main() {}
diff --git a/src/test/ui/moves/move-fn-self-receiver.stderr b/src/test/ui/moves/move-fn-self-receiver.stderr
deleted file mode 100644
index 4333e8a23e866..0000000000000
--- a/src/test/ui/moves/move-fn-self-receiver.stderr
+++ /dev/null
@@ -1,158 +0,0 @@
-error[E0382]: use of moved value: `val.0`
- --> $DIR/move-fn-self-receiver.rs:30:5
- |
-LL | val.0.into_iter().next();
- | ----------- `val.0` moved due to this method call
-LL | val.0;
- | ^^^^^ value used here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `val.0`
- --> $SRC_DIR/libcore/iter/traits/collect.rs:LL:COL
- |
-LL | fn into_iter(self) -> Self::IntoIter;
- | ^^^^
- = note: move occurs because `val.0` has type `std::vec::Vec<bool>`, which does not implement the `Copy` trait
-
-error[E0382]: use of moved value: `foo`
- --> $DIR/move-fn-self-receiver.rs:34:5
- |
-LL | let foo = Foo;
- | --- move occurs because `foo` has type `Foo`, which does not implement the `Copy` trait
-LL | foo.use_self();
- | ---------- `foo` moved due to this method call
-LL | foo;
- | ^^^ value used here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `foo`
- --> $DIR/move-fn-self-receiver.rs:13:17
- |
-LL | fn use_self(self) {}
- | ^^^^
-
-error[E0382]: use of moved value: `second_foo`
- --> $DIR/move-fn-self-receiver.rs:38:5
- |
-LL | let second_foo = Foo;
- | ---------- move occurs because `second_foo` has type `Foo`, which does not implement the `Copy` trait
-LL | second_foo.use_self();
- | ---------- `second_foo` moved due to this method call
-LL | second_foo;
- | ^^^^^^^^^^ value used here after move
-
-error[E0382]: use of moved value: `boxed_foo`
- --> $DIR/move-fn-self-receiver.rs:42:5
- |
-LL | let boxed_foo = Box::new(Foo);
- | --------- move occurs because `boxed_foo` has type `std::boxed::Box<Foo>`, which does not implement the `Copy` trait
-LL | boxed_foo.use_box_self();
- | -------------- `boxed_foo` moved due to this method call
-LL | boxed_foo;
- | ^^^^^^^^^ value used here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `boxed_foo`
- --> $DIR/move-fn-self-receiver.rs:14:21
- |
-LL | fn use_box_self(self: Box<Self>) {}
- | ^^^^
-
-error[E0382]: use of moved value: `pin_box_foo`
- --> $DIR/move-fn-self-receiver.rs:46:5
- |
-LL | let pin_box_foo = Box::pin(Foo);
- | ----------- move occurs because `pin_box_foo` has type `std::pin::Pin<std::boxed::Box<Foo>>`, which does not implement the `Copy` trait
-LL | pin_box_foo.use_pin_box_self();
- | ------------------ `pin_box_foo` moved due to this method call
-LL | pin_box_foo;
- | ^^^^^^^^^^^ value used here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `pin_box_foo`
- --> $DIR/move-fn-self-receiver.rs:15:25
- |
-LL | fn use_pin_box_self(self: Pin<Box<Self>>) {}
- | ^^^^
-
-error[E0505]: cannot move out of `mut_foo` because it is borrowed
- --> $DIR/move-fn-self-receiver.rs:50:5
- |
-LL | let ret = mut_foo.use_mut_self();
- | ------- borrow of `mut_foo` occurs here
-LL | mut_foo;
- | ^^^^^^^ move out of `mut_foo` occurs here
-LL | ret;
- | --- borrow later used here
-
-error[E0382]: use of moved value: `rc_foo`
- --> $DIR/move-fn-self-receiver.rs:55:5
- |
-LL | let rc_foo = Rc::new(Foo);
- | ------ move occurs because `rc_foo` has type `std::rc::Rc<Foo>`, which does not implement the `Copy` trait
-LL | rc_foo.use_rc_self();
- | ------------- `rc_foo` moved due to this method call
-LL | rc_foo;
- | ^^^^^^ value used here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `rc_foo`
- --> $DIR/move-fn-self-receiver.rs:16:20
- |
-LL | fn use_rc_self(self: Rc<Self>) {}
- | ^^^^
-
-error[E0382]: use of moved value: `foo_add`
- --> $DIR/move-fn-self-receiver.rs:59:5
- |
-LL | let foo_add = Foo;
- | ------- move occurs because `foo_add` has type `Foo`, which does not implement the `Copy` trait
-LL | foo_add + Foo;
- | ------------- `foo_add` moved due to usage in operator
-LL | foo_add;
- | ^^^^^^^ value used here after move
- |
-note: calling this operator moves the left-hand side
- --> $SRC_DIR/libcore/ops/arith.rs:LL:COL
- |
-LL | fn add(self, rhs: Rhs) -> Self::Output;
- | ^^^^
-
-error[E0382]: use of moved value: `implicit_into_iter`
- --> $DIR/move-fn-self-receiver.rs:63:5
- |
-LL | let implicit_into_iter = vec![true];
- | ------------------ move occurs because `implicit_into_iter` has type `std::vec::Vec<bool>`, which does not implement the `Copy` trait
-LL | for _val in implicit_into_iter {}
- | ------------------
- | |
- | `implicit_into_iter` moved due to this implicit call to `.into_iter()`
- | help: consider borrowing to avoid moving into the for loop: `&implicit_into_iter`
-LL | implicit_into_iter;
- | ^^^^^^^^^^^^^^^^^^ value used here after move
-
-error[E0382]: use of moved value: `explicit_into_iter`
- --> $DIR/move-fn-self-receiver.rs:67:5
- |
-LL | let explicit_into_iter = vec![true];
- | ------------------ move occurs because `explicit_into_iter` has type `std::vec::Vec<bool>`, which does not implement the `Copy` trait
-LL | for _val in explicit_into_iter.into_iter() {}
- | ----------- `explicit_into_iter` moved due to this method call
-LL | explicit_into_iter;
- | ^^^^^^^^^^^^^^^^^^ value used here after move
-
-error[E0382]: use of moved value: `container`
- --> $DIR/move-fn-self-receiver.rs:71:5
- |
-LL | let container = Container(vec![]);
- | --------- move occurs because `container` has type `Container`, which does not implement the `Copy` trait
-LL | for _val in container.custom_into_iter() {}
- | ------------------ `container` moved due to this method call
-LL | container;
- | ^^^^^^^^^ value used here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `container`
- --> $DIR/move-fn-self-receiver.rs:23:25
- |
-LL | fn custom_into_iter(self) -> impl Iterator<Item = bool> {
- | ^^^^
-
-error: aborting due to 11 previous errors
-
-Some errors have detailed explanations: E0382, E0505.
-For more information about an error, try `rustc --explain E0382`.
diff --git a/src/test/ui/moves/moves-based-on-type-access-to-field.stderr b/src/test/ui/moves/moves-based-on-type-access-to-field.stderr
index 142feb280d153..71a3c4506eaf2 100644
--- a/src/test/ui/moves/moves-based-on-type-access-to-field.stderr
+++ b/src/test/ui/moves/moves-based-on-type-access-to-field.stderr
@@ -4,15 +4,9 @@ error[E0382]: borrow of moved value: `x`
LL | let x = vec!["hi".to_string()];
| - move occurs because `x` has type `std::vec::Vec<std::string::String>`, which does not implement the `Copy` trait
LL | consume(x.into_iter().next().unwrap());
- | ----------- `x` moved due to this method call
+ | - value moved here
LL | touch(&x[0]);
| ^ value borrowed here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `x`
- --> $SRC_DIR/libcore/iter/traits/collect.rs:LL:COL
- |
-LL | fn into_iter(self) -> Self::IntoIter;
- | ^^^^
error: aborting due to previous error
diff --git a/src/test/ui/moves/moves-based-on-type-exprs.stderr b/src/test/ui/moves/moves-based-on-type-exprs.stderr
index ff98aab50c9f8..67fae606c4e43 100644
--- a/src/test/ui/moves/moves-based-on-type-exprs.stderr
+++ b/src/test/ui/moves/moves-based-on-type-exprs.stderr
@@ -104,15 +104,9 @@ error[E0382]: borrow of moved value: `x`
LL | let x = vec!["hi".to_string()];
| - move occurs because `x` has type `std::vec::Vec<std::string::String>`, which does not implement the `Copy` trait
LL | let _y = x.into_iter().next().unwrap();
- | ----------- `x` moved due to this method call
+ | - value moved here
LL | touch(&x);
| ^^ value borrowed here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `x`
- --> $SRC_DIR/libcore/iter/traits/collect.rs:LL:COL
- |
-LL | fn into_iter(self) -> Self::IntoIter;
- | ^^^^
error[E0382]: borrow of moved value: `x`
--> $DIR/moves-based-on-type-exprs.rs:83:11
@@ -120,15 +114,9 @@ error[E0382]: borrow of moved value: `x`
LL | let x = vec!["hi".to_string()];
| - move occurs because `x` has type `std::vec::Vec<std::string::String>`, which does not implement the `Copy` trait
LL | let _y = [x.into_iter().next().unwrap(); 1];
- | ----------- `x` moved due to this method call
+ | - value moved here
LL | touch(&x);
| ^^ value borrowed here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `x`
- --> $SRC_DIR/libcore/iter/traits/collect.rs:LL:COL
- |
-LL | fn into_iter(self) -> Self::IntoIter;
- | ^^^^
error: aborting due to 11 previous errors
diff --git a/src/test/ui/once-cant-call-twice-on-heap.stderr b/src/test/ui/once-cant-call-twice-on-heap.stderr
index 8761b5261d51b..7133a32431a67 100644
--- a/src/test/ui/once-cant-call-twice-on-heap.stderr
+++ b/src/test/ui/once-cant-call-twice-on-heap.stderr
@@ -4,15 +4,10 @@ error[E0382]: use of moved value: `blk`
LL | fn foo<F:FnOnce()>(blk: F) {
| --- move occurs because `blk` has type `F`, which does not implement the `Copy` trait
LL | blk();
- | ----- `blk` moved due to this call
+ | --- value moved here
LL | blk();
| ^^^ value used here after move
|
-note: this value implements `FnOnce`, which causes it to be moved when called
- --> $DIR/once-cant-call-twice-on-heap.rs:8:5
- |
-LL | blk();
- | ^^^
help: consider further restricting this bound
|
LL | fn foo<F:FnOnce() + Copy>(blk: F) {
diff --git a/src/test/ui/unboxed-closures/unboxed-closures-infer-fnonce-call-twice.stderr b/src/test/ui/unboxed-closures/unboxed-closures-infer-fnonce-call-twice.stderr
index ab6f06518467c..0b9aa61a765fa 100644
--- a/src/test/ui/unboxed-closures/unboxed-closures-infer-fnonce-call-twice.stderr
+++ b/src/test/ui/unboxed-closures/unboxed-closures-infer-fnonce-call-twice.stderr
@@ -2,7 +2,7 @@ error[E0382]: use of moved value: `tick`
--> $DIR/unboxed-closures-infer-fnonce-call-twice.rs:10:5
|
LL | tick();
- | ------ `tick` moved due to this call
+ | ---- value moved here
LL | tick();
| ^^^^ value used here after move
|
@@ -11,11 +11,6 @@ note: closure cannot be invoked more than once because it moves the variable `co
|
LL | let tick = || mem::drop(counter);
| ^^^^^^^
-note: this value implements `FnOnce`, which causes it to be moved when called
- --> $DIR/unboxed-closures-infer-fnonce-call-twice.rs:9:5
- |
-LL | tick();
- | ^^^^
error: aborting due to previous error
diff --git a/src/test/ui/unboxed-closures/unboxed-closures-infer-fnonce-move-call-twice.stderr b/src/test/ui/unboxed-closures/unboxed-closures-infer-fnonce-move-call-twice.stderr
index 8d70a2b17602b..20773d561f9f2 100644
--- a/src/test/ui/unboxed-closures/unboxed-closures-infer-fnonce-move-call-twice.stderr
+++ b/src/test/ui/unboxed-closures/unboxed-closures-infer-fnonce-move-call-twice.stderr
@@ -2,7 +2,7 @@ error[E0382]: use of moved value: `tick`
--> $DIR/unboxed-closures-infer-fnonce-move-call-twice.rs:10:5
|
LL | tick();
- | ------ `tick` moved due to this call
+ | ---- value moved here
LL | tick();
| ^^^^ value used here after move
|
@@ -11,11 +11,6 @@ note: closure cannot be invoked more than once because it moves the variable `co
|
LL | let tick = move || mem::drop(counter);
| ^^^^^^^
-note: this value implements `FnOnce`, which causes it to be moved when called
- --> $DIR/unboxed-closures-infer-fnonce-move-call-twice.rs:9:5
- |
-LL | tick();
- | ^^^^
error: aborting due to previous error
diff --git a/src/test/ui/unop-move-semantics.stderr b/src/test/ui/unop-move-semantics.stderr
index 7e9c8559a4b39..e0499cfe95ce9 100644
--- a/src/test/ui/unop-move-semantics.stderr
+++ b/src/test/ui/unop-move-semantics.stderr
@@ -4,16 +4,11 @@ error[E0382]: borrow of moved value: `x`
LL | fn move_then_borrow<T: Not<Output=T> + Clone>(x: T) {
| - move occurs because `x` has type `T`, which does not implement the `Copy` trait
LL | !x;
- | -- `x` moved due to this method call
+ | - value moved here
LL |
LL | x.clone();
| ^ value borrowed here after move
|
-note: this function consumes the receiver `self` by taking ownership of it, which moves `x`
- --> $SRC_DIR/libcore/ops/bit.rs:LL:COL
- |
-LL | fn not(self) -> Self::Output;
- | ^^^^
help: consider further restricting this bound
|
LL | fn move_then_borrow<T: Not<Output=T> + Clone + Copy>(x: T) {
diff --git a/src/test/ui/unsized-locals/borrow-after-move.stderr b/src/test/ui/unsized-locals/borrow-after-move.stderr
index 906b543e42122..110edab69be87 100644
--- a/src/test/ui/unsized-locals/borrow-after-move.stderr
+++ b/src/test/ui/unsized-locals/borrow-after-move.stderr
@@ -37,16 +37,10 @@ error[E0382]: borrow of moved value: `y`
LL | let y = *x;
| - move occurs because `y` has type `str`, which does not implement the `Copy` trait
LL | y.foo();
- | ----- `y` moved due to this method call
+ | - value moved here
...
LL | println!("{}", &y);
| ^^ value borrowed here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `y`
- --> $DIR/borrow-after-move.rs:4:12
- |
-LL | fn foo(self) -> String;
- | ^^^^
error[E0382]: borrow of moved value: `x`
--> $DIR/borrow-after-move.rs:39:24
diff --git a/src/test/ui/unsized-locals/double-move.stderr b/src/test/ui/unsized-locals/double-move.stderr
index 49b2031c6b9d9..5b936fb64474f 100644
--- a/src/test/ui/unsized-locals/double-move.stderr
+++ b/src/test/ui/unsized-locals/double-move.stderr
@@ -34,15 +34,9 @@ error[E0382]: use of moved value: `y`
LL | let y = *x;
| - move occurs because `y` has type `str`, which does not implement the `Copy` trait
LL | y.foo();
- | ----- `y` moved due to this method call
+ | - value moved here
LL | y.foo();
| ^ value used here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `y`
- --> $DIR/double-move.rs:4:12
- |
-LL | fn foo(self) -> String;
- | ^^^^
error[E0382]: use of moved value: `x`
--> $DIR/double-move.rs:45:9
diff --git a/src/test/ui/use/use-after-move-self-based-on-type.stderr b/src/test/ui/use/use-after-move-self-based-on-type.stderr
index b9440f4de07a9..9bf1175430c84 100644
--- a/src/test/ui/use/use-after-move-self-based-on-type.stderr
+++ b/src/test/ui/use/use-after-move-self-based-on-type.stderr
@@ -4,15 +4,9 @@ error[E0382]: use of moved value: `self`
LL | pub fn foo(self) -> isize {
| ---- move occurs because `self` has type `S`, which does not implement the `Copy` trait
LL | self.bar();
- | ----- `self` moved due to this method call
+ | ---- value moved here
LL | return self.x;
| ^^^^^^ value used here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `self`
- --> $DIR/use-after-move-self-based-on-type.rs:15:16
- |
-LL | pub fn bar(self) {}
- | ^^^^
error: aborting due to previous error
diff --git a/src/test/ui/use/use-after-move-self.stderr b/src/test/ui/use/use-after-move-self.stderr
index 3da53b024db44..3be0a65550b7f 100644
--- a/src/test/ui/use/use-after-move-self.stderr
+++ b/src/test/ui/use/use-after-move-self.stderr
@@ -4,15 +4,9 @@ error[E0382]: use of moved value: `self`
LL | pub fn foo(self) -> isize {
| ---- move occurs because `self` has type `S`, which does not implement the `Copy` trait
LL | self.bar();
- | ----- `self` moved due to this method call
+ | ---- value moved here
LL | return *self.x;
| ^^^^^^^ value used here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `self`
- --> $DIR/use-after-move-self.rs:13:16
- |
-LL | pub fn bar(self) {}
- | ^^^^
error: aborting due to previous error
diff --git a/src/test/ui/walk-struct-literal-with.stderr b/src/test/ui/walk-struct-literal-with.stderr
index ece63a2b81947..eeb594a21f38c 100644
--- a/src/test/ui/walk-struct-literal-with.stderr
+++ b/src/test/ui/walk-struct-literal-with.stderr
@@ -4,15 +4,9 @@ error[E0382]: borrow of moved value: `start`
LL | let start = Mine{test:"Foo".to_string(), other_val:0};
| ----- move occurs because `start` has type `Mine`, which does not implement the `Copy` trait
LL | let end = Mine{other_val:1, ..start.make_string_bar()};
- | ----------------- `start` moved due to this method call
+ | ----- value moved here
LL | println!("{}", start.test);
| ^^^^^^^^^^ value borrowed here after move
- |
-note: this function consumes the receiver `self` by taking ownership of it, which moves `start`
- --> $DIR/walk-struct-literal-with.rs:7:28
- |
-LL | fn make_string_bar(mut self) -> Mine{
- | ^^^^
error: aborting due to previous error
From 2959352b54b963e8ce4cc3b4ad9517437f863770 Mon Sep 17 00:00:00 2001
From: Aaron Hill <aa1ronham@gmail.com>
Date: Sun, 21 Jun 2020 16:28:58 -0400
Subject: [PATCH 15/15] Re-enable Clippy tests
---
src/bootstrap/test.rs | 5 +----
1 file changed, 1 insertion(+), 4 deletions(-)
diff --git a/src/bootstrap/test.rs b/src/bootstrap/test.rs
index 8a37a70d60d9a..bb35203c82604 100644
--- a/src/bootstrap/test.rs
+++ b/src/bootstrap/test.rs
@@ -554,10 +554,7 @@ impl Step for Clippy {
builder.add_rustc_lib_path(compiler, &mut cargo);
- // FIXME: Disable clippy tests for now, they're failing on master
- // (generally this would mean a toolstate failure but we don't have
- // toolstate for clippy anymore).
- // builder.run(&mut cargo.into());
+ builder.run(&mut cargo.into());
}
}