Auto merge of rust-lang#126369 - workingjubilee:rollup-fd21o5w, r=wor…

…kingjubilee

Rollup of 11 pull requests

Successful merges:

 - rust-lang#125165 (Migrate `run-make/pgo-branch-weights` to `rmake`)
 - rust-lang#125674 (Rewrite `symlinked-extern`, `symlinked-rlib` and `symlinked-libraries` `run-make` tests in `rmake.rs` format)
 - rust-lang#125688 (Walk into alias-eq nested goals even if normalization fails)
 - rust-lang#126142 (Harmonize using root or leaf obligation in trait error reporting)
 - rust-lang#126303 (Urls to docs in rust_hir)
 - rust-lang#126328 (Add Option::is_none_or)
 - rust-lang#126337 (Add test for walking order dependent opaque type behaviour)
 - rust-lang#126351 (std::unix::fs::link using direct linkat call for Solaris.)
 - rust-lang#126353 (Move `MatchAgainstFreshVars` to old solver)
 - rust-lang#126356 (docs(rustc): Improve discoverable of Cargo docs)
 - rust-lang#126362 (Make `try_from_target_usize` method public)

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

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -1057,7 +1057,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
 
  ty::Str | ty::Slice(_) | ty::Dynamic(_, _, ty::Dyn) | ty::Foreign(..) => false,
 
- ty::Tuple(tys) => tys.last().iter().all(|ty| is_very_trivially_sized(**ty)),
+ ty::Tuple(tys) => tys.last().is_none_or(|ty| is_very_trivially_sized(*ty)),
 
  ty::Pat(ty, ..) => is_very_trivially_sized(*ty),
 

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -446,7 +446,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
  let (alloc_size, _alloc_align, ret_val) = alloc_size(alloc_id, offset, prov)?;
  // 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) {
