compiler/rustc_incremental/src/persist/dirty_clean.rs

   1 //! Debugging code to test fingerprints computed for query results.
   2 //! For each node marked with `#[rustc_clean]` or `#[rustc_dirty]`,
   3 //! we will compare the fingerprint from the current and from the previous
   4 //! compilation session as appropriate:
   5 //!
   6 //! - `#[rustc_clean(cfg="rev2", except="typeck")]` if we are
   7 //!   in `#[cfg(rev2)]`, then the fingerprints associated with
   8 //!   `DepNode::typeck(X)` must be DIFFERENT (`X` is the `DefId` of the
   9 //!   current node).
  10 //! - `#[rustc_clean(cfg="rev2")]` same as above, except that the
  11 //!   fingerprints must be the SAME (along with all other fingerprints).
  12 //!
  13 //! Errors are reported if we are in the suitable configuration but
  14 //! the required condition is not met.
  15
  16 use rustc_ast::{self as ast, Attribute, NestedMetaItem};
  17 use rustc_data_structures::fingerprint::Fingerprint;
  18 use rustc_data_structures::fx::FxHashSet;
  19 use rustc_hir as hir;
  20 use rustc_hir::def_id::{DefId, LocalDefId};
  21 use rustc_hir::intravisit;
  22 use rustc_hir::itemlikevisit::ItemLikeVisitor;
  23 use rustc_hir::Node as HirNode;
  24 use rustc_hir::{ImplItemKind, ItemKind as HirItem, TraitItemKind};
  25 use rustc_middle::dep_graph::{label_strs, DepNode, DepNodeExt};
  26 use rustc_middle::hir::map::Map;
  27 use rustc_middle::ty::TyCtxt;
  28 use rustc_span::symbol::{sym, Symbol};
  29 use rustc_span::Span;
  30 use std::iter::FromIterator;
  31 use std::vec::Vec;
  32
  33 const EXCEPT: Symbol = sym::except;
  34 const LABEL: Symbol = sym::label;
  35 const CFG: Symbol = sym::cfg;
  36
  37 // Base and Extra labels to build up the labels
  38
  39 /// For typedef, constants, and statics
  40 const BASE_CONST: &[&str] = &[label_strs::type_of];
  41
  42 /// DepNodes for functions + methods
  43 const BASE_FN: &[&str] = &[
  44     // Callers will depend on the signature of these items, so we better test
  45     label_strs::fn_sig,
  46     label_strs::generics_of,
  47     label_strs::predicates_of,
  48     label_strs::type_of,
  49     // And a big part of compilation (that we eventually want to cache) is type inference
  50     // information:
  51     label_strs::typeck,
  52 ];
  53
  54 /// DepNodes for Hir, which is pretty much everything
  55 const BASE_HIR: &[&str] = &[
  56     // hir_owner and hir_owner_nodes should be computed for all nodes
  57     label_strs::hir_owner,
  58     label_strs::hir_owner_nodes,
  59 ];
  60
  61 /// `impl` implementation of struct/trait
  62 const BASE_IMPL: &[&str] =
  63     &[label_strs::associated_item_def_ids, label_strs::generics_of, label_strs::impl_trait_ref];
  64
  65 /// DepNodes for mir_built/Optimized, which is relevant in "executable"
  66 /// code, i.e., functions+methods
  67 const BASE_MIR: &[&str] = &[label_strs::optimized_mir, label_strs::promoted_mir];
  68
  69 /// Struct, Enum and Union DepNodes
  70 ///
  71 /// Note that changing the type of a field does not change the type of the struct or enum, but
  72 /// adding/removing fields or changing a fields name or visibility does.
  73 const BASE_STRUCT: &[&str] =
  74     &[label_strs::generics_of, label_strs::predicates_of, label_strs::type_of];
  75
  76 /// Trait definition `DepNode`s.
  77 const BASE_TRAIT_DEF: &[&str] = &[
  78     label_strs::associated_item_def_ids,
  79     label_strs::generics_of,
  80     label_strs::object_safety_violations,
  81     label_strs::predicates_of,
  82     label_strs::specialization_graph_of,
  83     label_strs::trait_def,
  84     label_strs::trait_impls_of,
  85 ];
  86
  87 /// Extra `DepNode`s for functions and methods.
  88 const EXTRA_ASSOCIATED: &[&str] = &[label_strs::associated_item];
  89
  90 const EXTRA_TRAIT: &[&str] = &[label_strs::trait_of_item];
  91
  92 // Fully Built Labels
  93
  94 const LABELS_CONST: &[&[&str]] = &[BASE_HIR, BASE_CONST];
  95
  96 /// Constant/Typedef in an impl
  97 const LABELS_CONST_IN_IMPL: &[&[&str]] = &[BASE_HIR, BASE_CONST, EXTRA_ASSOCIATED];
  98
  99 /// Trait-Const/Typedef DepNodes
 100 const LABELS_CONST_IN_TRAIT: &[&[&str]] = &[BASE_HIR, BASE_CONST, EXTRA_ASSOCIATED, EXTRA_TRAIT];
 101
 102 /// Function `DepNode`s.
 103 const LABELS_FN: &[&[&str]] = &[BASE_HIR, BASE_MIR, BASE_FN];
 104
 105 /// Method `DepNode`s.
 106 const LABELS_FN_IN_IMPL: &[&[&str]] = &[BASE_HIR, BASE_MIR, BASE_FN, EXTRA_ASSOCIATED];
 107
 108 /// Trait method `DepNode`s.
 109 const LABELS_FN_IN_TRAIT: &[&[&str]] =
 110     &[BASE_HIR, BASE_MIR, BASE_FN, EXTRA_ASSOCIATED, EXTRA_TRAIT];
 111
 112 /// For generic cases like inline-assembly, modules, etc.
 113 const LABELS_HIR_ONLY: &[&[&str]] = &[BASE_HIR];
 114
 115 /// Impl `DepNode`s.
 116 const LABELS_IMPL: &[&[&str]] = &[BASE_HIR, BASE_IMPL];
 117
 118 /// Abstract data type (struct, enum, union) `DepNode`s.
 119 const LABELS_ADT: &[&[&str]] = &[BASE_HIR, BASE_STRUCT];
 120
 121 /// Trait definition `DepNode`s.
 122 #[allow(dead_code)]
 123 const LABELS_TRAIT: &[&[&str]] = &[BASE_HIR, BASE_TRAIT_DEF];
 124
 125 // FIXME: Struct/Enum/Unions Fields (there is currently no way to attach these)
 126 //
 127 // Fields are kind of separate from their containers, as they can change independently from
 128 // them. We should at least check
 129 //
 130 //     type_of for these.
 131
 132 type Labels = FxHashSet<String>;
 133
 134 /// Represents the requested configuration by rustc_clean/dirty
 135 struct Assertion {
 136     clean: Labels,
 137     dirty: Labels,
 138 }
 139
 140 impl Assertion {
 141     fn from_clean_labels(labels: Labels) -> Assertion {
 142         Assertion { clean: labels, dirty: Labels::default() }
 143     }
 144
 145     fn from_dirty_labels(labels: Labels) -> Assertion {
 146         Assertion { clean: Labels::default(), dirty: labels }
 147     }
 148 }
 149
 150 pub fn check_dirty_clean_annotations(tcx: TyCtxt<'_>) {
 151     // can't add `#[rustc_dirty]` etc without opting in to this feature
 152     if !tcx.features().rustc_attrs {
 153         return;
 154     }
 155
 156     tcx.dep_graph.with_ignore(|| {
 157         let krate = tcx.hir().krate();
 158         let mut dirty_clean_visitor = DirtyCleanVisitor { tcx, checked_attrs: Default::default() };
 159         krate.visit_all_item_likes(&mut dirty_clean_visitor);
 160
 161         let mut all_attrs = FindAllAttrs {
 162             tcx,
 163             attr_names: &[sym::rustc_dirty, sym::rustc_clean],
 164             found_attrs: vec![],
 165         };
 166         intravisit::walk_crate(&mut all_attrs, krate);
 167
 168         // Note that we cannot use the existing "unused attribute"-infrastructure
 169         // here, since that is running before codegen. This is also the reason why
 170         // all codegen-specific attributes are `AssumedUsed` in rustc_ast::feature_gate.
 171         all_attrs.report_unchecked_attrs(&dirty_clean_visitor.checked_attrs);
 172     })
 173 }
 174
 175 pub struct DirtyCleanVisitor<'tcx> {
 176     tcx: TyCtxt<'tcx>,
 177     checked_attrs: FxHashSet<ast::AttrId>,
 178 }
 179
 180 impl DirtyCleanVisitor<'tcx> {
 181     /// Possibly "deserialize" the attribute into a clean/dirty assertion
 182     fn assertion_maybe(&mut self, item_id: LocalDefId, attr: &Attribute) -> Option<Assertion> {
 183         let is_clean = if self.tcx.sess.check_name(attr, sym::rustc_dirty) {
 184             false
 185         } else if self.tcx.sess.check_name(attr, sym::rustc_clean) {
 186             true
 187         } else {
 188             // skip: not rustc_clean/dirty
 189             return None;
 190         };
 191         if !check_config(self.tcx, attr) {
 192             // skip: not the correct `cfg=`
 193             return None;
 194         }
 195         let assertion = if let Some(labels) = self.labels(attr) {
 196             if is_clean {
 197                 Assertion::from_clean_labels(labels)
 198             } else {
 199                 Assertion::from_dirty_labels(labels)
 200             }
 201         } else {
 202             self.assertion_auto(item_id, attr, is_clean)
 203         };
 204         Some(assertion)
 205     }
 206
 207     /// Gets the "auto" assertion on pre-validated attr, along with the `except` labels.
 208     fn assertion_auto(
 209         &mut self,
 210         item_id: LocalDefId,
 211         attr: &Attribute,
 212         is_clean: bool,
 213     ) -> Assertion {
 214         let (name, mut auto) = self.auto_labels(item_id, attr);
 215         let except = self.except(attr);
 216         for e in except.iter() {
 217             if !auto.remove(e) {
 218                 let msg = format!(
 219                     "`except` specified DepNodes that can not be affected for \"{}\": \"{}\"",
 220                     name, e
 221                 );
 222                 self.tcx.sess.span_fatal(attr.span, &msg);
 223             }
 224         }
 225         if is_clean {
 226             Assertion { clean: auto, dirty: except }
 227         } else {
 228             Assertion { clean: except, dirty: auto }
 229         }
 230     }
 231
 232     fn labels(&self, attr: &Attribute) -> Option<Labels> {
 233         for item in attr.meta_item_list().unwrap_or_else(Vec::new) {
 234             if item.has_name(LABEL) {
 235                 let value = expect_associated_value(self.tcx, &item);
 236                 return Some(self.resolve_labels(&item, value));
 237             }
 238         }
 239         None
 240     }
 241
 242     /// `except=` attribute value
 243     fn except(&self, attr: &Attribute) -> Labels {
 244         for item in attr.meta_item_list().unwrap_or_else(Vec::new) {
 245             if item.has_name(EXCEPT) {
 246                 let value = expect_associated_value(self.tcx, &item);
 247                 return self.resolve_labels(&item, value);
 248             }
 249         }
 250         // if no `label` or `except` is given, only the node's group are asserted
 251         Labels::default()
 252     }
 253
 254     /// Return all DepNode labels that should be asserted for this item.
 255     /// index=0 is the "name" used for error messages
 256     fn auto_labels(&mut self, item_id: LocalDefId, attr: &Attribute) -> (&'static str, Labels) {
 257         let hir_id = self.tcx.hir().local_def_id_to_hir_id(item_id);
 258         let node = self.tcx.hir().get(hir_id);
 259         let (name, labels) = match node {
 260             HirNode::Item(item) => {
 261                 match item.kind {
 262                     // note: these are in the same order as hir::Item_;
 263                     // FIXME(michaelwoerister): do commented out ones
 264
 265                     // // An `extern crate` item, with optional original crate name,
 266                     // HirItem::ExternCrate(..),  // intentionally no assertions
 267
 268                     // // `use foo::bar::*;` or `use foo::bar::baz as quux;`
 269                     // HirItem::Use(..),  // intentionally no assertions
 270
 271                     // A `static` item
 272                     HirItem::Static(..) => ("ItemStatic", LABELS_CONST),
 273
 274                     // A `const` item
 275                     HirItem::Const(..) => ("ItemConst", LABELS_CONST),
 276
 277                     // A function declaration
 278                     HirItem::Fn(..) => ("ItemFn", LABELS_FN),
 279
 280                     // // A module
 281                     HirItem::Mod(..) => ("ItemMod", LABELS_HIR_ONLY),
 282
 283                     // // An external module
 284                     HirItem::ForeignMod { .. } => ("ItemForeignMod", LABELS_HIR_ONLY),
 285
 286                     // Module-level inline assembly (from global_asm!)
 287                     HirItem::GlobalAsm(..) => ("ItemGlobalAsm", LABELS_HIR_ONLY),
 288
 289                     // A type alias, e.g., `type Foo = Bar<u8>`
 290                     HirItem::TyAlias(..) => ("ItemTy", LABELS_HIR_ONLY),
 291
 292                     // An enum definition, e.g., `enum Foo<A, B> {C<A>, D<B>}`
 293                     HirItem::Enum(..) => ("ItemEnum", LABELS_ADT),
 294
 295                     // A struct definition, e.g., `struct Foo<A> {x: A}`
 296                     HirItem::Struct(..) => ("ItemStruct", LABELS_ADT),
 297
 298                     // A union definition, e.g., `union Foo<A, B> {x: A, y: B}`
 299                     HirItem::Union(..) => ("ItemUnion", LABELS_ADT),
 300
 301                     // Represents a Trait Declaration
 302                     // FIXME(michaelwoerister): trait declaration is buggy because sometimes some of
 303                     // the depnodes don't exist (because they legitimately didn't need to be
 304                     // calculated)
 305                     //
 306                     // michaelwoerister and vitiral came up with a possible solution,
 307                     // to just do this before every query
 308                     // ```
 309                     // ::rustc_middle::ty::query::plumbing::force_from_dep_node(tcx, dep_node)
 310                     // ```
 311                     //
 312                     // However, this did not seem to work effectively and more bugs were hit.
 313                     // Nebie @vitiral gave up :)
 314                     //
 315                     //HirItem::Trait(..) => ("ItemTrait", LABELS_TRAIT),
 316
 317                     // An implementation, eg `impl<A> Trait for Foo { .. }`
 318                     HirItem::Impl { .. } => ("ItemKind::Impl", LABELS_IMPL),
 319
 320                     _ => self.tcx.sess.span_fatal(
 321                         attr.span,
 322                         &format!(
 323                             "clean/dirty auto-assertions not yet defined \
 324                              for Node::Item.node={:?}",
 325                             item.kind
 326                         ),
 327                     ),
 328                 }
 329             }
 330             HirNode::TraitItem(item) => match item.kind {
 331                 TraitItemKind::Fn(..) => ("Node::TraitItem", LABELS_FN_IN_TRAIT),
 332                 TraitItemKind::Const(..) => ("NodeTraitConst", LABELS_CONST_IN_TRAIT),
 333                 TraitItemKind::Type(..) => ("NodeTraitType", LABELS_CONST_IN_TRAIT),
 334             },
 335             HirNode::ImplItem(item) => match item.kind {
 336                 ImplItemKind::Fn(..) => ("Node::ImplItem", LABELS_FN_IN_IMPL),
 337                 ImplItemKind::Const(..) => ("NodeImplConst", LABELS_CONST_IN_IMPL),
 338                 ImplItemKind::TyAlias(..) => ("NodeImplType", LABELS_CONST_IN_IMPL),
 339             },
 340             _ => self.tcx.sess.span_fatal(
 341                 attr.span,
 342                 &format!("clean/dirty auto-assertions not yet defined for {:?}", node),
 343             ),
 344         };
 345         let labels =
 346             Labels::from_iter(labels.iter().flat_map(|s| s.iter().map(|l| (*l).to_string())));
 347         (name, labels)
 348     }
 349
 350     fn resolve_labels(&self, item: &NestedMetaItem, value: Symbol) -> Labels {
 351         let mut out = Labels::default();
 352         for label in value.as_str().split(',') {
 353             let label = label.trim();
 354             if DepNode::has_label_string(label) {
 355                 if out.contains(label) {
 356                     self.tcx.sess.span_fatal(
 357                         item.span(),
 358                         &format!("dep-node label `{}` is repeated", label),
 359                     );
 360                 }
 361                 out.insert(label.to_string());
 362             } else {
 363                 self.tcx
 364                     .sess
 365                     .span_fatal(item.span(), &format!("dep-node label `{}` not recognized", label));
 366             }
 367         }
 368         out
 369     }
 370
 371     fn dep_nodes<'l>(
 372         &self,
 373         labels: &'l Labels,
 374         def_id: DefId,
 375     ) -> impl Iterator<Item = DepNode> + 'l {
 376         let def_path_hash = self.tcx.def_path_hash(def_id);
 377         labels.iter().map(move |label| match DepNode::from_label_string(label, def_path_hash) {
 378             Ok(dep_node) => dep_node,
 379             Err(()) => unreachable!("label: {}", label),
 380         })
 381     }
 382
 383     fn dep_node_str(&self, dep_node: &DepNode) -> String {
 384         if let Some(def_id) = dep_node.extract_def_id(self.tcx) {
 385             format!("{:?}({})", dep_node.kind, self.tcx.def_path_str(def_id))
 386         } else {
 387             format!("{:?}({:?})", dep_node.kind, dep_node.hash)
 388         }
 389     }
 390
 391     fn assert_dirty(&self, item_span: Span, dep_node: DepNode) {
 392         debug!("assert_dirty({:?})", dep_node);
 393
 394         let current_fingerprint = self.get_fingerprint(&dep_node);
 395         let prev_fingerprint = self.tcx.dep_graph.prev_fingerprint_of(&dep_node);
 396
 397         if current_fingerprint == prev_fingerprint {
 398             let dep_node_str = self.dep_node_str(&dep_node);
 399             self.tcx
 400                 .sess
 401                 .span_err(item_span, &format!("`{}` should be dirty but is not", dep_node_str));
 402         }
 403     }
 404
 405     fn get_fingerprint(&self, dep_node: &DepNode) -> Option<Fingerprint> {
 406         if self.tcx.dep_graph.dep_node_exists(dep_node) {
 407             let dep_node_index = self.tcx.dep_graph.dep_node_index_of(dep_node);
 408             Some(self.tcx.dep_graph.fingerprint_of(dep_node_index))
 409         } else {
 410             None
 411         }
 412     }
 413
 414     fn assert_clean(&self, item_span: Span, dep_node: DepNode) {
 415         debug!("assert_clean({:?})", dep_node);
 416
 417         let current_fingerprint = self.get_fingerprint(&dep_node);
 418         let prev_fingerprint = self.tcx.dep_graph.prev_fingerprint_of(&dep_node);
 419
 420         // if the node wasn't previously evaluated and now is (or vice versa),
 421         // then the node isn't actually clean or dirty.
 422         if (current_fingerprint == None) ^ (prev_fingerprint == None) {
 423             return;
 424         }
 425
 426         if current_fingerprint != prev_fingerprint {
 427             let dep_node_str = self.dep_node_str(&dep_node);
 428             self.tcx
 429                 .sess
 430                 .span_err(item_span, &format!("`{}` should be clean but is not", dep_node_str));
 431         }
 432     }
 433
 434     fn check_item(&mut self, item_id: LocalDefId, item_span: Span) {
 435         for attr in self.tcx.get_attrs(item_id.to_def_id()).iter() {
 436             let assertion = match self.assertion_maybe(item_id, attr) {
 437                 Some(a) => a,
 438                 None => continue,
 439             };
 440             self.checked_attrs.insert(attr.id);
 441             for dep_node in self.dep_nodes(&assertion.clean, item_id.to_def_id()) {
 442                 self.assert_clean(item_span, dep_node);
 443             }
 444             for dep_node in self.dep_nodes(&assertion.dirty, item_id.to_def_id()) {
 445                 self.assert_dirty(item_span, dep_node);
 446             }
 447         }
 448     }
 449 }
 450
 451 impl ItemLikeVisitor<'tcx> for DirtyCleanVisitor<'tcx> {
 452     fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
 453         self.check_item(item.def_id, item.span);
 454     }
 455
 456     fn visit_trait_item(&mut self, item: &hir::TraitItem<'_>) {
 457         self.check_item(item.def_id, item.span);
 458     }
 459
 460     fn visit_impl_item(&mut self, item: &hir::ImplItem<'_>) {
 461         self.check_item(item.def_id, item.span);
 462     }
 463
 464     fn visit_foreign_item(&mut self, item: &hir::ForeignItem<'_>) {
 465         self.check_item(item.def_id, item.span);
 466     }
 467 }
 468
 469 /// Given a `#[rustc_dirty]` or `#[rustc_clean]` attribute, scan
 470 /// for a `cfg="foo"` attribute and check whether we have a cfg
 471 /// flag called `foo`.
 472 ///
 473 /// Also make sure that the `label` and `except` fields do not
 474 /// both exist.
 475 fn check_config(tcx: TyCtxt<'_>, attr: &Attribute) -> bool {
 476     debug!("check_config(attr={:?})", attr);
 477     let config = &tcx.sess.parse_sess.config;
 478     debug!("check_config: config={:?}", config);
 479     let (mut cfg, mut except, mut label) = (None, false, false);
 480     for item in attr.meta_item_list().unwrap_or_else(Vec::new) {
 481         if item.has_name(CFG) {
 482             let value = expect_associated_value(tcx, &item);
 483             debug!("check_config: searching for cfg {:?}", value);
 484             cfg = Some(config.contains(&(value, None)));
 485         }
 486         if item.has_name(LABEL) {
 487             label = true;
 488         }
 489         if item.has_name(EXCEPT) {
 490             except = true;
 491         }
 492     }
 493
 494     if label && except {
 495         tcx.sess.span_fatal(attr.span, "must specify only one of: `label`, `except`");
 496     }
 497
 498     match cfg {
 499         None => tcx.sess.span_fatal(attr.span, "no cfg attribute"),
 500         Some(c) => c,
 501     }
 502 }
 503
 504 fn expect_associated_value(tcx: TyCtxt<'_>, item: &NestedMetaItem) -> Symbol {
 505     if let Some(value) = item.value_str() {
 506         value
 507     } else {
 508         let msg = if let Some(ident) = item.ident() {
 509             format!("associated value expected for `{}`", ident)
 510         } else {
 511             "expected an associated value".to_string()
 512         };
 513
 514         tcx.sess.span_fatal(item.span(), &msg);
 515     }
 516 }
 517
 518 // A visitor that collects all #[rustc_dirty]/#[rustc_clean] attributes from
 519 // the HIR. It is used to verify that we really ran checks for all annotated
 520 // nodes.
 521 pub struct FindAllAttrs<'a, 'tcx> {
 522     tcx: TyCtxt<'tcx>,
 523     attr_names: &'a [Symbol],
 524     found_attrs: Vec<&'tcx Attribute>,
 525 }
 526
 527 impl FindAllAttrs<'_, 'tcx> {
 528     fn is_active_attr(&mut self, attr: &Attribute) -> bool {
 529         for attr_name in self.attr_names {
 530             if self.tcx.sess.check_name(attr, *attr_name) && check_config(self.tcx, attr) {
 531                 return true;
 532             }
 533         }
 534
 535         false
 536     }
 537
 538     fn report_unchecked_attrs(&self, checked_attrs: &FxHashSet<ast::AttrId>) {
 539         for attr in &self.found_attrs {
 540             if !checked_attrs.contains(&attr.id) {
 541                 self.tcx.sess.span_err(
 542                     attr.span,
 543                     "found unchecked `#[rustc_dirty]` / `#[rustc_clean]` attribute",
 544                 );
 545             }
 546         }
 547     }
 548 }
 549
 550 impl intravisit::Visitor<'tcx> for FindAllAttrs<'_, 'tcx> {
 551     type Map = Map<'tcx>;
 552
 553     fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
 554         intravisit::NestedVisitorMap::All(self.tcx.hir())
 555     }
 556
 557     fn visit_attribute(&mut self, attr: &'tcx Attribute) {
 558         if self.is_active_attr(attr) {
 559             self.found_attrs.push(attr);
 560         }
 561     }
 562 }