Auto merge of #112344 - matthiaskrgr:rollup-tswr83e, r=matthiaskrgr

Rollup of 7 pull requests

Successful merges:

 - #111058 (Correct fortanix LVI test print function)
 - #111369 (Added custom risc32-imac for esp-espidf target)
 - #111962 (Make GDB Python Pretty Printers loadable after spawning GDB, avoiding required `rust-gdb`)
 - #112019 (Don't suggest changing `&self` and `&mut self` in function signature to be mutable when taking `&mut self` in closure)
 - #112199 (Fix suggestion for matching struct with `..` on both ends)
 - #112220 (Cleanup some `EarlyBinder::skip_binder()` -> `EarlyBinder::subst_identity()`)
 - #112325 (diagnostics: do not suggest type name tweaks on type-inferred closure args)

r? `@ghost`
`@rustbot` modify labels: rollup

compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs

@@ -416,12 +416,28 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, 'tcx> {
  _,
  ) = pat.kind
  {
- err.span_suggestion(
- upvar_ident.span,
- "consider changing this to be mutable",
- format!("mut {}", upvar_ident.name),
- Applicability::MachineApplicable,
- );
+ if upvar_ident.name == kw::SelfLower {
+ for (_, node) in self.infcx.tcx.hir().parent_iter(upvar_hir_id) {
+ if let Some(fn_decl) = node.fn_decl() {
+ if !matches!(fn_decl.implicit_self, hir::ImplicitSelfKind::ImmRef | hir::ImplicitSelfKind::MutRef) {
+ err.span_suggestion(
+ upvar_ident.span,
+ "consider changing this to be mutable",
+ format!("mut {}", upvar_ident.name),
+ Applicability::MachineApplicable,
+ );
+ break;
+ }
+ }
+ }
+ } else {
+ err.span_suggestion(
+ upvar_ident.span,
+ "consider changing this to be mutable",
+ format!("mut {}", upvar_ident.name),
+ Applicability::MachineApplicable,
+ );
+ }
  }
 
  let tcx = self.infcx.tcx;

compiler/rustc_hir_typeck/src/check.rs

