9 files changed, 68 insertions, 67 deletions

diff --git a/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs b/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
index b0144a289..14e4d92f0 100644
--- a/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
+++ b/crates/hir_ty/src/diagnostics/decl_check/case_conv.rs
@@ -6,7 +6,7 @@
 
 /// Converts an identifier to an UpperCamelCase form.
 /// Returns `None` if the string is already is UpperCamelCase.
-pub fn to_camel_case(ident: &str) -> Option<String> {
+pub(crate) fn to_camel_case(ident: &str) -> Option<String> {
     if is_camel_case(ident) {
         return None;
     }
@@ -59,7 +59,7 @@ pub fn to_camel_case(ident: &str) -> Option<String> {
 
 /// Converts an identifier to a lower_snake_case form.
 /// Returns `None` if the string is already in lower_snake_case.
-pub fn to_lower_snake_case(ident: &str) -> Option<String> {
+pub(crate) fn to_lower_snake_case(ident: &str) -> Option<String> {
     if is_lower_snake_case(ident) {
         return None;
     } else if is_upper_snake_case(ident) {
@@ -71,7 +71,7 @@ pub fn to_lower_snake_case(ident: &str) -> Option<String> {
 
 /// Converts an identifier to an UPPER_SNAKE_CASE form.
 /// Returns `None` if the string is already is UPPER_SNAKE_CASE.
-pub fn to_upper_snake_case(ident: &str) -> Option<String> {
+pub(crate) fn to_upper_snake_case(ident: &str) -> Option<String> {
     if is_upper_snake_case(ident) {
         return None;
     } else if is_lower_snake_case(ident) {
diff --git a/crates/hir_ty/src/diagnostics/expr.rs b/crates/hir_ty/src/diagnostics/expr.rs
index 278a4b947..434b19354 100644
--- a/crates/hir_ty/src/diagnostics/expr.rs
+++ b/crates/hir_ty/src/diagnostics/expr.rs
@@ -17,17 +17,10 @@ use crate::{
     ApplicationTy, InferenceResult, Ty, TypeCtor,
 };
 
-pub use hir_def::{
-    body::{
-        scope::{ExprScopes, ScopeEntry, ScopeId},
-        Body, BodySourceMap, ExprPtr, ExprSource, PatPtr, PatSource,
-    },
-    expr::{
-        ArithOp, Array, BinaryOp, BindingAnnotation, CmpOp, Expr, ExprId, Literal, LogicOp,
-        MatchArm, Ordering, Pat, PatId, RecordFieldPat, RecordLitField, Statement, UnaryOp,
-    },
-    src::HasSource,
-    LocalFieldId, Lookup, VariantId,
+pub(crate) use hir_def::{
+    body::{Body, BodySourceMap},
+    expr::{Expr, ExprId, MatchArm, Pat, PatId},
+    LocalFieldId, VariantId,
 };
 
 pub(super) struct ExprValidator<'a, 'b: 'a> {
diff --git a/crates/hir_ty/src/diagnostics/unsafe_check.rs b/crates/hir_ty/src/diagnostics/unsafe_check.rs
index 2da9688ca..6dc862826 100644
--- a/crates/hir_ty/src/diagnostics/unsafe_check.rs
+++ b/crates/hir_ty/src/diagnostics/unsafe_check.rs
@@ -59,12 +59,12 @@ impl<'a, 'b> UnsafeValidator<'a, 'b> {
     }
 }
 
-pub struct UnsafeExpr {
-    pub expr: ExprId,
-    pub inside_unsafe_block: bool,
+pub(crate) struct UnsafeExpr {
+    pub(crate) expr: ExprId,
+    pub(crate) inside_unsafe_block: bool,
 }
 
-pub fn unsafe_expressions(
+pub(crate) fn unsafe_expressions(
     db: &dyn HirDatabase,
     infer: &InferenceResult,
     def: DefWithBodyId,
diff --git a/crates/hir_ty/src/infer.rs b/crates/hir_ty/src/infer.rs
index 644ebd42d..f4c1fa2f2 100644
--- a/crates/hir_ty/src/infer.rs
+++ b/crates/hir_ty/src/infer.rs
@@ -214,9 +214,9 @@ struct InferenceContext<'a> {
 
 #[derive(Clone, Debug)]
 struct BreakableContext {
-    pub may_break: bool,
-    pub break_ty: Ty,
-    pub label: Option<name::Name>,
+    may_break: bool,
+    break_ty: Ty,
+    label: Option<name::Name>,
 }
 
 fn find_breakable<'c>(
diff --git a/crates/hir_ty/src/infer/expr.rs b/crates/hir_ty/src/infer/expr.rs
index 8ac4cf89a..605951b10 100644
--- a/crates/hir_ty/src/infer/expr.rs
+++ b/crates/hir_ty/src/infer/expr.rs
@@ -107,7 +107,7 @@ impl<'a> InferenceContext<'a> {
         }
     }
 
-    pub fn callable_sig(&mut self, ty: &Ty, num_args: usize) -> Option<(Vec<Ty>, Ty)> {
+    pub(crate) fn callable_sig(&mut self, ty: &Ty, num_args: usize) -> Option<(Vec<Ty>, Ty)> {
         match ty.callable_sig(self.db) {
             Some(sig) => Some((sig.params().to_vec(), sig.ret().clone())),
             None => self.callable_sig_from_fn_trait(ty, num_args),
diff --git a/crates/hir_ty/src/infer/unify.rs b/crates/hir_ty/src/infer/unify.rs
index 2e895d911..2406a7361 100644
--- a/crates/hir_ty/src/infer/unify.rs
+++ b/crates/hir_ty/src/infer/unify.rs
@@ -127,7 +127,7 @@ where
 }
 
 impl<T> Canonicalized<T> {
-    pub fn decanonicalize_ty(&self, mut ty: Ty) -> Ty {
+    pub(super) fn decanonicalize_ty(&self, mut ty: Ty) -> Ty {
         ty.walk_mut_binders(
             &mut |ty, binders| {
                 if let &mut Ty::Bound(bound) = ty {
@@ -141,7 +141,11 @@ impl<T> Canonicalized<T> {
         ty
     }
 
-    pub fn apply_solution(&self, ctx: &mut InferenceContext<'_>, solution: Canonical<Substs>) {
+    pub(super) fn apply_solution(
+        &self,
+        ctx: &mut InferenceContext<'_>,
+        solution: Canonical<Substs>,
+    ) {
         // the solution may contain new variables, which we need to convert to new inference vars
         let new_vars = Substs(
             solution
@@ -164,7 +168,7 @@ impl<T> Canonicalized<T> {
     }
 }
 
-pub fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
+pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option<Substs> {
     let mut table = InferenceTable::new();
     let vars = Substs(
         tys.kinds
@@ -199,41 +203,46 @@ pub(crate) struct InferenceTable {
 }
 
 impl InferenceTable {
-    pub fn new() -> Self {
+    pub(crate) fn new() -> Self {
         InferenceTable { var_unification_table: InPlaceUnificationTable::new() }
     }
 
-    pub fn new_type_var(&mut self) -> Ty {
+    pub(crate) fn new_type_var(&mut self) -> Ty {
         Ty::Infer(InferTy::TypeVar(self.var_unification_table.new_key(TypeVarValue::Unknown)))
     }
 
-    pub fn new_integer_var(&mut self) -> Ty {
+    pub(crate) fn new_integer_var(&mut self) -> Ty {
         Ty::Infer(InferTy::IntVar(self.var_unification_table.new_key(TypeVarValue::Unknown)))
     }
 
-    pub fn new_float_var(&mut self) -> Ty {
+    pub(crate) fn new_float_var(&mut self) -> Ty {
         Ty::Infer(InferTy::FloatVar(self.var_unification_table.new_key(TypeVarValue::Unknown)))
     }
 
-    pub fn new_maybe_never_type_var(&mut self) -> Ty {
+    pub(crate) fn new_maybe_never_type_var(&mut self) -> Ty {
         Ty::Infer(InferTy::MaybeNeverTypeVar(
             self.var_unification_table.new_key(TypeVarValue::Unknown),
         ))
     }
 
-    pub fn resolve_ty_completely(&mut self, ty: Ty) -> Ty {
+    pub(crate) fn resolve_ty_completely(&mut self, ty: Ty) -> Ty {
         self.resolve_ty_completely_inner(&mut Vec::new(), ty)
     }
 
-    pub fn resolve_ty_as_possible(&mut self, ty: Ty) -> Ty {
+    pub(crate) fn resolve_ty_as_possible(&mut self, ty: Ty) -> Ty {
         self.resolve_ty_as_possible_inner(&mut Vec::new(), ty)
     }
 
-    pub fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool {
+    pub(crate) fn unify(&mut self, ty1: &Ty, ty2: &Ty) -> bool {
         self.unify_inner(ty1, ty2, 0)
     }
 
-    pub fn unify_substs(&mut self, substs1: &Substs, substs2: &Substs, depth: usize) -> bool {
+    pub(crate) fn unify_substs(
+        &mut self,
+        substs1: &Substs,
+        substs2: &Substs,
+        depth: usize,
+    ) -> bool {
         substs1.0.iter().zip(substs2.0.iter()).all(|(t1, t2)| self.unify_inner(t1, t2, depth))
     }
 
@@ -331,7 +340,7 @@ impl InferenceTable {
 
     /// If `ty` is a type variable with known type, returns that type;
     /// otherwise, return ty.
-    pub fn resolve_ty_shallow<'b>(&mut self, ty: &'b Ty) -> Cow<'b, Ty> {
+    pub(crate) fn resolve_ty_shallow<'b>(&mut self, ty: &'b Ty) -> Cow<'b, Ty> {
         let mut ty = Cow::Borrowed(ty);
         // The type variable could resolve to a int/float variable. Hence try
         // resolving up to three times; each type of variable shouldn't occur
diff --git a/crates/hir_ty/src/lib.rs b/crates/hir_ty/src/lib.rs
index 768d95eff..5a8c97198 100644
--- a/crates/hir_ty/src/lib.rs
+++ b/crates/hir_ty/src/lib.rs
@@ -1,6 +1,5 @@
 //! The type system. We currently use this to infer types for completion, hover
 //! information and various assists.
-
 #[allow(unused)]
 macro_rules! eprintln {
     ($($tt:tt)*) => { stdx::eprintln!($($tt)*) };
@@ -1115,5 +1114,5 @@ pub struct ReturnTypeImplTraits {
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 pub(crate) struct ReturnTypeImplTrait {
-    pub bounds: Binders<Vec<GenericPredicate>>,
+    pub(crate) bounds: Binders<Vec<GenericPredicate>>,
 }
diff --git a/crates/hir_ty/src/test_db.rs b/crates/hir_ty/src/test_db.rs
index 15b8435e9..22254b765 100644
--- a/crates/hir_ty/src/test_db.rs
+++ b/crates/hir_ty/src/test_db.rs
@@ -21,7 +21,7 @@ use test_utils::extract_annotations;
     crate::db::HirDatabaseStorage
 )]
 #[derive(Default)]
-pub struct TestDB {
+pub(crate) struct TestDB {
     storage: salsa::Storage<TestDB>,
     events: Mutex<Option<Vec<salsa::Event>>>,
 }
@@ -113,13 +113,13 @@ impl TestDB {
 }
 
 impl TestDB {
-    pub fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event> {
+    pub(crate) fn log(&self, f: impl FnOnce()) -> Vec<salsa::Event> {
         *self.events.lock().unwrap() = Some(Vec::new());
         f();
         self.events.lock().unwrap().take().unwrap()
     }
 
-    pub fn log_executed(&self, f: impl FnOnce()) -> Vec<String> {
+    pub(crate) fn log_executed(&self, f: impl FnOnce()) -> Vec<String> {
         let events = self.log(f);
         events
             .into_iter()
diff --git a/crates/hir_ty/src/traits/chalk/tls.rs b/crates/hir_ty/src/traits/chalk/tls.rs
index 3c9766550..75b16172e 100644
--- a/crates/hir_ty/src/traits/chalk/tls.rs
+++ b/crates/hir_ty/src/traits/chalk/tls.rs
@@ -8,12 +8,12 @@ use super::{from_chalk, Interner, TypeAliasAsAssocType};
 use crate::{db::HirDatabase, CallableDefId};
 use hir_def::{AdtId, AssocContainerId, Lookup, TypeAliasId};
 
-pub use unsafe_tls::{set_current_program, with_current_program};
+pub(crate) use unsafe_tls::{set_current_program, with_current_program};
 
-pub struct DebugContext<'a>(&'a dyn HirDatabase);
+pub(crate) struct DebugContext<'a>(&'a dyn HirDatabase);
 
 impl DebugContext<'_> {
-    pub fn debug_struct_id(
+    pub(crate) fn debug_struct_id(
         &self,
         id: super::AdtId,
         f: &mut fmt::Formatter<'_>,
@@ -26,7 +26,7 @@ impl DebugContext<'_> {
         write!(f, "{}", name)
     }
 
-    pub fn debug_trait_id(
+    pub(crate) fn debug_trait_id(
         &self,
         id: super::TraitId,
         fmt: &mut fmt::Formatter<'_>,
@@ -36,7 +36,7 @@ impl DebugContext<'_> {
         write!(fmt, "{}", trait_data.name)
     }
 
-    pub fn debug_assoc_type_id(
+    pub(crate) fn debug_assoc_type_id(
         &self,
         id: super::AssocTypeId,
         fmt: &mut fmt::Formatter<'_>,
@@ -51,7 +51,7 @@ impl DebugContext<'_> {
         write!(fmt, "{}::{}", trait_data.name, type_alias_data.name)
     }
 
-    pub fn debug_opaque_ty_id(
+    pub(crate) fn debug_opaque_ty_id(
         &self,
         opaque_ty_id: chalk_ir::OpaqueTyId<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -59,7 +59,7 @@ impl DebugContext<'_> {
         fmt.debug_struct("OpaqueTyId").field("index", &opaque_ty_id.0).finish()
     }
 
-    pub fn debug_alias(
+    pub(crate) fn debug_alias(
         &self,
         alias_ty: &AliasTy<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -70,7 +70,7 @@ impl DebugContext<'_> {
         }
     }
 
-    pub fn debug_projection_ty(
+    pub(crate) fn debug_projection_ty(
         &self,
         projection_ty: &chalk_ir::ProjectionTy<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -95,7 +95,7 @@ impl DebugContext<'_> {
         write!(fmt, ">::{}", type_alias_data.name)
     }
 
-    pub fn debug_opaque_ty(
+    pub(crate) fn debug_opaque_ty(
         &self,
         opaque_ty: &chalk_ir::OpaqueTy<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -103,7 +103,7 @@ impl DebugContext<'_> {
         write!(fmt, "{:?}", opaque_ty.opaque_ty_id)
     }
 
-    pub fn debug_ty(
+    pub(crate) fn debug_ty(
         &self,
         ty: &chalk_ir::Ty<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -111,7 +111,7 @@ impl DebugContext<'_> {
         write!(fmt, "{:?}", ty.data(&Interner))
     }
 
-    pub fn debug_lifetime(
+    pub(crate) fn debug_lifetime(
         &self,
         lifetime: &Lifetime<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -119,7 +119,7 @@ impl DebugContext<'_> {
         write!(fmt, "{:?}", lifetime.data(&Interner))
     }
 
-    pub fn debug_generic_arg(
+    pub(crate) fn debug_generic_arg(
         &self,
         parameter: &GenericArg<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -127,7 +127,7 @@ impl DebugContext<'_> {
         write!(fmt, "{:?}", parameter.data(&Interner).inner_debug())
     }
 
-    pub fn debug_goal(
+    pub(crate) fn debug_goal(
         &self,
         goal: &Goal<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -136,7 +136,7 @@ impl DebugContext<'_> {
         write!(fmt, "{:?}", goal_data)
     }
 
-    pub fn debug_goals(
+    pub(crate) fn debug_goals(
         &self,
         goals: &Goals<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -144,7 +144,7 @@ impl DebugContext<'_> {
         write!(fmt, "{:?}", goals.debug(&Interner))
     }
 
-    pub fn debug_program_clause_implication(
+    pub(crate) fn debug_program_clause_implication(
         &self,
         pci: &ProgramClauseImplication<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -152,7 +152,7 @@ impl DebugContext<'_> {
         write!(fmt, "{:?}", pci.debug(&Interner))
     }
 
-    pub fn debug_substitution(
+    pub(crate) fn debug_substitution(
         &self,
         substitution: &chalk_ir::Substitution<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -160,7 +160,7 @@ impl DebugContext<'_> {
         write!(fmt, "{:?}", substitution.debug(&Interner))
     }
 
-    pub fn debug_separator_trait_ref(
+    pub(crate) fn debug_separator_trait_ref(
         &self,
         separator_trait_ref: &chalk_ir::SeparatorTraitRef<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -168,7 +168,7 @@ impl DebugContext<'_> {
         write!(fmt, "{:?}", separator_trait_ref.debug(&Interner))
     }
 
-    pub fn debug_fn_def_id(
+    pub(crate) fn debug_fn_def_id(
         &self,
         fn_def_id: chalk_ir::FnDefId<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -190,7 +190,7 @@ impl DebugContext<'_> {
         }
     }
 
-    pub fn debug_const(
+    pub(crate) fn debug_const(
         &self,
         _constant: &chalk_ir::Const<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -198,42 +198,42 @@ impl DebugContext<'_> {
         write!(fmt, "const")
     }
 
-    pub fn debug_variable_kinds(
+    pub(crate) fn debug_variable_kinds(
         &self,
         variable_kinds: &chalk_ir::VariableKinds<Interner>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> fmt::Result {
         write!(fmt, "{:?}", variable_kinds.as_slice(&Interner))
     }
-    pub fn debug_variable_kinds_with_angles(
+    pub(crate) fn debug_variable_kinds_with_angles(
         &self,
         variable_kinds: &chalk_ir::VariableKinds<Interner>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> fmt::Result {
         write!(fmt, "{:?}", variable_kinds.inner_debug(&Interner))
     }
-    pub fn debug_canonical_var_kinds(
+    pub(crate) fn debug_canonical_var_kinds(
         &self,
         canonical_var_kinds: &chalk_ir::CanonicalVarKinds<Interner>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> fmt::Result {
         write!(fmt, "{:?}", canonical_var_kinds.as_slice(&Interner))
     }
-    pub fn debug_program_clause(
+    pub(crate) fn debug_program_clause(
         &self,
         clause: &chalk_ir::ProgramClause<Interner>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> fmt::Result {
         write!(fmt, "{:?}", clause.data(&Interner))
     }
-    pub fn debug_program_clauses(
+    pub(crate) fn debug_program_clauses(
         &self,
         clauses: &chalk_ir::ProgramClauses<Interner>,
         fmt: &mut fmt::Formatter<'_>,
     ) -> fmt::Result {
         write!(fmt, "{:?}", clauses.as_slice(&Interner))
     }
-    pub fn debug_quantified_where_clauses(
+    pub(crate) fn debug_quantified_where_clauses(
         &self,
         clauses: &chalk_ir::QuantifiedWhereClauses<Interner>,
         fmt: &mut fmt::Formatter<'_>,
@@ -249,7 +249,7 @@ mod unsafe_tls {
 
     scoped_thread_local!(static PROGRAM: DebugContext);
 
-    pub fn with_current_program<R>(
+    pub(crate) fn with_current_program<R>(
         op: impl for<'a> FnOnce(Option<&'a DebugContext<'a>>) -> R,
     ) -> R {
         if PROGRAM.is_set() {
@@ -259,7 +259,7 @@ mod unsafe_tls {
         }
     }
 
-    pub fn set_current_program<OP, R>(p: &dyn HirDatabase, op: OP) -> R
+    pub(crate) fn set_current_program<OP, R>(p: &dyn HirDatabase, op: OP) -> R
     where
         OP: FnOnce() -> R,
     {