Reduce visibilities.

Three of the modules don't need to be `pub`, and then
`warn(unreachable_pub)` identifies a bunch more things that also
shouldn't be `pub`, plus a couple of things that are unused.

Author: nnethercote

compiler/rustc_infer/src/infer/mod.rs

@@ -56,17 +56,17 @@ use crate::traits::{self, ObligationCause, ObligationInspector, PredicateObligat
 pubmod at;
 pubmod canonical;
 mod context;
-pubmod free_regions;
+mod free_regions;
 mod freshen;
 mod lexical_region_resolve;
-pubmod opaque_types;
+mod opaque_types;
 pubmod outlives;
 mod projection;
 pubmod region_constraints;
 pubmod relate;
 pubmod resolve;
 pub(crate)mod snapshot;
-pubmod type_variable;
+mod type_variable;
 
 #[must_use]
 #[derive(Debug)]

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

@@ -19,8 +19,8 @@ use crate::traits::{self, Obligation};
 
 mod table;
 
-pubtypeOpaqueTypeMap<'tcx> = FxIndexMap<OpaqueTypeKey<'tcx>,OpaqueTypeDecl<'tcx>>;
-pubuse table::{OpaqueTypeStorage,OpaqueTypeTable};
+pub(crate)typeOpaqueTypeMap<'tcx> = FxIndexMap<OpaqueTypeKey<'tcx>,OpaqueTypeDecl<'tcx>>;
+pub(crate)use table::{OpaqueTypeStorage,OpaqueTypeTable};
 
 usesuper::DefineOpaqueTypes;
 
@@ -377,9 +377,9 @@ impl<'tcx> InferCtxt<'tcx> {
 ///
 /// We ignore any type parameters because impl trait values are assumed to
 /// capture all the in-scope type parameters.
-pubstructConstrainOpaqueTypeRegionVisitor<'tcx,OP:FnMut(ty::Region<'tcx>)>{
-pubtcx:TyCtxt<'tcx>,
-pubop:OP,
+structConstrainOpaqueTypeRegionVisitor<'tcx,OP:FnMut(ty::Region<'tcx>)>{
+tcx:TyCtxt<'tcx>,
+op:OP,
 }
 
 impl<'tcx,OP>TypeVisitor<TyCtxt<'tcx>>forConstrainOpaqueTypeRegionVisitor<'tcx,OP>
@@ -455,20 +455,6 @@ where
 }
 }
 
-pubenumUseKind{
-DefiningUse,
-OpaqueUse,
-}
-
-implUseKind{
-pubfnis_defining(self) -> bool{
-matchself{
-UseKind::DefiningUse => true,
-UseKind::OpaqueUse => false,
-}
-}
-}
-
 impl<'tcx>InferCtxt<'tcx>{
 #[instrument(skip(self), level = "debug")]
 fnregister_hidden_type(

compiler/rustc_infer/src/infer/opaque_types/table.rs

@@ -7,7 +7,7 @@ use super::{OpaqueTypeDecl, OpaqueTypeMap};
 usecrate::infer::snapshot::undo_log::{InferCtxtUndoLogs,UndoLog};
 
 #[derive(Default,Debug,Clone)]
-pubstructOpaqueTypeStorage<'tcx>{
+pub(crate)structOpaqueTypeStorage<'tcx>{
 /// Opaque types found in explicit return types and their
 /// associated fresh inference variable. Writeback resolves these
 /// variables to get the concrete type, which can be used to

compiler/rustc_infer/src/infer/type_variable.rs

@@ -20,7 +20,7 @@ impl<'tcx> Rollback<sv::UndoLog<ut::Delegate<TyVidEqKey<'tcx>>>> for TypeVariabl
 }
 
 #[derive(Clone)]
-pubstructTypeVariableStorage<'tcx>{
+pub(crate)structTypeVariableStorage<'tcx>{
 /// The origins of each type variable.
 values:IndexVec<TyVid,TypeVariableData>,
 /// Two variables are unified in `eq_relations` when we have a
@@ -29,7 +29,7 @@ pub struct TypeVariableStorage<'tcx> {
 eq_relations: ut::UnificationTableStorage<TyVidEqKey<'tcx>>,
 }
 