@@ -96,7 +96,19 @@ pub(super) fn check_fn<'a, 'tcx>(
  // for simple cases like `fn foo(x: Trait)`,
  // where we would error once on the parameter as a whole, and once on the binding `x`.
  if param.pat.simple_ident().is_none() && !params_can_be_unsized {
- fcx.require_type_is_sized(param_ty, param.pat.span, traits::SizedArgumentType(ty_span));
+ fcx.require_type_is_sized(
+ param_ty,
+ param.pat.span,
+ // ty_span == binding_span iff this is a closure parameter with no type ascription,
+ // or if it's an implicit `self` parameter
+ traits::SizedArgumentType(
+ if ty_span == Some(param.span) && tcx.is_closure(fn_def_id.into()) {
+ None
+ } else {
+ ty_span
+ },
+ ),
+ );
  }
 
  fcx.write_ty(param.hir_id, param_ty);

compiler/rustc_hir_typeck/src/gather_locals.rs

@@ -129,7 +129,17 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
  self.fcx.require_type_is_sized(
  var_ty,
  p.span,
- traits::SizedArgumentType(Some(ty_span)),
+ // ty_span == ident.span iff this is a closure parameter with no type
+ // ascription, or if it's an implicit `self` parameter
+ traits::SizedArgumentType(
+ if ty_span == ident.span
+ && self.fcx.tcx.is_closure(self.fcx.body_id.into())
+ {
+ None
+ } else {
+ Some(ty_span)
+ },
+ ),
  );
  }
  } else {

compiler/rustc_middle/src/ty/instance.rs

@@ -586,7 +586,7 @@ impl<'tcx> Instance<'tcx> {
  if let Some(substs) = self.substs_for_mir_body() {
  v.subst(tcx, substs)
  } else {
- v.skip_binder()
+ v.subst_identity()
  }
  }
 

compiler/rustc_mir_transform/src/shim.rs

@@ -647,7 +647,7 @@ fn build_call_shim<'tcx>(
  let mut sig = if let Some(sig_substs) = sig_substs {
  sig.subst(tcx, &sig_substs)
  } else {
- sig.skip_binder()
+ sig.subst_identity()
  };
 
  if let CallKind::Indirect(fnty) = call_kind {

compiler/rustc_parse/src/parser/pat.rs

@@ -938,7 +938,8 @@ impl<'a> Parser<'a> {
  let mut etc = false;
  let mut ate_comma = true;
  let mut delayed_err: Option<DiagnosticBuilder<'a, ErrorGuaranteed>> = None;
- let mut etc_span = None;
+ let mut first_etc_and_maybe_comma_span = None;
+ let mut last_non_comma_dotdot_span = None;
 
  while self.token != token::CloseDelim(Delimiter::Brace) {
  let attrs = match self.parse_outer_attributes() {
@@ -969,12 +970,27 @@ impl<'a> Parser<'a> {
  {
  etc = true;
  let mut etc_sp = self.token.span;
+ if first_etc_and_maybe_comma_span.is_none() {
+ if let Some(comma_tok) = self
+ .look_ahead(1, |t| if *t == token::Comma { Some(t.clone()) } else { None })
+ {
+ let nw_span = self
+ .sess
+ .source_map()
+ .span_extend_to_line(comma_tok.span)
+ .trim_start(comma_tok.span.shrink_to_lo())
+ .map(|s| self.sess.source_map().span_until_non_whitespace(s));
+ first_etc_and_maybe_comma_span = nw_span.map(|s| etc_sp.to(s));
+ } else {
+ first_etc_and_maybe_comma_span =
+ Some(self.sess.source_map().span_until_non_whitespace(etc_sp));
+ }
+ }
 
  self.recover_bad_dot_dot();
  self.bump(); // `..` || `...` || `_`
 
  if self.token == token::CloseDelim(Delimiter::Brace) {
- etc_span = Some(etc_sp);
  break;
  }
  let token_str = super::token_descr(&self.token);
@@ -996,7 +1012,6 @@ impl<'a> Parser<'a> {
  ate_comma = true;
  }
 
- etc_span = Some(etc_sp.until(self.token.span));
  if self.token == token::CloseDelim(Delimiter::Brace) {
  // If the struct looks otherwise well formed, recover and continue.
  if let Some(sp) = comma_sp {
@@ -1040,6 +1055,9 @@ impl<'a> Parser<'a> {
  }
  }?;
  ate_comma = this.eat(&token::Comma);
+
+ last_non_comma_dotdot_span = Some(this.prev_token.span);
+
  // We just ate a comma, so there's no need to use
  // `TrailingToken::Comma`
  Ok((field, TrailingToken::None))
@@ -1049,15 +1067,30 @@ impl<'a> Parser<'a> {
  }
 
  if let Some(mut err) = delayed_err {
- if let Some(etc_span) = etc_span {
- err.multipart_suggestion(
- "move the `..` to the end of the field list",
- vec![
- (etc_span, String::new()),
- (self.token.span, format!("{}.. }}", if ate_comma { "" } else { ", " })),
- ],
- Applicability::MachineApplicable,
- );
+ if let Some(first_etc_span) = first_etc_and_maybe_comma_span {
+ if self.prev_token == token::DotDot {
+ // We have `.., x, ..`.
+ err.multipart_suggestion(
+ "remove the starting `..`",
+ vec![(first_etc_span, String::new())],
+ Applicability::MachineApplicable,
+ );
+ } else {
+ if let Some(last_non_comma_dotdot_span) = last_non_comma_dotdot_span {
+ // We have `.., x`.
+ err.multipart_suggestion(
+ "move the `..` to the end of the field list",
+ vec![
+ (first_etc_span, String::new()),
+ (
+ self.token.span.to(last_non_comma_dotdot_span.shrink_to_hi()),
+ format!("{} .. }}", if ate_comma { "" } else { "," }),
+ ),
+ ],
+ Applicability::MachineApplicable,
+ );
+ }
+ }
  }
  err.emit();
  }

compiler/rustc_target/src/spec/mod.rs

@@ -1284,6 +1284,7 @@ supported_targets! {
  ("riscv32im-unknown-none-elf", riscv32im_unknown_none_elf),
  ("riscv32imc-unknown-none-elf", riscv32imc_unknown_none_elf),
  ("riscv32imc-esp-espidf", riscv32imc_esp_espidf),
+ ("riscv32imac-esp-espidf", riscv32imac_esp_espidf),
  ("riscv32imac-unknown-none-elf", riscv32imac_unknown_none_elf),
  ("riscv32imac-unknown-xous-elf", riscv32imac_unknown_xous_elf),
  ("riscv32gc-unknown-linux-gnu", riscv32gc_unknown_linux_gnu),

compiler/rustc_target/src/spec/riscv32imac_esp_espidf.rs

@@ -0,0 +1,31 @@
+use crate::spec::{cvs, PanicStrategy, RelocModel, Target, TargetOptions};
+
+pub fn target() -> Target {
+ Target {
+ data_layout: "e-m:e-p:32:32-i64:64-n32-S128".into(),
+ llvm_target: "riscv32".into(),
+ pointer_width: 32,
+ arch: "riscv32".into(),
+
+ options: TargetOptions {
+ families: cvs!["unix"],
+ os: "espidf".into(),
+ env: "newlib".into(),
+ vendor: "espressif".into(),
+ linker: Some("riscv32-esp-elf-gcc".into()),
+ cpu: "generic-rv32".into(),
+
+ // As RiscV32IMAC architecture does natively support atomics,
+ // automatically enable the support for the Rust STD library.
+ max_atomic_width: Some(64),
+ atomic_cas: true,
+
+ features: "+m,+a,+c".into(),
+ panic_strategy: PanicStrategy::Abort,
+ relocation_model: RelocModel::Static,
+ emit_debug_gdb_scripts: false,
+ eh_frame_header: false,
+ ..Default::default()
+ },
+ }
+}

compiler/rustc_trait_selection/src/traits/error_reporting/suggestions.rs

@@ -2807,8 +2807,8 @@ impl<'tcx> TypeErrCtxtExt<'tcx> for TypeErrCtxt<'_, 'tcx> {
  err.help("unsized locals are gated as an unstable feature");
  }
  }
- ObligationCauseCode::SizedArgumentType(sp) => {
- if let Some(span) = sp {
+ ObligationCauseCode::SizedArgumentType(ty_span) => {
+ if let Some(span) = ty_span {
  if let ty::PredicateKind::Clause(clause) = predicate.kind().skip_binder()
  && let ty::Clause::Trait(trait_pred) = clause
  && let ty::Dynamic(..) = trait_pred.self_ty().kind()

src/doc/rustc/src/platform-support.md

@@ -298,6 +298,7 @@ target | std | host | notes
 `riscv32im-unknown-none-elf` | * | | Bare RISC-V (RV32IM ISA)
 [`riscv32imac-unknown-xous-elf`](platform-support/riscv32imac-unknown-xous-elf.md) | ? | | RISC-V Xous (RV32IMAC ISA)
 [`riscv32imc-esp-espidf`](platform-support/esp-idf.md) | ✓ | | RISC-V ESP-IDF
+[`riscv32imac-esp-espidf`](platform-support/esp-idf.md) | ✓ | | RISC-V ESP-IDF
 `riscv64gc-unknown-freebsd` | | | RISC-V FreeBSD
 `riscv64gc-unknown-fuchsia` | | | RISC-V Fuchsia
 `riscv64gc-unknown-linux-musl` | | | RISC-V Linux (kernel 4.20, musl 1.2.0)

src/doc/rustc/src/platform-support/esp-idf.md

@@ -13,11 +13,12 @@ Targets for the [ESP-IDF](https:/espressif/esp-idf) development fram
 
 The target names follow this format: `$ARCH-esp-espidf`, where `$ARCH` specifies the target processor architecture. The following targets are currently defined:
 
-| Target name | Target CPU(s) |
-|--------------------------------|-----------------------|
-| `riscv32imc-esp-espidf` | [ESP32-C3](https://www.espressif.com/en/products/socs/esp32-c3) |
+| Target name | Target CPU(s) | Minimum ESP-IDF version |
+|--------------------------------|-----------------------|-------------------------|
+| `riscv32imc-esp-espidf` | [ESP32-C3](https://www.espressif.com/en/products/socs/esp32-c3) | `v4.3` |
+| `riscv32imac-esp-espidf` | [ESP32-C6](https://www.espressif.com/en/products/socs/esp32-c6) | `v5.1` |
 
-The minimum supported ESP-IDF version is `v4.3`, though it is recommended to use the latest stable release if possible.
+It is recommended to use the latest ESP-IDF stable release if possible.
 
 ## Building the target
 

src/etc/gdb_load_rust_pretty_printers.py

@@ -1,3 +1,14 @@
+# Add this folder to the python sys path; GDB Python-interpreter will now find modules in this path
+import sys
+from os import path
+self_dir = path.dirname(path.realpath(__file__))
+sys.path.append(self_dir)
+
 import gdb
 import gdb_lookup
-gdb_lookup.register_printers(gdb.current_objfile())
+
+# current_objfile can be none; even with `gdb foo-app`; sourcing this file after gdb init now works
+try:
+ gdb_lookup.register_printers(gdb.current_objfile())
+except Exception:
+ gdb_lookup.register_printers(gdb.selected_inferior().progspace)

src/librustdoc/clean/blanket_impl.rs

@@ -104,10 +104,10 @@ impl<'a, 'tcx> BlanketImplFinder<'a, 'tcx> {
  // the post-inference `trait_ref`, as it's more accurate.
  trait_: Some(clean_trait_ref_with_bindings(
  cx,
- ty::Binder::dummy(trait_ref.skip_binder()),
+ ty::Binder::dummy(trait_ref.subst_identity()),
  ThinVec::new(),
  )),
- for_: clean_middle_ty(ty::Binder::dummy(ty.skip_binder()), cx, None),
+ for_: clean_middle_ty(ty::Binder::dummy(ty.subst_identity()), cx, None),
  items: cx
  .tcx
  .associated_items(impl_def_id)
@@ -116,7 +116,7 @@ impl<'a, 'tcx> BlanketImplFinder<'a, 'tcx> {
  .collect::<Vec<_>>(),
  polarity: ty::ImplPolarity::Positive,
  kind: ImplKind::Blanket(Box::new(clean_middle_ty(
- ty::Binder::dummy(trait_ref.skip_binder().self_ty()),
+ ty::Binder::dummy(trait_ref.subst_identity().self_ty()),
  cx,
  None,
  ))),

tests/run-make/x86_64-fortanix-unknown-sgx-lvi/print.checks

@@ -1,6 +1,6 @@
 CHECK: print
 CHECK: lfence
-CHECK: lfence
-CHECK: lfence
-CHECK: callq 0x{{[[:xdigit:]]*}} <_Unwind_Resume>
-CHECK-NEXT: ud2
+CHECK: popq
+CHECK-NEXT: popq [[REGISTER:%[a-z]+]]
+CHECK-NEXT: lfence
+CHECK-NEXT: jmpq *[[REGISTER]]

tests/run-make/x86_64-fortanix-unknown-sgx-lvi/script.sh

@@ -33,6 +33,15 @@ function check {
  ${objdump} --disassemble-symbols="${func}" --demangle \
  ${enclave} > ${asm}
  ${filecheck} --input-file ${asm} ${checks}
+
+ if [ "${func_re}" != "rust_plus_one_global_asm" &&
+ "${func_re}" != "cmake_plus_one_c_global_asm" ]; then
+ # The assembler cannot avoid explicit `ret` instructions. Sequences
+ # of `shlq $0x0, (%rsp); lfence; retq` are used instead.
+ # https://www.intel.com/content/www/us/en/developer/articles/technical/
+ # software-security-guidance/technical-documentation/load-value-injection.html
+ ${filecheck} --implicit-check-not ret --input-file ${asm} ${checks}
+ fi
 }
 
 build

tests/ui/borrowck/issue-111554.rs

@@ -0,0 +1,28 @@
+struct Foo {}
+
+impl Foo {
+ pub fn foo(&mut self) {
+ || bar(&mut self);
+ //~^ ERROR cannot borrow `self` as mutable, as it is not declared as mutable
+ }
+
+ pub fn baz(&self) {
+ || bar(&mut self);
+ //~^ ERROR cannot borrow `self` as mutable, as it is not declared as mutable
+ //~| ERROR cannot borrow data in a `&` reference as mutable
+ }
+
+ pub fn qux(mut self) {
+ || bar(&mut self);
+ // OK
+ }
+
+ pub fn quux(self) {
+ || bar(&mut self);
+ //~^ ERROR cannot borrow `self` as mutable, as it is not declared as mutable
+ }
+}
+
+fn bar(_: &mut Foo) {}
+
+fn main() {}

tests/ui/borrowck/issue-111554.stderr

@@ -0,0 +1,29 @@
+error[E0596]: cannot borrow `self` as mutable, as it is not declared as mutable
+ --> $DIR/issue-111554.rs:5:16
+ |
+LL | || bar(&mut self);
+ | ^^^^^^^^^ cannot borrow as mutable
+
+error[E0596]: cannot borrow `self` as mutable, as it is not declared as mutable
+ --> $DIR/issue-111554.rs:10:16
+ |
+LL | || bar(&mut self);
+ | ^^^^^^^^^ cannot borrow as mutable
+
+error[E0596]: cannot borrow data in a `&` reference as mutable
+ --> $DIR/issue-111554.rs:10:16
+ |
+LL | || bar(&mut self);
+ | ^^^^^^^^^ cannot borrow as mutable
+
+error[E0596]: cannot borrow `self` as mutable, as it is not declared as mutable
+ --> $DIR/issue-111554.rs:21:16
+ |
+LL | pub fn quux(self) {
+ | ---- help: consider changing this to be mutable: `mut self`
+LL | || bar(&mut self);
+ | ^^^^^^^^^ cannot borrow as mutable
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0596`.

tests/ui/closures/issue-111932.rs

@@ -0,0 +1,9 @@
+trait Foo: std::fmt::Debug {}
+
+fn print_foos(foos: impl Iterator<Item = dyn Foo>) {
+ foos.for_each(|foo| { //~ ERROR [E0277]
+ println!("{:?}", foo); //~ ERROR [E0277]
+ });
+}
+
+fn main() {}