+ if offset.checked_add(size, &self.tcx).is_none_or(|end| end > alloc_size) {
  throw_ub!(PointerOutOfBounds {
  alloc_id,
  alloc_size,

compiler/rustc_const_eval/src/interpret/projection.rs

@@ -300,7 +300,7 @@ where
  ) -> InterpResult<'tcx, P> {
  let len = base.len(self)?; // also asserts that we have a type where this makes sense
  let actual_to = if from_end {
- if from.checked_add(to).map_or(true, |to| to > len) {
+ if from.checked_add(to).is_none_or(|to| to > len) {
  // This can only be reached in ConstProp and non-rustc-MIR.
  throw_ub!(BoundsCheckFailed { len: len, index: from.saturating_add(to) });
  }

compiler/rustc_const_eval/src/lib.rs

@@ -6,6 +6,7 @@
 #![feature(box_patterns)]
 #![feature(decl_macro)]
 #![feature(if_let_guard)]
+#![feature(is_none_or)]
 #![feature(let_chains)]
 #![feature(never_type)]
 #![feature(rustdoc_internals)]

compiler/rustc_hir/src/hir.rs

@@ -1633,6 +1633,13 @@ pub struct ConstBlock {
 }
 
 /// An expression.
+///
+/// For more details, see the [rust lang reference].
+/// Note that the reference does not document nightly-only features.
+/// There may be also slight differences in the names and representation of AST nodes between
+/// the compiler and the reference.
+///
+/// [rust lang reference]: https://doc.rust-lang.org/reference/expressions.html
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub struct Expr<'hir> {
  pub hir_id: HirId,
@@ -3147,6 +3154,13 @@ impl ItemId {
 /// An item
 ///
 /// The name might be a dummy name in case of anonymous items
+///
+/// For more details, see the [rust lang reference].
+/// Note that the reference does not document nightly-only features.
+/// There may be also slight differences in the names and representation of AST nodes between
+/// the compiler and the reference.
+///
+/// [rust lang reference]: https://doc.rust-lang.org/reference/items.html
 #[derive(Debug, Clone, Copy, HashStable_Generic)]
 pub struct Item<'hir> {
  pub ident: Ident,

compiler/rustc_hir_typeck/src/_match.rs

@@ -234,7 +234,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  let ret_ty = ret_coercion.borrow().expected_ty();
  let ret_ty = self.infcx.shallow_resolve(ret_ty);
  self.can_coerce(arm_ty, ret_ty)
- && prior_arm.map_or(true, |(_, ty, _)| self.can_coerce(ty, ret_ty))
+ && prior_arm.is_none_or(|(_, ty, _)| self.can_coerce(ty, ret_ty))
  // The match arms need to unify for the case of `impl Trait`.
  && !matches!(ret_ty.kind(), ty::Alias(ty::Opaque, ..))
  }

compiler/rustc_hir_typeck/src/coercion.rs

@@ -913,7 +913,7 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
  if self
  .tcx
  .upvars_mentioned(closure_def_id_a.expect_local())
- .map_or(true, |u| u.is_empty()) =>
+ .is_none_or(|u| u.is_empty()) =>
  {
  // We coerce the closure, which has fn type
  // `extern "rust-call" fn((arg0,arg1,...)) -> _`

compiler/rustc_hir_typeck/src/expr.rs

@@ -1557,7 +1557,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
  // If the length is 0, we don't create any elements, so we don't copy any. If the length is 1, we
  // don't copy that one element, we move it. Only check for Copy if the length is larger.
- if count.try_eval_target_usize(tcx, self.param_env).map_or(true, |len| len > 1) {
+ if count.try_eval_target_usize(tcx, self.param_env).is_none_or(|len| len > 1) {
  let lang_item = self.tcx.require_lang_item(LangItem::Copy, None);
  let code = traits::ObligationCauseCode::RepeatElementCopy {
  is_constable,

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -2240,7 +2240,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  for (idx, (generic_param, param)) in
  params_with_generics.iter().enumerate().filter(|(idx, _)| {
  check_for_matched_generics
- || expected_idx.map_or(true, |expected_idx| expected_idx == *idx)
+ || expected_idx.is_none_or(|expected_idx| expected_idx == *idx)
  })
  {
  let Some(generic_param) = generic_param else {

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -440,7 +440,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  };
  // Given `Result<_, E>`, check our expected ty is `Result<_, &E>` for
  // `as_ref` and `as_deref` compatibility.
- let error_tys_equate_as_ref = error_tys.map_or(true, |(found, expected)| {
+ let error_tys_equate_as_ref = error_tys.is_none_or(|(found, expected)| {
  self.can_eq(
  self.param_env,
  Ty::new_imm_ref(self.tcx, self.tcx.lifetimes.re_erased, found),
@@ -492,7 +492,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  && Some(adt.did()) == self.tcx.lang_items().string()
  && peeled.is_str()
  // `Result::map`, conversely, does not take ref of the error type.
- && error_tys.map_or(true, |(found, expected)| {
+ && error_tys.is_none_or(|(found, expected)| {
  self.can_eq(self.param_env, found, expected)
  })
  {

compiler/rustc_hir_typeck/src/lib.rs

@@ -4,6 +4,7 @@
 #![feature(box_patterns)]
 #![feature(control_flow_enum)]
 #![feature(if_let_guard)]
+#![feature(is_none_or)]
 #![feature(let_chains)]
 #![feature(never_type)]
 #![feature(try_blocks)]

compiler/rustc_infer/src/infer/error_reporting/note_and_explain.rs

@@ -546,7 +546,7 @@ impl<T> Trait<T> for X {
  for pred in hir_generics.bounds_for_param(def_id) {
  if self.constrain_generic_bound_associated_type_structured_suggestion(
  diag,
- &trait_ref,
+ trait_ref,
  pred.bounds,
  assoc,
  assoc_args,
@@ -715,7 +715,7 @@ fn foo(&self) -> Self::T { String::new() }
 
  self.constrain_generic_bound_associated_type_structured_suggestion(
  diag,
- &trait_ref,
+ trait_ref,
  opaque_hir_ty.bounds,
  assoc,
  assoc_args,
@@ -869,7 +869,7 @@ fn foo(&self) -> Self::T { String::new() }
  fn constrain_generic_bound_associated_type_structured_suggestion(
  &self,
  diag: &mut Diag<'_>,
- trait_ref: &ty::TraitRef<'tcx>,
+ trait_ref: ty::TraitRef<'tcx>,
  bounds: hir::GenericBounds<'_>,
  assoc: ty::AssocItem,
  assoc_args: &[ty::GenericArg<'tcx>],

compiler/rustc_infer/src/infer/relate/mod.rs

@@ -4,11 +4,9 @@
 
 pub use rustc_middle::ty::relate::*;
 
-pub use self::_match::MatchAgainstFreshVars;
 pub use self::combine::CombineFields;
 pub use self::combine::PredicateEmittingRelation;
 
-pub mod _match;
 pub(super) mod combine;
 mod generalize;
 mod glb;

compiler/rustc_infer/src/traits/util.rs

@@ -285,8 +285,7 @@ impl<'tcx, O: Elaboratable<'tcx>> Elaborator<'tcx, O> {
  let obligations =
  predicates.predicates.iter().enumerate().map(|(index, &(clause, span))| {
  elaboratable.child_with_derived_cause(
- clause
- .instantiate_supertrait(tcx, &bound_clause.rebind(data.trait_ref)),
+ clause.instantiate_supertrait(tcx, bound_clause.rebind(data.trait_ref)),
  span,
  bound_clause.rebind(data),
  index,

compiler/rustc_lint_defs/src/builtin.rs

@@ -3257,7 +3257,11 @@ declare_lint! {
  /// See the [Checking Conditional Configurations][check-cfg] section for more
  /// details.
  ///
+ /// See the [Cargo Specifics][unexpected_cfgs_lint_config] section for configuring this lint in
+ /// `Cargo.toml`.
+ ///
  /// [check-cfg]: https://doc.rust-lang.org/nightly/rustc/check-cfg.html
+ /// [unexpected_cfgs_lint_config]: https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html#check-cfg-in-lintsrust-table
  pub UNEXPECTED_CFGS,
  Warn,
  "detects unexpected names and values in `#[cfg]` conditions",

compiler/rustc_middle/src/traits/util.rs

@@ -37,7 +37,7 @@ impl<'tcx> Elaborator<'tcx> {
  let super_predicates =
  self.tcx.super_predicates_of(trait_ref.def_id()).predicates.iter().filter_map(
  |&(pred, _)| {
- let clause = pred.instantiate_supertrait(self.tcx, &trait_ref);
+ let clause = pred.instantiate_supertrait(self.tcx, trait_ref);
  self.visited.insert(clause).then_some(clause)
  },
  );

compiler/rustc_middle/src/ty/predicate.rs

@@ -313,7 +313,7 @@ impl<'tcx> Clause<'tcx> {
  pub fn instantiate_supertrait(
  self,
  tcx: TyCtxt<'tcx>,
- trait_ref: &ty::PolyTraitRef<'tcx>,
+ trait_ref: ty::PolyTraitRef<'tcx>,
  ) -> Clause<'tcx> {
  // The interaction between HRTB and supertraits is not entirely
  // obvious. Let me walk you (and myself) through an example.

compiler/rustc_trait_selection/src/solve/alias_relate.rs

@@ -48,6 +48,12 @@ impl<'tcx> EvalCtxt<'_, InferCtxt<'tcx>> {
  rhs
  };
 
+ // Add a `make_canonical_response` probe step so that we treat this as
+ // a candidate, even if `try_evaluate_added_goals` bails due to an error.
+ // It's `Certainty::AMBIGUOUS` because this candidate is not "finished",
+ // since equating the normalized terms will lead to additional constraints.
+ self.inspect.make_canonical_response(Certainty::AMBIGUOUS);
+
  // Apply the constraints.
  self.try_evaluate_added_goals()?;
  let lhs = self.resolve_vars_if_possible(lhs);

compiler/rustc_trait_selection/src/solve/fulfill.rs

@@ -460,9 +460,10 @@ impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
  polarity: ty::PredicatePolarity::Positive,
  }))
  }
- ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(_)) => {
- ChildMode::WellFormedObligation
- }
+ ty::PredicateKind::Clause(
+ ty::ClauseKind::WellFormed(_) | ty::ClauseKind::Projection(..),
+ )
+ | ty::PredicateKind::AliasRelate(..) => ChildMode::PassThrough,
  _ => {
  return ControlFlow::Break(self.obligation.clone());
  }
@@ -496,7 +497,7 @@ impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
  (_, GoalSource::InstantiateHigherRanked) => {
  obligation = self.obligation.clone();
  }
- (ChildMode::WellFormedObligation, _) => {
+ (ChildMode::PassThrough, _) => {
  obligation = make_obligation(self.obligation.cause.clone());
  }
  }
@@ -527,7 +528,7 @@ enum ChildMode<'tcx> {
  // Skip trying to derive an `ObligationCause` from this obligation, and
  // report *all* sub-obligations as if they came directly from the parent
  // obligation.
- WellFormedObligation,
+ PassThrough,
 }
 
 fn derive_cause<'tcx>(

compiler/rustc_trait_selection/src/solve/inspect/analyse.rs

@@ -15,7 +15,7 @@ use rustc_infer::infer::{DefineOpaqueTypes, InferCtxt, InferOk};
 use rustc_macros::extension;
 use rustc_middle::traits::query::NoSolution;
 use rustc_middle::traits::solve::{inspect, QueryResult};
-use rustc_middle::traits::solve::{Certainty, Goal};
+use rustc_middle::traits::solve::{Certainty, Goal, MaybeCause};
 use rustc_middle::traits::ObligationCause;
 use rustc_middle::ty::{TyCtxt, TypeFoldable};
 use rustc_middle::{bug, ty};
@@ -291,7 +291,10 @@ impl<'a, 'tcx> InspectGoal<'a, 'tcx> {
  steps.push(step)
  }
  inspect::ProbeStep::MakeCanonicalResponse { shallow_certainty: c } => {
- assert_eq!(shallow_certainty.replace(c), None);
+ assert!(matches!(
+ shallow_certainty.replace(c),
+ None | Some(Certainty::Maybe(MaybeCause::Ambiguity))
+ ));
  }
  inspect::ProbeStep::NestedProbe(ref probe) => {
  match probe.kind {

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

@@ -3597,7 +3597,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
  &self,
  obligation: &PredicateObligation<'tcx>,
  err: &mut Diag<'_>,
- trait_ref: &ty::PolyTraitRef<'tcx>,
+ trait_ref: ty::PolyTraitRef<'tcx>,
  ) {
  let rhs_span = match obligation.cause.code() {
  ObligationCauseCode::BinOp { rhs_span: Some(span), rhs_is_lit, .. } if *rhs_is_lit => {
@@ -4592,7 +4592,7 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
  &self,
  obligation: &PredicateObligation<'tcx>,
  err: &mut Diag<'_>,
- trait_ref: ty::PolyTraitRef<'tcx>,
+ trait_pred: ty::PolyTraitPredicate<'tcx>,
  ) {
  if ObligationCauseCode::QuestionMark != *obligation.cause.code().peel_derives() {
  return;
@@ -4602,10 +4602,9 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
  if let hir::Node::Item(item) = node
  && let hir::ItemKind::Fn(sig, _, body_id) = item.kind
  && let hir::FnRetTy::DefaultReturn(ret_span) = sig.decl.output
- && self.tcx.is_diagnostic_item(sym::FromResidual, trait_ref.def_id())
- && let ty::Tuple(l) = trait_ref.skip_binder().args.type_at(0).kind()
- && l.len() == 0
- && let ty::Adt(def, _) = trait_ref.skip_binder().args.type_at(1).kind()
+ && self.tcx.is_diagnostic_item(sym::FromResidual, trait_pred.def_id())
+ && trait_pred.skip_binder().trait_ref.args.type_at(0).is_unit()
+ && let ty::Adt(def, _) = trait_pred.skip_binder().trait_ref.args.type_at(1).kind()
  && self.tcx.is_diagnostic_item(sym::Result, def.did())
  {
  let body = self.tcx.hir().body(body_id);
@@ -4863,14 +4862,13 @@ impl<'a, 'hir> hir::intravisit::Visitor<'hir> for ReplaceImplTraitVisitor<'a> {
 pub(super) fn get_explanation_based_on_obligation<'tcx>(
  tcx: TyCtxt<'tcx>,
  obligation: &PredicateObligation<'tcx>,
- trait_ref: ty::PolyTraitRef<'tcx>,
- trait_predicate: &ty::PolyTraitPredicate<'tcx>,
+ trait_predicate: ty::PolyTraitPredicate<'tcx>,
  pre_message: String,
 ) -> String {
  if let ObligationCauseCode::MainFunctionType = obligation.cause.code() {
  "consider using `()`, or a `Result`".to_owned()
  } else {
- let ty_desc = match trait_ref.skip_binder().self_ty().kind() {
+ let ty_desc = match trait_predicate.self_ty().skip_binder().kind() {
  ty::FnDef(_, _) => Some("fn item"),
  ty::Closure(_, _) => Some("closure"),
  _ => None,
@@ -4895,7 +4893,7 @@ pub(super) fn get_explanation_based_on_obligation<'tcx>(
  format!(
  "{pre_message}the trait `{}` is not implemented for{desc} `{}`{post}",
  trait_predicate.print_modifiers_and_trait_path(),
- tcx.short_ty_string(trait_ref.skip_binder().self_ty(), &mut None),
+ tcx.short_ty_string(trait_predicate.self_ty().skip_binder(), &mut None),
  )
  } else {
  // "the trait bound `T: !Send` is not satisfied" reads better than "`!Send` is