nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-21 22:34:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix some pub(crate) that were undetected bc of instrument

Browse Source
This commit is contained in:
Michael Goulet 2024-10-04 14:02:09 -04:00
parent 267cf8d3b2
commit be2540a1f0
16 changed files with 31 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
compiler/rustc_borrowck/src/renumber.rs
View File

@ -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")]
pub fn renumber_mir<'tcx>(
pub(crate) fn renumber_mir<'tcx>(
infcx: &BorrowckInferCtxt<'tcx>,
body: &mut Body<'tcx>,
promoted: &mut IndexSlice<Promoted, Body<'tcx>>,

2
compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
View File

@ -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")]
pub fn apply_closure_requirements(
pub(crate) fn apply_closure_requirements(
&mut self,
closure_requirements: &ClosureRegionRequirements<'tcx>,
closure_def_id: DefId,

2
compiler/rustc_hir_typeck/src/_match.rs
View File

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

2
compiler/rustc_hir_typeck/src/cast.rs
View File

@ -671,7 +671,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
}
#[instrument(skip(fcx), level = "debug")]
pub fn check(mut self, fcx: &FnCtxt<'a, 'tcx>) {
pub(crate) fn check(mut self, 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);

2
compiler/rustc_hir_typeck/src/closure.rs
View File

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

4
compiler/rustc_hir_typeck/src/demand.rs
View File

@ -182,7 +182,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
#[instrument(skip(self), level = "debug")]
pub fn demand_suptype_with_origin(
pub(crate) fn demand_suptype_with_origin(
&'a self,
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))]
pub fn demand_coerce_diag(
pub(crate) fn demand_coerce_diag(
&'a self,
mut expr: &'tcx hir::Expr<'tcx>,
checked_ty: Ty<'tcx>,

22
compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
View File

@ -187,7 +187,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
#[instrument(level = "debug", skip(self))]
pub fn write_method_call_and_enforce_effects(
pub(crate) fn write_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")]
pub fn write_user_type_annotation_from_args(
pub(crate) fn write_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")]
pub fn write_user_type_annotation(
pub(crate) fn write_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")]
pub fn apply_adjustments(&self, expr: &hir::Expr<'_>, adj: Vec<Adjustment<'tcx>>) {
pub(crate) fn apply_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)]
pub fn lower_ty_saving_user_provided_ty(&self, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
pub(crate) fn lower_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)]
pub fn resolve_ty_and_res_fully_qualified_call(
pub(crate) fn resolve_ty_and_res_fully_qualified_call(
&self,
qpath: &'tcx QPath<'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")]
pub fn instantiate_value_path(
pub(crate) fn instantiate_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)]
pub fn try_structurally_resolve_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
pub(crate) fn try_structurally_resolve_type(&self, sp: Span, ty: Ty<'tcx>) -> Ty<'tcx> {
let ty = self.resolve_vars_with_obligations(ty);
if self.next_trait_solver()
@ -1471,7 +1471,11 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
#[instrument(level = "debug", skip(self, sp), ret)]
pub fn try_structurally_resolve_const(&self, sp: Span, ct: ty::Const<'tcx>) -> ty::Const<'tcx> {
pub(crate) fn try_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.
if self.next_trait_solver()

1
compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
View File

@ -984,7 +984,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
self.suggest_deref_unwrap_or(
&mut err,
error_span,
callee_ty,
call_ident,
expected_ty,

1
compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
View File

@ -1462,7 +1462,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
pub(crate) fn suggest_deref_unwrap_or(
&self,
err: &mut Diag<'_>,
error_span: Span,
callee_ty: Option<Ty<'tcx>>,
call_ident: Option<Ident>,
expected_ty: Ty<'tcx>,

8
compiler/rustc_hir_typeck/src/method/mod.rs
View File

@ -94,7 +94,7 @@ pub(crate) enum CandidateSource {
impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// Determines whether the type `self_ty` supports a visible method named `method_name` or not.
#[instrument(level = "debug", skip(self))]
pub fn method_exists_for_diagnostic(
pub(crate) fn method_exists_for_diagnostic(
&self,
method_name: Ident,
self_ty: Ty<'tcx>,
@ -178,7 +178,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// * `self_expr`: the self expression (`foo`)
/// * `args`: the expressions of the arguments (`a, b + 1, ...`)
#[instrument(level = "debug", skip(self))]
pub fn lookup_method(
pub(crate) fn lookup_method(
&self,
self_ty: Ty<'tcx>,
segment: &'tcx hir::PathSegment<'tcx>,
@ -281,7 +281,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
#[instrument(level = "debug", skip(self, call_expr))]
pub fn lookup_probe(
pub(crate) fn lookup_probe(
&self,
method_name: Ident,
self_ty: Ty<'tcx>,
@ -498,7 +498,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// * `self_ty_span` the span for the type being searched within (span of `Foo`)
/// * `expr_id`: the [`hir::HirId`] of the expression composing the entire call
#[instrument(level = "debug", skip(self), ret)]
pub fn resolve_fully_qualified_call(
pub(crate) fn resolve_fully_qualified_call(
&self,
span: Span,
method_name: Ident,

4
compiler/rustc_hir_typeck/src/method/probe.rs
View File

@ -224,7 +224,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
/// would use to decide if a method is a plausible fit for
/// ambiguity purposes).
#[instrument(level = "debug", skip(self, candidate_filter))]
pub fn probe_for_return_type_for_diagnostic(
pub(crate) fn probe_for_return_type_for_diagnostic(
&self,
span: Span,
mode: Mode,
@ -267,7 +267,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
#[instrument(level = "debug", skip(self))]
pub fn probe_for_name(
pub(crate) fn probe_for_name(
&self,
mode: Mode,
item_name: Ident,

2
compiler/rustc_hir_typeck/src/method/suggest.rs
View File

@ -183,7 +183,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
}
#[instrument(level = "debug", skip(self))]
pub fn report_method_error(
pub(crate) fn report_method_error(
&self,
call_id: HirId,
rcvr_ty: Ty<'tcx>,

2
compiler/rustc_mir_dataflow/src/elaborate_drops.rs
View File

@ -225,7 +225,7 @@ where
// FIXME: I think we should just control the flags externally,
// and then we do not need this machinery.
#[instrument(level = "debug")]
pub fn elaborate_drop(&mut self, bb: BasicBlock) {
fn elaborate_drop(&mut self, bb: BasicBlock) {
match self.elaborator.drop_style(self.path, DropFlagMode::Deep) {
DropStyle::Dead => {
self.elaborator

2
compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
View File

@ -315,7 +315,7 @@ fn encode_region<'tcx>(region: Region<'tcx>, dict: &mut FxHashMap<DictKey<'tcx>,
/// Encodes a ty:Ty using the Itanium C++ ABI with vendor extended type qualifiers and types for
/// Rust types that are not used at the FFI boundary.
#[instrument(level = "trace", skip(tcx, dict))]
pub fn encode_ty<'tcx>(
pub(crate) fn encode_ty<'tcx>(
tcx: TyCtxt<'tcx>,
ty: Ty<'tcx>,
dict: &mut FxHashMap<DictKey<'tcx>, usize>,

2
compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/transform.rs
View File

@ -291,7 +291,7 @@ fn trait_object_ty<'tcx>(tcx: TyCtxt<'tcx>, poly_trait_ref: ty::PolyTraitRef<'tc
/// the Fn trait that defines the method (for being attached as a secondary type id).
///
#[instrument(level = "trace", skip(tcx))]
pub fn transform_instance<'tcx>(
pub(crate) fn transform_instance<'tcx>(
tcx: TyCtxt<'tcx>,
mut instance: Instance<'tcx>,
options: TransformTyOptions,

2
compiler/rustc_transmute/src/maybe_transmutable/mod.rs
View File

@ -40,7 +40,7 @@ mod rustc {
/// This method begins by converting `src` and `dst` from `Ty`s to `Tree`s,
/// then computes an answer using those trees.
#[instrument(level = "debug", skip(self), fields(src = ?self.src, dst = ?self.dst))]
pub fn answer(self) -> Answer<<TyCtxt<'tcx> as QueryContext>::Ref> {
pub(crate) fn answer(self) -> Answer<<TyCtxt<'tcx> as QueryContext>::Ref> {
let Self { src, dst, assume, context } = self;
let layout_cx = LayoutCx::new(context, ParamEnv::reveal_all());