Rollup merge of #125391 - nnethercote:serialize-rs-tweaks, r=compiler-errors
Minor serialize/span tweaks
r? ``@jackh726``
diff --git a/compiler/rustc_ast/src/attr/mod.rs b/compiler/rustc_ast/src/attr/mod.rs
index 0684163..d5c9fc9 100644
--- a/compiler/rustc_ast/src/attr/mod.rs
+++ b/compiler/rustc_ast/src/attr/mod.rs
@@ -13,6 +13,7 @@
use rustc_index::bit_set::GrowableBitSet;
use rustc_span::symbol::{sym, Ident, Symbol};
use rustc_span::Span;
+use smallvec::{smallvec, SmallVec};
use std::iter;
use std::sync::atomic::{AtomicU32, Ordering};
use thin_vec::{thin_vec, ThinVec};
@@ -87,10 +88,20 @@
AttrKind::DocComment(..) => None,
}
}
+
pub fn name_or_empty(&self) -> Symbol {
self.ident().unwrap_or_else(Ident::empty).name
}
+ pub fn path(&self) -> SmallVec<[Symbol; 1]> {
+ match &self.kind {
+ AttrKind::Normal(normal) => {
+ normal.item.path.segments.iter().map(|s| s.ident.name).collect()
+ }
+ AttrKind::DocComment(..) => smallvec![sym::doc],
+ }
+ }
+
#[inline]
pub fn has_name(&self, name: Symbol) -> bool {
match &self.kind {
diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index a3731e9..31a184f 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -55,9 +55,6 @@
ast_passes_constraint_on_negative_bound =
associated type constraints not allowed on negative bounds
-ast_passes_deprecated_where_clause_location =
- where clause not allowed here
-
ast_passes_equality_in_where = equality constraints are not yet supported in `where` clauses
.label = not supported
.suggestion = if `{$ident}` is an associated type you're trying to set, use the associated type binding syntax
@@ -80,8 +77,6 @@
.suggestion = remove the {$remove_descr}
.label = `extern` block begins here
-ast_passes_extern_without_abi = extern declarations without an explicit ABI are deprecated
-
ast_passes_feature_on_non_nightly = `#![feature]` may not be used on the {$channel} release channel
.suggestion = remove the attribute
.stable_since = the feature `{$name}` has been stable since `{$since}` and no longer requires an attribute to enable
diff --git a/compiler/rustc_ast_passes/src/ast_validation.rs b/compiler/rustc_ast_passes/src/ast_validation.rs
index 9d07683..c57be3c 100644
--- a/compiler/rustc_ast_passes/src/ast_validation.rs
+++ b/compiler/rustc_ast_passes/src/ast_validation.rs
@@ -27,7 +27,6 @@
use thin_vec::thin_vec;
use crate::errors;
-use crate::fluent_generated as fluent;
/// Is `self` allowed semantically as the first parameter in an `FnDecl`?
enum SelfSemantic {
@@ -766,11 +765,10 @@
.span_to_snippet(span)
.is_ok_and(|snippet| !snippet.starts_with("#["))
{
- self.lint_buffer.buffer_lint_with_diagnostic(
+ self.lint_buffer.buffer_lint(
MISSING_ABI,
id,
span,
- fluent::ast_passes_extern_without_abi,
BuiltinLintDiag::MissingAbi(span, abi::Abi::FALLBACK),
)
}
@@ -1428,17 +1426,15 @@
Self::check_decl_no_pat(&sig.decl, |span, ident, mut_ident| {
if mut_ident && matches!(ctxt, FnCtxt::Assoc(_)) {
if let Some(ident) = ident {
- let msg = match ctxt {
- FnCtxt::Foreign => fluent::ast_passes_pattern_in_foreign,
- _ => fluent::ast_passes_pattern_in_bodiless,
- };
- let diag = BuiltinLintDiag::PatternsInFnsWithoutBody(span, ident);
- self.lint_buffer.buffer_lint_with_diagnostic(
+ self.lint_buffer.buffer_lint(
PATTERNS_IN_FNS_WITHOUT_BODY,
id,
span,
- msg,
- diag,
+ BuiltinLintDiag::PatternsInFnsWithoutBody {
+ span,
+ ident,
+ is_foreign: matches!(ctxt, FnCtxt::Foreign),
+ },
)
}
} else {
@@ -1510,12 +1506,11 @@
Some((right, snippet))
}
};
- self.lint_buffer.buffer_lint_with_diagnostic(
+ self.lint_buffer.buffer_lint(
DEPRECATED_WHERE_CLAUSE_LOCATION,
item.id,
err.span,
- fluent::ast_passes_deprecated_where_clause_location,
- BuiltinLintDiag::DeprecatedWhereclauseLocation(sugg),
+ BuiltinLintDiag::DeprecatedWhereclauseLocation(err.span, sugg),
);
}
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index 25a125f..a95a7bd 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -669,6 +669,7 @@
#[derive(Diagnostic)]
#[diag(ast_passes_pattern_in_foreign, code = E0130)]
+// FIXME: deduplicate with rustc_lint (`BuiltinLintDiag::PatternsInFnsWithoutBody`)
pub struct PatternInForeign {
#[primary_span]
#[label]
@@ -677,6 +678,7 @@
#[derive(Diagnostic)]
#[diag(ast_passes_pattern_in_bodiless, code = E0642)]
+// FIXME: deduplicate with rustc_lint (`BuiltinLintDiag::PatternsInFnsWithoutBody`)
pub struct PatternInBodiless {
#[primary_span]
#[label]
diff --git a/compiler/rustc_attr/src/builtin.rs b/compiler/rustc_attr/src/builtin.rs
index c08bf28..5113c5a 100644
--- a/compiler/rustc_attr/src/builtin.rs
+++ b/compiler/rustc_attr/src/builtin.rs
@@ -528,15 +528,10 @@
try_gate_cfg(cfg.name, cfg.span, sess, features);
match sess.psess.check_config.expecteds.get(&cfg.name) {
Some(ExpectedValues::Some(values)) if !values.contains(&cfg.value) => {
- sess.psess.buffer_lint_with_diagnostic(
+ sess.psess.buffer_lint(
UNEXPECTED_CFGS,
cfg.span,
lint_node_id,
- if let Some(value) = cfg.value {
- format!("unexpected `cfg` condition value: `{value}`")
- } else {
- format!("unexpected `cfg` condition value: (none)")
- },
BuiltinLintDiag::UnexpectedCfgValue(
(cfg.name, cfg.name_span),
cfg.value.map(|v| (v, cfg.value_span.unwrap())),
@@ -544,11 +539,10 @@
);
}
None if sess.psess.check_config.exhaustive_names => {
- sess.psess.buffer_lint_with_diagnostic(
+ sess.psess.buffer_lint(
UNEXPECTED_CFGS,
cfg.span,
lint_node_id,
- format!("unexpected `cfg` condition name: `{}`", cfg.name),
BuiltinLintDiag::UnexpectedCfgName(
(cfg.name, cfg.name_span),
cfg.value.map(|v| (v, cfg.value_span.unwrap())),
diff --git a/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs b/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
index 5aa8fe2..b23ad2e 100644
--- a/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
+++ b/compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
@@ -136,7 +136,7 @@
fn convert(
&mut self,
- predicate: ty::OutlivesPredicate<ty::GenericArg<'tcx>, ty::Region<'tcx>>,
+ predicate: ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>,
constraint_category: ConstraintCategory<'tcx>,
) {
debug!("generate: constraints at: {:#?}", self.locations);
@@ -276,7 +276,7 @@
&self,
ty: Ty<'tcx>,
next_outlives_predicates: &mut Vec<(
- ty::OutlivesPredicate<ty::GenericArg<'tcx>, ty::Region<'tcx>>,
+ ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>,
ConstraintCategory<'tcx>,
)>,
) -> Ty<'tcx> {
diff --git a/compiler/rustc_builtin_macros/messages.ftl b/compiler/rustc_builtin_macros/messages.ftl
index 0f15899..a3d6a1c 100644
--- a/compiler/rustc_builtin_macros/messages.ftl
+++ b/compiler/rustc_builtin_macros/messages.ftl
@@ -247,5 +247,3 @@
.label = not a trait
.str_lit = try using `#[derive({$sym})]`
.other = for example, write `#[derive(Debug)]` for `Debug`
-
-builtin_macros_unnameable_test_items = cannot test inner items
diff --git a/compiler/rustc_builtin_macros/src/asm.rs b/compiler/rustc_builtin_macros/src/asm.rs
index 49b1b8c..1a7961b 100644
--- a/compiler/rustc_builtin_macros/src/asm.rs
+++ b/compiler/rustc_builtin_macros/src/asm.rs
@@ -1,6 +1,7 @@
use crate::errors;
use crate::util::expr_to_spanned_string;
use ast::token::IdentIsRaw;
+use lint::BuiltinLintDiag;
use rustc_ast as ast;
use rustc_ast::ptr::P;
use rustc_ast::token::{self, Delimiter};
@@ -513,7 +514,7 @@
lint::builtin::BAD_ASM_STYLE,
find_span(".intel_syntax"),
ecx.current_expansion.lint_node_id,
- "avoid using `.intel_syntax`, Intel syntax is the default",
+ BuiltinLintDiag::AvoidUsingIntelSyntax,
);
}
if template_str.contains(".att_syntax") {
@@ -521,7 +522,7 @@
lint::builtin::BAD_ASM_STYLE,
find_span(".att_syntax"),
ecx.current_expansion.lint_node_id,
- "avoid using `.att_syntax`, prefer using `options(att_syntax)` instead",
+ BuiltinLintDiag::AvoidUsingAttSyntax,
);
}
}
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
index 46949f7..217fa5f 100644
--- a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -1621,14 +1621,13 @@
};
if let Some(ty) = exception {
- cx.sess.psess.buffer_lint_with_diagnostic(
+ cx.sess.psess.buffer_lint(
BYTE_SLICE_IN_PACKED_STRUCT_WITH_DERIVE,
sp,
ast::CRATE_NODE_ID,
- format!(
- "{ty} slice in a packed struct that derives a built-in trait"
- ),
- rustc_lint_defs::BuiltinLintDiag::ByteSliceInPackedStructWithDerive,
+ rustc_lint_defs::BuiltinLintDiag::ByteSliceInPackedStructWithDerive {
+ ty: ty.to_string(),
+ },
);
} else {
// Wrap the expression in `{...}`, causing a copy.
diff --git a/compiler/rustc_builtin_macros/src/format.rs b/compiler/rustc_builtin_macros/src/format.rs
index a5fc74f..5cb0407 100644
--- a/compiler/rustc_builtin_macros/src/format.rs
+++ b/compiler/rustc_builtin_macros/src/format.rs
@@ -556,7 +556,6 @@
let arg_name = args.explicit_args()[index].kind.ident().unwrap();
ecx.buffered_early_lint.push(BufferedEarlyLint {
span: arg_name.span.into(),
- msg: format!("named argument `{}` is not used by name", arg_name.name).into(),
node_id: rustc_ast::CRATE_NODE_ID,
lint_id: LintId::of(NAMED_ARGUMENTS_USED_POSITIONALLY),
diagnostic: BuiltinLintDiag::NamedArgumentUsedPositionally {
diff --git a/compiler/rustc_builtin_macros/src/source_util.rs b/compiler/rustc_builtin_macros/src/source_util.rs
index 47b2ee9..29e9915 100644
--- a/compiler/rustc_builtin_macros/src/source_util.rs
+++ b/compiler/rustc_builtin_macros/src/source_util.rs
@@ -11,6 +11,7 @@
resolve_path, DummyResult, ExpandResult, ExtCtxt, MacEager, MacResult, MacroExpanderResult,
};
use rustc_expand::module::DirOwnership;
+use rustc_lint_defs::BuiltinLintDiag;
use rustc_parse::new_parser_from_file;
use rustc_parse::parser::{ForceCollect, Parser};
use rustc_session::lint::builtin::INCOMPLETE_INCLUDE;
@@ -147,7 +148,7 @@
INCOMPLETE_INCLUDE,
self.p.token.span,
self.node_id,
- "include macro expected single expression in source",
+ BuiltinLintDiag::IncompleteInclude,
);
}
Some(expr)
diff --git a/compiler/rustc_builtin_macros/src/test_harness.rs b/compiler/rustc_builtin_macros/src/test_harness.rs
index 8cf4314..38ac2f1 100644
--- a/compiler/rustc_builtin_macros/src/test_harness.rs
+++ b/compiler/rustc_builtin_macros/src/test_harness.rs
@@ -9,6 +9,7 @@
use rustc_expand::base::{ExtCtxt, ResolverExpand};
use rustc_expand::expand::{AstFragment, ExpansionConfig};
use rustc_feature::Features;
+use rustc_lint_defs::BuiltinLintDiag;
use rustc_session::lint::builtin::UNNAMEABLE_TEST_ITEMS;
use rustc_session::Session;
use rustc_span::hygiene::{AstPass, SyntaxContext, Transparency};
@@ -163,7 +164,7 @@
UNNAMEABLE_TEST_ITEMS,
attr.span,
i.id,
- crate::fluent_generated::builtin_macros_unnameable_test_items,
+ BuiltinLintDiag::UnnameableTestItems,
);
}
}
diff --git a/compiler/rustc_builtin_macros/src/util.rs b/compiler/rustc_builtin_macros/src/util.rs
index 8dc7bc1..652e342 100644
--- a/compiler/rustc_builtin_macros/src/util.rs
+++ b/compiler/rustc_builtin_macros/src/util.rs
@@ -5,7 +5,7 @@
use rustc_expand::base::{Annotatable, ExpandResult, ExtCtxt};
use rustc_expand::expand::AstFragment;
use rustc_feature::AttributeTemplate;
-use rustc_lint_defs::builtin::DUPLICATE_MACRO_ATTRIBUTES;
+use rustc_lint_defs::{builtin::DUPLICATE_MACRO_ATTRIBUTES, BuiltinLintDiag};
use rustc_parse::{parser, validate_attr};
use rustc_session::errors::report_lit_error;
use rustc_span::{BytePos, Span, Symbol};
@@ -46,7 +46,7 @@
DUPLICATE_MACRO_ATTRIBUTES,
attr.span,
ecx.current_expansion.lint_node_id,
- "duplicated attribute",
+ BuiltinLintDiag::DuplicateMacroAttribute,
);
}
}
diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs
index 4eb24d7..66a7a2e 100644
--- a/compiler/rustc_codegen_ssa/src/lib.rs
+++ b/compiler/rustc_codegen_ssa/src/lib.rs
@@ -195,6 +195,7 @@
EmptyVersionNumber,
EncodingVersionMismatch { version_array: String, rlink_version: u32 },
RustcVersionMismatch { rustc_version: String },
+ CorruptFile,
}
pub fn provide(providers: &mut Providers) {
@@ -265,7 +266,9 @@
});
}
- let mut decoder = MemDecoder::new(&data[4..], 0);
+ let Ok(mut decoder) = MemDecoder::new(&data[4..], 0) else {
+ return Err(CodegenErrors::CorruptFile);
+ };
let rustc_version = decoder.read_str();
if rustc_version != sess.cfg_version {
return Err(CodegenErrors::RustcVersionMismatch {
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index 836e548..310fd46 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -25,9 +25,9 @@
use crate::errors::{LongRunning, LongRunningWarn};
use crate::fluent_generated as fluent;
use crate::interpret::{
- self, compile_time_machine, err_ub, throw_exhaust, throw_inval, throw_ub_custom,
+ self, compile_time_machine, err_ub, throw_exhaust, throw_inval, throw_ub_custom, throw_unsup,
throw_unsup_format, AllocId, AllocRange, ConstAllocation, CtfeProvenance, FnArg, FnVal, Frame,
- ImmTy, InterpCx, InterpResult, MPlaceTy, OpTy, Pointer, PointerArithmetic, Scalar,
+ GlobalAlloc, ImmTy, InterpCx, InterpResult, MPlaceTy, OpTy, Pointer, PointerArithmetic, Scalar,
};
use super::error::*;
@@ -759,11 +759,21 @@
ecx: &InterpCx<'mir, 'tcx, Self>,
alloc_id: AllocId,
) -> InterpResult<'tcx> {
+ // Check if this is the currently evaluated static.
if Some(alloc_id) == ecx.machine.static_root_ids.map(|(id, _)| id) {
- Err(ConstEvalErrKind::RecursiveStatic.into())
- } else {
- Ok(())
+ return Err(ConstEvalErrKind::RecursiveStatic.into());
}
+ // If this is another static, make sure we fire off the query to detect cycles.
+ // But only do that when checks for static recursion are enabled.
+ if ecx.machine.static_root_ids.is_some() {
+ if let Some(GlobalAlloc::Static(def_id)) = ecx.tcx.try_get_global_alloc(alloc_id) {
+ if ecx.tcx.is_foreign_item(def_id) {
+ throw_unsup!(ExternStatic(def_id));
+ }
+ ecx.ctfe_query(|tcx| tcx.eval_static_initializer(def_id))?;
+ }
+ }
+ Ok(())
}
}
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index dce4d56..72dad56 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -255,6 +255,7 @@
name = intrinsic_name,
);
}
+ // This will always return 0.
(a, b)
}
(Err(_), _) | (_, Err(_)) => {
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 350fd48..737f2fd 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -413,6 +413,8 @@
/// to the allocation it points to. Supports both shared and mutable references, as the actual
/// checking is offloaded to a helper closure.
///
+ /// `alloc_size` will only get called for non-zero-sized accesses.
+ ///
/// Returns `None` if and only if the size is 0.
fn check_and_deref_ptr<T>(
&self,
@@ -425,18 +427,19 @@
M::ProvenanceExtra,
) -> InterpResult<'tcx, (Size, Align, T)>,
) -> InterpResult<'tcx, Option<T>> {
+ // Everything is okay with size 0.
+ if size.bytes() == 0 {
+ return Ok(None);
+ }
+
Ok(match self.ptr_try_get_alloc_id(ptr) {
Err(addr) => {
- // We couldn't get a proper allocation. This is only okay if the access size is 0,
- // and the address is not null.
- if size.bytes() > 0 || addr == 0 {
- throw_ub!(DanglingIntPointer(addr, msg));
- }
- None
+ // We couldn't get a proper allocation.
+ throw_ub!(DanglingIntPointer(addr, msg));
}
Ok((alloc_id, offset, prov)) => {
let (alloc_size, _alloc_align, ret_val) = alloc_size(alloc_id, offset, prov)?;
- // Test bounds. This also ensures non-null.
+ // Test bounds.
// It is sufficient to check this for the end pointer. Also check for overflow!
if offset.checked_add(size, &self.tcx).map_or(true, |end| end > alloc_size) {
throw_ub!(PointerOutOfBounds {
@@ -447,14 +450,8 @@
msg,
})
}
- // Ensure we never consider the null pointer dereferenceable.
- if M::Provenance::OFFSET_IS_ADDR {
- assert_ne!(ptr.addr(), Size::ZERO);
- }
- // We can still be zero-sized in this branch, in which case we have to
- // return `None`.
- if size.bytes() == 0 { None } else { Some(ret_val) }
+ Some(ret_val)
}
})
}
@@ -641,16 +638,18 @@
size,
CheckInAllocMsg::MemoryAccessTest,
|alloc_id, offset, prov| {
- if !self.memory.validation_in_progress.get() {
- // We want to call the hook on *all* accesses that involve an AllocId,
- // including zero-sized accesses. That means we have to do it here
- // rather than below in the `Some` branch.
- M::before_alloc_read(self, alloc_id)?;
- }
let alloc = self.get_alloc_raw(alloc_id)?;
Ok((alloc.size(), alloc.align, (alloc_id, offset, prov, alloc)))
},
)?;
+ // We want to call the hook on *all* accesses that involve an AllocId, including zero-sized
+ // accesses. That means we cannot rely on the closure above or the `Some` branch below. We
+ // do this after `check_and_deref_ptr` to ensure some basic sanity has already been checked.
+ if !self.memory.validation_in_progress.get() {
+ if let Ok((alloc_id, ..)) = self.ptr_try_get_alloc_id(ptr) {
+ M::before_alloc_read(self, alloc_id)?;
+ }
+ }
if let Some((alloc_id, offset, prov, alloc)) = ptr_and_alloc {
let range = alloc_range(offset, size);
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 2bd4d9d..e36d301 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -434,6 +434,11 @@
found_bytes: has.bytes()
},
);
+ // Make sure this is non-null. We checked dereferenceability above, but if `size` is zero
+ // that does not imply non-null.
+ if self.ecx.scalar_may_be_null(Scalar::from_maybe_pointer(place.ptr(), self.ecx))? {
+ throw_validation_failure!(self.path, NullPtr { ptr_kind })
+ }
// Do not allow pointers to uninhabited types.
if place.layout.abi.is_uninhabited() {
let ty = place.layout.ty;
@@ -456,8 +461,8 @@
// `!` is a ZST and we want to validate it.
if let Ok((alloc_id, _offset, _prov)) = self.ecx.ptr_try_get_alloc_id(place.ptr()) {
let mut skip_recursive_check = false;
- let alloc_actual_mutbl = mutability(self.ecx, alloc_id);
- if let GlobalAlloc::Static(did) = self.ecx.tcx.global_alloc(alloc_id) {
+ if let Some(GlobalAlloc::Static(did)) = self.ecx.tcx.try_get_global_alloc(alloc_id)
+ {
let DefKind::Static { nested, .. } = self.ecx.tcx.def_kind(did) else { bug!() };
// Special handling for pointers to statics (irrespective of their type).
assert!(!self.ecx.tcx.is_thread_local_static(did));
@@ -495,6 +500,7 @@
// If this allocation has size zero, there is no actual mutability here.
let (size, _align, _alloc_kind) = self.ecx.get_alloc_info(alloc_id);
if size != Size::ZERO {
+ let alloc_actual_mutbl = mutability(self.ecx, alloc_id);
// Mutable pointer to immutable memory is no good.
if ptr_expected_mutbl == Mutability::Mut
&& alloc_actual_mutbl == Mutability::Not
@@ -831,6 +837,8 @@
trace!("visit_value: {:?}, {:?}", *op, op.layout);
// Check primitive types -- the leaves of our recursive descent.
+ // We assume that the Scalar validity range does not restrict these values
+ // any further than `try_visit_primitive` does!
if self.try_visit_primitive(op)? {
return Ok(());
}
diff --git a/compiler/rustc_driver_impl/messages.ftl b/compiler/rustc_driver_impl/messages.ftl
index 5b39248..31837e0 100644
--- a/compiler/rustc_driver_impl/messages.ftl
+++ b/compiler/rustc_driver_impl/messages.ftl
@@ -10,6 +10,8 @@
driver_impl_ice_path_error_env = the environment variable `RUSTC_ICE` is set to `{$env_var}`
driver_impl_ice_version = rustc {$version} running on {$triple}
+driver_impl_rlink_corrupt_file = corrupt metadata encountered in `{$file}`
+
driver_impl_rlink_empty_version_number = The input does not contain version number
driver_impl_rlink_encoding_version_mismatch = .rlink file was produced with encoding version `{$version_array}`, but the current version is `{$rlink_version}`
diff --git a/compiler/rustc_driver_impl/src/lib.rs b/compiler/rustc_driver_impl/src/lib.rs
index ba6b9ef..5532eff 100644
--- a/compiler/rustc_driver_impl/src/lib.rs
+++ b/compiler/rustc_driver_impl/src/lib.rs
@@ -96,7 +96,7 @@
use crate::session_diagnostics::{
RLinkEmptyVersionNumber, RLinkEncodingVersionMismatch, RLinkRustcVersionMismatch,
- RLinkWrongFileType, RlinkNotAFile, RlinkUnableToRead,
+ RLinkWrongFileType, RlinkCorruptFile, RlinkNotAFile, RlinkUnableToRead,
};
rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
@@ -645,8 +645,7 @@
match err {
CodegenErrors::WrongFileType => dcx.emit_fatal(RLinkWrongFileType),
CodegenErrors::EmptyVersionNumber => dcx.emit_fatal(RLinkEmptyVersionNumber),
- CodegenErrors::EncodingVersionMismatch { version_array, rlink_version } => sess
- .dcx()
+ CodegenErrors::EncodingVersionMismatch { version_array, rlink_version } => dcx
.emit_fatal(RLinkEncodingVersionMismatch { version_array, rlink_version }),
CodegenErrors::RustcVersionMismatch { rustc_version } => {
dcx.emit_fatal(RLinkRustcVersionMismatch {
@@ -654,6 +653,9 @@
current_version: sess.cfg_version,
})
}
+ CodegenErrors::CorruptFile => {
+ dcx.emit_fatal(RlinkCorruptFile { file });
+ }
};
}
};
diff --git a/compiler/rustc_driver_impl/src/session_diagnostics.rs b/compiler/rustc_driver_impl/src/session_diagnostics.rs
index 1a9683e..449878f 100644
--- a/compiler/rustc_driver_impl/src/session_diagnostics.rs
+++ b/compiler/rustc_driver_impl/src/session_diagnostics.rs
@@ -33,6 +33,12 @@
pub(crate) struct RlinkNotAFile;
#[derive(Diagnostic)]
+#[diag(driver_impl_rlink_corrupt_file)]
+pub(crate) struct RlinkCorruptFile<'a> {
+ pub file: &'a std::path::Path,
+}
+
+#[derive(Diagnostic)]
#[diag(driver_impl_ice)]
pub(crate) struct Ice;
diff --git a/compiler/rustc_errors/src/diagnostic_impls.rs b/compiler/rustc_errors/src/diagnostic_impls.rs
index 4bf7dcc..ee6df8e 100644
--- a/compiler/rustc_errors/src/diagnostic_impls.rs
+++ b/compiler/rustc_errors/src/diagnostic_impls.rs
@@ -118,6 +118,15 @@
}
}
+impl<I: rustc_type_ir::Interner, T> IntoDiagArg for rustc_type_ir::Binder<I, T>
+where
+ T: IntoDiagArg,
+{
+ fn into_diag_arg(self) -> DiagArgValue {
+ self.skip_binder().into_diag_arg()
+ }
+}
+
into_diag_arg_for_number!(i8, u8, i16, u16, i32, u32, i64, u64, i128, u128, isize, usize);
impl IntoDiagArg for bool {
@@ -282,6 +291,12 @@
}
}
+impl IntoDiagArg for hir::def::Namespace {
+ fn into_diag_arg(self) -> DiagArgValue {
+ DiagArgValue::Str(Cow::Borrowed(self.descr()))
+ }
+}
+
#[derive(Clone)]
pub struct DiagSymbolList(Vec<Symbol>);
diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 12868a6..91af875 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -1364,18 +1364,15 @@
};
if crate_matches {
- // FIXME: make this translatable
- #[allow(rustc::untranslatable_diagnostic)]
- sess.psess.buffer_lint_with_diagnostic(
- PROC_MACRO_BACK_COMPAT,
- item.ident.span,
- ast::CRATE_NODE_ID,
- "using an old version of `rental`",
- BuiltinLintDiag::ProcMacroBackCompat(
- "older versions of the `rental` crate will stop compiling in future versions of Rust; \
- please update to `rental` v0.5.6, or switch to one of the `rental` alternatives".to_string()
- )
- );
+ sess.psess.buffer_lint(
+ PROC_MACRO_BACK_COMPAT,
+ item.ident.span,
+ ast::CRATE_NODE_ID,
+ BuiltinLintDiag::ProcMacroBackCompat {
+ crate_name: "rental".to_string(),
+ fixed_version: "0.5.6".to_string(),
+ },
+ );
return true;
}
}
diff --git a/compiler/rustc_expand/src/config.rs b/compiler/rustc_expand/src/config.rs
index 35f0d8a..badfa6d 100644
--- a/compiler/rustc_expand/src/config.rs
+++ b/compiler/rustc_expand/src/config.rs
@@ -14,6 +14,7 @@
use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
use rustc_feature::Features;
use rustc_feature::{ACCEPTED_FEATURES, REMOVED_FEATURES, UNSTABLE_FEATURES};
+use rustc_lint_defs::BuiltinLintDiag;
use rustc_parse::validate_attr;
use rustc_session::parse::feature_err;
use rustc_session::Session;
@@ -248,7 +249,6 @@
/// Gives a compiler warning when the `cfg_attr` contains no attributes and
/// is in the original source file. Gives a compiler error if the syntax of
/// the attribute is incorrect.
- #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
pub(crate) fn expand_cfg_attr(&self, attr: &Attribute, recursive: bool) -> Vec<Attribute> {
let Some((cfg_predicate, expanded_attrs)) =
rustc_parse::parse_cfg_attr(attr, &self.sess.psess)
@@ -262,7 +262,7 @@
rustc_lint_defs::builtin::UNUSED_ATTRIBUTES,
attr.span,
ast::CRATE_NODE_ID,
- "`#[cfg_attr]` does not expand to any attributes",
+ BuiltinLintDiag::CfgAttrNoAttributes,
);
}
@@ -283,7 +283,6 @@
}
}
- #[allow(rustc::untranslatable_diagnostic)] // FIXME: make this translatable
fn expand_cfg_attr_item(
&self,
attr: &Attribute,
@@ -346,7 +345,7 @@
rustc_lint_defs::builtin::DEPRECATED_CFG_ATTR_CRATE_TYPE_NAME,
attr.span,
ast::CRATE_NODE_ID,
- "`crate_type` within an `#![cfg_attr] attribute is deprecated`",
+ BuiltinLintDiag::CrateTypeInCfgAttr,
);
}
if attr.has_name(sym::crate_name) {
@@ -354,7 +353,7 @@
rustc_lint_defs::builtin::DEPRECATED_CFG_ATTR_CRATE_TYPE_NAME,
attr.span,
ast::CRATE_NODE_ID,
- "`crate_name` within an `#![cfg_attr] attribute is deprecated`",
+ BuiltinLintDiag::CrateNameInCfgAttr,
);
}
attr
diff --git a/compiler/rustc_expand/src/expand.rs b/compiler/rustc_expand/src/expand.rs
index a049ac2..d8f0f22 100644
--- a/compiler/rustc_expand/src/expand.rs
+++ b/compiler/rustc_expand/src/expand.rs
@@ -1799,11 +1799,10 @@
}
if attr.is_doc_comment() {
- self.cx.sess.psess.buffer_lint_with_diagnostic(
+ self.cx.sess.psess.buffer_lint(
UNUSED_DOC_COMMENTS,
current_span,
self.cx.current_expansion.lint_node_id,
- "unused doc comment",
BuiltinLintDiag::UnusedDocComment(attr.span),
);
} else if rustc_attr::is_builtin_attr(attr) {
@@ -1811,11 +1810,10 @@
// `#[cfg]` and `#[cfg_attr]` are special - they are
// eagerly evaluated.
if attr_name != sym::cfg && attr_name != sym::cfg_attr {
- self.cx.sess.psess.buffer_lint_with_diagnostic(
+ self.cx.sess.psess.buffer_lint(
UNUSED_ATTRIBUTES,
attr.span,
self.cx.current_expansion.lint_node_id,
- format!("unused attribute `{attr_name}`"),
BuiltinLintDiag::UnusedBuiltinAttribute {
attr_name,
macro_name: pprust::path_to_string(&call.path),
diff --git a/compiler/rustc_expand/src/mbe/macro_check.rs b/compiler/rustc_expand/src/mbe/macro_check.rs
index dce8e0c..72dbbde 100644
--- a/compiler/rustc_expand/src/mbe/macro_check.rs
+++ b/compiler/rustc_expand/src/mbe/macro_check.rs
@@ -110,7 +110,8 @@
use rustc_ast::token::{Delimiter, IdentIsRaw, Token, TokenKind};
use rustc_ast::{NodeId, DUMMY_NODE_ID};
use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::{DiagMessage, MultiSpan};
+use rustc_errors::MultiSpan;
+use rustc_lint_defs::BuiltinLintDiag;
use rustc_session::lint::builtin::{META_VARIABLE_MISUSE, MISSING_FRAGMENT_SPECIFIER};
use rustc_session::parse::ParseSess;
use rustc_span::symbol::kw;
@@ -252,7 +253,7 @@
// 1. The meta-variable is already bound in the current LHS: This is an error.
let mut span = MultiSpan::from_span(span);
span.push_span_label(prev_info.span, "previous declaration");
- buffer_lint(psess, span, node_id, "duplicate matcher binding");
+ buffer_lint(psess, span, node_id, BuiltinLintDiag::DuplicateMatcherBinding);
} else if get_binder_info(macros, binders, name).is_none() {
// 2. The meta-variable is free: This is a binder.
binders.insert(name, BinderInfo { span, ops: ops.into() });
@@ -271,7 +272,7 @@
MISSING_FRAGMENT_SPECIFIER,
span,
node_id,
- "missing fragment specifier",
+ BuiltinLintDiag::MissingFragmentSpecifier,
);
}
if !macros.is_empty() {
@@ -595,7 +596,7 @@
return;
}
}
- buffer_lint(psess, span.into(), node_id, format!("unknown macro variable `{name}`"));
+ buffer_lint(psess, span.into(), node_id, BuiltinLintDiag::UnknownMacroVariable(name));
}
/// Returns whether `binder_ops` is a prefix of `occurrence_ops`.
@@ -628,8 +629,7 @@
if i >= occurrence_ops.len() {
let mut span = MultiSpan::from_span(span);
span.push_span_label(binder.span, "expected repetition");
- let message = format!("variable '{name}' is still repeating at this depth");
- buffer_lint(psess, span, node_id, message);
+ buffer_lint(psess, span, node_id, BuiltinLintDiag::MetaVariableStillRepeating(name));
return;
}
let occurrence = &occurrence_ops[i];
@@ -637,21 +637,15 @@
let mut span = MultiSpan::from_span(span);
span.push_span_label(binder.span, "expected repetition");
span.push_span_label(occurrence.span, "conflicting repetition");
- let message = "meta-variable repeats with different Kleene operator";
- buffer_lint(psess, span, node_id, message);
+ buffer_lint(psess, span, node_id, BuiltinLintDiag::MetaVariableWrongOperator);
return;
}
}
}
-fn buffer_lint(
- psess: &ParseSess,
- span: MultiSpan,
- node_id: NodeId,
- message: impl Into<DiagMessage>,
-) {
+fn buffer_lint(psess: &ParseSess, span: MultiSpan, node_id: NodeId, diag: BuiltinLintDiag) {
// Macros loaded from other crates have dummy node ids.
if node_id != DUMMY_NODE_ID {
- psess.buffer_lint(META_VARIABLE_MISUSE, span, node_id, message);
+ psess.buffer_lint(META_VARIABLE_MISUSE, span, node_id, diag);
}
}
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index 8f18055..d99ecb6 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -79,11 +79,10 @@
// but `m!()` is allowed in expression positions (cf. issue #34706).
if kind == AstFragmentKind::Expr && parser.token == token::Semi {
if is_local {
- parser.psess.buffer_lint_with_diagnostic(
+ parser.psess.buffer_lint(
SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
parser.token.span,
lint_node_id,
- "trailing semicolon in macro used in expression position",
BuiltinLintDiag::TrailingMacro(is_trailing_mac, macro_ident),
);
}
@@ -1154,11 +1153,10 @@
name,
Some(NonterminalKind::PatParam { inferred: false }),
));
- sess.psess.buffer_lint_with_diagnostic(
+ sess.psess.buffer_lint(
RUST_2021_INCOMPATIBLE_OR_PATTERNS,
span,
ast::CRATE_NODE_ID,
- "the meaning of the `pat` fragment specifier is changing in Rust 2021, which may affect this macro",
BuiltinLintDiag::OrPatternsBackCompat(span, suggestion),
);
}
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index ebaa9f8..0b4a871 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -515,12 +515,6 @@
EncodeCrossCrate::Yes, experimental!(deprecated_safe),
),
- // RFC 2397
- gated!(
- do_not_recommend, Normal, template!(Word), WarnFollowing,
- EncodeCrossCrate::Yes, experimental!(do_not_recommend)
- ),
-
// `#[cfi_encoding = ""]`
gated!(
cfi_encoding, Normal, template!(NameValueStr: "encoding"), ErrorPreceding,
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
index 00356ec..168a370 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
@@ -18,7 +18,7 @@
use rustc_infer::traits::FulfillmentError;
use rustc_middle::bug;
use rustc_middle::query::Key;
-use rustc_middle::ty::print::PrintTraitRefExt as _;
+use rustc_middle::ty::print::{PrintPolyTraitRefExt as _, PrintTraitRefExt as _};
use rustc_middle::ty::GenericParamDefKind;
use rustc_middle::ty::{self, suggest_constraining_type_param};
use rustc_middle::ty::{AdtDef, Ty, TyCtxt, TypeVisitableExt};
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 8caeb85..0cd77fe 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -40,6 +40,7 @@
use rustc_infer::traits::ObligationCause;
use rustc_middle::middle::stability::AllowUnstable;
use rustc_middle::mir::interpret::{LitToConstError, LitToConstInput};
+use rustc_middle::ty::print::PrintPolyTraitRefExt as _;
use rustc_middle::ty::{
self, Const, GenericArgKind, GenericArgsRef, GenericParamDefKind, ParamEnv, Ty, TyCtxt,
TypeVisitableExt,
diff --git a/compiler/rustc_hir_analysis/src/outlives/utils.rs b/compiler/rustc_hir_analysis/src/outlives/utils.rs
index 95290bb..5086c2a 100644
--- a/compiler/rustc_hir_analysis/src/outlives/utils.rs
+++ b/compiler/rustc_hir_analysis/src/outlives/utils.rs
@@ -9,7 +9,7 @@
/// Tracks the `T: 'a` or `'a: 'a` predicates that we have inferred
/// must be added to the struct header.
pub(crate) type RequiredPredicates<'tcx> =
- FxIndexMap<ty::OutlivesPredicate<GenericArg<'tcx>, ty::Region<'tcx>>, Span>;
+ FxIndexMap<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>, Span>;
/// Given a requirement `T: 'a` or `'b: 'a`, deduce the
/// outlives_component and add it to `required_predicates`
diff --git a/compiler/rustc_hir_typeck/src/demand.rs b/compiler/rustc_hir_typeck/src/demand.rs
index 6da5adc..7916366 100644
--- a/compiler/rustc_hir_typeck/src/demand.rs
+++ b/compiler/rustc_hir_typeck/src/demand.rs
@@ -373,8 +373,11 @@
let Some(arg_ty) = self.node_ty_opt(args[idx].hir_id) else {
return false;
};
- let possible_rcvr_ty = expr_finder.uses.iter().find_map(|binding| {
+ let possible_rcvr_ty = expr_finder.uses.iter().rev().find_map(|binding| {
let possible_rcvr_ty = self.node_ty_opt(binding.hir_id)?;
+ if possible_rcvr_ty.is_ty_var() {
+ return None;
+ }
// Fudge the receiver, so we can do new inference on it.
let possible_rcvr_ty = possible_rcvr_ty.fold_with(&mut fudger);
let method = self
@@ -386,6 +389,12 @@
binding,
)
.ok()?;
+ // Make sure we select the same method that we started with...
+ if Some(method.def_id)
+ != self.typeck_results.borrow().type_dependent_def_id(call_expr.hir_id)
+ {
+ return None;
+ }
// Unify the method signature with our incompatible arg, to
// do inference in the *opposite* direction and to find out
// what our ideal rcvr ty would look like.
@@ -456,6 +465,12 @@
) else {
continue;
};
+ // Make sure we select the same method that we started with...
+ if Some(method.def_id)
+ != self.typeck_results.borrow().type_dependent_def_id(parent_expr.hir_id)
+ {
+ continue;
+ }
let ideal_rcvr_ty = rcvr_ty.fold_with(&mut fudger);
let ideal_method = self
@@ -505,13 +520,19 @@
// blame arg, if possible. Don't do this if we're coming from
// arg mismatch code, because we'll possibly suggest a mutually
// incompatible fix at the original mismatch site.
+ // HACK(compiler-errors): We don't actually consider the implications
+ // of our inference guesses in `emit_type_mismatch_suggestions`, so
+ // only suggest things when we know our type error is precisely due to
+ // a type mismatch, and not via some projection or something. See #116155.
if matches!(source, TypeMismatchSource::Ty(_))
&& let Some(ideal_method) = ideal_method
- && let ideal_arg_ty = self.resolve_vars_if_possible(ideal_method.sig.inputs()[idx + 1])
- // HACK(compiler-errors): We don't actually consider the implications
- // of our inference guesses in `emit_type_mismatch_suggestions`, so
- // only suggest things when we know our type error is precisely due to
- // a type mismatch, and not via some projection or something. See #116155.
+ && Some(ideal_method.def_id)
+ == self
+ .typeck_results
+ .borrow()
+ .type_dependent_def_id(parent_expr.hir_id)
+ && let ideal_arg_ty =
+ self.resolve_vars_if_possible(ideal_method.sig.inputs()[idx + 1])
&& !ideal_arg_ty.has_non_region_infer()
{
self.emit_type_mismatch_suggestions(
diff --git a/compiler/rustc_hir_typeck/src/upvar.rs b/compiler/rustc_hir_typeck/src/upvar.rs
index 9d16f0d..e29a410 100644
--- a/compiler/rustc_hir_typeck/src/upvar.rs
+++ b/compiler/rustc_hir_typeck/src/upvar.rs
@@ -204,6 +204,60 @@
fake_reads: Default::default(),
};
+ let _ = euv::ExprUseVisitor::new(
+ &FnCtxt::new(self, self.tcx.param_env(closure_def_id), closure_def_id),
+ &mut delegate,
+ )
+ .consume_body(body);
+
+ // There are several curious situations with coroutine-closures where
+ // analysis is too aggressive with borrows when the coroutine-closure is
+ // marked `move`. Specifically:
+ //
+ // 1. If the coroutine-closure was inferred to be `FnOnce` during signature
+ // inference, then it's still possible that we try to borrow upvars from
+ // the coroutine-closure because they are not used by the coroutine body
+ // in a way that forces a move. See the test:
+ // `async-await/async-closures/force-move-due-to-inferred-kind.rs`.
+ //
+ // 2. If the coroutine-closure is forced to be `FnOnce` due to the way it
+ // uses its upvars, but not *all* upvars would force the closure to `FnOnce`.
+ // See the test: `async-await/async-closures/force-move-due-to-actually-fnonce.rs`.
+ //
+ // This would lead to an impossible to satisfy situation, since `AsyncFnOnce`
+ // coroutine bodies can't borrow from their parent closure. To fix this,
+ // we force the inner coroutine to also be `move`. This only matters for
+ // coroutine-closures that are `move` since otherwise they themselves will
+ // be borrowing from the outer environment, so there's no self-borrows occuring.
+ //
+ // One *important* note is that we do a call to `process_collected_capture_information`
+ // to eagerly test whether the coroutine would end up `FnOnce`, but we do this
+ // *before* capturing all the closure args by-value below, since that would always
+ // cause the analysis to return `FnOnce`.
+ if let UpvarArgs::Coroutine(..) = args
+ && let hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Closure) =
+ self.tcx.coroutine_kind(closure_def_id).expect("coroutine should have kind")
+ && let parent_hir_id =
+ self.tcx.local_def_id_to_hir_id(self.tcx.local_parent(closure_def_id))
+ && let parent_ty = self.node_ty(parent_hir_id)
+ && let hir::CaptureBy::Value { move_kw } =
+ self.tcx.hir_node(parent_hir_id).expect_closure().capture_clause
+ {
+ // (1.) Closure signature inference forced this closure to `FnOnce`.
+ if let Some(ty::ClosureKind::FnOnce) = self.closure_kind(parent_ty) {
+ capture_clause = hir::CaptureBy::Value { move_kw };
+ }
+ // (2.) The way that the closure uses its upvars means it's `FnOnce`.
+ else if let (_, ty::ClosureKind::FnOnce, _) = self
+ .process_collected_capture_information(
+ capture_clause,
+ &delegate.capture_information,
+ )
+ {
+ capture_clause = hir::CaptureBy::Value { move_kw };
+ }
+ }
+
// As noted in `lower_coroutine_body_with_moved_arguments`, we default the capture mode
// to `ByRef` for the `async {}` block internal to async fns/closure. This means
// that we would *not* be moving all of the parameters into the async block by default.
@@ -253,34 +307,6 @@
}
}
- let _ = euv::ExprUseVisitor::new(
- &FnCtxt::new(self, self.tcx.param_env(closure_def_id), closure_def_id),
- &mut delegate,
- )
- .consume_body(body);
-
- // If a coroutine is comes from a coroutine-closure that is `move`, but
- // the coroutine-closure was inferred to be `FnOnce` during signature
- // inference, then it's still possible that we try to borrow upvars from
- // the coroutine-closure because they are not used by the coroutine body
- // in a way that forces a move.
- //
- // This would lead to an impossible to satisfy situation, since `AsyncFnOnce`
- // coroutine bodies can't borrow from their parent closure. To fix this,
- // we force the inner coroutine to also be `move`. This only matters for
- // coroutine-closures that are `move` since otherwise they themselves will
- // be borrowing from the outer environment, so there's no self-borrows occuring.
- if let UpvarArgs::Coroutine(..) = args
- && let hir::CoroutineKind::Desugared(_, hir::CoroutineSource::Closure) =
- self.tcx.coroutine_kind(closure_def_id).expect("coroutine should have kind")
- && let parent_hir_id =
- self.tcx.local_def_id_to_hir_id(self.tcx.local_parent(closure_def_id))
- && let parent_ty = self.node_ty(parent_hir_id)
- && let Some(ty::ClosureKind::FnOnce) = self.closure_kind(parent_ty)
- {
- capture_clause = self.tcx.hir_node(parent_hir_id).expect_closure().capture_clause;
- }
-
debug!(
"For closure={:?}, capture_information={:#?}",
closure_def_id, delegate.capture_information
@@ -289,7 +315,7 @@
self.log_capture_analysis_first_pass(closure_def_id, &delegate.capture_information, span);
let (capture_information, closure_kind, origin) = self
- .process_collected_capture_information(capture_clause, delegate.capture_information);
+ .process_collected_capture_information(capture_clause, &delegate.capture_information);
self.compute_min_captures(closure_def_id, capture_information, span);
@@ -545,13 +571,14 @@
fn process_collected_capture_information(
&self,
capture_clause: hir::CaptureBy,
- capture_information: InferredCaptureInformation<'tcx>,
+ capture_information: &InferredCaptureInformation<'tcx>,
) -> (InferredCaptureInformation<'tcx>, ty::ClosureKind, Option<(Span, Place<'tcx>)>) {
let mut closure_kind = ty::ClosureKind::LATTICE_BOTTOM;
let mut origin: Option<(Span, Place<'tcx>)> = None;
let processed = capture_information
- .into_iter()
+ .iter()
+ .cloned()
.map(|(place, mut capture_info)| {
// Apply rules for safety before inferring closure kind
let (place, capture_kind) =
diff --git a/compiler/rustc_incremental/messages.ftl b/compiler/rustc_incremental/messages.ftl
index e74173b..de2177e 100644
--- a/compiler/rustc_incremental/messages.ftl
+++ b/compiler/rustc_incremental/messages.ftl
@@ -21,6 +21,8 @@
incremental_copy_workproduct_to_cache =
error copying object file `{$from}` to incremental directory as `{$to}`: {$err}
+incremental_corrupt_file = corrupt incremental compilation artifact found at `{$path}`. This file will automatically be ignored and deleted. If you see this message repeatedly or can provoke it without manually manipulating the compiler's artifacts, please file an issue. The incremental compilation system relies on hardlinks and filesystem locks behaving correctly, and may not deal well with OS crashes, so whatever information you can provide about your filesystem or other state may be very relevant.
+
incremental_create_dep_graph = failed to create dependency graph at `{$path}`: {$err}
incremental_create_incr_comp_dir =
diff --git a/compiler/rustc_incremental/src/errors.rs b/compiler/rustc_incremental/src/errors.rs
index 61bb035..e94a7fb 100644
--- a/compiler/rustc_incremental/src/errors.rs
+++ b/compiler/rustc_incremental/src/errors.rs
@@ -306,3 +306,9 @@
pub path: &'a Path,
pub err: std::io::Error,
}
+
+#[derive(Diagnostic)]
+#[diag(incremental_corrupt_file)]
+pub struct CorruptFile<'a> {
+ pub path: &'a Path,
+}
diff --git a/compiler/rustc_incremental/src/persist/load.rs b/compiler/rustc_incremental/src/persist/load.rs
index 26aaa247..9e6ce06 100644
--- a/compiler/rustc_incremental/src/persist/load.rs
+++ b/compiler/rustc_incremental/src/persist/load.rs
@@ -115,7 +115,12 @@
if let LoadResult::Ok { data: (work_products_data, start_pos) } = load_result {
// Decode the list of work_products
- let mut work_product_decoder = MemDecoder::new(&work_products_data[..], start_pos);
+ let Ok(mut work_product_decoder) =
+ MemDecoder::new(&work_products_data[..], start_pos)
+ else {
+ sess.dcx().emit_warn(errors::CorruptFile { path: &work_products_path });
+ return LoadResult::DataOutOfDate;
+ };
let work_products: Vec<SerializedWorkProduct> =
Decodable::decode(&mut work_product_decoder);
@@ -145,7 +150,10 @@
LoadResult::DataOutOfDate => LoadResult::DataOutOfDate,
LoadResult::LoadDepGraph(path, err) => LoadResult::LoadDepGraph(path, err),
LoadResult::Ok { data: (bytes, start_pos) } => {
- let mut decoder = MemDecoder::new(&bytes, start_pos);
+ let Ok(mut decoder) = MemDecoder::new(&bytes, start_pos) else {
+ sess.dcx().emit_warn(errors::CorruptFile { path: &path });
+ return LoadResult::DataOutOfDate;
+ };
let prev_commandline_args_hash = u64::decode(&mut decoder);
if prev_commandline_args_hash != expected_hash {
@@ -181,9 +189,14 @@
let _prof_timer = sess.prof.generic_activity("incr_comp_load_query_result_cache");
- match load_data(&query_cache_path(sess), sess) {
+ let path = query_cache_path(sess);
+ match load_data(&path, sess) {
LoadResult::Ok { data: (bytes, start_pos) } => {
- Some(OnDiskCache::new(sess, bytes, start_pos))
+ let cache = OnDiskCache::new(sess, bytes, start_pos).unwrap_or_else(|()| {
+ sess.dcx().emit_warn(errors::CorruptFile { path: &path });
+ OnDiskCache::new_empty(sess.source_map())
+ });
+ Some(cache)
}
_ => Some(OnDiskCache::new_empty(sess.source_map())),
}
diff --git a/compiler/rustc_infer/src/infer/outlives/env.rs b/compiler/rustc_infer/src/infer/outlives/env.rs
index c44a508..5bcb4f2 100644
--- a/compiler/rustc_infer/src/infer/outlives/env.rs
+++ b/compiler/rustc_infer/src/infer/outlives/env.rs
@@ -64,8 +64,7 @@
/// "Region-bound pairs" tracks outlives relations that are known to
/// be true, either because of explicit where-clauses like `T: 'a` or
/// because of implied bounds.
-pub type RegionBoundPairs<'tcx> =
- FxIndexSet<ty::OutlivesPredicate<GenericKind<'tcx>, Region<'tcx>>>;
+pub type RegionBoundPairs<'tcx> = FxIndexSet<ty::OutlivesPredicate<'tcx, GenericKind<'tcx>>>;
impl<'tcx> OutlivesEnvironment<'tcx> {
/// Create a builder using `ParamEnv` and add explicit outlives bounds into it.
diff --git a/compiler/rustc_infer/src/infer/outlives/verify.rs b/compiler/rustc_infer/src/infer/outlives/verify.rs
index bd981c2..7e977b9 100644
--- a/compiler/rustc_infer/src/infer/outlives/verify.rs
+++ b/compiler/rustc_infer/src/infer/outlives/verify.rs
@@ -94,7 +94,7 @@
pub fn approx_declared_bounds_from_env(
&self,
alias_ty: ty::AliasTy<'tcx>,
- ) -> Vec<ty::Binder<'tcx, ty::OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>>>> {
+ ) -> Vec<ty::PolyTypeOutlivesPredicate<'tcx>> {
let erased_alias_ty = self.tcx.erase_regions(alias_ty.to_ty(self.tcx));
self.declared_generic_bounds_from_env_for_erased_ty(erased_alias_ty)
}
@@ -193,7 +193,7 @@
fn declared_generic_bounds_from_env(
&self,
generic_ty: Ty<'tcx>,
- ) -> Vec<ty::Binder<'tcx, ty::OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>>>> {
+ ) -> Vec<ty::PolyTypeOutlivesPredicate<'tcx>> {
assert!(matches!(generic_ty.kind(), ty::Param(_) | ty::Placeholder(_)));
self.declared_generic_bounds_from_env_for_erased_ty(generic_ty)
}
@@ -213,7 +213,7 @@
fn declared_generic_bounds_from_env_for_erased_ty(
&self,
erased_ty: Ty<'tcx>,
- ) -> Vec<ty::Binder<'tcx, ty::OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>>>> {
+ ) -> Vec<ty::PolyTypeOutlivesPredicate<'tcx>> {
let tcx = self.tcx;
// To start, collect bounds from user environment. Note that
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index ce2382b..987e48a 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -399,31 +399,17 @@
if let ast::MetaItemKind::NameValue(spanned) = a.meta_kind().unwrap() {
let span = spanned.span;
- let lev_candidate = find_best_match_for_name(
+ let candidate = find_best_match_for_name(
&CRATE_TYPES.iter().map(|(k, _)| *k).collect::<Vec<_>>(),
n,
None,
);
- if let Some(candidate) = lev_candidate {
- lint_buffer.buffer_lint_with_diagnostic(
- lint::builtin::UNKNOWN_CRATE_TYPES,
- ast::CRATE_NODE_ID,
- span,
- "invalid `crate_type` value",
- BuiltinLintDiag::UnknownCrateTypes(
- span,
- "did you mean".to_string(),
- format!("\"{candidate}\""),
- ),
- );
- } else {
- lint_buffer.buffer_lint(
- lint::builtin::UNKNOWN_CRATE_TYPES,
- ast::CRATE_NODE_ID,
- span,
- "invalid `crate_type` value",
- );
- }
+ lint_buffer.buffer_lint(
+ lint::builtin::UNKNOWN_CRATE_TYPES,
+ ast::CRATE_NODE_ID,
+ span,
+ BuiltinLintDiag::UnknownCrateTypes { span, candidate },
+ );
}
} else {
// This is here mainly to check for using a macro, such as
diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index cf9d089..6f6480a 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -1,7 +1,20 @@
+lint_abs_path_with_module = absolute paths must start with `self`, `super`, `crate`, or an external crate name in the 2018 edition
+ .suggestion = use `crate`
+
+lint_ambiguous_glob_reexport = ambiguous glob re-exports
+ .label_first_reexport = the name `{$name}` in the {$namespace} namespace is first re-exported here
+ .label_duplicate_reexport = but the name `{$name}` in the {$namespace} namespace is also re-exported here
+
lint_ambiguous_wide_pointer_comparisons = ambiguous wide pointer comparison, the comparison includes metadata which may not be expected
.addr_metadata_suggestion = use explicit `std::ptr::eq` method to compare metadata and addresses
.addr_suggestion = use `std::ptr::addr_eq` or untyped pointers to only compare their addresses
+lint_associated_const_elided_lifetime = {$elided ->
+ [true] `&` without an explicit lifetime name cannot be used here
+ *[false] `'_` cannot be used here
+ }
+ .suggestion = use the `'static` lifetime
+
lint_async_fn_in_trait = use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
.note = you can suppress this lint if you plan to use the trait only in your own code, or do not care about auto traits like `Send` on the `Future`
.suggestion = you can alternatively desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
@@ -19,10 +32,19 @@
lint_atomic_ordering_store = atomic stores cannot have `Acquire` or `AcqRel` ordering
.help = consider using ordering modes `Release`, `SeqCst` or `Relaxed`
+lint_avoid_att_syntax =
+ avoid using `.att_syntax`, prefer using `options(att_syntax)` instead
+
+lint_avoid_intel_syntax =
+ avoid using `.intel_syntax`, Intel syntax is the default
+
lint_bad_attribute_argument = bad attribute argument
lint_bad_opt_access = {$msg}
+lint_break_with_label_and_loop = this labeled break expression is easy to confuse with an unlabeled break with a labeled value expression
+ .suggestion = wrap this expression in parentheses
+
lint_builtin_allow_internal_unsafe =
`allow_internal_unsafe` allows defining macros using unsafe without triggering the `unsafe_code` lint at their call site
@@ -30,6 +52,8 @@
.suggestion = try naming the parameter or explicitly ignoring it
lint_builtin_asm_labels = avoid using named labels in inline assembly
+ .help = only local labels of the form `<number>:` should be used in inline asm
+ .note = see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information
lint_builtin_box_pointers = type uses owned (Box type) pointers: {$ty}
@@ -154,6 +178,12 @@
lint_builtin_while_true = denote infinite loops with `loop {"{"} ... {"}"}`
.suggestion = use `loop`
+lint_byte_slice_in_packed_struct_with_derive = {$ty} slice in a packed struct that derives a built-in trait
+ .help = consider implementing the trait by hand, or remove the `packed` attribute
+
+lint_cfg_attr_no_attributes =
+ `#[cfg_attr]` does not expand to any attributes
+
lint_check_name_unknown_tool = unknown lint tool: `{$tool_name}`
lint_command_line_source = `forbid` lint level was set on command line
@@ -162,12 +192,20 @@
.current_use = this identifier can be confused with `{$existing_sym}`
.other_use = other identifier used here
+lint_crate_name_in_cfg_attr_deprecated =
+ `crate_name` within an `#![cfg_attr]` attribute is deprecated
+
+lint_crate_type_in_cfg_attr_deprecated =
+ `crate_type` within an `#![cfg_attr]` attribute is deprecated
+
lint_cstring_ptr = getting the inner pointer of a temporary `CString`
.as_ptr_label = this pointer will be invalid
.unwrap_label = this `CString` is deallocated at the end of the statement, bind it to a variable to extend its lifetime
.note = pointers do not have a lifetime; when calling `as_ptr` the `CString` will be deallocated at the end of the statement because nothing is referencing it as far as the type system is concerned
.help = for more information, see https://doc.rust-lang.org/reference/destructors.html
+lint_custom_inner_attribute_unstable = custom inner attributes are unstable
+
lint_default_hash_types = prefer `{$preferred}` over `{$used}`, it has better performance
.note = a `use rustc_data_structures::fx::{$preferred}` may be necessary
@@ -178,6 +216,11 @@
.suggestion = change it to
.help = change it to {$replace}
+lint_deprecated_where_clause_location = where clause not allowed here
+ .note = see issue #89122 <https://github.com/rust-lang/rust/issues/89122> for more information
+ .suggestion_move_to_end = move it to the end of the type declaration
+ .suggestion_remove_where = remove this `where`
+
lint_diag_out_of_impl =
diagnostics should only be created in `Diagnostic`/`Subdiagnostic`/`LintDiagnostic` impls
@@ -195,6 +238,11 @@
.label = argument has type `{$arg_ty}`
.note = use `let _ = ...` to ignore the expression or result
+lint_duplicate_macro_attribute =
+ duplicated attribute
+
+lint_duplicate_matcher_binding = duplicate matcher binding
+
lint_enum_intrinsics_mem_discriminant =
the return value of `mem::discriminant` is unspecified when called with a non-enum type
.note = the argument to `discriminant` should be a reference to an enum, but it was passed a reference to a `{$ty_param}`, which is not an enum.
@@ -207,6 +255,13 @@
.note = the `unfulfilled_lint_expectations` lint can't be expected and will always produce this message
.rationale = {$rationale}
+lint_extern_crate_not_idiomatic = `extern crate` is not idiomatic in the new edition
+ .suggestion = convert it to a `use`
+
+lint_extern_without_abi = extern declarations without an explicit ABI are deprecated
+ .label = ABI should be specified here
+ .help = the default ABI is {$default_abi}
+
lint_for_loops_over_fallibles =
for loop over {$article} `{$ty}`. This is more readably written as an `if let` statement
.suggestion = consider using `if let` to clear intent
@@ -221,6 +276,12 @@
.label = argument has type `{$arg_ty}`
.note = use `let _ = ...` to ignore the expression or result
+lint_hidden_glob_reexport = private item shadows public glob re-export
+ .note_glob_reexport = the name `{$name}` in the {$namespace} namespace is supposed to be publicly re-exported here
+ .note_private_item = but the private item here shadows it
+
+lint_hidden_lifetime_parameters = hidden lifetime parameters in types are deprecated
+
lint_hidden_unicode_codepoints = unicode codepoint changing visible direction of text present in {$label}
.label = this {$label} contains {$count ->
[one] an invisible
@@ -262,6 +323,11 @@
lint_ignored_unless_crate_specified = {$level}({$name}) is ignored unless specified at crate level
+lint_ill_formed_attribute_input = {$num_suggestions ->
+ [1] attribute must be of the form {$suggestions}
+ *[other] valid forms for the attribute are {$suggestions}
+ }
+
lint_impl_trait_overcaptures = `{$self_ty}` will capture more lifetimes than possibly intended in edition 2024
.note = specifically, {$num_captured ->
[one] this lifetime is
@@ -332,6 +398,14 @@
lint_improper_ctypes_union_layout_reason = this union has unspecified layout
lint_improper_ctypes_union_non_exhaustive = this union is non-exhaustive
+lint_incomplete_include =
+ include macro expected single expression in source
+
+lint_inner_macro_attribute_unstable = inner macro attributes are unstable
+
+lint_invalid_crate_type_value = invalid `crate_type` value
+ .suggestion = did you mean
+
# FIXME: we should ordinalize $valid_up_to when we add support for doing so
lint_invalid_from_utf8_checked = calls to `{$method}` with a invalid literal always return an error
.label = the literal was valid UTF-8 up to the {$valid_up_to} bytes
@@ -360,9 +434,22 @@
lint_invalid_reference_casting_note_ty_has_interior_mutability = even for types with interior mutability, the only legal way to obtain a mutable pointer from a shared reference is through `UnsafeCell::get`
+lint_legacy_derive_helpers = derive helper attribute is used before it is introduced
+ .label = the attribute is introduced here
+
lint_lintpass_by_hand = implementing `LintPass` by hand
.help = try using `declare_lint_pass!` or `impl_lint_pass!` instead
+lint_macro_expanded_macro_exports_accessed_by_absolute_paths = macro-expanded `macro_export` macros from the current crate cannot be referred to by absolute paths
+ .note = the macro is defined here
+
+lint_macro_is_private = macro `{$ident}` is private
+
+lint_macro_rule_never_used = rule #{$n} of macro `{$name}` is never used
+
+lint_macro_use_deprecated =
+ deprecated `#[macro_use]` attribute used to import macros should be replaced at use sites with a `use` item to import the macro instead
+
lint_malformed_attribute = malformed lint attribute input
lint_map_unit_fn = `Iterator::map` call that discard the iterator's values
@@ -372,6 +459,12 @@
.map_label = after this call to map, the resulting iterator is `impl Iterator<Item = ()>`, which means the only information carried by the iterator is the number of items
.suggestion = you might have meant to use `Iterator::for_each`
+lint_metavariable_still_repeating = variable '{$name}' is still repeating at this depth
+
+lint_metavariable_wrong_operator = meta-variable repeats with different Kleene operator
+
+lint_missing_fragment_specifier = missing fragment specifier
+
lint_mixed_script_confusables =
the usage of Script Group `{$set}` in this crate consists solely of mixed script confusables
.includes_note = the usage includes {$includes}
@@ -379,6 +472,11 @@
lint_multiple_supertrait_upcastable = `{$ident}` is object-safe and has multiple supertraits
+lint_named_argument_used_positionally = named argument `{$named_arg_name}` is not used by name
+ .label_named_arg = this named argument is referred to by position in formatting string
+ .label_position_arg = this formatting argument uses named argument `{$named_arg_name}` by position
+ .suggestion = use the named argument by name to avoid ambiguity
+
lint_node_source = `forbid` level set here
.note = {$reason}
@@ -490,6 +588,9 @@
lint_opaque_hidden_inferred_bound_sugg = add this bound
+lint_or_patterns_back_compat = the meaning of the `pat` fragment specifier is changing in Rust 2021, which may affect this macro
+ .suggestion = use pat_param to preserve semantics
+
lint_overflowing_bin_hex = literal out of range for `{$ty}`
.negative_note = the literal `{$lit}` (decimal `{$dec}`) does not fit into the type `{$ty}`
.negative_becomes_note = and the value `-{$lit}` will become `{$actually}{$ty}`
@@ -519,6 +620,21 @@
lint_path_statement_no_effect = path statement with no effect
+lint_pattern_in_bodiless = patterns aren't allowed in functions without bodies
+ .label = pattern not allowed in function without body
+
+lint_pattern_in_foreign = patterns aren't allowed in foreign function declarations
+ .label = pattern not allowed in foreign function
+
+lint_private_extern_crate_reexport =
+ extern crate `{$ident}` is private, and cannot be re-exported (error E0365), consider declaring with `pub`
+
+lint_proc_macro_back_compat = using an old version of `{$crate_name}`
+ .note = older versions of the `{$crate_name}` crate will stop compiling in future versions of Rust; please update to `{$crate_name}` v{$fixed_version}, or switch to one of the `{$crate_name}` alternatives
+
+lint_proc_macro_derive_resolution_fallback = cannot find {$ns} `{$ident}` in this scope
+ .label = names from parent modules are not accessible without an explicit import
+
lint_ptr_null_checks_fn_ptr = function pointers are not nullable, so checking them for null will always return false
.help = wrap the function pointer inside an `Option` and use `Option::is_none` to check for null pointer value
.label = expression has type `{$orig_ty}`
@@ -540,6 +656,16 @@
lint_reason_must_come_last = reason in lint attribute must come last
+lint_redundant_import = the item `{$ident}` is imported redundantly
+ .label_imported_here = the item `{ident}` is already imported here
+ .label_defined_here = the item `{ident}` is already defined here
+ .label_imported_prelude = the item `{ident}` is already imported by the extern prelude
+ .label_defined_prelude = the item `{ident}` is already defined by the extern prelude
+
+lint_redundant_import_visibility = glob import doesn't reexport anything with visibility `{$import_vis}` because no imported item is public enough
+ .note = the most public imported item is `{$max_vis}`
+ .help = reduce the glob import's visibility or increase visibility of imported items
+
lint_redundant_semicolons =
unnecessary trailing {$multiple ->
[true] semicolons
@@ -550,6 +676,8 @@
*[false] this semicolon
}
+lint_remove_mut_from_pattern = remove `mut` from the parameter
+
lint_removed_lint = lint `{$name}` has been removed: {$reason}
lint_renamed_lint = lint `{$name}` has been renamed to `{$replace}`
@@ -558,6 +686,10 @@
lint_requested_level = requested on the command line with `{$level} {$lint_name}`
+lint_reserved_prefix = prefix `{$prefix}` is unknown
+ .label = unknown prefix
+ .suggestion = insert whitespace here to avoid this being parsed as a prefix in Rust 2021
+
lint_shadowed_into_iter =
this method call resolves to `<&{$target} as IntoIterator>::into_iter` (due to backwards compatibility), but will resolve to `<{$target} as IntoIterator>::into_iter` in Rust {$edition}
.use_iter_suggestion = use `.iter()` instead of `.into_iter()` to avoid ambiguity
@@ -565,6 +697,11 @@
.use_explicit_into_iter_suggestion =
or use `IntoIterator::into_iter(..)` instead of `.into_iter()` to explicitly iterate by value
+lint_single_use_lifetime = lifetime parameter `{$ident}` only used once
+ .label_param = this lifetime...
+ .label_use = ...is used only here
+ .suggestion = elide the single-use lifetime
+
lint_span_use_eq_ctxt = use `.eq_ctxt()` instead of `.ctxt() == .ctxt()`
lint_supertrait_as_deref_target = this `Deref` implementation is covered by an implicit supertrait coercion
@@ -578,6 +715,10 @@
lint_suspicious_double_ref_deref =
using `.deref()` on a double reference, which returns `{$ty}` instead of dereferencing the inner type
+lint_trailing_semi_macro = trailing semicolon in macro used in expression position
+ .note1 = macro invocations at the end of a block are treated as expressions
+ .note2 = to ignore the value produced by the macro, add a semicolon after the invocation of `{$name}`
+
lint_ty_qualified = usage of qualified `ty::{$ty}`
.suggestion = try importing it and using it unqualified
@@ -591,12 +732,64 @@
.label = argument has type `{$arg_ty}`
.suggestion = use `std::mem::ManuallyDrop::into_inner` to get the inner value
+lint_unexpected_cfg_add_build_rs_println = or consider adding `{$build_rs_println}` to the top of the `build.rs`
+lint_unexpected_cfg_add_cargo_feature = consider using a Cargo feature instead
+lint_unexpected_cfg_add_cargo_toml_lint_cfg = or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:{$cargo_toml_lint_cfg}
+lint_unexpected_cfg_add_cmdline_arg = to expect this configuration use `{$cmdline_arg}`
+lint_unexpected_cfg_define_features = consider defining some features in `Cargo.toml`
+lint_unexpected_cfg_doc_cargo = see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
+lint_unexpected_cfg_doc_rustc = see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
+
+lint_unexpected_cfg_name = unexpected `cfg` condition name: `{$name}`
+lint_unexpected_cfg_name_expected_names = expected names are: {$possibilities}{$and_more ->
+ [0] {""}
+ *[other] {" "}and {$and_more} more
+ }
+lint_unexpected_cfg_name_expected_values = expected values for `{$best_match}` are: {$possibilities}
+lint_unexpected_cfg_name_similar_name = there is a config with a similar name
+lint_unexpected_cfg_name_similar_name_different_values = there is a config with a similar name and different values
+lint_unexpected_cfg_name_similar_name_no_value = there is a config with a similar name and no value
+lint_unexpected_cfg_name_similar_name_value = there is a config with a similar name and value
+lint_unexpected_cfg_name_with_similar_value = found config with similar value
+
+lint_unexpected_cfg_value = unexpected `cfg` condition value: {$has_value ->
+ [true] `{$value}`
+ *[false] (none)
+ }
+lint_unexpected_cfg_value_add_feature = consider adding `{$value}` as a feature in `Cargo.toml`
+lint_unexpected_cfg_value_expected_values = expected values for `{$name}` are: {$have_none_possibility ->
+ [true] {"(none), "}
+ *[false] {""}
+ }{$possibilities}{$and_more ->
+ [0] {""}
+ *[other] {" "}and {$and_more} more
+ }
+lint_unexpected_cfg_value_no_expected_value = no expected value for `{$name}`
+lint_unexpected_cfg_value_no_expected_values = no expected values for `{$name}`
+lint_unexpected_cfg_value_remove_condition = remove the condition
+lint_unexpected_cfg_value_remove_value = remove the value
+lint_unexpected_cfg_value_similar_name = there is a expected value with a similar name
+lint_unexpected_cfg_value_specify_value = specify a config value
+
lint_ungated_async_fn_track_caller = `#[track_caller]` on async functions is a no-op
.label = this function will not propagate the caller location
+lint_unicode_text_flow = unicode codepoint changing visible direction of text present in comment
+ .label = {$num_codepoints ->
+ [1] this comment contains an invisible unicode text flow control codepoint
+ *[other] this comment contains invisible unicode text flow control codepoints
+ }
+ .note = these kind of unicode codepoints change the way text flows on applications that support them, but can cause confusion because they change the order of characters on the screen
+ .suggestion = if their presence wasn't intentional, you can remove them
+ .label_comment_char = {$c_debug}
+
+
lint_unit_bindings = binding has unit type `()`
.label = this pattern is inferred to be the unit type `()`
+lint_unknown_diagnostic_attribute = unknown diagnostic attribute
+lint_unknown_diagnostic_attribute_typo_sugg = an attribute with a similar name exists
+
lint_unknown_gated_lint =
unknown lint: `{$name}`
.note = the `{$name}` lint is unstable
@@ -612,9 +805,16 @@
*[false] did you mean: `{$replace}`
}
+lint_unknown_macro_variable = unknown macro variable `{$name}`
+
lint_unknown_tool_in_scoped_lint = unknown tool name `{$tool_name}` found in scoped lint: `{$tool_name}::{$lint_name}`
.help = add `#![register_tool({$tool_name})]` to the crate root
+lint_unnameable_test_items = cannot test inner items
+
+lint_unnecessary_qualification = unnecessary qualification
+ .suggestion = remove the unnecessary path segments
+
lint_unsupported_group = `{$lint_group}` lint group is not supported with ´--force-warn´
lint_untranslatable_diag = diagnostics should be created using translatable messages
@@ -622,6 +822,9 @@
lint_unused_allocation = unnecessary allocation, use `&` instead
lint_unused_allocation_mut = unnecessary allocation, use `&mut` instead
+lint_unused_builtin_attribute = unused attribute `{$attr_name}`
+ .note = the built-in attribute `{$attr_name}` will be ignored, since it's applied to the macro invocation `{$macro_name}`
+
lint_unused_closure =
unused {$pre}{$count ->
[one] closure
@@ -638,14 +841,43 @@
}{$post} that must be used
.note = coroutines are lazy and do nothing unless resumed
+lint_unused_crate_dependency = external crate `{$extern_crate}` unused in `{$local_crate}`: remove the dependency or add `use {$extern_crate} as _;`
+
lint_unused_def = unused {$pre}`{$def}`{$post} that must be used
.suggestion = use `let _ = ...` to ignore the resulting value
lint_unused_delim = unnecessary {$delim} around {$item}
.suggestion = remove these {$delim}
+lint_unused_doc_comment = unused doc comment
+ .label = rustdoc does not generate documentation for macro invocations
+ .help = to document an item produced by a macro, the macro must produce the documentation as part of its expansion
+
+lint_unused_extern_crate = unused extern crate
+ .suggestion = remove it
+
lint_unused_import_braces = braces around {$node} is unnecessary
+lint_unused_imports = {$num_snippets ->
+ [one] unused import: {$span_snippets}
+ *[other] unused imports: {$span_snippets}
+ }
+ .suggestion_remove_whole_use = remove the whole `use` item
+ .suggestion_remove_imports = {$num_to_remove ->
+ [one] remove the unused import
+ *[other] remove the unused imports
+ }
+ .help = if this is a test module, consider adding a `#[cfg(test)]` to the containing module
+
+lint_unused_label = unused label
+
+lint_unused_lifetime = lifetime parameter `{$ident}` never used
+ .suggestion = elide the unused lifetime
+
+lint_unused_macro_definition = unused macro definition: `{$name}`
+
+lint_unused_macro_use = unused `#[macro_use]` import
+
lint_unused_op = unused {$op} that must be used
.label = the {$op} produces a value
.suggestion = use `let _ = ...` to ignore the resulting value
@@ -654,3 +886,6 @@
lint_variant_size_differences =
enum variant is more than three times larger ({$largest} bytes) than the next largest
+
+lint_wasm_c_abi =
+ older versions of the `wasm-bindgen` crate will be incompatible with future versions of Rust; please update to `wasm-bindgen` v0.2.88
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 6b9f9d1..0f059bc 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -30,10 +30,10 @@
BuiltinExplicitOutlivesSuggestion, BuiltinFeatureIssueNote, BuiltinIncompleteFeatures,
BuiltinIncompleteFeaturesHelp, BuiltinInternalFeatures, BuiltinKeywordIdents,
BuiltinMissingCopyImpl, BuiltinMissingDebugImpl, BuiltinMissingDoc,
- BuiltinMutablesTransmutes, BuiltinNoMangleGeneric, BuiltinNonShorthandFieldPatterns,
- BuiltinSpecialModuleNameUsed, BuiltinTrivialBounds, BuiltinTypeAliasGenericBounds,
- BuiltinTypeAliasGenericBoundsSuggestion, BuiltinTypeAliasWhereClause,
- BuiltinUngatedAsyncFnTrackCaller, BuiltinUnpermittedTypeInit,
+ BuiltinMutablesTransmutes, BuiltinNamedAsmLabel, BuiltinNoMangleGeneric,
+ BuiltinNonShorthandFieldPatterns, BuiltinSpecialModuleNameUsed, BuiltinTrivialBounds,
+ BuiltinTypeAliasGenericBounds, BuiltinTypeAliasGenericBoundsSuggestion,
+ BuiltinTypeAliasWhereClause, BuiltinUngatedAsyncFnTrackCaller, BuiltinUnpermittedTypeInit,
BuiltinUnpermittedTypeInitSub, BuiltinUnreachablePub, BuiltinUnsafe,
BuiltinUnstableFeatures, BuiltinUnusedDocComment, BuiltinUnusedDocCommentSub,
BuiltinWhileTrue, SuggestChangingAssocTypes,
@@ -60,7 +60,7 @@
use rustc_middle::ty::TypeVisitableExt;
use rustc_middle::ty::Upcast;
use rustc_middle::ty::{self, Ty, TyCtxt, VariantDef};
-use rustc_session::lint::{BuiltinLintDiag, FutureIncompatibilityReason};
+use rustc_session::lint::FutureIncompatibilityReason;
use rustc_session::{declare_lint, declare_lint_pass, impl_lint_pass};
use rustc_span::edition::Edition;
use rustc_span::source_map::Spanned;
@@ -2882,16 +2882,7 @@
let target_spans: MultiSpan =
if spans.len() > 0 { spans.into() } else { (*template_span).into() };
- cx.span_lint_with_diagnostics(
- NAMED_ASM_LABELS,
- Some(target_spans),
- fluent::lint_builtin_asm_labels,
- |_| {},
- BuiltinLintDiag::NamedAsmLabel(
- "only local labels of the form `<number>:` should be used in inline asm"
- .to_string(),
- ),
- );
+ cx.emit_span_lint(NAMED_ASM_LABELS, target_spans, BuiltinNamedAsmLabel);
}
}
}
diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs
index 62ba9ef..deeb3ae 100644
--- a/compiler/rustc_lint/src/context.rs
+++ b/compiler/rustc_lint/src/context.rs
@@ -527,30 +527,24 @@
pub buffered: LintBuffer,
}
-pub trait LintContext {
- fn sess(&self) -> &Session;
-
+impl EarlyContext<'_> {
/// Emit a lint at the appropriate level, with an optional associated span and an existing
/// diagnostic.
///
/// [`lint_level`]: rustc_middle::lint::lint_level#decorate-signature
#[rustc_lint_diagnostics]
- fn span_lint_with_diagnostics(
+ pub fn span_lint_with_diagnostics(
&self,
lint: &'static Lint,
- span: Option<impl Into<MultiSpan>>,
- msg: impl Into<DiagMessage>,
- decorate: impl for<'a, 'b> FnOnce(&'b mut Diag<'a, ()>),
+ span: MultiSpan,
diagnostic: BuiltinLintDiag,
) {
- // We first generate a blank diagnostic.
- self.opt_span_lint(lint, span, msg, |db| {
- // Now, set up surrounding context.
- diagnostics::builtin(self.sess(), diagnostic, db);
- // Rewrap `db`, and pass control to the user.
- decorate(db)
- });
+ diagnostics::emit_buffered_lint(self, lint, span, diagnostic)
}
+}
+
+pub trait LintContext {
+ fn sess(&self) -> &Session;
// FIXME: These methods should not take an Into<MultiSpan> -- instead, callers should need to
// set the span in their `decorate` function (preferably using set_span).
diff --git a/compiler/rustc_lint/src/context/diagnostics.rs b/compiler/rustc_lint/src/context/diagnostics.rs
index 5ad3ff7..236eeee 100644
--- a/compiler/rustc_lint/src/context/diagnostics.rs
+++ b/compiler/rustc_lint/src/context/diagnostics.rs
@@ -1,58 +1,57 @@
#![allow(rustc::diagnostic_outside_of_impl)]
#![allow(rustc::untranslatable_diagnostic)]
+use std::borrow::Cow;
+
use rustc_ast::util::unicode::TEXT_FLOW_CONTROL_CHARS;
-use rustc_errors::{elided_lifetime_in_path_suggestion, Diag};
-use rustc_errors::{Applicability, SuggestionStyle};
+use rustc_errors::Applicability;
+use rustc_errors::{elided_lifetime_in_path_suggestion, DiagArgValue, MultiSpan};
use rustc_middle::middle::stability;
-use rustc_session::lint::BuiltinLintDiag;
-use rustc_session::Session;
+use rustc_session::lint::{BuiltinLintDiag, Lint};
use rustc_span::BytePos;
+use crate::{lints, EarlyContext, LintContext as _};
+
mod check_cfg;
-pub(super) fn builtin(sess: &Session, diagnostic: BuiltinLintDiag, diag: &mut Diag<'_, ()>) {
+pub(super) fn emit_buffered_lint(
+ ctx: &EarlyContext<'_>,
+ lint: &'static Lint,
+ span: MultiSpan,
+ diagnostic: BuiltinLintDiag,
+) {
+ let sess = ctx.sess();
match diagnostic {
- BuiltinLintDiag::UnicodeTextFlow(span, content) => {
+ BuiltinLintDiag::UnicodeTextFlow(comment_span, content) => {
let spans: Vec<_> = content
.char_indices()
.filter_map(|(i, c)| {
TEXT_FLOW_CONTROL_CHARS.contains(&c).then(|| {
- let lo = span.lo() + BytePos(2 + i as u32);
- (c, span.with_lo(lo).with_hi(lo + BytePos(c.len_utf8() as u32)))
+ let lo = comment_span.lo() + BytePos(2 + i as u32);
+ (c, comment_span.with_lo(lo).with_hi(lo + BytePos(c.len_utf8() as u32)))
})
})
.collect();
- let (an, s) = match spans.len() {
- 1 => ("an ", ""),
- _ => ("", "s"),
- };
- diag.span_label(
+ let characters = spans
+ .iter()
+ .map(|&(c, span)| lints::UnicodeCharNoteSub { span, c_debug: format!("{c:?}") })
+ .collect();
+ let suggestions = (!spans.is_empty()).then_some(lints::UnicodeTextFlowSuggestion {
+ spans: spans.iter().map(|(_c, span)| *span).collect(),
+ });
+ ctx.emit_span_lint(
+ lint,
span,
- format!(
- "this comment contains {an}invisible unicode text flow control codepoint{s}",
- ),
- );
- for (c, span) in &spans {
- diag.span_label(*span, format!("{c:?}"));
- }
- diag.note(
- "these kind of unicode codepoints change the way text flows on \
- applications that support them, but can cause confusion because they \
- change the order of characters on the screen",
- );
- if !spans.is_empty() {
- diag.multipart_suggestion_with_style(
- "if their presence wasn't intentional, you can remove them",
- spans.into_iter().map(|(_, span)| (span, "".to_string())).collect(),
- Applicability::MachineApplicable,
- SuggestionStyle::HideCodeAlways,
- );
- }
+ lints::UnicodeTextFlow {
+ comment_span,
+ characters,
+ suggestions,
+ num_codepoints: spans.len(),
+ },
+ )
}
- BuiltinLintDiag::Normal => (),
- BuiltinLintDiag::AbsPathWithModule(span) => {
- let (sugg, app) = match sess.source_map().span_to_snippet(span) {
+ BuiltinLintDiag::AbsPathWithModule(mod_span) => {
+ let (replacement, applicability) = match sess.source_map().span_to_snippet(mod_span) {
Ok(ref s) => {
// FIXME(Manishearth) ideally the emitting code
// can tell us whether or not this is global
@@ -62,160 +61,207 @@
}
Err(_) => ("crate::<path>".to_string(), Applicability::HasPlaceholders),
};
- diag.span_suggestion(span, "use `crate`", sugg, app);
- }
- BuiltinLintDiag::ProcMacroDeriveResolutionFallback(span) => {
- diag.span_label(
+ ctx.emit_span_lint(
+ lint,
span,
- "names from parent modules are not accessible without an explicit import",
+ lints::AbsPathWithModule {
+ sugg: lints::AbsPathWithModuleSugg {
+ span: mod_span,
+ applicability,
+ replacement,
+ },
+ },
);
}
- BuiltinLintDiag::MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def) => {
- diag.span_note(span_def, "the macro is defined here");
- }
+ BuiltinLintDiag::ProcMacroDeriveResolutionFallback { span: macro_span, ns, ident } => ctx
+ .emit_span_lint(
+ lint,
+ span,
+ lints::ProcMacroDeriveResolutionFallback { span: macro_span, ns, ident },
+ ),
+ BuiltinLintDiag::MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def) => ctx
+ .emit_span_lint(
+ lint,
+ span,
+ lints::MacroExpandedMacroExportsAccessedByAbsolutePaths { definition: span_def },
+ ),
BuiltinLintDiag::ElidedLifetimesInPaths(n, path_span, incl_angl_brckt, insertion_span) => {
- diag.subdiagnostic(
- sess.dcx(),
- elided_lifetime_in_path_suggestion(
- sess.source_map(),
- n,
- path_span,
- incl_angl_brckt,
- insertion_span,
- ),
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::ElidedLifetimesInPaths {
+ subdiag: elided_lifetime_in_path_suggestion(
+ sess.source_map(),
+ n,
+ path_span,
+ incl_angl_brckt,
+ insertion_span,
+ ),
+ },
);
}
- BuiltinLintDiag::UnknownCrateTypes(span, note, sugg) => {
- diag.span_suggestion(span, note, sugg, Applicability::MaybeIncorrect);
+ BuiltinLintDiag::UnknownCrateTypes { span, candidate } => {
+ let sugg = candidate.map(|candidate| lints::UnknownCrateTypesSub { span, candidate });
+ ctx.emit_span_lint(lint, span, lints::UnknownCrateTypes { sugg });
}
- BuiltinLintDiag::UnusedImports(message, replaces, in_test_module) => {
- if !replaces.is_empty() {
- diag.tool_only_multipart_suggestion(
- message,
- replaces,
- Applicability::MachineApplicable,
- );
- }
+ BuiltinLintDiag::UnusedImports {
+ remove_whole_use,
+ num_to_remove,
+ remove_spans,
+ test_module_span,
+ span_snippets,
+ } => {
+ let sugg = if remove_whole_use {
+ lints::UnusedImportsSugg::RemoveWholeUse { span: remove_spans[0] }
+ } else {
+ lints::UnusedImportsSugg::RemoveImports { remove_spans, num_to_remove }
+ };
+ let test_module_span =
+ test_module_span.map(|span| sess.source_map().guess_head_span(span));
- if let Some(span) = in_test_module {
- diag.span_help(
- sess.source_map().guess_head_span(span),
- "if this is a test module, consider adding a `#[cfg(test)]` to the containing module",
- );
- }
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::UnusedImports {
+ sugg,
+ test_module_span,
+ num_snippets: span_snippets.len(),
+ span_snippets: DiagArgValue::StrListSepByAnd(
+ span_snippets.into_iter().map(Cow::Owned).collect(),
+ ),
+ },
+ );
}
BuiltinLintDiag::RedundantImport(spans, ident) => {
- for (span, is_imported) in spans {
- let introduced = if is_imported { "imported" } else { "defined" };
- let span_msg = if span.is_dummy() { "by the extern prelude" } else { "here" };
- diag.span_label(
- span,
- format!("the item `{ident}` is already {introduced} {span_msg}"),
- );
- }
+ let subs = spans
+ .into_iter()
+ .map(|(span, is_imported)| {
+ (match (span.is_dummy(), is_imported) {
+ (false, true) => lints::RedundantImportSub::ImportedHere,
+ (false, false) => lints::RedundantImportSub::DefinedHere,
+ (true, true) => lints::RedundantImportSub::ImportedPrelude,
+ (true, false) => lints::RedundantImportSub::DefinedPrelude,
+ })(span)
+ })
+ .collect();
+ ctx.emit_span_lint(lint, span, lints::RedundantImport { subs, ident });
}
- BuiltinLintDiag::DeprecatedMacro(suggestion, span) => {
- stability::deprecation_suggestion(diag, "macro", suggestion, span)
- }
- BuiltinLintDiag::UnusedDocComment(span) => {
- diag.span_label(span, "rustdoc does not generate documentation for macro invocations");
- diag.help("to document an item produced by a macro, \
- the macro must produce the documentation as part of its expansion");
- }
- BuiltinLintDiag::PatternsInFnsWithoutBody(span, ident) => {
- diag.span_suggestion(
- span,
- "remove `mut` from the parameter",
- ident,
- Applicability::MachineApplicable,
- );
- }
- BuiltinLintDiag::MissingAbi(span, default_abi) => {
- diag.span_label(span, "ABI should be specified here");
- diag.help(format!("the default ABI is {}", default_abi.name()));
- }
- BuiltinLintDiag::LegacyDeriveHelpers(span) => {
- diag.span_label(span, "the attribute is introduced here");
- }
- BuiltinLintDiag::ProcMacroBackCompat(note) => {
- diag.note(note);
- }
- BuiltinLintDiag::OrPatternsBackCompat(span, suggestion) => {
- diag.span_suggestion(
- span,
- "use pat_param to preserve semantics",
+ BuiltinLintDiag::DeprecatedMacro {
+ suggestion,
+ suggestion_span,
+ note,
+ path,
+ since_kind,
+ } => {
+ let sub = suggestion.map(|suggestion| stability::DeprecationSuggestion {
+ span: suggestion_span,
+ kind: "macro".to_owned(),
suggestion,
- Applicability::MachineApplicable,
+ });
+ ctx.emit_span_lint(
+ lint,
+ span,
+ stability::Deprecated { sub, kind: "macro".to_owned(), path, note, since_kind },
);
}
- BuiltinLintDiag::ReservedPrefix(span) => {
- diag.span_label(span, "unknown prefix");
- diag.span_suggestion_verbose(
- span.shrink_to_hi(),
- "insert whitespace here to avoid this being parsed as a prefix in Rust 2021",
- " ",
- Applicability::MachineApplicable,
+ BuiltinLintDiag::UnusedDocComment(attr_span) => {
+ ctx.emit_span_lint(lint, span, lints::UnusedDocComment { span: attr_span });
+ }
+ BuiltinLintDiag::PatternsInFnsWithoutBody { span: remove_span, ident, is_foreign } => {
+ let sub = lints::PatternsInFnsWithoutBodySub { ident, span: remove_span };
+
+ ctx.emit_span_lint(
+ lint,
+ span,
+ if is_foreign {
+ lints::PatternsInFnsWithoutBody::Foreign { sub }
+ } else {
+ lints::PatternsInFnsWithoutBody::Bodiless { sub }
+ },
+ );
+ }
+ BuiltinLintDiag::MissingAbi(label_span, default_abi) => {
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::MissingAbi { span: label_span, default_abi: default_abi.name() },
+ );
+ }
+ BuiltinLintDiag::LegacyDeriveHelpers(label_span) => {
+ ctx.emit_span_lint(lint, span, lints::LegacyDeriveHelpers { span: label_span });
+ }
+ BuiltinLintDiag::ProcMacroBackCompat { crate_name, fixed_version } => {
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::ProcMacroBackCompat { crate_name, fixed_version },
+ );
+ }
+ BuiltinLintDiag::OrPatternsBackCompat(suggestion_span, suggestion) => {
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::OrPatternsBackCompat { span: suggestion_span, suggestion },
+ );
+ }
+ BuiltinLintDiag::ReservedPrefix(label_span, prefix) => {
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::ReservedPrefix {
+ label: label_span,
+ suggestion: label_span.shrink_to_hi(),
+ prefix,
+ },
);
}
BuiltinLintDiag::UnusedBuiltinAttribute { attr_name, macro_name, invoc_span } => {
- diag.span_note(
- invoc_span,
- format!("the built-in attribute `{attr_name}` will be ignored, since it's applied to the macro invocation `{macro_name}`")
- );
- }
- BuiltinLintDiag::TrailingMacro(is_trailing, name) => {
- if is_trailing {
- diag.note("macro invocations at the end of a block are treated as expressions");
- diag.note(format!("to ignore the value produced by the macro, add a semicolon after the invocation of `{name}`"));
- }
- }
- BuiltinLintDiag::BreakWithLabelAndLoop(span) => {
- diag.multipart_suggestion(
- "wrap this expression in parentheses",
- vec![
- (span.shrink_to_lo(), "(".to_string()),
- (span.shrink_to_hi(), ")".to_string()),
- ],
- Applicability::MachineApplicable,
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::UnusedBuiltinAttribute { invoc_span, attr_name, macro_name },
);
}
- BuiltinLintDiag::NamedAsmLabel(help) => {
- diag.help(help);
- diag.note("see the asm section of Rust By Example <https://doc.rust-lang.org/nightly/rust-by-example/unsafe/asm.html#labels> for more information");
+ BuiltinLintDiag::TrailingMacro(is_trailing, name) => {
+ ctx.emit_span_lint(lint, span, lints::TrailingMacro { is_trailing, name });
+ }
+ BuiltinLintDiag::BreakWithLabelAndLoop(sugg_span) => {
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::BreakWithLabelAndLoop {
+ sub: lints::BreakWithLabelAndLoopSub {
+ left: sugg_span.shrink_to_lo(),
+ right: sugg_span.shrink_to_hi(),
+ },
+ },
+ );
}
BuiltinLintDiag::UnexpectedCfgName(name, value) => {
- check_cfg::unexpected_cfg_name(sess, diag, name, value)
+ ctx.emit_span_lint(lint, span, check_cfg::unexpected_cfg_name(sess, name, value));
}
BuiltinLintDiag::UnexpectedCfgValue(name, value) => {
- check_cfg::unexpected_cfg_value(sess, diag, name, value)
+ ctx.emit_span_lint(lint, span, check_cfg::unexpected_cfg_value(sess, name, value));
}
- BuiltinLintDiag::DeprecatedWhereclauseLocation(sugg) => {
- let left_sp = diag.span.primary_span().unwrap();
- match sugg {
- Some((right_sp, sugg)) => diag.multipart_suggestion(
- "move it to the end of the type declaration",
- vec![(left_sp, String::new()), (right_sp, sugg)],
- Applicability::MachineApplicable,
- ),
- None => diag.span_suggestion(
- left_sp,
- "remove this `where`",
- "",
- Applicability::MachineApplicable,
- ),
+ BuiltinLintDiag::DeprecatedWhereclauseLocation(left_sp, sugg) => {
+ let suggestion = match sugg {
+ Some((right_sp, sugg)) => lints::DeprecatedWhereClauseLocationSugg::MoveToEnd {
+ left: left_sp,
+ right: right_sp,
+ sugg,
+ },
+ None => lints::DeprecatedWhereClauseLocationSugg::RemoveWhere { span: left_sp },
};
- diag.note("see issue #89122 <https://github.com/rust-lang/rust/issues/89122> for more information");
+ ctx.emit_span_lint(lint, span, lints::DeprecatedWhereClauseLocation { suggestion });
}
BuiltinLintDiag::SingleUseLifetime {
param_span,
use_span: Some((use_span, elide)),
deletion_span,
+ ident,
} => {
debug!(?param_span, ?use_span, ?deletion_span);
- diag.span_label(param_span, "this lifetime...");
- diag.span_label(use_span, "...is used only here");
- if let Some(deletion_span) = deletion_span {
- let msg = "elide the single-use lifetime";
+ let suggestion = if let Some(deletion_span) = deletion_span {
let (use_span, replace_lt) = if elide {
let use_span = sess.source_map().span_extend_while_whitespace(use_span);
(use_span, String::new())
@@ -226,24 +272,22 @@
// issue 107998 for the case such as a wrong function pointer type
// `deletion_span` is empty and there is no need to report lifetime uses here
- let suggestions = if deletion_span.is_empty() {
- vec![(use_span, replace_lt)]
- } else {
- vec![(deletion_span, String::new()), (use_span, replace_lt)]
- };
- diag.multipart_suggestion(msg, suggestions, Applicability::MachineApplicable);
- }
+ let deletion_span =
+ if deletion_span.is_empty() { None } else { Some(deletion_span) };
+ Some(lints::SingleUseLifetimeSugg { deletion_span, use_span, replace_lt })
+ } else {
+ None
+ };
+
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::SingleUseLifetime { suggestion, param_span, use_span, ident },
+ );
}
- BuiltinLintDiag::SingleUseLifetime { param_span: _, use_span: None, deletion_span } => {
+ BuiltinLintDiag::SingleUseLifetime { use_span: None, deletion_span, ident, .. } => {
debug!(?deletion_span);
- if let Some(deletion_span) = deletion_span {
- diag.span_suggestion(
- deletion_span,
- "elide the unused lifetime",
- "",
- Applicability::MachineApplicable,
- );
- }
+ ctx.emit_span_lint(lint, span, lints::UnusedLifetime { deletion_span, ident });
}
BuiltinLintDiag::NamedArgumentUsedPositionally {
position_sp_to_replace,
@@ -252,19 +296,12 @@
named_arg_name,
is_formatting_arg,
} => {
- diag.span_label(
- named_arg_sp,
- "this named argument is referred to by position in formatting string",
- );
- if let Some(positional_arg_for_msg) = position_sp_for_msg {
- let msg = format!(
- "this formatting argument uses named argument `{named_arg_name}` by position"
- );
- diag.span_label(positional_arg_for_msg, msg);
- }
-
- if let Some(positional_arg_to_replace) = position_sp_to_replace {
- let name = if is_formatting_arg { named_arg_name + "$" } else { named_arg_name };
+ let (suggestion, name) = if let Some(positional_arg_to_replace) = position_sp_to_replace
+ {
+ let mut name = named_arg_name.clone();
+ if is_formatting_arg {
+ name.push('$')
+ };
let span_to_replace = if let Ok(positional_arg_content) =
sess.source_map().span_to_snippet(positional_arg_to_replace)
&& positional_arg_content.starts_with(':')
@@ -273,31 +310,40 @@
} else {
positional_arg_to_replace
};
- diag.span_suggestion_verbose(
- span_to_replace,
- "use the named argument by name to avoid ambiguity",
+ (Some(span_to_replace), name)
+ } else {
+ (None, String::new())
+ };
+
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::NamedArgumentUsedPositionally {
+ named_arg_sp,
+ position_label_sp: position_sp_for_msg,
+ suggestion,
name,
- Applicability::MaybeIncorrect,
- );
- }
+ named_arg_name,
+ },
+ )
}
- BuiltinLintDiag::ByteSliceInPackedStructWithDerive => {
- diag.help("consider implementing the trait by hand, or remove the `packed` attribute");
+ BuiltinLintDiag::ByteSliceInPackedStructWithDerive { ty } => {
+ ctx.emit_span_lint(lint, span, lints::ByteSliceInPackedStructWithDerive { ty })
}
BuiltinLintDiag::UnusedExternCrate { removal_span } => {
- diag.span_suggestion(removal_span, "remove it", "", Applicability::MachineApplicable);
+ ctx.emit_span_lint(lint, span, lints::UnusedExternCrate { removal_span })
}
BuiltinLintDiag::ExternCrateNotIdiomatic { vis_span, ident_span } => {
let suggestion_span = vis_span.between(ident_span);
- diag.span_suggestion_verbose(
- suggestion_span,
- "convert it to a `use`",
- if vis_span.is_empty() { "use " } else { " use " },
- Applicability::MachineApplicable,
+ let code = if vis_span.is_empty() { "use " } else { " use " };
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::ExternCrateNotIdiomatic { span: suggestion_span, code },
);
}
BuiltinLintDiag::AmbiguousGlobImports { diag: ambiguity } => {
- rustc_errors::report_ambiguity_error(diag, ambiguity);
+ ctx.emit_span_lint(lint, span, lints::AmbiguousGlobImports { ambiguity });
}
BuiltinLintDiag::AmbiguousGlobReexports {
name,
@@ -305,15 +351,15 @@
first_reexport_span,
duplicate_reexport_span,
} => {
- diag.span_label(
- first_reexport_span,
- format!("the name `{name}` in the {namespace} namespace is first re-exported here"),
- );
- diag.span_label(
- duplicate_reexport_span,
- format!(
- "but the name `{name}` in the {namespace} namespace is also re-exported here"
- ),
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::AmbiguousGlobReexports {
+ first_reexport: first_reexport_span,
+ duplicate_reexport: duplicate_reexport_span,
+ name,
+ namespace,
+ },
);
}
BuiltinLintDiag::HiddenGlobReexports {
@@ -322,38 +368,127 @@
glob_reexport_span,
private_item_span,
} => {
- diag.span_note(glob_reexport_span, format!("the name `{name}` in the {namespace} namespace is supposed to be publicly re-exported here"));
- diag.span_note(private_item_span, "but the private item here shadows it".to_owned());
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::HiddenGlobReexports {
+ glob_reexport: glob_reexport_span,
+ private_item: private_item_span,
+
+ name,
+ namespace,
+ },
+ );
}
BuiltinLintDiag::UnusedQualifications { removal_span } => {
- diag.span_suggestion_verbose(
- removal_span,
- "remove the unnecessary path segments",
- "",
- Applicability::MachineApplicable,
- );
+ ctx.emit_span_lint(lint, span, lints::UnusedQualifications { removal_span });
}
- BuiltinLintDiag::AssociatedConstElidedLifetime { elided, span } => {
- diag.span_suggestion_verbose(
- if elided { span.shrink_to_hi() } else { span },
- "use the `'static` lifetime",
- if elided { "'static " } else { "'static" },
- Applicability::MachineApplicable,
- );
- }
- BuiltinLintDiag::RedundantImportVisibility { max_vis, span } => {
- diag.span_note(span, format!("the most public imported item is `{max_vis}`"));
- diag.help(
- "reduce the glob import's visibility or increase visibility of imported items",
- );
- }
- BuiltinLintDiag::MaybeTypo { span, name } => {
- diag.span_suggestion_verbose(
+ BuiltinLintDiag::AssociatedConstElidedLifetime { elided, span: lt_span } => {
+ let lt_span = if elided { lt_span.shrink_to_hi() } else { lt_span };
+ let code = if elided { "'static " } else { "'static" };
+ ctx.emit_span_lint(
+ lint,
span,
- "an attribute with a similar name exists",
- name,
- Applicability::MachineApplicable,
+ lints::AssociatedConstElidedLifetime { span: lt_span, code, elided },
);
}
+ BuiltinLintDiag::RedundantImportVisibility { max_vis, span: vis_span, import_vis } => {
+ ctx.emit_span_lint(
+ lint,
+ span,
+ lints::RedundantImportVisibility { span: vis_span, help: (), max_vis, import_vis },
+ );
+ }
+ BuiltinLintDiag::UnknownDiagnosticAttribute { span: typo_span, typo_name } => {
+ let typo = typo_name.map(|typo_name| lints::UnknownDiagnosticAttributeTypoSugg {
+ span: typo_span,
+ typo_name,
+ });
+ ctx.emit_span_lint(lint, span, lints::UnknownDiagnosticAttribute { typo });
+ }
+ BuiltinLintDiag::MacroUseDeprecated => {
+ ctx.emit_span_lint(lint, span, lints::MacroUseDeprecated)
+ }
+ BuiltinLintDiag::UnusedMacroUse => ctx.emit_span_lint(lint, span, lints::UnusedMacroUse),
+ BuiltinLintDiag::PrivateExternCrateReexport(ident) => {
+ ctx.emit_span_lint(lint, span, lints::PrivateExternCrateReexport { ident })
+ }
+ BuiltinLintDiag::UnusedLabel => ctx.emit_span_lint(lint, span, lints::UnusedLabel),
+ BuiltinLintDiag::MacroIsPrivate(ident) => {
+ ctx.emit_span_lint(lint, span, lints::MacroIsPrivate { ident })
+ }
+ BuiltinLintDiag::UnusedMacroDefinition(name) => {
+ ctx.emit_span_lint(lint, span, lints::UnusedMacroDefinition { name })
+ }
+ BuiltinLintDiag::MacroRuleNeverUsed(n, name) => {
+ ctx.emit_span_lint(lint, span, lints::MacroRuleNeverUsed { n: n + 1, name })
+ }
+ BuiltinLintDiag::UnstableFeature(msg) => {
+ ctx.emit_span_lint(lint, span, lints::UnstableFeature { msg })
+ }
+ BuiltinLintDiag::AvoidUsingIntelSyntax => {
+ ctx.emit_span_lint(lint, span, lints::AvoidIntelSyntax)
+ }
+ BuiltinLintDiag::AvoidUsingAttSyntax => {
+ ctx.emit_span_lint(lint, span, lints::AvoidAttSyntax)
+ }
+ BuiltinLintDiag::IncompleteInclude => {
+ ctx.emit_span_lint(lint, span, lints::IncompleteInclude)
+ }
+ BuiltinLintDiag::UnnameableTestItems => {
+ ctx.emit_span_lint(lint, span, lints::UnnameableTestItems)
+ }
+ BuiltinLintDiag::DuplicateMacroAttribute => {
+ ctx.emit_span_lint(lint, span, lints::DuplicateMacroAttribute)
+ }
+ BuiltinLintDiag::CfgAttrNoAttributes => {
+ ctx.emit_span_lint(lint, span, lints::CfgAttrNoAttributes)
+ }
+ BuiltinLintDiag::CrateTypeInCfgAttr => {
+ ctx.emit_span_lint(lint, span, lints::CrateTypeInCfgAttr)
+ }
+ BuiltinLintDiag::CrateNameInCfgAttr => {
+ ctx.emit_span_lint(lint, span, lints::CrateNameInCfgAttr)
+ }
+ BuiltinLintDiag::MissingFragmentSpecifier => {
+ ctx.emit_span_lint(lint, span, lints::MissingFragmentSpecifier)
+ }
+ BuiltinLintDiag::MetaVariableStillRepeating(name) => {
+ ctx.emit_span_lint(lint, span, lints::MetaVariableStillRepeating { name })
+ }
+ BuiltinLintDiag::MetaVariableWrongOperator => {
+ ctx.emit_span_lint(lint, span, lints::MetaVariableWrongOperator)
+ }
+ BuiltinLintDiag::DuplicateMatcherBinding => {
+ ctx.emit_span_lint(lint, span, lints::DuplicateMatcherBinding)
+ }
+ BuiltinLintDiag::UnknownMacroVariable(name) => {
+ ctx.emit_span_lint(lint, span, lints::UnknownMacroVariable { name })
+ }
+ BuiltinLintDiag::UnusedCrateDependency { extern_crate, local_crate } => ctx.emit_span_lint(
+ lint,
+ span,
+ lints::UnusedCrateDependency { extern_crate, local_crate },
+ ),
+ BuiltinLintDiag::WasmCAbi => ctx.emit_span_lint(lint, span, lints::WasmCAbi),
+ BuiltinLintDiag::IllFormedAttributeInput { suggestions } => ctx.emit_span_lint(
+ lint,
+ span,
+ lints::IllFormedAttributeInput {
+ num_suggestions: suggestions.len(),
+ suggestions: DiagArgValue::StrListSepByAnd(
+ suggestions.into_iter().map(|s| format!("`{s}`").into()).collect(),
+ ),
+ },
+ ),
+ BuiltinLintDiag::InnerAttributeUnstable { is_macro } => ctx.emit_span_lint(
+ lint,
+ span,
+ if is_macro {
+ lints::InnerAttributeUnstable::InnerMacroAttribute
+ } else {
+ lints::InnerAttributeUnstable::CustomInnerAttribute
+ },
+ ),
}
}
diff --git a/compiler/rustc_lint/src/context/diagnostics/check_cfg.rs b/compiler/rustc_lint/src/context/diagnostics/check_cfg.rs
index 3fa04ab..020ca17 100644
--- a/compiler/rustc_lint/src/context/diagnostics/check_cfg.rs
+++ b/compiler/rustc_lint/src/context/diagnostics/check_cfg.rs
@@ -1,44 +1,27 @@
-use rustc_errors::{Applicability, Diag};
use rustc_middle::bug;
use rustc_session::{config::ExpectedValues, Session};
use rustc_span::edit_distance::find_best_match_for_name;
use rustc_span::{sym, Span, Symbol};
+use crate::lints;
+
const MAX_CHECK_CFG_NAMES_OR_VALUES: usize = 35;
-fn check_cfg_expected_note(
+fn sort_and_truncate_possibilities(
sess: &Session,
- possibilities: &[Symbol],
- type_: &str,
- name: Option<Symbol>,
- suffix: &str,
-) -> String {
- use std::fmt::Write;
-
+ mut possibilities: Vec<Symbol>,
+) -> (Vec<Symbol>, usize) {
let n_possibilities = if sess.opts.unstable_opts.check_cfg_all_expected {
possibilities.len()
} else {
std::cmp::min(possibilities.len(), MAX_CHECK_CFG_NAMES_OR_VALUES)
};
- let mut possibilities = possibilities.iter().map(Symbol::as_str).collect::<Vec<_>>();
- possibilities.sort();
+ possibilities.sort_by(|s1, s2| s1.as_str().cmp(s2.as_str()));
let and_more = possibilities.len().saturating_sub(n_possibilities);
- let possibilities = possibilities[..n_possibilities].join("`, `");
-
- let mut note = String::with_capacity(50 + possibilities.len());
-
- write!(&mut note, "expected {type_}").unwrap();
- if let Some(name) = name {
- write!(&mut note, " for `{name}`").unwrap();
- }
- write!(&mut note, " are: {suffix}`{possibilities}`").unwrap();
- if and_more > 0 {
- write!(&mut note, " and {and_more} more").unwrap();
- }
-
- note
+ possibilities.truncate(n_possibilities);
+ (possibilities, and_more)
}
enum EscapeQuotes {
@@ -61,10 +44,9 @@
pub(super) fn unexpected_cfg_name(
sess: &Session,
- diag: &mut Diag<'_, ()>,
(name, name_span): (Symbol, Span),
value: Option<(Symbol, Span)>,
-) {
+) -> lints::UnexpectedCfgName {
#[allow(rustc::potential_query_instability)]
let possibilities: Vec<Symbol> = sess.psess.check_config.expecteds.keys().copied().collect();
@@ -87,114 +69,122 @@
let is_from_cargo = rustc_session::utils::was_invoked_from_cargo();
let mut is_feature_cfg = name == sym::feature;
- if is_feature_cfg && is_from_cargo {
- diag.help("consider defining some features in `Cargo.toml`");
+ let code_sugg = if is_feature_cfg && is_from_cargo {
+ lints::unexpected_cfg_name::CodeSuggestion::DefineFeatures
// Suggest the most probable if we found one
} else if let Some(best_match) = find_best_match_for_name(&possibilities, name, None) {
+ is_feature_cfg |= best_match == sym::feature;
+
if let Some(ExpectedValues::Some(best_match_values)) =
sess.psess.check_config.expecteds.get(&best_match)
{
// We will soon sort, so the initial order does not matter.
#[allow(rustc::potential_query_instability)]
- let mut possibilities =
- best_match_values.iter().flatten().map(Symbol::as_str).collect::<Vec<_>>();
- possibilities.sort();
+ let mut possibilities = best_match_values.iter().flatten().collect::<Vec<_>>();
+ possibilities.sort_by_key(|s| s.as_str());
- let mut should_print_possibilities = true;
+ let get_possibilities_sub = || {
+ if !possibilities.is_empty() {
+ let possibilities =
+ possibilities.iter().copied().cloned().collect::<Vec<_>>().into();
+ Some(lints::unexpected_cfg_name::ExpectedValues { best_match, possibilities })
+ } else {
+ None
+ }
+ };
+
if let Some((value, value_span)) = value {
if best_match_values.contains(&Some(value)) {
- diag.span_suggestion(
- name_span,
- "there is a config with a similar name and value",
- best_match,
- Applicability::MaybeIncorrect,
- );
- should_print_possibilities = false;
+ lints::unexpected_cfg_name::CodeSuggestion::SimilarNameAndValue {
+ span: name_span,
+ code: best_match.to_string(),
+ }
} else if best_match_values.contains(&None) {
- diag.span_suggestion(
- name_span.to(value_span),
- "there is a config with a similar name and no value",
- best_match,
- Applicability::MaybeIncorrect,
- );
- should_print_possibilities = false;
+ lints::unexpected_cfg_name::CodeSuggestion::SimilarNameNoValue {
+ span: name_span.to(value_span),
+ code: best_match.to_string(),
+ }
} else if let Some(first_value) = possibilities.first() {
- diag.span_suggestion(
- name_span.to(value_span),
- "there is a config with a similar name and different values",
- format!("{best_match} = \"{first_value}\""),
- Applicability::MaybeIncorrect,
- );
+ lints::unexpected_cfg_name::CodeSuggestion::SimilarNameDifferentValues {
+ span: name_span.to(value_span),
+ code: format!("{best_match} = \"{first_value}\""),
+ expected: get_possibilities_sub(),
+ }
} else {
- diag.span_suggestion(
- name_span.to(value_span),
- "there is a config with a similar name and different values",
- best_match,
- Applicability::MaybeIncorrect,
- );
- };
+ lints::unexpected_cfg_name::CodeSuggestion::SimilarNameDifferentValues {
+ span: name_span.to(value_span),
+ code: best_match.to_string(),
+ expected: get_possibilities_sub(),
+ }
+ }
} else {
- diag.span_suggestion(
- name_span,
- "there is a config with a similar name",
- best_match,
- Applicability::MaybeIncorrect,
- );
- }
-
- if !possibilities.is_empty() && should_print_possibilities {
- let possibilities = possibilities.join("`, `");
- diag.help(format!("expected values for `{best_match}` are: `{possibilities}`"));
+ lints::unexpected_cfg_name::CodeSuggestion::SimilarName {
+ span: name_span,
+ code: best_match.to_string(),
+ expected: get_possibilities_sub(),
+ }
}
} else {
- diag.span_suggestion(
- name_span,
- "there is a config with a similar name",
- best_match,
- Applicability::MaybeIncorrect,
- );
- }
-
- is_feature_cfg |= best_match == sym::feature;
- } else {
- if !names_possibilities.is_empty() && names_possibilities.len() <= 3 {
- names_possibilities.sort();
- for cfg_name in names_possibilities.iter() {
- diag.span_suggestion(
- name_span,
- "found config with similar value",
- format!("{cfg_name} = \"{name}\""),
- Applicability::MaybeIncorrect,
- );
+ lints::unexpected_cfg_name::CodeSuggestion::SimilarName {
+ span: name_span,
+ code: best_match.to_string(),
+ expected: None,
}
}
- if !possibilities.is_empty() {
- diag.help_once(check_cfg_expected_note(sess, &possibilities, "names", None, ""));
+ } else {
+ let similar_values = if !names_possibilities.is_empty() && names_possibilities.len() <= 3 {
+ names_possibilities.sort();
+ names_possibilities
+ .iter()
+ .map(|cfg_name| lints::unexpected_cfg_name::FoundWithSimilarValue {
+ span: name_span,
+ code: format!("{cfg_name} = \"{name}\""),
+ })
+ .collect()
+ } else {
+ vec![]
+ };
+ let expected_names = if !possibilities.is_empty() {
+ let (possibilities, and_more) = sort_and_truncate_possibilities(sess, possibilities);
+ Some(lints::unexpected_cfg_name::ExpectedNames {
+ possibilities: possibilities.into(),
+ and_more,
+ })
+ } else {
+ None
+ };
+ lints::unexpected_cfg_name::CodeSuggestion::SimilarValues {
+ with_similar_values: similar_values,
+ expected_names,
}
- }
+ };
let inst = |escape_quotes| to_check_cfg_arg(name, value.map(|(v, _s)| v), escape_quotes);
- if is_from_cargo {
- if !is_feature_cfg {
- diag.help(format!("consider using a Cargo feature instead"));
- diag.help(format!("or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:\n [lints.rust]\n unexpected_cfgs = {{ level = \"warn\", check-cfg = ['{}'] }}", inst(EscapeQuotes::No)));
- diag.help(format!("or consider adding `println!(\"cargo::rustc-check-cfg={}\");` to the top of the `build.rs`", inst(EscapeQuotes::Yes)));
- }
- diag.note("see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration");
+ let invocation_help = if is_from_cargo {
+ let sub = if !is_feature_cfg {
+ Some(lints::UnexpectedCfgCargoHelp::new(
+ &inst(EscapeQuotes::No),
+ &inst(EscapeQuotes::Yes),
+ ))
+ } else {
+ None
+ };
+ lints::unexpected_cfg_name::InvocationHelp::Cargo { sub }
} else {
- let inst = inst(EscapeQuotes::No);
- diag.help(format!("to expect this configuration use `--check-cfg={inst}`",));
- diag.note("see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration");
- }
+ lints::unexpected_cfg_name::InvocationHelp::Rustc(lints::UnexpectedCfgRustcHelp::new(
+ &inst(EscapeQuotes::No),
+ ))
+ };
+
+ lints::UnexpectedCfgName { code_sugg, invocation_help, name }
}
pub(super) fn unexpected_cfg_value(
sess: &Session,
- diag: &mut Diag<'_, ()>,
(name, name_span): (Symbol, Span),
value: Option<(Symbol, Span)>,
-) {
+) -> lints::UnexpectedCfgValue {
let Some(ExpectedValues::Some(values)) = &sess.psess.check_config.expecteds.get(&name) else {
bug!(
"it shouldn't be possible to have a diagnostic on a value whose name is not in values"
@@ -214,53 +204,53 @@
// Show the full list if all possible values for a given name, but don't do it
// for names as the possibilities could be very long
- if !possibilities.is_empty() {
- diag.note(check_cfg_expected_note(
- sess,
- &possibilities,
- "values",
- Some(name),
- if have_none_possibility { "(none), " } else { "" },
- ));
+ let code_sugg = if !possibilities.is_empty() {
+ let expected_values = {
+ let (possibilities, and_more) =
+ sort_and_truncate_possibilities(sess, possibilities.clone());
+ lints::unexpected_cfg_value::ExpectedValues {
+ name,
+ have_none_possibility,
+ possibilities: possibilities.into(),
+ and_more,
+ }
+ };
- if let Some((value, value_span)) = value {
+ let suggestion = if let Some((value, value_span)) = value {
// Suggest the most probable if we found one
if let Some(best_match) = find_best_match_for_name(&possibilities, value, None) {
- diag.span_suggestion(
- value_span,
- "there is a expected value with a similar name",
- format!("\"{best_match}\""),
- Applicability::MaybeIncorrect,
- );
+ Some(lints::unexpected_cfg_value::ChangeValueSuggestion::SimilarName {
+ span: value_span,
+ best_match,
+ })
+ } else {
+ None
}
} else if let &[first_possibility] = &possibilities[..] {
- diag.span_suggestion(
- name_span.shrink_to_hi(),
- "specify a config value",
- format!(" = \"{first_possibility}\""),
- Applicability::MaybeIncorrect,
- );
- }
- } else if have_none_possibility {
- diag.note(format!("no expected value for `{name}`"));
- if let Some((_value, value_span)) = value {
- diag.span_suggestion(
- name_span.shrink_to_hi().to(value_span),
- "remove the value",
- "",
- Applicability::MaybeIncorrect,
- );
- }
- } else {
- diag.note(format!("no expected values for `{name}`"));
+ Some(lints::unexpected_cfg_value::ChangeValueSuggestion::SpecifyValue {
+ span: name_span.shrink_to_hi(),
+ first_possibility,
+ })
+ } else {
+ None
+ };
- let sp = if let Some((_value, value_span)) = value {
+ lints::unexpected_cfg_value::CodeSuggestion::ChangeValue { expected_values, suggestion }
+ } else if have_none_possibility {
+ let suggestion =
+ value.map(|(_value, value_span)| lints::unexpected_cfg_value::RemoveValueSuggestion {
+ span: name_span.shrink_to_hi().to(value_span),
+ });
+ lints::unexpected_cfg_value::CodeSuggestion::RemoveValue { suggestion, name }
+ } else {
+ let span = if let Some((_value, value_span)) = value {
name_span.to(value_span)
} else {
name_span
};
- diag.span_suggestion(sp, "remove the condition", "", Applicability::MaybeIncorrect);
- }
+ let suggestion = lints::unexpected_cfg_value::RemoveConditionSuggestion { span };
+ lints::unexpected_cfg_value::CodeSuggestion::RemoveCondition { suggestion, name }
+ };
// We don't want to suggest adding values to well known names
// since those are defined by rustc it-self. Users can still
@@ -269,24 +259,35 @@
let inst = |escape_quotes| to_check_cfg_arg(name, value.map(|(v, _s)| v), escape_quotes);
- if is_from_cargo {
- if name == sym::feature {
+ let invocation_help = if is_from_cargo {
+ let help = if name == sym::feature {
if let Some((value, _value_span)) = value {
- diag.help(format!("consider adding `{value}` as a feature in `Cargo.toml`"));
+ Some(lints::unexpected_cfg_value::CargoHelp::AddFeature { value })
} else {
- diag.help("consider defining some features in `Cargo.toml`");
+ Some(lints::unexpected_cfg_value::CargoHelp::DefineFeatures)
}
} else if !is_cfg_a_well_know_name {
- diag.help(format!("consider using a Cargo feature instead"));
- diag.help(format!("or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:\n [lints.rust]\n unexpected_cfgs = {{ level = \"warn\", check-cfg = ['{}'] }}", inst(EscapeQuotes::No)));
- diag.help(format!("or consider adding `println!(\"cargo::rustc-check-cfg={}\");` to the top of the `build.rs`", inst(EscapeQuotes::Yes)));
- }
- diag.note("see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration");
+ Some(lints::unexpected_cfg_value::CargoHelp::Other(lints::UnexpectedCfgCargoHelp::new(
+ &inst(EscapeQuotes::No),
+ &inst(EscapeQuotes::Yes),
+ )))
+ } else {
+ None
+ };
+ lints::unexpected_cfg_value::InvocationHelp::Cargo(help)
} else {
- if !is_cfg_a_well_know_name {
- let inst = inst(EscapeQuotes::No);
- diag.help(format!("to expect this configuration use `--check-cfg={inst}`",));
- }
- diag.note("see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration");
+ let help = if !is_cfg_a_well_know_name {
+ Some(lints::UnexpectedCfgRustcHelp::new(&inst(EscapeQuotes::No)))
+ } else {
+ None
+ };
+ lints::unexpected_cfg_value::InvocationHelp::Rustc(help)
+ };
+
+ lints::UnexpectedCfgValue {
+ code_sugg,
+ invocation_help,
+ has_value: value.is_some(),
+ value: value.map_or_else(String::new, |(v, _span)| v.to_string()),
}
}
diff --git a/compiler/rustc_lint/src/early.rs b/compiler/rustc_lint/src/early.rs
index 3f627ba..736c7a1 100644
--- a/compiler/rustc_lint/src/early.rs
+++ b/compiler/rustc_lint/src/early.rs
@@ -14,7 +14,7 @@
//! upon. As the ast is traversed, this keeps track of the current lint level
//! for all lint attributes.
-use crate::context::{EarlyContext, LintContext, LintStore};
+use crate::context::{EarlyContext, LintStore};
use crate::passes::{EarlyLintPass, EarlyLintPassObject};
use rustc_ast::ptr::P;
use rustc_ast::visit::{self as ast_visit, walk_list, Visitor};
@@ -44,14 +44,8 @@
#[allow(rustc::diagnostic_outside_of_impl)]
fn inlined_check_id(&mut self, id: ast::NodeId) {
for early_lint in self.context.buffered.take(id) {
- let BufferedEarlyLint { span, msg, node_id: _, lint_id, diagnostic } = early_lint;
- self.context.span_lint_with_diagnostics(
- lint_id.lint,
- Some(span),
- msg,
- |_| {},
- diagnostic,
- );
+ let BufferedEarlyLint { span, node_id: _, lint_id, diagnostic } = early_lint;
+ self.context.span_lint_with_diagnostics(lint_id.lint, span, diagnostic);
}
}
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index bc0c8cf..3bd6fac 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -5,16 +5,22 @@
use crate::errors::RequestedLevel;
use crate::fluent_generated as fluent;
use rustc_errors::{
- codes::*, Applicability, Diag, DiagMessage, DiagStyledString, EmissionGuarantee,
- LintDiagnostic, SubdiagMessageOp, Subdiagnostic, SuggestionStyle,
+ codes::*, Applicability, Diag, DiagArgValue, DiagMessage, DiagStyledString,
+ ElidedLifetimeInPathSubdiag, EmissionGuarantee, LintDiagnostic, SubdiagMessageOp,
+ Subdiagnostic, SuggestionStyle,
};
-use rustc_hir::def_id::DefId;
+use rustc_hir::{def::Namespace, def_id::DefId};
use rustc_macros::{LintDiagnostic, Subdiagnostic};
use rustc_middle::ty::{
inhabitedness::InhabitedPredicate, Clause, PolyExistentialTraitRef, Ty, TyCtxt,
};
-use rustc_session::Session;
-use rustc_span::{edition::Edition, sym, symbol::Ident, Span, Symbol};
+use rustc_session::{lint::AmbiguityErrorDiag, Session};
+use rustc_span::{
+ edition::Edition,
+ sym,
+ symbol::{Ident, MacroRulesNormalizedIdent},
+ Span, Symbol,
+};
use crate::{
builtin::InitError, builtin::TypeAliasBounds, errors::OverruledAttributeSub, LateContext,
@@ -1947,3 +1953,837 @@
#[label]
pub label: Span,
}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_builtin_asm_labels)]
+#[help]
+#[note]
+pub struct BuiltinNamedAsmLabel;
+
+#[derive(Subdiagnostic)]
+#[help(lint_unexpected_cfg_add_cargo_feature)]
+#[help(lint_unexpected_cfg_add_cargo_toml_lint_cfg)]
+#[help(lint_unexpected_cfg_add_build_rs_println)]
+pub struct UnexpectedCfgCargoHelp {
+ pub build_rs_println: String,
+ pub cargo_toml_lint_cfg: String,
+}
+
+impl UnexpectedCfgCargoHelp {
+ pub fn new(unescaped: &str, escaped: &str) -> Self {
+ Self {
+ cargo_toml_lint_cfg: format!(
+ "\n [lints.rust]\n unexpected_cfgs = {{ level = \"warn\", check-cfg = ['{unescaped}'] }}",
+ ),
+ build_rs_println: format!("println!(\"cargo::rustc-check-cfg={escaped}\");",),
+ }
+ }
+}
+
+#[derive(Subdiagnostic)]
+#[help(lint_unexpected_cfg_add_cmdline_arg)]
+pub struct UnexpectedCfgRustcHelp {
+ pub cmdline_arg: String,
+}
+
+impl UnexpectedCfgRustcHelp {
+ pub fn new(unescaped: &str) -> Self {
+ Self { cmdline_arg: format!("--check-cfg={unescaped}") }
+ }
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unexpected_cfg_name)]
+pub struct UnexpectedCfgName {
+ #[subdiagnostic]
+ pub code_sugg: unexpected_cfg_name::CodeSuggestion,
+ #[subdiagnostic]
+ pub invocation_help: unexpected_cfg_name::InvocationHelp,
+
+ pub name: Symbol,
+}
+
+pub mod unexpected_cfg_name {
+ use rustc_errors::DiagSymbolList;
+ use rustc_macros::Subdiagnostic;
+ use rustc_span::{Span, Symbol};
+
+ #[derive(Subdiagnostic)]
+ pub enum CodeSuggestion {
+ #[help(lint_unexpected_cfg_define_features)]
+ DefineFeatures,
+ #[suggestion(
+ lint_unexpected_cfg_name_similar_name_value,
+ applicability = "maybe-incorrect",
+ code = "{code}"
+ )]
+ SimilarNameAndValue {
+ #[primary_span]
+ span: Span,
+ code: String,
+ },
+ #[suggestion(
+ lint_unexpected_cfg_name_similar_name_no_value,
+ applicability = "maybe-incorrect",
+ code = "{code}"
+ )]
+ SimilarNameNoValue {
+ #[primary_span]
+ span: Span,
+ code: String,
+ },
+ #[suggestion(
+ lint_unexpected_cfg_name_similar_name_different_values,
+ applicability = "maybe-incorrect",
+ code = "{code}"
+ )]
+ SimilarNameDifferentValues {
+ #[primary_span]
+ span: Span,
+ code: String,
+ #[subdiagnostic]
+ expected: Option<ExpectedValues>,
+ },
+ #[suggestion(
+ lint_unexpected_cfg_name_similar_name,
+ applicability = "maybe-incorrect",
+ code = "{code}"
+ )]
+ SimilarName {
+ #[primary_span]
+ span: Span,
+ code: String,
+ #[subdiagnostic]
+ expected: Option<ExpectedValues>,
+ },
+ SimilarValues {
+ #[subdiagnostic]
+ with_similar_values: Vec<FoundWithSimilarValue>,
+ #[subdiagnostic]
+ expected_names: Option<ExpectedNames>,
+ },
+ }
+
+ #[derive(Subdiagnostic)]
+ #[help(lint_unexpected_cfg_name_expected_values)]
+ pub struct ExpectedValues {
+ pub best_match: Symbol,
+ pub possibilities: DiagSymbolList,
+ }
+
+ #[derive(Subdiagnostic)]
+ #[suggestion(
+ lint_unexpected_cfg_name_with_similar_value,
+ applicability = "maybe-incorrect",
+ code = "{code}"
+ )]
+ pub struct FoundWithSimilarValue {
+ #[primary_span]
+ pub span: Span,
+ pub code: String,
+ }
+
+ #[derive(Subdiagnostic)]
+ #[help_once(lint_unexpected_cfg_name_expected_names)]
+ pub struct ExpectedNames {
+ pub possibilities: DiagSymbolList,
+ pub and_more: usize,
+ }
+
+ #[derive(Subdiagnostic)]
+ pub enum InvocationHelp {
+ #[note(lint_unexpected_cfg_doc_cargo)]
+ Cargo {
+ #[subdiagnostic]
+ sub: Option<super::UnexpectedCfgCargoHelp>,
+ },
+ #[note(lint_unexpected_cfg_doc_rustc)]
+ Rustc(#[subdiagnostic] super::UnexpectedCfgRustcHelp),
+ }
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unexpected_cfg_value)]
+pub struct UnexpectedCfgValue {
+ #[subdiagnostic]
+ pub code_sugg: unexpected_cfg_value::CodeSuggestion,
+ #[subdiagnostic]
+ pub invocation_help: unexpected_cfg_value::InvocationHelp,
+
+ pub has_value: bool,
+ pub value: String,
+}
+
+pub mod unexpected_cfg_value {
+ use rustc_errors::DiagSymbolList;
+ use rustc_macros::Subdiagnostic;
+ use rustc_span::{Span, Symbol};
+
+ #[derive(Subdiagnostic)]
+ pub enum CodeSuggestion {
+ ChangeValue {
+ #[subdiagnostic]
+ expected_values: ExpectedValues,
+ #[subdiagnostic]
+ suggestion: Option<ChangeValueSuggestion>,
+ },
+ #[note(lint_unexpected_cfg_value_no_expected_value)]
+ RemoveValue {
+ #[subdiagnostic]
+ suggestion: Option<RemoveValueSuggestion>,
+
+ name: Symbol,
+ },
+ #[note(lint_unexpected_cfg_value_no_expected_values)]
+ RemoveCondition {
+ #[subdiagnostic]
+ suggestion: RemoveConditionSuggestion,
+
+ name: Symbol,
+ },
+ }
+
+ #[derive(Subdiagnostic)]
+ pub enum ChangeValueSuggestion {
+ #[suggestion(
+ lint_unexpected_cfg_value_similar_name,
+ code = r#""{best_match}""#,
+ applicability = "maybe-incorrect"
+ )]
+ SimilarName {
+ #[primary_span]
+ span: Span,
+ best_match: Symbol,
+ },
+ #[suggestion(
+ lint_unexpected_cfg_value_specify_value,
+ code = r#" = "{first_possibility}""#,
+ applicability = "maybe-incorrect"
+ )]
+ SpecifyValue {
+ #[primary_span]
+ span: Span,
+ first_possibility: Symbol,
+ },
+ }
+
+ #[derive(Subdiagnostic)]
+ #[suggestion(
+ lint_unexpected_cfg_value_remove_value,
+ code = "",
+ applicability = "maybe-incorrect"
+ )]
+ pub struct RemoveValueSuggestion {
+ #[primary_span]
+ pub span: Span,
+ }
+
+ #[derive(Subdiagnostic)]
+ #[suggestion(
+ lint_unexpected_cfg_value_remove_condition,
+ code = "",
+ applicability = "maybe-incorrect"
+ )]
+ pub struct RemoveConditionSuggestion {
+ #[primary_span]
+ pub span: Span,
+ }
+
+ #[derive(Subdiagnostic)]
+ #[note(lint_unexpected_cfg_value_expected_values)]
+ pub struct ExpectedValues {
+ pub name: Symbol,
+ pub have_none_possibility: bool,
+ pub possibilities: DiagSymbolList,
+ pub and_more: usize,
+ }
+
+ #[derive(Subdiagnostic)]
+ pub enum InvocationHelp {
+ #[note(lint_unexpected_cfg_doc_cargo)]
+ Cargo(#[subdiagnostic] Option<CargoHelp>),
+ #[note(lint_unexpected_cfg_doc_rustc)]
+ Rustc(#[subdiagnostic] Option<super::UnexpectedCfgRustcHelp>),
+ }
+
+ #[derive(Subdiagnostic)]
+ pub enum CargoHelp {
+ #[help(lint_unexpected_cfg_value_add_feature)]
+ AddFeature {
+ value: Symbol,
+ },
+ #[help(lint_unexpected_cfg_define_features)]
+ DefineFeatures,
+ Other(#[subdiagnostic] super::UnexpectedCfgCargoHelp),
+ }
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_macro_use_deprecated)]
+pub struct MacroUseDeprecated;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unused_macro_use)]
+pub struct UnusedMacroUse;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_private_extern_crate_reexport)]
+pub struct PrivateExternCrateReexport {
+ pub ident: Ident,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unused_label)]
+pub struct UnusedLabel;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_macro_is_private)]
+pub struct MacroIsPrivate {
+ pub ident: Ident,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unused_macro_definition)]
+pub struct UnusedMacroDefinition {
+ pub name: Symbol,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_macro_rule_never_used)]
+pub struct MacroRuleNeverUsed {
+ pub n: usize,
+ pub name: Symbol,
+}
+
+pub struct UnstableFeature {
+ pub msg: DiagMessage,
+}
+
+impl<'a> LintDiagnostic<'a, ()> for UnstableFeature {
+ fn decorate_lint<'b>(self, _diag: &'b mut Diag<'a, ()>) {}
+
+ fn msg(&self) -> DiagMessage {
+ self.msg.clone()
+ }
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_avoid_intel_syntax)]
+pub struct AvoidIntelSyntax;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_avoid_att_syntax)]
+pub struct AvoidAttSyntax;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_incomplete_include)]
+pub struct IncompleteInclude;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unnameable_test_items)]
+pub struct UnnameableTestItems;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_duplicate_macro_attribute)]
+pub struct DuplicateMacroAttribute;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_cfg_attr_no_attributes)]
+pub struct CfgAttrNoAttributes;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_crate_type_in_cfg_attr_deprecated)]
+pub struct CrateTypeInCfgAttr;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_crate_name_in_cfg_attr_deprecated)]
+pub struct CrateNameInCfgAttr;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_missing_fragment_specifier)]
+pub struct MissingFragmentSpecifier;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_metavariable_still_repeating)]
+pub struct MetaVariableStillRepeating {
+ pub name: MacroRulesNormalizedIdent,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_metavariable_wrong_operator)]
+pub struct MetaVariableWrongOperator;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_duplicate_matcher_binding)]
+pub struct DuplicateMatcherBinding;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unknown_macro_variable)]
+pub struct UnknownMacroVariable {
+ pub name: MacroRulesNormalizedIdent,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unused_crate_dependency)]
+pub struct UnusedCrateDependency {
+ pub extern_crate: Symbol,
+ pub local_crate: Symbol,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_wasm_c_abi)]
+pub struct WasmCAbi;
+
+#[derive(LintDiagnostic)]
+#[diag(lint_ill_formed_attribute_input)]
+pub struct IllFormedAttributeInput {
+ pub num_suggestions: usize,
+ pub suggestions: DiagArgValue,
+}
+
+#[derive(LintDiagnostic)]
+pub enum InnerAttributeUnstable {
+ #[diag(lint_inner_macro_attribute_unstable)]
+ InnerMacroAttribute,
+ #[diag(lint_custom_inner_attribute_unstable)]
+ CustomInnerAttribute,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unknown_diagnostic_attribute)]
+pub struct UnknownDiagnosticAttribute {
+ #[subdiagnostic]
+ pub typo: Option<UnknownDiagnosticAttributeTypoSugg>,
+}
+
+#[derive(Subdiagnostic)]
+#[suggestion(
+ lint_unknown_diagnostic_attribute_typo_sugg,
+ style = "verbose",
+ code = "{typo_name}",
+ applicability = "machine-applicable"
+)]
+pub struct UnknownDiagnosticAttributeTypoSugg {
+ #[primary_span]
+ pub span: Span,
+ pub typo_name: Symbol,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unicode_text_flow)]
+#[note]
+pub struct UnicodeTextFlow {
+ #[label]
+ pub comment_span: Span,
+ #[subdiagnostic]
+ pub characters: Vec<UnicodeCharNoteSub>,
+ #[subdiagnostic]
+ pub suggestions: Option<UnicodeTextFlowSuggestion>,
+
+ pub num_codepoints: usize,
+}
+
+#[derive(Subdiagnostic)]
+#[label(lint_label_comment_char)]
+pub struct UnicodeCharNoteSub {
+ #[primary_span]
+ pub span: Span,
+ pub c_debug: String,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(lint_suggestion, applicability = "machine-applicable", style = "hidden")]
+pub struct UnicodeTextFlowSuggestion {
+ #[suggestion_part(code = "")]
+ pub spans: Vec<Span>,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_abs_path_with_module)]
+pub struct AbsPathWithModule {
+ #[subdiagnostic]
+ pub sugg: AbsPathWithModuleSugg,
+}
+
+#[derive(Subdiagnostic)]
+#[suggestion(lint_suggestion, code = "{replacement}")]
+pub struct AbsPathWithModuleSugg {
+ #[primary_span]
+ pub span: Span,
+ #[applicability]
+ pub applicability: Applicability,
+ pub replacement: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_proc_macro_derive_resolution_fallback)]
+pub struct ProcMacroDeriveResolutionFallback {
+ #[label]
+ pub span: Span,
+ pub ns: Namespace,
+ pub ident: Ident,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_macro_expanded_macro_exports_accessed_by_absolute_paths)]
+pub struct MacroExpandedMacroExportsAccessedByAbsolutePaths {
+ #[note]
+ pub definition: Span,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_hidden_lifetime_parameters)]
+pub struct ElidedLifetimesInPaths {
+ #[subdiagnostic]
+ pub subdiag: ElidedLifetimeInPathSubdiag,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_invalid_crate_type_value)]
+pub struct UnknownCrateTypes {
+ #[subdiagnostic]
+ pub sugg: Option<UnknownCrateTypesSub>,
+}
+
+#[derive(Subdiagnostic)]
+#[suggestion(lint_suggestion, code = r#""{candidate}""#, applicability = "maybe-incorrect")]
+pub struct UnknownCrateTypesSub {
+ #[primary_span]
+ pub span: Span,
+ pub candidate: Symbol,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unused_imports)]
+pub struct UnusedImports {
+ #[subdiagnostic]
+ pub sugg: UnusedImportsSugg,
+ #[help]
+ pub test_module_span: Option<Span>,
+
+ pub span_snippets: DiagArgValue,
+ pub num_snippets: usize,
+}
+
+#[derive(Subdiagnostic)]
+pub enum UnusedImportsSugg {
+ #[suggestion(
+ lint_suggestion_remove_whole_use,
+ applicability = "machine-applicable",
+ code = "",
+ style = "tool-only"
+ )]
+ RemoveWholeUse {
+ #[primary_span]
+ span: Span,
+ },
+ #[multipart_suggestion(
+ lint_suggestion_remove_imports,
+ applicability = "machine-applicable",
+ style = "tool-only"
+ )]
+ RemoveImports {
+ #[suggestion_part(code = "")]
+ remove_spans: Vec<Span>,
+ num_to_remove: usize,
+ },
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_redundant_import)]
+pub struct RedundantImport {
+ #[subdiagnostic]
+ pub subs: Vec<RedundantImportSub>,
+
+ pub ident: Ident,
+}
+
+#[derive(Subdiagnostic)]
+pub enum RedundantImportSub {
+ #[label(lint_label_imported_here)]
+ ImportedHere(#[primary_span] Span),
+ #[label(lint_label_defined_here)]
+ DefinedHere(#[primary_span] Span),
+ #[label(lint_label_imported_prelude)]
+ ImportedPrelude(#[primary_span] Span),
+ #[label(lint_label_defined_prelude)]
+ DefinedPrelude(#[primary_span] Span),
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unused_doc_comment)]
+#[help]
+pub struct UnusedDocComment {
+ #[label]
+ pub span: Span,
+}
+
+#[derive(LintDiagnostic)]
+pub enum PatternsInFnsWithoutBody {
+ #[diag(lint_pattern_in_foreign)]
+ Foreign {
+ #[subdiagnostic]
+ sub: PatternsInFnsWithoutBodySub,
+ },
+ #[diag(lint_pattern_in_bodiless)]
+ Bodiless {
+ #[subdiagnostic]
+ sub: PatternsInFnsWithoutBodySub,
+ },
+}
+
+#[derive(Subdiagnostic)]
+#[suggestion(lint_remove_mut_from_pattern, code = "{ident}", applicability = "machine-applicable")]
+pub struct PatternsInFnsWithoutBodySub {
+ #[primary_span]
+ pub span: Span,
+
+ pub ident: Ident,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_extern_without_abi)]
+#[help]
+pub struct MissingAbi {
+ #[label]
+ pub span: Span,
+
+ pub default_abi: &'static str,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_legacy_derive_helpers)]
+pub struct LegacyDeriveHelpers {
+ #[label]
+ pub span: Span,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_proc_macro_back_compat)]
+#[note]
+pub struct ProcMacroBackCompat {
+ pub crate_name: String,
+ pub fixed_version: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_or_patterns_back_compat)]
+pub struct OrPatternsBackCompat {
+ #[suggestion(code = "{suggestion}", applicability = "machine-applicable")]
+ pub span: Span,
+ pub suggestion: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_reserved_prefix)]
+pub struct ReservedPrefix {
+ #[label]
+ pub label: Span,
+ #[suggestion(code = " ", applicability = "machine-applicable")]
+ pub suggestion: Span,
+
+ pub prefix: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unused_builtin_attribute)]
+pub struct UnusedBuiltinAttribute {
+ #[note]
+ pub invoc_span: Span,
+
+ pub attr_name: Symbol,
+ pub macro_name: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_trailing_semi_macro)]
+pub struct TrailingMacro {
+ #[note(lint_note1)]
+ #[note(lint_note2)]
+ pub is_trailing: bool,
+
+ pub name: Ident,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_break_with_label_and_loop)]
+pub struct BreakWithLabelAndLoop {
+ #[subdiagnostic]
+ pub sub: BreakWithLabelAndLoopSub,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(lint_suggestion, applicability = "machine-applicable")]
+pub struct BreakWithLabelAndLoopSub {
+ #[suggestion_part(code = "(")]
+ pub left: Span,
+ #[suggestion_part(code = ")")]
+ pub right: Span,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_deprecated_where_clause_location)]
+#[note]
+pub struct DeprecatedWhereClauseLocation {
+ #[subdiagnostic]
+ pub suggestion: DeprecatedWhereClauseLocationSugg,
+}
+
+#[derive(Subdiagnostic)]
+pub enum DeprecatedWhereClauseLocationSugg {
+ #[multipart_suggestion(lint_suggestion_move_to_end, applicability = "machine-applicable")]
+ MoveToEnd {
+ #[suggestion_part(code = "")]
+ left: Span,
+ #[suggestion_part(code = "{sugg}")]
+ right: Span,
+
+ sugg: String,
+ },
+ #[suggestion(lint_suggestion_remove_where, code = "", applicability = "machine-applicable")]
+ RemoveWhere {
+ #[primary_span]
+ span: Span,
+ },
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_single_use_lifetime)]
+pub struct SingleUseLifetime {
+ #[label(lint_label_param)]
+ pub param_span: Span,
+ #[label(lint_label_use)]
+ pub use_span: Span,
+ #[subdiagnostic]
+ pub suggestion: Option<SingleUseLifetimeSugg>,
+
+ pub ident: Ident,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(lint_suggestion, applicability = "machine-applicable")]
+pub struct SingleUseLifetimeSugg {
+ #[suggestion_part(code = "")]
+ pub deletion_span: Option<Span>,
+ #[suggestion_part(code = "{replace_lt}")]
+ pub use_span: Span,
+
+ pub replace_lt: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unused_lifetime)]
+pub struct UnusedLifetime {
+ #[suggestion(code = "", applicability = "machine-applicable")]
+ pub deletion_span: Option<Span>,
+
+ pub ident: Ident,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_named_argument_used_positionally)]
+pub struct NamedArgumentUsedPositionally {
+ #[label(lint_label_named_arg)]
+ pub named_arg_sp: Span,
+ #[label(lint_label_position_arg)]
+ pub position_label_sp: Option<Span>,
+ #[suggestion(style = "verbose", code = "{name}", applicability = "maybe-incorrect")]
+ pub suggestion: Option<Span>,
+
+ pub name: String,
+ pub named_arg_name: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_byte_slice_in_packed_struct_with_derive)]
+#[help]
+pub struct ByteSliceInPackedStructWithDerive {
+ // FIXME: make this translatable
+ pub ty: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unused_extern_crate)]
+pub struct UnusedExternCrate {
+ #[suggestion(code = "", applicability = "machine-applicable")]
+ pub removal_span: Span,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_extern_crate_not_idiomatic)]
+pub struct ExternCrateNotIdiomatic {
+ #[suggestion(style = "verbose", code = "{code}", applicability = "machine-applicable")]
+ pub span: Span,
+
+ pub code: &'static str,
+}
+
+// FIXME: make this translatable
+pub struct AmbiguousGlobImports {
+ pub ambiguity: AmbiguityErrorDiag,
+}
+
+impl<'a, G: EmissionGuarantee> LintDiagnostic<'a, G> for AmbiguousGlobImports {
+ fn decorate_lint<'b>(self, diag: &'b mut Diag<'a, G>) {
+ rustc_errors::report_ambiguity_error(diag, self.ambiguity);
+ }
+
+ fn msg(&self) -> DiagMessage {
+ DiagMessage::Str(self.ambiguity.msg.clone().into())
+ }
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_ambiguous_glob_reexport)]
+pub struct AmbiguousGlobReexports {
+ #[label(lint_label_first_reexport)]
+ pub first_reexport: Span,
+ #[label(lint_label_duplicate_reexport)]
+ pub duplicate_reexport: Span,
+
+ pub name: String,
+ // FIXME: make this translatable
+ pub namespace: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_hidden_glob_reexport)]
+pub struct HiddenGlobReexports {
+ #[note(lint_note_glob_reexport)]
+ pub glob_reexport: Span,
+ #[note(lint_note_private_item)]
+ pub private_item: Span,
+
+ pub name: String,
+ // FIXME: make this translatable
+ pub namespace: String,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_unnecessary_qualification)]
+pub struct UnusedQualifications {
+ #[suggestion(style = "verbose", code = "", applicability = "machine-applicable")]
+ pub removal_span: Span,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_associated_const_elided_lifetime)]
+pub struct AssociatedConstElidedLifetime {
+ #[suggestion(style = "verbose", code = "{code}", applicability = "machine-applicable")]
+ pub span: Span,
+
+ pub code: &'static str,
+ pub elided: bool,
+}
+
+#[derive(LintDiagnostic)]
+#[diag(lint_redundant_import_visibility)]
+pub struct RedundantImportVisibility {
+ #[note]
+ pub span: Span,
+ #[help]
+ pub help: (),
+
+ pub import_vis: String,
+ pub max_vis: String,
+}
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index e06e3e9..1941b0b 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -6,10 +6,12 @@
HashStable, StableCompare, StableHasher, ToStableHashKey,
};
use rustc_error_messages::{DiagMessage, MultiSpan};
+use rustc_hir::def::Namespace;
use rustc_hir::HashStableContext;
use rustc_hir::HirId;
use rustc_macros::{Decodable, Encodable, HashStable_Generic};
use rustc_span::edition::Edition;
+use rustc_span::symbol::MacroRulesNormalizedIdent;
use rustc_span::{sym, symbol::Ident, Span, Symbol};
use rustc_target::spec::abi::Abi;
@@ -565,19 +567,44 @@
pub b2_help_msgs: Vec<String>,
}
+#[derive(Debug, Clone)]
+pub enum DeprecatedSinceKind {
+ InEffect,
+ InFuture,
+ InVersion(String),
+}
+
// This could be a closure, but then implementing derive trait
// becomes hacky (and it gets allocated).
#[derive(Debug)]
pub enum BuiltinLintDiag {
- Normal,
AbsPathWithModule(Span),
- ProcMacroDeriveResolutionFallback(Span),
+ ProcMacroDeriveResolutionFallback {
+ span: Span,
+ ns: Namespace,
+ ident: Ident,
+ },
MacroExpandedMacroExportsAccessedByAbsolutePaths(Span),
ElidedLifetimesInPaths(usize, Span, bool, Span),
- UnknownCrateTypes(Span, String, String),
- UnusedImports(String, Vec<(Span, String)>, Option<Span>),
+ UnknownCrateTypes {
+ span: Span,
+ candidate: Option<Symbol>,
+ },
+ UnusedImports {
+ remove_whole_use: bool,
+ num_to_remove: usize,
+ remove_spans: Vec<Span>,
+ test_module_span: Option<Span>,
+ span_snippets: Vec<String>,
+ },
RedundantImport(Vec<(Span, bool)>, Ident),
- DeprecatedMacro(Option<Symbol>, Span),
+ DeprecatedMacro {
+ suggestion: Option<Symbol>,
+ suggestion_span: Span,
+ note: Option<Symbol>,
+ path: String,
+ since_kind: DeprecatedSinceKind,
+ },
MissingAbi(Span, Abi),
UnusedDocComment(Span),
UnusedBuiltinAttribute {
@@ -585,18 +612,24 @@
macro_name: String,
invoc_span: Span,
},
- PatternsInFnsWithoutBody(Span, Ident),
+ PatternsInFnsWithoutBody {
+ span: Span,
+ ident: Ident,
+ is_foreign: bool,
+ },
LegacyDeriveHelpers(Span),
- ProcMacroBackCompat(String),
+ ProcMacroBackCompat {
+ crate_name: String,
+ fixed_version: String,
+ },
OrPatternsBackCompat(Span, String),
- ReservedPrefix(Span),
+ ReservedPrefix(Span, String),
TrailingMacro(bool, Ident),
BreakWithLabelAndLoop(Span),
- NamedAsmLabel(String),
UnicodeTextFlow(Span, String),
UnexpectedCfgName((Symbol, Span), Option<(Symbol, Span)>),
UnexpectedCfgValue((Symbol, Span), Option<(Symbol, Span)>),
- DeprecatedWhereclauseLocation(Option<(Span, String)>),
+ DeprecatedWhereclauseLocation(Span, Option<(Span, String)>),
SingleUseLifetime {
/// Span of the parameter which declares this lifetime.
param_span: Span,
@@ -606,6 +639,7 @@
/// Span of the single use, or None if the lifetime is never used.
/// If true, the lifetime will be fully elided.
use_span: Option<(Span, bool)>,
+ ident: Ident,
},
NamedArgumentUsedPositionally {
/// Span where the named argument is used by position and will be replaced with the named
@@ -620,7 +654,10 @@
/// Indicates if the named argument is used as a width/precision for formatting
is_formatting_arg: bool,
},
- ByteSliceInPackedStructWithDerive,
+ ByteSliceInPackedStructWithDerive {
+ // FIXME: enum of byte/string
+ ty: String,
+ },
UnusedExternCrate {
removal_span: Span,
},
@@ -662,10 +699,43 @@
RedundantImportVisibility {
span: Span,
max_vis: String,
+ import_vis: String,
},
- MaybeTypo {
+ UnknownDiagnosticAttribute {
span: Span,
- name: Symbol,
+ typo_name: Option<Symbol>,
+ },
+ MacroUseDeprecated,
+ UnusedMacroUse,
+ PrivateExternCrateReexport(Ident),
+ UnusedLabel,
+ MacroIsPrivate(Ident),
+ UnusedMacroDefinition(Symbol),
+ MacroRuleNeverUsed(usize, Symbol),
+ UnstableFeature(DiagMessage),
+ AvoidUsingIntelSyntax,
+ AvoidUsingAttSyntax,
+ IncompleteInclude,
+ UnnameableTestItems,
+ DuplicateMacroAttribute,
+ CfgAttrNoAttributes,
+ CrateTypeInCfgAttr,
+ CrateNameInCfgAttr,
+ MissingFragmentSpecifier,
+ MetaVariableStillRepeating(MacroRulesNormalizedIdent),
+ MetaVariableWrongOperator,
+ DuplicateMatcherBinding,
+ UnknownMacroVariable(MacroRulesNormalizedIdent),
+ UnusedCrateDependency {
+ extern_crate: Symbol,
+ local_crate: Symbol,
+ },
+ WasmCAbi,
+ IllFormedAttributeInput {
+ suggestions: Vec<String>,
+ },
+ InnerAttributeUnstable {
+ is_macro: bool,
},
}
@@ -676,9 +746,6 @@
/// The span of code that we are linting on.
pub span: MultiSpan,
- /// The lint message.
- pub msg: DiagMessage,
-
/// The `NodeId` of the AST node that generated the lint.
pub node_id: NodeId,
@@ -706,12 +773,10 @@
lint: &'static Lint,
node_id: NodeId,
span: MultiSpan,
- msg: impl Into<DiagMessage>,
diagnostic: BuiltinLintDiag,
) {
let lint_id = LintId::of(lint);
- let msg = msg.into();
- self.add_early_lint(BufferedEarlyLint { lint_id, node_id, span, msg, diagnostic });
+ self.add_early_lint(BufferedEarlyLint { lint_id, node_id, span, diagnostic });
}
pub fn take(&mut self, id: NodeId) -> Vec<BufferedEarlyLint> {
@@ -724,20 +789,9 @@
lint: &'static Lint,
id: NodeId,
sp: impl Into<MultiSpan>,
- msg: impl Into<DiagMessage>,
- ) {
- self.add_lint(lint, id, sp.into(), msg, BuiltinLintDiag::Normal)
- }
-
- pub fn buffer_lint_with_diagnostic(
- &mut self,
- lint: &'static Lint,
- id: NodeId,
- sp: impl Into<MultiSpan>,
- msg: impl Into<DiagMessage>,
diagnostic: BuiltinLintDiag,
) {
- self.add_lint(lint, id, sp.into(), msg, diagnostic)
+ self.add_lint(lint, id, sp.into(), diagnostic)
}
}
diff --git a/compiler/rustc_log/src/lib.rs b/compiler/rustc_log/src/lib.rs
index 81257f9..e11c45b 100644
--- a/compiler/rustc_log/src/lib.rs
+++ b/compiler/rustc_log/src/lib.rs
@@ -159,7 +159,9 @@
if !target.contains(&self.backtrace_target) {
return Ok(());
}
- let backtrace = std::backtrace::Backtrace::capture();
+ // Use Backtrace::force_capture because we don't want to depend on the
+ // RUST_BACKTRACE environment variable being set.
+ let backtrace = std::backtrace::Backtrace::force_capture();
writeln!(writer, "stack backtrace: \n{backtrace:?}")
}
}
diff --git a/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs b/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs
index ae481ef..38d4a5e 100644
--- a/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs
+++ b/compiler/rustc_macros/src/diagnostics/diagnostic_builder.rs
@@ -158,7 +158,9 @@
let slug = subdiag.slug.unwrap_or_else(|| match subdiag.kind {
SubdiagnosticKind::Label => parse_quote! { _subdiag::label },
SubdiagnosticKind::Note => parse_quote! { _subdiag::note },
+ SubdiagnosticKind::NoteOnce => parse_quote! { _subdiag::note_once },
SubdiagnosticKind::Help => parse_quote! { _subdiag::help },
+ SubdiagnosticKind::HelpOnce => parse_quote! { _subdiag::help_once },
SubdiagnosticKind::Warn => parse_quote! { _subdiag::warn },
SubdiagnosticKind::Suggestion { .. } => parse_quote! { _subdiag::suggestion },
SubdiagnosticKind::MultipartSuggestion { .. } => unreachable!(),
@@ -233,9 +235,11 @@
};
let fn_ident = format_ident!("{}", subdiag);
match subdiag {
- SubdiagnosticKind::Note | SubdiagnosticKind::Help | SubdiagnosticKind::Warn => {
- Ok(self.add_subdiagnostic(&fn_ident, slug))
- }
+ SubdiagnosticKind::Note
+ | SubdiagnosticKind::NoteOnce
+ | SubdiagnosticKind::Help
+ | SubdiagnosticKind::HelpOnce
+ | SubdiagnosticKind::Warn => Ok(self.add_subdiagnostic(&fn_ident, slug)),
SubdiagnosticKind::Label | SubdiagnosticKind::Suggestion { .. } => {
throw_invalid_attr!(attr, |diag| diag
.help("`#[label]` and `#[suggestion]` can only be applied to fields"));
@@ -347,7 +351,11 @@
report_error_if_not_applied_to_span(attr, &info)?;
Ok(self.add_spanned_subdiagnostic(binding, &fn_ident, slug))
}
- SubdiagnosticKind::Note | SubdiagnosticKind::Help | SubdiagnosticKind::Warn => {
+ SubdiagnosticKind::Note
+ | SubdiagnosticKind::NoteOnce
+ | SubdiagnosticKind::Help
+ | SubdiagnosticKind::HelpOnce
+ | SubdiagnosticKind::Warn => {
let inner = info.ty.inner_type();
if type_matches_path(inner, &["rustc_span", "Span"])
|| type_matches_path(inner, &["rustc_span", "MultiSpan"])
diff --git a/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs b/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs
index 4523677..69014f3 100644
--- a/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs
+++ b/compiler/rustc_macros/src/diagnostics/subdiagnostic.rs
@@ -510,11 +510,11 @@
.map(|binding| self.generate_field_attr_code(binding, kind_stats))
.collect();
- if kind_slugs.is_empty() {
+ if kind_slugs.is_empty() && !self.has_subdiagnostic {
if self.is_enum {
// It's okay for a variant to not be a subdiagnostic at all..
return Ok(quote! {});
- } else if !self.has_subdiagnostic {
+ } else {
// ..but structs should always be _something_.
throw_span_err!(
self.variant.ast().ident.span().unwrap(),
diff --git a/compiler/rustc_macros/src/diagnostics/utils.rs b/compiler/rustc_macros/src/diagnostics/utils.rs
index 4684306..05a5a32 100644
--- a/compiler/rustc_macros/src/diagnostics/utils.rs
+++ b/compiler/rustc_macros/src/diagnostics/utils.rs
@@ -575,8 +575,12 @@
Label,
/// `#[note(...)]`
Note,
+ /// `#[note_once(...)]`
+ NoteOnce,
/// `#[help(...)]`
Help,
+ /// `#[help_once(...)]`
+ HelpOnce,
/// `#[warning(...)]`
Warn,
/// `#[suggestion{,_short,_hidden,_verbose}]`
@@ -624,7 +628,9 @@
let mut kind = match name {
"label" => SubdiagnosticKind::Label,
"note" => SubdiagnosticKind::Note,
+ "note_once" => SubdiagnosticKind::NoteOnce,
"help" => SubdiagnosticKind::Help,
+ "help_once" => SubdiagnosticKind::HelpOnce,
"warning" => SubdiagnosticKind::Warn,
_ => {
// Recover old `#[(multipart_)suggestion_*]` syntaxes
@@ -682,7 +688,9 @@
match kind {
SubdiagnosticKind::Label
| SubdiagnosticKind::Note
+ | SubdiagnosticKind::NoteOnce
| SubdiagnosticKind::Help
+ | SubdiagnosticKind::HelpOnce
| SubdiagnosticKind::Warn
| SubdiagnosticKind::MultipartSuggestion { .. } => {
return Ok(Some(SubdiagnosticVariant { kind, slug: None, no_span: false }));
@@ -836,7 +844,9 @@
}
SubdiagnosticKind::Label
| SubdiagnosticKind::Note
+ | SubdiagnosticKind::NoteOnce
| SubdiagnosticKind::Help
+ | SubdiagnosticKind::HelpOnce
| SubdiagnosticKind::Warn => {}
}
@@ -849,7 +859,9 @@
match self {
SubdiagnosticKind::Label => write!(f, "label"),
SubdiagnosticKind::Note => write!(f, "note"),
+ SubdiagnosticKind::NoteOnce => write!(f, "note_once"),
SubdiagnosticKind::Help => write!(f, "help"),
+ SubdiagnosticKind::HelpOnce => write!(f, "help_once"),
SubdiagnosticKind::Warn => write!(f, "warn"),
SubdiagnosticKind::Suggestion { .. } => write!(f, "suggestions_with_style"),
SubdiagnosticKind::MultipartSuggestion { .. } => {
diff --git a/compiler/rustc_macros/src/lib.rs b/compiler/rustc_macros/src/lib.rs
index c7b7ead..de9c916 100644
--- a/compiler/rustc_macros/src/lib.rs
+++ b/compiler/rustc_macros/src/lib.rs
@@ -108,7 +108,9 @@
// struct attributes
diag,
help,
+ help_once,
note,
+ note_once,
warning,
// field attributes
skip_arg,
@@ -125,7 +127,9 @@
// struct attributes
diag,
help,
+ help_once,
note,
+ note_once,
warning,
// field attributes
skip_arg,
@@ -142,7 +146,9 @@
// struct/variant attributes
label,
help,
+ help_once,
note,
+ note_once,
warning,
subdiagnostic,
suggestion,
diff --git a/compiler/rustc_metadata/messages.ftl b/compiler/rustc_metadata/messages.ftl
index 3d0846a..2f5dfad 100644
--- a/compiler/rustc_metadata/messages.ftl
+++ b/compiler/rustc_metadata/messages.ftl
@@ -284,8 +284,6 @@
metadata_unsupported_abi_i686 =
ABI not supported by `#[link(kind = "raw-dylib")]` on i686
-metadata_wasm_c_abi =
- older versions of the `wasm-bindgen` crate will be incompatible with future versions of Rust; please update to `wasm-bindgen` v0.2.88
metadata_wasm_import_form =
wasm import module must be of the form `wasm_import_module = "string"`
diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs
index e3205fc..be1a73e 100644
--- a/compiler/rustc_metadata/src/creader.rs
+++ b/compiler/rustc_metadata/src/creader.rs
@@ -20,7 +20,7 @@
use rustc_middle::ty::{TyCtxt, TyCtxtFeed};
use rustc_session::config::{self, CrateType, ExternLocation};
use rustc_session::cstore::{CrateDepKind, CrateSource, ExternCrate, ExternCrateSource};
-use rustc_session::lint;
+use rustc_session::lint::{self, BuiltinLintDiag};
use rustc_session::output::validate_crate_name;
use rustc_session::search_paths::PathKind;
use rustc_span::edition::Edition;
@@ -975,15 +975,14 @@
}
self.sess.psess.buffer_lint(
- lint::builtin::UNUSED_CRATE_DEPENDENCIES,
- span,
- ast::CRATE_NODE_ID,
- format!(
- "external crate `{}` unused in `{}`: remove the dependency or add `use {} as _;`",
- name,
- self.tcx.crate_name(LOCAL_CRATE),
- name),
- );
+ lint::builtin::UNUSED_CRATE_DEPENDENCIES,
+ span,
+ ast::CRATE_NODE_ID,
+ BuiltinLintDiag::UnusedCrateDependency {
+ extern_crate: name_interned,
+ local_crate: self.tcx.crate_name(LOCAL_CRATE),
+ },
+ );
}
}
@@ -1020,7 +1019,7 @@
lint::builtin::WASM_C_ABI,
span,
ast::CRATE_NODE_ID,
- crate::fluent_generated::metadata_wasm_c_abi,
+ BuiltinLintDiag::WasmCAbi,
);
}
}
diff --git a/compiler/rustc_metadata/src/locator.rs b/compiler/rustc_metadata/src/locator.rs
index 7de03be..6ff1997 100644
--- a/compiler/rustc_metadata/src/locator.rs
+++ b/compiler/rustc_metadata/src/locator.rs
@@ -853,7 +853,12 @@
slice_owned(mmap, Deref::deref)
}
};
- let blob = MetadataBlob(raw_bytes);
+ let Ok(blob) = MetadataBlob::new(raw_bytes) else {
+ return Err(MetadataError::LoadFailure(format!(
+ "corrupt metadata encountered in {}",
+ filename.display()
+ )));
+ };
match blob.check_compatibility(cfg_version) {
Ok(()) => Ok(blob),
Err(None) => Err(MetadataError::LoadFailure(format!(
diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
index bb68c6e..f91e121 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -40,10 +40,9 @@
mod cstore_impl;
/// A reference to the raw binary version of crate metadata.
-/// A `MetadataBlob` internally is just a reference counted pointer to
-/// the actual data, so cloning it is cheap.
-#[derive(Clone)]
-pub(crate) struct MetadataBlob(pub(crate) OwnedSlice);
+/// This struct applies [`MemDecoder`]'s validation when constructed
+/// so that later constructions are guaranteed to succeed.
+pub(crate) struct MetadataBlob(OwnedSlice);
impl std::ops::Deref for MetadataBlob {
type Target = [u8];
@@ -54,6 +53,19 @@
}
}
+impl MetadataBlob {
+ /// Runs the [`MemDecoder`] validation and if it passes, constructs a new [`MetadataBlob`].
+ pub fn new(slice: OwnedSlice) -> Result<Self, ()> {
+ if MemDecoder::new(&slice, 0).is_ok() { Ok(Self(slice)) } else { Err(()) }
+ }
+
+ /// Since this has passed the validation of [`MetadataBlob::new`], this returns bytes which are
+ /// known to pass the [`MemDecoder`] validation.
+ pub fn bytes(&self) -> &OwnedSlice {
+ &self.0
+ }
+}
+
/// A map from external crate numbers (as decoded from some crate file) to
/// local crate numbers (as generated during this session). Each external
/// crate may refer to types in other external crates, and each has their
@@ -165,7 +177,14 @@
fn decoder(self, pos: usize) -> DecodeContext<'a, 'tcx> {
let tcx = self.tcx();
DecodeContext {
- opaque: MemDecoder::new(self.blob(), pos),
+ // FIXME: This unwrap should never panic because we check that it won't when creating
+ // `MetadataBlob`. Ideally we'd just have a `MetadataDecoder` and hand out subslices of
+ // it as we do elsewhere in the compiler using `MetadataDecoder::split_at`. But we own
+ // the data for the decoder so holding onto the `MemDecoder` too would make us a
+ // self-referential struct which is downright goofy because `MetadataBlob` is already
+ // self-referential. Probably `MemDecoder` should contain an `OwnedSlice`, but that
+ // demands a significant refactoring due to our crate graph.
+ opaque: MemDecoder::new(self.blob(), pos).unwrap(),
cdata: self.cdata(),
blob: self.blob(),
sess: self.sess().or(tcx.map(|tcx| tcx.sess)),
@@ -393,7 +412,7 @@
where
F: FnOnce(&mut Self) -> R,
{
- let new_opaque = MemDecoder::new(self.opaque.data(), pos);
+ let new_opaque = self.opaque.split_at(pos);
let old_opaque = mem::replace(&mut self.opaque, new_opaque);
let old_state = mem::replace(&mut self.lazy_state, LazyState::NoNode);
let r = f(self);
diff --git a/compiler/rustc_metadata/src/rmeta/def_path_hash_map.rs b/compiler/rustc_metadata/src/rmeta/def_path_hash_map.rs
index 9950bc1..861bf6b 100644
--- a/compiler/rustc_metadata/src/rmeta/def_path_hash_map.rs
+++ b/compiler/rustc_metadata/src/rmeta/def_path_hash_map.rs
@@ -48,7 +48,7 @@
fn decode(d: &mut DecodeContext<'a, 'tcx>) -> DefPathHashMapRef<'static> {
let len = d.read_usize();
let pos = d.position();
- let o = d.blob().clone().0.slice(|blob| &blob[pos..pos + len]);
+ let o = d.blob().bytes().clone().slice(|blob| &blob[pos..pos + len]);
// Although we already have the data we need via the `OwnedSlice`, we still need
// to advance the `DecodeContext`'s position so it's in a valid state after
diff --git a/compiler/rustc_middle/messages.ftl b/compiler/rustc_middle/messages.ftl
index 27d555d..f4d6193 100644
--- a/compiler/rustc_middle/messages.ftl
+++ b/compiler/rustc_middle/messages.ftl
@@ -50,6 +50,20 @@
middle_cycle =
a cycle occurred during layout computation
+middle_deprecated = use of deprecated {$kind} `{$path}`{$has_note ->
+ [true] : {$note}
+ *[other] {""}
+ }
+middle_deprecated_in_future = use of {$kind} `{$path}` that will be deprecated in a future Rust version{$has_note ->
+ [true] : {$note}
+ *[other] {""}
+ }
+middle_deprecated_in_version = use of {$kind} `{$path}` that will be deprecated in future version {$version}{$has_note ->
+ [true] : {$note}
+ *[other] {""}
+ }
+middle_deprecated_suggestion = replace the use of the deprecated {$kind}
+
middle_drop_check_overflow =
overflow while adding drop-check rules for {$ty}
.note = overflowed on {$overflow_ty}
diff --git a/compiler/rustc_middle/src/infer/canonical.rs b/compiler/rustc_middle/src/infer/canonical.rs
index 49bf03e..dba71d8 100644
--- a/compiler/rustc_middle/src/infer/canonical.rs
+++ b/compiler/rustc_middle/src/infer/canonical.rs
@@ -32,7 +32,7 @@
use crate::infer::MemberConstraint;
use crate::mir::ConstraintCategory;
use crate::ty::GenericArg;
-use crate::ty::{self, List, Region, Ty, TyCtxt, TypeFlags, TypeVisitableExt};
+use crate::ty::{self, List, Ty, TyCtxt, TypeFlags, TypeVisitableExt};
pub type Canonical<'tcx, V> = ir::Canonical<TyCtxt<'tcx>, V>;
pub type CanonicalVarInfo<'tcx> = ir::CanonicalVarInfo<TyCtxt<'tcx>>;
@@ -141,7 +141,7 @@
}
pub type QueryOutlivesConstraint<'tcx> =
- (ty::OutlivesPredicate<GenericArg<'tcx>, Region<'tcx>>, ConstraintCategory<'tcx>);
+ (ty::OutlivesPredicate<'tcx, GenericArg<'tcx>>, ConstraintCategory<'tcx>);
TrivialTypeTraversalImpls! {
crate::infer::canonical::Certainty,
diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs
index 67bd53f..e5df057 100644
--- a/compiler/rustc_middle/src/middle/stability.rs
+++ b/compiler/rustc_middle/src/middle/stability.rs
@@ -9,15 +9,15 @@
self as attr, ConstStability, DefaultBodyStability, DeprecatedSince, Deprecation, Stability,
};
use rustc_data_structures::unord::UnordMap;
-use rustc_errors::{Applicability, Diag};
+use rustc_errors::{Applicability, Diag, EmissionGuarantee};
use rustc_feature::GateIssue;
use rustc_hir::def::DefKind;
use rustc_hir::def_id::{DefId, LocalDefId, LocalDefIdMap};
use rustc_hir::{self as hir, HirId};
-use rustc_macros::{Decodable, Encodable, HashStable};
+use rustc_macros::{Decodable, Encodable, HashStable, Subdiagnostic};
use rustc_middle::ty::print::with_no_trimmed_paths;
use rustc_session::lint::builtin::{DEPRECATED, DEPRECATED_IN_FUTURE, SOFT_UNSTABLE};
-use rustc_session::lint::{BuiltinLintDiag, Level, Lint, LintBuffer};
+use rustc_session::lint::{BuiltinLintDiag, DeprecatedSinceKind, Level, Lint, LintBuffer};
use rustc_session::parse::feature_err_issue;
use rustc_session::Session;
use rustc_span::symbol::{sym, Symbol};
@@ -125,90 +125,107 @@
}
}
-pub fn deprecation_suggestion(
- diag: &mut Diag<'_, ()>,
- kind: &str,
- suggestion: Option<Symbol>,
- span: Span,
-) {
- if let Some(suggestion) = suggestion {
- diag.span_suggestion_verbose(
- span,
- format!("replace the use of the deprecated {kind}"),
- suggestion,
- Applicability::MachineApplicable,
- );
- }
-}
-
fn deprecation_lint(is_in_effect: bool) -> &'static Lint {
if is_in_effect { DEPRECATED } else { DEPRECATED_IN_FUTURE }
}
-fn deprecation_message(
- is_in_effect: bool,
- since: DeprecatedSince,
- note: Option<Symbol>,
- kind: &str,
- path: &str,
-) -> String {
- let message = if is_in_effect {
- format!("use of deprecated {kind} `{path}`")
+#[derive(Subdiagnostic)]
+#[suggestion(
+ middle_deprecated_suggestion,
+ code = "{suggestion}",
+ style = "verbose",
+ applicability = "machine-applicable"
+)]
+pub struct DeprecationSuggestion {
+ #[primary_span]
+ pub span: Span,
+
+ pub kind: String,
+ pub suggestion: Symbol,
+}
+
+pub struct Deprecated {
+ pub sub: Option<DeprecationSuggestion>,
+
+ // FIXME: make this translatable
+ pub kind: String,
+ pub path: String,
+ pub note: Option<Symbol>,
+ pub since_kind: DeprecatedSinceKind,
+}
+
+impl<'a, G: EmissionGuarantee> rustc_errors::LintDiagnostic<'a, G> for Deprecated {
+ fn decorate_lint<'b>(self, diag: &'b mut Diag<'a, G>) {
+ diag.arg("kind", self.kind);
+ diag.arg("path", self.path);
+ if let DeprecatedSinceKind::InVersion(version) = self.since_kind {
+ diag.arg("version", version);
+ }
+ if let Some(note) = self.note {
+ diag.arg("has_note", true);
+ diag.arg("note", note);
+ } else {
+ diag.arg("has_note", false);
+ }
+ if let Some(sub) = self.sub {
+ diag.subdiagnostic(diag.dcx, sub);
+ }
+ }
+
+ fn msg(&self) -> rustc_errors::DiagMessage {
+ match &self.since_kind {
+ DeprecatedSinceKind::InEffect => crate::fluent_generated::middle_deprecated,
+ DeprecatedSinceKind::InFuture => crate::fluent_generated::middle_deprecated_in_future,
+ DeprecatedSinceKind::InVersion(_) => {
+ crate::fluent_generated::middle_deprecated_in_version
+ }
+ }
+ }
+}
+
+fn deprecated_since_kind(is_in_effect: bool, since: DeprecatedSince) -> DeprecatedSinceKind {
+ if is_in_effect {
+ DeprecatedSinceKind::InEffect
} else {
match since {
- DeprecatedSince::RustcVersion(version) => format!(
- "use of {kind} `{path}` that will be deprecated in future version {version}"
- ),
- DeprecatedSince::Future => {
- format!("use of {kind} `{path}` that will be deprecated in a future Rust version")
+ DeprecatedSince::RustcVersion(version) => {
+ DeprecatedSinceKind::InVersion(version.to_string())
}
+ DeprecatedSince::Future => DeprecatedSinceKind::InFuture,
DeprecatedSince::NonStandard(_)
| DeprecatedSince::Unspecified
| DeprecatedSince::Err => {
unreachable!("this deprecation is always in effect; {since:?}")
}
}
- };
-
- match note {
- Some(reason) => format!("{message}: {reason}"),
- None => message,
}
}
-pub fn deprecation_message_and_lint(
- depr: &Deprecation,
- kind: &str,
- path: &str,
-) -> (String, &'static Lint) {
- let is_in_effect = depr.is_in_effect();
- (
- deprecation_message(is_in_effect, depr.since, depr.note, kind, path),
- deprecation_lint(is_in_effect),
- )
-}
-
-pub fn early_report_deprecation(
+pub fn early_report_macro_deprecation(
lint_buffer: &mut LintBuffer,
- message: String,
- suggestion: Option<Symbol>,
- lint: &'static Lint,
+ depr: &Deprecation,
span: Span,
node_id: NodeId,
+ path: String,
) {
if span.in_derive_expansion() {
return;
}
- let diag = BuiltinLintDiag::DeprecatedMacro(suggestion, span);
- lint_buffer.buffer_lint_with_diagnostic(lint, node_id, span, message, diag);
+ let is_in_effect = depr.is_in_effect();
+ let diag = BuiltinLintDiag::DeprecatedMacro {
+ suggestion: depr.suggestion,
+ suggestion_span: span,
+ note: depr.note,
+ path,
+ since_kind: deprecated_since_kind(is_in_effect, depr.since.clone()),
+ };
+ lint_buffer.buffer_lint(deprecation_lint(is_in_effect), node_id, span, diag);
}
fn late_report_deprecation(
tcx: TyCtxt<'_>,
- message: String,
- suggestion: Option<Symbol>,
- lint: &'static Lint,
+ depr: &Deprecation,
span: Span,
method_span: Option<Span>,
hir_id: HirId,
@@ -217,13 +234,26 @@
if span.in_derive_expansion() {
return;
}
+
+ let def_path = with_no_trimmed_paths!(tcx.def_path_str(def_id));
+ let def_kind = tcx.def_descr(def_id);
+ let is_in_effect = depr.is_in_effect();
+
let method_span = method_span.unwrap_or(span);
- tcx.node_span_lint(lint, hir_id, method_span, message, |diag| {
- if let hir::Node::Expr(_) = tcx.hir_node(hir_id) {
- let kind = tcx.def_descr(def_id);
- deprecation_suggestion(diag, kind, suggestion, method_span);
- }
- });
+ let suggestion =
+ if let hir::Node::Expr(_) = tcx.hir_node(hir_id) { depr.suggestion } else { None };
+ let diag = Deprecated {
+ sub: suggestion.map(|suggestion| DeprecationSuggestion {
+ span: method_span,
+ kind: def_kind.to_owned(),
+ suggestion,
+ }),
+ kind: def_kind.to_owned(),
+ path: def_path,
+ note: depr.note,
+ since_kind: deprecated_since_kind(is_in_effect, depr.since),
+ };
+ tcx.emit_node_span_lint(deprecation_lint(is_in_effect), hir_id, method_span, diag);
}
/// Result of `TyCtxt::eval_stability`.
@@ -352,28 +382,9 @@
// Calculating message for lint involves calling `self.def_path_str`.
// Which by default to calculate visible path will invoke expensive `visible_parent_map` query.
// So we skip message calculation altogether, if lint is allowed.
- let is_in_effect = depr_attr.is_in_effect();
- let lint = deprecation_lint(is_in_effect);
+ let lint = deprecation_lint(depr_attr.is_in_effect());
if self.lint_level_at_node(lint, id).0 != Level::Allow {
- let def_path = with_no_trimmed_paths!(self.def_path_str(def_id));
- let def_kind = self.def_descr(def_id);
-
- late_report_deprecation(
- self,
- deprecation_message(
- is_in_effect,
- depr_attr.since,
- depr_attr.note,
- def_kind,
- &def_path,
- ),
- depr_attr.suggestion,
- lint,
- span,
- method_span,
- id,
- def_id,
- );
+ late_report_deprecation(self, depr_attr, span, method_span, id, def_id);
}
}
};
diff --git a/compiler/rustc_middle/src/query/on_disk_cache.rs b/compiler/rustc_middle/src/query/on_disk_cache.rs
index 2dcb587..941911c 100644
--- a/compiler/rustc_middle/src/query/on_disk_cache.rs
+++ b/compiler/rustc_middle/src/query/on_disk_cache.rs
@@ -154,24 +154,25 @@
impl<'sess> OnDiskCache<'sess> {
/// Creates a new `OnDiskCache` instance from the serialized data in `data`.
- pub fn new(sess: &'sess Session, data: Mmap, start_pos: usize) -> Self {
- debug_assert!(sess.opts.incremental.is_some());
+ ///
+ /// The serialized cache has some basic integrity checks, if those checks indicate that the
+ /// on-disk data is corrupt, an error is returned.
+ pub fn new(sess: &'sess Session, data: Mmap, start_pos: usize) -> Result<Self, ()> {
+ assert!(sess.opts.incremental.is_some());
- // Wrap in a scope so we can borrow `data`.
- let footer: Footer = {
- let mut decoder = MemDecoder::new(&data, start_pos);
+ let mut decoder = MemDecoder::new(&data, start_pos)?;
- // Decode the *position* of the footer, which can be found in the
- // last 8 bytes of the file.
- let footer_pos = decoder
- .with_position(decoder.len() - IntEncodedWithFixedSize::ENCODED_SIZE, |decoder| {
- IntEncodedWithFixedSize::decode(decoder).0 as usize
- });
- // Decode the file footer, which contains all the lookup tables, etc.
- decoder.with_position(footer_pos, |decoder| decode_tagged(decoder, TAG_FILE_FOOTER))
- };
+ // Decode the *position* of the footer, which can be found in the
+ // last 8 bytes of the file.
+ let footer_pos = decoder
+ .with_position(decoder.len() - IntEncodedWithFixedSize::ENCODED_SIZE, |decoder| {
+ IntEncodedWithFixedSize::decode(decoder).0 as usize
+ });
+ // Decode the file footer, which contains all the lookup tables, etc.
+ let footer: Footer =
+ decoder.with_position(footer_pos, |decoder| decode_tagged(decoder, TAG_FILE_FOOTER));
- Self {
+ Ok(Self {
serialized_data: RwLock::new(Some(data)),
file_index_to_stable_id: footer.file_index_to_stable_id,
file_index_to_file: Default::default(),
@@ -184,7 +185,7 @@
expn_data: footer.expn_data,
foreign_expn_data: footer.foreign_expn_data,
hygiene_context: Default::default(),
- }
+ })
}
pub fn new_empty(source_map: &'sess SourceMap) -> Self {
@@ -437,7 +438,8 @@
let serialized_data = self.serialized_data.read();
let mut decoder = CacheDecoder {
tcx,
- opaque: MemDecoder::new(serialized_data.as_deref().unwrap_or(&[]), pos.to_usize()),
+ opaque: MemDecoder::new(serialized_data.as_deref().unwrap_or(&[]), pos.to_usize())
+ .unwrap(),
source_map: self.source_map,
file_index_to_file: &self.file_index_to_file,
file_index_to_stable_id: &self.file_index_to_stable_id,
@@ -558,7 +560,7 @@
{
debug_assert!(pos < self.opaque.len());
- let new_opaque = MemDecoder::new(self.opaque.data(), pos);
+ let new_opaque = self.opaque.split_at(pos);
let old_opaque = mem::replace(&mut self.opaque, new_opaque);
let r = f(self);
self.opaque = old_opaque;
diff --git a/compiler/rustc_middle/src/ty/codec.rs b/compiler/rustc_middle/src/ty/codec.rs
index c0effe9..07652b4 100644
--- a/compiler/rustc_middle/src/ty/codec.rs
+++ b/compiler/rustc_middle/src/ty/codec.rs
@@ -115,18 +115,11 @@
}
}
-impl<'tcx, E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<E>
- for ty::Binder<'tcx, ty::PredicateKind<'tcx>>
-{
- fn encode(&self, e: &mut E) {
- self.bound_vars().encode(e);
- encode_with_shorthand(e, &self.skip_binder(), TyEncoder::predicate_shorthands);
- }
-}
-
impl<'tcx, E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<E> for ty::Predicate<'tcx> {
fn encode(&self, e: &mut E) {
- self.kind().encode(e);
+ let kind = self.kind();
+ kind.bound_vars().encode(e);
+ encode_with_shorthand(e, &kind.skip_binder(), TyEncoder::predicate_shorthands);
}
}
@@ -233,13 +226,11 @@
}
}
-impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<D>
- for ty::Binder<'tcx, ty::PredicateKind<'tcx>>
-{
- fn decode(decoder: &mut D) -> ty::Binder<'tcx, ty::PredicateKind<'tcx>> {
+impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<D> for ty::Predicate<'tcx> {
+ fn decode(decoder: &mut D) -> ty::Predicate<'tcx> {
let bound_vars = Decodable::decode(decoder);
// Handle shorthands first, if we have a usize > 0x80.
- ty::Binder::bind_with_vars(
+ let predicate_kind = ty::Binder::bind_with_vars(
if decoder.positioned_at_shorthand() {
let pos = decoder.read_usize();
assert!(pos >= SHORTHAND_OFFSET);
@@ -250,13 +241,7 @@
<ty::PredicateKind<'tcx> as Decodable<D>>::decode(decoder)
},
bound_vars,
- )
- }
-}
-
-impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<D> for ty::Predicate<'tcx> {
- fn decode(decoder: &mut D) -> ty::Predicate<'tcx> {
- let predicate_kind = Decodable::decode(decoder);
+ );
decoder.interner().mk_predicate(predicate_kind)
}
}
@@ -599,32 +584,3 @@
}
}
}
-
-macro_rules! impl_binder_encode_decode {
- ($($t:ty),+ $(,)?) => {
- $(
- impl<'tcx, E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<E> for ty::Binder<'tcx, $t> {
- fn encode(&self, e: &mut E) {
- self.bound_vars().encode(e);
- self.as_ref().skip_binder().encode(e);
- }
- }
- impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<D> for ty::Binder<'tcx, $t> {
- fn decode(decoder: &mut D) -> Self {
- let bound_vars = Decodable::decode(decoder);
- ty::Binder::bind_with_vars(Decodable::decode(decoder), bound_vars)
- }
- }
- )*
- }
-}
-
-impl_binder_encode_decode! {
- &'tcx ty::List<Ty<'tcx>>,
- ty::FnSig<'tcx>,
- ty::Predicate<'tcx>,
- ty::TraitPredicate<'tcx>,
- ty::ExistentialPredicate<'tcx>,
- ty::TraitRef<'tcx>,
- ty::ExistentialTraitRef<'tcx>,
-}
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 8185c99..896114e 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -31,8 +31,7 @@
self, AdtDef, AdtDefData, AdtKind, Binder, Clause, Clauses, Const, ConstData,
GenericParamDefKind, ImplPolarity, List, ListWithCachedTypeInfo, ParamConst, ParamTy, Pattern,
PatternKind, PolyExistentialPredicate, PolyFnSig, Predicate, PredicateKind, PredicatePolarity,
- Region, RegionKind, ReprOptions, TraitObjectVisitor, Ty, TyKind, TyVid, TypeVisitable,
- Visibility,
+ Region, RegionKind, ReprOptions, TraitObjectVisitor, Ty, TyKind, TyVid, Visibility,
};
use crate::ty::{GenericArg, GenericArgs, GenericArgsRef};
use rustc_ast::{self as ast, attr};
@@ -96,9 +95,8 @@
type GenericArg = ty::GenericArg<'tcx>;
type Term = ty::Term<'tcx>;
- type Binder<T: TypeVisitable<TyCtxt<'tcx>>> = Binder<'tcx, T>;
- type BoundVars = &'tcx List<ty::BoundVariableKind>;
- type BoundVar = ty::BoundVariableKind;
+ type BoundVarKinds = &'tcx List<ty::BoundVariableKind>;
+ type BoundVarKind = ty::BoundVariableKind;
type CanonicalVars = CanonicalVarInfos<'tcx>;
type PredefinedOpaques = solve::PredefinedOpaques<'tcx>;
@@ -123,7 +121,6 @@
type Abi = abi::Abi;
type Const = ty::Const<'tcx>;
- type AliasConst = ty::UnevaluatedConst<'tcx>;
type PlaceholderConst = ty::PlaceholderConst;
type ParamConst = ty::ParamConst;
type BoundConst = ty::BoundVar;
@@ -138,15 +135,7 @@
type ParamEnv = ty::ParamEnv<'tcx>;
type Predicate = Predicate<'tcx>;
- type TraitPredicate = ty::TraitPredicate<'tcx>;
- type RegionOutlivesPredicate = ty::RegionOutlivesPredicate<'tcx>;
- type TypeOutlivesPredicate = ty::TypeOutlivesPredicate<'tcx>;
- type ProjectionPredicate = ty::ProjectionPredicate<'tcx>;
- type NormalizesTo = ty::NormalizesTo<'tcx>;
- type SubtypePredicate = ty::SubtypePredicate<'tcx>;
-
- type CoercePredicate = ty::CoercePredicate<'tcx>;
- type ClosureKind = ty::ClosureKind;
+ type Clause = Clause<'tcx>;
type Clauses = ty::Clauses<'tcx>;
@@ -245,6 +234,10 @@
}
impl<'tcx> rustc_type_ir::inherent::Safety<TyCtxt<'tcx>> for hir::Safety {
+ fn is_safe(self) -> bool {
+ matches!(self, hir::Safety::Safe)
+ }
+
fn prefix_str(self) -> &'static str {
self.prefix_str()
}
diff --git a/compiler/rustc_middle/src/ty/generic_args.rs b/compiler/rustc_middle/src/ty/generic_args.rs
index 3d263e6..cb11bb3 100644
--- a/compiler/rustc_middle/src/ty/generic_args.rs
+++ b/compiler/rustc_middle/src/ty/generic_args.rs
@@ -51,6 +51,14 @@
fn identity_for_item(tcx: TyCtxt<'tcx>, def_id: DefId) -> ty::GenericArgsRef<'tcx> {
GenericArgs::identity_for_item(tcx, def_id)
}
+
+ fn extend_with_error(
+ tcx: TyCtxt<'tcx>,
+ def_id: DefId,
+ original_args: &[ty::GenericArg<'tcx>],
+ ) -> ty::GenericArgsRef<'tcx> {
+ ty::GenericArgs::extend_with_error(tcx, def_id, original_args)
+ }
}
impl<'tcx> rustc_type_ir::inherent::IntoKind for GenericArg<'tcx> {
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 8bb19bc..f274098 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -1814,6 +1814,11 @@
self.get_attrs(did, attr).next().is_some()
}
+ /// Determines whether an item is annotated with a multi-segement attribute
+ pub fn has_attrs_with_path(self, did: impl Into<DefId>, attrs: &[Symbol]) -> bool {
+ self.get_attrs_by_path(did.into(), attrs).next().is_some()
+ }
+
/// Returns `true` if this is an `auto trait`.
pub fn trait_is_auto(self, trait_def_id: DefId) -> bool {
self.trait_def(trait_def_id).has_auto_impl
diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
index be91249..293cc0a 100644
--- a/compiler/rustc_middle/src/ty/predicate.rs
+++ b/compiler/rustc_middle/src/ty/predicate.rs
@@ -1,15 +1,13 @@
use rustc_data_structures::captures::Captures;
use rustc_data_structures::intern::Interned;
use rustc_hir::def_id::DefId;
-use rustc_macros::{
- extension, HashStable, Lift, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable,
-};
+use rustc_macros::{extension, HashStable};
use rustc_type_ir as ir;
use std::cmp::Ordering;
use crate::ty::{
- self, Binder, DebruijnIndex, EarlyBinder, PredicatePolarity, Term, Ty, TyCtxt, TypeFlags,
- Upcast, UpcastFrom, WithCachedTypeInfo,
+ self, DebruijnIndex, EarlyBinder, PredicatePolarity, Ty, TyCtxt, TypeFlags, Upcast, UpcastFrom,
+ WithCachedTypeInfo,
};
pub type TraitRef<'tcx> = ir::TraitRef<TyCtxt<'tcx>>;
@@ -24,6 +22,15 @@
pub type NormalizesTo<'tcx> = ir::NormalizesTo<TyCtxt<'tcx>>;
pub type CoercePredicate<'tcx> = ir::CoercePredicate<TyCtxt<'tcx>>;
pub type SubtypePredicate<'tcx> = ir::SubtypePredicate<TyCtxt<'tcx>>;
+pub type OutlivesPredicate<'tcx, T> = ir::OutlivesPredicate<TyCtxt<'tcx>, T>;
+pub type RegionOutlivesPredicate<'tcx> = OutlivesPredicate<'tcx, ty::Region<'tcx>>;
+pub type TypeOutlivesPredicate<'tcx> = OutlivesPredicate<'tcx, Ty<'tcx>>;
+pub type PolyTraitPredicate<'tcx> = ty::Binder<'tcx, TraitPredicate<'tcx>>;
+pub type PolyRegionOutlivesPredicate<'tcx> = ty::Binder<'tcx, RegionOutlivesPredicate<'tcx>>;
+pub type PolyTypeOutlivesPredicate<'tcx> = ty::Binder<'tcx, TypeOutlivesPredicate<'tcx>>;
+pub type PolySubtypePredicate<'tcx> = ty::Binder<'tcx, SubtypePredicate<'tcx>>;
+pub type PolyCoercePredicate<'tcx> = ty::Binder<'tcx, CoercePredicate<'tcx>>;
+pub type PolyProjectionPredicate<'tcx> = ty::Binder<'tcx, ProjectionPredicate<'tcx>>;
/// A statement that can be proven by a trait solver. This includes things that may
/// show up in where clauses, such as trait predicates and projection predicates,
@@ -155,6 +162,8 @@
pub(super) Interned<'tcx, WithCachedTypeInfo<ty::Binder<'tcx, PredicateKind<'tcx>>>>,
);
+impl<'tcx> rustc_type_ir::inherent::Clause<TyCtxt<'tcx>> for Clause<'tcx> {}
+
impl<'tcx> Clause<'tcx> {
pub fn as_predicate(self) -> Predicate<'tcx> {
Predicate(self.0)
@@ -231,34 +240,6 @@
pub type PolyExistentialPredicate<'tcx> = ty::Binder<'tcx, ExistentialPredicate<'tcx>>;
-impl<'tcx> PolyExistentialPredicate<'tcx> {
- /// Given an existential predicate like `?Self: PartialEq<u32>` (e.g., derived from `dyn PartialEq<u32>`),
- /// and a concrete type `self_ty`, returns a full predicate where the existentially quantified variable `?Self`
- /// has been replaced with `self_ty` (e.g., `self_ty: PartialEq<u32>`, in our example).
- pub fn with_self_ty(&self, tcx: TyCtxt<'tcx>, self_ty: Ty<'tcx>) -> ty::Clause<'tcx> {
- match self.skip_binder() {
- ExistentialPredicate::Trait(tr) => {
- self.rebind(tr).with_self_ty(tcx, self_ty).upcast(tcx)
- }
- ExistentialPredicate::Projection(p) => {
- self.rebind(p.with_self_ty(tcx, self_ty)).upcast(tcx)
- }
- ExistentialPredicate::AutoTrait(did) => {
- let generics = tcx.generics_of(did);
- let trait_ref = if generics.own_params.len() == 1 {
- ty::TraitRef::new(tcx, did, [self_ty])
- } else {
- // If this is an ill-formed auto trait, then synthesize
- // new error args for the missing generics.
- let err_args = ty::GenericArgs::extend_with_error(tcx, did, &[self_ty.into()]);
- ty::TraitRef::new(tcx, did, err_args)
- };
- self.rebind(trait_ref).upcast(tcx)
- }
- }
- }
-}
-
impl<'tcx> ty::List<ty::PolyExistentialPredicate<'tcx>> {
/// Returns the "principal `DefId`" of this set of existential predicates.
///
@@ -322,49 +303,9 @@
}
pub type PolyTraitRef<'tcx> = ty::Binder<'tcx, TraitRef<'tcx>>;
-
-impl<'tcx> PolyTraitRef<'tcx> {
- pub fn self_ty(&self) -> ty::Binder<'tcx, Ty<'tcx>> {
- self.map_bound_ref(|tr| tr.self_ty())
- }
-
- pub fn def_id(&self) -> DefId {
- self.skip_binder().def_id
- }
-}
-
pub type PolyExistentialTraitRef<'tcx> = ty::Binder<'tcx, ExistentialTraitRef<'tcx>>;
-
-impl<'tcx> PolyExistentialTraitRef<'tcx> {
- pub fn def_id(&self) -> DefId {
- self.skip_binder().def_id
- }
-
- /// Object types don't have a self type specified. Therefore, when
- /// we convert the principal trait-ref into a normal trait-ref,
- /// you must give *some* self type. A common choice is `mk_err()`
- /// or some placeholder type.
- pub fn with_self_ty(&self, tcx: TyCtxt<'tcx>, self_ty: Ty<'tcx>) -> ty::PolyTraitRef<'tcx> {
- self.map_bound(|trait_ref| trait_ref.with_self_ty(tcx, self_ty))
- }
-}
-
pub type PolyExistentialProjection<'tcx> = ty::Binder<'tcx, ExistentialProjection<'tcx>>;
-impl<'tcx> PolyExistentialProjection<'tcx> {
- pub fn with_self_ty(
- &self,
- tcx: TyCtxt<'tcx>,
- self_ty: Ty<'tcx>,
- ) -> ty::PolyProjectionPredicate<'tcx> {
- self.map_bound(|p| p.with_self_ty(tcx, self_ty))
- }
-
- pub fn item_def_id(&self) -> DefId {
- self.skip_binder().def_id
- }
-}
-
impl<'tcx> Clause<'tcx> {
/// Performs a instantiation suitable for going from a
/// poly-trait-ref to supertraits that must hold if that
@@ -471,73 +412,6 @@
}
}
-pub type PolyTraitPredicate<'tcx> = ty::Binder<'tcx, TraitPredicate<'tcx>>;
-
-impl<'tcx> PolyTraitPredicate<'tcx> {
- pub fn def_id(self) -> DefId {
- // Ok to skip binder since trait `DefId` does not care about regions.
- self.skip_binder().def_id()
- }
-
- pub fn self_ty(self) -> ty::Binder<'tcx, Ty<'tcx>> {
- self.map_bound(|trait_ref| trait_ref.self_ty())
- }
-
- #[inline]
- pub fn polarity(self) -> PredicatePolarity {
- self.skip_binder().polarity
- }
-}
-
-/// `A: B`
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)]
-#[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
-pub struct OutlivesPredicate<A, B>(pub A, pub B);
-pub type RegionOutlivesPredicate<'tcx> = OutlivesPredicate<ty::Region<'tcx>, ty::Region<'tcx>>;
-pub type TypeOutlivesPredicate<'tcx> = OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>>;
-pub type PolyRegionOutlivesPredicate<'tcx> = ty::Binder<'tcx, RegionOutlivesPredicate<'tcx>>;
-pub type PolyTypeOutlivesPredicate<'tcx> = ty::Binder<'tcx, TypeOutlivesPredicate<'tcx>>;
-
-pub type PolySubtypePredicate<'tcx> = ty::Binder<'tcx, SubtypePredicate<'tcx>>;
-
-pub type PolyCoercePredicate<'tcx> = ty::Binder<'tcx, CoercePredicate<'tcx>>;
-
-pub type PolyProjectionPredicate<'tcx> = Binder<'tcx, ProjectionPredicate<'tcx>>;
-
-impl<'tcx> PolyProjectionPredicate<'tcx> {
- /// Returns the `DefId` of the trait of the associated item being projected.
- #[inline]
- pub fn trait_def_id(&self, tcx: TyCtxt<'tcx>) -> DefId {
- self.skip_binder().projection_term.trait_def_id(tcx)
- }
-
- /// Get the [PolyTraitRef] required for this projection to be well formed.
- /// Note that for generic associated types the predicates of the associated
- /// type also need to be checked.
- #[inline]
- pub fn required_poly_trait_ref(&self, tcx: TyCtxt<'tcx>) -> PolyTraitRef<'tcx> {
- // Note: unlike with `TraitRef::to_poly_trait_ref()`,
- // `self.0.trait_ref` is permitted to have escaping regions.
- // This is because here `self` has a `Binder` and so does our
- // return value, so we are preserving the number of binding
- // levels.
- self.map_bound(|predicate| predicate.projection_term.trait_ref(tcx))
- }
-
- pub fn term(&self) -> Binder<'tcx, Term<'tcx>> {
- self.map_bound(|predicate| predicate.term)
- }
-
- /// The `DefId` of the `TraitItem` for the associated type.
- ///
- /// Note that this is not the `DefId` of the `TraitRef` containing this
- /// associated type, which is in `tcx.associated_item(projection_def_id()).container`.
- pub fn projection_def_id(&self) -> DefId {
- // Ok to skip binder since trait `DefId` does not care about regions.
- self.skip_binder().projection_term.def_id
- }
-}
-
pub trait ToPolyTraitRef<'tcx> {
fn to_poly_trait_ref(&self) -> PolyTraitRef<'tcx>;
}
@@ -554,8 +428,8 @@
}
}
-impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<'tcx, PredicateKind<'tcx>>> for Predicate<'tcx> {
- fn upcast_from(from: Binder<'tcx, PredicateKind<'tcx>>, tcx: TyCtxt<'tcx>) -> Self {
+impl<'tcx> UpcastFrom<TyCtxt<'tcx>, ty::Binder<'tcx, PredicateKind<'tcx>>> for Predicate<'tcx> {
+ fn upcast_from(from: ty::Binder<'tcx, PredicateKind<'tcx>>, tcx: TyCtxt<'tcx>) -> Self {
tcx.mk_predicate(from)
}
}
@@ -566,8 +440,8 @@
}
}
-impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<'tcx, ClauseKind<'tcx>>> for Predicate<'tcx> {
- fn upcast_from(from: Binder<'tcx, ClauseKind<'tcx>>, tcx: TyCtxt<'tcx>) -> Self {
+impl<'tcx> UpcastFrom<TyCtxt<'tcx>, ty::Binder<'tcx, ClauseKind<'tcx>>> for Predicate<'tcx> {
+ fn upcast_from(from: ty::Binder<'tcx, ClauseKind<'tcx>>, tcx: TyCtxt<'tcx>) -> Self {
tcx.mk_predicate(from.map_bound(PredicateKind::Clause))
}
}
@@ -580,12 +454,12 @@
impl<'tcx> UpcastFrom<TyCtxt<'tcx>, ClauseKind<'tcx>> for Clause<'tcx> {
fn upcast_from(from: ClauseKind<'tcx>, tcx: TyCtxt<'tcx>) -> Self {
- tcx.mk_predicate(Binder::dummy(PredicateKind::Clause(from))).expect_clause()
+ tcx.mk_predicate(ty::Binder::dummy(PredicateKind::Clause(from))).expect_clause()
}
}
-impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<'tcx, ClauseKind<'tcx>>> for Clause<'tcx> {
- fn upcast_from(from: Binder<'tcx, ClauseKind<'tcx>>, tcx: TyCtxt<'tcx>) -> Self {
+impl<'tcx> UpcastFrom<TyCtxt<'tcx>, ty::Binder<'tcx, ClauseKind<'tcx>>> for Clause<'tcx> {
+ fn upcast_from(from: ty::Binder<'tcx, ClauseKind<'tcx>>, tcx: TyCtxt<'tcx>) -> Self {
tcx.mk_predicate(from.map_bound(|clause| PredicateKind::Clause(clause))).expect_clause()
}
}
@@ -609,22 +483,22 @@
}
}
-impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<'tcx, TraitRef<'tcx>>> for Predicate<'tcx> {
- fn upcast_from(from: Binder<'tcx, TraitRef<'tcx>>, tcx: TyCtxt<'tcx>) -> Self {
+impl<'tcx> UpcastFrom<TyCtxt<'tcx>, ty::Binder<'tcx, TraitRef<'tcx>>> for Predicate<'tcx> {
+ fn upcast_from(from: ty::Binder<'tcx, TraitRef<'tcx>>, tcx: TyCtxt<'tcx>) -> Self {
let pred: PolyTraitPredicate<'tcx> = from.upcast(tcx);
pred.upcast(tcx)
}
}
-impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<'tcx, TraitRef<'tcx>>> for Clause<'tcx> {
- fn upcast_from(from: Binder<'tcx, TraitRef<'tcx>>, tcx: TyCtxt<'tcx>) -> Self {
+impl<'tcx> UpcastFrom<TyCtxt<'tcx>, ty::Binder<'tcx, TraitRef<'tcx>>> for Clause<'tcx> {
+ fn upcast_from(from: ty::Binder<'tcx, TraitRef<'tcx>>, tcx: TyCtxt<'tcx>) -> Self {
let pred: PolyTraitPredicate<'tcx> = from.upcast(tcx);
pred.upcast(tcx)
}
}
-impl<'tcx> UpcastFrom<TyCtxt<'tcx>, Binder<'tcx, TraitRef<'tcx>>> for PolyTraitPredicate<'tcx> {
- fn upcast_from(from: Binder<'tcx, TraitRef<'tcx>>, _tcx: TyCtxt<'tcx>) -> Self {
+impl<'tcx> UpcastFrom<TyCtxt<'tcx>, ty::Binder<'tcx, TraitRef<'tcx>>> for PolyTraitPredicate<'tcx> {
+ fn upcast_from(from: ty::Binder<'tcx, TraitRef<'tcx>>, _tcx: TyCtxt<'tcx>) -> Self {
from.map_bound(|trait_ref| TraitPredicate {
trait_ref,
polarity: PredicatePolarity::Positive,
@@ -664,10 +538,8 @@
}
}
-impl<'tcx> UpcastFrom<TyCtxt<'tcx>, OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>>>
- for Predicate<'tcx>
-{
- fn upcast_from(from: OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>>, tcx: TyCtxt<'tcx>) -> Self {
+impl<'tcx> UpcastFrom<TyCtxt<'tcx>, TypeOutlivesPredicate<'tcx>> for Predicate<'tcx> {
+ fn upcast_from(from: TypeOutlivesPredicate<'tcx>, tcx: TyCtxt<'tcx>) -> Self {
ty::Binder::dummy(PredicateKind::Clause(ClauseKind::TypeOutlives(from))).upcast(tcx)
}
}
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 0dbb17e..a1ead1b 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -2860,10 +2860,9 @@
}
}
-impl<'tcx, T, U, P: PrettyPrinter<'tcx>> Print<'tcx, P> for ty::OutlivesPredicate<T, U>
+impl<'tcx, T, P: PrettyPrinter<'tcx>> Print<'tcx, P> for ty::OutlivesPredicate<'tcx, T>
where
T: Print<'tcx, P>,
- U: Print<'tcx, P>,
{
fn print(&self, cx: &mut P) -> Result<(), PrintError> {
define_scoped_cx!(cx);
@@ -2934,12 +2933,13 @@
}
}
+#[extension(pub trait PrintPolyTraitRefExt<'tcx>)]
impl<'tcx> ty::Binder<'tcx, ty::TraitRef<'tcx>> {
- pub fn print_only_trait_path(self) -> ty::Binder<'tcx, TraitRefPrintOnlyTraitPath<'tcx>> {
+ fn print_only_trait_path(self) -> ty::Binder<'tcx, TraitRefPrintOnlyTraitPath<'tcx>> {
self.map_bound(|tr| tr.print_only_trait_path())
}
- pub fn print_trait_sugared(self) -> ty::Binder<'tcx, TraitRefPrintSugared<'tcx>> {
+ fn print_trait_sugared(self) -> ty::Binder<'tcx, TraitRefPrintSugared<'tcx>> {
self.map_bound(|tr| tr.print_trait_sugared())
}
}
@@ -2960,8 +2960,9 @@
}
}
+#[extension(pub trait PrintPolyTraitPredicateExt<'tcx>)]
impl<'tcx> ty::PolyTraitPredicate<'tcx> {
- pub fn print_modifiers_and_trait_path(
+ fn print_modifiers_and_trait_path(
self,
) -> ty::Binder<'tcx, TraitPredPrintModifiersAndPath<'tcx>> {
self.map_bound(TraitPredPrintModifiersAndPath)
@@ -3014,21 +3015,7 @@
ty::Region<'tcx>,
Ty<'tcx>,
&'tcx ty::List<ty::PolyExistentialPredicate<'tcx>>,
- ty::Const<'tcx>,
-
- // HACK(eddyb) these are exhaustive instead of generic,
- // because `for<'tcx>` isn't possible yet.
- ty::PolyExistentialProjection<'tcx>,
- ty::PolyExistentialTraitRef<'tcx>,
- ty::Binder<'tcx, ty::TraitRef<'tcx>>,
- ty::Binder<'tcx, TraitRefPrintOnlyTraitPath<'tcx>>,
- ty::Binder<'tcx, TraitRefPrintSugared<'tcx>>,
- ty::Binder<'tcx, ty::FnSig<'tcx>>,
- ty::Binder<'tcx, ty::TraitPredicate<'tcx>>,
- ty::Binder<'tcx, TraitPredPrintModifiersAndPath<'tcx>>,
- ty::Binder<'tcx, ty::ProjectionPredicate<'tcx>>,
- ty::OutlivesPredicate<Ty<'tcx>, ty::Region<'tcx>>,
- ty::OutlivesPredicate<ty::Region<'tcx>, ty::Region<'tcx>>
+ ty::Const<'tcx>
}
define_print! {
diff --git a/compiler/rustc_middle/src/ty/region.rs b/compiler/rustc_middle/src/ty/region.rs
index 551e2ea..d7da373 100644
--- a/compiler/rustc_middle/src/ty/region.rs
+++ b/compiler/rustc_middle/src/ty/region.rs
@@ -384,6 +384,10 @@
fn var(self) -> BoundVar {
self.var
}
+
+ fn assert_eq(self, var: ty::BoundVariableKind) {
+ assert_eq!(self.kind, var.expect_region())
+ }
}
impl core::fmt::Debug for BoundRegion {
diff --git a/compiler/rustc_middle/src/ty/structural_impls.rs b/compiler/rustc_middle/src/ty/structural_impls.rs
index 81d92a2..af3aa3b 100644
--- a/compiler/rustc_middle/src/ty/structural_impls.rs
+++ b/compiler/rustc_middle/src/ty/structural_impls.rs
@@ -387,38 +387,6 @@
}
}
-impl<'tcx, T: TypeFoldable<TyCtxt<'tcx>>> TypeFoldable<TyCtxt<'tcx>> for ty::Binder<'tcx, T> {
- fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
- self,
- folder: &mut F,
- ) -> Result<Self, F::Error> {
- folder.try_fold_binder(self)
- }
-}
-
-impl<'tcx, T: TypeVisitable<TyCtxt<'tcx>>> TypeVisitable<TyCtxt<'tcx>> for ty::Binder<'tcx, T> {
- fn visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
- visitor.visit_binder(self)
- }
-}
-
-impl<'tcx, T: TypeFoldable<TyCtxt<'tcx>>> TypeSuperFoldable<TyCtxt<'tcx>> for ty::Binder<'tcx, T> {
- fn try_super_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
- self,
- folder: &mut F,
- ) -> Result<Self, F::Error> {
- self.try_map_bound(|ty| ty.try_fold_with(folder))
- }
-}
-
-impl<'tcx, T: TypeVisitable<TyCtxt<'tcx>>> TypeSuperVisitable<TyCtxt<'tcx>>
- for ty::Binder<'tcx, T>
-{
- fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>(&self, visitor: &mut V) -> V::Result {
- self.as_ref().skip_binder().visit_with(visitor)
- }
-}
-
impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>> {
fn try_fold_with<F: FallibleTypeFolder<TyCtxt<'tcx>>>(
self,
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index 2d9d178..fc9a854 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -3,17 +3,16 @@
#![allow(rustc::usage_of_ty_tykind)]
use crate::infer::canonical::Canonical;
-use crate::ty::visit::ValidateBoundVars;
use crate::ty::InferTy::*;
use crate::ty::{
self, AdtDef, BoundRegionKind, Discr, Region, Ty, TyCtxt, TypeFlags, TypeSuperVisitable,
- TypeVisitable, TypeVisitableExt, TypeVisitor,
+ TypeVisitable, TypeVisitor,
};
use crate::ty::{GenericArg, GenericArgs, GenericArgsRef};
use crate::ty::{List, ParamEnv};
use hir::def::{CtorKind, DefKind};
use rustc_data_structures::captures::Captures;
-use rustc_errors::{DiagArgValue, ErrorGuaranteed, IntoDiagArg, MultiSpan};
+use rustc_errors::{ErrorGuaranteed, MultiSpan};
use rustc_hir as hir;
use rustc_hir::def_id::DefId;
use rustc_hir::LangItem;
@@ -21,11 +20,11 @@
use rustc_span::symbol::{sym, Symbol};
use rustc_span::{Span, DUMMY_SP};
use rustc_target::abi::{FieldIdx, VariantIdx, FIRST_VARIANT};
-use rustc_target::spec::abi::{self, Abi};
+use rustc_target::spec::abi;
use std::assert_matches::debug_assert_matches;
use std::borrow::Cow;
use std::iter;
-use std::ops::{ControlFlow, Deref, Range};
+use std::ops::{ControlFlow, Range};
use ty::util::IntTypeExt;
use rustc_type_ir::TyKind::*;
@@ -40,6 +39,7 @@
pub type TypeAndMut<'tcx> = ir::TypeAndMut<TyCtxt<'tcx>>;
pub type AliasTy<'tcx> = ir::AliasTy<TyCtxt<'tcx>>;
pub type FnSig<'tcx> = ir::FnSig<TyCtxt<'tcx>>;
+pub type Binder<'tcx, T> = ir::Binder<TyCtxt<'tcx>, T>;
pub trait Article {
fn article(&self) -> &'static str;
@@ -373,7 +373,7 @@
self.split().signature_parts_ty
}
- pub fn coroutine_closure_sig(self) -> ty::Binder<'tcx, CoroutineClosureSignature<'tcx>> {
+ pub fn coroutine_closure_sig(self) -> Binder<'tcx, CoroutineClosureSignature<'tcx>> {
let interior = self.coroutine_witness_ty();
let ty::FnPtr(sig) = self.signature_parts_ty().kind() else { bug!() };
sig.map_bound(|sig| {
@@ -898,203 +898,6 @@
}
}
-/// Binder is a binder for higher-ranked lifetimes or types. It is part of the
-/// compiler's representation for things like `for<'a> Fn(&'a isize)`
-/// (which would be represented by the type `PolyTraitRef ==
-/// Binder<'tcx, TraitRef>`). Note that when we instantiate,
-/// erase, or otherwise "discharge" these bound vars, we change the
-/// type from `Binder<'tcx, T>` to just `T` (see
-/// e.g., `liberate_late_bound_regions`).
-///
-/// `Decodable` and `Encodable` are implemented for `Binder<T>` using the `impl_binder_encode_decode!` macro.
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
-#[derive(HashStable, Lift)]
-pub struct Binder<'tcx, T> {
- value: T,
- bound_vars: &'tcx List<BoundVariableKind>,
-}
-
-impl<'tcx, T> Binder<'tcx, T>
-where
- T: TypeVisitable<TyCtxt<'tcx>>,
-{
- /// Wraps `value` in a binder, asserting that `value` does not
- /// contain any bound vars that would be bound by the
- /// binder. This is commonly used to 'inject' a value T into a
- /// different binding level.
- #[track_caller]
- pub fn dummy(value: T) -> Binder<'tcx, T> {
- assert!(
- !value.has_escaping_bound_vars(),
- "`{value:?}` has escaping bound vars, so it cannot be wrapped in a dummy binder."
- );
- Binder { value, bound_vars: ty::List::empty() }
- }
-
- pub fn bind_with_vars(value: T, bound_vars: &'tcx List<BoundVariableKind>) -> Binder<'tcx, T> {
- if cfg!(debug_assertions) {
- let mut validator = ValidateBoundVars::new(bound_vars);
- value.visit_with(&mut validator);
- }
- Binder { value, bound_vars }
- }
-}
-
-impl<'tcx, T> rustc_type_ir::inherent::BoundVars<TyCtxt<'tcx>> for ty::Binder<'tcx, T> {
- fn bound_vars(&self) -> &'tcx List<ty::BoundVariableKind> {
- self.bound_vars
- }
-
- fn has_no_bound_vars(&self) -> bool {
- self.bound_vars.is_empty()
- }
-}
-
-impl<'tcx, T> Binder<'tcx, T> {
- /// Skips the binder and returns the "bound" value. This is a
- /// risky thing to do because it's easy to get confused about
- /// De Bruijn indices and the like. It is usually better to
- /// discharge the binder using `no_bound_vars` or
- /// `instantiate_bound_regions` or something like
- /// that. `skip_binder` is only valid when you are either
- /// extracting data that has nothing to do with bound vars, you
- /// are doing some sort of test that does not involve bound
- /// regions, or you are being very careful about your depth
- /// accounting.
- ///
- /// Some examples where `skip_binder` is reasonable:
- ///
- /// - extracting the `DefId` from a PolyTraitRef;
- /// - comparing the self type of a PolyTraitRef to see if it is equal to
- /// a type parameter `X`, since the type `X` does not reference any regions
- pub fn skip_binder(self) -> T {
- self.value
- }
-
- pub fn bound_vars(&self) -> &'tcx List<BoundVariableKind> {
- self.bound_vars
- }
-
- pub fn as_ref(&self) -> Binder<'tcx, &T> {
- Binder { value: &self.value, bound_vars: self.bound_vars }
- }
-
- pub fn as_deref(&self) -> Binder<'tcx, &T::Target>
- where
- T: Deref,
- {
- Binder { value: &self.value, bound_vars: self.bound_vars }
- }
-
- pub fn map_bound_ref<F, U: TypeVisitable<TyCtxt<'tcx>>>(&self, f: F) -> Binder<'tcx, U>
- where
- F: FnOnce(&T) -> U,
- {
- self.as_ref().map_bound(f)
- }
-
- pub fn map_bound<F, U: TypeVisitable<TyCtxt<'tcx>>>(self, f: F) -> Binder<'tcx, U>
- where
- F: FnOnce(T) -> U,
- {
- let Binder { value, bound_vars } = self;
- let value = f(value);
- if cfg!(debug_assertions) {
- let mut validator = ValidateBoundVars::new(bound_vars);
- value.visit_with(&mut validator);
- }
- Binder { value, bound_vars }
- }
-
- pub fn try_map_bound<F, U: TypeVisitable<TyCtxt<'tcx>>, E>(
- self,
- f: F,
- ) -> Result<Binder<'tcx, U>, E>
- where
- F: FnOnce(T) -> Result<U, E>,
- {
- let Binder { value, bound_vars } = self;
- let value = f(value)?;
- if cfg!(debug_assertions) {
- let mut validator = ValidateBoundVars::new(bound_vars);
- value.visit_with(&mut validator);
- }
- Ok(Binder { value, bound_vars })
- }
-
- /// Wraps a `value` in a binder, using the same bound variables as the
- /// current `Binder`. This should not be used if the new value *changes*
- /// the bound variables. Note: the (old or new) value itself does not
- /// necessarily need to *name* all the bound variables.
- ///
- /// This currently doesn't do anything different than `bind`, because we
- /// don't actually track bound vars. However, semantically, it is different
- /// because bound vars aren't allowed to change here, whereas they are
- /// in `bind`. This may be (debug) asserted in the future.
- pub fn rebind<U>(&self, value: U) -> Binder<'tcx, U>
- where
- U: TypeVisitable<TyCtxt<'tcx>>,
- {
- Binder::bind_with_vars(value, self.bound_vars)
- }
-
- /// Unwraps and returns the value within, but only if it contains
- /// no bound vars at all. (In other words, if this binder --
- /// and indeed any enclosing binder -- doesn't bind anything at
- /// all.) Otherwise, returns `None`.
- ///
- /// (One could imagine having a method that just unwraps a single
- /// binder, but permits late-bound vars bound by enclosing
- /// binders, but that would require adjusting the debruijn
- /// indices, and given the shallow binding structure we often use,
- /// would not be that useful.)
- pub fn no_bound_vars(self) -> Option<T>
- where
- T: TypeVisitable<TyCtxt<'tcx>>,
- {
- // `self.value` is equivalent to `self.skip_binder()`
- if self.value.has_escaping_bound_vars() { None } else { Some(self.skip_binder()) }
- }
-
- /// Splits the contents into two things that share the same binder
- /// level as the original, returning two distinct binders.
- ///
- /// `f` should consider bound regions at depth 1 to be free, and
- /// anything it produces with bound regions at depth 1 will be
- /// bound in the resulting return values.
- pub fn split<U, V, F>(self, f: F) -> (Binder<'tcx, U>, Binder<'tcx, V>)
- where
- F: FnOnce(T) -> (U, V),
- {
- let Binder { value, bound_vars } = self;
- let (u, v) = f(value);
- (Binder { value: u, bound_vars }, Binder { value: v, bound_vars })
- }
-}
-
-impl<'tcx, T> Binder<'tcx, Option<T>> {
- pub fn transpose(self) -> Option<Binder<'tcx, T>> {
- let Binder { value, bound_vars } = self;
- value.map(|value| Binder { value, bound_vars })
- }
-}
-
-impl<'tcx, T: IntoIterator> Binder<'tcx, T> {
- pub fn iter(self) -> impl Iterator<Item = ty::Binder<'tcx, T::Item>> {
- let Binder { value, bound_vars } = self;
- value.into_iter().map(|value| Binder { value, bound_vars })
- }
-}
-
-impl<'tcx, T> IntoDiagArg for Binder<'tcx, T>
-where
- T: IntoDiagArg,
-{
- fn into_diag_arg(self) -> DiagArgValue {
- self.value.into_diag_arg()
- }
-}
-
#[derive(Copy, Clone, Debug, TypeFoldable, TypeVisitable)]
pub struct GenSig<'tcx> {
pub resume_ty: Ty<'tcx>,
@@ -1103,48 +906,6 @@
}
pub type PolyFnSig<'tcx> = Binder<'tcx, FnSig<'tcx>>;
-
-impl<'tcx> PolyFnSig<'tcx> {
- #[inline]
- pub fn inputs(&self) -> Binder<'tcx, &'tcx [Ty<'tcx>]> {
- self.map_bound_ref(|fn_sig| fn_sig.inputs())
- }
-
- #[inline]
- #[track_caller]
- pub fn input(&self, index: usize) -> ty::Binder<'tcx, Ty<'tcx>> {
- self.map_bound_ref(|fn_sig| fn_sig.inputs()[index])
- }
-
- pub fn inputs_and_output(&self) -> ty::Binder<'tcx, &'tcx List<Ty<'tcx>>> {
- self.map_bound_ref(|fn_sig| fn_sig.inputs_and_output)
- }
-
- #[inline]
- pub fn output(&self) -> ty::Binder<'tcx, Ty<'tcx>> {
- self.map_bound_ref(|fn_sig| fn_sig.output())
- }
-
- pub fn c_variadic(&self) -> bool {
- self.skip_binder().c_variadic
- }
-
- pub fn safety(&self) -> hir::Safety {
- self.skip_binder().safety
- }
-
- pub fn abi(&self) -> abi::Abi {
- self.skip_binder().abi
- }
-
- pub fn is_fn_trait_compatible(&self) -> bool {
- matches!(
- self.skip_binder(),
- ty::FnSig { safety: rustc_hir::Safety::Safe, abi: Abi::Rust, c_variadic: false, .. }
- )
- }
-}
-
pub type CanonicalPolyFnSig<'tcx> = Canonical<'tcx, Binder<'tcx, FnSig<'tcx>>>;
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)]
@@ -1203,6 +964,10 @@
fn var(self) -> BoundVar {
self.var
}
+
+ fn assert_eq(self, var: ty::BoundVariableKind) {
+ assert_eq!(self.kind, var.expect_ty())
+ }
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, TyEncodable, TyDecodable)]
@@ -2001,7 +1766,7 @@
FnPtr(f) => *f,
Error(_) => {
// ignore errors (#54954)
- ty::Binder::dummy(ty::FnSig {
+ Binder::dummy(ty::FnSig {
inputs_and_output: ty::List::empty(),
c_variadic: false,
safety: hir::Safety::Safe,
diff --git a/compiler/rustc_middle/src/ty/visit.rs b/compiler/rustc_middle/src/ty/visit.rs
index 218567b..b1bbfd4 100644
--- a/compiler/rustc_middle/src/ty/visit.rs
+++ b/compiler/rustc_middle/src/ty/visit.rs
@@ -1,7 +1,6 @@
use crate::ty::{self, Binder, Ty, TyCtxt, TypeFlags};
use rustc_data_structures::fx::FxHashSet;
-use rustc_data_structures::sso::SsoHashSet;
use rustc_type_ir::fold::TypeFoldable;
use std::ops::ControlFlow;
@@ -145,103 +144,6 @@
}
}
-pub struct ValidateBoundVars<'tcx> {
- bound_vars: &'tcx ty::List<ty::BoundVariableKind>,
- binder_index: ty::DebruijnIndex,
- // We may encounter the same variable at different levels of binding, so
- // this can't just be `Ty`
- visited: SsoHashSet<(ty::DebruijnIndex, Ty<'tcx>)>,
-}
-
-impl<'tcx> ValidateBoundVars<'tcx> {
- pub fn new(bound_vars: &'tcx ty::List<ty::BoundVariableKind>) -> Self {
- ValidateBoundVars {
- bound_vars,
- binder_index: ty::INNERMOST,
- visited: SsoHashSet::default(),
- }
- }
-}
-
-impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for ValidateBoundVars<'tcx> {
- type Result = ControlFlow<()>;
-
- fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(
- &mut self,
- t: &Binder<'tcx, T>,
- ) -> Self::Result {
- self.binder_index.shift_in(1);
- let result = t.super_visit_with(self);
- self.binder_index.shift_out(1);
- result
- }
-
- fn visit_ty(&mut self, t: Ty<'tcx>) -> Self::Result {
- if t.outer_exclusive_binder() < self.binder_index
- || !self.visited.insert((self.binder_index, t))
- {
- return ControlFlow::Break(());
- }
- match *t.kind() {
- ty::Bound(debruijn, bound_ty) if debruijn == self.binder_index => {
- if self.bound_vars.len() <= bound_ty.var.as_usize() {
- bug!("Not enough bound vars: {:?} not found in {:?}", t, self.bound_vars);
- }
- let list_var = self.bound_vars[bound_ty.var.as_usize()];
- match list_var {
- ty::BoundVariableKind::Ty(kind) => {
- if kind != bound_ty.kind {
- bug!(
- "Mismatched type kinds: {:?} doesn't var in list {:?}",
- bound_ty.kind,
- list_var
- );
- }
- }
- _ => {
- bug!("Mismatched bound variable kinds! Expected type, found {:?}", list_var)
- }
- }
- }
-
- _ => (),
- };
-
- t.super_visit_with(self)
- }
-
- fn visit_region(&mut self, r: ty::Region<'tcx>) -> Self::Result {
- match *r {
- ty::ReBound(index, br) if index == self.binder_index => {
- if self.bound_vars.len() <= br.var.as_usize() {
- bug!("Not enough bound vars: {:?} not found in {:?}", br, self.bound_vars);
- }
- let list_var = self.bound_vars[br.var.as_usize()];
- match list_var {
- ty::BoundVariableKind::Region(kind) => {
- if kind != br.kind {
- bug!(
- "Mismatched region kinds: {:?} doesn't match var ({:?}) in list ({:?})",
- br.kind,
- list_var,
- self.bound_vars
- );
- }
- }
- _ => bug!(
- "Mismatched bound variable kinds! Expected region, found {:?}",
- list_var
- ),
- }
- }
-
- _ => (),
- };
-
- ControlFlow::Continue(())
- }
-}
-
/// Collects all the late-bound regions at the innermost binding level
/// into a hash set.
struct LateBoundRegionsCollector {
diff --git a/compiler/rustc_next_trait_solver/src/canonicalizer.rs b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
index 696639e..127ebde 100644
--- a/compiler/rustc_next_trait_solver/src/canonicalizer.rs
+++ b/compiler/rustc_next_trait_solver/src/canonicalizer.rs
@@ -217,10 +217,9 @@
self.infcx.interner()
}
- fn fold_binder<T>(&mut self, t: I::Binder<T>) -> I::Binder<T>
+ fn fold_binder<T>(&mut self, t: ty::Binder<I, T>) -> ty::Binder<I, T>
where
T: TypeFoldable<I>,
- I::Binder<T>: TypeSuperFoldable<I>,
{
self.binder_index.shift_in(1);
let t = t.super_fold_with(self);
@@ -455,10 +454,9 @@
self.interner
}
- fn fold_binder<T>(&mut self, t: I::Binder<T>) -> I::Binder<T>
+ fn fold_binder<T>(&mut self, t: ty::Binder<I, T>) -> ty::Binder<I, T>
where
T: TypeFoldable<I>,
- I::Binder<T>: TypeSuperFoldable<I>,
{
self.binder.shift_in(1);
let t = t.super_fold_with(self);
diff --git a/compiler/rustc_parse/src/lexer/mod.rs b/compiler/rustc_parse/src/lexer/mod.rs
index d2d200a..6eb8bed 100644
--- a/compiler/rustc_parse/src/lexer/mod.rs
+++ b/compiler/rustc_parse/src/lexer/mod.rs
@@ -370,11 +370,10 @@
let content = self.str_from(content_start);
if contains_text_flow_control_chars(content) {
let span = self.mk_sp(start, self.pos);
- self.psess.buffer_lint_with_diagnostic(
+ self.psess.buffer_lint(
TEXT_DIRECTION_CODEPOINT_IN_COMMENT,
span,
ast::CRATE_NODE_ID,
- "unicode codepoint changing visible direction of text present in comment",
BuiltinLintDiag::UnicodeTextFlow(span, content.to_string()),
);
}
@@ -723,12 +722,11 @@
self.dcx().emit_err(errors::UnknownPrefix { span: prefix_span, prefix, sugg });
} else {
// Before Rust 2021, only emit a lint for migration.
- self.psess.buffer_lint_with_diagnostic(
+ self.psess.buffer_lint(
RUST_2021_PREFIXES_INCOMPATIBLE_SYNTAX,
prefix_span,
ast::CRATE_NODE_ID,
- format!("prefix `{prefix}` is unknown"),
- BuiltinLintDiag::ReservedPrefix(prefix_span),
+ BuiltinLintDiag::ReservedPrefix(prefix_span, prefix.to_string()),
);
}
}
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index d2d2162..fd3f63a 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -1913,11 +1913,10 @@
| ExprKind::Block(_, None)
)
{
- self.psess.buffer_lint_with_diagnostic(
+ self.psess.buffer_lint(
BREAK_WITH_LABEL_AND_LOOP,
lo.to(expr.span),
ast::CRATE_NODE_ID,
- "this labeled break expression is easy to confuse with an unlabeled break with a labeled value expression",
BuiltinLintDiag::BreakWithLabelAndLoop(expr.span),
);
}
diff --git a/compiler/rustc_parse/src/validate_attr.rs b/compiler/rustc_parse/src/validate_attr.rs
index f88edf2..b91ef1a 100644
--- a/compiler/rustc_parse/src/validate_attr.rs
+++ b/compiler/rustc_parse/src/validate_attr.rs
@@ -10,6 +10,7 @@
use rustc_feature::{AttributeTemplate, BuiltinAttribute, BUILTIN_ATTRIBUTE_MAP};
use rustc_session::errors::report_lit_error;
use rustc_session::lint::builtin::ILL_FORMED_ATTRIBUTE_INPUT;
+use rustc_session::lint::BuiltinLintDiag;
use rustc_session::parse::ParseSess;
use rustc_span::{sym, Span, Symbol};
@@ -176,37 +177,26 @@
};
let error_msg = format!("malformed `{name}` attribute input");
- let mut msg = "attribute must be of the form ".to_owned();
let mut suggestions = vec![];
- let mut first = true;
let inner = if style == ast::AttrStyle::Inner { "!" } else { "" };
if template.word {
- first = false;
- let code = format!("#{inner}[{name}]");
- msg.push_str(&format!("`{code}`"));
- suggestions.push(code);
+ suggestions.push(format!("#{inner}[{name}]"));
}
if let Some(descr) = template.list {
- if !first {
- msg.push_str(" or ");
- }
- first = false;
- let code = format!("#{inner}[{name}({descr})]");
- msg.push_str(&format!("`{code}`"));
- suggestions.push(code);
+ suggestions.push(format!("#{inner}[{name}({descr})]"));
}
if let Some(descr) = template.name_value_str {
- if !first {
- msg.push_str(" or ");
- }
- let code = format!("#{inner}[{name} = \"{descr}\"]");
- msg.push_str(&format!("`{code}`"));
- suggestions.push(code);
+ suggestions.push(format!("#{inner}[{name} = \"{descr}\"]"));
}
- suggestions.sort();
if should_warn(name) {
- psess.buffer_lint(ILL_FORMED_ATTRIBUTE_INPUT, span, ast::CRATE_NODE_ID, msg);
+ psess.buffer_lint(
+ ILL_FORMED_ATTRIBUTE_INPUT,
+ span,
+ ast::CRATE_NODE_ID,
+ BuiltinLintDiag::IllFormedAttributeInput { suggestions: suggestions.clone() },
+ );
} else {
+ suggestions.sort();
psess
.dcx
.struct_span_err(span, error_msg)
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 3deefca..d850644 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -341,7 +341,7 @@
feature `{$implied_by}` implying `{$feature}` does not exist
passes_incorrect_do_not_recommend_location =
- `#[do_not_recommend]` can only be placed on trait implementations
+ `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
passes_incorrect_meta_item = expected a quoted string literal
passes_incorrect_meta_item_suggestion = consider surrounding this with quotes
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index b1438a5..1924533 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -113,92 +113,96 @@
let mut seen = FxHashMap::default();
let attrs = self.tcx.hir().attrs(hir_id);
for attr in attrs {
- if attr.path_matches(&[sym::diagnostic, sym::on_unimplemented]) {
- self.check_diagnostic_on_unimplemented(attr.span, hir_id, target);
- }
- match attr.name_or_empty() {
- sym::do_not_recommend => self.check_do_not_recommend(attr.span, target),
- sym::inline => self.check_inline(hir_id, attr, span, target),
- sym::coverage => self.check_coverage(hir_id, attr, span, target),
- sym::non_exhaustive => self.check_non_exhaustive(hir_id, attr, span, target),
- sym::marker => self.check_marker(hir_id, attr, span, target),
- sym::target_feature => self.check_target_feature(hir_id, attr, span, target, attrs),
- sym::thread_local => self.check_thread_local(attr, span, target),
- sym::track_caller => {
+ match attr.path().as_slice() {
+ [sym::diagnostic, sym::do_not_recommend] => {
+ self.check_do_not_recommend(attr.span, hir_id, target)
+ }
+ [sym::diagnostic, sym::on_unimplemented] => {
+ self.check_diagnostic_on_unimplemented(attr.span, hir_id, target)
+ }
+ [sym::inline] => self.check_inline(hir_id, attr, span, target),
+ [sym::coverage] => self.check_coverage(hir_id, attr, span, target),
+ [sym::non_exhaustive] => self.check_non_exhaustive(hir_id, attr, span, target),
+ [sym::marker] => self.check_marker(hir_id, attr, span, target),
+ [sym::target_feature] => {
+ self.check_target_feature(hir_id, attr, span, target, attrs)
+ }
+ [sym::thread_local] => self.check_thread_local(attr, span, target),
+ [sym::track_caller] => {
self.check_track_caller(hir_id, attr.span, attrs, span, target)
}
- sym::doc => self.check_doc_attrs(
+ [sym::doc] => self.check_doc_attrs(
attr,
hir_id,
target,
&mut specified_inline,
&mut doc_aliases,
),
- sym::no_link => self.check_no_link(hir_id, attr, span, target),
- sym::export_name => self.check_export_name(hir_id, attr, span, target),
- sym::rustc_layout_scalar_valid_range_start
- | sym::rustc_layout_scalar_valid_range_end => {
+ [sym::no_link] => self.check_no_link(hir_id, attr, span, target),
+ [sym::export_name] => self.check_export_name(hir_id, attr, span, target),
+ [sym::rustc_layout_scalar_valid_range_start]
+ | [sym::rustc_layout_scalar_valid_range_end] => {
self.check_rustc_layout_scalar_valid_range(attr, span, target)
}
- sym::allow_internal_unstable => {
+ [sym::allow_internal_unstable] => {
self.check_allow_internal_unstable(hir_id, attr, span, target, attrs)
}
- sym::debugger_visualizer => self.check_debugger_visualizer(attr, target),
- sym::rustc_allow_const_fn_unstable => {
+ [sym::debugger_visualizer] => self.check_debugger_visualizer(attr, target),
+ [sym::rustc_allow_const_fn_unstable] => {
self.check_rustc_allow_const_fn_unstable(hir_id, attr, span, target)
}
- sym::rustc_std_internal_symbol => {
+ [sym::rustc_std_internal_symbol] => {
self.check_rustc_std_internal_symbol(attr, span, target)
}
- sym::naked => self.check_naked(hir_id, attr, span, target),
- sym::rustc_never_returns_null_ptr => {
+ [sym::naked] => self.check_naked(hir_id, attr, span, target),
+ [sym::rustc_never_returns_null_ptr] => {
self.check_applied_to_fn_or_method(hir_id, attr, span, target)
}
- sym::rustc_legacy_const_generics => {
+ [sym::rustc_legacy_const_generics] => {
self.check_rustc_legacy_const_generics(hir_id, attr, span, target, item)
}
- sym::rustc_lint_query_instability => {
+ [sym::rustc_lint_query_instability] => {
self.check_rustc_lint_query_instability(hir_id, attr, span, target)
}
- sym::rustc_lint_diagnostics => {
+ [sym::rustc_lint_diagnostics] => {
self.check_rustc_lint_diagnostics(hir_id, attr, span, target)
}
- sym::rustc_lint_opt_ty => self.check_rustc_lint_opt_ty(attr, span, target),
- sym::rustc_lint_opt_deny_field_access => {
+ [sym::rustc_lint_opt_ty] => self.check_rustc_lint_opt_ty(attr, span, target),
+ [sym::rustc_lint_opt_deny_field_access] => {
self.check_rustc_lint_opt_deny_field_access(attr, span, target)
}
- sym::rustc_clean
- | sym::rustc_dirty
- | sym::rustc_if_this_changed
- | sym::rustc_then_this_would_need => self.check_rustc_dirty_clean(attr),
- sym::rustc_coinductive
- | sym::rustc_must_implement_one_of
- | sym::rustc_deny_explicit_impl
- | sym::const_trait => self.check_must_be_applied_to_trait(attr, span, target),
- sym::cmse_nonsecure_entry => {
+ [sym::rustc_clean]
+ | [sym::rustc_dirty]
+ | [sym::rustc_if_this_changed]
+ | [sym::rustc_then_this_would_need] => self.check_rustc_dirty_clean(attr),
+ [sym::rustc_coinductive]
+ | [sym::rustc_must_implement_one_of]
+ | [sym::rustc_deny_explicit_impl]
+ | [sym::const_trait] => self.check_must_be_applied_to_trait(attr, span, target),
+ [sym::cmse_nonsecure_entry] => {
self.check_cmse_nonsecure_entry(hir_id, attr, span, target)
}
- sym::collapse_debuginfo => self.check_collapse_debuginfo(attr, span, target),
- sym::must_not_suspend => self.check_must_not_suspend(attr, span, target),
- sym::must_use => self.check_must_use(hir_id, attr, target),
- sym::rustc_pass_by_value => self.check_pass_by_value(attr, span, target),
- sym::rustc_allow_incoherent_impl => {
+ [sym::collapse_debuginfo] => self.check_collapse_debuginfo(attr, span, target),
+ [sym::must_not_suspend] => self.check_must_not_suspend(attr, span, target),
+ [sym::must_use] => self.check_must_use(hir_id, attr, target),
+ [sym::rustc_pass_by_value] => self.check_pass_by_value(attr, span, target),
+ [sym::rustc_allow_incoherent_impl] => {
self.check_allow_incoherent_impl(attr, span, target)
}
- sym::rustc_has_incoherent_inherent_impls => {
+ [sym::rustc_has_incoherent_inherent_impls] => {
self.check_has_incoherent_inherent_impls(attr, span, target)
}
- sym::ffi_pure => self.check_ffi_pure(attr.span, attrs, target),
- sym::ffi_const => self.check_ffi_const(attr.span, target),
- sym::rustc_const_unstable
- | sym::rustc_const_stable
- | sym::unstable
- | sym::stable
- | sym::rustc_allowed_through_unstable_modules
- | sym::rustc_promotable => self.check_stability_promotable(attr, target),
- sym::link_ordinal => self.check_link_ordinal(attr, span, target),
- sym::rustc_confusables => self.check_confusables(attr, target),
- sym::rustc_safe_intrinsic => {
+ [sym::ffi_pure] => self.check_ffi_pure(attr.span, attrs, target),
+ [sym::ffi_const] => self.check_ffi_const(attr.span, target),
+ [sym::rustc_const_unstable]
+ | [sym::rustc_const_stable]
+ | [sym::unstable]
+ | [sym::stable]
+ | [sym::rustc_allowed_through_unstable_modules]
+ | [sym::rustc_promotable] => self.check_stability_promotable(attr, target),
+ [sym::link_ordinal] => self.check_link_ordinal(attr, span, target),
+ [sym::rustc_confusables] => self.check_confusables(attr, target),
+ [sym::rustc_safe_intrinsic] => {
self.check_rustc_safe_intrinsic(hir_id, attr, span, target)
}
_ => true,
@@ -290,18 +294,26 @@
);
}
- /// Checks if `#[do_not_recommend]` is applied on a trait impl.
- fn check_do_not_recommend(&self, attr_span: Span, target: Target) -> bool {
- if let Target::Impl = target {
- true
- } else {
- self.dcx().emit_err(errors::IncorrectDoNotRecommendLocation { span: attr_span });
- false
+ /// Checks if `#[diagnostic::do_not_recommend]` is applied on a trait impl.
+ fn check_do_not_recommend(&self, attr_span: Span, hir_id: HirId, target: Target) -> bool {
+ if !matches!(target, Target::Impl) {
+ self.tcx.emit_node_span_lint(
+ UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
+ hir_id,
+ attr_span,
+ errors::IncorrectDoNotRecommendLocation,
+ );
}
+ true
}
/// Checks if `#[diagnostic::on_unimplemented]` is applied to a trait definition
- fn check_diagnostic_on_unimplemented(&self, attr_span: Span, hir_id: HirId, target: Target) {
+ fn check_diagnostic_on_unimplemented(
+ &self,
+ attr_span: Span,
+ hir_id: HirId,
+ target: Target,
+ ) -> bool {
if !matches!(target, Target::Trait) {
self.tcx.emit_node_span_lint(
UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
@@ -310,6 +322,7 @@
DiagnosticOnUnimplementedOnlyForTraits,
);
}
+ true
}
/// Checks if an `#[inline]` is applied to a function or a closure. Returns `true` if valid.
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index b8586e7..1805527 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -17,12 +17,9 @@
use crate::check_attr::ProcMacroKind;
use crate::lang_items::Duplicate;
-#[derive(Diagnostic)]
+#[derive(LintDiagnostic)]
#[diag(passes_incorrect_do_not_recommend_location)]
-pub struct IncorrectDoNotRecommendLocation {
- #[primary_span]
- pub span: Span,
-}
+pub struct IncorrectDoNotRecommendLocation;
#[derive(LintDiagnostic)]
#[diag(passes_outer_crate_level_attr)]
diff --git a/compiler/rustc_query_system/src/dep_graph/serialized.rs b/compiler/rustc_query_system/src/dep_graph/serialized.rs
index b426bb8..8e91d9d 100644
--- a/compiler/rustc_query_system/src/dep_graph/serialized.rs
+++ b/compiler/rustc_query_system/src/dep_graph/serialized.rs
@@ -182,15 +182,13 @@
pub fn decode<D: Deps>(d: &mut MemDecoder<'_>) -> Arc<SerializedDepGraph> {
// The last 16 bytes are the node count and edge count.
debug!("position: {:?}", d.position());
- let (node_count, edge_count, graph_size) =
- d.with_position(d.len() - 3 * IntEncodedWithFixedSize::ENCODED_SIZE, |d| {
+ let (node_count, edge_count) =
+ d.with_position(d.len() - 2 * IntEncodedWithFixedSize::ENCODED_SIZE, |d| {
debug!("position: {:?}", d.position());
let node_count = IntEncodedWithFixedSize::decode(d).0 as usize;
let edge_count = IntEncodedWithFixedSize::decode(d).0 as usize;
- let graph_size = IntEncodedWithFixedSize::decode(d).0 as usize;
- (node_count, edge_count, graph_size)
+ (node_count, edge_count)
});
- assert_eq!(d.len(), graph_size);
debug!("position: {:?}", d.position());
debug!(?node_count, ?edge_count);
@@ -606,8 +604,6 @@
debug!("position: {:?}", encoder.position());
IntEncodedWithFixedSize(node_count).encode(&mut encoder);
IntEncodedWithFixedSize(edge_count).encode(&mut encoder);
- let graph_size = encoder.position() + IntEncodedWithFixedSize::ENCODED_SIZE;
- IntEncodedWithFixedSize(graph_size as u64).encode(&mut encoder);
debug!("position: {:?}", encoder.position());
// Drop the encoder so that nothing is written after the counts.
let result = encoder.finish();
diff --git a/compiler/rustc_resolve/src/check_unused.rs b/compiler/rustc_resolve/src/check_unused.rs
index 180e7f6..fc3669f 100644
--- a/compiler/rustc_resolve/src/check_unused.rs
+++ b/compiler/rustc_resolve/src/check_unused.rs
@@ -32,7 +32,7 @@
use rustc_ast::visit::{self, Visitor};
use rustc_data_structures::fx::{FxHashMap, FxIndexMap, FxIndexSet};
use rustc_data_structures::unord::UnordSet;
-use rustc_errors::{pluralize, MultiSpan};
+use rustc_errors::MultiSpan;
use rustc_hir::def::{DefKind, Res};
use rustc_session::lint::builtin::{MACRO_USE_EXTERN_CRATE, UNUSED_EXTERN_CRATES};
use rustc_session::lint::builtin::{UNUSED_IMPORTS, UNUSED_QUALIFICATIONS};
@@ -151,11 +151,10 @@
// We do this in any edition.
if warn_if_unused {
if let Some(&span) = maybe_unused_extern_crates.get(&extern_crate.id) {
- self.r.lint_buffer.buffer_lint_with_diagnostic(
+ self.r.lint_buffer.buffer_lint(
UNUSED_EXTERN_CRATES,
extern_crate.id,
span,
- "unused extern crate",
BuiltinLintDiag::UnusedExternCrate {
removal_span: extern_crate.span_with_attributes,
},
@@ -204,11 +203,10 @@
.span
.find_ancestor_inside(extern_crate.span)
.unwrap_or(extern_crate.ident.span);
- self.r.lint_buffer.buffer_lint_with_diagnostic(
+ self.r.lint_buffer.buffer_lint(
UNUSED_EXTERN_CRATES,
extern_crate.id,
extern_crate.span,
- "`extern crate` is not idiomatic in the new edition",
BuiltinLintDiag::ExternCrateNotIdiomatic { vis_span, ident_span },
);
}
@@ -394,10 +392,7 @@
MACRO_USE_EXTERN_CRATE,
import.root_id,
import.span,
- "deprecated `#[macro_use]` attribute used to \
- import macros should be replaced at use sites \
- with a `use` item to import the macro \
- instead",
+ BuiltinLintDiag::MacroUseDeprecated,
);
}
}
@@ -414,8 +409,12 @@
}
}
ImportKind::MacroUse { .. } => {
- let msg = "unused `#[macro_use]` import";
- self.lint_buffer.buffer_lint(UNUSED_IMPORTS, import.root_id, import.span, msg);
+ self.lint_buffer.buffer_lint(
+ UNUSED_IMPORTS,
+ import.root_id,
+ import.span,
+ BuiltinLintDiag::UnusedMacroUse,
+ );
}
_ => {}
}
@@ -434,20 +433,12 @@
visitor.report_unused_extern_crate_items(maybe_unused_extern_crates);
for unused in visitor.unused_imports.values() {
- let mut fixes = Vec::new();
- let spans = match calc_unused_spans(unused, &unused.use_tree, unused.use_tree_id) {
- UnusedSpanResult::Used => continue,
- UnusedSpanResult::Unused { spans, remove } => {
- fixes.push((remove, String::new()));
- spans
- }
- UnusedSpanResult::PartialUnused { spans, remove } => {
- for fix in &remove {
- fixes.push((*fix, String::new()));
- }
- spans
- }
- };
+ let (spans, remove_spans) =
+ match calc_unused_spans(unused, &unused.use_tree, unused.use_tree_id) {
+ UnusedSpanResult::Used => continue,
+ UnusedSpanResult::Unused { spans, remove } => (spans, vec![remove]),
+ UnusedSpanResult::PartialUnused { spans, remove } => (spans, remove),
+ };
let ms = MultiSpan::from_spans(spans);
@@ -459,23 +450,8 @@
.collect::<Vec<String>>();
span_snippets.sort();
- let msg = format!(
- "unused import{}{}",
- pluralize!(ms.primary_spans().len()),
- if !span_snippets.is_empty() {
- format!(": {}", span_snippets.join(", "))
- } else {
- String::new()
- }
- );
-
- let fix_msg = if fixes.len() == 1 && fixes[0].0 == unused.item_span {
- "remove the whole `use` item"
- } else if ms.primary_spans().len() > 1 {
- "remove the unused imports"
- } else {
- "remove the unused import"
- };
+ let remove_whole_use = remove_spans.len() == 1 && remove_spans[0] == unused.item_span;
+ let num_to_remove = ms.primary_spans().len();
// If we are in the `--test` mode, suppress a help that adds the `#[cfg(test)]`
// attribute; however, if not, suggest adding the attribute. There is no way to
@@ -501,12 +477,17 @@
}
};
- visitor.r.lint_buffer.buffer_lint_with_diagnostic(
+ visitor.r.lint_buffer.buffer_lint(
UNUSED_IMPORTS,
unused.use_tree_id,
ms,
- msg,
- BuiltinLintDiag::UnusedImports(fix_msg.into(), fixes, test_module_span),
+ BuiltinLintDiag::UnusedImports {
+ remove_whole_use,
+ num_to_remove,
+ remove_spans,
+ test_module_span,
+ span_snippets,
+ },
);
}
@@ -552,11 +533,10 @@
continue;
}
- self.lint_buffer.buffer_lint_with_diagnostic(
+ self.lint_buffer.buffer_lint(
UNUSED_QUALIFICATIONS,
unn_qua.node_id,
unn_qua.path_span,
- "unnecessary qualification",
BuiltinLintDiag::UnusedQualifications { removal_span: unn_qua.removal_span },
);
}
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index b28312f..856cfbc 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -128,13 +128,10 @@
self.report_with_use_injections(krate);
for &(span_use, span_def) in &self.macro_expanded_macro_export_errors {
- let msg = "macro-expanded `macro_export` macros from the current crate \
- cannot be referred to by absolute paths";
- self.lint_buffer.buffer_lint_with_diagnostic(
+ self.lint_buffer.buffer_lint(
MACRO_EXPANDED_MACRO_EXPORTS_ACCESSED_BY_ABSOLUTE_PATHS,
CRATE_NODE_ID,
span_use,
- msg,
BuiltinLintDiag::MacroExpandedMacroExportsAccessedByAbsolutePaths(span_def),
);
}
@@ -145,11 +142,10 @@
let NameBindingKind::Import { import, .. } = ambiguity_error.b1.0.kind else {
unreachable!()
};
- self.lint_buffer.buffer_lint_with_diagnostic(
+ self.lint_buffer.buffer_lint(
AMBIGUOUS_GLOB_IMPORTS,
import.root_id,
ambiguity_error.ident.span,
- diag.msg.to_string(),
BuiltinLintDiag::AmbiguousGlobImports { diag },
);
} else {
@@ -526,12 +522,10 @@
}
let diag = BuiltinLintDiag::AbsPathWithModule(root_span);
- self.lint_buffer.buffer_lint_with_diagnostic(
+ self.lint_buffer.buffer_lint(
ABSOLUTE_PATHS_NOT_STARTING_WITH_CRATE,
node_id,
root_span,
- "absolute paths must start with `self`, `super`, \
- `crate`, or an external crate name in the 2018 edition",
diag,
);
}
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index f887258..57db765 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -524,18 +524,15 @@
match binding {
Ok(binding) => {
if let Some(lint_id) = derive_fallback_lint_id {
- this.lint_buffer.buffer_lint_with_diagnostic(
+ this.lint_buffer.buffer_lint(
PROC_MACRO_DERIVE_RESOLUTION_FALLBACK,
lint_id,
orig_ident.span,
- format!(
- "cannot find {} `{}` in this scope",
- ns.descr(),
- ident
- ),
- BuiltinLintDiag::ProcMacroDeriveResolutionFallback(
- orig_ident.span,
- ),
+ BuiltinLintDiag::ProcMacroDeriveResolutionFallback {
+ span: orig_ident.span,
+ ns,
+ ident,
+ },
);
}
let misc_flags = if module == this.graph_root {
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index f53bcb0..51b87c5 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -619,11 +619,10 @@
&& binding.res() != Res::Err
&& exported_ambiguities.contains(&binding)
{
- self.lint_buffer.buffer_lint_with_diagnostic(
+ self.lint_buffer.buffer_lint(
AMBIGUOUS_GLOB_REEXPORTS,
import.root_id,
import.root_span,
- "ambiguous glob re-exports",
BuiltinLintDiag::AmbiguousGlobReexports {
name: key.ident.to_string(),
namespace: key.ns.descr().to_string(),
@@ -655,11 +654,10 @@
&& glob_binding.vis.is_public()
&& !binding.vis.is_public()
{
- self.lint_buffer.buffer_lint_with_diagnostic(
+ self.lint_buffer.buffer_lint(
HIDDEN_GLOB_REEXPORTS,
binding_id,
binding.span,
- "private item shadows public glob re-export",
BuiltinLintDiag::HiddenGlobReexports {
name: key.ident.name.to_string(),
namespace: key.ns.descr().to_owned(),
@@ -1015,17 +1013,13 @@
&& !max_vis.is_at_least(import_vis, self.tcx)
{
let def_id = self.local_def_id(id);
- let msg = format!(
- "glob import doesn't reexport anything with visibility `{}` because no imported item is public enough",
- import_vis.to_string(def_id, self.tcx)
- );
- self.lint_buffer.buffer_lint_with_diagnostic(
+ self.lint_buffer.buffer_lint(
UNUSED_IMPORTS,
id,
import.span,
- msg,
BuiltinLintDiag::RedundantImportVisibility {
max_vis: max_vis.to_string(def_id, self.tcx),
+ import_vis: import_vis.to_string(def_id, self.tcx),
span: import.span,
},
);
@@ -1252,16 +1246,11 @@
if !any_successful_reexport {
let (ns, binding) = reexport_error.unwrap();
if pub_use_of_private_extern_crate_hack(import, binding) {
- let msg = format!(
- "extern crate `{ident}` is private, and cannot be \
- re-exported (error E0365), consider declaring with \
- `pub`"
- );
self.lint_buffer.buffer_lint(
PUB_USE_OF_PRIVATE_EXTERN_CRATE,
import_id,
import.span,
- msg,
+ BuiltinLintDiag::PrivateExternCrateReexport(ident),
);
} else {
if ns == TypeNS {
@@ -1397,7 +1386,6 @@
UNUSED_IMPORTS,
id,
import.span,
- format!("the item `{source}` is imported redundantly"),
BuiltinLintDiag::RedundantImport(redundant_spans, source),
);
*/
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index 0f585aa..d1d0e33 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -24,7 +24,7 @@
use rustc_middle::ty::DelegationFnSig;
use rustc_middle::{bug, span_bug};
use rustc_session::config::{CrateType, ResolveDocLinks};
-use rustc_session::lint;
+use rustc_session::lint::{self, BuiltinLintDiag};
use rustc_session::parse::feature_err;
use rustc_span::source_map::{respan, Spanned};
use rustc_span::symbol::{kw, sym, Ident, Symbol};
@@ -1675,16 +1675,10 @@
return;
}
LifetimeRibKind::AnonymousWarn(node_id) => {
- let msg = if elided {
- "`&` without an explicit lifetime name cannot be used here"
- } else {
- "`'_` cannot be used here"
- };
- self.r.lint_buffer.buffer_lint_with_diagnostic(
+ self.r.lint_buffer.buffer_lint(
lint::builtin::ELIDED_LIFETIMES_IN_ASSOCIATED_CONSTANT,
node_id,
lifetime.ident.span,
- msg,
lint::BuiltinLintDiag::AssociatedConstElidedLifetime {
elided,
span: lifetime.ident.span,
@@ -1966,11 +1960,10 @@
}
if should_lint {
- self.r.lint_buffer.buffer_lint_with_diagnostic(
+ self.r.lint_buffer.buffer_lint(
lint::builtin::ELIDED_LIFETIMES_IN_PATHS,
segment_id,
elided_lifetime_span,
- "hidden lifetime parameters in types are deprecated",
lint::BuiltinLintDiag::ElidedLifetimesInPaths(
expected_lifetimes,
path_span,
@@ -4822,7 +4815,12 @@
late_resolution_visitor.resolve_doc_links(&krate.attrs, MaybeExported::Ok(CRATE_NODE_ID));
visit::walk_crate(&mut late_resolution_visitor, krate);
for (id, span) in late_resolution_visitor.diag_metadata.unused_labels.iter() {
- self.lint_buffer.buffer_lint(lint::builtin::UNUSED_LABELS, *id, *span, "unused label");
+ self.lint_buffer.buffer_lint(
+ lint::builtin::UNUSED_LABELS,
+ *id,
+ *span,
+ BuiltinLintDiag::UnusedLabel,
+ );
}
}
}
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index 980f43b..9daa22f 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -2652,15 +2652,15 @@
let deletion_span =
if param.bounds.is_empty() { deletion_span() } else { None };
- self.r.lint_buffer.buffer_lint_with_diagnostic(
+ self.r.lint_buffer.buffer_lint(
lint::builtin::SINGLE_USE_LIFETIMES,
param.id,
param.ident.span,
- format!("lifetime parameter `{}` only used once", param.ident),
lint::BuiltinLintDiag::SingleUseLifetime {
param_span: param.ident.span,
use_span: Some((use_span, elidable)),
deletion_span,
+ ident: param.ident,
},
);
}
@@ -2670,15 +2670,15 @@
// if the lifetime originates from expanded code, we won't be able to remove it #104432
if deletion_span.is_some_and(|sp| !sp.in_derive_expansion()) {
- self.r.lint_buffer.buffer_lint_with_diagnostic(
+ self.r.lint_buffer.buffer_lint(
lint::builtin::UNUSED_LIFETIMES,
param.id,
param.ident.span,
- format!("lifetime parameter `{}` never used", param.ident),
lint::BuiltinLintDiag::SingleUseLifetime {
param_span: param.ident.span,
use_span: None,
deletion_span,
+ ident: param.ident,
},
);
}
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index 01bcfec..f4c5ad8 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -51,7 +51,7 @@
use rustc_middle::ty::{ResolverGlobalCtxt, ResolverOutputs, TyCtxt, TyCtxtFeed};
use rustc_query_system::ich::StableHashingContext;
use rustc_session::lint::builtin::PRIVATE_MACRO_USE;
-use rustc_session::lint::LintBuffer;
+use rustc_session::lint::{BuiltinLintDiag, LintBuffer};
use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind, SyntaxContext, Transparency};
use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{Span, DUMMY_SP};
@@ -1860,8 +1860,12 @@
}
if let NameBindingKind::Import { import, binding } = used_binding.kind {
if let ImportKind::MacroUse { warn_private: true } = import.kind {
- let msg = format!("macro `{ident}` is private");
- self.lint_buffer().buffer_lint(PRIVATE_MACRO_USE, import.root_id, ident.span, msg);
+ self.lint_buffer().buffer_lint(
+ PRIVATE_MACRO_USE,
+ import.root_id,
+ ident.span,
+ BuiltinLintDiag::MacroIsPrivate(ident),
+ );
}
// Avoid marking `extern crate` items that refer to a name from extern prelude,
// but not introduce it, as used if they are accessed from lexical scope.
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index f8d245f..268e7f0 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -315,7 +315,7 @@
UNUSED_MACROS,
node_id,
ident.span,
- format!("unused macro definition: `{}`", ident.name),
+ BuiltinLintDiag::UnusedMacroDefinition(ident.name),
);
}
for (&(def_id, arm_i), &(ident, rule_span)) in self.unused_macro_rules.iter() {
@@ -328,7 +328,7 @@
UNUSED_MACRO_RULES,
node_id,
rule_span,
- format!("rule #{} of macro `{}` is never used", arm_i + 1, ident.name),
+ BuiltinLintDiag::MacroRuleNeverUsed(arm_i, ident.name),
);
}
}
@@ -552,14 +552,25 @@
// We are trying to avoid reporting this error if other related errors were reported.
if res != Res::Err && inner_attr && !self.tcx.features().custom_inner_attributes {
- let msg = match res {
- Res::Def(..) => "inner macro attributes are unstable",
- Res::NonMacroAttr(..) => "custom inner attributes are unstable",
+ let is_macro = match res {
+ Res::Def(..) => true,
+ Res::NonMacroAttr(..) => false,
_ => unreachable!(),
};
if soft_custom_inner_attributes_gate {
- self.tcx.sess.psess.buffer_lint(SOFT_UNSTABLE, path.span, node_id, msg);
+ self.tcx.sess.psess.buffer_lint(
+ SOFT_UNSTABLE,
+ path.span,
+ node_id,
+ BuiltinLintDiag::InnerAttributeUnstable { is_macro },
+ );
} else {
+ // FIXME: deduplicate with rustc_lint (`BuiltinLintDiag::InnerAttributeUnstable`)
+ let msg = if is_macro {
+ "inner macro attributes are unstable"
+ } else {
+ "custom inner attributes are unstable"
+ };
feature_err(&self.tcx.sess, sym::custom_inner_attributes, path.span, msg).emit();
}
}
@@ -567,22 +578,20 @@
if res == Res::NonMacroAttr(NonMacroAttrKind::Tool)
&& let [namespace, attribute, ..] = &*path.segments
&& namespace.ident.name == sym::diagnostic
- && attribute.ident.name != sym::on_unimplemented
+ && !(attribute.ident.name == sym::on_unimplemented
+ || (attribute.ident.name == sym::do_not_recommend
+ && self.tcx.features().do_not_recommend))
{
let distance =
edit_distance(attribute.ident.name.as_str(), sym::on_unimplemented.as_str(), 5);
- let help = if distance.is_some() {
- BuiltinLintDiag::MaybeTypo { span: attribute.span(), name: sym::on_unimplemented }
- } else {
- BuiltinLintDiag::Normal
- };
- self.tcx.sess.psess.buffer_lint_with_diagnostic(
+ let typo_name = distance.map(|_| sym::on_unimplemented);
+
+ self.tcx.sess.psess.buffer_lint(
UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
attribute.span(),
node_id,
- "unknown diagnostic attribute",
- help,
+ BuiltinLintDiag::UnknownDiagnosticAttribute { span: attribute.span(), typo_name },
);
}
@@ -782,11 +791,10 @@
.invocation_parents
.get(&parent_scope.expansion)
.map_or(ast::CRATE_NODE_ID, |id| self.def_id_to_node_id[id.0]);
- self.lint_buffer.buffer_lint_with_diagnostic(
+ self.lint_buffer.buffer_lint(
LEGACY_DERIVE_HELPERS,
node_id,
ident.span,
- "derive helper attribute is used before it is introduced",
BuiltinLintDiag::LegacyDeriveHelpers(binding.span),
);
}
@@ -836,8 +844,17 @@
let allowed_by_implication = implied_by.is_some_and(|feature| is_allowed(feature));
if !is_allowed(feature) && !allowed_by_implication {
let lint_buffer = &mut self.lint_buffer;
- let soft_handler =
- |lint, span, msg: String| lint_buffer.buffer_lint(lint, node_id, span, msg);
+ let soft_handler = |lint, span, msg: String| {
+ lint_buffer.buffer_lint(
+ lint,
+ node_id,
+ span,
+ BuiltinLintDiag::UnstableFeature(
+ // FIXME make this translatable
+ msg.into(),
+ ),
+ )
+ };
stability::report_unstable(
self.tcx.sess,
feature,
@@ -853,14 +870,12 @@
}
if let Some(depr) = &ext.deprecation {
let path = pprust::path_to_string(path);
- let (message, lint) = stability::deprecation_message_and_lint(depr, "macro", &path);
- stability::early_report_deprecation(
+ stability::early_report_macro_deprecation(
&mut self.lint_buffer,
- message,
- depr.suggestion,
- lint,
+ depr,
span,
node_id,
+ path,
);
}
}
diff --git a/compiler/rustc_serialize/src/opaque.rs b/compiler/rustc_serialize/src/opaque.rs
index eec83c02..1dcb699 100644
--- a/compiler/rustc_serialize/src/opaque.rs
+++ b/compiler/rustc_serialize/src/opaque.rs
@@ -17,6 +17,8 @@
pub type FileEncodeResult = Result<usize, (PathBuf, io::Error)>;
+pub const MAGIC_END_BYTES: &[u8] = b"rust-end-file";
+
/// The size of the buffer in `FileEncoder`.
const BUF_SIZE: usize = 8192;
@@ -181,6 +183,7 @@
}
pub fn finish(&mut self) -> FileEncodeResult {
+ self.write_all(MAGIC_END_BYTES);
self.flush();
#[cfg(debug_assertions)]
{
@@ -261,15 +264,18 @@
impl<'a> MemDecoder<'a> {
#[inline]
- pub fn new(data: &'a [u8], position: usize) -> MemDecoder<'a> {
+ pub fn new(data: &'a [u8], position: usize) -> Result<MemDecoder<'a>, ()> {
+ let data = data.strip_suffix(MAGIC_END_BYTES).ok_or(())?;
let Range { start, end } = data.as_ptr_range();
- MemDecoder { start, current: data[position..].as_ptr(), end, _marker: PhantomData }
+ Ok(MemDecoder { start, current: data[position..].as_ptr(), end, _marker: PhantomData })
}
#[inline]
- pub fn data(&self) -> &'a [u8] {
- // SAFETY: This recovers the original slice, only using members we never modify.
- unsafe { std::slice::from_raw_parts(self.start, self.len()) }
+ pub fn split_at(&self, position: usize) -> MemDecoder<'a> {
+ assert!(position <= self.len());
+ // SAFETY: We checked above that this offset is within the original slice
+ let current = unsafe { self.start.add(position) };
+ MemDecoder { start: self.start, current, end: self.end, _marker: PhantomData }
}
#[inline]
diff --git a/compiler/rustc_serialize/tests/leb128.rs b/compiler/rustc_serialize/tests/leb128.rs
index dc9b32a..fafe4b9 100644
--- a/compiler/rustc_serialize/tests/leb128.rs
+++ b/compiler/rustc_serialize/tests/leb128.rs
@@ -1,4 +1,6 @@
use rustc_serialize::leb128::*;
+use rustc_serialize::opaque::MemDecoder;
+use rustc_serialize::opaque::MAGIC_END_BYTES;
use rustc_serialize::Decoder;
macro_rules! impl_test_unsigned_leb128 {
@@ -25,13 +27,15 @@
let n = $write_fn_name(&mut buf, x);
stream.extend(&buf[..n]);
}
+ let stream_end = stream.len();
+ stream.extend(MAGIC_END_BYTES);
- let mut decoder = rustc_serialize::opaque::MemDecoder::new(&stream, 0);
+ let mut decoder = MemDecoder::new(&stream, 0).unwrap();
for &expected in &values {
let actual = $read_fn_name(&mut decoder);
assert_eq!(expected, actual);
}
- assert_eq!(stream.len(), decoder.position());
+ assert_eq!(stream_end, decoder.position());
}
};
}
@@ -72,13 +76,15 @@
let n = $write_fn_name(&mut buf, x);
stream.extend(&buf[..n]);
}
+ let stream_end = stream.len();
+ stream.extend(MAGIC_END_BYTES);
- let mut decoder = rustc_serialize::opaque::MemDecoder::new(&stream, 0);
+ let mut decoder = MemDecoder::new(&stream, 0).unwrap();
for &expected in &values {
let actual = $read_fn_name(&mut decoder);
assert_eq!(expected, actual);
}
- assert_eq!(stream.len(), decoder.position());
+ assert_eq!(stream_end, decoder.position());
}
};
}
diff --git a/compiler/rustc_serialize/tests/opaque.rs b/compiler/rustc_serialize/tests/opaque.rs
index 45ff85f..833151d 100644
--- a/compiler/rustc_serialize/tests/opaque.rs
+++ b/compiler/rustc_serialize/tests/opaque.rs
@@ -42,7 +42,7 @@
encoder.finish().unwrap();
let data = fs::read(&tmpfile).unwrap();
- let mut decoder = MemDecoder::new(&data[..], 0);
+ let mut decoder = MemDecoder::new(&data[..], 0).unwrap();
for value in values {
let decoded = Decodable::decode(&mut decoder);
assert_eq!(value, decoded);
diff --git a/compiler/rustc_session/src/parse.rs b/compiler/rustc_session/src/parse.rs
index f6053f4..df07f81 100644
--- a/compiler/rustc_session/src/parse.rs
+++ b/compiler/rustc_session/src/parse.rs
@@ -305,32 +305,12 @@
lint: &'static Lint,
span: impl Into<MultiSpan>,
node_id: NodeId,
- msg: impl Into<DiagMessage>,
- ) {
- self.buffered_lints.with_lock(|buffered_lints| {
- buffered_lints.push(BufferedEarlyLint {
- span: span.into(),
- node_id,
- msg: msg.into(),
- lint_id: LintId::of(lint),
- diagnostic: BuiltinLintDiag::Normal,
- });
- });
- }
-
- pub fn buffer_lint_with_diagnostic(
- &self,
- lint: &'static Lint,
- span: impl Into<MultiSpan>,
- node_id: NodeId,
- msg: impl Into<DiagMessage>,
diagnostic: BuiltinLintDiag,
) {
self.buffered_lints.with_lock(|buffered_lints| {
buffered_lints.push(BufferedEarlyLint {
span: span.into(),
node_id,
- msg: msg.into(),
lint_id: LintId::of(lint),
diagnostic,
});
diff --git a/compiler/rustc_session/src/version.rs b/compiler/rustc_session/src/version.rs
index 39e4541..e244c77 100644
--- a/compiler/rustc_session/src/version.rs
+++ b/compiler/rustc_session/src/version.rs
@@ -1,5 +1,10 @@
use rustc_macros::{current_rustc_version, Decodable, Encodable, HashStable_Generic};
-use std::fmt::{self, Display};
+use std::{
+ borrow::Cow,
+ fmt::{self, Display},
+};
+
+use rustc_errors::IntoDiagArg;
#[derive(Encodable, Decodable, Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[derive(HashStable_Generic)]
@@ -18,3 +23,9 @@
write!(formatter, "{}.{}.{}", self.major, self.minor, self.patch)
}
}
+
+impl IntoDiagArg for RustcVersion {
+ fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
+ rustc_errors::DiagArgValue::Str(Cow::Owned(self.to_string()))
+ }
+}
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
index 1544798..be20924 100644
--- a/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
+++ b/compiler/rustc_smir/src/rustc_smir/convert/ty.rs
@@ -707,12 +707,11 @@
}
}
-impl<'tcx, A, B, U, V> Stable<'tcx> for ty::OutlivesPredicate<A, B>
+impl<'tcx, T> Stable<'tcx> for ty::OutlivesPredicate<'tcx, T>
where
- A: Stable<'tcx, T = U>,
- B: Stable<'tcx, T = V>,
+ T: Stable<'tcx>,
{
- type T = stable_mir::ty::OutlivesPredicate<U, V>;
+ type T = stable_mir::ty::OutlivesPredicate<T::T, Region>;
fn stable(&self, tables: &mut Tables<'_>) -> Self::T {
let ty::OutlivesPredicate(a, b) = self;
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill.rs b/compiler/rustc_trait_selection/src/solve/fulfill.rs
index 4933080..7291eb0 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill.rs
@@ -380,7 +380,10 @@
source: CandidateSource::Impl(impl_def_id),
result: _,
} = candidate.kind()
- && goal.infcx().tcx.has_attr(impl_def_id, sym::do_not_recommend)
+ && goal
+ .infcx()
+ .tcx
+ .has_attrs_with_path(impl_def_id, &[sym::diagnostic, sym::do_not_recommend])
{
return ControlFlow::Break(self.obligation.clone());
}
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
index f9b6b28..6c56ebb 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs
@@ -47,7 +47,8 @@
use crate::traits::error_reporting::type_err_ctxt_ext::InferCtxtPrivExt;
use crate::traits::query::evaluate_obligation::InferCtxtExt as _;
use rustc_middle::ty::print::{
- with_forced_trimmed_paths, with_no_trimmed_paths, PrintTraitPredicateExt as _,
+ with_forced_trimmed_paths, with_no_trimmed_paths, PrintPolyTraitPredicateExt as _,
+ PrintTraitPredicateExt as _,
};
use itertools::EitherOrBoth;
diff --git a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
index 20dfb5e..494fca0 100644
--- a/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
+++ b/compiler/rustc_trait_selection/src/traits/error_reporting/type_err_ctxt_ext.rs
@@ -1012,7 +1012,10 @@
let mut base_cause = obligation.cause.code().clone();
loop {
if let ObligationCauseCode::ImplDerived(ref c) = base_cause {
- if self.tcx.has_attr(c.impl_or_alias_def_id, sym::do_not_recommend) {
+ if self.tcx.has_attrs_with_path(
+ c.impl_or_alias_def_id,
+ &[sym::diagnostic, sym::do_not_recommend],
+ ) {
let code = (*c.derived.parent_code).clone();
obligation.cause.map_code(|_| code);
obligation.predicate = c.derived.parent_trait_pred.upcast(self.tcx);
diff --git a/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs b/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs
index f7e84a4..00cc77e 100644
--- a/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/type_op/implied_outlives_bounds.rs
@@ -162,8 +162,7 @@
let mut checked_wf_args = rustc_data_structures::fx::FxHashSet::default();
let mut wf_args = vec![ty.into()];
- let mut outlives_bounds: Vec<ty::OutlivesPredicate<ty::GenericArg<'tcx>, ty::Region<'tcx>>> =
- vec![];
+ let mut outlives_bounds: Vec<ty::OutlivesPredicate<'tcx, ty::GenericArg<'tcx>>> = vec![];
while let Some(arg) = wf_args.pop() {
if !checked_wf_args.insert(arg) {
diff --git a/compiler/rustc_type_ir/src/binder.rs b/compiler/rustc_type_ir/src/binder.rs
new file mode 100644
index 0000000..5336b91
--- /dev/null
+++ b/compiler/rustc_type_ir/src/binder.rs
@@ -0,0 +1,340 @@
+use std::fmt::Debug;
+use std::hash::Hash;
+use std::ops::{ControlFlow, Deref};
+
+#[cfg(feature = "nightly")]
+use rustc_macros::HashStable_NoContext;
+use rustc_serialize::Decodable;
+
+use crate::fold::{FallibleTypeFolder, TypeFoldable, TypeSuperFoldable};
+use crate::inherent::*;
+use crate::lift::Lift;
+use crate::visit::{Flags, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor};
+use crate::{self as ty, Interner, SsoHashSet};
+
+/// Binder is a binder for higher-ranked lifetimes or types. It is part of the
+/// compiler's representation for things like `for<'a> Fn(&'a isize)`
+/// (which would be represented by the type `PolyTraitRef ==
+/// Binder<I, TraitRef>`). Note that when we instantiate,
+/// erase, or otherwise "discharge" these bound vars, we change the
+/// type from `Binder<I, T>` to just `T` (see
+/// e.g., `liberate_late_bound_regions`).
+///
+/// `Decodable` and `Encodable` are implemented for `Binder<T>` using the `impl_binder_encode_decode!` macro.
+#[derive(derivative::Derivative)]
+#[derivative(
+ Clone(bound = "T: Clone"),
+ Copy(bound = "T: Copy"),
+ Hash(bound = "T: Hash"),
+ PartialEq(bound = "T: PartialEq"),
+ Eq(bound = "T: Eq"),
+ Debug(bound = "T: Debug")
+)]
+#[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
+pub struct Binder<I: Interner, T> {
+ value: T,
+ bound_vars: I::BoundVarKinds,
+}
+
+// FIXME: We manually derive `Lift` because the `derive(Lift_Generic)` doesn't
+// understand how to turn `T` to `T::Lifted` in the output `type Lifted`.
+impl<I: Interner, U: Interner, T> Lift<U> for Binder<I, T>
+where
+ T: Lift<U>,
+ I::BoundVarKinds: Lift<U, Lifted = U::BoundVarKinds>,
+{
+ type Lifted = Binder<U, T::Lifted>;
+
+ fn lift_to_tcx(self, tcx: U) -> Option<Self::Lifted> {
+ Some(Binder {
+ value: self.value.lift_to_tcx(tcx)?,
+ bound_vars: self.bound_vars.lift_to_tcx(tcx)?,
+ })
+ }
+}
+
+macro_rules! impl_binder_encode_decode {
+ ($($t:ty),+ $(,)?) => {
+ $(
+ impl<I: Interner, E: crate::TyEncoder<I = I>> rustc_serialize::Encodable<E> for ty::Binder<I, $t>
+ where
+ $t: rustc_serialize::Encodable<E>,
+ I::BoundVarKinds: rustc_serialize::Encodable<E>,
+ {
+ fn encode(&self, e: &mut E) {
+ self.bound_vars().encode(e);
+ self.as_ref().skip_binder().encode(e);
+ }
+ }
+ impl<I: Interner, D: crate::TyDecoder<I = I>> Decodable<D> for ty::Binder<I, $t>
+ where
+ $t: TypeVisitable<I> + rustc_serialize::Decodable<D>,
+ I::BoundVarKinds: rustc_serialize::Decodable<D>,
+ {
+ fn decode(decoder: &mut D) -> Self {
+ let bound_vars = Decodable::decode(decoder);
+ ty::Binder::bind_with_vars(<$t>::decode(decoder), bound_vars)
+ }
+ }
+ )*
+ }
+}
+
+impl_binder_encode_decode! {
+ ty::FnSig<I>,
+ ty::TraitPredicate<I>,
+ ty::ExistentialPredicate<I>,
+ ty::TraitRef<I>,
+ ty::ExistentialTraitRef<I>,
+}
+
+impl<I: Interner, T> Binder<I, T>
+where
+ T: TypeVisitable<I>,
+{
+ /// Wraps `value` in a binder, asserting that `value` does not
+ /// contain any bound vars that would be bound by the
+ /// binder. This is commonly used to 'inject' a value T into a
+ /// different binding level.
+ #[track_caller]
+ pub fn dummy(value: T) -> Binder<I, T> {
+ assert!(
+ !value.has_escaping_bound_vars(),
+ "`{value:?}` has escaping bound vars, so it cannot be wrapped in a dummy binder."
+ );
+ Binder { value, bound_vars: Default::default() }
+ }
+
+ pub fn bind_with_vars(value: T, bound_vars: I::BoundVarKinds) -> Binder<I, T> {
+ if cfg!(debug_assertions) {
+ let mut validator = ValidateBoundVars::new(bound_vars);
+ value.visit_with(&mut validator);
+ }
+ Binder { value, bound_vars }
+ }
+}
+
+impl<I: Interner, T: TypeFoldable<I>> TypeFoldable<I> for Binder<I, T> {
+ fn try_fold_with<F: FallibleTypeFolder<I>>(self, folder: &mut F) -> Result<Self, F::Error> {
+ folder.try_fold_binder(self)
+ }
+}
+
+impl<I: Interner, T: TypeVisitable<I>> TypeVisitable<I> for Binder<I, T> {
+ fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> V::Result {
+ visitor.visit_binder(self)
+ }
+}
+
+impl<I: Interner, T: TypeFoldable<I>> TypeSuperFoldable<I> for Binder<I, T> {
+ fn try_super_fold_with<F: FallibleTypeFolder<I>>(
+ self,
+ folder: &mut F,
+ ) -> Result<Self, F::Error> {
+ self.try_map_bound(|ty| ty.try_fold_with(folder))
+ }
+}
+
+impl<I: Interner, T: TypeVisitable<I>> TypeSuperVisitable<I> for Binder<I, T> {
+ fn super_visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> V::Result {
+ self.as_ref().skip_binder().visit_with(visitor)
+ }
+}
+
+impl<I: Interner, T> Binder<I, T> {
+ /// Skips the binder and returns the "bound" value. This is a
+ /// risky thing to do because it's easy to get confused about
+ /// De Bruijn indices and the like. It is usually better to
+ /// discharge the binder using `no_bound_vars` or
+ /// `instantiate_bound_regions` or something like
+ /// that. `skip_binder` is only valid when you are either
+ /// extracting data that has nothing to do with bound vars, you
+ /// are doing some sort of test that does not involve bound
+ /// regions, or you are being very careful about your depth
+ /// accounting.
+ ///
+ /// Some examples where `skip_binder` is reasonable:
+ ///
+ /// - extracting the `DefId` from a PolyTraitRef;
+ /// - comparing the self type of a PolyTraitRef to see if it is equal to
+ /// a type parameter `X`, since the type `X` does not reference any regions
+ pub fn skip_binder(self) -> T {
+ self.value
+ }
+
+ pub fn bound_vars(&self) -> I::BoundVarKinds {
+ self.bound_vars
+ }
+
+ pub fn as_ref(&self) -> Binder<I, &T> {
+ Binder { value: &self.value, bound_vars: self.bound_vars }
+ }
+
+ pub fn as_deref(&self) -> Binder<I, &T::Target>
+ where
+ T: Deref,
+ {
+ Binder { value: &self.value, bound_vars: self.bound_vars }
+ }
+
+ pub fn map_bound_ref<F, U: TypeVisitable<I>>(&self, f: F) -> Binder<I, U>
+ where
+ F: FnOnce(&T) -> U,
+ {
+ self.as_ref().map_bound(f)
+ }
+
+ pub fn map_bound<F, U: TypeVisitable<I>>(self, f: F) -> Binder<I, U>
+ where
+ F: FnOnce(T) -> U,
+ {
+ let Binder { value, bound_vars } = self;
+ let value = f(value);
+ if cfg!(debug_assertions) {
+ let mut validator = ValidateBoundVars::new(bound_vars);
+ value.visit_with(&mut validator);
+ }
+ Binder { value, bound_vars }
+ }
+
+ pub fn try_map_bound<F, U: TypeVisitable<I>, E>(self, f: F) -> Result<Binder<I, U>, E>
+ where
+ F: FnOnce(T) -> Result<U, E>,
+ {
+ let Binder { value, bound_vars } = self;
+ let value = f(value)?;
+ if cfg!(debug_assertions) {
+ let mut validator = ValidateBoundVars::new(bound_vars);
+ value.visit_with(&mut validator);
+ }
+ Ok(Binder { value, bound_vars })
+ }
+
+ /// Wraps a `value` in a binder, using the same bound variables as the
+ /// current `Binder`. This should not be used if the new value *changes*
+ /// the bound variables. Note: the (old or new) value itself does not
+ /// necessarily need to *name* all the bound variables.
+ ///
+ /// This currently doesn't do anything different than `bind`, because we
+ /// don't actually track bound vars. However, semantically, it is different
+ /// because bound vars aren't allowed to change here, whereas they are
+ /// in `bind`. This may be (debug) asserted in the future.
+ pub fn rebind<U>(&self, value: U) -> Binder<I, U>
+ where
+ U: TypeVisitable<I>,
+ {
+ Binder::bind_with_vars(value, self.bound_vars)
+ }
+
+ /// Unwraps and returns the value within, but only if it contains
+ /// no bound vars at all. (In other words, if this binder --
+ /// and indeed any enclosing binder -- doesn't bind anything at
+ /// all.) Otherwise, returns `None`.
+ ///
+ /// (One could imagine having a method that just unwraps a single
+ /// binder, but permits late-bound vars bound by enclosing
+ /// binders, but that would require adjusting the debruijn
+ /// indices, and given the shallow binding structure we often use,
+ /// would not be that useful.)
+ pub fn no_bound_vars(self) -> Option<T>
+ where
+ T: TypeVisitable<I>,
+ {
+ // `self.value` is equivalent to `self.skip_binder()`
+ if self.value.has_escaping_bound_vars() { None } else { Some(self.skip_binder()) }
+ }
+
+ /// Splits the contents into two things that share the same binder
+ /// level as the original, returning two distinct binders.
+ ///
+ /// `f` should consider bound regions at depth 1 to be free, and
+ /// anything it produces with bound regions at depth 1 will be
+ /// bound in the resulting return values.
+ pub fn split<U, V, F>(self, f: F) -> (Binder<I, U>, Binder<I, V>)
+ where
+ F: FnOnce(T) -> (U, V),
+ {
+ let Binder { value, bound_vars } = self;
+ let (u, v) = f(value);
+ (Binder { value: u, bound_vars }, Binder { value: v, bound_vars })
+ }
+}
+
+impl<I: Interner, T> Binder<I, Option<T>> {
+ pub fn transpose(self) -> Option<Binder<I, T>> {
+ let Binder { value, bound_vars } = self;
+ value.map(|value| Binder { value, bound_vars })
+ }
+}
+
+impl<I: Interner, T: IntoIterator> Binder<I, T> {
+ pub fn iter(self) -> impl Iterator<Item = Binder<I, T::Item>> {
+ let Binder { value, bound_vars } = self;
+ value.into_iter().map(move |value| Binder { value, bound_vars })
+ }
+}
+
+pub struct ValidateBoundVars<I: Interner> {
+ bound_vars: I::BoundVarKinds,
+ binder_index: ty::DebruijnIndex,
+ // We may encounter the same variable at different levels of binding, so
+ // this can't just be `Ty`
+ visited: SsoHashSet<(ty::DebruijnIndex, I::Ty)>,
+}
+
+impl<I: Interner> ValidateBoundVars<I> {
+ pub fn new(bound_vars: I::BoundVarKinds) -> Self {
+ ValidateBoundVars {
+ bound_vars,
+ binder_index: ty::INNERMOST,
+ visited: SsoHashSet::default(),
+ }
+ }
+}
+
+impl<I: Interner> TypeVisitor<I> for ValidateBoundVars<I> {
+ type Result = ControlFlow<()>;
+
+ fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &Binder<I, T>) -> Self::Result {
+ self.binder_index.shift_in(1);
+ let result = t.super_visit_with(self);
+ self.binder_index.shift_out(1);
+ result
+ }
+
+ fn visit_ty(&mut self, t: I::Ty) -> Self::Result {
+ if t.outer_exclusive_binder() < self.binder_index
+ || !self.visited.insert((self.binder_index, t))
+ {
+ return ControlFlow::Break(());
+ }
+ match t.kind() {
+ ty::Bound(debruijn, bound_ty) if debruijn == self.binder_index => {
+ let idx = bound_ty.var().as_usize();
+ if self.bound_vars.len() <= idx {
+ panic!("Not enough bound vars: {:?} not found in {:?}", t, self.bound_vars);
+ }
+ bound_ty.assert_eq(self.bound_vars[idx]);
+ }
+ _ => {}
+ };
+
+ t.super_visit_with(self)
+ }
+
+ fn visit_region(&mut self, r: I::Region) -> Self::Result {
+ match r.kind() {
+ ty::ReBound(index, br) if index == self.binder_index => {
+ let idx = br.var().as_usize();
+ if self.bound_vars.len() <= idx {
+ panic!("Not enough bound vars: {:?} not found in {:?}", r, self.bound_vars);
+ }
+ br.assert_eq(self.bound_vars[idx]);
+ }
+
+ _ => (),
+ };
+
+ ControlFlow::Continue(())
+ }
+}
diff --git a/compiler/rustc_type_ir/src/const_kind.rs b/compiler/rustc_type_ir/src/const_kind.rs
index af07e9f..7076df2 100644
--- a/compiler/rustc_type_ir/src/const_kind.rs
+++ b/compiler/rustc_type_ir/src/const_kind.rs
@@ -5,7 +5,7 @@
use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic};
use std::fmt;
-use crate::{DebruijnIndex, DebugWithInfcx, InferCtxtLike, Interner, WithInfcx};
+use crate::{self as ty, DebruijnIndex, DebugWithInfcx, InferCtxtLike, Interner, WithInfcx};
use self::ConstKind::*;
@@ -29,7 +29,7 @@
/// An unnormalized const item such as an anon const or assoc const or free const item.
/// Right now anything other than anon consts does not actually work properly but this
/// should
- Unevaluated(I::AliasConst),
+ Unevaluated(ty::UnevaluatedConst<I>),
/// Used to hold computed value.
Value(I::ValueConst),
diff --git a/compiler/rustc_type_ir/src/fold.rs b/compiler/rustc_type_ir/src/fold.rs
index 01bb3d7..405aba3 100644
--- a/compiler/rustc_type_ir/src/fold.rs
+++ b/compiler/rustc_type_ir/src/fold.rs
@@ -48,8 +48,8 @@
use rustc_index::{Idx, IndexVec};
use std::mem;
-use crate::Lrc;
-use crate::{visit::TypeVisitable, Interner};
+use crate::visit::TypeVisitable;
+use crate::{self as ty, Interner, Lrc};
#[cfg(feature = "nightly")]
type Never = !;
@@ -128,10 +128,9 @@
pub trait TypeFolder<I: Interner>: FallibleTypeFolder<I, Error = Never> {
fn interner(&self) -> I;
- fn fold_binder<T>(&mut self, t: I::Binder<T>) -> I::Binder<T>
+ fn fold_binder<T>(&mut self, t: ty::Binder<I, T>) -> ty::Binder<I, T>
where
T: TypeFoldable<I>,
- I::Binder<T>: TypeSuperFoldable<I>,
{
t.super_fold_with(self)
}
@@ -167,10 +166,9 @@
fn interner(&self) -> I;
- fn try_fold_binder<T>(&mut self, t: I::Binder<T>) -> Result<I::Binder<T>, Self::Error>
+ fn try_fold_binder<T>(&mut self, t: ty::Binder<I, T>) -> Result<ty::Binder<I, T>, Self::Error>
where
T: TypeFoldable<I>,
- I::Binder<T>: TypeSuperFoldable<I>,
{
t.try_super_fold_with(self)
}
@@ -206,10 +204,9 @@
TypeFolder::interner(self)
}
- fn try_fold_binder<T>(&mut self, t: I::Binder<T>) -> Result<I::Binder<T>, Never>
+ fn try_fold_binder<T>(&mut self, t: ty::Binder<I, T>) -> Result<ty::Binder<I, T>, Never>
where
T: TypeFoldable<I>,
- I::Binder<T>: TypeSuperFoldable<I>,
{
Ok(self.fold_binder(t))
}
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index f66c6e7..77fe30a 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -8,11 +8,8 @@
use std::ops::Deref;
use crate::fold::{TypeFoldable, TypeSuperFoldable};
-use crate::visit::{Flags, TypeSuperVisitable};
-use crate::{
- AliasTy, AliasTyKind, BoundVar, ConstKind, ConstVid, DebruijnIndex, DebugWithInfcx, InferConst,
- InferTy, Interner, RegionKind, TyKind, TyVid, UnevaluatedConst, UniverseIndex,
-};
+use crate::visit::{Flags, TypeSuperVisitable, TypeVisitable};
+use crate::{self as ty, DebugWithInfcx, Interner, UpcastFrom};
pub trait Ty<I: Interner<Ty = Self>>:
Copy
@@ -21,24 +18,30 @@
+ Eq
+ Into<I::GenericArg>
+ Into<I::Term>
- + IntoKind<Kind = TyKind<I>>
+ + IntoKind<Kind = ty::TyKind<I>>
+ TypeSuperVisitable<I>
+ TypeSuperFoldable<I>
+ Flags
{
fn new_bool(interner: I) -> Self;
- fn new_infer(interner: I, var: InferTy) -> Self;
+ fn new_infer(interner: I, var: ty::InferTy) -> Self;
- fn new_var(interner: I, var: TyVid) -> Self;
+ fn new_var(interner: I, var: ty::TyVid) -> Self;
- fn new_anon_bound(interner: I, debruijn: DebruijnIndex, var: BoundVar) -> Self;
+ fn new_anon_bound(interner: I, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self;
- fn new_alias(interner: I, kind: AliasTyKind, alias_ty: AliasTy<I>) -> Self;
+ fn new_alias(interner: I, kind: ty::AliasTyKind, alias_ty: ty::AliasTy<I>) -> Self;
}
pub trait Tys<I: Interner<Tys = Self>>:
- Copy + Debug + Hash + Eq + IntoIterator<Item = I::Ty> + Deref<Target: Deref<Target = [I::Ty]>>
+ Copy
+ + Debug
+ + Hash
+ + Eq
+ + IntoIterator<Item = I::Ty>
+ + Deref<Target: Deref<Target = [I::Ty]>>
+ + TypeVisitable<I>
{
fn split_inputs_and_output(self) -> (I::FnInputTys, I::Ty);
}
@@ -49,13 +52,21 @@
}
pub trait Safety<I: Interner<Safety = Self>>: Copy + Debug + Hash + Eq {
+ fn is_safe(self) -> bool;
+
fn prefix_str(self) -> &'static str;
}
pub trait Region<I: Interner<Region = Self>>:
- Copy + DebugWithInfcx<I> + Hash + Eq + Into<I::GenericArg> + IntoKind<Kind = RegionKind<I>> + Flags
+ Copy
+ + DebugWithInfcx<I>
+ + Hash
+ + Eq
+ + Into<I::GenericArg>
+ + IntoKind<Kind = ty::RegionKind<I>>
+ + Flags
{
- fn new_anon_bound(interner: I, debruijn: DebruijnIndex, var: BoundVar) -> Self;
+ fn new_anon_bound(interner: I, debruijn: ty::DebruijnIndex, var: ty::BoundVar) -> Self;
fn new_static(interner: I) -> Self;
}
@@ -67,18 +78,23 @@
+ Eq
+ Into<I::GenericArg>
+ Into<I::Term>
- + IntoKind<Kind = ConstKind<I>>
+ + IntoKind<Kind = ty::ConstKind<I>>
+ TypeSuperVisitable<I>
+ TypeSuperFoldable<I>
+ Flags
{
- fn new_infer(interner: I, var: InferConst, ty: I::Ty) -> Self;
+ fn new_infer(interner: I, var: ty::InferConst, ty: I::Ty) -> Self;
- fn new_var(interner: I, var: ConstVid, ty: I::Ty) -> Self;
+ fn new_var(interner: I, var: ty::ConstVid, ty: I::Ty) -> Self;
- fn new_anon_bound(interner: I, debruijn: DebruijnIndex, var: BoundVar, ty: I::Ty) -> Self;
+ fn new_anon_bound(
+ interner: I,
+ debruijn: ty::DebruijnIndex,
+ var: ty::BoundVar,
+ ty: I::Ty,
+ ) -> Self;
- fn new_unevaluated(interner: I, uv: UnevaluatedConst<I>, ty: I::Ty) -> Self;
+ fn new_unevaluated(interner: I, uv: ty::UnevaluatedConst<I>, ty: I::Ty) -> Self;
fn ty(self) -> I::Ty;
}
@@ -100,6 +116,12 @@
fn type_at(self, i: usize) -> I::Ty;
fn identity_for_item(interner: I, def_id: I::DefId) -> I::GenericArgs;
+
+ fn extend_with_error(
+ tcx: I,
+ def_id: I::DefId,
+ original_args: &[I::GenericArg],
+ ) -> I::GenericArgs;
}
pub trait Predicate<I: Interner<Predicate = Self>>:
@@ -108,14 +130,25 @@
fn is_coinductive(self, interner: I) -> bool;
}
+pub trait Clause<I: Interner<Clause = Self>>:
+ Copy
+ + Debug
+ + Hash
+ + Eq
+ // FIXME: Remove these, uplift the `Upcast` impls.
+ + UpcastFrom<I, ty::Binder<I, ty::TraitRef<I>>>
+ + UpcastFrom<I, ty::Binder<I, ty::ProjectionPredicate<I>>>
+{
+}
+
/// Common capabilities of placeholder kinds
pub trait PlaceholderLike: Copy + Debug + Hash + Eq {
- fn universe(self) -> UniverseIndex;
- fn var(self) -> BoundVar;
+ fn universe(self) -> ty::UniverseIndex;
+ fn var(self) -> ty::BoundVar;
- fn with_updated_universe(self, ui: UniverseIndex) -> Self;
+ fn with_updated_universe(self, ui: ty::UniverseIndex) -> Self;
- fn new(ui: UniverseIndex, var: BoundVar) -> Self;
+ fn new(ui: ty::UniverseIndex, var: ty::BoundVar) -> Self;
}
pub trait IntoKind {
@@ -124,12 +157,8 @@
fn kind(self) -> Self::Kind;
}
-pub trait BoundVars<I: Interner> {
- fn bound_vars(&self) -> I::BoundVars;
-
- fn has_no_bound_vars(&self) -> bool;
-}
-
pub trait BoundVarLike<I: Interner> {
- fn var(self) -> BoundVar;
+ fn var(self) -> ty::BoundVar;
+
+ fn assert_eq(self, var: I::BoundVarKind);
}
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index 6516d5b..9b8bb21 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -28,19 +28,28 @@
+ IrPrint<CoercePredicate<Self>>
+ IrPrint<FnSig<Self>>
{
- type DefId: Copy + Debug + Hash + Eq;
+ type DefId: Copy + Debug + Hash + Eq + TypeVisitable<Self>;
type AdtDef: Copy + Debug + Hash + Eq;
type GenericArgs: GenericArgs<Self>;
/// The slice of args for a specific item. For a GAT like `type Foo<'a>`, it will be `['a]`,
/// not including the args from the parent item (trait or impl).
type OwnItemArgs: Copy + Debug + Hash + Eq;
- type GenericArg: Copy + DebugWithInfcx<Self> + Hash + Eq + IntoKind<Kind = GenericArgKind<Self>>;
- type Term: Copy + Debug + Hash + Eq + IntoKind<Kind = TermKind<Self>>;
+ type GenericArg: Copy
+ + DebugWithInfcx<Self>
+ + Hash
+ + Eq
+ + IntoKind<Kind = GenericArgKind<Self>>
+ + TypeVisitable<Self>;
+ type Term: Copy + Debug + Hash + Eq + IntoKind<Kind = TermKind<Self>> + TypeVisitable<Self>;
- type Binder<T: TypeVisitable<Self>>: BoundVars<Self> + TypeSuperVisitable<Self>;
- type BoundVars: IntoIterator<Item = Self::BoundVar>;
- type BoundVar;
+ type BoundVarKinds: Copy
+ + Debug
+ + Hash
+ + Eq
+ + Deref<Target: Deref<Target = [Self::BoundVarKind]>>
+ + Default;
+ type BoundVarKind: Copy + Debug + Hash + Eq;
type CanonicalVars: Copy + Debug + Hash + Eq + IntoIterator<Item = CanonicalVarInfo<Self>>;
type PredefinedOpaques: Copy + Debug + Hash + Eq;
@@ -51,7 +60,7 @@
// Kinds of tys
type Ty: Ty<Self>;
type Tys: Tys<Self>;
- type FnInputTys: Copy + Debug + Hash + Eq + Deref<Target = [Self::Ty]>;
+ type FnInputTys: Copy + Debug + Hash + Eq + Deref<Target = [Self::Ty]> + TypeVisitable<Self>;
type ParamTy: Copy + Debug + Hash + Eq;
type BoundTy: Copy + Debug + Hash + Eq + BoundVarLike<Self>;
type PlaceholderTy: PlaceholderLike;
@@ -67,7 +76,6 @@
// Kinds of consts
type Const: Const<Self>;
- type AliasConst: Copy + DebugWithInfcx<Self> + Hash + Eq;
type PlaceholderConst: PlaceholderLike;
type ParamConst: Copy + Debug + Hash + Eq;
type BoundConst: Copy + Debug + Hash + Eq + BoundVarLike<Self>;
@@ -84,14 +92,7 @@
// Predicates
type ParamEnv: Copy + Debug + Hash + Eq;
type Predicate: Predicate<Self>;
- type TraitPredicate: Copy + Debug + Hash + Eq;
- type RegionOutlivesPredicate: Copy + Debug + Hash + Eq;
- type TypeOutlivesPredicate: Copy + Debug + Hash + Eq;
- type ProjectionPredicate: Copy + Debug + Hash + Eq;
- type NormalizesTo: Copy + Debug + Hash + Eq;
- type SubtypePredicate: Copy + Debug + Hash + Eq;
- type CoercePredicate: Copy + Debug + Hash + Eq;
- type ClosureKind: Copy + Debug + Hash + Eq;
+ type Clause: Clause<Self>;
type Clauses: Copy + Debug + Hash + Eq + TypeSuperVisitable<Self> + Flags;
fn mk_canonical_var_infos(self, infos: &[CanonicalVarInfo<Self>]) -> Self::CanonicalVars;
diff --git a/compiler/rustc_type_ir/src/ir_print.rs b/compiler/rustc_type_ir/src/ir_print.rs
index af4b9ee..d57d081 100644
--- a/compiler/rustc_type_ir/src/ir_print.rs
+++ b/compiler/rustc_type_ir/src/ir_print.rs
@@ -1,8 +1,9 @@
use std::fmt;
use crate::{
- AliasTerm, AliasTy, CoercePredicate, ExistentialProjection, ExistentialTraitRef, FnSig,
- Interner, NormalizesTo, ProjectionPredicate, SubtypePredicate, TraitPredicate, TraitRef,
+ AliasTerm, AliasTy, Binder, CoercePredicate, ExistentialProjection, ExistentialTraitRef, FnSig,
+ Interner, NormalizesTo, OutlivesPredicate, ProjectionPredicate, SubtypePredicate,
+ TraitPredicate, TraitRef,
};
pub trait IrPrint<T> {
@@ -22,6 +23,15 @@
}
}
+impl<I: Interner, T> fmt::Display for Binder<I, T>
+where
+ I: IrPrint<Binder<I, T>>,
+{
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ <I as IrPrint<Binder<I, T>>>::print(self, fmt)
+ }
+}
+
macro_rules! define_debug_via_print {
($($ty:ident),+ $(,)?) => {
$(
@@ -49,3 +59,12 @@
);
define_debug_via_print!(TraitRef, ExistentialTraitRef, ExistentialProjection);
+
+impl<I: Interner, T> fmt::Display for OutlivesPredicate<I, T>
+where
+ I: IrPrint<OutlivesPredicate<I, T>>,
+{
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ <I as IrPrint<OutlivesPredicate<I, T>>>::print(self, fmt)
+ }
+}
diff --git a/compiler/rustc_type_ir/src/lib.rs b/compiler/rustc_type_ir/src/lib.rs
index fa9bda9..4a461b5 100644
--- a/compiler/rustc_type_ir/src/lib.rs
+++ b/compiler/rustc_type_ir/src/lib.rs
@@ -9,9 +9,13 @@
extern crate self as rustc_type_ir;
#[cfg(feature = "nightly")]
+use rustc_data_structures::sso::SsoHashSet;
+#[cfg(feature = "nightly")]
use rustc_data_structures::sync::Lrc;
#[cfg(feature = "nightly")]
use rustc_macros::{Decodable, Encodable, HashStable_NoContext};
+#[cfg(not(feature = "nightly"))]
+use std::collections::HashSet as SsoHashSet;
use std::fmt;
use std::hash::Hash;
#[cfg(not(feature = "nightly"))]
@@ -31,6 +35,7 @@
#[macro_use]
mod macros;
+mod binder;
mod canonical;
mod const_kind;
mod debug;
@@ -43,6 +48,7 @@
mod region_kind;
mod upcast;
+pub use binder::*;
pub use canonical::*;
#[cfg(feature = "nightly")]
pub use codec::*;
@@ -374,6 +380,10 @@
fn var(self) -> BoundVar {
self
}
+
+ fn assert_eq(self, _var: I::BoundVarKind) {
+ unreachable!("FIXME: We really should have a separate `BoundConst` for consts")
+ }
}
/// Represents the various closure traits in the language. This
diff --git a/compiler/rustc_type_ir/src/predicate.rs b/compiler/rustc_type_ir/src/predicate.rs
index c0619d7..4e12c6b 100644
--- a/compiler/rustc_type_ir/src/predicate.rs
+++ b/compiler/rustc_type_ir/src/predicate.rs
@@ -6,10 +6,38 @@
use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic};
use crate::inherent::*;
+use crate::lift::Lift;
+use crate::upcast::Upcast;
use crate::visit::TypeVisitableExt as _;
-use crate::{
- AliasTy, AliasTyKind, DebugWithInfcx, InferCtxtLike, Interner, UnevaluatedConst, WithInfcx,
-};
+use crate::{self as ty, DebugWithInfcx, InferCtxtLike, Interner, WithInfcx};
+
+/// `A: 'region`
+#[derive(derivative::Derivative)]
+#[derivative(
+ Clone(bound = "A: Clone"),
+ Copy(bound = "A: Copy"),
+ Hash(bound = "A: Hash"),
+ PartialEq(bound = "A: PartialEq"),
+ Eq(bound = "A: Eq"),
+ Debug(bound = "A: fmt::Debug")
+)]
+#[derive(TypeVisitable_Generic, TypeFoldable_Generic)]
+#[cfg_attr(feature = "nightly", derive(TyDecodable, TyEncodable, HashStable_NoContext))]
+pub struct OutlivesPredicate<I: Interner, A>(pub A, pub I::Region);
+
+// FIXME: We manually derive `Lift` because the `derive(Lift_Generic)` doesn't
+// understand how to turn `A` to `A::Lifted` in the output `type Lifted`.
+impl<I: Interner, U: Interner, A> Lift<U> for OutlivesPredicate<I, A>
+where
+ A: Lift<U>,
+ I::Region: Lift<U, Lifted = U::Region>,
+{
+ type Lifted = OutlivesPredicate<U, A::Lifted>;
+
+ fn lift_to_tcx(self, tcx: U) -> Option<Self::Lifted> {
+ Some(OutlivesPredicate(self.0.lift_to_tcx(tcx)?, self.1.lift_to_tcx(tcx)?))
+ }
+}
/// A complete reference to a trait. These take numerous guises in syntax,
/// but perhaps the most recognizable form is in a where-clause:
@@ -75,6 +103,16 @@
}
}
+impl<I: Interner> ty::Binder<I, TraitRef<I>> {
+ pub fn self_ty(&self) -> ty::Binder<I, I::Ty> {
+ self.map_bound_ref(|tr| tr.self_ty())
+ }
+
+ pub fn def_id(&self) -> I::DefId {
+ self.skip_binder().def_id
+ }
+}
+
#[derive(derivative::Derivative)]
#[derivative(
Clone(bound = ""),
@@ -112,6 +150,22 @@
}
}
+impl<I: Interner> ty::Binder<I, TraitPredicate<I>> {
+ pub fn def_id(self) -> I::DefId {
+ // Ok to skip binder since trait `DefId` does not care about regions.
+ self.skip_binder().def_id()
+ }
+
+ pub fn self_ty(self) -> ty::Binder<I, I::Ty> {
+ self.map_bound(|trait_ref| trait_ref.self_ty())
+ }
+
+ #[inline]
+ pub fn polarity(self) -> PredicatePolarity {
+ self.skip_binder().polarity
+ }
+}
+
impl<I: Interner> fmt::Debug for TraitPredicate<I> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
// FIXME(effects) printing?
@@ -204,6 +258,34 @@
}
}
+impl<I: Interner> ty::Binder<I, ExistentialPredicate<I>> {
+ /// Given an existential predicate like `?Self: PartialEq<u32>` (e.g., derived from `dyn PartialEq<u32>`),
+ /// and a concrete type `self_ty`, returns a full predicate where the existentially quantified variable `?Self`
+ /// has been replaced with `self_ty` (e.g., `self_ty: PartialEq<u32>`, in our example).
+ pub fn with_self_ty(&self, tcx: I, self_ty: I::Ty) -> I::Clause {
+ match self.skip_binder() {
+ ExistentialPredicate::Trait(tr) => {
+ self.rebind(tr).with_self_ty(tcx, self_ty).upcast(tcx)
+ }
+ ExistentialPredicate::Projection(p) => {
+ self.rebind(p.with_self_ty(tcx, self_ty)).upcast(tcx)
+ }
+ ExistentialPredicate::AutoTrait(did) => {
+ let generics = tcx.generics_of(did);
+ let trait_ref = if generics.count() == 1 {
+ ty::TraitRef::new(tcx, did, [self_ty])
+ } else {
+ // If this is an ill-formed auto trait, then synthesize
+ // new error args for the missing generics.
+ let err_args = GenericArgs::extend_with_error(tcx, did, &[self_ty.into()]);
+ ty::TraitRef::new(tcx, did, err_args)
+ };
+ self.rebind(trait_ref).upcast(tcx)
+ }
+ }
+ }
+}
+
/// An existential reference to a trait, where `Self` is erased.
/// For example, the trait object `Trait<'a, 'b, X, Y>` is:
/// ```ignore (illustrative)
@@ -253,6 +335,20 @@
}
}
+impl<I: Interner> ty::Binder<I, ExistentialTraitRef<I>> {
+ pub fn def_id(&self) -> I::DefId {
+ self.skip_binder().def_id
+ }
+
+ /// Object types don't have a self type specified. Therefore, when
+ /// we convert the principal trait-ref into a normal trait-ref,
+ /// you must give *some* self type. A common choice is `mk_err()`
+ /// or some placeholder type.
+ pub fn with_self_ty(&self, tcx: I, self_ty: I::Ty) -> ty::Binder<I, TraitRef<I>> {
+ self.map_bound(|trait_ref| trait_ref.with_self_ty(tcx, self_ty))
+ }
+}
+
/// A `ProjectionPredicate` for an `ExistentialTraitRef`.
#[derive(derivative::Derivative)]
#[derivative(
@@ -308,6 +404,16 @@
}
}
+impl<I: Interner> ty::Binder<I, ExistentialProjection<I>> {
+ pub fn with_self_ty(&self, tcx: I, self_ty: I::Ty) -> ty::Binder<I, ProjectionPredicate<I>> {
+ self.map_bound(|p| p.with_self_ty(tcx, self_ty))
+ }
+
+ pub fn item_def_id(&self) -> I::DefId {
+ self.skip_binder().def_id
+ }
+}
+
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
#[cfg_attr(feature = "nightly", derive(Encodable, Decodable, HashStable_NoContext))]
pub enum AliasTermKind {
@@ -414,7 +520,7 @@
AliasTerm { def_id, args, _use_alias_term_new_instead: () }
}
- pub fn expect_ty(self, interner: I) -> AliasTy<I> {
+ pub fn expect_ty(self, interner: I) -> ty::AliasTy<I> {
match self.kind(interner) {
AliasTermKind::ProjectionTy
| AliasTermKind::InherentTy
@@ -424,7 +530,7 @@
panic!("Cannot turn `UnevaluatedConst` into `AliasTy`")
}
}
- AliasTy { def_id: self.def_id, args: self.args, _use_alias_ty_new_instead: () }
+ ty::AliasTy { def_id: self.def_id, args: self.args, _use_alias_ty_new_instead: () }
}
pub fn kind(self, interner: I) -> AliasTermKind {
@@ -435,32 +541,32 @@
match self.kind(interner) {
AliasTermKind::ProjectionTy => Ty::new_alias(
interner,
- AliasTyKind::Projection,
- AliasTy { def_id: self.def_id, args: self.args, _use_alias_ty_new_instead: () },
+ ty::AliasTyKind::Projection,
+ ty::AliasTy { def_id: self.def_id, args: self.args, _use_alias_ty_new_instead: () },
)
.into(),
AliasTermKind::InherentTy => Ty::new_alias(
interner,
- AliasTyKind::Inherent,
- AliasTy { def_id: self.def_id, args: self.args, _use_alias_ty_new_instead: () },
+ ty::AliasTyKind::Inherent,
+ ty::AliasTy { def_id: self.def_id, args: self.args, _use_alias_ty_new_instead: () },
)
.into(),
AliasTermKind::OpaqueTy => Ty::new_alias(
interner,
- AliasTyKind::Opaque,
- AliasTy { def_id: self.def_id, args: self.args, _use_alias_ty_new_instead: () },
+ ty::AliasTyKind::Opaque,
+ ty::AliasTy { def_id: self.def_id, args: self.args, _use_alias_ty_new_instead: () },
)
.into(),
AliasTermKind::WeakTy => Ty::new_alias(
interner,
- AliasTyKind::Weak,
- AliasTy { def_id: self.def_id, args: self.args, _use_alias_ty_new_instead: () },
+ ty::AliasTyKind::Weak,
+ ty::AliasTy { def_id: self.def_id, args: self.args, _use_alias_ty_new_instead: () },
)
.into(),
AliasTermKind::UnevaluatedConst | AliasTermKind::ProjectionConst => {
I::Const::new_unevaluated(
interner,
- UnevaluatedConst::new(self.def_id, self.args),
+ ty::UnevaluatedConst::new(self.def_id, self.args),
interner.type_of_instantiated(self.def_id, self.args),
)
.into()
@@ -514,14 +620,14 @@
}
}
-impl<I: Interner> From<AliasTy<I>> for AliasTerm<I> {
- fn from(ty: AliasTy<I>) -> Self {
+impl<I: Interner> From<ty::AliasTy<I>> for AliasTerm<I> {
+ fn from(ty: ty::AliasTy<I>) -> Self {
AliasTerm { args: ty.args, def_id: ty.def_id, _use_alias_term_new_instead: () }
}
}
-impl<I: Interner> From<UnevaluatedConst<I>> for AliasTerm<I> {
- fn from(ct: UnevaluatedConst<I>) -> Self {
+impl<I: Interner> From<ty::UnevaluatedConst<I>> for AliasTerm<I> {
+ fn from(ct: ty::UnevaluatedConst<I>) -> Self {
AliasTerm { args: ct.args, def_id: ct.def, _use_alias_term_new_instead: () }
}
}
@@ -571,6 +677,40 @@
}
}
+impl<I: Interner> ty::Binder<I, ProjectionPredicate<I>> {
+ /// Returns the `DefId` of the trait of the associated item being projected.
+ #[inline]
+ pub fn trait_def_id(&self, tcx: I) -> I::DefId {
+ self.skip_binder().projection_term.trait_def_id(tcx)
+ }
+
+ /// Get the trait ref required for this projection to be well formed.
+ /// Note that for generic associated types the predicates of the associated
+ /// type also need to be checked.
+ #[inline]
+ pub fn required_poly_trait_ref(&self, tcx: I) -> ty::Binder<I, TraitRef<I>> {
+ // Note: unlike with `TraitRef::to_poly_trait_ref()`,
+ // `self.0.trait_ref` is permitted to have escaping regions.
+ // This is because here `self` has a `Binder` and so does our
+ // return value, so we are preserving the number of binding
+ // levels.
+ self.map_bound(|predicate| predicate.projection_term.trait_ref(tcx))
+ }
+
+ pub fn term(&self) -> ty::Binder<I, I::Term> {
+ self.map_bound(|predicate| predicate.term)
+ }
+
+ /// The `DefId` of the `TraitItem` for the associated type.
+ ///
+ /// Note that this is not the `DefId` of the `TraitRef` containing this
+ /// associated type, which is in `tcx.associated_item(projection_def_id()).container`.
+ pub fn projection_def_id(&self) -> I::DefId {
+ // Ok to skip binder since trait `DefId` does not care about regions.
+ self.skip_binder().projection_term.def_id
+ }
+}
+
impl<I: Interner> fmt::Debug for ProjectionPredicate<I> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "ProjectionPredicate({:?}, {:?})", self.projection_term, self.term)
diff --git a/compiler/rustc_type_ir/src/predicate_kind.rs b/compiler/rustc_type_ir/src/predicate_kind.rs
index c477ab1..efe270e 100644
--- a/compiler/rustc_type_ir/src/predicate_kind.rs
+++ b/compiler/rustc_type_ir/src/predicate_kind.rs
@@ -3,7 +3,7 @@
use rustc_type_ir_macros::{TypeFoldable_Generic, TypeVisitable_Generic};
use std::fmt;
-use crate::Interner;
+use crate::{self as ty, Interner};
/// A clause is something that can appear in where bounds or be inferred
/// by implied bounds.
@@ -15,17 +15,17 @@
/// Corresponds to `where Foo: Bar<A, B, C>`. `Foo` here would be
/// the `Self` type of the trait reference and `A`, `B`, and `C`
/// would be the type parameters.
- Trait(I::TraitPredicate),
+ Trait(ty::TraitPredicate<I>),
- /// `where 'a: 'b`
- RegionOutlives(I::RegionOutlivesPredicate),
+ /// `where 'a: 'r`
+ RegionOutlives(ty::OutlivesPredicate<I, I::Region>),
- /// `where T: 'a`
- TypeOutlives(I::TypeOutlivesPredicate),
+ /// `where T: 'r`
+ TypeOutlives(ty::OutlivesPredicate<I, I::Ty>),
/// `where <T as TraitRef>::Name == X`, approximately.
/// See the `ProjectionPredicate` struct for details.
- Projection(I::ProjectionPredicate),
+ Projection(ty::ProjectionPredicate<I>),
/// Ensures that a const generic argument to a parameter `const N: u8`
/// is of type `u8`.
@@ -75,7 +75,7 @@
/// This obligation is created most often when we have two
/// unresolved type variables and hence don't have enough
/// information to process the subtyping obligation yet.
- Subtype(I::SubtypePredicate),
+ Subtype(ty::SubtypePredicate<I>),
/// `T1` coerced to `T2`
///
@@ -85,7 +85,7 @@
/// obligation yet. At the moment, we actually process coercions
/// very much like subtyping and don't handle the full coercion
/// logic.
- Coerce(I::CoercePredicate),
+ Coerce(ty::CoercePredicate<I>),
/// Constants must be equal. The first component is the const that is expected.
ConstEquate(I::Const, I::Const),
@@ -102,7 +102,7 @@
/// `T as Trait>::Assoc`, `Projection(<T as Trait>::Assoc, ?x)` constrains `?x`
/// to `<T as Trait>::Assoc` while `NormalizesTo(<T as Trait>::Assoc, ?x)`
/// results in `NoSolution`.
- NormalizesTo(I::NormalizesTo),
+ NormalizesTo(ty::NormalizesTo<I>),
/// Separate from `ClauseKind::Projection` which is used for normalization in new solver.
/// This predicate requires two terms to be equal to eachother.
diff --git a/compiler/rustc_type_ir/src/ty_kind.rs b/compiler/rustc_type_ir/src/ty_kind.rs
index 629ea9f..38082bf 100644
--- a/compiler/rustc_type_ir/src/ty_kind.rs
+++ b/compiler/rustc_type_ir/src/ty_kind.rs
@@ -8,7 +8,7 @@
use std::fmt;
use crate::inherent::*;
-use crate::{DebruijnIndex, DebugWithInfcx, InferCtxtLike, Interner, TraitRef, WithInfcx};
+use crate::{self as ty, DebruijnIndex, DebugWithInfcx, InferCtxtLike, Interner, WithInfcx};
use self::TyKind::*;
@@ -514,7 +514,7 @@
/// For example, if this is a projection of `<T as StreamingIterator>::Item<'a>`,
/// then this function would return a `T: StreamingIterator` trait reference and
/// `['a]` as the own args.
- pub fn trait_ref_and_own_args(self, interner: I) -> (TraitRef<I>, I::OwnItemArgs) {
+ pub fn trait_ref_and_own_args(self, interner: I) -> (ty::TraitRef<I>, I::OwnItemArgs) {
debug_assert_eq!(self.kind(interner), AliasTyKind::Projection);
interner.trait_ref_and_own_args_for_alias(self.def_id, self.args)
}
@@ -526,7 +526,7 @@
/// WARNING: This will drop the args for generic associated types
/// consider calling [Self::trait_ref_and_own_args] to get those
/// as well.
- pub fn trait_ref(self, interner: I) -> TraitRef<I> {
+ pub fn trait_ref(self, interner: I) -> ty::TraitRef<I> {
self.trait_ref_and_own_args(interner).0
}
}
@@ -982,6 +982,49 @@
pub fn output(self) -> I::Ty {
self.split_inputs_and_output().1
}
+
+ pub fn is_fn_trait_compatible(self) -> bool {
+ let FnSig { safety, abi, c_variadic, .. } = self;
+ !c_variadic && safety.is_safe() && abi.is_rust()
+ }
+}
+
+impl<I: Interner> ty::Binder<I, FnSig<I>> {
+ #[inline]
+ pub fn inputs(self) -> ty::Binder<I, I::FnInputTys> {
+ self.map_bound(|fn_sig| fn_sig.inputs())
+ }
+
+ #[inline]
+ #[track_caller]
+ pub fn input(self, index: usize) -> ty::Binder<I, I::Ty> {
+ self.map_bound(|fn_sig| fn_sig.inputs()[index])
+ }
+
+ pub fn inputs_and_output(self) -> ty::Binder<I, I::Tys> {
+ self.map_bound(|fn_sig| fn_sig.inputs_and_output)
+ }
+
+ #[inline]
+ pub fn output(self) -> ty::Binder<I, I::Ty> {
+ self.map_bound(|fn_sig| fn_sig.output())
+ }
+
+ pub fn c_variadic(self) -> bool {
+ self.skip_binder().c_variadic
+ }
+
+ pub fn safety(self) -> I::Safety {
+ self.skip_binder().safety
+ }
+
+ pub fn abi(self) -> I::Abi {
+ self.skip_binder().abi
+ }
+
+ pub fn is_fn_trait_compatible(&self) -> bool {
+ self.skip_binder().is_fn_trait_compatible()
+ }
}
impl<I: Interner> fmt::Debug for FnSig<I> {
diff --git a/compiler/rustc_type_ir/src/visit.rs b/compiler/rustc_type_ir/src/visit.rs
index 3d4125f..6880c7b 100644
--- a/compiler/rustc_type_ir/src/visit.rs
+++ b/compiler/rustc_type_ir/src/visit.rs
@@ -90,7 +90,7 @@
#[cfg(not(feature = "nightly"))]
type Result: VisitorResult;
- fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &I::Binder<T>) -> Self::Result {
+ fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
t.super_visit_with(self)
}
@@ -376,11 +376,11 @@
impl<I: Interner> TypeVisitor<I> for HasTypeFlagsVisitor {
type Result = ControlFlow<FoundFlags>;
- fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &I::Binder<T>) -> Self::Result {
+ fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
// If we're looking for the HAS_BINDER_VARS flag, check if the
// binder has vars. This won't be present in the binder's bound
// value, so we need to check here too.
- if self.flags.intersects(TypeFlags::HAS_BINDER_VARS) && !t.has_no_bound_vars() {
+ if self.flags.intersects(TypeFlags::HAS_BINDER_VARS) && !t.bound_vars().is_empty() {
return ControlFlow::Break(FoundFlags);
}
@@ -476,7 +476,7 @@
impl<I: Interner> TypeVisitor<I> for HasEscapingVarsVisitor {
type Result = ControlFlow<FoundEscapingVars>;
- fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &I::Binder<T>) -> Self::Result {
+ fn visit_binder<T: TypeVisitable<I>>(&mut self, t: &ty::Binder<I, T>) -> Self::Result {
self.outer_index.shift_in(1);
let result = t.super_visit_with(self);
self.outer_index.shift_out(1);
diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs
index d58e1db..8e468a8 100644
--- a/library/core/src/intrinsics.rs
+++ b/library/core/src/intrinsics.rs
@@ -1483,10 +1483,10 @@
///
/// # Safety
///
- /// Both the starting and resulting pointer must be either in bounds or one
- /// byte past the end of an allocated object. If either pointer is out of
- /// bounds or arithmetic overflow occurs then any further use of the
- /// returned value will result in undefined behavior.
+ /// If the computed offset is non-zero, then both the starting and resulting pointer must be
+ /// either in bounds or at the end of an allocated object. If either pointer is out
+ /// of bounds or arithmetic overflow occurs then any further use of the returned value will
+ /// result in undefined behavior.
///
/// The stabilized version of this intrinsic is [`pointer::offset`].
#[must_use = "returns a new pointer rather than modifying its argument"]
@@ -1502,7 +1502,7 @@
/// # Safety
///
/// Unlike the `offset` intrinsic, this intrinsic does not restrict the
- /// resulting pointer to point into or one byte past the end of an allocated
+ /// resulting pointer to point into or at the end of an allocated
/// object, and it wraps with two's complement arithmetic. The resulting
/// value is not necessarily valid to be used to actually access memory.
///
diff --git a/library/core/src/primitive_docs.rs b/library/core/src/primitive_docs.rs
index 8283fdc..5989bcb 100644
--- a/library/core/src/primitive_docs.rs
+++ b/library/core/src/primitive_docs.rs
@@ -1476,14 +1476,17 @@
///
/// For instance, this means that unsafe code in a safe function may assume these invariants are
/// ensured of arguments passed by the caller, and it may assume that these invariants are ensured
-/// of return values from any safe functions it calls. In most cases, the inverse is also true:
-/// unsafe code must not violate these invariants when passing arguments to safe functions or
-/// returning values from safe functions; such violations may result in undefined behavior. Where
-/// exceptions to this latter requirement exist, they will be called out explicitly in documentation.
+/// of return values from any safe functions it calls.
+///
+/// For the other direction, things are more complicated: when unsafe code passes arguments
+/// to safe functions or returns values from safe functions, they generally must *at least*
+/// not violate these invariants. The full requirements are stronger, as the reference generally
+/// must point to data that is safe to use at type `T`.
///
/// It is not decided yet whether unsafe code may violate these invariants temporarily on internal
/// data. As a consequence, unsafe code which violates these invariants temporarily on internal data
-/// may become unsound in future versions of Rust depending on how this question is decided.
+/// may be unsound or become unsound in future versions of Rust depending on how this question is
+/// decided.
///
/// [allocated object]: ptr#allocated-object
#[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/core/src/ptr/const_ptr.rs b/library/core/src/ptr/const_ptr.rs
index 73bb256..c8065b2 100644
--- a/library/core/src/ptr/const_ptr.rs
+++ b/library/core/src/ptr/const_ptr.rs
@@ -465,8 +465,9 @@
/// If any of the following conditions are violated, the result is Undefined
/// Behavior:
///
- /// * Both the starting and resulting pointer must be either in bounds or one
- /// byte past the end of the same [allocated object].
+ /// * If the computed offset, **in bytes**, is non-zero, then both the starting and resulting
+ /// pointer must be either in bounds or at the end of the same [allocated object].
+ /// (If it is zero, then the function is always well-defined.)
///
/// * The computed offset, **in bytes**, cannot overflow an `isize`.
///
@@ -676,11 +677,11 @@
/// If any of the following conditions are violated, the result is Undefined
/// Behavior:
///
- /// * Both `self` and `origin` must be either in bounds or one
- /// byte past the end of the same [allocated object].
+ /// * `self` and `origin` must either
///
- /// * Both pointers must be *derived from* a pointer to the same object.
- /// (See below for an example.)
+ /// * both be *derived from* a pointer to the same [allocated object], and the memory range between
+ /// the two pointers must be either empty or in bounds of that object. (See below for an example.)
+ /// * or both be derived from an integer literal/constant, and point to the same address.
///
/// * The distance between the pointers, in bytes, must be an exact multiple
/// of the size of `T`.
@@ -951,8 +952,9 @@
/// If any of the following conditions are violated, the result is Undefined
/// Behavior:
///
- /// * Both the starting and resulting pointer must be either in bounds or one
- /// byte past the end of the same [allocated object].
+ /// * If the computed offset, **in bytes**, is non-zero, then both the starting and resulting
+ /// pointer must be either in bounds or at the end of the same [allocated object].
+ /// (If it is zero, then the function is always well-defined.)
///
/// * The computed offset, **in bytes**, cannot overflow an `isize`.
///
@@ -1035,8 +1037,9 @@
/// If any of the following conditions are violated, the result is Undefined
/// Behavior:
///
- /// * Both the starting and resulting pointer must be either in bounds or one
- /// byte past the end of the same [allocated object].
+ /// * If the computed offset, **in bytes**, is non-zero, then both the starting and resulting
+ /// pointer must be either in bounds or at the end of the same [allocated object].
+ /// (If it is zero, then the function is always well-defined.)
///
/// * The computed offset cannot exceed `isize::MAX` **bytes**.
///
diff --git a/library/core/src/ptr/mod.rs b/library/core/src/ptr/mod.rs
index f87b6bb..d2bbdc8 100644
--- a/library/core/src/ptr/mod.rs
+++ b/library/core/src/ptr/mod.rs
@@ -15,18 +15,13 @@
//! The precise rules for validity are not determined yet. The guarantees that are
//! provided at this point are very minimal:
//!
-//! * A [null] pointer is *never* valid, not even for accesses of [size zero][zst].
+//! * For operations of [size zero][zst], *every* pointer is valid, including the [null] pointer.
+//! The following points are only concerned with non-zero-sized accesses.
+//! * A [null] pointer is *never* valid.
//! * For a pointer to be valid, it is necessary, but not always sufficient, that the pointer
//! be *dereferenceable*: the memory range of the given size starting at the pointer must all be
//! within the bounds of a single allocated object. Note that in Rust,
//! every (stack-allocated) variable is considered a separate allocated object.
-//! * Even for operations of [size zero][zst], the pointer must not be pointing to deallocated
-//! memory, i.e., deallocation makes pointers invalid even for zero-sized operations. However,
-//! casting any non-zero integer *literal* to a pointer is valid for zero-sized accesses, even if
-//! some memory happens to exist at that address and gets deallocated. This corresponds to writing
-//! your own allocator: allocating zero-sized objects is not very hard. The canonical way to
-//! obtain a pointer that is valid for zero-sized accesses is [`NonNull::dangling`].
-//FIXME: mention `ptr::dangling` above, once it is stable.
//! * All accesses performed by functions in this module are *non-atomic* in the sense
//! of [atomic operations] used to synchronize between threads. This means it is
//! undefined behavior to perform two concurrent accesses to the same location from different
diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs
index 7856a1d..c539534 100644
--- a/library/core/src/ptr/mut_ptr.rs
+++ b/library/core/src/ptr/mut_ptr.rs
@@ -480,8 +480,9 @@
/// If any of the following conditions are violated, the result is Undefined
/// Behavior:
///
- /// * Both the starting and resulting pointer must be either in bounds or one
- /// byte past the end of the same [allocated object].
+ /// * If the computed offset, **in bytes**, is non-zero, then both the starting and resulting
+ /// pointer must be either in bounds or at the end of the same [allocated object].
+ /// (If it is zero, then the function is always well-defined.)
///
/// * The computed offset, **in bytes**, cannot overflow an `isize`.
///
@@ -904,11 +905,11 @@
/// If any of the following conditions are violated, the result is Undefined
/// Behavior:
///
- /// * Both `self` and `origin` must be either in bounds or one
- /// byte past the end of the same [allocated object].
+ /// * `self` and `origin` must either
///
- /// * Both pointers must be *derived from* a pointer to the same object.
- /// (See below for an example.)
+ /// * both be *derived from* a pointer to the same [allocated object], and the memory range between
+ /// the two pointers must be either empty or in bounds of that object. (See below for an example.)
+ /// * or both be derived from an integer literal/constant, and point to the same address.
///
/// * The distance between the pointers, in bytes, must be an exact multiple
/// of the size of `T`.
@@ -1095,8 +1096,9 @@
/// If any of the following conditions are violated, the result is Undefined
/// Behavior:
///
- /// * Both the starting and resulting pointer must be either in bounds or one
- /// byte past the end of the same [allocated object].
+ /// * If the computed offset, **in bytes**, is non-zero, then both the starting and resulting
+ /// pointer must be either in bounds or at the end of the same [allocated object].
+ /// (If it is zero, then the function is always well-defined.)
///
/// * The computed offset, **in bytes**, cannot overflow an `isize`.
///
@@ -1179,8 +1181,9 @@
/// If any of the following conditions are violated, the result is Undefined
/// Behavior:
///
- /// * Both the starting and resulting pointer must be either in bounds or one
- /// byte past the end of the same [allocated object].
+ /// * If the computed offset, **in bytes**, is non-zero, then both the starting and resulting
+ /// pointer must be either in bounds or at the end of the same [allocated object].
+ /// (If it is zero, then the function is always well-defined.)
///
/// * The computed offset cannot exceed `isize::MAX` **bytes**.
///
diff --git a/src/librustdoc/scrape_examples.rs b/src/librustdoc/scrape_examples.rs
index 9c9b386..e9b380f 100644
--- a/src/librustdoc/scrape_examples.rs
+++ b/src/librustdoc/scrape_examples.rs
@@ -344,7 +344,9 @@
Ok(bytes) => bytes,
Err(e) => dcx.fatal(format!("failed to load examples: {e}")),
};
- let mut decoder = MemDecoder::new(&bytes, 0);
+ let Ok(mut decoder) = MemDecoder::new(&bytes, 0) else {
+ dcx.fatal(format!("Corrupt metadata encountered in {path}"))
+ };
let calls = AllCallLocations::decode(&mut decoder);
for (function, fn_calls) in calls.into_iter() {
diff --git a/src/tools/cargo b/src/tools/cargo
index 0de7f2e..84dc5dc 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 0de7f2ec6c39d68022e6b97a39559d2f4dbf3930
+Subproject commit 84dc5dc11a9007a08f27170454da6097265e510e
diff --git a/src/tools/clippy/.github/driver.sh b/src/tools/clippy/.github/driver.sh
index 2eafdd0..09202b1 100755
--- a/src/tools/clippy/.github/driver.sh
+++ b/src/tools/clippy/.github/driver.sh
@@ -2,15 +2,18 @@
set -ex
-# Check sysroot handling
-sysroot=$(./target/debug/clippy-driver --print sysroot)
-test "$sysroot" = "$(rustc --print sysroot)"
+sysroot="$(rustc --print sysroot)"
+case $OS in
+ Linux) export LD_LIBRARY_PATH="$sysroot/lib" ;;
+ macOS) export DYLD_FALLBACK_LIBRARY_PATH="$sysroot/lib" ;;
+ Windows) export PATH="$(cygpath "$sysroot")/bin:$PATH" ;;
+ *) exit 1
+esac
-if [[ ${OS} == "Windows" ]]; then
- desired_sysroot=C:/tmp
-else
- desired_sysroot=/tmp
-fi
+# Check sysroot handling
+test "$(./target/debug/clippy-driver --print sysroot)" = "$sysroot"
+
+desired_sysroot="target/sysroot"
# Set --sysroot in command line
sysroot=$(./target/debug/clippy-driver --sysroot $desired_sysroot --print sysroot)
test "$sysroot" = $desired_sysroot
diff --git a/src/tools/clippy/.github/workflows/clippy.yml b/src/tools/clippy/.github/workflows/clippy.yml
index 8179e3e..06bf3b6 100644
--- a/src/tools/clippy/.github/workflows/clippy.yml
+++ b/src/tools/clippy/.github/workflows/clippy.yml
@@ -69,6 +69,6 @@
working-directory: clippy_dev
- name: Test clippy-driver
- run: |
- TOOLCHAIN=$(rustup show active-toolchain | cut -f1 -d' ')
- rustup run $TOOLCHAIN bash .github/driver.sh
+ run: .github/driver.sh
+ env:
+ OS: ${{ runner.os }}
diff --git a/src/tools/clippy/.github/workflows/clippy_bors.yml b/src/tools/clippy/.github/workflows/clippy_bors.yml
index 9451598..1f4bec9 100644
--- a/src/tools/clippy/.github/workflows/clippy_bors.yml
+++ b/src/tools/clippy/.github/workflows/clippy_bors.yml
@@ -116,9 +116,7 @@
working-directory: clippy_dev
- name: Test clippy-driver
- run: |
- TOOLCHAIN=$(rustup show active-toolchain | cut -f1 -d' ')
- rustup run $TOOLCHAIN bash .github/driver.sh
+ run: .github/driver.sh
env:
OS: ${{ runner.os }}
diff --git a/src/tools/clippy/CHANGELOG.md b/src/tools/clippy/CHANGELOG.md
index 9c9ea11..d5115f7 100644
--- a/src/tools/clippy/CHANGELOG.md
+++ b/src/tools/clippy/CHANGELOG.md
@@ -5249,6 +5249,7 @@
[`disallowed_type`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_type
[`disallowed_types`]: https://rust-lang.github.io/rust-clippy/master/index.html#disallowed_types
[`diverging_sub_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#diverging_sub_expression
+[`doc_lazy_continuation`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_lazy_continuation
[`doc_link_with_quotes`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_link_with_quotes
[`doc_markdown`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
[`double_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#double_comparisons
@@ -5447,6 +5448,7 @@
[`little_endian_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#little_endian_bytes
[`logic_bug`]: https://rust-lang.github.io/rust-clippy/master/index.html#logic_bug
[`lossy_float_literal`]: https://rust-lang.github.io/rust-clippy/master/index.html#lossy_float_literal
+[`macro_metavars_in_unsafe`]: https://rust-lang.github.io/rust-clippy/master/index.html#macro_metavars_in_unsafe
[`macro_use_imports`]: https://rust-lang.github.io/rust-clippy/master/index.html#macro_use_imports
[`main_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#main_recursion
[`manual_assert`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_assert
@@ -5702,6 +5704,7 @@
[`ref_option_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_option_ref
[`ref_patterns`]: https://rust-lang.github.io/rust-clippy/master/index.html#ref_patterns
[`regex_macro`]: https://rust-lang.github.io/rust-clippy/master/index.html#regex_macro
+[`renamed_function_params`]: https://rust-lang.github.io/rust-clippy/master/index.html#renamed_function_params
[`repeat_once`]: https://rust-lang.github.io/rust-clippy/master/index.html#repeat_once
[`repeat_vec_with_capacity`]: https://rust-lang.github.io/rust-clippy/master/index.html#repeat_vec_with_capacity
[`replace_consts`]: https://rust-lang.github.io/rust-clippy/master/index.html#replace_consts
@@ -5908,6 +5911,7 @@
[`verbose_file_reads`]: https://rust-lang.github.io/rust-clippy/master/index.html#verbose_file_reads
[`vtable_address_comparisons`]: https://rust-lang.github.io/rust-clippy/master/index.html#vtable_address_comparisons
[`waker_clone_wake`]: https://rust-lang.github.io/rust-clippy/master/index.html#waker_clone_wake
+[`while_float`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_float
[`while_immutable_condition`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_immutable_condition
[`while_let_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_let_loop
[`while_let_on_iterator`]: https://rust-lang.github.io/rust-clippy/master/index.html#while_let_on_iterator
@@ -5939,8 +5943,10 @@
[`allow-expect-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-expect-in-tests
[`allow-mixed-uninlined-format-args`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-mixed-uninlined-format-args
[`allow-one-hash-in-raw-strings`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-one-hash-in-raw-strings
+[`allow-panic-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-panic-in-tests
[`allow-print-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-print-in-tests
[`allow-private-module-inception`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-private-module-inception
+[`allow-renamed-params-for`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-renamed-params-for
[`allow-unwrap-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-unwrap-in-tests
[`allow-useless-vec-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-useless-vec-in-tests
[`allowed-dotfiles`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allowed-dotfiles
@@ -6002,4 +6008,5 @@
[`vec-box-size-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#vec-box-size-threshold
[`verbose-bit-mask-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#verbose-bit-mask-threshold
[`warn-on-all-wildcard-imports`]: https://doc.rust-lang.org/clippy/lint_configuration.html#warn-on-all-wildcard-imports
+[`warn-unsafe-macro-metavars-in-private-macros`]: https://doc.rust-lang.org/clippy/lint_configuration.html#warn-unsafe-macro-metavars-in-private-macros
<!-- end autogenerated links to configuration documentation -->
diff --git a/src/tools/clippy/book/src/lint_configuration.md b/src/tools/clippy/book/src/lint_configuration.md
index f6af981..c822300 100644
--- a/src/tools/clippy/book/src/lint_configuration.md
+++ b/src/tools/clippy/book/src/lint_configuration.md
@@ -101,6 +101,16 @@
* [`unnecessary_raw_string_hashes`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_raw_string_hashes)
+## `allow-panic-in-tests`
+Whether `panic` should be allowed in test functions or `#[cfg(test)]`
+
+**Default Value:** `false`
+
+---
+**Affected lints:**
+* [`panic`](https://rust-lang.github.io/rust-clippy/master/index.html#panic)
+
+
## `allow-print-in-tests`
Whether print macros (ex. `println!`) should be allowed in test functions or `#[cfg(test)]`
@@ -122,6 +132,28 @@
* [`module_inception`](https://rust-lang.github.io/rust-clippy/master/index.html#module_inception)
+## `allow-renamed-params-for`
+List of trait paths to ignore when checking renamed function parameters.
+
+#### Example
+
+```toml
+allow-renamed-params-for = [ "std::convert::From" ]
+```
+
+#### Noteworthy
+
+- By default, the following traits are ignored: `From`, `TryFrom`, `FromStr`
+- `".."` can be used as part of the list to indicate that the configured values should be appended to the
+default configuration of Clippy. By default, any configuration will replace the default value.
+
+**Default Value:** `["core::convert::From", "core::convert::TryFrom", "core::str::FromStr"]`
+
+---
+**Affected lints:**
+* [`renamed_function_params`](https://rust-lang.github.io/rust-clippy/master/index.html#renamed_function_params)
+
+
## `allow-unwrap-in-tests`
Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
@@ -900,3 +932,13 @@
* [`wildcard_imports`](https://rust-lang.github.io/rust-clippy/master/index.html#wildcard_imports)
+## `warn-unsafe-macro-metavars-in-private-macros`
+Whether to also emit warnings for unsafe blocks with metavariable expansions in **private** macros.
+
+**Default Value:** `false`
+
+---
+**Affected lints:**
+* [`macro_metavars_in_unsafe`](https://rust-lang.github.io/rust-clippy/master/index.html#macro_metavars_in_unsafe)
+
+
diff --git a/src/tools/clippy/clippy_config/src/conf.rs b/src/tools/clippy/clippy_config/src/conf.rs
index 5cfcbdb..cfdf620 100644
--- a/src/tools/clippy/clippy_config/src/conf.rs
+++ b/src/tools/clippy/clippy_config/src/conf.rs
@@ -40,6 +40,8 @@
const DEFAULT_DISALLOWED_NAMES: &[&str] = &["foo", "baz", "quux"];
const DEFAULT_ALLOWED_IDENTS_BELOW_MIN_CHARS: &[&str] = &["i", "j", "x", "y", "z", "w", "n"];
const DEFAULT_ALLOWED_PREFIXES: &[&str] = &["to", "as", "into", "from", "try_into", "try_from"];
+const DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS: &[&str] =
+ &["core::convert::From", "core::convert::TryFrom", "core::str::FromStr"];
/// Conf with parse errors
#[derive(Default)]
@@ -455,6 +457,10 @@
///
/// Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
(allow_unwrap_in_tests: bool = false),
+ /// Lint: PANIC.
+ ///
+ /// Whether `panic` should be allowed in test functions or `#[cfg(test)]`
+ (allow_panic_in_tests: bool = false),
/// Lint: DBG_MACRO.
///
/// Whether `dbg!` should be allowed in test functions or `#[cfg(test)]`
@@ -613,6 +619,27 @@
/// - Use `".."` as part of the list to indicate that the configured values should be appended to the
/// default configuration of Clippy. By default, any configuration will replace the default value
(allowed_prefixes: Vec<String> = DEFAULT_ALLOWED_PREFIXES.iter().map(ToString::to_string).collect()),
+ /// Lint: RENAMED_FUNCTION_PARAMS.
+ ///
+ /// List of trait paths to ignore when checking renamed function parameters.
+ ///
+ /// #### Example
+ ///
+ /// ```toml
+ /// allow-renamed-params-for = [ "std::convert::From" ]
+ /// ```
+ ///
+ /// #### Noteworthy
+ ///
+ /// - By default, the following traits are ignored: `From`, `TryFrom`, `FromStr`
+ /// - `".."` can be used as part of the list to indicate that the configured values should be appended to the
+ /// default configuration of Clippy. By default, any configuration will replace the default value.
+ (allow_renamed_params_for: Vec<String> =
+ DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS.iter().map(ToString::to_string).collect()),
+ /// Lint: MACRO_METAVARS_IN_UNSAFE.
+ ///
+ /// Whether to also emit warnings for unsafe blocks with metavariable expansions in **private** macros.
+ (warn_unsafe_macro_metavars_in_private_macros: bool = false),
}
/// Search for the configuration file.
@@ -674,6 +701,10 @@
extend_vec_if_indicator_present(&mut conf.conf.doc_valid_idents, DEFAULT_DOC_VALID_IDENTS);
extend_vec_if_indicator_present(&mut conf.conf.disallowed_names, DEFAULT_DISALLOWED_NAMES);
extend_vec_if_indicator_present(&mut conf.conf.allowed_prefixes, DEFAULT_ALLOWED_PREFIXES);
+ extend_vec_if_indicator_present(
+ &mut conf.conf.allow_renamed_params_for,
+ DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS,
+ );
// TODO: THIS SHOULD BE TESTED, this comment will be gone soon
if conf.conf.allowed_idents_below_min_chars.contains("..") {
conf.conf
diff --git a/src/tools/clippy/clippy_config/src/msrvs.rs b/src/tools/clippy/clippy_config/src/msrvs.rs
index 1480844..a3e7d0c 100644
--- a/src/tools/clippy/clippy_config/src/msrvs.rs
+++ b/src/tools/clippy/clippy_config/src/msrvs.rs
@@ -26,7 +26,8 @@
1,63,0 { CLONE_INTO }
1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE }
1,59,0 { THREAD_LOCAL_INITIALIZER_CAN_BE_MADE_CONST }
- 1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY }
+ 1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY, CONST_RAW_PTR_DEREF }
+ 1,56,0 { CONST_FN_UNION }
1,55,0 { SEEK_REWIND }
1,54,0 { INTO_KEYS }
1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
diff --git a/src/tools/clippy/clippy_dev/Cargo.toml b/src/tools/clippy/clippy_dev/Cargo.toml
index 42a9530..4104e7d 100644
--- a/src/tools/clippy/clippy_dev/Cargo.toml
+++ b/src/tools/clippy/clippy_dev/Cargo.toml
@@ -1,11 +1,12 @@
[package]
name = "clippy_dev"
+description = "Clippy developer tooling"
version = "0.0.1"
edition = "2021"
[dependencies]
aho-corasick = "1.0"
-clap = "4.1.4"
+clap = { version = "4.4", features = ["derive"] }
indoc = "1.0"
itertools = "0.12"
opener = "0.6"
diff --git a/src/tools/clippy/clippy_dev/src/main.rs b/src/tools/clippy/clippy_dev/src/main.rs
index 397a0e9..366b52b 100644
--- a/src/tools/clippy/clippy_dev/src/main.rs
+++ b/src/tools/clippy/clippy_dev/src/main.rs
@@ -2,350 +2,292 @@
// warn on lints, that are included in `rust-lang/rust`s bootstrap
#![warn(rust_2018_idioms, unused_lifetimes)]
-use clap::{Arg, ArgAction, ArgMatches, Command};
+use clap::{Args, Parser, Subcommand};
use clippy_dev::{dogfood, fmt, lint, new_lint, serve, setup, update_lints};
-use indoc::indoc;
use std::convert::Infallible;
fn main() {
- let matches = get_clap_config();
+ let dev = Dev::parse();
- match matches.subcommand() {
- Some(("bless", _)) => {
+ match dev.command {
+ DevCommand::Bless => {
eprintln!("use `cargo bless` to automatically replace `.stderr` and `.fixed` files as tests are being run");
},
- Some(("dogfood", matches)) => {
- dogfood::dogfood(
- matches.get_flag("fix"),
- matches.get_flag("allow-dirty"),
- matches.get_flag("allow-staged"),
- );
- },
- Some(("fmt", matches)) => {
- fmt::run(matches.get_flag("check"), matches.get_flag("verbose"));
- },
- Some(("update_lints", matches)) => {
- if matches.get_flag("print-only") {
+ DevCommand::Dogfood {
+ fix,
+ allow_dirty,
+ allow_staged,
+ } => dogfood::dogfood(fix, allow_dirty, allow_staged),
+ DevCommand::Fmt { check, verbose } => fmt::run(check, verbose),
+ DevCommand::UpdateLints { print_only, check } => {
+ if print_only {
update_lints::print_lints();
- } else if matches.get_flag("check") {
+ } else if check {
update_lints::update(update_lints::UpdateMode::Check);
} else {
update_lints::update(update_lints::UpdateMode::Change);
}
},
- Some(("new_lint", matches)) => {
- match new_lint::create(
- matches.get_one::<String>("pass").unwrap(),
- matches.get_one::<String>("name"),
- matches.get_one::<String>("category").map(String::as_str),
- matches.get_one::<String>("type").map(String::as_str),
- matches.get_flag("msrv"),
- ) {
- Ok(()) => update_lints::update(update_lints::UpdateMode::Change),
- Err(e) => eprintln!("Unable to create lint: {e}"),
- }
+ DevCommand::NewLint {
+ pass,
+ name,
+ category,
+ r#type,
+ msrv,
+ } => match new_lint::create(&pass, &name, &category, r#type.as_deref(), msrv) {
+ Ok(()) => update_lints::update(update_lints::UpdateMode::Change),
+ Err(e) => eprintln!("Unable to create lint: {e}"),
},
- Some(("setup", sub_command)) => match sub_command.subcommand() {
- Some(("git-hook", matches)) => {
- if matches.get_flag("remove") {
- setup::git_hook::remove_hook();
- } else {
- setup::git_hook::install_hook(matches.get_flag("force-override"));
- }
- },
- Some(("intellij", matches)) => {
- if matches.get_flag("remove") {
+ DevCommand::Setup(SetupCommand { subcommand }) => match subcommand {
+ SetupSubcommand::Intellij { remove, repo_path } => {
+ if remove {
setup::intellij::remove_rustc_src();
} else {
- setup::intellij::setup_rustc_src(
- matches
- .get_one::<String>("rustc-repo-path")
- .expect("this field is mandatory and therefore always valid"),
- );
+ setup::intellij::setup_rustc_src(&repo_path);
}
},
- Some(("toolchain", matches)) => {
- setup::toolchain::create(
- matches.get_flag("force"),
- matches.get_flag("release"),
- matches.get_one::<String>("name").unwrap(),
- );
+ SetupSubcommand::GitHook { remove, force_override } => {
+ if remove {
+ setup::git_hook::remove_hook();
+ } else {
+ setup::git_hook::install_hook(force_override);
+ }
},
- Some(("vscode-tasks", matches)) => {
- if matches.get_flag("remove") {
+ SetupSubcommand::Toolchain { force, release, name } => setup::toolchain::create(force, release, &name),
+ SetupSubcommand::VscodeTasks { remove, force_override } => {
+ if remove {
setup::vscode::remove_tasks();
} else {
- setup::vscode::install_tasks(matches.get_flag("force-override"));
+ setup::vscode::install_tasks(force_override);
}
},
- _ => {},
},
- Some(("remove", sub_command)) => match sub_command.subcommand() {
- Some(("git-hook", _)) => setup::git_hook::remove_hook(),
- Some(("intellij", _)) => setup::intellij::remove_rustc_src(),
- Some(("vscode-tasks", _)) => setup::vscode::remove_tasks(),
- _ => {},
+ DevCommand::Remove(RemoveCommand { subcommand }) => match subcommand {
+ RemoveSubcommand::Intellij => setup::intellij::remove_rustc_src(),
+ RemoveSubcommand::GitHook => setup::git_hook::remove_hook(),
+ RemoveSubcommand::VscodeTasks => setup::vscode::remove_tasks(),
},
- Some(("serve", matches)) => {
- let port = *matches.get_one::<u16>("port").unwrap();
- let lint = matches.get_one::<String>("lint");
- serve::run(port, lint);
- },
- Some(("lint", matches)) => {
- let path = matches.get_one::<String>("path").unwrap();
- let args = matches.get_many::<String>("args").into_iter().flatten();
- lint::run(path, args);
- },
- Some(("rename_lint", matches)) => {
- let old_name = matches.get_one::<String>("old_name").unwrap();
- let new_name = matches.get_one::<String>("new_name").unwrap_or(old_name);
- let uplift = matches.get_flag("uplift");
- update_lints::rename(old_name, new_name, uplift);
- },
- Some(("deprecate", matches)) => {
- let name = matches.get_one::<String>("name").unwrap();
- let reason = matches.get_one("reason");
- update_lints::deprecate(name, reason);
- },
- _ => {},
+ DevCommand::Serve { port, lint } => serve::run(port, lint),
+ DevCommand::Lint { path, args } => lint::run(&path, args.iter()),
+ DevCommand::RenameLint {
+ old_name,
+ new_name,
+ uplift,
+ } => update_lints::rename(&old_name, new_name.as_ref().unwrap_or(&old_name), uplift),
+ DevCommand::Deprecate { name, reason } => update_lints::deprecate(&name, reason.as_deref()),
}
}
-fn get_clap_config() -> ArgMatches {
- Command::new("Clippy developer tooling")
- .arg_required_else_help(true)
- .subcommands([
- Command::new("bless").about("bless the test output changes").arg(
- Arg::new("ignore-timestamp")
- .long("ignore-timestamp")
- .action(ArgAction::SetTrue)
- .help("Include files updated before clippy was built"),
- ),
- Command::new("dogfood").about("Runs the dogfood test").args([
- Arg::new("fix")
- .long("fix")
- .action(ArgAction::SetTrue)
- .help("Apply the suggestions when possible"),
- Arg::new("allow-dirty")
- .long("allow-dirty")
- .action(ArgAction::SetTrue)
- .help("Fix code even if the working directory has changes")
- .requires("fix"),
- Arg::new("allow-staged")
- .long("allow-staged")
- .action(ArgAction::SetTrue)
- .help("Fix code even if the working directory has staged changes")
- .requires("fix"),
- ]),
- Command::new("fmt")
- .about("Run rustfmt on all projects and tests")
- .args([
- Arg::new("check")
- .long("check")
- .action(ArgAction::SetTrue)
- .help("Use the rustfmt --check option"),
- Arg::new("verbose")
- .short('v')
- .long("verbose")
- .action(ArgAction::SetTrue)
- .help("Echo commands run"),
- ]),
- Command::new("update_lints")
- .about("Updates lint registration and information from the source code")
- .long_about(
- "Makes sure that:\n \
- * the lint count in README.md is correct\n \
- * the changelog contains markdown link references at the bottom\n \
- * all lint groups include the correct lints\n \
- * lint modules in `clippy_lints/*` are visible in `src/lib.rs` via `pub mod`\n \
- * all lints are registered in the lint store",
- )
- .args([
- Arg::new("print-only")
- .long("print-only")
- .action(ArgAction::SetTrue)
- .help(
- "Print a table of lints to STDOUT. \
- This does not include deprecated and internal lints. \
- (Does not modify any files)",
- ),
- Arg::new("check")
- .long("check")
- .action(ArgAction::SetTrue)
- .help("Checks that `cargo dev update_lints` has been run. Used on CI."),
- ]),
- Command::new("new_lint")
- .about("Create new lint and run `cargo dev update_lints`")
- .args([
- Arg::new("pass")
- .short('p')
- .long("pass")
- .help("Specify whether the lint runs during the early or late pass")
- .value_parser(["early", "late"])
- .conflicts_with("type")
- .default_value("late"),
- Arg::new("name")
- .short('n')
- .long("name")
- .help("Name of the new lint in snake case, ex: fn_too_long")
- .required(true)
- .value_parser(|name: &str| Ok::<_, Infallible>(name.replace('-', "_"))),
- Arg::new("category")
- .short('c')
- .long("category")
- .help("What category the lint belongs to")
- .default_value("nursery")
- .value_parser([
- "style",
- "correctness",
- "suspicious",
- "complexity",
- "perf",
- "pedantic",
- "restriction",
- "cargo",
- "nursery",
- "internal",
- ]),
- Arg::new("type").long("type").help("What directory the lint belongs in"),
- Arg::new("msrv")
- .long("msrv")
- .action(ArgAction::SetTrue)
- .help("Add MSRV config code to the lint"),
- ]),
- Command::new("setup")
- .about("Support for setting up your personal development environment")
- .arg_required_else_help(true)
- .subcommands([
- Command::new("git-hook")
- .about("Add a pre-commit git hook that formats your code to make it look pretty")
- .args([
- Arg::new("remove")
- .long("remove")
- .action(ArgAction::SetTrue)
- .help("Remove the pre-commit hook added with 'cargo dev setup git-hook'"),
- Arg::new("force-override")
- .long("force-override")
- .short('f')
- .action(ArgAction::SetTrue)
- .help("Forces the override of an existing git pre-commit hook"),
- ]),
- Command::new("intellij")
- .about("Alter dependencies so Intellij Rust can find rustc internals")
- .args([
- Arg::new("remove")
- .long("remove")
- .action(ArgAction::SetTrue)
- .help("Remove the dependencies added with 'cargo dev setup intellij'"),
- Arg::new("rustc-repo-path")
- .long("repo-path")
- .short('r')
- .help("The path to a rustc repo that will be used for setting the dependencies")
- .value_name("path")
- .conflicts_with("remove")
- .required(true),
- ]),
- Command::new("toolchain")
- .about("Install a rustup toolchain pointing to the local clippy build")
- .args([
- Arg::new("force")
- .long("force")
- .short('f')
- .action(ArgAction::SetTrue)
- .help("Override an existing toolchain"),
- Arg::new("release")
- .long("release")
- .short('r')
- .action(ArgAction::SetTrue)
- .help("Point to --release clippy binaries"),
- Arg::new("name")
- .long("name")
- .default_value("clippy")
- .help("The name of the created toolchain"),
- ]),
- Command::new("vscode-tasks")
- .about("Add several tasks to vscode for formatting, validation and testing")
- .args([
- Arg::new("remove")
- .long("remove")
- .action(ArgAction::SetTrue)
- .help("Remove the tasks added with 'cargo dev setup vscode-tasks'"),
- Arg::new("force-override")
- .long("force-override")
- .short('f')
- .action(ArgAction::SetTrue)
- .help("Forces the override of existing vscode tasks"),
- ]),
- ]),
- Command::new("remove")
- .about("Support for undoing changes done by the setup command")
- .arg_required_else_help(true)
- .subcommands([
- Command::new("git-hook").about("Remove any existing pre-commit git hook"),
- Command::new("vscode-tasks").about("Remove any existing vscode tasks"),
- Command::new("intellij").about("Removes rustc source paths added via `cargo dev setup intellij`"),
- ]),
- Command::new("serve")
- .about("Launch a local 'ALL the Clippy Lints' website in a browser")
- .args([
- Arg::new("port")
- .long("port")
- .short('p')
- .help("Local port for the http server")
- .default_value("8000")
- .value_parser(clap::value_parser!(u16)),
- Arg::new("lint").help("Which lint's page to load initially (optional)"),
- ]),
- Command::new("lint")
- .about("Manually run clippy on a file or package")
- .after_help(indoc! {"
- EXAMPLES
- Lint a single file:
- cargo dev lint tests/ui/attrs.rs
+#[derive(Parser)]
+#[command(name = "dev", about)]
+struct Dev {
+ #[command(subcommand)]
+ command: DevCommand,
+}
- Lint a package directory:
- cargo dev lint tests/ui-cargo/wildcard_dependencies/fail
- cargo dev lint ~/my-project
+#[derive(Subcommand)]
+enum DevCommand {
+ /// Bless the test output changes
+ Bless,
+ /// Runs the dogfood test
+ Dogfood {
+ #[arg(long)]
+ /// Apply the suggestions when possible
+ fix: bool,
+ #[arg(long, requires = "fix")]
+ /// Fix code even if the working directory has changes
+ allow_dirty: bool,
+ #[arg(long, requires = "fix")]
+ /// Fix code even if the working directory has staged changes
+ allow_staged: bool,
+ },
+ /// Run rustfmt on all projects and tests
+ Fmt {
+ #[arg(long)]
+ /// Use the rustfmt --check option
+ check: bool,
+ #[arg(short, long)]
+ /// Echo commands run
+ verbose: bool,
+ },
+ #[command(name = "update_lints")]
+ /// Updates lint registration and information from the source code
+ ///
+ /// Makes sure that: {n}
+ /// * the lint count in README.md is correct {n}
+ /// * the changelog contains markdown link references at the bottom {n}
+ /// * all lint groups include the correct lints {n}
+ /// * lint modules in `clippy_lints/*` are visible in `src/lib.rs` via `pub mod` {n}
+ /// * all lints are registered in the lint store
+ UpdateLints {
+ #[arg(long)]
+ /// Print a table of lints to STDOUT
+ ///
+ /// This does not include deprecated and internal lints. (Does not modify any files)
+ print_only: bool,
+ #[arg(long)]
+ /// Checks that `cargo dev update_lints` has been run. Used on CI.
+ check: bool,
+ },
+ #[command(name = "new_lint")]
+ /// Create a new lint and run `cargo dev update_lints`
+ NewLint {
+ #[arg(short, long, value_parser = ["early", "late"], conflicts_with = "type", default_value = "late")]
+ /// Specify whether the lint runs during the early or late pass
+ pass: String,
+ #[arg(
+ short,
+ long,
+ value_parser = |name: &str| Ok::<_, Infallible>(name.replace('-', "_")),
+ )]
+ /// Name of the new lint in snake case, ex: `fn_too_long`
+ name: String,
+ #[arg(
+ short,
+ long,
+ value_parser = [
+ "style",
+ "correctness",
+ "suspicious",
+ "complexity",
+ "perf",
+ "pedantic",
+ "restriction",
+ "cargo",
+ "nursery",
+ "internal",
+ ],
+ default_value = "nursery",
+ )]
+ /// What category the lint belongs to
+ category: String,
+ #[arg(long)]
+ /// What directory the lint belongs in
+ r#type: Option<String>,
+ #[arg(long)]
+ /// Add MSRV config code to the lint
+ msrv: bool,
+ },
+ /// Support for setting up your personal development environment
+ Setup(SetupCommand),
+ /// Support for removing changes done by the setup command
+ Remove(RemoveCommand),
+ /// Launch a local 'ALL the Clippy Lints' website in a browser
+ Serve {
+ #[arg(short, long, default_value = "8000")]
+ /// Local port for the http server
+ port: u16,
+ #[arg(long)]
+ /// Which lint's page to load initially (optional)
+ lint: Option<String>,
+ },
+ #[allow(clippy::doc_markdown)]
+ /// Manually run clippy on a file or package
+ ///
+ /// ## Examples
+ ///
+ /// Lint a single file: {n}
+ /// cargo dev lint tests/ui/attrs.rs
+ ///
+ /// Lint a package directory: {n}
+ /// cargo dev lint tests/ui-cargo/wildcard_dependencies/fail {n}
+ /// cargo dev lint ~/my-project
+ ///
+ /// Run rustfix: {n}
+ /// cargo dev lint ~/my-project -- --fix
+ ///
+ /// Set lint levels: {n}
+ /// cargo dev lint file.rs -- -W clippy::pedantic {n}
+ /// cargo dev lint ~/my-project -- -- -W clippy::pedantic
+ Lint {
+ /// The path to a file or package directory to lint
+ path: String,
+ /// Pass extra arguments to cargo/clippy-driver
+ args: Vec<String>,
+ },
+ #[command(name = "rename_lint")]
+ /// Rename a lint
+ RenameLint {
+ /// The name of the lint to rename
+ old_name: String,
+ #[arg(required_unless_present = "uplift")]
+ /// The new name of the lint
+ new_name: Option<String>,
+ #[arg(long)]
+ /// This lint will be uplifted into rustc
+ uplift: bool,
+ },
+ /// Deprecate the given lint
+ Deprecate {
+ /// The name of the lint to deprecate
+ name: String,
+ #[arg(long, short)]
+ /// The reason for deprecation
+ reason: Option<String>,
+ },
+}
- Run rustfix:
- cargo dev lint ~/my-project -- --fix
+#[derive(Args)]
+struct SetupCommand {
+ #[command(subcommand)]
+ subcommand: SetupSubcommand,
+}
- Set lint levels:
- cargo dev lint file.rs -- -W clippy::pedantic
- cargo dev lint ~/my-project -- -- -W clippy::pedantic
- "})
- .args([
- Arg::new("path")
- .required(true)
- .help("The path to a file or package directory to lint"),
- Arg::new("args")
- .action(ArgAction::Append)
- .help("Pass extra arguments to cargo/clippy-driver"),
- ]),
- Command::new("rename_lint").about("Renames the given lint").args([
- Arg::new("old_name")
- .index(1)
- .required(true)
- .help("The name of the lint to rename"),
- Arg::new("new_name")
- .index(2)
- .required_unless_present("uplift")
- .help("The new name of the lint"),
- Arg::new("uplift")
- .long("uplift")
- .action(ArgAction::SetTrue)
- .help("This lint will be uplifted into rustc"),
- ]),
- Command::new("deprecate").about("Deprecates the given lint").args([
- Arg::new("name")
- .index(1)
- .required(true)
- .help("The name of the lint to deprecate"),
- Arg::new("reason")
- .long("reason")
- .short('r')
- .help("The reason for deprecation"),
- ]),
- ])
- .get_matches()
+#[derive(Subcommand)]
+enum SetupSubcommand {
+ /// Alter dependencies so Intellij Rust can find rustc internals
+ Intellij {
+ #[arg(long)]
+ /// Remove the dependencies added with 'cargo dev setup intellij'
+ remove: bool,
+ #[arg(long, short, conflicts_with = "remove")]
+ /// The path to a rustc repo that will be used for setting the dependencies
+ repo_path: String,
+ },
+ /// Add a pre-commit git hook that formats your code to make it look pretty
+ GitHook {
+ #[arg(long)]
+ /// Remove the pre-commit hook added with 'cargo dev setup git-hook'
+ remove: bool,
+ #[arg(long, short)]
+ /// Forces the override of an existing git pre-commit hook
+ force_override: bool,
+ },
+ /// Install a rustup toolchain pointing to the local clippy build
+ Toolchain {
+ #[arg(long, short)]
+ /// Override an existing toolchain
+ force: bool,
+ #[arg(long, short)]
+ /// Point to --release clippy binary
+ release: bool,
+ #[arg(long, default_value = "clippy")]
+ /// Name of the toolchain
+ name: String,
+ },
+ /// Add several tasks to vscode for formatting, validation and testing
+ VscodeTasks {
+ #[arg(long)]
+ /// Remove the tasks added with 'cargo dev setup vscode-tasks'
+ remove: bool,
+ #[arg(long, short)]
+ /// Forces the override of existing vscode tasks
+ force_override: bool,
+ },
+}
+
+#[derive(Args)]
+struct RemoveCommand {
+ #[command(subcommand)]
+ subcommand: RemoveSubcommand,
+}
+
+#[derive(Subcommand)]
+enum RemoveSubcommand {
+ /// Remove the dependencies added with 'cargo dev setup intellij'
+ Intellij,
+ /// Remove the pre-commit git hook
+ GitHook,
+ /// Remove the tasks added with 'cargo dev setup vscode-tasks'
+ VscodeTasks,
}
diff --git a/src/tools/clippy/clippy_dev/src/new_lint.rs b/src/tools/clippy/clippy_dev/src/new_lint.rs
index 2940d56..b6481dd 100644
--- a/src/tools/clippy/clippy_dev/src/new_lint.rs
+++ b/src/tools/clippy/clippy_dev/src/new_lint.rs
@@ -36,22 +36,16 @@
/// # Errors
///
/// This function errors out if the files couldn't be created or written to.
-pub fn create(
- pass: &String,
- lint_name: Option<&String>,
- category: Option<&str>,
- mut ty: Option<&str>,
- msrv: bool,
-) -> io::Result<()> {
- if category == Some("cargo") && ty.is_none() {
+pub fn create(pass: &str, name: &str, category: &str, mut ty: Option<&str>, msrv: bool) -> io::Result<()> {
+ if category == "cargo" && ty.is_none() {
// `cargo` is a special category, these lints should always be in `clippy_lints/src/cargo`
ty = Some("cargo");
}
let lint = LintData {
pass,
- name: lint_name.expect("`name` argument is validated by clap"),
- category: category.expect("`category` argument is validated by clap"),
+ name,
+ category,
ty,
project_root: clippy_project_root(),
};
diff --git a/src/tools/clippy/clippy_dev/src/serve.rs b/src/tools/clippy/clippy_dev/src/serve.rs
index ea925f6..4a4261d 100644
--- a/src/tools/clippy/clippy_dev/src/serve.rs
+++ b/src/tools/clippy/clippy_dev/src/serve.rs
@@ -8,7 +8,7 @@
/// # Panics
///
/// Panics if the python commands could not be spawned
-pub fn run(port: u16, lint: Option<&String>) -> ! {
+pub fn run(port: u16, lint: Option<String>) -> ! {
let mut url = Some(match lint {
None => format!("http://localhost:{port}"),
Some(lint) => format!("http://localhost:{port}/#{lint}"),
diff --git a/src/tools/clippy/clippy_dev/src/update_lints.rs b/src/tools/clippy/clippy_dev/src/update_lints.rs
index 625b133..4535390 100644
--- a/src/tools/clippy/clippy_dev/src/update_lints.rs
+++ b/src/tools/clippy/clippy_dev/src/update_lints.rs
@@ -314,7 +314,7 @@
/// # Panics
///
/// If a file path could not read from or written to
-pub fn deprecate(name: &str, reason: Option<&String>) {
+pub fn deprecate(name: &str, reason: Option<&str>) {
fn finish(
(lints, mut deprecated_lints, renamed_lints): (Vec<Lint>, Vec<DeprecatedLint>, Vec<RenamedLint>),
name: &str,
@@ -335,7 +335,7 @@
println!("note: you must run `cargo uitest` to update the test results");
}
- let reason = reason.map_or(DEFAULT_DEPRECATION_REASON, String::as_str);
+ let reason = reason.unwrap_or(DEFAULT_DEPRECATION_REASON);
let name_lower = name.to_lowercase();
let name_upper = name.to_uppercase();
diff --git a/src/tools/clippy/clippy_lints/src/assigning_clones.rs b/src/tools/clippy/clippy_lints/src/assigning_clones.rs
index f0dafb1..e94a6f3 100644
--- a/src/tools/clippy/clippy_lints/src/assigning_clones.rs
+++ b/src/tools/clippy/clippy_lints/src/assigning_clones.rs
@@ -2,15 +2,15 @@
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::macros::HirNode;
use clippy_utils::sugg::Sugg;
-use clippy_utils::{is_trait_method, path_to_local};
+use clippy_utils::{is_trait_method, local_is_initialized, path_to_local};
use rustc_errors::Applicability;
-use rustc_hir::{self as hir, Expr, ExprKind, Node};
+use rustc_hir::{self as hir, Expr, ExprKind};
use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::ty::{self, Instance, Mutability};
use rustc_session::impl_lint_pass;
use rustc_span::def_id::DefId;
use rustc_span::symbol::sym;
-use rustc_span::ExpnKind;
+use rustc_span::{ExpnKind, SyntaxContext};
declare_clippy_lint! {
/// ### What it does
@@ -36,6 +36,7 @@
/// Use instead:
/// ```rust
/// struct Thing;
+ ///
/// impl Clone for Thing {
/// fn clone(&self) -> Self { todo!() }
/// fn clone_from(&mut self, other: &Self) { todo!() }
@@ -47,7 +48,7 @@
/// ```
#[clippy::version = "1.78.0"]
pub ASSIGNING_CLONES,
- perf,
+ pedantic,
"assigning the result of cloning may be inefficient"
}
@@ -67,7 +68,8 @@
impl<'tcx> LateLintPass<'tcx> for AssigningClones {
fn check_expr(&mut self, cx: &LateContext<'tcx>, assign_expr: &'tcx Expr<'_>) {
// Do not fire the lint in macros
- let expn_data = assign_expr.span().ctxt().outer_expn_data();
+ let ctxt = assign_expr.span().ctxt();
+ let expn_data = ctxt.outer_expn_data();
match expn_data.kind {
ExpnKind::AstPass(_) | ExpnKind::Desugaring(_) | ExpnKind::Macro(..) => return,
ExpnKind::Root => {},
@@ -82,7 +84,7 @@
};
if is_ok_to_suggest(cx, lhs, &call, &self.msrv) {
- suggest(cx, assign_expr, lhs, &call);
+ suggest(cx, ctxt, assign_expr, lhs, &call);
}
}
@@ -163,9 +165,7 @@
// TODO: This check currently bails if the local variable has no initializer.
// That is overly conservative - the lint should fire even if there was no initializer,
// but the variable has been initialized before `lhs` was evaluated.
- if let Some(Node::LetStmt(local)) = cx.tcx.hir().parent_id_iter(local).next().map(|p| cx.tcx.hir_node(p))
- && local.init.is_none()
- {
+ if !local_is_initialized(cx, local) {
return false;
}
}
@@ -222,14 +222,20 @@
implemented_fns.contains_key(&provided_fn.def_id)
}
-fn suggest<'tcx>(cx: &LateContext<'tcx>, assign_expr: &Expr<'tcx>, lhs: &Expr<'tcx>, call: &CallCandidate<'tcx>) {
+fn suggest<'tcx>(
+ cx: &LateContext<'tcx>,
+ ctxt: SyntaxContext,
+ assign_expr: &Expr<'tcx>,
+ lhs: &Expr<'tcx>,
+ call: &CallCandidate<'tcx>,
+) {
span_lint_and_then(cx, ASSIGNING_CLONES, assign_expr.span, call.message(), |diag| {
let mut applicability = Applicability::Unspecified;
diag.span_suggestion(
assign_expr.span,
call.suggestion_msg(),
- call.suggested_replacement(cx, lhs, &mut applicability),
+ call.suggested_replacement(cx, ctxt, lhs, &mut applicability),
applicability,
);
});
@@ -275,6 +281,7 @@
fn suggested_replacement(
&self,
cx: &LateContext<'tcx>,
+ ctxt: SyntaxContext,
lhs: &Expr<'tcx>,
applicability: &mut Applicability,
) -> String {
@@ -294,7 +301,7 @@
// Determine whether we need to reference the argument to clone_from().
let clone_receiver_type = cx.typeck_results().expr_ty(receiver);
let clone_receiver_adj_type = cx.typeck_results().expr_ty_adjusted(receiver);
- let mut arg_sugg = Sugg::hir_with_applicability(cx, receiver, "_", applicability);
+ let mut arg_sugg = Sugg::hir_with_context(cx, receiver, ctxt, "_", applicability);
if clone_receiver_type != clone_receiver_adj_type {
// The receiver may have been a value type, so we need to add an `&` to
// be sure the argument to clone_from will be a reference.
@@ -312,7 +319,7 @@
Sugg::hir_with_applicability(cx, lhs, "_", applicability).mut_addr()
};
// The RHS had to be exactly correct before the call, there is no auto-deref for function calls.
- let rhs_sugg = Sugg::hir_with_applicability(cx, self_arg, "_", applicability);
+ let rhs_sugg = Sugg::hir_with_context(cx, self_arg, ctxt, "_", applicability);
format!("Clone::clone_from({self_sugg}, {rhs_sugg})")
},
@@ -341,11 +348,11 @@
match self.kind {
CallKind::MethodCall { receiver } => {
- let receiver_sugg = Sugg::hir_with_applicability(cx, receiver, "_", applicability);
+ let receiver_sugg = Sugg::hir_with_context(cx, receiver, ctxt, "_", applicability);
format!("{receiver_sugg}.clone_into({rhs_sugg})")
},
CallKind::FunctionCall { self_arg, .. } => {
- let self_sugg = Sugg::hir_with_applicability(cx, self_arg, "_", applicability);
+ let self_sugg = Sugg::hir_with_context(cx, self_arg, ctxt, "_", applicability);
format!("ToOwned::clone_into({self_sugg}, {rhs_sugg})")
},
}
diff --git a/src/tools/clippy/clippy_lints/src/attrs/duplicated_attributes.rs b/src/tools/clippy/clippy_lints/src/attrs/duplicated_attributes.rs
index 736ee48..40a1c4e 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/duplicated_attributes.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/duplicated_attributes.rs
@@ -36,9 +36,10 @@
}
let Some(ident) = attr.ident() else { return };
let name = ident.name;
- if name == sym::doc || name == sym::cfg_attr {
+ if name == sym::doc || name == sym::cfg_attr || name == sym::rustc_on_unimplemented {
// FIXME: Would be nice to handle `cfg_attr` as well. Only problem is to check that cfg
// conditions are the same.
+ // `#[rustc_on_unimplemented]` contains duplicated subattributes, that's expected.
return;
}
if let Some(direct_parent) = parent.last()
diff --git a/src/tools/clippy/clippy_lints/src/attrs/mod.rs b/src/tools/clippy/clippy_lints/src/attrs/mod.rs
index 8f47bc7..39f4060 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/mod.rs
@@ -61,11 +61,21 @@
///
/// This lint permits lint attributes for lints emitted on the items themself.
/// For `use` items these lints are:
+ /// * ambiguous_glob_reexports
+ /// * dead_code
/// * deprecated
+ /// * hidden_glob_reexports
/// * unreachable_pub
- /// * unused_imports
+ /// * unused
+ /// * unused_braces
+ /// * unused_import_braces
+ /// * clippy::disallowed_types
/// * clippy::enum_glob_use
/// * clippy::macro_use_imports
+ /// * clippy::module_name_repetitions
+ /// * clippy::redundant_pub_crate
+ /// * clippy::single_component_path_imports
+ /// * clippy::unsafe_removed_from_name
/// * clippy::wildcard_imports
///
/// For `extern crate` items these lints are:
diff --git a/src/tools/clippy/clippy_lints/src/attrs/useless_attribute.rs b/src/tools/clippy/clippy_lints/src/attrs/useless_attribute.rs
index 7575f50..f086823 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/useless_attribute.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/useless_attribute.rs
@@ -2,6 +2,7 @@
use super::{Attribute, USELESS_ATTRIBUTE};
use clippy_utils::diagnostics::span_lint_and_then;
use clippy_utils::source::{first_line_of_span, snippet_opt};
+use rustc_ast::NestedMetaItem;
use rustc_errors::Applicability;
use rustc_hir::{Item, ItemKind};
use rustc_lint::{LateContext, LintContext};
@@ -20,26 +21,40 @@
for lint in lint_list {
match item.kind {
ItemKind::Use(..) => {
- if is_word(lint, sym::unused_imports)
- || is_word(lint, sym::deprecated)
- || is_word(lint, sym!(unreachable_pub))
- || is_word(lint, sym!(unused))
- || is_word(lint, sym!(unused_import_braces))
- || extract_clippy_lint(lint).map_or(false, |s| {
- matches!(
- s.as_str(),
- "wildcard_imports"
- | "enum_glob_use"
- | "redundant_pub_crate"
- | "macro_use_imports"
- | "unsafe_removed_from_name"
- | "module_name_repetitions"
- | "single_component_path_imports"
- )
- })
+ if let NestedMetaItem::MetaItem(meta_item) = lint
+ && meta_item.is_word()
+ && let Some(ident) = meta_item.ident()
+ && matches!(
+ ident.name.as_str(),
+ "ambiguous_glob_reexports"
+ | "dead_code"
+ | "deprecated"
+ | "hidden_glob_reexports"
+ | "unreachable_pub"
+ | "unused"
+ | "unused_braces"
+ | "unused_import_braces"
+ | "unused_imports"
+ )
{
return;
}
+
+ if extract_clippy_lint(lint).is_some_and(|symbol| {
+ matches!(
+ symbol.as_str(),
+ "wildcard_imports"
+ | "enum_glob_use"
+ | "redundant_pub_crate"
+ | "macro_use_imports"
+ | "unsafe_removed_from_name"
+ | "module_name_repetitions"
+ | "single_component_path_imports"
+ | "disallowed_types"
+ )
+ }) {
+ return;
+ }
},
ItemKind::ExternCrate(..) => {
if is_word(lint, sym::unused_imports) && skip_unused_imports {
diff --git a/src/tools/clippy/clippy_lints/src/cargo/lint_groups_priority.rs b/src/tools/clippy/clippy_lints/src/cargo/lint_groups_priority.rs
index a3291c9..0d9eaac 100644
--- a/src/tools/clippy/clippy_lints/src/cargo/lint_groups_priority.rs
+++ b/src/tools/clippy/clippy_lints/src/cargo/lint_groups_priority.rs
@@ -49,7 +49,7 @@
type LintTable = BTreeMap<Spanned<String>, Spanned<LintConfig>>;
-#[derive(Deserialize, Debug)]
+#[derive(Deserialize, Debug, Default)]
struct Lints {
#[serde(default)]
rust: LintTable,
@@ -57,9 +57,18 @@
clippy: LintTable,
}
+#[derive(Deserialize, Debug, Default)]
+struct Workspace {
+ #[serde(default)]
+ lints: Lints,
+}
+
#[derive(Deserialize, Debug)]
struct CargoToml {
+ #[serde(default)]
lints: Lints,
+ #[serde(default)]
+ workspace: Workspace,
}
#[derive(Default, Debug)]
@@ -164,5 +173,7 @@
check_table(cx, cargo_toml.lints.rust, &rustc_groups, &file);
check_table(cx, cargo_toml.lints.clippy, &clippy_groups, &file);
+ check_table(cx, cargo_toml.workspace.lints.rust, &rustc_groups, &file);
+ check_table(cx, cargo_toml.workspace.lints.clippy, &clippy_groups, &file);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs b/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs
index 2b6e17d..864489e 100644
--- a/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs
@@ -255,8 +255,10 @@
/// Peels binary operators such as [`BinOpKind::Mul`], [`BinOpKind::Div`] or [`BinOpKind::Rem`],
/// where the result depends on:
+///
/// - the number of negative values in the entire expression, or
/// - the number of negative values on the left hand side of the expression.
+///
/// Ignores overflow.
///
///
@@ -303,8 +305,10 @@
}
/// Peels binary operators such as [`BinOpKind::Add`], where the result depends on:
+///
/// - all the expressions being positive, or
/// - all the expressions being negative.
+///
/// Ignores overflow.
///
/// Expressions using other operators are preserved, so we can try to evaluate them later.
diff --git a/src/tools/clippy/clippy_lints/src/declared_lints.rs b/src/tools/clippy/clippy_lints/src/declared_lints.rs
index 5ff7d8e..df2ef46 100644
--- a/src/tools/clippy/clippy_lints/src/declared_lints.rs
+++ b/src/tools/clippy/clippy_lints/src/declared_lints.rs
@@ -140,6 +140,7 @@
crate::disallowed_names::DISALLOWED_NAMES_INFO,
crate::disallowed_script_idents::DISALLOWED_SCRIPT_IDENTS_INFO,
crate::disallowed_types::DISALLOWED_TYPES_INFO,
+ crate::doc::DOC_LAZY_CONTINUATION_INFO,
crate::doc::DOC_LINK_WITH_QUOTES_INFO,
crate::doc::DOC_MARKDOWN_INFO,
crate::doc::EMPTY_DOCS_INFO,
@@ -205,6 +206,7 @@
crate::functions::MUST_USE_CANDIDATE_INFO,
crate::functions::MUST_USE_UNIT_INFO,
crate::functions::NOT_UNSAFE_PTR_ARG_DEREF_INFO,
+ crate::functions::RENAMED_FUNCTION_PARAMS_INFO,
crate::functions::RESULT_LARGE_ERR_INFO,
crate::functions::RESULT_UNIT_ERR_INFO,
crate::functions::TOO_MANY_ARGUMENTS_INFO,
@@ -291,9 +293,11 @@
crate::loops::SAME_ITEM_PUSH_INFO,
crate::loops::SINGLE_ELEMENT_LOOP_INFO,
crate::loops::UNUSED_ENUMERATE_INDEX_INFO,
+ crate::loops::WHILE_FLOAT_INFO,
crate::loops::WHILE_IMMUTABLE_CONDITION_INFO,
crate::loops::WHILE_LET_LOOP_INFO,
crate::loops::WHILE_LET_ON_ITERATOR_INFO,
+ crate::macro_metavars_in_unsafe::MACRO_METAVARS_IN_UNSAFE_INFO,
crate::macro_use::MACRO_USE_IMPORTS_INFO,
crate::main_recursion::MAIN_RECURSION_INFO,
crate::manual_assert::MANUAL_ASSERT_INFO,
diff --git a/src/tools/clippy/clippy_lints/src/doc/lazy_continuation.rs b/src/tools/clippy/clippy_lints/src/doc/lazy_continuation.rs
new file mode 100644
index 0000000..38bc58a
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/doc/lazy_continuation.rs
@@ -0,0 +1,95 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use itertools::Itertools;
+use rustc_errors::{Applicability, SuggestionStyle};
+use rustc_lint::LateContext;
+use rustc_span::{BytePos, Span};
+use std::ops::Range;
+
+use super::DOC_LAZY_CONTINUATION;
+
+fn map_container_to_text(c: &super::Container) -> &'static str {
+ match c {
+ super::Container::Blockquote => "> ",
+ // numbered list can have up to nine digits, plus the dot, plus four spaces on either side
+ super::Container::List(indent) => &" "[0..*indent],
+ }
+}
+
+// TODO: Adjust the parameters as necessary
+pub(super) fn check(
+ cx: &LateContext<'_>,
+ doc: &str,
+ range: Range<usize>,
+ mut span: Span,
+ containers: &[super::Container],
+) {
+ if doc[range.clone()].contains('\t') {
+ // We don't do tab stops correctly.
+ return;
+ }
+
+ let ccount = doc[range.clone()].chars().filter(|c| *c == '>').count();
+ let blockquote_level = containers
+ .iter()
+ .filter(|c| matches!(c, super::Container::Blockquote))
+ .count();
+ let lcount = doc[range.clone()].chars().filter(|c| *c == ' ').count();
+ let list_indentation = containers
+ .iter()
+ .map(|c| {
+ if let super::Container::List(indent) = c {
+ *indent
+ } else {
+ 0
+ }
+ })
+ .sum();
+ if ccount < blockquote_level || lcount < list_indentation {
+ let msg = if ccount < blockquote_level {
+ "doc quote missing `>` marker"
+ } else {
+ "doc list item missing indentation"
+ };
+ span_lint_and_then(cx, DOC_LAZY_CONTINUATION, span, msg, |diag| {
+ if ccount == 0 && blockquote_level == 0 {
+ // simpler suggestion style for indentation
+ let indent = list_indentation - lcount;
+ diag.span_suggestion_with_style(
+ span.shrink_to_hi(),
+ "indent this line",
+ std::iter::repeat(" ").take(indent).join(""),
+ Applicability::MaybeIncorrect,
+ SuggestionStyle::ShowAlways,
+ );
+ diag.help("if this is supposed to be its own paragraph, add a blank line");
+ return;
+ }
+ let mut doc_start_range = &doc[range];
+ let mut suggested = String::new();
+ for c in containers {
+ let text = map_container_to_text(c);
+ if doc_start_range.starts_with(text) {
+ doc_start_range = &doc_start_range[text.len()..];
+ span = span
+ .with_lo(span.lo() + BytePos(u32::try_from(text.len()).expect("text is not 2**32 or bigger")));
+ } else if matches!(c, super::Container::Blockquote)
+ && let Some(i) = doc_start_range.find('>')
+ {
+ doc_start_range = &doc_start_range[i + 1..];
+ span =
+ span.with_lo(span.lo() + BytePos(u32::try_from(i).expect("text is not 2**32 or bigger") + 1));
+ } else {
+ suggested.push_str(text);
+ }
+ }
+ diag.span_suggestion_with_style(
+ span,
+ "add markers to start of line",
+ suggested,
+ Applicability::MachineApplicable,
+ SuggestionStyle::ShowAlways,
+ );
+ diag.help("if this not intended to be a quote at all, escape it with `\\>`");
+ });
+ }
+}
diff --git a/src/tools/clippy/clippy_lints/src/doc/missing_headers.rs b/src/tools/clippy/clippy_lints/src/doc/missing_headers.rs
index 36ba196..010fab8 100644
--- a/src/tools/clippy/clippy_lints/src/doc/missing_headers.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/missing_headers.rs
@@ -1,3 +1,4 @@
+use super::{DocHeaders, MISSING_ERRORS_DOC, MISSING_PANICS_DOC, MISSING_SAFETY_DOC, UNNECESSARY_SAFETY_DOC};
use clippy_utils::diagnostics::{span_lint, span_lint_and_note};
use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
use clippy_utils::{is_doc_hidden, return_ty};
@@ -6,15 +7,13 @@
use rustc_middle::ty;
use rustc_span::{sym, Span};
-use super::{DocHeaders, MISSING_ERRORS_DOC, MISSING_PANICS_DOC, MISSING_SAFETY_DOC, UNNECESSARY_SAFETY_DOC};
-
pub fn check(
cx: &LateContext<'_>,
owner_id: OwnerId,
sig: FnSig<'_>,
headers: DocHeaders,
body_id: Option<BodyId>,
- panic_span: Option<Span>,
+ panic_info: Option<(Span, bool)>,
check_private_items: bool,
) {
if !check_private_items && !cx.effective_visibilities.is_exported(owner_id.def_id) {
@@ -48,13 +47,13 @@
),
_ => (),
}
- if !headers.panics && panic_span.is_some() {
+ if !headers.panics && panic_info.map_or(false, |el| !el.1) {
span_lint_and_note(
cx,
MISSING_PANICS_DOC,
span,
"docs for function which may panic missing `# Panics` section",
- panic_span,
+ panic_info.map(|el| el.0),
"first possible panic found here",
);
}
diff --git a/src/tools/clippy/clippy_lints/src/doc/mod.rs b/src/tools/clippy/clippy_lints/src/doc/mod.rs
index 7fdb582..9f08973 100644
--- a/src/tools/clippy/clippy_lints/src/doc/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/mod.rs
@@ -1,13 +1,14 @@
+mod lazy_continuation;
use clippy_utils::attrs::is_doc_hidden;
use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
use clippy_utils::macros::{is_panic, root_macro_call_first_node};
use clippy_utils::ty::is_type_diagnostic_item;
use clippy_utils::visitors::Visitable;
-use clippy_utils::{is_entrypoint_fn, is_trait_impl_item, method_chain_args};
+use clippy_utils::{in_constant, is_entrypoint_fn, is_trait_impl_item, method_chain_args};
use pulldown_cmark::Event::{
Code, End, FootnoteReference, HardBreak, Html, Rule, SoftBreak, Start, TaskListMarker, Text,
};
-use pulldown_cmark::Tag::{BlockQuote, CodeBlock, Heading, Item, Link, Paragraph};
+use pulldown_cmark::Tag::{BlockQuote, CodeBlock, FootnoteDefinition, Heading, Item, Link, Paragraph};
use pulldown_cmark::{BrokenLink, CodeBlockKind, CowStr, Options};
use rustc_ast::ast::Attribute;
use rustc_data_structures::fx::FxHashSet;
@@ -362,6 +363,63 @@
"docstrings exist but documentation is empty"
}
+declare_clippy_lint! {
+ /// ### What it does
+ ///
+ /// In CommonMark Markdown, the language used to write doc comments, a
+ /// paragraph nested within a list or block quote does not need any line
+ /// after the first one to be indented or marked. The specification calls
+ /// this a "lazy paragraph continuation."
+ ///
+ /// ### Why is this bad?
+ ///
+ /// This is easy to write but hard to read. Lazy continuations makes
+ /// unintended markers hard to see, and make it harder to deduce the
+ /// document's intended structure.
+ ///
+ /// ### Example
+ ///
+ /// This table is probably intended to have two rows,
+ /// but it does not. It has zero rows, and is followed by
+ /// a block quote.
+ /// ```no_run
+ /// /// Range | Description
+ /// /// ----- | -----------
+ /// /// >= 1 | fully opaque
+ /// /// < 1 | partially see-through
+ /// fn set_opacity(opacity: f32) {}
+ /// ```
+ ///
+ /// Fix it by escaping the marker:
+ /// ```no_run
+ /// /// Range | Description
+ /// /// ----- | -----------
+ /// /// \>= 1 | fully opaque
+ /// /// < 1 | partially see-through
+ /// fn set_opacity(opacity: f32) {}
+ /// ```
+ ///
+ /// This example is actually intended to be a list:
+ /// ```no_run
+ /// /// * Do nothing.
+ /// /// * Then do something. Whatever it is needs done,
+ /// /// it should be done right now.
+ /// # fn do_stuff() {}
+ /// ```
+ ///
+ /// Fix it by indenting the list contents:
+ /// ```no_run
+ /// /// * Do nothing.
+ /// /// * Then do something. Whatever it is needs done,
+ /// /// it should be done right now.
+ /// # fn do_stuff() {}
+ /// ```
+ #[clippy::version = "1.80.0"]
+ pub DOC_LAZY_CONTINUATION,
+ style,
+ "require every line of a paragraph to be indented and marked"
+}
+
#[derive(Clone)]
pub struct Documentation {
valid_idents: FxHashSet<String>,
@@ -388,6 +446,7 @@
UNNECESSARY_SAFETY_DOC,
SUSPICIOUS_DOC_COMMENTS,
EMPTY_DOCS,
+ DOC_LAZY_CONTINUATION,
]);
impl<'tcx> LateLintPass<'tcx> for Documentation {
@@ -402,14 +461,14 @@
if !(is_entrypoint_fn(cx, item.owner_id.to_def_id()) || in_external_macro(cx.tcx.sess, item.span)) {
let body = cx.tcx.hir().body(body_id);
- let panic_span = FindPanicUnwrap::find_span(cx, cx.tcx.typeck(item.owner_id), body.value);
+ let panic_info = FindPanicUnwrap::find_span(cx, cx.tcx.typeck(item.owner_id), body.value);
missing_headers::check(
cx,
item.owner_id,
sig,
headers,
Some(body_id),
- panic_span,
+ panic_info,
self.check_private_items,
);
}
@@ -551,6 +610,7 @@
cx,
valid_idents,
parser.into_offset_iter(),
+ &doc,
Fragments {
fragments: &fragments,
doc: &doc,
@@ -560,6 +620,11 @@
const RUST_CODE: &[&str] = &["rust", "no_run", "should_panic", "compile_fail"];
+enum Container {
+ Blockquote,
+ List(usize),
+}
+
/// Checks parsed documentation.
/// This walks the "events" (think sections of markdown) produced by `pulldown_cmark`,
/// so lints here will generally access that information.
@@ -569,6 +634,7 @@
cx: &LateContext<'_>,
valid_idents: &FxHashSet<String>,
events: Events,
+ doc: &str,
fragments: Fragments<'_>,
) -> DocHeaders {
// true if a safety header was found
@@ -576,6 +642,7 @@
let mut in_code = false;
let mut in_link = None;
let mut in_heading = false;
+ let mut in_footnote_definition = false;
let mut is_rust = false;
let mut no_test = false;
let mut ignore = false;
@@ -586,7 +653,11 @@
let mut code_level = 0;
let mut blockquote_level = 0;
- for (event, range) in events {
+ let mut containers = Vec::new();
+
+ let mut events = events.peekable();
+
+ while let Some((event, range)) = events.next() {
match event {
Html(tag) => {
if tag.starts_with("<code") {
@@ -599,8 +670,14 @@
blockquote_level -= 1;
}
},
- Start(BlockQuote) => blockquote_level += 1,
- End(BlockQuote) => blockquote_level -= 1,
+ Start(BlockQuote) => {
+ blockquote_level += 1;
+ containers.push(Container::Blockquote);
+ },
+ End(BlockQuote) => {
+ blockquote_level -= 1;
+ containers.pop();
+ },
Start(CodeBlock(ref kind)) => {
in_code = true;
if let CodeBlockKind::Fenced(lang) = kind {
@@ -633,6 +710,13 @@
if let Start(Heading(_, _, _)) = event {
in_heading = true;
}
+ if let Start(Item) = event {
+ if let Some((_next_event, next_range)) = events.peek() {
+ containers.push(Container::List(next_range.start - range.start));
+ } else {
+ containers.push(Container::List(0));
+ }
+ }
ticks_unbalanced = false;
paragraph_range = range;
},
@@ -640,6 +724,9 @@
if let End(Heading(_, _, _)) = event {
in_heading = false;
}
+ if let End(Item) = event {
+ containers.pop();
+ }
if ticks_unbalanced && let Some(span) = fragments.span(cx, paragraph_range.clone()) {
span_lint_and_help(
cx,
@@ -658,8 +745,27 @@
}
text_to_check = Vec::new();
},
+ Start(FootnoteDefinition(..)) => in_footnote_definition = true,
+ End(FootnoteDefinition(..)) => in_footnote_definition = false,
Start(_tag) | End(_tag) => (), // We don't care about other tags
- SoftBreak | HardBreak | TaskListMarker(_) | Code(_) | Rule => (),
+ SoftBreak | HardBreak => {
+ if !containers.is_empty()
+ && let Some((next_event, next_range)) = events.peek()
+ && let Some(next_span) = fragments.span(cx, next_range.clone())
+ && let Some(span) = fragments.span(cx, range.clone())
+ && !in_footnote_definition
+ && !matches!(next_event, End(_))
+ {
+ lazy_continuation::check(
+ cx,
+ doc,
+ range.end..next_range.start,
+ Span::new(span.hi(), next_span.lo(), span.ctxt(), span.parent()),
+ &containers[..],
+ );
+ }
+ },
+ TaskListMarker(_) | Code(_) | Rule => (),
FootnoteReference(text) | Text(text) => {
paragraph_range.end = range.end;
ticks_unbalanced |= text.contains('`') && !in_code;
@@ -701,6 +807,7 @@
struct FindPanicUnwrap<'a, 'tcx> {
cx: &'a LateContext<'tcx>,
+ is_const: bool,
panic_span: Option<Span>,
typeck_results: &'tcx ty::TypeckResults<'tcx>,
}
@@ -710,14 +817,15 @@
cx: &'a LateContext<'tcx>,
typeck_results: &'tcx ty::TypeckResults<'tcx>,
body: impl Visitable<'tcx>,
- ) -> Option<Span> {
+ ) -> Option<(Span, bool)> {
let mut vis = Self {
cx,
+ is_const: false,
panic_span: None,
typeck_results,
};
body.visit(&mut vis);
- vis.panic_span
+ vis.panic_span.map(|el| (el, vis.is_const))
}
}
@@ -736,6 +844,7 @@
"assert" | "assert_eq" | "assert_ne"
)
{
+ self.is_const = in_constant(self.cx, expr.hir_id);
self.panic_span = Some(macro_call.span);
}
}
diff --git a/src/tools/clippy/clippy_lints/src/escape.rs b/src/tools/clippy/clippy_lints/src/escape.rs
index 6715de5..8d6e277 100644
--- a/src/tools/clippy/clippy_lints/src/escape.rs
+++ b/src/tools/clippy/clippy_lints/src/escape.rs
@@ -104,7 +104,9 @@
too_large_for_stack: self.too_large_for_stack,
};
- ExprUseVisitor::for_clippy(cx, fn_def_id, &mut v).consume_body(body).into_ok();
+ ExprUseVisitor::for_clippy(cx, fn_def_id, &mut v)
+ .consume_body(body)
+ .into_ok();
for node in v.set {
span_lint_hir(
diff --git a/src/tools/clippy/clippy_lints/src/explicit_write.rs b/src/tools/clippy/clippy_lints/src/explicit_write.rs
index 724e184..3c4a043 100644
--- a/src/tools/clippy/clippy_lints/src/explicit_write.rs
+++ b/src/tools/clippy/clippy_lints/src/explicit_write.rs
@@ -1,12 +1,12 @@
use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::macros::{find_format_args, format_args_inputs_span};
+use clippy_utils::macros::{format_args_inputs_span, FormatArgsStorage};
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::{is_expn_of, path_def_id};
use rustc_errors::Applicability;
use rustc_hir::def::Res;
use rustc_hir::{BindingMode, Block, BlockCheckMode, Expr, ExprKind, Node, PatKind, QPath, Stmt, StmtKind};
use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::declare_lint_pass;
+use rustc_session::impl_lint_pass;
use rustc_span::{sym, ExpnId};
declare_clippy_lint! {
@@ -38,7 +38,17 @@
"using the `write!()` family of functions instead of the `print!()` family of functions, when using the latter would work"
}
-declare_lint_pass!(ExplicitWrite => [EXPLICIT_WRITE]);
+pub struct ExplicitWrite {
+ format_args: FormatArgsStorage,
+}
+
+impl ExplicitWrite {
+ pub fn new(format_args: FormatArgsStorage) -> Self {
+ Self { format_args }
+ }
+}
+
+impl_lint_pass!(ExplicitWrite => [EXPLICIT_WRITE]);
impl<'tcx> LateLintPass<'tcx> for ExplicitWrite {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
@@ -57,7 +67,7 @@
Some(sym::io_stderr) => ("stderr", "e"),
_ => return,
};
- let Some(format_args) = find_format_args(cx, write_arg, ExpnId::root()) else {
+ let Some(format_args) = self.format_args.get(cx, write_arg, ExpnId::root()) else {
return;
};
@@ -83,7 +93,7 @@
};
let mut applicability = Applicability::MachineApplicable;
let inputs_snippet =
- snippet_with_applicability(cx, format_args_inputs_span(&format_args), "..", &mut applicability);
+ snippet_with_applicability(cx, format_args_inputs_span(format_args), "..", &mut applicability);
span_lint_and_sugg(
cx,
EXPLICIT_WRITE,
diff --git a/src/tools/clippy/clippy_lints/src/format.rs b/src/tools/clippy/clippy_lints/src/format.rs
index 8a0cd15..0b248f7 100644
--- a/src/tools/clippy/clippy_lints/src/format.rs
+++ b/src/tools/clippy/clippy_lints/src/format.rs
@@ -1,5 +1,5 @@
use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::macros::{find_format_arg_expr, find_format_args, root_macro_call_first_node};
+use clippy_utils::macros::{find_format_arg_expr, root_macro_call_first_node, FormatArgsStorage};
use clippy_utils::source::{snippet_opt, snippet_with_context};
use clippy_utils::sugg::Sugg;
use rustc_ast::{FormatArgsPiece, FormatOptions, FormatTrait};
@@ -7,7 +7,7 @@
use rustc_hir::{Expr, ExprKind};
use rustc_lint::{LateContext, LateLintPass};
use rustc_middle::ty;
-use rustc_session::declare_lint_pass;
+use rustc_session::impl_lint_pass;
use rustc_span::{sym, Span};
declare_clippy_lint! {
@@ -39,13 +39,24 @@
"useless use of `format!`"
}
-declare_lint_pass!(UselessFormat => [USELESS_FORMAT]);
+#[allow(clippy::module_name_repetitions)]
+pub struct UselessFormat {
+ format_args: FormatArgsStorage,
+}
+
+impl UselessFormat {
+ pub fn new(format_args: FormatArgsStorage) -> Self {
+ Self { format_args }
+ }
+}
+
+impl_lint_pass!(UselessFormat => [USELESS_FORMAT]);
impl<'tcx> LateLintPass<'tcx> for UselessFormat {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
if let Some(macro_call) = root_macro_call_first_node(cx, expr)
&& cx.tcx.is_diagnostic_item(sym::format_macro, macro_call.def_id)
- && let Some(format_args) = find_format_args(cx, expr, macro_call.expn)
+ && let Some(format_args) = self.format_args.get(cx, expr, macro_call.expn)
{
let mut applicability = Applicability::MachineApplicable;
let call_site = macro_call.span;
diff --git a/src/tools/clippy/clippy_lints/src/format_args.rs b/src/tools/clippy/clippy_lints/src/format_args.rs
index 003a999..8611580 100644
--- a/src/tools/clippy/clippy_lints/src/format_args.rs
+++ b/src/tools/clippy/clippy_lints/src/format_args.rs
@@ -3,8 +3,8 @@
use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
use clippy_utils::is_diag_trait_item;
use clippy_utils::macros::{
- find_format_arg_expr, find_format_args, format_arg_removal_span, format_placeholder_format_span, is_assert_macro,
- is_format_macro, is_panic, matching_root_macro_call, root_macro_call_first_node, FormatParamUsage, MacroCall,
+ find_format_arg_expr, format_arg_removal_span, format_placeholder_format_span, is_assert_macro, is_format_macro,
+ is_panic, matching_root_macro_call, root_macro_call_first_node, FormatArgsStorage, FormatParamUsage, MacroCall,
};
use clippy_utils::source::snippet_opt;
use clippy_utils::ty::{implements_trait, is_type_lang_item};
@@ -167,15 +167,18 @@
UNUSED_FORMAT_SPECS,
]);
+#[allow(clippy::struct_field_names)]
pub struct FormatArgs {
+ format_args: FormatArgsStorage,
msrv: Msrv,
ignore_mixed: bool,
}
impl FormatArgs {
#[must_use]
- pub fn new(msrv: Msrv, allow_mixed_uninlined_format_args: bool) -> Self {
+ pub fn new(format_args: FormatArgsStorage, msrv: Msrv, allow_mixed_uninlined_format_args: bool) -> Self {
Self {
+ format_args,
msrv,
ignore_mixed: allow_mixed_uninlined_format_args,
}
@@ -186,13 +189,13 @@
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
if let Some(macro_call) = root_macro_call_first_node(cx, expr)
&& is_format_macro(cx, macro_call.def_id)
- && let Some(format_args) = find_format_args(cx, expr, macro_call.expn)
+ && let Some(format_args) = self.format_args.get(cx, expr, macro_call.expn)
{
let linter = FormatArgsExpr {
cx,
expr,
macro_call: ¯o_call,
- format_args: &format_args,
+ format_args,
ignore_mixed: self.ignore_mixed,
};
diff --git a/src/tools/clippy/clippy_lints/src/format_impl.rs b/src/tools/clippy/clippy_lints/src/format_impl.rs
index 0a52347..09be723 100644
--- a/src/tools/clippy/clippy_lints/src/format_impl.rs
+++ b/src/tools/clippy/clippy_lints/src/format_impl.rs
@@ -1,5 +1,5 @@
use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
-use clippy_utils::macros::{find_format_arg_expr, find_format_args, is_format_macro, root_macro_call_first_node};
+use clippy_utils::macros::{find_format_arg_expr, is_format_macro, root_macro_call_first_node, FormatArgsStorage};
use clippy_utils::{get_parent_as_impl, is_diag_trait_item, path_to_local, peel_ref_operators};
use rustc_ast::{FormatArgsPiece, FormatTrait};
use rustc_errors::Applicability;
@@ -99,13 +99,15 @@
#[derive(Default)]
pub struct FormatImpl {
+ format_args: FormatArgsStorage,
// Whether we are inside Display or Debug trait impl - None for neither
format_trait_impl: Option<FormatTraitNames>,
}
impl FormatImpl {
- pub fn new() -> Self {
+ pub fn new(format_args: FormatArgsStorage) -> Self {
Self {
+ format_args,
format_trait_impl: None,
}
}
@@ -129,6 +131,7 @@
if let Some(format_trait_impl) = self.format_trait_impl {
let linter = FormatImplExpr {
cx,
+ format_args: &self.format_args,
expr,
format_trait_impl,
};
@@ -141,6 +144,7 @@
struct FormatImplExpr<'a, 'tcx> {
cx: &'a LateContext<'tcx>,
+ format_args: &'a FormatArgsStorage,
expr: &'tcx Expr<'tcx>,
format_trait_impl: FormatTraitNames,
}
@@ -175,7 +179,7 @@
if let Some(outer_macro) = root_macro_call_first_node(self.cx, self.expr)
&& let macro_def_id = outer_macro.def_id
&& is_format_macro(self.cx, macro_def_id)
- && let Some(format_args) = find_format_args(self.cx, self.expr, outer_macro.expn)
+ && let Some(format_args) = self.format_args.get(self.cx, self.expr, outer_macro.expn)
{
for piece in &format_args.template {
if let FormatArgsPiece::Placeholder(placeholder) = piece
diff --git a/src/tools/clippy/clippy_lints/src/from_str_radix_10.rs b/src/tools/clippy/clippy_lints/src/from_str_radix_10.rs
index 633ed96..82ce501 100644
--- a/src/tools/clippy/clippy_lints/src/from_str_radix_10.rs
+++ b/src/tools/clippy/clippy_lints/src/from_str_radix_10.rs
@@ -1,7 +1,7 @@
use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_integer_literal;
use clippy_utils::sugg::Sugg;
use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
+use clippy_utils::{in_constant, is_integer_literal};
use rustc_errors::Applicability;
use rustc_hir::{def, Expr, ExprKind, LangItem, PrimTy, QPath, TyKind};
use rustc_lint::{LateContext, LateLintPass};
@@ -47,6 +47,9 @@
fn check_expr(&mut self, cx: &LateContext<'tcx>, exp: &Expr<'tcx>) {
if let ExprKind::Call(maybe_path, [src, radix]) = &exp.kind
&& let ExprKind::Path(QPath::TypeRelative(ty, pathseg)) = &maybe_path.kind
+ // do not lint in constant context, because the suggestion won't work.
+ // NB: keep this check until a new `const_trait_impl` is available and stablized.
+ && !in_constant(cx, exp.hir_id)
// check if the first part of the path is some integer primitive
&& let TyKind::Path(ty_qpath) = &ty.kind
diff --git a/src/tools/clippy/clippy_lints/src/functions/mod.rs b/src/tools/clippy/clippy_lints/src/functions/mod.rs
index 9cc51fa..dfcaac9 100644
--- a/src/tools/clippy/clippy_lints/src/functions/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/functions/mod.rs
@@ -2,15 +2,17 @@
mod misnamed_getters;
mod must_use;
mod not_unsafe_ptr_arg_deref;
+mod renamed_function_params;
mod result;
mod too_many_arguments;
mod too_many_lines;
+use clippy_utils::def_path_def_ids;
use rustc_hir as hir;
use rustc_hir::intravisit;
use rustc_lint::{LateContext, LateLintPass};
use rustc_session::impl_lint_pass;
-use rustc_span::def_id::LocalDefId;
+use rustc_span::def_id::{DefIdSet, LocalDefId};
use rustc_span::Span;
declare_clippy_lint! {
@@ -359,13 +361,51 @@
"`impl Trait` is used in the function's parameters"
}
-#[derive(Copy, Clone)]
-#[allow(clippy::struct_field_names)]
+declare_clippy_lint! {
+ /// ### What it does
+ /// Lints when the name of function parameters from trait impl is
+ /// different than its default implementation.
+ ///
+ /// ### Why is this bad?
+ /// Using the default name for parameters of a trait method is often
+ /// more desirable for consistency's sake.
+ ///
+ /// ### Example
+ /// ```rust
+ /// struct A(u32);
+ ///
+ /// impl PartialEq for A {
+ /// fn eq(&self, b: &Self) -> bool {
+ /// self.0 == b.0
+ /// }
+ /// }
+ /// ```
+ /// Use instead:
+ /// ```rust
+ /// struct A(u32);
+ ///
+ /// impl PartialEq for A {
+ /// fn eq(&self, other: &Self) -> bool {
+ /// self.0 == other.0
+ /// }
+ /// }
+ /// ```
+ #[clippy::version = "1.74.0"]
+ pub RENAMED_FUNCTION_PARAMS,
+ restriction,
+ "renamed function parameters in trait implementation"
+}
+
+#[derive(Clone)]
pub struct Functions {
too_many_arguments_threshold: u64,
too_many_lines_threshold: u64,
large_error_threshold: u64,
avoid_breaking_exported_api: bool,
+ allow_renamed_params_for: Vec<String>,
+ /// A set of resolved `def_id` of traits that are configured to allow
+ /// function params renaming.
+ trait_ids: DefIdSet,
}
impl Functions {
@@ -374,12 +414,15 @@
too_many_lines_threshold: u64,
large_error_threshold: u64,
avoid_breaking_exported_api: bool,
+ allow_renamed_params_for: Vec<String>,
) -> Self {
Self {
too_many_arguments_threshold,
too_many_lines_threshold,
large_error_threshold,
avoid_breaking_exported_api,
+ allow_renamed_params_for,
+ trait_ids: DefIdSet::default(),
}
}
}
@@ -395,6 +438,7 @@
RESULT_LARGE_ERR,
MISNAMED_GETTERS,
IMPL_TRAIT_IN_PARAMS,
+ RENAMED_FUNCTION_PARAMS,
]);
impl<'tcx> LateLintPass<'tcx> for Functions {
@@ -424,6 +468,7 @@
must_use::check_impl_item(cx, item);
result::check_impl_item(cx, item, self.large_error_threshold);
impl_trait_in_params::check_impl_item(cx, item);
+ renamed_function_params::check_impl_item(cx, item, &self.trait_ids);
}
fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'_>) {
@@ -433,4 +478,12 @@
result::check_trait_item(cx, item, self.large_error_threshold);
impl_trait_in_params::check_trait_item(cx, item, self.avoid_breaking_exported_api);
}
+
+ fn check_crate(&mut self, cx: &LateContext<'tcx>) {
+ for path in &self.allow_renamed_params_for {
+ let path_segments: Vec<&str> = path.split("::").collect();
+ let ids = def_path_def_ids(cx, &path_segments);
+ self.trait_ids.extend(ids);
+ }
+ }
}
diff --git a/src/tools/clippy/clippy_lints/src/functions/renamed_function_params.rs b/src/tools/clippy/clippy_lints/src/functions/renamed_function_params.rs
new file mode 100644
index 0000000..c7de038
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/functions/renamed_function_params.rs
@@ -0,0 +1,110 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_errors::{Applicability, MultiSpan};
+use rustc_hir::def_id::{DefId, DefIdSet};
+use rustc_hir::hir_id::OwnerId;
+use rustc_hir::{Impl, ImplItem, ImplItemKind, ImplItemRef, ItemKind, Node, TraitRef};
+use rustc_lint::LateContext;
+use rustc_span::symbol::{kw, Ident, Symbol};
+use rustc_span::Span;
+
+use super::RENAMED_FUNCTION_PARAMS;
+
+pub(super) fn check_impl_item(cx: &LateContext<'_>, item: &ImplItem<'_>, ignored_traits: &DefIdSet) {
+ if !item.span.from_expansion()
+ && let ImplItemKind::Fn(_, body_id) = item.kind
+ && let parent_node = cx.tcx.parent_hir_node(item.hir_id())
+ && let Node::Item(parent_item) = parent_node
+ && let ItemKind::Impl(Impl {
+ items,
+ of_trait: Some(trait_ref),
+ ..
+ }) = &parent_item.kind
+ && let Some(did) = trait_item_def_id_of_impl(items, item.owner_id)
+ && !is_from_ignored_trait(trait_ref, ignored_traits)
+ {
+ let mut param_idents_iter = cx.tcx.hir().body_param_names(body_id);
+ let mut default_param_idents_iter = cx.tcx.fn_arg_names(did).iter().copied();
+
+ let renames = RenamedFnArgs::new(&mut default_param_idents_iter, &mut param_idents_iter);
+ if !renames.0.is_empty() {
+ let multi_span = renames.multi_span();
+ let plural = if renames.0.len() == 1 { "" } else { "s" };
+ span_lint_and_then(
+ cx,
+ RENAMED_FUNCTION_PARAMS,
+ multi_span,
+ format!("renamed function parameter{plural} of trait impl"),
+ |diag| {
+ diag.multipart_suggestion(
+ format!("consider using the default name{plural}"),
+ renames.0,
+ Applicability::Unspecified,
+ );
+ },
+ );
+ }
+ }
+}
+
+struct RenamedFnArgs(Vec<(Span, String)>);
+
+impl RenamedFnArgs {
+ /// Comparing between an iterator of default names and one with current names,
+ /// then collect the ones that got renamed.
+ fn new<I, T>(default_names: &mut I, current_names: &mut T) -> Self
+ where
+ I: Iterator<Item = Ident>,
+ T: Iterator<Item = Ident>,
+ {
+ let mut renamed: Vec<(Span, String)> = vec![];
+
+ debug_assert!(default_names.size_hint() == current_names.size_hint());
+ while let (Some(def_name), Some(cur_name)) = (default_names.next(), current_names.next()) {
+ let current_name = cur_name.name;
+ let default_name = def_name.name;
+ if is_unused_or_empty_symbol(current_name) || is_unused_or_empty_symbol(default_name) {
+ continue;
+ }
+ if current_name != default_name {
+ renamed.push((cur_name.span, default_name.to_string()));
+ }
+ }
+
+ Self(renamed)
+ }
+
+ fn multi_span(&self) -> MultiSpan {
+ self.0
+ .iter()
+ .map(|(span, _)| span)
+ .copied()
+ .collect::<Vec<Span>>()
+ .into()
+ }
+}
+
+fn is_unused_or_empty_symbol(symbol: Symbol) -> bool {
+ // FIXME: `body_param_names` currently returning empty symbols for `wild` as well,
+ // so we need to check if the symbol is empty first.
+ // Therefore the check of whether it's equal to [`kw::Underscore`] has no use for now,
+ // but it would be nice to keep it here just to be future-proof.
+ symbol.is_empty() || symbol == kw::Underscore || symbol.as_str().starts_with('_')
+}
+
+/// Get the [`trait_item_def_id`](ImplItemRef::trait_item_def_id) of a relevant impl item.
+fn trait_item_def_id_of_impl(items: &[ImplItemRef], target: OwnerId) -> Option<DefId> {
+ items.iter().find_map(|item| {
+ if item.id.owner_id == target {
+ item.trait_item_def_id
+ } else {
+ None
+ }
+ })
+}
+
+fn is_from_ignored_trait(of_trait: &TraitRef<'_>, ignored_traits: &DefIdSet) -> bool {
+ let Some(trait_did) = of_trait.trait_def_id() else {
+ return false;
+ };
+ ignored_traits.contains(&trait_did)
+}
diff --git a/src/tools/clippy/clippy_lints/src/future_not_send.rs b/src/tools/clippy/clippy_lints/src/future_not_send.rs
index 2c2daac..192fb61 100644
--- a/src/tools/clippy/clippy_lints/src/future_not_send.rs
+++ b/src/tools/clippy/clippy_lints/src/future_not_send.rs
@@ -4,8 +4,8 @@
use rustc_hir::{Body, FnDecl};
use rustc_infer::infer::TyCtxtInferExt;
use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::ty::{self, AliasTy, ClauseKind, PredicateKind};
use rustc_middle::ty::print::PrintTraitRefExt;
+use rustc_middle::ty::{self, AliasTy, ClauseKind, PredicateKind};
use rustc_session::declare_lint_pass;
use rustc_span::def_id::LocalDefId;
use rustc_span::{sym, Span};
diff --git a/src/tools/clippy/clippy_lints/src/lib.rs b/src/tools/clippy/clippy_lints/src/lib.rs
index a8bfbbd..3328d64 100644
--- a/src/tools/clippy/clippy_lints/src/lib.rs
+++ b/src/tools/clippy/clippy_lints/src/lib.rs
@@ -61,11 +61,6 @@
#[macro_use]
extern crate declare_clippy_lint;
-use std::collections::BTreeMap;
-
-use rustc_data_structures::fx::FxHashSet;
-use rustc_lint::{Lint, LintId};
-
#[cfg(feature = "internal")]
pub mod deprecated_lints;
#[cfg_attr(feature = "internal", allow(clippy::missing_clippy_version_attribute))]
@@ -199,6 +194,7 @@
mod lines_filter_map_ok;
mod literal_representation;
mod loops;
+mod macro_metavars_in_unsafe;
mod macro_use;
mod main_recursion;
mod manual_assert;
@@ -385,6 +381,10 @@
// end lints modules, do not remove this comment, it’s used in `update_lints`
use clippy_config::{get_configuration_metadata, Conf};
+use clippy_utils::macros::FormatArgsStorage;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_lint::{Lint, LintId};
+use std::collections::BTreeMap;
/// Register all pre expansion lints
///
@@ -533,6 +533,7 @@
allow_expect_in_tests,
allow_mixed_uninlined_format_args,
allow_one_hash_in_raw_strings,
+ allow_panic_in_tests,
allow_print_in_tests,
allow_private_module_inception,
allow_unwrap_in_tests,
@@ -597,9 +598,11 @@
ref allowed_duplicate_crates,
allow_comparison_to_zero,
ref allowed_prefixes,
+ ref allow_renamed_params_for,
blacklisted_names: _,
cyclomatic_complexity_threshold: _,
+ warn_unsafe_macro_metavars_in_private_macros,
} = *conf;
let msrv = || msrv.clone();
@@ -616,6 +619,14 @@
}
}
+ let format_args_storage = FormatArgsStorage::default();
+ let format_args = format_args_storage.clone();
+ store.register_early_pass(move || {
+ Box::new(utils::format_args_collector::FormatArgsCollector::new(
+ format_args.clone(),
+ ))
+ });
+
// all the internal lints
#[cfg(feature = "internal")]
{
@@ -656,7 +667,6 @@
.collect(),
))
});
- store.register_early_pass(|| Box::<utils::format_args_collector::FormatArgsCollector>::default());
store.register_late_pass(|_| Box::new(utils::dump_hir::DumpHir));
store.register_late_pass(|_| Box::new(utils::author::Author));
store.register_late_pass(move |_| {
@@ -698,6 +708,7 @@
store.register_late_pass(|_| Box::new(non_octal_unix_permissions::NonOctalUnixPermissions));
store.register_early_pass(|| Box::new(unnecessary_self_imports::UnnecessarySelfImports));
store.register_late_pass(move |_| Box::new(approx_const::ApproxConstant::new(msrv())));
+ let format_args = format_args_storage.clone();
store.register_late_pass(move |_| {
Box::new(methods::Methods::new(
avoid_breaking_exported_api,
@@ -705,6 +716,7 @@
allow_expect_in_tests,
allow_unwrap_in_tests,
allowed_dotfiles.clone(),
+ format_args.clone(),
))
});
store.register_late_pass(move |_| Box::new(matches::Matches::new(msrv())));
@@ -759,7 +771,7 @@
allow_in_test: allow_useless_vec_in_tests,
})
});
- store.register_late_pass(|_| Box::new(panic_unimplemented::PanicUnimplemented));
+ store.register_late_pass(move |_| Box::new(panic_unimplemented::PanicUnimplemented { allow_panic_in_tests }));
store.register_late_pass(|_| Box::new(strings::StringLitAsBytes));
store.register_late_pass(|_| Box::new(derive::Derive));
store.register_late_pass(move |_| Box::new(derivable_impls::DerivableImpls::new(msrv())));
@@ -769,7 +781,8 @@
store.register_late_pass(|_| Box::<regex::Regex>::default());
store.register_late_pass(move |_| Box::new(copies::CopyAndPaste::new(ignore_interior_mutability.clone())));
store.register_late_pass(|_| Box::new(copy_iterator::CopyIterator));
- store.register_late_pass(|_| Box::new(format::UselessFormat));
+ let format_args = format_args_storage.clone();
+ store.register_late_pass(move |_| Box::new(format::UselessFormat::new(format_args.clone())));
store.register_late_pass(|_| Box::new(swap::Swap));
store.register_late_pass(|_| Box::new(overflow_check_conditional::OverflowCheckConditional));
store.register_late_pass(|_| Box::<new_without_default::NewWithoutDefault>::default());
@@ -780,6 +793,7 @@
too_many_lines_threshold,
large_error_threshold,
avoid_breaking_exported_api,
+ allow_renamed_params_for.clone(),
))
});
store.register_late_pass(move |_| Box::new(doc::Documentation::new(doc_valid_idents, check_private_items)));
@@ -793,7 +807,8 @@
store.register_late_pass(|_| Box::new(partialeq_ne_impl::PartialEqNeImpl));
store.register_late_pass(|_| Box::new(unused_io_amount::UnusedIoAmount));
store.register_late_pass(move |_| Box::new(large_enum_variant::LargeEnumVariant::new(enum_variant_size_threshold)));
- store.register_late_pass(|_| Box::new(explicit_write::ExplicitWrite));
+ let format_args = format_args_storage.clone();
+ store.register_late_pass(move |_| Box::new(explicit_write::ExplicitWrite::new(format_args.clone())));
store.register_late_pass(|_| Box::new(needless_pass_by_value::NeedlessPassByValue));
store.register_late_pass(move |tcx| {
Box::new(pass_by_ref_or_value::PassByRefOrValue::new(
@@ -835,7 +850,8 @@
store.register_late_pass(move |_| Box::new(mut_key::MutableKeyType::new(ignore_interior_mutability.clone())));
store.register_early_pass(|| Box::new(reference::DerefAddrOf));
store.register_early_pass(|| Box::new(double_parens::DoubleParens));
- store.register_late_pass(|_| Box::new(format_impl::FormatImpl::new()));
+ let format_args = format_args_storage.clone();
+ store.register_late_pass(move |_| Box::new(format_impl::FormatImpl::new(format_args.clone())));
store.register_early_pass(|| Box::new(unsafe_removed_from_name::UnsafeNameRemoval));
store.register_early_pass(|| Box::new(else_if_without_else::ElseIfWithoutElse));
store.register_early_pass(|| Box::new(int_plus_one::IntPlusOne));
@@ -961,8 +977,14 @@
accept_comment_above_attributes,
))
});
- store
- .register_late_pass(move |_| Box::new(format_args::FormatArgs::new(msrv(), allow_mixed_uninlined_format_args)));
+ let format_args = format_args_storage.clone();
+ store.register_late_pass(move |_| {
+ Box::new(format_args::FormatArgs::new(
+ format_args.clone(),
+ msrv(),
+ allow_mixed_uninlined_format_args,
+ ))
+ });
store.register_late_pass(|_| Box::new(trailing_empty_array::TrailingEmptyArray));
store.register_early_pass(|| Box::new(octal_escapes::OctalEscapes));
store.register_late_pass(|_| Box::new(needless_late_init::NeedlessLateInit));
@@ -973,7 +995,8 @@
store.register_late_pass(|_| Box::new(default_union_representation::DefaultUnionRepresentation));
store.register_late_pass(|_| Box::<only_used_in_recursion::OnlyUsedInRecursion>::default());
store.register_late_pass(move |_| Box::new(dbg_macro::DbgMacro::new(allow_dbg_in_tests)));
- store.register_late_pass(move |_| Box::new(write::Write::new(allow_print_in_tests)));
+ let format_args = format_args_storage.clone();
+ store.register_late_pass(move |_| Box::new(write::Write::new(format_args.clone(), allow_print_in_tests)));
store.register_late_pass(move |_| {
Box::new(cargo::Cargo {
ignore_publish: cargo_ignore_publish,
@@ -1136,6 +1159,12 @@
store.register_late_pass(|_| Box::new(zero_repeat_side_effects::ZeroRepeatSideEffects));
store.register_late_pass(|_| Box::new(manual_unwrap_or_default::ManualUnwrapOrDefault));
store.register_late_pass(|_| Box::new(integer_division_remainder_used::IntegerDivisionRemainderUsed));
+ store.register_late_pass(move |_| {
+ Box::new(macro_metavars_in_unsafe::ExprMetavarsInUnsafe {
+ warn_unsafe_macro_metavars_in_private_macros,
+ ..Default::default()
+ })
+ });
// add lints here, do not remove this comment, it's used in `new_lint`
}
diff --git a/src/tools/clippy/clippy_lints/src/loops/mod.rs b/src/tools/clippy/clippy_lints/src/loops/mod.rs
index b5e39b3..3dcb050 100644
--- a/src/tools/clippy/clippy_lints/src/loops/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/mod.rs
@@ -17,6 +17,7 @@
mod single_element_loop;
mod unused_enumerate_index;
mod utils;
+mod while_float;
mod while_immutable_condition;
mod while_let_loop;
mod while_let_on_iterator;
@@ -418,6 +419,39 @@
declare_clippy_lint! {
/// ### What it does
+ /// Checks for while loops comparing floating point values.
+ ///
+ /// ### Why is this bad?
+ /// If you increment floating point values, errors can compound,
+ /// so, use integers instead if possible.
+ ///
+ /// ### Known problems
+ /// The lint will catch all while loops comparing floating point
+ /// values without regarding the increment.
+ ///
+ /// ### Example
+ /// ```no_run
+ /// let mut x = 0.0;
+ /// while x < 42.0 {
+ /// x += 1.0;
+ /// }
+ /// ```
+ ///
+ /// Use instead:
+ /// ```no_run
+ /// let mut x = 0;
+ /// while x < 42 {
+ /// x += 1;
+ /// }
+ /// ```
+ #[clippy::version = "1.80.0"]
+ pub WHILE_FLOAT,
+ nursery,
+ "while loops comaparing floating point values"
+}
+
+declare_clippy_lint! {
+ /// ### What it does
/// Checks whether a for loop is being used to push a constant
/// value into a Vec.
///
@@ -706,6 +740,7 @@
NEVER_LOOP,
MUT_RANGE_BOUND,
WHILE_IMMUTABLE_CONDITION,
+ WHILE_FLOAT,
SAME_ITEM_PUSH,
SINGLE_ELEMENT_LOOP,
MISSING_SPIN_LOOP,
@@ -762,6 +797,7 @@
if let Some(higher::While { condition, body, span }) = higher::While::hir(expr) {
while_immutable_condition::check(cx, condition, body);
+ while_float::check(cx, condition);
missing_spin_loop::check(cx, condition, body);
manual_while_let_some::check(cx, condition, body, span);
}
diff --git a/src/tools/clippy/clippy_lints/src/loops/mut_range_bound.rs b/src/tools/clippy/clippy_lints/src/loops/mut_range_bound.rs
index 6b9ecf5..6c6a9a1 100644
--- a/src/tools/clippy/clippy_lints/src/loops/mut_range_bound.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/mut_range_bound.rs
@@ -60,12 +60,9 @@
span_low: None,
span_high: None,
};
- ExprUseVisitor::for_clippy(
- cx,
- body.hir_id.owner.def_id,
- &mut delegate,
- )
- .walk_expr(body).into_ok();
+ ExprUseVisitor::for_clippy(cx, body.hir_id.owner.def_id, &mut delegate)
+ .walk_expr(body)
+ .into_ok();
delegate.mutation_span()
}
diff --git a/src/tools/clippy/clippy_lints/src/loops/while_float.rs b/src/tools/clippy/clippy_lints/src/loops/while_float.rs
new file mode 100644
index 0000000..cf62ce2
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/loops/while_float.rs
@@ -0,0 +1,20 @@
+use clippy_utils::diagnostics::span_lint;
+use rustc_hir::ExprKind;
+
+pub(super) fn check(cx: &rustc_lint::LateContext<'_>, condition: &rustc_hir::Expr<'_>) {
+ if let ExprKind::Binary(_op, left, right) = condition.kind
+ && is_float_type(cx, left)
+ && is_float_type(cx, right)
+ {
+ span_lint(
+ cx,
+ super::WHILE_FLOAT,
+ condition.span,
+ "while condition comparing floats",
+ );
+ }
+}
+
+fn is_float_type(cx: &rustc_lint::LateContext<'_>, expr: &rustc_hir::Expr<'_>) -> bool {
+ cx.typeck_results().expr_ty(expr).is_floating_point()
+}
diff --git a/src/tools/clippy/clippy_lints/src/macro_metavars_in_unsafe.rs b/src/tools/clippy/clippy_lints/src/macro_metavars_in_unsafe.rs
new file mode 100644
index 0000000..aea3d26
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/macro_metavars_in_unsafe.rs
@@ -0,0 +1,256 @@
+use std::collections::btree_map::Entry;
+use std::collections::BTreeMap;
+
+use clippy_utils::diagnostics::span_lint_hir_and_then;
+use clippy_utils::is_lint_allowed;
+use itertools::Itertools;
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::intravisit::{walk_block, walk_expr, walk_stmt, Visitor};
+use rustc_hir::{BlockCheckMode, Expr, ExprKind, HirId, Stmt, UnsafeSource};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::impl_lint_pass;
+use rustc_span::{sym, Span, SyntaxContext};
+
+declare_clippy_lint! {
+ /// ### What it does
+ /// Looks for macros that expand metavariables in an unsafe block.
+ ///
+ /// ### Why is this bad?
+ /// This hides an unsafe block and allows the user of the macro to write unsafe code without an explicit
+ /// unsafe block at callsite, making it possible to perform unsafe operations in seemingly safe code.
+ ///
+ /// The macro should be restructured so that these metavariables are referenced outside of unsafe blocks
+ /// and that the usual unsafety checks apply to the macro argument.
+ ///
+ /// This is usually done by binding it to a variable outside of the unsafe block
+ /// and then using that variable inside of the block as shown in the example, or by referencing it a second time
+ /// in a safe context, e.g. `if false { $expr }`.
+ ///
+ /// ### Known limitations
+ /// Due to how macros are represented in the compiler at the time Clippy runs its lints,
+ /// it's not possible to look for metavariables in macro definitions directly.
+ ///
+ /// Instead, this lint looks at expansions of macros.
+ /// This leads to false negatives for macros that are never actually invoked.
+ ///
+ /// By default, this lint is rather conservative and will only emit warnings on publicly-exported
+ /// macros from the same crate, because oftentimes private internal macros are one-off macros where
+ /// this lint would just be noise (e.g. macros that generate `impl` blocks).
+ /// The default behavior should help with preventing a high number of such false positives,
+ /// however it can be configured to also emit warnings in private macros if desired.
+ ///
+ /// ### Example
+ /// ```no_run
+ /// /// Gets the first element of a slice
+ /// macro_rules! first {
+ /// ($slice:expr) => {
+ /// unsafe {
+ /// let slice = $slice; // ⚠️ expansion inside of `unsafe {}`
+ ///
+ /// assert!(!slice.is_empty());
+ /// // SAFETY: slice is checked to have at least one element
+ /// slice.first().unwrap_unchecked()
+ /// }
+ /// }
+ /// }
+ ///
+ /// assert_eq!(*first!(&[1i32]), 1);
+ ///
+ /// // This will compile as a consequence (note the lack of `unsafe {}`)
+ /// assert_eq!(*first!(std::hint::unreachable_unchecked() as &[i32]), 1);
+ /// ```
+ /// Use instead:
+ /// ```compile_fail
+ /// macro_rules! first {
+ /// ($slice:expr) => {{
+ /// let slice = $slice; // ✅ outside of `unsafe {}`
+ /// unsafe {
+ /// assert!(!slice.is_empty());
+ /// // SAFETY: slice is checked to have at least one element
+ /// slice.first().unwrap_unchecked()
+ /// }
+ /// }}
+ /// }
+ ///
+ /// assert_eq!(*first!(&[1]), 1);
+ ///
+ /// // This won't compile:
+ /// assert_eq!(*first!(std::hint::unreachable_unchecked() as &[i32]), 1);
+ /// ```
+ #[clippy::version = "1.80.0"]
+ pub MACRO_METAVARS_IN_UNSAFE,
+ suspicious,
+ "expanding macro metavariables in an unsafe block"
+}
+impl_lint_pass!(ExprMetavarsInUnsafe => [MACRO_METAVARS_IN_UNSAFE]);
+
+#[derive(Clone, Debug)]
+pub enum MetavarState {
+ ReferencedInUnsafe { unsafe_blocks: Vec<HirId> },
+ ReferencedInSafe,
+}
+
+#[derive(Default)]
+pub struct ExprMetavarsInUnsafe {
+ pub warn_unsafe_macro_metavars_in_private_macros: bool,
+ /// A metavariable can be expanded more than once, potentially across multiple bodies, so it
+ /// requires some state kept across HIR nodes to make it possible to delay a warning
+ /// and later undo:
+ ///
+ /// ```ignore
+ /// macro_rules! x {
+ /// ($v:expr) => {
+ /// unsafe { $v; } // unsafe context, it might be possible to emit a warning here, so add it to the map
+ ///
+ /// $v; // `$v` expanded another time but in a safe context, set to ReferencedInSafe to suppress
+ /// }
+ /// }
+ /// ```
+ pub metavar_expns: BTreeMap<Span, MetavarState>,
+}
+
+struct BodyVisitor<'a, 'tcx> {
+ /// Stack of unsafe blocks -- the top item always represents the last seen unsafe block from
+ /// within a relevant macro.
+ macro_unsafe_blocks: Vec<HirId>,
+ /// When this is >0, it means that the node currently being visited is "within" a
+ /// macro definition. This is not necessary for correctness, it merely helps reduce the number
+ /// of spans we need to insert into the map, since only spans from macros are relevant.
+ expn_depth: u32,
+ cx: &'a LateContext<'tcx>,
+ lint: &'a mut ExprMetavarsInUnsafe,
+}
+
+fn is_public_macro(cx: &LateContext<'_>, def_id: LocalDefId) -> bool {
+ (cx.effective_visibilities.is_exported(def_id) || cx.tcx.has_attr(def_id, sym::macro_export))
+ && !cx.tcx.is_doc_hidden(def_id)
+}
+
+impl<'a, 'tcx> Visitor<'tcx> for BodyVisitor<'a, 'tcx> {
+ fn visit_stmt(&mut self, s: &'tcx Stmt<'tcx>) {
+ let from_expn = s.span.from_expansion();
+ if from_expn {
+ self.expn_depth += 1;
+ }
+ walk_stmt(self, s);
+ if from_expn {
+ self.expn_depth -= 1;
+ }
+ }
+
+ fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
+ let ctxt = e.span.ctxt();
+
+ if let ExprKind::Block(block, _) = e.kind
+ && let BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) = block.rules
+ && !ctxt.is_root()
+ && let Some(macro_def_id) = ctxt.outer_expn_data().macro_def_id
+ && let Some(macro_def_id) = macro_def_id.as_local()
+ && (self.lint.warn_unsafe_macro_metavars_in_private_macros || is_public_macro(self.cx, macro_def_id))
+ {
+ self.macro_unsafe_blocks.push(block.hir_id);
+ walk_block(self, block);
+ self.macro_unsafe_blocks.pop();
+ } else if ctxt.is_root() && self.expn_depth > 0 {
+ let unsafe_block = self.macro_unsafe_blocks.last().copied();
+
+ match (self.lint.metavar_expns.entry(e.span), unsafe_block) {
+ (Entry::Vacant(e), None) => {
+ e.insert(MetavarState::ReferencedInSafe);
+ },
+ (Entry::Vacant(e), Some(unsafe_block)) => {
+ e.insert(MetavarState::ReferencedInUnsafe {
+ unsafe_blocks: vec![unsafe_block],
+ });
+ },
+ (Entry::Occupied(mut e), None) => {
+ if let MetavarState::ReferencedInUnsafe { .. } = *e.get() {
+ e.insert(MetavarState::ReferencedInSafe);
+ }
+ },
+ (Entry::Occupied(mut e), Some(unsafe_block)) => {
+ if let MetavarState::ReferencedInUnsafe { unsafe_blocks } = e.get_mut()
+ && !unsafe_blocks.contains(&unsafe_block)
+ {
+ unsafe_blocks.push(unsafe_block);
+ }
+ },
+ }
+
+ // NB: No need to visit descendant nodes. They're guaranteed to represent the same
+ // metavariable
+ } else {
+ walk_expr(self, e);
+ }
+ }
+}
+
+impl<'tcx> LateLintPass<'tcx> for ExprMetavarsInUnsafe {
+ fn check_body(&mut self, cx: &LateContext<'tcx>, body: &'tcx rustc_hir::Body<'tcx>) {
+ if is_lint_allowed(cx, MACRO_METAVARS_IN_UNSAFE, body.value.hir_id) {
+ return;
+ }
+
+ // This BodyVisitor is separate and not part of the lint pass because there is no
+ // `check_stmt_post` on `(Late)LintPass`, which we'd need to detect when we're leaving a macro span
+
+ let mut vis = BodyVisitor {
+ #[expect(clippy::bool_to_int_with_if)] // obfuscates the meaning
+ expn_depth: if body.value.span.from_expansion() { 1 } else { 0 },
+ macro_unsafe_blocks: Vec::new(),
+ lint: self,
+ cx
+ };
+ vis.visit_body(body);
+ }
+
+ fn check_crate_post(&mut self, cx: &LateContext<'tcx>) {
+ // Aggregate all unsafe blocks from all spans:
+ // ```
+ // macro_rules! x {
+ // ($w:expr, $x:expr, $y:expr) => { $w; unsafe { $w; $x; }; unsafe { $x; $y; }; }
+ // }
+ // $w: [] (unsafe#0 is never added because it was referenced in a safe context)
+ // $x: [unsafe#0, unsafe#1]
+ // $y: [unsafe#1]
+ // ```
+ // We want to lint unsafe blocks #0 and #1
+ let bad_unsafe_blocks = self
+ .metavar_expns
+ .iter()
+ .filter_map(|(_, state)| match state {
+ MetavarState::ReferencedInUnsafe { unsafe_blocks } => Some(unsafe_blocks.as_slice()),
+ MetavarState::ReferencedInSafe => None,
+ })
+ .flatten()
+ .copied()
+ .map(|id| {
+ // Remove the syntax context to hide "in this macro invocation" in the diagnostic.
+ // The invocation doesn't matter. Also we want to dedupe by the unsafe block and not by anything
+ // related to the callsite.
+ let span = cx.tcx.hir().span(id);
+
+ (id, Span::new(span.lo(), span.hi(), SyntaxContext::root(), None))
+ })
+ .dedup_by(|&(_, a), &(_, b)| a == b);
+
+ for (id, span) in bad_unsafe_blocks {
+ span_lint_hir_and_then(
+ cx,
+ MACRO_METAVARS_IN_UNSAFE,
+ id,
+ span,
+ "this macro expands metavariables in an unsafe block",
+ |diag| {
+ diag.note("this allows the user of the macro to write unsafe code outside of an unsafe block");
+ diag.help(
+ "consider expanding any metavariables outside of this block, e.g. by storing them in a variable",
+ );
+ diag.help(
+ "... or also expand referenced metavariables in a safe context to require an unsafe block at callsite",
+ );
+ },
+ );
+ }
+ }
+}
diff --git a/src/tools/clippy/clippy_lints/src/manual_clamp.rs b/src/tools/clippy/clippy_lints/src/manual_clamp.rs
index 1eadc20..e2ab441 100644
--- a/src/tools/clippy/clippy_lints/src/manual_clamp.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_clamp.rs
@@ -611,15 +611,22 @@
/// The clamp meta pattern is a pattern shared between many (but not all) patterns.
/// In summary, this pattern consists of two if statements that meet many criteria,
+///
/// - binary operators that are one of [`>`, `<`, `>=`, `<=`].
+///
/// - Both binary statements must have a shared argument
+///
/// - Which can appear on the left or right side of either statement
+///
/// - The binary operators must define a finite range for the shared argument. To put this in
/// the terms of Rust `std` library, the following ranges are acceptable
+///
/// - `Range`
/// - `RangeInclusive`
+///
/// And all other range types are not accepted. For the purposes of `clamp` it's irrelevant
/// whether the range is inclusive or not, the output is the same.
+///
/// - The result of each if statement must be equal to the argument unique to that if statement. The
/// result can not be the shared argument in either case.
fn is_clamp_meta_pattern<'tcx>(
diff --git a/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs b/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs
index cd61e73..da8c918 100644
--- a/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/match_same_arms.rs
@@ -1,5 +1,5 @@
use clippy_utils::diagnostics::span_lint_hir_and_then;
-use clippy_utils::source::snippet;
+use clippy_utils::source::snippet_with_applicability;
use clippy_utils::{is_lint_allowed, path_to_local, search_same, SpanlessEq, SpanlessHash};
use core::cmp::Ordering;
use core::{iter, slice};
@@ -9,9 +9,9 @@
use rustc_hir::def_id::DefId;
use rustc_hir::{Arm, Expr, ExprKind, HirId, HirIdMap, HirIdMapEntry, HirIdSet, Pat, PatKind, RangeEnd};
use rustc_lint::builtin::NON_EXHAUSTIVE_OMITTED_PATTERNS;
-use rustc_lint::LateContext;
+use rustc_lint::{LateContext, LintContext};
use rustc_middle::ty;
-use rustc_span::{ErrorGuaranteed, Symbol};
+use rustc_span::{ErrorGuaranteed, Span, Symbol};
use super::MATCH_SAME_ARMS;
@@ -110,20 +110,22 @@
&& check_same_body()
};
+ let mut appl = Applicability::MaybeIncorrect;
let indexed_arms: Vec<(usize, &Arm<'_>)> = arms.iter().enumerate().collect();
for (&(i, arm1), &(j, arm2)) in search_same(&indexed_arms, hash, eq) {
if matches!(arm2.pat.kind, PatKind::Wild) {
if !cx.tcx.features().non_exhaustive_omitted_patterns_lint
|| is_lint_allowed(cx, NON_EXHAUSTIVE_OMITTED_PATTERNS, arm2.hir_id)
{
+ let arm_span = adjusted_arm_span(cx, arm1.span);
span_lint_hir_and_then(
cx,
MATCH_SAME_ARMS,
arm1.hir_id,
- arm1.span,
+ arm_span,
"this match arm has an identical body to the `_` wildcard arm",
|diag| {
- diag.span_suggestion(arm1.span, "try removing the arm", "", Applicability::MaybeIncorrect)
+ diag.span_suggestion(arm_span, "try removing the arm", "", appl)
.help("or try changing either arm body")
.span_note(arm2.span, "`_` wildcard arm here");
},
@@ -144,23 +146,36 @@
keep_arm.span,
"this match arm has an identical body to another arm",
|diag| {
- let move_pat_snip = snippet(cx, move_arm.pat.span, "<pat2>");
- let keep_pat_snip = snippet(cx, keep_arm.pat.span, "<pat1>");
+ let move_pat_snip = snippet_with_applicability(cx, move_arm.pat.span, "<pat2>", &mut appl);
+ let keep_pat_snip = snippet_with_applicability(cx, keep_arm.pat.span, "<pat1>", &mut appl);
diag.span_suggestion(
keep_arm.pat.span,
- "try merging the arm patterns",
+ "or try merging the arm patterns",
format!("{keep_pat_snip} | {move_pat_snip}"),
- Applicability::MaybeIncorrect,
+ appl,
)
- .help("or try changing either arm body")
- .span_note(move_arm.span, "other arm here");
+ .span_suggestion(
+ adjusted_arm_span(cx, move_arm.span),
+ "and remove this obsolete arm",
+ "",
+ appl,
+ )
+ .help("try changing either arm body");
},
);
}
}
}
+/// Extend arm's span to include the comma and whitespaces after it.
+fn adjusted_arm_span(cx: &LateContext<'_>, span: Span) -> Span {
+ let source_map = cx.sess().source_map();
+ source_map
+ .span_extend_while(span, |c| c == ',' || c.is_ascii_whitespace())
+ .unwrap_or(span)
+}
+
#[derive(Clone, Copy)]
enum NormalizedPat<'a> {
Wild,
diff --git a/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index f775ea0..6ac0705 100644
--- a/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -115,45 +115,60 @@
}
}
- fn get_type(&self, ex: &'tcx Expr<'_>) -> Ty<'tcx> {
- self.cx.typeck_results().expr_ty(ex)
+ fn is_sig_drop_expr(&mut self, ex: &'tcx Expr<'_>) -> bool {
+ !ex.is_syntactic_place_expr() && self.has_sig_drop_attr(self.cx.typeck_results().expr_ty(ex))
}
- fn has_seen_type(&mut self, ty: Ty<'tcx>) -> bool {
- !self.seen_types.insert(ty)
+ fn has_sig_drop_attr(&mut self, ty: Ty<'tcx>) -> bool {
+ self.seen_types.clear();
+ self.has_sig_drop_attr_impl(ty)
}
- fn has_sig_drop_attr(&mut self, cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
+ fn has_sig_drop_attr_impl(&mut self, ty: Ty<'tcx>) -> bool {
if let Some(adt) = ty.ty_adt_def() {
- if get_attr(cx.sess(), cx.tcx.get_attrs_unchecked(adt.did()), "has_significant_drop").count() > 0 {
+ if get_attr(
+ self.cx.sess(),
+ self.cx.tcx.get_attrs_unchecked(adt.did()),
+ "has_significant_drop",
+ )
+ .count()
+ > 0
+ {
return true;
}
}
- match ty.kind() {
- rustc_middle::ty::Adt(a, b) => {
- for f in a.all_fields() {
- let ty = f.ty(cx.tcx, b);
- if !self.has_seen_type(ty) && self.has_sig_drop_attr(cx, ty) {
- return true;
- }
- }
-
- for generic_arg in *b {
- if let GenericArgKind::Type(ty) = generic_arg.unpack() {
- if self.has_sig_drop_attr(cx, ty) {
- return true;
- }
- }
- }
- false
- },
- rustc_middle::ty::Array(ty, _)
- | rustc_middle::ty::RawPtr(ty, _)
- | rustc_middle::ty::Ref(_, ty, _)
- | rustc_middle::ty::Slice(ty) => self.has_sig_drop_attr(cx, *ty),
- _ => false,
+ if !self.seen_types.insert(ty) {
+ return false;
}
+
+ let result = match ty.kind() {
+ rustc_middle::ty::Adt(adt, args) => {
+ // if some field has significant drop,
+ adt.all_fields()
+ .map(|field| field.ty(self.cx.tcx, args))
+ .any(|ty| self.has_sig_drop_attr_impl(ty))
+ // or if there is no generic lifetime and..
+ // (to avoid false positive on `Ref<'a, MutexGuard<Foo>>`)
+ || (args
+ .iter()
+ .all(|arg| !matches!(arg.unpack(), GenericArgKind::Lifetime(_)))
+ // some generic parameter has significant drop
+ // (to avoid false negative on `Box<MutexGuard<Foo>>`)
+ && args
+ .iter()
+ .filter_map(|arg| match arg.unpack() {
+ GenericArgKind::Type(ty) => Some(ty),
+ _ => None,
+ })
+ .any(|ty| self.has_sig_drop_attr_impl(ty)))
+ },
+ rustc_middle::ty::Tuple(tys) => tys.iter().any(|ty| self.has_sig_drop_attr_impl(ty)),
+ rustc_middle::ty::Array(ty, _) | rustc_middle::ty::Slice(ty) => self.has_sig_drop_attr_impl(*ty),
+ _ => false,
+ };
+
+ result
}
}
@@ -232,7 +247,7 @@
if self.current_sig_drop.is_some() {
return;
}
- let ty = self.sig_drop_checker.get_type(expr);
+ let ty = self.cx.typeck_results().expr_ty(expr);
if ty.is_ref() {
// We checked that the type was ref, so builtin_deref will return Some,
// but let's avoid any chance of an ICE.
@@ -279,11 +294,7 @@
impl<'a, 'tcx> Visitor<'tcx> for SigDropHelper<'a, 'tcx> {
fn visit_expr(&mut self, ex: &'tcx Expr<'_>) {
- if !self.is_chain_end
- && self
- .sig_drop_checker
- .has_sig_drop_attr(self.cx, self.sig_drop_checker.get_type(ex))
- {
+ if !self.is_chain_end && self.sig_drop_checker.is_sig_drop_expr(ex) {
self.has_significant_drop = true;
return;
}
@@ -387,10 +398,7 @@
impl<'a, 'tcx> Visitor<'tcx> for ArmSigDropHelper<'a, 'tcx> {
fn visit_expr(&mut self, ex: &'tcx Expr<'tcx>) {
- if self
- .sig_drop_checker
- .has_sig_drop_attr(self.sig_drop_checker.cx, self.sig_drop_checker.get_type(ex))
- {
+ if self.sig_drop_checker.is_sig_drop_expr(ex) {
self.found_sig_drop_spans.insert(ex.span);
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/methods/expect_fun_call.rs b/src/tools/clippy/clippy_lints/src/methods/expect_fun_call.rs
index fba7685..c9f56e1 100644
--- a/src/tools/clippy/clippy_lints/src/methods/expect_fun_call.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/expect_fun_call.rs
@@ -1,5 +1,5 @@
use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::macros::{find_format_args, format_args_inputs_span, root_macro_call_first_node};
+use clippy_utils::macros::{format_args_inputs_span, root_macro_call_first_node, FormatArgsStorage};
use clippy_utils::source::snippet_with_applicability;
use clippy_utils::ty::{is_type_diagnostic_item, is_type_lang_item};
use rustc_errors::Applicability;
@@ -16,6 +16,7 @@
#[allow(clippy::too_many_lines)]
pub(super) fn check<'tcx>(
cx: &LateContext<'tcx>,
+ format_args_storage: &FormatArgsStorage,
expr: &hir::Expr<'_>,
method_span: Span,
name: &str,
@@ -134,9 +135,9 @@
// Special handling for `format!` as arg_root
if let Some(macro_call) = root_macro_call_first_node(cx, arg_root) {
if cx.tcx.is_diagnostic_item(sym::format_macro, macro_call.def_id)
- && let Some(format_args) = find_format_args(cx, arg_root, macro_call.expn)
+ && let Some(format_args) = format_args_storage.get(cx, arg_root, macro_call.expn)
{
- let span = format_args_inputs_span(&format_args);
+ let span = format_args_inputs_span(format_args);
let sugg = snippet_with_applicability(cx, span, "..", &mut applicability);
span_lint_and_sugg(
cx,
diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_filter.rs b/src/tools/clippy/clippy_lints/src/methods/iter_filter.rs
index 12647ea1..b93d51e 100644
--- a/src/tools/clippy/clippy_lints/src/methods/iter_filter.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/iter_filter.rs
@@ -126,15 +126,15 @@
///
/// How this is done:
/// 1. we know that this is invoked in a method call with `filter` as the method name via `mod.rs`
-/// 2. we check that we are in a trait method. Therefore we are in an
-/// `(x as Iterator).filter({filter_arg})` method call.
+/// 2. we check that we are in a trait method. Therefore we are in an `(x as
+/// Iterator).filter({filter_arg})` method call.
/// 3. we check that the parent expression is not a map. This is because we don't want to lint
/// twice, and we already have a specialized lint for that.
/// 4. we check that the span of the filter does not contain a comment.
/// 5. we get the type of the `Item` in the `Iterator`, and compare against the type of Option and
-/// Result.
+/// Result.
/// 6. we finally check the contents of the filter argument to see if it is a call to `is_some` or
-/// `is_ok`.
+/// `is_ok`.
/// 7. if all of the above are true, then we return the `FilterType`
fn expression_type(
cx: &LateContext<'_>,
diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs b/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs
index 7c852a3..05e7738 100644
--- a/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs
@@ -12,8 +12,10 @@
use rustc_span::{sym, Span};
/// lint use of:
+///
/// - `hashmap.iter().map(|(_, v)| v)`
/// - `hashmap.into_iter().map(|(_, v)| v)`
+///
/// on `HashMaps` and `BTreeMaps` in std
pub(super) fn check<'tcx>(
diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_overeager_cloned.rs b/src/tools/clippy/clippy_lints/src/methods/iter_overeager_cloned.rs
index a52d387..5ccb524 100644
--- a/src/tools/clippy/clippy_lints/src/methods/iter_overeager_cloned.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/iter_overeager_cloned.rs
@@ -69,12 +69,9 @@
used_move: HirIdSet::default(),
};
- ExprUseVisitor::for_clippy(
- cx,
- closure.def_id,
- &mut delegate,
- )
- .consume_body(body).into_ok();
+ ExprUseVisitor::for_clippy(cx, closure.def_id, &mut delegate)
+ .consume_body(body)
+ .into_ok();
let mut to_be_discarded = false;
diff --git a/src/tools/clippy/clippy_lints/src/methods/mod.rs b/src/tools/clippy/clippy_lints/src/methods/mod.rs
index 2b92bff..9d67aa2 100644
--- a/src/tools/clippy/clippy_lints/src/methods/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/mod.rs
@@ -133,6 +133,7 @@
use clippy_config::msrvs::{self, Msrv};
use clippy_utils::consts::{constant, Constant};
use clippy_utils::diagnostics::{span_lint, span_lint_and_help};
+use clippy_utils::macros::FormatArgsStorage;
use clippy_utils::ty::{contains_ty_adt_constructor_opaque, implements_trait, is_copy, is_type_diagnostic_item};
use clippy_utils::{contains_return, is_bool, is_trait_method, iter_input_pats, peel_blocks, return_ty};
pub use path_ends_with_ext::DEFAULT_ALLOWED_DOTFILES;
@@ -4087,12 +4088,14 @@
suspicious,
"is_empty() called on strings known at compile time"
}
+
pub struct Methods {
avoid_breaking_exported_api: bool,
msrv: Msrv,
allow_expect_in_tests: bool,
allow_unwrap_in_tests: bool,
allowed_dotfiles: FxHashSet<String>,
+ format_args: FormatArgsStorage,
}
impl Methods {
@@ -4103,6 +4106,7 @@
allow_expect_in_tests: bool,
allow_unwrap_in_tests: bool,
mut allowed_dotfiles: FxHashSet<String>,
+ format_args: FormatArgsStorage,
) -> Self {
allowed_dotfiles.extend(DEFAULT_ALLOWED_DOTFILES.iter().map(ToString::to_string));
@@ -4112,6 +4116,7 @@
allow_expect_in_tests,
allow_unwrap_in_tests,
allowed_dotfiles,
+ format_args,
}
}
}
@@ -4281,7 +4286,15 @@
ExprKind::MethodCall(method_call, receiver, args, _) => {
let method_span = method_call.ident.span;
or_fun_call::check(cx, expr, method_span, method_call.ident.as_str(), receiver, args);
- expect_fun_call::check(cx, expr, method_span, method_call.ident.as_str(), receiver, args);
+ expect_fun_call::check(
+ cx,
+ &self.format_args,
+ expr,
+ method_span,
+ method_call.ident.as_str(),
+ receiver,
+ args,
+ );
clone_on_copy::check(cx, expr, method_call.ident.name, receiver, args);
clone_on_ref_ptr::check(cx, expr, method_call.ident.name, receiver, args);
inefficient_to_string::check(cx, expr, method_call.ident.name, receiver, args);
diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_iter_cloned.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_iter_cloned.rs
index 520dcb2..7431dc1 100644
--- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_iter_cloned.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_iter_cloned.rs
@@ -3,10 +3,12 @@
use clippy_utils::higher::ForLoop;
use clippy_utils::source::snippet_opt;
use clippy_utils::ty::{get_iterator_item_ty, implements_trait};
-use clippy_utils::{fn_def_id, get_parent_expr};
+use clippy_utils::visitors::for_each_expr;
+use clippy_utils::{can_mut_borrow_both, fn_def_id, get_parent_expr, path_to_local};
+use core::ops::ControlFlow;
use rustc_errors::Applicability;
use rustc_hir::def_id::DefId;
-use rustc_hir::{Expr, ExprKind};
+use rustc_hir::{BindingMode, Expr, ExprKind, Node, PatKind};
use rustc_lint::LateContext;
use rustc_span::{sym, Symbol};
@@ -40,6 +42,53 @@
&& !clone_or_copy_needed
&& let Some(receiver_snippet) = snippet_opt(cx, receiver.span)
{
+ // Issue 12098
+ // https://github.com/rust-lang/rust-clippy/issues/12098
+ // if the assignee have `mut borrow` conflict with the iteratee
+ // the lint should not execute, former didn't consider the mut case
+
+ // check whether `expr` is mutable
+ fn is_mutable(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+ if let Some(hir_id) = path_to_local(expr)
+ && let Node::Pat(pat) = cx.tcx.hir_node(hir_id)
+ {
+ matches!(pat.kind, PatKind::Binding(BindingMode::MUT, ..))
+ } else {
+ true
+ }
+ }
+
+ fn is_caller_or_fields_change(cx: &LateContext<'_>, body: &Expr<'_>, caller: &Expr<'_>) -> bool {
+ let mut change = false;
+ if let ExprKind::Block(block, ..) = body.kind {
+ for_each_expr(block, |e| {
+ match e.kind {
+ ExprKind::Assign(assignee, _, _) | ExprKind::AssignOp(_, assignee, _) => {
+ change |= !can_mut_borrow_both(cx, caller, assignee);
+ },
+ _ => {},
+ }
+ // the return value has no effect but the function need one return value
+ ControlFlow::<()>::Continue(())
+ });
+ }
+ change
+ }
+
+ if let ExprKind::Call(_, [child, ..]) = expr.kind {
+ // filter first layer of iterator
+ let mut child = child;
+ // get inner real caller requests for clone
+ while let ExprKind::MethodCall(_, caller, _, _) = child.kind {
+ child = caller;
+ }
+ if is_mutable(cx, child) && is_caller_or_fields_change(cx, body, child) {
+ // skip lint
+ return true;
+ }
+ };
+
+ // the lint should not be executed if no violation happens
let snippet = if let ExprKind::MethodCall(maybe_iter_method_name, collection, [], _) = receiver.kind
&& maybe_iter_method_name.ident.name == sym::iter
&& let Some(iterator_trait_id) = cx.tcx.get_diagnostic_item(sym::Iterator)
diff --git a/src/tools/clippy/clippy_lints/src/methods/utils.rs b/src/tools/clippy/clippy_lints/src/methods/utils.rs
index c50f24f..34d7b9a 100644
--- a/src/tools/clippy/clippy_lints/src/methods/utils.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/utils.rs
@@ -120,6 +120,7 @@
/// operations performed on `binding_hir_ids` are:
/// * to take non-mutable references to them
/// * to use them as non-mutable `&self` in method calls
+///
/// If any of `binding_hir_ids` is used in any other way, then `clone_or_copy_needed` will be true
/// when `CloneOrCopyVisitor` is done visiting.
struct CloneOrCopyVisitor<'cx, 'tcx> {
diff --git a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
index ae6cf99..daf166b 100644
--- a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -1,6 +1,6 @@
use clippy_config::msrvs::{self, Msrv};
use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::mir::{enclosing_mir, expr_local, local_assignments, used_exactly_once, PossibleBorrowerMap};
+use clippy_utils::mir::PossibleBorrowerMap;
use clippy_utils::source::snippet_with_context;
use clippy_utils::ty::{implements_trait, is_copy};
use clippy_utils::{expr_use_ctxt, peel_n_hir_expr_refs, DefinedTy, ExprUseNode};
@@ -11,7 +11,6 @@
use rustc_index::bit_set::BitSet;
use rustc_infer::infer::TyCtxtInferExt;
use rustc_lint::{LateContext, LateLintPass};
-use rustc_middle::mir::{Rvalue, StatementKind};
use rustc_middle::ty::{
self, ClauseKind, EarlyBinder, FnSig, GenericArg, GenericArgKind, ParamTy, ProjectionPredicate, Ty,
};
@@ -106,7 +105,6 @@
}
&& let count = needless_borrow_count(
cx,
- &mut self.possible_borrowers,
fn_id,
cx.typeck_results().node_args(hir_id),
i,
@@ -155,11 +153,9 @@
/// The following constraints will be checked:
/// * The borrowed expression meets all the generic type's constraints.
/// * The generic type appears only once in the functions signature.
-/// * The borrowed value will not be moved if it is used later in the function.
-#[expect(clippy::too_many_arguments)]
+/// * The borrowed value is Copy itself OR not a variable (created by a function call)
fn needless_borrow_count<'tcx>(
cx: &LateContext<'tcx>,
- possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
fn_id: DefId,
callee_args: ty::GenericArgsRef<'tcx>,
arg_index: usize,
@@ -234,9 +230,9 @@
let referent_ty = cx.typeck_results().expr_ty(referent);
- if !is_copy(cx, referent_ty)
- && (referent_ty.has_significant_drop(cx.tcx, cx.param_env)
- || !referent_used_exactly_once(cx, possible_borrowers, reference))
+ if (!is_copy(cx, referent_ty) && !referent_ty.is_ref())
+ && let ExprKind::AddrOf(_, _, inner) = reference.kind
+ && !matches!(inner.kind, ExprKind::Call(..) | ExprKind::MethodCall(..))
{
return false;
}
@@ -339,37 +335,6 @@
}
}
-fn referent_used_exactly_once<'tcx>(
- cx: &LateContext<'tcx>,
- possible_borrowers: &mut Vec<(LocalDefId, PossibleBorrowerMap<'tcx, 'tcx>)>,
- reference: &Expr<'tcx>,
-) -> bool {
- if let Some(mir) = enclosing_mir(cx.tcx, reference.hir_id)
- && let Some(local) = expr_local(cx.tcx, reference)
- && let [location] = *local_assignments(mir, local).as_slice()
- && let block_data = &mir.basic_blocks[location.block]
- && let Some(statement) = block_data.statements.get(location.statement_index)
- && let StatementKind::Assign(box (_, Rvalue::Ref(_, _, place))) = statement.kind
- && !place.is_indirect_first_projection()
- {
- let body_owner_local_def_id = cx.tcx.hir().enclosing_body_owner(reference.hir_id);
- if possible_borrowers
- .last()
- .map_or(true, |&(local_def_id, _)| local_def_id != body_owner_local_def_id)
- {
- possible_borrowers.push((body_owner_local_def_id, PossibleBorrowerMap::new(cx, mir)));
- }
- let possible_borrower = &mut possible_borrowers.last_mut().unwrap().1;
- // If `only_borrowers` were used here, the `copyable_iterator::warn` test would fail. The reason is
- // that `PossibleBorrowerVisitor::visit_terminator` considers `place.local` a possible borrower of
- // itself. See the comment in that method for an explanation as to why.
- possible_borrower.bounded_borrowers(&[local], &[local, place.local], place.local, location)
- && used_exactly_once(mir, place.local).unwrap_or(false)
- } else {
- false
- }
-}
-
// Iteratively replaces `param_ty` with `new_ty` in `args`, and similarly for each resulting
// projected type that is a type parameter. Returns `false` if replacing the types would have an
// effect on the function signature beyond substituting `new_ty` for `param_ty`.
@@ -408,7 +373,11 @@
&& let Some(term_ty) = projection_predicate.term.ty()
&& let ty::Param(term_param_ty) = term_ty.kind()
{
- let projection = projection_predicate.projection_term.with_self_ty(cx.tcx, new_ty).expect_ty(cx.tcx).to_ty(cx.tcx);
+ let projection = projection_predicate
+ .projection_term
+ .with_self_ty(cx.tcx, new_ty)
+ .expect_ty(cx.tcx)
+ .to_ty(cx.tcx);
if let Ok(projected_ty) = cx.tcx.try_normalize_erasing_regions(cx.param_env, projection)
&& args[term_param_ty.index as usize] != GenericArg::from(projected_ty)
diff --git a/src/tools/clippy/clippy_lints/src/needless_continue.rs b/src/tools/clippy/clippy_lints/src/needless_continue.rs
index 8b4a12b..b97cb45 100644
--- a/src/tools/clippy/clippy_lints/src/needless_continue.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_continue.rs
@@ -178,8 +178,7 @@
/// Given an expression, returns true if either of the following is true
///
/// - The expression is a `continue` node.
-/// - The expression node is a block with the first statement being a
-/// `continue`.
+/// - The expression node is a block with the first statement being a `continue`.
fn needless_continue_in_else(else_expr: &ast::Expr, label: Option<&ast::Label>) -> bool {
match else_expr.kind {
ast::ExprKind::Block(ref else_block, _) => is_first_block_stmt_continue(else_block, label),
diff --git a/src/tools/clippy/clippy_lints/src/needless_late_init.rs b/src/tools/clippy/clippy_lints/src/needless_late_init.rs
index 6605d1f..5a0ae1a 100644
--- a/src/tools/clippy/clippy_lints/src/needless_late_init.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_late_init.rs
@@ -273,24 +273,16 @@
msg_span,
"unneeded late initialization",
|diag| {
- diag.tool_only_span_suggestion(
- local_stmt.span,
- "remove the local",
- "",
- Applicability::MachineApplicable,
- );
-
- diag.span_suggestion(
- assign.lhs_span,
- format!("declare `{binding_name}` here"),
- let_snippet,
+ diag.multipart_suggestion(
+ format!("move the declaration `{binding_name}` here"),
+ vec![(local_stmt.span, String::new()), (assign.lhs_span, let_snippet)],
Applicability::MachineApplicable,
);
},
);
},
ExprKind::If(cond, then_expr, Some(else_expr)) if !contains_let(cond) => {
- let (applicability, suggestions) = assignment_suggestions(cx, binding_id, [then_expr, else_expr])?;
+ let (applicability, mut suggestions) = assignment_suggestions(cx, binding_id, [then_expr, else_expr])?;
span_lint_and_then(
cx,
@@ -298,30 +290,26 @@
local_stmt.span,
"unneeded late initialization",
|diag| {
- diag.tool_only_span_suggestion(local_stmt.span, "remove the local", String::new(), applicability);
-
- diag.span_suggestion_verbose(
- usage.stmt.span.shrink_to_lo(),
- format!("declare `{binding_name}` here"),
- format!("{let_snippet} = "),
- applicability,
- );
-
- diag.multipart_suggestion("remove the assignments from the branches", suggestions, applicability);
+ suggestions.push((local_stmt.span, String::new()));
+ suggestions.push((usage.stmt.span.shrink_to_lo(), format!("{let_snippet} = ")));
if usage.needs_semi {
- diag.span_suggestion(
- usage.stmt.span.shrink_to_hi(),
- "add a semicolon after the `if` expression",
- ";",
- applicability,
- );
+ suggestions.push((usage.stmt.span.shrink_to_hi(), ";".to_owned()));
}
+
+ diag.multipart_suggestion(
+ format!(
+ "move the declaration `{binding_name}` here and remove the assignments from the branches"
+ ),
+ suggestions,
+ applicability,
+ );
},
);
},
ExprKind::Match(_, arms, MatchSource::Normal) => {
- let (applicability, suggestions) = assignment_suggestions(cx, binding_id, arms.iter().map(|arm| arm.body))?;
+ let (applicability, mut suggestions) =
+ assignment_suggestions(cx, binding_id, arms.iter().map(|arm| arm.body))?;
span_lint_and_then(
cx,
@@ -329,29 +317,18 @@
local_stmt.span,
"unneeded late initialization",
|diag| {
- diag.tool_only_span_suggestion(local_stmt.span, "remove the local", String::new(), applicability);
+ suggestions.push((local_stmt.span, String::new()));
+ suggestions.push((usage.stmt.span.shrink_to_lo(), format!("{let_snippet} = ")));
- diag.span_suggestion_verbose(
- usage.stmt.span.shrink_to_lo(),
- format!("declare `{binding_name}` here"),
- format!("{let_snippet} = "),
- applicability,
- );
+ if usage.needs_semi {
+ suggestions.push((usage.stmt.span.shrink_to_hi(), ";".to_owned()));
+ }
diag.multipart_suggestion(
- "remove the assignments from the `match` arms",
+ format!("move the declaration `{binding_name}` here and remove the assignments from the `match` arms"),
suggestions,
applicability,
);
-
- if usage.needs_semi {
- diag.span_suggestion(
- usage.stmt.span.shrink_to_hi(),
- "add a semicolon after the `match` expression",
- ";",
- applicability,
- );
- }
},
);
},
diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs
index 9b852f5..da6ed5f 100644
--- a/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -117,7 +117,9 @@
.associated_body()
.map(|(_, body_id)| hir.body(body_id))
{
- euv::ExprUseVisitor::for_clippy(cx, closure, &mut *ctx).consume_body(body).into_ok();
+ euv::ExprUseVisitor::for_clippy(cx, closure, &mut *ctx)
+ .consume_body(body)
+ .into_ok();
}
}
}
@@ -194,7 +196,9 @@
async_closures: FxHashSet::default(),
tcx: cx.tcx,
};
- euv::ExprUseVisitor::for_clippy(cx, fn_def_id, &mut ctx).consume_body(body).into_ok();
+ euv::ExprUseVisitor::for_clippy(cx, fn_def_id, &mut ctx)
+ .consume_body(body)
+ .into_ok();
let mut checked_closures = FxHashSet::default();
diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
index 0986571..f2e00ce 100644
--- a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
@@ -133,7 +133,9 @@
// function body.
let MovedVariablesCtxt { moved_vars } = {
let mut ctx = MovedVariablesCtxt::default();
- euv::ExprUseVisitor::for_clippy(cx, fn_def_id, &mut ctx).consume_body(body).into_ok();
+ euv::ExprUseVisitor::for_clippy(cx, fn_def_id, &mut ctx)
+ .consume_body(body)
+ .into_ok();
ctx
};
diff --git a/src/tools/clippy/clippy_lints/src/no_effect.rs b/src/tools/clippy/clippy_lints/src/no_effect.rs
index f915145..87f886b 100644
--- a/src/tools/clippy/clippy_lints/src/no_effect.rs
+++ b/src/tools/clippy/clippy_lints/src/no_effect.rs
@@ -94,7 +94,6 @@
fn check_block_post(&mut self, cx: &LateContext<'tcx>, _: &'tcx rustc_hir::Block<'tcx>) {
for hir_id in self.local_bindings.pop().unwrap() {
- // FIXME(rust/#120456) - is `swap_remove` correct?
if let Some(span) = self.underscore_bindings.swap_remove(&hir_id) {
span_lint_hir(
cx,
@@ -109,7 +108,6 @@
fn check_expr(&mut self, _: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
if let Some(def_id) = path_to_local(expr) {
- // FIXME(rust/#120456) - is `swap_remove` correct?
self.underscore_bindings.swap_remove(&def_id);
}
}
@@ -118,7 +116,11 @@
impl NoEffect {
fn check_no_effect(&mut self, cx: &LateContext<'_>, stmt: &Stmt<'_>) -> bool {
if let StmtKind::Semi(expr) = stmt.kind {
- // move `expr.span.from_expansion()` ahead
+ // Covered by rustc `path_statements` lint
+ if matches!(expr.kind, ExprKind::Path(_)) {
+ return true;
+ }
+
if expr.span.from_expansion() {
return false;
}
diff --git a/src/tools/clippy/clippy_lints/src/panic_unimplemented.rs b/src/tools/clippy/clippy_lints/src/panic_unimplemented.rs
index ef51a9a..75066c1 100644
--- a/src/tools/clippy/clippy_lints/src/panic_unimplemented.rs
+++ b/src/tools/clippy/clippy_lints/src/panic_unimplemented.rs
@@ -1,8 +1,14 @@
use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_in_test;
use clippy_utils::macros::{is_panic, root_macro_call_first_node};
use rustc_hir::Expr;
use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::declare_lint_pass;
+use rustc_session::impl_lint_pass;
+
+#[derive(Clone)]
+pub struct PanicUnimplemented {
+ pub allow_panic_in_tests: bool,
+}
declare_clippy_lint! {
/// ### What it does
@@ -77,7 +83,7 @@
"usage of the `unreachable!` macro"
}
-declare_lint_pass!(PanicUnimplemented => [UNIMPLEMENTED, UNREACHABLE, TODO, PANIC]);
+impl_lint_pass!(PanicUnimplemented => [UNIMPLEMENTED, UNREACHABLE, TODO, PANIC]);
impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
@@ -85,7 +91,9 @@
return;
};
if is_panic(cx, macro_call.def_id) {
- if cx.tcx.hir().is_inside_const_context(expr.hir_id) {
+ if cx.tcx.hir().is_inside_const_context(expr.hir_id)
+ || self.allow_panic_in_tests && is_in_test(cx.tcx, expr.hir_id)
+ {
return;
}
diff --git a/src/tools/clippy/clippy_lints/src/strings.rs b/src/tools/clippy/clippy_lints/src/strings.rs
index 87a3c38..2921241 100644
--- a/src/tools/clippy/clippy_lints/src/strings.rs
+++ b/src/tools/clippy/clippy_lints/src/strings.rs
@@ -389,6 +389,10 @@
impl<'tcx> LateLintPass<'tcx> for StrToString {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
+ if expr.span.from_expansion() {
+ return;
+ }
+
if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind
&& path.ident.name == sym::to_string
&& let ty = cx.typeck_results().expr_ty(self_arg)
@@ -437,6 +441,10 @@
impl<'tcx> LateLintPass<'tcx> for StringToString {
fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
+ if expr.span.from_expansion() {
+ return;
+ }
+
if let ExprKind::MethodCall(path, self_arg, ..) = &expr.kind
&& path.ident.name == sym::to_string
&& let ty = cx.typeck_results().expr_ty(self_arg)
diff --git a/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_non_zero.rs b/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
index 7d824ef..3729dfd 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_non_zero.rs
@@ -28,7 +28,7 @@
let int_ty = substs.type_at(0);
if from_ty != int_ty {
- return false;
+ return false;
}
span_lint_and_then(
diff --git a/src/tools/clippy/clippy_lints/src/unwrap.rs b/src/tools/clippy/clippy_lints/src/unwrap.rs
index 5b2841d..c0d9bcd 100644
--- a/src/tools/clippy/clippy_lints/src/unwrap.rs
+++ b/src/tools/clippy/clippy_lints/src/unwrap.rs
@@ -251,11 +251,7 @@
local_id: unwrap_info.local_id,
};
- let vis = ExprUseVisitor::for_clippy(
- self.cx,
- cond.hir_id.owner.def_id,
- &mut delegate,
- );
+ let vis = ExprUseVisitor::for_clippy(self.cx, cond.hir_id.owner.def_id, &mut delegate);
vis.walk_expr(cond).into_ok();
vis.walk_expr(branch).into_ok();
diff --git a/src/tools/clippy/clippy_lints/src/utils/format_args_collector.rs b/src/tools/clippy/clippy_lints/src/utils/format_args_collector.rs
index 58e66c9..5acfd35 100644
--- a/src/tools/clippy/clippy_lints/src/utils/format_args_collector.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/format_args_collector.rs
@@ -1,4 +1,4 @@
-use clippy_utils::macros::AST_FORMAT_ARGS;
+use clippy_utils::macros::FormatArgsStorage;
use clippy_utils::source::snippet_opt;
use itertools::Itertools;
use rustc_ast::{Crate, Expr, ExprKind, FormatArgs};
@@ -9,13 +9,20 @@
use rustc_span::{hygiene, Span};
use std::iter::once;
use std::mem;
-use std::rc::Rc;
-/// Collects [`rustc_ast::FormatArgs`] so that future late passes can call
-/// [`clippy_utils::macros::find_format_args`]
-#[derive(Default)]
+/// Populates [`FormatArgsStorage`] with AST [`FormatArgs`] nodes
pub struct FormatArgsCollector {
- format_args: FxHashMap<Span, Rc<FormatArgs>>,
+ format_args: FxHashMap<Span, FormatArgs>,
+ storage: FormatArgsStorage,
+}
+
+impl FormatArgsCollector {
+ pub fn new(storage: FormatArgsStorage) -> Self {
+ Self {
+ format_args: FxHashMap::default(),
+ storage,
+ }
+ }
}
impl_lint_pass!(FormatArgsCollector => []);
@@ -27,16 +34,12 @@
return;
}
- self.format_args
- .insert(expr.span.with_parent(None), Rc::new((**args).clone()));
+ self.format_args.insert(expr.span.with_parent(None), (**args).clone());
}
}
fn check_crate_post(&mut self, _: &EarlyContext<'_>, _: &Crate) {
- AST_FORMAT_ARGS.with(|ast_format_args| {
- let result = ast_format_args.set(mem::take(&mut self.format_args));
- debug_assert!(result.is_ok());
- });
+ self.storage.set(mem::take(&mut self.format_args));
}
}
diff --git a/src/tools/clippy/clippy_lints/src/write.rs b/src/tools/clippy/clippy_lints/src/write.rs
index 26c6859..ff6ee0d 100644
--- a/src/tools/clippy/clippy_lints/src/write.rs
+++ b/src/tools/clippy/clippy_lints/src/write.rs
@@ -1,5 +1,5 @@
use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
-use clippy_utils::macros::{find_format_args, format_arg_removal_span, root_macro_call_first_node, MacroCall};
+use clippy_utils::macros::{format_arg_removal_span, root_macro_call_first_node, FormatArgsStorage, MacroCall};
use clippy_utils::source::{expand_past_previous_comma, snippet_opt};
use clippy_utils::{is_in_cfg_test, is_in_test_function};
use rustc_ast::token::LitKind;
@@ -236,13 +236,15 @@
#[derive(Default)]
pub struct Write {
+ format_args: FormatArgsStorage,
in_debug_impl: bool,
allow_print_in_tests: bool,
}
impl Write {
- pub fn new(allow_print_in_tests: bool) -> Self {
+ pub fn new(format_args: FormatArgsStorage, allow_print_in_tests: bool) -> Self {
Self {
+ format_args,
allow_print_in_tests,
..Default::default()
}
@@ -307,7 +309,7 @@
_ => return,
}
- if let Some(format_args) = find_format_args(cx, expr, macro_call.expn) {
+ if let Some(format_args) = self.format_args.get(cx, expr, macro_call.expn) {
// ignore `writeln!(w)` and `write!(v, some_macro!())`
if format_args.span.from_expansion() {
return;
@@ -315,15 +317,15 @@
match diag_name {
sym::print_macro | sym::eprint_macro | sym::write_macro => {
- check_newline(cx, &format_args, ¯o_call, name);
+ check_newline(cx, format_args, ¯o_call, name);
},
sym::println_macro | sym::eprintln_macro | sym::writeln_macro => {
- check_empty_string(cx, &format_args, ¯o_call, name);
+ check_empty_string(cx, format_args, ¯o_call, name);
},
_ => {},
}
- check_literal(cx, &format_args, name);
+ check_literal(cx, format_args, name);
if !self.in_debug_impl {
for piece in &format_args.template {
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index 99d7aba..4c603bd 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -193,6 +193,21 @@
None
}
+/// Checks if the given local has an initializer or is from something other than a `let` statement
+///
+/// e.g. returns true for `x` in `fn f(x: usize) { .. }` and `let x = 1;` but false for `let x;`
+pub fn local_is_initialized(cx: &LateContext<'_>, local: HirId) -> bool {
+ for (_, node) in cx.tcx.hir().parent_iter(local) {
+ match node {
+ Node::Pat(..) | Node::PatField(..) => {},
+ Node::LetStmt(let_stmt) => return let_stmt.init.is_some(),
+ _ => return true,
+ }
+ }
+
+ false
+}
+
/// Returns `true` if the given `NodeId` is inside a constant context
///
/// # Example
@@ -1499,15 +1514,18 @@
}
/// Checks whether the given `Expr` is a range equivalent to a `RangeFull`.
+///
/// For the lower bound, this means that:
/// - either there is none
/// - or it is the smallest value that can be represented by the range's integer type
+///
/// For the upper bound, this means that:
/// - either there is none
/// - or it is the largest value that can be represented by the range's integer type and is
/// inclusive
/// - or it is a call to some container's `len` method and is exclusive, and the range is passed to
/// a method call on that same container (e.g. `v.drain(..v.len())`)
+///
/// If the given `Expr` is not some kind of range, the function returns `false`.
pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Option<&Path<'_>>) -> bool {
let ty = cx.typeck_results().expr_ty(expr);
diff --git a/src/tools/clippy/clippy_utils/src/macros.rs b/src/tools/clippy/clippy_utils/src/macros.rs
index 257dd76..8daab9b 100644
--- a/src/tools/clippy/clippy_utils/src/macros.rs
+++ b/src/tools/clippy/clippy_utils/src/macros.rs
@@ -5,15 +5,13 @@
use arrayvec::ArrayVec;
use rustc_ast::{FormatArgs, FormatArgument, FormatPlaceholder};
use rustc_data_structures::fx::FxHashMap;
+use rustc_data_structures::sync::{Lrc, OnceLock};
use rustc_hir::{self as hir, Expr, ExprKind, HirId, Node, QPath};
use rustc_lint::LateContext;
use rustc_span::def_id::DefId;
use rustc_span::hygiene::{self, MacroKind, SyntaxContext};
use rustc_span::{sym, BytePos, ExpnData, ExpnId, ExpnKind, Span, SpanData, Symbol};
-use std::cell::OnceCell;
use std::ops::ControlFlow;
-use std::rc::Rc;
-use std::sync::atomic::{AtomicBool, Ordering};
const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[
sym::assert_eq_macro,
@@ -388,50 +386,44 @@
}
}
-thread_local! {
- /// We preserve the [`FormatArgs`] structs from the early pass for use in the late pass to be
- /// able to access the many features of a [`LateContext`].
+/// Stores AST [`FormatArgs`] nodes for use in late lint passes, as they are in a desugared form in
+/// the HIR
+#[derive(Default, Clone)]
+pub struct FormatArgsStorage(Lrc<OnceLock<FxHashMap<Span, FormatArgs>>>);
+
+impl FormatArgsStorage {
+ /// Returns an AST [`FormatArgs`] node if a `format_args` expansion is found as a descendant of
+ /// `expn_id`
///
- /// A thread local is used because [`FormatArgs`] is `!Send` and `!Sync`, we are making an
- /// assumption that the early pass that populates the map and the later late passes will all be
- /// running on the same thread.
- #[doc(hidden)]
- pub static AST_FORMAT_ARGS: OnceCell<FxHashMap<Span, Rc<FormatArgs>>> = {
- static CALLED: AtomicBool = AtomicBool::new(false);
- debug_assert!(
- !CALLED.swap(true, Ordering::SeqCst),
- "incorrect assumption: `AST_FORMAT_ARGS` should only be accessed by a single thread",
- );
-
- OnceCell::new()
- };
-}
-
-/// Returns an AST [`FormatArgs`] node if a `format_args` expansion is found as a descendant of
-/// `expn_id`
-pub fn find_format_args(cx: &LateContext<'_>, start: &Expr<'_>, expn_id: ExpnId) -> Option<Rc<FormatArgs>> {
- let format_args_expr = for_each_expr(start, |expr| {
- let ctxt = expr.span.ctxt();
- if ctxt.outer_expn().is_descendant_of(expn_id) {
- if macro_backtrace(expr.span)
- .map(|macro_call| cx.tcx.item_name(macro_call.def_id))
- .any(|name| matches!(name, sym::const_format_args | sym::format_args | sym::format_args_nl))
- {
- ControlFlow::Break(expr)
+ /// See also [`find_format_arg_expr`]
+ pub fn get(&self, cx: &LateContext<'_>, start: &Expr<'_>, expn_id: ExpnId) -> Option<&FormatArgs> {
+ let format_args_expr = for_each_expr(start, |expr| {
+ let ctxt = expr.span.ctxt();
+ if ctxt.outer_expn().is_descendant_of(expn_id) {
+ if macro_backtrace(expr.span)
+ .map(|macro_call| cx.tcx.item_name(macro_call.def_id))
+ .any(|name| matches!(name, sym::const_format_args | sym::format_args | sym::format_args_nl))
+ {
+ ControlFlow::Break(expr)
+ } else {
+ ControlFlow::Continue(Descend::Yes)
+ }
} else {
- ControlFlow::Continue(Descend::Yes)
+ ControlFlow::Continue(Descend::No)
}
- } else {
- ControlFlow::Continue(Descend::No)
- }
- })?;
+ })?;
- AST_FORMAT_ARGS.with(|ast_format_args| {
- ast_format_args
- .get()?
- .get(&format_args_expr.span.with_parent(None))
- .cloned()
- })
+ debug_assert!(self.0.get().is_some(), "`FormatArgsStorage` not yet populated");
+
+ self.0.get()?.get(&format_args_expr.span.with_parent(None))
+ }
+
+ /// Should only be called by `FormatArgsCollector`
+ pub fn set(&self, format_args: FxHashMap<Span, FormatArgs>) {
+ self.0
+ .set(format_args)
+ .expect("`FormatArgsStorage::set` should only be called once");
+ }
}
/// Attempt to find the [`rustc_hir::Expr`] that corresponds to the [`FormatArgument`]'s value, if
diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
index ff9f065..8ee7d87 100644
--- a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
+++ b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
@@ -3,7 +3,7 @@
// of terminologies might not be relevant in the context of Clippy. Note that its behavior might
// differ from the time of `rustc` even if the name stays the same.
-use clippy_config::msrvs::Msrv;
+use clippy_config::msrvs::{self, Msrv};
use hir::LangItem;
use rustc_attr::StableSince;
use rustc_const_eval::transform::check_consts::ConstCx;
@@ -42,7 +42,7 @@
for bb in &*body.basic_blocks {
check_terminator(tcx, body, bb.terminator(), msrv)?;
for stmt in &bb.statements {
- check_statement(tcx, body, def_id, stmt)?;
+ check_statement(tcx, body, def_id, stmt, msrv)?;
}
}
Ok(())
@@ -102,13 +102,14 @@
def_id: DefId,
rvalue: &Rvalue<'tcx>,
span: Span,
+ msrv: &Msrv,
) -> McfResult {
match rvalue {
Rvalue::ThreadLocalRef(_) => Err((span, "cannot access thread local storage in const fn".into())),
Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
- check_place(tcx, *place, span, body)
+ check_place(tcx, *place, span, body, msrv)
},
- Rvalue::CopyForDeref(place) => check_place(tcx, *place, span, body),
+ Rvalue::CopyForDeref(place) => check_place(tcx, *place, span, body, msrv),
Rvalue::Repeat(operand, _)
| Rvalue::Use(operand)
| Rvalue::Cast(
@@ -122,7 +123,7 @@
| CastKind::PointerCoercion(PointerCoercion::MutToConstPointer | PointerCoercion::ArrayToPointer),
operand,
_,
- ) => check_operand(tcx, operand, span, body),
+ ) => check_operand(tcx, operand, span, body, msrv),
Rvalue::Cast(
CastKind::PointerCoercion(
PointerCoercion::UnsafeFnPointer
@@ -133,15 +134,13 @@
_,
) => Err((span, "function pointer casts are not allowed in const fn".into())),
Rvalue::Cast(CastKind::PointerCoercion(PointerCoercion::Unsize), op, cast_ty) => {
- let pointee_ty = if let Some(deref_ty) = cast_ty.builtin_deref(true) {
- deref_ty
- } else {
+ let Some(pointee_ty) = cast_ty.builtin_deref(true) else {
// We cannot allow this for now.
return Err((span, "unsizing casts are only allowed for references right now".into()));
};
let unsized_ty = tcx.struct_tail_erasing_lifetimes(pointee_ty, tcx.param_env(def_id));
if let ty::Slice(_) | ty::Str = unsized_ty.kind() {
- check_operand(tcx, op, span, body)?;
+ check_operand(tcx, op, span, body, msrv)?;
// Casting/coercing things to slices is fine.
Ok(())
} else {
@@ -162,8 +161,8 @@
)),
// binops are fine on integers
Rvalue::BinaryOp(_, box (lhs, rhs)) => {
- check_operand(tcx, lhs, span, body)?;
- check_operand(tcx, rhs, span, body)?;
+ check_operand(tcx, lhs, span, body, msrv)?;
+ check_operand(tcx, rhs, span, body, msrv)?;
let ty = lhs.ty(body, tcx);
if ty.is_integral() || ty.is_bool() || ty.is_char() {
Ok(())
@@ -179,14 +178,14 @@
Rvalue::UnaryOp(_, operand) => {
let ty = operand.ty(body, tcx);
if ty.is_integral() || ty.is_bool() {
- check_operand(tcx, operand, span, body)
+ check_operand(tcx, operand, span, body, msrv)
} else {
Err((span, "only int and `bool` operations are stable in const fn".into()))
}
},
Rvalue::Aggregate(_, operands) => {
for operand in operands {
- check_operand(tcx, operand, span, body)?;
+ check_operand(tcx, operand, span, body, msrv)?;
}
Ok(())
},
@@ -198,28 +197,29 @@
body: &Body<'tcx>,
def_id: DefId,
statement: &Statement<'tcx>,
+ msrv: &Msrv,
) -> McfResult {
let span = statement.source_info.span;
match &statement.kind {
StatementKind::Assign(box (place, rval)) => {
- check_place(tcx, *place, span, body)?;
- check_rvalue(tcx, body, def_id, rval, span)
+ check_place(tcx, *place, span, body, msrv)?;
+ check_rvalue(tcx, body, def_id, rval, span, msrv)
},
- StatementKind::FakeRead(box (_, place)) => check_place(tcx, *place, span, body),
+ StatementKind::FakeRead(box (_, place)) => check_place(tcx, *place, span, body, msrv),
// just an assignment
StatementKind::SetDiscriminant { place, .. } | StatementKind::Deinit(place) => {
- check_place(tcx, **place, span, body)
+ check_place(tcx, **place, span, body, msrv)
},
- StatementKind::Intrinsic(box NonDivergingIntrinsic::Assume(op)) => check_operand(tcx, op, span, body),
+ StatementKind::Intrinsic(box NonDivergingIntrinsic::Assume(op)) => check_operand(tcx, op, span, body, msrv),
StatementKind::Intrinsic(box NonDivergingIntrinsic::CopyNonOverlapping(
rustc_middle::mir::CopyNonOverlapping { dst, src, count },
)) => {
- check_operand(tcx, dst, span, body)?;
- check_operand(tcx, src, span, body)?;
- check_operand(tcx, count, span, body)
+ check_operand(tcx, dst, span, body, msrv)?;
+ check_operand(tcx, src, span, body, msrv)?;
+ check_operand(tcx, count, span, body, msrv)
},
// These are all NOPs
StatementKind::StorageLive(_)
@@ -233,7 +233,13 @@
}
}
-fn check_operand<'tcx>(tcx: TyCtxt<'tcx>, operand: &Operand<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
+fn check_operand<'tcx>(
+ tcx: TyCtxt<'tcx>,
+ operand: &Operand<'tcx>,
+ span: Span,
+ body: &Body<'tcx>,
+ msrv: &Msrv,
+) -> McfResult {
match operand {
Operand::Move(place) => {
if !place.projection.as_ref().is_empty()
@@ -245,9 +251,9 @@
));
}
- check_place(tcx, *place, span, body)
+ check_place(tcx, *place, span, body, msrv)
},
- Operand::Copy(place) => check_place(tcx, *place, span, body),
+ Operand::Copy(place) => check_place(tcx, *place, span, body, msrv),
Operand::Constant(c) => match c.check_static_ptr(tcx) {
Some(_) => Err((span, "cannot access `static` items in const fn".into())),
None => Ok(()),
@@ -255,23 +261,27 @@
}
}
-fn check_place<'tcx>(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
+fn check_place<'tcx>(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'tcx>, msrv: &Msrv) -> McfResult {
for (base, elem) in place.as_ref().iter_projections() {
match elem {
ProjectionElem::Field(..) => {
- let base_ty = base.ty(body, tcx).ty;
- if let Some(def) = base_ty.ty_adt_def() {
- // No union field accesses in `const fn`
- if def.is_union() {
- return Err((span, "accessing union fields is unstable".into()));
- }
+ if base.ty(body, tcx).ty.is_union() && !msrv.meets(msrvs::CONST_FN_UNION) {
+ return Err((span, "accessing union fields is unstable".into()));
}
},
+ ProjectionElem::Deref => match base.ty(body, tcx).ty.kind() {
+ ty::RawPtr(_, hir::Mutability::Mut) => {
+ return Err((span, "dereferencing raw mut pointer in const fn is unstable".into()));
+ },
+ ty::RawPtr(_, hir::Mutability::Not) if !msrv.meets(msrvs::CONST_RAW_PTR_DEREF) => {
+ return Err((span, "dereferencing raw const pointer in const fn is unstable".into()));
+ },
+ _ => (),
+ },
ProjectionElem::ConstantIndex { .. }
| ProjectionElem::OpaqueCast(..)
| ProjectionElem::Downcast(..)
| ProjectionElem::Subslice { .. }
- | ProjectionElem::Deref
| ProjectionElem::Subtype(_)
| ProjectionElem::Index(_) => {},
}
@@ -304,7 +314,7 @@
}
Ok(())
},
- TerminatorKind::SwitchInt { discr, targets: _ } => check_operand(tcx, discr, span, body),
+ TerminatorKind::SwitchInt { discr, targets: _ } => check_operand(tcx, discr, span, body, msrv),
TerminatorKind::CoroutineDrop | TerminatorKind::Yield { .. } => {
Err((span, "const fn coroutines are unstable".into()))
},
@@ -341,10 +351,10 @@
));
}
- check_operand(tcx, func, span, body)?;
+ check_operand(tcx, func, span, body, msrv)?;
for arg in args {
- check_operand(tcx, &arg.node, span, body)?;
+ check_operand(tcx, &arg.node, span, body, msrv)?;
}
Ok(())
} else {
@@ -357,7 +367,7 @@
msg: _,
target: _,
unwind: _,
- } => check_operand(tcx, cond, span, body),
+ } => check_operand(tcx, cond, span, body, msrv),
TerminatorKind::InlineAsm { .. } => Err((span, "cannot use inline assembly in const fn".into())),
}
}
diff --git a/src/tools/clippy/clippy_utils/src/source.rs b/src/tools/clippy/clippy_utils/src/source.rs
index e72467e..fd67e03 100644
--- a/src/tools/clippy/clippy_utils/src/source.rs
+++ b/src/tools/clippy/clippy_utils/src/source.rs
@@ -250,7 +250,7 @@
/// - Applicability level `Unspecified` will never be changed.
/// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
/// - If the default value is used and the applicability level is `MachineApplicable`, change it to
-/// `HasPlaceholders`
+/// `HasPlaceholders`
pub fn snippet_with_applicability<'a, T: LintContext>(
cx: &T,
span: Span,
diff --git a/src/tools/clippy/clippy_utils/src/sugg.rs b/src/tools/clippy/clippy_utils/src/sugg.rs
index bf03c6c..6319c7b 100644
--- a/src/tools/clippy/clippy_utils/src/sugg.rs
+++ b/src/tools/clippy/clippy_utils/src/sugg.rs
@@ -67,8 +67,7 @@
/// - Applicability level `Unspecified` will never be changed.
/// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
/// - If the default value is used and the applicability level is `MachineApplicable`, change it
- /// to
- /// `HasPlaceholders`
+ /// to `HasPlaceholders`
pub fn hir_with_applicability(
cx: &LateContext<'_>,
expr: &hir::Expr<'_>,
diff --git a/src/tools/clippy/clippy_utils/src/ty.rs b/src/tools/clippy/clippy_utils/src/ty.rs
index c29e3fe..2dacc34 100644
--- a/src/tools/clippy/clippy_utils/src/ty.rs
+++ b/src/tools/clippy/clippy_utils/src/ty.rs
@@ -273,11 +273,7 @@
let infcx = tcx.infer_ctxt().build();
let args = args
.into_iter()
- .map(|arg| {
- arg.into().unwrap_or_else(|| {
- infcx.next_ty_var(DUMMY_SP).into()
- })
- })
+ .map(|arg| arg.into().unwrap_or_else(|| infcx.next_ty_var(DUMMY_SP).into()))
.collect::<Vec<_>>();
// If an effect arg was not specified, we need to specify it.
@@ -795,7 +791,8 @@
inputs = Some(i);
},
ty::ClauseKind::Projection(p)
- if Some(p.projection_term.def_id) == lang_items.fn_once_output() && p.projection_term.self_ty() == ty =>
+ if Some(p.projection_term.def_id) == lang_items.fn_once_output()
+ && p.projection_term.self_ty() == ty =>
{
if output.is_some() {
// Multiple different fn trait impls. Is this even allowed?
@@ -956,11 +953,7 @@
impl AdtVariantInfo {
/// Returns ADT variants ordered by size
- pub fn new<'tcx>(
- cx: &LateContext<'tcx>,
- adt: AdtDef<'tcx>,
- subst: GenericArgsRef<'tcx>
- ) -> Vec<Self> {
+ pub fn new<'tcx>(cx: &LateContext<'tcx>, adt: AdtDef<'tcx>, subst: GenericArgsRef<'tcx>) -> Vec<Self> {
let mut variants_size = adt
.variants()
.iter()
diff --git a/src/tools/clippy/clippy_utils/src/usage.rs b/src/tools/clippy/clippy_utils/src/usage.rs
index 9abb4ef..2a25d51 100644
--- a/src/tools/clippy/clippy_utils/src/usage.rs
+++ b/src/tools/clippy/clippy_utils/src/usage.rs
@@ -16,13 +16,9 @@
used_mutably: HirIdSet::default(),
skip: false,
};
- ExprUseVisitor::for_clippy(
- cx,
- expr.hir_id.owner.def_id,
- &mut delegate,
- )
- .walk_expr(expr)
- .into_ok();
+ ExprUseVisitor::for_clippy(cx, expr.hir_id.owner.def_id, &mut delegate)
+ .walk_expr(expr)
+ .into_ok();
if delegate.skip {
return None;
diff --git a/src/tools/clippy/lintcheck/Cargo.toml b/src/tools/clippy/lintcheck/Cargo.toml
index a828d12..8c5a409 100644
--- a/src/tools/clippy/lintcheck/Cargo.toml
+++ b/src/tools/clippy/lintcheck/Cargo.toml
@@ -13,7 +13,7 @@
[dependencies]
anyhow = "1.0.69"
cargo_metadata = "0.15.3"
-clap = { version = "4.1.8", features = ["derive", "env"] }
+clap = { version = "4.4", features = ["derive", "env"] }
crates_io_api = "0.8.1"
crossbeam-channel = "0.5.6"
flate2 = "1.0"
diff --git a/src/tools/clippy/rust-toolchain b/src/tools/clippy/rust-toolchain
index 055f305..a0585ff 100644
--- a/src/tools/clippy/rust-toolchain
+++ b/src/tools/clippy/rust-toolchain
@@ -1,3 +1,3 @@
[toolchain]
-channel = "nightly-2024-05-02"
+channel = "nightly-2024-05-16"
components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
diff --git a/src/tools/clippy/tests/ui-cargo/lint_groups_priority/fail/Cargo.stderr b/src/tools/clippy/tests/ui-cargo/lint_groups_priority/fail/Cargo.stderr
index 103e60d..9177e99 100644
--- a/src/tools/clippy/tests/ui-cargo/lint_groups_priority/fail/Cargo.stderr
+++ b/src/tools/clippy/tests/ui-cargo/lint_groups_priority/fail/Cargo.stderr
@@ -42,4 +42,32 @@
19 | pedantic = { level = "warn", priority = -2 }
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-error: could not compile `fail` (lib) due to 3 previous errors
+error: lint group `rust_2018_idioms` has the same priority (0) as a lint
+ --> Cargo.toml:23:1
+ |
+23 | rust_2018_idioms = "warn"
+ | ^^^^^^^^^^^^^^^^ ------ has an implicit priority of 0
+24 | bare_trait_objects = "allow"
+ | ------------------ has the same priority as this lint
+ |
+ = note: the order of the lints in the table is ignored by Cargo
+help: to have lints override the group set `rust_2018_idioms` to a lower priority
+ |
+23 | rust_2018_idioms = { level = "warn", priority = -1 }
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: lint group `pedantic` has the same priority (0) as a lint
+ --> Cargo.toml:27:1
+ |
+27 | pedantic = "warn"
+ | ^^^^^^^^ ------ has an implicit priority of 0
+28 | similar_names = "allow"
+ | ------------- has the same priority as this lint
+ |
+ = note: the order of the lints in the table is ignored by Cargo
+help: to have lints override the group set `pedantic` to a lower priority
+ |
+27 | pedantic = { level = "warn", priority = -1 }
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+error: could not compile `fail` (lib) due to 5 previous errors
diff --git a/src/tools/clippy/tests/ui-cargo/lint_groups_priority/fail/Cargo.toml b/src/tools/clippy/tests/ui-cargo/lint_groups_priority/fail/Cargo.toml
index 4ce41f7..e4d4af9 100644
--- a/src/tools/clippy/tests/ui-cargo/lint_groups_priority/fail/Cargo.toml
+++ b/src/tools/clippy/tests/ui-cargo/lint_groups_priority/fail/Cargo.toml
@@ -18,3 +18,11 @@
[lints.clippy]
pedantic = { level = "warn", priority = -1 }
similar_names = { level = "allow", priority = -1 }
+
+[workspace.lints.rust]
+rust_2018_idioms = "warn"
+bare_trait_objects = "allow"
+
+[workspace.lints.clippy]
+pedantic = "warn"
+similar_names = "allow"
diff --git a/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/default/test.rs b/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/default/test.rs
new file mode 100644
index 0000000..f5e01b4
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/default/test.rs
@@ -0,0 +1,260 @@
+//! Tests macro_metavars_in_unsafe with default configuration
+#![feature(decl_macro, lint_reasons)]
+#![warn(clippy::macro_metavars_in_unsafe)]
+#![allow(clippy::no_effect)]
+
+#[macro_export]
+macro_rules! allow_works {
+ ($v:expr) => {
+ #[expect(clippy::macro_metavars_in_unsafe)]
+ unsafe {
+ $v;
+ };
+ };
+}
+
+#[macro_export]
+macro_rules! simple {
+ ($v:expr) => {
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ dbg!($v);
+ }
+ };
+}
+
+#[macro_export]
+#[rustfmt::skip] // for some reason rustfmt rewrites $r#unsafe to r#u$nsafe, bug?
+macro_rules! raw_symbol {
+ ($r#mod:expr, $r#unsafe:expr) => {
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ $r#mod;
+ }
+ $r#unsafe;
+ };
+}
+
+#[macro_export]
+macro_rules! multilevel_unsafe {
+ ($v:expr) => {
+ unsafe {
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ $v;
+ }
+ }
+ };
+}
+
+#[macro_export]
+macro_rules! in_function {
+ ($v:expr) => {
+ unsafe {
+ fn f() {
+ // function introduces a new body, so don't lint.
+ $v;
+ }
+ }
+ };
+}
+
+#[macro_export]
+macro_rules! in_function_with_unsafe {
+ ($v:expr) => {
+ unsafe {
+ fn f() {
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ $v;
+ }
+ }
+ }
+ };
+}
+
+#[macro_export]
+macro_rules! const_static {
+ ($c:expr, $s:expr) => {
+ unsafe {
+ // const and static introduces new body, don't lint
+ const _X: i32 = $c;
+ static _Y: i32 = $s;
+ }
+ };
+}
+
+#[macro_export]
+macro_rules! const_generic_in_struct {
+ ($inside_unsafe:expr, $outside_unsafe:expr) => {
+ unsafe {
+ struct Ty<
+ const L: i32 = 1,
+ const M: i32 = {
+ 1;
+ unsafe { $inside_unsafe }
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ },
+ const N: i32 = { $outside_unsafe },
+ >;
+ }
+ };
+}
+
+#[macro_export]
+macro_rules! fn_with_const_generic {
+ ($inside_unsafe:expr, $outside_unsafe:expr) => {
+ unsafe {
+ fn f<const N: usize>() {
+ $outside_unsafe;
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ $inside_unsafe;
+ }
+ }
+ }
+ };
+}
+
+#[macro_export]
+macro_rules! variables {
+ ($inside_unsafe:expr, $outside_unsafe:expr) => {
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ $inside_unsafe;
+ let inside_unsafe = 1;
+ inside_unsafe;
+ }
+ $outside_unsafe;
+ let outside_unsafe = 1;
+ outside_unsafe;
+ };
+}
+
+#[macro_export]
+macro_rules! multiple_matchers {
+ ($inside_unsafe:expr, $outside_unsafe:expr) => {
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ $inside_unsafe;
+ }
+ $outside_unsafe;
+ };
+ ($($v:expr, $x:expr),+) => {
+ $(
+ $v;
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ $x;
+ }
+ );+
+ };
+}
+
+#[macro_export]
+macro_rules! multiple_unsafe_blocks {
+ ($w:expr, $x:expr, $y:expr) => {
+ $w;
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ $x;
+ }
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ $x;
+ $y;
+ }
+ };
+}
+
+pub macro macro2_0($v:expr) {
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ $v;
+ }
+}
+
+// don't lint private macros with the default configuration
+macro_rules! private_mac {
+ ($v:expr) => {
+ unsafe {
+ $v;
+ }
+ };
+}
+
+// don't lint exported macros that are doc(hidden) because they also aren't part of the public API
+#[macro_export]
+#[doc(hidden)]
+macro_rules! exported_but_hidden {
+ ($v:expr) => {
+ unsafe {
+ $v;
+ }
+ };
+}
+
+// don't lint if the same metavariable is expanded in an unsafe block and then outside of one:
+// unsafe {} is still needed at callsite so not problematic
+#[macro_export]
+macro_rules! does_require_unsafe {
+ ($v:expr) => {
+ unsafe {
+ $v;
+ }
+ $v;
+ };
+}
+
+#[macro_export]
+macro_rules! unsafe_from_root_ctxt {
+ ($v:expr) => {
+ // Expands to unsafe { 1 }, but the unsafe block is from the root ctxt and not this macro,
+ // so no warning.
+ $v;
+ };
+}
+
+// invoked from another macro, should still generate a warning
+#[macro_export]
+macro_rules! nested_macro_helper {
+ ($v:expr) => {{
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ $v;
+ }
+ }};
+}
+
+#[macro_export]
+macro_rules! nested_macros {
+ ($v:expr, $v2:expr) => {{
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ nested_macro_helper!($v);
+ $v;
+ }
+ }};
+}
+
+fn main() {
+ allow_works!(1);
+ simple!(1);
+ raw_symbol!(1, 1);
+ multilevel_unsafe!(1);
+ in_function!(1);
+ in_function_with_unsafe!(1);
+ const_static!(1, 1);
+ const_generic_in_struct!(1, 1);
+ fn_with_const_generic!(1, 1);
+ variables!(1, 1);
+ multiple_matchers!(1, 1);
+ multiple_matchers!(1, 1, 1, 1);
+ macro2_0!(1);
+ private_mac!(1);
+ exported_but_hidden!(1);
+ does_require_unsafe!(1);
+ multiple_unsafe_blocks!(1, 1, 1);
+ unsafe_from_root_ctxt!(unsafe { 1 });
+ nested_macros!(1, 1);
+}
diff --git a/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/default/test.stderr b/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/default/test.stderr
new file mode 100644
index 0000000..d6b97f6
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/default/test.stderr
@@ -0,0 +1,187 @@
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:19:9
+ |
+LL | / unsafe {
+LL | |
+LL | | dbg!($v);
+LL | | }
+ | |_________^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+ = note: `-D clippy::macro-metavars-in-unsafe` implied by `-D warnings`
+ = help: to override `-D warnings` add `#[allow(clippy::macro_metavars_in_unsafe)]`
+
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:30:9
+ |
+LL | / unsafe {
+LL | |
+LL | | $r#mod;
+LL | | }
+ | |_________^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:42:13
+ |
+LL | / unsafe {
+LL | |
+LL | | $v;
+LL | | }
+ | |_____________^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:67:17
+ |
+LL | / unsafe {
+LL | |
+LL | | $v;
+LL | | }
+ | |_________________^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:95:21
+ |
+LL | unsafe { $inside_unsafe }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:110:17
+ |
+LL | / unsafe {
+LL | |
+LL | | $inside_unsafe;
+LL | | }
+ | |_________________^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:122:9
+ |
+LL | / unsafe {
+LL | |
+LL | | $inside_unsafe;
+LL | | let inside_unsafe = 1;
+LL | | inside_unsafe;
+LL | | }
+ | |_________^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:137:9
+ |
+LL | / unsafe {
+LL | |
+LL | | $inside_unsafe;
+LL | | }
+ | |_________^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:146:13
+ |
+LL | / unsafe {
+LL | |
+LL | | $x;
+LL | | }
+ | |_____________^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:171:5
+ |
+LL | / unsafe {
+LL | |
+LL | | $v;
+LL | | }
+ | |_____^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:158:9
+ |
+LL | / unsafe {
+LL | |
+LL | | $x;
+LL | | }
+ | |_________^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:162:9
+ |
+LL | / unsafe {
+LL | |
+LL | | $x;
+LL | | $y;
+LL | | }
+ | |_________^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:222:9
+ |
+LL | / unsafe {
+LL | |
+LL | | $v;
+LL | | }
+ | |_________^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/default/test.rs:232:9
+ |
+LL | / unsafe {
+LL | |
+LL | | nested_macro_helper!($v);
+LL | | $v;
+LL | | }
+ | |_________^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+
+error: aborting due to 14 previous errors
+
diff --git a/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/private/clippy.toml b/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/private/clippy.toml
new file mode 100644
index 0000000..d4bbc2a
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/private/clippy.toml
@@ -0,0 +1 @@
+warn-unsafe-macro-metavars-in-private-macros = true
diff --git a/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/private/test.rs b/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/private/test.rs
new file mode 100644
index 0000000..2bbe1fa
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/private/test.rs
@@ -0,0 +1,15 @@
+//! Tests macro_metavars_in_unsafe with private (non-exported) macros
+#![warn(clippy::macro_metavars_in_unsafe)]
+
+macro_rules! mac {
+ ($v:expr) => {
+ unsafe {
+ //~^ ERROR: this macro expands metavariables in an unsafe block
+ dbg!($v);
+ }
+ };
+}
+
+fn main() {
+ mac!(1);
+}
diff --git a/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/private/test.stderr b/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/private/test.stderr
new file mode 100644
index 0000000..f9c418b
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/private/test.stderr
@@ -0,0 +1,17 @@
+error: this macro expands metavariables in an unsafe block
+ --> tests/ui-toml/macro_metavars_in_unsafe/private/test.rs:6:9
+ |
+LL | / unsafe {
+LL | |
+LL | | dbg!($v);
+LL | | }
+ | |_________^
+ |
+ = note: this allows the user of the macro to write unsafe code outside of an unsafe block
+ = help: consider expanding any metavariables outside of this block, e.g. by storing them in a variable
+ = help: ... or also expand referenced metavariables in a safe context to require an unsafe block at callsite
+ = note: `-D clippy::macro-metavars-in-unsafe` implied by `-D warnings`
+ = help: to override `-D warnings` add `#[allow(clippy::macro_metavars_in_unsafe)]`
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/clippy/tests/ui-toml/panic/clippy.toml b/src/tools/clippy/tests/ui-toml/panic/clippy.toml
new file mode 100644
index 0000000..5d6230d
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/panic/clippy.toml
@@ -0,0 +1 @@
+allow-panic-in-tests = true
diff --git a/src/tools/clippy/tests/ui-toml/panic/panic.rs b/src/tools/clippy/tests/ui-toml/panic/panic.rs
new file mode 100644
index 0000000..618a37d
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/panic/panic.rs
@@ -0,0 +1,54 @@
+//@compile-flags: --test
+#![warn(clippy::panic)]
+
+fn main() {
+ enum Enam {
+ A,
+ }
+ let a = Enam::A;
+ match a {
+ Enam::A => {},
+ _ => panic!(""),
+ }
+}
+
+#[test]
+fn lonely_test() {
+ enum Enam {
+ A,
+ }
+ let a = Enam::A;
+ match a {
+ Enam::A => {},
+ _ => panic!(""),
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ // should not lint in `#[cfg(test)]` modules
+ #[test]
+ fn test_fn() {
+ enum Enam {
+ A,
+ }
+ let a = Enam::A;
+ match a {
+ Enam::A => {},
+ _ => panic!(""),
+ }
+
+ bar();
+ }
+
+ fn bar() {
+ enum Enam {
+ A,
+ }
+ let a = Enam::A;
+ match a {
+ Enam::A => {},
+ _ => panic!(""),
+ }
+ }
+}
diff --git a/src/tools/clippy/tests/ui-toml/panic/panic.stderr b/src/tools/clippy/tests/ui-toml/panic/panic.stderr
new file mode 100644
index 0000000..bf7503e
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/panic/panic.stderr
@@ -0,0 +1,11 @@
+error: `panic` should not be present in production code
+ --> tests/ui-toml/panic/panic.rs:11:14
+ |
+LL | _ => panic!(""),
+ | ^^^^^^^^^^
+ |
+ = note: `-D clippy::panic` implied by `-D warnings`
+ = help: to override `-D warnings` add `#[allow(clippy::panic)]`
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/clippy/tests/ui-toml/renamed_function_params/default/clippy.toml b/src/tools/clippy/tests/ui-toml/renamed_function_params/default/clippy.toml
new file mode 100644
index 0000000..5381e70
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/renamed_function_params/default/clippy.toml
@@ -0,0 +1,2 @@
+# Ignore `From`, `TryFrom`, `FromStr` by default
+# allow-renamed-params-for = []
diff --git a/src/tools/clippy/tests/ui-toml/renamed_function_params/extend/clippy.toml b/src/tools/clippy/tests/ui-toml/renamed_function_params/extend/clippy.toml
new file mode 100644
index 0000000..9b3853e
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/renamed_function_params/extend/clippy.toml
@@ -0,0 +1,2 @@
+# Ignore `From`, `TryFrom`, `FromStr` by default
+allow-renamed-params-for = [ "..", "std::ops::Add", "renamed_function_params::MyTrait" ]
diff --git a/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.default.stderr b/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.default.stderr
new file mode 100644
index 0000000..2d700f6
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.default.stderr
@@ -0,0 +1,46 @@
+error: renamed function parameter of trait impl
+ --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:30:18
+ |
+LL | fn eq(&self, rhs: &Self) -> bool {
+ | ^^^ help: consider using the default name: `other`
+ |
+ = note: `-D clippy::renamed-function-params` implied by `-D warnings`
+ = help: to override `-D warnings` add `#[allow(clippy::renamed_function_params)]`
+
+error: renamed function parameter of trait impl
+ --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:34:18
+ |
+LL | fn ne(&self, rhs: &Self) -> bool {
+ | ^^^ help: consider using the default name: `other`
+
+error: renamed function parameter of trait impl
+ --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:48:19
+ |
+LL | fn foo(&self, i_dont_wanna_use_your_name: u8) {} // only lint in `extend`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using the default name: `val`
+
+error: renamed function parameter of trait impl
+ --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:55:31
+ |
+LL | fn hash<H: Hasher>(&self, states: &mut H) {
+ | ^^^^^^ help: consider using the default name: `state`
+
+error: renamed function parameters of trait impl
+ --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:59:30
+ |
+LL | fn hash_slice<H: Hasher>(date: &[Self], states: &mut H) {
+ | ^^^^ ^^^^^^
+ |
+help: consider using the default names
+ |
+LL | fn hash_slice<H: Hasher>(data: &[Self], state: &mut H) {
+ | ~~~~ ~~~~~
+
+error: renamed function parameter of trait impl
+ --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:80:18
+ |
+LL | fn add(self, b: B) -> C {
+ | ^ help: consider using the default name: `rhs`
+
+error: aborting due to 6 previous errors
+
diff --git a/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.extend.stderr b/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.extend.stderr
new file mode 100644
index 0000000..e57554f
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.extend.stderr
@@ -0,0 +1,34 @@
+error: renamed function parameter of trait impl
+ --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:30:18
+ |
+LL | fn eq(&self, rhs: &Self) -> bool {
+ | ^^^ help: consider using the default name: `other`
+ |
+ = note: `-D clippy::renamed-function-params` implied by `-D warnings`
+ = help: to override `-D warnings` add `#[allow(clippy::renamed_function_params)]`
+
+error: renamed function parameter of trait impl
+ --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:34:18
+ |
+LL | fn ne(&self, rhs: &Self) -> bool {
+ | ^^^ help: consider using the default name: `other`
+
+error: renamed function parameter of trait impl
+ --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:55:31
+ |
+LL | fn hash<H: Hasher>(&self, states: &mut H) {
+ | ^^^^^^ help: consider using the default name: `state`
+
+error: renamed function parameters of trait impl
+ --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:59:30
+ |
+LL | fn hash_slice<H: Hasher>(date: &[Self], states: &mut H) {
+ | ^^^^ ^^^^^^
+ |
+help: consider using the default names
+ |
+LL | fn hash_slice<H: Hasher>(data: &[Self], state: &mut H) {
+ | ~~~~ ~~~~~
+
+error: aborting due to 4 previous errors
+
diff --git a/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.rs b/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.rs
new file mode 100644
index 0000000..f3eb910
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.rs
@@ -0,0 +1,110 @@
+//@no-rustfix
+//@revisions: default extend
+//@[default] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/renamed_function_params/default
+//@[extend] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/renamed_function_params/extend
+#![warn(clippy::renamed_function_params)]
+#![allow(clippy::partialeq_ne_impl, clippy::to_string_trait_impl)]
+#![allow(unused)]
+
+use std::hash::{Hash, Hasher};
+
+struct A;
+impl From<A> for String {
+ fn from(_value: A) -> Self {
+ String::new()
+ }
+}
+impl ToString for A {
+ fn to_string(&self) -> String {
+ String::new()
+ }
+}
+
+struct B(u32);
+impl std::convert::From<B> for String {
+ fn from(b: B) -> Self {
+ b.0.to_string()
+ }
+}
+impl PartialEq for B {
+ fn eq(&self, rhs: &Self) -> bool {
+ //~^ ERROR: renamed function parameter of trait impl
+ self.0 == rhs.0
+ }
+ fn ne(&self, rhs: &Self) -> bool {
+ //~^ ERROR: renamed function parameter of trait impl
+ self.0 != rhs.0
+ }
+}
+
+trait MyTrait {
+ fn foo(&self, val: u8);
+ fn bar(a: u8, b: u8);
+ fn baz(self, _val: u8);
+ fn quz(&self, _: u8);
+}
+
+impl MyTrait for B {
+ fn foo(&self, i_dont_wanna_use_your_name: u8) {} // only lint in `extend`
+ fn bar(_a: u8, _: u8) {}
+ fn baz(self, val: u8) {}
+ fn quz(&self, val: u8) {}
+}
+
+impl Hash for B {
+ fn hash<H: Hasher>(&self, states: &mut H) {
+ //~^ ERROR: renamed function parameter of trait impl
+ self.0.hash(states);
+ }
+ fn hash_slice<H: Hasher>(date: &[Self], states: &mut H) {
+ //~^ ERROR: renamed function parameters of trait impl
+ for d in date {
+ d.hash(states);
+ }
+ }
+}
+
+impl B {
+ fn totally_irrelevant(&self, right: bool) {}
+ fn some_fn(&self, other: impl MyTrait) {}
+}
+
+#[derive(Copy, Clone)]
+enum C {
+ A,
+ B(u32),
+}
+
+impl std::ops::Add<B> for C {
+ type Output = C;
+ fn add(self, b: B) -> C {
+ // only lint in `extend`
+ C::B(b.0)
+ }
+}
+
+impl From<A> for C {
+ fn from(_: A) -> C {
+ C::A
+ }
+}
+
+trait CustomTraitA {
+ fn foo(&self, other: u32);
+}
+trait CustomTraitB {
+ fn bar(&self, value: u8);
+}
+
+macro_rules! impl_trait {
+ ($impl_for:ident, $tr:ty, $fn_name:ident, $t:ty) => {
+ impl $tr for $impl_for {
+ fn $fn_name(&self, v: $t) {}
+ }
+ };
+}
+
+impl_trait!(C, CustomTraitA, foo, u32);
+impl_trait!(C, CustomTraitB, bar, u8);
+
+fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs b/src/tools/clippy/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs
index 7f28efd..f02bd07 100644
--- a/src/tools/clippy/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs
+++ b/src/tools/clippy/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs
@@ -40,3 +40,9 @@
let _ = HashMap;
let _: usize = 64_usize;
}
+
+mod useless_attribute {
+ // Regression test for https://github.com/rust-lang/rust-clippy/issues/12753
+ #[allow(clippy::disallowed_types)]
+ use std::collections::HashMap;
+}
diff --git a/src/tools/clippy/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/src/tools/clippy/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 722e9b3..5cf9c0f 100644
--- a/src/tools/clippy/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/src/tools/clippy/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -8,8 +8,10 @@
allow-expect-in-tests
allow-mixed-uninlined-format-args
allow-one-hash-in-raw-strings
+ allow-panic-in-tests
allow-print-in-tests
allow-private-module-inception
+ allow-renamed-params-for
allow-unwrap-in-tests
allow-useless-vec-in-tests
allowed-dotfiles
@@ -74,6 +76,7 @@
vec-box-size-threshold
verbose-bit-mask-threshold
warn-on-all-wildcard-imports
+ warn-unsafe-macro-metavars-in-private-macros
--> $DIR/tests/ui-toml/toml_unknown_key/clippy.toml:2:1
|
LL | foobar = 42
@@ -89,8 +92,10 @@
allow-expect-in-tests
allow-mixed-uninlined-format-args
allow-one-hash-in-raw-strings
+ allow-panic-in-tests
allow-print-in-tests
allow-private-module-inception
+ allow-renamed-params-for
allow-unwrap-in-tests
allow-useless-vec-in-tests
allowed-dotfiles
@@ -155,6 +160,7 @@
vec-box-size-threshold
verbose-bit-mask-threshold
warn-on-all-wildcard-imports
+ warn-unsafe-macro-metavars-in-private-macros
--> $DIR/tests/ui-toml/toml_unknown_key/clippy.toml:4:1
|
LL | barfoo = 53
@@ -170,8 +176,10 @@
allow-expect-in-tests
allow-mixed-uninlined-format-args
allow-one-hash-in-raw-strings
+ allow-panic-in-tests
allow-print-in-tests
allow-private-module-inception
+ allow-renamed-params-for
allow-unwrap-in-tests
allow-useless-vec-in-tests
allowed-dotfiles
@@ -236,6 +244,7 @@
vec-box-size-threshold
verbose-bit-mask-threshold
warn-on-all-wildcard-imports
+ warn-unsafe-macro-metavars-in-private-macros
--> $DIR/tests/ui-toml/toml_unknown_key/clippy.toml:7:1
|
LL | allow_mixed_uninlined_format_args = true
diff --git a/src/tools/clippy/tests/ui/assigning_clones.fixed b/src/tools/clippy/tests/ui/assigning_clones.fixed
index 8387c7d..70ab43b 100644
--- a/src/tools/clippy/tests/ui/assigning_clones.fixed
+++ b/src/tools/clippy/tests/ui/assigning_clones.fixed
@@ -62,6 +62,16 @@
mut_thing.clone_from(ref_thing + ref_thing);
}
+fn clone_method_macro() {
+ let mut s = String::from("");
+ s.clone_from(&format!("{} {}", "hello", "world"));
+}
+
+fn clone_function_macro() {
+ let mut s = String::from("");
+ Clone::clone_from(&mut s, &format!("{} {}", "hello", "world"));
+}
+
fn assign_to_init_mut_var(b: HasCloneFrom) -> HasCloneFrom {
let mut a = HasCloneFrom;
for _ in 1..10 {
@@ -86,6 +96,12 @@
a = b.clone();
}
+fn late_init_let_tuple() {
+ let (p, q): (String, String);
+ p = "ghi".to_string();
+ q = p.clone();
+}
+
#[derive(Clone)]
pub struct HasDeriveClone;
@@ -208,6 +224,16 @@
ToOwned::clone_into(ref_str, &mut mut_thing);
}
+fn owned_method_macro() {
+ let mut s = String::from("");
+ format!("{} {}", "hello", "world").clone_into(&mut s);
+}
+
+fn owned_function_macro() {
+ let mut s = String::from("");
+ ToOwned::clone_into(&format!("{} {}", "hello", "world"), &mut s);
+}
+
struct FakeToOwned;
impl FakeToOwned {
/// This looks just like `ToOwned::to_owned`
diff --git a/src/tools/clippy/tests/ui/assigning_clones.rs b/src/tools/clippy/tests/ui/assigning_clones.rs
index 6f4da9f..9699fed 100644
--- a/src/tools/clippy/tests/ui/assigning_clones.rs
+++ b/src/tools/clippy/tests/ui/assigning_clones.rs
@@ -62,6 +62,16 @@
*mut_thing = (ref_thing + ref_thing).clone();
}
+fn clone_method_macro() {
+ let mut s = String::from("");
+ s = format!("{} {}", "hello", "world").clone();
+}
+
+fn clone_function_macro() {
+ let mut s = String::from("");
+ s = Clone::clone(&format!("{} {}", "hello", "world"));
+}
+
fn assign_to_init_mut_var(b: HasCloneFrom) -> HasCloneFrom {
let mut a = HasCloneFrom;
for _ in 1..10 {
@@ -86,6 +96,12 @@
a = b.clone();
}
+fn late_init_let_tuple() {
+ let (p, q): (String, String);
+ p = "ghi".to_string();
+ q = p.clone();
+}
+
#[derive(Clone)]
pub struct HasDeriveClone;
@@ -208,6 +224,16 @@
mut_thing = ToOwned::to_owned(ref_str);
}
+fn owned_method_macro() {
+ let mut s = String::from("");
+ s = format!("{} {}", "hello", "world").to_owned();
+}
+
+fn owned_function_macro() {
+ let mut s = String::from("");
+ s = ToOwned::to_owned(&format!("{} {}", "hello", "world"));
+}
+
struct FakeToOwned;
impl FakeToOwned {
/// This looks just like `ToOwned::to_owned`
diff --git a/src/tools/clippy/tests/ui/assigning_clones.stderr b/src/tools/clippy/tests/ui/assigning_clones.stderr
index 793927b..a685163 100644
--- a/src/tools/clippy/tests/ui/assigning_clones.stderr
+++ b/src/tools/clippy/tests/ui/assigning_clones.stderr
@@ -62,64 +62,88 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `mut_thing.clone_from(ref_thing + ref_thing)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:68:9
+ --> tests/ui/assigning_clones.rs:67:5
+ |
+LL | s = format!("{} {}", "hello", "world").clone();
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `s.clone_from(&format!("{} {}", "hello", "world"))`
+
+error: assigning the result of `Clone::clone()` may be inefficient
+ --> tests/ui/assigning_clones.rs:72:5
+ |
+LL | s = Clone::clone(&format!("{} {}", "hello", "world"));
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(&mut s, &format!("{} {}", "hello", "world"))`
+
+error: assigning the result of `Clone::clone()` may be inefficient
+ --> tests/ui/assigning_clones.rs:78:9
|
LL | a = b.clone();
| ^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:133:5
+ --> tests/ui/assigning_clones.rs:149:5
|
LL | a = b.clone();
| ^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
error: assigning the result of `Clone::clone()` may be inefficient
- --> tests/ui/assigning_clones.rs:140:5
+ --> tests/ui/assigning_clones.rs:156:5
|
LL | a = b.clone();
| ^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:141:5
+ --> tests/ui/assigning_clones.rs:157:5
|
LL | a = c.to_owned();
| ^^^^^^^^^^^^^^^^ help: use `clone_into()`: `c.clone_into(&mut a)`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:171:5
+ --> tests/ui/assigning_clones.rs:187:5
|
LL | *mut_string = ref_str.to_owned();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(mut_string)`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:175:5
+ --> tests/ui/assigning_clones.rs:191:5
|
LL | mut_string = ref_str.to_owned();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(&mut mut_string)`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:196:5
+ --> tests/ui/assigning_clones.rs:212:5
|
LL | **mut_box_string = ref_str.to_owned();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(&mut (*mut_box_string))`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:200:5
+ --> tests/ui/assigning_clones.rs:216:5
|
LL | **mut_box_string = ref_str.to_owned();
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(&mut (*mut_box_string))`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:204:5
+ --> tests/ui/assigning_clones.rs:220:5
|
LL | *mut_thing = ToOwned::to_owned(ref_str);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ToOwned::clone_into(ref_str, mut_thing)`
error: assigning the result of `ToOwned::to_owned()` may be inefficient
- --> tests/ui/assigning_clones.rs:208:5
+ --> tests/ui/assigning_clones.rs:224:5
|
LL | mut_thing = ToOwned::to_owned(ref_str);
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ToOwned::clone_into(ref_str, &mut mut_thing)`
-error: aborting due to 20 previous errors
+error: assigning the result of `ToOwned::to_owned()` may be inefficient
+ --> tests/ui/assigning_clones.rs:229:5
+ |
+LL | s = format!("{} {}", "hello", "world").to_owned();
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `format!("{} {}", "hello", "world").clone_into(&mut s)`
+
+error: assigning the result of `ToOwned::to_owned()` may be inefficient
+ --> tests/ui/assigning_clones.rs:234:5
+ |
+LL | s = ToOwned::to_owned(&format!("{} {}", "hello", "world"));
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ToOwned::clone_into(&format!("{} {}", "hello", "world"), &mut s)`
+
+error: aborting due to 24 previous errors
diff --git a/src/tools/clippy/tests/ui/doc/doc_lazy_blockquote.fixed b/src/tools/clippy/tests/ui/doc/doc_lazy_blockquote.fixed
new file mode 100644
index 0000000..9877991
--- /dev/null
+++ b/src/tools/clippy/tests/ui/doc/doc_lazy_blockquote.fixed
@@ -0,0 +1,47 @@
+#![warn(clippy::doc_lazy_continuation)]
+
+/// > blockquote with
+/// > lazy continuation
+//~^ ERROR: doc quote missing `>` marker
+fn first() {}
+
+/// > blockquote with no
+/// > lazy continuation
+fn first_nowarn() {}
+
+/// > blockquote with no
+///
+/// lazy continuation
+fn two_nowarn() {}
+
+/// > nest here
+/// >
+/// > > nest here
+/// > > lazy continuation
+//~^ ERROR: doc quote missing `>` marker
+fn two() {}
+
+/// > nest here
+/// >
+/// > > nest here
+/// > > lazy continuation
+//~^ ERROR: doc quote missing `>` marker
+fn three() {}
+
+/// > * > nest here
+/// > > lazy continuation
+//~^ ERROR: doc quote missing `>` marker
+fn four() {}
+
+/// > * > nest here
+/// > > lazy continuation
+//~^ ERROR: doc quote missing `>` marker
+fn four_point_1() {}
+
+/// * > nest here lazy continuation
+fn five() {}
+
+/// 1. > nest here
+/// > lazy continuation (this results in strange indentation, but still works)
+//~^ ERROR: doc quote missing `>` marker
+fn six() {}
diff --git a/src/tools/clippy/tests/ui/doc/doc_lazy_blockquote.rs b/src/tools/clippy/tests/ui/doc/doc_lazy_blockquote.rs
new file mode 100644
index 0000000..587b2fd
--- /dev/null
+++ b/src/tools/clippy/tests/ui/doc/doc_lazy_blockquote.rs
@@ -0,0 +1,47 @@
+#![warn(clippy::doc_lazy_continuation)]
+
+/// > blockquote with
+/// lazy continuation
+//~^ ERROR: doc quote missing `>` marker
+fn first() {}
+
+/// > blockquote with no
+/// > lazy continuation
+fn first_nowarn() {}
+
+/// > blockquote with no
+///
+/// lazy continuation
+fn two_nowarn() {}
+
+/// > nest here
+/// >
+/// > > nest here
+/// > lazy continuation
+//~^ ERROR: doc quote missing `>` marker
+fn two() {}
+
+/// > nest here
+/// >
+/// > > nest here
+/// lazy continuation
+//~^ ERROR: doc quote missing `>` marker
+fn three() {}
+
+/// > * > nest here
+/// lazy continuation
+//~^ ERROR: doc quote missing `>` marker
+fn four() {}
+
+/// > * > nest here
+/// lazy continuation
+//~^ ERROR: doc quote missing `>` marker
+fn four_point_1() {}
+
+/// * > nest here lazy continuation
+fn five() {}
+
+/// 1. > nest here
+/// lazy continuation (this results in strange indentation, but still works)
+//~^ ERROR: doc quote missing `>` marker
+fn six() {}
diff --git a/src/tools/clippy/tests/ui/doc/doc_lazy_blockquote.stderr b/src/tools/clippy/tests/ui/doc/doc_lazy_blockquote.stderr
new file mode 100644
index 0000000..975184a
--- /dev/null
+++ b/src/tools/clippy/tests/ui/doc/doc_lazy_blockquote.stderr
@@ -0,0 +1,76 @@
+error: doc quote missing `>` marker
+ --> tests/ui/doc/doc_lazy_blockquote.rs:4:5
+ |
+LL | /// lazy continuation
+ | ^
+ |
+ = help: if this not intended to be a quote at all, escape it with `\>`
+ = note: `-D clippy::doc-lazy-continuation` implied by `-D warnings`
+ = help: to override `-D warnings` add `#[allow(clippy::doc_lazy_continuation)]`
+help: add markers to start of line
+ |
+LL | /// > lazy continuation
+ | +
+
+error: doc quote missing `>` marker
+ --> tests/ui/doc/doc_lazy_blockquote.rs:20:5
+ |
+LL | /// > lazy continuation
+ | ^^
+ |
+ = help: if this not intended to be a quote at all, escape it with `\>`
+help: add markers to start of line
+ |
+LL | /// > > lazy continuation
+ | +
+
+error: doc quote missing `>` marker
+ --> tests/ui/doc/doc_lazy_blockquote.rs:27:5
+ |
+LL | /// lazy continuation
+ | ^
+ |
+ = help: if this not intended to be a quote at all, escape it with `\>`
+help: add markers to start of line
+ |
+LL | /// > > lazy continuation
+ | +++
+
+error: doc quote missing `>` marker
+ --> tests/ui/doc/doc_lazy_blockquote.rs:32:5
+ |
+LL | /// lazy continuation
+ | ^
+ |
+ = help: if this not intended to be a quote at all, escape it with `\>`
+help: add markers to start of line
+ |
+LL | /// > > lazy continuation
+ | +++++++
+
+error: doc quote missing `>` marker
+ --> tests/ui/doc/doc_lazy_blockquote.rs:37:5
+ |
+LL | /// lazy continuation
+ | ^
+ |
+ = help: if this not intended to be a quote at all, escape it with `\>`
+help: add markers to start of line
+ |
+LL | /// > > lazy continuation
+ | +++++
+
+error: doc quote missing `>` marker
+ --> tests/ui/doc/doc_lazy_blockquote.rs:45:5
+ |
+LL | /// lazy continuation (this results in strange indentation, but still works)
+ | ^
+ |
+ = help: if this not intended to be a quote at all, escape it with `\>`
+help: add markers to start of line
+ |
+LL | /// > lazy continuation (this results in strange indentation, but still works)
+ | +
+
+error: aborting due to 6 previous errors
+
diff --git a/src/tools/clippy/tests/ui/doc/doc_lazy_list.fixed b/src/tools/clippy/tests/ui/doc/doc_lazy_list.fixed
new file mode 100644
index 0000000..409e6b0
--- /dev/null
+++ b/src/tools/clippy/tests/ui/doc/doc_lazy_list.fixed
@@ -0,0 +1,77 @@
+#![warn(clippy::doc_lazy_continuation)]
+
+/// 1. nest here
+/// lazy continuation
+//~^ ERROR: doc list item missing indentation
+fn one() {}
+
+/// 1. first line
+/// lazy list continuations don't make warnings with this lint
+//~^ ERROR: doc list item missing indentation
+/// because they don't have the
+//~^ ERROR: doc list item missing indentation
+fn two() {}
+
+/// - nest here
+/// lazy continuation
+//~^ ERROR: doc list item missing indentation
+fn three() {}
+
+/// - first line
+/// lazy list continuations don't make warnings with this lint
+//~^ ERROR: doc list item missing indentation
+/// because they don't have the
+//~^ ERROR: doc list item missing indentation
+fn four() {}
+
+/// - nest here
+/// lazy continuation
+//~^ ERROR: doc list item missing indentation
+fn five() {}
+
+/// - - first line
+/// this will warn on the lazy continuation
+//~^ ERROR: doc list item missing indentation
+/// and so should this
+//~^ ERROR: doc list item missing indentation
+fn six() {}
+
+/// - - first line
+///
+/// this is not a lazy continuation
+fn seven() {}
+
+#[rustfmt::skip]
+// https://github.com/rust-lang/rust-clippy/pull/12770#issuecomment-2118601768
+/// Returns a list of ProtocolDescriptors from a Serde JSON input.
+///
+/// Defined Protocol Identifiers for the Protocol Descriptor
+/// We intentionally omit deprecated profile identifiers.
+/// From Bluetooth Assigned Numbers:
+/// https://www.bluetooth.com/specifications/assigned-numbers/service-discovery
+///
+/// # Arguments
+/// * `protocol_descriptors`: A Json Representation of the ProtocolDescriptors
+/// to set up. Example:
+/// 'protocol_descriptors': [
+//~^ ERROR: doc list item missing indentation
+/// {
+/// 'protocol': 25, # u64 Representation of ProtocolIdentifier::AVDTP
+/// 'params': [
+/// {
+/// 'data': 0x0103 # to indicate 1.3
+/// },
+/// {
+/// 'data': 0x0105 # to indicate 1.5
+/// }
+/// ]
+/// },
+/// {
+/// 'protocol': 1, # u64 Representation of ProtocolIdentifier::SDP
+/// 'params': [{
+/// 'data': 0x0019
+/// }]
+/// }
+/// ]
+//~^ ERROR: doc list item missing indentation
+fn eight() {}
diff --git a/src/tools/clippy/tests/ui/doc/doc_lazy_list.rs b/src/tools/clippy/tests/ui/doc/doc_lazy_list.rs
new file mode 100644
index 0000000..30ab448
--- /dev/null
+++ b/src/tools/clippy/tests/ui/doc/doc_lazy_list.rs
@@ -0,0 +1,77 @@
+#![warn(clippy::doc_lazy_continuation)]
+
+/// 1. nest here
+/// lazy continuation
+//~^ ERROR: doc list item missing indentation
+fn one() {}
+
+/// 1. first line
+/// lazy list continuations don't make warnings with this lint
+//~^ ERROR: doc list item missing indentation
+/// because they don't have the
+//~^ ERROR: doc list item missing indentation
+fn two() {}
+
+/// - nest here
+/// lazy continuation
+//~^ ERROR: doc list item missing indentation
+fn three() {}
+
+/// - first line
+/// lazy list continuations don't make warnings with this lint
+//~^ ERROR: doc list item missing indentation
+/// because they don't have the
+//~^ ERROR: doc list item missing indentation
+fn four() {}
+
+/// - nest here
+/// lazy continuation
+//~^ ERROR: doc list item missing indentation
+fn five() {}
+
+/// - - first line
+/// this will warn on the lazy continuation
+//~^ ERROR: doc list item missing indentation
+/// and so should this
+//~^ ERROR: doc list item missing indentation
+fn six() {}
+
+/// - - first line
+///
+/// this is not a lazy continuation
+fn seven() {}
+
+#[rustfmt::skip]
+// https://github.com/rust-lang/rust-clippy/pull/12770#issuecomment-2118601768
+/// Returns a list of ProtocolDescriptors from a Serde JSON input.
+///
+/// Defined Protocol Identifiers for the Protocol Descriptor
+/// We intentionally omit deprecated profile identifiers.
+/// From Bluetooth Assigned Numbers:
+/// https://www.bluetooth.com/specifications/assigned-numbers/service-discovery
+///
+/// # Arguments
+/// * `protocol_descriptors`: A Json Representation of the ProtocolDescriptors
+/// to set up. Example:
+/// 'protocol_descriptors': [
+//~^ ERROR: doc list item missing indentation
+/// {
+/// 'protocol': 25, # u64 Representation of ProtocolIdentifier::AVDTP
+/// 'params': [
+/// {
+/// 'data': 0x0103 # to indicate 1.3
+/// },
+/// {
+/// 'data': 0x0105 # to indicate 1.5
+/// }
+/// ]
+/// },
+/// {
+/// 'protocol': 1, # u64 Representation of ProtocolIdentifier::SDP
+/// 'params': [{
+/// 'data': 0x0019
+/// }]
+/// }
+/// ]
+//~^ ERROR: doc list item missing indentation
+fn eight() {}
diff --git a/src/tools/clippy/tests/ui/doc/doc_lazy_list.stderr b/src/tools/clippy/tests/ui/doc/doc_lazy_list.stderr
new file mode 100644
index 0000000..ddfdc49
--- /dev/null
+++ b/src/tools/clippy/tests/ui/doc/doc_lazy_list.stderr
@@ -0,0 +1,136 @@
+error: doc list item missing indentation
+ --> tests/ui/doc/doc_lazy_list.rs:4:5
+ |
+LL | /// lazy continuation
+ | ^
+ |
+ = help: if this is supposed to be its own paragraph, add a blank line
+ = note: `-D clippy::doc-lazy-continuation` implied by `-D warnings`
+ = help: to override `-D warnings` add `#[allow(clippy::doc_lazy_continuation)]`
+help: indent this line
+ |
+LL | /// lazy continuation
+ | +++
+
+error: doc list item missing indentation
+ --> tests/ui/doc/doc_lazy_list.rs:9:5
+ |
+LL | /// lazy list continuations don't make warnings with this lint
+ | ^
+ |
+ = help: if this is supposed to be its own paragraph, add a blank line
+help: indent this line
+ |
+LL | /// lazy list continuations don't make warnings with this lint
+ | +++
+
+error: doc list item missing indentation
+ --> tests/ui/doc/doc_lazy_list.rs:11:5
+ |
+LL | /// because they don't have the
+ | ^
+ |
+ = help: if this is supposed to be its own paragraph, add a blank line
+help: indent this line
+ |
+LL | /// because they don't have the
+ | +++
+
+error: doc list item missing indentation
+ --> tests/ui/doc/doc_lazy_list.rs:16:5
+ |
+LL | /// lazy continuation
+ | ^
+ |
+ = help: if this is supposed to be its own paragraph, add a blank line
+help: indent this line
+ |
+LL | /// lazy continuation
+ | ++++
+
+error: doc list item missing indentation
+ --> tests/ui/doc/doc_lazy_list.rs:21:5
+ |
+LL | /// lazy list continuations don't make warnings with this lint
+ | ^
+ |
+ = help: if this is supposed to be its own paragraph, add a blank line
+help: indent this line
+ |
+LL | /// lazy list continuations don't make warnings with this lint
+ | ++++
+
+error: doc list item missing indentation
+ --> tests/ui/doc/doc_lazy_list.rs:23:5
+ |
+LL | /// because they don't have the
+ | ^
+ |
+ = help: if this is supposed to be its own paragraph, add a blank line
+help: indent this line
+ |
+LL | /// because they don't have the
+ | ++++
+
+error: doc list item missing indentation
+ --> tests/ui/doc/doc_lazy_list.rs:28:5
+ |
+LL | /// lazy continuation
+ | ^
+ |
+ = help: if this is supposed to be its own paragraph, add a blank line
+help: indent this line
+ |
+LL | /// lazy continuation
+ | ++++
+
+error: doc list item missing indentation
+ --> tests/ui/doc/doc_lazy_list.rs:33:5
+ |
+LL | /// this will warn on the lazy continuation
+ | ^
+ |
+ = help: if this is supposed to be its own paragraph, add a blank line
+help: indent this line
+ |
+LL | /// this will warn on the lazy continuation
+ | ++++++
+
+error: doc list item missing indentation
+ --> tests/ui/doc/doc_lazy_list.rs:35:5
+ |
+LL | /// and so should this
+ | ^^^^
+ |
+ = help: if this is supposed to be its own paragraph, add a blank line
+help: indent this line
+ |
+LL | /// and so should this
+ | ++
+
+error: doc list item missing indentation
+ --> tests/ui/doc/doc_lazy_list.rs:56:5
+ |
+LL | /// 'protocol_descriptors': [
+ | ^
+ |
+ = help: if this is supposed to be its own paragraph, add a blank line
+help: indent this line
+ |
+LL | /// 'protocol_descriptors': [
+ | +
+
+error: doc list item missing indentation
+ --> tests/ui/doc/doc_lazy_list.rs:75:5
+ |
+LL | /// ]
+ | ^
+ |
+ = help: if this is supposed to be its own paragraph, add a blank line
+help: indent this line
+ |
+LL | /// ]
+ | +
+
+error: aborting due to 11 previous errors
+
diff --git a/src/tools/clippy/tests/ui/duplicated_attributes.rs b/src/tools/clippy/tests/ui/duplicated_attributes.rs
index d51e7e3..97cf4a6 100644
--- a/src/tools/clippy/tests/ui/duplicated_attributes.rs
+++ b/src/tools/clippy/tests/ui/duplicated_attributes.rs
@@ -1,5 +1,5 @@
//@aux-build:proc_macro_attr.rs
-
+#![feature(rustc_attrs)]
#![warn(clippy::duplicated_attributes)]
#![cfg(any(unix, windows))]
#![allow(dead_code)]
@@ -20,6 +20,10 @@
#[cfg(unix)] // cfgs are not handled
fn bar() {}
+// No warning:
+#[rustc_on_unimplemented(on(_Self = "&str", label = "`a"), on(_Self = "alloc::string::String", label = "a"))]
+trait Abc {}
+
#[proc_macro_attr::duplicated_attr()] // Should not warn!
fn babar() {}
diff --git a/src/tools/clippy/tests/ui/from_str_radix_10.fixed b/src/tools/clippy/tests/ui/from_str_radix_10.fixed
index 8c253bf..f9ce1de 100644
--- a/src/tools/clippy/tests/ui/from_str_radix_10.fixed
+++ b/src/tools/clippy/tests/ui/from_str_radix_10.fixed
@@ -1,3 +1,4 @@
+#![feature(const_int_from_str)]
#![warn(clippy::from_str_radix_10)]
mod some_mod {
@@ -59,3 +60,13 @@
Ok(())
}
+
+fn issue_12732() {
+ const A: Result<u32, std::num::ParseIntError> = u32::from_str_radix("123", 10);
+ const B: () = {
+ let _ = u32::from_str_radix("123", 10);
+ };
+ const fn foo() {
+ let _ = u32::from_str_radix("123", 10);
+ }
+}
diff --git a/src/tools/clippy/tests/ui/from_str_radix_10.rs b/src/tools/clippy/tests/ui/from_str_radix_10.rs
index e9d0221..2d5b351 100644
--- a/src/tools/clippy/tests/ui/from_str_radix_10.rs
+++ b/src/tools/clippy/tests/ui/from_str_radix_10.rs
@@ -1,3 +1,4 @@
+#![feature(const_int_from_str)]
#![warn(clippy::from_str_radix_10)]
mod some_mod {
@@ -59,3 +60,13 @@
Ok(())
}
+
+fn issue_12732() {
+ const A: Result<u32, std::num::ParseIntError> = u32::from_str_radix("123", 10);
+ const B: () = {
+ let _ = u32::from_str_radix("123", 10);
+ };
+ const fn foo() {
+ let _ = u32::from_str_radix("123", 10);
+ }
+}
diff --git a/src/tools/clippy/tests/ui/from_str_radix_10.stderr b/src/tools/clippy/tests/ui/from_str_radix_10.stderr
index 4aa84ec..01a1bf8 100644
--- a/src/tools/clippy/tests/ui/from_str_radix_10.stderr
+++ b/src/tools/clippy/tests/ui/from_str_radix_10.stderr
@@ -1,5 +1,5 @@
error: this call to `from_str_radix` can be replaced with a call to `str::parse`
- --> tests/ui/from_str_radix_10.rs:28:5
+ --> tests/ui/from_str_radix_10.rs:29:5
|
LL | u32::from_str_radix("30", 10)?;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"30".parse::<u32>()`
@@ -8,43 +8,43 @@
= help: to override `-D warnings` add `#[allow(clippy::from_str_radix_10)]`
error: this call to `from_str_radix` can be replaced with a call to `str::parse`
- --> tests/ui/from_str_radix_10.rs:31:5
+ --> tests/ui/from_str_radix_10.rs:32:5
|
LL | i64::from_str_radix("24", 10)?;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"24".parse::<i64>()`
error: this call to `from_str_radix` can be replaced with a call to `str::parse`
- --> tests/ui/from_str_radix_10.rs:33:5
+ --> tests/ui/from_str_radix_10.rs:34:5
|
LL | isize::from_str_radix("100", 10)?;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"100".parse::<isize>()`
error: this call to `from_str_radix` can be replaced with a call to `str::parse`
- --> tests/ui/from_str_radix_10.rs:35:5
+ --> tests/ui/from_str_radix_10.rs:36:5
|
LL | u8::from_str_radix("7", 10)?;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"7".parse::<u8>()`
error: this call to `from_str_radix` can be replaced with a call to `str::parse`
- --> tests/ui/from_str_radix_10.rs:37:5
+ --> tests/ui/from_str_radix_10.rs:38:5
|
LL | u16::from_str_radix(&("10".to_owned() + "5"), 10)?;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `("10".to_owned() + "5").parse::<u16>()`
error: this call to `from_str_radix` can be replaced with a call to `str::parse`
- --> tests/ui/from_str_radix_10.rs:39:5
+ --> tests/ui/from_str_radix_10.rs:40:5
|
LL | i128::from_str_radix(Test + Test, 10)?;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(Test + Test).parse::<i128>()`
error: this call to `from_str_radix` can be replaced with a call to `str::parse`
- --> tests/ui/from_str_radix_10.rs:43:5
+ --> tests/ui/from_str_radix_10.rs:44:5
|
LL | i32::from_str_radix(string, 10)?;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `string.parse::<i32>()`
error: this call to `from_str_radix` can be replaced with a call to `str::parse`
- --> tests/ui/from_str_radix_10.rs:47:5
+ --> tests/ui/from_str_radix_10.rs:48:5
|
LL | i32::from_str_radix(&stringier, 10)?;
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `stringier.parse::<i32>()`
diff --git a/src/tools/clippy/tests/ui/match_same_arms.stderr b/src/tools/clippy/tests/ui/match_same_arms.stderr
index a926570..3c03827 100644
--- a/src/tools/clippy/tests/ui/match_same_arms.stderr
+++ b/src/tools/clippy/tests/ui/match_same_arms.stderr
@@ -2,7 +2,7 @@
--> tests/ui/match_same_arms.rs:12:9
|
LL | Abc::A => 0,
- | ^^^^^^^^^^^ help: try removing the arm
+ | ^^^^^^^^^^^^^ help: try removing the arm
|
= help: or try changing either arm body
note: `_` wildcard arm here
@@ -17,106 +17,114 @@
--> tests/ui/match_same_arms.rs:18:9
|
LL | (1, .., 3) => 42,
- | ----------^^^^^^
- | |
- | help: try merging the arm patterns: `(1, .., 3) | (.., 3)`
+ | ^^^^^^^^^^^^^^^^
|
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms.rs:19:9
+ = help: try changing either arm body
+help: or try merging the arm patterns
|
-LL | (.., 3) => 42,
- | ^^^^^^^^^^^^^
+LL | (1, .., 3) | (.., 3) => 42,
+ | ~~~~~~~~~~~~~~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - (.., 3) => 42,
+ |
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms.rs:25:9
|
LL | 51 => 1,
- | --^^^^^
- | |
- | help: try merging the arm patterns: `51 | 42`
- |
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms.rs:24:9
- |
-LL | 42 => 1,
| ^^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | 51 | 42 => 1,
+ | ~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - 42 => 1,
+ |
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms.rs:26:9
|
LL | 41 => 2,
- | --^^^^^
- | |
- | help: try merging the arm patterns: `41 | 52`
- |
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms.rs:27:9
- |
-LL | 52 => 2,
| ^^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | 41 | 52 => 2,
+ | ~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - 52 => 2,
+ |
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms.rs:33:9
|
LL | 2 => 2,
- | -^^^^^
- | |
- | help: try merging the arm patterns: `2 | 1`
- |
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms.rs:32:9
- |
-LL | 1 => 2,
| ^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | 2 | 1 => 2,
+ | ~~~~~
+help: and remove this obsolete arm
+ |
+LL - 1 => 2,
+ |
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms.rs:35:9
|
LL | 3 => 2,
- | -^^^^^
- | |
- | help: try merging the arm patterns: `3 | 1`
- |
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms.rs:32:9
- |
-LL | 1 => 2,
| ^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | 3 | 1 => 2,
+ | ~~~~~
+help: and remove this obsolete arm
+ |
+LL - 1 => 2,
+ |
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms.rs:33:9
|
LL | 2 => 2,
- | -^^^^^
- | |
- | help: try merging the arm patterns: `2 | 3`
- |
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms.rs:35:9
- |
-LL | 3 => 2,
| ^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | 2 | 3 => 2,
+ | ~~~~~
+help: and remove this obsolete arm
+ |
+LL - 3 => 2,
+LL +
+ |
error: this match arm has an identical body to another arm
--> tests/ui/match_same_arms.rs:52:17
|
LL | CommandInfo::External { name, .. } => name.to_string(),
- | ----------------------------------^^^^^^^^^^^^^^^^^^^^
- | |
- | help: try merging the arm patterns: `CommandInfo::External { name, .. } | CommandInfo::BuiltIn { name, .. }`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms.rs:51:17
+ = help: try changing either arm body
+help: or try merging the arm patterns
|
-LL | CommandInfo::BuiltIn { name, .. } => name.to_string(),
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | CommandInfo::External { name, .. } | CommandInfo::BuiltIn { name, .. } => name.to_string(),
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - CommandInfo::BuiltIn { name, .. } => name.to_string(),
+ |
error: aborting due to 8 previous errors
diff --git a/src/tools/clippy/tests/ui/match_same_arms2.fixed b/src/tools/clippy/tests/ui/match_same_arms2.fixed
new file mode 100644
index 0000000..fba0cf3
--- /dev/null
+++ b/src/tools/clippy/tests/ui/match_same_arms2.fixed
@@ -0,0 +1,241 @@
+#![warn(clippy::match_same_arms)]
+#![allow(
+ clippy::disallowed_names,
+ clippy::diverging_sub_expression,
+ clippy::uninlined_format_args,
+ clippy::match_single_binding,
+ clippy::match_like_matches_macro
+)]
+fn bar<T>(_: T) {}
+fn foo() -> bool {
+ unimplemented!()
+}
+
+fn match_same_arms() {
+ let _ = match 42 {
+ _ => {
+ foo();
+ let mut a = 42 + [23].len() as i32;
+ if true {
+ a += 7;
+ }
+ a = -31 - a;
+ a
+ },
+ };
+ //~^^^^^^^^^^^^^^^^^^^ ERROR: this match arm has an identical body to the `_` wildcard arm
+
+ let _ = match 42 {
+ 51 | 42 => foo(), //~ ERROR: this match arm has an identical body to another arm
+ _ => true,
+ };
+
+ let _ = match Some(42) {
+ None | Some(_) => 24, //~ ERROR: this match arm has an identical body to another arm
+ };
+
+ let _ = match Some(42) {
+ Some(foo) => 24,
+ None => 24,
+ };
+
+ let _ = match Some(42) {
+ Some(42) => 24,
+ Some(a) => 24, // bindings are different
+ None => 0,
+ };
+
+ let _ = match Some(42) {
+ Some(a) if a > 0 => 24,
+ Some(a) => 24, // one arm has a guard
+ None => 0,
+ };
+
+ match (Some(42), Some(42)) {
+ (None, Some(a)) | (Some(a), None) => bar(a), //~ ERROR: this match arm has an identical body to another arm
+ _ => (),
+ }
+
+ // No warning because guards are different
+ let _ = match Some(42) {
+ Some(a) if a == 42 => a,
+ Some(a) if a == 24 => a,
+ Some(_) => 24,
+ None => 0,
+ };
+
+ let _ = match (Some(42), Some(42)) {
+ (None, Some(a)) | (Some(a), None) if a == 42 => a, //~ ERROR: this match arm has an identical body to another arm
+ _ => 0,
+ };
+
+ match (Some(42), Some(42)) {
+ (Some(a), ..) | (.., Some(a)) => bar(a), //~ ERROR: this match arm has an identical body to another arm
+ _ => (),
+ }
+
+ let _ = match Some(()) {
+ Some(()) => 0.0,
+ None => -0.0,
+ };
+
+ match (Some(42), Some("")) {
+ (Some(a), None) => bar(a),
+ (None, Some(a)) => bar(a), // bindings have different types
+ _ => (),
+ }
+
+ let x: Result<i32, &str> = Ok(3);
+
+ // No warning because of the guard.
+ match x {
+ Ok(x) if x * x == 64 => println!("ok"),
+ Ok(_) => println!("ok"),
+ Err(_) => println!("err"),
+ }
+
+ // This used to be a false positive; see issue #1996.
+ match x {
+ Ok(3) => println!("ok"),
+ Ok(x) if x * x == 64 => println!("ok 64"),
+ Ok(_) => println!("ok"),
+ Err(_) => println!("err"),
+ }
+
+ match (x, Some(1i32)) {
+ (Ok(x), Some(_)) | (Ok(_), Some(x)) => println!("ok {}", x), //~ ERROR: this match arm has an identical body to another arm
+ _ => println!("err"),
+ }
+
+ // No warning; different types for `x`.
+ match (x, Some(1.0f64)) {
+ (Ok(x), Some(_)) => println!("ok {}", x),
+ (Ok(_), Some(x)) => println!("ok {}", x),
+ _ => println!("err"),
+ }
+
+ // False negative #2251.
+ match x {
+ Ok(_tmp) => println!("ok"),
+ Ok(_) | Ok(3) => println!("ok"), //~ ERROR: this match arm has an identical body to another arm
+ Err(_) => {
+ unreachable!();
+ },
+ }
+
+ // False positive #1390
+ macro_rules! empty {
+ ($e:expr) => {};
+ }
+ match 0 {
+ 0 => {
+ empty!(0);
+ },
+ 1 => {
+ empty!(1);
+ },
+ x => {
+ empty!(x);
+ },
+ };
+
+ // still lint if the tokens are the same
+ match 0 {
+ 1 | 0 => {
+ empty!(0);
+ },
+ x => {
+ empty!(x);
+ },
+ }
+ //~^^^^^^^ ERROR: this match arm has an identical body to another arm
+
+ match_expr_like_matches_macro_priority();
+}
+
+fn match_expr_like_matches_macro_priority() {
+ enum E {
+ A,
+ B,
+ C,
+ }
+ let x = E::A;
+ let _ans = match x {
+ E::A => false,
+ E::B => false,
+ _ => true,
+ };
+}
+
+fn main() {
+ let _ = match Some(0) {
+ Some(0) => 0,
+ Some(1) => 1,
+ #[cfg(feature = "foo")]
+ Some(2) => 2,
+ _ => 1,
+ };
+
+ enum Foo {
+ X(u32),
+ Y(u32),
+ Z(u32),
+ }
+
+ // Don't lint. `Foo::X(0)` and `Foo::Z(_)` overlap with the arm in between.
+ let _ = match Foo::X(0) {
+ Foo::X(0) => 1,
+ Foo::X(_) | Foo::Y(_) | Foo::Z(0) => 2,
+ Foo::Z(_) => 1,
+ _ => 0,
+ };
+
+ // Suggest moving `Foo::Z(_)` up.
+ let _ = match Foo::X(0) {
+ Foo::X(0) | Foo::Z(_) => 1, //~ ERROR: this match arm has an identical body to another arm
+ Foo::X(_) | Foo::Y(_) => 2,
+ _ => 0,
+ };
+
+ // Suggest moving `Foo::X(0)` down.
+ let _ = match Foo::X(0) {
+ Foo::Y(_) | Foo::Z(0) => 2,
+ Foo::Z(_) | Foo::X(0) => 1, //~ ERROR: this match arm has an identical body to another arm
+ _ => 0,
+ };
+
+ // Don't lint.
+ let _ = match 0 {
+ -2 => 1,
+ -5..=50 => 2,
+ -150..=88 => 1,
+ _ => 3,
+ };
+
+ struct Bar {
+ x: u32,
+ y: u32,
+ z: u32,
+ }
+
+ // Lint.
+ let _ = match None {
+ Some(Bar { y: 10, z: 0, .. }) => 2,
+ None => 50,
+ Some(Bar { y: 0, x: 5, .. }) | Some(Bar { x: 0, y: 5, .. }) => 1, //~ ERROR: this match arm has an identical body to another arm
+ _ => 200,
+ };
+
+ let _ = match 0 {
+ 0 => todo!(),
+ 1 => todo!(),
+ 2 => core::convert::identity::<u32>(todo!()),
+ 3 => core::convert::identity::<u32>(todo!()),
+ _ => 5,
+ };
+
+ let _ = match 0 {
+ 1 | 0 => cfg!(not_enable),
+ _ => false,
+ };
+}
diff --git a/src/tools/clippy/tests/ui/match_same_arms2.rs b/src/tools/clippy/tests/ui/match_same_arms2.rs
index 85ad096..8a4e3b3 100644
--- a/src/tools/clippy/tests/ui/match_same_arms2.rs
+++ b/src/tools/clippy/tests/ui/match_same_arms2.rs
@@ -2,9 +2,10 @@
#![allow(
clippy::disallowed_names,
clippy::diverging_sub_expression,
- clippy::uninlined_format_args
+ clippy::uninlined_format_args,
+ clippy::match_single_binding,
+ clippy::match_like_matches_macro
)]
-//@no-rustfix
fn bar<T>(_: T) {}
fn foo() -> bool {
unimplemented!()
diff --git a/src/tools/clippy/tests/ui/match_same_arms2.stderr b/src/tools/clippy/tests/ui/match_same_arms2.stderr
index f4c38c1..3d15176 100644
--- a/src/tools/clippy/tests/ui/match_same_arms2.stderr
+++ b/src/tools/clippy/tests/ui/match_same_arms2.stderr
@@ -1,18 +1,18 @@
error: this match arm has an identical body to the `_` wildcard arm
- --> tests/ui/match_same_arms2.rs:15:9
+ --> tests/ui/match_same_arms2.rs:16:9
|
LL | / 42 => {
LL | | foo();
LL | | let mut a = 42 + [23].len() as i32;
LL | | if true {
... |
-LL | | a
LL | | },
- | |_________^ help: try removing the arm
+LL | | _ => {
+ | |________^ help: try removing the arm
|
= help: or try changing either arm body
note: `_` wildcard arm here
- --> tests/ui/match_same_arms2.rs:24:9
+ --> tests/ui/match_same_arms2.rs:25:9
|
LL | / _ => {
LL | | foo();
@@ -26,203 +26,200 @@
= help: to override `-D warnings` add `#[allow(clippy::match_same_arms)]`
error: this match arm has an identical body to another arm
- --> tests/ui/match_same_arms2.rs:38:9
+ --> tests/ui/match_same_arms2.rs:39:9
|
LL | 51 => foo(),
- | --^^^^^^^^^
- | |
- | help: try merging the arm patterns: `51 | 42`
- |
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms2.rs:37:9
- |
-LL | 42 => foo(),
| ^^^^^^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | 51 | 42 => foo(),
+ | ~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - 42 => foo(),
+ |
error: this match arm has an identical body to another arm
- --> tests/ui/match_same_arms2.rs:44:9
+ --> tests/ui/match_same_arms2.rs:45:9
|
LL | None => 24,
- | ----^^^^^^
- | |
- | help: try merging the arm patterns: `None | Some(_)`
+ | ^^^^^^^^^^
|
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms2.rs:43:9
+ = help: try changing either arm body
+help: or try merging the arm patterns
|
-LL | Some(_) => 24,
- | ^^^^^^^^^^^^^
+LL | None | Some(_) => 24,
+ | ~~~~~~~~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - Some(_) => 24,
+ |
error: this match arm has an identical body to another arm
- --> tests/ui/match_same_arms2.rs:66:9
+ --> tests/ui/match_same_arms2.rs:67:9
|
LL | (None, Some(a)) => bar(a),
- | ---------------^^^^^^^^^^
- | |
- | help: try merging the arm patterns: `(None, Some(a)) | (Some(a), None)`
- |
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms2.rs:65:9
- |
-LL | (Some(a), None) => bar(a),
| ^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | (None, Some(a)) | (Some(a), None) => bar(a),
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - (Some(a), None) => bar(a),
+ |
error: this match arm has an identical body to another arm
- --> tests/ui/match_same_arms2.rs:80:9
+ --> tests/ui/match_same_arms2.rs:81:9
|
LL | (None, Some(a)) if a == 42 => a,
- | ---------------^^^^^^^^^^^^^^^^
- | |
- | help: try merging the arm patterns: `(None, Some(a)) | (Some(a), None)`
- |
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms2.rs:79:9
- |
-LL | (Some(a), None) if a == 42 => a,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | (None, Some(a)) | (Some(a), None) if a == 42 => a,
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - (Some(a), None) if a == 42 => a,
+ |
error: this match arm has an identical body to another arm
- --> tests/ui/match_same_arms2.rs:85:9
- |
-LL | (Some(a), ..) => bar(a),
- | -------------^^^^^^^^^^
- | |
- | help: try merging the arm patterns: `(Some(a), ..) | (.., Some(a))`
- |
- = help: or try changing either arm body
-note: other arm here
--> tests/ui/match_same_arms2.rs:86:9
|
-LL | (.., Some(a)) => bar(a),
+LL | (Some(a), ..) => bar(a),
| ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | (Some(a), ..) | (.., Some(a)) => bar(a),
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - (.., Some(a)) => bar(a),
+ |
error: this match arm has an identical body to another arm
- --> tests/ui/match_same_arms2.rs:119:9
- |
-LL | (Ok(x), Some(_)) => println!("ok {}", x),
- | ----------------^^^^^^^^^^^^^^^^^^^^^^^^
- | |
- | help: try merging the arm patterns: `(Ok(x), Some(_)) | (Ok(_), Some(x))`
- |
- = help: or try changing either arm body
-note: other arm here
--> tests/ui/match_same_arms2.rs:120:9
|
-LL | (Ok(_), Some(x)) => println!("ok {}", x),
+LL | (Ok(x), Some(_)) => println!("ok {}", x),
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | (Ok(x), Some(_)) | (Ok(_), Some(x)) => println!("ok {}", x),
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - (Ok(_), Some(x)) => println!("ok {}", x),
+ |
error: this match arm has an identical body to another arm
- --> tests/ui/match_same_arms2.rs:135:9
+ --> tests/ui/match_same_arms2.rs:136:9
|
LL | Ok(_) => println!("ok"),
- | -----^^^^^^^^^^^^^^^^^^
- | |
- | help: try merging the arm patterns: `Ok(_) | Ok(3)`
- |
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms2.rs:134:9
- |
-LL | Ok(3) => println!("ok"),
| ^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | Ok(_) | Ok(3) => println!("ok"),
+ | ~~~~~~~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - Ok(3) => println!("ok"),
+ |
error: this match arm has an identical body to another arm
- --> tests/ui/match_same_arms2.rs:162:9
+ --> tests/ui/match_same_arms2.rs:163:9
|
-LL | 1 => {
- | ^ help: try merging the arm patterns: `1 | 0`
- | _________|
- | |
+LL | / 1 => {
LL | | empty!(0);
LL | | },
| |_________^
|
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms2.rs:159:9
+ = help: try changing either arm body
+help: or try merging the arm patterns
|
-LL | / 0 => {
-LL | | empty!(0);
-LL | | },
- | |_________^
-
-error: match expression looks like `matches!` macro
- --> tests/ui/match_same_arms2.rs:181:16
+LL | 1 | 0 => {
+ | ~~~~~
+help: and remove this obsolete arm
|
-LL | let _ans = match x {
- | ________________^
-LL | | E::A => false,
-LL | | E::B => false,
-LL | | _ => true,
-LL | | };
- | |_____^ help: try: `!matches!(x, E::A | E::B)`
+LL - 0 => {
+LL - empty!(0);
+LL - },
|
- = note: `-D clippy::match-like-matches-macro` implied by `-D warnings`
- = help: to override `-D warnings` add `#[allow(clippy::match_like_matches_macro)]`
error: this match arm has an identical body to another arm
- --> tests/ui/match_same_arms2.rs:213:9
- |
-LL | Foo::X(0) => 1,
- | ---------^^^^^
- | |
- | help: try merging the arm patterns: `Foo::X(0) | Foo::Z(_)`
- |
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms2.rs:215:9
- |
-LL | Foo::Z(_) => 1,
- | ^^^^^^^^^^^^^^
-
-error: this match arm has an identical body to another arm
- --> tests/ui/match_same_arms2.rs:223:9
- |
-LL | Foo::Z(_) => 1,
- | ---------^^^^^
- | |
- | help: try merging the arm patterns: `Foo::Z(_) | Foo::X(0)`
- |
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms2.rs:221:9
+ --> tests/ui/match_same_arms2.rs:214:9
|
LL | Foo::X(0) => 1,
| ^^^^^^^^^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | Foo::X(0) | Foo::Z(_) => 1,
+ | ~~~~~~~~~~~~~~~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - Foo::Z(_) => 1,
+ |
error: this match arm has an identical body to another arm
- --> tests/ui/match_same_arms2.rs:246:9
+ --> tests/ui/match_same_arms2.rs:224:9
+ |
+LL | Foo::Z(_) => 1,
+ | ^^^^^^^^^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | Foo::Z(_) | Foo::X(0) => 1,
+ | ~~~~~~~~~~~~~~~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - Foo::X(0) => 1,
+ |
+
+error: this match arm has an identical body to another arm
+ --> tests/ui/match_same_arms2.rs:247:9
|
LL | Some(Bar { y: 0, x: 5, .. }) => 1,
- | ----------------------------^^^^^
- | |
- | help: try merging the arm patterns: `Some(Bar { y: 0, x: 5, .. }) | Some(Bar { x: 0, y: 5, .. })`
- |
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms2.rs:243:9
- |
-LL | Some(Bar { x: 0, y: 5, .. }) => 1,
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | Some(Bar { y: 0, x: 5, .. }) | Some(Bar { x: 0, y: 5, .. }) => 1,
+ | ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+help: and remove this obsolete arm
+ |
+LL - Some(Bar { x: 0, y: 5, .. }) => 1,
+ |
error: this match arm has an identical body to another arm
- --> tests/ui/match_same_arms2.rs:260:9
+ --> tests/ui/match_same_arms2.rs:261:9
|
LL | 1 => cfg!(not_enable),
- | -^^^^^^^^^^^^^^^^^^^^
- | |
- | help: try merging the arm patterns: `1 | 0`
- |
- = help: or try changing either arm body
-note: other arm here
- --> tests/ui/match_same_arms2.rs:259:9
- |
-LL | 0 => cfg!(not_enable),
| ^^^^^^^^^^^^^^^^^^^^^
+ |
+ = help: try changing either arm body
+help: or try merging the arm patterns
+ |
+LL | 1 | 0 => cfg!(not_enable),
+ | ~~~~~
+help: and remove this obsolete arm
+ |
+LL - 0 => cfg!(not_enable),
+ |
-error: aborting due to 14 previous errors
+error: aborting due to 13 previous errors
diff --git a/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.fixed b/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.fixed
new file mode 100644
index 0000000..804c0a8
--- /dev/null
+++ b/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.fixed
@@ -0,0 +1,61 @@
+#![feature(non_exhaustive_omitted_patterns_lint)]
+#![warn(clippy::match_same_arms)]
+#![no_main]
+use std::sync::atomic::Ordering; // #[non_exhaustive] enum
+
+fn repeat() -> ! {
+ panic!()
+}
+
+pub fn f(x: Ordering) {
+ #[deny(non_exhaustive_omitted_patterns)]
+ match x {
+ Ordering::Relaxed => println!("relaxed"),
+ Ordering::Release => println!("release"),
+ Ordering::Acquire => println!("acquire"),
+ Ordering::AcqRel | Ordering::SeqCst => repeat(),
+ _ => repeat(),
+ }
+}
+
+mod f {
+ #![deny(non_exhaustive_omitted_patterns)]
+
+ use super::*;
+
+ pub fn f(x: Ordering) {
+ match x {
+ Ordering::Relaxed => println!("relaxed"),
+ Ordering::Release => println!("release"),
+ Ordering::Acquire => println!("acquire"),
+ Ordering::AcqRel | Ordering::SeqCst => repeat(),
+ _ => repeat(),
+ }
+ }
+}
+
+// Below should still lint
+
+pub fn g(x: Ordering) {
+ match x {
+ Ordering::Relaxed => println!("relaxed"),
+ Ordering::Release => println!("release"),
+ Ordering::Acquire => println!("acquire"),
+ //~^ ERROR: this match arm has an identical body to the `_` wildcard arm
+ _ => repeat(),
+ }
+}
+
+mod g {
+ use super::*;
+
+ pub fn g(x: Ordering) {
+ match x {
+ Ordering::Relaxed => println!("relaxed"),
+ Ordering::Release => println!("release"),
+ Ordering::Acquire => println!("acquire"),
+ //~^ ERROR: this match arm has an identical body to the `_` wildcard arm
+ _ => repeat(),
+ }
+ }
+}
diff --git a/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.rs b/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.rs
index 5c277f9..e5066393 100644
--- a/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.rs
+++ b/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.rs
@@ -1,7 +1,6 @@
#![feature(non_exhaustive_omitted_patterns_lint)]
#![warn(clippy::match_same_arms)]
#![no_main]
-//@no-rustfix
use std::sync::atomic::Ordering; // #[non_exhaustive] enum
fn repeat() -> ! {
diff --git a/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.stderr b/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.stderr
index cf2a753..aa7f8c9 100644
--- a/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.stderr
+++ b/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.stderr
@@ -1,12 +1,13 @@
error: this match arm has an identical body to the `_` wildcard arm
- --> tests/ui/match_same_arms_non_exhaustive.rs:45:9
+ --> tests/ui/match_same_arms_non_exhaustive.rs:44:9
|
-LL | Ordering::AcqRel | Ordering::SeqCst => repeat(),
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the arm
+LL | / Ordering::AcqRel | Ordering::SeqCst => repeat(),
+LL | |
+ | |________^ help: try removing the arm
|
= help: or try changing either arm body
note: `_` wildcard arm here
- --> tests/ui/match_same_arms_non_exhaustive.rs:47:9
+ --> tests/ui/match_same_arms_non_exhaustive.rs:46:9
|
LL | _ => repeat(),
| ^^^^^^^^^^^^^
@@ -14,14 +15,15 @@
= help: to override `-D warnings` add `#[allow(clippy::match_same_arms)]`
error: this match arm has an identical body to the `_` wildcard arm
- --> tests/ui/match_same_arms_non_exhaustive.rs:59:13
+ --> tests/ui/match_same_arms_non_exhaustive.rs:58:13
|
-LL | Ordering::AcqRel | Ordering::SeqCst => repeat(),
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try removing the arm
+LL | / Ordering::AcqRel | Ordering::SeqCst => repeat(),
+LL | |
+ | |____________^ help: try removing the arm
|
= help: or try changing either arm body
note: `_` wildcard arm here
- --> tests/ui/match_same_arms_non_exhaustive.rs:61:13
+ --> tests/ui/match_same_arms_non_exhaustive.rs:60:13
|
LL | _ => repeat(),
| ^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/missing_const_for_fn/cant_be_const.rs b/src/tools/clippy/tests/ui/missing_const_for_fn/cant_be_const.rs
index d026e00..2750e0c 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_fn/cant_be_const.rs
+++ b/src/tools/clippy/tests/ui/missing_const_for_fn/cant_be_const.rs
@@ -161,7 +161,23 @@
f: u32,
}
-// Do not lint because accessing union fields from const functions is unstable
+// Do not lint because accessing union fields from const functions is unstable in 1.55
+#[clippy::msrv = "1.55"]
fn h(u: U) -> u32 {
unsafe { u.f }
}
+
+mod msrv {
+ struct Foo(*const u8, *mut u8);
+
+ impl Foo {
+ #[clippy::msrv = "1.57"]
+ fn deref_ptr_cannot_be_const(self) -> usize {
+ unsafe { *self.0 as usize }
+ }
+ #[clippy::msrv = "1.58"]
+ fn deref_mut_ptr_cannot_be_const(self) -> usize {
+ unsafe { *self.1 as usize }
+ }
+ }
+}
diff --git a/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.rs b/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.rs
index 12a8320..06dbbeb 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.rs
+++ b/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.rs
@@ -113,3 +113,31 @@
// Lint this, since it can be dropped in const contexts
// FIXME(effects)
fn d(this: D) {}
+
+mod msrv {
+ struct Foo(*const u8, &'static u8);
+
+ impl Foo {
+ #[clippy::msrv = "1.58"]
+ fn deref_ptr_can_be_const(self) -> usize {
+ //~^ ERROR: this could be a `const fn`
+ unsafe { *self.0 as usize }
+ }
+
+ fn deref_copied_val(self) -> usize {
+ //~^ ERROR: this could be a `const fn`
+ *self.1 as usize
+ }
+ }
+
+ union Bar {
+ val: u8,
+ }
+
+ #[clippy::msrv = "1.56"]
+ fn union_access_can_be_const() {
+ //~^ ERROR: this could be a `const fn`
+ let bar = Bar { val: 1 };
+ let _ = unsafe { bar.val };
+ }
+}
diff --git a/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.stderr b/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.stderr
index 082459f..b2cade3 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.stderr
+++ b/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.stderr
@@ -102,5 +102,33 @@
LL | | }
| |_^
-error: aborting due to 11 previous errors
+error: this could be a `const fn`
+ --> tests/ui/missing_const_for_fn/could_be_const.rs:122:9
+ |
+LL | / fn deref_ptr_can_be_const(self) -> usize {
+LL | |
+LL | | unsafe { *self.0 as usize }
+LL | | }
+ | |_________^
+
+error: this could be a `const fn`
+ --> tests/ui/missing_const_for_fn/could_be_const.rs:127:9
+ |
+LL | / fn deref_copied_val(self) -> usize {
+LL | |
+LL | | *self.1 as usize
+LL | | }
+ | |_________^
+
+error: this could be a `const fn`
+ --> tests/ui/missing_const_for_fn/could_be_const.rs:138:5
+ |
+LL | / fn union_access_can_be_const() {
+LL | |
+LL | | let bar = Bar { val: 1 };
+LL | | let _ = unsafe { bar.val };
+LL | | }
+ | |_____^
+
+error: aborting due to 14 previous errors
diff --git a/src/tools/clippy/tests/ui/missing_panics_doc.rs b/src/tools/clippy/tests/ui/missing_panics_doc.rs
index 0e1533f..b0fa8e9 100644
--- a/src/tools/clippy/tests/ui/missing_panics_doc.rs
+++ b/src/tools/clippy/tests/ui/missing_panics_doc.rs
@@ -191,3 +191,11 @@
// Not here.
some_macro_that_panics!()
}
+
+pub fn issue_12760<const N: usize>() {
+ const {
+ if N == 0 {
+ panic!();
+ }
+ }
+}
diff --git a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.fixed b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.fixed
index bd7a9a0..5478372 100644
--- a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.fixed
+++ b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.fixed
@@ -141,8 +141,8 @@
let f = |arg| {
let loc = "loc".to_owned();
let _ = std::fs::write("x", &env); // Don't lint. In environment
- let _ = std::fs::write("x", arg);
- let _ = std::fs::write("x", loc);
+ let _ = std::fs::write("x", &arg);
+ let _ = std::fs::write("x", &loc);
};
let _ = std::fs::write("x", &env); // Don't lint. Borrowed by `f`
f(arg);
@@ -158,13 +158,13 @@
fn f(_: impl Debug) {}
let x = X;
- f(&x); // Don't lint. Has significant drop
+ f(&x); // Don't lint, not copy, passed by a reference to a variable
}
{
fn f(_: impl AsRef<str>) {}
let x = String::new();
- f(x);
+ f(&x);
}
{
fn f(_: impl AsRef<str>) {}
@@ -299,4 +299,38 @@
check_str(&owner.0); // Don't lint. `owner` can't be partially moved because it impl Drop
}
}
+ {
+ #[derive(Debug)]
+ struct X(Vec<u8>);
+
+ fn f(_: impl Debug) {}
+
+ let x = X(vec![]);
+ f(&x); // Don't lint, makes x unavailable later
+ }
+ {
+ #[derive(Debug)]
+ struct X;
+
+ impl Drop for X {
+ fn drop(&mut self) {}
+ }
+
+ fn f(_: impl Debug) {}
+
+ #[derive(Debug)]
+ struct Y(X);
+
+ let y = Y(X);
+ f(&y); // Don't lint. Not copy, passed by a reference to value
+ }
+ {
+ fn f(_: impl AsRef<str>) {}
+ let x = String::new();
+ f(&x); // Don't lint, not a copy, makes it unavailable later
+ f(String::new()); // Lint, makes no difference
+ let y = "".to_owned();
+ f(&y); // Don't lint
+ f("".to_owned()); // Lint
+ }
}
diff --git a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.rs b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.rs
index 5cfd4ce..2643815 100644
--- a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.rs
+++ b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.rs
@@ -158,7 +158,7 @@
fn f(_: impl Debug) {}
let x = X;
- f(&x); // Don't lint. Has significant drop
+ f(&x); // Don't lint, not copy, passed by a reference to a variable
}
{
fn f(_: impl AsRef<str>) {}
@@ -299,4 +299,38 @@
check_str(&owner.0); // Don't lint. `owner` can't be partially moved because it impl Drop
}
}
+ {
+ #[derive(Debug)]
+ struct X(Vec<u8>);
+
+ fn f(_: impl Debug) {}
+
+ let x = X(vec![]);
+ f(&x); // Don't lint, makes x unavailable later
+ }
+ {
+ #[derive(Debug)]
+ struct X;
+
+ impl Drop for X {
+ fn drop(&mut self) {}
+ }
+
+ fn f(_: impl Debug) {}
+
+ #[derive(Debug)]
+ struct Y(X);
+
+ let y = Y(X);
+ f(&y); // Don't lint. Not copy, passed by a reference to value
+ }
+ {
+ fn f(_: impl AsRef<str>) {}
+ let x = String::new();
+ f(&x); // Don't lint, not a copy, makes it unavailable later
+ f(&String::new()); // Lint, makes no difference
+ let y = "".to_owned();
+ f(&y); // Don't lint
+ f(&"".to_owned()); // Lint
+ }
}
diff --git a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.stderr b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.stderr
index 83c076f..fba0755 100644
--- a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.stderr
+++ b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.stderr
@@ -50,28 +50,22 @@
| ^^^^^^^^^^^^^ help: change this to: `["-a", "-l"]`
error: the borrowed expression implements the required traits
- --> tests/ui/needless_borrows_for_generic_args.rs:144:41
- |
-LL | let _ = std::fs::write("x", &arg);
- | ^^^^ help: change this to: `arg`
-
-error: the borrowed expression implements the required traits
- --> tests/ui/needless_borrows_for_generic_args.rs:145:41
- |
-LL | let _ = std::fs::write("x", &loc);
- | ^^^^ help: change this to: `loc`
-
-error: the borrowed expression implements the required traits
- --> tests/ui/needless_borrows_for_generic_args.rs:167:11
- |
-LL | f(&x);
- | ^^ help: change this to: `x`
-
-error: the borrowed expression implements the required traits
--> tests/ui/needless_borrows_for_generic_args.rs:247:13
|
LL | foo(&a);
| ^^ help: change this to: `a`
-error: aborting due to 12 previous errors
+error: the borrowed expression implements the required traits
+ --> tests/ui/needless_borrows_for_generic_args.rs:331:11
+ |
+LL | f(&String::new()); // Lint, makes no difference
+ | ^^^^^^^^^^^^^^ help: change this to: `String::new()`
+
+error: the borrowed expression implements the required traits
+ --> tests/ui/needless_borrows_for_generic_args.rs:334:11
+ |
+LL | f(&"".to_owned()); // Lint
+ | ^^^^^^^^^^^^^^ help: change this to: `"".to_owned()`
+
+error: aborting due to 11 previous errors
diff --git a/src/tools/clippy/tests/ui/needless_late_init.stderr b/src/tools/clippy/tests/ui/needless_late_init.stderr
index 1695784..ce64861 100644
--- a/src/tools/clippy/tests/ui/needless_late_init.stderr
+++ b/src/tools/clippy/tests/ui/needless_late_init.stderr
@@ -8,10 +8,11 @@
|
= note: `-D clippy::needless-late-init` implied by `-D warnings`
= help: to override `-D warnings` add `#[allow(clippy::needless_late_init)]`
-help: declare `a` here
+help: move the declaration `a` here
|
-LL | let a = "zero";
- | ~~~~~
+LL ~
+LL ~ let a = "zero";
+ |
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:30:5
@@ -22,10 +23,12 @@
LL | b = 1;
| ^^^^^ initialised here
|
-help: declare `b` here
+help: move the declaration `b` here
|
-LL | let b = 1;
- | ~~~~~
+LL ~
+LL | let c;
+LL ~ let b = 1;
+ |
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:31:5
@@ -36,10 +39,12 @@
LL | c = 2;
| ^^^^^ initialised here
|
-help: declare `c` here
+help: move the declaration `c` here
|
-LL | let c = 2;
- | ~~~~~
+LL ~
+LL | b = 1;
+LL ~ let c = 2;
+ |
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:35:5
@@ -49,10 +54,11 @@
LL | d = 1;
| ^^^^^ initialised here
|
-help: declare `d` here
+help: move the declaration `d` here
|
-LL | let d: usize = 1;
- | ~~~~~~~~~~~~
+LL ~
+LL ~ let d: usize = 1;
+ |
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:38:5
@@ -62,10 +68,11 @@
LL | e = format!("{}", d);
| ^^^^^^^^^^^^^^^^^^^^ initialised here
|
-help: declare `e` here
+help: move the declaration `e` here
|
-LL | let e = format!("{}", d);
- | ~~~~~
+LL ~
+LL ~ let e = format!("{}", d);
+ |
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:43:5
@@ -73,20 +80,17 @@
LL | let a;
| ^^^^^^
|
-help: declare `a` here
+help: move the declaration `a` here and remove the assignments from the `match` arms
|
-LL | let a = match n {
- | +++++++
-help: remove the assignments from the `match` arms
- |
+LL ~
+LL | let n = 1;
+LL ~ let a = match n {
LL ~ 1 => "one",
LL | _ => {
LL ~ "two"
+LL | },
+LL ~ };
|
-help: add a semicolon after the `match` expression
- |
-LL | };
- | +
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:52:5
@@ -94,20 +98,15 @@
LL | let b;
| ^^^^^^
|
-help: declare `b` here
+help: move the declaration `b` here and remove the assignments from the branches
|
-LL | let b = if n == 3 {
- | +++++++
-help: remove the assignments from the branches
- |
+LL ~
+LL ~ let b = if n == 3 {
LL ~ "four"
LL | } else {
LL ~ "five"
+LL ~ };
|
-help: add a semicolon after the `if` expression
- |
-LL | };
- | +
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:59:5
@@ -115,20 +114,16 @@
LL | let d;
| ^^^^^^
|
-help: declare `d` here
+help: move the declaration `d` here and remove the assignments from the branches
|
-LL | let d = if true {
- | +++++++
-help: remove the assignments from the branches
- |
+LL ~
+LL ~ let d = if true {
+LL | let temp = 5;
LL ~ temp
LL | } else {
LL ~ 15
+LL ~ };
|
-help: add a semicolon after the `if` expression
- |
-LL | };
- | +
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:67:5
@@ -136,20 +131,15 @@
LL | let e;
| ^^^^^^
|
-help: declare `e` here
+help: move the declaration `e` here and remove the assignments from the branches
|
-LL | let e = if true {
- | +++++++
-help: remove the assignments from the branches
- |
+LL ~
+LL ~ let e = if true {
LL ~ format!("{} {}", a, b)
LL | } else {
LL ~ format!("{}", n)
+LL ~ };
|
-help: add a semicolon after the `if` expression
- |
-LL | };
- | +
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:74:5
@@ -157,14 +147,11 @@
LL | let f;
| ^^^^^^
|
-help: declare `f` here
+help: move the declaration `f` here and remove the assignments from the `match` arms
|
-LL | let f = match 1 {
- | +++++++
-help: remove the assignments from the `match` arms
- |
-LL - 1 => f = "three",
-LL + 1 => "three",
+LL ~
+LL ~ let f = match 1 {
+LL ~ 1 => "three",
|
error: unneeded late initialization
@@ -173,19 +160,15 @@
LL | let g: usize;
| ^^^^^^^^^^^^^
|
-help: declare `g` here
+help: move the declaration `g` here and remove the assignments from the branches
|
-LL | let g: usize = if true {
- | ++++++++++++++
-help: remove the assignments from the branches
+LL ~
+LL ~ let g: usize = if true {
+LL ~ 5
+LL | } else {
+LL | panic!();
+LL ~ };
|
-LL - g = 5;
-LL + 5
- |
-help: add a semicolon after the `if` expression
- |
-LL | };
- | +
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:88:5
@@ -196,10 +179,12 @@
LL | x = 1;
| ^^^^^ initialised here
|
-help: declare `x` here
+help: move the declaration `x` here
|
-LL | let x = 1;
- | ~~~~~
+LL ~
+LL | let y = SignificantDrop;
+LL ~ let x = 1;
+ |
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:92:5
@@ -210,10 +195,12 @@
LL | x = SignificantDrop;
| ^^^^^^^^^^^^^^^^^^^ initialised here
|
-help: declare `x` here
+help: move the declaration `x` here
|
-LL | let x = SignificantDrop;
- | ~~~~~
+LL ~
+LL | let y = 1;
+LL ~ let x = SignificantDrop;
+ |
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:96:5
@@ -224,10 +211,14 @@
LL | x = SignificantDrop;
| ^^^^^^^^^^^^^^^^^^^ initialised here
|
-help: declare `x` here
+help: move the declaration `x` here
|
-LL | let x = SignificantDrop;
- | ~~~~~
+LL ~
+LL | // types that should be considered insignificant
+ ...
+LL | let y = Box::new(4);
+LL ~ let x = SignificantDrop;
+ |
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:115:5
@@ -235,20 +226,17 @@
LL | let a;
| ^^^^^^
|
-help: declare `a` here
+help: move the declaration `a` here and remove the assignments from the `match` arms
|
-LL | let a = match n {
- | +++++++
-help: remove the assignments from the `match` arms
- |
+LL ~
+LL | let n = 1;
+LL ~ let a = match n {
LL ~ 1 => f().await,
LL | _ => {
LL ~ "two"
+LL | },
+LL ~ };
|
-help: add a semicolon after the `match` expression
- |
-LL | };
- | +
error: unneeded late initialization
--> tests/ui/needless_late_init.rs:132:5
@@ -256,20 +244,17 @@
LL | let a;
| ^^^^^^
|
-help: declare `a` here
+help: move the declaration `a` here and remove the assignments from the `match` arms
|
-LL | let a = match n {
- | +++++++
-help: remove the assignments from the `match` arms
- |
+LL ~
+LL | let n = 1;
+LL ~ let a = match n {
LL ~ 1 => f(),
LL | _ => {
LL ~ "two"
+LL | },
+LL ~ };
|
-help: add a semicolon after the `match` expression
- |
-LL | };
- | +
error: aborting due to 16 previous errors
diff --git a/src/tools/clippy/tests/ui/no_effect.rs b/src/tools/clippy/tests/ui/no_effect.rs
index dabeda7..0ea911c 100644
--- a/src/tools/clippy/tests/ui/no_effect.rs
+++ b/src/tools/clippy/tests/ui/no_effect.rs
@@ -1,6 +1,5 @@
#![feature(fn_traits, unboxed_closures)]
#![warn(clippy::no_effect_underscore_binding)]
-#![allow(dead_code, path_statements)]
#![allow(
clippy::deref_addrof,
clippy::redundant_field_names,
@@ -33,7 +32,6 @@
}
}
-struct Unit;
struct Tuple(i32);
struct Struct {
field: i32,
@@ -42,10 +40,6 @@
Tuple(i32),
Struct { field: i32 },
}
-struct DropUnit;
-impl Drop for DropUnit {
- fn drop(&mut self) {}
-}
struct DropStruct {
field: i32,
}
@@ -117,15 +111,9 @@
fn main() {
let s = get_struct();
- let s2 = get_struct();
0;
//~^ ERROR: statement with no effect
- //~| NOTE: `-D clippy::no-effect` implied by `-D warnings`
- s2;
- //~^ ERROR: statement with no effect
- Unit;
- //~^ ERROR: statement with no effect
Tuple(0);
//~^ ERROR: statement with no effect
Struct { field: 0 };
@@ -192,7 +180,6 @@
unsafe { unsafe_fn() };
let _used = get_struct();
let _x = vec![1];
- DropUnit;
DropStruct { field: 0 };
DropTuple(0);
DropEnum::Tuple(0);
diff --git a/src/tools/clippy/tests/ui/no_effect.stderr b/src/tools/clippy/tests/ui/no_effect.stderr
index c7c8eec..48ec997 100644
--- a/src/tools/clippy/tests/ui/no_effect.stderr
+++ b/src/tools/clippy/tests/ui/no_effect.stderr
@@ -1,5 +1,5 @@
error: statement with no effect
- --> tests/ui/no_effect.rs:122:5
+ --> tests/ui/no_effect.rs:115:5
|
LL | 0;
| ^^
@@ -8,151 +8,139 @@
= help: to override `-D warnings` add `#[allow(clippy::no_effect)]`
error: statement with no effect
- --> tests/ui/no_effect.rs:125:5
- |
-LL | s2;
- | ^^^
-
-error: statement with no effect
- --> tests/ui/no_effect.rs:127:5
- |
-LL | Unit;
- | ^^^^^
-
-error: statement with no effect
- --> tests/ui/no_effect.rs:129:5
+ --> tests/ui/no_effect.rs:117:5
|
LL | Tuple(0);
| ^^^^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:131:5
+ --> tests/ui/no_effect.rs:119:5
|
LL | Struct { field: 0 };
| ^^^^^^^^^^^^^^^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:133:5
+ --> tests/ui/no_effect.rs:121:5
|
LL | Struct { ..s };
| ^^^^^^^^^^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:135:5
+ --> tests/ui/no_effect.rs:123:5
|
LL | Union { a: 0 };
| ^^^^^^^^^^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:137:5
+ --> tests/ui/no_effect.rs:125:5
|
LL | Enum::Tuple(0);
| ^^^^^^^^^^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:139:5
+ --> tests/ui/no_effect.rs:127:5
|
LL | Enum::Struct { field: 0 };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:141:5
+ --> tests/ui/no_effect.rs:129:5
|
LL | 5 + 6;
| ^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:143:5
+ --> tests/ui/no_effect.rs:131:5
|
LL | *&42;
| ^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:145:5
+ --> tests/ui/no_effect.rs:133:5
|
LL | &6;
| ^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:147:5
+ --> tests/ui/no_effect.rs:135:5
|
LL | (5, 6, 7);
| ^^^^^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:149:5
+ --> tests/ui/no_effect.rs:137:5
|
LL | ..;
| ^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:151:5
+ --> tests/ui/no_effect.rs:139:5
|
LL | 5..;
| ^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:153:5
+ --> tests/ui/no_effect.rs:141:5
|
LL | ..5;
| ^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:155:5
+ --> tests/ui/no_effect.rs:143:5
|
LL | 5..6;
| ^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:157:5
+ --> tests/ui/no_effect.rs:145:5
|
LL | 5..=6;
| ^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:159:5
+ --> tests/ui/no_effect.rs:147:5
|
LL | [42, 55];
| ^^^^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:161:5
+ --> tests/ui/no_effect.rs:149:5
|
LL | [42, 55][1];
| ^^^^^^^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:163:5
+ --> tests/ui/no_effect.rs:151:5
|
LL | (42, 55).1;
| ^^^^^^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:165:5
+ --> tests/ui/no_effect.rs:153:5
|
LL | [42; 55];
| ^^^^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:167:5
+ --> tests/ui/no_effect.rs:155:5
|
LL | [42; 55][13];
| ^^^^^^^^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:170:5
+ --> tests/ui/no_effect.rs:158:5
|
LL | || x += 5;
| ^^^^^^^^^^
error: statement with no effect
- --> tests/ui/no_effect.rs:173:5
+ --> tests/ui/no_effect.rs:161:5
|
LL | FooString { s: s };
| ^^^^^^^^^^^^^^^^^^^
error: binding to `_` prefixed variable with no side-effect
- --> tests/ui/no_effect.rs:175:9
+ --> tests/ui/no_effect.rs:163:9
|
LL | let _unused = 1;
| ^^^^^^^
@@ -161,22 +149,22 @@
= help: to override `-D warnings` add `#[allow(clippy::no_effect_underscore_binding)]`
error: binding to `_` prefixed variable with no side-effect
- --> tests/ui/no_effect.rs:178:9
+ --> tests/ui/no_effect.rs:166:9
|
LL | let _penguin = || println!("Some helpful closure");
| ^^^^^^^^
error: binding to `_` prefixed variable with no side-effect
- --> tests/ui/no_effect.rs:180:9
+ --> tests/ui/no_effect.rs:168:9
|
LL | let _duck = Struct { field: 0 };
| ^^^^^
error: binding to `_` prefixed variable with no side-effect
- --> tests/ui/no_effect.rs:182:9
+ --> tests/ui/no_effect.rs:170:9
|
LL | let _cat = [2, 4, 6, 8][2];
| ^^^^
-error: aborting due to 29 previous errors
+error: aborting due to 27 previous errors
diff --git a/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.rs b/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.rs
index 0305d89..7fc89bb 100644
--- a/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.rs
+++ b/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.rs
@@ -675,4 +675,60 @@
}
}
+// https://github.com/rust-lang/rust-clippy/issues/9072
+fn should_not_trigger_lint_if_place_expr_has_significant_drop() {
+ let x = Mutex::new(vec![1, 2, 3]);
+ let x_guard = x.lock().unwrap();
+
+ match x_guard[0] {
+ 1 => println!("1!"),
+ x => println!("{x}"),
+ }
+
+ match x_guard.len() {
+ 1 => println!("1!"),
+ x => println!("{x}"),
+ }
+}
+
+struct Guard<'a, T>(MutexGuard<'a, T>);
+
+struct Ref<'a, T>(&'a T);
+
+impl<'a, T> Guard<'a, T> {
+ fn guard(&self) -> &MutexGuard<T> {
+ &self.0
+ }
+
+ fn guard_ref(&self) -> Ref<MutexGuard<T>> {
+ Ref(&self.0)
+ }
+
+ fn take(self) -> Box<MutexGuard<'a, T>> {
+ Box::new(self.0)
+ }
+}
+
+fn should_not_trigger_for_significant_drop_ref() {
+ let mutex = Mutex::new(vec![1, 2]);
+ let guard = Guard(mutex.lock().unwrap());
+
+ match guard.guard().len() {
+ 0 => println!("empty"),
+ _ => println!("not empty"),
+ }
+
+ match guard.guard_ref().0.len() {
+ 0 => println!("empty"),
+ _ => println!("not empty"),
+ }
+
+ match guard.take().len() {
+ //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
+ //~| NOTE: this might lead to deadlocks or other unexpected behavior
+ 0 => println!("empty"),
+ _ => println!("not empty"),
+ };
+}
+
fn main() {}
diff --git a/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.stderr b/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.stderr
index 7d5b1ac..811bb06 100644
--- a/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.stderr
+++ b/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.stderr
@@ -28,6 +28,9 @@
LL | println!("{}", s.lock_m().get_the_value());
| ---------- another value with significant `Drop` created here
...
+LL | println!("{}", s.lock_m().get_the_value());
+ | ---------- another value with significant `Drop` created here
+...
LL | }
| - temporary lives until here
|
@@ -47,6 +50,9 @@
LL | println!("{}", s.lock_m().get_the_value());
| ---------- another value with significant `Drop` created here
...
+LL | println!("{}", s.lock_m().get_the_value());
+ | ---------- another value with significant `Drop` created here
+...
LL | }
| - temporary lives until here
|
@@ -360,7 +366,7 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^
...
LL | _ => println!("Value is {}", s.lock().deref()),
- | ---------------- another value with significant `Drop` created here
+ | -------- another value with significant `Drop` created here
LL | };
| - temporary lives until here
|
@@ -378,7 +384,7 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^
...
LL | matcher => println!("Value is {}", s.lock().deref()),
- | ---------------- another value with significant `Drop` created here
+ | -------- another value with significant `Drop` created here
LL | _ => println!("Value was not a match"),
LL | };
| - temporary lives until here
@@ -499,5 +505,21 @@
LL ~ match value {
|
-error: aborting due to 26 previous errors
+error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
+ --> tests/ui/significant_drop_in_scrutinee.rs:726:11
+ |
+LL | match guard.take().len() {
+ | ^^^^^^^^^^^^^^^^^^
+...
+LL | };
+ | - temporary lives until here
+ |
+ = note: this might lead to deadlocks or other unexpected behavior
+help: try moving the temporary above the match
+ |
+LL ~ let value = guard.take().len();
+LL ~ match value {
+ |
+
+error: aborting due to 27 previous errors
diff --git a/src/tools/clippy/tests/ui/unnecessary_iter_cloned.fixed b/src/tools/clippy/tests/ui/unnecessary_iter_cloned.fixed
index ad0e5fa..2c582c9 100644
--- a/src/tools/clippy/tests/ui/unnecessary_iter_cloned.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_iter_cloned.fixed
@@ -21,6 +21,8 @@
let _ = check_files_ref_mut(&[(FileType::Account, path)]);
let _ = check_files_self_and_arg(&[(FileType::Account, path)]);
let _ = check_files_mut_path_buf(&[(FileType::Account, std::path::PathBuf::new())]);
+
+ check_mut_iteratee_and_modify_inner_variable();
}
// `check_files` and its variants are based on:
@@ -138,3 +140,33 @@
fn get_file_path(_file_type: &FileType) -> Result<std::path::PathBuf, std::io::Error> {
Ok(std::path::PathBuf::new())
}
+
+// Issue 12098
+// https://github.com/rust-lang/rust-clippy/issues/12098
+// no message emits
+fn check_mut_iteratee_and_modify_inner_variable() {
+ struct Test {
+ list: Vec<String>,
+ mut_this: bool,
+ }
+
+ impl Test {
+ fn list(&self) -> &[String] {
+ &self.list
+ }
+ }
+
+ let mut test = Test {
+ list: vec![String::from("foo"), String::from("bar")],
+ mut_this: false,
+ };
+
+ for _item in test.list().to_vec() {
+ println!("{}", _item);
+
+ test.mut_this = true;
+ {
+ test.mut_this = true;
+ }
+ }
+}
diff --git a/src/tools/clippy/tests/ui/unnecessary_iter_cloned.rs b/src/tools/clippy/tests/ui/unnecessary_iter_cloned.rs
index d3d59c4..a28ccd1 100644
--- a/src/tools/clippy/tests/ui/unnecessary_iter_cloned.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_iter_cloned.rs
@@ -21,6 +21,8 @@
let _ = check_files_ref_mut(&[(FileType::Account, path)]);
let _ = check_files_self_and_arg(&[(FileType::Account, path)]);
let _ = check_files_mut_path_buf(&[(FileType::Account, std::path::PathBuf::new())]);
+
+ check_mut_iteratee_and_modify_inner_variable();
}
// `check_files` and its variants are based on:
@@ -138,3 +140,33 @@
fn get_file_path(_file_type: &FileType) -> Result<std::path::PathBuf, std::io::Error> {
Ok(std::path::PathBuf::new())
}
+
+// Issue 12098
+// https://github.com/rust-lang/rust-clippy/issues/12098
+// no message emits
+fn check_mut_iteratee_and_modify_inner_variable() {
+ struct Test {
+ list: Vec<String>,
+ mut_this: bool,
+ }
+
+ impl Test {
+ fn list(&self) -> &[String] {
+ &self.list
+ }
+ }
+
+ let mut test = Test {
+ list: vec![String::from("foo"), String::from("bar")],
+ mut_this: false,
+ };
+
+ for _item in test.list().to_vec() {
+ println!("{}", _item);
+
+ test.mut_this = true;
+ {
+ test.mut_this = true;
+ }
+ }
+}
diff --git a/src/tools/clippy/tests/ui/unnecessary_iter_cloned.stderr b/src/tools/clippy/tests/ui/unnecessary_iter_cloned.stderr
index 9d3591e..fb98cfd 100644
--- a/src/tools/clippy/tests/ui/unnecessary_iter_cloned.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_iter_cloned.stderr
@@ -1,5 +1,5 @@
error: unnecessary use of `copied`
- --> tests/ui/unnecessary_iter_cloned.rs:29:22
+ --> tests/ui/unnecessary_iter_cloned.rs:31:22
|
LL | for (t, path) in files.iter().copied() {
| ^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@
|
error: unnecessary use of `copied`
- --> tests/ui/unnecessary_iter_cloned.rs:44:22
+ --> tests/ui/unnecessary_iter_cloned.rs:46:22
|
LL | for (t, path) in files.iter().copied() {
| ^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/useless_attribute.fixed b/src/tools/clippy/tests/ui/useless_attribute.fixed
index 8175908..231fc0a 100644
--- a/src/tools/clippy/tests/ui/useless_attribute.fixed
+++ b/src/tools/clippy/tests/ui/useless_attribute.fixed
@@ -86,8 +86,51 @@
#[rustfmt::skip]
#[allow(unused_import_braces)]
+#[allow(unused_braces)]
use module::{Struct};
fn main() {
test_indented_attr();
}
+
+// Regression test for https://github.com/rust-lang/rust-clippy/issues/4467
+#[allow(dead_code)]
+use std::collections as puppy_doggy;
+
+// Regression test for https://github.com/rust-lang/rust-clippy/issues/11595
+pub mod hidden_glob_reexports {
+ #![allow(unreachable_pub)]
+
+ mod my_prelude {
+ pub struct MyCoolTypeInternal;
+ pub use MyCoolTypeInternal as MyCoolType;
+ }
+
+ mod my_uncool_type {
+ pub(crate) struct MyUncoolType;
+ }
+
+ // This exports `MyCoolType`.
+ pub use my_prelude::*;
+
+ // This hides `my_prelude::MyCoolType`.
+ #[allow(hidden_glob_reexports)]
+ use my_uncool_type::MyUncoolType as MyCoolType;
+}
+
+// Regression test for https://github.com/rust-lang/rust-clippy/issues/10878
+pub mod ambiguous_glob_exports {
+ #![allow(unreachable_pub)]
+
+ mod my_prelude {
+ pub struct MyType;
+ }
+
+ mod my_type {
+ pub struct MyType;
+ }
+
+ #[allow(ambiguous_glob_reexports)]
+ pub use my_prelude::*;
+ pub use my_type::*;
+}
diff --git a/src/tools/clippy/tests/ui/useless_attribute.rs b/src/tools/clippy/tests/ui/useless_attribute.rs
index 59a9dcf..8dfcd21 100644
--- a/src/tools/clippy/tests/ui/useless_attribute.rs
+++ b/src/tools/clippy/tests/ui/useless_attribute.rs
@@ -86,8 +86,51 @@
#[rustfmt::skip]
#[allow(unused_import_braces)]
+#[allow(unused_braces)]
use module::{Struct};
fn main() {
test_indented_attr();
}
+
+// Regression test for https://github.com/rust-lang/rust-clippy/issues/4467
+#[allow(dead_code)]
+use std::collections as puppy_doggy;
+
+// Regression test for https://github.com/rust-lang/rust-clippy/issues/11595
+pub mod hidden_glob_reexports {
+ #![allow(unreachable_pub)]
+
+ mod my_prelude {
+ pub struct MyCoolTypeInternal;
+ pub use MyCoolTypeInternal as MyCoolType;
+ }
+
+ mod my_uncool_type {
+ pub(crate) struct MyUncoolType;
+ }
+
+ // This exports `MyCoolType`.
+ pub use my_prelude::*;
+
+ // This hides `my_prelude::MyCoolType`.
+ #[allow(hidden_glob_reexports)]
+ use my_uncool_type::MyUncoolType as MyCoolType;
+}
+
+// Regression test for https://github.com/rust-lang/rust-clippy/issues/10878
+pub mod ambiguous_glob_exports {
+ #![allow(unreachable_pub)]
+
+ mod my_prelude {
+ pub struct MyType;
+ }
+
+ mod my_type {
+ pub struct MyType;
+ }
+
+ #[allow(ambiguous_glob_reexports)]
+ pub use my_prelude::*;
+ pub use my_type::*;
+}
diff --git a/src/tools/clippy/tests/ui/while_float.rs b/src/tools/clippy/tests/ui/while_float.rs
new file mode 100644
index 0000000..a3b0618
--- /dev/null
+++ b/src/tools/clippy/tests/ui/while_float.rs
@@ -0,0 +1,14 @@
+#[deny(clippy::while_float)]
+fn main() {
+ let mut x = 0.0_f32;
+ while x < 42.0_f32 {
+ x += 0.5;
+ }
+ while x < 42.0 {
+ x += 1.0;
+ }
+ let mut x = 0;
+ while x < 42 {
+ x += 1;
+ }
+}
diff --git a/src/tools/clippy/tests/ui/while_float.stderr b/src/tools/clippy/tests/ui/while_float.stderr
new file mode 100644
index 0000000..b8e934b
--- /dev/null
+++ b/src/tools/clippy/tests/ui/while_float.stderr
@@ -0,0 +1,20 @@
+error: while condition comparing floats
+ --> tests/ui/while_float.rs:4:11
+ |
+LL | while x < 42.0_f32 {
+ | ^^^^^^^^^^^^
+ |
+note: the lint level is defined here
+ --> tests/ui/while_float.rs:1:8
+ |
+LL | #[deny(clippy::while_float)]
+ | ^^^^^^^^^^^^^^^^^^^
+
+error: while condition comparing floats
+ --> tests/ui/while_float.rs:7:11
+ |
+LL | while x < 42.0 {
+ | ^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/src/tools/clippy/util/gh-pages/script.js b/src/tools/clippy/util/gh-pages/script.js
index c63edd5..7fd779f 100644
--- a/src/tools/clippy/util/gh-pages/script.js
+++ b/src/tools/clippy/util/gh-pages/script.js
@@ -406,7 +406,7 @@
}
// Search by id
- if (lint.id.indexOf(searchStr.replace("-", "_")) !== -1) {
+ if (lint.id.indexOf(searchStr.replaceAll("-", "_")) !== -1) {
return true;
}
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_zst_deref.rs b/src/tools/miri/tests/fail/dangling_pointers/dangling_zst_deref.rs
deleted file mode 100644
index a1fefe0..0000000
--- a/src/tools/miri/tests/fail/dangling_pointers/dangling_zst_deref.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-// Make sure we find these even with many checks disabled.
-//@compile-flags: -Zmiri-disable-alignment-check -Zmiri-disable-stacked-borrows -Zmiri-disable-validation
-
-fn main() {
- let p = {
- let b = Box::new(42);
- &*b as *const i32 as *const ()
- };
- let _x = unsafe { *p }; //~ ERROR: has been freed
-}
diff --git a/src/tools/miri/tests/fail/dangling_pointers/dangling_zst_deref.stderr b/src/tools/miri/tests/fail/dangling_pointers/dangling_zst_deref.stderr
deleted file mode 100644
index 72b9a4a..0000000
--- a/src/tools/miri/tests/fail/dangling_pointers/dangling_zst_deref.stderr
+++ /dev/null
@@ -1,25 +0,0 @@
-error: Undefined Behavior: memory access failed: ALLOC has been freed, so this pointer is dangling
- --> $DIR/dangling_zst_deref.rs:LL:CC
- |
-LL | let _x = unsafe { *p };
- | ^^ memory access failed: ALLOC has been freed, so this pointer is dangling
- |
- = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
- = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
-help: ALLOC was allocated here:
- --> $DIR/dangling_zst_deref.rs:LL:CC
- |
-LL | let b = Box::new(42);
- | ^^^^^^^^^^^^
-help: ALLOC was deallocated here:
- --> $DIR/dangling_zst_deref.rs:LL:CC
- |
-LL | };
- | ^
- = note: BACKTRACE (of the first span):
- = note: inside `main` at $DIR/dangling_zst_deref.rs:LL:CC
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_deref_zst.rs b/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_deref_zst.rs
deleted file mode 100644
index 73d0b12..0000000
--- a/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_deref_zst.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-fn main() {
- // This pointer *could* be NULL so we cannot load from it, not even at ZST
- let ptr = (&0u8 as *const u8).wrapping_sub(0x800) as *const ();
- let _x: () = unsafe { *ptr }; //~ ERROR: out-of-bounds
-}
diff --git a/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_deref_zst.stderr b/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_deref_zst.stderr
deleted file mode 100644
index 13c53e2..0000000
--- a/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_deref_zst.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error: Undefined Behavior: memory access failed: ALLOC has size 1, so pointer at offset -2048 is out-of-bounds
- --> $DIR/maybe_null_pointer_deref_zst.rs:LL:CC
- |
-LL | let _x: () = unsafe { *ptr };
- | ^^^^ memory access failed: ALLOC has size 1, so pointer at offset -2048 is out-of-bounds
- |
- = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
- = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
- = note: BACKTRACE:
- = note: inside `main` at $DIR/maybe_null_pointer_deref_zst.rs:LL:CC
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_write_zst.rs b/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_write_zst.rs
deleted file mode 100644
index 5537207..0000000
--- a/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_write_zst.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-fn main() {
- // This pointer *could* be NULL so we cannot load from it, not even at ZST.
- // Not using the () type here, as writes of that type do not even have MIR generated.
- // Also not assigning directly as that's array initialization, not assignment.
- let zst_val = [1u8; 0];
- let ptr = (&0u8 as *const u8).wrapping_sub(0x800) as *mut [u8; 0];
- unsafe { *ptr = zst_val }; //~ ERROR: out-of-bounds
-}
diff --git a/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_write_zst.stderr b/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_write_zst.stderr
deleted file mode 100644
index e4e23e8..0000000
--- a/src/tools/miri/tests/fail/dangling_pointers/maybe_null_pointer_write_zst.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error: Undefined Behavior: memory access failed: ALLOC has size 1, so pointer at offset -2048 is out-of-bounds
- --> $DIR/maybe_null_pointer_write_zst.rs:LL:CC
- |
-LL | unsafe { *ptr = zst_val };
- | ^^^^^^^^^^^^^^ memory access failed: ALLOC has size 1, so pointer at offset -2048 is out-of-bounds
- |
- = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
- = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
- = note: BACKTRACE:
- = note: inside `main` at $DIR/maybe_null_pointer_write_zst.rs:LL:CC
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref_zst.rs b/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref_zst.rs
deleted file mode 100644
index f8af43f..0000000
--- a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref_zst.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-#[allow(deref_nullptr)]
-fn main() {
- let x: () = unsafe { *std::ptr::null() }; //~ ERROR: memory access failed: null pointer is a dangling pointer
- panic!("this should never print: {:?}", x);
-}
diff --git a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref_zst.stderr b/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref_zst.stderr
deleted file mode 100644
index 1a8794f..0000000
--- a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_deref_zst.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error: Undefined Behavior: memory access failed: null pointer is a dangling pointer (it has no provenance)
- --> $DIR/null_pointer_deref_zst.rs:LL:CC
- |
-LL | let x: () = unsafe { *std::ptr::null() };
- | ^^^^^^^^^^^^^^^^^ memory access failed: null pointer is a dangling pointer (it has no provenance)
- |
- = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
- = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
- = note: BACKTRACE:
- = note: inside `main` at $DIR/null_pointer_deref_zst.rs:LL:CC
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write_zst.rs b/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write_zst.rs
deleted file mode 100644
index edd6c8f..0000000
--- a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write_zst.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-#[allow(deref_nullptr)]
-fn main() {
- // Not using the () type here, as writes of that type do not even have MIR generated.
- // Also not assigning directly as that's array initialization, not assignment.
- let zst_val = [1u8; 0];
- unsafe { std::ptr::null_mut::<[u8; 0]>().write(zst_val) };
- //~^ERROR: memory access failed: null pointer is a dangling pointer
-}
diff --git a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write_zst.stderr b/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write_zst.stderr
deleted file mode 100644
index 1d4704e..0000000
--- a/src/tools/miri/tests/fail/dangling_pointers/null_pointer_write_zst.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error: Undefined Behavior: memory access failed: null pointer is a dangling pointer (it has no provenance)
- --> $DIR/null_pointer_write_zst.rs:LL:CC
- |
-LL | unsafe { std::ptr::null_mut::<[u8; 0]>().write(zst_val) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: null pointer is a dangling pointer (it has no provenance)
- |
- = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
- = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
- = note: BACKTRACE:
- = note: inside `main` at $DIR/null_pointer_write_zst.rs:LL:CC
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/fail/intrinsics/copy_null.rs b/src/tools/miri/tests/fail/intrinsics/copy_null.rs
deleted file mode 100644
index 237e517..0000000
--- a/src/tools/miri/tests/fail/intrinsics/copy_null.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-#![feature(intrinsics)]
-
-// Directly call intrinsic to avoid debug assertions in libstd
-extern "rust-intrinsic" {
- fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: usize);
-}
-
-fn main() {
- let mut data = [0u16; 4];
- let ptr = &mut data[0] as *mut u16;
- // Even copying 0 elements from NULL should error.
- unsafe {
- copy_nonoverlapping(std::ptr::null(), ptr, 0); //~ ERROR: memory access failed: null pointer is a dangling pointer
- }
-}
diff --git a/src/tools/miri/tests/fail/intrinsics/copy_null.stderr b/src/tools/miri/tests/fail/intrinsics/copy_null.stderr
deleted file mode 100644
index d73c034..0000000
--- a/src/tools/miri/tests/fail/intrinsics/copy_null.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error: Undefined Behavior: memory access failed: null pointer is a dangling pointer (it has no provenance)
- --> $DIR/copy_null.rs:LL:CC
- |
-LL | copy_nonoverlapping(std::ptr::null(), ptr, 0);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: null pointer is a dangling pointer (it has no provenance)
- |
- = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
- = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
- = note: BACKTRACE:
- = note: inside `main` at $DIR/copy_null.rs:LL:CC
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_0_plus_0.rs b/src/tools/miri/tests/fail/intrinsics/ptr_offset_0_plus_0.rs
deleted file mode 100644
index e2329c1..0000000
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_0_plus_0.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@compile-flags: -Zmiri-permissive-provenance
-
-#[rustfmt::skip] // fails with "left behind trailing whitespace"
-fn main() {
- let x = 0 as *mut i32;
- let _x = x.wrapping_offset(8); // ok, this has no inbounds tag
- let _x = unsafe { x.offset(0) }; // UB despite offset 0, NULL is never inbounds
- //~^ERROR: null pointer is a dangling pointer
-}
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_0_plus_0.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_offset_0_plus_0.stderr
deleted file mode 100644
index a8984c7..0000000
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_0_plus_0.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error: Undefined Behavior: out-of-bounds pointer arithmetic: null pointer is a dangling pointer (it has no provenance)
- --> $DIR/ptr_offset_0_plus_0.rs:LL:CC
- |
-LL | let _x = unsafe { x.offset(0) }; // UB despite offset 0, NULL is never inbounds
- | ^^^^^^^^^^^ out-of-bounds pointer arithmetic: null pointer is a dangling pointer (it has no provenance)
- |
- = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
- = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
- = note: BACKTRACE:
- = note: inside `main` at $DIR/ptr_offset_0_plus_0.rs:LL:CC
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_oob.rs b/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_oob.rs
deleted file mode 100644
index 0e5acf0..0000000
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_oob.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-fn main() {
- let start_ptr = &4 as *const _ as *const u8;
- let length = 10;
- let end_ptr = start_ptr.wrapping_add(length);
- // Even if the offset is 0, a dangling OOB pointer is not allowed.
- unsafe { end_ptr.offset_from(end_ptr) }; //~ERROR: pointer at offset 10 is out-of-bounds
-}
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_oob.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_oob.stderr
deleted file mode 100644
index 32a4461..0000000
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_from_oob.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error: Undefined Behavior: out-of-bounds `offset_from`: ALLOC has size 4, so pointer at offset 10 is out-of-bounds
- --> $DIR/ptr_offset_from_oob.rs:LL:CC
- |
-LL | unsafe { end_ptr.offset_from(end_ptr) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds `offset_from`: ALLOC has size 4, so pointer at offset 10 is out-of-bounds
- |
- = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
- = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
- = note: BACKTRACE:
- = note: inside `main` at $DIR/ptr_offset_from_oob.rs:LL:CC
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_ptr_plus_0.rs b/src/tools/miri/tests/fail/intrinsics/ptr_offset_ptr_plus_0.rs
deleted file mode 100644
index 575e288..0000000
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_ptr_plus_0.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-#[rustfmt::skip] // fails with "left behind trailing whitespace"
-fn main() {
- let x = Box::into_raw(Box::new(0u32));
- let x = x.wrapping_offset(8); // ok, this has no inbounds tag
- let _x = unsafe { x.offset(0) }; // UB despite offset 0, the pointer is not inbounds of the only object it can point to
- //~^ERROR: pointer at offset 32 is out-of-bounds
-}
diff --git a/src/tools/miri/tests/fail/intrinsics/ptr_offset_ptr_plus_0.stderr b/src/tools/miri/tests/fail/intrinsics/ptr_offset_ptr_plus_0.stderr
deleted file mode 100644
index 304d362..0000000
--- a/src/tools/miri/tests/fail/intrinsics/ptr_offset_ptr_plus_0.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error: Undefined Behavior: out-of-bounds pointer arithmetic: ALLOC has size 4, so pointer at offset 32 is out-of-bounds
- --> $DIR/ptr_offset_ptr_plus_0.rs:LL:CC
- |
-LL | let _x = unsafe { x.offset(0) }; // UB despite offset 0, the pointer is not inbounds of the only object it can point to
- | ^^^^^^^^^^^ out-of-bounds pointer arithmetic: ALLOC has size 4, so pointer at offset 32 is out-of-bounds
- |
- = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
- = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
-help: ALLOC was allocated here:
- --> $DIR/ptr_offset_ptr_plus_0.rs:LL:CC
- |
-LL | let x = Box::into_raw(Box::new(0u32));
- | ^^^^^^^^^^^^^^
- = note: BACKTRACE (of the first span):
- = note: inside `main` at $DIR/ptr_offset_ptr_plus_0.rs:LL:CC
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/fail/intrinsics/write_bytes_null.rs b/src/tools/miri/tests/fail/intrinsics/write_bytes_null.rs
deleted file mode 100644
index 2f46c82..0000000
--- a/src/tools/miri/tests/fail/intrinsics/write_bytes_null.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![feature(intrinsics)]
-
-// Directly call intrinsic to avoid debug assertions in libstd
-extern "rust-intrinsic" {
- fn write_bytes<T>(dst: *mut T, val: u8, count: usize);
-}
-
-fn main() {
- unsafe { write_bytes::<u8>(std::ptr::null_mut(), 0, 0) }; //~ ERROR: memory access failed: null pointer is a dangling pointer
-}
diff --git a/src/tools/miri/tests/fail/intrinsics/write_bytes_null.stderr b/src/tools/miri/tests/fail/intrinsics/write_bytes_null.stderr
deleted file mode 100644
index def1809..0000000
--- a/src/tools/miri/tests/fail/intrinsics/write_bytes_null.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error: Undefined Behavior: memory access failed: null pointer is a dangling pointer (it has no provenance)
- --> $DIR/write_bytes_null.rs:LL:CC
- |
-LL | unsafe { write_bytes::<u8>(std::ptr::null_mut(), 0, 0) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: null pointer is a dangling pointer (it has no provenance)
- |
- = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
- = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
- = note: BACKTRACE:
- = note: inside `main` at $DIR/write_bytes_null.rs:LL:CC
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/fail/zst2.rs b/src/tools/miri/tests/fail/zst2.rs
deleted file mode 100644
index 04218c2..0000000
--- a/src/tools/miri/tests/fail/zst2.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-fn main() {
- // Not using the () type here, as writes of that type do not even have MIR generated.
- // Also not assigning directly as that's array initialization, not assignment.
- let zst_val = [1u8; 0];
-
- // make sure ZST accesses are checked against being "truly" dangling pointers
- // (into deallocated allocations).
- let mut x_box = Box::new(1u8);
- let x = &mut *x_box as *mut _ as *mut [u8; 0];
- drop(x_box);
- unsafe { *x = zst_val }; //~ ERROR: has been freed
-}
diff --git a/src/tools/miri/tests/fail/zst2.stderr b/src/tools/miri/tests/fail/zst2.stderr
deleted file mode 100644
index b3f65e7..0000000
--- a/src/tools/miri/tests/fail/zst2.stderr
+++ /dev/null
@@ -1,25 +0,0 @@
-error: Undefined Behavior: memory access failed: ALLOC has been freed, so this pointer is dangling
- --> $DIR/zst2.rs:LL:CC
- |
-LL | unsafe { *x = zst_val };
- | ^^^^^^^^^^^^ memory access failed: ALLOC has been freed, so this pointer is dangling
- |
- = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
- = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
-help: ALLOC was allocated here:
- --> $DIR/zst2.rs:LL:CC
- |
-LL | let mut x_box = Box::new(1u8);
- | ^^^^^^^^^^^^^
-help: ALLOC was deallocated here:
- --> $DIR/zst2.rs:LL:CC
- |
-LL | drop(x_box);
- | ^^^^^^^^^^^
- = note: BACKTRACE (of the first span):
- = note: inside `main` at $DIR/zst2.rs:LL:CC
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/fail/zst3.rs b/src/tools/miri/tests/fail/zst3.rs
deleted file mode 100644
index 454bef2..0000000
--- a/src/tools/miri/tests/fail/zst3.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-fn main() {
- // Not using the () type here, as writes of that type do not even have MIR generated.
- // Also not assigning directly as that's array initialization, not assignment.
- let zst_val = [1u8; 0];
-
- // make sure ZST accesses are checked against being "truly" dangling pointers
- // (that are out-of-bounds).
- let mut x_box = Box::new(1u8);
- let x = (&mut *x_box as *mut u8).wrapping_offset(1);
- // This one is just "at the edge", but still okay
- unsafe { *(x as *mut [u8; 0]) = zst_val };
- // One byte further is OOB.
- let x = x.wrapping_offset(1);
- unsafe { *(x as *mut [u8; 0]) = zst_val }; //~ ERROR: out-of-bounds
-}
diff --git a/src/tools/miri/tests/fail/zst3.stderr b/src/tools/miri/tests/fail/zst3.stderr
deleted file mode 100644
index b9495fb..0000000
--- a/src/tools/miri/tests/fail/zst3.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error: Undefined Behavior: memory access failed: ALLOC has size 1, so pointer at offset 2 is out-of-bounds
- --> $DIR/zst3.rs:LL:CC
- |
-LL | unsafe { *(x as *mut [u8; 0]) = zst_val };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: ALLOC has size 1, so pointer at offset 2 is out-of-bounds
- |
- = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
- = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
-help: ALLOC was allocated here:
- --> $DIR/zst3.rs:LL:CC
- |
-LL | let mut x_box = Box::new(1u8);
- | ^^^^^^^^^^^^^
- = note: BACKTRACE (of the first span):
- = note: inside `main` at $DIR/zst3.rs:LL:CC
-
-note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/miri/tests/fail/zst1.rs b/src/tools/miri/tests/fail/zst_local_oob.rs
similarity index 100%
rename from src/tools/miri/tests/fail/zst1.rs
rename to src/tools/miri/tests/fail/zst_local_oob.rs
diff --git a/src/tools/miri/tests/fail/zst1.stderr b/src/tools/miri/tests/fail/zst_local_oob.stderr
similarity index 88%
rename from src/tools/miri/tests/fail/zst1.stderr
rename to src/tools/miri/tests/fail/zst_local_oob.stderr
index cda837d..ba1ccaa 100644
--- a/src/tools/miri/tests/fail/zst1.stderr
+++ b/src/tools/miri/tests/fail/zst_local_oob.stderr
@@ -1,5 +1,5 @@
error: Undefined Behavior: memory access failed: ALLOC has size 0, so pointer to 1 byte starting at offset 0 is out-of-bounds
- --> $DIR/zst1.rs:LL:CC
+ --> $DIR/zst_local_oob.rs:LL:CC
|
LL | let _val = unsafe { *x };
| ^^ memory access failed: ALLOC has size 0, so pointer to 1 byte starting at offset 0 is out-of-bounds
@@ -7,7 +7,7 @@
= help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
= help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
= note: BACKTRACE:
- = note: inside `main` at $DIR/zst1.rs:LL:CC
+ = note: inside `main` at $DIR/zst_local_oob.rs:LL:CC
note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
diff --git a/src/tools/miri/tests/pass/align_offset_symbolic.rs b/src/tools/miri/tests/pass/align_offset_symbolic.rs
index dec3d77..9647277 100644
--- a/src/tools/miri/tests/pass/align_offset_symbolic.rs
+++ b/src/tools/miri/tests/pass/align_offset_symbolic.rs
@@ -118,10 +118,9 @@
let parts: (*const (), *const u8) = unsafe { mem::transmute(ptr) };
let vtable = parts.1;
let offset = vtable.align_offset(mem::align_of::<TWOPTR>());
- let _vtable_aligned = vtable.wrapping_add(offset) as *const [TWOPTR; 0];
- // FIXME: we can't actually do the access since vtable pointers act like zero-sized allocations.
- // Enable the next line once https://github.com/rust-lang/rust/issues/117945 is implemented.
- //let _place = unsafe { &*vtable_aligned };
+ let vtable_aligned = vtable.wrapping_add(offset) as *const [TWOPTR; 0];
+ // Zero-sized deref, so no in-bounds requirement.
+ let _place = unsafe { &*vtable_aligned };
}
fn main() {
diff --git a/src/tools/miri/tests/pass/zero-sized-accesses-and-offsets.rs b/src/tools/miri/tests/pass/zero-sized-accesses-and-offsets.rs
new file mode 100644
index 0000000..2d142be
--- /dev/null
+++ b/src/tools/miri/tests/pass/zero-sized-accesses-and-offsets.rs
@@ -0,0 +1,59 @@
+//! Tests specific for <https://github.com/rust-lang/rust/issues/117945>: zero-sized operations.
+#![feature(strict_provenance)]
+
+use std::ptr;
+
+fn main() {
+ // Null.
+ test_ptr(ptr::null_mut::<()>());
+ // No provenance.
+ test_ptr(ptr::without_provenance_mut::<()>(1));
+ // Out-of-bounds.
+ let mut b = Box::new(0i32);
+ let ptr = ptr::addr_of_mut!(*b) as *mut ();
+ test_ptr(ptr.wrapping_byte_add(2));
+ // Dangling (use-after-free).
+ drop(b);
+ test_ptr(ptr);
+}
+
+fn test_ptr(ptr: *mut ()) {
+ unsafe {
+ // Reads and writes.
+ let mut val = *ptr;
+ *ptr = val;
+ ptr.read();
+ ptr.write(());
+ // Memory access intrinsics.
+ // - memcpy (1st and 2nd argument)
+ ptr.copy_from_nonoverlapping(&(), 1);
+ ptr.copy_to_nonoverlapping(&mut val, 1);
+ // - memmove (1st and 2nd argument)
+ ptr.copy_from(&(), 1);
+ ptr.copy_to(&mut val, 1);
+ // - memset
+ ptr.write_bytes(0u8, 1);
+ // Offset.
+ let _ = ptr.offset(0);
+ let _ = ptr.offset(1); // this is still 0 bytes
+ // Distance.
+ let ptr = ptr.cast::<i32>();
+ ptr.offset_from(ptr);
+ /*
+ FIXME: this is disabled for now as these cases are not yet allowed.
+ // Distance from other "bad" pointers that have the same address, but different provenance. Some
+ // of this is library UB, but we don't want it to be language UB since that would violate
+ // provenance monotonicity: if we allow computing the distance between two ptrs with no
+ // provenance, we have to allow computing it between two ptrs with arbitrary provenance.
+ // - Distance from "no provenance"
+ ptr.offset_from(ptr::without_provenance_mut(ptr.addr()));
+ // - Distance from out-of-bounds pointer
+ let mut b = Box::new(0i32);
+ let other_ptr = ptr::addr_of_mut!(*b);
+ ptr.offset_from(other_ptr.with_addr(ptr.addr()));
+ // - Distance from use-after-free pointer
+ drop(b);
+ ptr.offset_from(other_ptr.with_addr(ptr.addr()));
+ */
+ }
+}
diff --git a/tests/crashes/118185.rs b/tests/crashes/118185.rs
deleted file mode 100644
index c3a29c3..0000000
--- a/tests/crashes/118185.rs
+++ /dev/null
@@ -1,26 +0,0 @@
-//@ known-bug: #118185
-
-fn main() {
- let target: Target = create_target();
- target.get(0); // correct arguments work
- target.get(10.0); // CRASH HERE
-}
-
-// must be generic
-fn create_target<T>() -> T {
- unimplemented!()
-}
-
-// unimplemented trait, but contains function with the same name
-pub trait RandomTrait {
- fn get(&mut self); // but less arguments
-}
-
-struct Target;
-
-impl Target {
- // correct function with arguments
- pub fn get(&self, data: i32) {
- unimplemented!()
- }
-}
diff --git a/tests/rustdoc/issue-95633.rs b/tests/rustdoc-ui/pub-use-primitive-document-private-items-95633.rs
similarity index 71%
rename from tests/rustdoc/issue-95633.rs
rename to tests/rustdoc-ui/pub-use-primitive-document-private-items-95633.rs
index 5695ef5..d53a67c 100644
--- a/tests/rustdoc/issue-95633.rs
+++ b/tests/rustdoc-ui/pub-use-primitive-document-private-items-95633.rs
@@ -1,6 +1,8 @@
+//@ check-pass
//@ compile-flags: --document-private-items
// This ensures that no ICE is triggered when rustdoc is run on this code.
+// https://github.com/rust-lang/rust/issues/95633
mod stdlib {
pub (crate) use std::i8;
diff --git a/tests/rustdoc/issue-82465-asref-for-and-of-local.rs b/tests/rustdoc/asref-for-and-of-local-82465.rs
similarity index 63%
rename from tests/rustdoc/issue-82465-asref-for-and-of-local.rs
rename to tests/rustdoc/asref-for-and-of-local-82465.rs
index adf4d11..e620468 100644
--- a/tests/rustdoc/issue-82465-asref-for-and-of-local.rs
+++ b/tests/rustdoc/asref-for-and-of-local-82465.rs
@@ -1,7 +1,10 @@
+// https://github.com/rust-lang/rust/issues/82465
+#![crate_name = "foo"]
+
use std::convert::AsRef;
pub struct Local;
-// @has issue_82465_asref_for_and_of_local/struct.Local.html '//h3[@class="code-header"]' 'impl AsRef<str> for Local'
+// @has foo/struct.Local.html '//h3[@class="code-header"]' 'impl AsRef<str> for Local'
impl AsRef<str> for Local {
fn as_ref(&self) -> &str {
todo!()
diff --git a/tests/rustdoc/issue-88600.rs b/tests/rustdoc/enum-variant-doc-hidden-field-88600.rs
similarity index 93%
rename from tests/rustdoc/issue-88600.rs
rename to tests/rustdoc/enum-variant-doc-hidden-field-88600.rs
index f89af47..31d96e9 100644
--- a/tests/rustdoc/issue-88600.rs
+++ b/tests/rustdoc/enum-variant-doc-hidden-field-88600.rs
@@ -1,4 +1,6 @@
// This test ensure that #[doc(hidden)] is applied correctly in enum variant fields.
+// https://github.com/rust-lang/rust/issues/88600
+#![crate_name = "foo"]
// Denotes a field which should be hidden.
pub struct H;
@@ -6,7 +8,7 @@
// Denotes a field which should not be hidden (shown).
pub struct S;
-// @has issue_88600/enum.FooEnum.html
+// @has foo/enum.FooEnum.html
pub enum FooEnum {
// @has - '//*[@id="variant.HiddenTupleItem"]//h3' 'HiddenTupleItem(/* private fields */)'
// @count - '//*[@id="variant.HiddenTupleItem.field.0"]' 0
diff --git a/tests/rustdoc/issue-89309-heading-levels.rs b/tests/rustdoc/heading-levels-89309.rs
similarity index 92%
rename from tests/rustdoc/issue-89309-heading-levels.rs
rename to tests/rustdoc/heading-levels-89309.rs
index bb706c2..caa9942 100644
--- a/tests/rustdoc/issue-89309-heading-levels.rs
+++ b/tests/rustdoc/heading-levels-89309.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/89309
#![crate_name = "foo"]
// @has foo/trait.Read.html
diff --git a/tests/rustdoc/auxiliary/issue-85454.rs b/tests/rustdoc/inline_cross/auxiliary/issue-85454.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/issue-85454.rs
rename to tests/rustdoc/inline_cross/auxiliary/issue-85454.rs
diff --git a/tests/rustdoc/auxiliary/issue-98697-reexport-with-anonymous-lifetime.rs b/tests/rustdoc/inline_cross/auxiliary/reexport-with-anonymous-lifetime-98697.rs
similarity index 100%
rename from tests/rustdoc/auxiliary/issue-98697-reexport-with-anonymous-lifetime.rs
rename to tests/rustdoc/inline_cross/auxiliary/reexport-with-anonymous-lifetime-98697.rs
diff --git a/tests/rustdoc/issue-85454.rs b/tests/rustdoc/inline_cross/qpath-self-85454.rs
similarity index 94%
rename from tests/rustdoc/issue-85454.rs
rename to tests/rustdoc/inline_cross/qpath-self-85454.rs
index 790db0c..de806db 100644
--- a/tests/rustdoc/issue-85454.rs
+++ b/tests/rustdoc/inline_cross/qpath-self-85454.rs
@@ -1,6 +1,7 @@
//@ aux-build:issue-85454.rs
//@ build-aux-docs
#![crate_name = "foo"]
+// https://github.com/rust-lang/rust/issues/85454
extern crate issue_85454;
diff --git a/tests/rustdoc/inline_cross/reexport-with-anonymous-lifetime-98697.rs b/tests/rustdoc/inline_cross/reexport-with-anonymous-lifetime-98697.rs
new file mode 100644
index 0000000..fe6e5a3
--- /dev/null
+++ b/tests/rustdoc/inline_cross/reexport-with-anonymous-lifetime-98697.rs
@@ -0,0 +1,18 @@
+//@ aux-build:reexport-with-anonymous-lifetime-98697.rs
+//@ ignore-cross-compile
+#![crate_name = "foo"]
+
+// When reexporting a function with a HRTB with anonymous lifetimes,
+// make sure the anonymous lifetimes are not rendered.
+//
+// https://github.com/rust-lang/rust/issues/98697
+
+extern crate reexport_with_anonymous_lifetime_98697;
+
+// @has foo/fn.repro.html '//pre[@class="rust item-decl"]/code' 'fn repro<F>()where F: Fn(&str)'
+// @!has foo/fn.repro.html '//pre[@class="rust item-decl"]/code' 'for<'
+pub use reexport_with_anonymous_lifetime_98697::repro;
+
+// @has foo/struct.Extra.html '//div[@id="trait-implementations-list"]//h3[@class="code-header"]' 'impl MyTrait<&Extra> for Extra'
+// @!has foo/struct.Extra.html '//div[@id="trait-implementations-list"]//h3[@class="code-header"]' 'impl<'
+pub use reexport_with_anonymous_lifetime_98697::Extra;
diff --git a/tests/rustdoc/issue-94183-blanket-impl-reexported-trait.rs b/tests/rustdoc/inline_local/blanket-impl-reexported-trait-94183.rs
similarity index 94%
rename from tests/rustdoc/issue-94183-blanket-impl-reexported-trait.rs
rename to tests/rustdoc/inline_local/blanket-impl-reexported-trait-94183.rs
index 95ddd4c..343e030 100644
--- a/tests/rustdoc/issue-94183-blanket-impl-reexported-trait.rs
+++ b/tests/rustdoc/inline_local/blanket-impl-reexported-trait-94183.rs
@@ -2,6 +2,7 @@
// This test ensures that a publicly re-exported private trait will
// appear in the blanket impl list.
+// https://github.com/rust-lang/rust/issues/94183
#![crate_name = "foo"]
// @has 'foo/struct.S.html'
diff --git a/tests/rustdoc/issue-81141-private-reexport-in-public-api-2.rs b/tests/rustdoc/inline_local/private-reexport-in-public-api-81141-2.rs
similarity index 84%
rename from tests/rustdoc/issue-81141-private-reexport-in-public-api-2.rs
rename to tests/rustdoc/inline_local/private-reexport-in-public-api-81141-2.rs
index fba310c..c066f54 100644
--- a/tests/rustdoc/issue-81141-private-reexport-in-public-api-2.rs
+++ b/tests/rustdoc/inline_local/private-reexport-in-public-api-81141-2.rs
@@ -1,5 +1,6 @@
//@ edition:2015
+// https://github.com/rust-lang/rust/issues/81141
#![crate_name = "foo"]
use external::Public as Private;
diff --git a/tests/rustdoc/issue-81141-private-reexport-in-public-api.rs b/tests/rustdoc/inline_local/private-reexport-in-public-api-81141.rs
similarity index 97%
rename from tests/rustdoc/issue-81141-private-reexport-in-public-api.rs
rename to tests/rustdoc/inline_local/private-reexport-in-public-api-81141.rs
index bd54d02..d695ed7 100644
--- a/tests/rustdoc/issue-81141-private-reexport-in-public-api.rs
+++ b/tests/rustdoc/inline_local/private-reexport-in-public-api-81141.rs
@@ -1,6 +1,7 @@
// This test ensures that if a private re-export is present in a public API, it'll be
// replaced by the first public item in the re-export chain or by the private item.
+// https://github.com/rust-lang/rust/issues/81141
#![crate_name = "foo"]
use crate::bar::Bar as Alias;
diff --git a/tests/rustdoc/issue-81141-private-reexport-in-public-api-generics.rs b/tests/rustdoc/inline_local/private-reexport-in-public-api-generics-81141.rs
similarity index 85%
rename from tests/rustdoc/issue-81141-private-reexport-in-public-api-generics.rs
rename to tests/rustdoc/inline_local/private-reexport-in-public-api-generics-81141.rs
index 7e28950..1c86c76 100644
--- a/tests/rustdoc/issue-81141-private-reexport-in-public-api-generics.rs
+++ b/tests/rustdoc/inline_local/private-reexport-in-public-api-generics-81141.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/81141
#![crate_name = "foo"]
use crate::bar::Foo as Alias;
diff --git a/tests/rustdoc/issue-81141-private-reexport-in-public-api-hidden.rs b/tests/rustdoc/inline_local/private-reexport-in-public-api-hidden-81141.rs
similarity index 85%
rename from tests/rustdoc/issue-81141-private-reexport-in-public-api-hidden.rs
rename to tests/rustdoc/inline_local/private-reexport-in-public-api-hidden-81141.rs
index 388f69b..7d6fadf 100644
--- a/tests/rustdoc/issue-81141-private-reexport-in-public-api-hidden.rs
+++ b/tests/rustdoc/inline_local/private-reexport-in-public-api-hidden-81141.rs
@@ -1,5 +1,6 @@
//@ compile-flags: -Z unstable-options --document-hidden-items
+// https://github.com/rust-lang/rust/issues/81141
#![crate_name = "foo"]
#[doc(hidden)]
diff --git a/tests/rustdoc/issue-81141-private-reexport-in-public-api-private.rs b/tests/rustdoc/inline_local/private-reexport-in-public-api-private-81141.rs
similarity index 93%
rename from tests/rustdoc/issue-81141-private-reexport-in-public-api-private.rs
rename to tests/rustdoc/inline_local/private-reexport-in-public-api-private-81141.rs
index 2633f98..6bf5078 100644
--- a/tests/rustdoc/issue-81141-private-reexport-in-public-api-private.rs
+++ b/tests/rustdoc/inline_local/private-reexport-in-public-api-private-81141.rs
@@ -1,5 +1,6 @@
//@ compile-flags: --document-private-items
+// https://github.com/rust-lang/rust/issues/81141
#![crate_name = "foo"]
use crate::bar::Bar as Alias;
diff --git a/tests/rustdoc/inline_local/reexported-macro-and-macro-export-sidebar-89852.rs b/tests/rustdoc/inline_local/reexported-macro-and-macro-export-sidebar-89852.rs
new file mode 100644
index 0000000..cffe128
--- /dev/null
+++ b/tests/rustdoc/inline_local/reexported-macro-and-macro-export-sidebar-89852.rs
@@ -0,0 +1,16 @@
+//@ edition:2018
+
+// https://github.com/rust-lang/rust/issues/89852
+#![crate_name = "foo"]
+#![no_core]
+#![feature(no_core)]
+
+// @matchesraw 'foo/sidebar-items.js' '"repro"'
+// @!matchesraw 'foo/sidebar-items.js' '"repro".*"repro"'
+
+#[macro_export]
+macro_rules! repro {
+ () => {};
+}
+
+pub use crate::repro as repro2;
diff --git a/tests/rustdoc/issue-83375-multiple-mods-w-same-name-doc-inline.rs b/tests/rustdoc/issue-83375-multiple-mods-w-same-name-doc-inline.rs
deleted file mode 100644
index d0960df..0000000
--- a/tests/rustdoc/issue-83375-multiple-mods-w-same-name-doc-inline.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-#![crate_name = "foo"]
-
-pub mod sub {
- pub struct Item;
-
- pub mod prelude {
- pub use super::Item;
- }
-}
-
-// @count foo/index.html '//a[@class="mod"][@title="mod foo::prelude"]' 1
-// @count foo/prelude/index.html '//div[@class="item-row"]' 0
-pub mod prelude {}
-
-#[doc(inline)]
-pub use sub::*;
diff --git a/tests/rustdoc/issue-86620.rs b/tests/rustdoc/issue-86620.rs
deleted file mode 100644
index a7ac0f1..0000000
--- a/tests/rustdoc/issue-86620.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ aux-build:issue-86620-1.rs
-
-extern crate issue_86620_1;
-
-use issue_86620_1::*;
-
-// @!has issue_86620/struct.S.html '//*[@id="method.vzip"]//a[@class="fnname"]/@href' #tymethod.vzip
-// @has issue_86620/struct.S.html '//*[@id="method.vzip"]//a[@class="anchor"]/@href' #method.vzip
-pub struct S;
diff --git a/tests/rustdoc/issue-89852.rs b/tests/rustdoc/issue-89852.rs
deleted file mode 100644
index e9b3d80..0000000
--- a/tests/rustdoc/issue-89852.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-//@ edition:2018
-
-#![no_core]
-#![feature(no_core)]
-
-// @matchesraw 'issue_89852/sidebar-items.js' '"repro"'
-// @!matchesraw 'issue_89852/sidebar-items.js' '"repro".*"repro"'
-
-#[macro_export]
-macro_rules! repro {
- () => {};
-}
-
-pub use crate::repro as repro2;
diff --git a/tests/rustdoc/issue-95873.rs b/tests/rustdoc/issue-95873.rs
deleted file mode 100644
index 83f1f2f..0000000
--- a/tests/rustdoc/issue-95873.rs
+++ /dev/null
@@ -1,2 +0,0 @@
-// @has issue_95873/index.html "//*[@class='item-name']" "pub use ::std as x;"
-pub use ::std as x;
diff --git a/tests/rustdoc/issue-98697.rs b/tests/rustdoc/issue-98697.rs
deleted file mode 100644
index df9f291..0000000
--- a/tests/rustdoc/issue-98697.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-//@ aux-build:issue-98697-reexport-with-anonymous-lifetime.rs
-//@ ignore-cross-compile
-
-// When reexporting a function with a HRTB with anonymous lifetimes,
-// make sure the anonymous lifetimes are not rendered.
-//
-// https://github.com/rust-lang/rust/issues/98697
-
-extern crate issue_98697_reexport_with_anonymous_lifetime;
-
-// @has issue_98697/fn.repro.html '//pre[@class="rust item-decl"]/code' 'fn repro<F>()where F: Fn(&str)'
-// @!has issue_98697/fn.repro.html '//pre[@class="rust item-decl"]/code' 'for<'
-pub use issue_98697_reexport_with_anonymous_lifetime::repro;
-
-// @has issue_98697/struct.Extra.html '//div[@id="trait-implementations-list"]//h3[@class="code-header"]' 'impl MyTrait<&Extra> for Extra'
-// @!has issue_98697/struct.Extra.html '//div[@id="trait-implementations-list"]//h3[@class="code-header"]' 'impl<'
-pub use issue_98697_reexport_with_anonymous_lifetime::Extra;
diff --git a/tests/rustdoc/method-anchor-in-blanket-impl-86620.rs b/tests/rustdoc/method-anchor-in-blanket-impl-86620.rs
new file mode 100644
index 0000000..537dadd
--- /dev/null
+++ b/tests/rustdoc/method-anchor-in-blanket-impl-86620.rs
@@ -0,0 +1,11 @@
+//@ aux-build:issue-86620-1.rs
+#![crate_name = "foo"]
+// https://github.com/rust-lang/rust/issues/86620
+
+extern crate issue_86620_1;
+
+use issue_86620_1::*;
+
+// @!has foo/struct.S.html '//*[@id="method.vzip"]//a[@class="fnname"]/@href' #tymethod.vzip
+// @has foo/struct.S.html '//*[@id="method.vzip"]//a[@class="anchor"]/@href' #method.vzip
+pub struct S;
diff --git a/tests/rustdoc/issue-99221-multiple-macro-rules-w-same-name-submodule.rs b/tests/rustdoc/multiple-macro-rules-w-same-name-submodule-99221.rs
similarity index 85%
rename from tests/rustdoc/issue-99221-multiple-macro-rules-w-same-name-submodule.rs
rename to tests/rustdoc/multiple-macro-rules-w-same-name-submodule-99221.rs
index d3ccd1c..ed1e42c 100644
--- a/tests/rustdoc/issue-99221-multiple-macro-rules-w-same-name-submodule.rs
+++ b/tests/rustdoc/multiple-macro-rules-w-same-name-submodule-99221.rs
@@ -2,6 +2,7 @@
//@ build-aux-docs
//@ ignore-cross-compile
+// https://github.com/rust-lang/rust/issues/99221
#![crate_name = "foo"]
#[macro_use]
diff --git a/tests/rustdoc/issue-83375-multiple-mods-w-same-name-doc-inline-last-item.rs b/tests/rustdoc/multiple-mods-w-same-name-doc-inline-83375.rs
similarity index 85%
copy from tests/rustdoc/issue-83375-multiple-mods-w-same-name-doc-inline-last-item.rs
copy to tests/rustdoc/multiple-mods-w-same-name-doc-inline-83375.rs
index 9bce258..9b3dfd4 100644
--- a/tests/rustdoc/issue-83375-multiple-mods-w-same-name-doc-inline-last-item.rs
+++ b/tests/rustdoc/multiple-mods-w-same-name-doc-inline-83375.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/83375
#![crate_name = "foo"]
pub mod sub {
@@ -8,9 +9,9 @@
}
}
-#[doc(inline)]
-pub use sub::*;
-
// @count foo/index.html '//a[@class="mod"][@title="mod foo::prelude"]' 1
// @count foo/prelude/index.html '//div[@class="item-row"]' 0
pub mod prelude {}
+
+#[doc(inline)]
+pub use sub::*;
diff --git a/tests/rustdoc/issue-83375-multiple-mods-w-same-name-doc-inline-last-item.rs b/tests/rustdoc/multiple-mods-w-same-name-doc-inline-last-item-83375.rs
similarity index 85%
rename from tests/rustdoc/issue-83375-multiple-mods-w-same-name-doc-inline-last-item.rs
rename to tests/rustdoc/multiple-mods-w-same-name-doc-inline-last-item-83375.rs
index 9bce258..7bad825 100644
--- a/tests/rustdoc/issue-83375-multiple-mods-w-same-name-doc-inline-last-item.rs
+++ b/tests/rustdoc/multiple-mods-w-same-name-doc-inline-last-item-83375.rs
@@ -1,3 +1,4 @@
+// https://github.com/rust-lang/rust/issues/83375
#![crate_name = "foo"]
pub mod sub {
diff --git a/tests/rustdoc/pub-use-root-path-95873.rs b/tests/rustdoc/pub-use-root-path-95873.rs
new file mode 100644
index 0000000..5a817fb
--- /dev/null
+++ b/tests/rustdoc/pub-use-root-path-95873.rs
@@ -0,0 +1,5 @@
+// https://github.com/rust-lang/rust/issues/95873
+#![crate_name = "foo"]
+
+// @has foo/index.html "//*[@class='item-name']" "pub use ::std as x;"
+pub use ::std as x;
diff --git a/tests/rustdoc/issue-80233-normalize-auto-trait.rs b/tests/rustdoc/synthetic_auto/normalize-auto-trait-80233.rs
similarity index 85%
rename from tests/rustdoc/issue-80233-normalize-auto-trait.rs
rename to tests/rustdoc/synthetic_auto/normalize-auto-trait-80233.rs
index 62fbc24..0649801 100644
--- a/tests/rustdoc/issue-80233-normalize-auto-trait.rs
+++ b/tests/rustdoc/synthetic_auto/normalize-auto-trait-80233.rs
@@ -1,7 +1,9 @@
// Regression test for issue #80233
// Tests that we don't ICE when processing auto traits
+// https://github.com/rust-lang/rust/issues/80233
#![crate_type = "lib"]
+#![crate_name = "foo"]
pub trait Trait1 {}
pub trait Trait2 {
@@ -30,7 +32,7 @@
pub struct Struct1 {}
-// @has issue_80233_normalize_auto_trait/struct.Question.html
+// @has foo/struct.Question.html
// @has - '//h3[@class="code-header"]' 'impl<T> Send for Question<T>'
pub struct Question<T: Trait1> {
pub ins: <<Vec<T> as Trait3>::Type3 as Trait2>::Type2,
diff --git a/tests/rustdoc/issue-96381.rs b/tests/rustdoc/underscore-type-in-trait-impl-96381.rs
similarity index 85%
rename from tests/rustdoc/issue-96381.rs
rename to tests/rustdoc/underscore-type-in-trait-impl-96381.rs
index 90875c0..6d6e5e0 100644
--- a/tests/rustdoc/issue-96381.rs
+++ b/tests/rustdoc/underscore-type-in-trait-impl-96381.rs
@@ -1,4 +1,5 @@
//@ should-fail
+// https://github.com/rust-lang/rust/issues/96381
#![allow(unused)]
diff --git a/tests/ui/async-await/async-closures/force-move-due-to-actually-fnonce.rs b/tests/ui/async-await/async-closures/force-move-due-to-actually-fnonce.rs
new file mode 100644
index 0000000..ce49f55
--- /dev/null
+++ b/tests/ui/async-await/async-closures/force-move-due-to-actually-fnonce.rs
@@ -0,0 +1,27 @@
+//@ aux-build:block-on.rs
+//@ edition:2021
+//@ check-pass
+
+#![feature(async_closure)]
+
+extern crate block_on;
+
+fn consume(_: String) {}
+
+fn main() {
+ block_on::block_on(async {
+ let x = 1i32;
+ let s = String::new();
+ // `consume(s)` pulls the closure's kind down to `FnOnce`,
+ // which means that we don't treat the borrow of `x` as a
+ // self-borrow (with `'env` lifetime). This leads to a lifetime
+ // error which is solved by forcing the inner coroutine to
+ // be `move` as well, so that it moves `x`.
+ let c = async move || {
+ println!("{x}");
+ // This makes the closure FnOnce...
+ consume(s);
+ };
+ c().await;
+ });
+}
diff --git a/tests/ui/async-await/async-closures/force-move-due-to-inferred-kind.rs b/tests/ui/async-await/async-closures/force-move-due-to-inferred-kind.rs
new file mode 100644
index 0000000..803c990
--- /dev/null
+++ b/tests/ui/async-await/async-closures/force-move-due-to-inferred-kind.rs
@@ -0,0 +1,24 @@
+//@ aux-build:block-on.rs
+//@ edition:2021
+//@ check-pass
+
+#![feature(async_closure)]
+
+extern crate block_on;
+
+fn force_fnonce<T: async FnOnce()>(t: T) -> T { t }
+
+fn main() {
+ block_on::block_on(async {
+ let x = 1i32;
+ // `force_fnonce` pulls the closure's kind down to `FnOnce`,
+ // which means that we don't treat the borrow of `x` as a
+ // self-borrow (with `'env` lifetime). This leads to a lifetime
+ // error which is solved by forcing the inner coroutine to
+ // be `move` as well, so that it moves `x`.
+ let c = force_fnonce(async move || {
+ println!("{x}");
+ });
+ c().await;
+ });
+}
diff --git a/tests/ui/cfg/future-compat-crate-attributes-using-cfg_attr.stderr b/tests/ui/cfg/future-compat-crate-attributes-using-cfg_attr.stderr
index 75df314..82b2d7d 100644
--- a/tests/ui/cfg/future-compat-crate-attributes-using-cfg_attr.stderr
+++ b/tests/ui/cfg/future-compat-crate-attributes-using-cfg_attr.stderr
@@ -1,4 +1,4 @@
-error: `crate_type` within an `#![cfg_attr] attribute is deprecated`
+error: `crate_type` within an `#![cfg_attr]` attribute is deprecated
--> $DIR/future-compat-crate-attributes-using-cfg_attr.rs:4:18
|
LL | #![cfg_attr(foo, crate_type="bin")]
@@ -8,7 +8,7 @@
= note: for more information, see issue #91632 <https://github.com/rust-lang/rust/issues/91632>
= note: `#[deny(deprecated_cfg_attr_crate_type_name)]` on by default
-error: `crate_name` within an `#![cfg_attr] attribute is deprecated`
+error: `crate_name` within an `#![cfg_attr]` attribute is deprecated
--> $DIR/future-compat-crate-attributes-using-cfg_attr.rs:9:18
|
LL | #![cfg_attr(foo, crate_name="bar")]
@@ -17,7 +17,7 @@
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #91632 <https://github.com/rust-lang/rust/issues/91632>
-error: `crate_type` within an `#![cfg_attr] attribute is deprecated`
+error: `crate_type` within an `#![cfg_attr]` attribute is deprecated
--> $DIR/future-compat-crate-attributes-using-cfg_attr.rs:4:18
|
LL | #![cfg_attr(foo, crate_type="bin")]
@@ -27,7 +27,7 @@
= note: for more information, see issue #91632 <https://github.com/rust-lang/rust/issues/91632>
= note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-error: `crate_name` within an `#![cfg_attr] attribute is deprecated`
+error: `crate_name` within an `#![cfg_attr]` attribute is deprecated
--> $DIR/future-compat-crate-attributes-using-cfg_attr.rs:9:18
|
LL | #![cfg_attr(foo, crate_name="bar")]
diff --git a/tests/ui/check-cfg/allow-same-level.stderr b/tests/ui/check-cfg/allow-same-level.stderr
index ae4c160..b311a80 100644
--- a/tests/ui/check-cfg/allow-same-level.stderr
+++ b/tests/ui/check-cfg/allow-same-level.stderr
@@ -4,7 +4,7 @@
LL | #[cfg(FALSE)]
| ^^^^^
|
- = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: to expect this configuration use `--check-cfg=cfg(FALSE)`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
= note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/cargo-feature.none.stderr b/tests/ui/check-cfg/cargo-feature.none.stderr
index a940eda..9d3117e 100644
--- a/tests/ui/check-cfg/cargo-feature.none.stderr
+++ b/tests/ui/check-cfg/cargo-feature.none.stderr
@@ -25,7 +25,7 @@
LL | #[cfg(tokio_unstable)]
| ^^^^^^^^^^^^^^
|
- = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: consider using a Cargo feature instead
= help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
[lints.rust]
diff --git a/tests/ui/check-cfg/cargo-feature.some.stderr b/tests/ui/check-cfg/cargo-feature.some.stderr
index 70d3182..14e24cb 100644
--- a/tests/ui/check-cfg/cargo-feature.some.stderr
+++ b/tests/ui/check-cfg/cargo-feature.some.stderr
@@ -25,7 +25,7 @@
LL | #[cfg(tokio_unstable)]
| ^^^^^^^^^^^^^^
|
- = help: expected names are: `CONFIG_NVME`, `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `CONFIG_NVME`, `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: consider using a Cargo feature instead
= help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
[lints.rust]
diff --git a/tests/ui/check-cfg/cfg-value-for-cfg-name-duplicate.stderr b/tests/ui/check-cfg/cfg-value-for-cfg-name-duplicate.stderr
index 4975129..08bd438 100644
--- a/tests/ui/check-cfg/cfg-value-for-cfg-name-duplicate.stderr
+++ b/tests/ui/check-cfg/cfg-value-for-cfg-name-duplicate.stderr
@@ -4,7 +4,7 @@
LL | #[cfg(value)]
| ^^^^^
|
- = help: expected names are: `bar`, `bee`, `clippy`, `cow`, `debug_assertions`, `doc`, `doctest`, `foo`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `bar`, `bee`, `clippy`, `cow`, `debug_assertions`, `doc`, `doctest`, `foo`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: to expect this configuration use `--check-cfg=cfg(value)`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
= note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/cfg-value-for-cfg-name-multiple.stderr b/tests/ui/check-cfg/cfg-value-for-cfg-name-multiple.stderr
index 6404556..6db1144 100644
--- a/tests/ui/check-cfg/cfg-value-for-cfg-name-multiple.stderr
+++ b/tests/ui/check-cfg/cfg-value-for-cfg-name-multiple.stderr
@@ -4,7 +4,7 @@
LL | #[cfg(my_value)]
| ^^^^^^^^
|
- = help: expected names are: `bar`, `clippy`, `debug_assertions`, `doc`, `doctest`, `foo`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `bar`, `clippy`, `debug_assertions`, `doc`, `doctest`, `foo`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: to expect this configuration use `--check-cfg=cfg(my_value)`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
= note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/cfg-value-for-cfg-name.stderr b/tests/ui/check-cfg/cfg-value-for-cfg-name.stderr
index bda1a60..a5f8176 100644
--- a/tests/ui/check-cfg/cfg-value-for-cfg-name.stderr
+++ b/tests/ui/check-cfg/cfg-value-for-cfg-name.stderr
@@ -4,7 +4,7 @@
LL | #[cfg(linux)]
| ^^^^^ help: found config with similar value: `target_os = "linux"`
|
- = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: to expect this configuration use `--check-cfg=cfg(linux)`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
= note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/compact-names.stderr b/tests/ui/check-cfg/compact-names.stderr
index 079be8d..6fecdb5 100644
--- a/tests/ui/check-cfg/compact-names.stderr
+++ b/tests/ui/check-cfg/compact-names.stderr
@@ -4,7 +4,7 @@
LL | #[cfg(target(os = "linux", architecture = "arm"))]
| ^^^^^^^^^^^^^^^^^^^^
|
- = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: to expect this configuration use `--check-cfg=cfg(target_architecture, values("arm"))`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
= note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/compact-values.stderr b/tests/ui/check-cfg/compact-values.stderr
index 4fe921d..c8d14f8 100644
--- a/tests/ui/check-cfg/compact-values.stderr
+++ b/tests/ui/check-cfg/compact-values.stderr
@@ -4,7 +4,7 @@
LL | #[cfg(target(os = "linux", pointer_width = "X"))]
| ^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_pointer_width` are: `16`, `32`, `64`
+ = note: expected values for `target_pointer_width` are: `16`, `32`, and `64`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
= note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/concat-values.stderr b/tests/ui/check-cfg/concat-values.stderr
index a508c39..ec74095 100644
--- a/tests/ui/check-cfg/concat-values.stderr
+++ b/tests/ui/check-cfg/concat-values.stderr
@@ -4,7 +4,7 @@
LL | #[cfg(my_cfg)]
| ^^^^^^
|
- = note: expected values for `my_cfg` are: `bar`, `foo`
+ = note: expected values for `my_cfg` are: `bar` and `foo`
= help: to expect this configuration use `--check-cfg=cfg(my_cfg)`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
= note: `#[warn(unexpected_cfgs)]` on by default
@@ -15,7 +15,7 @@
LL | #[cfg(my_cfg = "unk")]
| ^^^^^^^^^^^^^^
|
- = note: expected values for `my_cfg` are: `bar`, `foo`
+ = note: expected values for `my_cfg` are: `bar` and `foo`
= help: to expect this configuration use `--check-cfg=cfg(my_cfg, values("unk"))`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
diff --git a/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr b/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr
index 755373d..2497864 100644
--- a/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr
+++ b/tests/ui/check-cfg/exhaustive-names-values.empty_cfg.stderr
@@ -4,7 +4,7 @@
LL | #[cfg(unknown_key = "value")]
| ^^^^^^^^^^^^^^^^^^^^^
|
- = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: to expect this configuration use `--check-cfg=cfg(unknown_key, values("value"))`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
= note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/exhaustive-names-values.feature.stderr b/tests/ui/check-cfg/exhaustive-names-values.feature.stderr
index 6344739..a7d4c6d 100644
--- a/tests/ui/check-cfg/exhaustive-names-values.feature.stderr
+++ b/tests/ui/check-cfg/exhaustive-names-values.feature.stderr
@@ -4,7 +4,7 @@
LL | #[cfg(unknown_key = "value")]
| ^^^^^^^^^^^^^^^^^^^^^
|
- = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: to expect this configuration use `--check-cfg=cfg(unknown_key, values("value"))`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
= note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/exhaustive-names-values.full.stderr b/tests/ui/check-cfg/exhaustive-names-values.full.stderr
index 6344739..a7d4c6d 100644
--- a/tests/ui/check-cfg/exhaustive-names-values.full.stderr
+++ b/tests/ui/check-cfg/exhaustive-names-values.full.stderr
@@ -4,7 +4,7 @@
LL | #[cfg(unknown_key = "value")]
| ^^^^^^^^^^^^^^^^^^^^^
|
- = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: to expect this configuration use `--check-cfg=cfg(unknown_key, values("value"))`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
= note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/exhaustive-names.stderr b/tests/ui/check-cfg/exhaustive-names.stderr
index 605825c..7ac3241 100644
--- a/tests/ui/check-cfg/exhaustive-names.stderr
+++ b/tests/ui/check-cfg/exhaustive-names.stderr
@@ -4,7 +4,7 @@
LL | #[cfg(unknown_key = "value")]
| ^^^^^^^^^^^^^^^^^^^^^
|
- = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: to expect this configuration use `--check-cfg=cfg(unknown_key, values("value"))`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
= note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/mix.stderr b/tests/ui/check-cfg/mix.stderr
index 5459169..8c1bf5a 100644
--- a/tests/ui/check-cfg/mix.stderr
+++ b/tests/ui/check-cfg/mix.stderr
@@ -44,7 +44,7 @@
LL | #[cfg_attr(uu, test)]
| ^^
|
- = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `feature`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: to expect this configuration use `--check-cfg=cfg(uu)`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
@@ -251,7 +251,7 @@
LL | cfg!(target_feature = "zebra");
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_feature` are: `10e60`, `2e3`, `3e3r1`, `3e3r2`, `3e3r3`, `3e7`, `7e10`, `a`, `aclass`, `adx`, `aes`, `altivec`, `alu32`, `atomics`, `avx`, `avx2`, `avx512bf16`, `avx512bitalg`, `avx512bw`, `avx512cd`, `avx512dq`, `avx512er`, `avx512f`, `avx512fp16`, `avx512ifma`, `avx512pf`, `avx512vbmi`, `avx512vbmi2`, `avx512vl`, `avx512vnni`, `avx512vp2intersect`, `avx512vpopcntdq`, `bf16`, `bmi1`, `bmi2` and 188 more
+ = note: expected values for `target_feature` are: `10e60`, `2e3`, `3e3r1`, `3e3r2`, `3e3r3`, `3e7`, `7e10`, `a`, `aclass`, `adx`, `aes`, `altivec`, `alu32`, `atomics`, `avx`, `avx2`, `avx512bf16`, `avx512bitalg`, `avx512bw`, `avx512cd`, `avx512dq`, `avx512er`, `avx512f`, `avx512fp16`, `avx512ifma`, `avx512pf`, `avx512vbmi`, `avx512vbmi2`, `avx512vl`, `avx512vnni`, `avx512vp2intersect`, `avx512vpopcntdq`, `bf16`, `bmi1`, and `bmi2` and 188 more
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: 27 warnings emitted
diff --git a/tests/ui/check-cfg/stmt-no-ice.stderr b/tests/ui/check-cfg/stmt-no-ice.stderr
index ab0deae..e8b61d8 100644
--- a/tests/ui/check-cfg/stmt-no-ice.stderr
+++ b/tests/ui/check-cfg/stmt-no-ice.stderr
@@ -4,7 +4,7 @@
LL | #[cfg(crossbeam_loom)]
| ^^^^^^^^^^^^^^
|
- = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: to expect this configuration use `--check-cfg=cfg(crossbeam_loom)`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
= note: `#[warn(unexpected_cfgs)]` on by default
diff --git a/tests/ui/check-cfg/unexpected-cfg-value.stderr b/tests/ui/check-cfg/unexpected-cfg-value.stderr
index efcf65b..0fa0dde 100644
--- a/tests/ui/check-cfg/unexpected-cfg-value.stderr
+++ b/tests/ui/check-cfg/unexpected-cfg-value.stderr
@@ -6,7 +6,7 @@
| |
| help: there is a expected value with a similar name: `"serde"`
|
- = note: expected values for `feature` are: `full`, `serde`
+ = note: expected values for `feature` are: `full` and `serde`
= help: to expect this configuration use `--check-cfg=cfg(feature, values("sedre"))`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
= note: `#[warn(unexpected_cfgs)]` on by default
@@ -17,7 +17,7 @@
LL | #[cfg(feature = "rand")]
| ^^^^^^^^^^^^^^^^
|
- = note: expected values for `feature` are: `full`, `serde`
+ = note: expected values for `feature` are: `full` and `serde`
= help: to expect this configuration use `--check-cfg=cfg(feature, values("rand"))`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
diff --git a/tests/ui/check-cfg/well-known-names.stderr b/tests/ui/check-cfg/well-known-names.stderr
index 2ce6fe8..4113021 100644
--- a/tests/ui/check-cfg/well-known-names.stderr
+++ b/tests/ui/check-cfg/well-known-names.stderr
@@ -18,7 +18,7 @@
LL | #[cfg(features = "foo")]
| ^^^^^^^^^^^^^^^^
|
- = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, `windows`
+ = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `miri`, `overflow_checks`, `panic`, `proc_macro`, `relocation_model`, `rustfmt`, `sanitize`, `sanitizer_cfi_generalize_pointers`, `sanitizer_cfi_normalize_integers`, `target_abi`, `target_arch`, `target_endian`, `target_env`, `target_family`, `target_feature`, `target_has_atomic`, `target_has_atomic_equal_alignment`, `target_has_atomic_load_store`, `target_os`, `target_pointer_width`, `target_thread_local`, `target_vendor`, `test`, `ub_checks`, `unix`, and `windows`
= help: to expect this configuration use `--check-cfg=cfg(features, values("foo"))`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
diff --git a/tests/ui/check-cfg/well-known-values.stderr b/tests/ui/check-cfg/well-known-values.stderr
index db4a5fd..c13446b 100644
--- a/tests/ui/check-cfg/well-known-values.stderr
+++ b/tests/ui/check-cfg/well-known-values.stderr
@@ -71,7 +71,7 @@
LL | panic = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `panic` are: `abort`, `unwind`
+ = note: expected values for `panic` are: `abort` and `unwind`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -91,7 +91,7 @@
LL | relocation_model = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `relocation_model` are: `dynamic-no-pic`, `pic`, `pie`, `ropi`, `ropi-rwpi`, `rwpi`, `static`
+ = note: expected values for `relocation_model` are: `dynamic-no-pic`, `pic`, `pie`, `ropi`, `ropi-rwpi`, `rwpi`, and `static`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -111,7 +111,7 @@
LL | sanitize = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `sanitize` are: `address`, `cfi`, `dataflow`, `hwaddress`, `kcfi`, `kernel-address`, `leak`, `memory`, `memtag`, `safestack`, `shadow-call-stack`, `thread`
+ = note: expected values for `sanitize` are: `address`, `cfi`, `dataflow`, `hwaddress`, `kcfi`, `kernel-address`, `leak`, `memory`, `memtag`, `safestack`, `shadow-call-stack`, and `thread`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -120,7 +120,7 @@
LL | target_abi = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_abi` are: ``, `abi64`, `abiv2`, `abiv2hf`, `eabi`, `eabihf`, `elf`, `fortanix`, `ilp32`, `llvm`, `macabi`, `sim`, `softfloat`, `spe`, `uwp`, `vec-extabi`, `x32`
+ = note: expected values for `target_abi` are: ``, `abi64`, `abiv2`, `abiv2hf`, `eabi`, `eabihf`, `elf`, `fortanix`, `ilp32`, `llvm`, `macabi`, `sim`, `softfloat`, `spe`, `uwp`, `vec-extabi`, and `x32`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -129,7 +129,7 @@
LL | target_arch = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_arch` are: `aarch64`, `arm`, `arm64ec`, `avr`, `bpf`, `csky`, `hexagon`, `loongarch64`, `m68k`, `mips`, `mips32r6`, `mips64`, `mips64r6`, `msp430`, `nvptx64`, `powerpc`, `powerpc64`, `riscv32`, `riscv64`, `s390x`, `sparc`, `sparc64`, `wasm32`, `wasm64`, `x86`, `x86_64`
+ = note: expected values for `target_arch` are: `aarch64`, `arm`, `arm64ec`, `avr`, `bpf`, `csky`, `hexagon`, `loongarch64`, `m68k`, `mips`, `mips32r6`, `mips64`, `mips64r6`, `msp430`, `nvptx64`, `powerpc`, `powerpc64`, `riscv32`, `riscv64`, `s390x`, `sparc`, `sparc64`, `wasm32`, `wasm64`, `x86`, and `x86_64`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -138,7 +138,7 @@
LL | target_endian = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_endian` are: `big`, `little`
+ = note: expected values for `target_endian` are: `big` and `little`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -147,7 +147,7 @@
LL | target_env = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_env` are: ``, `gnu`, `msvc`, `musl`, `newlib`, `nto70`, `nto71`, `ohos`, `p2`, `psx`, `relibc`, `sgx`, `uclibc`
+ = note: expected values for `target_env` are: ``, `gnu`, `msvc`, `musl`, `newlib`, `nto70`, `nto71`, `ohos`, `p2`, `psx`, `relibc`, `sgx`, and `uclibc`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -156,7 +156,7 @@
LL | target_family = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_family` are: `unix`, `wasm`, `windows`
+ = note: expected values for `target_family` are: `unix`, `wasm`, and `windows`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -165,7 +165,7 @@
LL | target_feature = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_feature` are: `10e60`, `2e3`, `3e3r1`, `3e3r2`, `3e3r3`, `3e7`, `7e10`, `a`, `aclass`, `adx`, `aes`, `altivec`, `alu32`, `atomics`, `avx`, `avx2`, `avx512bf16`, `avx512bitalg`, `avx512bw`, `avx512cd`, `avx512dq`, `avx512er`, `avx512f`, `avx512fp16`, `avx512ifma`, `avx512pf`, `avx512vbmi`, `avx512vbmi2`, `avx512vl`, `avx512vnni`, `avx512vp2intersect`, `avx512vpopcntdq`, `bf16`, `bmi1`, `bmi2`, `bti`, `bulk-memory`, `c`, `cache`, `cmpxchg16b`, `crc`, `crt-static`, `d`, `d32`, `dit`, `doloop`, `dotprod`, `dpb`, `dpb2`, `dsp`, `dsp1e2`, `dspe60`, `e`, `e1`, `e2`, `edsp`, `elrw`, `ermsb`, `exception-handling`, `extended-const`, `f`, `f16c`, `f32mm`, `f64mm`, `fcma`, `fdivdu`, `fhm`, `flagm`, `float1e2`, `float1e3`, `float3e4`, `float7e60`, `floate1`, `fma`, `fp-armv8`, `fp16`, `fp64`, `fpuv2_df`, `fpuv2_sf`, `fpuv3_df`, `fpuv3_hf`, `fpuv3_hi`, `fpuv3_sf`, `frecipe`, `frintts`, `fxsr`, `gfni`, `hard-float`, `hard-float-abi`, `hard-tp`, `high-registers`, `hvx`, `hvx-length128b`, `hwdiv`, `i8mm`, `jsconv`, `lahfsahf`, `lasx`, `lbt`, `lor`, `lse`, `lsx`, `lvz`, `lzcnt`, `m`, `mclass`, `movbe`, `mp`, `mp1e2`, `msa`, `mte`, `multivalue`, `mutable-globals`, `neon`, `nontrapping-fptoint`, `nvic`, `paca`, `pacg`, `pan`, `pclmulqdq`, `pmuv3`, `popcnt`, `power10-vector`, `power8-altivec`, `power8-vector`, `power9-altivec`, `power9-vector`, `prfchw`, `rand`, `ras`, `rclass`, `rcpc`, `rcpc2`, `rdm`, `rdrand`, `rdseed`, `reference-types`, `relax`, `relaxed-simd`, `rtm`, `sb`, `sha`, `sha2`, `sha3`, `sign-ext`, `simd128`, `sm4`, `spe`, `ssbs`, `sse`, `sse2`, `sse3`, `sse4.1`, `sse4.2`, `sse4a`, `ssse3`, `sve`, `sve2`, `sve2-aes`, `sve2-bitperm`, `sve2-sha3`, `sve2-sm4`, `tbm`, `thumb-mode`, `thumb2`, `tme`, `trust`, `trustzone`, `ual`, `unaligned-scalar-mem`, `v`, `v5te`, `v6`, `v6k`, `v6t2`, `v7`, `v8`, `v8.1a`, `v8.2a`, `v8.3a`, `v8.4a`, `v8.5a`, `v8.6a`, `v8.7a`, `vaes`, `vdsp2e60f`, `vdspv1`, `vdspv2`, `vfp2`, `vfp3`, `vfp4`, `vh`, `virt`, `virtualization`, `vpclmulqdq`, `vsx`, `xsave`, `xsavec`, `xsaveopt`, `xsaves`, `zba`, `zbb`, `zbc`, `zbkb`, `zbkc`, `zbkx`, `zbs`, `zdinx`, `zfh`, `zfhmin`, `zfinx`, `zhinx`, `zhinxmin`, `zk`, `zkn`, `zknd`, `zkne`, `zknh`, `zkr`, `zks`, `zksed`, `zksh`, `zkt`
+ = note: expected values for `target_feature` are: `10e60`, `2e3`, `3e3r1`, `3e3r2`, `3e3r3`, `3e7`, `7e10`, `a`, `aclass`, `adx`, `aes`, `altivec`, `alu32`, `atomics`, `avx`, `avx2`, `avx512bf16`, `avx512bitalg`, `avx512bw`, `avx512cd`, `avx512dq`, `avx512er`, `avx512f`, `avx512fp16`, `avx512ifma`, `avx512pf`, `avx512vbmi`, `avx512vbmi2`, `avx512vl`, `avx512vnni`, `avx512vp2intersect`, `avx512vpopcntdq`, `bf16`, `bmi1`, `bmi2`, `bti`, `bulk-memory`, `c`, `cache`, `cmpxchg16b`, `crc`, `crt-static`, `d`, `d32`, `dit`, `doloop`, `dotprod`, `dpb`, `dpb2`, `dsp`, `dsp1e2`, `dspe60`, `e`, `e1`, `e2`, `edsp`, `elrw`, `ermsb`, `exception-handling`, `extended-const`, `f`, `f16c`, `f32mm`, `f64mm`, `fcma`, `fdivdu`, `fhm`, `flagm`, `float1e2`, `float1e3`, `float3e4`, `float7e60`, `floate1`, `fma`, `fp-armv8`, `fp16`, `fp64`, `fpuv2_df`, `fpuv2_sf`, `fpuv3_df`, `fpuv3_hf`, `fpuv3_hi`, `fpuv3_sf`, `frecipe`, `frintts`, `fxsr`, `gfni`, `hard-float`, `hard-float-abi`, `hard-tp`, `high-registers`, `hvx`, `hvx-length128b`, `hwdiv`, `i8mm`, `jsconv`, `lahfsahf`, `lasx`, `lbt`, `lor`, `lse`, `lsx`, `lvz`, `lzcnt`, `m`, `mclass`, `movbe`, `mp`, `mp1e2`, `msa`, `mte`, `multivalue`, `mutable-globals`, `neon`, `nontrapping-fptoint`, `nvic`, `paca`, `pacg`, `pan`, `pclmulqdq`, `pmuv3`, `popcnt`, `power10-vector`, `power8-altivec`, `power8-vector`, `power9-altivec`, `power9-vector`, `prfchw`, `rand`, `ras`, `rclass`, `rcpc`, `rcpc2`, `rdm`, `rdrand`, `rdseed`, `reference-types`, `relax`, `relaxed-simd`, `rtm`, `sb`, `sha`, `sha2`, `sha3`, `sign-ext`, `simd128`, `sm4`, `spe`, `ssbs`, `sse`, `sse2`, `sse3`, `sse4.1`, `sse4.2`, `sse4a`, `ssse3`, `sve`, `sve2`, `sve2-aes`, `sve2-bitperm`, `sve2-sha3`, `sve2-sm4`, `tbm`, `thumb-mode`, `thumb2`, `tme`, `trust`, `trustzone`, `ual`, `unaligned-scalar-mem`, `v`, `v5te`, `v6`, `v6k`, `v6t2`, `v7`, `v8`, `v8.1a`, `v8.2a`, `v8.3a`, `v8.4a`, `v8.5a`, `v8.6a`, `v8.7a`, `vaes`, `vdsp2e60f`, `vdspv1`, `vdspv2`, `vfp2`, `vfp3`, `vfp4`, `vh`, `virt`, `virtualization`, `vpclmulqdq`, `vsx`, `xsave`, `xsavec`, `xsaveopt`, `xsaves`, `zba`, `zbb`, `zbc`, `zbkb`, `zbkc`, `zbkx`, `zbs`, `zdinx`, `zfh`, `zfhmin`, `zfinx`, `zhinx`, `zhinxmin`, `zk`, `zkn`, `zknd`, `zkne`, `zknh`, `zkr`, `zks`, `zksed`, `zksh`, and `zkt`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -174,7 +174,7 @@
LL | target_has_atomic = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_has_atomic` are: (none), `128`, `16`, `32`, `64`, `8`, `ptr`
+ = note: expected values for `target_has_atomic` are: (none), `128`, `16`, `32`, `64`, `8`, and `ptr`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -183,7 +183,7 @@
LL | target_has_atomic_equal_alignment = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_has_atomic_equal_alignment` are: (none), `128`, `16`, `32`, `64`, `8`, `ptr`
+ = note: expected values for `target_has_atomic_equal_alignment` are: (none), `128`, `16`, `32`, `64`, `8`, and `ptr`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -192,7 +192,7 @@
LL | target_has_atomic_load_store = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_has_atomic_load_store` are: (none), `128`, `16`, `32`, `64`, `8`, `ptr`
+ = note: expected values for `target_has_atomic_load_store` are: (none), `128`, `16`, `32`, `64`, `8`, and `ptr`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -201,7 +201,7 @@
LL | target_os = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_os` are: `aix`, `android`, `cuda`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `macos`, `netbsd`, `none`, `nto`, `openbsd`, `psp`, `redox`, `solaris`, `solid_asp3`, `teeos`, `tvos`, `uefi`, `unknown`, `visionos`, `vita`, `vxworks`, `wasi`, `watchos`, `windows`, `xous`, `zkvm`
+ = note: expected values for `target_os` are: `aix`, `android`, `cuda`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `macos`, `netbsd`, `none`, `nto`, `openbsd`, `psp`, `redox`, `solaris`, `solid_asp3`, `teeos`, `tvos`, `uefi`, `unknown`, `visionos`, `vita`, `vxworks`, `wasi`, `watchos`, `windows`, `xous`, and `zkvm`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -210,7 +210,7 @@
LL | target_pointer_width = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_pointer_width` are: `16`, `32`, `64`
+ = note: expected values for `target_pointer_width` are: `16`, `32`, and `64`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -230,7 +230,7 @@
LL | target_vendor = "_UNEXPECTED_VALUE",
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
- = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, `wrs`
+ = note: expected values for `target_vendor` are: `apple`, `espressif`, `fortanix`, `ibm`, `kmc`, `nintendo`, `nvidia`, `pc`, `risc0`, `sony`, `sun`, `unikraft`, `unknown`, `uwp`, `win7`, and `wrs`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: unexpected `cfg` condition value: `_UNEXPECTED_VALUE`
@@ -285,7 +285,7 @@
| |
| help: there is a expected value with a similar name: `"linux"`
|
- = note: expected values for `target_os` are: `aix`, `android`, `cuda`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `macos`, `netbsd`, `none`, `nto`, `openbsd`, `psp`, `redox`, `solaris`, `solid_asp3`, `teeos`, `tvos`, `uefi`, `unknown`, `visionos`, `vita`, `vxworks`, `wasi`, `watchos`, `windows`, `xous`, `zkvm`
+ = note: expected values for `target_os` are: `aix`, `android`, `cuda`, `dragonfly`, `emscripten`, `espidf`, `freebsd`, `fuchsia`, `haiku`, `hermit`, `horizon`, `hurd`, `illumos`, `ios`, `l4re`, `linux`, `macos`, `netbsd`, `none`, `nto`, `openbsd`, `psp`, `redox`, `solaris`, `solid_asp3`, `teeos`, `tvos`, `uefi`, `unknown`, `visionos`, `vita`, `vxworks`, `wasi`, `watchos`, `windows`, `xous`, and `zkvm`
= note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg.html> for more information about checking conditional configuration
warning: 29 warnings emitted
diff --git a/tests/ui/const-ptr/forbidden_slices.rs b/tests/ui/const-ptr/forbidden_slices.rs
index 85baeed..2550a3a 100644
--- a/tests/ui/const-ptr/forbidden_slices.rs
+++ b/tests/ui/const-ptr/forbidden_slices.rs
@@ -12,7 +12,7 @@
slice::{from_ptr_range, from_raw_parts},
};
-// Null is never valid for reads
+// Null is never valid for references
pub static S0: &[u32] = unsafe { from_raw_parts(ptr::null(), 0) };
//~^ ERROR: it is undefined behavior to use this value
pub static S1: &[()] = unsafe { from_raw_parts(ptr::null(), 0) };
@@ -46,10 +46,11 @@
};
pub static R0: &[u32] = unsafe { from_ptr_range(ptr::null()..ptr::null()) };
-pub static R1: &[()] = unsafe { from_ptr_range(ptr::null()..ptr::null()) };
+//~^ ERROR it is undefined behavior to use this value
+pub static R1: &[()] = unsafe { from_ptr_range(ptr::null()..ptr::null()) }; // errors inside libcore
pub static R2: &[u32] = unsafe {
let ptr = &D0 as *const u32;
- from_ptr_range(ptr..ptr.add(2))
+ from_ptr_range(ptr..ptr.add(2)) // errors inside libcore
};
pub static R4: &[u8] = unsafe {
//~^ ERROR: it is undefined behavior to use this value
diff --git a/tests/ui/const-ptr/forbidden_slices.stderr b/tests/ui/const-ptr/forbidden_slices.stderr
index 250366d..eb41a25 100644
--- a/tests/ui/const-ptr/forbidden_slices.stderr
+++ b/tests/ui/const-ptr/forbidden_slices.stderr
@@ -88,20 +88,16 @@
HEX_DUMP
}
-error[E0080]: could not evaluate static initializer
- --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
- |
- = note: out-of-bounds `offset_from`: null pointer is a dangling pointer (it has no provenance)
- |
-note: inside `std::ptr::const_ptr::<impl *const u32>::sub_ptr`
- --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `from_ptr_range::<'_, u32>`
- --> $SRC_DIR/core/src/slice/raw.rs:LL:COL
-note: inside `R0`
- --> $DIR/forbidden_slices.rs:48:34
+error[E0080]: it is undefined behavior to use this value
+ --> $DIR/forbidden_slices.rs:48:1
|
LL | pub static R0: &[u32] = unsafe { from_ptr_range(ptr::null()..ptr::null()) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ | ^^^^^^^^^^^^^^^^^^^^^ constructing invalid value: encountered a null reference
+ |
+ = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
+ = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
+ HEX_DUMP
+ }
error[E0080]: could not evaluate static initializer
--> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
@@ -113,9 +109,9 @@
note: inside `from_ptr_range::<'_, ()>`
--> $SRC_DIR/core/src/slice/raw.rs:LL:COL
note: inside `R1`
- --> $DIR/forbidden_slices.rs:49:33
+ --> $DIR/forbidden_slices.rs:50:33
|
-LL | pub static R1: &[()] = unsafe { from_ptr_range(ptr::null()..ptr::null()) };
+LL | pub static R1: &[()] = unsafe { from_ptr_range(ptr::null()..ptr::null()) }; // errors inside libcore
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
@@ -127,13 +123,13 @@
note: inside `std::ptr::const_ptr::<impl *const u32>::add`
--> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
note: inside `R2`
- --> $DIR/forbidden_slices.rs:52:25
+ --> $DIR/forbidden_slices.rs:53:25
|
-LL | from_ptr_range(ptr..ptr.add(2))
+LL | from_ptr_range(ptr..ptr.add(2)) // errors inside libcore
| ^^^^^^^^^^
error[E0080]: it is undefined behavior to use this value
- --> $DIR/forbidden_slices.rs:54:1
+ --> $DIR/forbidden_slices.rs:55:1
|
LL | pub static R4: &[u8] = unsafe {
| ^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<deref>[0]: encountered uninitialized memory, but expected an integer
@@ -144,7 +140,7 @@
}
error[E0080]: it is undefined behavior to use this value
- --> $DIR/forbidden_slices.rs:59:1
+ --> $DIR/forbidden_slices.rs:60:1
|
LL | pub static R5: &[u8] = unsafe {
| ^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<deref>[0]: encountered a pointer, but expected an integer
@@ -157,7 +153,7 @@
= help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
error[E0080]: it is undefined behavior to use this value
- --> $DIR/forbidden_slices.rs:64:1
+ --> $DIR/forbidden_slices.rs:65:1
|
LL | pub static R6: &[bool] = unsafe {
| ^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<deref>[0]: encountered 0x11, but expected a boolean
@@ -168,7 +164,7 @@
}
error[E0080]: it is undefined behavior to use this value
- --> $DIR/forbidden_slices.rs:69:1
+ --> $DIR/forbidden_slices.rs:70:1
|
LL | pub static R7: &[u16] = unsafe {
| ^^^^^^^^^^^^^^^^^^^^^ constructing invalid value: encountered an unaligned reference (required 2 byte alignment but found 1)
@@ -186,7 +182,7 @@
note: inside `std::ptr::const_ptr::<impl *const u64>::add`
--> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
note: inside `R8`
- --> $DIR/forbidden_slices.rs:76:25
+ --> $DIR/forbidden_slices.rs:77:25
|
LL | from_ptr_range(ptr..ptr.add(1))
| ^^^^^^^^^^
@@ -201,7 +197,7 @@
note: inside `from_ptr_range::<'_, u32>`
--> $SRC_DIR/core/src/slice/raw.rs:LL:COL
note: inside `R9`
- --> $DIR/forbidden_slices.rs:81:34
+ --> $DIR/forbidden_slices.rs:82:34
|
LL | pub static R9: &[u32] = unsafe { from_ptr_range(&D0..(&D0 as *const u32).add(1)) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -216,7 +212,7 @@
note: inside `from_ptr_range::<'_, u32>`
--> $SRC_DIR/core/src/slice/raw.rs:LL:COL
note: inside `R10`
- --> $DIR/forbidden_slices.rs:82:35
+ --> $DIR/forbidden_slices.rs:83:35
|
LL | pub static R10: &[u32] = unsafe { from_ptr_range(&D0..&D0) };
| ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/consts/const-compare-bytes-ub.rs b/tests/ui/consts/const-compare-bytes-ub.rs
index b357bab..903ba15 100644
--- a/tests/ui/consts/const-compare-bytes-ub.rs
+++ b/tests/ui/consts/const-compare-bytes-ub.rs
@@ -7,11 +7,11 @@
fn main() {
const LHS_NULL: i32 = unsafe {
- compare_bytes(0 as *const u8, 2 as *const u8, 0)
+ compare_bytes(0 as *const u8, 2 as *const u8, 1)
//~^ ERROR evaluation of constant value failed
};
const RHS_NULL: i32 = unsafe {
- compare_bytes(1 as *const u8, 0 as *const u8, 0)
+ compare_bytes(1 as *const u8, 0 as *const u8, 1)
//~^ ERROR evaluation of constant value failed
};
const DANGLING_PTR_NON_ZERO_LENGTH: i32 = unsafe {
diff --git a/tests/ui/consts/const-compare-bytes-ub.stderr b/tests/ui/consts/const-compare-bytes-ub.stderr
index d8971eb..9e49706 100644
--- a/tests/ui/consts/const-compare-bytes-ub.stderr
+++ b/tests/ui/consts/const-compare-bytes-ub.stderr
@@ -1,14 +1,14 @@
error[E0080]: evaluation of constant value failed
--> $DIR/const-compare-bytes-ub.rs:10:9
|
-LL | compare_bytes(0 as *const u8, 2 as *const u8, 0)
+LL | compare_bytes(0 as *const u8, 2 as *const u8, 1)
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: null pointer is a dangling pointer (it has no provenance)
error[E0080]: evaluation of constant value failed
--> $DIR/const-compare-bytes-ub.rs:14:9
|
-LL | compare_bytes(1 as *const u8, 0 as *const u8, 0)
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: null pointer is a dangling pointer (it has no provenance)
+LL | compare_bytes(1 as *const u8, 0 as *const u8, 1)
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: 0x1[noalloc] is a dangling pointer (it has no provenance)
error[E0080]: evaluation of constant value failed
--> $DIR/const-compare-bytes-ub.rs:18:9
diff --git a/tests/ui/consts/copy-intrinsic.rs b/tests/ui/consts/copy-intrinsic.rs
index 94d7bdc..4183dc0 100644
--- a/tests/ui/consts/copy-intrinsic.rs
+++ b/tests/ui/consts/copy-intrinsic.rs
@@ -23,16 +23,20 @@
const COPY_OOB_1: () = unsafe {
let mut x = 0i32;
let dangle = (&mut x as *mut i32).wrapping_add(10);
- // Even if the first ptr is an int ptr and this is a ZST copy, we should detect dangling 2nd ptrs.
- copy_nonoverlapping(0x100 as *const i32, dangle, 0); //~ ERROR evaluation of constant value failed [E0080]
- //~| pointer at offset 40 is out-of-bounds
+ // Zero-sized copy is fine.
+ copy_nonoverlapping(0x100 as *const i32, dangle, 0);
+ // Non-zero-sized copy is not.
+ copy_nonoverlapping(0x100 as *const i32, dangle, 1); //~ ERROR evaluation of constant value failed [E0080]
+ //~| 0x100[noalloc] is a dangling pointer
};
const COPY_OOB_2: () = unsafe {
let x = 0i32;
let dangle = (&x as *const i32).wrapping_add(10);
- // Even if the second ptr is an int ptr and this is a ZST copy, we should detect dangling 1st ptrs.
- copy_nonoverlapping(dangle, 0x100 as *mut i32, 0); //~ ERROR evaluation of constant value failed [E0080]
- //~| pointer at offset 40 is out-of-bounds
+ // Zero-sized copy is fine.
+ copy_nonoverlapping(dangle, 0x100 as *mut i32, 0);
+ // Non-zero-sized copy is not.
+ copy_nonoverlapping(dangle, 0x100 as *mut i32, 1); //~ ERROR evaluation of constant value failed [E0080]
+ //~| offset 40 is out-of-bounds
};
const COPY_SIZE_OVERFLOW: () = unsafe {
diff --git a/tests/ui/consts/copy-intrinsic.stderr b/tests/ui/consts/copy-intrinsic.stderr
index 0e4e6a6..d34e61c 100644
--- a/tests/ui/consts/copy-intrinsic.stderr
+++ b/tests/ui/consts/copy-intrinsic.stderr
@@ -1,23 +1,23 @@
error[E0080]: evaluation of constant value failed
- --> $DIR/copy-intrinsic.rs:27:5
+ --> $DIR/copy-intrinsic.rs:29:5
|
-LL | copy_nonoverlapping(0x100 as *const i32, dangle, 0);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: ALLOC0 has size 4, so pointer at offset 40 is out-of-bounds
+LL | copy_nonoverlapping(0x100 as *const i32, dangle, 1);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: 0x100[noalloc] is a dangling pointer (it has no provenance)
error[E0080]: evaluation of constant value failed
- --> $DIR/copy-intrinsic.rs:34:5
+ --> $DIR/copy-intrinsic.rs:38:5
|
-LL | copy_nonoverlapping(dangle, 0x100 as *mut i32, 0);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: ALLOC1 has size 4, so pointer at offset 40 is out-of-bounds
+LL | copy_nonoverlapping(dangle, 0x100 as *mut i32, 1);
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: ALLOC0 has size 4, so pointer to 4 bytes starting at offset 40 is out-of-bounds
error[E0080]: evaluation of constant value failed
- --> $DIR/copy-intrinsic.rs:41:5
+ --> $DIR/copy-intrinsic.rs:45:5
|
LL | copy(&x, &mut y, 1usize << (mem::size_of::<usize>() * 8 - 1));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ overflow computing total size of `copy`
error[E0080]: evaluation of constant value failed
- --> $DIR/copy-intrinsic.rs:47:5
+ --> $DIR/copy-intrinsic.rs:51:5
|
LL | copy_nonoverlapping(&x, &mut y, 1usize << (mem::size_of::<usize>() * 8 - 1));
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ overflow computing total size of `copy_nonoverlapping`
diff --git a/tests/ui/consts/dangling-alloc-id-ice.rs b/tests/ui/consts/dangling-alloc-id-ice.rs
index 76d6f33..6b07b8b 100644
--- a/tests/ui/consts/dangling-alloc-id-ice.rs
+++ b/tests/ui/consts/dangling-alloc-id-ice.rs
@@ -10,7 +10,7 @@
}
const FOO: &() = {
- //~^ ERROR it is undefined behavior to use this value
+ //~^ ERROR encountered dangling pointer
let y = ();
unsafe { Foo { y: &y }.long_live_the_unit }
};
diff --git a/tests/ui/consts/dangling-alloc-id-ice.stderr b/tests/ui/consts/dangling-alloc-id-ice.stderr
index 881c0b1..de31acf 100644
--- a/tests/ui/consts/dangling-alloc-id-ice.stderr
+++ b/tests/ui/consts/dangling-alloc-id-ice.stderr
@@ -1,14 +1,8 @@
-error[E0080]: it is undefined behavior to use this value
+error: encountered dangling pointer in final value of constant
--> $DIR/dangling-alloc-id-ice.rs:12:1
|
LL | const FOO: &() = {
- | ^^^^^^^^^^^^^^ constructing invalid value: encountered a dangling reference (use-after-free)
- |
- = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior.
- = note: the raw bytes of the constant (size: $SIZE, align: $ALIGN) {
- HEX_DUMP
- }
+ | ^^^^^^^^^^^^^^
error: aborting due to 1 previous error
-For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/offset_from_ub.rs b/tests/ui/consts/offset_from_ub.rs
index e0dd270..57767e9 100644
--- a/tests/ui/consts/offset_from_ub.rs
+++ b/tests/ui/consts/offset_from_ub.rs
@@ -34,8 +34,8 @@
pub const OFFSET_FROM_NULL: isize = {
let ptr = 0 as *const u8;
- unsafe { ptr_offset_from(ptr, ptr) } //~ERROR evaluation of constant value failed
- //~| null pointer is a dangling pointer
+ // Null isn't special for zero-sized "accesses" (i.e., the range between the two pointers)
+ unsafe { ptr_offset_from(ptr, ptr) }
};
pub const DIFFERENT_INT: isize = { // offset_from with two different integers: like DIFFERENT_ALLOC
@@ -67,8 +67,8 @@
let start_ptr = &4 as *const _ as *const u8;
let length = 10;
let end_ptr = (start_ptr).wrapping_add(length);
- unsafe { ptr_offset_from(end_ptr, end_ptr) } //~ERROR evaluation of constant value failed
- //~| pointer at offset 10 is out-of-bounds
+ // Out-of-bounds is fine as long as the range between the pointers is empty.
+ unsafe { ptr_offset_from(end_ptr, end_ptr) }
};
pub const DIFFERENT_ALLOC_UNSIGNED: usize = {
diff --git a/tests/ui/consts/offset_from_ub.stderr b/tests/ui/consts/offset_from_ub.stderr
index e3bac8d..65f75a6 100644
--- a/tests/ui/consts/offset_from_ub.stderr
+++ b/tests/ui/consts/offset_from_ub.stderr
@@ -24,12 +24,6 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ exact_div: 1_isize cannot be divided by 2_isize without remainder
error[E0080]: evaluation of constant value failed
- --> $DIR/offset_from_ub.rs:37:14
- |
-LL | unsafe { ptr_offset_from(ptr, ptr) }
- | ^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds `offset_from`: null pointer is a dangling pointer (it has no provenance)
-
-error[E0080]: evaluation of constant value failed
--> $DIR/offset_from_ub.rs:44:14
|
LL | unsafe { ptr_offset_from(ptr2, ptr1) }
@@ -48,12 +42,6 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds `offset_from`: ALLOC1 has size 4, so pointer to 10 bytes starting at offset 0 is out-of-bounds
error[E0080]: evaluation of constant value failed
- --> $DIR/offset_from_ub.rs:70:14
- |
-LL | unsafe { ptr_offset_from(end_ptr, end_ptr) }
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds `offset_from`: ALLOC2 has size 4, so pointer at offset 10 is out-of-bounds
-
-error[E0080]: evaluation of constant value failed
--> $DIR/offset_from_ub.rs:79:14
|
LL | unsafe { ptr_offset_from_unsigned(field_ptr, base_ptr) }
@@ -109,6 +97,6 @@
LL | unsafe { ptr1.offset_from(ptr2.wrapping_offset(1)) }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-error: aborting due to 15 previous errors
+error: aborting due to 13 previous errors
For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/consts/offset_ub.rs b/tests/ui/consts/offset_ub.rs
index 920ecb6..36e4ff1 100644
--- a/tests/ui/consts/offset_ub.rs
+++ b/tests/ui/consts/offset_ub.rs
@@ -17,10 +17,10 @@
pub const ZERO_SIZED_ALLOC: *const u8 = unsafe { [0u8; 0].as_ptr().offset(1) }; //~NOTE
pub const DANGLING: *const u8 = unsafe { ptr::NonNull::<u8>::dangling().as_ptr().offset(4) }; //~NOTE
-// Right now, a zero offset from null is UB
-pub const NULL_OFFSET_ZERO: *const u8 = unsafe { ptr::null::<u8>().offset(0) }; //~NOTE
-
// Make sure that we don't panic when computing abs(offset*size_of::<T>())
pub const UNDERFLOW_ABS: *const u8 = unsafe { (usize::MAX as *const u8).offset(isize::MIN) }; //~NOTE
+// Offset-by-zero is allowed.
+pub const NULL_OFFSET_ZERO: *const u8 = unsafe { ptr::null::<u8>().offset(0) };
+
fn main() {}
diff --git a/tests/ui/consts/offset_ub.stderr b/tests/ui/consts/offset_ub.stderr
index b398b20..89371f0 100644
--- a/tests/ui/consts/offset_ub.stderr
+++ b/tests/ui/consts/offset_ub.stderr
@@ -131,29 +131,16 @@
error[E0080]: evaluation of constant value failed
--> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
|
- = note: out-of-bounds pointer arithmetic: null pointer is a dangling pointer (it has no provenance)
- |
-note: inside `std::ptr::const_ptr::<impl *const u8>::offset`
- --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `NULL_OFFSET_ZERO`
- --> $DIR/offset_ub.rs:21:50
- |
-LL | pub const NULL_OFFSET_ZERO: *const u8 = unsafe { ptr::null::<u8>().offset(0) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
- --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
- |
= note: out-of-bounds pointer arithmetic: 0x7f..f[noalloc] is a dangling pointer (it has no provenance)
|
note: inside `std::ptr::const_ptr::<impl *const u8>::offset`
--> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
note: inside `UNDERFLOW_ABS`
- --> $DIR/offset_ub.rs:24:47
+ --> $DIR/offset_ub.rs:21:47
|
LL | pub const UNDERFLOW_ABS: *const u8 = unsafe { (usize::MAX as *const u8).offset(isize::MIN) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-error: aborting due to 12 previous errors
+error: aborting due to 11 previous errors
For more information about this error, try `rustc --explain E0080`.
diff --git a/tests/ui/diagnostic_namespace/do_not_recommend/as_expression.rs b/tests/ui/diagnostic_namespace/do_not_recommend/as_expression.rs
index 9cdc193..5fd5cc5 100644
--- a/tests/ui/diagnostic_namespace/do_not_recommend/as_expression.rs
+++ b/tests/ui/diagnostic_namespace/do_not_recommend/as_expression.rs
@@ -26,7 +26,7 @@
type SqlType = T;
}
-#[do_not_recommend]
+#[diagnostic::do_not_recommend]
impl<T, ST> AsExpression<ST> for T
where
T: Expression<SqlType = ST>,
diff --git a/tests/ui/diagnostic_namespace/do_not_recommend/feature-gate-do_not_recommend.rs b/tests/ui/diagnostic_namespace/do_not_recommend/feature-gate-do_not_recommend.rs
new file mode 100644
index 0000000..5a26d28
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/do_not_recommend/feature-gate-do_not_recommend.rs
@@ -0,0 +1,17 @@
+#![feature(do_not_recommend)]
+
+pub trait Foo {}
+
+impl Foo for i32 {}
+
+pub trait Bar {}
+
+#[diagnostic::do_not_recommend]
+impl<T: Foo> Bar for T {}
+
+fn stuff<T: Bar>(_: T) {}
+
+fn main() {
+ stuff(1u8);
+ //~^ the trait bound `u8: Bar` is not satisfied
+}
diff --git a/tests/ui/rfcs/rfc-2397-do-not-recommend/feature-gate-do_not_recommend.stderr b/tests/ui/diagnostic_namespace/do_not_recommend/feature-gate-do_not_recommend.stderr
similarity index 79%
rename from tests/ui/rfcs/rfc-2397-do-not-recommend/feature-gate-do_not_recommend.stderr
rename to tests/ui/diagnostic_namespace/do_not_recommend/feature-gate-do_not_recommend.stderr
index e6f1994..3951231 100644
--- a/tests/ui/rfcs/rfc-2397-do-not-recommend/feature-gate-do_not_recommend.stderr
+++ b/tests/ui/diagnostic_namespace/do_not_recommend/feature-gate-do_not_recommend.stderr
@@ -1,11 +1,11 @@
error[E0277]: the trait bound `u8: Bar` is not satisfied
- --> $DIR/feature-gate-do_not_recommend.rs:19:11
+ --> $DIR/feature-gate-do_not_recommend.rs:15:11
|
LL | stuff(1u8);
| ^^^ the trait `Bar` is not implemented for `u8`
|
note: required by a bound in `stuff`
- --> $DIR/feature-gate-do_not_recommend.rs:16:13
+ --> $DIR/feature-gate-do_not_recommend.rs:12:13
|
LL | fn stuff<T: Bar>(_: T) {}
| ^^^ required by this bound in `stuff`
diff --git a/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.rs b/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.rs
new file mode 100644
index 0000000..400ef83
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.rs
@@ -0,0 +1,39 @@
+//@ check-pass
+#![feature(do_not_recommend)]
+
+#[diagnostic::do_not_recommend]
+//~^WARN `#[diagnostic::do_not_recommend]` can only be placed
+const CONST: () = ();
+
+#[diagnostic::do_not_recommend]
+//~^WARN `#[diagnostic::do_not_recommend]` can only be placed
+static STATIC: () = ();
+
+#[diagnostic::do_not_recommend]
+//~^WARN `#[diagnostic::do_not_recommend]` can only be placed
+type Type = ();
+
+#[diagnostic::do_not_recommend]
+//~^WARN `#[diagnostic::do_not_recommend]` can only be placed
+enum Enum {}
+
+#[diagnostic::do_not_recommend]
+//~^WARN `#[diagnostic::do_not_recommend]` can only be placed
+extern "C" {}
+
+#[diagnostic::do_not_recommend]
+//~^WARN `#[diagnostic::do_not_recommend]` can only be placed
+fn fun() {}
+
+#[diagnostic::do_not_recommend]
+//~^WARN `#[diagnostic::do_not_recommend]` can only be placed
+struct Struct {}
+
+#[diagnostic::do_not_recommend]
+//~^WARN `#[diagnostic::do_not_recommend]` can only be placed
+trait Trait {}
+
+#[diagnostic::do_not_recommend]
+impl Trait for i32 {}
+
+fn main() {}
diff --git a/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.stderr b/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.stderr
new file mode 100644
index 0000000..c83fd46
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/do_not_recommend/incorrect-locations.stderr
@@ -0,0 +1,52 @@
+warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
+ --> $DIR/incorrect-locations.rs:4:1
+ |
+LL | #[diagnostic::do_not_recommend]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+ = note: `#[warn(unknown_or_malformed_diagnostic_attributes)]` on by default
+
+warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
+ --> $DIR/incorrect-locations.rs:8:1
+ |
+LL | #[diagnostic::do_not_recommend]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
+ --> $DIR/incorrect-locations.rs:12:1
+ |
+LL | #[diagnostic::do_not_recommend]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
+ --> $DIR/incorrect-locations.rs:16:1
+ |
+LL | #[diagnostic::do_not_recommend]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
+ --> $DIR/incorrect-locations.rs:20:1
+ |
+LL | #[diagnostic::do_not_recommend]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
+ --> $DIR/incorrect-locations.rs:24:1
+ |
+LL | #[diagnostic::do_not_recommend]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
+ --> $DIR/incorrect-locations.rs:28:1
+ |
+LL | #[diagnostic::do_not_recommend]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
+ --> $DIR/incorrect-locations.rs:32:1
+ |
+LL | #[diagnostic::do_not_recommend]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: 8 warnings emitted
+
diff --git a/tests/ui/diagnostic_namespace/do_not_recommend/simple.rs b/tests/ui/diagnostic_namespace/do_not_recommend/simple.rs
index 6fb15b9..780649b 100644
--- a/tests/ui/diagnostic_namespace/do_not_recommend/simple.rs
+++ b/tests/ui/diagnostic_namespace/do_not_recommend/simple.rs
@@ -6,7 +6,7 @@
trait Foo {}
-#[do_not_recommend]
+#[diagnostic::do_not_recommend]
impl<T> Foo for T where T: Send {}
fn needs_foo<T: Foo>() {}
diff --git a/tests/ui/diagnostic_namespace/do_not_recommend/stacked.rs b/tests/ui/diagnostic_namespace/do_not_recommend/stacked.rs
index 695660d..fc355bd 100644
--- a/tests/ui/diagnostic_namespace/do_not_recommend/stacked.rs
+++ b/tests/ui/diagnostic_namespace/do_not_recommend/stacked.rs
@@ -8,7 +8,7 @@
trait DontRecommend {}
trait Other {}
-#[do_not_recommend]
+#[diagnostic::do_not_recommend]
impl<T> Root for T where T: DontRecommend {}
impl<T> DontRecommend for T where T: Other {}
diff --git a/tests/ui/diagnostic_namespace/do_not_recommend/unstable-feature.rs b/tests/ui/diagnostic_namespace/do_not_recommend/unstable-feature.rs
new file mode 100644
index 0000000..ccc687a
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/do_not_recommend/unstable-feature.rs
@@ -0,0 +1,8 @@
+#![deny(unknown_or_malformed_diagnostic_attributes)]
+trait Foo {}
+
+#[diagnostic::do_not_recommend]
+//~^ ERROR unknown diagnostic attribute [unknown_or_malformed_diagnostic_attributes]
+impl Foo for i32 {}
+
+fn main() {}
diff --git a/tests/ui/diagnostic_namespace/do_not_recommend/unstable-feature.stderr b/tests/ui/diagnostic_namespace/do_not_recommend/unstable-feature.stderr
new file mode 100644
index 0000000..d833222
--- /dev/null
+++ b/tests/ui/diagnostic_namespace/do_not_recommend/unstable-feature.stderr
@@ -0,0 +1,14 @@
+error: unknown diagnostic attribute
+ --> $DIR/unstable-feature.rs:4:15
+ |
+LL | #[diagnostic::do_not_recommend]
+ | ^^^^^^^^^^^^^^^^
+ |
+note: the lint level is defined here
+ --> $DIR/unstable-feature.rs:1:9
+ |
+LL | #![deny(unknown_or_malformed_diagnostic_attributes)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.rs b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.rs
index bd3b69c..ca60bc6 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.rs
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.rs
@@ -45,7 +45,7 @@
//~| NOTE not a function or closure
#[inline = "2100"] fn f() { }
- //~^ ERROR attribute must be of the form
+ //~^ ERROR valid forms for the attribute are
//~| WARN this was previously accepted
//~| NOTE #[deny(ill_formed_attribute_input)]` on by default
//~| NOTE for more information, see issue #57571 <https://github.com/rust-lang/rust/issues/57571>
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
index 89fa2ab..ac2bf78 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
@@ -7,7 +7,7 @@
= help: add `#![feature(rustc_attrs)]` to the crate attributes to enable
= note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-error: attribute must be of the form `#[inline]` or `#[inline(always|never)]`
+error: valid forms for the attribute are `#[inline]` and `#[inline(always|never)]`
--> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:47:5
|
LL | #[inline = "2100"] fn f() { }
diff --git a/tests/ui/lint/anonymous-reexport.stderr b/tests/ui/lint/anonymous-reexport.stderr
index e3854a5..c4ee18f 100644
--- a/tests/ui/lint/anonymous-reexport.stderr
+++ b/tests/ui/lint/anonymous-reexport.stderr
@@ -34,7 +34,7 @@
LL | pub use self::my_mod::{Bar as _, Foo as _};
| ^^^^^^^^
-error: unused imports: `Bar as _`, `TyBar as _`
+error: unused imports: `Bar as _` and `TyBar as _`
--> $DIR/anonymous-reexport.rs:17:24
|
LL | pub use self::my_mod::{Bar as _, TyBar as _};
diff --git a/tests/ui/lint/unused/import_remove_line.stderr b/tests/ui/lint/unused/import_remove_line.stderr
index 0e8c5de..b2a1666 100644
--- a/tests/ui/lint/unused/import_remove_line.stderr
+++ b/tests/ui/lint/unused/import_remove_line.stderr
@@ -1,4 +1,4 @@
-warning: unused imports: `Duration`, `Instant`
+warning: unused imports: `Duration` and `Instant`
--> $DIR/import_remove_line.rs:7:17
|
LL | use std::time::{Duration, Instant};
diff --git a/tests/ui/lint/unused/lint-unused-imports.rs b/tests/ui/lint/unused/lint-unused-imports.rs
index 88f2baa..710fb7a 100644
--- a/tests/ui/lint/unused/lint-unused-imports.rs
+++ b/tests/ui/lint/unused/lint-unused-imports.rs
@@ -10,7 +10,7 @@
// Should get errors for both 'Some' and 'None'
use std::option::Option::{Some, None};
-//~^ ERROR unused imports: `None`, `Some`
+//~^ ERROR unused imports: `None` and `Some`
use test::A; //~ ERROR unused import: `test::A`
// Be sure that if we just bring some methods into scope that they're also
diff --git a/tests/ui/lint/unused/lint-unused-imports.stderr b/tests/ui/lint/unused/lint-unused-imports.stderr
index 07684a8..a848fb3 100644
--- a/tests/ui/lint/unused/lint-unused-imports.stderr
+++ b/tests/ui/lint/unused/lint-unused-imports.stderr
@@ -10,7 +10,7 @@
LL | #![deny(unused_imports)]
| ^^^^^^^^^^^^^^
-error: unused imports: `None`, `Some`
+error: unused imports: `None` and `Some`
--> $DIR/lint-unused-imports.rs:12:27
|
LL | use std::option::Option::{Some, None};
diff --git a/tests/ui/malformed/malformed-regressions.rs b/tests/ui/malformed/malformed-regressions.rs
index ac1444b..f0a7aac 100644
--- a/tests/ui/malformed/malformed-regressions.rs
+++ b/tests/ui/malformed/malformed-regressions.rs
@@ -1,8 +1,8 @@
-#[doc] //~ ERROR attribute must be of the form
+#[doc] //~ ERROR valid forms for the attribute are
//~^ WARN this was previously accepted
-#[ignore()] //~ ERROR attribute must be of the form
+#[ignore()] //~ ERROR valid forms for the attribute are
//~^ WARN this was previously accepted
-#[inline = ""] //~ ERROR attribute must be of the form
+#[inline = ""] //~ ERROR valid forms for the attribute are
//~^ WARN this was previously accepted
#[link] //~ ERROR attribute must be of the form
//~^ WARN this was previously accepted
diff --git a/tests/ui/malformed/malformed-regressions.stderr b/tests/ui/malformed/malformed-regressions.stderr
index 9bfbe7e..e1dbdb9 100644
--- a/tests/ui/malformed/malformed-regressions.stderr
+++ b/tests/ui/malformed/malformed-regressions.stderr
@@ -1,4 +1,4 @@
-error: attribute must be of the form `#[doc(hidden|inline|...)]` or `#[doc = "string"]`
+error: valid forms for the attribute are `#[doc(hidden|inline|...)]` and `#[doc = "string"]`
--> $DIR/malformed-regressions.rs:1:1
|
LL | #[doc]
@@ -8,7 +8,7 @@
= note: for more information, see issue #57571 <https://github.com/rust-lang/rust/issues/57571>
= note: `#[deny(ill_formed_attribute_input)]` on by default
-error: attribute must be of the form `#[ignore]` or `#[ignore = "reason"]`
+error: valid forms for the attribute are `#[ignore]` and `#[ignore = "reason"]`
--> $DIR/malformed-regressions.rs:3:1
|
LL | #[ignore()]
@@ -17,7 +17,7 @@
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
= note: for more information, see issue #57571 <https://github.com/rust-lang/rust/issues/57571>
-error: attribute must be of the form `#[inline]` or `#[inline(always|never)]`
+error: valid forms for the attribute are `#[inline]` and `#[inline(always|never)]`
--> $DIR/malformed-regressions.rs:5:1
|
LL | #[inline = ""]
diff --git a/tests/crashes/118185-2.rs b/tests/ui/mismatched_types/diagnostic-method-lookup-returns-sig-with-fewer-args.rs
similarity index 84%
rename from tests/crashes/118185-2.rs
rename to tests/ui/mismatched_types/diagnostic-method-lookup-returns-sig-with-fewer-args.rs
index c3a29c3..fd41bee 100644
--- a/tests/crashes/118185-2.rs
+++ b/tests/ui/mismatched_types/diagnostic-method-lookup-returns-sig-with-fewer-args.rs
@@ -1,9 +1,8 @@
-//@ known-bug: #118185
-
fn main() {
let target: Target = create_target();
target.get(0); // correct arguments work
- target.get(10.0); // CRASH HERE
+ target.get(10.0); // (used to crash here)
+ //~^ ERROR mismatched types
}
// must be generic
diff --git a/tests/ui/mismatched_types/diagnostic-method-lookup-returns-sig-with-fewer-args.stderr b/tests/ui/mismatched_types/diagnostic-method-lookup-returns-sig-with-fewer-args.stderr
new file mode 100644
index 0000000..0f86916
--- /dev/null
+++ b/tests/ui/mismatched_types/diagnostic-method-lookup-returns-sig-with-fewer-args.stderr
@@ -0,0 +1,17 @@
+error[E0308]: mismatched types
+ --> $DIR/diagnostic-method-lookup-returns-sig-with-fewer-args.rs:4:16
+ |
+LL | target.get(10.0); // (used to crash here)
+ | --- ^^^^ expected `i32`, found floating-point number
+ | |
+ | arguments to this method are incorrect
+ |
+note: method defined here
+ --> $DIR/diagnostic-method-lookup-returns-sig-with-fewer-args.rs:22:12
+ |
+LL | pub fn get(&self, data: i32) {
+ | ^^^ ---------
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/privacy/issue-46209-private-enum-variant-reexport.rs b/tests/ui/privacy/issue-46209-private-enum-variant-reexport.rs
index 653dcab..796ba4d 100644
--- a/tests/ui/privacy/issue-46209-private-enum-variant-reexport.rs
+++ b/tests/ui/privacy/issue-46209-private-enum-variant-reexport.rs
@@ -6,7 +6,7 @@
pub use self::Lieutenant::{JuniorGrade, Full};
//~^ ERROR `JuniorGrade` is private, and cannot be re-exported
//~| ERROR `Full` is private, and cannot be re-exported
- //~| ERROR unused imports: `Full`, `JuniorGrade`
+ //~| ERROR unused imports: `Full` and `JuniorGrade`
pub use self::PettyOfficer::*;
//~^ ERROR glob import doesn't reexport anything
//~| ERROR unused import: `self::PettyOfficer::*`
diff --git a/tests/ui/privacy/issue-46209-private-enum-variant-reexport.stderr b/tests/ui/privacy/issue-46209-private-enum-variant-reexport.stderr
index 93a39ed..f1701d5 100644
--- a/tests/ui/privacy/issue-46209-private-enum-variant-reexport.stderr
+++ b/tests/ui/privacy/issue-46209-private-enum-variant-reexport.stderr
@@ -46,7 +46,7 @@
LL | pub use self::Professor::*;
| ^^^^^^^^^^^^^^^^^^
-error: unused imports: `Full`, `JuniorGrade`
+error: unused imports: `Full` and `JuniorGrade`
--> $DIR/issue-46209-private-enum-variant-reexport.rs:6:32
|
LL | pub use self::Lieutenant::{JuniorGrade, Full};
diff --git a/tests/ui/rfcs/rfc-2397-do-not-recommend/feature-gate-do_not_recommend.rs b/tests/ui/rfcs/rfc-2397-do-not-recommend/feature-gate-do_not_recommend.rs
deleted file mode 100644
index c9dc1c6..0000000
--- a/tests/ui/rfcs/rfc-2397-do-not-recommend/feature-gate-do_not_recommend.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-#![feature(do_not_recommend)]
-
-pub trait Foo {
-}
-
-impl Foo for i32 {
-}
-
-pub trait Bar {
-}
-
-#[do_not_recommend]
-impl<T: Foo> Bar for T {
-}
-
-fn stuff<T: Bar>(_: T) {}
-
-fn main() {
- stuff(1u8);
- //~^ the trait bound `u8: Bar` is not satisfied
-}
diff --git a/tests/ui/rfcs/rfc-2397-do-not-recommend/incorrect-locations.rs b/tests/ui/rfcs/rfc-2397-do-not-recommend/incorrect-locations.rs
deleted file mode 100644
index 91863f5..0000000
--- a/tests/ui/rfcs/rfc-2397-do-not-recommend/incorrect-locations.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-#![feature(do_not_recommend)]
-
-#[do_not_recommend]
-//~^ `#[do_not_recommend]` can only be placed
-const CONST: () = ();
-
-#[do_not_recommend]
-//~^ `#[do_not_recommend]` can only be placed
-static Static: () = ();
-
-#[do_not_recommend]
-//~^ `#[do_not_recommend]` can only be placed
-type Type = ();
-
-#[do_not_recommend]
-//~^ `#[do_not_recommend]` can only be placed
-enum Enum {
-}
-
-#[do_not_recommend]
-//~^ `#[do_not_recommend]` can only be placed
-extern {
-}
-
-#[do_not_recommend]
-//~^ `#[do_not_recommend]` can only be placed
-fn fun() {
-}
-
-#[do_not_recommend]
-//~^ `#[do_not_recommend]` can only be placed
-struct Struct {
-}
-
-#[do_not_recommend]
-//~^ `#[do_not_recommend]` can only be placed
-trait Trait {
-}
-
-#[do_not_recommend]
-impl Trait for i32 {
-}
-
-fn main() {
-}
diff --git a/tests/ui/rfcs/rfc-2397-do-not-recommend/incorrect-locations.stderr b/tests/ui/rfcs/rfc-2397-do-not-recommend/incorrect-locations.stderr
deleted file mode 100644
index 01ebc23..0000000
--- a/tests/ui/rfcs/rfc-2397-do-not-recommend/incorrect-locations.stderr
+++ /dev/null
@@ -1,50 +0,0 @@
-error: `#[do_not_recommend]` can only be placed on trait implementations
- --> $DIR/incorrect-locations.rs:3:1
- |
-LL | #[do_not_recommend]
- | ^^^^^^^^^^^^^^^^^^^
-
-error: `#[do_not_recommend]` can only be placed on trait implementations
- --> $DIR/incorrect-locations.rs:7:1
- |
-LL | #[do_not_recommend]
- | ^^^^^^^^^^^^^^^^^^^
-
-error: `#[do_not_recommend]` can only be placed on trait implementations
- --> $DIR/incorrect-locations.rs:11:1
- |
-LL | #[do_not_recommend]
- | ^^^^^^^^^^^^^^^^^^^
-
-error: `#[do_not_recommend]` can only be placed on trait implementations
- --> $DIR/incorrect-locations.rs:15:1
- |
-LL | #[do_not_recommend]
- | ^^^^^^^^^^^^^^^^^^^
-
-error: `#[do_not_recommend]` can only be placed on trait implementations
- --> $DIR/incorrect-locations.rs:20:1
- |
-LL | #[do_not_recommend]
- | ^^^^^^^^^^^^^^^^^^^
-
-error: `#[do_not_recommend]` can only be placed on trait implementations
- --> $DIR/incorrect-locations.rs:25:1
- |
-LL | #[do_not_recommend]
- | ^^^^^^^^^^^^^^^^^^^
-
-error: `#[do_not_recommend]` can only be placed on trait implementations
- --> $DIR/incorrect-locations.rs:30:1
- |
-LL | #[do_not_recommend]
- | ^^^^^^^^^^^^^^^^^^^
-
-error: `#[do_not_recommend]` can only be placed on trait implementations
- --> $DIR/incorrect-locations.rs:35:1
- |
-LL | #[do_not_recommend]
- | ^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 8 previous errors
-
diff --git a/tests/ui/rfcs/rfc-2397-do-not-recommend/unstable-feature.rs b/tests/ui/rfcs/rfc-2397-do-not-recommend/unstable-feature.rs
deleted file mode 100644
index f0c5c22..0000000
--- a/tests/ui/rfcs/rfc-2397-do-not-recommend/unstable-feature.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-trait Foo {
-}
-
-#[do_not_recommend]
-//~^ ERROR the `#[do_not_recommend]` attribute is an experimental feature
-impl Foo for i32 {
-}
-
-fn main() {
-}
diff --git a/tests/ui/rfcs/rfc-2397-do-not-recommend/unstable-feature.stderr b/tests/ui/rfcs/rfc-2397-do-not-recommend/unstable-feature.stderr
deleted file mode 100644
index 02bc51c..0000000
--- a/tests/ui/rfcs/rfc-2397-do-not-recommend/unstable-feature.stderr
+++ /dev/null
@@ -1,13 +0,0 @@
-error[E0658]: the `#[do_not_recommend]` attribute is an experimental feature
- --> $DIR/unstable-feature.rs:4:1
- |
-LL | #[do_not_recommend]
- | ^^^^^^^^^^^^^^^^^^^
- |
- = note: see issue #51992 <https://github.com/rust-lang/rust/issues/51992> for more information
- = help: add `#![feature(do_not_recommend)]` to the crate attributes to enable
- = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/span/multispan-import-lint.stderr b/tests/ui/span/multispan-import-lint.stderr
index 4a955d1..a4ea1af 100644
--- a/tests/ui/span/multispan-import-lint.stderr
+++ b/tests/ui/span/multispan-import-lint.stderr
@@ -1,4 +1,4 @@
-warning: unused imports: `Eq`, `Ord`, `PartialEq`, `PartialOrd`
+warning: unused imports: `Eq`, `Ord`, `PartialEq`, and `PartialOrd`
--> $DIR/multispan-import-lint.rs:5:16
|
LL | use std::cmp::{Eq, Ord, min, PartialEq, PartialOrd};
diff --git a/tests/ui/suggestions/unused-imports.stderr b/tests/ui/suggestions/unused-imports.stderr
index bf11260..31edb4e 100644
--- a/tests/ui/suggestions/unused-imports.stderr
+++ b/tests/ui/suggestions/unused-imports.stderr
@@ -1,4 +1,4 @@
-warning: unused imports: `A`, `C`
+warning: unused imports: `A` and `C`
--> $DIR/unused-imports.rs:22:14
|
LL | use nested::{A, B, C};
@@ -10,7 +10,7 @@
LL | #![warn(unused_imports)]
| ^^^^^^^^^^^^^^
-warning: unused imports: `D`, `E`, `G`
+warning: unused imports: `D`, `E`, and `G`
--> $DIR/unused-imports.rs:26:5
|
LL | D,
diff --git a/tests/ui/use/use-nested-groups-unused-imports.rs b/tests/ui/use/use-nested-groups-unused-imports.rs
index ca6b8ba..0c8ae55 100644
--- a/tests/ui/use/use-nested-groups-unused-imports.rs
+++ b/tests/ui/use/use-nested-groups-unused-imports.rs
@@ -13,7 +13,7 @@
}
use foo::{Foo, bar::{baz::{}, foobar::*}, *};
- //~^ ERROR unused imports: `*`, `Foo`, `baz::{}`, `foobar::*`
+ //~^ ERROR unused imports: `*`, `Foo`, `baz::{}`, and `foobar::*`
use foo::bar::baz::{*, *};
//~^ ERROR unused import: `*`
use foo::{};
diff --git a/tests/ui/use/use-nested-groups-unused-imports.stderr b/tests/ui/use/use-nested-groups-unused-imports.stderr
index 6610f8e..dd39a85 100644
--- a/tests/ui/use/use-nested-groups-unused-imports.stderr
+++ b/tests/ui/use/use-nested-groups-unused-imports.stderr
@@ -1,4 +1,4 @@
-error: unused imports: `*`, `Foo`, `baz::{}`, `foobar::*`
+error: unused imports: `*`, `Foo`, `baz::{}`, and `foobar::*`
--> $DIR/use-nested-groups-unused-imports.rs:15:11
|
LL | use foo::{Foo, bar::{baz::{}, foobar::*}, *};