-pubstructTypeVariableTable<'a,'tcx>{
+pub(crate)structTypeVariableTable<'a,'tcx>{
 storage:&'amutTypeVariableStorage<'tcx>,
 
 undo_log:&'amutInferCtxtUndoLogs<'tcx>,
@@ -50,22 +50,22 @@ pub(crate) struct TypeVariableData {
 }
 
 #[derive(Copy,Clone,Debug)]
-pubenumTypeVariableValue<'tcx>{
+pub(crate)enumTypeVariableValue<'tcx>{
 Known{value:Ty<'tcx>},
 Unknown{universe: ty::UniverseIndex},
 }
 
 impl<'tcx>TypeVariableValue<'tcx>{
 /// If this value is known, returns the type it is known to be.
 /// Otherwise, `None`.
-pubfnknown(&self) -> Option<Ty<'tcx>>{
+pub(crate)fnknown(&self) -> Option<Ty<'tcx>>{
 match*self{
 TypeVariableValue::Unknown{ .. } => None,
 TypeVariableValue::Known{ value } => Some(value),
 }
 }
 
-pubfnis_unknown(&self) -> bool{
+pub(crate)fnis_unknown(&self) -> bool{
 match*self{
 TypeVariableValue::Unknown{ .. } => true,
 TypeVariableValue::Known{ .. } => false,
@@ -74,7 +74,7 @@ impl<'tcx> TypeVariableValue<'tcx> {
 }
 
 impl<'tcx>TypeVariableStorage<'tcx>{
-pubfnnew() -> TypeVariableStorage<'tcx>{
+pub(crate)fnnew() -> TypeVariableStorage<'tcx>{
 TypeVariableStorage{
 values:Default::default(),
 eq_relations: ut::UnificationTableStorage::new(),
@@ -105,14 +105,14 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
 ///
 /// Note that this function does not return care whether
 /// `vid` has been unified with something else or not.
-pubfnvar_origin(&self,vid: ty::TyVid) -> TypeVariableOrigin{
+pub(crate)fnvar_origin(&self,vid: ty::TyVid) -> TypeVariableOrigin{
 self.storage.values[vid].origin
 }
 
 /// Records that `a == b`, depending on `dir`.
 ///
 /// Precondition: neither `a` nor `b` are known.
-pubfnequate(&mutself,a: ty::TyVid,b: ty::TyVid){
+pub(crate)fnequate(&mutself,a: ty::TyVid,b: ty::TyVid){
 debug_assert!(self.probe(a).is_unknown());
 debug_assert!(self.probe(b).is_unknown());
 self.eq_relations().union(a, b);
@@ -121,7 +121,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
 /// Instantiates `vid` with the type `ty`.
 ///
 /// Precondition: `vid` must not have been previously instantiated.
-pubfninstantiate(&mutself,vid: ty::TyVid,ty:Ty<'tcx>){
+pub(crate)fninstantiate(&mutself,vid: ty::TyVid,ty:Ty<'tcx>){
 let vid = self.root_var(vid);
 debug_assert!(!ty.is_ty_var(),"instantiating ty var with var: {vid:?} {ty:?}");
 debug_assert!(self.probe(vid).is_unknown());
@@ -143,7 +143,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
 /// - `origin`: indicates *why* the type variable was created.
 /// The code in this module doesn't care, but it can be useful
 /// for improving error messages.
-pubfnnew_var(
+pub(crate)fnnew_var(
 &mutself,
 universe: ty::UniverseIndex,
 origin:TypeVariableOrigin,
@@ -158,7 +158,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
 }
 
 /// Returns the number of type variables created thus far.
-pubfnnum_vars(&self) -> usize{
+pub(crate)fnnum_vars(&self) -> usize{
 self.storage.values.len()
 }
 
@@ -167,42 +167,29 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
 /// will yield the same root variable (per the union-find
 /// algorithm), so `root_var(a) == root_var(b)` implies that `a ==
 /// b` (transitively).
-pubfnroot_var(&mutself,vid: ty::TyVid) -> ty::TyVid{
+pub(crate)fnroot_var(&mutself,vid: ty::TyVid) -> ty::TyVid{
 self.eq_relations().find(vid).vid
 }
 
 /// Retrieves the type to which `vid` has been instantiated, if
 /// any.
-pubfnprobe(&mutself,vid: ty::TyVid) -> TypeVariableValue<'tcx>{
+pub(crate)fnprobe(&mutself,vid: ty::TyVid) -> TypeVariableValue<'tcx>{
 self.inlined_probe(vid)
 }
 
 /// An always-inlined variant of `probe`, for very hot call sites.
 #[inline(always)]
-pubfninlined_probe(&mutself,vid: ty::TyVid) -> TypeVariableValue<'tcx>{
+pub(crate)fninlined_probe(&mutself,vid: ty::TyVid) -> TypeVariableValue<'tcx>{
 self.eq_relations().inlined_probe_value(vid)
 }
 
-/// If `t` is a type-inference variable, and it has been
-/// instantiated, then return the with which it was
-/// instantiated. Otherwise, returns `t`.
-pubfnreplace_if_possible(&mutself,t:Ty<'tcx>) -> Ty<'tcx>{
-match*t.kind(){
- ty::Infer(ty::TyVar(v)) => matchself.probe(v){
-TypeVariableValue::Unknown{ .. } => t,
-TypeVariableValue::Known{ value } => value,
-},
- _ => t,
-}
-}
-
 #[inline]
 fneq_relations(&mutself) -> super::UnificationTable<'_,'tcx,TyVidEqKey<'tcx>>{
 self.storage.eq_relations.with_log(self.undo_log)
 }
 
 /// Returns a range of the type variables created during the snapshot.
-pubfnvars_since_snapshot(
+pub(crate)fnvars_since_snapshot(
 &mutself,
 value_count:usize,
 ) -> (Range<TyVid>,Vec<TypeVariableOrigin>){
@@ -215,7 +202,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
 
 /// Returns indices of all variables that are not yet
 /// instantiated.
-pubfnunresolved_variables(&mutself) -> Vec<ty::TyVid>{
+pub(crate)fnunresolved_variables(&mutself) -> Vec<ty::TyVid>{
 (0..self.num_vars())
 .filter_map(|i| {
 let vid = ty::TyVid::from_usize(i);