mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Remove crate visibility usage in compiler

Browse source
This commit is contained in:
Jacob Pratt 2022-05-20 19:51:09 -04:00
parent 536020c5f9
commit 49c82f31a8
No known key found for this signature in database
GPG key ID: B80E19E4662B5AA4
186 changed files with 865 additions and 800 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_ast/src/attr/mod.rs
View file

@ -340,7 +340,7 @@ pub fn mk_nested_word_item(ident: Ident) -> NestedMetaItem {
NestedMetaItem::MetaItem(mk_word_item(ident))
}
crate fn mk_attr_id() -> AttrId {
pub(crate) fn mk_attr_id() -> AttrId {
use std::sync::atomic::AtomicU32;
use std::sync::atomic::Ordering;

1
compiler/rustc_ast/src/lib.rs
View file

@ -12,7 +12,6 @@
#![feature(box_patterns)]
#![feature(const_default_impls)]
#![feature(const_trait_impl)]
#![feature(crate_visibility_modifier)]
#![feature(if_let_guard)]
#![feature(label_break_value)]
#![feature(let_chains)]

2
compiler/rustc_ast/src/token.rs
View file

@ -134,7 +134,7 @@ impl LitKind {
}
}
crate fn may_have_suffix(self) -> bool {
pub(crate) fn may_have_suffix(self) -> bool {
matches!(self, Integer | Float | Err)
}
}

6
compiler/rustc_ast_lowering/src/asm.rs
View file

@ -17,7 +17,11 @@ use std::collections::hash_map::Entry;
use std::fmt::Write;
impl<'a, 'hir> LoweringContext<'a, 'hir> {
crate fn lower_inline_asm(&mut self, sp: Span, asm: &InlineAsm) -> &'hir hir::InlineAsm<'hir> {
pub(crate) fn lower_inline_asm(
&mut self,
sp: Span,
asm: &InlineAsm,
) -> &'hir hir::InlineAsm<'hir> {
// Rustdoc needs to support asm! from foreign architectures: don't try
// lowering the register constraints in this case.
let asm_arch = if self.sess.opts.actually_rustdoc { None } else { self.sess.asm_arch };

2
compiler/rustc_ast_lowering/src/item.rs
View file

@ -848,7 +848,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
/// Construct `ExprKind::Err` for the given `span`.
crate fn expr_err(&mut self, span: Span) -> hir::Expr<'hir> {
pub(crate) fn expr_err(&mut self, span: Span) -> hir::Expr<'hir> {
self.expr(span, hir::ExprKind::Err, AttrVec::new())
}

1
compiler/rustc_ast_lowering/src/lib.rs
View file

@ -30,7 +30,6 @@
//! get confused if the spans from leaf AST nodes occur in multiple places
//! in the HIR, especially for multiple identifiers.
#![feature(crate_visibility_modifier)]
#![feature(box_patterns)]
#![feature(let_chains)]
#![feature(let_else)]

6
compiler/rustc_ast_lowering/src/pat.rs
View file

@ -12,11 +12,11 @@ use rustc_span::symbol::Ident;
use rustc_span::{source_map::Spanned, Span};
impl<'a, 'hir> LoweringContext<'a, 'hir> {
crate fn lower_pat(&mut self, pattern: &Pat) -> &'hir hir::Pat<'hir> {
pub(crate) fn lower_pat(&mut self, pattern: &Pat) -> &'hir hir::Pat<'hir> {
self.arena.alloc(self.lower_pat_mut(pattern))
}
crate fn lower_pat_mut(&mut self, mut pattern: &Pat) -> hir::Pat<'hir> {
pub(crate) fn lower_pat_mut(&mut self, mut pattern: &Pat) -> hir::Pat<'hir> {
ensure_sufficient_stack(|| {
// loop here to avoid recursion
let node = loop {
@ -290,7 +290,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
/// Emit a friendly error for extra `..` patterns in a tuple/tuple struct/slice pattern.
crate fn ban_extra_rest_pat(&self, sp: Span, prev_sp: Span, ctx: &str) {
pub(crate) fn ban_extra_rest_pat(&self, sp: Span, prev_sp: Span, ctx: &str) {
self.diagnostic()
.struct_span_err(sp, &format!("`..` can only be used once per {} pattern", ctx))
.span_label(sp, &format!("can only be used once per {} pattern", ctx))

10
compiler/rustc_ast_lowering/src/path.rs
View file

@ -15,7 +15,7 @@ use smallvec::smallvec;
use tracing::debug;
impl<'a, 'hir> LoweringContext<'a, 'hir> {
crate fn lower_qpath(
pub(crate) fn lower_qpath(
&mut self,
id: NodeId,
qself: &Option<QSelf>,
@ -142,7 +142,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
);
}
crate fn lower_path_extra(
pub(crate) fn lower_path_extra(
&mut self,
res: Res,
p: &Path,
@ -163,7 +163,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
})
}
crate fn lower_path(
pub(crate) fn lower_path(
&mut self,
id: NodeId,
p: &Path,
@ -174,7 +174,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
self.lower_path_extra(res, p, param_mode)
}
crate fn lower_path_segment(
pub(crate) fn lower_path_segment(
&mut self,
path_span: Span,
segment: &PathSegment,
@ -381,7 +381,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
/// An associated type binding `Output = $ty`.
crate fn output_ty_binding(
pub(crate) fn output_ty_binding(
&mut self,
span: Span,
ty: &'hir hir::Ty<'hir>,

1
compiler/rustc_ast_pretty/src/lib.rs
View file

@ -1,5 +1,4 @@
#![feature(associated_type_bounds)]
#![feature(crate_visibility_modifier)]
#![feature(box_patterns)]
#![feature(with_negative_coherence)]
#![recursion_limit = "256"]

57
compiler/rustc_ast_pretty/src/pprust/state.rs
View file

@ -95,7 +95,7 @@ pub struct State<'a> {
ann: &'a (dyn PpAnn + 'a),
}
crate const INDENT_UNIT: isize = 4;
pub(crate) const INDENT_UNIT: isize = 4;
/// Requires you to pass an input filename and reader so that
/// it can scan the input text for comments to copy forward.
@ -955,8 +955,13 @@ impl<'a> State<'a> {
State { s: pp::Printer::new(), comments: None, ann: &NoAnn }
}
crate fn commasep_cmnt<T, F, G>(&mut self, b: Breaks, elts: &[T], mut op: F, mut get_span: G)
where
pub(crate) fn commasep_cmnt<T, F, G>(
&mut self,
b: Breaks,
elts: &[T],
mut op: F,
mut get_span: G,
) where
F: FnMut(&mut State<'_>, &T),
G: FnMut(&T) -> rustc_span::Span,
{
@ -976,7 +981,7 @@ impl<'a> State<'a> {
self.end();
}
crate fn commasep_exprs(&mut self, b: Breaks, exprs: &[P<ast::Expr>]) {
pub(crate) fn commasep_exprs(&mut self, b: Breaks, exprs: &[P<ast::Expr>]) {
self.commasep_cmnt(b, exprs, |s, e| s.print_expr(e), |e| e.span)
}
@ -1109,7 +1114,7 @@ impl<'a> State<'a> {
self.print_trait_ref(&t.trait_ref)
}
crate fn print_stmt(&mut self, st: &ast::Stmt) {
pub(crate) fn print_stmt(&mut self, st: &ast::Stmt) {
self.maybe_print_comment(st.span.lo());
match st.kind {
ast::StmtKind::Local(ref loc) => {
@ -1164,19 +1169,19 @@ impl<'a> State<'a> {
self.maybe_print_trailing_comment(st.span, None)
}
crate fn print_block(&mut self, blk: &ast::Block) {
pub(crate) fn print_block(&mut self, blk: &ast::Block) {
self.print_block_with_attrs(blk, &[])
}
crate fn print_block_unclosed_indent(&mut self, blk: &ast::Block) {
pub(crate) fn print_block_unclosed_indent(&mut self, blk: &ast::Block) {
self.print_block_maybe_unclosed(blk, &[], false)
}
crate fn print_block_with_attrs(&mut self, blk: &ast::Block, attrs: &[ast::Attribute]) {
pub(crate) fn print_block_with_attrs(&mut self, blk: &ast::Block, attrs: &[ast::Attribute]) {
self.print_block_maybe_unclosed(blk, attrs, true)
}
crate fn print_block_maybe_unclosed(
pub(crate) fn print_block_maybe_unclosed(
&mut self,
blk: &ast::Block,
attrs: &[ast::Attribute],
@ -1210,7 +1215,7 @@ impl<'a> State<'a> {
}
/// Print a `let pat = expr` expression.
crate fn print_let(&mut self, pat: &ast::Pat, expr: &ast::Expr) {
pub(crate) fn print_let(&mut self, pat: &ast::Pat, expr: &ast::Expr) {
self.word("let ");
self.print_pat(pat);
self.space();
@ -1219,7 +1224,7 @@ impl<'a> State<'a> {
self.print_expr_cond_paren(expr, Self::cond_needs_par(expr) || npals())
}
crate fn print_mac(&mut self, m: &ast::MacCall) {
pub(crate) fn print_mac(&mut self, m: &ast::MacCall) {
self.print_mac_common(
Some(MacHeader::Path(&m.path)),
true,
@ -1360,7 +1365,7 @@ impl<'a> State<'a> {
self.pclose();
}
crate fn print_local_decl(&mut self, loc: &ast::Local) {
pub(crate) fn print_local_decl(&mut self, loc: &ast::Local) {
self.print_pat(&loc.pat);
if let Some(ref ty) = loc.ty {
self.word_space(":");
@ -1368,7 +1373,7 @@ impl<'a> State<'a> {
}
}
crate fn print_name(&mut self, name: Symbol) {
pub(crate) fn print_name(&mut self, name: Symbol) {
self.word(name.to_string());
self.ann.post(self, AnnNode::Name(&name))
}
@ -1392,7 +1397,7 @@ impl<'a> State<'a> {
}
}
crate fn print_pat(&mut self, pat: &ast::Pat) {
pub(crate) fn print_pat(&mut self, pat: &ast::Pat) {
self.maybe_print_comment(pat.span.lo());
self.ann.pre(self, AnnNode::Pat(pat));
/* Pat isn't normalized, but the beauty of it
@ -1551,7 +1556,7 @@ impl<'a> State<'a> {
}
}
crate fn print_asyncness(&mut self, asyncness: ast::Async) {
pub(crate) fn print_asyncness(&mut self, asyncness: ast::Async) {
if asyncness.is_async() {
self.word_nbsp("async");
}
@ -1584,11 +1589,11 @@ impl<'a> State<'a> {
}
}
crate fn print_lifetime(&mut self, lifetime: ast::Lifetime) {
pub(crate) fn print_lifetime(&mut self, lifetime: ast::Lifetime) {
self.print_name(lifetime.ident.name)
}
crate fn print_lifetime_bounds(
pub(crate) fn print_lifetime_bounds(
&mut self,
lifetime: ast::Lifetime,
bounds: &ast::GenericBounds,
@ -1608,7 +1613,7 @@ impl<'a> State<'a> {
}
}
crate fn print_generic_params(&mut self, generic_params: &[ast::GenericParam]) {
pub(crate) fn print_generic_params(&mut self, generic_params: &[ast::GenericParam]) {
if generic_params.is_empty() {
return;
}
@ -1662,12 +1667,12 @@ impl<'a> State<'a> {
}
}
crate fn print_mt(&mut self, mt: &ast::MutTy, print_const: bool) {
pub(crate) fn print_mt(&mut self, mt: &ast::MutTy, print_const: bool) {
self.print_mutability(mt.mutbl, print_const);
self.print_type(&mt.ty)
}
crate fn print_param(&mut self, input: &ast::Param, is_closure: bool) {
pub(crate) fn print_param(&mut self, input: &ast::Param, is_closure: bool) {
self.ibox(INDENT_UNIT);
self.print_outer_attributes_inline(&input.attrs);
@ -1695,7 +1700,7 @@ impl<'a> State<'a> {
self.end();
}
crate fn print_fn_ret_ty(&mut self, fn_ret_ty: &ast::FnRetTy) {
pub(crate) fn print_fn_ret_ty(&mut self, fn_ret_ty: &ast::FnRetTy) {
if let ast::FnRetTy::Ty(ty) = fn_ret_ty {
self.space_if_not_bol();
self.ibox(INDENT_UNIT);
@ -1706,7 +1711,7 @@ impl<'a> State<'a> {
}
}
crate fn print_ty_fn(
pub(crate) fn print_ty_fn(
&mut self,
ext: ast::Extern,
unsafety: ast::Unsafe,
@ -1730,7 +1735,7 @@ impl<'a> State<'a> {
self.end();
}
crate fn print_fn_header_info(&mut self, header: ast::FnHeader) {
pub(crate) fn print_fn_header_info(&mut self, header: ast::FnHeader) {
self.print_constness(header.constness);
self.print_asyncness(header.asyncness);
self.print_unsafety(header.unsafety);
@ -1750,21 +1755,21 @@ impl<'a> State<'a> {
self.word("fn")
}
crate fn print_unsafety(&mut self, s: ast::Unsafe) {
pub(crate) fn print_unsafety(&mut self, s: ast::Unsafe) {
match s {
ast::Unsafe::No => {}
ast::Unsafe::Yes(_) => self.word_nbsp("unsafe"),
}
}
crate fn print_constness(&mut self, s: ast::Const) {
pub(crate) fn print_constness(&mut self, s: ast::Const) {
match s {
ast::Const::No => {}
ast::Const::Yes(_) => self.word_nbsp("const"),
}
}
crate fn print_is_auto(&mut self, s: ast::IsAuto) {
pub(crate) fn print_is_auto(&mut self, s: ast::IsAuto) {
match s {
ast::IsAuto::Yes => self.word_nbsp("auto"),
ast::IsAuto::No => {}

16
compiler/rustc_ast_pretty/src/pprust/state/item.rs
View file

@ -19,7 +19,7 @@ impl<'a> State<'a> {
}
}
crate fn print_foreign_item(&mut self, item: &ast::ForeignItem) {
pub(crate) fn print_foreign_item(&mut self, item: &ast::ForeignItem) {
let ast::Item { id, span, ident, ref attrs, ref kind, ref vis, tokens: _ } = *item;
self.ann.pre(self, AnnNode::SubItem(id));
self.hardbreak_if_not_bol();
@ -128,7 +128,7 @@ impl<'a> State<'a> {
}
/// Pretty-prints an item.
crate fn print_item(&mut self, item: &ast::Item) {
pub(crate) fn print_item(&mut self, item: &ast::Item) {
self.hardbreak_if_not_bol();
self.maybe_print_comment(item.span.lo());
self.print_outer_attributes(&item.attrs);
@ -400,7 +400,7 @@ impl<'a> State<'a> {
self.bclose(span, empty)
}
crate fn print_visibility(&mut self, vis: &ast::Visibility) {
pub(crate) fn print_visibility(&mut self, vis: &ast::Visibility) {
match vis.kind {
ast::VisibilityKind::Public => self.word_nbsp("pub"),
ast::VisibilityKind::Crate(sugar) => match sugar {
@ -484,7 +484,7 @@ impl<'a> State<'a> {
}
}
crate fn print_variant(&mut self, v: &ast::Variant) {
pub(crate) fn print_variant(&mut self, v: &ast::Variant) {
self.head("");
self.print_visibility(&v.vis);
let generics = ast::Generics::default();
@ -496,7 +496,7 @@ impl<'a> State<'a> {
}
}
crate fn print_assoc_item(&mut self, item: &ast::AssocItem) {
pub(crate) fn print_assoc_item(&mut self, item: &ast::AssocItem) {
let ast::Item { id, span, ident, ref attrs, ref kind, ref vis, tokens: _ } = *item;
self.ann.pre(self, AnnNode::SubItem(id));
self.hardbreak_if_not_bol();
@ -562,7 +562,7 @@ impl<'a> State<'a> {
}
}
crate fn print_fn(
pub(crate) fn print_fn(
&mut self,
decl: &ast::FnDecl,
header: ast::FnHeader,
@ -579,7 +579,7 @@ impl<'a> State<'a> {
self.print_where_clause(&generics.where_clause)
}
crate fn print_fn_params_and_ret(&mut self, decl: &ast::FnDecl, is_closure: bool) {
pub(crate) fn print_fn_params_and_ret(&mut self, decl: &ast::FnDecl, is_closure: bool) {
let (open, close) = if is_closure { ("|", "|") } else { ("(", ")") };
self.word(open);
self.commasep(Inconsistent, &decl.inputs, |s, param| s.print_param(param, is_closure));
@ -591,7 +591,7 @@ impl<'a> State<'a> {
self.print_where_clause_parts(where_clause.has_where_token, &where_clause.predicates);
}
crate fn print_where_clause_parts(
pub(crate) fn print_where_clause_parts(
&mut self,
has_where_token: bool,
predicates: &[ast::WherePredicate],

12
compiler/rustc_borrowck/src/borrow_set.rs
View file

@ -29,7 +29,7 @@ pub struct BorrowSet<'tcx> {
/// Map from local to all the borrows on that local.
pub local_map: FxHashMap<mir::Local, FxHashSet<BorrowIndex>>,
crate locals_state_at_exit: LocalsStateAtExit,
pub(crate) locals_state_at_exit: LocalsStateAtExit,
}
impl<'tcx> Index<BorrowIndex> for BorrowSet<'tcx> {
@ -148,23 +148,23 @@ impl<'tcx> BorrowSet<'tcx> {
}
}
crate fn activations_at_location(&self, location: Location) -> &[BorrowIndex] {
pub(crate) fn activations_at_location(&self, location: Location) -> &[BorrowIndex] {
self.activation_map.get(&location).map_or(&[], |activations| &activations[..])
}
crate fn len(&self) -> usize {
pub(crate) fn len(&self) -> usize {
self.location_map.len()
}
crate fn indices(&self) -> impl Iterator<Item = BorrowIndex> {
pub(crate) fn indices(&self) -> impl Iterator<Item = BorrowIndex> {
BorrowIndex::from_usize(0)..BorrowIndex::from_usize(self.len())
}
crate fn iter_enumerated(&self) -> impl Iterator<Item = (BorrowIndex, &BorrowData<'tcx>)> {
pub(crate) fn iter_enumerated(&self) -> impl Iterator<Item = (BorrowIndex, &BorrowData<'tcx>)> {
self.indices().zip(self.location_map.values())
}
crate fn get_index_of(&self, location: &Location) -> Option<BorrowIndex> {
pub(crate) fn get_index_of(&self, location: &Location) -> Option<BorrowIndex> {
self.location_map.get_index_of(location).map(BorrowIndex::from)
}
}

50
compiler/rustc_borrowck/src/borrowck_errors.rs
View file

@ -3,7 +3,7 @@ use rustc_middle::ty::{self, Ty, TyCtxt};
use rustc_span::Span;
impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
crate fn cannot_move_when_borrowed(
pub(crate) fn cannot_move_when_borrowed(
&self,
span: Span,
desc: &str,
@ -11,7 +11,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
struct_span_err!(self, span, E0505, "cannot move out of {} because it is borrowed", desc,)
}
crate fn cannot_use_when_mutably_borrowed(
pub(crate) fn cannot_use_when_mutably_borrowed(
&self,
span: Span,
desc: &str,
@ -31,7 +31,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
err
}
crate fn cannot_act_on_uninitialized_variable(
pub(crate) fn cannot_act_on_uninitialized_variable(
&self,
span: Span,
verb: &str,
@ -47,7 +47,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
)
}
crate fn cannot_mutably_borrow_multiply(
pub(crate) fn cannot_mutably_borrow_multiply(
&self,
new_loan_span: Span,
desc: &str,
@ -97,7 +97,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
err
}
crate fn cannot_uniquely_borrow_by_two_closures(
pub(crate) fn cannot_uniquely_borrow_by_two_closures(
&self,
new_loan_span: Span,
desc: &str,
@ -126,7 +126,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
err
}
crate fn cannot_uniquely_borrow_by_one_closure(
pub(crate) fn cannot_uniquely_borrow_by_one_closure(
&self,
new_loan_span: Span,
container_name: &str,
@ -157,7 +157,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
err
}
crate fn cannot_reborrow_already_uniquely_borrowed(
pub(crate) fn cannot_reborrow_already_uniquely_borrowed(
&self,
new_loan_span: Span,
container_name: &str,
@ -193,7 +193,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
err
}
crate fn cannot_reborrow_already_borrowed(
pub(crate) fn cannot_reborrow_already_borrowed(
&self,
span: Span,
desc_new: &str,
@ -242,7 +242,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
err
}
crate fn cannot_assign_to_borrowed(
pub(crate) fn cannot_assign_to_borrowed(
&self,
span: Span,
borrow_span: Span,
@ -261,7 +261,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
err
}
crate fn cannot_reassign_immutable(
pub(crate) fn cannot_reassign_immutable(
&self,
span: Span,
desc: &str,
@ -271,7 +271,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
struct_span_err!(self, span, E0384, "cannot assign {} {}", msg, desc)
}
crate fn cannot_assign(
pub(crate) fn cannot_assign(
&self,
span: Span,
desc: &str,
@ -279,7 +279,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
struct_span_err!(self, span, E0594, "cannot assign to {}", desc)
}
crate fn cannot_move_out_of(
pub(crate) fn cannot_move_out_of(
&self,
move_from_span: Span,
move_from_desc: &str,
@ -290,7 +290,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
/// Signal an error due to an attempt to move out of the interior
/// of an array or slice. `is_index` is None when error origin
/// didn't capture whether there was an indexing operation or not.
crate fn cannot_move_out_of_interior_noncopy(
pub(crate) fn cannot_move_out_of_interior_noncopy(
&self,
move_from_span: Span,
ty: Ty<'_>,
@ -313,7 +313,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
err
}
crate fn cannot_move_out_of_interior_of_drop(
pub(crate) fn cannot_move_out_of_interior_of_drop(
&self,
move_from_span: Span,
container_ty: Ty<'_>,
@ -329,7 +329,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
err
}
crate fn cannot_act_on_moved_value(
pub(crate) fn cannot_act_on_moved_value(
&self,
use_span: Span,
verb: &str,
@ -349,7 +349,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
)
}
crate fn cannot_borrow_path_as_mutable_because(
pub(crate) fn cannot_borrow_path_as_mutable_because(
&self,
span: Span,
path: &str,
@ -358,7 +358,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
struct_span_err!(self, span, E0596, "cannot borrow {} as mutable{}", path, reason,)
}
crate fn cannot_mutate_in_immutable_section(
pub(crate) fn cannot_mutate_in_immutable_section(
&self,
mutate_span: Span,
immutable_span: Span,
@ -380,7 +380,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
err
}
crate fn cannot_borrow_across_generator_yield(
pub(crate) fn cannot_borrow_across_generator_yield(
&self,
span: Span,
yield_span: Span,
@ -395,7 +395,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
err
}
crate fn cannot_borrow_across_destructor(
pub(crate) fn cannot_borrow_across_destructor(
&self,
borrow_span: Span,
) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
@ -407,7 +407,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
)
}
crate fn path_does_not_live_long_enough(
pub(crate) fn path_does_not_live_long_enough(
&self,
span: Span,
path: &str,
@ -415,7 +415,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
struct_span_err!(self, span, E0597, "{} does not live long enough", path,)
}
crate fn cannot_return_reference_to_local(
pub(crate) fn cannot_return_reference_to_local(
&self,
span: Span,
return_kind: &str,
@ -440,7 +440,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
err
}
crate fn cannot_capture_in_long_lived_closure(
pub(crate) fn cannot_capture_in_long_lived_closure(
&self,
closure_span: Span,
closure_kind: &str,
@ -462,14 +462,14 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
err
}
crate fn thread_local_value_does_not_live_long_enough(
pub(crate) fn thread_local_value_does_not_live_long_enough(
&self,
span: Span,
) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
struct_span_err!(self, span, E0712, "thread-local variable borrowed past end of function",)
}
crate fn temporary_value_borrowed_for_too_long(
pub(crate) fn temporary_value_borrowed_for_too_long(
&self,
span: Span,
) -> DiagnosticBuilder<'cx, ErrorGuaranteed> {
@ -486,7 +486,7 @@ impl<'cx, 'tcx> crate::MirBorrowckCtxt<'cx, 'tcx> {
}
}
crate fn borrowed_data_escapes_closure<'tcx>(
pub(crate) fn borrowed_data_escapes_closure<'tcx>(
tcx: TyCtxt<'tcx>,
escape_span: Span,
escapes_from: &str,

32
compiler/rustc_borrowck/src/constraints/graph.rs
View file

@ -13,19 +13,19 @@ use crate::{
/// The construct graph organizes the constraints by their end-points.
/// It can be used to view a `R1: R2` constraint as either an edge `R1
/// -> R2` or `R2 -> R1` depending on the direction type `D`.
crate struct ConstraintGraph<D: ConstraintGraphDirecton> {
pub(crate) struct ConstraintGraph<D: ConstraintGraphDirecton> {
_direction: D,
first_constraints: IndexVec<RegionVid, Option<OutlivesConstraintIndex>>,
next_constraints: IndexVec<OutlivesConstraintIndex, Option<OutlivesConstraintIndex>>,
}
crate type NormalConstraintGraph = ConstraintGraph<Normal>;
pub(crate) type NormalConstraintGraph = ConstraintGraph<Normal>;
crate type ReverseConstraintGraph = ConstraintGraph<Reverse>;
pub(crate) type ReverseConstraintGraph = ConstraintGraph<Reverse>;
/// Marker trait that controls whether a `R1: R2` constraint
/// represents an edge `R1 -> R2` or `R2 -> R1`.
crate trait ConstraintGraphDirecton: Copy + 'static {
pub(crate) trait ConstraintGraphDirecton: Copy + 'static {
fn start_region(c: &OutlivesConstraint<'_>) -> RegionVid;
fn end_region(c: &OutlivesConstraint<'_>) -> RegionVid;
fn is_normal() -> bool;
@ -36,7 +36,7 @@ crate trait ConstraintGraphDirecton: Copy + 'static {
/// inference. This is because we compute the value of R1 by union'ing
/// all the things that it relies on.
#[derive(Copy, Clone, Debug)]
crate struct Normal;
pub(crate) struct Normal;
impl ConstraintGraphDirecton for Normal {
fn start_region(c: &OutlivesConstraint<'_>) -> RegionVid {
@ -57,7 +57,7 @@ impl ConstraintGraphDirecton for Normal {
/// we wish to iterate from a region (e.g., R2) to all the regions
/// that will outlive it (e.g., R1).
#[derive(Copy, Clone, Debug)]
crate struct Reverse;
pub(crate) struct Reverse;
impl ConstraintGraphDirecton for Reverse {
fn start_region(c: &OutlivesConstraint<'_>) -> RegionVid {
@ -78,7 +78,11 @@ impl<D: ConstraintGraphDirecton> ConstraintGraph<D> {
/// R2` is treated as an edge `R1 -> R2`. We use this graph to
/// construct SCCs for region inference but also for error
/// reporting.
crate fn new(direction: D, set: &OutlivesConstraintSet<'_>, num_region_vars: usize) -> Self {
pub(crate) fn new(
direction: D,
set: &OutlivesConstraintSet<'_>,
num_region_vars: usize,
) -> Self {
let mut first_constraints = IndexVec::from_elem_n(None, num_region_vars);
let mut next_constraints = IndexVec::from_elem(None, &set.outlives);
@ -96,7 +100,7 @@ impl<D: ConstraintGraphDirecton> ConstraintGraph<D> {
/// Given the constraint set from which this graph was built
/// creates a region graph so that you can iterate over *regions*
/// and not constraints.
crate fn region_graph<'rg, 'tcx>(
pub(crate) fn region_graph<'rg, 'tcx>(
&'rg self,
set: &'rg OutlivesConstraintSet<'tcx>,
static_region: RegionVid,
@ -105,7 +109,7 @@ impl<D: ConstraintGraphDirecton> ConstraintGraph<D> {
}
/// Given a region `R`, iterate over all constraints `R: R1`.
crate fn outgoing_edges<'a, 'tcx>(
pub(crate) fn outgoing_edges<'a, 'tcx>(
&'a self,
region_sup: RegionVid,
constraints: &'a OutlivesConstraintSet<'tcx>,
@ -129,7 +133,7 @@ impl<D: ConstraintGraphDirecton> ConstraintGraph<D> {
}
}
crate struct Edges<'s, 'tcx, D: ConstraintGraphDirecton> {
pub(crate) struct Edges<'s, 'tcx, D: ConstraintGraphDirecton> {
graph: &'s ConstraintGraph<D>,
constraints: &'s OutlivesConstraintSet<'tcx>,
pointer: Option<OutlivesConstraintIndex>,
@ -169,7 +173,7 @@ impl<'s, 'tcx, D: ConstraintGraphDirecton> Iterator for Edges<'s, 'tcx, D> {
/// This struct brings together a constraint set and a (normal, not
/// reverse) constraint graph. It implements the graph traits and is
/// usd for doing the SCC computation.
crate struct RegionGraph<'s, 'tcx, D: ConstraintGraphDirecton> {
pub(crate) struct RegionGraph<'s, 'tcx, D: ConstraintGraphDirecton> {
set: &'s OutlivesConstraintSet<'tcx>,
constraint_graph: &'s ConstraintGraph<D>,
static_region: RegionVid,
@ -180,7 +184,7 @@ impl<'s, 'tcx, D: ConstraintGraphDirecton> RegionGraph<'s, 'tcx, D> {
/// R2` is treated as an edge `R1 -> R2`. We use this graph to
/// construct SCCs for region inference but also for error
/// reporting.
crate fn new(
pub(crate) fn new(
set: &'s OutlivesConstraintSet<'tcx>,
constraint_graph: &'s ConstraintGraph<D>,
static_region: RegionVid,
@ -190,14 +194,14 @@ impl<'s, 'tcx, D: ConstraintGraphDirecton> RegionGraph<'s, 'tcx, D> {
/// Given a region `R`, iterate over all regions `R1` such that
/// there exists a constraint `R: R1`.
crate fn outgoing_regions(&self, region_sup: RegionVid) -> Successors<'s, 'tcx, D> {
pub(crate) fn outgoing_regions(&self, region_sup: RegionVid) -> Successors<'s, 'tcx, D> {
Successors {
edges: self.constraint_graph.outgoing_edges(region_sup, self.set, self.static_region),
}
}
}
crate struct Successors<'s, 'tcx, D: ConstraintGraphDirecton> {
pub(crate) struct Successors<'s, 'tcx, D: ConstraintGraphDirecton> {
edges: Edges<'s, 'tcx, D>,
}

14
compiler/rustc_borrowck/src/constraints/mod.rs
View file

@ -8,19 +8,19 @@ use std::ops::Index;
use crate::type_check::Locations;
crate mod graph;
pub(crate) mod graph;
/// A set of NLL region constraints. These include "outlives"
/// constraints of the form `R1: R2`. Each constraint is identified by
/// a unique `OutlivesConstraintIndex` and you can index into the set
/// (`constraint_set[i]`) to access the constraint details.
#[derive(Clone, Default)]
crate struct OutlivesConstraintSet<'tcx> {
pub(crate) struct OutlivesConstraintSet<'tcx> {
outlives: IndexVec<OutlivesConstraintIndex, OutlivesConstraint<'tcx>>,
}
impl<'tcx> OutlivesConstraintSet<'tcx> {
crate fn push(&mut self, constraint: OutlivesConstraint<'tcx>) {
pub(crate) fn push(&mut self, constraint: OutlivesConstraint<'tcx>) {
debug!(
"OutlivesConstraintSet::push({:?}: {:?} @ {:?}",
constraint.sup, constraint.sub, constraint.locations
@ -38,20 +38,20 @@ impl<'tcx> OutlivesConstraintSet<'tcx> {
/// N.B., this graph contains a "frozen" view of the current
/// constraints. Any new constraints added to the `OutlivesConstraintSet`
/// after the graph is built will not be present in the graph.
crate fn graph(&self, num_region_vars: usize) -> graph::NormalConstraintGraph {
pub(crate) fn graph(&self, num_region_vars: usize) -> graph::NormalConstraintGraph {
graph::ConstraintGraph::new(graph::Normal, self, num_region_vars)
}
/// Like `graph`, but constraints a reverse graph where `R1: R2`
/// represents an edge `R2 -> R1`.
crate fn reverse_graph(&self, num_region_vars: usize) -> graph::ReverseConstraintGraph {
pub(crate) fn reverse_graph(&self, num_region_vars: usize) -> graph::ReverseConstraintGraph {
graph::ConstraintGraph::new(graph::Reverse, self, num_region_vars)
}
/// Computes cycles (SCCs) in the graph of regions. In particular,
/// find all regions R1, R2 such that R1: R2 and R2: R1 and group
/// them into an SCC, and find the relationships between SCCs.
crate fn compute_sccs(
pub(crate) fn compute_sccs(
&self,
constraint_graph: &graph::NormalConstraintGraph,
static_region: RegionVid,
@ -60,7 +60,7 @@ impl<'tcx> OutlivesConstraintSet<'tcx> {
Sccs::new(region_graph)
}
crate fn outlives(&self) -> &IndexVec<OutlivesConstraintIndex, OutlivesConstraint<'tcx>> {
pub(crate) fn outlives(&self) -> &IndexVec<OutlivesConstraintIndex, OutlivesConstraint<'tcx>> {
&self.outlives
}
}

2
compiler/rustc_borrowck/src/dataflow.rs
View file

@ -233,7 +233,7 @@ impl<'tcx> OutOfScopePrecomputer<'_, 'tcx> {
}
impl<'a, 'tcx> Borrows<'a, 'tcx> {
crate fn new(
pub(crate) fn new(
tcx: TyCtxt<'tcx>,
body: &'a Body<'tcx>,
nonlexical_regioncx: &'a RegionInferenceContext<'tcx>,

10
compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs
View file

@ -22,7 +22,7 @@ use crate::region_infer::values::RegionElement;
use crate::MirBorrowckCtxt;
#[derive(Clone)]
crate struct UniverseInfo<'tcx>(UniverseInfoInner<'tcx>);
pub(crate) struct UniverseInfo<'tcx>(UniverseInfoInner<'tcx>);
/// What operation a universe was created for.
#[derive(Clone)]
@ -36,15 +36,15 @@ enum UniverseInfoInner<'tcx> {
}
impl<'tcx> UniverseInfo<'tcx> {
crate fn other() -> UniverseInfo<'tcx> {
pub(crate) fn other() -> UniverseInfo<'tcx> {
UniverseInfo(UniverseInfoInner::Other)
}
crate fn relate(expected: Ty<'tcx>, found: Ty<'tcx>) -> UniverseInfo<'tcx> {
pub(crate) fn relate(expected: Ty<'tcx>, found: Ty<'tcx>) -> UniverseInfo<'tcx> {
UniverseInfo(UniverseInfoInner::RelateTys { expected, found })
}
crate fn report_error(
pub(crate) fn report_error(
&self,
mbcx: &mut MirBorrowckCtxt<'_, 'tcx>,
placeholder: ty::PlaceholderRegion,
@ -76,7 +76,7 @@ impl<'tcx> UniverseInfo<'tcx> {
}
}
crate trait ToUniverseInfo<'tcx> {
pub(crate) trait ToUniverseInfo<'tcx> {
fn to_universe_info(self, base_universe: ty::UniverseIndex) -> UniverseInfo<'tcx>;
}

2
compiler/rustc_borrowck/src/diagnostics/find_use.rs
View file

@ -11,7 +11,7 @@ use rustc_middle::mir::visit::{MirVisitable, PlaceContext, Visitor};
use rustc_middle::mir::{Body, Local, Location};
use rustc_middle::ty::{RegionVid, TyCtxt};
crate fn find<'tcx>(
pub(crate) fn find<'tcx>(
body: &Body<'tcx>,
regioncx: &Rc<RegionInferenceContext<'tcx>>,
tcx: TyCtxt<'tcx>,

12
compiler/rustc_borrowck/src/diagnostics/mod.rs
View file

@ -35,12 +35,12 @@ mod move_errors;
mod mutability_errors;
mod region_errors;
crate use bound_region_errors::{ToUniverseInfo, UniverseInfo};
crate use mutability_errors::AccessKind;
crate use outlives_suggestion::OutlivesSuggestionBuilder;
crate use region_errors::{ErrorConstraintInfo, RegionErrorKind, RegionErrors};
crate use region_name::{RegionName, RegionNameSource};
crate use rustc_const_eval::util::CallKind;
pub(crate) use bound_region_errors::{ToUniverseInfo, UniverseInfo};
pub(crate) use mutability_errors::AccessKind;
pub(crate) use outlives_suggestion::OutlivesSuggestionBuilder;
pub(crate) use region_errors::{ErrorConstraintInfo, RegionErrorKind, RegionErrors};
pub(crate) use region_name::{RegionName, RegionNameSource};
pub(crate) use rustc_const_eval::util::CallKind;
use rustc_middle::mir::tcx::PlaceTy;
pub(super) struct IncludingDowncast(pub(super) bool);

6
compiler/rustc_borrowck/src/diagnostics/outlives_suggestion.rs
View file

@ -149,7 +149,7 @@ impl OutlivesSuggestionBuilder {
}
/// Add the outlives constraint `fr: outlived_fr` to the set of constraints we need to suggest.
crate fn collect_constraint(&mut self, fr: RegionVid, outlived_fr: RegionVid) {
pub(crate) fn collect_constraint(&mut self, fr: RegionVid, outlived_fr: RegionVid) {
debug!("Collected {:?}: {:?}", fr, outlived_fr);
// Add to set of constraints for final help note.
@ -158,7 +158,7 @@ impl OutlivesSuggestionBuilder {
/// Emit an intermediate note on the given `Diagnostic` if the involved regions are
/// suggestable.
crate fn intermediate_suggestion(
pub(crate) fn intermediate_suggestion(
&mut self,
mbcx: &MirBorrowckCtxt<'_, '_>,
errci: &ErrorConstraintInfo,
@ -179,7 +179,7 @@ impl OutlivesSuggestionBuilder {
/// If there is a suggestion to emit, add a diagnostic to the buffer. This is the final
/// suggestion including all collected constraints.
crate fn add_suggestion(&self, mbcx: &mut MirBorrowckCtxt<'_, '_>) {
pub(crate) fn add_suggestion(&self, mbcx: &mut MirBorrowckCtxt<'_, '_>) {
// No constraints to add? Done.
if self.constraints_to_add.is_empty() {
debug!("No constraints to suggest.");

4
compiler/rustc_borrowck/src/diagnostics/region_errors.rs
View file

@ -58,10 +58,10 @@ impl ConstraintDescription for ConstraintCategory {
///
/// Usually we expect this to either be empty or contain a small number of items, so we can avoid
/// allocation most of the time.
crate type RegionErrors<'tcx> = Vec<RegionErrorKind<'tcx>>;
pub(crate) type RegionErrors<'tcx> = Vec<RegionErrorKind<'tcx>>;
#[derive(Clone, Debug)]
crate enum RegionErrorKind<'tcx> {
pub(crate) enum RegionErrorKind<'tcx> {
/// A generic bound failure for a type test (`T: 'a`).
TypeTestError { type_test: TypeTest<'tcx> },

22
compiler/rustc_borrowck/src/diagnostics/region_name.rs
View file

@ -15,18 +15,18 @@ use crate::{nll::ToRegionVid, universal_regions::DefiningTy, MirBorrowckCtxt};
/// A name for a particular region used in emitting diagnostics. This name could be a generated
/// name like `'1`, a name used by the user like `'a`, or a name like `'static`.
#[derive(Debug, Clone)]
crate struct RegionName {
pub(crate) struct RegionName {
/// The name of the region (interned).
crate name: Symbol,
pub(crate) name: Symbol,
/// Where the region comes from.
crate source: RegionNameSource,
pub(crate) source: RegionNameSource,
}
/// Denotes the source of a region that is named by a `RegionName`. For example, a free region that
/// was named by the user would get `NamedFreeRegion` and `'static` lifetime would get `Static`.
/// This helps to print the right kinds of diagnostics.
#[derive(Debug, Clone)]
crate enum RegionNameSource {
pub(crate) enum RegionNameSource {
/// A bound (not free) region that was substituted at the def site (not an HRTB).
NamedEarlyBoundRegion(Span),
/// A free region that the user has a name (`'a`) for.
@ -50,7 +50,7 @@ crate enum RegionNameSource {
/// Describes what to highlight to explain to the user that we're giving an anonymous region a
/// synthesized name, and how to highlight it.
#[derive(Debug, Clone)]
crate enum RegionNameHighlight {
pub(crate) enum RegionNameHighlight {
/// The anonymous region corresponds to a reference that was found by traversing the type in the HIR.
MatchedHirTy(Span),
/// The anonymous region corresponds to a `'_` in the generics list of a struct/enum/union.
@ -65,7 +65,7 @@ crate enum RegionNameHighlight {
}
impl RegionName {
crate fn was_named(&self) -> bool {
pub(crate) fn was_named(&self) -> bool {
match self.source {
RegionNameSource::NamedEarlyBoundRegion(..)
| RegionNameSource::NamedFreeRegion(..)
@ -79,7 +79,7 @@ impl RegionName {
}
}
crate fn span(&self) -> Option<Span> {
pub(crate) fn span(&self) -> Option<Span> {
match self.source {
RegionNameSource::Static => None,
RegionNameSource::NamedEarlyBoundRegion(span)
@ -98,7 +98,7 @@ impl RegionName {
}
}
crate fn highlight_region_name(&self, diag: &mut Diagnostic) {
pub(crate) fn highlight_region_name(&self, diag: &mut Diagnostic) {
match &self.source {
RegionNameSource::NamedFreeRegion(span)
| RegionNameSource::NamedEarlyBoundRegion(span) => {
@ -178,11 +178,11 @@ impl Display for RegionName {
}
impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
crate fn mir_def_id(&self) -> hir::def_id::LocalDefId {
pub(crate) fn mir_def_id(&self) -> hir::def_id::LocalDefId {
self.body.source.def_id().as_local().unwrap()
}
crate fn mir_hir_id(&self) -> hir::HirId {
pub(crate) fn mir_hir_id(&self) -> hir::HirId {
self.infcx.tcx.hir().local_def_id_to_hir_id(self.mir_def_id())
}
@ -222,7 +222,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> {
/// ```
///
/// and then return the name `'1` for us to use.
crate fn give_region_a_name(&self, fr: RegionVid) -> Option<RegionName> {
pub(crate) fn give_region_a_name(&self, fr: RegionVid) -> Option<RegionName> {
debug!(
"give_region_a_name(fr={:?}, counter={:?})",
fr,

14
compiler/rustc_borrowck/src/diagnostics/var_name.rs
View file

@ -7,7 +7,7 @@ use rustc_span::source_map::Span;
use rustc_span::symbol::Symbol;
impl<'tcx> RegionInferenceContext<'tcx> {
crate fn get_var_name_and_span_for_region(
pub(crate) fn get_var_name_and_span_for_region(
&self,
tcx: TyCtxt<'tcx>,
body: &Body<'tcx>,
@ -34,7 +34,11 @@ impl<'tcx> RegionInferenceContext<'tcx> {
}
/// Search the upvars (if any) to find one that references fr. Return its index.
crate fn get_upvar_index_for_region(&self, tcx: TyCtxt<'tcx>, fr: RegionVid) -> Option<usize> {
pub(crate) fn get_upvar_index_for_region(
&self,
tcx: TyCtxt<'tcx>,
fr: RegionVid,
) -> Option<usize> {
let upvar_index =
self.universal_regions().defining_ty.upvar_tys().position(|upvar_ty| {
debug!("get_upvar_index_for_region: upvar_ty={:?}", upvar_ty);
@ -57,7 +61,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
/// Given the index of an upvar, finds its name and the span from where it was
/// declared.
crate fn get_upvar_name_and_span_for_region(
pub(crate) fn get_upvar_name_and_span_for_region(
&self,
tcx: TyCtxt<'tcx>,
upvars: &[Upvar<'tcx>],
@ -81,7 +85,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
///
/// N.B., in the case of a closure, the index is indexing into the signature as seen by the
/// user - in particular, index 0 is not the implicit self parameter.
crate fn get_argument_index_for_region(
pub(crate) fn get_argument_index_for_region(
&self,
tcx: TyCtxt<'tcx>,
fr: RegionVid,
@ -107,7 +111,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
/// Given the index of an argument, finds its name (if any) and the span from where it was
/// declared.
crate fn get_argument_name_and_span_for_region(
pub(crate) fn get_argument_name_and_span_for_region(
&self,
body: &Body<'tcx>,
local_names: &IndexVec<Local, Option<Symbol>>,

2
compiler/rustc_borrowck/src/facts.rs
View file

@ -25,7 +25,7 @@ impl polonius_engine::FactTypes for RustcFacts {
pub type AllFacts = PoloniusFacts<RustcFacts>;
crate trait AllFactsExt {
pub(crate) trait AllFactsExt {
/// Returns `true` if there is a need to gather `AllFacts` given the
/// current `-Z` flags.
fn enabled(tcx: TyCtxt<'_>) -> bool;

1
compiler/rustc_borrowck/src/lib.rs
View file

@ -2,7 +2,6 @@
#![allow(rustc::potential_query_instability)]
#![feature(box_patterns)]
#![feature(crate_visibility_modifier)]
#![feature(let_chains)]
#![feature(let_else)]
#![feature(min_specialization)]

2
compiler/rustc_borrowck/src/location.rs
View file

@ -30,7 +30,7 @@ pub enum RichLocation {
}
impl LocationTable {
crate fn new(body: &Body<'_>) -> Self {
pub(crate) fn new(body: &Body<'_>) -> Self {
let mut num_points = 0;
let statements_before_block = body
.basic_blocks()

22
compiler/rustc_borrowck/src/member_constraints.rs
View file

@ -8,7 +8,7 @@ use std::ops::Index;
/// Compactly stores a set of `R0 member of [R1...Rn]` constraints,
/// indexed by the region `R0`.
crate struct MemberConstraintSet<'tcx, R>
pub(crate) struct MemberConstraintSet<'tcx, R>
where
R: Copy + Eq,
{
@ -28,17 +28,17 @@ where
}
/// Represents a `R0 member of [R1..Rn]` constraint
crate struct NllMemberConstraint<'tcx> {
pub(crate) struct NllMemberConstraint<'tcx> {
next_constraint: Option<NllMemberConstraintIndex>,
/// The span where the hidden type was instantiated.
crate definition_span: Span,
pub(crate) definition_span: Span,
/// The hidden type in which `R0` appears. (Used in error reporting.)
crate hidden_ty: Ty<'tcx>,
pub(crate) hidden_ty: Ty<'tcx>,
/// The region `R0`.
crate member_region_vid: ty::RegionVid,
pub(crate) member_region_vid: ty::RegionVid,
/// Index of `R1` in `choice_regions` vector from `MemberConstraintSet`.
start_index: usize,
@ -48,7 +48,7 @@ crate struct NllMemberConstraint<'tcx> {
}
rustc_index::newtype_index! {
crate struct NllMemberConstraintIndex {
pub(crate) struct NllMemberConstraintIndex {
DEBUG_FORMAT = "MemberConstraintIndex({})"
}
}
@ -73,7 +73,7 @@ impl<'tcx> MemberConstraintSet<'tcx, ty::RegionVid> {
/// within into `RegionVid` format -- it typically consults the
/// `UniversalRegions` data structure that is known to the caller
/// (but which this code is unaware of).
crate fn push_constraint(
pub(crate) fn push_constraint(
&mut self,
m_c: &MemberConstraint<'tcx>,
mut to_region_vid: impl FnMut(ty::Region<'tcx>) -> ty::RegionVid,
@ -106,7 +106,7 @@ where
/// the original `RegionVid` to an scc index. In some cases, we
/// may have multiple `R1` values mapping to the same `R2` key -- that
/// is ok, the two sets will be merged.
crate fn into_mapped<R2>(
pub(crate) fn into_mapped<R2>(
self,
mut map_fn: impl FnMut(R1) -> R2,
) -> MemberConstraintSet<'tcx, R2>
@ -144,14 +144,14 @@ impl<R> MemberConstraintSet<'_, R>
where
R: Copy + Hash + Eq,
{
crate fn all_indices(&self) -> impl Iterator<Item = NllMemberConstraintIndex> + '_ {
pub(crate) fn all_indices(&self) -> impl Iterator<Item = NllMemberConstraintIndex> + '_ {
self.constraints.indices()
}
/// Iterate down the constraint indices associated with a given
/// peek-region. You can then use `choice_regions` and other
/// methods to access data.
crate fn indices(
pub(crate) fn indices(
&self,
member_region_vid: R,
) -> impl Iterator<Item = NllMemberConstraintIndex> + '_ {
@ -172,7 +172,7 @@ where
/// ```text
/// R0 member of [R1..Rn]
/// ```
crate fn choice_regions(&self, pci: NllMemberConstraintIndex) -> &[ty::RegionVid] {
pub(crate) fn choice_regions(&self, pci: NllMemberConstraintIndex) -> &[ty::RegionVid] {
let NllMemberConstraint { start_index, end_index, .. } = &self.constraints[pci];
&self.choice_regions[*start_index..*end_index]
}

4
compiler/rustc_borrowck/src/nll.rs
View file

@ -42,7 +42,7 @@ pub type PoloniusOutput = Output<RustcFacts>;
/// The output of `nll::compute_regions`. This includes the computed `RegionInferenceContext`, any
/// closure requirements to propagate, and any generated errors.
crate struct NllOutput<'tcx> {
pub(crate) struct NllOutput<'tcx> {
pub regioncx: RegionInferenceContext<'tcx>,
pub opaque_type_values: VecMap<DefId, OpaqueHiddenType<'tcx>>,
pub polonius_input: Option<Box<AllFacts>>,
@ -457,6 +457,6 @@ impl ToRegionVid for RegionVid {
}
}
crate trait ConstraintDescription {
pub(crate) trait ConstraintDescription {
fn description(&self) -> &'static str;
}

2
compiler/rustc_borrowck/src/place_ext.rs
View file

@ -5,7 +5,7 @@ use rustc_middle::mir::{Body, Mutability, Place};
use rustc_middle::ty::{self, TyCtxt};
/// Extension methods for the `Place` type.
crate trait PlaceExt<'tcx> {
pub(crate) trait PlaceExt<'tcx> {
/// Returns `true` if we can safely ignore borrows of this place.
/// This is true whenever there is no action that the user can do
/// to the place `self` that would invalidate the borrow. This is true

4
compiler/rustc_borrowck/src/places_conflict.rs
View file

@ -14,7 +14,7 @@ use std::iter;
/// being run in the calling context, the conservative choice is to assume the compared indices
/// are disjoint (and therefore, do not overlap).
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
crate enum PlaceConflictBias {
pub(crate) enum PlaceConflictBias {
Overlap,
NoOverlap,
}
@ -22,7 +22,7 @@ crate enum PlaceConflictBias {
/// Helper function for checking if places conflict with a mutable borrow and deep access depth.
/// This is used to check for places conflicting outside of the borrow checking code (such as in
/// dataflow).
crate fn places_conflict<'tcx>(
pub(crate) fn places_conflict<'tcx>(
tcx: TyCtxt<'tcx>,
body: &Body<'tcx>,
borrow_place: Place<'tcx>,

4
compiler/rustc_borrowck/src/region_infer/graphviz.rs
View file

@ -11,12 +11,12 @@ use rustc_graphviz as dot;
impl<'tcx> RegionInferenceContext<'tcx> {
/// Write out the region constraint graph.
crate fn dump_graphviz_raw_constraints(&self, mut w: &mut dyn Write) -> io::Result<()> {
pub(crate) fn dump_graphviz_raw_constraints(&self, mut w: &mut dyn Write) -> io::Result<()> {
dot::render(&RawConstraints { regioncx: self }, &mut w)
}
/// Write out the region constraint graph.
crate fn dump_graphviz_scc_constraints(&self, mut w: &mut dyn Write) -> io::Result<()> {
pub(crate) fn dump_graphviz_scc_constraints(&self, mut w: &mut dyn Write) -> io::Result<()> {
let mut nodes_per_scc: IndexVec<ConstraintSccIndex, _> =
self.constraint_sccs.all_sccs().map(|_| Vec::new()).collect();

32
compiler/rustc_borrowck/src/region_infer/mod.rs
View file

@ -513,26 +513,26 @@ impl<'tcx> RegionInferenceContext<'tcx> {
}
/// Adds annotations for `#[rustc_regions]`; see `UniversalRegions::annotate`.
crate fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diagnostic) {
pub(crate) fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diagnostic) {
self.universal_regions.annotate(tcx, err)
}
/// Returns `true` if the region `r` contains the point `p`.
///
/// Panics if called before `solve()` executes,
crate fn region_contains(&self, r: impl ToRegionVid, p: impl ToElementIndex) -> bool {
pub(crate) fn region_contains(&self, r: impl ToRegionVid, p: impl ToElementIndex) -> bool {
let scc = self.constraint_sccs.scc(r.to_region_vid());
self.scc_values.contains(scc, p)
}
/// Returns access to the value of `r` for debugging purposes.
crate fn region_value_str(&self, r: RegionVid) -> String {
pub(crate) fn region_value_str(&self, r: RegionVid) -> String {
let scc = self.constraint_sccs.scc(r.to_region_vid());
self.scc_values.region_value_str(scc)
}
/// Returns access to the value of `r` for debugging purposes.
crate fn region_universe(&self, r: RegionVid) -> ty::UniverseIndex {
pub(crate) fn region_universe(&self, r: RegionVid) -> ty::UniverseIndex {
let scc = self.constraint_sccs.scc(r.to_region_vid());
self.scc_universes[scc]
}
@ -1693,7 +1693,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
/// that cannot be named by `fr1`; in that case, we will require
/// that `fr1: 'static` because it is the only way to `fr1: r` to
/// be satisfied. (See `add_incompatible_universe`.)
crate fn provides_universal_region(
pub(crate) fn provides_universal_region(
&self,
r: RegionVid,
fr1: RegionVid,
@ -1712,7 +1712,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
/// If `r2` represents a placeholder region, then this returns
/// `true` if `r1` cannot name that placeholder in its
/// value; otherwise, returns `false`.
crate fn cannot_name_placeholder(&self, r1: RegionVid, r2: RegionVid) -> bool {
pub(crate) fn cannot_name_placeholder(&self, r1: RegionVid, r2: RegionVid) -> bool {
debug!("cannot_name_value_of(r1={:?}, r2={:?})", r1, r2);
match self.definitions[r2].origin {
@ -1731,7 +1731,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
}
}
crate fn retrieve_closure_constraint_info(
pub(crate) fn retrieve_closure_constraint_info(
&self,
_body: &Body<'tcx>,
constraint: &OutlivesConstraint<'tcx>,
@ -1766,7 +1766,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
}
/// Finds a good `ObligationCause` to blame for the fact that `fr1` outlives `fr2`.
crate fn find_outlives_blame_span(
pub(crate) fn find_outlives_blame_span(
&self,
body: &Body<'tcx>,
fr1: RegionVid,
@ -1788,7 +1788,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
///
/// Returns: a series of constraints as well as the region `R`
/// that passed the target test.
crate fn find_constraint_paths_between_regions(
pub(crate) fn find_constraint_paths_between_regions(
&self,
from_region: RegionVid,
target_test: impl Fn(RegionVid) -> bool,
@ -1882,7 +1882,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
/// Finds some region R such that `fr1: R` and `R` is live at `elem`.
#[instrument(skip(self), level = "trace")]
crate fn find_sub_region_live_at(&self, fr1: RegionVid, elem: Location) -> RegionVid {
pub(crate) fn find_sub_region_live_at(&self, fr1: RegionVid, elem: Location) -> RegionVid {
trace!(scc = ?self.constraint_sccs.scc(fr1));
trace!(universe = ?self.scc_universes[self.constraint_sccs.scc(fr1)]);
self.find_constraint_paths_between_regions(fr1, |r| {
@ -1919,7 +1919,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
}
/// Get the region outlived by `longer_fr` and live at `element`.
crate fn region_from_element(
pub(crate) fn region_from_element(
&self,
longer_fr: RegionVid,
element: &RegionElement,
@ -1939,17 +1939,17 @@ impl<'tcx> RegionInferenceContext<'tcx> {
}
/// Get the region definition of `r`.
crate fn region_definition(&self, r: RegionVid) -> &RegionDefinition<'tcx> {
pub(crate) fn region_definition(&self, r: RegionVid) -> &RegionDefinition<'tcx> {
&self.definitions[r]
}
/// Check if the SCC of `r` contains `upper`.
crate fn upper_bound_in_region_scc(&self, r: RegionVid, upper: RegionVid) -> bool {
pub(crate) fn upper_bound_in_region_scc(&self, r: RegionVid, upper: RegionVid) -> bool {
let r_scc = self.constraint_sccs.scc(r);
self.scc_values.contains(r_scc, upper)
}
crate fn universal_regions(&self) -> &UniversalRegions<'tcx> {
pub(crate) fn universal_regions(&self) -> &UniversalRegions<'tcx> {
self.universal_regions.as_ref()
}
@ -1959,7 +1959,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
/// creating a constraint path that forces `R` to outlive
/// `from_region`, and then finding the best choices within that
/// path to blame.
crate fn best_blame_constraint(
pub(crate) fn best_blame_constraint(
&self,
body: &Body<'tcx>,
from_region: RegionVid,
@ -2171,7 +2171,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
categorized_path.remove(0)
}
crate fn universe_info(&self, universe: ty::UniverseIndex) -> UniverseInfo<'tcx> {
pub(crate) fn universe_info(&self, universe: ty::UniverseIndex) -> UniverseInfo<'tcx> {
self.universe_causes[&universe].clone()
}
}

2
compiler/rustc_borrowck/src/region_infer/reverse_sccs.rs
View file

@ -8,7 +8,7 @@ use rustc_middle::ty::RegionVid;
use std::ops::Range;
use std::rc::Rc;
crate struct ReverseSccGraph {
pub(crate) struct ReverseSccGraph {
graph: VecGraph<ConstraintSccIndex>,
/// For each SCC, the range of `universal_regions` that use that SCC as
/// their value.

82
compiler/rustc_borrowck/src/region_infer/values.rs
View file

@ -10,7 +10,7 @@ use std::fmt::Debug;
use std::rc::Rc;
/// Maps between a `Location` and a `PointIndex` (and vice versa).
crate struct RegionValueElements {
pub(crate) struct RegionValueElements {
/// For each basic block, how many points are contained within?
statements_before_block: IndexVec<BasicBlock, usize>,
@ -22,7 +22,7 @@ crate struct RegionValueElements {
}
impl RegionValueElements {
crate fn new(body: &Body<'_>) -> Self {
pub(crate) fn new(body: &Body<'_>) -> Self {
let mut num_points = 0;
let statements_before_block: IndexVec<BasicBlock, usize> = body
.basic_blocks()
@ -45,30 +45,30 @@ impl RegionValueElements {
}
/// Total number of point indices
crate fn num_points(&self) -> usize {
pub(crate) fn num_points(&self) -> usize {
self.num_points
}
/// Converts a `Location` into a `PointIndex`. O(1).
crate fn point_from_location(&self, location: Location) -> PointIndex {
pub(crate) fn point_from_location(&self, location: Location) -> PointIndex {
let Location { block, statement_index } = location;
let start_index = self.statements_before_block[block];
PointIndex::new(start_index + statement_index)
}
/// Converts a `Location` into a `PointIndex`. O(1).
crate fn entry_point(&self, block: BasicBlock) -> PointIndex {
pub(crate) fn entry_point(&self, block: BasicBlock) -> PointIndex {
let start_index = self.statements_before_block[block];
PointIndex::new(start_index)
}
/// Return the PointIndex for the block start of this index.
crate fn to_block_start(&self, index: PointIndex) -> PointIndex {
pub(crate) fn to_block_start(&self, index: PointIndex) -> PointIndex {
PointIndex::new(self.statements_before_block[self.basic_blocks[index]])
}
/// Converts a `PointIndex` back to a location. O(1).
crate fn to_location(&self, index: PointIndex) -> Location {
pub(crate) fn to_location(&self, index: PointIndex) -> Location {
assert!(index.index() < self.num_points);
let block = self.basic_blocks[index];
let start_index = self.statements_before_block[block];
@ -80,7 +80,7 @@ impl RegionValueElements {
/// out of range (because they round up to the nearest 2^N number
/// of bits). Use this function to filter such points out if you
/// like.
crate fn point_in_range(&self, index: PointIndex) -> bool {
pub(crate) fn point_in_range(&self, index: PointIndex) -> bool {
index.index() < self.num_points
}
}
@ -99,7 +99,7 @@ rustc_index::newtype_index! {
/// An individual element in a region value -- the value of a
/// particular region variable consists of a set of these elements.
#[derive(Debug, Clone)]
crate enum RegionElement {
pub(crate) enum RegionElement {
/// A point in the control-flow graph.
Location(Location),
@ -114,7 +114,7 @@ crate enum RegionElement {
/// When we initially compute liveness, we use an interval matrix storing
/// liveness ranges for each region-vid.
crate struct LivenessValues<N: Idx> {
pub(crate) struct LivenessValues<N: Idx> {
elements: Rc<RegionValueElements>,
points: SparseIntervalMatrix<N, PointIndex>,
}
@ -123,18 +123,18 @@ impl<N: Idx> LivenessValues<N> {
/// Creates a new set of "region values" that tracks causal information.
/// Each of the regions in num_region_variables will be initialized with an
/// empty set of points and no causal information.
crate fn new(elements: Rc<RegionValueElements>) -> Self {
pub(crate) fn new(elements: Rc<RegionValueElements>) -> Self {
Self { points: SparseIntervalMatrix::new(elements.num_points), elements }
}
/// Iterate through each region that has a value in this set.
crate fn rows(&self) -> impl Iterator<Item = N> {
pub(crate) fn rows(&self) -> impl Iterator<Item = N> {
self.points.rows()
}
/// Adds the given element to the value for the given region. Returns whether
/// the element is newly added (i.e., was not already present).
crate fn add_element(&mut self, row: N, location: Location) -> bool {
pub(crate) fn add_element(&mut self, row: N, location: Location) -> bool {
debug!("LivenessValues::add(r={:?}, location={:?})", row, location);
let index = self.elements.point_from_location(location);
self.points.insert(row, index)
@ -142,24 +142,24 @@ impl<N: Idx> LivenessValues<N> {
/// Adds all the elements in the given bit array into the given
/// region. Returns whether any of them are newly added.
crate fn add_elements(&mut self, row: N, locations: &IntervalSet<PointIndex>) -> bool {
pub(crate) fn add_elements(&mut self, row: N, locations: &IntervalSet<PointIndex>) -> bool {
debug!("LivenessValues::add_elements(row={:?}, locations={:?})", row, locations);
self.points.union_row(row, locations)
}
/// Adds all the control-flow points to the values for `r`.
crate fn add_all_points(&mut self, row: N) {
pub(crate) fn add_all_points(&mut self, row: N) {
self.points.insert_all_into_row(row);
}
/// Returns `true` if the region `r` contains the given element.
crate fn contains(&self, row: N, location: Location) -> bool {
pub(crate) fn contains(&self, row: N, location: Location) -> bool {
let index = self.elements.point_from_location(location);
self.points.row(row).map_or(false, |r| r.contains(index))
}
/// Returns an iterator of all the elements contained by the region `r`
crate fn get_elements(&self, row: N) -> impl Iterator<Item = Location> + '_ {
pub(crate) fn get_elements(&self, row: N) -> impl Iterator<Item = Location> + '_ {
self.points
.row(row)
.into_iter()
@ -169,7 +169,7 @@ impl<N: Idx> LivenessValues<N> {
}
/// Returns a "pretty" string value of the region. Meant for debugging.
crate fn region_value_str(&self, r: N) -> String {
pub(crate) fn region_value_str(&self, r: N) -> String {
region_value_str(self.get_elements(r).map(RegionElement::Location))
}
}
@ -178,25 +178,28 @@ impl<N: Idx> LivenessValues<N> {
/// rustc to the internal `PlaceholderIndex` values that are used in
/// NLL.
#[derive(Default)]
crate struct PlaceholderIndices {
pub(crate) struct PlaceholderIndices {
indices: FxIndexSet<ty::PlaceholderRegion>,
}
impl PlaceholderIndices {
crate fn insert(&mut self, placeholder: ty::PlaceholderRegion) -> PlaceholderIndex {
pub(crate) fn insert(&mut self, placeholder: ty::PlaceholderRegion) -> PlaceholderIndex {
let (index, _) = self.indices.insert_full(placeholder);
index.into()
}
crate fn lookup_index(&self, placeholder: ty::PlaceholderRegion) -> PlaceholderIndex {
pub(crate) fn lookup_index(&self, placeholder: ty::PlaceholderRegion) -> PlaceholderIndex {
self.indices.get_index_of(&placeholder).unwrap().into()
}
crate fn lookup_placeholder(&self, placeholder: PlaceholderIndex) -> ty::PlaceholderRegion {
pub(crate) fn lookup_placeholder(
&self,
placeholder: PlaceholderIndex,
) -> ty::PlaceholderRegion {
self.indices[placeholder.index()]
}
crate fn len(&self) -> usize {
pub(crate) fn len(&self) -> usize {
self.indices.len()
}
}
@ -220,7 +223,7 @@ impl PlaceholderIndices {
/// because (since it is returned) it must live for at least `'a`. But
/// it would also contain various points from within the function.
#[derive(Clone)]
crate struct RegionValues<N: Idx> {
pub(crate) struct RegionValues<N: Idx> {
elements: Rc<RegionValueElements>,
placeholder_indices: Rc<PlaceholderIndices>,
points: SparseIntervalMatrix<N, PointIndex>,
@ -235,7 +238,7 @@ impl<N: Idx> RegionValues<N> {
/// Creates a new set of "region values" that tracks causal information.
/// Each of the regions in num_region_variables will be initialized with an
/// empty set of points and no causal information.
crate fn new(
pub(crate) fn new(
elements: &Rc<RegionValueElements>,
num_universal_regions: usize,
placeholder_indices: &Rc<PlaceholderIndices>,
@ -252,33 +255,33 @@ impl<N: Idx> RegionValues<N> {
/// Adds the given element to the value for the given region. Returns whether
/// the element is newly added (i.e., was not already present).
crate fn add_element(&mut self, r: N, elem: impl ToElementIndex) -> bool {
pub(crate) fn add_element(&mut self, r: N, elem: impl ToElementIndex) -> bool {
debug!("add(r={:?}, elem={:?})", r, elem);
elem.add_to_row(self, r)
}
/// Adds all the control-flow points to the values for `r`.
crate fn add_all_points(&mut self, r: N) {
pub(crate) fn add_all_points(&mut self, r: N) {
self.points.insert_all_into_row(r);
}
/// Adds all elements in `r_from` to `r_to` (because e.g., `r_to:
/// r_from`).
crate fn add_region(&mut self, r_to: N, r_from: N) -> bool {
pub(crate) fn add_region(&mut self, r_to: N, r_from: N) -> bool {
self.points.union_rows(r_from, r_to)
| self.free_regions.union_rows(r_from, r_to)
| self.placeholders.union_rows(r_from, r_to)
}
/// Returns `true` if the region `r` contains the given element.
crate fn contains(&self, r: N, elem: impl ToElementIndex) -> bool {
pub(crate) fn contains(&self, r: N, elem: impl ToElementIndex) -> bool {
elem.contained_in_row(self, r)
}
/// `self[to] |= values[from]`, essentially: that is, take all the
/// elements for the region `from` from `values` and add them to
/// the region `to` in `self`.
crate fn merge_liveness<M: Idx>(&mut self, to: N, from: M, values: &LivenessValues<M>) {
pub(crate) fn merge_liveness<M: Idx>(&mut self, to: N, from: M, values: &LivenessValues<M>) {
if let Some(set) = values.points.row(from) {
self.points.union_row(to, set);
}
@ -286,7 +289,7 @@ impl<N: Idx> RegionValues<N> {
/// Returns `true` if `sup_region` contains all the CFG points that
/// `sub_region` contains. Ignores universal regions.
crate fn contains_points(&self, sup_region: N, sub_region: N) -> bool {
pub(crate) fn contains_points(&self, sup_region: N, sub_region: N) -> bool {
if let Some(sub_row) = self.points.row(sub_region) {
if let Some(sup_row) = self.points.row(sup_region) {
sup_row.superset(sub_row)
@ -301,7 +304,7 @@ impl<N: Idx> RegionValues<N> {
}
/// Returns the locations contained within a given region `r`.
crate fn locations_outlived_by<'a>(&'a self, r: N) -> impl Iterator<Item = Location> + 'a {
pub(crate) fn locations_outlived_by<'a>(&'a self, r: N) -> impl Iterator<Item = Location> + 'a {
self.points.row(r).into_iter().flat_map(move |set| {
set.iter()
.take_while(move |&p| self.elements.point_in_range(p))
@ -310,7 +313,7 @@ impl<N: Idx> RegionValues<N> {
}
/// Returns just the universal regions that are contained in a given region's value.
crate fn universal_regions_outlived_by<'a>(
pub(crate) fn universal_regions_outlived_by<'a>(
&'a self,
r: N,
) -> impl Iterator<Item = RegionVid> + 'a {
@ -318,7 +321,7 @@ impl<N: Idx> RegionValues<N> {
}
/// Returns all the elements contained in a given region's value.
crate fn placeholders_contained_in<'a>(
pub(crate) fn placeholders_contained_in<'a>(
&'a self,
r: N,
) -> impl Iterator<Item = ty::PlaceholderRegion> + 'a {
@ -330,7 +333,10 @@ impl<N: Idx> RegionValues<N> {
}
/// Returns all the elements contained in a given region's value.
crate fn elements_contained_in<'a>(&'a self, r: N) -> impl Iterator<Item = RegionElement> + 'a {
pub(crate) fn elements_contained_in<'a>(
&'a self,
r: N,
) -> impl Iterator<Item = RegionElement> + 'a {
let points_iter = self.locations_outlived_by(r).map(RegionElement::Location);
let free_regions_iter =
@ -343,12 +349,12 @@ impl<N: Idx> RegionValues<N> {
}
/// Returns a "pretty" string value of the region. Meant for debugging.
crate fn region_value_str(&self, r: N) -> String {
pub(crate) fn region_value_str(&self, r: N) -> String {
region_value_str(self.elements_contained_in(r))
}
}
crate trait ToElementIndex: Debug + Copy {
pub(crate) trait ToElementIndex: Debug + Copy {
fn add_to_row<N: Idx>(self, values: &mut RegionValues<N>, row: N) -> bool;
fn contained_in_row<N: Idx>(self, values: &RegionValues<N>, row: N) -> bool;
@ -388,7 +394,7 @@ impl ToElementIndex for ty::PlaceholderRegion {
}
}
crate fn location_set_str(
pub(crate) fn location_set_str(
elements: &RegionValueElements,
points: impl IntoIterator<Item = PointIndex>,
) -> String {

4
compiler/rustc_borrowck/src/type_check/constraint_conversion.rs
View file

@ -18,7 +18,7 @@ use crate::{
universal_regions::UniversalRegions,
};
crate struct ConstraintConversion<'a, 'tcx> {
pub(crate) struct ConstraintConversion<'a, 'tcx> {
infcx: &'a InferCtxt<'a, 'tcx>,
tcx: TyCtxt<'tcx>,
universal_regions: &'a UniversalRegions<'tcx>,
@ -32,7 +32,7 @@ crate struct ConstraintConversion<'a, 'tcx> {
}
impl<'a, 'tcx> ConstraintConversion<'a, 'tcx> {
crate fn new(
pub(crate) fn new(
infcx: &'a InferCtxt<'a, 'tcx>,
universal_regions: &'a UniversalRegions<'tcx>,
region_bound_pairs: &'a RegionBoundPairs<'tcx>,

28
compiler/rustc_borrowck/src/type_check/free_region_relations.rs
View file

@ -19,7 +19,7 @@ use crate::{
};
#[derive(Debug)]
crate struct UniversalRegionRelations<'tcx> {
pub(crate) struct UniversalRegionRelations<'tcx> {
universal_regions: Rc<UniversalRegions<'tcx>>,
/// Stores the outlives relations that are known to hold from the
@ -52,13 +52,13 @@ type RegionBoundPairs<'tcx> = Vec<(ty::Region<'tcx>, GenericKind<'tcx>)>;
/// then the output type as the last element.
type NormalizedInputsAndOutput<'tcx> = Vec<Ty<'tcx>>;
crate struct CreateResult<'tcx> {
crate universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,
crate region_bound_pairs: RegionBoundPairs<'tcx>,
crate normalized_inputs_and_output: NormalizedInputsAndOutput<'tcx>,
pub(crate) struct CreateResult<'tcx> {
pub(crate) universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,
pub(crate) region_bound_pairs: RegionBoundPairs<'tcx>,
pub(crate) normalized_inputs_and_output: NormalizedInputsAndOutput<'tcx>,
}
crate fn create<'tcx>(
pub(crate) fn create<'tcx>(
infcx: &InferCtxt<'_, 'tcx>,
param_env: ty::ParamEnv<'tcx>,
implicit_region_bound: Option<ty::Region<'tcx>>,
@ -96,7 +96,7 @@ impl UniversalRegionRelations<'_> {
///
/// (See `TransitiveRelation::postdom_upper_bound` for details on
/// the postdominating upper bound in general.)
crate fn postdom_upper_bound(&self, fr1: RegionVid, fr2: RegionVid) -> RegionVid {
pub(crate) fn postdom_upper_bound(&self, fr1: RegionVid, fr2: RegionVid) -> RegionVid {
assert!(self.universal_regions.is_universal_region(fr1));
assert!(self.universal_regions.is_universal_region(fr2));
self.inverse_outlives
@ -109,7 +109,7 @@ impl UniversalRegionRelations<'_> {
/// outlives `fr` and (b) is not local.
///
/// (*) If there are multiple competing choices, we return all of them.
crate fn non_local_upper_bounds<'a>(&'a self, fr: RegionVid) -> Vec<RegionVid> {
pub(crate) fn non_local_upper_bounds<'a>(&'a self, fr: RegionVid) -> Vec<RegionVid> {
debug!("non_local_upper_bound(fr={:?})", fr);
let res = self.non_local_bounds(&self.inverse_outlives, fr);
assert!(!res.is_empty(), "can't find an upper bound!?");
@ -118,7 +118,7 @@ impl UniversalRegionRelations<'_> {
/// Returns the "postdominating" bound of the set of
/// `non_local_upper_bounds` for the given region.
crate fn non_local_upper_bound(&self, fr: RegionVid) -> RegionVid {
pub(crate) fn non_local_upper_bound(&self, fr: RegionVid) -> RegionVid {
let upper_bounds = self.non_local_upper_bounds(fr);
// In case we find more than one, reduce to one for
@ -147,7 +147,7 @@ impl UniversalRegionRelations<'_> {
///
/// (*) If there are multiple competing choices, we pick the "postdominating"
/// one. See `TransitiveRelation::postdom_upper_bound` for details.
crate fn non_local_lower_bound(&self, fr: RegionVid) -> Option<RegionVid> {
pub(crate) fn non_local_lower_bound(&self, fr: RegionVid) -> Option<RegionVid> {
debug!("non_local_lower_bound(fr={:?})", fr);
let lower_bounds = self.non_local_bounds(&self.outlives, fr);
@ -203,18 +203,18 @@ impl UniversalRegionRelations<'_> {
/// Returns `true` if fr1 is known to outlive fr2.
///
/// This will only ever be true for universally quantified regions.
crate fn outlives(&self, fr1: RegionVid, fr2: RegionVid) -> bool {
pub(crate) fn outlives(&self, fr1: RegionVid, fr2: RegionVid) -> bool {
self.outlives.contains(fr1, fr2)
}
/// Returns a vector of free regions `x` such that `fr1: x` is
/// known to hold.
crate fn regions_outlived_by(&self, fr1: RegionVid) -> Vec<RegionVid> {
pub(crate) fn regions_outlived_by(&self, fr1: RegionVid) -> Vec<RegionVid> {
self.outlives.reachable_from(fr1)
}
/// Returns the _non-transitive_ set of known `outlives` constraints between free regions.
crate fn known_outlives(&self) -> impl Iterator<Item = (RegionVid, RegionVid)> + '_ {
pub(crate) fn known_outlives(&self) -> impl Iterator<Item = (RegionVid, RegionVid)> + '_ {
self.outlives.base_edges()
}
}
@ -232,7 +232,7 @@ struct UniversalRegionRelationsBuilder<'this, 'tcx> {
}
impl<'tcx> UniversalRegionRelationsBuilder<'_, 'tcx> {
crate fn create(mut self) -> CreateResult<'tcx> {
pub(crate) fn create(mut self) -> CreateResult<'tcx> {
let unnormalized_input_output_tys = self
.universal_regions
.unnormalized_input_tys

14
compiler/rustc_borrowck/src/type_check/liveness/local_use_map.rs
View file

@ -18,7 +18,7 @@ use crate::region_infer::values::{PointIndex, RegionValueElements};
/// (and code simplicity) was favored. The rationale is that we only keep
/// a small number of `IndexVec`s throughout the entire analysis while, in
/// contrast, we're accessing each `Local` *many* times.
crate struct LocalUseMap {
pub(crate) struct LocalUseMap {
/// Head of a linked list of **definitions** of each variable --
/// definition in this context means assignment, e.g., `x` is
/// defined in `x = y` but not `y`; that first def is the head of
@ -58,7 +58,11 @@ impl vll::LinkElem for Appearance {
}
impl LocalUseMap {
crate fn build(live_locals: &[Local], elements: &RegionValueElements, body: &Body<'_>) -> Self {
pub(crate) fn build(
live_locals: &[Local],
elements: &RegionValueElements,
body: &Body<'_>,
) -> Self {
let nones = IndexVec::from_elem_n(None, body.local_decls.len());
let mut local_use_map = LocalUseMap {
first_def_at: nones.clone(),
@ -81,17 +85,17 @@ impl LocalUseMap {
local_use_map
}
crate fn defs(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ {
pub(crate) fn defs(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ {
vll::iter(self.first_def_at[local], &self.appearances)
.map(move |aa| self.appearances[aa].point_index)
}
crate fn uses(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ {
pub(crate) fn uses(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ {
vll::iter(self.first_use_at[local], &self.appearances)
.map(move |aa| self.appearances[aa].point_index)
}
crate fn drops(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ {
pub(crate) fn drops(&self, local: Local) -> impl Iterator<Item = PointIndex> + '_ {
vll::iter(self.first_drop_at[local], &self.appearances)
.map(move |aa| self.appearances[aa].point_index)
}

29
compiler/rustc_borrowck/src/type_check/mod.rs
View file

@ -94,7 +94,7 @@ mod canonical;
mod constraint_conversion;
pub mod free_region_relations;
mod input_output;
crate mod liveness;
pub(crate) mod liveness;
mod relate_tys;
/// Type checks the given `mir` in the context of the inference
@ -897,28 +897,29 @@ struct BorrowCheckContext<'a, 'tcx> {
upvars: &'a [Upvar<'tcx>],
}
crate struct MirTypeckResults<'tcx> {
crate constraints: MirTypeckRegionConstraints<'tcx>,
crate universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,
crate opaque_type_values: VecMap<OpaqueTypeKey<'tcx>, (OpaqueHiddenType<'tcx>, OpaqueTyOrigin)>,
pub(crate) struct MirTypeckResults<'tcx> {
pub(crate) constraints: MirTypeckRegionConstraints<'tcx>,
pub(crate) universal_region_relations: Frozen<UniversalRegionRelations<'tcx>>,
pub(crate) opaque_type_values:
VecMap<OpaqueTypeKey<'tcx>, (OpaqueHiddenType<'tcx>, OpaqueTyOrigin)>,
}
/// A collection of region constraints that must be satisfied for the
/// program to be considered well-typed.
crate struct MirTypeckRegionConstraints<'tcx> {
pub(crate) struct MirTypeckRegionConstraints<'tcx> {
/// Maps from a `ty::Placeholder` to the corresponding
/// `PlaceholderIndex` bit that we will use for it.
///
/// To keep everything in sync, do not insert this set
/// directly. Instead, use the `placeholder_region` helper.
crate placeholder_indices: PlaceholderIndices,
pub(crate) placeholder_indices: PlaceholderIndices,
/// Each time we add a placeholder to `placeholder_indices`, we
/// also create a corresponding "representative" region vid for
/// that wraps it. This vector tracks those. This way, when we
/// convert the same `ty::RePlaceholder(p)` twice, we can map to
/// the same underlying `RegionVid`.
crate placeholder_index_to_region: IndexVec<PlaceholderIndex, ty::Region<'tcx>>,
pub(crate) placeholder_index_to_region: IndexVec<PlaceholderIndex, ty::Region<'tcx>>,
/// In general, the type-checker is not responsible for enforcing
/// liveness constraints; this job falls to the region inferencer,
@ -927,18 +928,18 @@ crate struct MirTypeckRegionConstraints<'tcx> {
/// not otherwise appear in the MIR -- in particular, the
/// late-bound regions that it instantiates at call-sites -- and
/// hence it must report on their liveness constraints.
crate liveness_constraints: LivenessValues<RegionVid>,
pub(crate) liveness_constraints: LivenessValues<RegionVid>,
crate outlives_constraints: OutlivesConstraintSet<'tcx>,
pub(crate) outlives_constraints: OutlivesConstraintSet<'tcx>,
crate member_constraints: MemberConstraintSet<'tcx, RegionVid>,
pub(crate) member_constraints: MemberConstraintSet<'tcx, RegionVid>,
crate closure_bounds_mapping:
pub(crate) closure_bounds_mapping:
FxHashMap<Location, FxHashMap<(RegionVid, RegionVid), (ConstraintCategory, Span)>>,
crate universe_causes: FxHashMap<ty::UniverseIndex, UniverseInfo<'tcx>>,
pub(crate) universe_causes: FxHashMap<ty::UniverseIndex, UniverseInfo<'tcx>>,
crate type_tests: Vec<TypeTest<'tcx>>,
pub(crate) type_tests: Vec<TypeTest<'tcx>>,
}
impl<'tcx> MirTypeckRegionConstraints<'tcx> {

2
compiler/rustc_borrowck/src/universal_regions.rs
View file

@ -336,7 +336,7 @@ impl<'tcx> UniversalRegions<'tcx> {
/// that this region imposes on others. The methods in this file
/// handle the part about dumping the inference context internal
/// state.
crate fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diagnostic) {
pub(crate) fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diagnostic) {
match self.defining_ty {
DefiningTy::Closure(def_id, substs) => {
err.note(&format!(

2
compiler/rustc_borrowck/src/used_muts.rs
View file

@ -22,7 +22,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
/// been assigned to - this set is used as a proxy for locals that were not initialized due to
/// unreachable code. These locals are then considered "used" to silence the lint for them.
/// See #55344 for context.
crate fn gather_used_muts(
pub(crate) fn gather_used_muts(
&mut self,
temporary_used_locals: FxHashSet<Local>,
mut never_initialized_mut_locals: FxHashSet<Local>,

2
compiler/rustc_builtin_macros/src/cfg_accessible.rs
View file

@ -7,7 +7,7 @@ use rustc_parse::validate_attr;
use rustc_span::symbol::sym;
use rustc_span::Span;
crate struct Expander;
pub(crate) struct Expander;
fn validate_input<'a>(ecx: &mut ExtCtxt<'_>, mi: &'a ast::MetaItem) -> Option<&'a ast::Path> {
match mi.meta_item_list() {

4
compiler/rustc_builtin_macros/src/cfg_eval.rs
View file

@ -19,7 +19,7 @@ use rustc_span::symbol::sym;
use rustc_span::Span;
use smallvec::SmallVec;
crate fn expand(
pub(crate) fn expand(
ecx: &mut ExtCtxt<'_>,
_span: Span,
meta_item: &ast::MetaItem,
@ -30,7 +30,7 @@ crate fn expand(
vec![cfg_eval(ecx.sess, ecx.ecfg.features, annotatable, ecx.current_expansion.lint_node_id)]
}
crate fn cfg_eval(
pub(crate) fn cfg_eval(
sess: &Session,
features: Option<&Features>,
annotatable: Annotatable,

2
compiler/rustc_builtin_macros/src/derive.rs
View file

@ -10,7 +10,7 @@ use rustc_session::Session;
use rustc_span::symbol::{sym, Ident};
use rustc_span::Span;
crate struct Expander;
pub(crate) struct Expander;
impl MultiItemModifier for Expander {
fn expand(

4
compiler/rustc_builtin_macros/src/deriving/mod.rs
View file

@ -38,8 +38,8 @@ pub mod partial_ord;
pub mod generic;
crate struct BuiltinDerive(
crate fn(&mut ExtCtxt<'_>, Span, &MetaItem, &Annotatable, &mut dyn FnMut(Annotatable)),
pub(crate) struct BuiltinDerive(
pub(crate) fn(&mut ExtCtxt<'_>, Span, &MetaItem, &Annotatable, &mut dyn FnMut(Annotatable)),
);
impl MultiItemModifier for BuiltinDerive {

1
compiler/rustc_builtin_macros/src/lib.rs
View file

@ -4,7 +4,6 @@
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![feature(array_windows)]
#![feature(box_patterns)]
#![feature(crate_visibility_modifier)]
#![feature(decl_macro)]
#![feature(is_sorted)]
#![feature(nll)]

6
compiler/rustc_codegen_llvm/src/back/lto.rs
View file

@ -354,14 +354,14 @@ fn fat_lto(
Ok(LtoModuleCodegen::Fat { module, _serialized_bitcode: serialized_bitcode })
}
crate struct Linker<'a>(&'a mut llvm::Linker<'a>);
pub(crate) struct Linker<'a>(&'a mut llvm::Linker<'a>);
impl<'a> Linker<'a> {
crate fn new(llmod: &'a llvm::Module) -> Self {
pub(crate) fn new(llmod: &'a llvm::Module) -> Self {
unsafe { Linker(llvm::LLVMRustLinkerNew(llmod)) }
}
crate fn add(&mut self, bytecode: &[u8]) -> Result<(), ()> {
pub(crate) fn add(&mut self, bytecode: &[u8]) -> Result<(), ()> {
unsafe {
if llvm::LLVMRustLinkerAdd(
self.0,

2
compiler/rustc_codegen_llvm/src/builder.rs
View file

@ -1412,7 +1412,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
unsafe { llvm::LLVMBuildVAArg(self.llbuilder, list, ty, UNNAMED) }
}
crate fn call_intrinsic(&mut self, intrinsic: &str, args: &[&'ll Value]) -> &'ll Value {
pub(crate) fn call_intrinsic(&mut self, intrinsic: &str, args: &[&'ll Value]) -> &'ll Value {
let (ty, f) = self.cx.get_intrinsic(intrinsic);
self.call(ty, f, args, None)
}

6
compiler/rustc_codegen_llvm/src/consts.rs
View file

@ -212,11 +212,11 @@ pub fn ptrcast<'ll>(val: &'ll Value, ty: &'ll Type) -> &'ll Value {
}
impl<'ll> CodegenCx<'ll, '_> {
crate fn const_bitcast(&self, val: &'ll Value, ty: &'ll Type) -> &'ll Value {
pub(crate) fn const_bitcast(&self, val: &'ll Value, ty: &'ll Type) -> &'ll Value {
unsafe { llvm::LLVMConstBitCast(val, ty) }
}
crate fn static_addr_of_mut(
pub(crate) fn static_addr_of_mut(
&self,
cv: &'ll Value,
align: Align,
@ -241,7 +241,7 @@ impl<'ll> CodegenCx<'ll, '_> {
}
}
crate fn get_static(&self, def_id: DefId) -> &'ll Value {
pub(crate) fn get_static(&self, def_id: DefId) -> &'ll Value {
let instance = Instance::mono(self.tcx, def_id);
if let Some(&g) = self.instances.borrow().get(&instance) {
return g;

8
compiler/rustc_codegen_llvm/src/context.rs
View file

@ -330,7 +330,7 @@ pub unsafe fn create_module<'ll>(
}
impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
crate fn new(
pub(crate) fn new(
tcx: TyCtxt<'tcx>,
codegen_unit: &'tcx CodegenUnit<'tcx>,
llvm_module: &'ll crate::ModuleLlvm,
@ -447,7 +447,7 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
}
}
crate fn statics_to_rauw(&self) -> &RefCell<Vec<(&'ll Value, &'ll Value)>> {
pub(crate) fn statics_to_rauw(&self) -> &RefCell<Vec<(&'ll Value, &'ll Value)>> {
&self.statics_to_rauw
}
@ -599,7 +599,7 @@ impl<'ll, 'tcx> MiscMethods<'tcx> for CodegenCx<'ll, 'tcx> {
}
impl<'ll> CodegenCx<'ll, '_> {
crate fn get_intrinsic(&self, key: &str) -> (&'ll Type, &'ll Value) {
pub(crate) fn get_intrinsic(&self, key: &str) -> (&'ll Type, &'ll Value) {
if let Some(v) = self.intrinsics.borrow().get(key).cloned() {
return v;
}
@ -890,7 +890,7 @@ impl<'ll> CodegenCx<'ll, '_> {
None
}
crate fn eh_catch_typeinfo(&self) -> &'ll Value {
pub(crate) fn eh_catch_typeinfo(&self) -> &'ll Value {
if let Some(eh_catch_typeinfo) = self.eh_catch_typeinfo.get() {
return eh_catch_typeinfo;
}

1
compiler/rustc_codegen_llvm/src/lib.rs
View file

@ -5,7 +5,6 @@
//! This API is completely unstable and subject to change.
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![feature(crate_visibility_modifier)]
#![feature(let_chains)]
#![feature(let_else)]
#![feature(extern_types)]

10
compiler/rustc_codegen_llvm/src/llvm/ffi.rs
View file

@ -775,7 +775,7 @@ pub mod coverageinfo {
}
impl CounterMappingRegion {
crate fn code_region(
pub(crate) fn code_region(
counter: coverage_map::Counter,
file_id: u32,
start_line: u32,
@ -799,7 +799,7 @@ pub mod coverageinfo {
// This function might be used in the future; the LLVM API is still evolving, as is coverage
// support.
#[allow(dead_code)]
crate fn branch_region(
pub(crate) fn branch_region(
counter: coverage_map::Counter,
false_counter: coverage_map::Counter,
file_id: u32,
@ -824,7 +824,7 @@ pub mod coverageinfo {
// This function might be used in the future; the LLVM API is still evolving, as is coverage
// support.
#[allow(dead_code)]
crate fn expansion_region(
pub(crate) fn expansion_region(
file_id: u32,
expanded_file_id: u32,
start_line: u32,
@ -848,7 +848,7 @@ pub mod coverageinfo {
// This function might be used in the future; the LLVM API is still evolving, as is coverage
// support.
#[allow(dead_code)]
crate fn skipped_region(
pub(crate) fn skipped_region(
file_id: u32,
start_line: u32,
start_col: u32,
@ -871,7 +871,7 @@ pub mod coverageinfo {
// This function might be used in the future; the LLVM API is still evolving, as is coverage
// support.
#[allow(dead_code)]
crate fn gap_region(
pub(crate) fn gap_region(
counter: coverage_map::Counter,
file_id: u32,
start_line: u32,

30
compiler/rustc_codegen_llvm/src/type_.rs
View file

@ -39,33 +39,33 @@ impl fmt::Debug for Type {
}
impl<'ll> CodegenCx<'ll, '_> {
crate fn type_named_struct(&self, name: &str) -> &'ll Type {
pub(crate) fn type_named_struct(&self, name: &str) -> &'ll Type {
let name = SmallCStr::new(name);
unsafe { llvm::LLVMStructCreateNamed(self.llcx, name.as_ptr()) }
}
crate fn set_struct_body(&self, ty: &'ll Type, els: &[&'ll Type], packed: bool) {
pub(crate) fn set_struct_body(&self, ty: &'ll Type, els: &[&'ll Type], packed: bool) {
unsafe { llvm::LLVMStructSetBody(ty, els.as_ptr(), els.len() as c_uint, packed as Bool) }
}
crate fn type_void(&self) -> &'ll Type {
pub(crate) fn type_void(&self) -> &'ll Type {
unsafe { llvm::LLVMVoidTypeInContext(self.llcx) }
}
crate fn type_metadata(&self) -> &'ll Type {
pub(crate) fn type_metadata(&self) -> &'ll Type {
unsafe { llvm::LLVMRustMetadataTypeInContext(self.llcx) }
}
///x Creates an integer type with the given number of bits, e.g., i24
crate fn type_ix(&self, num_bits: u64) -> &'ll Type {
pub(crate) fn type_ix(&self, num_bits: u64) -> &'ll Type {
unsafe { llvm::LLVMIntTypeInContext(self.llcx, num_bits as c_uint) }
}
crate fn type_vector(&self, ty: &'ll Type, len: u64) -> &'ll Type {
pub(crate) fn type_vector(&self, ty: &'ll Type, len: u64) -> &'ll Type {
unsafe { llvm::LLVMVectorType(ty, len as c_uint) }
}
crate fn func_params_types(&self, ty: &'ll Type) -> Vec<&'ll Type> {
pub(crate) fn func_params_types(&self, ty: &'ll Type) -> Vec<&'ll Type> {
unsafe {
let n_args = llvm::LLVMCountParamTypes(ty) as usize;
let mut args = Vec::with_capacity(n_args);
@ -75,11 +75,11 @@ impl<'ll> CodegenCx<'ll, '_> {
}
}
crate fn type_bool(&self) -> &'ll Type {
pub(crate) fn type_bool(&self) -> &'ll Type {
self.type_i8()
}
crate fn type_int_from_ty(&self, t: ty::IntTy) -> &'ll Type {
pub(crate) fn type_int_from_ty(&self, t: ty::IntTy) -> &'ll Type {
match t {
ty::IntTy::Isize => self.type_isize(),
ty::IntTy::I8 => self.type_i8(),
@ -90,7 +90,7 @@ impl<'ll> CodegenCx<'ll, '_> {
}
}
crate fn type_uint_from_ty(&self, t: ty::UintTy) -> &'ll Type {
pub(crate) fn type_uint_from_ty(&self, t: ty::UintTy) -> &'ll Type {
match t {
ty::UintTy::Usize => self.type_isize(),
ty::UintTy::U8 => self.type_i8(),
@ -101,14 +101,14 @@ impl<'ll> CodegenCx<'ll, '_> {
}
}
crate fn type_float_from_ty(&self, t: ty::FloatTy) -> &'ll Type {
pub(crate) fn type_float_from_ty(&self, t: ty::FloatTy) -> &'ll Type {
match t {
ty::FloatTy::F32 => self.type_f32(),
ty::FloatTy::F64 => self.type_f64(),
}
}
crate fn type_pointee_for_align(&self, align: Align) -> &'ll Type {
pub(crate) fn type_pointee_for_align(&self, align: Align) -> &'ll Type {
// FIXME(eddyb) We could find a better approximation if ity.align < align.
let ity = Integer::approximate_align(self, align);
self.type_from_integer(ity)
@ -116,7 +116,7 @@ impl<'ll> CodegenCx<'ll, '_> {
/// Return a LLVM type that has at most the required alignment,
/// and exactly the required size, as a best-effort padding array.
crate fn type_padding_filler(&self, size: Size, align: Align) -> &'ll Type {
pub(crate) fn type_padding_filler(&self, size: Size, align: Align) -> &'ll Type {
let unit = Integer::approximate_align(self, align);
let size = size.bytes();
let unit_size = unit.size().bytes();
@ -124,11 +124,11 @@ impl<'ll> CodegenCx<'ll, '_> {
self.type_array(self.type_from_integer(unit), size / unit_size)
}
crate fn type_variadic_func(&self, args: &[&'ll Type], ret: &'ll Type) -> &'ll Type {
pub(crate) fn type_variadic_func(&self, args: &[&'ll Type], ret: &'ll Type) -> &'ll Type {
unsafe { llvm::LLVMFunctionType(ret, args.as_ptr(), args.len() as c_uint, True) }
}
crate fn type_array(&self, ty: &'ll Type, len: u64) -> &'ll Type {
pub(crate) fn type_array(&self, ty: &'ll Type, len: u64) -> &'ll Type {
unsafe { llvm::LLVMRustArrayType(ty, len) }
}
}

2
compiler/rustc_const_eval/src/const_eval/machine.rs
View file

@ -163,7 +163,7 @@ impl<K: Hash + Eq, V> interpret::AllocMap<K, V> for FxHashMap<K, V> {
}
}
crate type CompileTimeEvalContext<'mir, 'tcx> =
pub(crate) type CompileTimeEvalContext<'mir, 'tcx> =
InterpCx<'mir, 'tcx, CompileTimeInterpreter<'mir, 'tcx>>;
#[derive(Debug, PartialEq, Eq, Copy, Clone)]

2
compiler/rustc_const_eval/src/interpret/intrinsics.rs
View file

@ -44,7 +44,7 @@ fn numeric_intrinsic<Tag>(name: Symbol, bits: u128, kind: Primitive) -> Scalar<T
/// The logic for all nullary intrinsics is implemented here. These intrinsics don't get evaluated
/// inside an `InterpCx` and instead have their value computed directly from rustc internal info.
crate fn eval_nullary_intrinsic<'tcx>(
pub(crate) fn eval_nullary_intrinsic<'tcx>(
tcx: TyCtxt<'tcx>,
param_env: ty::ParamEnv<'tcx>,
def_id: DefId,

6
compiler/rustc_const_eval/src/interpret/intrinsics/caller_location.rs
View file

@ -15,7 +15,7 @@ use crate::interpret::{
impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
/// Walks up the callstack from the intrinsic's callsite, searching for the first callsite in a
/// frame which is not `#[track_caller]`.
crate fn find_closest_untracked_caller_location(&self) -> Span {
pub(crate) fn find_closest_untracked_caller_location(&self) -> Span {
for frame in self.stack().iter().rev() {
debug!("find_closest_untracked_caller_location: checking frame {:?}", frame.instance);
@ -74,7 +74,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
}
/// Allocate a `const core::panic::Location` with the provided filename and line/column numbers.
crate fn alloc_caller_location(
pub(crate) fn alloc_caller_location(
&mut self,
filename: Symbol,
line: u32,
@ -113,7 +113,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
location
}
crate fn location_triple_for_span(&self, span: Span) -> (Symbol, u32, u32) {
pub(crate) fn location_triple_for_span(&self, span: Span) -> (Symbol, u32, u32) {
let topmost = span.ctxt().outer_expn().expansion_cause().unwrap_or(span);
let caller = self.tcx.sess.source_map().lookup_char_pos(topmost.lo());
(

2
compiler/rustc_const_eval/src/interpret/intrinsics/type_name.rs
View file

@ -189,7 +189,7 @@ impl Write for AbsolutePathPrinter<'_> {
}
/// Directly returns an `Allocation` containing an absolute path representation of the given type.
crate fn alloc_type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> ConstAllocation<'tcx> {
pub(crate) fn alloc_type_name<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> ConstAllocation<'tcx> {
let path = AbsolutePathPrinter { tcx, path: String::new() }.print_type(ty).unwrap().path;
let alloc = Allocation::from_bytes_byte_aligned_immutable(path.into_bytes());
tcx.intern_const_alloc(alloc)

2
compiler/rustc_const_eval/src/interpret/mod.rs
View file

@ -29,5 +29,5 @@ pub use self::place::{MPlaceTy, MemPlace, MemPlaceMeta, Place, PlaceTy};
pub use self::validity::{CtfeValidationMode, RefTracking};
pub use self::visitor::{MutValueVisitor, Value, ValueVisitor};
crate use self::intrinsics::eval_nullary_intrinsic;
pub(crate) use self::intrinsics::eval_nullary_intrinsic;
use eval_context::{from_known_layout, mir_assign_valid_types};

2
compiler/rustc_const_eval/src/interpret/operand.rs
View file

@ -643,7 +643,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
}
}
crate fn const_val_to_op(
pub(crate) fn const_val_to_op(
&self,
val_val: ConstValue<'tcx>,
ty: Ty<'tcx>,

2
compiler/rustc_const_eval/src/interpret/util.rs
View file

@ -8,7 +8,7 @@ use std::ops::ControlFlow;
/// In case it does, returns a `TooGeneric` const eval error. Note that due to polymorphization
/// types may be "concrete enough" even though they still contain generic parameters in
/// case these parameters are unused.
crate fn ensure_monomorphic_enough<'tcx, T>(tcx: TyCtxt<'tcx>, ty: T) -> InterpResult<'tcx>
pub(crate) fn ensure_monomorphic_enough<'tcx, T>(tcx: TyCtxt<'tcx>, ty: T) -> InterpResult<'tcx>
where
T: TypeFoldable<'tcx>,
{

1
compiler/rustc_const_eval/src/lib.rs
View file

@ -7,7 +7,6 @@ Rust MIR: a lowered representation of Rust.
#![feature(assert_matches)]
#![feature(box_patterns)]
#![feature(control_flow_enum)]
#![feature(crate_visibility_modifier)]
#![feature(decl_macro)]
#![feature(exact_size_is_empty)]
#![feature(let_else)]

2
compiler/rustc_errors/src/diagnostic.rs
View file

@ -90,7 +90,7 @@ pub trait AddSubdiagnostic {
pub struct Diagnostic {
// NOTE(eddyb) this is private to disallow arbitrary after-the-fact changes,
// outside of what methods in this crate themselves allow.
crate level: Level,
pub(crate) level: Level,
pub message: Vec<(DiagnosticMessage, Style)>,
pub code: Option<DiagnosticId>,

12
compiler/rustc_errors/src/diagnostic_builder.rs
View file

@ -88,7 +88,7 @@ mod sealed_level_is_error {
use crate::Level;
/// Sealed helper trait for statically checking that a `Level` is an error.
crate trait IsError<const L: Level> {}
pub(crate) trait IsError<const L: Level> {}
impl IsError<{ Level::Bug }> for () {}
impl IsError<{ Level::DelayedBug }> for () {}
@ -101,7 +101,7 @@ mod sealed_level_is_error {
impl<'a> DiagnosticBuilder<'a, ErrorGuaranteed> {
/// Convenience function for internal use, clients should use one of the
/// `struct_*` methods on [`Handler`].
crate fn new_guaranteeing_error<M: Into<DiagnosticMessage>, const L: Level>(
pub(crate) fn new_guaranteeing_error<M: Into<DiagnosticMessage>, const L: Level>(
handler: &'a Handler,
message: M,
) -> Self
@ -168,7 +168,7 @@ impl EmissionGuarantee for ErrorGuaranteed {
impl<'a> DiagnosticBuilder<'a, ()> {
/// Convenience function for internal use, clients should use one of the
/// `struct_*` methods on [`Handler`].
crate fn new<M: Into<DiagnosticMessage>>(
pub(crate) fn new<M: Into<DiagnosticMessage>>(
handler: &'a Handler,
level: Level,
message: M,
@ -179,7 +179,7 @@ impl<'a> DiagnosticBuilder<'a, ()> {
/// Creates a new `DiagnosticBuilder` with an already constructed
/// diagnostic.
crate fn new_diagnostic(handler: &'a Handler, diagnostic: Diagnostic) -> Self {
pub(crate) fn new_diagnostic(handler: &'a Handler, diagnostic: Diagnostic) -> Self {
debug!("Created new diagnostic");
Self {
inner: DiagnosticBuilderInner {
@ -210,14 +210,14 @@ impl EmissionGuarantee for () {
impl<'a> DiagnosticBuilder<'a, !> {
/// Convenience function for internal use, clients should use one of the
/// `struct_*` methods on [`Handler`].
crate fn new_fatal(handler: &'a Handler, message: impl Into<DiagnosticMessage>) -> Self {
pub(crate) fn new_fatal(handler: &'a Handler, message: impl Into<DiagnosticMessage>) -> Self {
let diagnostic = Diagnostic::new_with_code(Level::Fatal, None, message);
Self::new_diagnostic_fatal(handler, diagnostic)
}
/// Creates a new `DiagnosticBuilder` with an already constructed
/// diagnostic.
crate fn new_diagnostic_fatal(handler: &'a Handler, diagnostic: Diagnostic) -> Self {
pub(crate) fn new_diagnostic_fatal(handler: &'a Handler, diagnostic: Diagnostic) -> Self {
debug!("Created new diagnostic");
Self {
inner: DiagnosticBuilderInner {

1
compiler/rustc_errors/src/lib.rs
View file

@ -3,7 +3,6 @@
//! This module contains the code for creating and emitting diagnostics.
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![feature(crate_visibility_modifier)]
#![feature(drain_filter)]
#![feature(backtrace)]
#![feature(if_let_guard)]

2
compiler/rustc_expand/src/base.rs
View file

@ -28,7 +28,7 @@ use std::iter;
use std::path::PathBuf;
use std::rc::Rc;
crate use rustc_span::hygiene::MacroKind;
pub(crate) use rustc_span::hygiene::MacroKind;
// When adding new variants, make sure to
// adjust the `visit_*` / `flat_map_*` calls in `InvocationCollector`

6
compiler/rustc_expand/src/config.rs
View file

@ -347,7 +347,7 @@ impl<'a> StripUnconfigured<'a> {
/// Gives a compiler warning when the `cfg_attr` contains no attributes and
/// is in the original source file. Gives a compiler error if the syntax of
/// the attribute is incorrect.
crate fn expand_cfg_attr(&self, attr: Attribute, recursive: bool) -> Vec<Attribute> {
pub(crate) fn expand_cfg_attr(&self, attr: Attribute, recursive: bool) -> Vec<Attribute> {
let Some((cfg_predicate, expanded_attrs)) =
rustc_parse::parse_cfg_attr(&attr, &self.sess.parse_sess) else {
return vec![];
@ -451,7 +451,7 @@ impl<'a> StripUnconfigured<'a> {
attrs.iter().all(|attr| !is_cfg(attr) || self.cfg_true(attr))
}
crate fn cfg_true(&self, attr: &Attribute) -> bool {
pub(crate) fn cfg_true(&self, attr: &Attribute) -> bool {
let meta_item = match validate_attr::parse_meta(&self.sess.parse_sess, attr) {
Ok(meta_item) => meta_item,
Err(mut err) => {
@ -465,7 +465,7 @@ impl<'a> StripUnconfigured<'a> {
}
/// If attributes are not allowed on expressions, emit an error for `attr`
crate fn maybe_emit_expr_attr_err(&self, attr: &Attribute) {
pub(crate) fn maybe_emit_expr_attr_err(&self, attr: &Attribute) {
if !self.features.map_or(true, |features| features.stmt_expr_attributes) {
let mut err = feature_err(
&self.sess.parse_sess,

2
compiler/rustc_expand/src/expand.rs
View file

@ -214,7 +214,7 @@ pub enum SupportsMacroExpansion {
}
impl AstFragmentKind {
crate fn dummy(self, span: Span) -> AstFragment {
pub(crate) fn dummy(self, span: Span) -> AstFragment {
self.make_from(DummyResult::any(span)).expect("couldn't create a dummy AST fragment")
}

5
compiler/rustc_expand/src/lib.rs
View file

@ -1,7 +1,6 @@
#![allow(rustc::potential_query_instability)]
#![feature(associated_type_bounds)]
#![feature(associated_type_defaults)]
#![feature(crate_visibility_modifier)]
#![feature(if_let_guard)]
#![feature(let_chains)]
#![feature(let_else)]
@ -21,7 +20,7 @@ mod placeholders;
mod proc_macro_server;
pub use mbe::macro_rules::compile_declarative_macro;
crate use rustc_span::hygiene;
pub(crate) use rustc_span::hygiene;
pub mod base;
pub mod build;
#[macro_use]
@ -30,7 +29,7 @@ pub mod expand;
pub mod module;
pub mod proc_macro;
crate mod mbe;
pub(crate) mod mbe;
// HACK(Centril, #64197): These shouldn't really be here.
// Rather, they should be with their respective modules which are defined in other crates.

12
compiler/rustc_expand/src/mbe.rs
View file

@ -3,12 +3,12 @@
//! why we call this module `mbe`. For external documentation, prefer the
//! official terminology: "declarative macros".
crate mod macro_check;
crate mod macro_parser;
crate mod macro_rules;
crate mod metavar_expr;
crate mod quoted;
crate mod transcribe;
pub(crate) mod macro_check;
pub(crate) mod macro_parser;
pub(crate) mod macro_rules;
pub(crate) mod metavar_expr;
pub(crate) mod quoted;
pub(crate) mod transcribe;
use metavar_expr::MetaVarExpr;
use rustc_ast::token::{Delimiter, NonterminalKind, Token, TokenKind};

10
compiler/rustc_expand/src/mbe/macro_parser.rs
View file

@ -70,8 +70,8 @@
//! eof: [a $( a )* a b ·]
//! ```
crate use NamedMatch::*;
crate use ParseResult::*;
pub(crate) use NamedMatch::*;
pub(crate) use ParseResult::*;
use crate::mbe::{KleeneOp, TokenTree};
@ -262,7 +262,7 @@ enum EofMatcherPositions {
}
/// Represents the possible results of an attempted parse.
crate enum ParseResult<T> {
pub(crate) enum ParseResult<T> {
/// Parsed successfully.
Success(T),
/// Arm failed to match. If the second parameter is `token::Eof`, it indicates an unexpected
@ -276,7 +276,7 @@ crate enum ParseResult<T> {
/// A `ParseResult` where the `Success` variant contains a mapping of
/// `MacroRulesNormalizedIdent`s to `NamedMatch`es. This represents the mapping
/// of metavars to the token trees they bind to.
crate type NamedParseResult = ParseResult<FxHashMap<MacroRulesNormalizedIdent, NamedMatch>>;
pub(crate) type NamedParseResult = ParseResult<FxHashMap<MacroRulesNormalizedIdent, NamedMatch>>;
/// Count how many metavars declarations are in `matcher`.
pub(super) fn count_metavar_decls(matcher: &[TokenTree]) -> usize {
@ -340,7 +340,7 @@ pub(super) fn count_metavar_decls(matcher: &[TokenTree]) -> usize {
/// ])
/// ```
#[derive(Debug, Clone)]
crate enum NamedMatch {
pub(crate) enum NamedMatch {
MatchedSeq(Vec<NamedMatch>),
// A metavar match of type `tt`.

6
compiler/rustc_expand/src/mbe/macro_rules.rs
View file

@ -33,7 +33,7 @@ use std::collections::hash_map::Entry;
use std::{mem, slice};
use tracing::debug;
crate struct ParserAnyMacro<'a> {
pub(crate) struct ParserAnyMacro<'a> {
parser: Parser<'a>,
/// Span of the expansion site of the macro this parser is for
@ -47,7 +47,7 @@ crate struct ParserAnyMacro<'a> {
is_local: bool,
}
crate fn annotate_err_with_kind(err: &mut Diagnostic, kind: AstFragmentKind, span: Span) {
pub(crate) fn annotate_err_with_kind(err: &mut Diagnostic, kind: AstFragmentKind, span: Span) {
match kind {
AstFragmentKind::Ty => {
err.span_label(span, "this macro call doesn't expand to a type");
@ -113,7 +113,7 @@ fn emit_frag_parse_err(
}
impl<'a> ParserAnyMacro<'a> {
crate fn make(mut self: Box<ParserAnyMacro<'a>>, kind: AstFragmentKind) -> AstFragment {
pub(crate) fn make(mut self: Box<ParserAnyMacro<'a>>, kind: AstFragmentKind) -> AstFragment {
let ParserAnyMacro {
site_span,
macro_ident,

6
compiler/rustc_expand/src/mbe/metavar_expr.rs
View file

@ -9,7 +9,7 @@ use rustc_span::Span;
/// A meta-variable expression, for expansions based on properties of meta-variables.
#[derive(Debug, Clone, PartialEq, Encodable, Decodable)]
crate enum MetaVarExpr {
pub(crate) enum MetaVarExpr {
/// The number of repetitions of an identifier, optionally limited to a number
/// of outer-most repetition depths. If the depth limit is `None` then the depth is unlimited.
Count(Ident, Option<usize>),
@ -28,7 +28,7 @@ crate enum MetaVarExpr {
impl MetaVarExpr {
/// Attempt to parse a meta-variable expression from a token stream.
crate fn parse<'sess>(
pub(crate) fn parse<'sess>(
input: &TokenStream,
outer_span: Span,
sess: &'sess ParseSess,
@ -62,7 +62,7 @@ impl MetaVarExpr {
Ok(rslt)
}
crate fn ident(&self) -> Option<Ident> {
pub(crate) fn ident(&self) -> Option<Ident> {
match *self {
MetaVarExpr::Count(ident, _) | MetaVarExpr::Ignore(ident) => Some(ident),
MetaVarExpr::Index(..) | MetaVarExpr::Length(..) => None,

6
compiler/rustc_expand/src/module.rs
View file

@ -26,7 +26,7 @@ pub struct ModulePathSuccess {
pub dir_ownership: DirOwnership,
}
crate struct ParsedExternalMod {
pub(crate) struct ParsedExternalMod {
pub items: Vec<P<Item>>,
pub spans: ModSpans,
pub file_path: PathBuf,
@ -42,7 +42,7 @@ pub enum ModError<'a> {
ParserError(DiagnosticBuilder<'a, ErrorGuaranteed>),
}
crate fn parse_external_mod(
pub(crate) fn parse_external_mod(
sess: &Session,
ident: Ident,
span: Span, // The span to blame on errors.
@ -78,7 +78,7 @@ crate fn parse_external_mod(
ParsedExternalMod { items, spans, file_path, dir_path, dir_ownership }
}
crate fn mod_dir_path(
pub(crate) fn mod_dir_path(
sess: &Session,
ident: Ident,
attrs: &[Attribute],

10
compiler/rustc_expand/src/tests.rs
View file

@ -22,7 +22,7 @@ fn string_to_parser(ps: &ParseSess, source_str: String) -> Parser<'_> {
new_parser_from_source_str(ps, PathBuf::from("bogofile").into(), source_str)
}
crate fn with_error_checking_parse<'a, T, F>(s: String, ps: &'a ParseSess, f: F) -> T
pub(crate) fn with_error_checking_parse<'a, T, F>(s: String, ps: &'a ParseSess, f: F) -> T
where
F: FnOnce(&mut Parser<'a>) -> PResult<'a, T>,
{
@ -33,7 +33,7 @@ where
}
/// Maps a string to tts, using a made-up filename.
crate fn string_to_stream(source_str: String) -> TokenStream {
pub(crate) fn string_to_stream(source_str: String) -> TokenStream {
let ps = ParseSess::new(FilePathMapping::empty());
source_file_to_stream(
&ps,
@ -44,7 +44,7 @@ crate fn string_to_stream(source_str: String) -> TokenStream {
}
/// Parses a string, returns a crate.
crate fn string_to_crate(source_str: String) -> ast::Crate {
pub(crate) fn string_to_crate(source_str: String) -> ast::Crate {
let ps = ParseSess::new(FilePathMapping::empty());
with_error_checking_parse(source_str, &ps, |p| p.parse_crate_mod())
}
@ -53,7 +53,7 @@ crate fn string_to_crate(source_str: String) -> ast::Crate {
/// may be deleted or replaced with other whitespace to match the pattern.
/// This function is relatively Unicode-ignorant; fortunately, the careful design
/// of UTF-8 mitigates this ignorance. It doesn't do NKF-normalization(?).
crate fn matches_codepattern(a: &str, b: &str) -> bool {
pub(crate) fn matches_codepattern(a: &str, b: &str) -> bool {
let mut a_iter = a.chars().peekable();
let mut b_iter = b.chars().peekable();
@ -109,7 +109,7 @@ struct SpanLabel {
label: &'static str,
}
crate struct Shared<T: Write> {
pub(crate) struct Shared<T: Write> {
pub data: Arc<Mutex<T>>,
}

2
compiler/rustc_hir/src/hir.rs
View file

@ -1,6 +1,6 @@
use crate::def::{CtorKind, DefKind, Res};
use crate::def_id::DefId;
crate use crate::hir_id::{HirId, ItemLocalId};
pub(crate) use crate::hir_id::{HirId, ItemLocalId};
use crate::intravisit::FnKind;
use crate::LangItem;

1
compiler/rustc_hir/src/lib.rs
View file

@ -4,7 +4,6 @@
#![feature(associated_type_defaults)]
#![feature(const_btree_new)]
#![feature(crate_visibility_modifier)]
#![feature(let_else)]
#![feature(once_cell)]
#![feature(min_specialization)]

2
compiler/rustc_lint/src/builtin.rs
View file

@ -2705,7 +2705,7 @@ impl SymbolName {
}
impl ClashingExternDeclarations {
crate fn new() -> Self {
pub(crate) fn new() -> Self {
ClashingExternDeclarations { seen_decls: FxHashMap::default() }
}
/// Insert a new foreign item into the seen set. If a symbol with the same name already exists

2
compiler/rustc_lint/src/late.rs
View file

@ -34,7 +34,7 @@ use tracing::debug;
/// Extract the `LintStore` from the query context.
/// This function exists because we've erased `LintStore` as `dyn Any` in the context.
crate fn unerased_lint_store(tcx: TyCtxt<'_>) -> &LintStore {
pub(crate) fn unerased_lint_store(tcx: TyCtxt<'_>) -> &LintStore {
let store: &dyn Any = &*tcx.lint_store;
store.downcast_ref().unwrap()
}

1
compiler/rustc_lint/src/lib.rs
View file

@ -30,7 +30,6 @@
#![feature(array_windows)]
#![feature(box_patterns)]
#![feature(control_flow_enum)]
#![feature(crate_visibility_modifier)]
#![feature(if_let_guard)]
#![feature(iter_intersperse)]
#![feature(iter_order_by)]

9
compiler/rustc_lint/src/types.rs
View file

@ -651,7 +651,7 @@ declare_lint! {
declare_lint_pass!(ImproperCTypesDefinitions => [IMPROPER_CTYPES_DEFINITIONS]);
#[derive(Clone, Copy)]
crate enum CItemKind {
pub(crate) enum CItemKind {
Declaration,
Definition,
}
@ -667,7 +667,10 @@ enum FfiResult<'tcx> {
FfiUnsafe { ty: Ty<'tcx>, reason: String, help: Option<String> },
}
crate fn nonnull_optimization_guaranteed<'tcx>(tcx: TyCtxt<'tcx>, def: ty::AdtDef<'tcx>) -> bool {
pub(crate) fn nonnull_optimization_guaranteed<'tcx>(
tcx: TyCtxt<'tcx>,
def: ty::AdtDef<'tcx>,
) -> bool {
tcx.has_attr(def.did(), sym::rustc_nonnull_optimization_guaranteed)
}
@ -766,7 +769,7 @@ fn get_nullable_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'t
/// Currently restricted to function pointers, boxes, references, `core::num::NonZero*`,
/// `core::ptr::NonNull`, and `#[repr(transparent)]` newtypes.
/// FIXME: This duplicates code in codegen.
crate fn repr_nullable_ptr<'tcx>(
pub(crate) fn repr_nullable_ptr<'tcx>(
cx: &LateContext<'tcx>,
ty: Ty<'tcx>,
ckind: CItemKind,

16
compiler/rustc_metadata/src/creader.rs
View file

@ -70,7 +70,7 @@ pub enum LoadedMacro {
ProcMacro(SyntaxExtension),
}
crate struct Library {
pub(crate) struct Library {
pub source: CrateSource,
pub metadata: MetadataBlob,
}
@ -82,7 +82,7 @@ enum LoadResult {
/// A reference to `CrateMetadata` that can also give access to whole crate store when necessary.
#[derive(Clone, Copy)]
crate struct CrateMetadataRef<'a> {
pub(crate) struct CrateMetadataRef<'a> {
pub cdata: &'a CrateMetadata,
pub cstore: &'a CStore,
}
@ -133,7 +133,7 @@ impl CStore {
CrateNum::new(self.metas.len() - 1)
}
crate fn get_crate_data(&self, cnum: CrateNum) -> CrateMetadataRef<'_> {
pub(crate) fn get_crate_data(&self, cnum: CrateNum) -> CrateMetadataRef<'_> {
let cdata = self.metas[cnum]
.as_ref()
.unwrap_or_else(|| panic!("Failed to get crate data for {:?}", cnum));
@ -145,7 +145,7 @@ impl CStore {
self.metas[cnum] = Some(Lrc::new(data));
}
crate fn iter_crate_data(&self) -> impl Iterator<Item = (CrateNum, &CrateMetadata)> {
pub(crate) fn iter_crate_data(&self) -> impl Iterator<Item = (CrateNum, &CrateMetadata)> {
self.metas
.iter_enumerated()
.filter_map(|(cnum, data)| data.as_ref().map(|data| (cnum, &**data)))
@ -164,7 +164,7 @@ impl CStore {
}
}
crate fn crate_dependencies_in_postorder(&self, cnum: CrateNum) -> Vec<CrateNum> {
pub(crate) fn crate_dependencies_in_postorder(&self, cnum: CrateNum) -> Vec<CrateNum> {
let mut deps = Vec::new();
if cnum == LOCAL_CRATE {
for (cnum, _) in self.iter_crate_data() {
@ -182,15 +182,15 @@ impl CStore {
deps
}
crate fn injected_panic_runtime(&self) -> Option<CrateNum> {
pub(crate) fn injected_panic_runtime(&self) -> Option<CrateNum> {
self.injected_panic_runtime
}
crate fn allocator_kind(&self) -> Option<AllocatorKind> {
pub(crate) fn allocator_kind(&self) -> Option<AllocatorKind> {
self.allocator_kind
}
crate fn has_global_allocator(&self) -> bool {
pub(crate) fn has_global_allocator(&self) -> bool {
self.has_global_allocator
}

2
compiler/rustc_metadata/src/dependency_format.rs
View file

@ -62,7 +62,7 @@ use rustc_session::cstore::CrateDepKind;
use rustc_session::cstore::LinkagePreference::{self, RequireDynamic, RequireStatic};
use rustc_target::spec::PanicStrategy;
crate fn calculate(tcx: TyCtxt<'_>) -> Dependencies {
pub(crate) fn calculate(tcx: TyCtxt<'_>) -> Dependencies {
tcx.sess
.crate_types()
.iter()

2
compiler/rustc_metadata/src/foreign_modules.rs
View file

@ -3,7 +3,7 @@ use rustc_hir::def::DefKind;
use rustc_middle::ty::TyCtxt;
use rustc_session::cstore::ForeignModule;
crate fn collect(tcx: TyCtxt<'_>) -> Vec<ForeignModule> {
pub(crate) fn collect(tcx: TyCtxt<'_>) -> Vec<ForeignModule> {
let mut modules = Vec::new();
for id in tcx.hir().items() {
if !matches!(tcx.def_kind(id.def_id), DefKind::ForeignMod) {

1
compiler/rustc_metadata/src/lib.rs
View file

@ -1,5 +1,4 @@
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
#![feature(crate_visibility_modifier)]
#![feature(decl_macro)]
#![feature(drain_filter)]
#![feature(generators)]

22
compiler/rustc_metadata/src/locator.rs
View file

@ -239,7 +239,7 @@ use std::{cmp, fmt, fs};
use tracing::{debug, info};
#[derive(Clone)]
crate struct CrateLocator<'a> {
pub(crate) struct CrateLocator<'a> {
// Immutable per-session configuration.
only_needs_metadata: bool,
sysroot: &'a Path,
@ -260,19 +260,19 @@ crate struct CrateLocator<'a> {
}
#[derive(Clone)]
crate struct CratePaths {
pub(crate) struct CratePaths {
name: Symbol,
source: CrateSource,
}
impl CratePaths {
crate fn new(name: Symbol, source: CrateSource) -> CratePaths {
pub(crate) fn new(name: Symbol, source: CrateSource) -> CratePaths {
CratePaths { name, source }
}
}
#[derive(Copy, Clone, PartialEq)]
crate enum CrateFlavor {
pub(crate) enum CrateFlavor {
Rlib,
Rmeta,
Dylib,
@ -289,7 +289,7 @@ impl fmt::Display for CrateFlavor {
}
impl<'a> CrateLocator<'a> {
crate fn new(
pub(crate) fn new(
sess: &'a Session,
metadata_loader: &'a dyn MetadataLoader,
crate_name: Symbol,
@ -344,7 +344,7 @@ impl<'a> CrateLocator<'a> {
}
}
crate fn reset(&mut self) {
pub(crate) fn reset(&mut self) {
self.crate_rejections.via_hash.clear();
self.crate_rejections.via_triple.clear();
self.crate_rejections.via_kind.clear();
@ -353,7 +353,7 @@ impl<'a> CrateLocator<'a> {
self.crate_rejections.via_invalid.clear();
}
crate fn maybe_load_library_crate(&mut self) -> Result<Option<Library>, CrateError> {
pub(crate) fn maybe_load_library_crate(&mut self) -> Result<Option<Library>, CrateError> {
if !self.exact_paths.is_empty() {
return self.find_commandline_library();
}
@ -728,7 +728,7 @@ impl<'a> CrateLocator<'a> {
Ok(self.extract_lib(rlibs, rmetas, dylibs)?.map(|(_, lib)| lib))
}
crate fn into_error(self, root: Option<CratePaths>) -> CrateError {
pub(crate) fn into_error(self, root: Option<CratePaths>) -> CrateError {
CrateError::LocatorCombined(CombinedLocatorError {
crate_name: self.crate_name,
root,
@ -894,7 +894,7 @@ struct CrateRejections {
/// Candidate rejection reasons collected during crate search.
/// If no candidate is accepted, then these reasons are presented to the user,
/// otherwise they are ignored.
crate struct CombinedLocatorError {
pub(crate) struct CombinedLocatorError {
crate_name: Symbol,
root: Option<CratePaths>,
triple: TargetTriple,
@ -903,7 +903,7 @@ crate struct CombinedLocatorError {
crate_rejections: CrateRejections,
}
crate enum CrateError {
pub(crate) enum CrateError {
NonAsciiName(Symbol),
ExternLocationNotExist(Symbol, PathBuf),
ExternLocationNotFile(Symbol, PathBuf),
@ -937,7 +937,7 @@ impl fmt::Display for MetadataError<'_> {
}
impl CrateError {
crate fn report(self, sess: &Session, span: Span, missing_core: bool) {
pub(crate) fn report(self, sess: &Session, span: Span, missing_core: bool) {
let mut diag = match self {
CrateError::NonAsciiName(crate_name) => sess.struct_span_err(
span,

4
compiler/rustc_metadata/src/native_libs.rs
View file

@ -12,7 +12,7 @@ use rustc_session::Session;
use rustc_span::symbol::{sym, Symbol};
use rustc_target::spec::abi::Abi;
crate fn collect(tcx: TyCtxt<'_>) -> Vec<NativeLib> {
pub(crate) fn collect(tcx: TyCtxt<'_>) -> Vec<NativeLib> {
let mut collector = Collector { tcx, libs: Vec::new() };
for id in tcx.hir().items() {
collector.process_item(id);
@ -21,7 +21,7 @@ crate fn collect(tcx: TyCtxt<'_>) -> Vec<NativeLib> {
collector.libs
}
crate fn relevant_lib(sess: &Session, lib: &NativeLib) -> bool {
pub(crate) fn relevant_lib(sess: &Session, lib: &NativeLib) -> bool {
match lib.cfg {
Some(ref cfg) => attr::cfg_matches(cfg, &sess.parse_sess, CRATE_NODE_ID, None),
None => true,

64
compiler/rustc_metadata/src/rmeta/decoder.rs
View file

@ -57,7 +57,7 @@ mod cstore_impl;
/// A `MetadataBlob` internally is just a reference counted pointer to
/// the actual data, so cloning it is cheap.
#[derive(Clone)]
crate struct MetadataBlob(Lrc<MetadataRef>);
pub(crate) struct MetadataBlob(Lrc<MetadataRef>);
// This is needed so we can create an OwningRef into the blob.
// The data behind a `MetadataBlob` has a stable address because it is
@ -78,9 +78,9 @@ impl std::ops::Deref for MetadataBlob {
// local crate numbers (as generated during this session). Each external
// crate may refer to types in other external crates, and each has their
// own crate numbers.
crate type CrateNumMap = IndexVec<CrateNum, CrateNum>;
pub(crate) type CrateNumMap = IndexVec<CrateNum, CrateNum>;
crate struct CrateMetadata {
pub(crate) struct CrateMetadata {
/// The primary crate data - binary metadata blob.
blob: MetadataBlob,
@ -744,20 +744,20 @@ where
implement_ty_decoder!(DecodeContext<'a, 'tcx>);
impl<'tcx> MetadataBlob {
crate fn new(metadata_ref: MetadataRef) -> MetadataBlob {
pub(crate) fn new(metadata_ref: MetadataRef) -> MetadataBlob {
MetadataBlob(Lrc::new(metadata_ref))
}
crate fn is_compatible(&self) -> bool {
pub(crate) fn is_compatible(&self) -> bool {
self.blob().starts_with(METADATA_HEADER)
}
crate fn get_rustc_version(&self) -> String {
pub(crate) fn get_rustc_version(&self) -> String {
Lazy::<String>::from_position(NonZeroUsize::new(METADATA_HEADER.len() + 4).unwrap())
.decode(self)
}
crate fn get_root(&self) -> CrateRoot<'tcx> {
pub(crate) fn get_root(&self) -> CrateRoot<'tcx> {
let slice = &self.blob()[..];
let offset = METADATA_HEADER.len();
let pos = (((slice[offset + 0] as u32) << 24)
@ -767,7 +767,7 @@ impl<'tcx> MetadataBlob {
Lazy::<CrateRoot<'tcx>>::from_position(NonZeroUsize::new(pos).unwrap()).decode(self)
}
crate fn list_crate_metadata(&self, out: &mut dyn io::Write) -> io::Result<()> {
pub(crate) fn list_crate_metadata(&self, out: &mut dyn io::Write) -> io::Result<()> {
let root = self.get_root();
writeln!(out, "Crate info:")?;
writeln!(out, "name {}{}", root.name, root.extra_filename)?;
@ -792,27 +792,27 @@ impl<'tcx> MetadataBlob {
}
impl CrateRoot<'_> {
crate fn is_proc_macro_crate(&self) -> bool {
pub(crate) fn is_proc_macro_crate(&self) -> bool {
self.proc_macro_data.is_some()
}
crate fn name(&self) -> Symbol {
pub(crate) fn name(&self) -> Symbol {
self.name
}
crate fn hash(&self) -> Svh {
pub(crate) fn hash(&self) -> Svh {
self.hash
}
crate fn stable_crate_id(&self) -> StableCrateId {
pub(crate) fn stable_crate_id(&self) -> StableCrateId {
self.stable_crate_id
}
crate fn triple(&self) -> &TargetTriple {
pub(crate) fn triple(&self) -> &TargetTriple {
&self.triple
}
crate fn decode_crate_deps<'a>(
pub(crate) fn decode_crate_deps<'a>(
&self,
metadata: &'a MetadataBlob,
) -> impl ExactSizeIterator<Item = CrateDep> + Captures<'a> {
@ -1759,7 +1759,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
}
impl CrateMetadata {
crate fn new(
pub(crate) fn new(
sess: &Session,
cstore: &CStore,
blob: MetadataBlob,
@ -1819,15 +1819,15 @@ impl CrateMetadata {
cdata
}
crate fn dependencies(&self) -> LockGuard<'_, Vec<CrateNum>> {
pub(crate) fn dependencies(&self) -> LockGuard<'_, Vec<CrateNum>> {
self.dependencies.borrow()
}
crate fn add_dependency(&self, cnum: CrateNum) {
pub(crate) fn add_dependency(&self, cnum: CrateNum) {
self.dependencies.borrow_mut().push(cnum);
}
crate fn update_extern_crate(&self, new_extern_crate: ExternCrate) -> bool {
pub(crate) fn update_extern_crate(&self, new_extern_crate: ExternCrate) -> bool {
let mut extern_crate = self.extern_crate.borrow_mut();
let update = Some(new_extern_crate.rank()) > extern_crate.as_ref().map(ExternCrate::rank);
if update {
@ -1836,59 +1836,59 @@ impl CrateMetadata {
update
}
crate fn source(&self) -> &CrateSource {
pub(crate) fn source(&self) -> &CrateSource {
&*self.source
}
crate fn dep_kind(&self) -> CrateDepKind {
pub(crate) fn dep_kind(&self) -> CrateDepKind {
*self.dep_kind.lock()
}
crate fn update_dep_kind(&self, f: impl FnOnce(CrateDepKind) -> CrateDepKind) {
pub(crate) fn update_dep_kind(&self, f: impl FnOnce(CrateDepKind) -> CrateDepKind) {
self.dep_kind.with_lock(|dep_kind| *dep_kind = f(*dep_kind))
}
crate fn panic_strategy(&self) -> PanicStrategy {
pub(crate) fn panic_strategy(&self) -> PanicStrategy {
self.root.panic_strategy
}
crate fn needs_panic_runtime(&self) -> bool {
pub(crate) fn needs_panic_runtime(&self) -> bool {
self.root.needs_panic_runtime
}
crate fn is_panic_runtime(&self) -> bool {
pub(crate) fn is_panic_runtime(&self) -> bool {
self.root.panic_runtime
}
crate fn is_profiler_runtime(&self) -> bool {
pub(crate) fn is_profiler_runtime(&self) -> bool {
self.root.profiler_runtime
}
crate fn needs_allocator(&self) -> bool {
pub(crate) fn needs_allocator(&self) -> bool {
self.root.needs_allocator
}
crate fn has_global_allocator(&self) -> bool {
pub(crate) fn has_global_allocator(&self) -> bool {
self.root.has_global_allocator
}
crate fn has_default_lib_allocator(&self) -> bool {
pub(crate) fn has_default_lib_allocator(&self) -> bool {
self.root.has_default_lib_allocator
}
crate fn is_proc_macro_crate(&self) -> bool {
pub(crate) fn is_proc_macro_crate(&self) -> bool {
self.root.is_proc_macro_crate()
}
crate fn name(&self) -> Symbol {
pub(crate) fn name(&self) -> Symbol {
self.root.name
}
crate fn stable_crate_id(&self) -> StableCrateId {
pub(crate) fn stable_crate_id(&self) -> StableCrateId {
self.root.stable_crate_id
}
crate fn hash(&self) -> Svh {
pub(crate) fn hash(&self) -> Svh {
self.root.hash
}

2
compiler/rustc_metadata/src/rmeta/def_path_hash_map.rs
View file

@ -6,7 +6,7 @@ use rustc_hir::def_path_hash_map::{Config as HashMapConfig, DefPathHashMap};
use rustc_serialize::{opaque, Decodable, Decoder, Encodable, Encoder};
use rustc_span::def_id::{DefIndex, DefPathHash};
crate enum DefPathHashMapRef<'tcx> {
pub(crate) enum DefPathHashMapRef<'tcx> {
OwnedFromMetadata(odht::HashTable<HashMapConfig, OwningRef<MetadataBlob, [u8]>>),
BorrowedFromTcx(&'tcx DefPathHashMap),
}

18
compiler/rustc_metadata/src/rmeta/mod.rs
View file

@ -36,7 +36,7 @@ use std::num::NonZeroUsize;
pub use decoder::provide_extern;
use decoder::DecodeContext;
crate use decoder::{CrateMetadata, CrateNumMap, MetadataBlob};
pub(crate) use decoder::{CrateMetadata, CrateNumMap, MetadataBlob};
use encoder::EncodeContext;
pub use encoder::{encode_metadata, EncodedMetadata};
use rustc_span::hygiene::SyntaxContextData;
@ -46,7 +46,7 @@ mod def_path_hash_map;
mod encoder;
mod table;
crate fn rustc_version() -> String {
pub(crate) fn rustc_version() -> String {
format!("rustc {}", option_env!("CFG_VERSION").unwrap_or("unknown version"))
}
@ -169,7 +169,7 @@ type ExpnDataTable = Lazy<Table<ExpnIndex, Lazy<ExpnData>>>;
type ExpnHashTable = Lazy<Table<ExpnIndex, Lazy<ExpnHash>>>;
#[derive(MetadataEncodable, MetadataDecodable)]
crate struct ProcMacroData {
pub(crate) struct ProcMacroData {
proc_macro_decls_static: DefIndex,
stability: Option<attr::Stability>,
macros: Lazy<[DefIndex]>,
@ -192,7 +192,7 @@ crate struct ProcMacroData {
/// a normal crate, much of what we serialized would be unusable in addition
/// to being unused.
#[derive(MetadataEncodable, MetadataDecodable)]
crate struct CrateRoot<'tcx> {
pub(crate) struct CrateRoot<'tcx> {
name: Symbol,
triple: TargetTriple,
extra_filename: String,
@ -245,7 +245,7 @@ crate struct CrateRoot<'tcx> {
/// This creates a type-safe way to enforce that we remap the CrateNum between the on-disk
/// representation and the compilation session.
#[derive(Copy, Clone)]
crate struct RawDefId {
pub(crate) struct RawDefId {
krate: u32,
index: u32,
}
@ -265,7 +265,7 @@ impl RawDefId {
}
#[derive(Encodable, Decodable)]
crate struct CrateDep {
pub(crate) struct CrateDep {
pub name: Symbol,
pub hash: Svh,
pub host_hash: Option<Svh>,
@ -274,13 +274,13 @@ crate struct CrateDep {
}
#[derive(MetadataEncodable, MetadataDecodable)]
crate struct TraitImpls {
pub(crate) struct TraitImpls {
trait_id: (u32, DefIndex),
impls: Lazy<[(DefIndex, Option<SimplifiedType>)]>,
}
#[derive(MetadataEncodable, MetadataDecodable)]
crate struct IncoherentImpls {
pub(crate) struct IncoherentImpls {
self_ty: SimplifiedType,
impls: Lazy<[DefIndex]>,
}
@ -289,7 +289,7 @@ crate struct IncoherentImpls {
macro_rules! define_tables {
($($name:ident: Table<$IDX:ty, $T:ty>),+ $(,)?) => {
#[derive(MetadataEncodable, MetadataDecodable)]
crate struct LazyTables<'tcx> {
pub(crate) struct LazyTables<'tcx> {
$($name: Lazy!(Table<$IDX, $T>)),+
}

7
compiler/rustc_middle/src/dep_graph/dep_node.rs
View file

@ -195,13 +195,16 @@ rustc_dep_node_append!([define_dep_nodes!][ <'tcx>
// WARNING: `construct` is generic and does not know that `CompileCodegenUnit` takes `Symbol`s as keys.
// Be very careful changing this type signature!
crate fn make_compile_codegen_unit(tcx: TyCtxt<'_>, name: Symbol) -> DepNode {
pub(crate) fn make_compile_codegen_unit(tcx: TyCtxt<'_>, name: Symbol) -> DepNode {
DepNode::construct(tcx, DepKind::CompileCodegenUnit, &name)
}
// WARNING: `construct` is generic and does not know that `CompileMonoItem` takes `MonoItem`s as keys.
// Be very careful changing this type signature!
crate fn make_compile_mono_item<'tcx>(tcx: TyCtxt<'tcx>, mono_item: &MonoItem<'tcx>) -> DepNode {
pub(crate) fn make_compile_mono_item<'tcx>(
tcx: TyCtxt<'tcx>,
mono_item: &MonoItem<'tcx>,
) -> DepNode {
DepNode::construct(tcx, DepKind::CompileMonoItem, mono_item)
}

2
compiler/rustc_middle/src/dep_graph/mod.rs
View file

@ -12,7 +12,7 @@ pub use rustc_query_system::dep_graph::{
};
pub use dep_node::{label_strs, DepKind, DepKindStruct, DepNode, DepNodeExt};
crate use dep_node::{make_compile_codegen_unit, make_compile_mono_item};
pub(crate) use dep_node::{make_compile_codegen_unit, make_compile_mono_item};
pub type DepGraph = rustc_query_system::dep_graph::DepGraph<DepKind>;
pub type TaskDeps = rustc_query_system::dep_graph::TaskDeps<DepKind>;

1
compiler/rustc_middle/src/lib.rs
View file

@ -46,7 +46,6 @@
#![feature(min_specialization)]
#![feature(trusted_len)]
#![feature(type_alias_impl_trait)]
#![feature(crate_visibility_modifier)]
#![feature(associated_type_bounds)]
#![feature(rustc_attrs)]
#![feature(half_open_range_patterns)]

4
compiler/rustc_middle/src/mir/interpret/mod.rs
View file

@ -414,7 +414,7 @@ impl<'tcx> GlobalAlloc<'tcx> {
}
}
crate struct AllocMap<'tcx> {
pub(crate) struct AllocMap<'tcx> {
/// Maps `AllocId`s to their corresponding allocations.
alloc_map: FxHashMap<AllocId, GlobalAlloc<'tcx>>,
@ -430,7 +430,7 @@ crate struct AllocMap<'tcx> {
}
impl<'tcx> AllocMap<'tcx> {
crate fn new() -> Self {
pub(crate) fn new() -> Self {
AllocMap {
alloc_map: Default::default(),
dedup: Default::default(),

2
compiler/rustc_middle/src/ty/context.rs
View file

@ -1230,7 +1230,7 @@ impl<'tcx> TyCtxt<'tcx> {
}
}
crate fn query_kind(self, k: DepKind) -> &'tcx DepKindStruct {
pub(crate) fn query_kind(self, k: DepKind) -> &'tcx DepKindStruct {
&self.query_kinds[k as usize]
}

4
compiler/rustc_middle/src/ty/mod.rs
View file

@ -409,7 +409,7 @@ pub struct CReaderCacheKey {
/// of the relevant methods.
#[derive(PartialEq, Eq, PartialOrd, Ord)]
#[allow(rustc::usage_of_ty_tykind)]
crate struct TyS<'tcx> {
pub(crate) struct TyS<'tcx> {
/// This field shouldn't be used directly and may be removed in the future.
/// Use `Ty::kind()` instead.
kind: TyKind<'tcx>,
@ -500,7 +500,7 @@ impl ty::EarlyBoundRegion {
/// See comments on `TyS`, which apply here too (albeit for
/// `PredicateS`/`Predicate` rather than `TyS`/`Ty`).
#[derive(Debug)]
crate struct PredicateS<'tcx> {
pub(crate) struct PredicateS<'tcx> {
kind: Binder<'tcx, PredicateKind<'tcx>>,
flags: TypeFlags,
/// See the comment for the corresponding field of [TyS].

2
compiler/rustc_mir_build/src/build/block.rs
View file

@ -6,7 +6,7 @@ use rustc_middle::{mir::*, ty};
use rustc_span::Span;
impl<'a, 'tcx> Builder<'a, 'tcx> {
crate fn ast_block(
pub(crate) fn ast_block(
&mut self,
destination: Place<'tcx>,
block: BasicBlock,

22
compiler/rustc_mir_build/src/build/cfg.rs
View file

@ -5,33 +5,33 @@ use rustc_middle::mir::*;
use rustc_middle::ty::TyCtxt;
impl<'tcx> CFG<'tcx> {
crate fn block_data(&self, blk: BasicBlock) -> &BasicBlockData<'tcx> {
pub(crate) fn block_data(&self, blk: BasicBlock) -> &BasicBlockData<'tcx> {
&self.basic_blocks[blk]
}
crate fn block_data_mut(&mut self, blk: BasicBlock) -> &mut BasicBlockData<'tcx> {
pub(crate) fn block_data_mut(&mut self, blk: BasicBlock) -> &mut BasicBlockData<'tcx> {
&mut self.basic_blocks[blk]
}
// llvm.org/PR32488 makes this function use an excess of stack space. Mark
// it as #[inline(never)] to keep rustc's stack use in check.
#[inline(never)]
crate fn start_new_block(&mut self) -> BasicBlock {
pub(crate) fn start_new_block(&mut self) -> BasicBlock {
self.basic_blocks.push(BasicBlockData::new(None))
}
crate fn start_new_cleanup_block(&mut self) -> BasicBlock {
pub(crate) fn start_new_cleanup_block(&mut self) -> BasicBlock {
let bb = self.start_new_block();
self.block_data_mut(bb).is_cleanup = true;
bb
}
crate fn push(&mut self, block: BasicBlock, statement: Statement<'tcx>) {
pub(crate) fn push(&mut self, block: BasicBlock, statement: Statement<'tcx>) {
debug!("push({:?}, {:?})", block, statement);
self.block_data_mut(block).statements.push(statement);
}
crate fn push_assign(
pub(crate) fn push_assign(
&mut self,
block: BasicBlock,
source_info: SourceInfo,
@ -44,7 +44,7 @@ impl<'tcx> CFG<'tcx> {
);
}
crate fn push_assign_constant(
pub(crate) fn push_assign_constant(
&mut self,
block: BasicBlock,
source_info: SourceInfo,
@ -59,7 +59,7 @@ impl<'tcx> CFG<'tcx> {
);
}
crate fn push_assign_unit(
pub(crate) fn push_assign_unit(
&mut self,
block: BasicBlock,
source_info: SourceInfo,
@ -78,7 +78,7 @@ impl<'tcx> CFG<'tcx> {
);
}
crate fn push_fake_read(
pub(crate) fn push_fake_read(
&mut self,
block: BasicBlock,
source_info: SourceInfo,
@ -90,7 +90,7 @@ impl<'tcx> CFG<'tcx> {
self.push(block, stmt);
}
crate fn terminate(
pub(crate) fn terminate(
&mut self,
block: BasicBlock,
source_info: SourceInfo,
@ -107,7 +107,7 @@ impl<'tcx> CFG<'tcx> {
}
/// In the `origin` block, push a `goto -> target` terminator.
crate fn goto(&mut self, origin: BasicBlock, source_info: SourceInfo, target: BasicBlock) {
pub(crate) fn goto(&mut self, origin: BasicBlock, source_info: SourceInfo, target: BasicBlock) {
self.terminate(origin, source_info, TerminatorKind::Goto { target })
}
}

2
compiler/rustc_mir_build/src/build/expr/as_constant.rs
View file

@ -11,7 +11,7 @@ use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty, TyCtxt};
impl<'a, 'tcx> Builder<'a, 'tcx> {
/// Compile `expr`, yielding a compile-time constant. Assumes that
/// `expr` is a valid compile-time constant!
crate fn as_constant(&mut self, expr: &Expr<'tcx>) -> Constant<'tcx> {
pub(crate) fn as_constant(&mut self, expr: &Expr<'tcx>) -> Constant<'tcx> {
let create_uneval_from_def_id =
|tcx: TyCtxt<'tcx>, def_id: DefId, ty: Ty<'tcx>, substs: SubstsRef<'tcx>| {
let uneval = ty::Unevaluated::new(ty::WithOptConstParam::unknown(def_id), substs);

8
compiler/rustc_mir_build/src/build/expr/as_operand.rs
View file

@ -14,7 +14,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
/// after the current enclosing `ExprKind::Scope` has ended, so
/// please do *not* return it from functions to avoid bad
/// miscompiles.
crate fn as_local_operand(
pub(crate) fn as_local_operand(
&mut self,
block: BasicBlock,
expr: &Expr<'tcx>,
@ -73,7 +73,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
/// value to the stack.
///
/// See #68034 for more details.
crate fn as_local_call_operand(
pub(crate) fn as_local_call_operand(
&mut self,
block: BasicBlock,
expr: &Expr<'tcx>,
@ -97,7 +97,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
/// Like `as_local_call_operand`, except that the argument will
/// not be valid once `scope` ends.
#[instrument(level = "debug", skip(self, scope))]
crate fn as_operand(
pub(crate) fn as_operand(
&mut self,
mut block: BasicBlock,
scope: Option<region::Scope>,
@ -132,7 +132,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
}
}
crate fn as_call_operand(
pub(crate) fn as_call_operand(
&mut self,
mut block: BasicBlock,
scope: Option<region::Scope>,

24
compiler/rustc_mir_build/src/build/expr/as_place.rs
View file

@ -21,7 +21,7 @@ use std::iter;
/// The "outermost" place that holds this value.
#[derive(Copy, Clone, Debug, PartialEq)]
crate enum PlaceBase {
pub(crate) enum PlaceBase {
/// Denotes the start of a `Place`.
Local(Local),
@ -71,7 +71,7 @@ crate enum PlaceBase {
/// This is used internally when building a place for an expression like `a.b.c`. The fields `b`
/// and `c` can be progressively pushed onto the place builder that is created when converting `a`.
#[derive(Clone, Debug, PartialEq)]
crate struct PlaceBuilder<'tcx> {
pub(crate) struct PlaceBuilder<'tcx> {
base: PlaceBase,
projection: Vec<PlaceElem<'tcx>>,
}
@ -283,7 +283,7 @@ fn to_upvars_resolved_place_builder<'a, 'tcx>(
}
impl<'tcx> PlaceBuilder<'tcx> {
crate fn into_place<'a>(
pub(crate) fn into_place<'a>(
self,
tcx: TyCtxt<'tcx>,
typeck_results: &'a ty::TypeckResults<'tcx>,
@ -314,7 +314,7 @@ impl<'tcx> PlaceBuilder<'tcx> {
/// not captured. This can happen because the final mir that will be
/// generated doesn't require a read for this place. Failures will only
/// happen inside closures.
crate fn try_upvars_resolved<'a>(
pub(crate) fn try_upvars_resolved<'a>(
self,
tcx: TyCtxt<'tcx>,
typeck_results: &'a ty::TypeckResults<'tcx>,
@ -322,19 +322,19 @@ impl<'tcx> PlaceBuilder<'tcx> {
to_upvars_resolved_place_builder(self, tcx, typeck_results)
}
crate fn base(&self) -> PlaceBase {
pub(crate) fn base(&self) -> PlaceBase {
self.base
}
crate fn field(self, f: Field, ty: Ty<'tcx>) -> Self {
pub(crate) fn field(self, f: Field, ty: Ty<'tcx>) -> Self {
self.project(PlaceElem::Field(f, ty))
}
crate fn deref(self) -> Self {
pub(crate) fn deref(self) -> Self {
self.project(PlaceElem::Deref)
}
crate fn downcast(self, adt_def: AdtDef<'tcx>, variant_index: VariantIdx) -> Self {
pub(crate) fn downcast(self, adt_def: AdtDef<'tcx>, variant_index: VariantIdx) -> Self {
self.project(PlaceElem::Downcast(Some(adt_def.variant(variant_index).name), variant_index))
}
@ -342,7 +342,7 @@ impl<'tcx> PlaceBuilder<'tcx> {
self.project(PlaceElem::Index(index))
}
crate fn project(mut self, elem: PlaceElem<'tcx>) -> Self {
pub(crate) fn project(mut self, elem: PlaceElem<'tcx>) -> Self {
self.projection.push(elem);
self
}
@ -373,7 +373,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
/// Extra care is needed if any user code is allowed to run between calling
/// this method and using it, as is the case for `match` and index
/// expressions.
crate fn as_place(
pub(crate) fn as_place(
&mut self,
mut block: BasicBlock,
expr: &Expr<'tcx>,
@ -384,7 +384,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
/// This is used when constructing a compound `Place`, so that we can avoid creating
/// intermediate `Place` values until we know the full set of projections.
crate fn as_place_builder(
pub(crate) fn as_place_builder(
&mut self,
block: BasicBlock,
expr: &Expr<'tcx>,
@ -397,7 +397,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
/// place. The place itself may or may not be mutable:
/// * If this expr is a place expr like a.b, then we will return that place.
/// * Otherwise, a temporary is created: in that event, it will be an immutable temporary.
crate fn as_read_only_place(
pub(crate) fn as_read_only_place(
&mut self,
mut block: BasicBlock,
expr: &Expr<'tcx>,

6
compiler/rustc_mir_build/src/build/expr/as_rvalue.rs
View file

@ -21,7 +21,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
/// The operand returned from this function will *not be valid* after
/// an ExprKind::Scope is passed, so please do *not* return it from
/// functions to avoid bad miscompiles.
crate fn as_local_rvalue(
pub(crate) fn as_local_rvalue(
&mut self,
block: BasicBlock,
expr: &Expr<'tcx>,
@ -31,7 +31,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
}
/// Compile `expr`, yielding an rvalue.
crate fn as_rvalue(
pub(crate) fn as_rvalue(
&mut self,
mut block: BasicBlock,
scope: Option<region::Scope>,
@ -416,7 +416,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
}
}
crate fn build_binary_op(
pub(crate) fn build_binary_op(
&mut self,
mut block: BasicBlock,
op: BinOp,

Some files were not shown because too many files have changed in this diff Show more