From b6101184537b1165cfdd5fc473e04ad4c5b7bffa Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Mon, 2 Nov 2020 13:13:32 +0100 Subject: Deny unreachable-pub It's very useful when `pub` is equivalent to "this is crate's public API", let's enforce this! Ideally, we should enforce it for local `cargo test`, and only during CI, but that needs https://github.com/rust-lang/cargo/issues/5034. --- .../hir_ty/src/diagnostics/decl_check/case_conv.rs | 6 +-- crates/hir_ty/src/diagnostics/expr.rs | 15 ++---- crates/hir_ty/src/diagnostics/unsafe_check.rs | 8 ++-- crates/hir_ty/src/infer.rs | 6 +-- crates/hir_ty/src/infer/expr.rs | 2 +- crates/hir_ty/src/infer/unify.rs | 35 ++++++++------ crates/hir_ty/src/lib.rs | 3 +- crates/hir_ty/src/test_db.rs | 6 +-- crates/hir_ty/src/traits/chalk/tls.rs | 54 +++++++++++----------- 9 files changed, 68 insertions(+), 67 deletions(-) (limited to 'crates/hir_ty') 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 { +pub(crate) fn to_camel_case(ident: &str) -> Option { if is_camel_case(ident) { return None; } @@ -59,7 +59,7 @@ pub fn to_camel_case(ident: &str) -> Option { /// 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 { +pub(crate) fn to_lower_snake_case(ident: &str) -> Option { 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 { /// 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 { +pub(crate) fn to_upper_snake_case(ident: &str) -> Option { 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, + may_break: bool, + break_ty: Ty, + label: Option, } 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)> { + pub(crate) fn callable_sig(&mut self, ty: &Ty, num_args: usize) -> Option<(Vec, 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 Canonicalized { - 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 Canonicalized { ty } - pub fn apply_solution(&self, ctx: &mut InferenceContext<'_>, solution: Canonical) { + pub(super) fn apply_solution( + &self, + ctx: &mut InferenceContext<'_>, + solution: Canonical, + ) { // 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 Canonicalized { } } -pub fn unify(tys: &Canonical<(Ty, Ty)>) -> Option { +pub(crate) fn unify(tys: &Canonical<(Ty, Ty)>) -> Option { 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>, + pub(crate) bounds: Binders>, } 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, events: Mutex>>, } @@ -113,13 +113,13 @@ impl TestDB { } impl TestDB { - pub fn log(&self, f: impl FnOnce()) -> Vec { + pub(crate) fn log(&self, f: impl FnOnce()) -> Vec { *self.events.lock().unwrap() = Some(Vec::new()); f(); self.events.lock().unwrap().take().unwrap() } - pub fn log_executed(&self, f: impl FnOnce()) -> Vec { + pub(crate) fn log_executed(&self, f: impl FnOnce()) -> Vec { 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, fmt: &mut fmt::Formatter<'_>, @@ -190,7 +190,7 @@ impl DebugContext<'_> { } } - pub fn debug_const( + pub(crate) fn debug_const( &self, _constant: &chalk_ir::Const, 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, 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, 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, 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, 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, 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, fmt: &mut fmt::Formatter<'_>, @@ -249,7 +249,7 @@ mod unsafe_tls { scoped_thread_local!(static PROGRAM: DebugContext); - pub fn with_current_program( + pub(crate) fn with_current_program( 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(p: &dyn HirDatabase, op: OP) -> R + pub(crate) fn set_current_program(p: &dyn HirDatabase, op: OP) -> R where OP: FnOnce() -> R, { -- cgit v1.2.3