Auto merge of #131269 - workingjubilee:rollup-bf7fzhf, r=workingjubilee

Rollup of 10 pull requests
Successful merges:
- #130453 (Add x86_64-unknown-trusty as tier 3 target)
- #130518 (Stabilize the `map`/`value` methods on `ControlFlow`)
- #131116 (Increase Stack Size for AIX)
- #131171 (Fix `target_env` in `avr-unknown-gnu-atmega328`)
- #131174 (Fix `target_abi` in `sparc-unknown-none-elf`)
- #131177 ( Stabilize 5 `const_mut_refs`-dependent API)
- #131238 (Remove mw from triagebot.toml)
- #131240 (Fix typo in csky-unknown-linux-gnuabiv2.md)
- #131257 ([rustdoc] Fix list margins)
- #131264 (Fix some `pub(crate)` that were undetected bc of `#[instrument]`)
r? `@ghost`
`@rustbot` modify labels: rollup

Author: bors

compiler/rustc_borrowck/src/lib.rs

@@ -5,7 +5,6 @@
 #![doc(rust_logo)]
 #![feature(assert_matches)]
 #![feature(box_patterns)]
-#![feature(control_flow_enum)]
 #![feature(file_buffered)]
 #![feature(let_chains)]
 #![feature(never_type)]

compiler/rustc_borrowck/src/renumber.rs

@@ -11,7 +11,7 @@ use crate::BorrowckInferCtxt;
 /// Replaces all free regions appearing in the MIR with fresh
 /// inference variables, returning the number of variables created.
 #[instrument(skip(infcx, body, promoted), level = "debug")]
-pubfnrenumber_mir<'tcx>(
+pub(crate)fnrenumber_mir<'tcx>(
 infcx:&BorrowckInferCtxt<'tcx>,
 body:&mutBody<'tcx>,
 promoted:&mutIndexSlice<Promoted,Body<'tcx>>,

compiler/rustc_borrowck/src/type_check/constraint_conversion.rs

@@ -97,7 +97,7 @@ impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
 /// that we computed for the closure. This has the effect of adding new outlives obligations
 /// to existing region variables in `closure_args`.
 #[instrument(skip(self), level = "debug")]
