Minimize visibilities.

This makes it much clearer which things are used outside the crate.

Author: nnethercote

compiler/rustc_codegen_ssa/src/back/archive.rs

@@ -157,7 +157,7 @@ pub trait ArchiveBuilderBuilder {
 }
 }
 
-pubfncreate_mingw_dll_import_lib(
+fncreate_mingw_dll_import_lib(
 sess:&Session,
 lib_name:&str,
 import_name_and_ordinal_vector:Vec<(String,Option<u16>)>,

compiler/rustc_codegen_ssa/src/back/command.rs

@@ -8,7 +8,7 @@ use std::{fmt, io, mem};
 use rustc_target::spec::LldFlavor;
 
 #[derive(Clone)]
-pubstructCommand{
+pub(crate)structCommand{
 program:Program,
 args:Vec<OsString>,
 env:Vec<(OsString,OsString)>,
@@ -23,28 +23,28 @@ enum Program {
 }
 
 implCommand{
-pubfnnew<P:AsRef<OsStr>>(program:P) -> Command{
+pub(crate)fnnew<P:AsRef<OsStr>>(program:P) -> Command{
 Command::_new(Program::Normal(program.as_ref().to_owned()))
 }
 
-pubfnbat_script<P:AsRef<OsStr>>(program:P) -> Command{
+pub(crate)fnbat_script<P:AsRef<OsStr>>(program:P) -> Command{
 Command::_new(Program::CmdBatScript(program.as_ref().to_owned()))
 }
 
-pubfnlld<P:AsRef<OsStr>>(program:P,flavor:LldFlavor) -> Command{
+pub(crate)fnlld<P:AsRef<OsStr>>(program:P,flavor:LldFlavor) -> Command{
 Command::_new(Program::Lld(program.as_ref().to_owned(), flavor))
 }
 
 fn_new(program:Program) -> Command{
 Command{ program,args:Vec::new(),env:Vec::new(),env_remove:Vec::new()}
 }
 
-pubfnarg<P:AsRef<OsStr>>(&mutself,arg:P) -> &mutCommand{
+pub(crate)fnarg<P:AsRef<OsStr>>(&mutself,arg:P) -> &mutCommand{
 self._arg(arg.as_ref());
 self
 }
 
-pubfnargs<I>(&mutself,args:I) -> &mutCommand
+pub(crate)fnargs<I>(&mutself,args:I) -> &mutCommand
 where
 I:IntoIterator<Item:AsRef<OsStr>>,
 {
@@ -58,7 +58,7 @@ impl Command {
 self.args.push(arg.to_owned());
 }
 
-pubfnenv<K,V>(&mutself,key:K,value:V) -> &mutCommand
+pub(crate)fnenv<K,V>(&mutself,key:K,value:V) -> &mutCommand
 where
 K:AsRef<OsStr>,
 V:AsRef<OsStr>,
@@ -71,7 +71,7 @@ impl Command {
 self.env.push((key.to_owned(), value.to_owned()));
 }
 
-pubfnenv_remove<K>(&mutself,key:K) -> &mutCommand
+pub(crate)fnenv_remove<K>(&mutself,key:K) -> &mutCommand
 where
 K:AsRef<OsStr>,
 {
@@ -83,11 +83,11 @@ impl Command {
 self.env_remove.push(key.to_owned());
 }
 
-pubfnoutput(&mutself) -> io::Result<Output>{
+pub(crate)fnoutput(&mutself) -> io::Result<Output>{
 self.command().output()
 }
 
-pubfncommand(&self) -> process::Command{
+pub(crate)fncommand(&self) -> process::Command{
 letmut ret = matchself.program{
 Program::Normal(ref p) => process::Command::new(p),
 Program::CmdBatScript(ref p) => {
@@ -111,17 +111,17 @@ impl Command {
 
 // extensions
 
-pubfnget_args(&self) -> &[OsString]{
+pub(crate)fnget_args(&self) -> &[OsString]{
 &self.args
 }
 
-pubfntake_args(&mutself) -> Vec<OsString>{
+pub(crate)fntake_args(&mutself) -> Vec<OsString>{
  mem::take(&mutself.args)
 }
 
 /// Returns a `true` if we're pretty sure that this'll blow OS spawn limits,
 /// or `false` if we should attempt to spawn and see what the OS says.
-pubfnvery_likely_to_exceed_some_spawn_limit(&self) -> bool{
+pub(crate)fnvery_likely_to_exceed_some_spawn_limit(&self) -> bool{
 // We mostly only care about Windows in this method, on Unix the limits
 // can be gargantuan anyway so we're pretty unlikely to hit them
 ifcfg!(unix){

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -28,7 +28,7 @@ use crate::errors;
 /// and prevent inspection of linker output in case of errors, which we occasionally do.
 /// This should be acceptable because other messages from rustc are in English anyway,
 /// and may also be desirable to improve searchability of the linker diagnostics.
-pubfndisable_localization(linker:&mutCommand){
+pub(crate)fndisable_localization(linker:&mutCommand){
 // No harm in setting both env vars simultaneously.
 // Unix-style linkers.
  linker.env("LC_ALL","C");
@@ -39,7 +39,7 @@ pub fn disable_localization(linker: &mut Command) {
 /// The third parameter is for env vars, used on windows to set up the
 /// path for MSVC to find its DLLs, and gcc to find its bundled
 /// toolchain
-pubfnget_linker<'a>(
+pub(crate)fnget_linker<'a>(
 sess:&'aSession,
 linker:&Path,
 flavor:LinkerFlavor,
@@ -213,28 +213,36 @@ fn link_or_cc_args<L: Linker + ?Sized>(
 macro_rules! generate_arg_methods {
 ($($ty:ty)*) => { $(
 impl $ty {
-pubfn verbatim_args(&mutself, args:implIntoIterator<Item:AsRef<OsStr>>) -> &mutSelf{
+ #[allow(unused)]
+pub(crate)fn verbatim_args(&mutself, args:implIntoIterator<Item:AsRef<OsStr>>) -> &mutSelf{
  verbatim_args(self, args)
 }
-pubfn verbatim_arg(&mutself, arg:implAsRef<OsStr>) -> &mutSelf{
+ #[allow(unused)]
+pub(crate)fn verbatim_arg(&mutself, arg:implAsRef<OsStr>) -> &mutSelf{
  verbatim_args(self, iter::once(arg))
 }
-pubfn link_args(&mutself, args:implIntoIterator<Item:AsRef<OsStr>,IntoIter:ExactSizeIterator>) -> &mutSelf{
+ #[allow(unused)]
+pub(crate)fn link_args(&mutself, args:implIntoIterator<Item:AsRef<OsStr>,IntoIter:ExactSizeIterator>) -> &mutSelf{
  link_args(self, args)
 }
-pubfn link_arg(&mutself, arg:implAsRef<OsStr>) -> &mutSelf{
+ #[allow(unused)]
+pub(crate)fn link_arg(&mutself, arg:implAsRef<OsStr>) -> &mutSelf{
  link_args(self, iter::once(arg))
 }
-pubfn cc_args(&mutself, args:implIntoIterator<Item:AsRef<OsStr>>) -> &mutSelf{
+ #[allow(unused)]
+pub(crate)fn cc_args(&mutself, args:implIntoIterator<Item:AsRef<OsStr>>) -> &mutSelf{
  cc_args(self, args)
 }
-pubfn cc_arg(&mutself, arg:implAsRef<OsStr>) -> &mutSelf{
+ #[allow(unused)]
+pub(crate)fn cc_arg(&mutself, arg:implAsRef<OsStr>) -> &mutSelf{
  cc_args(self, iter::once(arg))
 }
-pubfn link_or_cc_args(&mutself, args:implIntoIterator<Item:AsRef<OsStr>>) -> &mutSelf{
+ #[allow(unused)]
+pub(crate)fn link_or_cc_args(&mutself, args:implIntoIterator<Item:AsRef<OsStr>>) -> &mutSelf{
  link_or_cc_args(self, args)
 }
-pubfn link_or_cc_arg(&mutself, arg:implAsRef<OsStr>) -> &mutSelf{
+ #[allow(unused)]
+pub(crate)fn link_or_cc_arg(&mutself, arg:implAsRef<OsStr>) -> &mutSelf{
  link_or_cc_args(self, iter::once(arg))
 }
 }
@@ -261,7 +269,7 @@ generate_arg_methods! {
 /// represents the meaning of each option being passed down. This trait is then
 /// used to dispatch on whether a GNU-like linker (generally `ld.exe`) or an
 /// MSVC linker (e.g., `link.exe`) is being used.
-pubtraitLinker{
+pub(crate)traitLinker{
 fncmd(&mutself) -> &mutCommand;
 fnis_cc(&self) -> bool{
 false
@@ -312,12 +320,12 @@ pub trait Linker {
 }
 
 impldynLinker + '_{
-pubfntake_cmd(&mutself) -> Command{
+pub(crate)fntake_cmd(&mutself) -> Command{
  mem::replace(self.cmd(),Command::new(""))
 }
 }
 
-pubstructGccLinker<'a>{
+structGccLinker<'a>{
 cmd:Command,
 sess:&'aSession,
 target_cpu:&'astr,
@@ -847,7 +855,7 @@ impl<'a> Linker for GccLinker<'a> {
 }
 }
 
-pubstructMsvcLinker<'a>{
+structMsvcLinker<'a>{
 cmd:Command,
 sess:&'aSession,
 }
@@ -1095,7 +1103,7 @@ impl<'a> Linker for MsvcLinker<'a> {
 }
 }
 
-pubstructEmLinker<'a>{
+structEmLinker<'a>{
 cmd:Command,
 sess:&'aSession,
 }
@@ -1212,7 +1220,7 @@ impl<'a> Linker for EmLinker<'a> {
 }
 }
 
-pubstructWasmLd<'a>{
+structWasmLd<'a>{
 cmd:Command,
 sess:&'aSession,
 }
@@ -1396,7 +1404,7 @@ impl<'a> WasmLd<'a> {
 }
 
 /// Linker shepherd script for L4Re (Fiasco)
-pubstructL4Bender<'a>{
+structL4Bender<'a>{
 cmd:Command,
 sess:&'aSession,
 hinted_static:bool,
@@ -1502,7 +1510,7 @@ impl<'a> Linker for L4Bender<'a> {
 }
 
 impl<'a>L4Bender<'a>{
-pubfnnew(cmd:Command,sess:&'aSession) -> L4Bender<'a>{
+fnnew(cmd:Command,sess:&'aSession) -> L4Bender<'a>{
 L4Bender{ cmd, sess,hinted_static:false}
 }
 
@@ -1515,14 +1523,14 @@ impl<'a> L4Bender<'a> {
 }
 
 /// Linker for AIX.
-pubstructAixLinker<'a>{
+structAixLinker<'a>{
 cmd:Command,
 sess:&'aSession,
 hinted_static:Option<bool>,
 }
 
 impl<'a>AixLinker<'a>{
-pubfnnew(cmd:Command,sess:&'aSession) -> AixLinker<'a>{
+fnnew(cmd:Command,sess:&'aSession) -> AixLinker<'a>{
 AixLinker{ cmd, sess,hinted_static:None}
 }
 
@@ -1750,7 +1758,7 @@ pub(crate) fn linked_symbols(
 
 /// Much simplified and explicit CLI for the NVPTX linker. The linker operates
 /// with bitcode and uses LLVM backend to generate a PTX assembly.
-pubstructPtxLinker<'a>{
+structPtxLinker<'a>{
 cmd:Command,
 sess:&'aSession,
 }
@@ -1816,7 +1824,7 @@ impl<'a> Linker for PtxLinker<'a> {
 }
 
 /// The `self-contained` LLVM bitcode linker
-pubstructLlbcLinker<'a>{
+structLlbcLinker<'a>{
 cmd:Command,
 sess:&'aSession,
 }
@@ -1887,7 +1895,7 @@ impl<'a> Linker for LlbcLinker<'a> {
 fnlinker_plugin_lto(&mutself){}
 }
 
-pubstructBpfLinker<'a>{
+structBpfLinker<'a>{
 cmd:Command,
 sess:&'aSession,
 }

compiler/rustc_codegen_ssa/src/back/metadata.rs

@@ -32,7 +32,7 @@ use rustc_target::spec::{ef_avr_arch, RelocModel, Target};
 /// <dd>The metadata can be found in the `.rustc` section of the shared library.</dd>
 /// </dl>
 #[derive(Debug)]
-pubstructDefaultMetadataLoader;
+pub(crate)structDefaultMetadataLoader;
 
 staticAIX_METADATA_SYMBOL_NAME:&'staticstr = "__aix_rust_metadata";
 
@@ -416,7 +416,7 @@ fn macho_is_arm64e(target: &Target) -> bool {
  target.llvm_target.starts_with("arm64e")
 }
 
-pubenumMetadataPosition{
+pub(crate)enumMetadataPosition{
 First,
 Last,
 }
@@ -452,7 +452,7 @@ pub enum MetadataPosition {
 /// * ELF - All other targets are similar to Windows in that there's a
 /// `SHF_EXCLUDE` flag we can set on sections in an object file to get
 /// automatically removed from the final output.
-pubfncreate_wrapper_file(
+pub(crate)fncreate_wrapper_file(
 sess:&Session,
 section_name:String,
 data:&[u8],

compiler/rustc_codegen_ssa/src/back/mod.rs

@@ -1,9 +1,9 @@
 pubmod archive;
-pubmod command;
+pub(crate)mod command;
 pubmod link;
-pubmod linker;
+pub(crate)mod linker;
 pubmod lto;
 pubmod metadata;
-pubmod rpath;
+pub(crate)mod rpath;
 pubmod symbol_export;
 pubmod write;

compiler/rustc_codegen_ssa/src/back/rpath.rs

@@ -6,14 +6,14 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_fs_util::try_canonicalize;
 use tracing::debug;
 
-pubstructRPathConfig<'a>{
+pub(super)structRPathConfig<'a>{
 publibs:&'a[&'aPath],
 pubout_filename:PathBuf,
 pubis_like_osx:bool,
 publinker_is_gnu:bool,
 }
 
-pubfnget_rpath_flags(config:&RPathConfig<'_>) -> Vec<OsString>{
+pub(super)fnget_rpath_flags(config:&RPathConfig<'_>) -> Vec<OsString>{
 debug!("preparing the RPATH!");
 
 let rpaths = get_rpaths(config);

compiler/rustc_codegen_ssa/src/back/symbol_export.rs

@@ -18,7 +18,7 @@ use tracing::debug;
 
 usecrate::base::allocator_kind_for_codegen;
 
-pubfnthreshold(tcx:TyCtxt<'_>) -> SymbolExportLevel{
+fnthreshold(tcx:TyCtxt<'_>) -> SymbolExportLevel{
 crates_export_threshold(tcx.crate_types())
 }
 
@@ -484,7 +484,7 @@ fn is_unreachable_local_definition_provider(tcx: TyCtxt<'_>, def_id: LocalDefId)
  !tcx.reachable_set(()).contains(&def_id)
 }
 
-pubfnprovide(providers:&mutProviders){
+pub(crate)fnprovide(providers:&mutProviders){
  providers.reachable_non_generics = reachable_non_generics_provider;
  providers.is_reachable_non_generic = is_reachable_non_generic_provider_local;
  providers.exported_symbols = exported_symbols_provider_local;
@@ -525,7 +525,7 @@ fn symbol_export_level(tcx: TyCtxt<'_>, sym_def_id: DefId) -> SymbolExportLevel
 }
 
 /// This is the symbol name of the given instance instantiated in a specific crate.
-pubfnsymbol_name_for_instance_in_crate<'tcx>(
+pub(crate)fnsymbol_name_for_instance_in_crate<'tcx>(
 tcx:TyCtxt<'tcx>,
 symbol:ExportedSymbol<'tcx>,
 instantiating_crate:CrateNum,
@@ -582,7 +582,7 @@ pub fn symbol_name_for_instance_in_crate<'tcx>(
 /// This is the symbol name of the given instance as seen by the linker.
 ///
 /// On 32-bit Windows symbols are decorated according to their calling conventions.
-pubfnlinking_symbol_name_for_instance_in_crate<'tcx>(
+pub(crate)fnlinking_symbol_name_for_instance_in_crate<'tcx>(
 tcx:TyCtxt<'tcx>,
 symbol:ExportedSymbol<'tcx>,
 instantiating_crate:CrateNum,
@@ -661,7 +661,7 @@ pub fn linking_symbol_name_for_instance_in_crate<'tcx>(
 format!("{prefix}{undecorated}{suffix}{args_in_bytes}")
 }
 
-pubfnexporting_symbol_name_for_instance_in_crate<'tcx>(
+pub(crate)fnexporting_symbol_name_for_instance_in_crate<'tcx>(
 tcx:TyCtxt<'tcx>,
 symbol:ExportedSymbol<'tcx>,
 cnum:CrateNum,