Auto merge of #125457 - fmease:gacs-diag-infer-plac-missing-ty, r=compiler-errors
Properly deal with missing/placeholder types inside GACs
Fixes #124833.
r? oli-obk (#123130)
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/src/tokenstream.rs b/compiler/rustc_ast/src/tokenstream.rs
index fb66655..3d46415 100644
--- a/compiler/rustc_ast/src/tokenstream.rs
+++ b/compiler/rustc_ast/src/tokenstream.rs
@@ -661,11 +661,11 @@
if attr_style == AttrStyle::Inner {
vec![
TokenTree::token_joint(token::Pound, span),
- TokenTree::token_alone(token::Not, span),
+ TokenTree::token_joint_hidden(token::Not, span),
body,
]
} else {
- vec![TokenTree::token_alone(token::Pound, span), body]
+ vec![TokenTree::token_joint_hidden(token::Pound, span), body]
}
}
}
diff --git a/compiler/rustc_ast/src/util/classify.rs b/compiler/rustc_ast/src/util/classify.rs
index f6e9e1a..382c903 100644
--- a/compiler/rustc_ast/src/util/classify.rs
+++ b/compiler/rustc_ast/src/util/classify.rs
@@ -81,8 +81,17 @@
}
}
+pub enum TrailingBrace<'a> {
+ /// Trailing brace in a macro call, like the one in `x as *const brace! {}`.
+ /// We will suggest changing the macro call to a different delimiter.
+ MacCall(&'a ast::MacCall),
+ /// Trailing brace in any other expression, such as `a + B {}`. We will
+ /// suggest wrapping the innermost expression in parentheses: `a + (B {})`.
+ Expr(&'a ast::Expr),
+}
+
/// If an expression ends with `}`, returns the innermost expression ending in the `}`
-pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<&ast::Expr> {
+pub fn expr_trailing_brace(mut expr: &ast::Expr) -> Option<TrailingBrace<'_>> {
loop {
match &expr.kind {
AddrOf(_, _, e)
@@ -111,10 +120,14 @@
| Struct(..)
| TryBlock(..)
| While(..)
- | ConstBlock(_) => break Some(expr),
+ | ConstBlock(_) => break Some(TrailingBrace::Expr(expr)),
+
+ Cast(_, ty) => {
+ break type_trailing_braced_mac_call(ty).map(TrailingBrace::MacCall);
+ }
MacCall(mac) => {
- break (mac.args.delim == Delimiter::Brace).then_some(expr);
+ break (mac.args.delim == Delimiter::Brace).then_some(TrailingBrace::MacCall(mac));
}
InlineAsm(_) | OffsetOf(_, _) | IncludedBytes(_) | FormatArgs(_) => {
@@ -131,7 +144,6 @@
| MethodCall(_)
| Tup(_)
| Lit(_)
- | Cast(_, _)
| Type(_, _)
| Await(_, _)
| Field(_, _)
@@ -148,3 +160,78 @@
}
}
}
+
+/// If the type's last token is `}`, it must be due to a braced macro call, such
+/// as in `*const brace! { ... }`. Returns that trailing macro call.
+fn type_trailing_braced_mac_call(mut ty: &ast::Ty) -> Option<&ast::MacCall> {
+ loop {
+ match &ty.kind {
+ ast::TyKind::MacCall(mac) => {
+ break (mac.args.delim == Delimiter::Brace).then_some(mac);
+ }
+
+ ast::TyKind::Ptr(mut_ty) | ast::TyKind::Ref(_, mut_ty) => {
+ ty = &mut_ty.ty;
+ }
+
+ ast::TyKind::BareFn(fn_ty) => match &fn_ty.decl.output {
+ ast::FnRetTy::Default(_) => break None,
+ ast::FnRetTy::Ty(ret) => ty = ret,
+ },
+
+ ast::TyKind::Path(_, path) => match path_return_type(path) {
+ Some(trailing_ty) => ty = trailing_ty,
+ None => break None,
+ },
+
+ ast::TyKind::TraitObject(bounds, _) | ast::TyKind::ImplTrait(_, bounds, _) => {
+ match bounds.last() {
+ Some(ast::GenericBound::Trait(bound, _)) => {
+ match path_return_type(&bound.trait_ref.path) {
+ Some(trailing_ty) => ty = trailing_ty,
+ None => break None,
+ }
+ }
+ Some(ast::GenericBound::Outlives(_)) | None => break None,
+ }
+ }
+
+ ast::TyKind::Slice(..)
+ | ast::TyKind::Array(..)
+ | ast::TyKind::Never
+ | ast::TyKind::Tup(..)
+ | ast::TyKind::Paren(..)
+ | ast::TyKind::Typeof(..)
+ | ast::TyKind::Infer
+ | ast::TyKind::ImplicitSelf
+ | ast::TyKind::CVarArgs
+ | ast::TyKind::Pat(..)
+ | ast::TyKind::Dummy
+ | ast::TyKind::Err(..) => break None,
+
+ // These end in brace, but cannot occur in a let-else statement.
+ // They are only parsed as fields of a data structure. For the
+ // purpose of denying trailing braces in the expression of a
+ // let-else, we can disregard these.
+ ast::TyKind::AnonStruct(..) | ast::TyKind::AnonUnion(..) => break None,
+ }
+ }
+}
+
+/// Returns the trailing return type in the given path, if it has one.
+///
+/// ```ignore (illustrative)
+/// ::std::ops::FnOnce(&str) -> fn() -> *const c_void
+/// ^^^^^^^^^^^^^^^^^^^^^
+/// ```
+fn path_return_type(path: &ast::Path) -> Option<&ast::Ty> {
+ let last_segment = path.segments.last()?;
+ let args = last_segment.args.as_ref()?;
+ match &**args {
+ ast::GenericArgs::Parenthesized(args) => match &args.output {
+ ast::FnRetTy::Default(_) => None,
+ ast::FnRetTy::Ty(ret) => Some(ret),
+ },
+ ast::GenericArgs::AngleBracketed(_) => None,
+ }
+}
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index 545b98a..f02fe4c 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -681,22 +681,40 @@
}
}
+ // The easiest way to implement token stream pretty printing would be to
+ // print each token followed by a single space. But that would produce ugly
+ // output, so we go to some effort to do better.
+ //
+ // First, we track whether each token that appears in source code is
+ // followed by a space, with `Spacing`, and reproduce that in the output.
+ // This works well in a lot of cases. E.g. `stringify!(x + y)` produces
+ // "x + y" and `stringify!(x+y)` produces "x+y".
+ //
+ // But this doesn't work for code produced by proc macros (which have no
+ // original source text representation) nor for code produced by decl
+ // macros (which are tricky because the whitespace after tokens appearing
+ // in macro rules isn't always what you want in the produced output). For
+ // these we mostly use `Spacing::Alone`, which is the conservative choice.
+ //
+ // So we have a backup mechanism for when `Spacing::Alone` occurs between a
+ // pair of tokens: we check if that pair of tokens can obviously go
+ // together without a space between them. E.g. token `x` followed by token
+ // `,` is better printed as `x,` than `x ,`. (Even if the original source
+ // code was `x ,`.)
+ //
+ // Finally, we must be careful about changing the output. Token pretty
+ // printing is used by `stringify!` and `impl Display for
+ // proc_macro::TokenStream`, and some programs rely on the output having a
+ // particular form, even though they shouldn't. In particular, some proc
+ // macros do `format!({stream})` on a token stream and then "parse" the
+ // output with simple string matching that can't handle whitespace changes.
+ // E.g. we have seen cases where a proc macro can handle `a :: b` but not
+ // `a::b`. See #117433 for some examples.
fn print_tts(&mut self, tts: &TokenStream, convert_dollar_crate: bool) {
let mut iter = tts.trees().peekable();
while let Some(tt) = iter.next() {
let spacing = self.print_tt(tt, convert_dollar_crate);
if let Some(next) = iter.peek() {
- // Should we print a space after `tt`? There are two guiding
- // factors.
- // - `spacing` is the more important and accurate one. Most
- // tokens have good spacing information, and
- // `Joint`/`JointHidden` get used a lot.
- // - `space_between` is the backup. Code produced by proc
- // macros has worse spacing information, with no
- // `JointHidden` usage and too much `Alone` usage, which
- // would result in over-spaced output such as
- // `( x () , y . z )`. `space_between` avoids some of the
- // excess whitespace.
if spacing == Spacing::Alone && space_between(tt, next) {
self.space();
}
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/src/assert/context.rs b/compiler/rustc_builtin_macros/src/assert/context.rs
index 085ea34..7814422 100644
--- a/compiler/rustc_builtin_macros/src/assert/context.rs
+++ b/compiler/rustc_builtin_macros/src/assert/context.rs
@@ -153,7 +153,7 @@
fn build_panic(&self, expr_str: &str, panic_path: Path) -> P<Expr> {
let escaped_expr_str = escape_to_fmt(expr_str);
let initial = [
- TokenTree::token_joint_hidden(
+ TokenTree::token_joint(
token::Literal(token::Lit {
kind: token::LitKind::Str,
symbol: Symbol::intern(&if self.fmt_string.is_empty() {
@@ -172,7 +172,7 @@
];
let captures = self.capture_decls.iter().flat_map(|cap| {
[
- TokenTree::token_joint_hidden(
+ TokenTree::token_joint(
token::Ident(cap.ident.name, IdentIsRaw::No),
cap.ident.span,
),
diff --git a/compiler/rustc_builtin_macros/src/deriving/default.rs b/compiler/rustc_builtin_macros/src/deriving/default.rs
index bf92ddb..577523a 100644
--- a/compiler/rustc_builtin_macros/src/deriving/default.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/default.rs
@@ -3,7 +3,7 @@
use crate::errors;
use core::ops::ControlFlow;
use rustc_ast as ast;
-use rustc_ast::visit::walk_list;
+use rustc_ast::visit::visit_opt;
use rustc_ast::{attr, EnumDef, VariantData};
use rustc_expand::base::{Annotatable, DummyResult, ExtCtxt};
use rustc_span::symbol::Ident;
@@ -224,7 +224,7 @@
self.visit_ident(v.ident);
self.visit_vis(&v.vis);
self.visit_variant_data(&v.data);
- walk_list!(self, visit_anon_const, &v.disr_expr);
+ visit_opt!(self, visit_anon_const, &v.disr_expr);
for attr in &v.attrs {
rustc_ast::visit::walk_attribute(self, attr);
}
diff --git a/compiler/rustc_codegen_cranelift/src/driver/aot.rs b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
index fce4690..394c810 100644
--- a/compiler/rustc_codegen_cranelift/src/driver/aot.rs
+++ b/compiler/rustc_codegen_cranelift/src/driver/aot.rs
@@ -200,7 +200,7 @@
// to get rid of it.
for output_type in crate_output.outputs.keys() {
match *output_type {
- OutputType::Bitcode => {
+ OutputType::Bitcode | OutputType::ThinLinkBitcode => {
// Cranelift doesn't have bitcode
// user_wants_bitcode = true;
// // Copy to .bc, but always keep the .0.bc. There is a later
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
index 0c7cffb..1625e6e 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
@@ -14,6 +14,7 @@
use rustc_codegen_ssa::mir::place::PlaceRef;
use rustc_codegen_ssa::traits::{BaseTypeMethods, BuilderMethods};
use rustc_hir as hir;
+use rustc_middle::mir::BinOp;
use rustc_middle::span_bug;
use rustc_middle::ty::layout::HasTyCtxt;
use rustc_middle::ty::{self, Ty};
@@ -122,12 +123,12 @@
let in_ty = arg_tys[0];
let comparison = match name {
- sym::simd_eq => Some(hir::BinOpKind::Eq),
- sym::simd_ne => Some(hir::BinOpKind::Ne),
- sym::simd_lt => Some(hir::BinOpKind::Lt),
- sym::simd_le => Some(hir::BinOpKind::Le),
- sym::simd_gt => Some(hir::BinOpKind::Gt),
- sym::simd_ge => Some(hir::BinOpKind::Ge),
+ sym::simd_eq => Some(BinOp::Eq),
+ sym::simd_ne => Some(BinOp::Ne),
+ sym::simd_lt => Some(BinOp::Lt),
+ sym::simd_le => Some(BinOp::Le),
+ sym::simd_gt => Some(BinOp::Gt),
+ sym::simd_ge => Some(BinOp::Ge),
_ => None,
};
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index 3f2fadc..b1785e1 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -335,6 +335,10 @@
fn data(&self) -> &[u8] {
unimplemented!();
}
+
+ fn thin_link_data(&self) -> &[u8] {
+ unimplemented!();
+ }
}
pub struct GccContext {
@@ -414,7 +418,7 @@
back::write::codegen(cgcx, dcx, module, config)
}
- fn prepare_thin(_module: ModuleCodegen<Self::Module>) -> (String, Self::ThinBuffer) {
+ fn prepare_thin(_module: ModuleCodegen<Self::Module>, _emit_summary: bool) -> (String, Self::ThinBuffer) {
unimplemented!();
}
diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs
index 71d4343..db28c68 100644
--- a/compiler/rustc_codegen_llvm/src/asm.rs
+++ b/compiler/rustc_codegen_llvm/src/asm.rs
@@ -16,6 +16,7 @@
use rustc_span::{Pos, Span};
use rustc_target::abi::*;
use rustc_target::asm::*;
+use tracing::debug;
use libc::{c_char, c_uint};
use smallvec::SmallVec;
diff --git a/compiler/rustc_codegen_llvm/src/back/archive.rs b/compiler/rustc_codegen_llvm/src/back/archive.rs
index c304c0c..fa7e7e5 100644
--- a/compiler/rustc_codegen_llvm/src/back/archive.rs
+++ b/compiler/rustc_codegen_llvm/src/back/archive.rs
@@ -18,6 +18,7 @@
get_native_object_symbols, try_extract_macho_fat_archive, ArArchiveBuilder,
ArchiveBuildFailure, ArchiveBuilder, ArchiveBuilderBuilder, UnknownArchiveKind,
};
+use tracing::trace;
use rustc_session::cstore::DllImport;
use rustc_session::Session;
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index e61af86..bb7c8fe 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -20,6 +20,7 @@
use rustc_middle::dep_graph::WorkProduct;
use rustc_middle::middle::exported_symbols::{SymbolExportInfo, SymbolExportLevel};
use rustc_session::config::{self, CrateType, Lto};
+use tracing::{debug, info};
use std::collections::BTreeMap;
use std::ffi::{CStr, CString};
@@ -229,9 +230,12 @@
thin_lto(cgcx, &dcx, modules, upstream_modules, cached_modules, &symbols_below_threshold)
}
-pub(crate) fn prepare_thin(module: ModuleCodegen<ModuleLlvm>) -> (String, ThinBuffer) {
+pub(crate) fn prepare_thin(
+ module: ModuleCodegen<ModuleLlvm>,
+ emit_summary: bool,
+) -> (String, ThinBuffer) {
let name = module.name;
- let buffer = ThinBuffer::new(module.module_llvm.llmod(), true);
+ let buffer = ThinBuffer::new(module.module_llvm.llmod(), true, emit_summary);
(name, buffer)
}
@@ -671,9 +675,9 @@
unsafe impl Sync for ThinBuffer {}
impl ThinBuffer {
- pub fn new(m: &llvm::Module, is_thin: bool) -> ThinBuffer {
+ pub fn new(m: &llvm::Module, is_thin: bool, emit_summary: bool) -> ThinBuffer {
unsafe {
- let buffer = llvm::LLVMRustThinLTOBufferCreate(m, is_thin);
+ let buffer = llvm::LLVMRustThinLTOBufferCreate(m, is_thin, emit_summary);
ThinBuffer(buffer)
}
}
@@ -687,6 +691,14 @@
slice::from_raw_parts(ptr, len)
}
}
+
+ fn thin_link_data(&self) -> &[u8] {
+ unsafe {
+ let ptr = llvm::LLVMRustThinLTOBufferThinLinkDataPtr(self.0) as *const _;
+ let len = llvm::LLVMRustThinLTOBufferThinLinkDataLen(self.0);
+ slice::from_raw_parts(ptr, len)
+ }
+ }
}
impl Drop for ThinBuffer {
diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index 49f9d7d..02e3bb0 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -35,6 +35,7 @@
use rustc_span::symbol::sym;
use rustc_span::InnerSpan;
use rustc_target::spec::{CodeModel, RelocModel, SanitizerSet, SplitDebuginfo, TlsModel};
+use tracing::debug;
use crate::llvm::diagnostic::OptimizationDiagnosticKind;
use libc::{c_char, c_int, c_void, size_t};
@@ -708,13 +709,15 @@
// asm from LLVM and use `gcc` to create the object file.
let bc_out = cgcx.output_filenames.temp_path(OutputType::Bitcode, module_name);
+ let bc_summary_out =
+ cgcx.output_filenames.temp_path(OutputType::ThinLinkBitcode, module_name);
let obj_out = cgcx.output_filenames.temp_path(OutputType::Object, module_name);
if config.bitcode_needed() {
let _timer = cgcx
.prof
.generic_activity_with_arg("LLVM_module_codegen_make_bitcode", &*module.name);
- let thin = ThinBuffer::new(llmod, config.emit_thin_lto);
+ let thin = ThinBuffer::new(llmod, config.emit_thin_lto, config.emit_thin_lto_summary);
let data = thin.data();
if let Some(bitcode_filename) = bc_out.file_name() {
@@ -725,6 +728,25 @@
);
}
+ if config.emit_thin_lto_summary
+ && let Some(thin_link_bitcode_filename) = bc_summary_out.file_name()
+ {
+ let summary_data = thin.thin_link_data();
+ cgcx.prof.artifact_size(
+ "llvm_bitcode_summary",
+ thin_link_bitcode_filename.to_string_lossy(),
+ summary_data.len() as u64,
+ );
+
+ let _timer = cgcx.prof.generic_activity_with_arg(
+ "LLVM_module_codegen_emit_bitcode_summary",
+ &*module.name,
+ );
+ if let Err(err) = fs::write(&bc_summary_out, summary_data) {
+ dcx.emit_err(WriteBytecode { path: &bc_summary_out, err });
+ }
+ }
+
if config.emit_bc || config.emit_obj == EmitObj::Bitcode {
let _timer = cgcx
.prof
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 230c58d..72ff9ea 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -30,6 +30,7 @@
use std::iter;
use std::ops::Deref;
use std::ptr;
+use tracing::{debug, instrument};
// All Builders must have an llfn associated with them
#[must_use]
diff --git a/compiler/rustc_codegen_llvm/src/callee.rs b/compiler/rustc_codegen_llvm/src/callee.rs
index e675362..659c6ae 100644
--- a/compiler/rustc_codegen_llvm/src/callee.rs
+++ b/compiler/rustc_codegen_llvm/src/callee.rs
@@ -12,6 +12,7 @@
use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt};
use rustc_middle::ty::{self, Instance, TypeVisitableExt};
+use tracing::debug;
/// Codegens a reference to a fn/method item, monomorphizing and
/// inlining as it goes.
diff --git a/compiler/rustc_codegen_llvm/src/common.rs b/compiler/rustc_codegen_llvm/src/common.rs
index ec33ce6..ab8036a 100644
--- a/compiler/rustc_codegen_llvm/src/common.rs
+++ b/compiler/rustc_codegen_llvm/src/common.rs
@@ -19,6 +19,7 @@
use libc::{c_char, c_uint};
use std::fmt::Write;
+use tracing::debug;
/*
* A note on nomenclature of linking: "extern", "foreign", and "upcall".
diff --git a/compiler/rustc_codegen_llvm/src/consts.rs b/compiler/rustc_codegen_llvm/src/consts.rs
index 9e85c2d..a2314f4 100644
--- a/compiler/rustc_codegen_llvm/src/consts.rs
+++ b/compiler/rustc_codegen_llvm/src/consts.rs
@@ -25,6 +25,7 @@
Align, AlignFromBytesError, HasDataLayout, Primitive, Scalar, Size, WrappingRange,
};
use std::ops::Range;
+use tracing::{debug, instrument, trace};
pub fn const_alloc_to_llvm<'ll>(
cx: &CodegenCx<'ll, '_>,
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs
index d85d941..b969fe2 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/map_data.rs
@@ -9,6 +9,7 @@
};
use rustc_middle::ty::Instance;
use rustc_span::Symbol;
+use tracing::{debug, instrument};
/// Holds all of the coverage mapping data associated with a function instance,
/// collected during traversal of `Coverage` statements in the function's MIR.
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
index 3f3969b..d2c0f20 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mapgen.rs
@@ -14,6 +14,7 @@
use rustc_middle::ty::{self, TyCtxt};
use rustc_span::def_id::DefIdSet;
use rustc_span::Symbol;
+use tracing::debug;
/// Generates and exports the Coverage Map.
///
diff --git a/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs b/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs
index 26ea95f..7b7f8c8 100644
--- a/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/coverageinfo/mod.rs
@@ -17,6 +17,7 @@
use rustc_middle::ty::layout::HasTyCtxt;
use rustc_middle::ty::Instance;
use rustc_target::abi::{Align, Size};
+use tracing::{debug, instrument};
use std::cell::RefCell;
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
index f44738b..10d3c0d 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
@@ -41,6 +41,7 @@
use rustc_target::abi::{Align, Size};
use rustc_target::spec::DebuginfoKind;
use smallvec::smallvec;
+use tracing::{debug, instrument};
use libc::{c_char, c_longlong, c_uint};
use std::borrow::Cow;
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
index 6149c18..3486ce4 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
@@ -42,6 +42,7 @@
use std::cell::RefCell;
use std::iter;
use std::ops::Range;
+use tracing::debug;
mod create_scope_map;
pub mod gdb;
diff --git a/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs b/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs
index c758010..155e7a8 100644
--- a/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs
+++ b/compiler/rustc_codegen_llvm/src/debuginfo/utils.rs
@@ -6,7 +6,7 @@
use rustc_hir::def_id::DefId;
use rustc_middle::ty::layout::{HasParamEnv, LayoutOf};
use rustc_middle::ty::{self, Ty};
-use trace;
+use tracing::trace;
use crate::common::CodegenCx;
use crate::llvm;
diff --git a/compiler/rustc_codegen_llvm/src/declare.rs b/compiler/rustc_codegen_llvm/src/declare.rs
index 7117c4a..bf86d0e 100644
--- a/compiler/rustc_codegen_llvm/src/declare.rs
+++ b/compiler/rustc_codegen_llvm/src/declare.rs
@@ -24,6 +24,7 @@
use rustc_middle::ty::{Instance, Ty};
use rustc_sanitizers::{cfi, kcfi};
use smallvec::SmallVec;
+use tracing::debug;
/// Declare a function.
///
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index 80e863a..3d2ce55 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -14,12 +14,14 @@
use rustc_codegen_ssa::mir::place::PlaceRef;
use rustc_codegen_ssa::traits::*;
use rustc_hir as hir;
+use rustc_middle::mir::BinOp;
use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, LayoutOf};
use rustc_middle::ty::{self, GenericArgsRef, Ty};
use rustc_middle::{bug, span_bug};
use rustc_span::{sym, Span, Symbol};
use rustc_target::abi::{self, Align, Float, HasDataLayout, Primitive, Size};
use rustc_target::spec::{HasTargetSpec, PanicStrategy};
+use tracing::debug;
use std::cmp::Ordering;
@@ -1104,12 +1106,12 @@
let in_ty = arg_tys[0];
let comparison = match name {
- sym::simd_eq => Some(hir::BinOpKind::Eq),
- sym::simd_ne => Some(hir::BinOpKind::Ne),
- sym::simd_lt => Some(hir::BinOpKind::Lt),
- sym::simd_le => Some(hir::BinOpKind::Le),
- sym::simd_gt => Some(hir::BinOpKind::Gt),
- sym::simd_ge => Some(hir::BinOpKind::Ge),
+ sym::simd_eq => Some(BinOp::Eq),
+ sym::simd_ne => Some(BinOp::Ne),
+ sym::simd_lt => Some(BinOp::Lt),
+ sym::simd_le => Some(BinOp::Le),
+ sym::simd_gt => Some(BinOp::Gt),
+ sym::simd_ge => Some(BinOp::Ge),
_ => None,
};
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index 1cecf68..0029ec9 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -15,9 +15,6 @@
#![feature(let_chains)]
#![feature(impl_trait_in_assoc_type)]
-#[macro_use]
-extern crate tracing;
-
use back::owned_target_machine::OwnedTargetMachine;
use back::write::{create_informational_target_machine, create_target_machine};
@@ -240,8 +237,11 @@
) -> Result<CompiledModule, FatalError> {
back::write::codegen(cgcx, dcx, module, config)
}
- fn prepare_thin(module: ModuleCodegen<Self::Module>) -> (String, Self::ThinBuffer) {
- back::lto::prepare_thin(module)
+ fn prepare_thin(
+ module: ModuleCodegen<Self::Module>,
+ emit_summary: bool,
+ ) -> (String, Self::ThinBuffer) {
+ back::lto::prepare_thin(module, emit_summary)
}
fn serialize_module(module: ModuleCodegen<Self::Module>) -> (String, Self::ModuleBuffer) {
(module.name, back::lto::ModuleBuffer::new(module.module_llvm.llmod()))
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 7a34e21..132e1f9 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -2350,10 +2350,16 @@
#[allow(improper_ctypes)]
pub fn LLVMRustModuleInstructionStats(M: &Module, Str: &RustString);
- pub fn LLVMRustThinLTOBufferCreate(M: &Module, is_thin: bool) -> &'static mut ThinLTOBuffer;
+ pub fn LLVMRustThinLTOBufferCreate(
+ M: &Module,
+ is_thin: bool,
+ emit_summary: bool,
+ ) -> &'static mut ThinLTOBuffer;
pub fn LLVMRustThinLTOBufferFree(M: &'static mut ThinLTOBuffer);
pub fn LLVMRustThinLTOBufferPtr(M: &ThinLTOBuffer) -> *const c_char;
pub fn LLVMRustThinLTOBufferLen(M: &ThinLTOBuffer) -> size_t;
+ pub fn LLVMRustThinLTOBufferThinLinkDataPtr(M: &ThinLTOBuffer) -> *const c_char;
+ pub fn LLVMRustThinLTOBufferThinLinkDataLen(M: &ThinLTOBuffer) -> size_t;
pub fn LLVMRustCreateThinLTOData(
Modules: *const ThinLTOModule,
NumModules: c_uint,
diff --git a/compiler/rustc_codegen_llvm/src/mono_item.rs b/compiler/rustc_codegen_llvm/src/mono_item.rs
index 29100a6..a7df084 100644
--- a/compiler/rustc_codegen_llvm/src/mono_item.rs
+++ b/compiler/rustc_codegen_llvm/src/mono_item.rs
@@ -13,6 +13,7 @@
use rustc_middle::ty::{self, Instance, TypeVisitableExt};
use rustc_session::config::CrateType;
use rustc_target::spec::RelocModel;
+use tracing::debug;
impl<'tcx> PreDefineMethods<'tcx> for CodegenCx<'_, 'tcx> {
fn predefine_static(
diff --git a/compiler/rustc_codegen_llvm/src/type_of.rs b/compiler/rustc_codegen_llvm/src/type_of.rs
index 5f60fd2..011d8ab 100644
--- a/compiler/rustc_codegen_llvm/src/type_of.rs
+++ b/compiler/rustc_codegen_llvm/src/type_of.rs
@@ -8,6 +8,7 @@
use rustc_target::abi::{Abi, Align, FieldsShape};
use rustc_target::abi::{Float, Int, Pointer};
use rustc_target::abi::{Scalar, Size, Variants};
+use tracing::debug;
use std::fmt::Write;
diff --git a/compiler/rustc_codegen_ssa/messages.ftl b/compiler/rustc_codegen_ssa/messages.ftl
index d159fe5..1a851ad 100644
--- a/compiler/rustc_codegen_ssa/messages.ftl
+++ b/compiler/rustc_codegen_ssa/messages.ftl
@@ -212,6 +212,8 @@
codegen_ssa_select_cpp_build_tool_workload = in the Visual Studio installer, ensure the "C++ build tools" workload is selected
+codegen_ssa_self_contained_linker_missing = the self-contained linker was requested, but it wasn't found in the target's sysroot, or in rustc's sysroot
+
codegen_ssa_shuffle_indices_evaluation = could not evaluate shuffle_indices at compile time
codegen_ssa_specify_libraries_to_link = use the `-l` flag to specify native libraries to link
diff --git a/compiler/rustc_codegen_ssa/src/assert_module_sources.rs b/compiler/rustc_codegen_ssa/src/assert_module_sources.rs
index e441aea..6e7d736 100644
--- a/compiler/rustc_codegen_ssa/src/assert_module_sources.rs
+++ b/compiler/rustc_codegen_ssa/src/assert_module_sources.rs
@@ -37,6 +37,7 @@
use std::borrow::Cow;
use std::fmt;
use thin_vec::ThinVec;
+use tracing::debug;
#[allow(missing_docs)]
pub fn assert_module_sources(tcx: TyCtxt<'_>, set_reuse: &dyn Fn(&mut CguReuseTracker)) {
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 37b8f81..bdb808b 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -52,6 +52,7 @@
use std::path::{Path, PathBuf};
use std::process::{ExitStatus, Output, Stdio};
use std::{env, fmt, fs, io, mem, str};
+use tracing::{debug, info, warn};
pub fn ensure_removed(dcx: &DiagCtxt, path: &Path) {
if let Err(e) = fs::remove_file(path) {
@@ -786,12 +787,33 @@
if matches!(flavor, LinkerFlavor::Gnu(Cc::Yes, _))
&& unknown_arg_regex.is_match(&out)
&& out.contains("-no-pie")
- && cmd.get_args().iter().any(|e| e.to_string_lossy() == "-no-pie")
+ && cmd.get_args().iter().any(|e| e == "-no-pie")
{
info!("linker output: {:?}", out);
warn!("Linker does not support -no-pie command line option. Retrying without.");
for arg in cmd.take_args() {
- if arg.to_string_lossy() != "-no-pie" {
+ if arg != "-no-pie" {
+ cmd.arg(arg);
+ }
+ }
+ info!("{:?}", &cmd);
+ continue;
+ }
+
+ // Check if linking failed with an error message that indicates the driver didn't recognize
+ // the `-fuse-ld=lld` option. If so, re-perform the link step without it. This avoids having
+ // to spawn multiple instances on the happy path to do version checking, and ensures things
+ // keep working on the tier 1 baseline of GLIBC 2.17+. That is generally understood as GCCs
+ // circa RHEL/CentOS 7, 4.5 or so, whereas lld support was added in GCC 9.
+ if matches!(flavor, LinkerFlavor::Gnu(Cc::Yes, Lld::Yes))
+ && unknown_arg_regex.is_match(&out)
+ && out.contains("-fuse-ld=lld")
+ && cmd.get_args().iter().any(|e| e.to_string_lossy() == "-fuse-ld=lld")
+ {
+ info!("linker output: {:?}", out);
+ warn!("The linker driver does not support `-fuse-ld=lld`. Retrying without it.");
+ for arg in cmd.take_args() {
+ if arg.to_string_lossy() != "-fuse-ld=lld" {
cmd.arg(arg);
}
}
@@ -804,7 +826,7 @@
if matches!(flavor, LinkerFlavor::Gnu(Cc::Yes, _))
&& unknown_arg_regex.is_match(&out)
&& (out.contains("-static-pie") || out.contains("--no-dynamic-linker"))
- && cmd.get_args().iter().any(|e| e.to_string_lossy() == "-static-pie")
+ && cmd.get_args().iter().any(|e| e == "-static-pie")
{
info!("linker output: {:?}", out);
warn!(
@@ -843,7 +865,7 @@
assert!(pre_objects_static.is_empty() || !pre_objects_static_pie.is_empty());
assert!(post_objects_static.is_empty() || !post_objects_static_pie.is_empty());
for arg in cmd.take_args() {
- if arg.to_string_lossy() == "-static-pie" {
+ if arg == "-static-pie" {
// Replace the output kind.
cmd.arg("-static");
} else if pre_objects_static_pie.contains(&arg) {
@@ -3119,13 +3141,21 @@
let self_contained_linker = self_contained_cli || self_contained_target;
if self_contained_linker && !sess.opts.cg.link_self_contained.is_linker_disabled() {
+ let mut linker_path_exists = false;
for path in sess.get_tools_search_paths(false) {
+ let linker_path = path.join("gcc-ld");
+ linker_path_exists |= linker_path.exists();
cmd.arg({
let mut arg = OsString::from("-B");
- arg.push(path.join("gcc-ld"));
+ arg.push(linker_path);
arg
});
}
+ if !linker_path_exists {
+ // As a sanity check, we emit an error if none of these paths exist: we want
+ // self-contained linking and have no linker.
+ sess.dcx().emit_fatal(errors::SelfContainedLinkerMissing);
+ }
}
// 2. Implement the "linker flavor" part of this feature by asking `cc` to use some kind of
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index f85056f..a824789 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -22,6 +22,7 @@
use rustc_target::spec::{Cc, LinkOutputKind, LinkerFlavor, Lld};
use cc::windows_registry;
+use tracing::{debug, warn};
/// Disables non-English messages from localized linkers.
/// Such messages may cause issues with text encoding on Windows (#35785)
diff --git a/compiler/rustc_codegen_ssa/src/back/rpath.rs b/compiler/rustc_codegen_ssa/src/back/rpath.rs
index ebbf49a..3114f1c 100644
--- a/compiler/rustc_codegen_ssa/src/back/rpath.rs
+++ b/compiler/rustc_codegen_ssa/src/back/rpath.rs
@@ -3,6 +3,7 @@
use rustc_fs_util::try_canonicalize;
use std::ffi::OsString;
use std::path::{Path, PathBuf};
+use tracing::debug;
pub struct RPathConfig<'a> {
pub libs: &'a [&'a Path],
diff --git a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
index 0e335bf..79d6641 100644
--- a/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
+++ b/compiler/rustc_codegen_ssa/src/back/symbol_export.rs
@@ -18,6 +18,7 @@
use rustc_middle::util::Providers;
use rustc_session::config::{CrateType, OomStrategy};
use rustc_target::spec::{SanitizerSet, TlsModel};
+use tracing::debug;
pub fn threshold(tcx: TyCtxt<'_>) -> SymbolExportLevel {
crates_export_threshold(tcx.crate_types())
@@ -399,7 +400,7 @@
tcx: TyCtxt<'_>,
(): (),
) -> DefIdMap<UnordMap<GenericArgsRef<'_>, CrateNum>> {
- let cnums = tcx.crates(());
+ let cnums = tcx.used_crates(());
let mut instances: DefIdMap<UnordMap<_, _>> = Default::default();
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index 53ba0da..d57f4dd 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -49,6 +49,7 @@
use std::sync::mpsc::{channel, Receiver, Sender};
use std::sync::Arc;
use std::thread;
+use tracing::debug;
const PRE_LTO_BC_EXT: &str = "pre-lto.bc";
@@ -107,6 +108,7 @@
pub emit_asm: bool,
pub emit_obj: EmitObj,
pub emit_thin_lto: bool,
+ pub emit_thin_lto_summary: bool,
pub bc_cmdline: String,
// Miscellaneous flags. These are mostly copied from command-line
@@ -231,6 +233,10 @@
),
emit_obj,
emit_thin_lto: sess.opts.unstable_opts.emit_thin_lto,
+ emit_thin_lto_summary: if_regular!(
+ sess.opts.output_types.contains_key(&OutputType::ThinLinkBitcode),
+ false
+ ),
bc_cmdline: sess.target.bitcode_llvm_cmdline.to_string(),
verify_llvm_ir: sess.verify_llvm_ir(),
@@ -282,6 +288,7 @@
pub fn bitcode_needed(&self) -> bool {
self.emit_bc
+ || self.emit_thin_lto_summary
|| self.emit_obj == EmitObj::Bitcode
|| self.emit_obj == EmitObj::ObjectCode(BitcodeSection::Full)
}
@@ -629,6 +636,9 @@
// them for making an rlib.
copy_if_one_unit(OutputType::Bitcode, true);
}
+ OutputType::ThinLinkBitcode => {
+ copy_if_one_unit(OutputType::ThinLinkBitcode, false);
+ }
OutputType::LlvmAssembly => {
copy_if_one_unit(OutputType::LlvmAssembly, false);
}
@@ -882,7 +892,7 @@
match lto_type {
ComputedLtoType::No => finish_intra_module_work(cgcx, module, module_config),
ComputedLtoType::Thin => {
- let (name, thin_buffer) = B::prepare_thin(module);
+ let (name, thin_buffer) = B::prepare_thin(module, false);
if let Some(path) = bitcode {
fs::write(&path, thin_buffer.data()).unwrap_or_else(|e| {
panic!("Error writing pre-lto-bitcode file `{}`: {}", path.display(), e);
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 877e5b7..b4556f8 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -20,7 +20,6 @@
use rustc_data_structures::profiling::{get_resident_set_size, print_time_passes_entry};
use rustc_data_structures::sync::par_map;
use rustc_data_structures::unord::UnordMap;
-use rustc_hir as hir;
use rustc_hir::def_id::{DefId, LOCAL_CRATE};
use rustc_hir::lang_items::LangItem;
use rustc_metadata::EncodedMetadata;
@@ -30,6 +29,7 @@
use rustc_middle::middle::exported_symbols;
use rustc_middle::middle::exported_symbols::SymbolExportKind;
use rustc_middle::middle::lang_items;
+use rustc_middle::mir::BinOp;
use rustc_middle::mir::mono::{CodegenUnit, CodegenUnitNameBuilder, MonoItem};
use rustc_middle::query::Providers;
use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, TyAndLayout};
@@ -45,33 +45,34 @@
use std::time::{Duration, Instant};
use itertools::Itertools;
+use tracing::{debug, info};
-pub fn bin_op_to_icmp_predicate(op: hir::BinOpKind, signed: bool) -> IntPredicate {
+pub fn bin_op_to_icmp_predicate(op: BinOp, signed: bool) -> IntPredicate {
match op {
- hir::BinOpKind::Eq => IntPredicate::IntEQ,
- hir::BinOpKind::Ne => IntPredicate::IntNE,
- hir::BinOpKind::Lt => {
+ BinOp::Eq => IntPredicate::IntEQ,
+ BinOp::Ne => IntPredicate::IntNE,
+ BinOp::Lt => {
if signed {
IntPredicate::IntSLT
} else {
IntPredicate::IntULT
}
}
- hir::BinOpKind::Le => {
+ BinOp::Le => {
if signed {
IntPredicate::IntSLE
} else {
IntPredicate::IntULE
}
}
- hir::BinOpKind::Gt => {
+ BinOp::Gt => {
if signed {
IntPredicate::IntSGT
} else {
IntPredicate::IntUGT
}
}
- hir::BinOpKind::Ge => {
+ BinOp::Ge => {
if signed {
IntPredicate::IntSGE
} else {
@@ -86,14 +87,14 @@
}
}
-pub fn bin_op_to_fcmp_predicate(op: hir::BinOpKind) -> RealPredicate {
+pub fn bin_op_to_fcmp_predicate(op: BinOp) -> RealPredicate {
match op {
- hir::BinOpKind::Eq => RealPredicate::RealOEQ,
- hir::BinOpKind::Ne => RealPredicate::RealUNE,
- hir::BinOpKind::Lt => RealPredicate::RealOLT,
- hir::BinOpKind::Le => RealPredicate::RealOLE,
- hir::BinOpKind::Gt => RealPredicate::RealOGT,
- hir::BinOpKind::Ge => RealPredicate::RealOGE,
+ BinOp::Eq => RealPredicate::RealOEQ,
+ BinOp::Ne => RealPredicate::RealUNE,
+ BinOp::Lt => RealPredicate::RealOLT,
+ BinOp::Le => RealPredicate::RealOLE,
+ BinOp::Gt => RealPredicate::RealOGT,
+ BinOp::Ge => RealPredicate::RealOGE,
op => {
bug!(
"comparison_op_to_fcmp_predicate: expected comparison operator, \
@@ -110,7 +111,7 @@
rhs: Bx::Value,
t: Ty<'tcx>,
ret_ty: Bx::Type,
- op: hir::BinOpKind,
+ op: BinOp,
) -> Bx::Value {
let signed = match t.kind() {
ty::Float(_) => {
@@ -539,7 +540,7 @@
tcx.debugger_visualizers(LOCAL_CRATE)
.iter()
.chain(
- tcx.crates(())
+ tcx.used_crates(())
.iter()
.filter(|&cnum| {
let used_crate_source = tcx.used_crate_source(*cnum);
@@ -849,7 +850,7 @@
// `compiler_builtins` are always placed last to ensure that they're linked correctly.
used_crates.extend(compiler_builtins);
- let crates = tcx.crates(());
+ let crates = tcx.used_crates(());
let n_crates = crates.len();
let mut info = CrateInfo {
target_cpu,
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index ed6a0c2..3641e78 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -414,6 +414,10 @@
pub struct MsvcMissingLinker;
#[derive(Diagnostic)]
+#[diag(codegen_ssa_self_contained_linker_missing)]
+pub struct SelfContainedLinkerMissing;
+
+#[derive(Diagnostic)]
#[diag(codegen_ssa_check_installed_visual_studio)]
pub struct CheckInstalledVisualStudio;
diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs
index 4eb24d7..1668104 100644
--- a/compiler/rustc_codegen_ssa/src/lib.rs
+++ b/compiler/rustc_codegen_ssa/src/lib.rs
@@ -15,9 +15,6 @@
//! The backend-agnostic functions of this crate use functions defined in various traits that
//! have to be implemented by each backend.
-#[macro_use]
-extern crate tracing;
-
use rustc_ast as ast;
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::fx::FxIndexMap;
@@ -195,6 +192,7 @@
EmptyVersionNumber,
EncodingVersionMismatch { version_array: String, rlink_version: u32 },
RustcVersionMismatch { rustc_version: String },
+ CorruptFile,
}
pub fn provide(providers: &mut Providers) {
@@ -265,7 +263,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_codegen_ssa/src/meth.rs b/compiler/rustc_codegen_ssa/src/meth.rs
index 23036e9..d6fc8e5 100644
--- a/compiler/rustc_codegen_ssa/src/meth.rs
+++ b/compiler/rustc_codegen_ssa/src/meth.rs
@@ -5,6 +5,7 @@
use rustc_session::config::Lto;
use rustc_symbol_mangling::typeid_for_trait_ref;
use rustc_target::abi::call::FnAbi;
+use tracing::{debug, instrument};
#[derive(Copy, Clone, Debug)]
pub struct VirtualIndex(u64);
diff --git a/compiler/rustc_codegen_ssa/src/mir/analyze.rs b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
index 09ae7cf..0577ba3 100644
--- a/compiler/rustc_codegen_ssa/src/mir/analyze.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/analyze.rs
@@ -11,6 +11,7 @@
use rustc_middle::mir::{self, DefLocation, Location, TerminatorKind};
use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf};
use rustc_middle::{bug, span_bug};
+use tracing::debug;
pub fn non_ssa_locals<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
fx: &FunctionCx<'a, 'tcx, Bx>,
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index ba6aad5..1cb1ba9 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -24,6 +24,7 @@
use rustc_target::abi::call::{ArgAbi, FnAbi, PassMode, Reg};
use rustc_target::abi::{self, HasDataLayout, WrappingRange};
use rustc_target::spec::abi::Abi;
+use tracing::{debug, info};
use std::cmp;
diff --git a/compiler/rustc_codegen_ssa/src/mir/locals.rs b/compiler/rustc_codegen_ssa/src/mir/locals.rs
index 7db260c..c7f63ea 100644
--- a/compiler/rustc_codegen_ssa/src/mir/locals.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/locals.rs
@@ -7,6 +7,8 @@
use rustc_middle::mir;
use rustc_middle::ty::print::with_no_trimmed_paths;
use std::ops::{Index, IndexMut};
+use tracing::{debug, warn};
+
pub(super) struct Locals<'tcx, V> {
values: IndexVec<mir::Local, LocalRef<'tcx, V>>,
}
diff --git a/compiler/rustc_codegen_ssa/src/mir/mod.rs b/compiler/rustc_codegen_ssa/src/mir/mod.rs
index cf6e2e8..e8da984 100644
--- a/compiler/rustc_codegen_ssa/src/mir/mod.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/mod.rs
@@ -10,6 +10,7 @@
use rustc_middle::ty::{self, Instance, Ty, TyCtxt, TypeFoldable, TypeVisitableExt};
use rustc_middle::{bug, span_bug};
use rustc_target::abi::call::{FnAbi, PassMode};
+use tracing::{debug, instrument};
use std::iter;
diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index 32fd9b6..5b2f9a3 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -16,6 +16,7 @@
use arrayvec::ArrayVec;
use either::Either;
+use tracing::debug;
/// The representation of a Rust value. The enum variant is in fact
/// uniquely determined by the value's type, but is kept as a
diff --git a/compiler/rustc_codegen_ssa/src/mir/place.rs b/compiler/rustc_codegen_ssa/src/mir/place.rs
index 971ac2d..7c3569a 100644
--- a/compiler/rustc_codegen_ssa/src/mir/place.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/place.rs
@@ -12,6 +12,7 @@
use rustc_middle::ty::{self, Ty};
use rustc_target::abi::{Align, FieldsShape, Int, Pointer, Size, TagEncoding};
use rustc_target::abi::{VariantIdx, Variants};
+use tracing::{debug, instrument};
/// The location and extra runtime properties of the place.
///
@@ -159,9 +160,9 @@
bx.inbounds_ptradd(self.val.llval, bx.const_usize(offset.bytes()))
};
let val = PlaceValue {
- llval,
+ llval,
llextra: if bx.cx().type_has_metadata(field.ty) { self.val.llextra } else { None },
- align: effective_field_align,
+ align: effective_field_align,
};
val.with_type(field)
};
@@ -408,9 +409,9 @@
};
let llval = bx.inbounds_gep(
- bx.cx().backend_type(self.layout),
- self.val.llval,
- &[bx.cx().const_usize(0), llindex],
+ bx.cx().backend_type(self.layout),
+ self.val.llval,
+ &[bx.cx().const_usize(0), llindex],
);
let align = self.val.align.restrict_for_offset(offset);
PlaceValue::new_sized(llval, align).with_type(layout)
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index 00b28cb..4dd80d3 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -7,7 +7,6 @@
use crate::traits::*;
use crate::MemFlags;
-use rustc_hir as hir;
use rustc_middle::mir;
use rustc_middle::ty::cast::{CastTy, IntTy};
use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, TyAndLayout};
@@ -18,6 +17,7 @@
use rustc_target::abi::{self, FieldIdx, FIRST_VARIANT};
use arrayvec::ArrayVec;
+use tracing::{debug, instrument};
impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
#[instrument(level = "trace", skip(self, bx))]
@@ -896,9 +896,9 @@
| mir::BinOp::Le
| mir::BinOp::Ge => {
if is_float {
- bx.fcmp(base::bin_op_to_fcmp_predicate(op.to_hir_binop()), lhs, rhs)
+ bx.fcmp(base::bin_op_to_fcmp_predicate(op), lhs, rhs)
} else {
- bx.icmp(base::bin_op_to_icmp_predicate(op.to_hir_binop(), is_signed), lhs, rhs)
+ bx.icmp(base::bin_op_to_icmp_predicate(op, is_signed), lhs, rhs)
}
}
mir::BinOp::Cmp => {
@@ -912,16 +912,16 @@
// `PartialOrd`, so only use it in debug for now. Once LLVM can handle it
// better (see <https://github.com/llvm/llvm-project/issues/73417>), it'll
// be worth trying it in optimized builds as well.
- let is_gt = bx.icmp(pred(hir::BinOpKind::Gt), lhs, rhs);
+ let is_gt = bx.icmp(pred(mir::BinOp::Gt), lhs, rhs);
let gtext = bx.zext(is_gt, bx.type_i8());
- let is_lt = bx.icmp(pred(hir::BinOpKind::Lt), lhs, rhs);
+ let is_lt = bx.icmp(pred(mir::BinOp::Lt), lhs, rhs);
let ltext = bx.zext(is_lt, bx.type_i8());
bx.unchecked_ssub(gtext, ltext)
} else {
// These operations are those expected by `tests/codegen/integer-cmp.rs`,
// from <https://github.com/rust-lang/rust/pull/63767>.
- let is_lt = bx.icmp(pred(hir::BinOpKind::Lt), lhs, rhs);
- let is_ne = bx.icmp(pred(hir::BinOpKind::Ne), lhs, rhs);
+ let is_lt = bx.icmp(pred(mir::BinOp::Lt), lhs, rhs);
+ let is_ne = bx.icmp(pred(mir::BinOp::Ne), lhs, rhs);
let ge = bx.select(
is_ne,
bx.cx().const_i8(Ordering::Greater as i8),
diff --git a/compiler/rustc_codegen_ssa/src/mir/statement.rs b/compiler/rustc_codegen_ssa/src/mir/statement.rs
index a042902..27494f4 100644
--- a/compiler/rustc_codegen_ssa/src/mir/statement.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/statement.rs
@@ -1,6 +1,7 @@
use rustc_middle::mir::{self, NonDivergingIntrinsic};
use rustc_middle::span_bug;
use rustc_session::config::OptLevel;
+use tracing::instrument;
use super::FunctionCx;
use super::LocalRef;
diff --git a/compiler/rustc_codegen_ssa/src/mono_item.rs b/compiler/rustc_codegen_ssa/src/mono_item.rs
index 40921c2..0fbcb93 100644
--- a/compiler/rustc_codegen_ssa/src/mono_item.rs
+++ b/compiler/rustc_codegen_ssa/src/mono_item.rs
@@ -9,6 +9,7 @@
use rustc_middle::ty;
use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf};
use rustc_middle::ty::Instance;
+use tracing::debug;
pub trait MonoItemExt<'a, 'tcx> {
fn define<Bx: BuilderMethods<'a, 'tcx>>(&self, cx: &'a Bx::CodegenCx);
diff --git a/compiler/rustc_codegen_ssa/src/size_of_val.rs b/compiler/rustc_codegen_ssa/src/size_of_val.rs
index 032699f..130fe2e 100644
--- a/compiler/rustc_codegen_ssa/src/size_of_val.rs
+++ b/compiler/rustc_codegen_ssa/src/size_of_val.rs
@@ -9,6 +9,7 @@
use rustc_middle::ty::print::{with_no_trimmed_paths, with_no_visible_paths};
use rustc_middle::ty::{self, Ty};
use rustc_target::abi::WrappingRange;
+use tracing::{debug, trace};
pub fn size_and_align_of_dst<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
bx: &mut Bx,
diff --git a/compiler/rustc_codegen_ssa/src/traits/write.rs b/compiler/rustc_codegen_ssa/src/traits/write.rs
index 0485408..f83e34a 100644
--- a/compiler/rustc_codegen_ssa/src/traits/write.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/write.rs
@@ -56,12 +56,16 @@
module: ModuleCodegen<Self::Module>,
config: &ModuleConfig,
) -> Result<CompiledModule, FatalError>;
- fn prepare_thin(module: ModuleCodegen<Self::Module>) -> (String, Self::ThinBuffer);
+ fn prepare_thin(
+ module: ModuleCodegen<Self::Module>,
+ want_summary: bool,
+ ) -> (String, Self::ThinBuffer);
fn serialize_module(module: ModuleCodegen<Self::Module>) -> (String, Self::ModuleBuffer);
}
pub trait ThinBufferMethods: Send + Sync {
fn data(&self) -> &[u8];
+ fn thin_link_data(&self) -> &[u8];
}
pub trait ModuleBufferMethods: Send + Sync {
diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index 20f0f27..2dbeb7d 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -246,11 +246,10 @@
const_eval_operator_non_const =
cannot call non-const operator in {const_eval_const_context}s
-const_eval_overflow =
- overflow executing `{$name}`
-
+const_eval_overflow_arith =
+ arithmetic overflow in `{$intrinsic}`
const_eval_overflow_shift =
- overflowing shift by {$val} in `{$name}`
+ overflowing shift by {$shift_amount} in `{$intrinsic}`
const_eval_panic =
the evaluated program panicked at '{$msg}', {$file}:{$line}:{$col}
diff --git a/compiler/rustc_const_eval/src/const_eval/dummy_machine.rs b/compiler/rustc_const_eval/src/const_eval/dummy_machine.rs
index 94c9f05..530a05a 100644
--- a/compiler/rustc_const_eval/src/const_eval/dummy_machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/dummy_machine.rs
@@ -125,7 +125,7 @@
bin_op: BinOp,
left: &interpret::ImmTy<'tcx, Self::Provenance>,
right: &interpret::ImmTy<'tcx, Self::Provenance>,
- ) -> interpret::InterpResult<'tcx, (ImmTy<'tcx, Self::Provenance>, bool)> {
+ ) -> interpret::InterpResult<'tcx, ImmTy<'tcx, Self::Provenance>> {
use rustc_middle::mir::BinOp::*;
Ok(match bin_op {
Eq | Ne | Lt | Le | Gt | Ge => {
@@ -154,7 +154,7 @@
Ge => left >= right,
_ => bug!(),
};
- (ImmTy::from_bool(res, *ecx.tcx), false)
+ ImmTy::from_bool(res, *ecx.tcx)
}
// Some more operations are possible with atomics.
diff --git a/compiler/rustc_const_eval/src/const_eval/error.rs b/compiler/rustc_const_eval/src/const_eval/error.rs
index 08c9609..7a1c2a7b 100644
--- a/compiler/rustc_const_eval/src/const_eval/error.rs
+++ b/compiler/rustc_const_eval/src/const_eval/error.rs
@@ -2,7 +2,7 @@
use rustc_errors::{DiagArgName, DiagArgValue, DiagMessage, Diagnostic, IntoDiagArg};
use rustc_hir::CRATE_HIR_ID;
-use rustc_middle::mir::interpret::Provenance;
+use rustc_middle::mir::interpret::{Provenance, ReportedErrorInfo};
use rustc_middle::mir::AssertKind;
use rustc_middle::query::TyCtxtAt;
use rustc_middle::ty::TyCtxt;
@@ -139,9 +139,10 @@
ErrorHandled::TooGeneric(span)
}
err_inval!(AlreadyReported(guar)) => ErrorHandled::Reported(guar, span),
- err_inval!(Layout(LayoutError::ReferencesError(guar))) => {
- ErrorHandled::Reported(guar.into(), span)
- }
+ err_inval!(Layout(LayoutError::ReferencesError(guar))) => ErrorHandled::Reported(
+ ReportedErrorInfo::tainted_by_errors(guar),
+ span,
+ ),
// Report remaining errors.
_ => {
let (our_span, frames) = get_span_and_frames();
diff --git a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
index 6a9a21b..966951e 100644
--- a/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
+++ b/compiler/rustc_const_eval/src/const_eval/eval_queries.rs
@@ -1,6 +1,7 @@
use std::sync::atomic::Ordering::Relaxed;
use either::{Left, Right};
+use tracing::{debug, instrument, trace};
use rustc_hir::def::DefKind;
use rustc_middle::bug;
diff --git a/compiler/rustc_const_eval/src/const_eval/machine.rs b/compiler/rustc_const_eval/src/const_eval/machine.rs
index 836e548..b8b4426 100644
--- a/compiler/rustc_const_eval/src/const_eval/machine.rs
+++ b/compiler/rustc_const_eval/src/const_eval/machine.rs
@@ -21,13 +21,14 @@
use rustc_span::Span;
use rustc_target::abi::{Align, Size};
use rustc_target::spec::abi::Abi as CallAbi;
+use tracing::debug;
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::*;
@@ -589,7 +590,7 @@
_bin_op: mir::BinOp,
_left: &ImmTy<'tcx>,
_right: &ImmTy<'tcx>,
- ) -> InterpResult<'tcx, (ImmTy<'tcx>, bool)> {
+ ) -> InterpResult<'tcx, ImmTy<'tcx>> {
throw_unsup_format!("pointer arithmetic or comparison is not supported at compile-time");
}
@@ -759,11 +760,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/const_eval/mod.rs b/compiler/rustc_const_eval/src/const_eval/mod.rs
index a5c8c0b..4ae4816 100644
--- a/compiler/rustc_const_eval/src/const_eval/mod.rs
+++ b/compiler/rustc_const_eval/src/const_eval/mod.rs
@@ -6,6 +6,7 @@
use rustc_middle::query::{Key, TyCtxtAt};
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_target::abi::VariantIdx;
+use tracing::instrument;
use crate::interpret::{format_interp_error, InterpCx};
diff --git a/compiler/rustc_const_eval/src/const_eval/valtrees.rs b/compiler/rustc_const_eval/src/const_eval/valtrees.rs
index fbf2ca5..b906bfa 100644
--- a/compiler/rustc_const_eval/src/const_eval/valtrees.rs
+++ b/compiler/rustc_const_eval/src/const_eval/valtrees.rs
@@ -6,6 +6,7 @@
use rustc_middle::ty::{self, ScalarInt, Ty, TyCtxt};
use rustc_span::DUMMY_SP;
use rustc_target::abi::{Abi, VariantIdx};
+use tracing::{debug, instrument, trace};
use super::eval_queries::{mk_eval_cx_to_read_const_val, op_to_const};
use super::machine::CompileTimeEvalContext;
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
index 90d4f11..e5ea4c3 100644
--- a/compiler/rustc_const_eval/src/errors.rs
+++ b/compiler/rustc_const_eval/src/errors.rs
@@ -1,5 +1,6 @@
use std::borrow::Cow;
+use either::Either;
use rustc_errors::{
codes::*, Diag, DiagArgValue, DiagCtxt, DiagMessage, Diagnostic, EmissionGuarantee, Level,
};
@@ -481,6 +482,8 @@
DivisionOverflow => const_eval_division_overflow,
RemainderOverflow => const_eval_remainder_overflow,
PointerArithOverflow => const_eval_pointer_arithmetic_overflow,
+ ArithOverflow { .. } => const_eval_overflow_arith,
+ ShiftOverflow { .. } => const_eval_overflow_shift,
InvalidMeta(InvalidMetaKind::SliceTooBig) => const_eval_invalid_meta_slice,
InvalidMeta(InvalidMetaKind::TooBig) => const_eval_invalid_meta,
UnterminatedCString(_) => const_eval_unterminated_c_string,
@@ -539,6 +542,19 @@
| UninhabitedEnumVariantWritten(_)
| UninhabitedEnumVariantRead(_) => {}
+ ArithOverflow { intrinsic } => {
+ diag.arg("intrinsic", intrinsic);
+ }
+ ShiftOverflow { intrinsic, shift_amount } => {
+ diag.arg("intrinsic", intrinsic);
+ diag.arg(
+ "shift_amount",
+ match shift_amount {
+ Either::Left(v) => v.to_string(),
+ Either::Right(v) => v.to_string(),
+ },
+ );
+ }
BoundsCheckFailed { len, index } => {
diag.arg("len", len);
diag.arg("index", index);
diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs
index 799e12f..ecfb25e 100644
--- a/compiler/rustc_const_eval/src/interpret/cast.rs
+++ b/compiler/rustc_const_eval/src/interpret/cast.rs
@@ -10,6 +10,7 @@
use rustc_middle::{bug, span_bug};
use rustc_target::abi::Integer;
use rustc_type_ir::TyKind::*;
+use tracing::trace;
use super::{
err_inval, throw_ub, throw_ub_custom, util::ensure_monomorphic_enough, FnVal, ImmTy, Immediate,
diff --git a/compiler/rustc_const_eval/src/interpret/discriminant.rs b/compiler/rustc_const_eval/src/interpret/discriminant.rs
index 8ddc741..0790f06 100644
--- a/compiler/rustc_const_eval/src/interpret/discriminant.rs
+++ b/compiler/rustc_const_eval/src/interpret/discriminant.rs
@@ -6,6 +6,7 @@
use rustc_middle::ty::{self, ScalarInt, Ty};
use rustc_target::abi::{self, TagEncoding};
use rustc_target::abi::{VariantIdx, Variants};
+use tracing::{instrument, trace};
use super::{
err_ub, throw_ub, ImmTy, InterpCx, InterpResult, Machine, Readable, Scalar, Writeable,
@@ -172,7 +173,7 @@
let tag_val = ImmTy::from_uint(tag_bits, tag_layout);
let niche_start_val = ImmTy::from_uint(niche_start, tag_layout);
let variant_index_relative_val =
- self.wrapping_binary_op(mir::BinOp::Sub, &tag_val, &niche_start_val)?;
+ self.binary_op(mir::BinOp::Sub, &tag_val, &niche_start_val)?;
let variant_index_relative =
variant_index_relative_val.to_scalar().assert_bits(tag_val.layout.size);
// Check if this is in the range that indicates an actual discriminant.
@@ -292,11 +293,7 @@
let variant_index_relative_val =
ImmTy::from_uint(variant_index_relative, tag_layout);
let tag = self
- .wrapping_binary_op(
- mir::BinOp::Add,
- &variant_index_relative_val,
- &niche_start_val,
- )?
+ .binary_op(mir::BinOp::Add, &variant_index_relative_val, &niche_start_val)?
.to_scalar()
.assert_int();
Ok(Some((tag, tag_field)))
diff --git a/compiler/rustc_const_eval/src/interpret/eval_context.rs b/compiler/rustc_const_eval/src/interpret/eval_context.rs
index 344bb7c..d82623f 100644
--- a/compiler/rustc_const_eval/src/interpret/eval_context.rs
+++ b/compiler/rustc_const_eval/src/interpret/eval_context.rs
@@ -2,6 +2,7 @@
use std::{fmt, mem};
use either::{Either, Left, Right};
+use tracing::{debug, info, info_span, instrument, trace};
use hir::CRATE_HIR_ID;
use rustc_errors::DiagCtxt;
@@ -1181,9 +1182,20 @@
) -> InterpResult<'tcx, OpTy<'tcx, M::Provenance>> {
M::eval_mir_constant(self, *val, span, layout, |ecx, val, span, layout| {
let const_val = val.eval(*ecx.tcx, ecx.param_env, span).map_err(|err| {
- if M::ALL_CONSTS_ARE_PRECHECKED && !matches!(err, ErrorHandled::TooGeneric(..)) {
- // Looks like the const is not captued by `required_consts`, that's bad.
- bug!("interpret const eval failure of {val:?} which is not in required_consts");
+ if M::ALL_CONSTS_ARE_PRECHECKED {
+ match err {
+ ErrorHandled::TooGeneric(..) => {},
+ ErrorHandled::Reported(reported, span) => {
+ if reported.is_tainted_by_errors() {
+ // const-eval will return "tainted" errors if e.g. the layout cannot
+ // be computed as the type references non-existing names.
+ // See <https://github.com/rust-lang/rust/issues/124348>.
+ } else {
+ // Looks like the const is not captued by `required_consts`, that's bad.
+ span_bug!(span, "interpret const eval failure of {val:?} which is not in required_consts");
+ }
+ }
+ }
}
err.emit_note(*ecx.tcx);
err
diff --git a/compiler/rustc_const_eval/src/interpret/intern.rs b/compiler/rustc_const_eval/src/interpret/intern.rs
index 3565b4f..c34b658 100644
--- a/compiler/rustc_const_eval/src/interpret/intern.rs
+++ b/compiler/rustc_const_eval/src/interpret/intern.rs
@@ -23,6 +23,7 @@
use rustc_middle::ty::layout::TyAndLayout;
use rustc_span::def_id::LocalDefId;
use rustc_span::sym;
+use tracing::{instrument, trace};
use super::{err_ub, AllocId, Allocation, InterpCx, MPlaceTy, Machine, MemoryKind, PlaceTy};
use crate::const_eval;
diff --git a/compiler/rustc_const_eval/src/interpret/intrinsics.rs b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
index dce4d56..3a8f8dc 100644
--- a/compiler/rustc_const_eval/src/interpret/intrinsics.rs
+++ b/compiler/rustc_const_eval/src/interpret/intrinsics.rs
@@ -14,6 +14,7 @@
};
use rustc_span::symbol::{sym, Symbol};
use rustc_target::abi::Size;
+use tracing::trace;
use super::{
err_inval, err_ub_custom, err_unsup_format, memory::MemoryKind, throw_inval, throw_ub_custom,
@@ -255,6 +256,7 @@
name = intrinsic_name,
);
}
+ // This will always return 0.
(a, b)
}
(Err(_), _) | (_, Err(_)) => {
@@ -285,9 +287,10 @@
let (val, overflowed) = {
let a_offset = ImmTy::from_uint(a_offset, usize_layout);
let b_offset = ImmTy::from_uint(b_offset, usize_layout);
- self.overflowing_binary_op(BinOp::Sub, &a_offset, &b_offset)?
+ self.binary_op(BinOp::SubWithOverflow, &a_offset, &b_offset)?
+ .to_scalar_pair()
};
- if overflowed {
+ if overflowed.to_bool()? {
// a < b
if intrinsic_name == sym::ptr_offset_from_unsigned {
throw_ub_custom!(
@@ -299,7 +302,7 @@
// The signed form of the intrinsic allows this. If we interpret the
// difference as isize, we'll get the proper signed difference. If that
// seems *positive*, they were more than isize::MAX apart.
- let dist = val.to_scalar().to_target_isize(self)?;
+ let dist = val.to_target_isize(self)?;
if dist >= 0 {
throw_ub_custom!(
fluent::const_eval_offset_from_underflow,
@@ -309,7 +312,7 @@
dist
} else {
// b >= a
- let dist = val.to_scalar().to_target_isize(self)?;
+ let dist = val.to_target_isize(self)?;
// If converting to isize produced a *negative* result, we had an overflow
// because they were more than isize::MAX apart.
if dist < 0 {
@@ -515,9 +518,8 @@
// Performs an exact division, resulting in undefined behavior where
// `x % y != 0` or `y == 0` or `x == T::MIN && y == -1`.
// First, check x % y != 0 (or if that computation overflows).
- let (res, overflow) = self.overflowing_binary_op(BinOp::Rem, a, b)?;
- assert!(!overflow); // All overflow is UB, so this should never return on overflow.
- if res.to_scalar().assert_bits(a.layout.size) != 0 {
+ let rem = self.binary_op(BinOp::Rem, a, b)?;
+ if rem.to_scalar().assert_bits(a.layout.size) != 0 {
throw_ub_custom!(
fluent::const_eval_exact_div_has_remainder,
a = format!("{a}"),
@@ -525,7 +527,8 @@
)
}
// `Rem` says this is all right, so we can let `Div` do its job.
- self.binop_ignore_overflow(BinOp::Div, a, b, &dest.clone().into())
+ let res = self.binary_op(BinOp::Div, a, b)?;
+ self.write_immediate(*res, dest)
}
pub fn saturating_arith(
@@ -538,8 +541,9 @@
assert!(matches!(l.layout.ty.kind(), ty::Int(..) | ty::Uint(..)));
assert!(matches!(mir_op, BinOp::Add | BinOp::Sub));
- let (val, overflowed) = self.overflowing_binary_op(mir_op, l, r)?;
- Ok(if overflowed {
+ let (val, overflowed) =
+ self.binary_op(mir_op.wrapping_to_overflowing().unwrap(), l, r)?.to_scalar_pair();
+ Ok(if overflowed.to_bool()? {
let size = l.layout.size;
let num_bits = size.bits();
if l.layout.abi.is_signed() {
@@ -570,7 +574,7 @@
}
}
} else {
- val.to_scalar()
+ val
})
}
diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs
index 2eaebc1..72a16db 100644
--- a/compiler/rustc_const_eval/src/interpret/machine.rs
+++ b/compiler/rustc_const_eval/src/interpret/machine.rs
@@ -252,7 +252,7 @@
bin_op: mir::BinOp,
left: &ImmTy<'tcx, Self::Provenance>,
right: &ImmTy<'tcx, Self::Provenance>,
- ) -> InterpResult<'tcx, (ImmTy<'tcx, Self::Provenance>, bool)>;
+ ) -> InterpResult<'tcx, ImmTy<'tcx, Self::Provenance>>;
/// Generate the NaN returned by a float operation, given the list of inputs.
/// (This is all inputs, not just NaN inputs!)
diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs
index 350fd48..23273e6 100644
--- a/compiler/rustc_const_eval/src/interpret/memory.rs
+++ b/compiler/rustc_const_eval/src/interpret/memory.rs
@@ -21,6 +21,8 @@
use rustc_middle::ty::{self, Instance, ParamEnv, Ty, TyCtxt};
use rustc_target::abi::{Align, HasDataLayout, Size};
+use tracing::{debug, instrument, trace};
+
use crate::fluent_generated as fluent;
use super::{
@@ -413,6 +415,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 +429,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 +452,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 +640,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/operand.rs b/compiler/rustc_const_eval/src/interpret/operand.rs
index bad9732..8f01b87 100644
--- a/compiler/rustc_const_eval/src/interpret/operand.rs
+++ b/compiler/rustc_const_eval/src/interpret/operand.rs
@@ -4,10 +4,11 @@
use std::assert_matches::assert_matches;
use either::{Either, Left, Right};
+use tracing::trace;
use rustc_hir::def::Namespace;
use rustc_middle::mir::interpret::ScalarSizeMismatch;
-use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
+use rustc_middle::ty::layout::{HasParamEnv, HasTyCtxt, LayoutOf, TyAndLayout};
use rustc_middle::ty::print::{FmtPrinter, PrettyPrinter};
use rustc_middle::ty::{ConstInt, ScalarInt, Ty, TyCtxt};
use rustc_middle::{bug, span_bug};
@@ -249,6 +250,15 @@
Self::from_scalar(Scalar::from_i8(c as i8), layout)
}
+ pub fn from_pair(a: Self, b: Self, tcx: TyCtxt<'tcx>) -> Self {
+ let layout = tcx
+ .layout_of(
+ ty::ParamEnv::reveal_all().and(Ty::new_tup(tcx, &[a.layout.ty, b.layout.ty])),
+ )
+ .unwrap();
+ Self::from_scalar_pair(a.to_scalar(), b.to_scalar(), layout)
+ }
+
/// Return the immediate as a `ScalarInt`. Ensures that it has the size that the layout of the
/// immediate indicates.
#[inline]
@@ -270,6 +280,17 @@
ConstInt::new(int, self.layout.ty.is_signed(), self.layout.ty.is_ptr_sized_integral())
}
+ #[inline]
+ #[cfg_attr(debug_assertions, track_caller)] // only in debug builds due to perf (see #98980)
+ pub fn to_pair(self, cx: &(impl HasTyCtxt<'tcx> + HasParamEnv<'tcx>)) -> (Self, Self) {
+ let layout = self.layout;
+ let (val0, val1) = self.to_scalar_pair();
+ (
+ ImmTy::from_scalar(val0, layout.field(cx, 0)),
+ ImmTy::from_scalar(val1, layout.field(cx, 1)),
+ )
+ }
+
/// Compute the "sub-immediate" that is located within the `base` at the given offset with the
/// given layout.
// Not called `offset` to avoid confusion with the trait method.
diff --git a/compiler/rustc_const_eval/src/interpret/operator.rs b/compiler/rustc_const_eval/src/interpret/operator.rs
index 5f59e3d..62641b8 100644
--- a/compiler/rustc_const_eval/src/interpret/operator.rs
+++ b/compiler/rustc_const_eval/src/interpret/operator.rs
@@ -1,78 +1,23 @@
+use either::Either;
+
use rustc_apfloat::{Float, FloatConvert};
use rustc_middle::mir;
use rustc_middle::mir::interpret::{InterpResult, Scalar};
use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
-use rustc_middle::ty::{self, FloatTy, ScalarInt, Ty};
+use rustc_middle::ty::{self, FloatTy, ScalarInt};
use rustc_middle::{bug, span_bug};
use rustc_span::symbol::sym;
-use rustc_target::abi::Abi;
+use tracing::trace;
-use super::{err_ub, throw_ub, throw_ub_custom, ImmTy, Immediate, InterpCx, Machine, PlaceTy};
-
-use crate::fluent_generated as fluent;
+use super::{err_ub, throw_ub, ImmTy, InterpCx, Machine};
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
- /// Applies the binary operation `op` to the two operands and writes a tuple of the result
- /// and a boolean signifying the potential overflow to the destination.
- pub fn binop_with_overflow(
- &mut self,
- op: mir::BinOp,
- left: &ImmTy<'tcx, M::Provenance>,
- right: &ImmTy<'tcx, M::Provenance>,
- dest: &PlaceTy<'tcx, M::Provenance>,
- ) -> InterpResult<'tcx> {
- let (val, overflowed) = self.overflowing_binary_op(op, left, right)?;
- debug_assert_eq!(
- Ty::new_tup(self.tcx.tcx, &[val.layout.ty, self.tcx.types.bool]),
- dest.layout.ty,
- "type mismatch for result of {op:?}",
- );
- // Write the result to `dest`.
- if let Abi::ScalarPair(..) = dest.layout.abi {
- // We can use the optimized path and avoid `place_field` (which might do
- // `force_allocation`).
- let pair = Immediate::ScalarPair(val.to_scalar(), Scalar::from_bool(overflowed));
- self.write_immediate(pair, dest)?;
- } else {
- assert!(self.tcx.sess.opts.unstable_opts.randomize_layout);
- // With randomized layout, `(int, bool)` might cease to be a `ScalarPair`, so we have to
- // do a component-wise write here. This code path is slower than the above because
- // `place_field` will have to `force_allocate` locals here.
- let val_field = self.project_field(dest, 0)?;
- self.write_scalar(val.to_scalar(), &val_field)?;
- let overflowed_field = self.project_field(dest, 1)?;
- self.write_scalar(Scalar::from_bool(overflowed), &overflowed_field)?;
- }
- Ok(())
- }
-
- /// Applies the binary operation `op` to the arguments and writes the result to the
- /// destination.
- pub fn binop_ignore_overflow(
- &mut self,
- op: mir::BinOp,
- left: &ImmTy<'tcx, M::Provenance>,
- right: &ImmTy<'tcx, M::Provenance>,
- dest: &PlaceTy<'tcx, M::Provenance>,
- ) -> InterpResult<'tcx> {
- let val = self.wrapping_binary_op(op, left, right)?;
- assert_eq!(val.layout.ty, dest.layout.ty, "type mismatch for result of {op:?}");
- self.write_immediate(*val, dest)
- }
-}
-
-impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
- fn three_way_compare<T: Ord>(&self, lhs: T, rhs: T) -> (ImmTy<'tcx, M::Provenance>, bool) {
+ fn three_way_compare<T: Ord>(&self, lhs: T, rhs: T) -> ImmTy<'tcx, M::Provenance> {
let res = Ord::cmp(&lhs, &rhs);
- return (ImmTy::from_ordering(res, *self.tcx), false);
+ return ImmTy::from_ordering(res, *self.tcx);
}
- fn binary_char_op(
- &self,
- bin_op: mir::BinOp,
- l: char,
- r: char,
- ) -> (ImmTy<'tcx, M::Provenance>, bool) {
+ fn binary_char_op(&self, bin_op: mir::BinOp, l: char, r: char) -> ImmTy<'tcx, M::Provenance> {
use rustc_middle::mir::BinOp::*;
if bin_op == Cmp {
@@ -88,15 +33,10 @@
Ge => l >= r,
_ => span_bug!(self.cur_span(), "Invalid operation on char: {:?}", bin_op),
};
- (ImmTy::from_bool(res, *self.tcx), false)
+ ImmTy::from_bool(res, *self.tcx)
}
- fn binary_bool_op(
- &self,
- bin_op: mir::BinOp,
- l: bool,
- r: bool,
- ) -> (ImmTy<'tcx, M::Provenance>, bool) {
+ fn binary_bool_op(&self, bin_op: mir::BinOp, l: bool, r: bool) -> ImmTy<'tcx, M::Provenance> {
use rustc_middle::mir::BinOp::*;
let res = match bin_op {
@@ -111,7 +51,7 @@
BitXor => l ^ r,
_ => span_bug!(self.cur_span(), "Invalid operation on bool: {:?}", bin_op),
};
- (ImmTy::from_bool(res, *self.tcx), false)
+ ImmTy::from_bool(res, *self.tcx)
}
fn binary_float_op<F: Float + FloatConvert<F> + Into<Scalar<M::Provenance>>>(
@@ -120,14 +60,14 @@
layout: TyAndLayout<'tcx>,
l: F,
r: F,
- ) -> (ImmTy<'tcx, M::Provenance>, bool) {
+ ) -> ImmTy<'tcx, M::Provenance> {
use rustc_middle::mir::BinOp::*;
// Performs appropriate non-deterministic adjustments of NaN results.
let adjust_nan =
|f: F| -> F { if f.is_nan() { M::generate_nan(self, &[l, r]) } else { f } };
- let val = match bin_op {
+ match bin_op {
Eq => ImmTy::from_bool(l == r, *self.tcx),
Ne => ImmTy::from_bool(l != r, *self.tcx),
Lt => ImmTy::from_bool(l < r, *self.tcx),
@@ -140,8 +80,7 @@
Div => ImmTy::from_scalar(adjust_nan((l / r).value).into(), layout),
Rem => ImmTy::from_scalar(adjust_nan((l % r).value).into(), layout),
_ => span_bug!(self.cur_span(), "invalid float op: `{:?}`", bin_op),
- };
- (val, false)
+ }
}
fn binary_int_op(
@@ -149,7 +88,7 @@
bin_op: mir::BinOp,
left: &ImmTy<'tcx, M::Provenance>,
right: &ImmTy<'tcx, M::Provenance>,
- ) -> InterpResult<'tcx, (ImmTy<'tcx, M::Provenance>, bool)> {
+ ) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
use rustc_middle::mir::BinOp::*;
// This checks the size, so that we can just assert it below.
@@ -169,25 +108,27 @@
ShrUnchecked => Some(sym::unchecked_shr),
_ => None,
};
+ let with_overflow = bin_op.is_overflowing();
// Shift ops can have an RHS with a different numeric type.
if matches!(bin_op, Shl | ShlUnchecked | Shr | ShrUnchecked) {
let size = left.layout.size.bits();
- // The shift offset is implicitly masked to the type size. (This is the one MIR operator
- // that does *not* directly map to a single LLVM operation.) Compute how much we
- // actually shift and whether there was an overflow due to shifting too much.
+ // Compute the equivalent shift modulo `size` that is in the range `0..size`. (This is
+ // the one MIR operator that does *not* directly map to a single LLVM operation.)
let (shift_amount, overflow) = if right.layout.abi.is_signed() {
let shift_amount = r_signed();
let overflow = shift_amount < 0 || shift_amount >= i128::from(size);
// Deliberately wrapping `as` casts: shift_amount *can* be negative, but the result
// of the `as` will be equal modulo `size` (since it is a power of two).
let masked_amount = (shift_amount as u128) % u128::from(size);
- assert_eq!(overflow, shift_amount != (masked_amount as i128));
+ assert_eq!(overflow, shift_amount != i128::try_from(masked_amount).unwrap());
(masked_amount, overflow)
} else {
let shift_amount = r_unsigned();
+ let overflow = shift_amount >= u128::from(size);
let masked_amount = shift_amount % u128::from(size);
- (masked_amount, shift_amount != masked_amount)
+ assert_eq!(overflow, shift_amount != masked_amount);
+ (masked_amount, overflow)
};
let shift_amount = u32::try_from(shift_amount).unwrap(); // we masked so this will always fit
// Compute the shifted result.
@@ -209,19 +150,18 @@
ScalarInt::truncate_from_uint(result, left.layout.size).0
};
- if overflow && let Some(intrinsic_name) = throw_ub_on_overflow {
- throw_ub_custom!(
- fluent::const_eval_overflow_shift,
- val = if right.layout.abi.is_signed() {
- r_signed().to_string()
+ if overflow && let Some(intrinsic) = throw_ub_on_overflow {
+ throw_ub!(ShiftOverflow {
+ intrinsic,
+ shift_amount: if right.layout.abi.is_signed() {
+ Either::Right(r_signed())
} else {
- r_unsigned().to_string()
- },
- name = intrinsic_name
- );
+ Either::Left(r_unsigned())
+ }
+ });
}
- return Ok((ImmTy::from_scalar_int(result, left.layout), overflow));
+ return Ok(ImmTy::from_scalar_int(result, left.layout));
}
// For the remaining ops, the types must be the same on both sides
@@ -246,7 +186,7 @@
_ => None,
};
if let Some(op) = op {
- return Ok((ImmTy::from_bool(op(&l_signed(), &r_signed()), *self.tcx), false));
+ return Ok(ImmTy::from_bool(op(&l_signed(), &r_signed()), *self.tcx));
}
if bin_op == Cmp {
return Ok(self.three_way_compare(l_signed(), r_signed()));
@@ -256,9 +196,9 @@
Rem if r.is_null() => throw_ub!(RemainderByZero),
Div => Some(i128::overflowing_div),
Rem => Some(i128::overflowing_rem),
- Add | AddUnchecked => Some(i128::overflowing_add),
- Sub | SubUnchecked => Some(i128::overflowing_sub),
- Mul | MulUnchecked => Some(i128::overflowing_mul),
+ Add | AddUnchecked | AddWithOverflow => Some(i128::overflowing_add),
+ Sub | SubUnchecked | SubWithOverflow => Some(i128::overflowing_sub),
+ Mul | MulUnchecked | MulWithOverflow => Some(i128::overflowing_mul),
_ => None,
};
if let Some(op) = op {
@@ -282,10 +222,16 @@
// If that truncation loses any information, we have an overflow.
let (result, lossy) = ScalarInt::truncate_from_int(result, left.layout.size);
let overflow = oflo || lossy;
- if overflow && let Some(intrinsic_name) = throw_ub_on_overflow {
- throw_ub_custom!(fluent::const_eval_overflow, name = intrinsic_name);
+ if overflow && let Some(intrinsic) = throw_ub_on_overflow {
+ throw_ub!(ArithOverflow { intrinsic });
}
- return Ok((ImmTy::from_scalar_int(result, left.layout), overflow));
+ let res = ImmTy::from_scalar_int(result, left.layout);
+ return Ok(if with_overflow {
+ let overflow = ImmTy::from_bool(overflow, *self.tcx);
+ ImmTy::from_pair(res, overflow, *self.tcx)
+ } else {
+ res
+ });
}
}
// From here on it's okay to treat everything as unsigned.
@@ -296,7 +242,7 @@
return Ok(self.three_way_compare(l, r));
}
- let val = match bin_op {
+ Ok(match bin_op {
Eq => ImmTy::from_bool(l == r, *self.tcx),
Ne => ImmTy::from_bool(l != r, *self.tcx),
@@ -309,40 +255,42 @@
BitAnd => ImmTy::from_uint(l & r, left.layout),
BitXor => ImmTy::from_uint(l ^ r, left.layout),
- Add | AddUnchecked | Sub | SubUnchecked | Mul | MulUnchecked | Rem | Div => {
+ _ => {
assert!(!left.layout.abi.is_signed());
let op: fn(u128, u128) -> (u128, bool) = match bin_op {
- Add | AddUnchecked => u128::overflowing_add,
- Sub | SubUnchecked => u128::overflowing_sub,
- Mul | MulUnchecked => u128::overflowing_mul,
+ Add | AddUnchecked | AddWithOverflow => u128::overflowing_add,
+ Sub | SubUnchecked | SubWithOverflow => u128::overflowing_sub,
+ Mul | MulUnchecked | MulWithOverflow => u128::overflowing_mul,
Div if r == 0 => throw_ub!(DivisionByZero),
Rem if r == 0 => throw_ub!(RemainderByZero),
Div => u128::overflowing_div,
Rem => u128::overflowing_rem,
- _ => bug!(),
+ _ => span_bug!(
+ self.cur_span(),
+ "invalid binary op {:?}: {:?}, {:?} (both {})",
+ bin_op,
+ left,
+ right,
+ right.layout.ty,
+ ),
};
let (result, oflo) = op(l, r);
// Truncate to target type.
// If that truncation loses any information, we have an overflow.
let (result, lossy) = ScalarInt::truncate_from_uint(result, left.layout.size);
let overflow = oflo || lossy;
- if overflow && let Some(intrinsic_name) = throw_ub_on_overflow {
- throw_ub_custom!(fluent::const_eval_overflow, name = intrinsic_name);
+ if overflow && let Some(intrinsic) = throw_ub_on_overflow {
+ throw_ub!(ArithOverflow { intrinsic });
}
- return Ok((ImmTy::from_scalar_int(result, left.layout), overflow));
+ let res = ImmTy::from_scalar_int(result, left.layout);
+ if with_overflow {
+ let overflow = ImmTy::from_bool(overflow, *self.tcx);
+ ImmTy::from_pair(res, overflow, *self.tcx)
+ } else {
+ res
+ }
}
-
- _ => span_bug!(
- self.cur_span(),
- "invalid binary op {:?}: {:?}, {:?} (both {})",
- bin_op,
- left,
- right,
- right.layout.ty,
- ),
- };
-
- Ok((val, false))
+ })
}
fn binary_ptr_op(
@@ -350,7 +298,7 @@
bin_op: mir::BinOp,
left: &ImmTy<'tcx, M::Provenance>,
right: &ImmTy<'tcx, M::Provenance>,
- ) -> InterpResult<'tcx, (ImmTy<'tcx, M::Provenance>, bool)> {
+ ) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
use rustc_middle::mir::BinOp::*;
match bin_op {
@@ -369,10 +317,7 @@
offset_count.checked_mul(pointee_size).ok_or(err_ub!(PointerArithOverflow))?;
let offset_ptr = self.ptr_offset_inbounds(ptr, offset_bytes)?;
- Ok((
- ImmTy::from_scalar(Scalar::from_maybe_pointer(offset_ptr, self), left.layout),
- false,
- ))
+ Ok(ImmTy::from_scalar(Scalar::from_maybe_pointer(offset_ptr, self), left.layout))
}
// Fall back to machine hook so Miri can support more pointer ops.
@@ -380,13 +325,15 @@
}
}
- /// Returns the result of the specified operation, and whether it overflowed.
- pub fn overflowing_binary_op(
+ /// Returns the result of the specified operation.
+ ///
+ /// Whether this produces a scalar or a pair depends on the specific `bin_op`.
+ pub fn binary_op(
&self,
bin_op: mir::BinOp,
left: &ImmTy<'tcx, M::Provenance>,
right: &ImmTy<'tcx, M::Provenance>,
- ) -> InterpResult<'tcx, (ImmTy<'tcx, M::Provenance>, bool)> {
+ ) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
trace!(
"Running binary op {:?}: {:?} ({}), {:?} ({})",
bin_op,
@@ -458,24 +405,13 @@
}
}
- #[inline]
- pub fn wrapping_binary_op(
- &self,
- bin_op: mir::BinOp,
- left: &ImmTy<'tcx, M::Provenance>,
- right: &ImmTy<'tcx, M::Provenance>,
- ) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
- let (val, _overflow) = self.overflowing_binary_op(bin_op, left, right)?;
- Ok(val)
- }
-
/// Returns the result of the specified operation, whether it overflowed, and
/// the result type.
- pub fn overflowing_unary_op(
+ pub fn unary_op(
&self,
un_op: mir::UnOp,
val: &ImmTy<'tcx, M::Provenance>,
- ) -> InterpResult<'tcx, (ImmTy<'tcx, M::Provenance>, bool)> {
+ ) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
use rustc_middle::mir::UnOp::*;
let layout = val.layout;
@@ -489,7 +425,7 @@
Not => !val,
_ => span_bug!(self.cur_span(), "Invalid bool op {:?}", un_op),
};
- Ok((ImmTy::from_bool(res, *self.tcx), false))
+ Ok(ImmTy::from_bool(res, *self.tcx))
}
ty::Float(fty) => {
// No NaN adjustment here, `-` is a bitwise operation!
@@ -498,37 +434,25 @@
(Neg, FloatTy::F64) => Scalar::from_f64(-val.to_f64()?),
_ => span_bug!(self.cur_span(), "Invalid float op {:?}", un_op),
};
- Ok((ImmTy::from_scalar(res, layout), false))
+ Ok(ImmTy::from_scalar(res, layout))
}
_ => {
assert!(layout.ty.is_integral());
let val = val.to_bits(layout.size)?;
- let (res, overflow) = match un_op {
- Not => (self.truncate(!val, layout), false), // bitwise negation, then truncate
+ let res = match un_op {
+ Not => self.truncate(!val, layout), // bitwise negation, then truncate
Neg => {
// arithmetic negation
assert!(layout.abi.is_signed());
let val = self.sign_extend(val, layout) as i128;
- let (res, overflow) = val.overflowing_neg();
+ let res = val.wrapping_neg();
let res = res as u128;
// Truncate to target type.
- // If that truncation loses any information, we have an overflow.
- let truncated = self.truncate(res, layout);
- (truncated, overflow || self.sign_extend(truncated, layout) != res)
+ self.truncate(res, layout)
}
};
- Ok((ImmTy::from_uint(res, layout), overflow))
+ Ok(ImmTy::from_uint(res, layout))
}
}
}
-
- #[inline]
- pub fn wrapping_unary_op(
- &self,
- un_op: mir::UnOp,
- val: &ImmTy<'tcx, M::Provenance>,
- ) -> InterpResult<'tcx, ImmTy<'tcx, M::Provenance>> {
- let (val, _overflow) = self.overflowing_unary_op(un_op, val)?;
- Ok(val)
- }
}
diff --git a/compiler/rustc_const_eval/src/interpret/place.rs b/compiler/rustc_const_eval/src/interpret/place.rs
index 9ced825..588db0f 100644
--- a/compiler/rustc_const_eval/src/interpret/place.rs
+++ b/compiler/rustc_const_eval/src/interpret/place.rs
@@ -5,6 +5,7 @@
use std::assert_matches::assert_matches;
use either::{Either, Left, Right};
+use tracing::{instrument, trace};
use rustc_ast::Mutability;
use rustc_middle::mir;
diff --git a/compiler/rustc_const_eval/src/interpret/projection.rs b/compiler/rustc_const_eval/src/interpret/projection.rs
index 0a2fedb..cfc4d70 100644
--- a/compiler/rustc_const_eval/src/interpret/projection.rs
+++ b/compiler/rustc_const_eval/src/interpret/projection.rs
@@ -18,6 +18,8 @@
use rustc_target::abi::Size;
use rustc_target::abi::{self, VariantIdx};
+use tracing::{debug, instrument};
+
use super::{
throw_ub, throw_unsup_format, InterpCx, InterpResult, MPlaceTy, Machine, MemPlaceMeta, OpTy,
Provenance, Scalar,
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index cb72d55..58210fe 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -3,6 +3,7 @@
//! The main entry point is the `step` method.
use either::Either;
+use tracing::{info, instrument, trace};
use rustc_index::IndexSlice;
use rustc_middle::mir;
@@ -167,19 +168,17 @@
let left = self.read_immediate(&self.eval_operand(left, layout)?)?;
let layout = util::binop_right_homogeneous(bin_op).then_some(left.layout);
let right = self.read_immediate(&self.eval_operand(right, layout)?)?;
- if let Some(bin_op) = bin_op.overflowing_to_wrapping() {
- self.binop_with_overflow(bin_op, &left, &right, &dest)?;
- } else {
- self.binop_ignore_overflow(bin_op, &left, &right, &dest)?;
- }
+ let result = self.binary_op(bin_op, &left, &right)?;
+ assert_eq!(result.layout, dest.layout, "layout mismatch for result of {bin_op:?}");
+ self.write_immediate(*result, &dest)?;
}
UnaryOp(un_op, ref operand) => {
// The operand always has the same type as the result.
let val = self.read_immediate(&self.eval_operand(operand, Some(dest.layout))?)?;
- let val = self.wrapping_unary_op(un_op, &val)?;
- assert_eq!(val.layout, dest.layout, "layout mismatch for result of {un_op:?}");
- self.write_immediate(*val, &dest)?;
+ let result = self.unary_op(un_op, &val)?;
+ assert_eq!(result.layout, dest.layout, "layout mismatch for result of {un_op:?}");
+ self.write_immediate(*result, &dest)?;
}
Aggregate(box ref kind, ref operands) => {
diff --git a/compiler/rustc_const_eval/src/interpret/terminator.rs b/compiler/rustc_const_eval/src/interpret/terminator.rs
index b82c185..360cefb 100644
--- a/compiler/rustc_const_eval/src/interpret/terminator.rs
+++ b/compiler/rustc_const_eval/src/interpret/terminator.rs
@@ -1,6 +1,7 @@
use std::borrow::Cow;
use either::Either;
+use tracing::trace;
use rustc_middle::span_bug;
use rustc_middle::{
@@ -97,7 +98,7 @@
for (const_int, target) in targets.iter() {
// Compare using MIR BinOp::Eq, to also support pointer values.
// (Avoiding `self.binary_op` as that does some redundant layout computation.)
- let res = self.wrapping_binary_op(
+ let res = self.binary_op(
mir::BinOp::Eq,
&discr,
&ImmTy::from_uint(const_int, discr.layout),
diff --git a/compiler/rustc_const_eval/src/interpret/traits.rs b/compiler/rustc_const_eval/src/interpret/traits.rs
index b603ef0..8b59045 100644
--- a/compiler/rustc_const_eval/src/interpret/traits.rs
+++ b/compiler/rustc_const_eval/src/interpret/traits.rs
@@ -2,6 +2,7 @@
use rustc_middle::ty::layout::LayoutOf;
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_target::abi::{Align, Size};
+use tracing::trace;
use super::util::ensure_monomorphic_enough;
use super::{InterpCx, Machine};
diff --git a/compiler/rustc_const_eval/src/interpret/util.rs b/compiler/rustc_const_eval/src/interpret/util.rs
index e304d1e..f0f9df7 100644
--- a/compiler/rustc_const_eval/src/interpret/util.rs
+++ b/compiler/rustc_const_eval/src/interpret/util.rs
@@ -7,6 +7,7 @@
self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
};
use std::ops::ControlFlow;
+use tracing::debug;
use super::{throw_inval, InterpCx, MPlaceTy, MemPlaceMeta, MemoryKind};
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 2bd4d9d..cf6027a 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -8,6 +8,7 @@
use std::num::NonZero;
use either::{Left, Right};
+use tracing::trace;
use hir::def::DefKind;
use rustc_ast::Mutability;
@@ -434,6 +435,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 +462,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 +501,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 +838,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_const_eval/src/interpret/visitor.rs b/compiler/rustc_const_eval/src/interpret/visitor.rs
index 59bcc51..692eb6c 100644
--- a/compiler/rustc_const_eval/src/interpret/visitor.rs
+++ b/compiler/rustc_const_eval/src/interpret/visitor.rs
@@ -6,6 +6,7 @@
use rustc_middle::ty::{self, Ty};
use rustc_target::abi::FieldIdx;
use rustc_target::abi::{FieldsShape, VariantIdx, Variants};
+use tracing::trace;
use std::num::NonZero;
diff --git a/compiler/rustc_const_eval/src/lib.rs b/compiler/rustc_const_eval/src/lib.rs
index 7b293e2..b14780c 100644
--- a/compiler/rustc_const_eval/src/lib.rs
+++ b/compiler/rustc_const_eval/src/lib.rs
@@ -14,9 +14,6 @@
#![feature(yeet_expr)]
#![feature(if_let_guard)]
-#[macro_use]
-extern crate tracing;
-
pub mod const_eval;
mod errors;
pub mod interpret;
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/check.rs b/compiler/rustc_const_eval/src/transform/check_consts/check.rs
index c8c5414..5fbf5b4 100644
--- a/compiler/rustc_const_eval/src/transform/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/transform/check_consts/check.rs
@@ -20,6 +20,8 @@
use std::mem;
use std::ops::Deref;
+use tracing::{debug, instrument, trace};
+
use super::ops::{self, NonConstOp, Status};
use super::qualifs::{self, HasMutInterior, NeedsDrop, NeedsNonConstDrop};
use super::resolver::FlowSensitiveAnalysis;
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/ops.rs b/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
index 8775685..8406e0f 100644
--- a/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
+++ b/compiler/rustc_const_eval/src/transform/check_consts/ops.rs
@@ -19,6 +19,7 @@
use rustc_span::symbol::sym;
use rustc_span::{BytePos, Pos, Span, Symbol};
use rustc_trait_selection::traits::SelectionContext;
+use tracing::debug;
use super::ConstCx;
use crate::errors;
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/post_drop_elaboration.rs b/compiler/rustc_const_eval/src/transform/check_consts/post_drop_elaboration.rs
index 5cd1378..f0763f1 100644
--- a/compiler/rustc_const_eval/src/transform/check_consts/post_drop_elaboration.rs
+++ b/compiler/rustc_const_eval/src/transform/check_consts/post_drop_elaboration.rs
@@ -2,6 +2,7 @@
use rustc_middle::mir::{self, BasicBlock, Location};
use rustc_middle::ty::{Ty, TyCtxt};
use rustc_span::{symbol::sym, Span};
+use tracing::trace;
use super::check::Qualifs;
use super::ops::{self, NonConstOp};
diff --git a/compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs
index 7e8a208..5949444 100644
--- a/compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs
+++ b/compiler/rustc_const_eval/src/transform/check_consts/qualifs.rs
@@ -13,6 +13,7 @@
use rustc_trait_selection::traits::{
ImplSource, Obligation, ObligationCause, ObligationCtxt, SelectionContext,
};
+use tracing::{instrument, trace};
use super::ConstCx;
diff --git a/compiler/rustc_const_eval/src/util/alignment.rs b/compiler/rustc_const_eval/src/util/alignment.rs
index 8642dfc..528274e 100644
--- a/compiler/rustc_const_eval/src/util/alignment.rs
+++ b/compiler/rustc_const_eval/src/util/alignment.rs
@@ -1,6 +1,7 @@
use rustc_middle::mir::*;
use rustc_middle::ty::{self, TyCtxt};
use rustc_target::abi::Align;
+use tracing::debug;
/// Returns `true` if this place is allowed to be less aligned
/// than its containing struct (because it is within a packed
diff --git a/compiler/rustc_const_eval/src/util/caller_location.rs b/compiler/rustc_const_eval/src/util/caller_location.rs
index 403bc1e..bc5fe39 100644
--- a/compiler/rustc_const_eval/src/util/caller_location.rs
+++ b/compiler/rustc_const_eval/src/util/caller_location.rs
@@ -5,6 +5,7 @@
use rustc_middle::ty::layout::LayoutOf;
use rustc_middle::ty::{self, Mutability};
use rustc_span::symbol::Symbol;
+use tracing::trace;
use crate::const_eval::{mk_eval_cx_to_read_const_val, CanAccessMutGlobal, CompileTimeEvalContext};
use crate::interpret::*;
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_error_messages/src/lib.rs b/compiler/rustc_error_messages/src/lib.rs
index ad82c2d..2a8f422 100644
--- a/compiler/rustc_error_messages/src/lib.rs
+++ b/compiler/rustc_error_messages/src/lib.rs
@@ -5,9 +5,6 @@
#![feature(type_alias_impl_trait)]
#![allow(internal_features)]
-#[macro_use]
-extern crate tracing;
-
use fluent_bundle::FluentResource;
use fluent_syntax::parser::ParserError;
use icu_provider_adapters::fallback::{LocaleFallbackProvider, LocaleFallbacker};
@@ -20,6 +17,7 @@
use std::fs;
use std::io;
use std::path::{Path, PathBuf};
+use tracing::{instrument, trace};
#[cfg(not(parallel_compiler))]
use std::cell::LazyCell as Lazy;
diff --git a/compiler/rustc_errors/src/diagnostic_impls.rs b/compiler/rustc_errors/src/diagnostic_impls.rs
index 662c8a7..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 {
diff --git a/compiler/rustc_expand/src/mbe.rs b/compiler/rustc_expand/src/mbe.rs
index a805c4f..08d4a03 100644
--- a/compiler/rustc_expand/src/mbe.rs
+++ b/compiler/rustc_expand/src/mbe.rs
@@ -68,12 +68,15 @@
/// `MetaVarExpr` are "first-class" token trees. Useful for parsing macros.
#[derive(Debug, PartialEq, Encodable, Decodable)]
enum TokenTree {
+ /// A token. Unlike `tokenstream::TokenTree::Token` this lacks a `Spacing`.
+ /// See the comments about `Spacing` in the `transcribe` function.
Token(Token),
/// A delimited sequence, e.g. `($e:expr)` (RHS) or `{ $e }` (LHS).
Delimited(DelimSpan, DelimSpacing, Delimited),
/// A kleene-style repetition sequence, e.g. `$($e:expr)*` (RHS) or `$($e),*` (LHS).
Sequence(DelimSpan, SequenceRepetition),
- /// e.g., `$var`.
+ /// e.g., `$var`. The span covers the leading dollar and the ident. (The span within the ident
+ /// only covers the ident, e.g. `var`.)
MetaVar(Span, Ident),
/// e.g., `$var:expr`. Only appears on the LHS.
MetaVarDecl(Span, Ident /* name to bind */, Option<NonterminalKind>),
diff --git a/compiler/rustc_expand/src/mbe/quoted.rs b/compiler/rustc_expand/src/mbe/quoted.rs
index d3ea48e..8ad7cb1 100644
--- a/compiler/rustc_expand/src/mbe/quoted.rs
+++ b/compiler/rustc_expand/src/mbe/quoted.rs
@@ -62,7 +62,10 @@
match tree {
TokenTree::MetaVar(start_sp, ident) if parsing_patterns => {
let span = match trees.next() {
- Some(&tokenstream::TokenTree::Token(Token { kind: token::Colon, span }, _)) => {
+ Some(&tokenstream::TokenTree::Token(
+ Token { kind: token::Colon, span: colon_span },
+ _,
+ )) => {
match trees.next() {
Some(tokenstream::TokenTree::Token(token, _)) => match token.ident() {
Some((fragment, _)) => {
@@ -126,10 +129,12 @@
}
_ => token.span,
},
- tree => tree.map_or(span, tokenstream::TokenTree::span),
+ Some(tree) => tree.span(),
+ None => colon_span,
}
}
- tree => tree.map_or(start_sp, tokenstream::TokenTree::span),
+ Some(tree) => tree.span(),
+ None => start_sp,
};
result.push(TokenTree::MetaVarDecl(span, ident, None));
@@ -176,7 +181,7 @@
// Depending on what `tree` is, we could be parsing different parts of a macro
match tree {
// `tree` is a `$` token. Look at the next token in `trees`
- &tokenstream::TokenTree::Token(Token { kind: token::Dollar, span }, _) => {
+ &tokenstream::TokenTree::Token(Token { kind: token::Dollar, span: dollar_span }, _) => {
// FIXME: Handle `Invisible`-delimited groups in a more systematic way
// during parsing.
let mut next = outer_trees.next();
@@ -209,7 +214,7 @@
err.emit();
// Returns early the same read `$` to avoid spanning
// unrelated diagnostics that could be performed afterwards
- return TokenTree::token(token::Dollar, span);
+ return TokenTree::token(token::Dollar, dollar_span);
}
Ok(elem) => {
maybe_emit_macro_metavar_expr_feature(
@@ -251,7 +256,7 @@
// special metavariable that names the crate of the invocation.
Some(tokenstream::TokenTree::Token(token, _)) if token.is_ident() => {
let (ident, is_raw) = token.ident().unwrap();
- let span = ident.span.with_lo(span.lo());
+ let span = ident.span.with_lo(dollar_span.lo());
if ident.name == kw::Crate && matches!(is_raw, IdentIsRaw::No) {
TokenTree::token(token::Ident(kw::DollarCrate, is_raw), span)
} else {
@@ -260,16 +265,19 @@
}
// `tree` is followed by another `$`. This is an escaped `$`.
- Some(&tokenstream::TokenTree::Token(Token { kind: token::Dollar, span }, _)) => {
+ Some(&tokenstream::TokenTree::Token(
+ Token { kind: token::Dollar, span: dollar_span2 },
+ _,
+ )) => {
if parsing_patterns {
span_dollar_dollar_or_metavar_in_the_lhs_err(
sess,
- &Token { kind: token::Dollar, span },
+ &Token { kind: token::Dollar, span: dollar_span2 },
);
} else {
- maybe_emit_macro_metavar_expr_feature(features, sess, span);
+ maybe_emit_macro_metavar_expr_feature(features, sess, dollar_span2);
}
- TokenTree::token(token::Dollar, span)
+ TokenTree::token(token::Dollar, dollar_span2)
}
// `tree` is followed by some other token. This is an error.
@@ -281,7 +289,7 @@
}
// There are no more tokens. Just return the `$` we already have.
- None => TokenTree::token(token::Dollar, span),
+ None => TokenTree::token(token::Dollar, dollar_span),
}
}
diff --git a/compiler/rustc_expand/src/mbe/transcribe.rs b/compiler/rustc_expand/src/mbe/transcribe.rs
index 3901b82..8a084dc 100644
--- a/compiler/rustc_expand/src/mbe/transcribe.rs
+++ b/compiler/rustc_expand/src/mbe/transcribe.rs
@@ -253,8 +253,23 @@
mbe::TokenTree::MetaVar(mut sp, mut original_ident) => {
// Find the matched nonterminal from the macro invocation, and use it to replace
// the meta-var.
+ //
+ // We use `Spacing::Alone` everywhere here, because that's the conservative choice
+ // and spacing of declarative macros is tricky. E.g. in this macro:
+ // ```
+ // macro_rules! idents {
+ // ($($a:ident,)*) => { stringify!($($a)*) }
+ // }
+ // ```
+ // `$a` has no whitespace after it and will be marked `JointHidden`. If you then
+ // call `idents!(x,y,z,)`, each of `x`, `y`, and `z` will be marked as `Joint`. So
+ // if you choose to use `$x`'s spacing or the identifier's spacing, you'll end up
+ // producing "xyz", which is bad because it effectively merges tokens.
+ // `Spacing::Alone` is the safer option. Fortunately, `space_between` will avoid
+ // some of the unnecessary whitespace.
let ident = MacroRulesNormalizedIdent::new(original_ident);
if let Some(cur_matched) = lookup_cur_matched(ident, interp, &repeats) {
+ // njn: explain the use of alone here
let tt = match cur_matched {
MatchedSingle(ParseNtResult::Tt(tt)) => {
// `tt`s are emitted into the output stream directly as "raw tokens",
diff --git a/compiler/rustc_expand/src/proc_macro_server.rs b/compiler/rustc_expand/src/proc_macro_server.rs
index 1f3547c..ec7e441 100644
--- a/compiler/rustc_expand/src/proc_macro_server.rs
+++ b/compiler/rustc_expand/src/proc_macro_server.rs
@@ -309,10 +309,10 @@
use rustc_ast::token::*;
// The code below is conservative, using `token_alone`/`Spacing::Alone`
- // in most places. When the resulting code is pretty-printed by
- // `print_tts` it ends up with spaces between most tokens, which is
- // safe but ugly. It's hard in general to do better when working at the
- // token level.
+ // in most places. It's hard in general to do better when working at
+ // the token level. When the resulting code is pretty-printed by
+ // `print_tts` the `space_between` function helps avoid a lot of
+ // unnecessary whitespace, so the results aren't too bad.
let (tree, rustc) = self;
match tree {
TokenTree::Punct(Punct { ch, joint, span }) => {
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/messages.ftl b/compiler/rustc_hir_analysis/messages.ftl
index 3edea01..cf492a2 100644
--- a/compiler/rustc_hir_analysis/messages.ftl
+++ b/compiler/rustc_hir_analysis/messages.ftl
@@ -371,9 +371,9 @@
.suggestion = cast the value to `{$cast_ty}`
.help = cast the value to `{$cast_ty}`
-hir_analysis_pattern_type_non_const_range = "range patterns must have constant range start and end"
-hir_analysis_pattern_type_wild_pat = "wildcard patterns are not permitted for pattern types"
- .label = "this type is the same as the inner type without a pattern"
+hir_analysis_pattern_type_non_const_range = range patterns must have constant range start and end
+hir_analysis_pattern_type_wild_pat = wildcard patterns are not permitted for pattern types
+ .label = this type is the same as the inner type without a pattern
hir_analysis_placeholder_not_allowed_item_signatures = the placeholder `_` is not allowed within types on item signatures for {$kind}
.label = not allowed in type signatures
diff --git a/compiler/rustc_hir_analysis/src/check/region.rs b/compiler/rustc_hir_analysis/src/check/region.rs
index 4540310..e51f95e 100644
--- a/compiler/rustc_hir_analysis/src/check/region.rs
+++ b/compiler/rustc_hir_analysis/src/check/region.rs
@@ -6,7 +6,7 @@
//!
//! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/borrow_check.html
-use rustc_ast::visit::walk_list;
+use rustc_ast::visit::visit_opt;
use rustc_data_structures::fx::FxHashSet;
use rustc_hir as hir;
use rustc_hir::def_id::DefId;
@@ -168,7 +168,7 @@
hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => visitor.visit_stmt(statement),
}
}
- walk_list!(visitor, visit_expr, &blk.expr);
+ visit_opt!(visitor, visit_expr, &blk.expr);
}
visitor.cx = prev_cx;
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..9c687d3 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};
@@ -1382,7 +1382,7 @@
span: Span,
},
SelfTyParam(Span),
- TyParam(DefId),
+ Param(DefId),
DefVariant,
None,
}
@@ -1498,11 +1498,11 @@
GenericsArgsErrExtend::DefVariant => {
err.note("enum variants can't have type parameters");
}
- GenericsArgsErrExtend::TyParam(def_id) => {
- if let Some(span) = tcx.def_ident_span(def_id) {
- let name = tcx.item_name(def_id);
- err.span_note(span, format!("type parameter `{name}` defined here"));
- }
+ GenericsArgsErrExtend::Param(def_id) => {
+ let span = tcx.def_ident_span(def_id).unwrap();
+ let kind = tcx.def_descr(def_id);
+ let name = tcx.item_name(def_id);
+ err.span_note(span, format!("{kind} `{name}` defined here"));
}
GenericsArgsErrExtend::SelfTyParam(span) => {
err.span_suggestion_verbose(
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..4b1c0da 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,
@@ -1757,7 +1758,7 @@
assert_eq!(opt_self_ty, None);
let _ = self.prohibit_generic_args(
path.segments.iter(),
- GenericsArgsErrExtend::TyParam(def_id),
+ GenericsArgsErrExtend::Param(def_id),
);
self.lower_ty_param(hir_id)
}
@@ -2190,10 +2191,15 @@
hir::ExprKind::Path(hir::QPath::Resolved(
_,
- &hir::Path {
- res: Res::Def(DefKind::ConstParam, def_id), ..
+ path @ &hir::Path {
+ res: Res::Def(DefKind::ConstParam, def_id),
+ ..
},
)) => {
+ let _ = self.prohibit_generic_args(
+ path.segments.iter(),
+ GenericsArgsErrExtend::Param(def_id),
+ );
let ty = tcx
.type_of(def_id)
.no_bound_vars()
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/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index 33c2443..11a1c65 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -1159,7 +1159,7 @@
let sig = self
.at(cause, self.param_env)
.trace(prev_ty, new_ty)
- .lub(DefineOpaqueTypes::No, a_sig, b_sig)
+ .lub(DefineOpaqueTypes::Yes, a_sig, b_sig)
.map(|ok| self.register_infer_ok_obligations(ok))?;
// Reify both sides and return the reified fn pointer type.
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/assert_dep_graph.rs b/compiler/rustc_incremental/src/assert_dep_graph.rs
index 8c66f239..41caa5d 100644
--- a/compiler/rustc_incremental/src/assert_dep_graph.rs
+++ b/compiler/rustc_incremental/src/assert_dep_graph.rs
@@ -49,10 +49,10 @@
use rustc_middle::{bug, span_bug};
use rustc_span::symbol::{sym, Symbol};
use rustc_span::Span;
-
use std::env;
use std::fs::{self, File};
use std::io::{BufWriter, Write};
+use tracing::debug;
#[allow(missing_docs)]
pub fn assert_dep_graph(tcx: TyCtxt<'_>) {
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/lib.rs b/compiler/rustc_incremental/src/lib.rs
index 79402c8..960a2d0 100644
--- a/compiler/rustc_incremental/src/lib.rs
+++ b/compiler/rustc_incremental/src/lib.rs
@@ -6,9 +6,6 @@
#![feature(rustdoc_internals)]
#![allow(internal_features)]
-#[macro_use]
-extern crate tracing;
-
mod assert_dep_graph;
mod errors;
mod persist;
diff --git a/compiler/rustc_incremental/src/persist/dirty_clean.rs b/compiler/rustc_incremental/src/persist/dirty_clean.rs
index e901ca3..2a0d681 100644
--- a/compiler/rustc_incremental/src/persist/dirty_clean.rs
+++ b/compiler/rustc_incremental/src/persist/dirty_clean.rs
@@ -33,6 +33,7 @@
use rustc_span::symbol::{sym, Symbol};
use rustc_span::Span;
use thin_vec::ThinVec;
+use tracing::debug;
const LOADED_FROM_DISK: Symbol = sym::loaded_from_disk;
const EXCEPT: Symbol = sym::except;
diff --git a/compiler/rustc_incremental/src/persist/file_format.rs b/compiler/rustc_incremental/src/persist/file_format.rs
index b459f82..303785b 100644
--- a/compiler/rustc_incremental/src/persist/file_format.rs
+++ b/compiler/rustc_incremental/src/persist/file_format.rs
@@ -19,6 +19,7 @@
use std::fs;
use std::io::{self, Read};
use std::path::{Path, PathBuf};
+use tracing::debug;
/// The first few bytes of files generated by incremental compilation.
const FILE_MAGIC: &[u8] = b"RSIC";
diff --git a/compiler/rustc_incremental/src/persist/fs.rs b/compiler/rustc_incremental/src/persist/fs.rs
index 193042b..9afea3d 100644
--- a/compiler/rustc_incremental/src/persist/fs.rs
+++ b/compiler/rustc_incremental/src/persist/fs.rs
@@ -125,6 +125,7 @@
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use rand::{thread_rng, RngCore};
+use tracing::debug;
#[cfg(test)]
mod tests;
diff --git a/compiler/rustc_incremental/src/persist/load.rs b/compiler/rustc_incremental/src/persist/load.rs
index 26aaa247..6c3f73c 100644
--- a/compiler/rustc_incremental/src/persist/load.rs
+++ b/compiler/rustc_incremental/src/persist/load.rs
@@ -12,6 +12,7 @@
use rustc_span::ErrorGuaranteed;
use std::path::{Path, PathBuf};
use std::sync::Arc;
+use tracing::{debug, warn};
use super::data::*;
use super::file_format;
@@ -115,7 +116,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 +151,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 +190,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_incremental/src/persist/save.rs b/compiler/rustc_incremental/src/persist/save.rs
index 9777f76..3bf582b 100644
--- a/compiler/rustc_incremental/src/persist/save.rs
+++ b/compiler/rustc_incremental/src/persist/save.rs
@@ -11,6 +11,7 @@
use rustc_session::Session;
use std::fs;
use std::sync::Arc;
+use tracing::debug;
use super::data::*;
use super::dirty_clean;
diff --git a/compiler/rustc_incremental/src/persist/work_product.rs b/compiler/rustc_incremental/src/persist/work_product.rs
index 906233e..e230da9 100644
--- a/compiler/rustc_incremental/src/persist/work_product.rs
+++ b/compiler/rustc_incremental/src/persist/work_product.rs
@@ -10,6 +10,7 @@
use rustc_session::Session;
use std::fs as std_fs;
use std::path::Path;
+use tracing::debug;
/// Copies a CGU work product to the incremental compilation directory, so next compilation can
/// find and reuse it.
diff --git a/compiler/rustc_infer/messages.ftl b/compiler/rustc_infer/messages.ftl
index 8f1c4ad..fbe8d31 100644
--- a/compiler/rustc_infer/messages.ftl
+++ b/compiler/rustc_infer/messages.ftl
@@ -104,10 +104,10 @@
infer_consider_specifying_length = consider specifying the actual array length
infer_data_flows = ...but data{$label_var1_exists ->
[true] {" "}from `{$label_var1}`
- *[false] -> {""}
+ *[false] {""}
} flows{$label_var2_exists ->
[true] {" "}into `{$label_var2}`
- *[false] -> {""}
+ *[false] {""}
} here
infer_data_lifetime_flow = ...but data with one lifetime flows into the other here
diff --git a/compiler/rustc_infer/src/infer/error_reporting/mod.rs b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
index 46a7e7b..e0894ed 100644
--- a/compiler/rustc_infer/src/infer/error_reporting/mod.rs
+++ b/compiler/rustc_infer/src/infer/error_reporting/mod.rs
@@ -173,7 +173,10 @@
ty::ReError(_) => return,
- ty::ReVar(_) | ty::ReBound(..) | ty::ReErased => {
+ // FIXME(#125431): `ReVar` shouldn't reach here.
+ ty::ReVar(_) => (format!("lifetime `{region}`"), alt_span),
+
+ ty::ReBound(..) | ty::ReErased => {
bug!("unexpected region for note_and_explain_region: {:?}", region);
}
};
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/interface.rs b/compiler/rustc_interface/src/interface.rs
index d43be6c..5254a65 100644
--- a/compiler/rustc_interface/src/interface.rs
+++ b/compiler/rustc_interface/src/interface.rs
@@ -11,7 +11,6 @@
use rustc_errors::registry::Registry;
use rustc_errors::{DiagCtxt, ErrorGuaranteed};
use rustc_lint::LintStore;
-
use rustc_middle::ty;
use rustc_middle::ty::CurrentGcx;
use rustc_middle::util::Providers;
@@ -28,6 +27,7 @@
use std::path::PathBuf;
use std::result;
use std::sync::Arc;
+use tracing::trace;
pub type Result<T> = result::Result<T, ErrorGuaranteed>;
diff --git a/compiler/rustc_interface/src/lib.rs b/compiler/rustc_interface/src/lib.rs
index 75df006..c1d460d 100644
--- a/compiler/rustc_interface/src/lib.rs
+++ b/compiler/rustc_interface/src/lib.rs
@@ -4,9 +4,6 @@
#![feature(thread_spawn_unchecked)]
#![feature(try_blocks)]
-#[macro_use]
-extern crate tracing;
-
mod callbacks;
mod errors;
pub mod interface;
diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs
index 76d5d7a..33995f8 100644
--- a/compiler/rustc_interface/src/passes.rs
+++ b/compiler/rustc_interface/src/passes.rs
@@ -39,6 +39,7 @@
use std::path::{Path, PathBuf};
use std::sync::LazyLock;
use std::{env, fs, iter};
+use tracing::{info, instrument};
pub fn parse<'a>(sess: &'a Session) -> PResult<'a, ast::Crate> {
let krate = sess.time("parse_crate", || match &sess.io.input {
@@ -458,7 +459,7 @@
}
}
- for &cnum in tcx.crates(()) {
+ for &cnum in tcx.crates_including_speculative(()) {
let source = tcx.used_crate_source(cnum);
if let Some((path, _)) = &source.dylib {
files.push(escape_dep_filename(&path.display().to_string()));
diff --git a/compiler/rustc_interface/src/util.rs b/compiler/rustc_interface/src/util.rs
index 987e48a..8dac524 100644
--- a/compiler/rustc_interface/src/util.rs
+++ b/compiler/rustc_interface/src/util.rs
@@ -1,5 +1,4 @@
use crate::errors;
-use info;
use rustc_ast as ast;
use rustc_codegen_ssa::traits::CodegenBackend;
#[cfg(parallel_compiler)]
@@ -23,6 +22,7 @@
use std::sync::OnceLock;
use std::thread;
use std::{env, iter};
+use tracing::info;
/// Function pointer type that constructs a new CodegenBackend.
pub type MakeBackendFn = fn() -> Box<dyn CodegenBackend>;
diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 6f6480a..a9304f2 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -263,7 +263,7 @@
.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
+ for loop over {$article} `{$ref_prefix}{$ty}`. This is more readably written as an `if let` statement
.suggestion = consider using `if let` to clear intent
.remove_next = to iterate over `{$recv_snip}` remove the call to `next`
.use_while_let = to check pattern in a loop use `while let`
@@ -627,7 +627,7 @@
.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`
+ extern crate `{$ident}` is private, and cannot be re-exported, 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
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 0f059bc..85d54ce 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -70,6 +70,7 @@
use rustc_trait_selection::infer::{InferCtxtExt, TyCtxtInferExt};
use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
use rustc_trait_selection::traits::{self, misc::type_allowed_to_implement_copy};
+use tracing::debug;
use crate::nonstandard_style::{method_context, MethodLateContext};
@@ -674,11 +675,10 @@
return;
}
}
- let param_env = ty::ParamEnv::empty();
- if ty.is_copy_modulo_regions(cx.tcx, param_env) {
+ if ty.is_copy_modulo_regions(cx.tcx, cx.param_env) {
return;
}
- if type_implements_negative_copy_modulo_regions(cx.tcx, ty, param_env) {
+ if type_implements_negative_copy_modulo_regions(cx.tcx, ty, cx.param_env) {
return;
}
if def.is_variant_list_non_exhaustive()
@@ -694,7 +694,7 @@
.tcx
.infer_ctxt()
.build()
- .type_implements_trait(iter_trait, [ty], param_env)
+ .type_implements_trait(iter_trait, [ty], cx.param_env)
.must_apply_modulo_regions()
{
return;
@@ -711,7 +711,7 @@
if type_allowed_to_implement_copy(
cx.tcx,
- param_env,
+ cx.param_env,
ty,
traits::ObligationCause::misc(item.span, item.owner_id.def_id),
)
diff --git a/compiler/rustc_lint/src/context.rs b/compiler/rustc_lint/src/context.rs
index deeb3ae..c23a67f 100644
--- a/compiler/rustc_lint/src/context.rs
+++ b/compiler/rustc_lint/src/context.rs
@@ -39,10 +39,10 @@
use rustc_span::symbol::{sym, Ident, Symbol};
use rustc_span::Span;
use rustc_target::abi;
-
use std::cell::Cell;
use std::iter;
use std::slice;
+use tracing::debug;
mod diagnostics;
diff --git a/compiler/rustc_lint/src/context/diagnostics.rs b/compiler/rustc_lint/src/context/diagnostics.rs
index 236eeee..23c5e0a 100644
--- a/compiler/rustc_lint/src/context/diagnostics.rs
+++ b/compiler/rustc_lint/src/context/diagnostics.rs
@@ -9,6 +9,7 @@
use rustc_middle::middle::stability;
use rustc_session::lint::{BuiltinLintDiag, Lint};
use rustc_span::BytePos;
+use tracing::debug;
use crate::{lints, EarlyContext, LintContext as _};
diff --git a/compiler/rustc_lint/src/context/diagnostics/check_cfg.rs b/compiler/rustc_lint/src/context/diagnostics/check_cfg.rs
index 020ca17..c69e680 100644
--- a/compiler/rustc_lint/src/context/diagnostics/check_cfg.rs
+++ b/compiler/rustc_lint/src/context/diagnostics/check_cfg.rs
@@ -42,6 +42,22 @@
}
}
+fn cargo_help_sub(
+ sess: &Session,
+ inst: &impl Fn(EscapeQuotes) -> String,
+) -> lints::UnexpectedCfgCargoHelp {
+ // We don't want to suggest the `build.rs` way to expected cfgs if we are already in a
+ // `build.rs`. We therefor do a best effort check (looking if the `--crate-name` is
+ // `build_script_build`) to try to figure out if we are building a Cargo build script
+
+ let unescaped = &inst(EscapeQuotes::No);
+ if matches!(&sess.opts.crate_name, Some(crate_name) if crate_name == "build_script_build") {
+ lints::UnexpectedCfgCargoHelp::lint_cfg(unescaped)
+ } else {
+ lints::UnexpectedCfgCargoHelp::lint_cfg_and_build_rs(unescaped, &inst(EscapeQuotes::Yes))
+ }
+}
+
pub(super) fn unexpected_cfg_name(
sess: &Session,
(name, name_span): (Symbol, Span),
@@ -162,14 +178,7 @@
let inst = |escape_quotes| to_check_cfg_arg(name, value.map(|(v, _s)| v), escape_quotes);
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
- };
+ let sub = if !is_feature_cfg { Some(cargo_help_sub(sess, &inst)) } else { None };
lints::unexpected_cfg_name::InvocationHelp::Cargo { sub }
} else {
lints::unexpected_cfg_name::InvocationHelp::Rustc(lints::UnexpectedCfgRustcHelp::new(
@@ -267,10 +276,7 @@
Some(lints::unexpected_cfg_value::CargoHelp::DefineFeatures)
}
} else if !is_cfg_a_well_know_name {
- Some(lints::unexpected_cfg_value::CargoHelp::Other(lints::UnexpectedCfgCargoHelp::new(
- &inst(EscapeQuotes::No),
- &inst(EscapeQuotes::Yes),
- )))
+ Some(lints::unexpected_cfg_value::CargoHelp::Other(cargo_help_sub(sess, &inst)))
} else {
None
};
diff --git a/compiler/rustc_lint/src/early.rs b/compiler/rustc_lint/src/early.rs
index 736c7a1..3292216 100644
--- a/compiler/rustc_lint/src/early.rs
+++ b/compiler/rustc_lint/src/early.rs
@@ -26,6 +26,7 @@
use rustc_session::Session;
use rustc_span::symbol::Ident;
use rustc_span::Span;
+use tracing::debug;
macro_rules! lint_callback { ($cx:expr, $f:ident, $($args:expr),*) => ({
$cx.pass.$f(&$cx.context, $($args),*);
diff --git a/compiler/rustc_lint/src/for_loops_over_fallibles.rs b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
index a6876d8..b05f5e7 100644
--- a/compiler/rustc_lint/src/for_loops_over_fallibles.rs
+++ b/compiler/rustc_lint/src/for_loops_over_fallibles.rs
@@ -52,14 +52,27 @@
let ty = cx.typeck_results().expr_ty(arg);
- let &ty::Adt(adt, args) = ty.kind() else { return };
+ let (adt, args, ref_mutability) = match ty.kind() {
+ &ty::Adt(adt, args) => (adt, args, None),
+ &ty::Ref(_, ty, mutability) => match ty.kind() {
+ &ty::Adt(adt, args) => (adt, args, Some(mutability)),
+ _ => return,
+ },
+ _ => return,
+ };
let (article, ty, var) = match adt.did() {
+ did if cx.tcx.is_diagnostic_item(sym::Option, did) && ref_mutability.is_some() => ("a", "Option", "Some"),
did if cx.tcx.is_diagnostic_item(sym::Option, did) => ("an", "Option", "Some"),
did if cx.tcx.is_diagnostic_item(sym::Result, did) => ("a", "Result", "Ok"),
_ => return,
};
+ let ref_prefix = match ref_mutability {
+ None => "",
+ Some(ref_mutability) => ref_mutability.ref_prefix_str(),
+ };
+
let sub = if let Some(recv) = extract_iterator_next_call(cx, arg)
&& let Ok(recv_snip) = cx.sess().source_map().span_to_snippet(recv.span)
{
@@ -85,7 +98,7 @@
cx.emit_span_lint(
FOR_LOOPS_OVER_FALLIBLES,
arg.span,
- ForLoopsOverFalliblesDiag { article, ty, sub, question_mark, suggestion },
+ ForLoopsOverFalliblesDiag { article, ref_prefix, ty, sub, question_mark, suggestion },
);
}
}
diff --git a/compiler/rustc_lint/src/foreign_modules.rs b/compiler/rustc_lint/src/foreign_modules.rs
index 2c86964..5da1cbc 100644
--- a/compiler/rustc_lint/src/foreign_modules.rs
+++ b/compiler/rustc_lint/src/foreign_modules.rs
@@ -8,6 +8,7 @@
use rustc_session::declare_lint;
use rustc_span::{sym, Span, Symbol};
use rustc_target::abi::FIRST_VARIANT;
+use tracing::{debug, instrument};
use crate::lints::{BuiltinClashingExtern, BuiltinClashingExternSub};
use crate::{types, LintVec};
diff --git a/compiler/rustc_lint/src/internal.rs b/compiler/rustc_lint/src/internal.rs
index 153d91c..6e291a3 100644
--- a/compiler/rustc_lint/src/internal.rs
+++ b/compiler/rustc_lint/src/internal.rs
@@ -15,6 +15,7 @@
use rustc_span::hygiene::{ExpnKind, MacroKind};
use rustc_span::symbol::{kw, sym, Symbol};
use rustc_span::Span;
+use tracing::debug;
declare_tool_lint! {
/// The `default_hash_type` lint detects use of [`std::collections::HashMap`]/[`std::collections::HashSet`],
diff --git a/compiler/rustc_lint/src/late.rs b/compiler/rustc_lint/src/late.rs
index ca18827..b638ab1 100644
--- a/compiler/rustc_lint/src/late.rs
+++ b/compiler/rustc_lint/src/late.rs
@@ -26,9 +26,9 @@
use rustc_session::lint::LintPass;
use rustc_session::Session;
use rustc_span::Span;
-
use std::any::Any;
use std::cell::Cell;
+use tracing::debug;
/// Extract the [`LintStore`] from [`Session`].
///
diff --git a/compiler/rustc_lint/src/levels.rs b/compiler/rustc_lint/src/levels.rs
index 12b3d1d..98e3210 100644
--- a/compiler/rustc_lint/src/levels.rs
+++ b/compiler/rustc_lint/src/levels.rs
@@ -41,6 +41,7 @@
use rustc_session::Session;
use rustc_span::symbol::{sym, Symbol};
use rustc_span::{Span, DUMMY_SP};
+use tracing::{debug, instrument};
use crate::errors::{
MalformedAttribute, MalformedAttributeSub, OverruledAttribute, OverruledAttributeSub,
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index 64fcc7e..0ccfe23 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -39,9 +39,6 @@
#![feature(rustc_attrs)]
#![allow(internal_features)]
-#[macro_use]
-extern crate tracing;
-
mod async_fn_in_trait;
pub mod builtin;
mod context;
diff --git a/compiler/rustc_lint/src/lints.rs b/compiler/rustc_lint/src/lints.rs
index 3bd6fac..2f44bc4 100644
--- a/compiler/rustc_lint/src/lints.rs
+++ b/compiler/rustc_lint/src/lints.rs
@@ -620,6 +620,7 @@
#[diag(lint_for_loops_over_fallibles)]
pub struct ForLoopsOverFalliblesDiag<'a> {
pub article: &'static str,
+ pub ref_prefix: &'static str,
pub ty: &'static str,
#[subdiagnostic]
pub sub: ForLoopsOverFalliblesLoopSub<'a>,
@@ -1961,21 +1962,33 @@
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,
+pub enum UnexpectedCfgCargoHelp {
+ #[help(lint_unexpected_cfg_add_cargo_feature)]
+ #[help(lint_unexpected_cfg_add_cargo_toml_lint_cfg)]
+ LintCfg { cargo_toml_lint_cfg: String },
+ #[help(lint_unexpected_cfg_add_cargo_feature)]
+ #[help(lint_unexpected_cfg_add_cargo_toml_lint_cfg)]
+ #[help(lint_unexpected_cfg_add_build_rs_println)]
+ LintCfgAndBuildRs { cargo_toml_lint_cfg: String, build_rs_println: 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}\");",),
+ fn cargo_toml_lint_cfg(unescaped: &str) -> String {
+ format!(
+ "\n [lints.rust]\n unexpected_cfgs = {{ level = \"warn\", check-cfg = ['{unescaped}'] }}"
+ )
+ }
+
+ pub fn lint_cfg(unescaped: &str) -> Self {
+ UnexpectedCfgCargoHelp::LintCfg {
+ cargo_toml_lint_cfg: Self::cargo_toml_lint_cfg(unescaped),
+ }
+ }
+
+ pub fn lint_cfg_and_build_rs(unescaped: &str, escaped: &str) -> Self {
+ UnexpectedCfgCargoHelp::LintCfgAndBuildRs {
+ cargo_toml_lint_cfg: Self::cargo_toml_lint_cfg(unescaped),
+ build_rs_println: format!("println!(\"cargo::rustc-check-cfg={escaped}\");"),
}
}
}
@@ -2227,7 +2240,7 @@
pub struct UnusedMacroUse;
#[derive(LintDiagnostic)]
-#[diag(lint_private_extern_crate_reexport)]
+#[diag(lint_private_extern_crate_reexport, code = E0365)]
pub struct PrivateExternCrateReexport {
pub ident: Ident,
}
diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs
index f9f766f..9d3a838 100644
--- a/compiler/rustc_lint/src/types.rs
+++ b/compiler/rustc_lint/src/types.rs
@@ -31,9 +31,9 @@
use rustc_target::abi::{Abi, Size, WrappingRange};
use rustc_target::abi::{Integer, TagEncoding, Variants};
use rustc_target::spec::abi::Abi as SpecAbi;
-
use std::iter;
use std::ops::ControlFlow;
+use tracing::debug;
declare_lint! {
/// The `unused_comparisons` lint detects comparisons made useless by
diff --git a/compiler/rustc_lint/src/unused.rs b/compiler/rustc_lint/src/unused.rs
index 8866b2b..a699354 100644
--- a/compiler/rustc_lint/src/unused.rs
+++ b/compiler/rustc_lint/src/unused.rs
@@ -22,6 +22,7 @@
use rustc_span::{BytePos, Span};
use std::iter;
use std::ops::ControlFlow;
+use tracing::instrument;
declare_lint! {
/// The `unused_must_use` lint detects unused result of a type flagged as
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index 067374c..3fcf3ac 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -1488,13 +1488,15 @@
// a ThinLTO summary attached.
struct LLVMRustThinLTOBuffer {
std::string data;
+ std::string thin_link_data;
};
extern "C" LLVMRustThinLTOBuffer*
-LLVMRustThinLTOBufferCreate(LLVMModuleRef M, bool is_thin) {
+LLVMRustThinLTOBufferCreate(LLVMModuleRef M, bool is_thin, bool emit_summary) {
auto Ret = std::make_unique<LLVMRustThinLTOBuffer>();
{
auto OS = raw_string_ostream(Ret->data);
+ auto ThinLinkOS = raw_string_ostream(Ret->thin_link_data);
{
if (is_thin) {
PassBuilder PB;
@@ -1508,7 +1510,10 @@
PB.registerLoopAnalyses(LAM);
PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
ModulePassManager MPM;
- MPM.addPass(ThinLTOBitcodeWriterPass(OS, nullptr));
+ // We only pass ThinLinkOS to be filled in if we want the summary,
+ // because otherwise LLVM does extra work and may double-emit some
+ // errors or warnings.
+ MPM.addPass(ThinLTOBitcodeWriterPass(OS, emit_summary ? &ThinLinkOS : nullptr));
MPM.run(*unwrap(M), MAM);
} else {
WriteBitcodeToFile(*unwrap(M), OS);
@@ -1533,6 +1538,16 @@
return Buffer->data.length();
}
+extern "C" const void*
+LLVMRustThinLTOBufferThinLinkDataPtr(const LLVMRustThinLTOBuffer *Buffer) {
+ return Buffer->thin_link_data.data();
+}
+
+extern "C" size_t
+LLVMRustThinLTOBufferThinLinkDataLen(const LLVMRustThinLTOBuffer *Buffer) {
+ return Buffer->thin_link_data.length();
+}
+
// This is what we used to parse upstream bitcode for actual ThinLTO
// processing. We'll call this once per module optimized through ThinLTO, and
// it'll be called concurrently on many threads.
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/serialize.rs b/compiler/rustc_macros/src/serialize.rs
index 5fa11d2..7b5dd16 100644
--- a/compiler/rustc_macros/src/serialize.rs
+++ b/compiler/rustc_macros/src/serialize.rs
@@ -13,7 +13,7 @@
quote! {}
};
- s.add_impl_generic(parse_quote! {#decoder_ty: ::rustc_type_ir::codec::TyDecoder #bound });
+ s.add_impl_generic(parse_quote! { #decoder_ty: ::rustc_type_ir::codec::TyDecoder #bound });
s.add_bounds(synstructure::AddBounds::Fields);
s.underscore_const(true);
@@ -34,7 +34,7 @@
pub fn decodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
let decoder_ty = quote! { __D };
- s.add_impl_generic(parse_quote! {#decoder_ty: ::rustc_span::SpanDecoder});
+ s.add_impl_generic(parse_quote! { #decoder_ty: ::rustc_span::SpanDecoder });
s.add_bounds(synstructure::AddBounds::Generics);
s.underscore_const(true);
@@ -43,7 +43,7 @@
pub fn decodable_generic_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
let decoder_ty = quote! { __D };
- s.add_impl_generic(parse_quote! {#decoder_ty: ::rustc_serialize::Decoder});
+ s.add_impl_generic(parse_quote! { #decoder_ty: ::rustc_serialize::Decoder });
s.add_bounds(synstructure::AddBounds::Generics);
s.underscore_const(true);
@@ -120,7 +120,7 @@
let __decoder = quote! { __decoder };
// Use the span of the field for the method call, so
// that backtraces will point to the field.
- quote_spanned! {field_span=> #decode_inner_method(#__decoder) }
+ quote_spanned! { field_span=> #decode_inner_method(#__decoder) }
}
pub fn type_encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
@@ -133,7 +133,7 @@
};
let encoder_ty = quote! { __E };
- s.add_impl_generic(parse_quote! {#encoder_ty: ::rustc_type_ir::codec::TyEncoder #bound });
+ s.add_impl_generic(parse_quote! { #encoder_ty: ::rustc_type_ir::codec::TyEncoder #bound });
s.add_bounds(synstructure::AddBounds::Fields);
s.underscore_const(true);
@@ -142,7 +142,7 @@
pub fn meta_encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
if !s.ast().generics.lifetimes().any(|lt| lt.lifetime.ident == "tcx") {
- s.add_impl_generic(parse_quote! {'tcx});
+ s.add_impl_generic(parse_quote! { 'tcx });
}
s.add_impl_generic(parse_quote! { '__a });
let encoder_ty = quote! { EncodeContext<'__a, 'tcx> };
@@ -154,7 +154,7 @@
pub fn encodable_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
let encoder_ty = quote! { __E };
- s.add_impl_generic(parse_quote! { #encoder_ty: ::rustc_span::SpanEncoder});
+ s.add_impl_generic(parse_quote! { #encoder_ty: ::rustc_span::SpanEncoder });
s.add_bounds(synstructure::AddBounds::Generics);
s.underscore_const(true);
@@ -163,7 +163,7 @@
pub fn encodable_generic_derive(mut s: synstructure::Structure<'_>) -> proc_macro2::TokenStream {
let encoder_ty = quote! { __E };
- s.add_impl_generic(parse_quote! { #encoder_ty: ::rustc_serialize::Encoder});
+ s.add_impl_generic(parse_quote! { #encoder_ty: ::rustc_serialize::Encoder });
s.add_bounds(synstructure::AddBounds::Generics);
s.underscore_const(true);
diff --git a/compiler/rustc_metadata/messages.ftl b/compiler/rustc_metadata/messages.ftl
index 2f5dfad..932603c 100644
--- a/compiler/rustc_metadata/messages.ftl
+++ b/compiler/rustc_metadata/messages.ftl
@@ -91,9 +91,6 @@
found staticlib `{$crate_name}` instead of rlib or dylib{$add_info}
.help = please recompile that crate using --crate-type lib
-metadata_framework_only_windows =
- link kind `raw-dylib` is only supported on Windows targets
-
metadata_global_alloc_required =
no global memory allocator found but one is required; link to std or add `#[global_allocator]` to a static item that implements the GlobalAlloc trait
@@ -233,6 +230,9 @@
metadata_raw_dylib_no_nul =
link name must not contain NUL characters if link kind is `raw-dylib`
+metadata_raw_dylib_only_windows =
+ link kind `raw-dylib` is only supported on Windows targets
+
metadata_renaming_no_link =
renaming of the library `{$lib_name}` was specified, however this crate contains no `#[link(...)]` attributes referencing this library
diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs
index be1a73e..44a3e97 100644
--- a/compiler/rustc_metadata/src/creader.rs
+++ b/compiler/rustc_metadata/src/creader.rs
@@ -27,6 +27,7 @@
use rustc_span::symbol::{sym, Symbol};
use rustc_span::{Span, DUMMY_SP};
use rustc_target::spec::{PanicStrategy, Target, TargetTriple};
+use tracing::{debug, info, trace};
use proc_macro::bridge::client::ProcMacro;
use std::error::Error;
diff --git a/compiler/rustc_metadata/src/dependency_format.rs b/compiler/rustc_metadata/src/dependency_format.rs
index 99181f9..bf9bbfb 100644
--- a/compiler/rustc_metadata/src/dependency_format.rs
+++ b/compiler/rustc_metadata/src/dependency_format.rs
@@ -65,6 +65,7 @@
use rustc_session::config::CrateType;
use rustc_session::cstore::CrateDepKind;
use rustc_session::cstore::LinkagePreference::{self, RequireDynamic, RequireStatic};
+use tracing::info;
pub(crate) fn calculate(tcx: TyCtxt<'_>) -> Dependencies {
tcx.crate_types()
@@ -143,7 +144,7 @@
&& sess.crt_static(Some(ty))
&& !sess.target.crt_static_allows_dylibs)
{
- for &cnum in tcx.crates(()).iter() {
+ for &cnum in tcx.used_crates(()).iter() {
if tcx.dep_kind(cnum).macros_only() {
continue;
}
@@ -164,7 +165,7 @@
// Sweep all crates for found dylibs. Add all dylibs, as well as their
// dependencies, ensuring there are no conflicts. The only valid case for a
// dependency to be relied upon twice is for both cases to rely on a dylib.
- for &cnum in tcx.crates(()).iter() {
+ for &cnum in tcx.used_crates(()).iter() {
if tcx.dep_kind(cnum).macros_only() {
continue;
}
@@ -182,7 +183,7 @@
}
// Collect what we've got so far in the return vector.
- let last_crate = tcx.crates(()).len();
+ let last_crate = tcx.used_crates(()).len();
let mut ret = (1..last_crate + 1)
.map(|cnum| match formats.get(&CrateNum::new(cnum)) {
Some(&RequireDynamic) => Linkage::Dynamic,
@@ -196,7 +197,7 @@
//
// If the crate hasn't been included yet and it's not actually required
// (e.g., it's an allocator) then we skip it here as well.
- for &cnum in tcx.crates(()).iter() {
+ for &cnum in tcx.used_crates(()).iter() {
let src = tcx.used_crate_source(cnum);
if src.dylib.is_none()
&& !formats.contains_key(&cnum)
@@ -284,7 +285,7 @@
fn attempt_static(tcx: TyCtxt<'_>, unavailable: &mut Vec<CrateNum>) -> Option<DependencyList> {
let all_crates_available_as_rlib = tcx
- .crates(())
+ .used_crates(())
.iter()
.copied()
.filter_map(|cnum| {
@@ -305,7 +306,7 @@
// All crates are available in an rlib format, so we're just going to link
// everything in explicitly so long as it's actually required.
let mut ret = tcx
- .crates(())
+ .used_crates(())
.iter()
.map(|&cnum| match tcx.dep_kind(cnum) {
CrateDepKind::Explicit => Linkage::Static,
diff --git a/compiler/rustc_metadata/src/errors.rs b/compiler/rustc_metadata/src/errors.rs
index fb0010f..47d183a 100644
--- a/compiler/rustc_metadata/src/errors.rs
+++ b/compiler/rustc_metadata/src/errors.rs
@@ -142,8 +142,8 @@
}
#[derive(Diagnostic)]
-#[diag(metadata_framework_only_windows, code = E0455)]
-pub struct FrameworkOnlyWindows {
+#[diag(metadata_raw_dylib_only_windows, code = E0455)]
+pub struct RawDylibOnlyWindows {
#[primary_span]
pub span: Span,
}
diff --git a/compiler/rustc_metadata/src/lib.rs b/compiler/rustc_metadata/src/lib.rs
index 00bb4c4..acaf9fb 100644
--- a/compiler/rustc_metadata/src/lib.rs
+++ b/compiler/rustc_metadata/src/lib.rs
@@ -20,9 +20,6 @@
extern crate proc_macro;
-#[macro_use]
-extern crate tracing;
-
pub use rmeta::provide;
mod dependency_format;
diff --git a/compiler/rustc_metadata/src/locator.rs b/compiler/rustc_metadata/src/locator.rs
index 7de03be..73443de 100644
--- a/compiler/rustc_metadata/src/locator.rs
+++ b/compiler/rustc_metadata/src/locator.rs
@@ -231,6 +231,7 @@
use rustc_span::symbol::Symbol;
use rustc_span::Span;
use rustc_target::spec::{Target, TargetTriple};
+use tracing::{debug, info};
use snap::read::FrameDecoder;
use std::borrow::Cow;
@@ -853,7 +854,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/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs
index 58760be..1254ebe 100644
--- a/compiler/rustc_metadata/src/native_libs.rs
+++ b/compiler/rustc_metadata/src/native_libs.rs
@@ -151,7 +151,7 @@
}
"raw-dylib" => {
if !sess.target.is_like_windows {
- sess.dcx().emit_err(errors::FrameworkOnlyWindows { span });
+ sess.dcx().emit_err(errors::RawDylibOnlyWindows { span });
}
NativeLibKind::RawDylib
}
diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
index bb68c6e..695525e 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -28,6 +28,7 @@
use rustc_session::Session;
use rustc_span::symbol::kw;
use rustc_span::{BytePos, Pos, SpanData, SpanDecoder, SyntaxContext, DUMMY_SP};
+use tracing::debug;
use proc_macro::bridge::client::ProcMacro;
use std::iter::TrustedLen;
@@ -40,10 +41,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 +54,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 +178,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 +413,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/decoder/cstore_impl.rs b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
index c783149..4cad317 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
@@ -435,7 +435,7 @@
// traversal, but not globally minimal across all crates.
let bfs_queue = &mut VecDeque::new();
- for &cnum in tcx.crates(()) {
+ for &cnum in tcx.crates_including_speculative(()) {
// Ignore crates without a corresponding local `extern crate` item.
if tcx.missing_extern_crate_item(cnum) {
continue;
@@ -505,7 +505,7 @@
tcx.arena
.alloc_slice(&CStore::from_tcx(tcx).crate_dependencies_in_postorder(LOCAL_CRATE))
},
- crates: |tcx, ()| {
+ crates_including_speculative: |tcx, ()| {
// The list of loaded crates is now frozen in query cache,
// so make sure cstore is not mutably accessed from here on.
tcx.untracked().cstore.freeze();
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_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs
index db0dc6d..4587a43 100644
--- a/compiler/rustc_metadata/src/rmeta/encoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/encoder.rs
@@ -33,6 +33,7 @@
use std::fs::File;
use std::io::{Read, Seek, Write};
use std::path::{Path, PathBuf};
+use tracing::{debug, instrument, trace};
pub(super) struct EncodeContext<'a, 'tcx> {
opaque: opaque::FileEncoder,
@@ -1898,7 +1899,7 @@
let deps = self
.tcx
- .crates(())
+ .crates_including_speculative(())
.iter()
.map(|&cnum| {
let dep = CrateDep {
diff --git a/compiler/rustc_metadata/src/rmeta/table.rs b/compiler/rustc_metadata/src/rmeta/table.rs
index 019cb91..23a6ceb 100644
--- a/compiler/rustc_metadata/src/rmeta/table.rs
+++ b/compiler/rustc_metadata/src/rmeta/table.rs
@@ -2,6 +2,7 @@
use rustc_hir::def::CtorOf;
use rustc_index::Idx;
+use tracing::trace;
pub(super) trait IsDefault: Default {
fn is_default(&self) -> bool;
diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs
index f3f24f7..b17af47 100644
--- a/compiler/rustc_middle/src/hir/map/mod.rs
+++ b/compiler/rustc_middle/src/hir/map/mod.rs
@@ -1016,7 +1016,7 @@
let krate = tcx.hir_crate(());
let hir_body_hash = krate.opt_hir_hash.expect("HIR hash missing while computing crate hash");
- let upstream_crates = upstream_crates(tcx);
+ let upstream_crates = upstream_crates_for_hashing(tcx);
let resolutions = tcx.resolutions(());
@@ -1085,9 +1085,9 @@
Svh::new(crate_hash)
}
-fn upstream_crates(tcx: TyCtxt<'_>) -> Vec<(StableCrateId, Svh)> {
+fn upstream_crates_for_hashing(tcx: TyCtxt<'_>) -> Vec<(StableCrateId, Svh)> {
let mut upstream_crates: Vec<_> = tcx
- .crates(())
+ .crates_including_speculative(())
.iter()
.map(|&cnum| {
let stable_crate_id = tcx.stable_crate_id(cnum);
diff --git a/compiler/rustc_middle/src/hooks/mod.rs b/compiler/rustc_middle/src/hooks/mod.rs
index d35b9fc..bf10a71 100644
--- a/compiler/rustc_middle/src/hooks/mod.rs
+++ b/compiler/rustc_middle/src/hooks/mod.rs
@@ -10,6 +10,7 @@
use rustc_session::StableCrateId;
use rustc_span::def_id::{CrateNum, LocalDefId};
use rustc_span::{ExpnHash, ExpnId, DUMMY_SP};
+use tracing::instrument;
macro_rules! declare_hooks {
($($(#[$attr:meta])*hook $name:ident($($arg:ident: $K:ty),*) -> $V: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/lib.rs b/compiler/rustc_middle/src/lib.rs
index 70437fd..d47e393 100644
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -63,9 +63,6 @@
#![feature(yeet_expr)]
// tidy-alphabetical-end
-#[macro_use]
-extern crate tracing;
-
#[cfg(test)]
mod tests;
diff --git a/compiler/rustc_middle/src/lint.rs b/compiler/rustc_middle/src/lint.rs
index 086582e..d82d23d 100644
--- a/compiler/rustc_middle/src/lint.rs
+++ b/compiler/rustc_middle/src/lint.rs
@@ -12,6 +12,7 @@
use rustc_session::Session;
use rustc_span::hygiene::{ExpnKind, MacroKind};
use rustc_span::{symbol, DesugaringKind, Span, Symbol, DUMMY_SP};
+use tracing::instrument;
use crate::ty::TyCtxt;
diff --git a/compiler/rustc_middle/src/middle/region.rs b/compiler/rustc_middle/src/middle/region.rs
index de07ba9..6e89dc4 100644
--- a/compiler/rustc_middle/src/middle/region.rs
+++ b/compiler/rustc_middle/src/middle/region.rs
@@ -13,6 +13,7 @@
use rustc_hir::{HirId, HirIdMap, Node};
use rustc_macros::{HashStable, TyDecodable, TyEncodable};
use rustc_span::{Span, DUMMY_SP};
+use tracing::debug;
use std::fmt;
use std::ops::Deref;
diff --git a/compiler/rustc_middle/src/middle/stability.rs b/compiler/rustc_middle/src/middle/stability.rs
index e5df057..a377e35 100644
--- a/compiler/rustc_middle/src/middle/stability.rs
+++ b/compiler/rustc_middle/src/middle/stability.rs
@@ -23,6 +23,7 @@
use rustc_span::symbol::{sym, Symbol};
use rustc_span::Span;
use std::num::NonZero;
+use tracing::debug;
#[derive(PartialEq, Clone, Copy, Debug)]
pub enum StabilityLevel {
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
index e974279..4e37295 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
@@ -3,12 +3,12 @@
use std::cmp;
+use super::{alloc_range, AllocError, AllocRange, AllocResult, CtfeProvenance, Provenance};
use rustc_data_structures::sorted_map::SortedMap;
use rustc_macros::HashStable;
-use rustc_target::abi::{HasDataLayout, Size};
-
-use super::{alloc_range, AllocError, AllocRange, AllocResult, CtfeProvenance, Provenance};
use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
+use rustc_target::abi::{HasDataLayout, Size};
+use tracing::trace;
/// Stores the provenance information of pointers stored in memory.
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs
index 6e152cb..eabbcc2 100644
--- a/compiler/rustc_middle/src/mir/interpret/error.rs
+++ b/compiler/rustc_middle/src/mir/interpret/error.rs
@@ -1,19 +1,22 @@
-use super::{AllocId, AllocRange, ConstAllocation, Pointer, Scalar};
+use std::borrow::Cow;
+use std::{any::Any, backtrace::Backtrace, fmt};
-use crate::error;
-use crate::mir::{ConstAlloc, ConstValue};
-use crate::ty::{self, layout, tls, Ty, TyCtxt, ValTree};
+use either::Either;
use rustc_ast_ir::Mutability;
use rustc_data_structures::sync::Lock;
use rustc_errors::{DiagArgName, DiagArgValue, DiagMessage, ErrorGuaranteed, IntoDiagArg};
use rustc_macros::{HashStable, TyDecodable, TyEncodable};
use rustc_session::CtfeBacktrace;
+use rustc_span::Symbol;
use rustc_span::{def_id::DefId, Span, DUMMY_SP};
use rustc_target::abi::{call, Align, Size, VariantIdx, WrappingRange};
-use std::borrow::Cow;
-use std::{any::Any, backtrace::Backtrace, fmt};
+use super::{AllocId, AllocRange, ConstAllocation, Pointer, Scalar};
+
+use crate::error;
+use crate::mir::{ConstAlloc, ConstValue};
+use crate::ty::{self, layout, tls, Ty, TyCtxt, ValTree};
#[derive(Debug, Copy, Clone, PartialEq, Eq, HashStable, TyEncodable, TyDecodable)]
pub enum ErrorHandled {
@@ -63,6 +66,9 @@
pub fn tainted_by_errors(error: ErrorGuaranteed) -> ReportedErrorInfo {
ReportedErrorInfo { is_tainted_by_errors: true, error }
}
+ pub fn is_tainted_by_errors(&self) -> bool {
+ self.is_tainted_by_errors
+ }
}
impl From<ErrorGuaranteed> for ReportedErrorInfo {
@@ -310,6 +316,10 @@
RemainderOverflow,
/// Overflowing inbounds pointer arithmetic.
PointerArithOverflow,
+ /// Overflow in arithmetic that may not overflow.
+ ArithOverflow { intrinsic: Symbol },
+ /// Shift by too much.
+ ShiftOverflow { intrinsic: Symbol, shift_amount: Either<u128, i128> },
/// Invalid metadata in a wide pointer
InvalidMeta(InvalidMetaKind),
/// Reading a C string that does not end within its allocation.
diff --git a/compiler/rustc_middle/src/mir/interpret/mod.rs b/compiler/rustc_middle/src/mir/interpret/mod.rs
index 739b141..16093cf 100644
--- a/compiler/rustc_middle/src/mir/interpret/mod.rs
+++ b/compiler/rustc_middle/src/mir/interpret/mod.rs
@@ -15,6 +15,7 @@
use std::sync::atomic::{AtomicU32, Ordering};
use smallvec::{smallvec, SmallVec};
+use tracing::{debug, trace};
use rustc_ast::LitKind;
use rustc_data_structures::fx::FxHashMap;
diff --git a/compiler/rustc_middle/src/mir/interpret/queries.rs b/compiler/rustc_middle/src/mir/interpret/queries.rs
index 04d6301..a851819 100644
--- a/compiler/rustc_middle/src/mir/interpret/queries.rs
+++ b/compiler/rustc_middle/src/mir/interpret/queries.rs
@@ -9,6 +9,7 @@
use rustc_hir::def_id::DefId;
use rustc_session::lint;
use rustc_span::{Span, DUMMY_SP};
+use tracing::{debug, instrument};
impl<'tcx> TyCtxt<'tcx> {
/// Evaluates a constant without providing any generic parameters. This is useful to evaluate consts
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index 25cc9ac..2b2b939 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -37,6 +37,7 @@
use rustc_span::{Span, DUMMY_SP};
use either::Either;
+use tracing::trace;
use std::borrow::Cow;
use std::cell::RefCell;
diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs
index daab6c8..a3d2140 100644
--- a/compiler/rustc_middle/src/mir/mono.rs
+++ b/compiler/rustc_middle/src/mir/mono.rs
@@ -18,6 +18,7 @@
use rustc_span::Span;
use std::fmt;
use std::hash::Hash;
+use tracing::debug;
/// Describes how a monomorphization will be instantiated in object files.
#[derive(PartialEq)]
diff --git a/compiler/rustc_middle/src/mir/patch.rs b/compiler/rustc_middle/src/mir/patch.rs
index 3341229..18c48d9 100644
--- a/compiler/rustc_middle/src/mir/patch.rs
+++ b/compiler/rustc_middle/src/mir/patch.rs
@@ -1,4 +1,5 @@
use rustc_middle::mir::*;
+use tracing::debug;
/// This struct represents a patch to MIR, which can add
/// new statements and basic blocks and patch over block
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index 7e8598b..7bfb4ac 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -15,6 +15,7 @@
use rustc_middle::mir::visit::Visitor;
use rustc_middle::mir::*;
use rustc_target::abi::Size;
+use tracing::trace;
const INDENT: &str = " ";
/// Alignment for lining up comments following MIR statements
diff --git a/compiler/rustc_middle/src/mir/tcx.rs b/compiler/rustc_middle/src/mir/tcx.rs
index e1ae2e0..a122cff 100644
--- a/compiler/rustc_middle/src/mir/tcx.rs
+++ b/compiler/rustc_middle/src/mir/tcx.rs
@@ -5,6 +5,7 @@
use crate::mir::*;
use rustc_hir as hir;
+use tracing::{debug, instrument};
#[derive(Copy, Clone, Debug, TypeFoldable, TypeVisitable)]
pub struct PlaceTy<'tcx> {
@@ -295,11 +296,13 @@
}
impl BinOp {
- pub fn to_hir_binop(self) -> hir::BinOpKind {
+ pub(crate) fn to_hir_binop(self) -> hir::BinOpKind {
match self {
- BinOp::Add => hir::BinOpKind::Add,
- BinOp::Sub => hir::BinOpKind::Sub,
- BinOp::Mul => hir::BinOpKind::Mul,
+ // HIR `+`/`-`/`*` can map to either of these MIR BinOp, depending
+ // on whether overflow checks are enabled or not.
+ BinOp::Add | BinOp::AddWithOverflow => hir::BinOpKind::Add,
+ BinOp::Sub | BinOp::SubWithOverflow => hir::BinOpKind::Sub,
+ BinOp::Mul | BinOp::MulWithOverflow => hir::BinOpKind::Mul,
BinOp::Div => hir::BinOpKind::Div,
BinOp::Rem => hir::BinOpKind::Rem,
BinOp::BitXor => hir::BinOpKind::BitXor,
@@ -313,10 +316,8 @@
BinOp::Gt => hir::BinOpKind::Gt,
BinOp::Le => hir::BinOpKind::Le,
BinOp::Ge => hir::BinOpKind::Ge,
+ // We don't have HIR syntax for these.
BinOp::Cmp
- | BinOp::AddWithOverflow
- | BinOp::SubWithOverflow
- | BinOp::MulWithOverflow
| BinOp::AddUnchecked
| BinOp::SubUnchecked
| BinOp::MulUnchecked
@@ -338,6 +339,11 @@
})
}
+ /// Returns whether this is a `FooWithOverflow`
+ pub fn is_overflowing(self) -> bool {
+ self.overflowing_to_wrapping().is_some()
+ }
+
/// If this is a `Foo`, return `Some(FooWithOverflow)`.
pub fn wrapping_to_overflowing(self) -> Option<BinOp> {
Some(match self {
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index c2f7a22..5a6decc 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -780,7 +780,7 @@
separate_provide_extern
}
- /// Maps from a trait item to the trait item "descriptor".
+ /// Maps from a trait/impl item to the trait/impl item "descriptor".
query associated_item(key: DefId) -> ty::AssocItem {
desc { |tcx| "computing associated item data for `{}`", tcx.def_path_str(key) }
cache_on_disk_if { key.is_local() }
@@ -1860,13 +1860,22 @@
eval_always
desc { "calculating the stability index for the local crate" }
}
- query crates(_: ()) -> &'tcx [CrateNum] {
+ /// All loaded crates, including those loaded purely for doc links or diagnostics.
+ /// (Diagnostics include lints, so speculatively loaded crates may occur in successful
+ /// compilation even without doc links.)
+ /// Should be used when encoding crate metadata (and therefore when generating crate hash,
+ /// depinfo and similar things), to avoid dangling crate references in other encoded data,
+ /// like source maps.
+ /// May also be used for diagnostics - if we are loading a crate anyway we can suggest some
+ /// items from it as well.
+ /// But otherwise, `used_crates` should generally be used.
+ query crates_including_speculative(_: ()) -> &'tcx [CrateNum] {
eval_always
desc { "fetching all foreign CrateNum instances" }
}
- // Crates that are loaded non-speculatively (not for diagnostics or doc links).
- // FIXME: This is currently only used for collecting lang items, but should be used instead of
- // `crates` in most other cases too.
+ /// Crates that are loaded non-speculatively (not for diagnostics or doc links).
+ /// Should be used to maintain observable language behavior, for example when collecting lang
+ /// items or impls from all crates, or collecting libraries to link.
query used_crates(_: ()) -> &'tcx [CrateNum] {
eval_always
desc { "fetching `CrateNum`s for all crates loaded non-speculatively" }
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/thir.rs b/compiler/rustc_middle/src/thir.rs
index c68b7a6..454897a 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -32,6 +32,7 @@
use std::cmp::Ordering;
use std::fmt;
use std::ops::Index;
+use tracing::instrument;
pub mod visit;
diff --git a/compiler/rustc_middle/src/ty/_match.rs b/compiler/rustc_middle/src/ty/_match.rs
index e28e4d6..f30270a 100644
--- a/compiler/rustc_middle/src/ty/_match.rs
+++ b/compiler/rustc_middle/src/ty/_match.rs
@@ -1,6 +1,7 @@
use crate::ty::error::TypeError;
use crate::ty::relate::{self, Relate, RelateResult, TypeRelation};
use crate::ty::{self, InferConst, Ty, TyCtxt};
+use tracing::{debug, instrument};
/// A type "A" *matches* "B" if the fresh types in B could be
/// instantiated with values so as to make it equal to A. Matching is
diff --git a/compiler/rustc_middle/src/ty/adt.rs b/compiler/rustc_middle/src/ty/adt.rs
index 77da3fb..4819375 100644
--- a/compiler/rustc_middle/src/ty/adt.rs
+++ b/compiler/rustc_middle/src/ty/adt.rs
@@ -17,6 +17,7 @@
use rustc_session::DataTypeKind;
use rustc_span::symbol::sym;
use rustc_target::abi::{ReprOptions, VariantIdx, FIRST_VARIANT};
+use tracing::{debug, info, trace};
use std::cell::RefCell;
use std::hash::{Hash, Hasher};
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/consts.rs b/compiler/rustc_middle/src/ty/consts.rs
index f7cc055..40a0dbe 100644
--- a/compiler/rustc_middle/src/ty/consts.rs
+++ b/compiler/rustc_middle/src/ty/consts.rs
@@ -8,6 +8,7 @@
use rustc_hir::def_id::LocalDefId;
use rustc_macros::{HashStable, TyDecodable, TyEncodable};
use rustc_type_ir::{self as ir, TypeFlags, WithCachedTypeInfo};
+use tracing::{debug, instrument};
mod int;
mod kind;
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 8185c99..6e53b5b 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};
@@ -75,6 +74,7 @@
use rustc_type_ir::TyKind::*;
use rustc_type_ir::WithCachedTypeInfo;
use rustc_type_ir::{CollectAndApply, Interner, TypeFlags};
+use tracing::{debug, instrument};
use std::assert_matches::assert_matches;
use std::borrow::Borrow;
@@ -96,9 +96,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 +122,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 +136,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 +235,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()
}
@@ -1618,7 +1612,7 @@
pub fn all_traits(self) -> impl Iterator<Item = DefId> + 'tcx {
iter::once(LOCAL_CRATE)
- .chain(self.crates(()).iter().copied())
+ .chain(self.used_crates(()).iter().copied())
.flat_map(move |cnum| self.traits(cnum).iter().copied())
}
diff --git a/compiler/rustc_middle/src/ty/erase_regions.rs b/compiler/rustc_middle/src/ty/erase_regions.rs
index cfd36fd..cd6e7df 100644
--- a/compiler/rustc_middle/src/ty/erase_regions.rs
+++ b/compiler/rustc_middle/src/ty/erase_regions.rs
@@ -1,6 +1,7 @@
use crate::query::Providers;
use crate::ty::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
use crate::ty::{self, Ty, TyCtxt, TypeFlags, TypeVisitableExt};
+use tracing::debug;
pub(super) fn provide(providers: &mut Providers) {
*providers = Providers { erase_regions_ty, ..*providers };
diff --git a/compiler/rustc_middle/src/ty/fold.rs b/compiler/rustc_middle/src/ty/fold.rs
index fd3bee1..d432aea 100644
--- a/compiler/rustc_middle/src/ty/fold.rs
+++ b/compiler/rustc_middle/src/ty/fold.rs
@@ -1,6 +1,7 @@
use crate::ty::{self, Binder, BoundTy, Ty, TyCtxt, TypeVisitableExt};
use rustc_data_structures::fx::FxIndexMap;
use rustc_hir::def_id::DefId;
+use tracing::{debug, instrument};
pub use rustc_type_ir::fold::{FallibleTypeFolder, TypeFoldable, TypeFolder, TypeSuperFoldable};
diff --git a/compiler/rustc_middle/src/ty/generic_args.rs b/compiler/rustc_middle/src/ty/generic_args.rs
index 3d263e6..c7b15c6 100644
--- a/compiler/rustc_middle/src/ty/generic_args.rs
+++ b/compiler/rustc_middle/src/ty/generic_args.rs
@@ -18,6 +18,7 @@
use rustc_serialize::{Decodable, Encodable};
use rustc_type_ir::WithCachedTypeInfo;
use smallvec::SmallVec;
+use tracing::debug;
use core::intrinsics;
use std::marker::PhantomData;
@@ -51,6 +52,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/generics.rs b/compiler/rustc_middle/src/ty/generics.rs
index cfaca05..870e486 100644
--- a/compiler/rustc_middle/src/ty/generics.rs
+++ b/compiler/rustc_middle/src/ty/generics.rs
@@ -6,6 +6,7 @@
use rustc_macros::{HashStable, TyDecodable, TyEncodable};
use rustc_span::symbol::{kw, Symbol};
use rustc_span::Span;
+use tracing::instrument;
use super::{Clause, InstantiatedPredicates, ParamConst, ParamTy, Ty, TyCtxt};
diff --git a/compiler/rustc_middle/src/ty/impls_ty.rs b/compiler/rustc_middle/src/ty/impls_ty.rs
index ef7a7a9..efcf428 100644
--- a/compiler/rustc_middle/src/ty/impls_ty.rs
+++ b/compiler/rustc_middle/src/ty/impls_ty.rs
@@ -12,6 +12,7 @@
use rustc_query_system::ich::StableHashingContext;
use std::cell::RefCell;
use std::ptr;
+use tracing::trace;
impl<'a, 'tcx, H, T> HashStable<StableHashingContext<'a>> for &'tcx ty::list::RawList<H, T>
where
diff --git a/compiler/rustc_middle/src/ty/inhabitedness/inhabited_predicate.rs b/compiler/rustc_middle/src/ty/inhabitedness/inhabited_predicate.rs
index e3eea83..54b8507 100644
--- a/compiler/rustc_middle/src/ty/inhabitedness/inhabited_predicate.rs
+++ b/compiler/rustc_middle/src/ty/inhabitedness/inhabited_predicate.rs
@@ -1,5 +1,6 @@
use rustc_macros::HashStable;
use smallvec::SmallVec;
+use tracing::instrument;
use crate::ty::context::TyCtxt;
use crate::ty::{self, DefId, OpaqueTypeKey, ParamEnv, Ty};
diff --git a/compiler/rustc_middle/src/ty/inhabitedness/mod.rs b/compiler/rustc_middle/src/ty/inhabitedness/mod.rs
index da5d57d..afdf2cb 100644
--- a/compiler/rustc_middle/src/ty/inhabitedness/mod.rs
+++ b/compiler/rustc_middle/src/ty/inhabitedness/mod.rs
@@ -48,6 +48,7 @@
use crate::ty::{self, DefId, Ty, TypeVisitableExt, VariantDef, Visibility};
use rustc_type_ir::TyKind::*;
+use tracing::instrument;
pub mod inhabited_predicate;
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
index a08fde9..7da7f69 100644
--- a/compiler/rustc_middle/src/ty/instance.rs
+++ b/compiler/rustc_middle/src/ty/instance.rs
@@ -14,6 +14,7 @@
use rustc_middle::ty::normalize_erasing_regions::NormalizationError;
use rustc_span::def_id::LOCAL_CRATE;
use rustc_span::Symbol;
+use tracing::{debug, instrument};
use std::assert_matches::assert_matches;
use std::fmt;
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index cf701f8..60ce874 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -19,6 +19,7 @@
use rustc_target::spec::{
abi::Abi as SpecAbi, HasTargetSpec, HasWasmCAbiOpt, PanicStrategy, Target, WasmCAbi,
};
+use tracing::debug;
use std::borrow::Cow;
use std::cmp;
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 8bb19bc..79cfeb7 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -61,6 +61,7 @@
use rustc_target::abi::{Align, FieldIdx, Integer, IntegerType, VariantIdx};
pub use rustc_target::abi::{ReprFlags, ReprOptions};
pub use rustc_type_ir::{DebugWithInfcx, InferCtxtLike, WithInfcx};
+use tracing::{debug, instrument};
pub use vtable::*;
use std::assert_matches::assert_matches;
@@ -1814,6 +1815,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/normalize_erasing_regions.rs b/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs
index 115cf3e..e2cfabf 100644
--- a/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs
+++ b/compiler/rustc_middle/src/ty/normalize_erasing_regions.rs
@@ -11,6 +11,7 @@
use crate::ty::fold::{FallibleTypeFolder, TypeFoldable, TypeFolder};
use crate::ty::{self, EarlyBinder, GenericArgsRef, Ty, TyCtxt, TypeVisitableExt};
use rustc_macros::{HashStable, TyDecodable, TyEncodable};
+use tracing::{debug, instrument};
#[derive(Debug, Copy, Clone, HashStable, TyEncodable, TyDecodable)]
pub enum NormalizationError<'tcx> {
diff --git a/compiler/rustc_middle/src/ty/opaque_types.rs b/compiler/rustc_middle/src/ty/opaque_types.rs
index fa5265c..bbcbcdc 100644
--- a/compiler/rustc_middle/src/ty/opaque_types.rs
+++ b/compiler/rustc_middle/src/ty/opaque_types.rs
@@ -5,6 +5,7 @@
use rustc_data_structures::fx::FxHashMap;
use rustc_span::def_id::DefId;
use rustc_span::Span;
+use tracing::{debug, instrument, trace};
/// Converts generic params of a TypeFoldable from one
/// item's generics to another. Usually from a function's generics
diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
index be91249..efb6cf2 100644
--- a/compiler/rustc_middle/src/ty/predicate.rs
+++ b/compiler/rustc_middle/src/ty/predicate.rs
@@ -1,15 +1,14 @@
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 tracing::instrument;
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 +23,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 +163,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 +241,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 +304,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 +413,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 +429,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 +441,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 +455,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 +484,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 +539,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/mod.rs b/compiler/rustc_middle/src/ty/print/mod.rs
index dc77f59..3c27df9 100644
--- a/compiler/rustc_middle/src/ty/print/mod.rs
+++ b/compiler/rustc_middle/src/ty/print/mod.rs
@@ -7,6 +7,7 @@
use rustc_hir as hir;
use rustc_hir::def_id::{CrateNum, DefId, LocalDefId};
use rustc_hir::definitions::{DefPathData, DisambiguatedDefPathData};
+use tracing::{debug, instrument, trace};
// `pretty` is a separate module only for organization.
mod pretty;
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index 0dbb17e..0bcd02a 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! {
@@ -3271,7 +3258,7 @@
let queue = &mut Vec::new();
let mut seen_defs: DefIdSet = Default::default();
- for &cnum in tcx.crates(()).iter() {
+ for &cnum in tcx.crates_including_speculative(()).iter() {
let def_id = cnum.as_def_id();
// Ignore crates that are not direct dependencies.
diff --git a/compiler/rustc_middle/src/ty/region.rs b/compiler/rustc_middle/src/ty/region.rs
index 551e2ea..958e7e4 100644
--- a/compiler/rustc_middle/src/ty/region.rs
+++ b/compiler/rustc_middle/src/ty/region.rs
@@ -8,6 +8,7 @@
use rustc_type_ir::RegionKind as IrRegionKind;
pub use rustc_type_ir::RegionVid;
use std::ops::Deref;
+use tracing::debug;
use crate::ty::{self, BoundVar, TyCtxt, TypeFlags};
@@ -384,6 +385,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/relate.rs b/compiler/rustc_middle/src/ty/relate.rs
index 947de3f..f02b484 100644
--- a/compiler/rustc_middle/src/ty/relate.rs
+++ b/compiler/rustc_middle/src/ty/relate.rs
@@ -14,6 +14,7 @@
use rustc_macros::TypeVisitable;
use rustc_target::spec::abi;
use std::iter;
+use tracing::{debug, instrument};
use super::Pattern;
diff --git a/compiler/rustc_middle/src/ty/rvalue_scopes.rs b/compiler/rustc_middle/src/ty/rvalue_scopes.rs
index cb2f728..8ec7946 100644
--- a/compiler/rustc_middle/src/ty/rvalue_scopes.rs
+++ b/compiler/rustc_middle/src/ty/rvalue_scopes.rs
@@ -2,6 +2,7 @@
use rustc_hir as hir;
use rustc_hir::ItemLocalMap;
use rustc_macros::{HashStable, TyDecodable, TyEncodable};
+use tracing::debug;
/// `RvalueScopes` is a mapping from sub-expressions to _extended_ lifetime as determined by
/// rules laid out in `rustc_hir_analysis::check::rvalue_scopes`.
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..40f3db8 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| {
@@ -401,6 +401,45 @@
pub fn coroutine_witness_ty(self) -> Ty<'tcx> {
self.split().coroutine_witness_ty
}
+
+ pub fn has_self_borrows(&self) -> bool {
+ match self.coroutine_captures_by_ref_ty().kind() {
+ ty::FnPtr(sig) => sig
+ .skip_binder()
+ .visit_with(&mut HasRegionsBoundAt { binder: ty::INNERMOST })
+ .is_break(),
+ ty::Error(_) => true,
+ _ => bug!(),
+ }
+ }
+}
+/// Unlike `has_escaping_bound_vars` or `outermost_exclusive_binder`, this will
+/// detect only regions bound *at* the debruijn index.
+struct HasRegionsBoundAt {
+ binder: ty::DebruijnIndex,
+}
+// FIXME: Could be optimized to not walk into components with no escaping bound vars.
+impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for HasRegionsBoundAt {
+ type Result = ControlFlow<()>;
+ fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(
+ &mut self,
+ t: &ty::Binder<'tcx, T>,
+ ) -> Self::Result {
+ self.binder.shift_in(1);
+ t.super_visit_with(self)?;
+ self.binder.shift_out(1);
+ ControlFlow::Continue(())
+ }
+
+ fn visit_region(&mut self, r: ty::Region<'tcx>) -> Self::Result {
+ if let ty::ReBound(binder, _) = *r
+ && self.binder == binder
+ {
+ ControlFlow::Break(())
+ } else {
+ ControlFlow::Continue(())
+ }
+ }
}
#[derive(Copy, Clone, PartialEq, Eq, Debug, TypeFoldable, TypeVisitable)]
@@ -898,203 +937,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 +945,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 +1003,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 +1805,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/trait_def.rs b/compiler/rustc_middle/src/ty/trait_def.rs
index cf1cbb9..37a34f2 100644
--- a/compiler/rustc_middle/src/ty/trait_def.rs
+++ b/compiler/rustc_middle/src/ty/trait_def.rs
@@ -5,6 +5,7 @@
use rustc_hir as hir;
use rustc_hir::def_id::DefId;
use std::iter;
+use tracing::debug;
use rustc_data_structures::fx::FxIndexMap;
use rustc_errors::ErrorGuaranteed;
@@ -205,7 +206,7 @@
// Traits defined in the current crate can't have impls in upstream
// crates, so we don't bother querying the cstore.
if !trait_id.is_local() {
- for &cnum in tcx.crates(()).iter() {
+ for &cnum in tcx.used_crates(()).iter() {
for &(impl_def_id, simplified_self_ty) in
tcx.implementations_of_trait((cnum, trait_id)).iter()
{
@@ -247,7 +248,7 @@
let mut impls = Vec::new();
let mut res = Ok(());
- for cnum in iter::once(LOCAL_CRATE).chain(tcx.crates(()).iter().copied()) {
+ for cnum in iter::once(LOCAL_CRATE).chain(tcx.used_crates(()).iter().copied()) {
let incoherent_impls = match tcx.crate_incoherent_impls((cnum, simp)) {
Ok(impls) => impls,
Err(e) => {
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index 8c14f1e..5a3d902 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -24,6 +24,7 @@
use rustc_target::spec::abi::Abi;
use smallvec::{smallvec, SmallVec};
use std::{fmt, iter};
+use tracing::{debug, instrument, trace};
#[derive(Copy, Clone, Debug)]
pub struct Discr<'tcx> {
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_middle/src/ty/walk.rs b/compiler/rustc_middle/src/ty/walk.rs
index 089e617..a9421aa 100644
--- a/compiler/rustc_middle/src/ty/walk.rs
+++ b/compiler/rustc_middle/src/ty/walk.rs
@@ -5,6 +5,7 @@
use crate::ty::{GenericArg, GenericArgKind};
use rustc_data_structures::sso::SsoHashSet;
use smallvec::{smallvec, SmallVec};
+use tracing::debug;
// The TypeWalker's stack is hot enough that it's worth going to some effort to
// avoid heap allocations.
diff --git a/compiler/rustc_middle/src/util/call_kind.rs b/compiler/rustc_middle/src/util/call_kind.rs
index 4e2a2c6..a4cbfe8 100644
--- a/compiler/rustc_middle/src/util/call_kind.rs
+++ b/compiler/rustc_middle/src/util/call_kind.rs
@@ -8,6 +8,7 @@
use rustc_hir::{lang_items, LangItem};
use rustc_span::symbol::Ident;
use rustc_span::{sym, DesugaringKind, Span};
+use tracing::debug;
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub enum CallDesugaringKind {
diff --git a/compiler/rustc_middle/src/util/find_self_call.rs b/compiler/rustc_middle/src/util/find_self_call.rs
index 0ca4fce..027e270 100644
--- a/compiler/rustc_middle/src/util/find_self_call.rs
+++ b/compiler/rustc_middle/src/util/find_self_call.rs
@@ -3,6 +3,7 @@
use crate::ty::{self, TyCtxt};
use rustc_span::def_id::DefId;
use rustc_span::source_map::Spanned;
+use tracing::debug;
/// Checks if the specified `local` is used as the `self` parameter of a method call
/// in the provided `BasicBlock`. If it is, then the `DefId` of the called method is
diff --git a/compiler/rustc_mir_build/messages.ftl b/compiler/rustc_mir_build/messages.ftl
index 0bb44db..67e1e15 100644
--- a/compiler/rustc_mir_build/messages.ftl
+++ b/compiler/rustc_mir_build/messages.ftl
@@ -335,12 +335,12 @@
mir_build_unsafe_not_inherited = items do not inherit unsafety from separate enclosing items
mir_build_unsafe_op_in_unsafe_fn_borrow_of_layout_constrained_field_requires_unsafe =
- borrow of layout constrained field with interior mutability is unsafe and requires unsafe block (error E0133)
+ borrow of layout constrained field with interior mutability is unsafe and requires unsafe block
.note = references to fields of layout constrained fields lose the constraints. Coupled with interior mutability, the field can be changed to invalid values
.label = borrow of layout constrained field with interior mutability
mir_build_unsafe_op_in_unsafe_fn_call_to_fn_with_requires_unsafe =
- call to function `{$function}` with `#[target_feature]` is unsafe and requires unsafe block (error E0133)
+ call to function `{$function}` with `#[target_feature]` is unsafe and requires unsafe block
.help = in order for the call to be safe, the context requires the following additional target {$missing_target_features_count ->
[1] feature
*[count] features
@@ -355,48 +355,47 @@
.label = call to function with `#[target_feature]`
mir_build_unsafe_op_in_unsafe_fn_call_to_unsafe_fn_requires_unsafe =
- call to unsafe function `{$function}` is unsafe and requires unsafe block (error E0133)
+ call to unsafe function `{$function}` is unsafe and requires unsafe block
.note = consult the function's documentation for information on how to avoid undefined behavior
.label = call to unsafe function
mir_build_unsafe_op_in_unsafe_fn_call_to_unsafe_fn_requires_unsafe_nameless =
- call to unsafe function is unsafe and requires unsafe block (error E0133)
+ call to unsafe function is unsafe and requires unsafe block
.note = consult the function's documentation for information on how to avoid undefined behavior
.label = call to unsafe function
mir_build_unsafe_op_in_unsafe_fn_deref_raw_pointer_requires_unsafe =
- dereference of raw pointer is unsafe and requires unsafe block (error E0133)
+ dereference of raw pointer is unsafe and requires unsafe block
.note = raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
.label = dereference of raw pointer
mir_build_unsafe_op_in_unsafe_fn_extern_static_requires_unsafe =
- use of extern static is unsafe and requires unsafe block (error E0133)
+ use of extern static is unsafe and requires unsafe block
.note = extern statics are not controlled by the Rust type system: invalid data, aliasing violations or data races will cause undefined behavior
.label = use of extern static
mir_build_unsafe_op_in_unsafe_fn_initializing_type_with_requires_unsafe =
- initializing type with `rustc_layout_scalar_valid_range` attr is unsafe and requires unsafe
- block (error E0133)
+ initializing type with `rustc_layout_scalar_valid_range` attr is unsafe and requires unsafe block
.note = initializing a layout restricted type's field with a value outside the valid range is undefined behavior
.label = initializing type with `rustc_layout_scalar_valid_range` attr
mir_build_unsafe_op_in_unsafe_fn_inline_assembly_requires_unsafe =
- use of inline assembly is unsafe and requires unsafe block (error E0133)
+ use of inline assembly is unsafe and requires unsafe block
.note = inline assembly is entirely unchecked and can cause undefined behavior
.label = use of inline assembly
mir_build_unsafe_op_in_unsafe_fn_mutable_static_requires_unsafe =
- use of mutable static is unsafe and requires unsafe block (error E0133)
+ use of mutable static is unsafe and requires unsafe block
.note = mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
.label = use of mutable static
mir_build_unsafe_op_in_unsafe_fn_mutation_of_layout_constrained_field_requires_unsafe =
- mutation of layout constrained field is unsafe and requires unsafe block (error E0133)
+ mutation of layout constrained field is unsafe and requires unsafe block
.note = mutating layout constrained fields cannot statically be checked for valid values
.label = mutation of layout constrained field
mir_build_unsafe_op_in_unsafe_fn_union_field_requires_unsafe =
- access to union field is unsafe and requires unsafe block (error E0133)
+ access to union field is unsafe and requires unsafe block
.note = the field may not be properly initialized: using uninitialized data will cause undefined behavior
.label = access to union field
diff --git a/compiler/rustc_mir_build/src/build/block.rs b/compiler/rustc_mir_build/src/build/block.rs
index 6ae98e1..c1d645a 100644
--- a/compiler/rustc_mir_build/src/build/block.rs
+++ b/compiler/rustc_mir_build/src/build/block.rs
@@ -5,6 +5,7 @@
use rustc_middle::thir::*;
use rustc_middle::{mir::*, ty};
use rustc_span::Span;
+use tracing::debug;
impl<'a, 'tcx> Builder<'a, 'tcx> {
pub(crate) fn ast_block(
diff --git a/compiler/rustc_mir_build/src/build/cfg.rs b/compiler/rustc_mir_build/src/build/cfg.rs
index 18e4529..6034c8f 100644
--- a/compiler/rustc_mir_build/src/build/cfg.rs
+++ b/compiler/rustc_mir_build/src/build/cfg.rs
@@ -3,6 +3,7 @@
use crate::build::CFG;
use rustc_middle::mir::*;
use rustc_middle::ty::TyCtxt;
+use tracing::debug;
impl<'tcx> CFG<'tcx> {
pub(crate) fn block_data(&self, blk: BasicBlock) -> &BasicBlockData<'tcx> {
diff --git a/compiler/rustc_mir_build/src/build/custom/parse.rs b/compiler/rustc_mir_build/src/build/custom/parse.rs
index 0384b9b..8bcd429 100644
--- a/compiler/rustc_mir_build/src/build/custom/parse.rs
+++ b/compiler/rustc_mir_build/src/build/custom/parse.rs
@@ -38,7 +38,7 @@
) => {{
let expr_id = $self.preparse($expr_id);
let expr = &$self.thir[expr_id];
- debug!("Trying to parse {:?} as {}", expr.kind, $expected);
+ tracing::debug!("Trying to parse {:?} as {}", expr.kind, $expected);
let $expr_name = expr;
match &expr.kind {
$(
diff --git a/compiler/rustc_mir_build/src/build/expr/as_constant.rs b/compiler/rustc_mir_build/src/build/expr/as_constant.rs
index 817f5f7..b4dd423 100644
--- a/compiler/rustc_mir_build/src/build/expr/as_constant.rs
+++ b/compiler/rustc_mir_build/src/build/expr/as_constant.rs
@@ -11,6 +11,7 @@
};
use rustc_middle::{bug, span_bug};
use rustc_target::abi::Size;
+use tracing::{instrument, trace};
impl<'a, 'tcx> Builder<'a, 'tcx> {
/// Compile `expr`, yielding a compile-time constant. Assumes that
diff --git a/compiler/rustc_mir_build/src/build/expr/as_operand.rs b/compiler/rustc_mir_build/src/build/expr/as_operand.rs
index 076ee7f..09ce134 100644
--- a/compiler/rustc_mir_build/src/build/expr/as_operand.rs
+++ b/compiler/rustc_mir_build/src/build/expr/as_operand.rs
@@ -5,6 +5,7 @@
use rustc_middle::middle::region;
use rustc_middle::mir::*;
use rustc_middle::thir::*;
+use tracing::{debug, instrument};
impl<'a, 'tcx> Builder<'a, 'tcx> {
/// Returns an operand suitable for use until the end of the current
diff --git a/compiler/rustc_mir_build/src/build/expr/as_place.rs b/compiler/rustc_mir_build/src/build/expr/as_place.rs
index 9963629..93d0d4e 100644
--- a/compiler/rustc_mir_build/src/build/expr/as_place.rs
+++ b/compiler/rustc_mir_build/src/build/expr/as_place.rs
@@ -15,6 +15,7 @@
use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty, Variance};
use rustc_span::Span;
use rustc_target::abi::{FieldIdx, VariantIdx, FIRST_VARIANT};
+use tracing::{debug, instrument, trace};
use std::assert_matches::assert_matches;
use std::iter;
diff --git a/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs
index 60a2827..9f9b566 100644
--- a/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs
+++ b/compiler/rustc_mir_build/src/build/expr/as_rvalue.rs
@@ -18,6 +18,7 @@
use rustc_middle::ty::layout::IntegerExt;
use rustc_middle::ty::{self, Ty, UpvarArgs};
use rustc_span::{Span, DUMMY_SP};
+use tracing::debug;
impl<'a, 'tcx> Builder<'a, 'tcx> {
/// Returns an rvalue suitable for use until the end of the current
diff --git a/compiler/rustc_mir_build/src/build/expr/as_temp.rs b/compiler/rustc_mir_build/src/build/expr/as_temp.rs
index 27e66e7..607c7c3 100644
--- a/compiler/rustc_mir_build/src/build/expr/as_temp.rs
+++ b/compiler/rustc_mir_build/src/build/expr/as_temp.rs
@@ -6,6 +6,7 @@
use rustc_middle::middle::region;
use rustc_middle::mir::*;
use rustc_middle::thir::*;
+use tracing::{debug, instrument};
impl<'a, 'tcx> Builder<'a, 'tcx> {
/// Compile `expr` into a fresh temporary. This is used when building
diff --git a/compiler/rustc_mir_build/src/build/expr/into.rs b/compiler/rustc_mir_build/src/build/expr/into.rs
index f8c9107..9349133 100644
--- a/compiler/rustc_mir_build/src/build/expr/into.rs
+++ b/compiler/rustc_mir_build/src/build/expr/into.rs
@@ -12,6 +12,7 @@
use rustc_middle::ty::CanonicalUserTypeAnnotation;
use rustc_span::source_map::Spanned;
use std::iter;
+use tracing::{debug, instrument};
impl<'a, 'tcx> Builder<'a, 'tcx> {
/// Compile `expr`, storing the result into `destination`, which
diff --git a/compiler/rustc_mir_build/src/build/expr/stmt.rs b/compiler/rustc_mir_build/src/build/expr/stmt.rs
index 7f5e45e..2bdeb57 100644
--- a/compiler/rustc_mir_build/src/build/expr/stmt.rs
+++ b/compiler/rustc_mir_build/src/build/expr/stmt.rs
@@ -3,6 +3,7 @@
use rustc_middle::middle::region;
use rustc_middle::mir::*;
use rustc_middle::thir::*;
+use tracing::debug;
impl<'a, 'tcx> Builder<'a, 'tcx> {
/// Builds a block of MIR statements to evaluate the THIR `expr`.
diff --git a/compiler/rustc_mir_build/src/build/matches/mod.rs b/compiler/rustc_mir_build/src/build/matches/mod.rs
index 3fc7193..5413878 100644
--- a/compiler/rustc_mir_build/src/build/matches/mod.rs
+++ b/compiler/rustc_mir_build/src/build/matches/mod.rs
@@ -20,6 +20,8 @@
use rustc_span::symbol::Symbol;
use rustc_span::{BytePos, Pos, Span};
use rustc_target::abi::VariantIdx;
+use tracing::{debug, instrument};
+
// helper functions, broken out by category:
mod simplify;
mod test;
@@ -925,7 +927,7 @@
for subpattern in prefix.iter() {
self.visit_primary_bindings(subpattern, pattern_user_ty.clone().index(), f);
}
- for subpattern in slice {
+ if let Some(subpattern) = slice {
self.visit_primary_bindings(
subpattern,
pattern_user_ty.clone().subslice(from, to),
diff --git a/compiler/rustc_mir_build/src/build/matches/simplify.rs b/compiler/rustc_mir_build/src/build/matches/simplify.rs
index 90f12e5..543301c 100644
--- a/compiler/rustc_mir_build/src/build/matches/simplify.rs
+++ b/compiler/rustc_mir_build/src/build/matches/simplify.rs
@@ -14,6 +14,7 @@
use crate::build::matches::{MatchPair, PatternExtraData, TestCase};
use crate::build::Builder;
+use tracing::{debug, instrument};
use std::mem;
diff --git a/compiler/rustc_mir_build/src/build/matches/test.rs b/compiler/rustc_mir_build/src/build/matches/test.rs
index f3faeb4..2040071 100644
--- a/compiler/rustc_mir_build/src/build/matches/test.rs
+++ b/compiler/rustc_mir_build/src/build/matches/test.rs
@@ -18,6 +18,7 @@
use rustc_span::source_map::Spanned;
use rustc_span::symbol::{sym, Symbol};
use rustc_span::{Span, DUMMY_SP};
+use tracing::{debug, instrument};
use std::cmp::Ordering;
diff --git a/compiler/rustc_mir_build/src/build/matches/util.rs b/compiler/rustc_mir_build/src/build/matches/util.rs
index 14c74c7..770f689 100644
--- a/compiler/rustc_mir_build/src/build/matches/util.rs
+++ b/compiler/rustc_mir_build/src/build/matches/util.rs
@@ -7,6 +7,7 @@
use rustc_middle::ty::TypeVisitableExt;
use rustc_middle::ty::{self, Ty};
use rustc_span::Span;
+use tracing::debug;
impl<'a, 'tcx> Builder<'a, 'tcx> {
pub(crate) fn field_match_pairs<'pat>(
diff --git a/compiler/rustc_mir_build/src/build/misc.rs b/compiler/rustc_mir_build/src/build/misc.rs
index c263de7..04e6d24 100644
--- a/compiler/rustc_mir_build/src/build/misc.rs
+++ b/compiler/rustc_mir_build/src/build/misc.rs
@@ -7,6 +7,7 @@
use rustc_middle::ty::{self, Ty};
use rustc_span::Span;
use rustc_trait_selection::infer::InferCtxtExt;
+use tracing::debug;
impl<'a, 'tcx> Builder<'a, 'tcx> {
/// Adds a new temporary value of type `ty` storing the result of
diff --git a/compiler/rustc_mir_build/src/build/scope.rs b/compiler/rustc_mir_build/src/build/scope.rs
index be32363..c7850c7 100644
--- a/compiler/rustc_mir_build/src/build/scope.rs
+++ b/compiler/rustc_mir_build/src/build/scope.rs
@@ -94,6 +94,7 @@
use rustc_session::lint::Level;
use rustc_span::source_map::Spanned;
use rustc_span::{Span, DUMMY_SP};
+use tracing::{debug, instrument};
#[derive(Debug)]
pub struct Scopes<'tcx> {
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index e2a2846..38e6c00 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -21,7 +21,7 @@
}
#[derive(LintDiagnostic)]
-#[diag(mir_build_unsafe_op_in_unsafe_fn_call_to_unsafe_fn_requires_unsafe)]
+#[diag(mir_build_unsafe_op_in_unsafe_fn_call_to_unsafe_fn_requires_unsafe, code = E0133)]
#[note]
pub struct UnsafeOpInUnsafeFnCallToUnsafeFunctionRequiresUnsafe {
#[label]
@@ -32,7 +32,7 @@
}
#[derive(LintDiagnostic)]
-#[diag(mir_build_unsafe_op_in_unsafe_fn_call_to_unsafe_fn_requires_unsafe_nameless)]
+#[diag(mir_build_unsafe_op_in_unsafe_fn_call_to_unsafe_fn_requires_unsafe_nameless, code = E0133)]
#[note]
pub struct UnsafeOpInUnsafeFnCallToUnsafeFunctionRequiresUnsafeNameless {
#[label]
@@ -42,7 +42,7 @@
}
#[derive(LintDiagnostic)]
-#[diag(mir_build_unsafe_op_in_unsafe_fn_inline_assembly_requires_unsafe)]
+#[diag(mir_build_unsafe_op_in_unsafe_fn_inline_assembly_requires_unsafe, code = E0133)]
#[note]
pub struct UnsafeOpInUnsafeFnUseOfInlineAssemblyRequiresUnsafe {
#[label]
@@ -52,7 +52,7 @@
}
#[derive(LintDiagnostic)]
-#[diag(mir_build_unsafe_op_in_unsafe_fn_initializing_type_with_requires_unsafe)]
+#[diag(mir_build_unsafe_op_in_unsafe_fn_initializing_type_with_requires_unsafe, code = E0133)]
#[note]
pub struct UnsafeOpInUnsafeFnInitializingTypeWithRequiresUnsafe {
#[label]
@@ -62,7 +62,7 @@
}
#[derive(LintDiagnostic)]
-#[diag(mir_build_unsafe_op_in_unsafe_fn_mutable_static_requires_unsafe)]
+#[diag(mir_build_unsafe_op_in_unsafe_fn_mutable_static_requires_unsafe, code = E0133)]
#[note]
pub struct UnsafeOpInUnsafeFnUseOfMutableStaticRequiresUnsafe {
#[label]
@@ -72,7 +72,7 @@
}
#[derive(LintDiagnostic)]
-#[diag(mir_build_unsafe_op_in_unsafe_fn_extern_static_requires_unsafe)]
+#[diag(mir_build_unsafe_op_in_unsafe_fn_extern_static_requires_unsafe, code = E0133)]
#[note]
pub struct UnsafeOpInUnsafeFnUseOfExternStaticRequiresUnsafe {
#[label]
@@ -82,7 +82,7 @@
}
#[derive(LintDiagnostic)]
-#[diag(mir_build_unsafe_op_in_unsafe_fn_deref_raw_pointer_requires_unsafe)]
+#[diag(mir_build_unsafe_op_in_unsafe_fn_deref_raw_pointer_requires_unsafe, code = E0133)]
#[note]
pub struct UnsafeOpInUnsafeFnDerefOfRawPointerRequiresUnsafe {
#[label]
@@ -92,7 +92,7 @@
}
#[derive(LintDiagnostic)]
-#[diag(mir_build_unsafe_op_in_unsafe_fn_union_field_requires_unsafe)]
+#[diag(mir_build_unsafe_op_in_unsafe_fn_union_field_requires_unsafe, code = E0133)]
#[note]
pub struct UnsafeOpInUnsafeFnAccessToUnionFieldRequiresUnsafe {
#[label]
@@ -102,7 +102,10 @@
}
#[derive(LintDiagnostic)]
-#[diag(mir_build_unsafe_op_in_unsafe_fn_mutation_of_layout_constrained_field_requires_unsafe)]
+#[diag(
+ mir_build_unsafe_op_in_unsafe_fn_mutation_of_layout_constrained_field_requires_unsafe,
+ code = E0133
+)]
#[note]
pub struct UnsafeOpInUnsafeFnMutationOfLayoutConstrainedFieldRequiresUnsafe {
#[label]
@@ -112,7 +115,10 @@
}
#[derive(LintDiagnostic)]
-#[diag(mir_build_unsafe_op_in_unsafe_fn_borrow_of_layout_constrained_field_requires_unsafe)]
+#[diag(
+ mir_build_unsafe_op_in_unsafe_fn_borrow_of_layout_constrained_field_requires_unsafe,
+ code = E0133,
+)]
pub struct UnsafeOpInUnsafeFnBorrowOfLayoutConstrainedFieldRequiresUnsafe {
#[label]
pub span: Span,
@@ -121,7 +127,7 @@
}
#[derive(LintDiagnostic)]
-#[diag(mir_build_unsafe_op_in_unsafe_fn_call_to_fn_with_requires_unsafe)]
+#[diag(mir_build_unsafe_op_in_unsafe_fn_call_to_fn_with_requires_unsafe, code = E0133)]
#[help]
pub struct UnsafeOpInUnsafeFnCallToFunctionWithRequiresUnsafe {
#[label]
diff --git a/compiler/rustc_mir_build/src/lib.rs b/compiler/rustc_mir_build/src/lib.rs
index 2e1cb0e..74600c6 100644
--- a/compiler/rustc_mir_build/src/lib.rs
+++ b/compiler/rustc_mir_build/src/lib.rs
@@ -10,9 +10,6 @@
#![feature(let_chains)]
#![feature(try_blocks)]
-#[macro_use]
-extern crate tracing;
-
mod build;
mod check_unsafety;
mod errors;
diff --git a/compiler/rustc_mir_build/src/thir/constant.rs b/compiler/rustc_mir_build/src/thir/constant.rs
index 03c7c1f..31bc721 100644
--- a/compiler/rustc_mir_build/src/thir/constant.rs
+++ b/compiler/rustc_mir_build/src/thir/constant.rs
@@ -2,6 +2,7 @@
use rustc_middle::bug;
use rustc_middle::mir::interpret::{LitToConstError, LitToConstInput};
use rustc_middle::ty::{self, ParamEnv, ScalarInt, TyCtxt};
+use tracing::trace;
use crate::build::parse_float_into_scalar;
diff --git a/compiler/rustc_mir_build/src/thir/cx/block.rs b/compiler/rustc_mir_build/src/thir/cx/block.rs
index d4a3479..54eafdd 100644
--- a/compiler/rustc_mir_build/src/thir/cx/block.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/block.rs
@@ -1,12 +1,12 @@
use crate::thir::cx::Cx;
use rustc_hir as hir;
+use rustc_index::Idx;
use rustc_middle::middle::region;
use rustc_middle::thir::*;
use rustc_middle::ty;
-
-use rustc_index::Idx;
use rustc_middle::ty::CanonicalUserTypeAnnotation;
+use tracing::debug;
impl<'tcx> Cx<'tcx> {
pub(crate) fn mirror_block(&mut self, block: &'tcx hir::Block<'tcx>) -> BlockId {
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index b776666..28f9300 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -25,6 +25,7 @@
use rustc_span::source_map::Spanned;
use rustc_span::{sym, Span, DUMMY_SP};
use rustc_target::abi::{FieldIdx, FIRST_VARIANT};
+use tracing::{debug, info, instrument, trace};
impl<'tcx> Cx<'tcx> {
pub(crate) fn mirror_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) -> ExprId {
diff --git a/compiler/rustc_mir_build/src/thir/cx/mod.rs b/compiler/rustc_mir_build/src/thir/cx/mod.rs
index d1d21f8..3c0e252 100644
--- a/compiler/rustc_mir_build/src/thir/cx/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/mod.rs
@@ -17,6 +17,7 @@
use rustc_middle::middle::region;
use rustc_middle::thir::*;
use rustc_middle::ty::{self, RvalueScopes, TyCtxt};
+use tracing::instrument;
pub(crate) fn thir_body(
tcx: TyCtxt<'_>,
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index 592f0dc..30f57c8 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -24,6 +24,7 @@
};
use rustc_span::hygiene::DesugaringKind;
use rustc_span::{sym, Span};
+use tracing::instrument;
pub(crate) fn check_match(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Result<(), ErrorGuaranteed> {
let typeck_results = tcx.typeck(def_id);
diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
index c6f81c3..bac47fa 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -12,6 +12,7 @@
use rustc_target::abi::{FieldIdx, VariantIdx};
use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt;
use rustc_trait_selection::traits::{self, ObligationCause};
+use tracing::{debug, instrument, trace};
use std::cell::Cell;
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
index dc845b3..7408c67 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -25,6 +25,7 @@
use rustc_span::def_id::LocalDefId;
use rustc_span::{ErrorGuaranteed, Span};
use rustc_target::abi::{FieldIdx, Integer};
+use tracing::{debug, instrument};
use std::cmp::Ordering;
diff --git a/compiler/rustc_mir_build/src/thir/util.rs b/compiler/rustc_mir_build/src/thir/util.rs
index 340eb3c..53a2a08 100644
--- a/compiler/rustc_mir_build/src/thir/util.rs
+++ b/compiler/rustc_mir_build/src/thir/util.rs
@@ -1,6 +1,7 @@
use rustc_hir as hir;
use rustc_middle::bug;
use rustc_middle::ty::{self, CanonicalUserType, TyCtxt, UserType};
+use tracing::debug;
pub(crate) trait UserAnnotatedTyHelpers<'tcx> {
fn tcx(&self) -> TyCtxt<'tcx>;
diff --git a/compiler/rustc_mir_dataflow/src/drop_flag_effects.rs b/compiler/rustc_mir_dataflow/src/drop_flag_effects.rs
index de1ca8d..82c59d7 100644
--- a/compiler/rustc_mir_dataflow/src/drop_flag_effects.rs
+++ b/compiler/rustc_mir_dataflow/src/drop_flag_effects.rs
@@ -1,6 +1,7 @@
use crate::elaborate_drops::DropFlagState;
use rustc_middle::mir::{self, Body, Location, Terminator, TerminatorKind};
use rustc_target::abi::VariantIdx;
+use tracing::debug;
use super::move_paths::{InitKind, LookupResult, MoveData, MovePathIndex};
use super::MoveDataParamEnv;
diff --git a/compiler/rustc_mir_dataflow/src/elaborate_drops.rs b/compiler/rustc_mir_dataflow/src/elaborate_drops.rs
index 185e87b..bdc59e8 100644
--- a/compiler/rustc_mir_dataflow/src/elaborate_drops.rs
+++ b/compiler/rustc_mir_dataflow/src/elaborate_drops.rs
@@ -11,6 +11,7 @@
use rustc_span::DUMMY_SP;
use rustc_target::abi::{FieldIdx, VariantIdx, FIRST_VARIANT};
use std::{fmt, iter};
+use tracing::{debug, instrument};
/// The value of an inserted drop flag.
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
diff --git a/compiler/rustc_mir_dataflow/src/framework/engine.rs b/compiler/rustc_mir_dataflow/src/framework/engine.rs
index ea9cf65..564a99e 100644
--- a/compiler/rustc_mir_dataflow/src/framework/engine.rs
+++ b/compiler/rustc_mir_dataflow/src/framework/engine.rs
@@ -19,6 +19,7 @@
use rustc_middle::ty::print::with_no_trimmed_paths;
use rustc_middle::ty::TyCtxt;
use rustc_span::symbol::{sym, Symbol};
+use tracing::{debug, error};
use super::fmt::DebugWithContext;
use super::graphviz;
diff --git a/compiler/rustc_mir_dataflow/src/impls/initialized.rs b/compiler/rustc_mir_dataflow/src/impls/initialized.rs
index 180168c..f0b79da 100644
--- a/compiler/rustc_mir_dataflow/src/impls/initialized.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/initialized.rs
@@ -3,6 +3,7 @@
use rustc_middle::bug;
use rustc_middle::mir::{self, Body, CallReturnPlaces, Location, TerminatorEdges};
use rustc_middle::ty::{self, TyCtxt};
+use tracing::{debug, instrument};
use crate::drop_flag_effects_for_function_entry;
use crate::drop_flag_effects_for_location;
diff --git a/compiler/rustc_mir_dataflow/src/lib.rs b/compiler/rustc_mir_dataflow/src/lib.rs
index 5e96a73..0b397a6 100644
--- a/compiler/rustc_mir_dataflow/src/lib.rs
+++ b/compiler/rustc_mir_dataflow/src/lib.rs
@@ -4,9 +4,6 @@
#![feature(let_chains)]
#![feature(try_blocks)]
-#[macro_use]
-extern crate tracing;
-
use rustc_middle::ty;
// Please change the public `use` directives cautiously, as they might be used by external tools.
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
index 521ecb1..1fb77be 100644
--- a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
+++ b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -4,6 +4,7 @@
use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
use rustc_middle::{bug, span_bug};
use smallvec::{smallvec, SmallVec};
+use tracing::debug;
use std::mem;
diff --git a/compiler/rustc_mir_dataflow/src/rustc_peek.rs b/compiler/rustc_mir_dataflow/src/rustc_peek.rs
index d7e3c91..1de9055 100644
--- a/compiler/rustc_mir_dataflow/src/rustc_peek.rs
+++ b/compiler/rustc_mir_dataflow/src/rustc_peek.rs
@@ -18,6 +18,7 @@
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_span::symbol::{sym, Symbol};
use rustc_span::Span;
+use tracing::{debug, info};
pub struct SanityCheck;
diff --git a/compiler/rustc_mir_dataflow/src/value_analysis.rs b/compiler/rustc_mir_dataflow/src/value_analysis.rs
index 1e5322d..5e2d88f 100644
--- a/compiler/rustc_mir_dataflow/src/value_analysis.rs
+++ b/compiler/rustc_mir_dataflow/src/value_analysis.rs
@@ -45,6 +45,7 @@
use rustc_middle::mir::*;
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_target::abi::{FieldIdx, VariantIdx};
+use tracing::debug;
use crate::lattice::{HasBottom, HasTop};
use crate::{
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
index 3d24a56..53a016f 100644
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -165,9 +165,7 @@
}
}
}
- Rvalue::BinaryOp(overflowing_op, box (left, right))
- if let Some(op) = overflowing_op.overflowing_to_wrapping() =>
- {
+ Rvalue::BinaryOp(op, box (left, right)) if op.is_overflowing() => {
// Flood everything now, so we can use `insert_value_idx` directly later.
state.flood(target.as_ref(), self.map());
@@ -177,7 +175,7 @@
let overflow_target = self.map().apply(target, TrackElem::Field(1_u32.into()));
if value_target.is_some() || overflow_target.is_some() {
- let (val, overflow) = self.binary_op(state, op, left, right);
+ let (val, overflow) = self.binary_op(state, *op, left, right);
if let Some(value_target) = value_target {
// We have flooded `target` earlier.
@@ -186,7 +184,7 @@
if let Some(overflow_target) = overflow_target {
let overflow = match overflow {
FlatSet::Top => FlatSet::Top,
- FlatSet::Elem(overflow) => FlatSet::Elem(Scalar::from_bool(overflow)),
+ FlatSet::Elem(overflow) => FlatSet::Elem(overflow),
FlatSet::Bottom => FlatSet::Bottom,
};
// We have flooded `target` earlier.
@@ -266,15 +264,16 @@
FlatSet::Top => FlatSet::Top,
}
}
- Rvalue::BinaryOp(op, box (left, right)) => {
+ Rvalue::BinaryOp(op, box (left, right)) if !op.is_overflowing() => {
// Overflows must be ignored here.
+ // The overflowing operators are handled in `handle_assign`.
let (val, _overflow) = self.binary_op(state, *op, left, right);
val
}
Rvalue::UnaryOp(op, operand) => match self.eval_operand(operand, state) {
FlatSet::Elem(value) => self
.ecx
- .wrapping_unary_op(*op, &value)
+ .unary_op(*op, &value)
.map_or(FlatSet::Top, |val| self.wrap_immediate(*val)),
FlatSet::Bottom => FlatSet::Bottom,
FlatSet::Top => FlatSet::Top,
@@ -439,7 +438,7 @@
op: BinOp,
left: &Operand<'tcx>,
right: &Operand<'tcx>,
- ) -> (FlatSet<Scalar>, FlatSet<bool>) {
+ ) -> (FlatSet<Scalar>, FlatSet<Scalar>) {
let left = self.eval_operand(left, state);
let right = self.eval_operand(right, state);
@@ -447,9 +446,17 @@
(FlatSet::Bottom, _) | (_, FlatSet::Bottom) => (FlatSet::Bottom, FlatSet::Bottom),
// Both sides are known, do the actual computation.
(FlatSet::Elem(left), FlatSet::Elem(right)) => {
- match self.ecx.overflowing_binary_op(op, &left, &right) {
- Ok((val, overflow)) => {
- (FlatSet::Elem(val.to_scalar()), FlatSet::Elem(overflow))
+ match self.ecx.binary_op(op, &left, &right) {
+ // Ideally this would return an Immediate, since it's sometimes
+ // a pair and sometimes not. But as a hack we always return a pair
+ // and just make the 2nd component `Bottom` when it does not exist.
+ Ok(val) => {
+ if matches!(val.layout.abi, Abi::ScalarPair(..)) {
+ let (val, overflow) = val.to_scalar_pair();
+ (FlatSet::Elem(val), FlatSet::Elem(overflow))
+ } else {
+ (FlatSet::Elem(val.to_scalar()), FlatSet::Bottom)
+ }
}
_ => (FlatSet::Top, FlatSet::Top),
}
@@ -475,7 +482,7 @@
(FlatSet::Elem(arg_scalar), FlatSet::Bottom)
}
BinOp::Mul if layout.ty.is_integral() && arg_value == 0 => {
- (FlatSet::Elem(arg_scalar), FlatSet::Elem(false))
+ (FlatSet::Elem(arg_scalar), FlatSet::Elem(Scalar::from_bool(false)))
}
_ => (FlatSet::Top, FlatSet::Top),
}
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 1f3e407..9d2e715 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -223,7 +223,7 @@
NullaryOp(NullOp<'tcx>, Ty<'tcx>),
UnaryOp(UnOp, VnIndex),
BinaryOp(BinOp, VnIndex, VnIndex),
- CheckedBinaryOp(BinOp, VnIndex, VnIndex),
+ CheckedBinaryOp(BinOp, VnIndex, VnIndex), // FIXME get rid of this, work like MIR instead
Cast {
kind: CastKind,
value: VnIndex,
@@ -497,7 +497,7 @@
UnaryOp(un_op, operand) => {
let operand = self.evaluated[operand].as_ref()?;
let operand = self.ecx.read_immediate(operand).ok()?;
- let (val, _) = self.ecx.overflowing_unary_op(un_op, &operand).ok()?;
+ let val = self.ecx.unary_op(un_op, &operand).ok()?;
val.into()
}
BinaryOp(bin_op, lhs, rhs) => {
@@ -505,7 +505,7 @@
let lhs = self.ecx.read_immediate(lhs).ok()?;
let rhs = self.evaluated[rhs].as_ref()?;
let rhs = self.ecx.read_immediate(rhs).ok()?;
- let (val, _) = self.ecx.overflowing_binary_op(bin_op, &lhs, &rhs).ok()?;
+ let val = self.ecx.binary_op(bin_op, &lhs, &rhs).ok()?;
val.into()
}
CheckedBinaryOp(bin_op, lhs, rhs) => {
@@ -513,14 +513,11 @@
let lhs = self.ecx.read_immediate(lhs).ok()?;
let rhs = self.evaluated[rhs].as_ref()?;
let rhs = self.ecx.read_immediate(rhs).ok()?;
- let (val, overflowed) = self.ecx.overflowing_binary_op(bin_op, &lhs, &rhs).ok()?;
- let tuple = Ty::new_tup_from_iter(
- self.tcx,
- [val.layout.ty, self.tcx.types.bool].into_iter(),
- );
- let tuple = self.ecx.layout_of(tuple).ok()?;
- ImmTy::from_scalar_pair(val.to_scalar(), Scalar::from_bool(overflowed), tuple)
- .into()
+ let val = self
+ .ecx
+ .binary_op(bin_op.wrapping_to_overflowing().unwrap(), &lhs, &rhs)
+ .ok()?;
+ val.into()
}
Cast { kind, value, from: _, to } => match kind {
CastKind::IntToInt | CastKind::IntToFloat => {
diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs
index 38fc37a..0fa5c1b 100644
--- a/compiler/rustc_mir_transform/src/known_panics_lint.rs
+++ b/compiler/rustc_mir_transform/src/known_panics_lint.rs
@@ -304,20 +304,25 @@
fn check_unary_op(&mut self, op: UnOp, arg: &Operand<'tcx>, location: Location) -> Option<()> {
let arg = self.eval_operand(arg)?;
- if let (val, true) = self.use_ecx(|this| {
- let val = this.ecx.read_immediate(&arg)?;
- let (_res, overflow) = this.ecx.overflowing_unary_op(op, &val)?;
- Ok((val, overflow))
- })? {
- // `AssertKind` only has an `OverflowNeg` variant, so make sure that is
- // appropriate to use.
- assert_eq!(op, UnOp::Neg, "Neg is the only UnOp that can overflow");
- self.report_assert_as_lint(
- location,
- AssertLintKind::ArithmeticOverflow,
- AssertKind::OverflowNeg(val.to_const_int()),
- );
- return None;
+ // The only operator that can overflow is `Neg`.
+ if op == UnOp::Neg && arg.layout.ty.is_integral() {
+ // Compute this as `0 - arg` so we can use `SubWithOverflow` to check for overflow.
+ let (arg, overflow) = self.use_ecx(|this| {
+ let arg = this.ecx.read_immediate(&arg)?;
+ let (_res, overflow) = this
+ .ecx
+ .binary_op(BinOp::SubWithOverflow, &ImmTy::from_int(0, arg.layout), &arg)?
+ .to_scalar_pair();
+ Ok((arg, overflow.to_bool()?))
+ })?;
+ if overflow {
+ self.report_assert_as_lint(
+ location,
+ AssertLintKind::ArithmeticOverflow,
+ AssertKind::OverflowNeg(arg.to_const_int()),
+ );
+ return None;
+ }
}
Some(())
@@ -363,11 +368,20 @@
}
}
- if let (Some(l), Some(r)) = (l, r) {
- // The remaining operators are handled through `overflowing_binary_op`.
+ // Div/Rem are handled via the assertions they trigger.
+ // But for Add/Sub/Mul, those assertions only exist in debug builds, and we want to
+ // lint in release builds as well, so we check on the operation instead.
+ // So normalize to the "overflowing" operator, and then ensure that it
+ // actually is an overflowing operator.
+ let op = op.wrapping_to_overflowing().unwrap_or(op);
+ // The remaining operators are handled through `wrapping_to_overflowing`.
+ if let (Some(l), Some(r)) = (l, r)
+ && l.layout.ty.is_integral()
+ && op.is_overflowing()
+ {
if self.use_ecx(|this| {
- let (_res, overflow) = this.ecx.overflowing_binary_op(op, &l, &r)?;
- Ok(overflow)
+ let (_res, overflow) = this.ecx.binary_op(op, &l, &r)?.to_scalar_pair();
+ overflow.to_bool()
})? {
self.report_assert_as_lint(
location,
@@ -399,8 +413,7 @@
}
Rvalue::BinaryOp(op, box (left, right)) => {
trace!("checking BinaryOp(op = {:?}, left = {:?}, right = {:?})", op, left, right);
- let op = op.overflowing_to_wrapping().unwrap_or(*op);
- self.check_binary_op(op, left, right, location)?;
+ self.check_binary_op(*op, left, right, location)?;
}
// Do not try creating references (#67862)
@@ -547,17 +560,15 @@
let right = self.eval_operand(right)?;
let right = self.use_ecx(|this| this.ecx.read_immediate(&right))?;
- if let Some(bin_op) = bin_op.overflowing_to_wrapping() {
- let (val, overflowed) =
- self.use_ecx(|this| this.ecx.overflowing_binary_op(bin_op, &left, &right))?;
- let overflowed = ImmTy::from_bool(overflowed, self.tcx);
+ let val = self.use_ecx(|this| this.ecx.binary_op(bin_op, &left, &right))?;
+ if matches!(val.layout.abi, Abi::ScalarPair(..)) {
+ // FIXME `Value` should properly support pairs in `Immediate`... but currently it does not.
+ let (val, overflow) = val.to_pair(&self.ecx);
Value::Aggregate {
variant: VariantIdx::ZERO,
- fields: [Value::from(val), overflowed.into()].into_iter().collect(),
+ fields: [val.into(), overflow.into()].into_iter().collect(),
}
} else {
- let val =
- self.use_ecx(|this| this.ecx.wrapping_binary_op(bin_op, &left, &right))?;
val.into()
}
}
@@ -566,7 +577,7 @@
let operand = self.eval_operand(operand)?;
let val = self.use_ecx(|this| this.ecx.read_immediate(&operand))?;
- let val = self.use_ecx(|this| this.ecx.wrapping_unary_op(un_op, &val))?;
+ let val = self.use_ecx(|this| this.ecx.unary_op(un_op, &val))?;
val.into()
}
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index 4b43564..76972ff 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -236,6 +236,7 @@
use rustc_span::{Span, DUMMY_SP};
use rustc_target::abi::Size;
use std::path::PathBuf;
+use tracing::{debug, instrument, trace};
use crate::errors::{
self, EncounteredErrorWhileInstantiating, NoOptimizedMir, RecursionLimit, TypeLengthLimit,
diff --git a/compiler/rustc_monomorphize/src/collector/move_check.rs b/compiler/rustc_monomorphize/src/collector/move_check.rs
index 4cc7275..851f86e 100644
--- a/compiler/rustc_monomorphize/src/collector/move_check.rs
+++ b/compiler/rustc_monomorphize/src/collector/move_check.rs
@@ -1,4 +1,5 @@
use rustc_session::lint::builtin::LARGE_ASSIGNMENTS;
+use tracing::debug;
use super::*;
use crate::errors::LargeAssignmentsLint;
diff --git a/compiler/rustc_monomorphize/src/lib.rs b/compiler/rustc_monomorphize/src/lib.rs
index ddfb42a..b298fe5 100644
--- a/compiler/rustc_monomorphize/src/lib.rs
+++ b/compiler/rustc_monomorphize/src/lib.rs
@@ -2,9 +2,6 @@
#![feature(is_sorted)]
#![allow(rustc::potential_query_instability)]
-#[macro_use]
-extern crate tracing;
-
use rustc_hir::lang_items::LangItem;
use rustc_middle::bug;
use rustc_middle::query::{Providers, TyCtxtAt};
diff --git a/compiler/rustc_monomorphize/src/partitioning.rs b/compiler/rustc_monomorphize/src/partitioning.rs
index 8f7b4c6..21d5200 100644
--- a/compiler/rustc_monomorphize/src/partitioning.rs
+++ b/compiler/rustc_monomorphize/src/partitioning.rs
@@ -116,6 +116,7 @@
use rustc_session::config::{DumpMonoStatsFormat, SwitchWithOptPath};
use rustc_session::CodegenUnits;
use rustc_span::symbol::Symbol;
+use tracing::debug;
use crate::collector::UsageMap;
use crate::collector::{self, MonoItemCollectionStrategy};
diff --git a/compiler/rustc_monomorphize/src/polymorphize.rs b/compiler/rustc_monomorphize/src/polymorphize.rs
index 14ebe27..dc13766 100644
--- a/compiler/rustc_monomorphize/src/polymorphize.rs
+++ b/compiler/rustc_monomorphize/src/polymorphize.rs
@@ -18,6 +18,7 @@
GenericArgsRef, Ty, TyCtxt, UnusedGenericParams,
};
use rustc_span::symbol::sym;
+use tracing::{debug, instrument};
use crate::errors::UnusedGenericParamsHint;
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 6eb8bed..d3a6a03 100644
--- a/compiler/rustc_parse/src/lexer/mod.rs
+++ b/compiler/rustc_parse/src/lexer/mod.rs
@@ -18,6 +18,7 @@
use rustc_session::parse::ParseSess;
use rustc_span::symbol::Symbol;
use rustc_span::{edition::Edition, BytePos, Pos, Span};
+use tracing::debug;
mod diagnostics;
mod tokentrees;
diff --git a/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs b/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs
index fa242a3..cad25c6 100644
--- a/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs
+++ b/compiler/rustc_parse/src/lexer/unescape_error_reporting.rs
@@ -6,6 +6,7 @@
use rustc_errors::{Applicability, DiagCtxt, ErrorGuaranteed};
use rustc_lexer::unescape::{EscapeError, Mode};
use rustc_span::{BytePos, Span};
+use tracing::debug;
use crate::errors::{MoreThanOneCharNote, MoreThanOneCharSugg, NoBraceUnicodeSub, UnescapeError};
diff --git a/compiler/rustc_parse/src/lib.rs b/compiler/rustc_parse/src/lib.rs
index 0f973df..322739b 100644
--- a/compiler/rustc_parse/src/lib.rs
+++ b/compiler/rustc_parse/src/lib.rs
@@ -10,9 +10,6 @@
#![feature(iter_intersperse)]
#![feature(let_chains)]
-#[macro_use]
-extern crate tracing;
-
use rustc_ast as ast;
use rustc_ast::token;
use rustc_ast::tokenstream::TokenStream;
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index ac12787..9677eea 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -45,6 +45,7 @@
use std::mem::take;
use std::ops::{Deref, DerefMut};
use thin_vec::{thin_vec, ThinVec};
+use tracing::{debug, trace};
/// Creates a placeholder argument.
pub(super) fn dummy_arg(ident: Ident, guar: ErrorGuaranteed) -> Param {
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index fd3f63a..1b99bc0 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -36,6 +36,7 @@
use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{BytePos, ErrorGuaranteed, Pos, Span};
use thin_vec::{thin_vec, ThinVec};
+use tracing::instrument;
/// Possibly accepts an `token::Interpolated` expression (a pre-parsed expression
/// dropped into the token stream, which happens while parsing the result of
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index f43ddad..53757c3 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -23,6 +23,7 @@
use std::fmt::Write;
use std::mem;
use thin_vec::{thin_vec, ThinVec};
+use tracing::debug;
impl<'a> Parser<'a> {
/// Parses a source module as a crate. This is the main entry point for the parser.
diff --git a/compiler/rustc_parse/src/parser/stmt.rs b/compiler/rustc_parse/src/parser/stmt.rs
index 7424fbe..be539d1 100644
--- a/compiler/rustc_parse/src/parser/stmt.rs
+++ b/compiler/rustc_parse/src/parser/stmt.rs
@@ -15,7 +15,7 @@
use rustc_ast as ast;
use rustc_ast::ptr::P;
use rustc_ast::token::{self, Delimiter, TokenKind};
-use rustc_ast::util::classify;
+use rustc_ast::util::classify::{self, TrailingBrace};
use rustc_ast::{AttrStyle, AttrVec, LocalKind, MacCall, MacCallStmt, MacStmtStyle};
use rustc_ast::{Block, BlockCheckMode, Expr, ExprKind, HasAttrs, Local, Recovered, Stmt};
use rustc_ast::{StmtKind, DUMMY_NODE_ID};
@@ -407,18 +407,24 @@
fn check_let_else_init_trailing_brace(&self, init: &ast::Expr) {
if let Some(trailing) = classify::expr_trailing_brace(init) {
- let sugg = match &trailing.kind {
- ExprKind::MacCall(mac) => errors::WrapInParentheses::MacroArgs {
- left: mac.args.dspan.open,
- right: mac.args.dspan.close,
- },
- _ => errors::WrapInParentheses::Expression {
- left: trailing.span.shrink_to_lo(),
- right: trailing.span.shrink_to_hi(),
- },
+ let (span, sugg) = match trailing {
+ TrailingBrace::MacCall(mac) => (
+ mac.span(),
+ errors::WrapInParentheses::MacroArgs {
+ left: mac.args.dspan.open,
+ right: mac.args.dspan.close,
+ },
+ ),
+ TrailingBrace::Expr(expr) => (
+ expr.span,
+ errors::WrapInParentheses::Expression {
+ left: expr.span.shrink_to_lo(),
+ right: expr.span.shrink_to_hi(),
+ },
+ ),
};
self.dcx().emit_err(errors::InvalidCurlyInLetElse {
- span: trailing.span.with_lo(trailing.span.hi() - BytePos(1)),
+ span: span.with_lo(span.hi() - BytePos(1)),
sugg,
});
}
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..4fe84b9 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -39,6 +39,7 @@
use rustc_trait_selection::traits::ObligationCtxt;
use std::cell::Cell;
use std::collections::hash_map::Entry;
+use tracing::debug;
#[derive(LintDiagnostic)]
#[diag(passes_diagnostic_diagnostic_on_unimplemented_only_for_traits)]
@@ -113,92 +114,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 +295,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 +323,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/dead.rs b/compiler/rustc_passes/src/dead.rs
index 933412f..ddc50e2 100644
--- a/compiler/rustc_passes/src/dead.rs
+++ b/compiler/rustc_passes/src/dead.rs
@@ -425,10 +425,11 @@
&& let ItemKind::Impl(impl_ref) =
self.tcx.hir().expect_item(local_impl_id).kind
{
- if self.tcx.visibility(trait_id).is_public()
- && matches!(trait_item.kind, hir::TraitItemKind::Fn(..))
+ if matches!(trait_item.kind, hir::TraitItemKind::Fn(..))
&& !ty_ref_to_pub_struct(self.tcx, impl_ref.self_ty)
{
+ // skip methods of private ty,
+ // they would be solved in `solve_rest_impl_items`
continue;
}
@@ -485,32 +486,46 @@
fn solve_rest_impl_items(&mut self, mut unsolved_impl_items: Vec<(hir::ItemId, LocalDefId)>) {
let mut ready;
- (ready, unsolved_impl_items) = unsolved_impl_items
- .into_iter()
- .partition(|&(impl_id, _)| self.impl_item_with_used_self(impl_id));
+ (ready, unsolved_impl_items) =
+ unsolved_impl_items.into_iter().partition(|&(impl_id, impl_item_id)| {
+ self.impl_item_with_used_self(impl_id, impl_item_id)
+ });
while !ready.is_empty() {
self.worklist =
ready.into_iter().map(|(_, id)| (id, ComesFromAllowExpect::No)).collect();
self.mark_live_symbols();
- (ready, unsolved_impl_items) = unsolved_impl_items
- .into_iter()
- .partition(|&(impl_id, _)| self.impl_item_with_used_self(impl_id));
+ (ready, unsolved_impl_items) =
+ unsolved_impl_items.into_iter().partition(|&(impl_id, impl_item_id)| {
+ self.impl_item_with_used_self(impl_id, impl_item_id)
+ });
}
}
- fn impl_item_with_used_self(&mut self, impl_id: hir::ItemId) -> bool {
+ fn impl_item_with_used_self(&mut self, impl_id: hir::ItemId, impl_item_id: LocalDefId) -> bool {
if let TyKind::Path(hir::QPath::Resolved(_, path)) =
self.tcx.hir().item(impl_id).expect_impl().self_ty.kind
&& let Res::Def(def_kind, def_id) = path.res
&& let Some(local_def_id) = def_id.as_local()
&& matches!(def_kind, DefKind::Struct | DefKind::Enum | DefKind::Union)
{
- self.live_symbols.contains(&local_def_id)
- } else {
- false
+ if self.tcx.visibility(impl_item_id).is_public() {
+ // for the public method, we don't know the trait item is used or not,
+ // so we mark the method live if the self is used
+ return self.live_symbols.contains(&local_def_id);
+ }
+
+ if let Some(trait_item_id) = self.tcx.associated_item(impl_item_id).trait_item_def_id
+ && let Some(local_id) = trait_item_id.as_local()
+ {
+ // for the private method, we can know the trait item is used or not,
+ // so we mark the method live if the self is used and the trait item is used
+ return self.live_symbols.contains(&local_id)
+ && self.live_symbols.contains(&local_def_id);
+ }
}
+ false
}
}
@@ -745,20 +760,22 @@
matches!(fn_sig.decl.implicit_self, hir::ImplicitSelfKind::None);
}
- // for impl trait blocks, mark associate functions live if the trait is public
+ // for trait impl blocks,
+ // mark the method live if the self_ty is public,
+ // or the method is public and may construct self
if of_trait
&& (!matches!(tcx.def_kind(local_def_id), DefKind::AssocFn)
|| tcx.visibility(local_def_id).is_public()
&& (ty_is_pub || may_construct_self))
{
worklist.push((local_def_id, ComesFromAllowExpect::No));
- } else if of_trait && tcx.visibility(local_def_id).is_public() {
- // pub method && private ty & methods not construct self
- unsolved_impl_items.push((id, local_def_id));
} else if let Some(comes_from_allow) =
has_allow_dead_code_or_lang_attr(tcx, local_def_id)
{
worklist.push((local_def_id, comes_from_allow));
+ } else if of_trait {
+ // private method || public method not constructs self
+ unsolved_impl_items.push((id, local_def_id));
}
}
}
diff --git a/compiler/rustc_passes/src/diagnostic_items.rs b/compiler/rustc_passes/src/diagnostic_items.rs
index 906ecdf..78653e5 100644
--- a/compiler/rustc_passes/src/diagnostic_items.rs
+++ b/compiler/rustc_passes/src/diagnostic_items.rs
@@ -82,7 +82,7 @@
let mut items = DiagnosticItems::default();
// Collect diagnostic items in other crates.
- for &cnum in tcx.crates(()).iter().chain(std::iter::once(&LOCAL_CRATE)) {
+ for &cnum in tcx.crates_including_speculative(()).iter().chain(std::iter::once(&LOCAL_CRATE)) {
for (&name, &def_id) in &tcx.diagnostic_items(cnum).name_to_id {
collect_item(tcx, &mut items, name, def_id);
}
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index b8586e7..7fdd992 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)]
@@ -1103,7 +1100,7 @@
pub struct OutsideLoop<'a> {
#[primary_span]
#[label]
- pub span: Span,
+ pub spans: Vec<Span>,
pub name: &'a str,
pub is_break: bool,
#[subdiagnostic]
@@ -1115,7 +1112,7 @@
#[suggestion_part(code = "'block: ")]
pub block_span: Span,
#[suggestion_part(code = " 'block")]
- pub break_span: Span,
+ pub break_spans: Vec<Span>,
}
#[derive(Diagnostic)]
diff --git a/compiler/rustc_passes/src/lib.rs b/compiler/rustc_passes/src/lib.rs
index d3608759..045a0a1 100644
--- a/compiler/rustc_passes/src/lib.rs
+++ b/compiler/rustc_passes/src/lib.rs
@@ -12,9 +12,6 @@
#![feature(map_try_insert)]
#![feature(try_blocks)]
-#[macro_use]
-extern crate tracing;
-
use rustc_middle::query::Providers;
pub mod abi_test;
diff --git a/compiler/rustc_passes/src/liveness.rs b/compiler/rustc_passes/src/liveness.rs
index b50cb15..b0a7536 100644
--- a/compiler/rustc_passes/src/liveness.rs
+++ b/compiler/rustc_passes/src/liveness.rs
@@ -99,10 +99,10 @@
use rustc_session::lint;
use rustc_span::symbol::{kw, sym, Symbol};
use rustc_span::{BytePos, Span};
-
use std::io;
use std::io::prelude::*;
use std::rc::Rc;
+use tracing::{debug, instrument};
mod rwu_table;
diff --git a/compiler/rustc_passes/src/loops.rs b/compiler/rustc_passes/src/loops.rs
index 3b20112..2587a18 100644
--- a/compiler/rustc_passes/src/loops.rs
+++ b/compiler/rustc_passes/src/loops.rs
@@ -1,3 +1,5 @@
+use std::collections::BTreeMap;
+use std::fmt;
use Context::*;
use rustc_hir as hir;
@@ -25,22 +27,55 @@
Closure(Span),
Coroutine { coroutine_span: Span, kind: hir::CoroutineDesugaring, source: hir::CoroutineSource },
UnlabeledBlock(Span),
+ UnlabeledIfBlock(Span),
LabeledBlock,
Constant,
}
-#[derive(Copy, Clone)]
+#[derive(Clone)]
+struct BlockInfo {
+ name: String,
+ spans: Vec<Span>,
+ suggs: Vec<Span>,
+}
+
+#[derive(PartialEq)]
+enum BreakContextKind {
+ Break,
+ Continue,
+}
+
+impl fmt::Display for BreakContextKind {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ match self {
+ BreakContextKind::Break => "break",
+ BreakContextKind::Continue => "continue",
+ }
+ .fmt(f)
+ }
+}
+
+#[derive(Clone)]
struct CheckLoopVisitor<'a, 'tcx> {
sess: &'a Session,
tcx: TyCtxt<'tcx>,
- cx: Context,
+ // Keep track of a stack of contexts, so that suggestions
+ // are not made for contexts where it would be incorrect,
+ // such as adding a label for an `if`.
+ // e.g. `if 'foo: {}` would be incorrect.
+ cx_stack: Vec<Context>,
+ block_breaks: BTreeMap<Span, BlockInfo>,
}
fn check_mod_loops(tcx: TyCtxt<'_>, module_def_id: LocalModDefId) {
- tcx.hir().visit_item_likes_in_module(
- module_def_id,
- &mut CheckLoopVisitor { sess: tcx.sess, tcx, cx: Normal },
- );
+ let mut check = CheckLoopVisitor {
+ sess: tcx.sess,
+ tcx,
+ cx_stack: vec![Normal],
+ block_breaks: Default::default(),
+ };
+ tcx.hir().visit_item_likes_in_module(module_def_id, &mut check);
+ check.report_outside_loop_error();
}
pub(crate) fn provide(providers: &mut Providers) {
@@ -83,6 +118,45 @@
fn visit_expr(&mut self, e: &'hir hir::Expr<'hir>) {
match e.kind {
+ hir::ExprKind::If(cond, then, else_opt) => {
+ self.visit_expr(cond);
+
+ let get_block = |ck_loop: &CheckLoopVisitor<'a, 'hir>,
+ expr: &hir::Expr<'hir>|
+ -> Option<&hir::Block<'hir>> {
+ if let hir::ExprKind::Block(b, None) = expr.kind
+ && matches!(
+ ck_loop.cx_stack.last(),
+ Some(&Normal)
+ | Some(&Constant)
+ | Some(&UnlabeledBlock(_))
+ | Some(&UnlabeledIfBlock(_))
+ )
+ {
+ Some(b)
+ } else {
+ None
+ }
+ };
+
+ if let Some(b) = get_block(self, then) {
+ self.with_context(UnlabeledIfBlock(b.span.shrink_to_lo()), |v| {
+ v.visit_block(b)
+ });
+ } else {
+ self.visit_expr(then);
+ }
+
+ if let Some(else_expr) = else_opt {
+ if let Some(b) = get_block(self, else_expr) {
+ self.with_context(UnlabeledIfBlock(b.span.shrink_to_lo()), |v| {
+ v.visit_block(b)
+ });
+ } else {
+ self.visit_expr(else_expr);
+ }
+ }
+ }
hir::ExprKind::Loop(ref b, _, source, _) => {
self.with_context(Loop(source), |v| v.visit_block(b));
}
@@ -101,11 +175,14 @@
hir::ExprKind::Block(ref b, Some(_label)) => {
self.with_context(LabeledBlock, |v| v.visit_block(b));
}
- hir::ExprKind::Block(ref b, None) if matches!(self.cx, Fn) => {
+ hir::ExprKind::Block(ref b, None) if matches!(self.cx_stack.last(), Some(&Fn)) => {
self.with_context(Normal, |v| v.visit_block(b));
}
hir::ExprKind::Block(ref b, None)
- if matches!(self.cx, Normal | Constant | UnlabeledBlock(_)) =>
+ if matches!(
+ self.cx_stack.last(),
+ Some(&Normal) | Some(&Constant) | Some(&UnlabeledBlock(_))
+ ) =>
{
self.with_context(UnlabeledBlock(b.span.shrink_to_lo()), |v| v.visit_block(b));
}
@@ -178,7 +255,12 @@
Some(label) => sp_lo.with_hi(label.ident.span.hi()),
None => sp_lo.shrink_to_lo(),
};
- self.require_break_cx("break", e.span, label_sp);
+ self.require_break_cx(
+ BreakContextKind::Break,
+ e.span,
+ label_sp,
+ self.cx_stack.len() - 1,
+ );
}
hir::ExprKind::Continue(destination) => {
self.require_label_in_labeled_block(e.span, &destination, "continue");
@@ -200,7 +282,12 @@
}
Err(_) => {}
}
- self.require_break_cx("continue", e.span, e.span)
+ self.require_break_cx(
+ BreakContextKind::Continue,
+ e.span,
+ e.span,
+ self.cx_stack.len() - 1,
+ )
}
_ => intravisit::walk_expr(self, e),
}
@@ -212,18 +299,26 @@
where
F: FnOnce(&mut CheckLoopVisitor<'a, 'hir>),
{
- let old_cx = self.cx;
- self.cx = cx;
+ self.cx_stack.push(cx);
f(self);
- self.cx = old_cx;
+ self.cx_stack.pop();
}
- fn require_break_cx(&self, name: &str, span: Span, break_span: Span) {
- let is_break = name == "break";
- match self.cx {
+ fn require_break_cx(
+ &mut self,
+ br_cx_kind: BreakContextKind,
+ span: Span,
+ break_span: Span,
+ cx_pos: usize,
+ ) {
+ match self.cx_stack[cx_pos] {
LabeledBlock | Loop(_) => {}
Closure(closure_span) => {
- self.sess.dcx().emit_err(BreakInsideClosure { span, closure_span, name });
+ self.sess.dcx().emit_err(BreakInsideClosure {
+ span,
+ closure_span,
+ name: &br_cx_kind.to_string(),
+ });
}
Coroutine { coroutine_span, kind, source } => {
let kind = match kind {
@@ -239,17 +334,32 @@
self.sess.dcx().emit_err(BreakInsideCoroutine {
span,
coroutine_span,
- name,
+ name: &br_cx_kind.to_string(),
kind,
source,
});
}
- UnlabeledBlock(block_span) if is_break && block_span.eq_ctxt(break_span) => {
- let suggestion = Some(OutsideLoopSuggestion { block_span, break_span });
- self.sess.dcx().emit_err(OutsideLoop { span, name, is_break, suggestion });
+ UnlabeledBlock(block_span)
+ if br_cx_kind == BreakContextKind::Break && block_span.eq_ctxt(break_span) =>
+ {
+ let block = self.block_breaks.entry(block_span).or_insert_with(|| BlockInfo {
+ name: br_cx_kind.to_string(),
+ spans: vec![],
+ suggs: vec![],
+ });
+ block.spans.push(span);
+ block.suggs.push(break_span);
}
- Normal | Constant | Fn | UnlabeledBlock(_) => {
- self.sess.dcx().emit_err(OutsideLoop { span, name, is_break, suggestion: None });
+ UnlabeledIfBlock(_) if br_cx_kind == BreakContextKind::Break => {
+ self.require_break_cx(br_cx_kind, span, break_span, cx_pos - 1);
+ }
+ Normal | Constant | Fn | UnlabeledBlock(_) | UnlabeledIfBlock(_) => {
+ self.sess.dcx().emit_err(OutsideLoop {
+ spans: vec![span],
+ name: &br_cx_kind.to_string(),
+ is_break: br_cx_kind == BreakContextKind::Break,
+ suggestion: None,
+ });
}
}
}
@@ -261,7 +371,7 @@
cf_type: &str,
) -> bool {
if !span.is_desugaring(DesugaringKind::QuestionMark)
- && self.cx == LabeledBlock
+ && self.cx_stack.last() == Some(&LabeledBlock)
&& label.label.is_none()
{
self.sess.dcx().emit_err(UnlabeledInLabeledBlock { span, cf_type });
@@ -269,4 +379,18 @@
}
false
}
+
+ fn report_outside_loop_error(&mut self) {
+ for (s, block) in &self.block_breaks {
+ self.sess.dcx().emit_err(OutsideLoop {
+ spans: block.spans.clone(),
+ name: &block.name,
+ is_break: true,
+ suggestion: Some(OutsideLoopSuggestion {
+ block_span: *s,
+ break_spans: block.suggs.clone(),
+ }),
+ });
+ }
+ }
}
diff --git a/compiler/rustc_passes/src/reachable.rs b/compiler/rustc_passes/src/reachable.rs
index 55b7c6d..ab1dd24 100644
--- a/compiler/rustc_passes/src/reachable.rs
+++ b/compiler/rustc_passes/src/reachable.rs
@@ -37,6 +37,7 @@
use rustc_middle::ty::{self, ExistentialTraitRef, TyCtxt};
use rustc_privacy::DefIdVisitor;
use rustc_session::config::CrateType;
+use tracing::debug;
/// Determines whether this item is recursive for reachability. See `is_recursively_reachable_local`
/// below for details.
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index 05c833c..31c709f 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -25,9 +25,9 @@
use rustc_span::symbol::{sym, Symbol};
use rustc_span::Span;
use rustc_target::spec::abi::Abi;
-
use std::mem::replace;
use std::num::NonZero;
+use tracing::{debug, info};
#[derive(PartialEq)]
enum AnnotationKind {
@@ -1020,7 +1020,7 @@
// stabilization diagnostic, but it can be avoided when there are no
// `remaining_lib_features`.
let mut all_implications = remaining_implications.clone();
- for &cnum in tcx.crates(()) {
+ for &cnum in tcx.used_crates(()) {
all_implications
.extend_unord(tcx.stability_implications(cnum).items().map(|(k, v)| (*k, *v)));
}
@@ -1033,7 +1033,7 @@
&all_implications,
);
- for &cnum in tcx.crates(()) {
+ for &cnum in tcx.used_crates(()) {
if remaining_lib_features.is_empty() && remaining_implications.is_empty() {
break;
}
diff --git a/compiler/rustc_passes/src/weak_lang_items.rs b/compiler/rustc_passes/src/weak_lang_items.rs
index 90691ca..d80addf 100644
--- a/compiler/rustc_passes/src/weak_lang_items.rs
+++ b/compiler/rustc_passes/src/weak_lang_items.rs
@@ -68,7 +68,7 @@
}
let mut missing = FxHashSet::default();
- for &cnum in tcx.crates(()).iter() {
+ for &cnum in tcx.used_crates(()).iter() {
for &item in tcx.missing_lang_items(cnum).iter() {
missing.insert(item);
}
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/late.rs b/compiler/rustc_resolve/src/late.rs
index d1d0e33..63d0d6c 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -12,7 +12,7 @@
use crate::{ResolutionError, Resolver, Segment, UseError};
use rustc_ast::ptr::P;
-use rustc_ast::visit::{walk_list, AssocCtxt, BoundKind, FnCtxt, FnKind, Visitor};
+use rustc_ast::visit::{visit_opt, walk_list, AssocCtxt, BoundKind, FnCtxt, FnKind, Visitor};
use rustc_ast::*;
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
use rustc_errors::{codes::*, Applicability, DiagArgValue, IntoDiagArg, StashKey};
@@ -3280,7 +3280,7 @@
fn resolve_local(&mut self, local: &'ast Local) {
debug!("resolving local ({:?})", local);
// Resolve the type.
- walk_list!(self, visit_ty, &local.ty);
+ visit_opt!(self, visit_ty, &local.ty);
// Resolve the initializer.
if let Some((init, els)) = local.kind.init_else_opt() {
@@ -3479,8 +3479,8 @@
fn resolve_arm(&mut self, arm: &'ast Arm) {
self.with_rib(ValueNS, RibKind::Normal, |this| {
this.resolve_pattern_top(&arm.pat, PatternSource::Match);
- walk_list!(this, visit_expr, &arm.guard);
- walk_list!(this, visit_expr, &arm.body);
+ visit_opt!(this, visit_expr, &arm.guard);
+ visit_opt!(this, visit_expr, &arm.body);
});
}
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index 092eb1c..268e7f0 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -578,7 +578,9 @@
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);
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/config.rs b/compiler/rustc_session/src/config.rs
index 7dd9fdf..5ac4d19 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -465,6 +465,7 @@
#[derive(Encodable, Decodable)]
pub enum OutputType {
Bitcode,
+ ThinLinkBitcode,
Assembly,
LlvmAssembly,
Mir,
@@ -492,6 +493,7 @@
match *self {
OutputType::Exe | OutputType::DepInfo | OutputType::Metadata => true,
OutputType::Bitcode
+ | OutputType::ThinLinkBitcode
| OutputType::Assembly
| OutputType::LlvmAssembly
| OutputType::Mir
@@ -502,6 +504,7 @@
pub fn shorthand(&self) -> &'static str {
match *self {
OutputType::Bitcode => "llvm-bc",
+ OutputType::ThinLinkBitcode => "thin-link-bitcode",
OutputType::Assembly => "asm",
OutputType::LlvmAssembly => "llvm-ir",
OutputType::Mir => "mir",
@@ -518,6 +521,7 @@
"llvm-ir" => OutputType::LlvmAssembly,
"mir" => OutputType::Mir,
"llvm-bc" => OutputType::Bitcode,
+ "thin-link-bitcode" => OutputType::ThinLinkBitcode,
"obj" => OutputType::Object,
"metadata" => OutputType::Metadata,
"link" => OutputType::Exe,
@@ -528,8 +532,9 @@
fn shorthands_display() -> String {
format!(
- "`{}`, `{}`, `{}`, `{}`, `{}`, `{}`, `{}`, `{}`",
+ "`{}`, `{}`, `{}`, `{}`, `{}`, `{}`, `{}`, `{}`, `{}`",
OutputType::Bitcode.shorthand(),
+ OutputType::ThinLinkBitcode.shorthand(),
OutputType::Assembly.shorthand(),
OutputType::LlvmAssembly.shorthand(),
OutputType::Mir.shorthand(),
@@ -543,6 +548,7 @@
pub fn extension(&self) -> &'static str {
match *self {
OutputType::Bitcode => "bc",
+ OutputType::ThinLinkBitcode => "indexing.o",
OutputType::Assembly => "s",
OutputType::LlvmAssembly => "ll",
OutputType::Mir => "mir",
@@ -559,9 +565,11 @@
| OutputType::LlvmAssembly
| OutputType::Mir
| OutputType::DepInfo => true,
- OutputType::Bitcode | OutputType::Object | OutputType::Metadata | OutputType::Exe => {
- false
- }
+ OutputType::Bitcode
+ | OutputType::ThinLinkBitcode
+ | OutputType::Object
+ | OutputType::Metadata
+ | OutputType::Exe => false,
}
}
}
@@ -644,6 +652,7 @@
pub fn should_codegen(&self) -> bool {
self.0.keys().any(|k| match *k {
OutputType::Bitcode
+ | OutputType::ThinLinkBitcode
| OutputType::Assembly
| OutputType::LlvmAssembly
| OutputType::Mir
@@ -657,6 +666,7 @@
pub fn should_link(&self) -> bool {
self.0.keys().any(|k| match *k {
OutputType::Bitcode
+ | OutputType::ThinLinkBitcode
| OutputType::Assembly
| OutputType::LlvmAssembly
| OutputType::Mir
@@ -1769,6 +1779,12 @@
display = OutputType::shorthands_display(),
))
});
+ if output_type == OutputType::ThinLinkBitcode && !unstable_opts.unstable_options {
+ early_dcx.early_fatal(format!(
+ "{} requested but -Zunstable-options not specified",
+ OutputType::ThinLinkBitcode.shorthand()
+ ));
+ }
output_types.insert(output_type, path);
}
}
diff --git a/compiler/rustc_session/src/filesearch.rs b/compiler/rustc_session/src/filesearch.rs
index f4e2436..9cb8cd8 100644
--- a/compiler/rustc_session/src/filesearch.rs
+++ b/compiler/rustc_session/src/filesearch.rs
@@ -51,6 +51,14 @@
PathBuf::from_iter([sysroot, Path::new(&rustlib_path), Path::new("lib")])
}
+/// Returns a path to the target's `bin` folder within its `rustlib` path in the sysroot. This is
+/// where binaries are usually installed, e.g. the self-contained linkers, lld-wrappers, LLVM tools,
+/// etc.
+pub fn make_target_bin_path(sysroot: &Path, target_triple: &str) -> PathBuf {
+ let rustlib_path = rustc_target::target_rustlib_path(sysroot, target_triple);
+ PathBuf::from_iter([sysroot, Path::new(&rustlib_path), Path::new("bin")])
+}
+
#[cfg(unix)]
fn current_dll_path() -> Result<PathBuf, String> {
use std::ffi::{CStr, OsStr};
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index a2872fc..a5cf136 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -449,15 +449,24 @@
)
}
- /// Returns a list of directories where target-specific tool binaries are located.
+ /// Returns a list of directories where target-specific tool binaries are located. Some fallback
+ /// directories are also returned, for example if `--sysroot` is used but tools are missing
+ /// (#125246): we also add the bin directories to the sysroot where rustc is located.
pub fn get_tools_search_paths(&self, self_contained: bool) -> Vec<PathBuf> {
- let rustlib_path = rustc_target::target_rustlib_path(&self.sysroot, config::host_triple());
- let p = PathBuf::from_iter([
- Path::new(&self.sysroot),
- Path::new(&rustlib_path),
- Path::new("bin"),
- ]);
- if self_contained { vec![p.clone(), p.join("self-contained")] } else { vec![p] }
+ let bin_path = filesearch::make_target_bin_path(&self.sysroot, config::host_triple());
+ let fallback_sysroot_paths = filesearch::sysroot_candidates()
+ .into_iter()
+ .map(|sysroot| filesearch::make_target_bin_path(&sysroot, config::host_triple()));
+ let search_paths = std::iter::once(bin_path).chain(fallback_sysroot_paths);
+
+ if self_contained {
+ // The self-contained tools are expected to be e.g. in `bin/self-contained` in the
+ // sysroot's `rustlib` path, so we add such a subfolder to the bin path, and the
+ // fallback paths.
+ search_paths.flat_map(|path| [path.clone(), path.join("self-contained")]).collect()
+ } else {
+ search_paths.collect()
+ }
}
pub fn init_incr_comp_session(&self, session_dir: PathBuf, lock_file: flock::Lock) {
diff --git a/compiler/rustc_smir/src/rustc_smir/context.rs b/compiler/rustc_smir/src/rustc_smir/context.rs
index fd31c02..7afe46f 100644
--- a/compiler/rustc_smir/src/rustc_smir/context.rs
+++ b/compiler/rustc_smir/src/rustc_smir/context.rs
@@ -23,8 +23,8 @@
use stable_mir::target::{MachineInfo, MachineSize};
use stable_mir::ty::{
AdtDef, AdtKind, Allocation, ClosureDef, ClosureKind, Const, FieldDef, FnDef, ForeignDef,
- ForeignItemKind, GenericArgs, LineInfo, PolyFnSig, RigidTy, Span, Ty, TyKind, UintTy,
- VariantDef,
+ ForeignItemKind, GenericArgs, IntrinsicDef, LineInfo, PolyFnSig, RigidTy, Span, Ty, TyKind,
+ UintTy, VariantDef,
};
use stable_mir::{Crate, CrateDef, CrateItem, CrateNum, DefId, Error, Filename, ItemKind, Symbol};
use std::cell::RefCell;
@@ -126,7 +126,7 @@
let mut tables = self.0.borrow_mut();
let tcx = tables.tcx;
iter::once(LOCAL_CRATE)
- .chain(tables.tcx.crates(()).iter().copied())
+ .chain(tables.tcx.used_crates(()).iter().copied())
.flat_map(|cnum| tcx.trait_impls_in_crate(cnum).iter())
.map(|impl_def_id| tables.impl_def(*impl_def_id))
.collect()
@@ -201,14 +201,19 @@
fn external_crates(&self) -> Vec<stable_mir::Crate> {
let tables = self.0.borrow();
- tables.tcx.crates(()).iter().map(|crate_num| smir_crate(tables.tcx, *crate_num)).collect()
+ tables
+ .tcx
+ .used_crates(())
+ .iter()
+ .map(|crate_num| smir_crate(tables.tcx, *crate_num))
+ .collect()
}
fn find_crates(&self, name: &str) -> Vec<stable_mir::Crate> {
let tables = self.0.borrow();
let crates: Vec<stable_mir::Crate> = [LOCAL_CRATE]
.iter()
- .chain(tables.tcx.crates(()).iter())
+ .chain(tables.tcx.used_crates(()).iter())
.filter_map(|crate_num| {
let crate_name = tables.tcx.crate_name(*crate_num).to_string();
(name == crate_name).then(|| smir_crate(tables.tcx, *crate_num))
@@ -307,6 +312,28 @@
sig.stable(&mut *tables)
}
+ fn intrinsic(&self, def: DefId) -> Option<IntrinsicDef> {
+ let mut tables = self.0.borrow_mut();
+ let tcx = tables.tcx;
+ let def_id = def.internal(&mut *tables, tcx);
+ let intrinsic = tcx.intrinsic_raw(def_id);
+ intrinsic.map(|_| IntrinsicDef(def))
+ }
+
+ fn intrinsic_name(&self, def: IntrinsicDef) -> Symbol {
+ let mut tables = self.0.borrow_mut();
+ let tcx = tables.tcx;
+ let def_id = def.0.internal(&mut *tables, tcx);
+ tcx.intrinsic(def_id).unwrap().name.to_string()
+ }
+
+ fn intrinsic_must_be_overridden(&self, def: IntrinsicDef) -> bool {
+ let mut tables = self.0.borrow_mut();
+ let tcx = tables.tcx;
+ let def_id = def.0.internal(&mut *tables, tcx);
+ tcx.intrinsic_raw(def_id).unwrap().must_be_overridden
+ }
+
fn closure_sig(&self, args: &GenericArgs) -> PolyFnSig {
let mut tables = self.0.borrow_mut();
let tcx = tables.tcx;
@@ -645,16 +672,6 @@
}
}
- /// Retrieve the plain intrinsic name of an instance.
- ///
- /// This assumes that the instance is an intrinsic.
- fn intrinsic_name(&self, def: InstanceDef) -> Symbol {
- let tables = self.0.borrow_mut();
- let instance = tables.instances[def];
- let intrinsic = tables.tcx.intrinsic(instance.def_id()).unwrap();
- intrinsic.name.to_string()
- }
-
fn ty_layout(&self, ty: Ty) -> Result<Layout, Error> {
let mut tables = self.0.borrow_mut();
let tcx = tables.tcx;
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_span/src/hygiene.rs b/compiler/rustc_span/src/hygiene.rs
index aa4bcef..00ef17d 100644
--- a/compiler/rustc_span/src/hygiene.rs
+++ b/compiler/rustc_span/src/hygiene.rs
@@ -40,6 +40,7 @@
use std::collections::hash_map::Entry;
use std::fmt;
use std::hash::Hash;
+use tracing::{debug, trace};
/// A `SyntaxContext` represents a chain of pairs `(ExpnId, Transparency)` named "marks".
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index f83bacd..b2ca01f 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -33,15 +33,16 @@
#![feature(rustdoc_internals)]
// tidy-alphabetical-end
+// The code produced by the `Encodable`/`Decodable` derive macros refer to
+// `rustc_span::Span{Encoder,Decoder}`. That's fine outside this crate, but doesn't work inside
+// this crate without this line making `rustc_span` available.
extern crate self as rustc_span;
-#[macro_use]
-extern crate tracing;
-
use rustc_data_structures::{outline, AtomicRef};
use rustc_macros::{Decodable, Encodable, HashStable_Generic};
use rustc_serialize::opaque::{FileEncoder, MemDecoder};
use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
+use tracing::debug;
mod caching_source_map_view;
pub mod source_map;
diff --git a/compiler/rustc_span/src/source_map.rs b/compiler/rustc_span/src/source_map.rs
index 2093dcf..fb212d6 100644
--- a/compiler/rustc_span/src/source_map.rs
+++ b/compiler/rustc_span/src/source_map.rs
@@ -16,6 +16,7 @@
use std::fs;
use std::io::{self, BorrowedBuf, Read};
use std::path;
+use tracing::{debug, instrument, trace};
#[cfg(test)]
mod tests;
diff --git a/compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs b/compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs
index 930ae5a..6f68875 100644
--- a/compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_trait_selection/src/solve/assembly/structural_traits.rs
@@ -300,14 +300,11 @@
return Err(NoSolution);
}
- // If `Fn`/`FnMut`, we only implement this goal if we
- // have no captures.
- let no_borrows = match args.tupled_upvars_ty().kind() {
- ty::Tuple(tys) => tys.is_empty(),
- ty::Error(_) => false,
- _ => bug!("tuple_fields called on non-tuple"),
- };
- if closure_kind != ty::ClosureKind::FnOnce && !no_borrows {
+ // A coroutine-closure implements `FnOnce` *always*, since it may
+ // always be called once. It additionally implements `Fn`/`FnMut`
+ // only if it has no upvars referencing the closure-env lifetime,
+ // and if the closure kind permits it.
+ if closure_kind != ty::ClosureKind::FnOnce && args.has_self_borrows() {
return Err(NoSolution);
}
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_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index b9e853a..fd7c47a 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -418,20 +418,11 @@
// Ambiguity if upvars haven't been constrained yet
&& !args.tupled_upvars_ty().is_ty_var()
{
- let no_borrows = match args.tupled_upvars_ty().kind() {
- ty::Tuple(tys) => tys.is_empty(),
- ty::Error(_) => false,
- _ => bug!("tuple_fields called on non-tuple"),
- };
// A coroutine-closure implements `FnOnce` *always*, since it may
// always be called once. It additionally implements `Fn`/`FnMut`
- // only if it has no upvars (therefore no borrows from the closure
- // that would need to be represented with a lifetime) and if the
- // closure kind permits it.
- // FIXME(async_closures): Actually, it could also implement `Fn`/`FnMut`
- // if it takes all of its upvars by copy, and none by ref. This would
- // require us to record a bit more information during upvar analysis.
- if no_borrows && closure_kind.extends(kind) {
+ // only if it has no upvars referencing the closure-env lifetime,
+ // and if the closure kind permits it.
+ if closure_kind.extends(kind) && !args.has_self_borrows() {
candidates.vec.push(ClosureCandidate { is_const });
} else if kind == ty::ClosureKind::FnOnce {
candidates.vec.push(ClosureCandidate { is_const });
diff --git a/compiler/rustc_ty_utils/src/abi.rs b/compiler/rustc_ty_utils/src/abi.rs
index 9090bb3..6f513f2 100644
--- a/compiler/rustc_ty_utils/src/abi.rs
+++ b/compiler/rustc_ty_utils/src/abi.rs
@@ -14,6 +14,7 @@
};
use rustc_target::abi::*;
use rustc_target::spec::abi::Abi as SpecAbi;
+use tracing::debug;
use std::iter;
diff --git a/compiler/rustc_ty_utils/src/consts.rs b/compiler/rustc_ty_utils/src/consts.rs
index b40a0d0..67ffb8a 100644
--- a/compiler/rustc_ty_utils/src/consts.rs
+++ b/compiler/rustc_ty_utils/src/consts.rs
@@ -11,6 +11,7 @@
use rustc_middle::{mir, thir};
use rustc_span::Span;
use rustc_target::abi::{VariantIdx, FIRST_VARIANT};
+use tracing::{debug, instrument};
use std::iter;
diff --git a/compiler/rustc_ty_utils/src/instance.rs b/compiler/rustc_ty_utils/src/instance.rs
index 41f482d..0d08920 100644
--- a/compiler/rustc_ty_utils/src/instance.rs
+++ b/compiler/rustc_ty_utils/src/instance.rs
@@ -9,6 +9,7 @@
use rustc_span::sym;
use rustc_trait_selection::traits;
use rustc_type_ir::ClosureKind;
+use tracing::debug;
use traits::{translate_args, Reveal};
use crate::errors::UnexpectedFnPtrAssociatedItem;
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index 1ef2249..1dee14f 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -16,6 +16,7 @@
use rustc_span::sym;
use rustc_span::symbol::Symbol;
use rustc_target::abi::*;
+use tracing::{debug, instrument, trace};
use std::fmt::Debug;
use std::iter;
diff --git a/compiler/rustc_ty_utils/src/lib.rs b/compiler/rustc_ty_utils/src/lib.rs
index e8c5c54..bd89265 100644
--- a/compiler/rustc_ty_utils/src/lib.rs
+++ b/compiler/rustc_ty_utils/src/lib.rs
@@ -16,9 +16,6 @@
#![feature(let_chains)]
#![feature(never_type)]
-#[macro_use]
-extern crate tracing;
-
use rustc_middle::query::Providers;
mod abi;
diff --git a/compiler/rustc_ty_utils/src/needs_drop.rs b/compiler/rustc_ty_utils/src/needs_drop.rs
index 4e23fb3..72ee1a4 100644
--- a/compiler/rustc_ty_utils/src/needs_drop.rs
+++ b/compiler/rustc_ty_utils/src/needs_drop.rs
@@ -9,6 +9,7 @@
use rustc_middle::ty::{self, EarlyBinder, Ty, TyCtxt};
use rustc_session::Limit;
use rustc_span::sym;
+use tracing::debug;
use crate::errors::NeedsDropOverflow;
diff --git a/compiler/rustc_ty_utils/src/opaque_types.rs b/compiler/rustc_ty_utils/src/opaque_types.rs
index be227ec..ccc5220 100644
--- a/compiler/rustc_ty_utils/src/opaque_types.rs
+++ b/compiler/rustc_ty_utils/src/opaque_types.rs
@@ -8,6 +8,7 @@
use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_middle::ty::{TypeSuperVisitable, TypeVisitable, TypeVisitor};
use rustc_span::Span;
+use tracing::{instrument, trace};
use crate::errors::{DuplicateArg, NotParam};
diff --git a/compiler/rustc_ty_utils/src/sig_types.rs b/compiler/rustc_ty_utils/src/sig_types.rs
index 2d8c782..97a1b94 100644
--- a/compiler/rustc_ty_utils/src/sig_types.rs
+++ b/compiler/rustc_ty_utils/src/sig_types.rs
@@ -8,6 +8,7 @@
use rustc_middle::ty::{self, TyCtxt};
use rustc_span::Span;
use rustc_type_ir::visit::TypeVisitable;
+use tracing::{instrument, trace};
pub trait SpannedTypeVisitor<'tcx> {
type Result: VisitorResult = ();
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index 3094956..617e8a5 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -10,6 +10,7 @@
use rustc_span::def_id::{DefId, LocalDefId, CRATE_DEF_ID};
use rustc_span::DUMMY_SP;
use rustc_trait_selection::traits;
+use tracing::{debug, instrument};
#[instrument(level = "debug", skip(tcx), ret)]
fn sized_constraint_for_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
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/compiler/stable_mir/src/compiler_interface.rs b/compiler/stable_mir/src/compiler_interface.rs
index 231d9ba..4dd6422 100644
--- a/compiler/stable_mir/src/compiler_interface.rs
+++ b/compiler/stable_mir/src/compiler_interface.rs
@@ -13,8 +13,8 @@
use crate::ty::{
AdtDef, AdtKind, Allocation, ClosureDef, ClosureKind, Const, FieldDef, FnDef, ForeignDef,
ForeignItemKind, ForeignModule, ForeignModuleDef, GenericArgs, GenericPredicates, Generics,
- ImplDef, ImplTrait, LineInfo, PolyFnSig, RigidTy, Span, TraitDecl, TraitDef, Ty, TyKind,
- UintTy, VariantDef,
+ ImplDef, ImplTrait, IntrinsicDef, LineInfo, PolyFnSig, RigidTy, Span, TraitDecl, TraitDef, Ty,
+ TyKind, UintTy, VariantDef,
};
use crate::{
mir, Crate, CrateItem, CrateItems, CrateNum, DefId, Error, Filename, ImplTraitDecls, ItemKind,
@@ -88,6 +88,16 @@
/// Retrieve the function signature for the given generic arguments.
fn fn_sig(&self, def: FnDef, args: &GenericArgs) -> PolyFnSig;
+ /// Retrieve the intrinsic definition if the item corresponds one.
+ fn intrinsic(&self, item: DefId) -> Option<IntrinsicDef>;
+
+ /// Retrieve the plain function name of an intrinsic.
+ fn intrinsic_name(&self, def: IntrinsicDef) -> Symbol;
+
+ /// Returns whether the intrinsic has no meaningful body and all backends
+ /// need to shim all calls to it.
+ fn intrinsic_must_be_overridden(&self, def: IntrinsicDef) -> bool;
+
/// Retrieve the closure signature for the given generic arguments.
fn closure_sig(&self, args: &GenericArgs) -> PolyFnSig;
@@ -198,7 +208,6 @@
fn vtable_allocation(&self, global_alloc: &GlobalAlloc) -> Option<AllocId>;
fn krate(&self, def_id: DefId) -> Crate;
fn instance_name(&self, def: InstanceDef, trimmed: bool) -> Symbol;
- fn intrinsic_name(&self, def: InstanceDef) -> Symbol;
/// Return information about the target machine.
fn target_info(&self) -> MachineInfo;
diff --git a/compiler/stable_mir/src/mir/mono.rs b/compiler/stable_mir/src/mir/mono.rs
index 3940389..572f149 100644
--- a/compiler/stable_mir/src/mir/mono.rs
+++ b/compiler/stable_mir/src/mir/mono.rs
@@ -106,7 +106,9 @@
/// which is more convenient to match with intrinsic symbols.
pub fn intrinsic_name(&self) -> Option<Symbol> {
match self.kind {
- InstanceKind::Intrinsic => Some(with(|context| context.intrinsic_name(self.def))),
+ InstanceKind::Intrinsic => {
+ Some(with(|context| context.intrinsic(self.def.def_id()).unwrap().fn_name()))
+ }
InstanceKind::Item | InstanceKind::Virtual { .. } | InstanceKind::Shim => None,
}
}
diff --git a/compiler/stable_mir/src/ty.rs b/compiler/stable_mir/src/ty.rs
index 321c56b..f3ac2bf 100644
--- a/compiler/stable_mir/src/ty.rs
+++ b/compiler/stable_mir/src/ty.rs
@@ -621,6 +621,41 @@
pub fn body(&self) -> Option<Body> {
with(|ctx| ctx.has_body(self.0).then(|| ctx.mir_body(self.0)))
}
+
+ /// Get the information of the intrinsic if this function is a definition of one.
+ pub fn as_intrinsic(&self) -> Option<IntrinsicDef> {
+ with(|cx| cx.intrinsic(self.def_id()))
+ }
+
+ /// Check if the function is an intrinsic.
+ #[inline]
+ pub fn is_intrinsic(&self) -> bool {
+ self.as_intrinsic().is_some()
+ }
+}
+
+crate_def! {
+ pub IntrinsicDef;
+}
+
+impl IntrinsicDef {
+ /// Returns the plain name of the intrinsic.
+ /// e.g., `transmute` for `core::intrinsics::transmute`.
+ pub fn fn_name(&self) -> Symbol {
+ with(|cx| cx.intrinsic_name(*self))
+ }
+
+ /// Returns whether the intrinsic has no meaningful body and all backends
+ /// need to shim all calls to it.
+ pub fn must_be_overridden(&self) -> bool {
+ with(|cx| cx.intrinsic_must_be_overridden(*self))
+ }
+}
+
+impl From<IntrinsicDef> for FnDef {
+ fn from(def: IntrinsicDef) -> Self {
+ FnDef(def.0)
+ }
}
crate_def! {
diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
index 2e7fcb9..3960f71 100644
--- a/library/alloc/Cargo.toml
+++ b/library/alloc/Cargo.toml
@@ -40,3 +40,15 @@
panic_immediate_abort = ["core/panic_immediate_abort"]
# Choose algorithms that are optimized for binary size instead of runtime performance
optimize_for_size = ["core/optimize_for_size"]
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+# x.py uses beta cargo, so `check-cfg` entries do not yet take effect
+# for rust-lang/rust. But for users of `-Zbuild-std` it does.
+# The unused warning is waiting for rust-lang/cargo#13925 to reach beta.
+check-cfg = [
+ 'cfg(bootstrap)',
+ 'cfg(no_global_oom_handling)',
+ 'cfg(no_rc)',
+ 'cfg(no_sync)',
+]
diff --git a/library/core/Cargo.toml b/library/core/Cargo.toml
index 11d3397..0c26423 100644
--- a/library/core/Cargo.toml
+++ b/library/core/Cargo.toml
@@ -36,3 +36,18 @@
# Make `RefCell` store additional debugging information, which is printed out when
# a borrow error occurs
debug_refcell = []
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+# x.py uses beta cargo, so `check-cfg` entries do not yet take effect
+# for rust-lang/rust. But for users of `-Zbuild-std` it does.
+# The unused warning is waiting for rust-lang/cargo#13925 to reach beta.
+check-cfg = [
+ 'cfg(bootstrap)',
+ 'cfg(no_fp_fmt_parse)',
+ 'cfg(stdarch_intel_sde)',
+ # core use #[path] imports to portable-simd `core_simd` crate
+ # and to stdarch `core_arch` crate which messes-up with Cargo list
+ # of declared features, we therefor expect any feature cfg
+ 'cfg(feature, values(any()))',
+]
diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs
index 9b372ea..60a2786 100644
--- a/library/core/src/fmt/mod.rs
+++ b/library/core/src/fmt/mod.rs
@@ -340,7 +340,9 @@
#[rustc_const_unstable(feature = "const_fmt_arguments_new", issue = "none")]
pub const fn new_const(pieces: &'a [&'static str]) -> Self {
if pieces.len() > 1 {
- panic!("invalid args");
+ // Since panic!() expands to panic_fmt(format_args!()), using panic! here is both a
+ // bit silly and also significantly increases the amount of MIR generated by panics.
+ crate::panicking::panic_nounwind("invalid args");
}
Arguments { pieces, fmt: None, args: &[] }
}
@@ -350,7 +352,8 @@
#[inline]
pub fn new_v1(pieces: &'a [&'static str], args: &'a [rt::Argument<'a>]) -> Arguments<'a> {
if pieces.len() < args.len() || pieces.len() > args.len() + 1 {
- panic!("invalid args");
+ // See Arguments::new_const for why we don't use panic!.
+ crate::panicking::panic_nounwind("invalid args");
}
Arguments { pieces, fmt: None, args }
}
diff --git a/library/core/src/internal_macros.rs b/library/core/src/internal_macros.rs
index bf53b22..d3a4d6a 100644
--- a/library/core/src/internal_macros.rs
+++ b/library/core/src/internal_macros.rs
@@ -80,47 +80,6 @@
}
}
-/// Create a zero-size type similar to a closure type, but named.
-macro_rules! impl_fn_for_zst {
- ($(
- $( #[$attr: meta] )*
- struct $Name: ident impl$( <$( $lifetime : lifetime ),+> )? Fn =
- |$( $arg: ident: $ArgTy: ty ),*| -> $ReturnTy: ty
- $body: block;
- )+) => {
- $(
- $( #[$attr] )*
- struct $Name;
-
- impl $( <$( $lifetime ),+> )? Fn<($( $ArgTy, )*)> for $Name {
- #[inline]
- extern "rust-call" fn call(&self, ($( $arg, )*): ($( $ArgTy, )*)) -> $ReturnTy {
- $body
- }
- }
-
- impl $( <$( $lifetime ),+> )? FnMut<($( $ArgTy, )*)> for $Name {
- #[inline]
- extern "rust-call" fn call_mut(
- &mut self,
- ($( $arg, )*): ($( $ArgTy, )*)
- ) -> $ReturnTy {
- Fn::call(&*self, ($( $arg, )*))
- }
- }
-
- impl $( <$( $lifetime ),+> )? FnOnce<($( $ArgTy, )*)> for $Name {
- type Output = $ReturnTy;
-
- #[inline]
- extern "rust-call" fn call_once(self, ($( $arg, )*): ($( $ArgTy, )*)) -> $ReturnTy {
- Fn::call(&self, ($( $arg, )*))
- }
- }
- )+
- }
-}
-
/// A macro for defining `#[cfg]` if-else statements.
///
/// `cfg_if` is similar to the `if/elif` C preprocessor macro by allowing definition of a cascade
diff --git a/library/core/src/intrinsics.rs b/library/core/src/intrinsics.rs
index d58e1db..5a2a4c5 100644
--- a/library/core/src/intrinsics.rs
+++ b/library/core/src/intrinsics.rs
@@ -987,7 +987,7 @@
#[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_intrinsic]
#[rustc_nounwind]
-#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_checks_ub)]
+#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_is_spec)]
pub const fn likely(b: bool) -> bool {
b
}
@@ -1007,7 +1007,7 @@
#[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_intrinsic]
#[rustc_nounwind]
-#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_checks_ub)]
+#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_is_spec)]
pub const fn unlikely(b: bool) -> bool {
b
}
@@ -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.
///
@@ -2483,7 +2483,7 @@
#[rustc_nounwind]
#[rustc_do_not_const_check]
#[inline]
-#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_checks_ub)]
+#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_is_spec)]
pub const fn ptr_guaranteed_cmp<T>(ptr: *const T, other: *const T) -> u8 {
(ptr == other) as u8
}
@@ -2748,7 +2748,7 @@
#[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_nounwind]
#[rustc_intrinsic]
-#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_checks_ub)]
+#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_is_spec)]
pub const unsafe fn const_allocate(_size: usize, _align: usize) -> *mut u8 {
// const eval overrides this function, but runtime code for now just returns null pointers.
// See <https://github.com/rust-lang/rust/issues/93935>.
@@ -2769,7 +2769,7 @@
#[unstable(feature = "core_intrinsics", issue = "none")]
#[rustc_nounwind]
#[rustc_intrinsic]
-#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_checks_ub)]
+#[cfg_attr(not(bootstrap), miri::intrinsic_fallback_is_spec)]
pub const unsafe fn const_deallocate(_ptr: *mut u8, _size: usize, _align: usize) {
// Runtime NOP
}
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index dcf68b3..206d1ab 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -255,6 +255,7 @@
#![feature(trait_alias)]
#![feature(transparent_unions)]
#![feature(try_blocks)]
+#![feature(type_alias_impl_trait)]
#![feature(unboxed_closures)]
#![feature(unsized_fn_params)]
#![feature(with_negative_coherence)]
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/library/core/src/slice/ascii.rs b/library/core/src/slice/ascii.rs
index 8ad0452..19c91ba 100644
--- a/library/core/src/slice/ascii.rs
+++ b/library/core/src/slice/ascii.rs
@@ -108,7 +108,7 @@
without modifying the original"]
#[stable(feature = "inherent_ascii_escape", since = "1.60.0")]
pub fn escape_ascii(&self) -> EscapeAscii<'_> {
- EscapeAscii { inner: self.iter().flat_map(EscapeByte) }
+ EscapeAscii { inner: self.iter().flat_map(|byte| byte.escape_ascii()) }
}
/// Returns a byte slice with leading ASCII whitespace bytes removed.
@@ -190,12 +190,7 @@
}
}
-impl_fn_for_zst! {
- #[derive(Clone)]
- struct EscapeByte impl Fn = |byte: &u8| -> ascii::EscapeDefault {
- ascii::escape_default(*byte)
- };
-}
+type EscapeByte = impl (Fn(&u8) -> ascii::EscapeDefault) + Copy;
/// An iterator over the escaped version of a byte slice.
///
diff --git a/library/core/src/str/iter.rs b/library/core/src/str/iter.rs
index 19627f2..d61f041 100644
--- a/library/core/src/str/iter.rs
+++ b/library/core/src/str/iter.rs
@@ -1274,8 +1274,10 @@
#[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
#[derive(Clone, Debug)]
pub struct SplitAsciiWhitespace<'a> {
- pub(super) inner:
- Map<Filter<SliceSplit<'a, u8, IsAsciiWhitespace>, BytesIsNotEmpty>, UnsafeBytesToStr>,
+ pub(super) inner: Map<
+ Filter<SliceSplit<'a, u8, IsAsciiWhitespace>, BytesIsNotEmpty<'a>>,
+ UnsafeBytesToStr<'a>,
+ >,
}
/// An iterator over the substrings of a string,
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index 669cdc9..edda4d1 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -983,7 +983,7 @@
#[cfg_attr(not(test), rustc_diagnostic_item = "str_split_whitespace")]
#[inline]
pub fn split_whitespace(&self) -> SplitWhitespace<'_> {
- SplitWhitespace { inner: self.split(IsWhitespace).filter(IsNotEmpty) }
+ SplitWhitespace { inner: self.split(char::is_whitespace).filter(|s| !s.is_empty()) }
}
/// Splits a string slice by ASCII whitespace.
@@ -1032,8 +1032,13 @@
#[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
#[inline]
pub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_> {
- let inner =
- self.as_bytes().split(IsAsciiWhitespace).filter(BytesIsNotEmpty).map(UnsafeBytesToStr);
+ let inner = self
+ .as_bytes()
+ .split(u8::is_ascii_whitespace)
+ .filter(|s| !s.is_empty())
+ // SAFETY: the byte slice came from a string and was only split
+ // along character boundaries, so the resulting slices are strings.
+ .map(|bytes| unsafe { from_utf8_unchecked(bytes) });
SplitAsciiWhitespace { inner }
}
@@ -1085,7 +1090,11 @@
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn lines(&self) -> Lines<'_> {
- Lines(self.split_inclusive('\n').map(LinesMap))
+ Lines(self.split_inclusive('\n').map(|line| {
+ let Some(line) = line.strip_suffix('\n') else { return line };
+ let Some(line) = line.strip_suffix('\r') else { return line };
+ line
+ }))
}
/// An iterator over the lines of a string.
@@ -2636,14 +2645,19 @@
#[stable(feature = "str_escape", since = "1.34.0")]
pub fn escape_debug(&self) -> EscapeDebug<'_> {
let mut chars = self.chars();
- EscapeDebug {
- inner: chars
- .next()
- .map(|first| first.escape_debug_ext(EscapeDebugExtArgs::ESCAPE_ALL))
- .into_iter()
- .flatten()
- .chain(chars.flat_map(CharEscapeDebugContinue)),
- }
+ let first = chars
+ .next()
+ .map(|first| first.escape_debug_ext(EscapeDebugExtArgs::ESCAPE_ALL))
+ .into_iter()
+ .flatten();
+ let inner = first.chain(chars.flat_map(|c| {
+ c.escape_debug_ext(EscapeDebugExtArgs {
+ escape_grapheme_extended: false,
+ escape_single_quote: true,
+ escape_double_quote: true,
+ })
+ }));
+ EscapeDebug { inner }
}
/// Return an iterator that escapes each char in `self` with [`char::escape_default`].
@@ -2681,7 +2695,7 @@
without modifying the original"]
#[stable(feature = "str_escape", since = "1.34.0")]
pub fn escape_default(&self) -> EscapeDefault<'_> {
- EscapeDefault { inner: self.chars().flat_map(CharEscapeDefault) }
+ EscapeDefault { inner: self.chars().flat_map(char::escape_default) }
}
/// Return an iterator that escapes each char in `self` with [`char::escape_unicode`].
@@ -2719,7 +2733,7 @@
without modifying the original"]
#[stable(feature = "str_escape", since = "1.34.0")]
pub fn escape_unicode(&self) -> EscapeUnicode<'_> {
- EscapeUnicode { inner: self.chars().flat_map(CharEscapeUnicode) }
+ EscapeUnicode { inner: self.chars().flat_map(char::escape_unicode) }
}
}
@@ -2750,59 +2764,15 @@
}
}
-impl_fn_for_zst! {
- /// A nameable, cloneable fn type
- #[derive(Clone)]
- struct LinesMap impl<'a> Fn = |line: &'a str| -> &'a str {
- let Some(line) = line.strip_suffix('\n') else { return line };
- let Some(line) = line.strip_suffix('\r') else { return line };
- line
- };
-
- #[derive(Clone)]
- struct CharEscapeDebugContinue impl Fn = |c: char| -> char::EscapeDebug {
- c.escape_debug_ext(EscapeDebugExtArgs {
- escape_grapheme_extended: false,
- escape_single_quote: true,
- escape_double_quote: true
- })
- };
-
- #[derive(Clone)]
- struct CharEscapeUnicode impl Fn = |c: char| -> char::EscapeUnicode {
- c.escape_unicode()
- };
- #[derive(Clone)]
- struct CharEscapeDefault impl Fn = |c: char| -> char::EscapeDefault {
- c.escape_default()
- };
-
- #[derive(Clone)]
- struct IsWhitespace impl Fn = |c: char| -> bool {
- c.is_whitespace()
- };
-
- #[derive(Clone)]
- struct IsAsciiWhitespace impl Fn = |byte: &u8| -> bool {
- byte.is_ascii_whitespace()
- };
-
- #[derive(Clone)]
- struct IsNotEmpty impl<'a, 'b> Fn = |s: &'a &'b str| -> bool {
- !s.is_empty()
- };
-
- #[derive(Clone)]
- struct BytesIsNotEmpty impl<'a, 'b> Fn = |s: &'a &'b [u8]| -> bool {
- !s.is_empty()
- };
-
- #[derive(Clone)]
- struct UnsafeBytesToStr impl<'a> Fn = |bytes: &'a [u8]| -> &'a str {
- // SAFETY: not safe
- unsafe { from_utf8_unchecked(bytes) }
- };
-}
+type LinesMap = impl (Fn(&str) -> &str) + Copy;
+type CharEscapeDebugContinue = impl (FnMut(char) -> char::EscapeDebug) + Copy;
+type CharEscapeUnicode = impl (Fn(char) -> char::EscapeUnicode) + Copy;
+type CharEscapeDefault = impl (Fn(char) -> char::EscapeDefault) + Copy;
+type IsWhitespace = impl (Fn(char) -> bool) + Copy;
+type IsAsciiWhitespace = impl (Fn(&u8) -> bool) + Copy;
+type IsNotEmpty = impl (Fn(&&str) -> bool) + Copy;
+type BytesIsNotEmpty<'a> = impl (FnMut(&&'a [u8]) -> bool) + Copy;
+type UnsafeBytesToStr<'a> = impl (FnMut(&'a [u8]) -> &'a str) + Copy;
// This is required to make `impl From<&str> for Box<dyn Error>` and `impl<E> From<E> for Box<dyn Error>` not overlap.
#[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/core/src/task/wake.rs b/library/core/src/task/wake.rs
index 7691721..3d21b09 100644
--- a/library/core/src/task/wake.rs
+++ b/library/core/src/task/wake.rs
@@ -5,6 +5,7 @@
use crate::any::Any;
use crate::fmt;
use crate::marker::PhantomData;
+use crate::panic::AssertUnwindSafe;
use crate::ptr;
/// A `RawWaker` allows the implementor of a task executor to create a [`Waker`]
@@ -236,7 +237,7 @@
pub struct Context<'a> {
waker: &'a Waker,
local_waker: &'a LocalWaker,
- ext: ExtData<'a>,
+ ext: AssertUnwindSafe<ExtData<'a>>,
// Ensure we future-proof against variance changes by forcing
// the lifetime to be invariant (argument-position lifetimes
// are contravariant while return-position lifetimes are
@@ -279,7 +280,9 @@
#[unstable(feature = "context_ext", issue = "123392")]
#[rustc_const_unstable(feature = "const_waker", issue = "102012")]
pub const fn ext(&mut self) -> &mut dyn Any {
- match &mut self.ext {
+ // FIXME: this field makes Context extra-weird about unwind safety
+ // can we justify AssertUnwindSafe if we stabilize this? do we care?
+ match &mut *self.ext {
ExtData::Some(data) => *data,
ExtData::None(unit) => unit,
}
@@ -353,7 +356,7 @@
#[rustc_const_unstable(feature = "const_waker", issue = "102012")]
#[unstable(feature = "context_ext", issue = "123392")]
pub const fn from(cx: &'a mut Context<'_>) -> Self {
- let ext = match &mut cx.ext {
+ let ext = match &mut *cx.ext {
ExtData::Some(ext) => ExtData::Some(*ext),
ExtData::None(()) => ExtData::None(()),
};
@@ -396,7 +399,7 @@
#[rustc_const_unstable(feature = "const_waker", issue = "102012")]
pub const fn build(self) -> Context<'a> {
let ContextBuilder { waker, local_waker, ext, _marker, _marker2 } = self;
- Context { waker, local_waker, ext, _marker, _marker2 }
+ Context { waker, local_waker, ext: AssertUnwindSafe(ext), _marker, _marker2 }
}
}
diff --git a/library/core/tests/result.rs b/library/core/tests/result.rs
index a47ef7a..00a6fd7 100644
--- a/library/core/tests/result.rs
+++ b/library/core/tests/result.rs
@@ -170,6 +170,7 @@
}
#[test]
+#[allow(for_loops_over_fallibles)]
pub fn test_iter_mut() {
let mut ok: Result<isize, &'static str> = Ok(100);
for loc in ok.iter_mut() {
diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs
index 23ae2e7..3d7d36b 100644
--- a/library/proc_macro/src/lib.rs
+++ b/library/proc_macro/src/lib.rs
@@ -815,6 +815,18 @@
/// "macro variable" `$var`. It is important to preserve operator priorities in cases like
/// `$var * 3` where `$var` is `1 + 2`.
/// Invisible delimiters might not survive roundtrip of a token stream through a string.
+ ///
+ /// <div class="warning">
+ ///
+ /// Note: rustc currently can ignore the grouping of tokens delimited by `None` in the output
+ /// of a proc_macro. Only `None`-delimited groups created by a macro_rules macro in the input
+ /// of a proc_macro macro are preserved, and only in very specific circumstances.
+ /// Any `None`-delimited groups (re)created by a proc_macro will therefore not preserve
+ /// operator priorities as indicated above. The other `Delimiter` variants should be used
+ /// instead in this context. This is a rustc bug. For details, see
+ /// [rust-lang/rust#67062](https://github.com/rust-lang/rust/issues/67062).
+ ///
+ /// </div>
#[stable(feature = "proc_macro_lib2", since = "1.29.0")]
None,
}
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index 5b36867..e56f038 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -97,3 +97,17 @@
name = "stdbenches"
path = "benches/lib.rs"
test = true
+
+[lints.rust.unexpected_cfgs]
+level = "warn"
+# x.py uses beta cargo, so `check-cfg` entries do not yet take effect
+# for rust-lang/rust. But for users of `-Zbuild-std` it does.
+# The unused warning is waiting for rust-lang/cargo#13925 to reach beta.
+check-cfg = [
+ 'cfg(bootstrap)',
+ 'cfg(target_arch, values("xtensa"))',
+ # std use #[path] imports to portable-simd `std_float` crate
+ # and to the `backtrace` crate which messes-up with Cargo list
+ # of declared features, we therefor expect any feature cfg
+ 'cfg(feature, values(any()))',
+]
diff --git a/library/std/build.rs b/library/std/build.rs
index 7a47b52..7d975df 100644
--- a/library/std/build.rs
+++ b/library/std/build.rs
@@ -7,9 +7,13 @@
let target_vendor =
env::var("CARGO_CFG_TARGET_VENDOR").expect("CARGO_CFG_TARGET_VENDOR was not set");
let target_env = env::var("CARGO_CFG_TARGET_ENV").expect("CARGO_CFG_TARGET_ENV was not set");
+
+ println!("cargo:rustc-check-cfg=cfg(netbsd10)");
if target_os == "netbsd" && env::var("RUSTC_STD_NETBSD10").is_ok() {
println!("cargo:rustc-cfg=netbsd10");
}
+
+ println!("cargo:rustc-check-cfg=cfg(restricted_std)");
if target_os == "linux"
|| target_os == "android"
|| target_os == "netbsd"
@@ -59,8 +63,11 @@
// - arch=avr
// - JSON targets
// - Any new targets that have not been explicitly added above.
- println!("cargo:rustc-cfg=feature=\"restricted-std\"");
+ println!("cargo:rustc-cfg=restricted_std");
}
- println!("cargo:rustc-env=STD_ENV_ARCH={}", env::var("CARGO_CFG_TARGET_ARCH").unwrap());
+
+ println!("cargo:rustc-check-cfg=cfg(backtrace_in_libstd)");
println!("cargo:rustc-cfg=backtrace_in_libstd");
+
+ println!("cargo:rustc-env=STD_ENV_ARCH={}", env::var("CARGO_CFG_TARGET_ARCH").unwrap());
}
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index 949c543..4a18db3 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -213,9 +213,9 @@
//! [array]: prim@array
//! [slice]: prim@slice
-#![cfg_attr(not(feature = "restricted-std"), stable(feature = "rust1", since = "1.0.0"))]
+#![cfg_attr(not(restricted_std), stable(feature = "rust1", since = "1.0.0"))]
#![cfg_attr(
- feature = "restricted-std",
+ restricted_std,
unstable(
feature = "restricted_std",
issue = "none",
diff --git a/library/std/src/sys/thread_local/fast_local.rs b/library/std/src/sys/thread_local/fast_local.rs
deleted file mode 100644
index 49b51a7..0000000
--- a/library/std/src/sys/thread_local/fast_local.rs
+++ /dev/null
@@ -1,247 +0,0 @@
-use super::lazy::LazyKeyInner;
-use crate::cell::Cell;
-use crate::sys::thread_local_dtor::register_dtor;
-use crate::{fmt, mem, panic, ptr};
-
-#[doc(hidden)]
-#[allow_internal_unstable(thread_local_internals, cfg_target_thread_local, thread_local)]
-#[allow_internal_unsafe]
-#[unstable(feature = "thread_local_internals", issue = "none")]
-#[rustc_macro_transparency = "semitransparent"]
-pub macro thread_local_inner {
- // used to generate the `LocalKey` value for const-initialized thread locals
- (@key $t:ty, const $init:expr) => {{
- #[inline]
- #[deny(unsafe_op_in_unsafe_fn)]
- unsafe fn __getit(
- _init: $crate::option::Option<&mut $crate::option::Option<$t>>,
- ) -> $crate::option::Option<&'static $t> {
- const INIT_EXPR: $t = $init;
- // If the platform has support for `#[thread_local]`, use it.
- #[thread_local]
- // We use `UnsafeCell` here instead of `static mut` to ensure any generated TLS shims
- // have a nonnull attribute on their return value.
- static VAL: $crate::cell::UnsafeCell<$t> = $crate::cell::UnsafeCell::new(INIT_EXPR);
-
- // If a dtor isn't needed we can do something "very raw" and
- // just get going.
- if !$crate::mem::needs_drop::<$t>() {
- unsafe {
- return $crate::option::Option::Some(&*VAL.get())
- }
- }
-
- // 0 == dtor not registered
- // 1 == dtor registered, dtor not run
- // 2 == dtor registered and is running or has run
- #[thread_local]
- static STATE: $crate::cell::Cell<$crate::primitive::u8> = $crate::cell::Cell::new(0);
-
- // Safety: Performs `drop_in_place(ptr as *mut $t)`, and requires
- // all that comes with it.
- unsafe extern "C" fn destroy(ptr: *mut $crate::primitive::u8) {
- $crate::thread::local_impl::abort_on_dtor_unwind(|| {
- let old_state = STATE.replace(2);
- $crate::debug_assert_eq!(old_state, 1);
- // Safety: safety requirement is passed on to caller.
- unsafe { $crate::ptr::drop_in_place(ptr.cast::<$t>()); }
- });
- }
-
- unsafe {
- match STATE.get() {
- // 0 == we haven't registered a destructor, so do
- // so now.
- 0 => {
- $crate::thread::local_impl::Key::<$t>::register_dtor(
- VAL.get() as *mut $crate::primitive::u8,
- destroy,
- );
- STATE.set(1);
- $crate::option::Option::Some(&*VAL.get())
- }
- // 1 == the destructor is registered and the value
- // is valid, so return the pointer.
- 1 => $crate::option::Option::Some(&*VAL.get()),
- // otherwise the destructor has already run, so we
- // can't give access.
- _ => $crate::option::Option::None,
- }
- }
- }
-
- unsafe {
- $crate::thread::LocalKey::new(__getit)
- }
- }},
-
- // used to generate the `LocalKey` value for `thread_local!`
- (@key $t:ty, $init:expr) => {
- {
- #[inline]
- fn __init() -> $t { $init }
-
- #[inline]
- unsafe fn __getit(
- init: $crate::option::Option<&mut $crate::option::Option<$t>>,
- ) -> $crate::option::Option<&'static $t> {
- #[thread_local]
- static __KEY: $crate::thread::local_impl::Key<$t> =
- $crate::thread::local_impl::Key::<$t>::new();
-
- unsafe {
- __KEY.get(move || {
- if let $crate::option::Option::Some(init) = init {
- if let $crate::option::Option::Some(value) = init.take() {
- return value;
- }
- if $crate::cfg!(debug_assertions) {
- $crate::unreachable!("missing default value");
- }
- }
- __init()
- })
- }
- }
-
- unsafe {
- $crate::thread::LocalKey::new(__getit)
- }
- }
- },
- ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $($init:tt)*) => {
- $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
- $crate::thread::local_impl::thread_local_inner!(@key $t, $($init)*);
- },
-}
-
-#[derive(Copy, Clone)]
-enum DtorState {
- Unregistered,
- Registered,
- RunningOrHasRun,
-}
-
-// This data structure has been carefully constructed so that the fast path
-// only contains one branch on x86. That optimization is necessary to avoid
-// duplicated tls lookups on OSX.
-//
-// LLVM issue: https://bugs.llvm.org/show_bug.cgi?id=41722
-pub struct Key<T> {
- // If `LazyKeyInner::get` returns `None`, that indicates either:
- // * The value has never been initialized
- // * The value is being recursively initialized
- // * The value has already been destroyed or is being destroyed
- // To determine which kind of `None`, check `dtor_state`.
- //
- // This is very optimizer friendly for the fast path - initialized but
- // not yet dropped.
- inner: LazyKeyInner<T>,
-
- // Metadata to keep track of the state of the destructor. Remember that
- // this variable is thread-local, not global.
- dtor_state: Cell<DtorState>,
-}
-
-impl<T> fmt::Debug for Key<T> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_struct("Key").finish_non_exhaustive()
- }
-}
-impl<T> Key<T> {
- pub const fn new() -> Key<T> {
- Key { inner: LazyKeyInner::new(), dtor_state: Cell::new(DtorState::Unregistered) }
- }
-
- // note that this is just a publicly-callable function only for the
- // const-initialized form of thread locals, basically a way to call the
- // free `register_dtor` function defined elsewhere in std.
- pub unsafe fn register_dtor(a: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
- unsafe {
- register_dtor(a, dtor);
- }
- }
-
- pub unsafe fn get<F: FnOnce() -> T>(&self, init: F) -> Option<&'static T> {
- // SAFETY: See the definitions of `LazyKeyInner::get` and
- // `try_initialize` for more information.
- //
- // The caller must ensure no mutable references are ever active to
- // the inner cell or the inner T when this is called.
- // The `try_initialize` is dependant on the passed `init` function
- // for this.
- unsafe {
- match self.inner.get() {
- Some(val) => Some(val),
- None => self.try_initialize(init),
- }
- }
- }
-
- // `try_initialize` is only called once per fast thread local variable,
- // except in corner cases where thread_local dtors reference other
- // thread_local's, or it is being recursively initialized.
- //
- // Macos: Inlining this function can cause two `tlv_get_addr` calls to
- // be performed for every call to `Key::get`.
- // LLVM issue: https://bugs.llvm.org/show_bug.cgi?id=41722
- #[inline(never)]
- unsafe fn try_initialize<F: FnOnce() -> T>(&self, init: F) -> Option<&'static T> {
- // SAFETY: See comment above (this function doc).
- if !mem::needs_drop::<T>() || unsafe { self.try_register_dtor() } {
- // SAFETY: See comment above (this function doc).
- Some(unsafe { self.inner.initialize(init) })
- } else {
- None
- }
- }
-
- // `try_register_dtor` is only called once per fast thread local
- // variable, except in corner cases where thread_local dtors reference
- // other thread_local's, or it is being recursively initialized.
- unsafe fn try_register_dtor(&self) -> bool {
- match self.dtor_state.get() {
- DtorState::Unregistered => {
- // SAFETY: dtor registration happens before initialization.
- // Passing `self` as a pointer while using `destroy_value<T>`
- // is safe because the function will build a pointer to a
- // Key<T>, which is the type of self and so find the correct
- // size.
- unsafe { register_dtor(self as *const _ as *mut u8, destroy_value::<T>) };
- self.dtor_state.set(DtorState::Registered);
- true
- }
- DtorState::Registered => {
- // recursively initialized
- true
- }
- DtorState::RunningOrHasRun => false,
- }
- }
-}
-
-unsafe extern "C" fn destroy_value<T>(ptr: *mut u8) {
- let ptr = ptr as *mut Key<T>;
-
- // SAFETY:
- //
- // The pointer `ptr` has been built just above and comes from
- // `try_register_dtor` where it is originally a Key<T> coming from `self`,
- // making it non-NUL and of the correct type.
- //
- // Right before we run the user destructor be sure to set the
- // `Option<T>` to `None`, and `dtor_state` to `RunningOrHasRun`. This
- // causes future calls to `get` to run `try_initialize_drop` again,
- // which will now fail, and return `None`.
- //
- // Wrap the call in a catch to ensure unwinding is caught in the event
- // a panic takes place in a destructor.
- if let Err(_) = panic::catch_unwind(panic::AssertUnwindSafe(|| unsafe {
- let Key { inner, dtor_state } = &*ptr;
- let value = inner.take();
- dtor_state.set(DtorState::RunningOrHasRun);
- drop(value);
- })) {
- rtabort!("thread local panicked on drop");
- }
-}
diff --git a/library/std/src/sys/thread_local/fast_local/eager.rs b/library/std/src/sys/thread_local/fast_local/eager.rs
new file mode 100644
index 0000000..c2bc580
--- /dev/null
+++ b/library/std/src/sys/thread_local/fast_local/eager.rs
@@ -0,0 +1,82 @@
+use crate::cell::{Cell, UnsafeCell};
+use crate::ptr::{self, drop_in_place};
+use crate::sys::thread_local::abort_on_dtor_unwind;
+use crate::sys::thread_local_dtor::register_dtor;
+
+#[derive(Clone, Copy)]
+enum State {
+ Initial,
+ Alive,
+ Destroyed,
+}
+
+#[allow(missing_debug_implementations)]
+pub struct Storage<T> {
+ state: Cell<State>,
+ val: UnsafeCell<T>,
+}
+
+impl<T> Storage<T> {
+ pub const fn new(val: T) -> Storage<T> {
+ Storage { state: Cell::new(State::Initial), val: UnsafeCell::new(val) }
+ }
+
+ /// Get a reference to the TLS value. If the TLS variable has been destroyed,
+ /// `None` is returned.
+ ///
+ /// # Safety
+ /// * The `self` reference must remain valid until the TLS destructor has been
+ /// run.
+ /// * The returned reference may only be used until thread destruction occurs
+ /// and may not be used after reentrant initialization has occurred.
+ ///
+ // FIXME(#110897): return NonNull instead of lying about the lifetime.
+ #[inline]
+ pub unsafe fn get(&self) -> Option<&'static T> {
+ match self.state.get() {
+ // SAFETY: as the state is not `Destroyed`, the value cannot have
+ // been destroyed yet. The reference fulfills the terms outlined
+ // above.
+ State::Alive => unsafe { Some(&*self.val.get()) },
+ State::Destroyed => None,
+ State::Initial => unsafe { self.initialize() },
+ }
+ }
+
+ #[cold]
+ unsafe fn initialize(&self) -> Option<&'static T> {
+ // Register the destructor
+
+ // SAFETY:
+ // * the destructor will be called at thread destruction.
+ // * the caller guarantees that `self` will be valid until that time.
+ unsafe {
+ register_dtor(ptr::from_ref(self).cast_mut().cast(), destroy::<T>);
+ }
+ self.state.set(State::Alive);
+ // SAFETY: as the state is not `Destroyed`, the value cannot have
+ // been destroyed yet. The reference fulfills the terms outlined
+ // above.
+ unsafe { Some(&*self.val.get()) }
+ }
+}
+
+/// Transition an `Alive` TLS variable into the `Destroyed` state, dropping its
+/// value.
+///
+/// # Safety
+/// * Must only be called at thread destruction.
+/// * `ptr` must point to an instance of `Storage` with `Alive` state and be
+/// valid for accessing that instance.
+unsafe extern "C" fn destroy<T>(ptr: *mut u8) {
+ // Print a nice abort message if a panic occurs.
+ abort_on_dtor_unwind(|| {
+ let storage = unsafe { &*(ptr as *const Storage<T>) };
+ // Update the state before running the destructor as it may attempt to
+ // access the variable.
+ storage.state.set(State::Destroyed);
+ unsafe {
+ drop_in_place(storage.val.get());
+ }
+ })
+}
diff --git a/library/std/src/sys/thread_local/fast_local/lazy.rs b/library/std/src/sys/thread_local/fast_local/lazy.rs
new file mode 100644
index 0000000..1437176
--- /dev/null
+++ b/library/std/src/sys/thread_local/fast_local/lazy.rs
@@ -0,0 +1,122 @@
+use crate::cell::UnsafeCell;
+use crate::hint::unreachable_unchecked;
+use crate::mem::forget;
+use crate::ptr;
+use crate::sys::thread_local::abort_on_dtor_unwind;
+use crate::sys::thread_local_dtor::register_dtor;
+
+pub unsafe trait DestroyedState: Sized {
+ fn register_dtor<T>(s: &Storage<T, Self>);
+}
+
+unsafe impl DestroyedState for ! {
+ fn register_dtor<T>(_: &Storage<T, !>) {}
+}
+
+unsafe impl DestroyedState for () {
+ fn register_dtor<T>(s: &Storage<T, ()>) {
+ unsafe {
+ register_dtor(ptr::from_ref(s).cast_mut().cast(), destroy::<T>);
+ }
+ }
+}
+
+enum State<T, D> {
+ Initial,
+ Alive(T),
+ Destroyed(D),
+}
+
+#[allow(missing_debug_implementations)]
+pub struct Storage<T, D> {
+ state: UnsafeCell<State<T, D>>,
+}
+
+impl<T, D> Storage<T, D>
+where
+ D: DestroyedState,
+{
+ pub const fn new() -> Storage<T, D> {
+ Storage { state: UnsafeCell::new(State::Initial) }
+ }
+
+ /// Get a reference to the TLS value, potentially initializing it with the
+ /// provided parameters. If the TLS variable has been destroyed, `None` is
+ /// returned.
+ ///
+ /// # Safety
+ /// * The `self` reference must remain valid until the TLS destructor is run,
+ /// at which point the returned reference is invalidated.
+ /// * The returned reference may only be used until thread destruction occurs
+ /// and may not be used after reentrant initialization has occurred.
+ ///
+ // FIXME(#110897): return NonNull instead of lying about the lifetime.
+ #[inline]
+ pub unsafe fn get_or_init(
+ &self,
+ i: Option<&mut Option<T>>,
+ f: impl FnOnce() -> T,
+ ) -> Option<&'static T> {
+ // SAFETY:
+ // No mutable reference to the inner value exists outside the calls to
+ // `replace`. The lifetime of the returned reference fulfills the terms
+ // outlined above.
+ let state = unsafe { &*self.state.get() };
+ match state {
+ State::Alive(v) => Some(v),
+ State::Destroyed(_) => None,
+ State::Initial => unsafe { self.initialize(i, f) },
+ }
+ }
+
+ #[cold]
+ unsafe fn initialize(
+ &self,
+ i: Option<&mut Option<T>>,
+ f: impl FnOnce() -> T,
+ ) -> Option<&'static T> {
+ // Perform initialization
+
+ let v = i.and_then(Option::take).unwrap_or_else(f);
+
+ // SAFETY:
+ // If references to the inner value exist, they were created in `f`
+ // and are invalidated here. The caller promises to never use them
+ // after this.
+ let old = unsafe { self.state.get().replace(State::Alive(v)) };
+ match old {
+ // If the variable is not being recursively initialized, register
+ // the destructor. This might be a noop if the value does not need
+ // destruction.
+ State::Initial => D::register_dtor(self),
+ // Else, drop the old value. This might be changed to a panic.
+ val => drop(val),
+ }
+
+ // SAFETY:
+ // Initialization was completed and the state was set to `Alive`, so the
+ // reference fulfills the terms outlined above.
+ unsafe {
+ let State::Alive(v) = &*self.state.get() else { unreachable_unchecked() };
+ Some(v)
+ }
+ }
+}
+
+/// Transition an `Alive` TLS variable into the `Destroyed` state, dropping its
+/// value.
+///
+/// # Safety
+/// * Must only be called at thread destruction.
+/// * `ptr` must point to an instance of `Storage<T, ()>` and be valid for
+/// accessing that instance.
+unsafe extern "C" fn destroy<T>(ptr: *mut u8) {
+ // Print a nice abort message if a panic occurs.
+ abort_on_dtor_unwind(|| {
+ let storage = unsafe { &*(ptr as *const Storage<T, ()>) };
+ // Update the state before running the destructor as it may attempt to
+ // access the variable.
+ let val = unsafe { storage.state.get().replace(State::Destroyed(())) };
+ drop(val);
+ })
+}
diff --git a/library/std/src/sys/thread_local/fast_local/mod.rs b/library/std/src/sys/thread_local/fast_local/mod.rs
new file mode 100644
index 0000000..2537907
--- /dev/null
+++ b/library/std/src/sys/thread_local/fast_local/mod.rs
@@ -0,0 +1,122 @@
+//! Thread local support for platforms with native TLS.
+//!
+//! To achieve the best performance, we choose from four different types for
+//! the TLS variable, depending from the method of initialization used (`const`
+//! or lazy) and the drop requirements of the stored type:
+//!
+//! | | `Drop` | `!Drop` |
+//! |--------:|:--------------------:|:-------------------:|
+//! | `const` | `EagerStorage<T>` | `T` |
+//! | lazy | `LazyStorage<T, ()>` | `LazyStorage<T, !>` |
+//!
+//! For `const` initialization and `!Drop` types, we simply use `T` directly,
+//! but for other situations, we implement a state machine to handle
+//! initialization of the variable and its destructor and destruction.
+//! Upon accessing the TLS variable, the current state is compared:
+//!
+//! 1. If the state is `Initial`, initialize the storage, transition the state
+//! to `Alive` and (if applicable) register the destructor, and return a
+//! reference to the value.
+//! 2. If the state is `Alive`, initialization was previously completed, so
+//! return a reference to the value.
+//! 3. If the state is `Destroyed`, the destructor has been run already, so
+//! return [`None`].
+//!
+//! The TLS destructor sets the state to `Destroyed` and drops the current value.
+//!
+//! To simplify the code, we make `LazyStorage` generic over the destroyed state
+//! and use the `!` type (never type) as type parameter for `!Drop` types. This
+//! eliminates the `Destroyed` state for these values, which can allow more niche
+//! optimizations to occur for the `State` enum. For `Drop` types, `()` is used.
+
+#![deny(unsafe_op_in_unsafe_fn)]
+
+mod eager;
+mod lazy;
+
+pub use eager::Storage as EagerStorage;
+pub use lazy::Storage as LazyStorage;
+
+#[doc(hidden)]
+#[allow_internal_unstable(
+ thread_local_internals,
+ cfg_target_thread_local,
+ thread_local,
+ never_type
+)]
+#[allow_internal_unsafe]
+#[unstable(feature = "thread_local_internals", issue = "none")]
+#[rustc_macro_transparency = "semitransparent"]
+pub macro thread_local_inner {
+ // used to generate the `LocalKey` value for const-initialized thread locals
+ (@key $t:ty, const $init:expr) => {{
+ const __INIT: $t = $init;
+
+ #[inline]
+ #[deny(unsafe_op_in_unsafe_fn)]
+ unsafe fn __getit(
+ _init: $crate::option::Option<&mut $crate::option::Option<$t>>,
+ ) -> $crate::option::Option<&'static $t> {
+ use $crate::thread::local_impl::EagerStorage;
+ use $crate::mem::needs_drop;
+ use $crate::ptr::addr_of;
+
+ if needs_drop::<$t>() {
+ #[thread_local]
+ static VAL: EagerStorage<$t> = EagerStorage::new(__INIT);
+ unsafe {
+ VAL.get()
+ }
+ } else {
+ #[thread_local]
+ static VAL: $t = __INIT;
+ unsafe {
+ $crate::option::Option::Some(&*addr_of!(VAL))
+ }
+ }
+ }
+
+ unsafe {
+ $crate::thread::LocalKey::new(__getit)
+ }
+ }},
+
+ // used to generate the `LocalKey` value for `thread_local!`
+ (@key $t:ty, $init:expr) => {{
+ #[inline]
+ fn __init() -> $t {
+ $init
+ }
+
+ #[inline]
+ #[deny(unsafe_op_in_unsafe_fn)]
+ unsafe fn __getit(
+ init: $crate::option::Option<&mut $crate::option::Option<$t>>,
+ ) -> $crate::option::Option<&'static $t> {
+ use $crate::thread::local_impl::LazyStorage;
+ use $crate::mem::needs_drop;
+
+ if needs_drop::<$t>() {
+ #[thread_local]
+ static VAL: LazyStorage<$t, ()> = LazyStorage::new();
+ unsafe {
+ VAL.get_or_init(init, __init)
+ }
+ } else {
+ #[thread_local]
+ static VAL: LazyStorage<$t, !> = LazyStorage::new();
+ unsafe {
+ VAL.get_or_init(init, __init)
+ }
+ }
+ }
+
+ unsafe {
+ $crate::thread::LocalKey::new(__getit)
+ }
+ }},
+ ($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $($init:tt)*) => {
+ $(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
+ $crate::thread::local_impl::thread_local_inner!(@key $t, $($init)*);
+ },
+}
diff --git a/library/std/src/sys/thread_local/mod.rs b/library/std/src/sys/thread_local/mod.rs
index 7500c95..36f6f90 100644
--- a/library/std/src/sys/thread_local/mod.rs
+++ b/library/std/src/sys/thread_local/mod.rs
@@ -10,12 +10,12 @@
#[doc(hidden)]
mod static_local;
#[doc(hidden)]
- pub use static_local::{Key, thread_local_inner};
+ pub use static_local::{EagerStorage, LazyStorage, thread_local_inner};
} else if #[cfg(target_thread_local)] {
#[doc(hidden)]
mod fast_local;
#[doc(hidden)]
- pub use fast_local::{Key, thread_local_inner};
+ pub use fast_local::{EagerStorage, LazyStorage, thread_local_inner};
} else {
#[doc(hidden)]
mod os_local;
@@ -24,6 +24,9 @@
}
}
+// Not used by the fast-local TLS anymore.
+// FIXME(#110897): remove this.
+#[allow(unused)]
mod lazy {
use crate::cell::UnsafeCell;
use crate::hint;
diff --git a/library/std/src/sys/thread_local/static_local.rs b/library/std/src/sys/thread_local/static_local.rs
index 162c3fb..6beda2e 100644
--- a/library/std/src/sys/thread_local/static_local.rs
+++ b/library/std/src/sys/thread_local/static_local.rs
@@ -1,5 +1,7 @@
-use super::lazy::LazyKeyInner;
-use crate::fmt;
+//! On some targets like wasm there's no threads, so no need to generate
+//! thread locals and we can instead just use plain statics!
+
+use crate::cell::UnsafeCell;
#[doc(hidden)]
#[allow_internal_unstable(thread_local_internals)]
@@ -9,22 +11,17 @@
pub macro thread_local_inner {
// used to generate the `LocalKey` value for const-initialized thread locals
(@key $t:ty, const $init:expr) => {{
- #[inline] // see comments below
+ const __INIT: $t = $init;
+
+ #[inline]
#[deny(unsafe_op_in_unsafe_fn)]
unsafe fn __getit(
_init: $crate::option::Option<&mut $crate::option::Option<$t>>,
) -> $crate::option::Option<&'static $t> {
- const INIT_EXPR: $t = $init;
+ use $crate::thread::local_impl::EagerStorage;
- // wasm without atomics maps directly to `static mut`, and dtors
- // aren't implemented because thread dtors aren't really a thing
- // on wasm right now
- //
- // FIXME(#84224) this should come after the `target_thread_local`
- // block.
- static mut VAL: $t = INIT_EXPR;
- // SAFETY: we only ever create shared references, so there's no mutable aliasing.
- unsafe { $crate::option::Option::Some(&*$crate::ptr::addr_of!(VAL)) }
+ static VAL: EagerStorage<$t> = EagerStorage { value: __INIT };
+ $crate::option::Option::Some(&VAL.value)
}
unsafe {
@@ -33,74 +30,83 @@
}},
// used to generate the `LocalKey` value for `thread_local!`
- (@key $t:ty, $init:expr) => {
- {
- #[inline]
- fn __init() -> $t { $init }
- #[inline]
- unsafe fn __getit(
- init: $crate::option::Option<&mut $crate::option::Option<$t>>,
- ) -> $crate::option::Option<&'static $t> {
- static __KEY: $crate::thread::local_impl::Key<$t> =
- $crate::thread::local_impl::Key::new();
+ (@key $t:ty, $init:expr) => {{
+ #[inline]
+ fn __init() -> $t { $init }
- unsafe {
- __KEY.get(move || {
- if let $crate::option::Option::Some(init) = init {
- if let $crate::option::Option::Some(value) = init.take() {
- return value;
- } else if $crate::cfg!(debug_assertions) {
- $crate::unreachable!("missing default value");
- }
- }
- __init()
- })
- }
- }
+ #[inline]
+ #[deny(unsafe_op_in_unsafe_fn)]
+ unsafe fn __getit(
+ init: $crate::option::Option<&mut $crate::option::Option<$t>>,
+ ) -> $crate::option::Option<&'static $t> {
+ use $crate::thread::local_impl::LazyStorage;
- unsafe {
- $crate::thread::LocalKey::new(__getit)
- }
+ static VAL: LazyStorage<$t> = LazyStorage::new();
+ unsafe { $crate::option::Option::Some(VAL.get(init, __init)) }
}
- },
+
+ unsafe {
+ $crate::thread::LocalKey::new(__getit)
+ }
+ }},
($(#[$attr:meta])* $vis:vis $name:ident, $t:ty, $($init:tt)*) => {
$(#[$attr])* $vis const $name: $crate::thread::LocalKey<$t> =
$crate::thread::local_impl::thread_local_inner!(@key $t, $($init)*);
},
}
-/// On some targets like wasm there's no threads, so no need to generate
-/// thread locals and we can instead just use plain statics!
-
-pub struct Key<T> {
- inner: LazyKeyInner<T>,
+#[allow(missing_debug_implementations)]
+pub struct EagerStorage<T> {
+ pub value: T,
}
-unsafe impl<T> Sync for Key<T> {}
+// SAFETY: the target doesn't have threads.
+unsafe impl<T> Sync for EagerStorage<T> {}
-impl<T> fmt::Debug for Key<T> {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_struct("Key").finish_non_exhaustive()
+#[allow(missing_debug_implementations)]
+pub struct LazyStorage<T> {
+ value: UnsafeCell<Option<T>>,
+}
+
+impl<T> LazyStorage<T> {
+ pub const fn new() -> LazyStorage<T> {
+ LazyStorage { value: UnsafeCell::new(None) }
+ }
+
+ /// Gets a reference to the contained value, initializing it if necessary.
+ ///
+ /// # Safety
+ /// The returned reference may not be used after reentrant initialization has occurred.
+ #[inline]
+ pub unsafe fn get(
+ &'static self,
+ i: Option<&mut Option<T>>,
+ f: impl FnOnce() -> T,
+ ) -> &'static T {
+ let value = unsafe { &*self.value.get() };
+ match value {
+ Some(v) => v,
+ None => self.initialize(i, f),
+ }
+ }
+
+ #[cold]
+ unsafe fn initialize(
+ &'static self,
+ i: Option<&mut Option<T>>,
+ f: impl FnOnce() -> T,
+ ) -> &'static T {
+ let value = i.and_then(Option::take).unwrap_or_else(f);
+ // Destroy the old value, after updating the TLS variable as the
+ // destructor might reference it.
+ // FIXME(#110897): maybe panic on recursive initialization.
+ unsafe {
+ self.value.get().replace(Some(value));
+ }
+ // SAFETY: we just set this to `Some`.
+ unsafe { (*self.value.get()).as_ref().unwrap_unchecked() }
}
}
-impl<T> Key<T> {
- pub const fn new() -> Key<T> {
- Key { inner: LazyKeyInner::new() }
- }
-
- pub unsafe fn get(&self, init: impl FnOnce() -> T) -> Option<&'static T> {
- // SAFETY: The caller must ensure no reference is ever handed out to
- // the inner cell nor mutable reference to the Option<T> inside said
- // cell. This make it safe to hand a reference, though the lifetime
- // of 'static is itself unsafe, making the get method unsafe.
- let value = unsafe {
- match self.inner.get() {
- Some(ref value) => value,
- None => self.inner.initialize(init),
- }
- };
-
- Some(value)
- }
-}
+// SAFETY: the target doesn't have threads.
+unsafe impl<T> Sync for LazyStorage<T> {}
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
index 78bc9af..2221587 100644
--- a/library/std/src/thread/mod.rs
+++ b/library/std/src/thread/mod.rs
@@ -205,7 +205,7 @@
#[doc(hidden)]
#[unstable(feature = "thread_local_internals", issue = "none")]
pub mod local_impl {
- pub use crate::sys::thread_local::{thread_local_inner, Key, abort_on_dtor_unwind};
+ pub use crate::sys::thread_local::*;
}
}
}
diff --git a/src/bootstrap/src/lib.rs b/src/bootstrap/src/lib.rs
index 698a576..52c9446 100644
--- a/src/bootstrap/src/lib.rs
+++ b/src/bootstrap/src/lib.rs
@@ -84,13 +84,14 @@
(Some(Mode::ToolRustc), "rust_analyzer", None),
(Some(Mode::ToolStd), "rust_analyzer", None),
(Some(Mode::Codegen), "parallel_compiler", None),
+ // NOTE: consider updating `check-cfg` entries in `std/Cargo.toml` too.
+ // cfg(bootstrap) remove these once the bootstrap compiler supports
+ // `lints.rust.unexpected_cfgs.check-cfg`
(Some(Mode::Std), "stdarch_intel_sde", None),
(Some(Mode::Std), "no_fp_fmt_parse", None),
(Some(Mode::Std), "no_global_oom_handling", None),
(Some(Mode::Std), "no_rc", None),
(Some(Mode::Std), "no_sync", None),
- (Some(Mode::Std), "netbsd10", None),
- (Some(Mode::Std), "backtrace_in_libstd", None),
/* Extra values not defined in the built-in targets yet, but used in std */
(Some(Mode::Std), "target_env", Some(&["libnx", "p2"])),
(Some(Mode::Std), "target_os", Some(&["visionos"])),
diff --git a/src/doc/rustc/src/SUMMARY.md b/src/doc/rustc/src/SUMMARY.md
index 6f81495..4ef2fce 100644
--- a/src/doc/rustc/src/SUMMARY.md
+++ b/src/doc/rustc/src/SUMMARY.md
@@ -20,10 +20,10 @@
- [\*-apple-darwin](platform-support/apple-darwin.md)
- [i686-apple-darwin](platform-support/i686-apple-darwin.md)
- [x86_64h-apple-darwin](platform-support/x86_64h-apple-darwin.md)
- - [arm64e-apple-darwin.md](platform-support/arm64e-apple-darwin.md)
+ - [arm64e-apple-darwin](platform-support/arm64e-apple-darwin.md)
- [\*-apple-ios](platform-support/apple-ios.md)
- [\*-apple-ios-macabi](platform-support/apple-ios-macabi.md)
- - [arm64e-apple-ios.md](platform-support/arm64e-apple-ios.md)
+ - [arm64e-apple-ios](platform-support/arm64e-apple-ios.md)
- [\*-apple-tvos](platform-support/apple-tvos.md)
- [\*-apple-watchos](platform-support/apple-watchos.md)
- [\*-apple-visionos](platform-support/apple-visionos.md)
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index b54ec62..7aab07c 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -1937,7 +1937,7 @@
let mut primitive_locations = FxHashMap::default();
// NOTE: technically this misses crates that are only passed with `--extern` and not loaded when checking the crate.
// This is a degenerate case that I don't plan to support.
- for &crate_num in tcx.crates(()) {
+ for &crate_num in tcx.crates_including_speculative(()) {
let e = ExternalCrate { crate_num };
let crate_name = e.name(tcx);
debug!(?crate_num, ?crate_name);
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index feb03b9..462b31f 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -347,7 +347,7 @@
show_coverage,
};
- for cnum in tcx.crates(()) {
+ for cnum in tcx.crates_including_speculative(()) {
crate::visit_lib::lib_embargo_visit_item(&mut ctxt, cnum.as_def_id());
}
diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs
index a3b88a8..28ddf76 100644
--- a/src/librustdoc/formats/cache.rs
+++ b/src/librustdoc/formats/cache.rs
@@ -155,7 +155,7 @@
// Cache where all our extern crates are located
// FIXME: this part is specific to HTML so it'd be nice to remove it from the common code
- for &crate_num in tcx.crates(()) {
+ for &crate_num in tcx.crates_including_speculative(()) {
let e = ExternalCrate { crate_num };
let name = e.name(tcx);
diff --git a/src/librustdoc/passes/collect_trait_impls.rs b/src/librustdoc/passes/collect_trait_impls.rs
index c92cf9d..22daac9 100644
--- a/src/librustdoc/passes/collect_trait_impls.rs
+++ b/src/librustdoc/passes/collect_trait_impls.rs
@@ -47,7 +47,7 @@
// External trait impls.
{
let _prof_timer = tcx.sess.prof.generic_activity("build_extern_trait_impls");
- for &cnum in tcx.crates(()) {
+ for &cnum in tcx.crates_including_speculative(()) {
for &impl_def_id in tcx.trait_impls_in_crate(cnum) {
cx.with_param_env(impl_def_id, |cx| {
inline::build_impl(cx, impl_def_id, None, &mut new_items_external);
diff --git a/src/librustdoc/scrape_examples.rs b/src/librustdoc/scrape_examples.rs
index 9c9b386..64753a5 100644
--- a/src/librustdoc/scrape_examples.rs
+++ b/src/librustdoc/scrape_examples.rs
@@ -283,7 +283,7 @@
// Collect CrateIds corresponding to provided target crates
// If two different versions of the crate in the dependency tree, then examples will be collected from both.
let all_crates = tcx
- .crates(())
+ .crates_including_speculative(())
.iter()
.chain([&LOCAL_CRATE])
.map(|crate_num| (crate_num, tcx.crate_name(*crate_num)))
@@ -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..94d4656 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
@@ -632,7 +647,7 @@
/// This function is expensive and should be used sparingly.
pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Vec<Res> {
fn find_crates(tcx: TyCtxt<'_>, name: Symbol) -> impl Iterator<Item = DefId> + '_ {
- tcx.crates(())
+ tcx.crates_including_speculative(())
.iter()
.copied()
.filter(move |&num| tcx.crate_name(num) == name)
@@ -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/compiletest/src/json.rs b/src/tools/compiletest/src/json.rs
index 10726b9..29e8809 100644
--- a/src/tools/compiletest/src/json.rs
+++ b/src/tools/compiletest/src/json.rs
@@ -282,7 +282,7 @@
// Add notes for the backtrace
for span in primary_spans {
- for frame in &span.expansion {
+ if let Some(frame) = &span.expansion {
push_backtrace(expected_errors, frame, file_name);
}
}
@@ -315,7 +315,7 @@
});
}
- for previous_expansion in &expansion.span.expansion {
+ if let Some(previous_expansion) = &expansion.span.expansion {
push_backtrace(expected_errors, previous_expansion, file_name);
}
}
diff --git a/src/tools/miri/src/concurrency/data_race.rs b/src/tools/miri/src/concurrency/data_race.rs
index f2bec97..10835e0 100644
--- a/src/tools/miri/src/concurrency/data_race.rs
+++ b/src/tools/miri/src/concurrency/data_race.rs
@@ -648,7 +648,7 @@
place: &MPlaceTy<'tcx, Provenance>,
rhs: &ImmTy<'tcx, Provenance>,
op: mir::BinOp,
- neg: bool,
+ not: bool,
atomic: AtomicRwOrd,
) -> InterpResult<'tcx, ImmTy<'tcx, Provenance>> {
let this = self.eval_context_mut();
@@ -656,9 +656,8 @@
let old = this.allow_data_races_mut(|this| this.read_immediate(place))?;
- // Atomics wrap around on overflow.
- let val = this.wrapping_binary_op(op, &old, rhs)?;
- let val = if neg { this.wrapping_unary_op(mir::UnOp::Not, &val)? } else { val };
+ let val = this.binary_op(op, &old, rhs)?;
+ let val = if not { this.unary_op(mir::UnOp::Not, &val)? } else { val };
this.allow_data_races_mut(|this| this.write_immediate(*val, place))?;
this.validate_atomic_rmw(place, atomic)?;
@@ -700,7 +699,7 @@
this.atomic_access_check(place, AtomicAccessType::Rmw)?;
let old = this.allow_data_races_mut(|this| this.read_immediate(place))?;
- let lt = this.wrapping_binary_op(mir::BinOp::Lt, &old, &rhs)?.to_scalar().to_bool()?;
+ let lt = this.binary_op(mir::BinOp::Lt, &old, &rhs)?.to_scalar().to_bool()?;
#[rustfmt::skip] // rustfmt makes this unreadable
let new_val = if min {
@@ -744,7 +743,7 @@
// Read as immediate for the sake of `binary_op()`
let old = this.allow_data_races_mut(|this| this.read_immediate(place))?;
// `binary_op` will bail if either of them is not a scalar.
- let eq = this.wrapping_binary_op(mir::BinOp::Eq, &old, expect_old)?;
+ let eq = this.binary_op(mir::BinOp::Eq, &old, expect_old)?;
// If the operation would succeed, but is "weak", fail some portion
// of the time, based on `success_rate`.
let success_rate = 1.0 - this.machine.cmpxchg_weak_failure_rate;
diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index 4050ae3..bd16038 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -126,7 +126,7 @@
// the one in the sysroot and the one locally built by `cargo test`.)
// FIXME: can we prefer the one from the sysroot?
'crates: for krate in
- tcx.crates(()).iter().filter(|&&krate| tcx.crate_name(krate).as_str() == crate_name)
+ tcx.used_crates(()).iter().filter(|&&krate| tcx.crate_name(krate).as_str() == crate_name)
{
let mut cur_item = DefId { krate: *krate, index: CRATE_DEF_INDEX };
// Go over the modules.
@@ -1365,7 +1365,7 @@
.map(|crates| crates.split(',').map(|krate| krate.to_string()).collect::<Vec<_>>())
.unwrap_or_default();
let mut local_crates = Vec::new();
- for &crate_num in tcx.crates(()) {
+ for &crate_num in tcx.crates_including_speculative(()) {
let name = tcx.crate_name(crate_num);
let name = name.as_str();
if local_crate_names.iter().any(|local_name| local_name == name) {
diff --git a/src/tools/miri/src/intrinsics/atomic.rs b/src/tools/miri/src/intrinsics/atomic.rs
index 501dbc1..0daf59c 100644
--- a/src/tools/miri/src/intrinsics/atomic.rs
+++ b/src/tools/miri/src/intrinsics/atomic.rs
@@ -4,8 +4,8 @@
use helpers::check_arg_count;
pub enum AtomicOp {
- /// The `bool` indicates whether the result of the operation should be negated
- /// (must be a boolean-typed operation).
+ /// The `bool` indicates whether the result of the operation should be negated (`UnOp::Not`,
+ /// must be a boolean-typed operation).
MirOp(mir::BinOp, bool),
Max,
Min,
@@ -213,8 +213,8 @@
this.write_immediate(*old, dest)?; // old value is returned
Ok(())
}
- AtomicOp::MirOp(op, neg) => {
- let old = this.atomic_rmw_op_immediate(&place, &rhs, op, neg, atomic)?;
+ AtomicOp::MirOp(op, not) => {
+ let old = this.atomic_rmw_op_immediate(&place, &rhs, op, not, atomic)?;
this.write_immediate(*old, dest)?; // old value is returned
Ok(())
}
diff --git a/src/tools/miri/src/intrinsics/mod.rs b/src/tools/miri/src/intrinsics/mod.rs
index 0a7927d..3e39376 100644
--- a/src/tools/miri/src/intrinsics/mod.rs
+++ b/src/tools/miri/src/intrinsics/mod.rs
@@ -43,18 +43,18 @@
if this.tcx.intrinsic(instance.def_id()).unwrap().must_be_overridden {
throw_unsup_format!("unimplemented intrinsic: `{intrinsic_name}`")
}
- let intrinsic_fallback_checks_ub = Symbol::intern("intrinsic_fallback_checks_ub");
+ let intrinsic_fallback_is_spec = Symbol::intern("intrinsic_fallback_is_spec");
if this
.tcx
.get_attrs_by_path(
instance.def_id(),
- &[sym::miri, intrinsic_fallback_checks_ub],
+ &[sym::miri, intrinsic_fallback_is_spec],
)
.next()
.is_none()
{
throw_unsup_format!(
- "miri can only use intrinsic fallback bodies that check UB. After verifying that `{intrinsic_name}` does so, add the `#[miri::intrinsic_fallback_checks_ub]` attribute to it; also ping @rust-lang/miri when you do that"
+ "Miri can only use intrinsic fallback bodies that exactly reflect the specification: they fully check for UB and are as non-deterministic as possible. After verifying that `{intrinsic_name}` does so, add the `#[miri::intrinsic_fallback_is_spec]` attribute to it; also ping @rust-lang/miri when you do that"
);
}
Ok(Some(ty::Instance {
@@ -365,8 +365,8 @@
"frem_algebraic" => mir::BinOp::Rem,
_ => bug!(),
};
- let res = this.wrapping_binary_op(op, &a, &b)?;
- // `wrapping_binary_op` already called `generate_nan` if necessary.
+ let res = this.binary_op(op, &a, &b)?;
+ // `binary_op` already called `generate_nan` if necessary.
this.write_immediate(*res, dest)?;
}
@@ -411,12 +411,12 @@
),
_ => {}
}
- let res = this.wrapping_binary_op(op, &a, &b)?;
+ let res = this.binary_op(op, &a, &b)?;
if !float_finite(&res)? {
throw_ub_format!("`{intrinsic_name}` intrinsic produced non-finite value as result");
}
// This cannot be a NaN so we also don't have to apply any non-determinism.
- // (Also, `wrapping_binary_op` already called `generate_nan` if needed.)
+ // (Also, `binary_op` already called `generate_nan` if needed.)
this.write_immediate(*res, dest)?;
}
diff --git a/src/tools/miri/src/intrinsics/simd.rs b/src/tools/miri/src/intrinsics/simd.rs
index e178187..67a2d56 100644
--- a/src/tools/miri/src/intrinsics/simd.rs
+++ b/src/tools/miri/src/intrinsics/simd.rs
@@ -1,3 +1,5 @@
+use either::Either;
+
use rustc_apfloat::{Float, Round};
use rustc_middle::ty::layout::{HasParamEnv, LayoutOf};
use rustc_middle::{mir, ty, ty::FloatTy};
@@ -82,7 +84,7 @@
let val = match which {
Op::MirOp(mir_op) => {
// This already does NaN adjustments
- this.wrapping_unary_op(mir_op, &op)?.to_scalar()
+ this.unary_op(mir_op, &op)?.to_scalar()
}
Op::Abs => {
// Works for f32 and f64.
@@ -217,8 +219,8 @@
"mul" => Op::MirOp(BinOp::Mul),
"div" => Op::MirOp(BinOp::Div),
"rem" => Op::MirOp(BinOp::Rem),
- "shl" => Op::MirOp(BinOp::Shl),
- "shr" => Op::MirOp(BinOp::Shr),
+ "shl" => Op::MirOp(BinOp::ShlUnchecked),
+ "shr" => Op::MirOp(BinOp::ShrUnchecked),
"and" => Op::MirOp(BinOp::BitAnd),
"or" => Op::MirOp(BinOp::BitOr),
"xor" => Op::MirOp(BinOp::BitXor),
@@ -243,15 +245,19 @@
let val = match which {
Op::MirOp(mir_op) => {
// This does NaN adjustments.
- let (val, overflowed) = this.overflowing_binary_op(mir_op, &left, &right)?;
- if matches!(mir_op, BinOp::Shl | BinOp::Shr) {
- // Shifts have extra UB as SIMD operations that the MIR binop does not have.
- // See <https://github.com/rust-lang/rust/issues/91237>.
- if overflowed {
- let r_val = right.to_scalar().to_bits(right.layout.size)?;
- throw_ub_format!("overflowing shift by {r_val} in `simd_{intrinsic_name}` in SIMD lane {i}");
+ let val = this.binary_op(mir_op, &left, &right).map_err(|err| {
+ match err.kind() {
+ InterpError::UndefinedBehavior(UndefinedBehaviorInfo::ShiftOverflow { shift_amount, .. }) => {
+ // This resets the interpreter backtrace, but it's not worth avoiding that.
+ let shift_amount = match shift_amount {
+ Either::Left(v) => v.to_string(),
+ Either::Right(v) => v.to_string(),
+ };
+ err_ub_format!("overflowing shift by {shift_amount} in `simd_{intrinsic_name}` in lane {i}").into()
+ }
+ _ => err
}
- }
+ })?;
if matches!(mir_op, BinOp::Eq | BinOp::Ne | BinOp::Lt | BinOp::Le | BinOp::Gt | BinOp::Ge) {
// Special handling for boolean-returning operations
assert_eq!(val.layout.ty, this.tcx.types.bool);
@@ -370,11 +376,11 @@
let op = this.read_immediate(&this.project_index(&op, i)?)?;
res = match which {
Op::MirOp(mir_op) => {
- this.wrapping_binary_op(mir_op, &res, &op)?
+ this.binary_op(mir_op, &res, &op)?
}
Op::MirOpBool(mir_op) => {
let op = imm_from_bool(simd_element_to_bool(op)?);
- this.wrapping_binary_op(mir_op, &res, &op)?
+ this.binary_op(mir_op, &res, &op)?
}
Op::MinMax(mmop) => {
if matches!(res.layout.ty.kind(), ty::Float(_)) {
@@ -385,7 +391,7 @@
MinMax::Min => BinOp::Le,
MinMax::Max => BinOp::Ge,
};
- if this.wrapping_binary_op(mirop, &res, &op)?.to_scalar().to_bool()? {
+ if this.binary_op(mirop, &res, &op)?.to_scalar().to_bool()? {
res
} else {
op
@@ -414,7 +420,7 @@
let mut res = init;
for i in 0..op_len {
let op = this.read_immediate(&this.project_index(&op, i)?)?;
- res = this.wrapping_binary_op(mir_op, &res, &op)?;
+ res = this.binary_op(mir_op, &res, &op)?;
}
this.write_immediate(*res, dest)?;
}
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index cbf02d7..0c6a256 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -1025,7 +1025,7 @@
bin_op: mir::BinOp,
left: &ImmTy<'tcx, Provenance>,
right: &ImmTy<'tcx, Provenance>,
- ) -> InterpResult<'tcx, (ImmTy<'tcx, Provenance>, bool)> {
+ ) -> InterpResult<'tcx, ImmTy<'tcx, Provenance>> {
ecx.binary_ptr_op(bin_op, left, right)
}
diff --git a/src/tools/miri/src/operator.rs b/src/tools/miri/src/operator.rs
index d99be39..7a00826 100644
--- a/src/tools/miri/src/operator.rs
+++ b/src/tools/miri/src/operator.rs
@@ -14,7 +14,7 @@
bin_op: mir::BinOp,
left: &ImmTy<'tcx, Provenance>,
right: &ImmTy<'tcx, Provenance>,
- ) -> InterpResult<'tcx, (ImmTy<'tcx, Provenance>, bool)> {
+ ) -> InterpResult<'tcx, ImmTy<'tcx, Provenance>> {
use rustc_middle::mir::BinOp::*;
let this = self.eval_context_ref();
@@ -45,7 +45,7 @@
Ge => left >= right,
_ => bug!(),
};
- (ImmTy::from_bool(res, *this.tcx), false)
+ ImmTy::from_bool(res, *this.tcx)
}
// Some more operations are possible with atomics.
@@ -60,16 +60,14 @@
right.to_scalar().to_target_usize(this)?,
this.machine.layouts.usize,
);
- let (result, overflowing) = this.overflowing_binary_op(bin_op, &left, &right)?;
+ let result = this.binary_op(bin_op, &left, &right)?;
// Construct a new pointer with the provenance of `ptr` (the LHS).
let result_ptr = Pointer::new(
ptr.provenance,
Size::from_bytes(result.to_scalar().to_target_usize(this)?),
);
- (
- ImmTy::from_scalar(Scalar::from_maybe_pointer(result_ptr, this), left.layout),
- overflowing,
- )
+
+ ImmTy::from_scalar(Scalar::from_maybe_pointer(result_ptr, this), left.layout)
}
_ => span_bug!(this.cur_span(), "Invalid operator on pointers: {:?}", bin_op),
diff --git a/src/tools/miri/src/shims/x86/mod.rs b/src/tools/miri/src/shims/x86/mod.rs
index 48b7222..74c2b0c 100644
--- a/src/tools/miri/src/shims/x86/mod.rs
+++ b/src/tools/miri/src/shims/x86/mod.rs
@@ -50,13 +50,16 @@
let a = this.read_immediate(a)?;
let b = this.read_immediate(b)?;
- let (sum, overflow1) = this.overflowing_binary_op(mir::BinOp::Add, &a, &b)?;
- let (sum, overflow2) = this.overflowing_binary_op(
- mir::BinOp::Add,
- &sum,
- &ImmTy::from_uint(c_in, a.layout),
- )?;
- let c_out = overflow1 | overflow2;
+ let (sum, overflow1) =
+ this.binary_op(mir::BinOp::AddWithOverflow, &a, &b)?.to_pair(this);
+ let (sum, overflow2) = this
+ .binary_op(
+ mir::BinOp::AddWithOverflow,
+ &sum,
+ &ImmTy::from_uint(c_in, a.layout),
+ )?
+ .to_pair(this);
+ let c_out = overflow1.to_scalar().to_bool()? | overflow2.to_scalar().to_bool()?;
this.write_scalar(Scalar::from_u8(c_out.into()), &this.project_field(dest, 0)?)?;
this.write_immediate(*sum, &this.project_field(dest, 1)?)?;
@@ -76,13 +79,11 @@
let a = this.read_immediate(a)?;
let b = this.read_immediate(b)?;
- let (sub, overflow1) = this.overflowing_binary_op(mir::BinOp::Sub, &a, &b)?;
- let (sub, overflow2) = this.overflowing_binary_op(
- mir::BinOp::Sub,
- &sub,
- &ImmTy::from_uint(b_in, a.layout),
- )?;
- let b_out = overflow1 | overflow2;
+ let (sub, overflow1) = this.binary_op(mir::BinOp::SubWithOverflow, &a, &b)?.to_pair(this);
+ let (sub, overflow2) = this
+ .binary_op(mir::BinOp::SubWithOverflow, &sub, &ImmTy::from_uint(b_in, a.layout))?
+ .to_pair(this);
+ let b_out = overflow1.to_scalar().to_bool()? | overflow2.to_scalar().to_bool()?;
this.write_scalar(Scalar::from_u8(b_out.into()), &this.project_field(dest, 0)?)?;
this.write_immediate(*sub, &this.project_field(dest, 1)?)?;
@@ -245,7 +246,7 @@
) -> InterpResult<'tcx, Scalar<Provenance>> {
match which {
FloatBinOp::Arith(which) => {
- let res = this.wrapping_binary_op(which, left, right)?;
+ let res = this.binary_op(which, left, right)?;
Ok(res.to_scalar())
}
FloatBinOp::Cmp { gt, lt, eq, unord } => {
@@ -744,12 +745,9 @@
let op = this.read_immediate(&this.project_index(&op, i)?)?;
let dest = this.project_index(&dest, i)?;
- let lt_zero = this.wrapping_binary_op(mir::BinOp::Lt, &op, &zero)?;
- let res = if lt_zero.to_scalar().to_bool()? {
- this.wrapping_unary_op(mir::UnOp::Neg, &op)?
- } else {
- op
- };
+ let lt_zero = this.binary_op(mir::BinOp::Lt, &op, &zero)?;
+ let res =
+ if lt_zero.to_scalar().to_bool()? { this.unary_op(mir::UnOp::Neg, &op)? } else { op };
this.write_immediate(*res, &dest)?;
}
@@ -832,7 +830,7 @@
let res = if saturating {
Immediate::from(this.saturating_arith(which, &lhs, &rhs)?)
} else {
- *this.wrapping_binary_op(which, &lhs, &rhs)?
+ *this.binary_op(which, &lhs, &rhs)?
};
this.write_immediate(res, &this.project_index(&dest, j)?)?;
@@ -884,8 +882,8 @@
let left = this.read_immediate(&this.project_index(&left, j)?)?;
let right = this.read_immediate(&this.project_index(&right, j)?)?;
- let mul = this.wrapping_binary_op(mir::BinOp::Mul, &left, &right)?;
- sum = this.wrapping_binary_op(mir::BinOp::Add, &sum, &mul)?;
+ let mul = this.binary_op(mir::BinOp::Mul, &left, &right)?;
+ sum = this.binary_op(mir::BinOp::Add, &sum, &mul)?;
}
}
@@ -1276,11 +1274,8 @@
let left = this.read_immediate(&this.project_index(&left, i)?)?;
let right = this.read_scalar(&this.project_index(&right, i)?)?.to_int(dest.layout.size)?;
- let res = this.wrapping_binary_op(
- mir::BinOp::Mul,
- &left,
- &ImmTy::from_int(right.signum(), dest.layout),
- )?;
+ let res =
+ this.binary_op(mir::BinOp::Mul, &left, &ImmTy::from_int(right.signum(), dest.layout))?;
this.write_immediate(*res, &dest)?;
}
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/intrinsic_fallback_checks_ub.stderr b/src/tools/miri/tests/fail/intrinsic_fallback_checks_ub.stderr
deleted file mode 100644
index 699dda5..0000000
--- a/src/tools/miri/tests/fail/intrinsic_fallback_checks_ub.stderr
+++ /dev/null
@@ -1,14 +0,0 @@
-error: unsupported operation: miri can only use intrinsic fallback bodies that check UB. After verifying that `ptr_guaranteed_cmp` does so, add the `#[miri::intrinsic_fallback_checks_ub]` attribute to it; also ping @rust-lang/miri when you do that
- --> $DIR/intrinsic_fallback_checks_ub.rs:LL:CC
- |
-LL | ptr_guaranteed_cmp::<()>(std::ptr::null(), std::ptr::null());
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ miri can only use intrinsic fallback bodies that check UB. After verifying that `ptr_guaranteed_cmp` does so, add the `#[miri::intrinsic_fallback_checks_ub]` attribute to it; also ping @rust-lang/miri when you do that
- |
- = help: this is likely not a bug in the program; it indicates that the program performed an operation that Miri does not support
- = note: BACKTRACE:
- = note: inside `main` at $DIR/intrinsic_fallback_checks_ub.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/intrinsic_fallback_checks_ub.rs b/src/tools/miri/tests/fail/intrinsic_fallback_is_spec.rs
similarity index 75%
rename from src/tools/miri/tests/fail/intrinsic_fallback_checks_ub.rs
rename to src/tools/miri/tests/fail/intrinsic_fallback_is_spec.rs
index 93c9d3d..888c548 100644
--- a/src/tools/miri/tests/fail/intrinsic_fallback_checks_ub.rs
+++ b/src/tools/miri/tests/fail/intrinsic_fallback_is_spec.rs
@@ -10,5 +10,5 @@
fn main() {
ptr_guaranteed_cmp::<()>(std::ptr::null(), std::ptr::null());
- //~^ ERROR: can only use intrinsic fallback bodies that check UB.
+ //~^ ERROR: can only use intrinsic fallback bodies that exactly reflect the specification
}
diff --git a/src/tools/miri/tests/fail/intrinsic_fallback_is_spec.stderr b/src/tools/miri/tests/fail/intrinsic_fallback_is_spec.stderr
new file mode 100644
index 0000000..db3941a
--- /dev/null
+++ b/src/tools/miri/tests/fail/intrinsic_fallback_is_spec.stderr
@@ -0,0 +1,14 @@
+error: unsupported operation: Miri can only use intrinsic fallback bodies that exactly reflect the specification: they fully check for UB and are as non-deterministic as possible. After verifying that `ptr_guaranteed_cmp` does so, add the `#[miri::intrinsic_fallback_is_spec]` attribute to it; also ping @rust-lang/miri when you do that
+ --> $DIR/intrinsic_fallback_is_spec.rs:LL:CC
+ |
+LL | ptr_guaranteed_cmp::<()>(std::ptr::null(), std::ptr::null());
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Miri can only use intrinsic fallback bodies that exactly reflect the specification: they fully check for UB and are as non-deterministic as possible. After verifying that `ptr_guaranteed_cmp` does so, add the `#[miri::intrinsic_fallback_is_spec]` attribute to it; also ping @rust-lang/miri when you do that
+ |
+ = help: this is likely not a bug in the program; it indicates that the program performed an operation that Miri does not support
+ = note: BACKTRACE:
+ = note: inside `main` at $DIR/intrinsic_fallback_is_spec.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/simd-shl-too-far.rs b/src/tools/miri/tests/fail/intrinsics/simd-shl-too-far.rs
index 8a49c84..12aa7c10 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-shl-too-far.rs
+++ b/src/tools/miri/tests/fail/intrinsics/simd-shl-too-far.rs
@@ -10,6 +10,6 @@
unsafe {
let x = i32x2(1, 1);
let y = i32x2(100, 0);
- simd_shl(x, y); //~ERROR: overflowing shift by 100 in `simd_shl` in SIMD lane 0
+ simd_shl(x, y); //~ERROR: overflowing shift by 100 in `simd_shl` in lane 0
}
}
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-shl-too-far.stderr b/src/tools/miri/tests/fail/intrinsics/simd-shl-too-far.stderr
index 3a4ec00..475067d 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-shl-too-far.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-shl-too-far.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: overflowing shift by 100 in `simd_shl` in SIMD lane 0
+error: Undefined Behavior: overflowing shift by 100 in `simd_shl` in lane 0
--> $DIR/simd-shl-too-far.rs:LL:CC
|
LL | simd_shl(x, y);
- | ^^^^^^^^^^^^^^ overflowing shift by 100 in `simd_shl` in SIMD lane 0
+ | ^^^^^^^^^^^^^^ overflowing shift by 100 in `simd_shl` in lane 0
|
= 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
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-shr-too-far.rs b/src/tools/miri/tests/fail/intrinsics/simd-shr-too-far.rs
index 433998c..ada7cf4 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-shr-too-far.rs
+++ b/src/tools/miri/tests/fail/intrinsics/simd-shr-too-far.rs
@@ -10,6 +10,6 @@
unsafe {
let x = i32x2(1, 1);
let y = i32x2(20, 40);
- simd_shr(x, y); //~ERROR: overflowing shift by 40 in `simd_shr` in SIMD lane 1
+ simd_shr(x, y); //~ERROR: overflowing shift by 40 in `simd_shr` in lane 1
}
}
diff --git a/src/tools/miri/tests/fail/intrinsics/simd-shr-too-far.stderr b/src/tools/miri/tests/fail/intrinsics/simd-shr-too-far.stderr
index 07636b8..0d63078 100644
--- a/src/tools/miri/tests/fail/intrinsics/simd-shr-too-far.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/simd-shr-too-far.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: overflowing shift by 40 in `simd_shr` in SIMD lane 1
+error: Undefined Behavior: overflowing shift by 40 in `simd_shr` in lane 1
--> $DIR/simd-shr-too-far.rs:LL:CC
|
LL | simd_shr(x, y);
- | ^^^^^^^^^^^^^^ overflowing shift by 40 in `simd_shr` in SIMD lane 1
+ | ^^^^^^^^^^^^^^ overflowing shift by 40 in `simd_shr` in lane 1
|
= 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
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_add1.rs b/src/tools/miri/tests/fail/intrinsics/unchecked_add1.rs
index 3f8b4e5..0ed758d 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_add1.rs
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_add1.rs
@@ -1,4 +1,4 @@
fn main() {
// MAX overflow
- let _val = unsafe { 40000u16.unchecked_add(30000) }; //~ ERROR: overflow executing `unchecked_add`
+ let _val = unsafe { 40000u16.unchecked_add(30000) }; //~ ERROR: arithmetic overflow in `unchecked_add`
}
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_add1.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_add1.stderr
index 922de42..eae9ec7 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_add1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_add1.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: overflow executing `unchecked_add`
+error: Undefined Behavior: arithmetic overflow in `unchecked_add`
--> $DIR/unchecked_add1.rs:LL:CC
|
LL | let _val = unsafe { 40000u16.unchecked_add(30000) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ overflow executing `unchecked_add`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ arithmetic overflow in `unchecked_add`
|
= 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
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_add2.rs b/src/tools/miri/tests/fail/intrinsics/unchecked_add2.rs
index 3283dbf..3b49520 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_add2.rs
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_add2.rs
@@ -1,4 +1,4 @@
fn main() {
// MIN overflow
- let _val = unsafe { (-30000i16).unchecked_add(-8000) }; //~ ERROR: overflow executing `unchecked_add`
+ let _val = unsafe { (-30000i16).unchecked_add(-8000) }; //~ ERROR: arithmetic overflow in `unchecked_add`
}
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_add2.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_add2.stderr
index 05456ea..6a0dcfc 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_add2.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_add2.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: overflow executing `unchecked_add`
+error: Undefined Behavior: arithmetic overflow in `unchecked_add`
--> $DIR/unchecked_add2.rs:LL:CC
|
LL | let _val = unsafe { (-30000i16).unchecked_add(-8000) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ overflow executing `unchecked_add`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ arithmetic overflow in `unchecked_add`
|
= 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
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_mul1.rs b/src/tools/miri/tests/fail/intrinsics/unchecked_mul1.rs
index 2feed77..3dc83a2 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_mul1.rs
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_mul1.rs
@@ -1,4 +1,4 @@
fn main() {
// MAX overflow
- let _val = unsafe { 300u16.unchecked_mul(250u16) }; //~ ERROR: overflow executing `unchecked_mul`
+ let _val = unsafe { 300u16.unchecked_mul(250u16) }; //~ ERROR: arithmetic overflow in `unchecked_mul`
}
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_mul1.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_mul1.stderr
index 533beaa..e37d982 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_mul1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_mul1.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: overflow executing `unchecked_mul`
+error: Undefined Behavior: arithmetic overflow in `unchecked_mul`
--> $DIR/unchecked_mul1.rs:LL:CC
|
LL | let _val = unsafe { 300u16.unchecked_mul(250u16) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ overflow executing `unchecked_mul`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ arithmetic overflow in `unchecked_mul`
|
= 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
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_mul2.rs b/src/tools/miri/tests/fail/intrinsics/unchecked_mul2.rs
index 42cd509..49cd293 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_mul2.rs
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_mul2.rs
@@ -1,4 +1,4 @@
fn main() {
// MIN overflow
- let _val = unsafe { 1_000_000_000i32.unchecked_mul(-4) }; //~ ERROR: overflow executing `unchecked_mul`
+ let _val = unsafe { 1_000_000_000i32.unchecked_mul(-4) }; //~ ERROR: arithmetic overflow in `unchecked_mul`
}
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_mul2.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_mul2.stderr
index 4c6bae6..949077c 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_mul2.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_mul2.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: overflow executing `unchecked_mul`
+error: Undefined Behavior: arithmetic overflow in `unchecked_mul`
--> $DIR/unchecked_mul2.rs:LL:CC
|
LL | let _val = unsafe { 1_000_000_000i32.unchecked_mul(-4) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ overflow executing `unchecked_mul`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ arithmetic overflow in `unchecked_mul`
|
= 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
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_sub1.rs b/src/tools/miri/tests/fail/intrinsics/unchecked_sub1.rs
index e5178bf..f24c974 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_sub1.rs
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_sub1.rs
@@ -1,4 +1,4 @@
fn main() {
// MIN overflow
- let _val = unsafe { 14u32.unchecked_sub(22) }; //~ ERROR: overflow executing `unchecked_sub`
+ let _val = unsafe { 14u32.unchecked_sub(22) }; //~ ERROR: arithmetic overflow in `unchecked_sub`
}
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_sub1.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_sub1.stderr
index 72187e2..39bfd8a 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_sub1.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_sub1.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: overflow executing `unchecked_sub`
+error: Undefined Behavior: arithmetic overflow in `unchecked_sub`
--> $DIR/unchecked_sub1.rs:LL:CC
|
LL | let _val = unsafe { 14u32.unchecked_sub(22) };
- | ^^^^^^^^^^^^^^^^^^^^^^^ overflow executing `unchecked_sub`
+ | ^^^^^^^^^^^^^^^^^^^^^^^ arithmetic overflow in `unchecked_sub`
|
= 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
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_sub2.rs b/src/tools/miri/tests/fail/intrinsics/unchecked_sub2.rs
index ac9fd1e..74b08b1 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_sub2.rs
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_sub2.rs
@@ -1,4 +1,4 @@
fn main() {
// MAX overflow
- let _val = unsafe { 30000i16.unchecked_sub(-7000) }; //~ ERROR: overflow executing `unchecked_sub`
+ let _val = unsafe { 30000i16.unchecked_sub(-7000) }; //~ ERROR: arithmetic overflow in `unchecked_sub`
}
diff --git a/src/tools/miri/tests/fail/intrinsics/unchecked_sub2.stderr b/src/tools/miri/tests/fail/intrinsics/unchecked_sub2.stderr
index ec28384..604eba9 100644
--- a/src/tools/miri/tests/fail/intrinsics/unchecked_sub2.stderr
+++ b/src/tools/miri/tests/fail/intrinsics/unchecked_sub2.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: overflow executing `unchecked_sub`
+error: Undefined Behavior: arithmetic overflow in `unchecked_sub`
--> $DIR/unchecked_sub2.rs:LL:CC
|
LL | let _val = unsafe { 30000i16.unchecked_sub(-7000) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ overflow executing `unchecked_sub`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ arithmetic overflow in `unchecked_sub`
|
= 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
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/src/tools/run-make-support/src/cc.rs b/src/tools/run-make-support/src/cc.rs
index a67f5c8..799c36b 100644
--- a/src/tools/run-make-support/src/cc.rs
+++ b/src/tools/run-make-support/src/cc.rs
@@ -45,6 +45,14 @@
self
}
+ /// Adds directories to the list that the linker searches for libraries.
+ /// Equivalent to `-L`.
+ pub fn library_search_path<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
+ self.cmd.arg("-L");
+ self.cmd.arg(path.as_ref());
+ self
+ }
+
/// Specify `-o` or `-Fe`/`-Fo` depending on platform/compiler. This assumes that the executable
/// is under `$TMPDIR`.
pub fn out_exe(&mut self, name: &str) -> &mut Self {
diff --git a/src/tools/run-make-support/src/rustc.rs b/src/tools/run-make-support/src/rustc.rs
index f581204..1c83b63 100644
--- a/src/tools/run-make-support/src/rustc.rs
+++ b/src/tools/run-make-support/src/rustc.rs
@@ -156,13 +156,20 @@
self
}
- /// Add a directory to the library search path. Equivalent to `-L`` in rustc.
+ /// Add a directory to the library search path. Equivalent to `-L` in rustc.
pub fn library_search_path<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
self.cmd.arg("-L");
self.cmd.arg(path.as_ref());
self
}
+ /// Override the system root. Equivalent to `--sysroot` in rustc.
+ pub fn sysroot<P: AsRef<Path>>(&mut self, path: P) -> &mut Self {
+ self.cmd.arg("--sysroot");
+ self.cmd.arg(path.as_ref());
+ self
+ }
+
/// Specify the edition year.
pub fn edition(&mut self, edition: &str) -> &mut Self {
self.cmd.arg("--edition");
diff --git a/src/tools/tidy/src/allowed_run_make_makefiles.txt b/src/tools/tidy/src/allowed_run_make_makefiles.txt
index 96fb8e2..ad900ce 100644
--- a/src/tools/tidy/src/allowed_run_make_makefiles.txt
+++ b/src/tools/tidy/src/allowed_run_make_makefiles.txt
@@ -25,7 +25,6 @@
run-make/compressed-debuginfo/Makefile
run-make/const-prop-lint/Makefile
run-make/const_fn_mir/Makefile
-run-make/core-no-oom-handling/Makefile
run-make/crate-data-smoke/Makefile
run-make/crate-hash-rustc-version/Makefile
run-make/crate-name-priority/Makefile
@@ -98,24 +97,19 @@
run-make/issue-18943/Makefile
run-make/issue-20626/Makefile
run-make/issue-22131/Makefile
-run-make/issue-24445/Makefile
run-make/issue-25581/Makefile
run-make/issue-26006/Makefile
run-make/issue-26092/Makefile
run-make/issue-28595/Makefile
-run-make/issue-30063/Makefile
run-make/issue-33329/Makefile
run-make/issue-35164/Makefile
run-make/issue-36710/Makefile
run-make/issue-37839/Makefile
run-make/issue-37893/Makefile
-run-make/issue-38237/Makefile
run-make/issue-40535/Makefile
-run-make/issue-46239/Makefile
run-make/issue-47384/Makefile
run-make/issue-47551/Makefile
run-make/issue-51671/Makefile
-run-make/issue-53964/Makefile
run-make/issue-64153/Makefile
run-make/issue-68794-textrel-on-minimal-lib/Makefile
run-make/issue-69368/Makefile
@@ -233,10 +227,8 @@
run-make/rmeta-preferred/Makefile
run-make/rustc-macro-dep-files/Makefile
run-make/rustdoc-io-error/Makefile
-run-make/rustdoc-scrape-examples-macros/Makefile
run-make/rustdoc-verify-output-files/Makefile
run-make/rustdoc-with-output-option/Makefile
-run-make/rustdoc-with-short-out-dir-option/Makefile
run-make/sanitizer-cdylib-link/Makefile
run-make/sanitizer-dylib-link/Makefile
run-make/sanitizer-staticlib-link/Makefile
diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index 6b8106b..881b4f8 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -3988,8 +3988,6 @@
ui/test-attrs/issue-53675-a-test-called-panic.rs
ui/threads-sendsync/issue-24313.rs
ui/threads-sendsync/issue-29488.rs
-ui/threads-sendsync/issue-43733-2.rs
-ui/threads-sendsync/issue-43733.rs
ui/threads-sendsync/issue-4446.rs
ui/threads-sendsync/issue-4448.rs
ui/threads-sendsync/issue-8827.rs
diff --git a/src/tools/tidy/src/style.rs b/src/tools/tidy/src/style.rs
index 9cabab5..64cc227 100644
--- a/src/tools/tidy/src/style.rs
+++ b/src/tools/tidy/src/style.rs
@@ -243,7 +243,7 @@
if parent.file_name().map_or_else(
|| false,
|f| {
- f.to_string_lossy() == folder_to_find
+ f == folder_to_find
&& parent
.parent()
.and_then(|f| f.file_name())
diff --git a/tests/codegen/noalias-freeze.rs b/tests/codegen/noalias-freeze.rs
new file mode 100644
index 0000000..8086f3a
--- /dev/null
+++ b/tests/codegen/noalias-freeze.rs
@@ -0,0 +1,21 @@
+//@ compile-flags: -Copt-level=1
+
+// References returned by a Frozen pointer type
+// could be marked as "noalias", which caused miscompilation errors.
+// This test runs the most minimal possible code that can reproduce this bug,
+// and checks that noalias does not appear.
+// See https://github.com/rust-lang/rust/issues/46239
+
+#![crate_type = "lib"]
+
+fn project<T>(x: &(T,)) -> &T { &x.0 }
+
+fn dummy() {}
+
+// CHECK-LABEL: @foo(
+// CHECK-NOT: noalias
+#[no_mangle]
+pub fn foo() {
+ let f = (dummy as fn(),);
+ (*project(&f))();
+}
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/crashes/124348.rs b/tests/crashes/124348.rs
deleted file mode 100644
index 554f383..0000000
--- a/tests/crashes/124348.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-//@ known-bug: #124348
-enum Eek {
- TheConst,
- UnusedByTheConst(Sum),
-}
-
-const EEK_ZERO: &[Eek] = &[];
diff --git a/tests/run-make/alloc-no-oom-handling/rmake.rs b/tests/run-make/alloc-no-oom-handling/rmake.rs
index fec3c65..4bca5d1 100644
--- a/tests/run-make/alloc-no-oom-handling/rmake.rs
+++ b/tests/run-make/alloc-no-oom-handling/rmake.rs
@@ -1,4 +1,4 @@
-// This test checks that alloc can still compile correctly
+// This test checks that alloc can still compile successfully
// when the unstable no_global_oom_handling feature is turned on.
// See https://github.com/rust-lang/rust/pull/84266
diff --git a/tests/run-make/alloc-no-rc/rmake.rs b/tests/run-make/alloc-no-rc/rmake.rs
index c5744a3..8ff7332 100644
--- a/tests/run-make/alloc-no-rc/rmake.rs
+++ b/tests/run-make/alloc-no-rc/rmake.rs
@@ -1,4 +1,4 @@
-// This test checks that alloc can still compile correctly
+// This test checks that alloc can still compile successfully
// when the unstable no_rc feature is turned on.
// See https://github.com/rust-lang/rust/pull/84266
diff --git a/tests/run-make/alloc-no-sync/rmake.rs b/tests/run-make/alloc-no-sync/rmake.rs
index 6410eca..3a3ceed 100644
--- a/tests/run-make/alloc-no-sync/rmake.rs
+++ b/tests/run-make/alloc-no-sync/rmake.rs
@@ -1,4 +1,4 @@
-// This test checks that alloc can still compile correctly
+// This test checks that alloc can still compile successfully
// when the unstable no_sync feature is turned on.
// See https://github.com/rust-lang/rust/pull/84266
diff --git a/tests/run-make/core-no-oom-handling/Makefile b/tests/run-make/core-no-oom-handling/Makefile
deleted file mode 100644
index 28c5261..0000000
--- a/tests/run-make/core-no-oom-handling/Makefile
+++ /dev/null
@@ -1,6 +0,0 @@
-include ../tools.mk
-
-FAKEROOT=$(TMPDIR)/fakeroot
-
-all:
- $(RUSTC) --edition=2021 -Dwarnings --crate-type=rlib ../../../library/core/src/lib.rs --sysroot=$(FAKEROOT) --cfg no_global_oom_handling
diff --git a/tests/run-make/core-no-oom-handling/rmake.rs b/tests/run-make/core-no-oom-handling/rmake.rs
new file mode 100644
index 0000000..7576742
--- /dev/null
+++ b/tests/run-make/core-no-oom-handling/rmake.rs
@@ -0,0 +1,16 @@
+// This test checks that the core library can still compile successfully
+// when the no_global_oom_handling feature is turned on.
+// See https://github.com/rust-lang/rust/pull/110649
+
+use run_make_support::{rustc, tmp_dir};
+
+fn main() {
+ rustc()
+ .edition("2021")
+ .arg("-Dwarnings")
+ .crate_type("rlib")
+ .input("../../../library/core/src/lib.rs")
+ .sysroot(tmp_dir().join("fakeroot"))
+ .cfg("no_global_oom_handling")
+ .run();
+}
diff --git a/tests/run-make/issue-38237/bar.rs b/tests/run-make/deref-impl-rustdoc-ice/bar.rs
similarity index 100%
rename from tests/run-make/issue-38237/bar.rs
rename to tests/run-make/deref-impl-rustdoc-ice/bar.rs
diff --git a/tests/run-make/issue-38237/baz.rs b/tests/run-make/deref-impl-rustdoc-ice/baz.rs
similarity index 100%
rename from tests/run-make/issue-38237/baz.rs
rename to tests/run-make/deref-impl-rustdoc-ice/baz.rs
diff --git a/tests/run-make/issue-38237/foo.rs b/tests/run-make/deref-impl-rustdoc-ice/foo.rs
similarity index 100%
rename from tests/run-make/issue-38237/foo.rs
rename to tests/run-make/deref-impl-rustdoc-ice/foo.rs
diff --git a/tests/run-make/deref-impl-rustdoc-ice/rmake.rs b/tests/run-make/deref-impl-rustdoc-ice/rmake.rs
new file mode 100644
index 0000000..c2156de
--- /dev/null
+++ b/tests/run-make/deref-impl-rustdoc-ice/rmake.rs
@@ -0,0 +1,16 @@
+// A very specific set of circumstances (mainly, implementing Deref, and
+// having a procedural macro and a Debug derivation in external crates) caused
+// an internal compiler error (ICE) when trying to use rustdoc. This test
+// reproduces the exact circumstances which caused the bug and checks
+// that it does not happen again.
+// See https://github.com/rust-lang/rust/issues/38237
+
+//@ ignore-cross-compile
+
+use run_make_support::{rustc, rustdoc, tmp_dir};
+
+fn main() {
+ rustc().input("foo.rs").run();
+ rustc().input("bar.rs").run();
+ rustdoc().input("baz.rs").library_search_path(tmp_dir()).output(tmp_dir()).run();
+}
diff --git a/tests/run-make/issue-53964/app.rs b/tests/run-make/external-crate-panic-handle-no-lint/app.rs
similarity index 100%
rename from tests/run-make/issue-53964/app.rs
rename to tests/run-make/external-crate-panic-handle-no-lint/app.rs
diff --git a/tests/run-make/issue-53964/panic.rs b/tests/run-make/external-crate-panic-handle-no-lint/panic.rs
similarity index 100%
rename from tests/run-make/issue-53964/panic.rs
rename to tests/run-make/external-crate-panic-handle-no-lint/panic.rs
diff --git a/tests/run-make/external-crate-panic-handle-no-lint/rmake.rs b/tests/run-make/external-crate-panic-handle-no-lint/rmake.rs
new file mode 100644
index 0000000..de40232
--- /dev/null
+++ b/tests/run-make/external-crate-panic-handle-no-lint/rmake.rs
@@ -0,0 +1,12 @@
+// Defining a crate that provides panic handling as an external crate
+// could uselessly trigger the "unused external crate" lint. In this test,
+// if the lint is triggered, it will trip #![deny(unused_extern_crates)],
+// and cause the test to fail.
+// See https://github.com/rust-lang/rust/issues/53964
+
+use run_make_support::{rustc, tmp_dir};
+
+fn main() {
+ rustc().input("panic.rs").run();
+ rustc().input("app.rs").panic("abort").emit("obj").library_search_path(tmp_dir()).run();
+}
diff --git a/tests/run-make/issue-24445/Makefile b/tests/run-make/issue-24445/Makefile
deleted file mode 100644
index a13910a..0000000
--- a/tests/run-make/issue-24445/Makefile
+++ /dev/null
@@ -1,11 +0,0 @@
-# ignore-cross-compile
-include ../tools.mk
-
-# only-linux
-
-all:
- $(RUSTC) foo.rs
- $(CC) foo.c -lfoo -L $(TMPDIR) -Wl,--gc-sections -lpthread -ldl -o $(TMPDIR)/foo
- $(call RUN,foo)
- $(CC) foo.c -lfoo -L $(TMPDIR) -Wl,--gc-sections -lpthread -ldl -pie -fPIC -o $(TMPDIR)/foo
- $(call RUN,foo)
diff --git a/tests/run-make/issue-30063/Makefile b/tests/run-make/issue-30063/Makefile
deleted file mode 100644
index 8a69ca7..0000000
--- a/tests/run-make/issue-30063/Makefile
+++ /dev/null
@@ -1,36 +0,0 @@
-# ignore-cross-compile
-include ../tools.mk
-
-all:
- rm -f $(TMPDIR)/foo-output
- $(RUSTC) -C codegen-units=4 -o $(TMPDIR)/foo-output foo.rs
- rm $(TMPDIR)/foo-output
-
- rm -f $(TMPDIR)/asm-output
- $(RUSTC) -C codegen-units=4 --emit=asm -o $(TMPDIR)/asm-output foo.rs
- rm $(TMPDIR)/asm-output
-
- rm -f $(TMPDIR)/bc-output
- $(RUSTC) -C codegen-units=4 --emit=llvm-bc -o $(TMPDIR)/bc-output foo.rs
- rm $(TMPDIR)/bc-output
-
- rm -f $(TMPDIR)/ir-output
- $(RUSTC) -C codegen-units=4 --emit=llvm-ir -o $(TMPDIR)/ir-output foo.rs
- rm $(TMPDIR)/ir-output
-
- rm -f $(TMPDIR)/link-output
- $(RUSTC) -C codegen-units=4 --emit=link -o $(TMPDIR)/link-output foo.rs
- rm $(TMPDIR)/link-output
-
- rm -f $(TMPDIR)/obj-output
- $(RUSTC) -C codegen-units=4 --emit=obj -o $(TMPDIR)/obj-output foo.rs
- rm $(TMPDIR)/obj-output
-
- rm -f $(TMPDIR)/dep-output
- $(RUSTC) -C codegen-units=4 --emit=dep-info -o $(TMPDIR)/dep-output foo.rs
- rm $(TMPDIR)/dep-output
-
-# # (This case doesn't work yet, and may be fundamentally wrong-headed anyway.)
-# rm -f $(TMPDIR)/multi-output
-# $(RUSTC) -C codegen-units=4 --emit=asm,obj -o $(TMPDIR)/multi-output foo.rs
-# rm $(TMPDIR)/multi-output
diff --git a/tests/run-make/issue-38237/Makefile b/tests/run-make/issue-38237/Makefile
deleted file mode 100644
index 80dddc5..0000000
--- a/tests/run-make/issue-38237/Makefile
+++ /dev/null
@@ -1,6 +0,0 @@
-# ignore-cross-compile
-include ../tools.mk
-
-all:
- $(RUSTC) foo.rs; $(RUSTC) bar.rs
- $(RUSTDOC) baz.rs -L $(TMPDIR) -o $(TMPDIR)
diff --git a/tests/run-make/issue-46239/Makefile b/tests/run-make/issue-46239/Makefile
deleted file mode 100644
index 0006ced..0000000
--- a/tests/run-make/issue-46239/Makefile
+++ /dev/null
@@ -1,6 +0,0 @@
-# ignore-cross-compile
-include ../tools.mk
-
-all:
- $(RUSTC) main.rs -C opt-level=1
- $(call RUN,main)
diff --git a/tests/run-make/issue-46239/main.rs b/tests/run-make/issue-46239/main.rs
deleted file mode 100644
index b7df5cf..0000000
--- a/tests/run-make/issue-46239/main.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-fn project<T>(x: &(T,)) -> &T { &x.0 }
-
-fn dummy() {}
-
-fn main() {
- let f = (dummy as fn(),);
- (*project(&f))();
-}
diff --git a/tests/run-make/issue-53964/Makefile b/tests/run-make/issue-53964/Makefile
deleted file mode 100644
index 6bd8302..0000000
--- a/tests/run-make/issue-53964/Makefile
+++ /dev/null
@@ -1,5 +0,0 @@
-include ../tools.mk
-
-all:
- $(RUSTC) panic.rs
- $(RUSTC) -C panic=abort --emit=obj app.rs -L $(TMPDIR)
diff --git a/tests/run-make/issue-24445/foo.c b/tests/run-make/non-pie-thread-local/foo.c
similarity index 100%
rename from tests/run-make/issue-24445/foo.c
rename to tests/run-make/non-pie-thread-local/foo.c
diff --git a/tests/run-make/issue-24445/foo.rs b/tests/run-make/non-pie-thread-local/foo.rs
similarity index 100%
rename from tests/run-make/issue-24445/foo.rs
rename to tests/run-make/non-pie-thread-local/foo.rs
diff --git a/tests/run-make/non-pie-thread-local/rmake.rs b/tests/run-make/non-pie-thread-local/rmake.rs
new file mode 100644
index 0000000..1ef447e
--- /dev/null
+++ b/tests/run-make/non-pie-thread-local/rmake.rs
@@ -0,0 +1,34 @@
+// It was once required to use a position-independent executable (PIE)
+// in order to use the thread_local! macro, or some symbols would contain
+// a NULL address. This was fixed, and this test checks a non-PIE, then a PIE
+// build to see if this bug makes a resurgence.
+// See https://github.com/rust-lang/rust/pull/24448
+
+//@ ignore-cross-compile
+//@ only-linux
+
+use run_make_support::{cc, run, rustc, tmp_dir};
+
+fn main() {
+ rustc().input("foo.rs").run();
+ cc().input("foo.c")
+ .arg("-lfoo")
+ .library_search_path(tmp_dir())
+ .arg("-Wl,--gc-sections")
+ .arg("-lpthread")
+ .arg("-ldl")
+ .out_exe("foo")
+ .run();
+ run("foo");
+ cc().input("foo.c")
+ .arg("-lfoo")
+ .library_search_path(tmp_dir())
+ .arg("-Wl,--gc-sections")
+ .arg("-lpthread")
+ .arg("-ldl")
+ .arg("-pie")
+ .arg("-fPIC")
+ .out_exe("foo")
+ .run();
+ run("foo");
+}
diff --git a/tests/run-make/issue-30063/foo.rs b/tests/run-make/reset-codegen-1/foo.rs
similarity index 100%
rename from tests/run-make/issue-30063/foo.rs
rename to tests/run-make/reset-codegen-1/foo.rs
diff --git a/tests/run-make/reset-codegen-1/rmake.rs b/tests/run-make/reset-codegen-1/rmake.rs
new file mode 100644
index 0000000..4b91ba7
--- /dev/null
+++ b/tests/run-make/reset-codegen-1/rmake.rs
@@ -0,0 +1,38 @@
+// When rustc received 4 codegen-units, an output path and an emit flag all simultaneously,
+// this could cause an annoying recompilation issue, uselessly lengthening the build process.
+// A fix was delivered, which resets codegen-units to 1 when necessary,
+// but as it directly affected the way codegen-units are manipulated,
+// this test was created to check that this fix did not cause compilation failures.
+// See https://github.com/rust-lang/rust/issues/30063
+
+//@ ignore-cross-compile
+
+use run_make_support::{rustc, tmp_dir};
+use std::fs;
+
+fn compile(output_file: &str, emit: Option<&str>) {
+ let mut rustc = rustc();
+ let rustc = rustc.codegen_units(4).output(tmp_dir().join(output_file)).input("foo.rs");
+ if let Some(emit) = emit {
+ rustc.emit(emit);
+ }
+ rustc.run();
+}
+
+fn main() {
+ let flags = [
+ ("foo-output", None),
+ ("asm-output", Some("asm")),
+ ("bc-output", Some("llvm-bc")),
+ ("ir-output", Some("llvm-ir")),
+ ("link-output", Some("link")),
+ ("obj-output", Some("obj")),
+ ("dep-output", Some("dep-info")),
+ ("multi-output", Some("asm,obj")),
+ ];
+ for (output_file, emit) in flags {
+ fs::remove_file(output_file).unwrap_or_default();
+ compile(output_file, emit);
+ fs::remove_file(output_file);
+ }
+}
diff --git a/tests/run-make/rustdoc-scrape-examples-macros/Makefile b/tests/run-make/rustdoc-scrape-examples-macros/Makefile
deleted file mode 100644
index edc19d8..0000000
--- a/tests/run-make/rustdoc-scrape-examples-macros/Makefile
+++ /dev/null
@@ -1,19 +0,0 @@
-# ignore-cross-compile
-include ../../run-make/tools.mk
-
-OUTPUT_DIR := "$(TMPDIR)/rustdoc"
-DYLIB_NAME := $(shell echo | $(RUSTC) --crate-name foobar_macro --crate-type dylib --print file-names -)
-
-all:
- $(RUSTC) src/proc.rs --crate-name foobar_macro --edition=2021 --crate-type proc-macro --emit=dep-info,link
-
- $(RUSTC) src/lib.rs --crate-name foobar --edition=2021 --crate-type lib --emit=dep-info,link
-
- $(RUSTDOC) examples/ex.rs --crate-name ex --crate-type bin --output $(OUTPUT_DIR) \
- --extern foobar=$(TMPDIR)/libfoobar.rlib --extern foobar_macro=$(TMPDIR)/$(DYLIB_NAME) \
- -Z unstable-options --scrape-examples-output-path $(TMPDIR)/ex.calls --scrape-examples-target-crate foobar
-
- $(RUSTDOC) src/lib.rs --crate-name foobar --crate-type lib --output $(OUTPUT_DIR) \
- -Z unstable-options --with-examples $(TMPDIR)/ex.calls
-
- $(HTMLDOCCK) $(OUTPUT_DIR) src/lib.rs
diff --git a/tests/run-make/rustdoc-scrape-examples-macros/rmake.rs b/tests/run-make/rustdoc-scrape-examples-macros/rmake.rs
new file mode 100644
index 0000000..81b7def
--- /dev/null
+++ b/tests/run-make/rustdoc-scrape-examples-macros/rmake.rs
@@ -0,0 +1,64 @@
+//@ ignore-cross-compile
+
+use run_make_support::{htmldocck, rustc, rustdoc, tmp_dir};
+
+fn main() {
+ let tmp_dir = tmp_dir();
+ let out_dir = tmp_dir.join("rustdoc");
+ let ex_dir = tmp_dir.join("ex.calls");
+ let proc_crate_name = "foobar_macro";
+ let crate_name = "foobar";
+
+ let dylib_name = String::from_utf8(
+ rustc()
+ .crate_name(proc_crate_name)
+ .crate_type("dylib")
+ .arg("--print")
+ .arg("file-names")
+ .arg("-")
+ .command_output()
+ .stdout,
+ )
+ .unwrap();
+
+ rustc()
+ .input("src/proc.rs")
+ .crate_name(proc_crate_name)
+ .edition("2021")
+ .crate_type("proc-macro")
+ .emit("dep-info,link")
+ .run();
+ rustc()
+ .input("src/lib.rs")
+ .crate_name(crate_name)
+ .edition("2021")
+ .crate_type("lib")
+ .emit("dep-info,link")
+ .run();
+
+ rustdoc()
+ .input("examples/ex.rs")
+ .crate_name("ex")
+ .crate_type("bin")
+ .output(&out_dir)
+ .extern_(crate_name, tmp_dir.join(format!("lib{crate_name}.rlib")))
+ .extern_(proc_crate_name, tmp_dir.join(dylib_name.trim()))
+ .arg("-Zunstable-options")
+ .arg("--scrape-examples-output-path")
+ .arg(&ex_dir)
+ .arg("--scrape-examples-target-crate")
+ .arg(crate_name)
+ .run();
+
+ rustdoc()
+ .input("src/lib.rs")
+ .crate_name(crate_name)
+ .crate_type("lib")
+ .output(&out_dir)
+ .arg("-Zunstable-options")
+ .arg("--with-examples")
+ .arg(&ex_dir)
+ .run();
+
+ assert!(htmldocck().arg(out_dir).arg("src/lib.rs").status().unwrap().success());
+}
diff --git a/tests/run-make/rustdoc-with-short-out-dir-option/Makefile b/tests/run-make/rustdoc-with-short-out-dir-option/Makefile
deleted file mode 100644
index 1b9327b..0000000
--- a/tests/run-make/rustdoc-with-short-out-dir-option/Makefile
+++ /dev/null
@@ -1,8 +0,0 @@
-include ../tools.mk
-
-OUTPUT_DIR := "$(TMPDIR)/rustdoc"
-
-all:
- $(RUSTDOC) src/lib.rs --crate-name foobar --crate-type lib -o $(OUTPUT_DIR)
-
- $(HTMLDOCCK) $(OUTPUT_DIR) src/lib.rs
diff --git a/tests/run-make/rustdoc-with-short-out-dir-option/rmake.rs b/tests/run-make/rustdoc-with-short-out-dir-option/rmake.rs
new file mode 100644
index 0000000..6206173
--- /dev/null
+++ b/tests/run-make/rustdoc-with-short-out-dir-option/rmake.rs
@@ -0,0 +1,16 @@
+use run_make_support::{htmldocck, rustdoc, tmp_dir};
+
+fn main() {
+ let out_dir = tmp_dir().join("rustdoc");
+
+ rustdoc()
+ .input("src/lib.rs")
+ .crate_name("foobar")
+ .crate_type("lib")
+ // This is intentionally using `-o` option flag and not the `output()` method.
+ .arg("-o")
+ .arg(&out_dir)
+ .run();
+
+ assert!(htmldocck().arg(out_dir).arg("src/lib.rs").status().unwrap().success());
+}
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%
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-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%
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-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-fulldeps/stable-mir/check_intrinsics.rs b/tests/ui-fulldeps/stable-mir/check_intrinsics.rs
index 171850b..7e247ce 100644
--- a/tests/ui-fulldeps/stable-mir/check_intrinsics.rs
+++ b/tests/ui-fulldeps/stable-mir/check_intrinsics.rs
@@ -11,6 +11,7 @@
//@ ignore-windows-gnu mingw has troubles with linking https://github.com/rust-lang/rust/pull/116837
#![feature(rustc_private)]
+#![feature(assert_matches)]
extern crate rustc_hir;
#[macro_use]
@@ -23,8 +24,8 @@
use stable_mir::mir::mono::{Instance, InstanceKind};
use stable_mir::mir::visit::{Location, MirVisitor};
use stable_mir::mir::{LocalDecl, Terminator, TerminatorKind};
-use stable_mir::ty::{RigidTy, TyKind};
-use std::collections::HashSet;
+use stable_mir::ty::{FnDef, GenericArgs, RigidTy, TyKind};
+use std::assert_matches::assert_matches;
use std::convert::TryFrom;
use std::io::Write;
use std::ops::ControlFlow;
@@ -39,9 +40,10 @@
visitor.visit_body(&main_body);
let calls = visitor.calls;
- assert_eq!(calls.len(), 2, "Expected 2 calls, but found: {calls:?}");
- for intrinsic in &calls {
- check_intrinsic(intrinsic)
+ assert_eq!(calls.len(), 3, "Expected 3 calls, but found: {calls:?}");
+ for (fn_def, args) in calls.into_iter() {
+ check_instance(&Instance::resolve(fn_def, &args).unwrap());
+ check_def(fn_def);
}
ControlFlow::Continue(())
@@ -53,22 +55,39 @@
///
/// If by any chance this test breaks because you changed how an intrinsic is implemented, please
/// update the test to invoke a different intrinsic.
-fn check_intrinsic(intrinsic: &Instance) {
- assert_eq!(intrinsic.kind, InstanceKind::Intrinsic);
- let name = intrinsic.intrinsic_name().unwrap();
- if intrinsic.has_body() {
- let Some(body) = intrinsic.body() else { unreachable!("Expected a body") };
+fn check_instance(instance: &Instance) {
+ assert_eq!(instance.kind, InstanceKind::Intrinsic);
+ let name = instance.intrinsic_name().unwrap();
+ if instance.has_body() {
+ let Some(body) = instance.body() else { unreachable!("Expected a body") };
assert!(!body.blocks.is_empty());
- assert_eq!(&name, "likely");
+ assert_matches!(name.as_str(), "likely" | "vtable_size");
} else {
- assert!(intrinsic.body().is_none());
+ assert!(instance.body().is_none());
assert_eq!(&name, "size_of_val");
}
}
+fn check_def(fn_def: FnDef) {
+ assert!(fn_def.is_intrinsic());
+ let intrinsic = fn_def.as_intrinsic().unwrap();
+ assert_eq!(fn_def, intrinsic.into());
+
+ let name = intrinsic.fn_name();
+ match name.as_str() {
+ "likely" | "size_of_val" => {
+ assert!(!intrinsic.must_be_overridden());
+ }
+ "vtable_size" => {
+ assert!(intrinsic.must_be_overridden());
+ }
+ _ => unreachable!("Unexpected intrinsic: {}", name),
+ }
+}
+
struct CallsVisitor<'a> {
locals: &'a [LocalDecl],
- calls: HashSet<Instance>,
+ calls: Vec<(FnDef, GenericArgs)>,
}
impl<'a> MirVisitor for CallsVisitor<'a> {
@@ -77,10 +96,10 @@
TerminatorKind::Call { func, .. } => {
let TyKind::RigidTy(RigidTy::FnDef(def, args)) =
func.ty(self.locals).unwrap().kind()
- else {
- return;
- };
- self.calls.insert(Instance::resolve(def, &args).unwrap());
+ else {
+ return;
+ };
+ self.calls.push((def, args.clone()));
}
_ => {}
}
@@ -106,6 +125,7 @@
#![feature(core_intrinsics)]
use std::intrinsics::*;
pub fn use_intrinsics(init: bool) -> bool {{
+ let vtable_sz = unsafe {{ vtable_size(0 as *const ()) }};
let sz = unsafe {{ size_of_val("hi") }};
likely(init && sz == 2)
}}
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/async-await/async-closures/implements-fnmut.rs b/tests/ui/async-await/async-closures/implements-fnmut.rs
new file mode 100644
index 0000000..1ed326c
--- /dev/null
+++ b/tests/ui/async-await/async-closures/implements-fnmut.rs
@@ -0,0 +1,23 @@
+//@ check-pass
+//@ edition: 2021
+
+// Demonstrates that an async closure may implement `FnMut` (not just `async FnMut`!)
+// if it has no self-borrows. In this case, `&Ty` is not borrowed from the closure env,
+// since it's fine to reborrow it with its original lifetime. See the doc comment on
+// `should_reborrow_from_env_of_parent_coroutine_closure` for more detail for when we
+// must borrow from the closure env.
+
+#![feature(async_closure)]
+
+fn main() {}
+
+fn needs_fn_mut<T>(x: impl FnMut() -> T) {}
+
+fn hello(x: &Ty) {
+ needs_fn_mut(async || { x.hello(); });
+}
+
+struct Ty;
+impl Ty {
+ fn hello(&self) {}
+}
diff --git a/tests/ui/async-await/async-is-unwindsafe.rs b/tests/ui/async-await/async-is-unwindsafe.rs
index d0202f7..53009b6 100644
--- a/tests/ui/async-await/async-is-unwindsafe.rs
+++ b/tests/ui/async-await/async-is-unwindsafe.rs
@@ -11,7 +11,6 @@
is_unwindsafe(async {
//~^ ERROR the type `&mut Context<'_>` may not be safely transferred across an unwind boundary
- //~| ERROR the type `&mut (dyn Any + 'static)` may not be safely transferred across an unwind boundary
use std::ptr::null;
use std::task::{Context, RawWaker, RawWakerVTable, Waker};
let waker = unsafe {
diff --git a/tests/ui/async-await/async-is-unwindsafe.stderr b/tests/ui/async-await/async-is-unwindsafe.stderr
index 6bb06df..5d87fc7 100644
--- a/tests/ui/async-await/async-is-unwindsafe.stderr
+++ b/tests/ui/async-await/async-is-unwindsafe.stderr
@@ -6,18 +6,19 @@
| |_____|
| ||
LL | ||
-LL | ||
LL | || use std::ptr::null;
+LL | || use std::task::{Context, RawWaker, RawWakerVTable, Waker};
... ||
LL | || drop(cx_ref);
LL | || });
| ||_____-^ `&mut Context<'_>` may not be safely transferred across an unwind boundary
| |_____|
- | within this `{async block@$DIR/async-is-unwindsafe.rs:12:19: 30:6}`
+ | within this `{async block@$DIR/async-is-unwindsafe.rs:12:19: 29:6}`
|
- = help: within `{async block@$DIR/async-is-unwindsafe.rs:12:19: 30:6}`, the trait `UnwindSafe` is not implemented for `&mut Context<'_>`, which is required by `{async block@$DIR/async-is-unwindsafe.rs:12:19: 30:6}: UnwindSafe`
+ = help: within `{async block@$DIR/async-is-unwindsafe.rs:12:19: 29:6}`, the trait `UnwindSafe` is not implemented for `&mut Context<'_>`, which is required by `{async block@$DIR/async-is-unwindsafe.rs:12:19: 29:6}: UnwindSafe`
+ = note: `UnwindSafe` is implemented for `&Context<'_>`, but not for `&mut Context<'_>`
note: future does not implement `UnwindSafe` as this value is used across an await
- --> $DIR/async-is-unwindsafe.rs:26:18
+ --> $DIR/async-is-unwindsafe.rs:25:18
|
LL | let cx_ref = &mut cx;
| ------ has type `&mut Context<'_>` which does not implement `UnwindSafe`
@@ -30,38 +31,6 @@
LL | fn is_unwindsafe(_: impl std::panic::UnwindSafe) {}
| ^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_unwindsafe`
-error[E0277]: the type `&mut (dyn Any + 'static)` may not be safely transferred across an unwind boundary
- --> $DIR/async-is-unwindsafe.rs:12:5
- |
-LL | is_unwindsafe(async {
- | _____^_____________-
- | |_____|
- | ||
-LL | ||
-LL | ||
-LL | || use std::ptr::null;
-... ||
-LL | || drop(cx_ref);
-LL | || });
- | ||_____-^ `&mut (dyn Any + 'static)` may not be safely transferred across an unwind boundary
- | |_____|
- | within this `{async block@$DIR/async-is-unwindsafe.rs:12:19: 30:6}`
- |
- = help: within `{async block@$DIR/async-is-unwindsafe.rs:12:19: 30:6}`, the trait `UnwindSafe` is not implemented for `&mut (dyn Any + 'static)`, which is required by `{async block@$DIR/async-is-unwindsafe.rs:12:19: 30:6}: UnwindSafe`
-note: future does not implement `UnwindSafe` as this value is used across an await
- --> $DIR/async-is-unwindsafe.rs:26:18
- |
-LL | let mut cx = Context::from_waker(&waker);
- | ------ has type `Context<'_>` which does not implement `UnwindSafe`
-...
-LL | async {}.await; // this needs an inner await point
- | ^^^^^ await occurs here, with `mut cx` maybe used later
-note: required by a bound in `is_unwindsafe`
- --> $DIR/async-is-unwindsafe.rs:3:26
- |
-LL | fn is_unwindsafe(_: impl std::panic::UnwindSafe) {}
- | ^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `is_unwindsafe`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/async-await/context-is-sorta-unwindsafe.rs b/tests/ui/async-await/context-is-sorta-unwindsafe.rs
new file mode 100644
index 0000000..278476e
--- /dev/null
+++ b/tests/ui/async-await/context-is-sorta-unwindsafe.rs
@@ -0,0 +1,14 @@
+//@ run-pass
+// Tests against a regression surfaced by crater in https://github.com/rust-lang/rust/issues/125193
+// Unwind Safety is not a very coherent concept, but we'd prefer no regressions until we kibosh it
+// and this is an unstable feature anyways sooo...
+
+use std::panic::UnwindSafe;
+use std::task::Context;
+
+fn unwind_safe<T: UnwindSafe>() {}
+
+fn main() {
+ unwind_safe::<Context<'_>>(); // test UnwindSafe
+ unwind_safe::<&Context<'_>>(); // test RefUnwindSafe
+}
diff --git a/tests/ui/check-cfg/cargo-build-script.rs b/tests/ui/check-cfg/cargo-build-script.rs
new file mode 100644
index 0000000..a3ba879
--- /dev/null
+++ b/tests/ui/check-cfg/cargo-build-script.rs
@@ -0,0 +1,22 @@
+// This test checks that when we are building a build script provided
+// by Cargo we only suggest expecting the unexpected cfgs in the Cargo.toml.
+//
+//@ check-pass
+//@ no-auto-check-cfg
+//@ rustc-env:CARGO_CRATE_NAME=build_script_build
+//@ compile-flags:--crate-name=build_script_build
+//@ compile-flags:--check-cfg=cfg(has_bar)
+
+#[cfg(has_foo)]
+//~^ WARNING unexpected `cfg` condition name
+fn foo() {}
+
+#[cfg(has_foo = "yes")]
+//~^ WARNING unexpected `cfg` condition name
+fn foo() {}
+
+#[cfg(has_bar = "yes")]
+//~^ WARNING unexpected `cfg` condition value
+fn has_bar() {}
+
+fn main() {}
diff --git a/tests/ui/check-cfg/cargo-build-script.stderr b/tests/ui/check-cfg/cargo-build-script.stderr
new file mode 100644
index 0000000..9ab3290
--- /dev/null
+++ b/tests/ui/check-cfg/cargo-build-script.stderr
@@ -0,0 +1,43 @@
+warning: unexpected `cfg` condition name: `has_foo`
+ --> $DIR/cargo-build-script.rs:10:7
+ |
+LL | #[cfg(has_foo)]
+ | ^^^^^^^
+ |
+ = help: expected names are: `clippy`, `debug_assertions`, `doc`, `doctest`, `has_bar`, `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]
+ unexpected_cfgs = { level = "warn", check-cfg = ['cfg(has_foo)'] }
+ = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
+ = note: `#[warn(unexpected_cfgs)]` on by default
+
+warning: unexpected `cfg` condition name: `has_foo`
+ --> $DIR/cargo-build-script.rs:14:7
+ |
+LL | #[cfg(has_foo = "yes")]
+ | ^^^^^^^^^^^^^^^
+ |
+ = help: consider using a Cargo feature instead
+ = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
+ [lints.rust]
+ unexpected_cfgs = { level = "warn", check-cfg = ['cfg(has_foo, values("yes"))'] }
+ = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
+
+warning: unexpected `cfg` condition value: `yes`
+ --> $DIR/cargo-build-script.rs:18:7
+ |
+LL | #[cfg(has_bar = "yes")]
+ | ^^^^^^^--------
+ | |
+ | help: remove the value
+ |
+ = note: no expected value for `has_bar`
+ = help: consider using a Cargo feature instead
+ = help: or consider adding in `Cargo.toml` the `check-cfg` lint config for the lint:
+ [lints.rust]
+ unexpected_cfgs = { level = "warn", check-cfg = ['cfg(has_bar, values("yes"))'] }
+ = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
+
+warning: 3 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/const-int-unchecked.stderr b/tests/ui/consts/const-int-unchecked.stderr
index 84b2229..3130603 100644
--- a/tests/ui/consts/const-int-unchecked.stderr
+++ b/tests/ui/consts/const-int-unchecked.stderr
@@ -242,19 +242,19 @@
--> $DIR/const-int-unchecked.rs:123:25
|
LL | const _: u16 = unsafe { std::intrinsics::unchecked_add(40000u16, 30000) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ overflow executing `unchecked_add`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ arithmetic overflow in `unchecked_add`
error[E0080]: evaluation of constant value failed
--> $DIR/const-int-unchecked.rs:126:25
|
LL | const _: u32 = unsafe { std::intrinsics::unchecked_sub(14u32, 22) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ overflow executing `unchecked_sub`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ arithmetic overflow in `unchecked_sub`
error[E0080]: evaluation of constant value failed
--> $DIR/const-int-unchecked.rs:129:25
|
LL | const _: u16 = unsafe { std::intrinsics::unchecked_mul(300u16, 250u16) };
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ overflow executing `unchecked_mul`
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ arithmetic overflow in `unchecked_mul`
error[E0080]: evaluation of constant value failed
--> $DIR/const-int-unchecked.rs:132:25
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/erroneous_type_in_const_return_value.rs b/tests/ui/consts/erroneous_type_in_const_return_value.rs
new file mode 100644
index 0000000..304211f
--- /dev/null
+++ b/tests/ui/consts/erroneous_type_in_const_return_value.rs
@@ -0,0 +1,12 @@
+//! ICE test #124348
+//! We should not be running const eval if the layout has errors.
+
+enum Eek {
+ TheConst,
+ UnusedByTheConst(Sum),
+ //~^ ERROR cannot find type `Sum` in this scope
+}
+
+const EEK_ZERO: &[Eek] = &[];
+
+fn main() {}
diff --git a/tests/ui/consts/erroneous_type_in_const_return_value.stderr b/tests/ui/consts/erroneous_type_in_const_return_value.stderr
new file mode 100644
index 0000000..453f5b6
--- /dev/null
+++ b/tests/ui/consts/erroneous_type_in_const_return_value.stderr
@@ -0,0 +1,14 @@
+error[E0412]: cannot find type `Sum` in this scope
+ --> $DIR/erroneous_type_in_const_return_value.rs:6:22
+ |
+LL | UnusedByTheConst(Sum),
+ | ^^^ not found in this scope
+ |
+help: consider importing this trait
+ |
+LL + use std::iter::Sum;
+ |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0412`.
diff --git a/tests/ui/consts/erroneous_type_in_promoted.rs b/tests/ui/consts/erroneous_type_in_promoted.rs
new file mode 100644
index 0000000..32e33c2
--- /dev/null
+++ b/tests/ui/consts/erroneous_type_in_promoted.rs
@@ -0,0 +1,14 @@
+//! ICE test #124348
+//! We should not be running const eval if the layout has errors.
+
+enum Eek {
+ TheConst,
+ UnusedByTheConst(Sum),
+ //~^ ERROR cannot find type `Sum` in this scope
+}
+
+const fn foo() {
+ let x: &'static [Eek] = &[];
+}
+
+fn main() {}
diff --git a/tests/ui/consts/erroneous_type_in_promoted.stderr b/tests/ui/consts/erroneous_type_in_promoted.stderr
new file mode 100644
index 0000000..0601fc9
--- /dev/null
+++ b/tests/ui/consts/erroneous_type_in_promoted.stderr
@@ -0,0 +1,14 @@
+error[E0412]: cannot find type `Sum` in this scope
+ --> $DIR/erroneous_type_in_promoted.rs:6:22
+ |
+LL | UnusedByTheConst(Sum),
+ | ^^^ not found in this scope
+ |
+help: consider importing this trait
+ |
+LL + use std::iter::Sum;
+ |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0412`.
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/extern-flag/empty-extern-arg.stderr b/tests/ui/extern-flag/empty-extern-arg.stderr
index 2785b12..6ad3eff 100644
--- a/tests/ui/extern-flag/empty-extern-arg.stderr
+++ b/tests/ui/extern-flag/empty-extern-arg.stderr
@@ -1,13 +1,6 @@
error: extern location for std does not exist:
-error: `#[panic_handler]` function required, but not found
-
-error: unwinding panics are not supported without std
- |
- = help: using nightly cargo, use -Zbuild-std with panic="abort" to avoid unwinding
- = note: since the core library is usually precompiled with panic="unwind", rebuilding your crate with panic="abort" may not be enough to fix the problem
-
error: requires `sized` lang_item
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
diff --git a/tests/ui/fn/fn_def_opaque_coercion_to_fn_ptr.rs b/tests/ui/fn/fn_def_opaque_coercion_to_fn_ptr.rs
new file mode 100644
index 0000000..5250e3a
--- /dev/null
+++ b/tests/ui/fn/fn_def_opaque_coercion_to_fn_ptr.rs
@@ -0,0 +1,57 @@
+//! Test that coercing between function items of different functions works,
+//! as long as their signatures match. The resulting value is a function pointer.
+
+#![feature(type_alias_impl_trait)]
+
+fn foo<T>(t: T) -> T {
+ t
+}
+
+fn bar<T>(t: T) -> T {
+ t
+}
+
+type F = impl Sized;
+
+fn f(a: F) {
+ let mut x = bar::<F>;
+ x = foo::<()>; //~ ERROR: mismatched types
+ x(a);
+ x(());
+}
+
+type I = impl Sized;
+
+fn i(a: I) {
+ let mut x = bar::<()>;
+ x = foo::<I>; //~ ERROR: mismatched types
+ x(a);
+ x(());
+}
+
+type J = impl Sized;
+
+fn j(a: J) {
+ let x = match true {
+ true => bar::<J>,
+ false => foo::<()>,
+ };
+ x(a);
+ x(());
+}
+
+fn k() -> impl Sized {
+ fn bind<T, F: FnOnce(T) -> T>(_: T, f: F) -> F {
+ f
+ }
+ let x = match true {
+ true => {
+ let f = foo;
+ bind(k(), f)
+ }
+ false => bar::<()>,
+ };
+ todo!()
+}
+
+fn main() {}
diff --git a/tests/ui/fn/fn_def_opaque_coercion_to_fn_ptr.stderr b/tests/ui/fn/fn_def_opaque_coercion_to_fn_ptr.stderr
new file mode 100644
index 0000000..0b3331b
--- /dev/null
+++ b/tests/ui/fn/fn_def_opaque_coercion_to_fn_ptr.stderr
@@ -0,0 +1,38 @@
+error[E0308]: mismatched types
+ --> $DIR/fn_def_opaque_coercion_to_fn_ptr.rs:18:9
+ |
+LL | type F = impl Sized;
+ | ---------- the expected opaque type
+...
+LL | let mut x = bar::<F>;
+ | -------- expected due to this value
+LL | x = foo::<()>;
+ | ^^^^^^^^^ expected fn item, found a different fn item
+ |
+ = note: expected fn item `fn(F) -> F {bar::<F>}`
+ found fn item `fn(()) {foo::<()>}`
+
+error[E0308]: mismatched types
+ --> $DIR/fn_def_opaque_coercion_to_fn_ptr.rs:27:9
+ |
+LL | fn foo<T>(t: T) -> T {
+ | -------------------- function `foo` defined here
+...
+LL | type I = impl Sized;
+ | ---------- the found opaque type
+...
+LL | let mut x = bar::<()>;
+ | --------- expected due to this value
+LL | x = foo::<I>;
+ | ^^^^^^^^ expected fn item, found a different fn item
+ |
+ = note: expected fn item `fn(()) {bar::<()>}`
+ found fn item `fn(I) -> I {foo::<I>}`
+help: use parentheses to call this function
+ |
+LL | x = foo::<I>(/* I */);
+ | +++++++++
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/inference/note-and-explain-ReVar-124973.rs b/tests/ui/inference/note-and-explain-ReVar-124973.rs
new file mode 100644
index 0000000..f1e2464
--- /dev/null
+++ b/tests/ui/inference/note-and-explain-ReVar-124973.rs
@@ -0,0 +1,8 @@
+//@ edition:2018
+
+#![feature(c_variadic)]
+
+async unsafe extern "C" fn multiple_named_lifetimes<'a, 'b>(_: u8, ...) {}
+//~^ ERROR hidden type for `impl Future<Output = ()>` captures lifetime that does not appear in bounds
+
+fn main() {}
diff --git a/tests/ui/inference/note-and-explain-ReVar-124973.stderr b/tests/ui/inference/note-and-explain-ReVar-124973.stderr
new file mode 100644
index 0000000..574f650
--- /dev/null
+++ b/tests/ui/inference/note-and-explain-ReVar-124973.stderr
@@ -0,0 +1,13 @@
+error[E0700]: hidden type for `impl Future<Output = ()>` captures lifetime that does not appear in bounds
+ --> $DIR/note-and-explain-ReVar-124973.rs:5:73
+ |
+LL | async unsafe extern "C" fn multiple_named_lifetimes<'a, 'b>(_: u8, ...) {}
+ | ----------------------------------------------------------------------- ^^
+ | |
+ | opaque type defined here
+ |
+ = note: hidden type `{async fn body of multiple_named_lifetimes<'a, 'b>()}` captures lifetime `'_`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0700`.
diff --git a/tests/ui/lint/dead-code/unused-adt-impls-trait.rs b/tests/ui/lint/dead-code/unused-adt-impls-trait.rs
new file mode 100644
index 0000000..4714859
--- /dev/null
+++ b/tests/ui/lint/dead-code/unused-adt-impls-trait.rs
@@ -0,0 +1,34 @@
+#![deny(dead_code)]
+
+struct Used;
+struct Unused; //~ ERROR struct `Unused` is never constructed
+
+pub trait PubTrait {
+ fn foo(&self) -> Self;
+}
+
+impl PubTrait for Used {
+ fn foo(&self) -> Self { Used }
+}
+
+impl PubTrait for Unused {
+ fn foo(&self) -> Self { Unused }
+}
+
+trait PriTrait {
+ fn foo(&self) -> Self;
+}
+
+impl PriTrait for Used {
+ fn foo(&self) -> Self { Used }
+}
+
+impl PriTrait for Unused {
+ fn foo(&self) -> Self { Unused }
+}
+
+fn main() {
+ let t = Used;
+ let _t = <Used as PubTrait>::foo(&t);
+ let _t = <Used as PriTrait>::foo(&t);
+}
diff --git a/tests/ui/lint/dead-code/unused-adt-impls-trait.stderr b/tests/ui/lint/dead-code/unused-adt-impls-trait.stderr
new file mode 100644
index 0000000..28bae5c
--- /dev/null
+++ b/tests/ui/lint/dead-code/unused-adt-impls-trait.stderr
@@ -0,0 +1,14 @@
+error: struct `Unused` is never constructed
+ --> $DIR/unused-adt-impls-trait.rs:4:8
+ |
+LL | struct Unused;
+ | ^^^^^^
+ |
+note: the lint level is defined here
+ --> $DIR/unused-adt-impls-trait.rs:1:9
+ |
+LL | #![deny(dead_code)]
+ | ^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/lint/for_loop_over_fallibles.rs b/tests/ui/lint/for_loop_over_fallibles.rs
index 52c3b8f..89ac20c 100644
--- a/tests/ui/lint/for_loop_over_fallibles.rs
+++ b/tests/ui/lint/for_loop_over_fallibles.rs
@@ -41,3 +41,25 @@
Ok(())
}
+
+fn _by_ref() {
+ // Shared refs
+ for _ in &Some(1) {}
+ //~^ WARN for loop over a `&Option`. This is more readably written as an `if let` statement
+ //~| HELP to check pattern in a loop use `while let`
+ //~| HELP consider using `if let` to clear intent
+ for _ in &Ok::<_, ()>(1) {}
+ //~^ WARN for loop over a `&Result`. This is more readably written as an `if let` statement
+ //~| HELP to check pattern in a loop use `while let`
+ //~| HELP consider using `if let` to clear intent
+
+ // Mutable refs
+ for _ in &mut Some(1) {}
+ //~^ WARN for loop over a `&mut Option`. This is more readably written as an `if let` statement
+ //~| HELP to check pattern in a loop use `while let`
+ //~| HELP consider using `if let` to clear intent
+ for _ in &mut Ok::<_, ()>(1) {}
+ //~^ WARN for loop over a `&mut Result`. This is more readably written as an `if let` statement
+ //~| HELP to check pattern in a loop use `while let`
+ //~| HELP consider using `if let` to clear intent
+}
diff --git a/tests/ui/lint/for_loop_over_fallibles.stderr b/tests/ui/lint/for_loop_over_fallibles.stderr
index 96efdf8..f695de0 100644
--- a/tests/ui/lint/for_loop_over_fallibles.stderr
+++ b/tests/ui/lint/for_loop_over_fallibles.stderr
@@ -97,5 +97,65 @@
LL | if let Ok(_) = Ok::<_, ()>([0; 0]) {}
| ~~~~~~~~~~ ~~~
-warning: 6 warnings emitted
+warning: for loop over a `&Option`. This is more readably written as an `if let` statement
+ --> $DIR/for_loop_over_fallibles.rs:47:14
+ |
+LL | for _ in &Some(1) {}
+ | ^^^^^^^^
+ |
+help: to check pattern in a loop use `while let`
+ |
+LL | while let Some(_) = &Some(1) {}
+ | ~~~~~~~~~~~~~~~ ~~~
+help: consider using `if let` to clear intent
+ |
+LL | if let Some(_) = &Some(1) {}
+ | ~~~~~~~~~~~~ ~~~
+
+warning: for loop over a `&Result`. This is more readably written as an `if let` statement
+ --> $DIR/for_loop_over_fallibles.rs:51:14
+ |
+LL | for _ in &Ok::<_, ()>(1) {}
+ | ^^^^^^^^^^^^^^^
+ |
+help: to check pattern in a loop use `while let`
+ |
+LL | while let Ok(_) = &Ok::<_, ()>(1) {}
+ | ~~~~~~~~~~~~~ ~~~
+help: consider using `if let` to clear intent
+ |
+LL | if let Ok(_) = &Ok::<_, ()>(1) {}
+ | ~~~~~~~~~~ ~~~
+
+warning: for loop over a `&mut Option`. This is more readably written as an `if let` statement
+ --> $DIR/for_loop_over_fallibles.rs:57:14
+ |
+LL | for _ in &mut Some(1) {}
+ | ^^^^^^^^^^^^
+ |
+help: to check pattern in a loop use `while let`
+ |
+LL | while let Some(_) = &mut Some(1) {}
+ | ~~~~~~~~~~~~~~~ ~~~
+help: consider using `if let` to clear intent
+ |
+LL | if let Some(_) = &mut Some(1) {}
+ | ~~~~~~~~~~~~ ~~~
+
+warning: for loop over a `&mut Result`. This is more readably written as an `if let` statement
+ --> $DIR/for_loop_over_fallibles.rs:61:14
+ |
+LL | for _ in &mut Ok::<_, ()>(1) {}
+ | ^^^^^^^^^^^^^^^^^^^
+ |
+help: to check pattern in a loop use `while let`
+ |
+LL | while let Ok(_) = &mut Ok::<_, ()>(1) {}
+ | ~~~~~~~~~~~~~ ~~~
+help: consider using `if let` to clear intent
+ |
+LL | if let Ok(_) = &mut Ok::<_, ()>(1) {}
+ | ~~~~~~~~~~ ~~~
+
+warning: 10 warnings emitted
diff --git a/tests/ui/lint/missing_copy_impl_trivial_bounds.rs b/tests/ui/lint/missing_copy_impl_trivial_bounds.rs
new file mode 100644
index 0000000..9b74341
--- /dev/null
+++ b/tests/ui/lint/missing_copy_impl_trivial_bounds.rs
@@ -0,0 +1,21 @@
+//@ check-pass
+
+#![feature(trivial_bounds)]
+#![allow(trivial_bounds)]
+
+// Make sure that we still use the where-clauses from the struct when checking
+// if it may implement `Copy` unconditionally.
+// Fix for <https://github.com/rust-lang/rust/issues/125394>.
+
+pub trait Foo {
+ type Assoc;
+}
+
+pub struct Bar;
+
+// This needs to be public
+pub struct Baz2(<Bar as Foo>::Assoc)
+where
+ Bar: Foo;
+
+fn main() {}
diff --git a/tests/ui/loops/loop-if-else-break-issue-123261.fixed b/tests/ui/loops/loop-if-else-break-issue-123261.fixed
new file mode 100644
index 0000000..f9e88c1
--- /dev/null
+++ b/tests/ui/loops/loop-if-else-break-issue-123261.fixed
@@ -0,0 +1,31 @@
+//@ run-rustfix
+
+#![allow(unused)]
+
+fn main() {
+ let n = 1;
+ let m = 2;
+ let x = 'block: {
+ if n == 0 {
+ break 'block 1; //~ ERROR [E0268]
+ } else {
+ break 'block 2;
+ }
+ };
+
+ let y = 'block: {
+ if n == 0 {
+ break 'block 1; //~ ERROR [E0268]
+ }
+ break 'block 0;
+ };
+
+ let z = 'block: {
+ if n == 0 {
+ if m > 1 {
+ break 'block 3; //~ ERROR [E0268]
+ }
+ }
+ break 'block 1;
+ };
+}
diff --git a/tests/ui/loops/loop-if-else-break-issue-123261.rs b/tests/ui/loops/loop-if-else-break-issue-123261.rs
new file mode 100644
index 0000000..a1f9dab
--- /dev/null
+++ b/tests/ui/loops/loop-if-else-break-issue-123261.rs
@@ -0,0 +1,31 @@
+//@ run-rustfix
+
+#![allow(unused)]
+
+fn main() {
+ let n = 1;
+ let m = 2;
+ let x = {
+ if n == 0 {
+ break 1; //~ ERROR [E0268]
+ } else {
+ break 2;
+ }
+ };
+
+ let y = {
+ if n == 0 {
+ break 1; //~ ERROR [E0268]
+ }
+ break 0;
+ };
+
+ let z = {
+ if n == 0 {
+ if m > 1 {
+ break 3; //~ ERROR [E0268]
+ }
+ }
+ break 1;
+ };
+}
diff --git a/tests/ui/loops/loop-if-else-break-issue-123261.stderr b/tests/ui/loops/loop-if-else-break-issue-123261.stderr
new file mode 100644
index 0000000..7bd192f
--- /dev/null
+++ b/tests/ui/loops/loop-if-else-break-issue-123261.stderr
@@ -0,0 +1,59 @@
+error[E0268]: `break` outside of a loop or labeled block
+ --> $DIR/loop-if-else-break-issue-123261.rs:10:13
+ |
+LL | break 1;
+ | ^^^^^^^ cannot `break` outside of a loop or labeled block
+LL | } else {
+LL | break 2;
+ | ^^^^^^^ cannot `break` outside of a loop or labeled block
+ |
+help: consider labeling this block to be able to break within it
+ |
+LL ~ let x = 'block: {
+LL | if n == 0 {
+LL ~ break 'block 1;
+LL | } else {
+LL ~ break 'block 2;
+ |
+
+error[E0268]: `break` outside of a loop or labeled block
+ --> $DIR/loop-if-else-break-issue-123261.rs:18:13
+ |
+LL | break 1;
+ | ^^^^^^^ cannot `break` outside of a loop or labeled block
+LL | }
+LL | break 0;
+ | ^^^^^^^ cannot `break` outside of a loop or labeled block
+ |
+help: consider labeling this block to be able to break within it
+ |
+LL ~ let y = 'block: {
+LL | if n == 0 {
+LL ~ break 'block 1;
+LL | }
+LL ~ break 'block 0;
+ |
+
+error[E0268]: `break` outside of a loop or labeled block
+ --> $DIR/loop-if-else-break-issue-123261.rs:26:17
+ |
+LL | break 3;
+ | ^^^^^^^ cannot `break` outside of a loop or labeled block
+...
+LL | break 1;
+ | ^^^^^^^ cannot `break` outside of a loop or labeled block
+ |
+help: consider labeling this block to be able to break within it
+ |
+LL ~ let z = 'block: {
+LL | if n == 0 {
+LL | if m > 1 {
+LL ~ break 'block 3;
+LL | }
+LL | }
+LL ~ break 'block 1;
+ |
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0268`.
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/parser/bad-let-else-statement.rs b/tests/ui/parser/bad-let-else-statement.rs
index de41a07..ff6619c 100644
--- a/tests/ui/parser/bad-let-else-statement.rs
+++ b/tests/ui/parser/bad-let-else-statement.rs
@@ -3,8 +3,7 @@
#![feature(explicit_tail_calls)]
fn a() {
- let foo = {
- //~^ WARN irrefutable `let...else` pattern
+ let 0 = {
1
} else {
//~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
@@ -22,8 +21,7 @@
}
fn c() {
- let foo = if true {
- //~^ WARN irrefutable `let...else` pattern
+ let 0 = if true {
1
} else {
0
@@ -43,8 +41,7 @@
}
fn e() {
- let foo = match true {
- //~^ WARN irrefutable `let...else` pattern
+ let 0 = match true {
true => 1,
false => 0
} else {
@@ -53,10 +50,12 @@
};
}
-struct X {a: i32}
fn f() {
- let foo = X {
- //~^ WARN irrefutable `let...else` pattern
+ struct X {
+ a: i32,
+ }
+
+ let X { a: 0 } = X {
a: 1
} else {
//~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
@@ -74,8 +73,7 @@
}
fn h() {
- let foo = const {
- //~^ WARN irrefutable `let...else` pattern
+ let 0 = const {
1
} else {
//~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
@@ -84,8 +82,7 @@
}
fn i() {
- let foo = &{
- //~^ WARN irrefutable `let...else` pattern
+ let 0 = &{
1
} else {
//~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
@@ -94,8 +91,8 @@
}
fn j() {
- let bar = 0;
- let foo = bar = { //~ ERROR: cannot assign twice
+ let mut bar = 0;
+ let foo = bar = {
//~^ WARN irrefutable `let...else` pattern
1
} else {
@@ -105,8 +102,7 @@
}
fn k() {
- let foo = 1 + {
- //~^ WARN irrefutable `let...else` pattern
+ let 0 = 1 + {
1
} else {
//~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
@@ -115,8 +111,8 @@
}
fn l() {
- let foo = 1..{
- //~^ WARN irrefutable `let...else` pattern
+ const RANGE: std::ops::Range<u8> = 0..0;
+ let RANGE = 1..{
1
} else {
//~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
@@ -125,8 +121,7 @@
}
fn m() {
- let foo = return {
- //~^ WARN irrefutable `let...else` pattern
+ let 0 = return {
()
} else {
//~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
@@ -135,8 +130,7 @@
}
fn n() {
- let foo = -{
- //~^ WARN irrefutable `let...else` pattern
+ let 0 = -{
1
} else {
//~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
@@ -145,8 +139,7 @@
}
fn o() -> Result<(), ()> {
- let foo = do yeet {
- //~^ WARN irrefutable `let...else` pattern
+ let 0 = do yeet {
()
} else {
//~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
@@ -155,8 +148,7 @@
}
fn p() {
- let foo = become {
- //~^ WARN irrefutable `let...else` pattern
+ let 0 = become {
()
} else {
//~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
@@ -185,22 +177,37 @@
fn s() {
macro_rules! a {
- () => { {} }
- //~^ WARN irrefutable `let...else` pattern
- //~| WARN irrefutable `let...else` pattern
+ () => {
+ { 1 }
+ };
}
macro_rules! b {
(1) => {
- let x = a!() else { return; };
+ let 0 = a!() else { return; };
};
(2) => {
- let x = a! {} else { return; };
+ let 0 = a! {} else { return; };
//~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
};
}
- b!(1); b!(2);
+ b!(1);
+ b!(2);
+}
+
+fn t() {
+ macro_rules! primitive {
+ (8) => { u8 };
+ }
+
+ let foo = &std::ptr::null as &'static dyn std::ops::Fn() -> *const primitive! {
+ //~^ WARN irrefutable `let...else` pattern
+ 8
+ } else {
+ //~^ ERROR right curly brace `}` before `else` in a `let...else` statement not allowed
+ return;
+ };
}
fn main() {}
diff --git a/tests/ui/parser/bad-let-else-statement.stderr b/tests/ui/parser/bad-let-else-statement.stderr
index 3f7e176..0bf6a34 100644
--- a/tests/ui/parser/bad-let-else-statement.stderr
+++ b/tests/ui/parser/bad-let-else-statement.stderr
@@ -1,19 +1,18 @@
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:9:5
+ --> $DIR/bad-let-else-statement.rs:8:5
|
LL | } else {
| ^
|
help: wrap the expression in parentheses
|
-LL ~ let foo = ({
-LL |
+LL ~ let 0 = ({
LL | 1
LL ~ }) else {
|
error: `for...else` loops are not supported
- --> $DIR/bad-let-else-statement.rs:18:7
+ --> $DIR/bad-let-else-statement.rs:17:7
|
LL | let foo = for i in 1..2 {
| --- `else` is attached to this loop
@@ -28,22 +27,22 @@
= note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:30:5
+ --> $DIR/bad-let-else-statement.rs:28:5
|
LL | } else {
| ^
|
help: wrap the expression in parentheses
|
-LL ~ let foo = (if true {
-LL |
- ...
+LL ~ let 0 = (if true {
+LL | 1
+LL | } else {
LL | 0
LL ~ }) else {
|
error: `loop...else` loops are not supported
- --> $DIR/bad-let-else-statement.rs:39:7
+ --> $DIR/bad-let-else-statement.rs:37:7
|
LL | let foo = loop {
| ---- `else` is attached to this loop
@@ -58,36 +57,34 @@
= note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:50:5
+ --> $DIR/bad-let-else-statement.rs:47:5
|
LL | } else {
| ^
|
help: wrap the expression in parentheses
|
-LL ~ let foo = (match true {
-LL |
+LL ~ let 0 = (match true {
LL | true => 1,
LL | false => 0
LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:61:5
+ --> $DIR/bad-let-else-statement.rs:60:5
|
LL | } else {
| ^
|
help: wrap the expression in parentheses
|
-LL ~ let foo = (X {
-LL |
+LL ~ let X { a: 0 } = (X {
LL | a: 1
LL ~ }) else {
|
error: `while...else` loops are not supported
- --> $DIR/bad-let-else-statement.rs:70:7
+ --> $DIR/bad-let-else-statement.rs:69:7
|
LL | let foo = while false {
| ----- `else` is attached to this loop
@@ -102,35 +99,33 @@
= note: consider moving this `else` clause to a separate `if` statement and use a `bool` variable to control if it should run
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:80:5
+ --> $DIR/bad-let-else-statement.rs:78:5
|
LL | } else {
| ^
|
help: wrap the expression in parentheses
|
-LL ~ let foo = (const {
-LL |
+LL ~ let 0 = (const {
LL | 1
LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:90:5
+ --> $DIR/bad-let-else-statement.rs:87:5
|
LL | } else {
| ^
|
help: wrap the expression in parentheses
|
-LL ~ let foo = &({
-LL |
+LL ~ let 0 = &({
LL | 1
LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:101:5
+ --> $DIR/bad-let-else-statement.rs:98:5
|
LL | } else {
| ^
@@ -144,91 +139,85 @@
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:111:5
+ --> $DIR/bad-let-else-statement.rs:107:5
|
LL | } else {
| ^
|
help: wrap the expression in parentheses
|
-LL ~ let foo = 1 + ({
-LL |
+LL ~ let 0 = 1 + ({
LL | 1
LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:121:5
+ --> $DIR/bad-let-else-statement.rs:117:5
|
LL | } else {
| ^
|
help: wrap the expression in parentheses
|
-LL ~ let foo = 1..({
-LL |
+LL ~ let RANGE = 1..({
LL | 1
LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:131:5
+ --> $DIR/bad-let-else-statement.rs:126:5
|
LL | } else {
| ^
|
help: wrap the expression in parentheses
|
-LL ~ let foo = return ({
-LL |
+LL ~ let 0 = return ({
LL | ()
LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:141:5
+ --> $DIR/bad-let-else-statement.rs:135:5
|
LL | } else {
| ^
|
help: wrap the expression in parentheses
|
-LL ~ let foo = -({
-LL |
+LL ~ let 0 = -({
LL | 1
LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:151:5
+ --> $DIR/bad-let-else-statement.rs:144:5
|
LL | } else {
| ^
|
help: wrap the expression in parentheses
|
-LL ~ let foo = do yeet ({
-LL |
+LL ~ let 0 = do yeet ({
LL | ()
LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:161:5
+ --> $DIR/bad-let-else-statement.rs:153:5
|
LL | } else {
| ^
|
help: wrap the expression in parentheses
|
-LL ~ let foo = become ({
-LL |
+LL ~ let 0 = become ({
LL | ()
LL ~ }) else {
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:171:5
+ --> $DIR/bad-let-else-statement.rs:163:5
|
LL | } else {
| ^
@@ -242,7 +231,7 @@
|
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:181:31
+ --> $DIR/bad-let-else-statement.rs:173:31
|
LL | let bad = format_args! {""} else { return; };
| ^
@@ -253,24 +242,38 @@
| ~ ~
error: right curly brace `}` before `else` in a `let...else` statement not allowed
- --> $DIR/bad-let-else-statement.rs:198:25
+ --> $DIR/bad-let-else-statement.rs:207:5
|
-LL | let x = a! {} else { return; };
+LL | } else {
+ | ^
+ |
+help: use parentheses instead of braces for this macro
+ |
+LL ~ let foo = &std::ptr::null as &'static dyn std::ops::Fn() -> *const primitive! (
+LL |
+LL | 8
+LL ~ ) else {
+ |
+
+error: right curly brace `}` before `else` in a `let...else` statement not allowed
+ --> $DIR/bad-let-else-statement.rs:190:25
+ |
+LL | let 0 = a! {} else { return; };
| ^
...
-LL | b!(1); b!(2);
- | ----- in this macro invocation
+LL | b!(2);
+ | ----- in this macro invocation
|
= note: this error originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
help: use parentheses instead of braces for this macro
|
-LL | let x = a! () else { return; };
+LL | let 0 = a! () else { return; };
| ~~
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:6:5
+ --> $DIR/bad-let-else-statement.rs:95:5
|
-LL | / let foo = {
+LL | / let foo = bar = {
LL | |
LL | | 1
LL | | } else {
@@ -281,169 +284,7 @@
= note: `#[warn(irrefutable_let_patterns)]` on by default
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:25:5
- |
-LL | / let foo = if true {
-LL | |
-LL | | 1
-LL | | } else {
-LL | | 0
-LL | | } else {
- | |_____^
- |
- = note: this pattern will always match, so the `else` clause is useless
- = help: consider removing the `else` clause
-
-warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:46:5
- |
-LL | / let foo = match true {
-LL | |
-LL | | true => 1,
-LL | | false => 0
-LL | | } else {
- | |_____^
- |
- = note: this pattern will always match, so the `else` clause is useless
- = help: consider removing the `else` clause
-
-warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:58:5
- |
-LL | / let foo = X {
-LL | |
-LL | | a: 1
-LL | | } else {
- | |_____^
- |
- = note: this pattern will always match, so the `else` clause is useless
- = help: consider removing the `else` clause
-
-warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:77:5
- |
-LL | / let foo = const {
-LL | |
-LL | | 1
-LL | | } else {
- | |_____^
- |
- = note: this pattern will always match, so the `else` clause is useless
- = help: consider removing the `else` clause
-
-warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:87:5
- |
-LL | / let foo = &{
-LL | |
-LL | | 1
-LL | | } else {
- | |_____^
- |
- = note: this pattern will always match, so the `else` clause is useless
- = help: consider removing the `else` clause
-
-warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:98:5
- |
-LL | / let foo = bar = {
-LL | |
-LL | | 1
-LL | | } else {
- | |_____^
- |
- = note: this pattern will always match, so the `else` clause is useless
- = help: consider removing the `else` clause
-
-error[E0384]: cannot assign twice to immutable variable `bar`
- --> $DIR/bad-let-else-statement.rs:98:15
- |
-LL | let bar = 0;
- | ---
- | |
- | first assignment to `bar`
- | help: consider making this binding mutable: `mut bar`
-LL | let foo = bar = {
- | _______________^
-LL | |
-LL | | 1
-LL | | } else {
- | |_____^ cannot assign twice to immutable variable
-
-warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:108:5
- |
-LL | / let foo = 1 + {
-LL | |
-LL | | 1
-LL | | } else {
- | |_____^
- |
- = note: this pattern will always match, so the `else` clause is useless
- = help: consider removing the `else` clause
-
-warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:118:5
- |
-LL | / let foo = 1..{
-LL | |
-LL | | 1
-LL | | } else {
- | |_____^
- |
- = note: this pattern will always match, so the `else` clause is useless
- = help: consider removing the `else` clause
-
-warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:128:5
- |
-LL | / let foo = return {
-LL | |
-LL | | ()
-LL | | } else {
- | |_____^
- |
- = note: this pattern will always match, so the `else` clause is useless
- = help: consider removing the `else` clause
-
-warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:138:5
- |
-LL | / let foo = -{
-LL | |
-LL | | 1
-LL | | } else {
- | |_____^
- |
- = note: this pattern will always match, so the `else` clause is useless
- = help: consider removing the `else` clause
-
-warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:148:5
- |
-LL | / let foo = do yeet {
-LL | |
-LL | | ()
-LL | | } else {
- | |_____^
- |
- = note: this pattern will always match, so the `else` clause is useless
- = help: consider removing the `else` clause
-
-warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:158:5
- |
-LL | / let foo = become {
-LL | |
-LL | | ()
-LL | | } else {
- | |_____^
- |
- = note: this pattern will always match, so the `else` clause is useless
- = help: consider removing the `else` clause
-
-warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:168:5
+ --> $DIR/bad-let-else-statement.rs:160:5
|
LL | / let foo = |x: i32| {
LL | |
@@ -455,7 +296,7 @@
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:178:5
+ --> $DIR/bad-let-else-statement.rs:170:5
|
LL | let ok = format_args!("") else { return; };
| ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -464,7 +305,7 @@
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:181:5
+ --> $DIR/bad-let-else-statement.rs:173:5
|
LL | let bad = format_args! {""} else { return; };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -473,45 +314,16 @@
= help: consider removing the `else` clause
warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:188:19
+ --> $DIR/bad-let-else-statement.rs:204:5
|
-LL | () => { {} }
- | ___________________^
+LL | / let foo = &std::ptr::null as &'static dyn std::ops::Fn() -> *const primitive! {
LL | |
-LL | |
-LL | | }
-... |
-LL | | (1) => {
-LL | | let x = a!() else { return; };
- | |____________^
-...
-LL | b!(1); b!(2);
- | ----- in this macro invocation
+LL | | 8
+LL | | } else {
+ | |_____^
|
= note: this pattern will always match, so the `else` clause is useless
= help: consider removing the `else` clause
- = note: this warning originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
-warning: irrefutable `let...else` pattern
- --> $DIR/bad-let-else-statement.rs:188:19
- |
-LL | () => { {} }
- | ___________________^
-LL | |
-LL | |
-LL | | }
-... |
-LL | | (2) => {
-LL | | let x = a! {} else { return; };
- | |____________^
-...
-LL | b!(1); b!(2);
- | ----- in this macro invocation
- |
- = note: this pattern will always match, so the `else` clause is useless
- = help: consider removing the `else` clause
- = note: this warning originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
+error: aborting due to 20 previous errors; 5 warnings emitted
-error: aborting due to 20 previous errors; 18 warnings emitted
-
-For more information about this error, try `rustc --explain E0384`.
diff --git a/tests/ui/parser/break-in-unlabeled-block-in-macro.stderr b/tests/ui/parser/break-in-unlabeled-block-in-macro.stderr
index 9407e8a..2f46cb3 100644
--- a/tests/ui/parser/break-in-unlabeled-block-in-macro.stderr
+++ b/tests/ui/parser/break-in-unlabeled-block-in-macro.stderr
@@ -21,16 +21,21 @@
= note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0268]: `break` outside of a loop or labeled block
- --> $DIR/break-in-unlabeled-block-in-macro.rs:27:19
+ --> $DIR/break-in-unlabeled-block-in-macro.rs:33:17
|
-LL | foo!(stmt break ());
- | ^^^^^^^^ cannot `break` outside of a loop or labeled block
+LL | foo!(=> break ());
+ | ^^^^^^^^ cannot `break` outside of a loop or labeled block
+
+error[E0268]: `break` outside of a loop or labeled block
+ --> $DIR/break-in-unlabeled-block-in-macro.rs:38:17
|
-help: consider labeling this block to be able to break within it
+LL | break ()
+ | ^^^^^^^^ cannot `break` outside of a loop or labeled block
+...
+LL | bar!()
+ | ------ in this macro invocation
|
-LL ~ 'block: {
-LL ~ foo!(stmt break 'block ());
- |
+ = note: this error originates in the macro `bar` (in Nightly builds, run with -Z macro-backtrace for more info)
error[E0268]: `break` outside of a loop or labeled block
--> $DIR/break-in-unlabeled-block-in-macro.rs:12:11
@@ -48,21 +53,16 @@
| +++++++ ++++++
error[E0268]: `break` outside of a loop or labeled block
- --> $DIR/break-in-unlabeled-block-in-macro.rs:33:17
+ --> $DIR/break-in-unlabeled-block-in-macro.rs:27:19
|
-LL | foo!(=> break ());
- | ^^^^^^^^ cannot `break` outside of a loop or labeled block
-
-error[E0268]: `break` outside of a loop or labeled block
- --> $DIR/break-in-unlabeled-block-in-macro.rs:38:17
+LL | foo!(stmt break ());
+ | ^^^^^^^^ cannot `break` outside of a loop or labeled block
|
-LL | break ()
- | ^^^^^^^^ cannot `break` outside of a loop or labeled block
-...
-LL | bar!()
- | ------ in this macro invocation
+help: consider labeling this block to be able to break within it
|
- = note: this error originates in the macro `bar` (in Nightly builds, run with -Z macro-backtrace for more info)
+LL ~ 'block: {
+LL ~ foo!(stmt break 'block ());
+ |
error: aborting due to 6 previous errors
diff --git a/tests/ui/privacy/pub-priv-dep/auxiliary/diamond_priv_dep.rs b/tests/ui/privacy/pub-priv-dep/auxiliary/diamond_priv_dep.rs
new file mode 100644
index 0000000..ed76815
--- /dev/null
+++ b/tests/ui/privacy/pub-priv-dep/auxiliary/diamond_priv_dep.rs
@@ -0,0 +1,9 @@
+//@ aux-crate:shared=shared.rs
+
+extern crate shared;
+
+pub use shared::Shared;
+
+pub struct SharedInType {
+ pub f: Shared
+}
diff --git a/tests/ui/privacy/pub-priv-dep/auxiliary/diamond_pub_dep.rs b/tests/ui/privacy/pub-priv-dep/auxiliary/diamond_pub_dep.rs
new file mode 100644
index 0000000..ed76815
--- /dev/null
+++ b/tests/ui/privacy/pub-priv-dep/auxiliary/diamond_pub_dep.rs
@@ -0,0 +1,9 @@
+//@ aux-crate:shared=shared.rs
+
+extern crate shared;
+
+pub use shared::Shared;
+
+pub struct SharedInType {
+ pub f: Shared
+}
diff --git a/tests/ui/privacy/pub-priv-dep/auxiliary/indirect1.rs b/tests/ui/privacy/pub-priv-dep/auxiliary/indirect1.rs
new file mode 100644
index 0000000..0e4a73c
--- /dev/null
+++ b/tests/ui/privacy/pub-priv-dep/auxiliary/indirect1.rs
@@ -0,0 +1,4 @@
+//@ aux-crate:priv:indirect2=indirect2.rs
+//@ compile-flags: -Zunstable-options
+
+extern crate indirect2;
diff --git a/tests/ui/privacy/pub-priv-dep/auxiliary/indirect2.rs b/tests/ui/privacy/pub-priv-dep/auxiliary/indirect2.rs
new file mode 100644
index 0000000..5f6b289
--- /dev/null
+++ b/tests/ui/privacy/pub-priv-dep/auxiliary/indirect2.rs
@@ -0,0 +1,4 @@
+//@ aux-crate:shared=shared.rs
+
+// This is public.
+extern crate shared;
diff --git a/tests/ui/privacy/pub-priv-dep/auxiliary/pm.rs b/tests/ui/privacy/pub-priv-dep/auxiliary/pm.rs
new file mode 100644
index 0000000..9e2aa89
--- /dev/null
+++ b/tests/ui/privacy/pub-priv-dep/auxiliary/pm.rs
@@ -0,0 +1,22 @@
+//@ force-host
+//@ no-prefer-dynamic
+
+#![crate_type = "proc-macro"]
+
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+#[proc_macro]
+pub fn fn_like(input: TokenStream) -> TokenStream {
+ "".parse().unwrap()
+}
+
+#[proc_macro_derive(PmDerive)]
+pub fn pm_derive(item: TokenStream) -> TokenStream {
+ "".parse().unwrap()
+}
+
+#[proc_macro_attribute]
+pub fn pm_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
+ "".parse().unwrap()
+}
diff --git a/tests/ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs b/tests/ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs
index e7afeb8..4eeecdc 100644
--- a/tests/ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs
+++ b/tests/ui/privacy/pub-priv-dep/auxiliary/priv_dep.rs
@@ -1,2 +1,11 @@
pub struct OtherType;
pub trait OtherTrait {}
+
+#[macro_export]
+macro_rules! m {
+ () => {};
+}
+
+pub enum E {
+ V1
+}
diff --git a/tests/ui/privacy/pub-priv-dep/auxiliary/reexport.rs b/tests/ui/privacy/pub-priv-dep/auxiliary/reexport.rs
new file mode 100644
index 0000000..0655e3a
--- /dev/null
+++ b/tests/ui/privacy/pub-priv-dep/auxiliary/reexport.rs
@@ -0,0 +1,5 @@
+//@ aux-crate:shared=shared.rs
+
+extern crate shared;
+
+pub use shared::Shared;
diff --git a/tests/ui/privacy/pub-priv-dep/auxiliary/shared.rs b/tests/ui/privacy/pub-priv-dep/auxiliary/shared.rs
new file mode 100644
index 0000000..efc4daa
--- /dev/null
+++ b/tests/ui/privacy/pub-priv-dep/auxiliary/shared.rs
@@ -0,0 +1 @@
+pub struct Shared;
diff --git a/tests/ui/privacy/pub-priv-dep/diamond_deps.rs b/tests/ui/privacy/pub-priv-dep/diamond_deps.rs
new file mode 100644
index 0000000..0e1f6f3
--- /dev/null
+++ b/tests/ui/privacy/pub-priv-dep/diamond_deps.rs
@@ -0,0 +1,48 @@
+//@ aux-crate:priv:diamond_priv_dep=diamond_priv_dep.rs
+//@ aux-crate:diamond_pub_dep=diamond_pub_dep.rs
+//@ compile-flags: -Zunstable-options
+
+// A diamond dependency:
+//
+// diamond_reepxort
+// /\
+// (public) / \ (PRIVATE)
+// / \
+// diamond_pub_dep diamond_priv_dep
+// \ /
+// (public) \ / (public)
+// \/
+// shared
+//
+// Where the pub and private crates reexport something from the shared crate.
+//
+// Checks the behavior when the same shared item appears in the public API,
+// depending on whether it comes from the public side or the private side.
+//
+// NOTE: compiletest does not support deduplicating shared dependencies.
+// However, it should work well enough for this test, the only downside is
+// that diamond_shared gets built twice.
+
+#![crate_type = "lib"]
+#![deny(exported_private_dependencies)]
+
+extern crate diamond_priv_dep;
+extern crate diamond_pub_dep;
+
+// FIXME: This should trigger.
+pub fn leaks_priv() -> diamond_priv_dep::Shared {
+ diamond_priv_dep::Shared
+}
+
+pub fn leaks_pub() -> diamond_pub_dep::Shared {
+ diamond_pub_dep::Shared
+}
+
+pub struct PrivInStruct {
+ pub f: diamond_priv_dep::SharedInType
+//~^ ERROR type `diamond_priv_dep::SharedInType` from private dependency 'diamond_priv_dep' in public interface
+}
+
+pub struct PubInStruct {
+ pub f: diamond_pub_dep::SharedInType
+}
diff --git a/tests/ui/privacy/pub-priv-dep/diamond_deps.stderr b/tests/ui/privacy/pub-priv-dep/diamond_deps.stderr
new file mode 100644
index 0000000..8a6d35a
--- /dev/null
+++ b/tests/ui/privacy/pub-priv-dep/diamond_deps.stderr
@@ -0,0 +1,14 @@
+error: type `diamond_priv_dep::SharedInType` from private dependency 'diamond_priv_dep' in public interface
+ --> $DIR/diamond_deps.rs:42:5
+ |
+LL | pub f: diamond_priv_dep::SharedInType
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ |
+note: the lint level is defined here
+ --> $DIR/diamond_deps.rs:27:9
+ |
+LL | #![deny(exported_private_dependencies)]
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/privacy/pub-priv-dep/pub-priv1.rs b/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
index f26dbb4..112eaf5 100644
--- a/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
+++ b/tests/ui/privacy/pub-priv-dep/pub-priv1.rs
@@ -1,12 +1,20 @@
//@ aux-crate:priv:priv_dep=priv_dep.rs
//@ aux-build:pub_dep.rs
+//@ aux-crate:priv:pm=pm.rs
//@ compile-flags: -Zunstable-options
+
+// Basic behavior check of exported_private_dependencies from either a public
+// dependency or a private one.
+
#![deny(exported_private_dependencies)]
// This crate is a private dependency
-extern crate priv_dep;
+// FIXME: This should trigger.
+pub extern crate priv_dep;
// This crate is a public dependency
extern crate pub_dep;
+// This crate is a private dependency
+extern crate pm;
use priv_dep::{OtherTrait, OtherType};
use pub_dep::PubType;
@@ -25,7 +33,10 @@
}
impl PublicType {
- pub fn pub_fn(param: OtherType) {}
+ pub fn pub_fn_param(param: OtherType) {}
+ //~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+
+ pub fn pub_fn_return() -> OtherType { OtherType }
//~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
fn priv_fn(param: OtherType) {}
@@ -36,9 +47,61 @@
}
//~^^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
+pub trait WithSuperTrait: OtherTrait {}
+//~^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
+
+pub trait PubLocalTraitWithAssoc {
+ type X;
+}
+
+pub struct PrivateAssoc;
+impl PubLocalTraitWithAssoc for PrivateAssoc {
+ type X = OtherType;
+//~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+}
+
+pub fn in_bounds<T: OtherTrait>(x: T) { unimplemented!() }
+//~^ ERROR trait `OtherTrait` from private dependency 'priv_dep' in public interface
+
+pub fn private_in_generic() -> std::num::Saturating<OtherType> { unimplemented!() }
+//~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+
+pub static STATIC: OtherType = OtherType;
+//~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+
+pub const CONST: OtherType = OtherType;
+//~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+
+pub type Alias = OtherType;
+//~^ ERROR type `OtherType` from private dependency 'priv_dep' in public interface
+
+pub struct PublicWithPrivateImpl;
+
+// FIXME: This should trigger.
+// See https://github.com/rust-lang/rust/issues/71043
+impl OtherTrait for PublicWithPrivateImpl {}
+
+pub trait PubTraitOnPrivate {}
+
+// FIXME: This should trigger.
+// See https://github.com/rust-lang/rust/issues/71043
+impl PubTraitOnPrivate for OtherType {}
+
pub struct AllowedPrivType {
#[allow(exported_private_dependencies)]
pub allowed: OtherType,
}
+// FIXME: This should trigger.
+pub use priv_dep::m;
+// FIXME: This should trigger.
+pub use pm::fn_like;
+// FIXME: This should trigger.
+pub use pm::PmDerive;
+// FIXME: This should trigger.
+pub use pm::pm_attr;
+
+// FIXME: This should trigger.
+pub use priv_dep::E::V1;
+
fn main() {}
diff --git a/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr b/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
index e62a440..53d461a 100644
--- a/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
+++ b/tests/ui/privacy/pub-priv-dep/pub-priv1.stderr
@@ -1,26 +1,74 @@
error: type `OtherType` from private dependency 'priv_dep' in public interface
- --> $DIR/pub-priv1.rs:21:5
+ --> $DIR/pub-priv1.rs:29:5
|
LL | pub field: OtherType,
| ^^^^^^^^^^^^^^^^^^^^
|
note: the lint level is defined here
- --> $DIR/pub-priv1.rs:4:9
+ --> $DIR/pub-priv1.rs:9:9
|
LL | #![deny(exported_private_dependencies)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: type `OtherType` from private dependency 'priv_dep' in public interface
- --> $DIR/pub-priv1.rs:28:5
+ --> $DIR/pub-priv1.rs:36:5
|
-LL | pub fn pub_fn(param: OtherType) {}
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | pub fn pub_fn_param(param: OtherType) {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+ --> $DIR/pub-priv1.rs:39:5
+ |
+LL | pub fn pub_fn_return() -> OtherType { OtherType }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
- --> $DIR/pub-priv1.rs:35:5
+ --> $DIR/pub-priv1.rs:46:5
|
LL | type Foo: OtherTrait;
| ^^^^^^^^^^^^^^^^^^^^
-error: aborting due to 3 previous errors
+error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
+ --> $DIR/pub-priv1.rs:50:1
+ |
+LL | pub trait WithSuperTrait: OtherTrait {}
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+ --> $DIR/pub-priv1.rs:59:5
+ |
+LL | type X = OtherType;
+ | ^^^^^^
+
+error: trait `OtherTrait` from private dependency 'priv_dep' in public interface
+ --> $DIR/pub-priv1.rs:63:1
+ |
+LL | pub fn in_bounds<T: OtherTrait>(x: T) { unimplemented!() }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+ --> $DIR/pub-priv1.rs:66:1
+ |
+LL | pub fn private_in_generic() -> std::num::Saturating<OtherType> { unimplemented!() }
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+ --> $DIR/pub-priv1.rs:69:1
+ |
+LL | pub static STATIC: OtherType = OtherType;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+ --> $DIR/pub-priv1.rs:72:1
+ |
+LL | pub const CONST: OtherType = OtherType;
+ | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: type `OtherType` from private dependency 'priv_dep' in public interface
+ --> $DIR/pub-priv1.rs:75:1
+ |
+LL | pub type Alias = OtherType;
+ | ^^^^^^^^^^^^^^
+
+error: aborting due to 11 previous errors
diff --git a/tests/ui/privacy/pub-priv-dep/reexport_from_priv.rs b/tests/ui/privacy/pub-priv-dep/reexport_from_priv.rs
new file mode 100644
index 0000000..3c6e982
--- /dev/null
+++ b/tests/ui/privacy/pub-priv-dep/reexport_from_priv.rs
@@ -0,0 +1,15 @@
+//@ aux-crate:priv:reexport=reexport.rs
+//@ compile-flags: -Zunstable-options
+//@ check-pass
+
+// Checks the behavior of a reexported item from a private dependency.
+
+#![crate_type = "lib"]
+#![deny(exported_private_dependencies)]
+
+extern crate reexport;
+
+// FIXME: This should trigger.
+pub fn leaks_priv() -> reexport::Shared {
+ reexport::Shared
+}
diff --git a/tests/ui/privacy/pub-priv-dep/shared_both_private.rs b/tests/ui/privacy/pub-priv-dep/shared_both_private.rs
new file mode 100644
index 0000000..20a4b85
--- /dev/null
+++ b/tests/ui/privacy/pub-priv-dep/shared_both_private.rs
@@ -0,0 +1,32 @@
+//@ aux-crate:priv:shared=shared.rs
+//@ aux-crate:reexport=reexport.rs
+//@ compile-flags: -Zunstable-options
+//@ check-pass
+
+// A shared dependency, where a private dependency reexports a public dependency.
+//
+// shared_both_private
+// /\
+// (PRIVATE) / | (PRIVATE)
+// / |
+// reexport |
+// \ |
+// (public) \ /
+// \/
+// shared
+
+#![crate_type = "lib"]
+#![deny(exported_private_dependencies)]
+
+extern crate shared;
+extern crate reexport;
+
+// FIXME: This should trigger.
+pub fn leaks_priv() -> shared::Shared {
+ shared::Shared
+}
+
+// FIXME: This should trigger.
+pub fn leaks_priv_reexport() -> reexport::Shared {
+ reexport::Shared
+}
diff --git a/tests/ui/privacy/pub-priv-dep/shared_direct_private.rs b/tests/ui/privacy/pub-priv-dep/shared_direct_private.rs
new file mode 100644
index 0000000..b329a7a
--- /dev/null
+++ b/tests/ui/privacy/pub-priv-dep/shared_direct_private.rs
@@ -0,0 +1,39 @@
+//@ aux-crate:priv:shared=shared.rs
+//@ aux-crate:reexport=reexport.rs
+//@ compile-flags: -Zunstable-options
+//@ check-pass
+
+// A shared dependency, where the public side reexports the same item as a
+// direct private dependency.
+//
+// shared_direct_private
+// /\
+// (public) / | (PRIVATE)
+// / |
+// reexport |
+// \ |
+// (public) \ /
+// \/
+// shared
+//
+
+#![crate_type = "lib"]
+#![deny(exported_private_dependencies)]
+
+extern crate shared;
+extern crate reexport;
+
+// FIXME: Should this trigger?
+//
+// One could make an argument that I said I want "reexport" to be public, and
+// since "reexport" says "shared_direct_private" is public, then it should
+// transitively be public for me. However, as written, this is explicitly
+// referring to a dependency that is marked "private", which I think is
+// confusing.
+pub fn leaks_priv() -> shared::Shared {
+ shared::Shared
+}
+
+pub fn leaks_pub() -> reexport::Shared {
+ reexport::Shared
+}
diff --git a/tests/ui/privacy/pub-priv-dep/shared_indirect.rs b/tests/ui/privacy/pub-priv-dep/shared_indirect.rs
new file mode 100644
index 0000000..34b624b
--- /dev/null
+++ b/tests/ui/privacy/pub-priv-dep/shared_indirect.rs
@@ -0,0 +1,29 @@
+//@ aux-crate:priv:shared=shared.rs
+//@ aux-crate:priv:indirect1=indirect1.rs
+//@ compile-flags: -Zunstable-options
+//@ check-pass
+
+// A shared dependency, where it is only indirectly public.
+//
+// shared_indirect
+// /\
+// (PRIVATE) / | (PRIVATE)
+// / |
+// indirect1 | |
+// (PRIVATE) | |
+// indirect2 | |
+// \ |
+// (public) \ /
+// \/
+// shared
+
+#![crate_type = "lib"]
+#![deny(exported_private_dependencies)]
+
+extern crate shared;
+extern crate indirect1;
+
+// FIXME: This should trigger.
+pub fn leaks_priv() -> shared::Shared {
+ shared::Shared
+}
diff --git a/tests/ui/pub/pub-reexport-priv-extern-crate.stderr b/tests/ui/pub/pub-reexport-priv-extern-crate.stderr
index c7fadc6..3fa5b0f 100644
--- a/tests/ui/pub/pub-reexport-priv-extern-crate.stderr
+++ b/tests/ui/pub/pub-reexport-priv-extern-crate.stderr
@@ -22,7 +22,7 @@
LL | extern crate core;
| ^^^^^^^^^^^^^^^^^^
-error: extern crate `core` is private, and cannot be re-exported (error E0365), consider declaring with `pub`
+error[E0365]: extern crate `core` is private, and cannot be re-exported, consider declaring with `pub`
--> $DIR/pub-reexport-priv-extern-crate.rs:2:9
|
LL | pub use core as reexported_core;
@@ -34,4 +34,5 @@
error: aborting due to 3 previous errors
-For more information about this error, try `rustc --explain E0603`.
+Some errors have detailed explanations: E0365, E0603.
+For more information about an error, try `rustc --explain E0365`.
diff --git a/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.stderr b/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.stderr
index aa660db..537819a 100644
--- a/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.stderr
+++ b/tests/ui/rfcs/rfc-2396-target_feature-11/safe-calls.stderr
@@ -91,7 +91,7 @@
= help: in order for the call to be safe, the context requires the following additional target features: sse2 and fxsr
= note: the fxsr and sse2 target features being enabled in the build configuration does not remove the requirement to list them in `#[target_feature]`
-error: call to function `sse2` with `#[target_feature]` is unsafe and requires unsafe block (error E0133)
+error[E0133]: call to function `sse2` with `#[target_feature]` is unsafe and requires unsafe block
--> $DIR/safe-calls.rs:70:5
|
LL | sse2();
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/rust-2021/inherent-dyn-collision.fixed b/tests/ui/rust-2021/inherent-dyn-collision.fixed
index f570261..8fe1bf8 100644
--- a/tests/ui/rust-2021/inherent-dyn-collision.fixed
+++ b/tests/ui/rust-2021/inherent-dyn-collision.fixed
@@ -25,6 +25,7 @@
// having a struct of the same name as the trait in-scope, while *also*
// implementing the trait for that struct but **without** importing the
// trait itself into scope
+ #[allow(dead_code)]
struct TryIntoU32;
impl super::TryIntoU32 for TryIntoU32 {
diff --git a/tests/ui/rust-2021/inherent-dyn-collision.rs b/tests/ui/rust-2021/inherent-dyn-collision.rs
index 0bcb34e..47c8446 100644
--- a/tests/ui/rust-2021/inherent-dyn-collision.rs
+++ b/tests/ui/rust-2021/inherent-dyn-collision.rs
@@ -25,6 +25,7 @@
// having a struct of the same name as the trait in-scope, while *also*
// implementing the trait for that struct but **without** importing the
// trait itself into scope
+ #[allow(dead_code)]
struct TryIntoU32;
impl super::TryIntoU32 for TryIntoU32 {
diff --git a/tests/ui/rust-2021/inherent-dyn-collision.stderr b/tests/ui/rust-2021/inherent-dyn-collision.stderr
index f590557..d9e720d 100644
--- a/tests/ui/rust-2021/inherent-dyn-collision.stderr
+++ b/tests/ui/rust-2021/inherent-dyn-collision.stderr
@@ -1,5 +1,5 @@
warning: trait method `try_into` will become ambiguous in Rust 2021
- --> $DIR/inherent-dyn-collision.rs:41:9
+ --> $DIR/inherent-dyn-collision.rs:42:9
|
LL | get_dyn_trait().try_into().unwrap()
| ^^^^^^^^^^^^^^^ help: disambiguate the method call: `(&*get_dyn_trait())`
diff --git a/tests/ui/threads-sendsync/issue-43733-2.rs b/tests/ui/threads-sendsync/issue-43733-2.rs
deleted file mode 100644
index 372ebf2..0000000
--- a/tests/ui/threads-sendsync/issue-43733-2.rs
+++ /dev/null
@@ -1,30 +0,0 @@
-//@ needs-threads
-//@ dont-check-compiler-stderr
-#![feature(cfg_target_thread_local, thread_local_internals)]
-
-// On platforms *without* `#[thread_local]`, use
-// a custom non-`Sync` type to fake the same error.
-#[cfg(not(target_thread_local))]
-struct Key<T> {
- _data: std::cell::UnsafeCell<Option<T>>,
- _flag: std::cell::Cell<()>,
-}
-
-#[cfg(not(target_thread_local))]
-impl<T> Key<T> {
- const fn new() -> Self {
- Key {
- _data: std::cell::UnsafeCell::new(None),
- _flag: std::cell::Cell::new(()),
- }
- }
-}
-
-#[cfg(target_thread_local)]
-use std::thread::local_impl::Key;
-
-static __KEY: Key<()> = Key::new();
-//~^ ERROR `UnsafeCell<Option<()>>` cannot be shared between threads
-//~| ERROR cannot be shared between threads safely [E0277]
-
-fn main() {}
diff --git a/tests/ui/threads-sendsync/issue-43733.rs b/tests/ui/threads-sendsync/issue-43733.rs
deleted file mode 100644
index c90f608..0000000
--- a/tests/ui/threads-sendsync/issue-43733.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//@ needs-threads
-#![feature(thread_local)]
-#![feature(cfg_target_thread_local, thread_local_internals)]
-
-use std::cell::RefCell;
-
-type Foo = std::cell::RefCell<String>;
-
-#[cfg(target_thread_local)]
-#[thread_local]
-static __KEY: std::thread::local_impl::Key<Foo> = std::thread::local_impl::Key::new();
-
-#[cfg(not(target_thread_local))]
-static __KEY: std::thread::local_impl::Key<Foo> = std::thread::local_impl::Key::new();
-
-fn __getit(_: Option<&mut Option<RefCell<String>>>) -> std::option::Option<&'static Foo> {
- __KEY.get(Default::default)
- //~^ ERROR call to unsafe function `Key::<T>::get` is unsafe
-}
-
-static FOO: std::thread::LocalKey<Foo> = std::thread::LocalKey::new(__getit);
-//~^ ERROR call to unsafe function `LocalKey::<T>::new` is unsafe
-
-fn main() {
- FOO.with(|foo| println!("{}", foo.borrow()));
- std::thread::spawn(|| {
- FOO.with(|foo| *foo.borrow_mut() += "foo");
- })
- .join()
- .unwrap();
- FOO.with(|foo| println!("{}", foo.borrow()));
-}
diff --git a/tests/ui/threads-sendsync/issue-43733.stderr b/tests/ui/threads-sendsync/issue-43733.stderr
deleted file mode 100644
index 9b13646..0000000
--- a/tests/ui/threads-sendsync/issue-43733.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0133]: call to unsafe function `Key::<T>::get` is unsafe and requires unsafe function or block
- --> $DIR/issue-43733.rs:17:5
- |
-LL | __KEY.get(Default::default)
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
- |
- = note: consult the function's documentation for information on how to avoid undefined behavior
-
-error[E0133]: call to unsafe function `LocalKey::<T>::new` is unsafe and requires unsafe function or block
- --> $DIR/issue-43733.rs:21:42
- |
-LL | static FOO: std::thread::LocalKey<Foo> = std::thread::LocalKey::new(__getit);
- | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ call to unsafe function
- |
- = note: consult the function's documentation for information on how to avoid undefined behavior
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.rs b/tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.rs
new file mode 100644
index 0000000..050b7b4
--- /dev/null
+++ b/tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.rs
@@ -0,0 +1,10 @@
+#![feature(pattern_types, core_pattern_type)]
+#![allow(internal_features)]
+
+type Pat<const START: u32, const END: u32> =
+ std::pat::pattern_type!(u32 is START::<(), i32, 2>..=END::<_, Assoc = ()>);
+//~^ ERROR type and const arguments are not allowed on const parameter `START`
+//~| ERROR type arguments are not allowed on const parameter `END`
+//~| ERROR associated type bindings are not allowed here
+
+fn main() {}
diff --git a/tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.stderr b/tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.stderr
new file mode 100644
index 0000000..40effe9
--- /dev/null
+++ b/tests/ui/type/pattern_types/bad_const_generics_args_on_const_param.stderr
@@ -0,0 +1,38 @@
+error[E0109]: type and const arguments are not allowed on const parameter `START`
+ --> $DIR/bad_const_generics_args_on_const_param.rs:5:44
+ |
+LL | std::pat::pattern_type!(u32 is START::<(), i32, 2>..=END::<_, Assoc = ()>);
+ | ----- ^^ ^^^ ^ type and const arguments not allowed
+ | |
+ | not allowed on const parameter `START`
+ |
+note: const parameter `START` defined here
+ --> $DIR/bad_const_generics_args_on_const_param.rs:4:16
+ |
+LL | type Pat<const START: u32, const END: u32> =
+ | ^^^^^
+
+error[E0109]: type arguments are not allowed on const parameter `END`
+ --> $DIR/bad_const_generics_args_on_const_param.rs:5:64
+ |
+LL | std::pat::pattern_type!(u32 is START::<(), i32, 2>..=END::<_, Assoc = ()>);
+ | --- ^ type argument not allowed
+ | |
+ | not allowed on const parameter `END`
+ |
+note: const parameter `END` defined here
+ --> $DIR/bad_const_generics_args_on_const_param.rs:4:34
+ |
+LL | type Pat<const START: u32, const END: u32> =
+ | ^^^
+
+error[E0229]: associated type bindings are not allowed here
+ --> $DIR/bad_const_generics_args_on_const_param.rs:5:67
+ |
+LL | std::pat::pattern_type!(u32 is START::<(), i32, 2>..=END::<_, Assoc = ()>);
+ | ^^^^^^^^^^ associated type not allowed here
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0109, E0229.
+For more information about an error, try `rustc --explain E0109`.
diff --git a/tests/ui/type/pattern_types/bad_pat.stderr b/tests/ui/type/pattern_types/bad_pat.stderr
index 4f0f0bc..2abf271 100644
--- a/tests/ui/type/pattern_types/bad_pat.stderr
+++ b/tests/ui/type/pattern_types/bad_pat.stderr
@@ -14,7 +14,7 @@
|
= note: inclusive ranges must be bounded at the end (`..=b` or `a..=b`)
-error: "wildcard patterns are not permitted for pattern types"
+error: wildcard patterns are not permitted for pattern types
--> $DIR/bad_pat.rs:11:33
|
LL | type Wild = pattern_type!(() is _);
diff --git a/tests/ui/unsafe/edition-2024-unsafe_op_in_unsafe_fn.stderr b/tests/ui/unsafe/edition-2024-unsafe_op_in_unsafe_fn.stderr
index 2eb1754..fe12dd7 100644
--- a/tests/ui/unsafe/edition-2024-unsafe_op_in_unsafe_fn.stderr
+++ b/tests/ui/unsafe/edition-2024-unsafe_op_in_unsafe_fn.stderr
@@ -1,4 +1,4 @@
-warning: call to unsafe function `unsf` is unsafe and requires unsafe block (error E0133)
+warning[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
--> $DIR/edition-2024-unsafe_op_in_unsafe_fn.rs:10:5
|
LL | unsf();
@@ -15,3 +15,4 @@
warning: 1 warning emitted
+For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/edition_2024_default.stderr b/tests/ui/unsafe/unsafe_op_in_unsafe_fn/edition_2024_default.stderr
index e6d1d4e..05f36ab 100644
--- a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/edition_2024_default.stderr
+++ b/tests/ui/unsafe/unsafe_op_in_unsafe_fn/edition_2024_default.stderr
@@ -1,4 +1,4 @@
-warning: call to unsafe function `unsf` is unsafe and requires unsafe block (error E0133)
+warning[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
--> $DIR/edition_2024_default.rs:13:5
|
LL | unsf();
@@ -15,3 +15,4 @@
warning: 1 warning emitted
+For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/in_2024_compatibility.stderr b/tests/ui/unsafe/unsafe_op_in_unsafe_fn/in_2024_compatibility.stderr
index 5092c1e..3f97199 100644
--- a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/in_2024_compatibility.stderr
+++ b/tests/ui/unsafe/unsafe_op_in_unsafe_fn/in_2024_compatibility.stderr
@@ -1,4 +1,4 @@
-error: call to unsafe function `unsf` is unsafe and requires unsafe block (error E0133)
+error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
--> $DIR/in_2024_compatibility.rs:7:5
|
LL | unsf();
@@ -20,3 +20,4 @@
error: aborting due to 1 previous error
+For more information about this error, try `rustc --explain E0133`.
diff --git a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/rfc-2585-unsafe_op_in_unsafe_fn.stderr b/tests/ui/unsafe/unsafe_op_in_unsafe_fn/rfc-2585-unsafe_op_in_unsafe_fn.stderr
index 4bc604a1..1f80342 100644
--- a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/rfc-2585-unsafe_op_in_unsafe_fn.stderr
+++ b/tests/ui/unsafe/unsafe_op_in_unsafe_fn/rfc-2585-unsafe_op_in_unsafe_fn.stderr
@@ -1,4 +1,4 @@
-error: call to unsafe function `unsf` is unsafe and requires unsafe block (error E0133)
+error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
--> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:9:5
|
LL | unsf();
@@ -17,7 +17,7 @@
LL | #![deny(unsafe_op_in_unsafe_fn)]
| ^^^^^^^^^^^^^^^^^^^^^^
-error: dereference of raw pointer is unsafe and requires unsafe block (error E0133)
+error[E0133]: dereference of raw pointer is unsafe and requires unsafe block
--> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:11:5
|
LL | *PTR;
@@ -26,7 +26,7 @@
= note: for more information, see issue #71668 <https://github.com/rust-lang/rust/issues/71668>
= note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
-error: use of mutable static is unsafe and requires unsafe block (error E0133)
+error[E0133]: use of mutable static is unsafe and requires unsafe block
--> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:13:5
|
LL | VOID = ();
@@ -47,7 +47,7 @@
LL | #![deny(unused_unsafe)]
| ^^^^^^^^^^^^^
-error: call to unsafe function `unsf` is unsafe and requires unsafe block (error E0133)
+error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
--> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:24:5
|
LL | unsf();
@@ -67,7 +67,7 @@
| ^^^^^^^^
= note: `#[deny(unsafe_op_in_unsafe_fn)]` implied by `#[deny(warnings)]`
-error: dereference of raw pointer is unsafe and requires unsafe block (error E0133)
+error[E0133]: dereference of raw pointer is unsafe and requires unsafe block
--> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:26:5
|
LL | *PTR;
@@ -76,7 +76,7 @@
= note: for more information, see issue #71668 <https://github.com/rust-lang/rust/issues/71668>
= note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
-error: use of mutable static is unsafe and requires unsafe block (error E0133)
+error[E0133]: use of mutable static is unsafe and requires unsafe block
--> $DIR/rfc-2585-unsafe_op_in_unsafe_fn.rs:28:5
|
LL | VOID = ();
diff --git a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/wrapping-unsafe-block-sugg.stderr b/tests/ui/unsafe/unsafe_op_in_unsafe_fn/wrapping-unsafe-block-sugg.stderr
index b9f5969..1ce22ec 100644
--- a/tests/ui/unsafe/unsafe_op_in_unsafe_fn/wrapping-unsafe-block-sugg.stderr
+++ b/tests/ui/unsafe/unsafe_op_in_unsafe_fn/wrapping-unsafe-block-sugg.stderr
@@ -1,4 +1,4 @@
-error: call to unsafe function `unsf` is unsafe and requires unsafe block (error E0133)
+error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
--> $DIR/wrapping-unsafe-block-sugg.rs:13:5
|
LL | unsf();
@@ -17,7 +17,7 @@
LL | #![deny(unsafe_op_in_unsafe_fn)]
| ^^^^^^^^^^^^^^^^^^^^^^
-error: call to unsafe function `unsf` is unsafe and requires unsafe block (error E0133)
+error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
--> $DIR/wrapping-unsafe-block-sugg.rs:17:5
|
LL | unsf();
@@ -26,7 +26,7 @@
= note: for more information, see issue #71668 <https://github.com/rust-lang/rust/issues/71668>
= note: consult the function's documentation for information on how to avoid undefined behavior
-error: dereference of raw pointer is unsafe and requires unsafe block (error E0133)
+error[E0133]: dereference of raw pointer is unsafe and requires unsafe block
--> $DIR/wrapping-unsafe-block-sugg.rs:25:13
|
LL | let y = *x;
@@ -40,7 +40,7 @@
LL | pub unsafe fn bar(x: *const i32) -> i32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-error: dereference of raw pointer is unsafe and requires unsafe block (error E0133)
+error[E0133]: dereference of raw pointer is unsafe and requires unsafe block
--> $DIR/wrapping-unsafe-block-sugg.rs:29:9
|
LL | y + *x
@@ -49,7 +49,7 @@
= note: for more information, see issue #71668 <https://github.com/rust-lang/rust/issues/71668>
= note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior
-error: use of mutable static is unsafe and requires unsafe block (error E0133)
+error[E0133]: use of mutable static is unsafe and requires unsafe block
--> $DIR/wrapping-unsafe-block-sugg.rs:38:13
|
LL | let y = BAZ;
@@ -63,7 +63,7 @@
LL | pub unsafe fn baz() -> i32 {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^
-error: use of mutable static is unsafe and requires unsafe block (error E0133)
+error[E0133]: use of mutable static is unsafe and requires unsafe block
--> $DIR/wrapping-unsafe-block-sugg.rs:42:9
|
LL | y + BAZ
@@ -72,7 +72,7 @@
= note: for more information, see issue #71668 <https://github.com/rust-lang/rust/issues/71668>
= note: mutable statics can be mutated by multiple threads: aliasing violations or data races will cause undefined behavior
-error: call to unsafe function `unsf` is unsafe and requires unsafe block (error E0133)
+error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
--> $DIR/wrapping-unsafe-block-sugg.rs:48:36
|
LL | macro_rules! unsafe_macro { () => (unsf()) }
@@ -90,7 +90,7 @@
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
= note: this error originates in the macro `unsafe_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
-error: call to unsafe function `unsf` is unsafe and requires unsafe block (error E0133)
+error[E0133]: call to unsafe function `unsf` is unsafe and requires unsafe block
--> $DIR/wrapping-unsafe-block-sugg.rs:48:36
|
LL | macro_rules! unsafe_macro { () => (unsf()) }
@@ -105,3 +105,4 @@
error: aborting due to 8 previous errors
+For more information about this error, try `rustc --explain E0133`.
