diff --git a/src/librustc/hir/map/collector.rs b/src/librustc/hir/map/collector.rs index 5c1e74dcf43b9..02a1e33eeb918 100644 --- a/src/librustc/hir/map/collector.rs +++ b/src/librustc/hir/map/collector.rs @@ -12,6 +12,7 @@ use super::*; use dep_graph::{DepGraph, DepKind, DepNodeIndex}; use hir::intravisit::{Visitor, NestedVisitorMap}; +use middle::cstore::CrateStore; use session::CrateDisambiguator; use std::iter::repeat; use syntax::ast::{NodeId, CRATE_NODE_ID}; @@ -119,7 +120,9 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> { } pub(super) fn finalize_and_compute_crate_hash(self, - crate_disambiguator: CrateDisambiguator) + crate_disambiguator: CrateDisambiguator, + cstore: &CrateStore, + commandline_args_hash: u64) -> Vec> { let mut node_hashes: Vec<_> = self .hir_body_nodes @@ -132,9 +135,23 @@ impl<'a, 'hir> NodeCollector<'a, 'hir> { node_hashes.sort_unstable_by(|&(ref d1, _), &(ref d2, _)| d1.cmp(d2)); + let mut upstream_crates: Vec<_> = cstore.crates_untracked().iter().map(|&cnum| { + let name = cstore.crate_name_untracked(cnum).as_str(); + let disambiguator = cstore.crate_disambiguator_untracked(cnum) + .to_fingerprint(); + let hash = cstore.crate_hash_untracked(cnum); + (name, disambiguator, hash) + }).collect(); + + upstream_crates.sort_unstable_by(|&(name1, dis1, _), &(name2, dis2, _)| { + (name1, dis1).cmp(&(name2, dis2)) + }); + self.dep_graph.with_task(DepNode::new_no_params(DepKind::Krate), &self.hcx, - (node_hashes, crate_disambiguator.to_fingerprint()), + ((node_hashes, upstream_crates), + (commandline_args_hash, + crate_disambiguator.to_fingerprint())), identity_fn); self.map } diff --git a/src/librustc/hir/map/mod.rs b/src/librustc/hir/map/mod.rs index 8b00280b26b56..28527b6f0bc64 100644 --- a/src/librustc/hir/map/mod.rs +++ b/src/librustc/hir/map/mod.rs @@ -1059,7 +1059,10 @@ pub fn map_crate<'hir>(sess: &::session::Session, intravisit::walk_crate(&mut collector, &forest.krate); let crate_disambiguator = sess.local_crate_disambiguator(); - collector.finalize_and_compute_crate_hash(crate_disambiguator) + let cmdline_args = sess.opts.dep_tracking_hash(); + collector.finalize_and_compute_crate_hash(crate_disambiguator, + cstore, + cmdline_args) }; if log_enabled!(::log::LogLevel::Debug) { diff --git a/src/librustc/ich/hcx.rs b/src/librustc/ich/hcx.rs index d95b825b9e562..0ef42177c14a8 100644 --- a/src/librustc/ich/hcx.rs +++ b/src/librustc/ich/hcx.rs @@ -14,7 +14,6 @@ use hir::map::DefPathHash; use hir::map::definitions::Definitions; use ich::{self, CachingCodemapView}; use middle::cstore::CrateStore; -use session::config::DebugInfoLevel::NoDebugInfo; use ty::{TyCtxt, fast_reject}; use session::Session; @@ -24,7 +23,7 @@ use std::cell::RefCell; use std::collections::HashMap; use syntax::ast; -use syntax::attr; + use syntax::codemap::CodeMap; use syntax::ext::hygiene::SyntaxContext; use syntax::symbol::Symbol; @@ -51,7 +50,6 @@ pub struct StableHashingContext<'gcx> { body_resolver: BodyResolver<'gcx>, hash_spans: bool, hash_bodies: bool, - overflow_checks_enabled: bool, node_id_hashing_mode: NodeIdHashingMode, // Very often, we are hashing something that does not need the @@ -89,8 +87,7 @@ impl<'gcx> StableHashingContext<'gcx> { definitions: &'gcx Definitions, cstore: &'gcx CrateStore) -> Self { - let hash_spans_initial = sess.opts.debuginfo != NoDebugInfo; - let check_overflow_initial = sess.overflow_checks(); + let hash_spans_initial = !sess.opts.debugging_opts.incremental_ignore_spans; debug_assert!(ich::IGNORED_ATTRIBUTES.len() > 0); IGNORED_ATTR_NAMES.with(|names| { @@ -110,7 +107,6 @@ impl<'gcx> StableHashingContext<'gcx> { raw_codemap: sess.codemap(), hash_spans: hash_spans_initial, hash_bodies: true, - overflow_checks_enabled: check_overflow_initial, node_id_hashing_mode: NodeIdHashingMode::HashDefPath, } } @@ -120,11 +116,6 @@ impl<'gcx> StableHashingContext<'gcx> { self.sess } - pub fn force_span_hashing(mut self) -> Self { - self.hash_spans = true; - self - } - #[inline] pub fn while_hashing_hir_bodies(&mut self, hash_bodies: bool, @@ -174,11 +165,6 @@ impl<'gcx> StableHashingContext<'gcx> { self.definitions.node_to_hir_id(node_id) } - #[inline] - pub fn hash_spans(&self) -> bool { - self.hash_spans - } - #[inline] pub fn hash_bodies(&self) -> bool { self.hash_bodies @@ -204,58 +190,13 @@ impl<'gcx> StableHashingContext<'gcx> { }) } - pub fn hash_hir_item_like(&mut self, - item_attrs: &[ast::Attribute], - is_const: bool, - f: F) { - let prev_overflow_checks = self.overflow_checks_enabled; - if is_const || attr::contains_name(item_attrs, "rustc_inherit_overflow_checks") { - self.overflow_checks_enabled = true; - } + pub fn hash_hir_item_like(&mut self, f: F) { let prev_hash_node_ids = self.node_id_hashing_mode; self.node_id_hashing_mode = NodeIdHashingMode::Ignore; f(self); self.node_id_hashing_mode = prev_hash_node_ids; - self.overflow_checks_enabled = prev_overflow_checks; - } - - #[inline] - pub fn binop_can_panic_at_runtime(&self, binop: hir::BinOp_) -> bool - { - match binop { - hir::BiAdd | - hir::BiSub | - hir::BiShl | - hir::BiShr | - hir::BiMul => self.overflow_checks_enabled, - - hir::BiDiv | - hir::BiRem => true, - - hir::BiAnd | - hir::BiOr | - hir::BiBitXor | - hir::BiBitAnd | - hir::BiBitOr | - hir::BiEq | - hir::BiLt | - hir::BiLe | - hir::BiNe | - hir::BiGe | - hir::BiGt => false - } - } - - #[inline] - pub fn unop_can_panic_at_runtime(&self, unop: hir::UnOp) -> bool - { - match unop { - hir::UnDeref | - hir::UnNot => false, - hir::UnNeg => self.overflow_checks_enabled, - } } } diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs index 77bf3da679dd7..1533e37d7f759 100644 --- a/src/librustc/ich/impls_hir.rs +++ b/src/librustc/ich/impls_hir.rs @@ -529,63 +529,9 @@ impl<'gcx> HashStable> for hir::Expr { ref attrs } = *self; - let spans_always_on = match *node { - hir::ExprBox(..) | - hir::ExprArray(..) | - hir::ExprCall(..) | - hir::ExprLit(..) | - hir::ExprCast(..) | - hir::ExprType(..) | - hir::ExprIf(..) | - hir::ExprWhile(..) | - hir::ExprLoop(..) | - hir::ExprMatch(..) | - hir::ExprClosure(..) | - hir::ExprBlock(..) | - hir::ExprAssign(..) | - hir::ExprTupField(..) | - hir::ExprAddrOf(..) | - hir::ExprBreak(..) | - hir::ExprAgain(..) | - hir::ExprRet(..) | - hir::ExprYield(..) | - hir::ExprInlineAsm(..) | - hir::ExprRepeat(..) | - hir::ExprTup(..) | - hir::ExprMethodCall(..) | - hir::ExprPath(..) | - hir::ExprStruct(..) | - hir::ExprField(..) => { - // For these we only hash the span when debuginfo is on. - false - } - // For the following, spans might be significant because of - // panic messages indicating the source location. - hir::ExprBinary(op, ..) => { - hcx.binop_can_panic_at_runtime(op.node) - } - hir::ExprUnary(op, _) => { - hcx.unop_can_panic_at_runtime(op) - } - hir::ExprAssignOp(op, ..) => { - hcx.binop_can_panic_at_runtime(op.node) - } - hir::ExprIndex(..) => { - true - } - }; - - if spans_always_on { - hcx.while_hashing_spans(true, |hcx| { - span.hash_stable(hcx, hasher); - node.hash_stable(hcx, hasher); - attrs.hash_stable(hcx, hasher); - }); - } else { - span.hash_stable(hcx, hasher); - node.hash_stable(hcx, hasher); - attrs.hash_stable(hcx, hasher); - } + span.hash_stable(hcx, hasher); + node.hash_stable(hcx, hasher); + attrs.hash_stable(hcx, hasher); }) } } @@ -712,15 +658,7 @@ impl<'gcx> HashStable> for hir::TraitItem { span } = *self; - let is_const = match *node { - hir::TraitItemKind::Const(..) | - hir::TraitItemKind::Type(..) => true, - hir::TraitItemKind::Method(hir::MethodSig { constness, .. }, _) => { - constness == hir::Constness::Const - } - }; - - hcx.hash_hir_item_like(attrs, is_const, |hcx| { + hcx.hash_hir_item_like(|hcx| { name.hash_stable(hcx, hasher); attrs.hash_stable(hcx, hasher); generics.hash_stable(hcx, hasher); @@ -757,15 +695,7 @@ impl<'gcx> HashStable> for hir::ImplItem { span } = *self; - let is_const = match *node { - hir::ImplItemKind::Const(..) | - hir::ImplItemKind::Type(..) => true, - hir::ImplItemKind::Method(hir::MethodSig { constness, .. }, _) => { - constness == hir::Constness::Const - } - }; - - hcx.hash_hir_item_like(attrs, is_const, |hcx| { + hcx.hash_hir_item_like(|hcx| { name.hash_stable(hcx, hasher); vis.hash_stable(hcx, hasher); defaultness.hash_stable(hcx, hasher); @@ -884,30 +814,6 @@ impl<'gcx> HashStable> for hir::Item { fn hash_stable(&self, hcx: &mut StableHashingContext<'gcx>, hasher: &mut StableHasher) { - let is_const = match self.node { - hir::ItemStatic(..) | - hir::ItemConst(..) => { - true - } - hir::ItemFn(_, _, constness, ..) => { - constness == hir::Constness::Const - } - hir::ItemUse(..) | - hir::ItemExternCrate(..) | - hir::ItemForeignMod(..) | - hir::ItemGlobalAsm(..) | - hir::ItemMod(..) | - hir::ItemAutoImpl(..) | - hir::ItemTrait(..) | - hir::ItemImpl(..) | - hir::ItemTy(..) | - hir::ItemEnum(..) | - hir::ItemStruct(..) | - hir::ItemUnion(..) => { - false - } - }; - let hir::Item { name, ref attrs, @@ -918,7 +824,7 @@ impl<'gcx> HashStable> for hir::Item { span } = *self; - hcx.hash_hir_item_like(attrs, is_const, |hcx| { + hcx.hash_hir_item_like(|hcx| { name.hash_stable(hcx, hasher); attrs.hash_stable(hcx, hasher); node.hash_stable(hcx, hasher); diff --git a/src/librustc/ich/impls_mir.rs b/src/librustc/ich/impls_mir.rs index 331b44ac119c6..5d091813c9939 100644 --- a/src/librustc/ich/impls_mir.rs +++ b/src/librustc/ich/impls_mir.rs @@ -55,48 +55,11 @@ for mir::UnsafetyViolationKind { } } } -impl<'gcx> HashStable> -for mir::Terminator<'gcx> { - #[inline] - fn hash_stable(&self, - hcx: &mut StableHashingContext<'gcx>, - hasher: &mut StableHasher) { - let mir::Terminator { - ref kind, - ref source_info, - } = *self; - let hash_spans_unconditionally = match *kind { - mir::TerminatorKind::Assert { .. } => { - // Assert terminators generate a panic message that contains the - // source location, so we always have to feed its span into the - // ICH. - true - } - mir::TerminatorKind::Goto { .. } | - mir::TerminatorKind::SwitchInt { .. } | - mir::TerminatorKind::Resume | - mir::TerminatorKind::Return | - mir::TerminatorKind::GeneratorDrop | - mir::TerminatorKind::Unreachable | - mir::TerminatorKind::Drop { .. } | - mir::TerminatorKind::DropAndReplace { .. } | - mir::TerminatorKind::Yield { .. } | - mir::TerminatorKind::Call { .. } | - mir::TerminatorKind::FalseEdges { .. } => false, - }; - - if hash_spans_unconditionally { - hcx.while_hashing_spans(true, |hcx| { - source_info.hash_stable(hcx, hasher); - }) - } else { - source_info.hash_stable(hcx, hasher); - } - - kind.hash_stable(hcx, hasher); - } -} +impl_stable_hash_for!(struct mir::Terminator<'tcx> { + kind, + source_info +}); impl<'gcx, T> HashStable> for mir::ClearCrossCrate where T: HashStable> diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 70b63886084f5..c3e714e4357d2 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -1084,6 +1084,8 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options, "dump hash information in textual format to stdout"), incremental_verify_ich: bool = (false, parse_bool, [UNTRACKED], "verify incr. comp. hashes of green query instances"), + incremental_ignore_spans: bool = (false, parse_bool, [UNTRACKED], + "ignore spans during ICH computation -- used for testing"), dump_dep_graph: bool = (false, parse_bool, [UNTRACKED], "dump the dependency graph to $RUST_DEP_GRAPH (default: /tmp/dep_graph.gv)"), query_dep_graph: bool = (false, parse_bool, [UNTRACKED], diff --git a/src/librustc/ty/maps/config.rs b/src/librustc/ty/maps/config.rs index 496284ad9c9f4..2d0a3799178a5 100644 --- a/src/librustc/ty/maps/config.rs +++ b/src/librustc/ty/maps/config.rs @@ -27,6 +27,7 @@ pub trait QueryConfig { pub(super) trait QueryDescription<'tcx>: QueryConfig { fn describe(tcx: TyCtxt, key: Self::Key) -> String; + #[inline] fn cache_on_disk(_: Self::Key) -> bool { false } @@ -34,7 +35,7 @@ pub(super) trait QueryDescription<'tcx>: QueryConfig { fn try_load_from_disk(_: TyCtxt<'_, 'tcx, 'tcx>, _: SerializedDepNodeIndex) -> Option { - bug!("QueryDescription::load_from_disk() called for unsupport query.") + bug!("QueryDescription::load_from_disk() called for an unsupported query.") } } @@ -166,6 +167,18 @@ impl<'tcx> QueryDescription<'tcx> for queries::symbol_name<'tcx> { fn describe(_tcx: TyCtxt, instance: ty::Instance<'tcx>) -> String { format!("computing the symbol for `{}`", instance) } + + #[inline] + fn cache_on_disk(_: Self::Key) -> bool { + true + } + + #[inline] + fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>, + id: SerializedDepNodeIndex) + -> Option { + tcx.on_disk_query_result_cache.try_load_query_result(tcx, id) + } } impl<'tcx> QueryDescription<'tcx> for queries::describe_def<'tcx> { @@ -234,6 +247,18 @@ impl<'tcx> QueryDescription<'tcx> for queries::const_is_rvalue_promotable_to_sta format!("const checking if rvalue is promotable to static `{}`", tcx.item_path_str(def_id)) } + + #[inline] + fn cache_on_disk(_: Self::Key) -> bool { + true + } + + #[inline] + fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>, + id: SerializedDepNodeIndex) + -> Option { + tcx.on_disk_query_result_cache.try_load_query_result(tcx, id) + } } impl<'tcx> QueryDescription<'tcx> for queries::rvalue_promotable_map<'tcx> { @@ -254,6 +279,18 @@ impl<'tcx> QueryDescription<'tcx> for queries::trans_fulfill_obligation<'tcx> { fn describe(tcx: TyCtxt, key: (ty::ParamEnv<'tcx>, ty::PolyTraitRef<'tcx>)) -> String { format!("checking if `{}` fulfills its obligations", tcx.item_path_str(key.1.def_id())) } + + #[inline] + fn cache_on_disk(_: Self::Key) -> bool { + true + } + + #[inline] + fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>, + id: SerializedDepNodeIndex) + -> Option { + tcx.on_disk_query_result_cache.try_load_query_result(tcx, id) + } } impl<'tcx> QueryDescription<'tcx> for queries::trait_impls_of<'tcx> { @@ -567,3 +604,42 @@ impl<'tcx> QueryDescription<'tcx> for queries::typeck_tables_of<'tcx> { } } +impl<'tcx> QueryDescription<'tcx> for queries::optimized_mir<'tcx> { + #[inline] + fn cache_on_disk(def_id: Self::Key) -> bool { + def_id.is_local() + } + + fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>, + id: SerializedDepNodeIndex) + -> Option { + let mir: Option<::mir::Mir<'tcx>> = tcx.on_disk_query_result_cache + .try_load_query_result(tcx, id); + mir.map(|x| tcx.alloc_mir(x)) + } +} + +macro_rules! impl_disk_cacheable_query( + ($query_name:ident, |$key:tt| $cond:expr) => { + impl<'tcx> QueryDescription<'tcx> for queries::$query_name<'tcx> { + #[inline] + fn cache_on_disk($key: Self::Key) -> bool { + $cond + } + + #[inline] + fn try_load_from_disk<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>, + id: SerializedDepNodeIndex) + -> Option { + tcx.on_disk_query_result_cache.try_load_query_result(tcx, id) + } + } + } +); + +impl_disk_cacheable_query!(unsafety_check_result, |def_id| def_id.is_local()); +impl_disk_cacheable_query!(borrowck, |def_id| def_id.is_local()); +impl_disk_cacheable_query!(mir_borrowck, |def_id| def_id.is_local()); +impl_disk_cacheable_query!(mir_const_qualif, |def_id| def_id.is_local()); +impl_disk_cacheable_query!(contains_extern_indicator, |_| true); +impl_disk_cacheable_query!(def_symbol_name, |_| true); diff --git a/src/librustc/ty/maps/on_disk_cache.rs b/src/librustc/ty/maps/on_disk_cache.rs index 8dc9b0877a01c..079b518efd898 100644 --- a/src/librustc/ty/maps/on_disk_cache.rs +++ b/src/librustc/ty/maps/on_disk_cache.rs @@ -207,6 +207,16 @@ impl<'sess> OnDiskCache<'sess> { // Encode TypeckTables encode_query_results::(tcx, enc, qri)?; + encode_query_results::(tcx, enc, qri)?; + encode_query_results::(tcx, enc, qri)?; + encode_query_results::(tcx, enc, qri)?; + encode_query_results::(tcx, enc, qri)?; + encode_query_results::(tcx, enc, qri)?; + encode_query_results::(tcx, enc, qri)?; + encode_query_results::(tcx, enc, qri)?; + encode_query_results::(tcx, enc, qri)?; + encode_query_results::(tcx, enc, qri)?; + encode_query_results::(tcx, enc, qri)?; } // Encode diagnostics diff --git a/src/librustc/ty/maps/plumbing.rs b/src/librustc/ty/maps/plumbing.rs index fdaa13e7fd16f..ec6d190b8bde9 100644 --- a/src/librustc/ty/maps/plumbing.rs +++ b/src/librustc/ty/maps/plumbing.rs @@ -974,4 +974,7 @@ impl_load_from_cache!( BorrowCheck => borrowck, MirBorrowCheck => mir_borrowck, MirConstQualif => mir_const_qualif, + SymbolName => def_symbol_name, + ConstIsRvaluePromotableToStatic => const_is_rvalue_promotable_to_static, + ContainsExternIndicator => contains_extern_indicator, ); diff --git a/src/librustc_metadata/astencode.rs b/src/librustc_metadata/astencode.rs index 722d0cad238f4..71b15643cbcef 100644 --- a/src/librustc_metadata/astencode.rs +++ b/src/librustc_metadata/astencode.rs @@ -47,9 +47,7 @@ impl<'a, 'b, 'tcx> IsolatedEncoder<'a, 'b, 'tcx> { let mut hasher = StableHasher::new(); hcx.while_hashing_hir_bodies(true, |hcx| { - hcx.while_hashing_spans(false, |hcx| { - body.hash_stable(hcx, &mut hasher); - }); + body.hash_stable(hcx, &mut hasher); }); hasher.finish() diff --git a/src/test/incremental/hashes/call_expressions.rs b/src/test/incremental/hashes/call_expressions.rs index a62d84fedf3aa..da8a62a976508 100644 --- a/src/test/incremental/hashes/call_expressions.rs +++ b/src/test/incremental/hashes/call_expressions.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] diff --git a/src/test/incremental/hashes/closure_expressions.rs b/src/test/incremental/hashes/closure_expressions.rs index 4abc77e0ab64d..f695d16e44396 100644 --- a/src/test/incremental/hashes/closure_expressions.rs +++ b/src/test/incremental/hashes/closure_expressions.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/consts.rs b/src/test/incremental/hashes/consts.rs index 496ae4276f863..47f5a2d2bbe85 100644 --- a/src/test/incremental/hashes/consts.rs +++ b/src/test/incremental/hashes/consts.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/enum_constructors.rs b/src/test/incremental/hashes/enum_constructors.rs index f38d18646306e..541261f1d80dd 100644 --- a/src/test/incremental/hashes/enum_constructors.rs +++ b/src/test/incremental/hashes/enum_constructors.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/enum_defs.rs b/src/test/incremental/hashes/enum_defs.rs index dbb7aca1924d3..02746785856cc 100644 --- a/src/test/incremental/hashes/enum_defs.rs +++ b/src/test/incremental/hashes/enum_defs.rs @@ -23,7 +23,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/exported_vs_not.rs b/src/test/incremental/hashes/exported_vs_not.rs index 985c064f6a0a2..a796c87f19bbf 100644 --- a/src/test/incremental/hashes/exported_vs_not.rs +++ b/src/test/incremental/hashes/exported_vs_not.rs @@ -10,7 +10,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/extern_mods.rs b/src/test/incremental/hashes/extern_mods.rs index 7ccb452b7ed26..bcdd5661e7181 100644 --- a/src/test/incremental/hashes/extern_mods.rs +++ b/src/test/incremental/hashes/extern_mods.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/for_loops.rs b/src/test/incremental/hashes/for_loops.rs index 763b0cd05d4f9..80feabcdfddc4 100644 --- a/src/test/incremental/hashes/for_loops.rs +++ b/src/test/incremental/hashes/for_loops.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/function_interfaces.rs b/src/test/incremental/hashes/function_interfaces.rs index b3eb566367c72..b23c41ace140b 100644 --- a/src/test/incremental/hashes/function_interfaces.rs +++ b/src/test/incremental/hashes/function_interfaces.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] diff --git a/src/test/incremental/hashes/if_expressions.rs b/src/test/incremental/hashes/if_expressions.rs index d6878028cfae2..426c58c834def 100644 --- a/src/test/incremental/hashes/if_expressions.rs +++ b/src/test/incremental/hashes/if_expressions.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] diff --git a/src/test/incremental/hashes/indexing_expressions.rs b/src/test/incremental/hashes/indexing_expressions.rs index 715146146f148..e66e239b33c95 100644 --- a/src/test/incremental/hashes/indexing_expressions.rs +++ b/src/test/incremental/hashes/indexing_expressions.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/inherent_impls.rs b/src/test/incremental/hashes/inherent_impls.rs index c8c2fa5e8c813..93aba4a3ee11e 100644 --- a/src/test/incremental/hashes/inherent_impls.rs +++ b/src/test/incremental/hashes/inherent_impls.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] diff --git a/src/test/incremental/hashes/inline_asm.rs b/src/test/incremental/hashes/inline_asm.rs index 0947239c573c2..bb527855113c2 100644 --- a/src/test/incremental/hashes/inline_asm.rs +++ b/src/test/incremental/hashes/inline_asm.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/let_expressions.rs b/src/test/incremental/hashes/let_expressions.rs index f3bddc669842b..851b13c705516 100644 --- a/src/test/incremental/hashes/let_expressions.rs +++ b/src/test/incremental/hashes/let_expressions.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] diff --git a/src/test/incremental/hashes/loop_expressions.rs b/src/test/incremental/hashes/loop_expressions.rs index 8d015288757bf..b3d1074ee9d94 100644 --- a/src/test/incremental/hashes/loop_expressions.rs +++ b/src/test/incremental/hashes/loop_expressions.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/match_expressions.rs b/src/test/incremental/hashes/match_expressions.rs index 38edd675cc637..263901f402540 100644 --- a/src/test/incremental/hashes/match_expressions.rs +++ b/src/test/incremental/hashes/match_expressions.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] diff --git a/src/test/incremental/hashes/panic_exprs.rs b/src/test/incremental/hashes/panic_exprs.rs index c76c10f2ab443..2b6a140be32a9 100644 --- a/src/test/incremental/hashes/panic_exprs.rs +++ b/src/test/incremental/hashes/panic_exprs.rs @@ -28,155 +28,134 @@ // Indexing expression --------------------------------------------------------- -#[cfg(cfail1)] -pub fn indexing(slice: &[u8]) -> u8 { - slice[100] -} - -#[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn indexing(slice: &[u8]) -> u8 { - slice[100] + #[cfg(cfail1)] + { + slice[100] + } + #[cfg(not(cfail1))] + { + slice[100] + } } // Arithmetic overflow plus ---------------------------------------------------- -#[cfg(cfail1)] -pub fn arithmetic_overflow_plus(val: i32) -> i32 { - val + 1 -} - -#[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn arithmetic_overflow_plus(val: i32) -> i32 { - val + 1 + #[cfg(cfail1)] + { + val + 1 + } + #[cfg(not(cfail1))] + { + val + 1 + } } // Arithmetic overflow minus ---------------------------------------------------- -#[cfg(cfail1)] -pub fn arithmetic_overflow_minus(val: i32) -> i32 { - val - 1 -} - -#[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn arithmetic_overflow_minus(val: i32) -> i32 { - val - 1 + #[cfg(cfail1)] + { + val - 1 + } + #[cfg(not(cfail1))] + { + val - 1 + } } // Arithmetic overflow mult ---------------------------------------------------- -#[cfg(cfail1)] -pub fn arithmetic_overflow_mult(val: i32) -> i32 { - val * 2 -} - -#[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn arithmetic_overflow_mult(val: i32) -> i32 { - val * 2 + #[cfg(cfail1)] + { + val * 2 + } + #[cfg(not(cfail1))] + { + val * 2 + } } // Arithmetic overflow negation ------------------------------------------------ -#[cfg(cfail1)] -pub fn arithmetic_overflow_negation(val: i32) -> i32 { - -val -} - -#[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn arithmetic_overflow_negation(val: i32) -> i32 { - -val + #[cfg(cfail1)] + { + -val + } + #[cfg(not(cfail1))] + { + -val + } } // Division by zero ------------------------------------------------------------ -#[cfg(cfail1)] -pub fn division_by_zero(val: i32) -> i32 { - 2 / val -} - -#[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn division_by_zero(val: i32) -> i32 { - 2 / val + #[cfg(cfail1)] + { + 2 / val + } + #[cfg(not(cfail1))] + { + 2 / val + } } // Division by zero ------------------------------------------------------------ -#[cfg(cfail1)] -pub fn mod_by_zero(val: i32) -> i32 { - 2 % val -} - -#[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn mod_by_zero(val: i32) -> i32 { - 2 % val + #[cfg(cfail1)] + { + 2 % val + } + #[cfg(not(cfail1))] + { + 2 % val + } } // shift left ------------------------------------------------------------------ -#[cfg(cfail1)] -pub fn shift_left(val: i32, shift: usize) -> i32 { - val << shift -} - -#[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn shift_left(val: i32, shift: usize) -> i32 { - val << shift + #[cfg(cfail1)] + { + val << shift + } + #[cfg(not(cfail1))] + { + val << shift + } } // shift right ------------------------------------------------------------------ -#[cfg(cfail1)] -pub fn shift_right(val: i32, shift: usize) -> i32 { - val >> shift -} - -#[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] pub fn shift_right(val: i32, shift: usize) -> i32 { - val >> shift -} - - -// THE FOLLOWING ITEMS SHOULD NOT BE INFLUENCED BY THEIR SOURCE LOCATION - -// bitwise --------------------------------------------------------------------- -#[cfg(cfail1)] -pub fn bitwise(val: i32) -> i32 { - !val & 0x101010101 | 0x45689 ^ 0x2372382 -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2")] -#[rustc_clean(cfg="cfail3")] -pub fn bitwise(val: i32) -> i32 { - !val & 0x101010101 | 0x45689 ^ 0x2372382 -} - - -// logical --------------------------------------------------------------------- -#[cfg(cfail1)] -pub fn logical(val1: bool, val2: bool, val3: bool) -> bool { - val1 && val2 || val3 -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2")] -#[rustc_clean(cfg="cfail3")] -pub fn logical(val1: bool, val2: bool, val3: bool) -> bool { - val1 && val2 || val3 + #[cfg(cfail1)] + { + val >> shift + } + #[cfg(not(cfail1))] + { + val >> shift + } } diff --git a/src/test/incremental/hashes/panic_exprs_no_overflow_checks.rs b/src/test/incremental/hashes/panic_exprs_no_overflow_checks.rs deleted file mode 100644 index 8402da04091ec..0000000000000 --- a/src/test/incremental/hashes/panic_exprs_no_overflow_checks.rs +++ /dev/null @@ -1,225 +0,0 @@ -// Copyright 2016 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. - -// This test case tests the incremental compilation hash (ICH) implementation -// for exprs that can panic at runtime (e.g. because of bounds checking). For -// these expressions an error message containing their source location is -// generated, so their hash must always depend on their location in the source -// code, not just when debuginfo is enabled. - -// As opposed to the panic_exprs.rs test case, this test case checks that things -// behave as expected when overflow checks are off: -// -// - Addition, subtraction, and multiplication do not change the ICH, unless -// the function containing them is marked with rustc_inherit_overflow_checks. -// - Division by zero and bounds checks always influence the ICH - -// The general pattern followed here is: Change one thing between rev1 and rev2 -// and make sure that the hash has changed, then change nothing between rev2 and -// rev3 and make sure that the hash has not changed. - -// must-compile-successfully -// revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph -Z force-overflow-checks=off - -#![allow(warnings)] -#![feature(rustc_attrs)] -#![crate_type="rlib"] - - -// Indexing expression --------------------------------------------------------- -#[cfg(cfail1)] -pub fn indexing(slice: &[u8]) -> u8 { - slice[100] -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] -#[rustc_clean(cfg="cfail3")] -pub fn indexing(slice: &[u8]) -> u8 { - slice[100] -} - - -// Arithmetic overflow plus ---------------------------------------------------- -#[cfg(cfail1)] -#[rustc_inherit_overflow_checks] -pub fn arithmetic_overflow_plus_inherit(val: i32) -> i32 { - val + 1 -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] -#[rustc_clean(cfg="cfail3")] -#[rustc_inherit_overflow_checks] -pub fn arithmetic_overflow_plus_inherit(val: i32) -> i32 { - val + 1 -} - - -// Arithmetic overflow minus ---------------------------------------------------- -#[cfg(cfail1)] -#[rustc_inherit_overflow_checks] -pub fn arithmetic_overflow_minus_inherit(val: i32) -> i32 { - val - 1 -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] -#[rustc_clean(cfg="cfail3")] -#[rustc_inherit_overflow_checks] -pub fn arithmetic_overflow_minus_inherit(val: i32) -> i32 { - val - 1 -} - - -// Arithmetic overflow mult ---------------------------------------------------- -#[cfg(cfail1)] -#[rustc_inherit_overflow_checks] -pub fn arithmetic_overflow_mult_inherit(val: i32) -> i32 { - val * 2 -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] -#[rustc_clean(cfg="cfail3")] -#[rustc_inherit_overflow_checks] -pub fn arithmetic_overflow_mult_inherit(val: i32) -> i32 { - val * 2 -} - - -// Arithmetic overflow negation ------------------------------------------------ -#[cfg(cfail1)] -#[rustc_inherit_overflow_checks] -pub fn arithmetic_overflow_negation_inherit(val: i32) -> i32 { - -val -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] -#[rustc_clean(cfg="cfail3")] -#[rustc_inherit_overflow_checks] -pub fn arithmetic_overflow_negation_inherit(val: i32) -> i32 { - -val -} - - -// Division by zero ------------------------------------------------------------ -#[cfg(cfail1)] -pub fn division_by_zero(val: i32) -> i32 { - 2 / val -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] -#[rustc_clean(cfg="cfail3")] -pub fn division_by_zero(val: i32) -> i32 { - 2 / val -} - -// Division by zero ------------------------------------------------------------ -#[cfg(cfail1)] -pub fn mod_by_zero(val: i32) -> i32 { - 2 % val -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] -#[rustc_clean(cfg="cfail3")] -pub fn mod_by_zero(val: i32) -> i32 { - 2 % val -} - - - -// THE FOLLOWING ITEMS SHOULD NOT BE INFLUENCED BY THEIR SOURCE LOCATION - -// bitwise --------------------------------------------------------------------- -#[cfg(cfail1)] -pub fn bitwise(val: i32) -> i32 { - !val & 0x101010101 | 0x45689 ^ 0x2372382 << 1 >> 1 -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2")] -#[rustc_clean(cfg="cfail3")] -pub fn bitwise(val: i32) -> i32 { - !val & 0x101010101 | 0x45689 ^ 0x2372382 << 1 >> 1 -} - - -// logical --------------------------------------------------------------------- -#[cfg(cfail1)] -pub fn logical(val1: bool, val2: bool, val3: bool) -> bool { - val1 && val2 || val3 -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2")] -#[rustc_clean(cfg="cfail3")] -pub fn logical(val1: bool, val2: bool, val3: bool) -> bool { - val1 && val2 || val3 -} - -// Arithmetic overflow plus ---------------------------------------------------- -#[cfg(cfail1)] -pub fn arithmetic_overflow_plus(val: i32) -> i32 { - val + 1 -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2")] -#[rustc_clean(cfg="cfail3")] -pub fn arithmetic_overflow_plus(val: i32) -> i32 { - val + 1 -} - - -// Arithmetic overflow minus ---------------------------------------------------- -#[cfg(cfail1)] -pub fn arithmetic_overflow_minus(val: i32) -> i32 { - val - 1 -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2")] -#[rustc_clean(cfg="cfail3")] -pub fn arithmetic_overflow_minus(val: i32) -> i32 { - val - 1 -} - - -// Arithmetic overflow mult ---------------------------------------------------- -#[cfg(cfail1)] -pub fn arithmetic_overflow_mult(val: i32) -> i32 { - val * 2 -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2")] -#[rustc_clean(cfg="cfail3")] -pub fn arithmetic_overflow_mult(val: i32) -> i32 { - val * 2 -} - - -// Arithmetic overflow negation ------------------------------------------------ -#[cfg(cfail1)] -pub fn arithmetic_overflow_negation(val: i32) -> i32 { - -val -} - -#[cfg(not(cfail1))] -#[rustc_clean(cfg="cfail2")] -#[rustc_clean(cfg="cfail3")] -pub fn arithmetic_overflow_negation(val: i32) -> i32 { - -val -} diff --git a/src/test/incremental/hashes/statics.rs b/src/test/incremental/hashes/statics.rs index e729a2c039e4c..b9616d8c6b53e 100644 --- a/src/test/incremental/hashes/statics.rs +++ b/src/test/incremental/hashes/statics.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/struct_constructors.rs b/src/test/incremental/hashes/struct_constructors.rs index a16f4a2fdfd65..3cdaf0e468a7a 100644 --- a/src/test/incremental/hashes/struct_constructors.rs +++ b/src/test/incremental/hashes/struct_constructors.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/struct_defs.rs b/src/test/incremental/hashes/struct_defs.rs index d89d779c849c3..d7b70720418d8 100644 --- a/src/test/incremental/hashes/struct_defs.rs +++ b/src/test/incremental/hashes/struct_defs.rs @@ -23,7 +23,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] diff --git a/src/test/incremental/hashes/trait_defs.rs b/src/test/incremental/hashes/trait_defs.rs index e09659be75599..0816d6e5f452c 100644 --- a/src/test/incremental/hashes/trait_defs.rs +++ b/src/test/incremental/hashes/trait_defs.rs @@ -23,7 +23,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/trait_impls.rs b/src/test/incremental/hashes/trait_impls.rs index eb31175b6f257..a232883f7a9b4 100644 --- a/src/test/incremental/hashes/trait_impls.rs +++ b/src/test/incremental/hashes/trait_impls.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] diff --git a/src/test/incremental/hashes/type_defs.rs b/src/test/incremental/hashes/type_defs.rs index 59346f5fdb23e..c5521d2fae2eb 100644 --- a/src/test/incremental/hashes/type_defs.rs +++ b/src/test/incremental/hashes/type_defs.rs @@ -23,7 +23,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/unary_and_binary_exprs.rs b/src/test/incremental/hashes/unary_and_binary_exprs.rs index ec4ae62b12b13..85f6ef60c5dc0 100644 --- a/src/test/incremental/hashes/unary_and_binary_exprs.rs +++ b/src/test/incremental/hashes/unary_and_binary_exprs.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph -Z force-overflow-checks=off +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/while_let_loops.rs b/src/test/incremental/hashes/while_let_loops.rs index eae5aea651075..092e8e4bc093b 100644 --- a/src/test/incremental/hashes/while_let_loops.rs +++ b/src/test/incremental/hashes/while_let_loops.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/hashes/while_loops.rs b/src/test/incremental/hashes/while_loops.rs index 6b1898e401b24..7128a4faaf950 100644 --- a/src/test/incremental/hashes/while_loops.rs +++ b/src/test/incremental/hashes/while_loops.rs @@ -18,7 +18,7 @@ // must-compile-successfully // revisions: cfail1 cfail2 cfail3 -// compile-flags: -Z query-dep-graph +// compile-flags: -Z query-dep-graph -Zincremental-ignore-spans #![allow(warnings)] #![feature(rustc_attrs)] diff --git a/src/test/incremental/ich_method_call_trait_scope.rs b/src/test/incremental/ich_method_call_trait_scope.rs index 7f4e2b0f17652..996c9ed21cf67 100644 --- a/src/test/incremental/ich_method_call_trait_scope.rs +++ b/src/test/incremental/ich_method_call_trait_scope.rs @@ -30,21 +30,10 @@ trait Trait2 { impl Trait2 for () { } -#[cfg(rpass1)] mod mod3 { + #[cfg(rpass1)] use Trait1; - - fn bar() { - ().method(); - } - - fn baz() { - 22; // no method call, traits in scope don't matter - } -} - -#[cfg(rpass2)] -mod mod3 { + #[cfg(rpass2)] use Trait2; #[rustc_clean(label="Hir", cfg="rpass2")] diff --git a/src/test/incremental/ich_nested_items.rs b/src/test/incremental/ich_nested_items.rs index 2e0f0ba083783..8566a24c84b26 100644 --- a/src/test/incremental/ich_nested_items.rs +++ b/src/test/incremental/ich_nested_items.rs @@ -17,23 +17,18 @@ #![crate_type = "rlib"] #![feature(rustc_attrs)] -#[cfg(cfail1)] -pub fn foo() { - pub fn bar() { } - pub fn baz() { } -} - -#[cfg(cfail2)] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_dirty(label="HirBody", cfg="cfail2")] pub fn foo() { - #[rustc_clean(label="Hir", cfg="cfail2")] - #[rustc_clean(label="HirBody", cfg="cfail2")] + #[cfg(cfail1)] pub fn baz() { } // order is different... #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail2")] pub fn bar() { } // but that doesn't matter. + #[cfg(cfail2)] + pub fn baz() { } // order is different... + pub fn bap() { } // neither does adding a new item } diff --git a/src/test/incremental/ich_resolve_results.rs b/src/test/incremental/ich_resolve_results.rs index 49a88c530ff64..9e5b51f3e7a01 100644 --- a/src/test/incremental/ich_resolve_results.rs +++ b/src/test/incremental/ich_resolve_results.rs @@ -25,49 +25,29 @@ mod mod2 { pub struct Foo(pub i64); } -#[cfg(rpass1)] mod mod3 { - use test; + #[cfg(rpass1)] use mod1::Foo; - - fn in_expr() { - Foo(0); - } - - fn in_type() { - test::(); - } -} - -#[cfg(rpass2)] -mod mod3 { - use mod1::Foo; // <-- Nothing changed, but reordered! use test; - #[rustc_clean(label="Hir", cfg="rpass2")] - #[rustc_clean(label="HirBody", cfg="rpass2")] - fn in_expr() { - Foo(0); - } + // In rpass2 we move the use declaration. + #[cfg(rpass2)] + use mod1::Foo; + + // In rpass3 we let the declaration point to something else. + #[cfg(rpass3)] + use mod2::Foo; #[rustc_clean(label="Hir", cfg="rpass2")] #[rustc_clean(label="HirBody", cfg="rpass2")] - fn in_type() { - test::(); - } -} - -#[cfg(rpass3)] -mod mod3 { - use test; - use mod2::Foo; // <-- This changed! - #[rustc_clean(label="Hir", cfg="rpass3")] #[rustc_dirty(label="HirBody", cfg="rpass3")] fn in_expr() { Foo(0); } + #[rustc_clean(label="Hir", cfg="rpass2")] + #[rustc_clean(label="HirBody", cfg="rpass2")] #[rustc_clean(label="Hir", cfg="rpass3")] #[rustc_dirty(label="HirBody", cfg="rpass3")] fn in_type() { diff --git a/src/test/incremental/source_loc_macros.rs b/src/test/incremental/source_loc_macros.rs index 36d1b3ecbcd14..3f669ae3fc860 100644 --- a/src/test/incremental/source_loc_macros.rs +++ b/src/test/incremental/source_loc_macros.rs @@ -35,28 +35,30 @@ fn file_same() { let _ = file!(); } -#[cfg(rpass1)] -fn line_different() { - let _ = line!(); -} - -#[cfg(rpass2)] #[rustc_clean(label="Hir", cfg="rpass2")] #[rustc_dirty(label="HirBody", cfg="rpass2")] fn line_different() { - let _ = line!(); -} - -#[cfg(rpass1)] -fn col_different() { - let _ = column!(); + #[cfg(rpass1)] + { + let _ = line!(); + } + #[cfg(rpass2)] + { + let _ = line!(); + } } -#[cfg(rpass2)] #[rustc_clean(label="Hir", cfg="rpass2")] #[rustc_dirty(label="HirBody", cfg="rpass2")] fn col_different() { - let _ = column!(); + #[cfg(rpass1)] + { + let _ = column!(); + } + #[cfg(rpass2)] + { + let _ = column!(); + } } fn main() { diff --git a/src/test/incremental/spans_insignificant_w_o_debuginfo.rs b/src/test/incremental/spans_insignificant_w_o_debuginfo.rs deleted file mode 100644 index 90ec4a9d55831..0000000000000 --- a/src/test/incremental/spans_insignificant_w_o_debuginfo.rs +++ /dev/null @@ -1,26 +0,0 @@ -// Copyright 2016 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. - -// This test makes sure that just changing a definition's location in the -// source file does *not* change its incr. comp. hash, if debuginfo is disabled. - -// revisions:rpass1 rpass2 - -// compile-flags: -Z query-dep-graph - -#![feature(rustc_attrs)] - -#[cfg(rpass1)] -pub fn main() {} - -#[cfg(rpass2)] -#[rustc_clean(label="Hir", cfg="rpass2")] -#[rustc_clean(label="HirBody", cfg="rpass2")] -pub fn main() {} diff --git a/src/test/incremental/spans_significant_w_panic.rs b/src/test/incremental/spans_significant_w_panic.rs index c0bf35e781c70..1fefec7a0a799 100644 --- a/src/test/incremental/spans_significant_w_panic.rs +++ b/src/test/incremental/spans_significant_w_panic.rs @@ -23,8 +23,7 @@ pub fn main() { } #[cfg(rpass2)] -#[rustc_clean(label="Hir", cfg="rpass2")] -#[rustc_dirty(label="HirBody", cfg="rpass2")] +#[rustc_dirty(label="MirOptimized", cfg="rpass2")] pub fn main() { let _ = 0u8 + 1; }