|
| 1 | +use clippy_config::Conf; |
| 2 | +use clippy_config::types::{DisallowedPath, create_disallowed_map}; |
| 3 | +use clippy_utils::diagnostics::span_lint_and_then; |
| 4 | +use clippy_utils::paths::PathNS; |
| 5 | +use clippy_utils::ty::get_field_def_id_by_name; |
| 6 | +use rustc_hir::def::{DefKind, Res}; |
| 7 | +use rustc_hir::def_id::DefIdMap; |
| 8 | +use rustc_hir::{Expr, ExprKind, Pat, PatKind}; |
| 9 | +use rustc_lint::{LateContext, LateLintPass}; |
| 10 | +use rustc_middle::ty::TyCtxt; |
| 11 | +use rustc_session::impl_lint_pass; |
| 12 | + |
| 13 | +declare_clippy_lint! { |
| 14 | + /// ### What it does |
| 15 | + /// Denies the configured fields in clippy.toml |
| 16 | + /// |
| 17 | + /// Note: Even though this lint is warn-by-default, it will only trigger if |
| 18 | + /// fields are defined in the clippy.toml file. |
| 19 | + /// |
| 20 | + /// ### Why is this bad? |
| 21 | + /// Some fields are undesirable in certain contexts, and it's beneficial to |
| 22 | + /// lint for them as needed. |
| 23 | + /// |
| 24 | + /// ### Example |
| 25 | + /// An example clippy.toml configuration: |
| 26 | + /// ```toml |
| 27 | + /// # clippy.toml |
| 28 | + /// disallowed-fields = [ |
| 29 | + /// # Can use a string as the path of the disallowed field. |
| 30 | + /// "std::ops::Range::start", |
| 31 | + /// # Can also use an inline table with a `path` key. |
| 32 | + /// { path = "std::ops::Range::start" }, |
| 33 | + /// # When using an inline table, can add a `reason` for why the field |
| 34 | + /// # is disallowed. |
| 35 | + /// { path = "std::ops::Range::start", reason = "The start of the range is not used" }, |
| 36 | + /// ] |
| 37 | + /// ``` |
| 38 | + /// |
| 39 | + /// ```rust |
| 40 | + /// use std::ops::Range; |
| 41 | + /// |
| 42 | + /// let range = Range { start: 0, end: 1 }; |
| 43 | + /// println!("{}", range.start); // `start` is disallowed in the config. |
| 44 | + /// ``` |
| 45 | + /// |
| 46 | + /// Use instead: |
| 47 | + /// ```rust |
| 48 | + /// use std::ops::Range; |
| 49 | + /// |
| 50 | + /// let range = Range { start: 0, end: 1 }; |
| 51 | + /// println!("{}", range.end); // `end` is _not_ disallowed in the config. |
| 52 | + /// ``` |
| 53 | + #[clippy::version = "1.93.0"] |
| 54 | + pub DISALLOWED_FIELDS, |
| 55 | + style, |
| 56 | + "declaration of a disallowed field use" |
| 57 | +} |
| 58 | + |
| 59 | +pub struct DisallowedFields { |
| 60 | + disallowed: DefIdMap<(&'static str, &'static DisallowedPath)>, |
| 61 | +} |
| 62 | + |
| 63 | +impl DisallowedFields { |
| 64 | + pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self { |
| 65 | + let (disallowed, _) = create_disallowed_map( |
| 66 | + tcx, |
| 67 | + &conf.disallowed_fields, |
| 68 | + PathNS::Field, |
| 69 | + |def_kind| matches!(def_kind, DefKind::Field), |
| 70 | + "field", |
| 71 | + false, |
| 72 | + ); |
| 73 | + Self { disallowed } |
| 74 | + } |
| 75 | +} |
| 76 | + |
| 77 | +impl_lint_pass!(DisallowedFields => [DISALLOWED_FIELDS]); |
| 78 | + |
| 79 | +impl<'tcx> LateLintPass<'tcx> for DisallowedFields { |
| 80 | + fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) { |
| 81 | + let (id, span) = match &expr.kind { |
| 82 | + ExprKind::Path(path) if let Res::Def(_, id) = cx.qpath_res(path, expr.hir_id) => (id, expr.span), |
| 83 | + ExprKind::Field(e, ident) => { |
| 84 | + // Very round-about way to get the field `DefId` from the expr: first we get its |
| 85 | + // parent `Ty`. Then we go through all its fields to find the one with the expected |
| 86 | + // name and get the `DefId` from it. |
| 87 | + if let Some(parent_ty) = cx.typeck_results().expr_ty_adjusted_opt(e) |
| 88 | + && let Some(field_def_id) = get_field_def_id_by_name(parent_ty, ident.name) |
| 89 | + { |
| 90 | + (field_def_id, ident.span) |
| 91 | + } else { |
| 92 | + return; |
| 93 | + } |
| 94 | + }, |
| 95 | + _ => return, |
| 96 | + }; |
| 97 | + if let Some(&(path, disallowed_path)) = self.disallowed.get(&id) { |
| 98 | + span_lint_and_then( |
| 99 | + cx, |
| 100 | + DISALLOWED_FIELDS, |
| 101 | + span, |
| 102 | + format!("use of a disallowed field `{path}`"), |
| 103 | + disallowed_path.diag_amendment(span), |
| 104 | + ); |
| 105 | + } |
| 106 | + } |
| 107 | + |
| 108 | + fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) { |
| 109 | + let PatKind::Struct(struct_path, pat_fields, _) = pat.kind else { |
| 110 | + return; |
| 111 | + }; |
| 112 | + match cx.typeck_results().qpath_res(&struct_path, pat.hir_id) { |
| 113 | + Res::Def(DefKind::Struct, struct_def_id) => { |
| 114 | + let adt_def = cx.tcx.adt_def(struct_def_id); |
| 115 | + for field in pat_fields { |
| 116 | + if let Some(def_id) = adt_def.all_fields().find_map(|adt_field| { |
| 117 | + if field.ident.name == adt_field.name { |
| 118 | + Some(adt_field.did) |
| 119 | + } else { |
| 120 | + None |
| 121 | + } |
| 122 | + }) && let Some(&(path, disallowed_path)) = self.disallowed.get(&def_id) |
| 123 | + { |
| 124 | + span_lint_and_then( |
| 125 | + cx, |
| 126 | + DISALLOWED_FIELDS, |
| 127 | + field.span, |
| 128 | + format!("use of a disallowed field `{path}`"), |
| 129 | + disallowed_path.diag_amendment(field.span), |
| 130 | + ); |
| 131 | + } |
| 132 | + } |
| 133 | + }, |
| 134 | + Res::Def(DefKind::Variant, variant_def_id) => { |
| 135 | + let enum_def_id = cx.tcx.parent(variant_def_id); |
| 136 | + let variant = cx.tcx.adt_def(enum_def_id).variant_with_id(variant_def_id); |
| 137 | + |
| 138 | + for field in pat_fields { |
| 139 | + if let Some(def_id) = variant.fields.iter().find_map(|adt_field| { |
| 140 | + if field.ident.name == adt_field.name { |
| 141 | + Some(adt_field.did) |
| 142 | + } else { |
| 143 | + None |
| 144 | + } |
| 145 | + }) && let Some(&(path, disallowed_path)) = self.disallowed.get(&def_id) |
| 146 | + { |
| 147 | + span_lint_and_then( |
| 148 | + cx, |
| 149 | + DISALLOWED_FIELDS, |
| 150 | + field.span, |
| 151 | + format!("use of a disallowed field `{path}`"), |
| 152 | + disallowed_path.diag_amendment(field.span), |
| 153 | + ); |
| 154 | + } |
| 155 | + } |
| 156 | + }, |
| 157 | + _ => {}, |
| 158 | + } |
| 159 | + } |
| 160 | +} |
0 commit comments