-pubfnapply_closure_requirements(
+pub(crate)fnapply_closure_requirements(
 &mutself,
 closure_requirements:&ClosureRegionRequirements<'tcx>,
 closure_def_id:DefId,

compiler/rustc_data_structures/src/stack.rs

@@ -5,7 +5,11 @@ const RED_ZONE: usize = 100 * 1024; // 100k
 
 // Only the first stack that is pushed, grows exponentially (2^n * STACK_PER_RECURSION) from then
 // on. This flag has performance relevant characteristics. Don't set it too high.
+#[cfg(not(target_os = "aix"))]
 constSTACK_PER_RECURSION:usize = 1024*1024;// 1MB
+// LLVM for AIX doesn't feature TCO, increase recursion size for workaround.
+#[cfg(target_os = "aix")]
+constSTACK_PER_RECURSION:usize = 16*1024*1024;// 16MB
 
 /// Grows the stack on demand to prevent stack overflow. Call this in strategic locations
 /// to "break up" recursive calls. E.g. almost any call to `visit_expr` or equivalent can benefit

compiler/rustc_hir_analysis/src/lib.rs

@@ -62,7 +62,6 @@ This API is completely unstable and subject to change.
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
 #![doc(rust_logo)]
 #![feature(assert_matches)]
-#![feature(control_flow_enum)]
 #![feature(if_let_guard)]
 #![feature(iter_intersperse)]
 #![feature(let_chains)]

compiler/rustc_hir_typeck/src/_match.rs

@@ -15,7 +15,7 @@ use crate::{Diverges, Expectation, FnCtxt, Needs};
 
 impl<'a,'tcx>FnCtxt<'a,'tcx>{
 #[instrument(skip(self), level = "debug", ret)]
-pubfncheck_match(
+pub(crate)fncheck_match(
 &self,
 expr:&'tcx hir::Expr<'tcx>,
 scrut:&'tcx hir::Expr<'tcx>,

compiler/rustc_hir_typeck/src/cast.rs

@@ -671,7 +671,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
 }
 
 #[instrument(skip(fcx), level = "debug")]
-pubfncheck(mutself,fcx:&FnCtxt<'a,'tcx>){
+pub(crate)fncheck(mutself,fcx:&FnCtxt<'a,'tcx>){
 self.expr_ty = fcx.structurally_resolve_type(self.expr_span,self.expr_ty);
 self.cast_ty = fcx.structurally_resolve_type(self.cast_span,self.cast_ty);
 

compiler/rustc_hir_typeck/src/closure.rs

@@ -44,7 +44,7 @@ struct ClosureSignatures<'tcx> {
 
 impl<'a,'tcx>FnCtxt<'a,'tcx>{
 #[instrument(skip(self, closure), level = "debug")]
-pubfncheck_expr_closure(
+pub(crate)fncheck_expr_closure(
 &self,
 closure:&hir::Closure<'tcx>,
 expr_span:Span,

compiler/rustc_hir_typeck/src/demand.rs

@@ -182,7 +182,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 }
 
 #[instrument(skip(self), level = "debug")]
-pubfndemand_suptype_with_origin(
+pub(crate)fndemand_suptype_with_origin(
 &'aself,
 cause:&ObligationCause<'tcx>,
 expected:Ty<'tcx>,
@@ -247,7 +247,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 /// N.B., this code relies on `self.diverges` to be accurate. In particular, assignments to `!`
 /// will be permitted if the diverges flag is currently "always".
 #[instrument(level = "debug", skip(self, expr, expected_ty_expr, allow_two_phase))]
-pubfndemand_coerce_diag(
+pub(crate)fndemand_coerce_diag(
 &'aself,
 mutexpr:&'tcx hir::Expr<'tcx>,
 checked_ty:Ty<'tcx>,

compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs

@@ -187,7 +187,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 }
 
 #[instrument(level = "debug", skip(self))]
-pubfnwrite_method_call_and_enforce_effects(
+pub(crate)fnwrite_method_call_and_enforce_effects(
 &self,
 hir_id:HirId,
 span:Span,
@@ -214,7 +214,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 /// occurred**, so that annotations like `Vec<_>` are preserved
 /// properly.
 #[instrument(skip(self), level = "debug")]
-pubfnwrite_user_type_annotation_from_args(
+pub(crate)fnwrite_user_type_annotation_from_args(
 &self,
 hir_id:HirId,
 def_id:DefId,
@@ -235,7 +235,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 }
 
 #[instrument(skip(self), level = "debug")]
-pubfnwrite_user_type_annotation(
+pub(crate)fnwrite_user_type_annotation(
 &self,
 hir_id:HirId,
 canonical_user_type_annotation:CanonicalUserType<'tcx>,
@@ -254,7 +254,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 }
 
 #[instrument(skip(self, expr), level = "debug")]
-pubfnapply_adjustments(&self,expr:&hir::Expr<'_>,adj:Vec<Adjustment<'tcx>>){
+pub(crate)fnapply_adjustments(&self,expr:&hir::Expr<'_>,adj:Vec<Adjustment<'tcx>>){
 debug!("expr = {:#?}", expr);
 
 if adj.is_empty(){
@@ -448,7 +448,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 }
 
 #[instrument(level = "debug", skip_all)]
-pubfnlower_ty_saving_user_provided_ty(&self,hir_ty:&hir::Ty<'tcx>) -> Ty<'tcx>{
+pub(crate)fnlower_ty_saving_user_provided_ty(&self,hir_ty:&hir::Ty<'tcx>) -> Ty<'tcx>{
 let ty = self.lower_ty(hir_ty);
 debug!(?ty);
 
@@ -736,7 +736,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 /// Resolves an associated value path into a base type and associated constant, or method
 /// resolution. The newly resolved definition is written into `type_dependent_defs`.
 #[instrument(level = "trace", skip(self), ret)]
-pubfnresolve_ty_and_res_fully_qualified_call(
+pub(crate)fnresolve_ty_and_res_fully_qualified_call(
 &self,
 qpath:&'tcxQPath<'tcx>,
 hir_id:HirId,
@@ -995,7 +995,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 // Instantiates the given path, which must refer to an item with the given
 // number of type parameters and type.
 #[instrument(skip(self, span), level = "debug")]
-pubfninstantiate_value_path(
+pub(crate)fninstantiate_value_path(
 &self,
 segments:&'tcx[hir::PathSegment<'tcx>],
 self_ty:Option<LoweredTy<'tcx>>,
@@ -1446,7 +1446,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 /// variable. This is different from `structurally_resolve_type` which errors
 /// in this case.
 #[instrument(level = "debug", skip(self, sp), ret)]
-pubfntry_structurally_resolve_type(&self,sp:Span,ty:Ty<'tcx>) -> Ty<'tcx>{
+pub(crate)fntry_structurally_resolve_type(&self,sp:Span,ty:Ty<'tcx>) -> Ty<'tcx>{
 let ty = self.resolve_vars_with_obligations(ty);
 
 ifself.next_trait_solver()
@@ -1471,7 +1471,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 }
 
 #[instrument(level = "debug", skip(self, sp), ret)]
-pubfntry_structurally_resolve_const(&self,sp:Span,ct: ty::Const<'tcx>) -> ty::Const<'tcx>{
+pub(crate)fntry_structurally_resolve_const(
+&self,
+sp:Span,
+ct: ty::Const<'tcx>,
+) -> ty::Const<'tcx>{
 // FIXME(min_const_generic_exprs): We could process obligations here if `ct` is a var.
 
 ifself.next_trait_solver()