From ea2d90e903af29dcfc5bff3bb08ddbc6c4464975 Mon Sep 17 00:00:00 2001 From: Niko Matsakis Date: Tue, 23 Aug 2016 11:57:27 -0400 Subject: [PATCH] consider DepNode::Krate to be an input This seems not only more correct but allows us to write tests that check whether the krate hash as a whole is clean/dirty --- src/librustc/dep_graph/dep_node.rs | 5 +++ .../persist/dirty_clean.rs | 2 + src/librustc_incremental/persist/hash.rs | 11 +++-- src/librustc_incremental/persist/load.rs | 2 +- src/librustc_incremental/persist/preds.rs | 2 +- src/test/incremental/crate_hash_reorder.rs | 40 +++++++++++++++++++ 6 files changed, 57 insertions(+), 5 deletions(-) create mode 100644 src/test/incremental/crate_hash_reorder.rs diff --git a/src/librustc/dep_graph/dep_node.rs b/src/librustc/dep_graph/dep_node.rs index 40fd3dede3d08..e95fbcc89175a 100644 --- a/src/librustc/dep_graph/dep_node.rs +++ b/src/librustc/dep_graph/dep_node.rs @@ -147,6 +147,11 @@ impl DepNode { } } + if label == "Krate" { + // special case + return Ok(DepNode::Krate); + } + check! { CollectItem, BorrowCheck, diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs index 3c77cc07d3d89..65da3a09ecca5 100644 --- a/src/librustc_incremental/persist/dirty_clean.rs +++ b/src/librustc_incremental/persist/dirty_clean.rs @@ -133,6 +133,7 @@ impl<'a, 'tcx> DirtyCleanVisitor<'a, 'tcx> { debug!("assert_dirty({:?})", dep_node); match dep_node { + DepNode::Krate | DepNode::Hir(_) => { // HIR nodes are inputs, so if we are asserting that the HIR node is // dirty, we check the dirty input set. @@ -161,6 +162,7 @@ impl<'a, 'tcx> DirtyCleanVisitor<'a, 'tcx> { debug!("assert_clean({:?})", dep_node); match dep_node { + DepNode::Krate | DepNode::Hir(_) => { // For HIR nodes, check the inputs. if self.dirty_inputs.contains(&dep_node) { diff --git a/src/librustc_incremental/persist/hash.rs b/src/librustc_incremental/persist/hash.rs index 12dacf273b962..5d01f88060282 100644 --- a/src/librustc_incremental/persist/hash.rs +++ b/src/librustc_incremental/persist/hash.rs @@ -45,14 +45,19 @@ impl<'a, 'tcx> HashContext<'a, 'tcx> { pub fn is_hashable(dep_node: &DepNode) -> bool { match *dep_node { + DepNode::Krate | DepNode::Hir(_) => true, DepNode::MetaData(def_id) => !def_id.is_local(), _ => false, } } - pub fn hash(&mut self, dep_node: &DepNode) -> Option<(DefId, u64)> { + pub fn hash(&mut self, dep_node: &DepNode) -> Option { match *dep_node { + DepNode::Krate => { + Some(self.incremental_hashes_map[dep_node]) + } + // HIR nodes (which always come from our crate) are an input: DepNode::Hir(def_id) => { assert!(def_id.is_local(), @@ -65,7 +70,7 @@ impl<'a, 'tcx> HashContext<'a, 'tcx> { def_id, self.tcx.item_path_str(def_id)); - Some((def_id, self.incremental_hashes_map[dep_node])) + Some(self.incremental_hashes_map[dep_node]) } // MetaData from other crates is an *input* to us. @@ -73,7 +78,7 @@ impl<'a, 'tcx> HashContext<'a, 'tcx> { // don't hash them, but we do compute a hash for them and // save it for others to use. DepNode::MetaData(def_id) if !def_id.is_local() => { - Some((def_id, self.metadata_hash(def_id))) + Some(self.metadata_hash(def_id)) } _ => { diff --git a/src/librustc_incremental/persist/load.rs b/src/librustc_incremental/persist/load.rs index 7449205c536fa..75448d199f73e 100644 --- a/src/librustc_incremental/persist/load.rs +++ b/src/librustc_incremental/persist/load.rs @@ -222,7 +222,7 @@ fn dirty_nodes<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, for hash in serialized_hashes { if let Some(dep_node) = retraced.map(&hash.dep_node) { - let (_, current_hash) = hcx.hash(&dep_node).unwrap(); + let current_hash = hcx.hash(&dep_node).unwrap(); if current_hash == hash.hash { continue; } diff --git a/src/librustc_incremental/persist/preds.rs b/src/librustc_incremental/persist/preds.rs index a82951afcb1ef..af13484e4288d 100644 --- a/src/librustc_incremental/persist/preds.rs +++ b/src/librustc_incremental/persist/preds.rs @@ -62,7 +62,7 @@ impl<'q> Predecessors<'q> { let mut hashes = FnvHashMap(); for input in inputs.values().flat_map(|v| v.iter().cloned()) { hashes.entry(input) - .or_insert_with(|| hcx.hash(input).unwrap().1); + .or_insert_with(|| hcx.hash(input).unwrap()); } Predecessors { diff --git a/src/test/incremental/crate_hash_reorder.rs b/src/test/incremental/crate_hash_reorder.rs new file mode 100644 index 0000000000000..1dec361eb07d7 --- /dev/null +++ b/src/test/incremental/crate_hash_reorder.rs @@ -0,0 +1,40 @@ +// Copyright 2014 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// Test incremental compilation tracking where we change field names +// in between revisions (hashing should be stable). + +// revisions:rpass1 rpass2 rpass3 +// compile-flags: -Z query-dep-graph + +#![feature(rustc_attrs)] + +// Check that reordering otherwise identical items is not considered a +// change at all. +#[rustc_clean(label="Krate", cfg="rpass2")] + +// But removing an item, naturally, is. +#[rustc_dirty(label="Krate", cfg="rpass3")] + +#[cfg(rpass1)] +pub struct X { + pub x: u32, +} + +pub struct Y { + pub x: u32, +} + +#[cfg(rpass2)] +pub struct X { + pub x: u32, +} + +pub fn main() { }