bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #120006 - cjgillot:no-hir-owner, r=wesleywiser

Browse source 
Get rid of the hir_owner query.

This query was meant as a firewall between `hir_owner_nodes` which is supposed to change often, and the queries that only depend on the item signature. That firewall was inefficient, leaking the contents of the HIR body through `HirId`s.

`hir_owner` incurs a significant cost, as we need to hash HIR twice in multiple modes. This PR proposes to remove it, and simplify the hashing scheme.

For the future, `def_kind`, `def_span`... are much more efficient for incremental decoupling, and should be preferred.
This commit is contained in:
bors 2024-01-19 02:36:13 +00:00
commit d3c9082a44
30 changed files with 581 additions and 716 deletions
Download patch file Download diff file Expand all files Collapse all files

6
compiler/rustc_ast_lowering/src/lib.rs
View file

@ -662,9 +662,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let (opt_hash_including_bodies, attrs_hash) = if self.tcx.needs_crate_hash() { let (opt_hash_including_bodies, attrs_hash) = if self.tcx.needs_crate_hash() {
self.tcx.with_stable_hashing_context(|mut hcx| { self.tcx.with_stable_hashing_context(|mut hcx| {
let mut stable_hasher = StableHasher::new(); let mut stable_hasher = StableHasher::new();
hcx.with_hir_bodies(node.def_id(), &bodies, |hcx| { node.hash_stable(&mut hcx, &mut stable_hasher);
node.hash_stable(hcx, &mut stable_hasher) // Bodies are stored out of line, so we need to pull them explicitly in the hash.
}); bodies.hash_stable(&mut hcx, &mut stable_hasher);
let h1 = stable_hasher.finish(); let h1 = stable_hasher.finish();
let mut stable_hasher = StableHasher::new(); let mut stable_hasher = StableHasher::new();

4
compiler/rustc_hir/src/hir.rs
View file

@ -841,7 +841,7 @@ pub struct OwnerNodes<'tcx> {
} }
impl<'tcx> OwnerNodes<'tcx> { impl<'tcx> OwnerNodes<'tcx> {
fn node(&self) -> OwnerNode<'tcx> { pub fn node(&self) -> OwnerNode<'tcx> {
use rustc_index::Idx; use rustc_index::Idx;
let node = self.nodes[ItemLocalId::new(0)].as_ref().unwrap().node; let node = self.nodes[ItemLocalId::new(0)].as_ref().unwrap().node;
let node = node.as_owner().unwrap(); // Indexing must ensure it is an OwnerNode. let node = node.as_owner().unwrap(); // Indexing must ensure it is an OwnerNode.
@ -1305,7 +1305,7 @@ pub enum UnsafeSource {
UserProvided, UserProvided,
} }
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)] #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, HashStable_Generic)]
pub struct BodyId { pub struct BodyId {
pub hir_id: HirId, pub hir_id: HirId,
} }

7
compiler/rustc_hir/src/stable_hash_impls.rs
View file

@ -12,7 +12,6 @@ use rustc_span::def_id::DefPathHash;
pub trait HashStableContext: pub trait HashStableContext:
rustc_ast::HashStableContext + rustc_target::HashStableContext rustc_ast::HashStableContext + rustc_target::HashStableContext
{ {
fn hash_body_id(&mut self, _: BodyId, hasher: &mut StableHasher);
} }
impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for HirId { impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for HirId {
@ -80,12 +79,6 @@ impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for ForeignItemId
} }
} }
impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for BodyId {
fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
hcx.hash_body_id(*self, hasher)
}
}
// The following implementations of HashStable for `ItemId`, `TraitItemId`, and // The following implementations of HashStable for `ItemId`, `TraitItemId`, and
// `ImplItemId` deserve special attention. Normally we do not hash `NodeId`s within // `ImplItemId` deserve special attention. Normally we do not hash `NodeId`s within
// the HIR, since they just signify a HIR nodes own path. But `ItemId` et al // the HIR, since they just signify a HIR nodes own path. But `ItemId` et al

8
compiler/rustc_incremental/src/assert_dep_graph.rs
View file

@ -128,9 +128,11 @@ impl<'tcx> IfThisChanged<'tcx> {
if attr.has_name(sym::rustc_if_this_changed) { if attr.has_name(sym::rustc_if_this_changed) {
let dep_node_interned = self.argument(attr); let dep_node_interned = self.argument(attr);
let dep_node = match dep_node_interned { let dep_node = match dep_node_interned {
None => { None => DepNode::from_def_path_hash(
DepNode::from_def_path_hash(self.tcx, def_path_hash, dep_kinds::hir_owner) self.tcx,
} def_path_hash,
dep_kinds::hir_owner_nodes,
),
Some(n) => { Some(n) => {
match DepNode::from_label_string(self.tcx, n.as_str(), def_path_hash) { match DepNode::from_label_string(self.tcx, n.as_str(), def_path_hash) {
Ok(n) => n, Ok(n) => n,

3
compiler/rustc_incremental/src/persist/dirty_clean.rs
View file

@ -57,8 +57,7 @@ const BASE_FN: &[&str] = &[
/// DepNodes for Hir, which is pretty much everything /// DepNodes for Hir, which is pretty much everything
const BASE_HIR: &[&str] = &[ const BASE_HIR: &[&str] = &[
// hir_owner and hir_owner_nodes should be computed for all nodes // hir_owner_nodes should be computed for all nodes
label_strs::hir_owner,
label_strs::hir_owner_nodes, label_strs::hir_owner_nodes,
]; ];

58
compiler/rustc_middle/src/hir/map/mod.rs
View file

@ -1,4 +1,4 @@
use crate::hir::{ModuleItems, Owner}; use crate::hir::ModuleItems;
use crate::middle::debugger_visualizer::DebuggerVisualizerFile; use crate::middle::debugger_visualizer::DebuggerVisualizerFile;
use crate::query::LocalCrate; use crate::query::LocalCrate;
use crate::ty::TyCtxt; use crate::ty::TyCtxt;
@ -108,7 +108,7 @@ impl<'hir> Iterator for ParentOwnerIterator<'hir> {
if self.current_id.local_id.index() != 0 { if self.current_id.local_id.index() != 0 {
self.current_id.local_id = ItemLocalId::new(0); self.current_id.local_id = ItemLocalId::new(0);
if let Some(node) = self.map.tcx.hir_owner(self.current_id.owner) { if let Some(node) = self.map.tcx.hir_owner(self.current_id.owner) {
return Some((self.current_id.owner, node.node)); return Some((self.current_id.owner, node));
} }
} }
if self.current_id == CRATE_HIR_ID { if self.current_id == CRATE_HIR_ID {
@ -126,23 +126,23 @@ impl<'hir> Iterator for ParentOwnerIterator<'hir> {
// If this `HirId` doesn't have an entry, skip it and look for its `parent_id`. // If this `HirId` doesn't have an entry, skip it and look for its `parent_id`.
if let Some(node) = self.map.tcx.hir_owner(self.current_id.owner) { if let Some(node) = self.map.tcx.hir_owner(self.current_id.owner) {
return Some((self.current_id.owner, node.node)); return Some((self.current_id.owner, node));
} }
} }
} }
} }
impl<'tcx> TyCtxt<'tcx> { impl<'tcx> TyCtxt<'tcx> {
#[inline]
fn hir_owner(self, owner: OwnerId) -> Option<OwnerNode<'tcx>> {
Some(self.hir_owner_nodes(owner).as_owner()?.node())
}
/// Retrieves the `hir::Node` corresponding to `id`, returning `None` if cannot be found. /// Retrieves the `hir::Node` corresponding to `id`, returning `None` if cannot be found.
pub fn opt_hir_node(self, id: HirId) -> Option<Node<'tcx>> { pub fn opt_hir_node(self, id: HirId) -> Option<Node<'tcx>> {
if id.local_id == ItemLocalId::from_u32(0) { let owner = self.hir_owner_nodes(id.owner).as_owner()?;
let owner = self.hir_owner(id.owner)?; let node = owner.nodes[id.local_id].as_ref()?;
Some(owner.node.into()) Some(node.node)
} else {
let owner = self.hir_owner_nodes(id.owner).as_owner()?;
let node = owner.nodes[id.local_id].as_ref()?;
Some(node.node)
}
} }
/// Retrieves the `hir::Node` corresponding to `id`, returning `None` if cannot be found. /// Retrieves the `hir::Node` corresponding to `id`, returning `None` if cannot be found.
@ -174,7 +174,7 @@ impl<'hir> Map<'hir> {
#[inline] #[inline]
pub fn root_module(self) -> &'hir Mod<'hir> { pub fn root_module(self) -> &'hir Mod<'hir> {
match self.tcx.hir_owner(CRATE_OWNER_ID).map(|o| o.node) { match self.tcx.hir_owner(CRATE_OWNER_ID) {
Some(OwnerNode::Crate(item)) => item, Some(OwnerNode::Crate(item)) => item,
_ => bug!(), _ => bug!(),
} }
@ -242,27 +242,27 @@ impl<'hir> Map<'hir> {
pub fn get_generics(self, id: LocalDefId) -> Option<&'hir Generics<'hir>> { pub fn get_generics(self, id: LocalDefId) -> Option<&'hir Generics<'hir>> {
let node = self.tcx.hir_owner(OwnerId { def_id: id })?; let node = self.tcx.hir_owner(OwnerId { def_id: id })?;
node.node.generics() node.generics()
} }
pub fn owner(self, id: OwnerId) -> OwnerNode<'hir> { pub fn owner(self, id: OwnerId) -> OwnerNode<'hir> {
self.tcx.hir_owner(id).unwrap_or_else(|| bug!("expected owner for {:?}", id)).node self.tcx.hir_owner(id).unwrap_or_else(|| bug!("expected owner for {:?}", id))
} }
pub fn item(self, id: ItemId) -> &'hir Item<'hir> { pub fn item(self, id: ItemId) -> &'hir Item<'hir> {
self.tcx.hir_owner(id.owner_id).unwrap().node.expect_item() self.tcx.hir_owner(id.owner_id).unwrap().expect_item()
} }
pub fn trait_item(self, id: TraitItemId) -> &'hir TraitItem<'hir> { pub fn trait_item(self, id: TraitItemId) -> &'hir TraitItem<'hir> {
self.tcx.hir_owner(id.owner_id).unwrap().node.expect_trait_item() self.tcx.hir_owner(id.owner_id).unwrap().expect_trait_item()
} }
pub fn impl_item(self, id: ImplItemId) -> &'hir ImplItem<'hir> { pub fn impl_item(self, id: ImplItemId) -> &'hir ImplItem<'hir> {
self.tcx.hir_owner(id.owner_id).unwrap().node.expect_impl_item() self.tcx.hir_owner(id.owner_id).unwrap().expect_impl_item()
} }
pub fn foreign_item(self, id: ForeignItemId) -> &'hir ForeignItem<'hir> { pub fn foreign_item(self, id: ForeignItemId) -> &'hir ForeignItem<'hir> {
self.tcx.hir_owner(id.owner_id).unwrap().node.expect_foreign_item() self.tcx.hir_owner(id.owner_id).unwrap().expect_foreign_item()
} }
pub fn body(self, id: BodyId) -> &'hir Body<'hir> { pub fn body(self, id: BodyId) -> &'hir Body<'hir> {
@ -436,7 +436,7 @@ impl<'hir> Map<'hir> {
pub fn get_module(self, module: LocalModDefId) -> (&'hir Mod<'hir>, Span, HirId) { pub fn get_module(self, module: LocalModDefId) -> (&'hir Mod<'hir>, Span, HirId) {
let hir_id = HirId::make_owner(module.to_local_def_id()); let hir_id = HirId::make_owner(module.to_local_def_id());
match self.tcx.hir_owner(hir_id.owner).map(|o| o.node) { match self.tcx.hir_owner(hir_id.owner) {
Some(OwnerNode::Item(&Item { span, kind: ItemKind::Mod(m), .. })) => (m, span, hir_id), Some(OwnerNode::Item(&Item { span, kind: ItemKind::Mod(m), .. })) => (m, span, hir_id),
Some(OwnerNode::Crate(item)) => (item, item.spans.inner_span, hir_id), Some(OwnerNode::Crate(item)) => (item, item.spans.inner_span, hir_id),
node => panic!("not a module: {node:?}"), node => panic!("not a module: {node:?}"),
@ -726,11 +726,10 @@ impl<'hir> Map<'hir> {
pub fn get_foreign_abi(self, hir_id: HirId) -> Abi { pub fn get_foreign_abi(self, hir_id: HirId) -> Abi {
let parent = self.get_parent_item(hir_id); let parent = self.get_parent_item(hir_id);
if let Some(node) = self.tcx.hir_owner(parent) { if let Some(node) = self.tcx.hir_owner(parent)
if let OwnerNode::Item(Item { kind: ItemKind::ForeignMod { abi, .. }, .. }) = node.node && let OwnerNode::Item(Item { kind: ItemKind::ForeignMod { abi, .. }, .. }) = node
{ {
return *abi; return *abi;
}
} }
bug!( bug!(
"expected foreign mod or inlined parent, found {}", "expected foreign mod or inlined parent, found {}",
@ -742,33 +741,32 @@ impl<'hir> Map<'hir> {
self.tcx self.tcx
.hir_owner(OwnerId { def_id }) .hir_owner(OwnerId { def_id })
.unwrap_or_else(|| bug!("expected owner for {:?}", def_id)) .unwrap_or_else(|| bug!("expected owner for {:?}", def_id))
.node
} }
pub fn expect_item(self, id: LocalDefId) -> &'hir Item<'hir> { pub fn expect_item(self, id: LocalDefId) -> &'hir Item<'hir> {
match self.tcx.hir_owner(OwnerId { def_id: id }) { match self.tcx.hir_owner(OwnerId { def_id: id }) {
Some(Owner { node: OwnerNode::Item(item), .. }) => item, Some(OwnerNode::Item(item)) => item,
_ => bug!("expected item, found {}", self.node_to_string(HirId::make_owner(id))), _ => bug!("expected item, found {}", self.node_to_string(HirId::make_owner(id))),
} }
} }
pub fn expect_impl_item(self, id: LocalDefId) -> &'hir ImplItem<'hir> { pub fn expect_impl_item(self, id: LocalDefId) -> &'hir ImplItem<'hir> {
match self.tcx.hir_owner(OwnerId { def_id: id }) { match self.tcx.hir_owner(OwnerId { def_id: id }) {
Some(Owner { node: OwnerNode::ImplItem(item), .. }) => item, Some(OwnerNode::ImplItem(item)) => item,
_ => bug!("expected impl item, found {}", self.node_to_string(HirId::make_owner(id))), _ => bug!("expected impl item, found {}", self.node_to_string(HirId::make_owner(id))),
} }
} }
pub fn expect_trait_item(self, id: LocalDefId) -> &'hir TraitItem<'hir> { pub fn expect_trait_item(self, id: LocalDefId) -> &'hir TraitItem<'hir> {
match self.tcx.hir_owner(OwnerId { def_id: id }) { match self.tcx.hir_owner(OwnerId { def_id: id }) {
Some(Owner { node: OwnerNode::TraitItem(item), .. }) => item, Some(OwnerNode::TraitItem(item)) => item,
_ => bug!("expected trait item, found {}", self.node_to_string(HirId::make_owner(id))), _ => bug!("expected trait item, found {}", self.node_to_string(HirId::make_owner(id))),
} }
} }
pub fn get_fn_output(self, def_id: LocalDefId) -> Option<&'hir FnRetTy<'hir>> { pub fn get_fn_output(self, def_id: LocalDefId) -> Option<&'hir FnRetTy<'hir>> {
match self.tcx.hir_owner(OwnerId { def_id }) { match self.tcx.hir_owner(OwnerId { def_id }) {
Some(Owner { node, .. }) => node.fn_decl().map(|fn_decl| &fn_decl.output), Some(node) => node.fn_decl().map(|fn_decl| &fn_decl.output),
_ => None, _ => None,
} }
} }
@ -782,7 +780,7 @@ impl<'hir> Map<'hir> {
pub fn expect_foreign_item(self, id: OwnerId) -> &'hir ForeignItem<'hir> { pub fn expect_foreign_item(self, id: OwnerId) -> &'hir ForeignItem<'hir> {
match self.tcx.hir_owner(id) { match self.tcx.hir_owner(id) {
Some(Owner { node: OwnerNode::ForeignItem(item), .. }) => item, Some(OwnerNode::ForeignItem(item)) => item,
_ => { _ => {
bug!( bug!(
"expected foreign item, found {}", "expected foreign item, found {}",

35
compiler/rustc_middle/src/hir/mod.rs
View file

@ -8,34 +8,12 @@ pub mod place;
use crate::query::Providers; use crate::query::Providers;
use crate::ty::{EarlyBinder, ImplSubject, TyCtxt}; use crate::ty::{EarlyBinder, ImplSubject, TyCtxt};
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::sync::{try_par_for_each_in, DynSend, DynSync}; use rustc_data_structures::sync::{try_par_for_each_in, DynSend, DynSync};
use rustc_hir::def::DefKind; use rustc_hir::def::DefKind;
use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId}; use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId};
use rustc_hir::*; use rustc_hir::*;
use rustc_query_system::ich::StableHashingContext;
use rustc_span::{ErrorGuaranteed, ExpnId, DUMMY_SP}; use rustc_span::{ErrorGuaranteed, ExpnId, DUMMY_SP};
/// Top-level HIR node for current owner. This only contains the node for which
/// `HirId::local_id == 0`, and excludes bodies.
///
/// This struct exists to encapsulate all access to the hir_owner query in this module, and to
/// implement HashStable without hashing bodies.
#[derive(Copy, Clone, Debug)]
pub struct Owner<'tcx> {
node: OwnerNode<'tcx>,
}
impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Owner<'tcx> {
#[inline]
fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
// Perform a shallow hash instead using the deep hash saved in `OwnerNodes`. This lets us
// differentiate queries that depend on the full HIR tree from those that only depend on
// the item signature.
hcx.without_hir_bodies(|hcx| self.node.hash_stable(hcx, hasher));
}
}
/// Gather the LocalDefId for each item-like within a module, including items contained within /// Gather the LocalDefId for each item-like within a module, including items contained within
/// bodies. The Ids are in visitor order. This is used to partition a pass between modules. /// bodies. The Ids are in visitor order. This is used to partition a pass between modules.
#[derive(Debug, HashStable, Encodable, Decodable)] #[derive(Debug, HashStable, Encodable, Decodable)]
@ -149,11 +127,6 @@ pub fn provide(providers: &mut Providers) {
providers.hir_crate_items = map::hir_crate_items; providers.hir_crate_items = map::hir_crate_items;
providers.crate_hash = map::crate_hash; providers.crate_hash = map::crate_hash;
providers.hir_module_items = map::hir_module_items; providers.hir_module_items = map::hir_module_items;
providers.hir_owner = |tcx, id| {
let owner = tcx.hir_crate(()).owners.get(id.def_id)?.as_owner()?;
let node = owner.node();
Some(Owner { node })
};
providers.opt_local_def_id_to_hir_id = |tcx, id| { providers.opt_local_def_id_to_hir_id = |tcx, id| {
let owner = tcx.hir_crate(()).owners[id].map(|_| ()); let owner = tcx.hir_crate(()).owners[id].map(|_| ());
Some(match owner { Some(match owner {
@ -162,7 +135,13 @@ pub fn provide(providers: &mut Providers) {
MaybeOwner::NonOwner(hir_id) => hir_id, MaybeOwner::NonOwner(hir_id) => hir_id,
}) })
}; };
providers.hir_owner_nodes = |tcx, id| tcx.hir_crate(()).owners[id.def_id].map(|i| &i.nodes); providers.hir_owner_nodes = |tcx, id| {
if let Some(i) = tcx.hir_crate(()).owners.get(id.def_id) {
i.map(|i| &i.nodes)
} else {
MaybeOwner::Phantom
}
};
providers.hir_owner_parent = |tcx, id| { providers.hir_owner_parent = |tcx, id| {
// Accessing the local_parent is ok since its value is hashed as part of `id`'s DefPathHash. // Accessing the local_parent is ok since its value is hashed as part of `id`'s DefPathHash.
tcx.opt_local_parent(id.def_id).map_or(CRATE_HIR_ID, |parent| { tcx.opt_local_parent(id.def_id).map_or(CRATE_HIR_ID, |parent| {

5
compiler/rustc_middle/src/query/erase.rs
View file

@ -164,10 +164,6 @@ impl<T> EraseType for Option<&'_ [T]> {
type Result = [u8; size_of::<Option<&'static [()]>>()]; type Result = [u8; size_of::<Option<&'static [()]>>()];
} }
impl EraseType for Option<rustc_middle::hir::Owner<'_>> {
type Result = [u8; size_of::<Option<rustc_middle::hir::Owner<'static>>>()];
}
impl EraseType for Option<mir::DestructuredConstant<'_>> { impl EraseType for Option<mir::DestructuredConstant<'_>> {
type Result = [u8; size_of::<Option<mir::DestructuredConstant<'static>>>()]; type Result = [u8; size_of::<Option<mir::DestructuredConstant<'static>>>()];
} }
@ -324,7 +320,6 @@ macro_rules! tcx_lifetime {
} }
tcx_lifetime! { tcx_lifetime! {
rustc_middle::hir::Owner,
rustc_middle::middle::exported_symbols::ExportedSymbol, rustc_middle::middle::exported_symbols::ExportedSymbol,
rustc_middle::mir::Const, rustc_middle::mir::Const,
rustc_middle::mir::DestructuredConstant, rustc_middle::mir::DestructuredConstant,

8
compiler/rustc_middle/src/query/mod.rs
View file

@ -174,14 +174,6 @@ rustc_queries! {
cache_on_disk_if { true } cache_on_disk_if { true }
} }
/// Gives access to the HIR node for the HIR owner `key`.
///
/// This can be conveniently accessed by methods on `tcx.hir()`.
/// Avoid calling this query directly.
query hir_owner(key: hir::OwnerId) -> Option<crate::hir::Owner<'tcx>> {
desc { |tcx| "getting HIR owner of `{}`", tcx.def_path_str(key) }
}
/// Gives access to the HIR ID for the given `LocalDefId` owner `key` if any. /// Gives access to the HIR ID for the given `LocalDefId` owner `key` if any.
/// ///
/// Definitions that were generated with no HIR, would be fed to return `None`. /// Definitions that were generated with no HIR, would be fed to return `None`.

35
compiler/rustc_query_system/src/ich/hcx.rs
View file

@ -1,10 +1,8 @@
use crate::ich; use crate::ich;
use rustc_ast as ast; use rustc_ast as ast;
use rustc_data_structures::sorted_map::SortedMap;
use rustc_data_structures::stable_hasher::{HashStable, HashingControls, StableHasher}; use rustc_data_structures::stable_hasher::{HashStable, HashingControls, StableHasher};
use rustc_data_structures::sync::Lrc; use rustc_data_structures::sync::Lrc;
use rustc_hir as hir;
use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::def_id::{DefId, LocalDefId};
use rustc_hir::definitions::DefPathHash; use rustc_hir::definitions::DefPathHash;
use rustc_session::cstore::Untracked; use rustc_session::cstore::Untracked;
@ -23,7 +21,6 @@ pub struct StableHashingContext<'a> {
// The value of `-Z incremental-ignore-spans`. // The value of `-Z incremental-ignore-spans`.
// This field should only be used by `unstable_opts_incremental_ignore_span` // This field should only be used by `unstable_opts_incremental_ignore_span`
incremental_ignore_spans: bool, incremental_ignore_spans: bool,
pub(super) body_resolver: BodyResolver<'a>,
// Very often, we are hashing something that does not need the // Very often, we are hashing something that does not need the
// `CachingSourceMapView`, so we initialize it lazily. // `CachingSourceMapView`, so we initialize it lazily.
raw_source_map: &'a SourceMap, raw_source_map: &'a SourceMap,
@ -31,26 +28,12 @@ pub struct StableHashingContext<'a> {
hashing_controls: HashingControls, hashing_controls: HashingControls,
} }
/// The `BodyResolver` allows mapping a `BodyId` to the corresponding `hir::Body`.
/// We could also just store a plain reference to the `hir::Crate` but we want
/// to avoid that the crate is used to get untracked access to all of the HIR.
#[derive(Clone, Copy)]
pub(super) enum BodyResolver<'tcx> {
Forbidden,
Ignore,
Traverse {
owner: hir::OwnerId,
bodies: &'tcx SortedMap<hir::ItemLocalId, &'tcx hir::Body<'tcx>>,
},
}
impl<'a> StableHashingContext<'a> { impl<'a> StableHashingContext<'a> {
#[inline] #[inline]
pub fn new(sess: &'a Session, untracked: &'a Untracked) -> Self { pub fn new(sess: &'a Session, untracked: &'a Untracked) -> Self {
let hash_spans_initial = !sess.opts.unstable_opts.incremental_ignore_spans; let hash_spans_initial = !sess.opts.unstable_opts.incremental_ignore_spans;
StableHashingContext { StableHashingContext {
body_resolver: BodyResolver::Forbidden,
untracked, untracked,
incremental_ignore_spans: sess.opts.unstable_opts.incremental_ignore_spans, incremental_ignore_spans: sess.opts.unstable_opts.incremental_ignore_spans,
caching_source_map: None, caching_source_map: None,
@ -59,24 +42,6 @@ impl<'a> StableHashingContext<'a> {
} }
} }
#[inline]
pub fn without_hir_bodies(&mut self, f: impl FnOnce(&mut StableHashingContext<'_>)) {
f(&mut StableHashingContext { body_resolver: BodyResolver::Ignore, ..self.clone() });
}
#[inline]
pub fn with_hir_bodies(
&mut self,
owner: hir::OwnerId,
bodies: &SortedMap<hir::ItemLocalId, &hir::Body<'_>>,
f: impl FnOnce(&mut StableHashingContext<'_>),
) {
f(&mut StableHashingContext {
body_resolver: BodyResolver::Traverse { owner, bodies },
..self.clone()
});
}
#[inline] #[inline]
pub fn while_hashing_spans<F: FnOnce(&mut Self)>(&mut self, hash_spans: bool, f: F) { pub fn while_hashing_spans<F: FnOnce(&mut Self)>(&mut self, hash_spans: bool, f: F) {
let prev_hash_spans = self.hashing_controls.hash_spans; let prev_hash_spans = self.hashing_controls.hash_spans;

22
compiler/rustc_query_system/src/ich/impls_hir.rs
View file

@ -1,22 +0,0 @@
//! This module contains `HashStable` implementations for various HIR data
//! types in no particular order.
use crate::ich::hcx::BodyResolver;
use crate::ich::StableHashingContext;
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_hir as hir;
impl<'ctx> rustc_hir::HashStableContext for StableHashingContext<'ctx> {
#[inline]
fn hash_body_id(&mut self, id: hir::BodyId, hasher: &mut StableHasher) {
let hcx = self;
match hcx.body_resolver {
BodyResolver::Forbidden => panic!("Hashing HIR bodies is forbidden."),
BodyResolver::Ignore => {}
BodyResolver::Traverse { owner, bodies } => {
assert_eq!(id.hir_id.owner, owner);
bodies[&id.hir_id.local_id].hash_stable(hcx, hasher);
}
}
}
}

2
compiler/rustc_query_system/src/ich/impls_syntax.rs
View file

@ -57,6 +57,8 @@ impl<'ctx> rustc_ast::HashStableContext for StableHashingContext<'ctx> {
} }
} }
impl<'ctx> rustc_hir::HashStableContext for StableHashingContext<'ctx> {}
impl<'a> HashStable<StableHashingContext<'a>> for SourceFile { impl<'a> HashStable<StableHashingContext<'a>> for SourceFile {
fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) { fn hash_stable(&self, hcx: &mut StableHashingContext<'a>, hasher: &mut StableHasher) {
let SourceFile { let SourceFile {

1
compiler/rustc_query_system/src/ich/mod.rs
View file

@ -4,7 +4,6 @@ pub use self::hcx::StableHashingContext;
use rustc_span::symbol::{sym, Symbol}; use rustc_span::symbol::{sym, Symbol};
mod hcx; mod hcx;
mod impls_hir;
mod impls_syntax; mod impls_syntax;
pub const IGNORED_ATTRIBUTES: &[Symbol] = &[ pub const IGNORED_ATTRIBUTES: &[Symbol] = &[

5
tests/incremental/dirty_clean.rs
View file

@ -26,12 +26,11 @@ mod y {
use x; use x;
#[rustc_clean( #[rustc_clean(
except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of,fn_sig", except="hir_owner_nodes,generics_of,predicates_of,type_of,fn_sig",
cfg="cfail2", cfg="cfail2",
)] )]
pub fn y() { pub fn y() {
//[cfail2]~^ ERROR `hir_owner(y)` should be dirty but is not //[cfail2]~^ ERROR `hir_owner_nodes(y)` should be dirty but is not
//[cfail2]~| ERROR `hir_owner_nodes(y)` should be dirty but is not
//[cfail2]~| ERROR `generics_of(y)` should be dirty but is not //[cfail2]~| ERROR `generics_of(y)` should be dirty but is not
//[cfail2]~| ERROR `predicates_of(y)` should be dirty but is not //[cfail2]~| ERROR `predicates_of(y)` should be dirty but is not
//[cfail2]~| ERROR `type_of(y)` should be dirty but is not //[cfail2]~| ERROR `type_of(y)` should be dirty but is not

4
tests/incremental/hash-module-order.rs
View file

@ -12,14 +12,14 @@
#![feature(rustc_attrs)] #![feature(rustc_attrs)]
#[cfg(rpass1)] #[cfg(rpass1)]
#[rustc_clean(cfg="rpass1",except="hir_owner")] #[rustc_clean(cfg="rpass1",except="hir_owner_nodes")]
mod foo { mod foo {
struct First; struct First;
struct Second; struct Second;
} }
#[cfg(rpass2)] #[cfg(rpass2)]
#[rustc_clean(cfg="rpass2",except="hir_owner")] #[rustc_clean(cfg="rpass2",except="hir_owner_nodes")]
mod foo { mod foo {
struct Second; struct Second;
struct First; struct First;

10
tests/incremental/hashes/consts.rs
View file

@ -19,7 +19,7 @@
const CONST_VISIBILITY: u8 = 0; const CONST_VISIBILITY: u8 = 0;
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
pub const CONST_VISIBILITY: u8 = 0; pub const CONST_VISIBILITY: u8 = 0;
@ -29,7 +29,7 @@ pub const CONST_VISIBILITY: u8 = 0;
const CONST_CHANGE_TYPE_1: i32 = 0; const CONST_CHANGE_TYPE_1: i32 = 0;
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
const CONST_CHANGE_TYPE_1: u32 = 0; const CONST_CHANGE_TYPE_1: u32 = 0;
@ -39,7 +39,7 @@ const CONST_CHANGE_TYPE_1: u32 = 0;
const CONST_CHANGE_TYPE_2: Option<u32> = None; const CONST_CHANGE_TYPE_2: Option<u32> = None;
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
const CONST_CHANGE_TYPE_2: Option<u64> = None; const CONST_CHANGE_TYPE_2: Option<u64> = None;
@ -99,11 +99,11 @@ mod const_change_type_indirectly {
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
use super::ReferencedType2 as Type; use super::ReferencedType2 as Type;
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
const CONST_CHANGE_TYPE_INDIRECTLY_1: Type = Type; const CONST_CHANGE_TYPE_INDIRECTLY_1: Type = Type;
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
const CONST_CHANGE_TYPE_INDIRECTLY_2: Option<Type> = None; const CONST_CHANGE_TYPE_INDIRECTLY_2: Option<Type> = None;
} }

36
tests/incremental/hashes/enum_constructors.rs
View file

@ -148,17 +148,9 @@ pub mod change_constructor_path_indirectly_struct_like {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::Enum2 as TheEnum; use super::Enum2 as TheEnum;
#[rustc_clean( #[rustc_clean(cfg="cfail2", except="fn_sig,hir_owner_nodes,optimized_mir,typeck")]
cfg="cfail2",
except="fn_sig,hir_owner,hir_owner_nodes,optimized_mir,\
typeck"
)]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean( #[rustc_clean(cfg="cfail5", except="fn_sig,hir_owner_nodes,optimized_mir,typeck")]
cfg="cfail5",
except="fn_sig,hir_owner,hir_owner_nodes,optimized_mir,\
typeck"
)]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn function() -> TheEnum { pub fn function() -> TheEnum {
TheEnum::Struct { TheEnum::Struct {
@ -261,17 +253,9 @@ pub mod change_constructor_path_indirectly_tuple_like {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::Enum2 as TheEnum; use super::Enum2 as TheEnum;
#[rustc_clean( #[rustc_clean(cfg="cfail2", except="fn_sig,hir_owner_nodes,optimized_mir,typeck")]
cfg="cfail2",
except="fn_sig,hir_owner,hir_owner_nodes,optimized_mir,\
typeck"
)]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean( #[rustc_clean(cfg="cfail5", except="fn_sig,hir_owner_nodes,optimized_mir,typeck")]
cfg="cfail5",
except="fn_sig,hir_owner,hir_owner_nodes,optimized_mir,\
typeck"
)]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn function() -> TheEnum { pub fn function() -> TheEnum {
TheEnum::Tuple(0, 1, 2) TheEnum::Tuple(0, 1, 2)
@ -350,17 +334,9 @@ pub mod change_constructor_path_indirectly_c_like {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::Clike2 as TheEnum; use super::Clike2 as TheEnum;
#[rustc_clean( #[rustc_clean(cfg="cfail2", except="fn_sig,hir_owner_nodes,optimized_mir,typeck")]
cfg="cfail2",
except="fn_sig,hir_owner,hir_owner_nodes,optimized_mir,\
typeck"
)]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean( #[rustc_clean(cfg="cfail5", except="fn_sig,hir_owner_nodes,optimized_mir,typeck")]
cfg="cfail5",
except="fn_sig,hir_owner,hir_owner_nodes,optimized_mir,\
typeck"
)]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn function() -> TheEnum { pub fn function() -> TheEnum {
TheEnum::B TheEnum::B

134
tests/incremental/hashes/enum_defs.rs
View file

@ -31,7 +31,7 @@ enum EnumVisibility { A }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub enum EnumVisibility { A } pub enum EnumVisibility { A }
@ -45,9 +45,9 @@ enum EnumChangeNameCStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumChangeNameCStyleVariant { enum EnumChangeNameCStyleVariant {
Variant1, Variant1,
@ -64,9 +64,9 @@ enum EnumChangeNameTupleStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumChangeNameTupleStyleVariant { enum EnumChangeNameTupleStyleVariant {
Variant1, Variant1,
@ -83,9 +83,9 @@ enum EnumChangeNameStructStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumChangeNameStructStyleVariant { enum EnumChangeNameStructStyleVariant {
Variant1, Variant1,
@ -118,9 +118,9 @@ enum EnumChangeValueCStyleVariant1 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumChangeValueCStyleVariant1 { enum EnumChangeValueCStyleVariant1 {
Variant1, Variant1,
@ -136,9 +136,9 @@ enum EnumAddCStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumAddCStyleVariant { enum EnumAddCStyleVariant {
Variant1, Variant1,
@ -155,9 +155,9 @@ enum EnumRemoveCStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumRemoveCStyleVariant { enum EnumRemoveCStyleVariant {
Variant1, Variant1,
@ -172,9 +172,9 @@ enum EnumAddTupleStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumAddTupleStyleVariant { enum EnumAddTupleStyleVariant {
Variant1, Variant1,
@ -191,9 +191,9 @@ enum EnumRemoveTupleStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumRemoveTupleStyleVariant { enum EnumRemoveTupleStyleVariant {
Variant1, Variant1,
@ -208,9 +208,9 @@ enum EnumAddStructStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumAddStructStyleVariant { enum EnumAddStructStyleVariant {
Variant1, Variant1,
@ -227,9 +227,9 @@ enum EnumRemoveStructStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumRemoveStructStyleVariant { enum EnumRemoveStructStyleVariant {
Variant1, Variant1,
@ -244,9 +244,9 @@ enum EnumChangeFieldTypeTupleStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumChangeFieldTypeTupleStyleVariant { enum EnumChangeFieldTypeTupleStyleVariant {
Variant1(u32, Variant1(u32,
@ -263,9 +263,9 @@ enum EnumChangeFieldTypeStructStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumChangeFieldTypeStructStyleVariant { enum EnumChangeFieldTypeStructStyleVariant {
Variant1, Variant1,
@ -284,9 +284,9 @@ enum EnumChangeFieldNameStructStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumChangeFieldNameStructStyleVariant { enum EnumChangeFieldNameStructStyleVariant {
Variant1 { a: u32, c: u32 }, Variant1 { a: u32, c: u32 },
@ -301,9 +301,9 @@ enum EnumChangeOrderTupleStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumChangeOrderTupleStyleVariant { enum EnumChangeOrderTupleStyleVariant {
Variant1( Variant1(
@ -320,9 +320,9 @@ enum EnumChangeFieldOrderStructStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumChangeFieldOrderStructStyleVariant { enum EnumChangeFieldOrderStructStyleVariant {
Variant1 { b: f32, a: u32 }, Variant1 { b: f32, a: u32 },
@ -337,9 +337,9 @@ enum EnumAddFieldTupleStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumAddFieldTupleStyleVariant { enum EnumAddFieldTupleStyleVariant {
Variant1(u32, u32, u32), Variant1(u32, u32, u32),
@ -354,9 +354,9 @@ enum EnumAddFieldStructStyleVariant {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumAddFieldStructStyleVariant { enum EnumAddFieldStructStyleVariant {
Variant1 { a: u32, b: u32, c: u32 }, Variant1 { a: u32, b: u32, c: u32 },
@ -411,9 +411,9 @@ enum EnumChangeNameOfTypeParameter<S> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,generics_of,predicates_of,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,generics_of,predicates_of,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumChangeNameOfTypeParameter<T> { enum EnumChangeNameOfTypeParameter<T> {
Variant1(T), Variant1(T),
@ -429,9 +429,9 @@ enum EnumAddTypeParameter<S> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,generics_of,predicates_of,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,generics_of,predicates_of,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumAddTypeParameter<S, T> { enum EnumAddTypeParameter<S, T> {
Variant1(S), Variant1(S),
@ -447,9 +447,9 @@ enum EnumChangeNameOfLifetimeParameter<'a> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,generics_of,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,generics_of,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,generics_of,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,generics_of,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumChangeNameOfLifetimeParameter<'b> { enum EnumChangeNameOfLifetimeParameter<'b> {
Variant1(&'b u32), Variant1(&'b u32),
@ -465,9 +465,9 @@ enum EnumAddLifetimeParameter<'a> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,generics_of,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,generics_of,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,generics_of,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,generics_of,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumAddLifetimeParameter<'a, 'b> { enum EnumAddLifetimeParameter<'a, 'b> {
Variant1(&'a u32), Variant1(&'a u32),
@ -484,9 +484,9 @@ enum EnumAddLifetimeParameterBound<'a, 'b> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumAddLifetimeParameterBound<'a, 'b: 'a> { enum EnumAddLifetimeParameterBound<'a, 'b: 'a> {
Variant1(&'a u32), Variant1(&'a u32),
@ -501,9 +501,9 @@ enum EnumAddLifetimeBoundToParameter<'a, T> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumAddLifetimeBoundToParameter<'a, T: 'a> { enum EnumAddLifetimeBoundToParameter<'a, T: 'a> {
Variant1(T), Variant1(T),
@ -519,9 +519,9 @@ enum EnumAddTraitBound<S> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,generics_of,predicates_of,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,generics_of,predicates_of,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumAddTraitBound<T: Sync> { enum EnumAddTraitBound<T: Sync> {
Variant1(T), Variant1(T),
@ -537,9 +537,9 @@ enum EnumAddLifetimeParameterBoundWhere<'a, 'b> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumAddLifetimeParameterBoundWhere<'a, 'b> where 'b: 'a { enum EnumAddLifetimeParameterBoundWhere<'a, 'b> where 'b: 'a {
Variant1(&'a u32), Variant1(&'a u32),
@ -556,9 +556,9 @@ enum EnumAddLifetimeBoundToParameterWhere<'a, T> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumAddLifetimeBoundToParameterWhere<'a, T> where T: 'a { enum EnumAddLifetimeBoundToParameterWhere<'a, T> where T: 'a {
Variant1(T), Variant1(T),
@ -574,9 +574,9 @@ enum EnumAddTraitBoundWhere<S> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,generics_of,predicates_of,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,generics_of,predicates_of,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumAddTraitBoundWhere<T> where T: Sync { enum EnumAddTraitBoundWhere<T> where T: Sync {
Variant1(T), Variant1(T),
@ -592,9 +592,9 @@ enum EnumSwapUsageTypeParameters<A, B> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumSwapUsageTypeParameters<A, B> { enum EnumSwapUsageTypeParameters<A, B> {
Variant1 { Variant1 {
@ -615,9 +615,9 @@ enum EnumSwapUsageLifetimeParameters<'a, 'b> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum EnumSwapUsageLifetimeParameters<'a, 'b> { enum EnumSwapUsageLifetimeParameters<'a, 'b> {
Variant1 { Variant1 {
@ -642,9 +642,9 @@ mod change_field_type_indirectly_tuple_style {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::ReferencedType2 as FieldType; use super::ReferencedType2 as FieldType;
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum TupleStyle { enum TupleStyle {
Variant1( Variant1(
@ -662,9 +662,9 @@ mod change_field_type_indirectly_struct_style {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::ReferencedType2 as FieldType; use super::ReferencedType2 as FieldType;
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum StructStyle { enum StructStyle {
Variant1 { Variant1 {
@ -687,9 +687,9 @@ mod change_trait_bound_indirectly {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::ReferencedTrait2 as Trait; use super::ReferencedTrait2 as Trait;
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum Enum<T: Trait> { enum Enum<T: Trait> {
Variant1(T) Variant1(T)
@ -705,9 +705,9 @@ mod change_trait_bound_indirectly_where {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::ReferencedTrait2 as Trait; use super::ReferencedTrait2 as Trait;
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
enum Enum<T> where T: Trait { enum Enum<T> where T: Trait {
Variant1(T) Variant1(T)

12
tests/incremental/hashes/extern_mods.rs
View file

@ -24,9 +24,9 @@ extern "C" {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg = "cfail2", except = "hir_owner,hir_owner_nodes")] #[rustc_clean(cfg = "cfail2", except = "hir_owner_nodes")]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean(cfg = "cfail5", except = "hir_owner,hir_owner_nodes")] #[rustc_clean(cfg = "cfail5", except = "hir_owner_nodes")]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
extern "C" { extern "C" {
pub fn change_function_name2(c: i64) -> i32; pub fn change_function_name2(c: i64) -> i32;
@ -129,9 +129,9 @@ extern "C" {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg = "cfail2", except = "hir_owner,hir_owner_nodes")] #[rustc_clean(cfg = "cfail2", except = "hir_owner_nodes")]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean(cfg = "cfail5", except = "hir_owner,hir_owner_nodes")] #[rustc_clean(cfg = "cfail5", except = "hir_owner_nodes")]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
extern "rust-call" { extern "rust-call" {
pub fn change_calling_convention(c: (i32,)); pub fn change_calling_convention(c: (i32,));
@ -159,9 +159,9 @@ extern "C" {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg = "cfail2", except = "hir_owner,hir_owner_nodes")] #[rustc_clean(cfg = "cfail2", except = "hir_owner_nodes")]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean(cfg = "cfail5", except = "hir_owner,hir_owner_nodes")] #[rustc_clean(cfg = "cfail5", except = "hir_owner_nodes")]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
extern "C" { extern "C" {
pub fn add_function1(c: i32); pub fn add_function1(c: i32);

76
tests/incremental/hashes/function_interfaces.rs
View file

@ -25,12 +25,12 @@ pub fn add_parameter() {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean( #[rustc_clean(
cfg = "cfail2", cfg = "cfail2",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean( #[rustc_clean(
cfg = "cfail5", cfg = "cfail5",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn add_parameter(p: i32) {} pub fn add_parameter(p: i32) {}
@ -41,9 +41,9 @@ pub fn add_parameter(p: i32) {}
pub fn add_return_type() {} pub fn add_return_type() {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg = "cfail2", except = "hir_owner, hir_owner_nodes")] #[rustc_clean(cfg = "cfail2", except = "hir_owner_nodes")]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean(cfg = "cfail5", except = "hir_owner, hir_owner_nodes, optimized_mir")] #[rustc_clean(cfg = "cfail5", except = "hir_owner_nodes, optimized_mir")]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn add_return_type() -> () {} pub fn add_return_type() -> () {}
@ -55,12 +55,12 @@ pub fn type_of_parameter(p: i32) {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean( #[rustc_clean(
cfg = "cfail2", cfg = "cfail2",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean( #[rustc_clean(
cfg = "cfail5", cfg = "cfail5",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn type_of_parameter(p: i64) {} pub fn type_of_parameter(p: i64) {}
@ -73,12 +73,12 @@ pub fn type_of_parameter_ref(p: &i32) {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean( #[rustc_clean(
cfg = "cfail2", cfg = "cfail2",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean( #[rustc_clean(
cfg = "cfail5", cfg = "cfail5",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn type_of_parameter_ref(p: &mut i32) {} pub fn type_of_parameter_ref(p: &mut i32) {}
@ -91,12 +91,12 @@ pub fn order_of_parameters(p1: i32, p2: i64) {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean( #[rustc_clean(
cfg = "cfail2", cfg = "cfail2",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean( #[rustc_clean(
cfg = "cfail5", cfg = "cfail5",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn order_of_parameters(p2: i64, p1: i32) {} pub fn order_of_parameters(p2: i64, p1: i32) {}
@ -109,12 +109,12 @@ pub fn make_unsafe() {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean( #[rustc_clean(
cfg = "cfail2", cfg = "cfail2",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean( #[rustc_clean(
cfg = "cfail5", cfg = "cfail5",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub unsafe fn make_unsafe() {} pub unsafe fn make_unsafe() {}
@ -125,9 +125,9 @@ pub unsafe fn make_unsafe() {}
pub fn make_extern() {} pub fn make_extern() {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg = "cfail2", except = "hir_owner, hir_owner_nodes, typeck, fn_sig")] #[rustc_clean(cfg = "cfail2", except = "hir_owner_nodes, typeck, fn_sig")]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean(cfg = "cfail5", except = "hir_owner, hir_owner_nodes, typeck, fn_sig")] #[rustc_clean(cfg = "cfail5", except = "hir_owner_nodes, typeck, fn_sig")]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub extern "C" fn make_extern() {} pub extern "C" fn make_extern() {}
@ -139,12 +139,12 @@ pub fn type_parameter () {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean( #[rustc_clean(
cfg = "cfail2", cfg = "cfail2",
except = "hir_owner, hir_owner_nodes, generics_of, type_of, predicates_of" except = "hir_owner_nodes, generics_of, type_of, predicates_of"
)] )]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean( #[rustc_clean(
cfg = "cfail5", cfg = "cfail5",
except = "hir_owner, hir_owner_nodes, generics_of, type_of, predicates_of" except = "hir_owner_nodes, generics_of, type_of, predicates_of"
)] )]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn type_parameter<T>() {} pub fn type_parameter<T>() {}
@ -155,9 +155,9 @@ pub fn type_parameter<T>() {}
pub fn lifetime_parameter () {} pub fn lifetime_parameter () {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg = "cfail2", except = "hir_owner, hir_owner_nodes, generics_of,fn_sig")] #[rustc_clean(cfg = "cfail2", except = "hir_owner_nodes, generics_of,fn_sig")]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean(cfg = "cfail5", except = "hir_owner, hir_owner_nodes, generics_of,fn_sig")] #[rustc_clean(cfg = "cfail5", except = "hir_owner_nodes, generics_of,fn_sig")]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn lifetime_parameter<'a>() {} pub fn lifetime_parameter<'a>() {}
@ -167,7 +167,7 @@ pub fn lifetime_parameter<'a>() {}
pub fn trait_bound<T >() {} pub fn trait_bound<T >() {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg = "cfail2", except = "hir_owner, hir_owner_nodes, predicates_of")] #[rustc_clean(cfg = "cfail2", except = "hir_owner_nodes, predicates_of")]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
pub fn trait_bound<T: Eq>() {} pub fn trait_bound<T: Eq>() {}
@ -177,9 +177,9 @@ pub fn trait_bound<T: Eq>() {}
pub fn builtin_bound<T >() {} pub fn builtin_bound<T >() {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg = "cfail2", except = "hir_owner, hir_owner_nodes, predicates_of")] #[rustc_clean(cfg = "cfail2", except = "hir_owner_nodes, predicates_of")]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean(cfg = "cfail5", except = "hir_owner, hir_owner_nodes, predicates_of")] #[rustc_clean(cfg = "cfail5", except = "hir_owner_nodes, predicates_of")]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn builtin_bound<T: Send>() {} pub fn builtin_bound<T: Send>() {}
@ -191,12 +191,12 @@ pub fn lifetime_bound<'a, T>() {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean( #[rustc_clean(
cfg = "cfail2", cfg = "cfail2",
except = "hir_owner, hir_owner_nodes, generics_of, type_of, predicates_of,fn_sig" except = "hir_owner_nodes, generics_of, type_of, predicates_of,fn_sig"
)] )]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean( #[rustc_clean(
cfg = "cfail5", cfg = "cfail5",
except = "hir_owner, hir_owner_nodes, generics_of, type_of, predicates_of,fn_sig,optimized_mir" except = "hir_owner_nodes, generics_of, type_of, predicates_of,fn_sig,optimized_mir"
)] )]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn lifetime_bound<'a, T: 'a>() {} pub fn lifetime_bound<'a, T: 'a>() {}
@ -207,7 +207,7 @@ pub fn lifetime_bound<'a, T: 'a>() {}
pub fn second_trait_bound<T: Eq >() {} pub fn second_trait_bound<T: Eq >() {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg = "cfail2", except = "hir_owner, hir_owner_nodes, predicates_of")] #[rustc_clean(cfg = "cfail2", except = "hir_owner_nodes, predicates_of")]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
pub fn second_trait_bound<T: Eq + Clone>() {} pub fn second_trait_bound<T: Eq + Clone>() {}
@ -217,9 +217,9 @@ pub fn second_trait_bound<T: Eq + Clone>() {}
pub fn second_builtin_bound<T: Send >() {} pub fn second_builtin_bound<T: Send >() {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg = "cfail2", except = "hir_owner, hir_owner_nodes, predicates_of")] #[rustc_clean(cfg = "cfail2", except = "hir_owner_nodes, predicates_of")]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean(cfg = "cfail5", except = "hir_owner, hir_owner_nodes, predicates_of")] #[rustc_clean(cfg = "cfail5", except = "hir_owner_nodes, predicates_of")]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn second_builtin_bound<T: Send + Sized>() {} pub fn second_builtin_bound<T: Send + Sized>() {}
@ -231,12 +231,12 @@ pub fn second_lifetime_bound<'a, 'b, T: 'a >() {}
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean( #[rustc_clean(
cfg = "cfail2", cfg = "cfail2",
except = "hir_owner, hir_owner_nodes, generics_of, type_of, predicates_of,fn_sig" except = "hir_owner_nodes, generics_of, type_of, predicates_of,fn_sig"
)] )]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean( #[rustc_clean(
cfg = "cfail5", cfg = "cfail5",
except = "hir_owner, hir_owner_nodes, generics_of, type_of, predicates_of,fn_sig" except = "hir_owner_nodes, generics_of, type_of, predicates_of,fn_sig"
)] )]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn second_lifetime_bound<'a, 'b, T: 'a + 'b>() {} pub fn second_lifetime_bound<'a, 'b, T: 'a + 'b>() {}
@ -302,9 +302,9 @@ pub fn return_impl_trait() -> i32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg = "cfail2", except = "hir_owner, hir_owner_nodes, typeck, fn_sig")] #[rustc_clean(cfg = "cfail2", except = "hir_owner_nodes, typeck, fn_sig")]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean(cfg = "cfail5", except = "hir_owner, hir_owner_nodes, typeck, fn_sig, optimized_mir")] #[rustc_clean(cfg = "cfail5", except = "hir_owner_nodes, typeck, fn_sig, optimized_mir")]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn return_impl_trait() -> impl Clone { pub fn return_impl_trait() -> impl Clone {
0 0
@ -339,12 +339,12 @@ pub mod change_return_type_indirectly {
#[rustc_clean( #[rustc_clean(
cfg = "cfail2", cfg = "cfail2",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean( #[rustc_clean(
cfg = "cfail5", cfg = "cfail5",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn indirect_return_type() -> ReturnType { pub fn indirect_return_type() -> ReturnType {
@ -362,12 +362,12 @@ pub mod change_parameter_type_indirectly {
#[rustc_clean( #[rustc_clean(
cfg = "cfail2", cfg = "cfail2",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean( #[rustc_clean(
cfg = "cfail5", cfg = "cfail5",
except = "hir_owner, hir_owner_nodes, optimized_mir, typeck, fn_sig" except = "hir_owner_nodes, optimized_mir, typeck, fn_sig"
)] )]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn indirect_parameter_type(p: ParameterType) {} pub fn indirect_parameter_type(p: ParameterType) {}
@ -384,9 +384,9 @@ pub mod change_trait_bound_indirectly {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::ReferencedTrait2 as Trait; use super::ReferencedTrait2 as Trait;
#[rustc_clean(cfg = "cfail2", except = "hir_owner, hir_owner_nodes, predicates_of")] #[rustc_clean(cfg = "cfail2", except = "hir_owner_nodes, predicates_of")]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean(cfg = "cfail5", except = "hir_owner, hir_owner_nodes, predicates_of")] #[rustc_clean(cfg = "cfail5", except = "hir_owner_nodes, predicates_of")]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn indirect_trait_bound<T: Trait>(p: T) {} pub fn indirect_trait_bound<T: Trait>(p: T) {}
} }
@ -399,9 +399,9 @@ pub mod change_trait_bound_indirectly_in_where_clause {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::ReferencedTrait2 as Trait; use super::ReferencedTrait2 as Trait;
#[rustc_clean(cfg = "cfail2", except = "hir_owner, hir_owner_nodes, predicates_of")] #[rustc_clean(cfg = "cfail2", except = "hir_owner_nodes, predicates_of")]
#[rustc_clean(cfg = "cfail3")] #[rustc_clean(cfg = "cfail3")]
#[rustc_clean(cfg = "cfail5", except = "hir_owner, hir_owner_nodes, predicates_of")] #[rustc_clean(cfg = "cfail5", except = "hir_owner_nodes, predicates_of")]
#[rustc_clean(cfg = "cfail6")] #[rustc_clean(cfg = "cfail6")]
pub fn indirect_trait_bound_where<T>(p: T) pub fn indirect_trait_bound_where<T>(p: T)
where where

16
tests/incremental/hashes/if_expressions.rs
View file

@ -27,9 +27,9 @@ pub fn change_condition(x: bool) -> u32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn change_condition(x: bool) -> u32 { pub fn change_condition(x: bool) -> u32 {
if !x { if !x {
@ -103,9 +103,9 @@ pub fn add_else_branch(x: bool) -> u32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_else_branch(x: bool) -> u32 { pub fn add_else_branch(x: bool) -> u32 {
let mut ret = 1; let mut ret = 1;
@ -156,9 +156,9 @@ pub fn change_then_branch_if_let(x: Option<u32>) -> u32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn change_then_branch_if_let(x: Option<u32>) -> u32 { pub fn change_then_branch_if_let(x: Option<u32>) -> u32 {
if let Some(x) = x { if let Some(x) = x {
@ -209,9 +209,9 @@ pub fn add_else_branch_if_let(x: Option<u32>) -> u32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,typeck,optimized_mir")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,typeck,optimized_mir")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_else_branch_if_let(x: Option<u32>) -> u32 { pub fn add_else_branch_if_let(x: Option<u32>) -> u32 {
let mut ret = 1; let mut ret = 1;

12
tests/incremental/hashes/indexing_expressions.rs
View file

@ -74,9 +74,9 @@ fn add_lower_bound(slice: &[u32]) -> &[u32] {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,typeck", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,typeck", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,typeck", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,typeck", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
fn add_lower_bound(slice: &[u32]) -> &[u32] { fn add_lower_bound(slice: &[u32]) -> &[u32] {
&slice[3..4] &slice[3..4]
@ -91,9 +91,9 @@ fn add_upper_bound(slice: &[u32]) -> &[u32] {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,typeck", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,typeck", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,typeck", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,typeck", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
fn add_upper_bound(slice: &[u32]) -> &[u32] { fn add_upper_bound(slice: &[u32]) -> &[u32] {
&slice[3..7] &slice[3..7]
@ -125,9 +125,9 @@ fn exclusive_to_inclusive_range(slice: &[u32]) -> &[u32] {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,typeck", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,typeck", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,typeck", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,typeck", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
fn exclusive_to_inclusive_range(slice: &[u32]) -> &[u32] { fn exclusive_to_inclusive_range(slice: &[u32]) -> &[u32] {
&slice[3..=7] &slice[3..=7]

128
tests/incremental/hashes/inherent_impls.rs
View file

@ -26,9 +26,9 @@ impl Foo {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,associated_item_def_ids")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,associated_item_def_ids")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,associated_item_def_ids")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,associated_item_def_ids")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl Foo { impl Foo {
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
@ -115,7 +115,7 @@ impl Foo {
impl Foo { impl Foo {
//-------------------------- //--------------------------
//-------------------------- //--------------------------
//-------------------------------------------------------------- //----------------------------------------------------
//-------------------------- //--------------------------
pub fn method_privacy() { } pub fn method_privacy() { }
} }
@ -128,7 +128,7 @@ impl Foo {
impl Foo { impl Foo {
#[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
fn method_privacy() { } fn method_privacy() { }
} }
@ -138,31 +138,31 @@ impl Foo {
impl Foo { impl Foo {
//------------ //------------
//--------------- //---------------
//--------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------
// //
//-------------------------- //--------------------------
//------------ //------------
//--------------- //---------------
//--------------------------------------------------------------------------------------------- //-----------------------------------------------------------------------------------
// //
//-------------------------- //--------------------------
pub fn method_selfness() { } pub fn method_selfness() { }
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl Foo { impl Foo {
#[rustc_clean( #[rustc_clean(
cfg="cfail2", cfg="cfail2",
except="hir_owner,hir_owner_nodes,fn_sig,generics_of,typeck,associated_item,optimized_mir", except="hir_owner_nodes,fn_sig,generics_of,typeck,associated_item,optimized_mir",
)] )]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean( #[rustc_clean(
cfg="cfail5", cfg="cfail5",
except="hir_owner,hir_owner_nodes,fn_sig,generics_of,typeck,associated_item,optimized_mir", except="hir_owner_nodes,fn_sig,generics_of,typeck,associated_item,optimized_mir",
)] )]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn method_selfness(&self) { } pub fn method_selfness(&self) { }
@ -171,9 +171,9 @@ impl Foo {
// Change Method Selfmutness --------------------------------------------------- // Change Method Selfmutness ---------------------------------------------------
#[cfg(any(cfail1,cfail4))] #[cfg(any(cfail1,cfail4))]
impl Foo { impl Foo {
//------------------------------------------------------------------------------------------ //--------------------------------------------------------------------------------
//-------------------------- //--------------------------
//------------------------------------------------------------------------------------------ //--------------------------------------------------------------------------------
//-------------------------- //--------------------------
pub fn method_selfmutness(& self) { } pub fn method_selfmutness(& self) { }
} }
@ -184,9 +184,9 @@ impl Foo {
#[rustc_clean(cfg="cfail5")] #[rustc_clean(cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl Foo { impl Foo {
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,fn_sig,typeck,optimized_mir")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,fn_sig,typeck,optimized_mir")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn method_selfmutness(&mut self) { } pub fn method_selfmutness(&mut self) { }
} }
@ -200,9 +200,9 @@ impl Foo {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,associated_item_def_ids")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,associated_item_def_ids")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,associated_item_def_ids")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,associated_item_def_ids")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl Foo { impl Foo {
#[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail2")]
@ -221,9 +221,9 @@ impl Foo {
// Add Method Parameter -------------------------------------------------------- // Add Method Parameter --------------------------------------------------------
#[cfg(any(cfail1,cfail4))] #[cfg(any(cfail1,cfail4))]
impl Foo { impl Foo {
//------------------------------------------------------------------------------------------ //--------------------------------------------------------------------------------
//-------------------------- //--------------------------
//------------------------------------------------------------------------------------------ //--------------------------------------------------------------------------------
//-------------------------- //--------------------------
pub fn add_method_parameter(&self ) { } pub fn add_method_parameter(&self ) { }
} }
@ -234,9 +234,9 @@ impl Foo {
#[rustc_clean(cfg="cfail5")] #[rustc_clean(cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl Foo { impl Foo {
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,fn_sig,typeck,optimized_mir")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,fn_sig,typeck,optimized_mir")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_method_parameter(&self, _: i32) { } pub fn add_method_parameter(&self, _: i32) { }
} }
@ -271,9 +271,9 @@ impl Foo {
// Change Method Return Type --------------------------------------------------- // Change Method Return Type ---------------------------------------------------
#[cfg(any(cfail1,cfail4))] #[cfg(any(cfail1,cfail4))]
impl Foo { impl Foo {
//------------------------------------------------------------------------------------------ //--------------------------------------------------------------------------------
//-------------------------- //--------------------------
//------------------------------------------------------------------------------------------ //--------------------------------------------------------------------------------
//-------------------------- //--------------------------
pub fn change_method_return_type(&self) -> u16 { 0 } pub fn change_method_return_type(&self) -> u16 { 0 }
} }
@ -284,9 +284,9 @@ impl Foo {
#[rustc_clean(cfg="cfail5")] #[rustc_clean(cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl Foo { impl Foo {
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,fn_sig,optimized_mir,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,fn_sig,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,fn_sig,optimized_mir,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,fn_sig,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn change_method_return_type(&self) -> u32 { 0 } pub fn change_method_return_type(&self) -> u32 { 0 }
} }
@ -348,9 +348,9 @@ impl Foo {
// Make method unsafe ---------------------------------------------------------- // Make method unsafe ----------------------------------------------------------
#[cfg(any(cfail1,cfail4))] #[cfg(any(cfail1,cfail4))]
impl Foo { impl Foo {
//------------------------------------------------------------------------------------------ //--------------------------------------------------------------------------------
//-------------------------- //--------------------------
//------------------------------------------------------------------------------------------ //--------------------------------------------------------------------------------
//-------------------------- //--------------------------
pub fn make_method_unsafe(&self) { } pub fn make_method_unsafe(&self) { }
} }
@ -361,9 +361,9 @@ impl Foo {
#[rustc_clean(cfg="cfail5")] #[rustc_clean(cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl Foo { impl Foo {
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,fn_sig,typeck,optimized_mir")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,fn_sig,typeck,optimized_mir")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub unsafe fn make_method_unsafe(&self) { } pub unsafe fn make_method_unsafe(&self) { }
} }
@ -373,9 +373,9 @@ impl Foo {
// Make method extern ---------------------------------------------------------- // Make method extern ----------------------------------------------------------
#[cfg(any(cfail1,cfail4))] #[cfg(any(cfail1,cfail4))]
impl Foo { impl Foo {
//---------------------------------------------------------------------------- //------------------------------------------------------------------
//-------------------------- //--------------------------
//---------------------------------------------------------------------------- //------------------------------------------------------------------
//-------------------------- //--------------------------
pub fn make_method_extern(&self) { } pub fn make_method_extern(&self) { }
} }
@ -386,9 +386,9 @@ impl Foo {
#[rustc_clean(cfg="cfail5")] #[rustc_clean(cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl Foo { impl Foo {
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,fn_sig,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,fn_sig,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,fn_sig,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,fn_sig,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub extern "C" fn make_method_extern(&self) { } pub extern "C" fn make_method_extern(&self) { }
} }
@ -398,9 +398,9 @@ impl Foo {
// Change method calling convention -------------------------------------------- // Change method calling convention --------------------------------------------
#[cfg(any(cfail1,cfail4))] #[cfg(any(cfail1,cfail4))]
impl Foo { impl Foo {
//---------------------------------------------------------------------------- //------------------------------------------------------------------
//-------------------------- //--------------------------
//---------------------------------------------------------------------------- //------------------------------------------------------------------
//-------------------------- //--------------------------
pub extern "C" fn change_method_calling_convention(&self) { } pub extern "C" fn change_method_calling_convention(&self) { }
} }
@ -411,9 +411,9 @@ impl Foo {
#[rustc_clean(cfg="cfail5")] #[rustc_clean(cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl Foo { impl Foo {
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,fn_sig,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,fn_sig,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,fn_sig,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,fn_sig,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub extern "system" fn change_method_calling_convention(&self) { } pub extern "system" fn change_method_calling_convention(&self) { }
} }
@ -432,9 +432,9 @@ impl Foo {
// ---------------------------------------------------------- // ----------------------------------------------------------
// ----------------------------------------------------------- // -----------------------------------------------------------
// ---------------------------------------------------------- // ----------------------------------------------------------
// -------------------------------------------------------------------- // ----------------------------------------------------------
// ------------------------- // -------------------------
// -------------------------------------------------------------------------------- // ----------------------------------------------------------------------
// ------------------------- // -------------------------
pub fn add_lifetime_parameter_to_method (&self) { } pub fn add_lifetime_parameter_to_method (&self) { }
} }
@ -454,9 +454,9 @@ impl Foo {
// if we lower generics before the body, then the `HirId` for // if we lower generics before the body, then the `HirId` for
// things in the body will be affected. So if you start to see // things in the body will be affected. So if you start to see
// `typeck` appear dirty, that might be the cause. -nmatsakis // `typeck` appear dirty, that might be the cause. -nmatsakis
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,fn_sig")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,fn_sig")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,fn_sig,generics_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,fn_sig,generics_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_lifetime_parameter_to_method<'a>(&self) { } pub fn add_lifetime_parameter_to_method<'a>(&self) { }
} }
@ -477,12 +477,12 @@ impl Foo {
// ------------------------------------------------- // -------------------------------------------------
// ----------- // -----------
// -------------- // --------------
// ---------------------------------------------------------------------- // ------------------------------------------------------------
// //
// ------------------------- // -------------------------
// ----------- // -----------
// -------------- // --------------
// ---------------------------------------------------------------------- // ------------------------------------------------------------
// //
// ------------------------- // -------------------------
pub fn add_type_parameter_to_method (&self) { } pub fn add_type_parameter_to_method (&self) { }
@ -505,12 +505,12 @@ impl Foo {
// appear dirty, that might be the cause. -nmatsakis // appear dirty, that might be the cause. -nmatsakis
#[rustc_clean( #[rustc_clean(
cfg="cfail2", cfg="cfail2",
except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of", except="hir_owner_nodes,generics_of,predicates_of,type_of",
)] )]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean( #[rustc_clean(
cfg="cfail5", cfg="cfail5",
except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of", except="hir_owner_nodes,generics_of,predicates_of,type_of",
)] )]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_type_parameter_to_method<T>(&self) { } pub fn add_type_parameter_to_method<T>(&self) { }
@ -523,12 +523,12 @@ impl Foo {
impl Foo { impl Foo {
//------------ //------------
//--------------- //---------------
//----------------------------------------------------------------------------- //-------------------------------------------------------------------
// //
//-------------------------- //--------------------------
//------------ //------------
//--------------- //---------------
//----------------------------------------------------------------------------- //-------------------------------------------------------------------
// //
//-------------------------- //--------------------------
pub fn add_lifetime_bound_to_lifetime_param_of_method<'a, 'b >(&self) { } pub fn add_lifetime_bound_to_lifetime_param_of_method<'a, 'b >(&self) { }
@ -542,12 +542,12 @@ impl Foo {
impl Foo { impl Foo {
#[rustc_clean( #[rustc_clean(
cfg="cfail2", cfg="cfail2",
except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of,fn_sig" except="hir_owner_nodes,generics_of,predicates_of,type_of,fn_sig"
)] )]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean( #[rustc_clean(
cfg="cfail5", cfg="cfail5",
except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of,fn_sig" except="hir_owner_nodes,generics_of,predicates_of,type_of,fn_sig"
)] )]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_lifetime_bound_to_lifetime_param_of_method<'a, 'b: 'a>(&self) { } pub fn add_lifetime_bound_to_lifetime_param_of_method<'a, 'b: 'a>(&self) { }
@ -569,12 +569,12 @@ impl Foo {
// ------------------------------------------------- // -------------------------------------------------
// ----------- // -----------
// -------------- // --------------
// ---------------------------------------------------------------------------- // ------------------------------------------------------------------
// //
// ------------------------- // -------------------------
// ----------- // -----------
// -------------- // --------------
// ---------------------------------------------------------------------------- // ------------------------------------------------------------------
// //
// ------------------------- // -------------------------
pub fn add_lifetime_bound_to_type_param_of_method<'a, T >(&self) { } pub fn add_lifetime_bound_to_type_param_of_method<'a, T >(&self) { }
@ -597,12 +597,12 @@ impl Foo {
// appear dirty, that might be the cause. -nmatsakis // appear dirty, that might be the cause. -nmatsakis
#[rustc_clean( #[rustc_clean(
cfg="cfail2", cfg="cfail2",
except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of,fn_sig" except="hir_owner_nodes,generics_of,predicates_of,type_of,fn_sig"
)] )]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean( #[rustc_clean(
cfg="cfail5", cfg="cfail5",
except="hir_owner,hir_owner_nodes,generics_of,predicates_of,type_of,fn_sig" except="hir_owner_nodes,generics_of,predicates_of,type_of,fn_sig"
)] )]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_lifetime_bound_to_type_param_of_method<'a, T: 'a>(&self) { } pub fn add_lifetime_bound_to_type_param_of_method<'a, T: 'a>(&self) { }
@ -622,9 +622,9 @@ impl Foo {
// ------------------------------------------------------------ // ------------------------------------------------------------
// ------------------------------------------------------ // ------------------------------------------------------
// ------------------------------------------------- // -------------------------------------------------
// --------------------------------------------------------------------------- // -----------------------------------------------------------------
// ------------------------- // -------------------------
// --------------------------------------------------------------------------- // -----------------------------------------------------------------
// ------------------------- // -------------------------
pub fn add_trait_bound_to_type_param_of_method<T >(&self) { } pub fn add_trait_bound_to_type_param_of_method<T >(&self) { }
} }
@ -644,9 +644,9 @@ impl Foo {
// generics before the body, then the `HirId` for things in the // generics before the body, then the `HirId` for things in the
// body will be affected. So if you start to see `typeck` // body will be affected. So if you start to see `typeck`
// appear dirty, that might be the cause. -nmatsakis // appear dirty, that might be the cause. -nmatsakis
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,predicates_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,predicates_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_trait_bound_to_type_param_of_method<T: Clone>(&self) { } pub fn add_trait_bound_to_type_param_of_method<T: Clone>(&self) { }
} }
@ -689,9 +689,9 @@ impl Bar<u32> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,generics_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,generics_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,generics_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,generics_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl<T> Bar<T> { impl<T> Bar<T> {
#[rustc_clean( #[rustc_clean(
@ -716,9 +716,9 @@ impl Bar<u32> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl Bar<u64> { impl Bar<u64> {
#[rustc_clean(cfg="cfail2", except="fn_sig,optimized_mir,typeck")] #[rustc_clean(cfg="cfail2", except="fn_sig,optimized_mir,typeck")]
@ -737,9 +737,9 @@ impl<T> Bar<T> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl<T: 'static> Bar<T> { impl<T: 'static> Bar<T> {
#[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail2")]
@ -758,9 +758,9 @@ impl<T> Bar<T> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl<T: Clone> Bar<T> { impl<T: Clone> Bar<T> {
#[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail2")]

28
tests/incremental/hashes/match_expressions.rs
View file

@ -28,9 +28,9 @@ pub fn add_arm(x: u32) -> u32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_arm(x: u32) -> u32 { pub fn add_arm(x: u32) -> u32 {
match x { match x {
@ -79,9 +79,9 @@ pub fn add_guard_clause(x: u32, y: bool) -> u32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_guard_clause(x: u32, y: bool) -> u32 { pub fn add_guard_clause(x: u32, y: bool) -> u32 {
match x { match x {
@ -104,9 +104,9 @@ pub fn change_guard_clause(x: u32, y: bool) -> u32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn change_guard_clause(x: u32, y: bool) -> u32 { pub fn change_guard_clause(x: u32, y: bool) -> u32 {
match x { match x {
@ -129,9 +129,9 @@ pub fn add_at_binding(x: u32) -> u32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_at_binding(x: u32) -> u32 { pub fn add_at_binding(x: u32) -> u32 {
match x { match x {
@ -178,9 +178,9 @@ pub fn change_simple_name_to_pattern(x: u32) -> u32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn change_simple_name_to_pattern(x: u32) -> u32 { pub fn change_simple_name_to_pattern(x: u32) -> u32 {
match (x, x & 1) { match (x, x & 1) {
@ -273,9 +273,9 @@ pub fn add_amp_to_binding_in_pattern(x: u32) -> u32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_amp_to_binding_in_pattern(x: u32) -> u32 { pub fn add_amp_to_binding_in_pattern(x: u32) -> u32 {
match (&x, x & 1) { match (&x, x & 1) {
@ -322,9 +322,9 @@ pub fn add_alternative_to_arm(x: u32) -> u32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_alternative_to_arm(x: u32) -> u32 { pub fn add_alternative_to_arm(x: u32) -> u32 {
match x { match x {

22
tests/incremental/hashes/statics.rs
View file

@ -26,7 +26,7 @@ static STATIC_VISIBILITY: u8 = 0;
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub static STATIC_VISIBILITY: u8 = 0; pub static STATIC_VISIBILITY: u8 = 0;
@ -36,9 +36,9 @@ pub static STATIC_VISIBILITY: u8 = 0;
static STATIC_MUTABILITY: u8 = 0; static STATIC_MUTABILITY: u8 = 0;
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
static mut STATIC_MUTABILITY: u8 = 0; static mut STATIC_MUTABILITY: u8 = 0;
@ -87,9 +87,9 @@ static STATIC_THREAD_LOCAL: u8 = 0;
static STATIC_CHANGE_TYPE_1: i16 = 0; static STATIC_CHANGE_TYPE_1: i16 = 0;
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
static STATIC_CHANGE_TYPE_1: u64 = 0; static STATIC_CHANGE_TYPE_1: u64 = 0;
@ -99,9 +99,9 @@ static STATIC_CHANGE_TYPE_1: u64 = 0;
static STATIC_CHANGE_TYPE_2: Option<i8> = None; static STATIC_CHANGE_TYPE_2: Option<i8> = None;
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
static STATIC_CHANGE_TYPE_2: Option<u16> = None; static STATIC_CHANGE_TYPE_2: Option<u16> = None;
@ -169,15 +169,15 @@ mod static_change_type_indirectly {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::ReferencedType2 as Type; use super::ReferencedType2 as Type;
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
static STATIC_CHANGE_TYPE_INDIRECTLY_1: Type = Type; static STATIC_CHANGE_TYPE_INDIRECTLY_1: Type = Type;
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
static STATIC_CHANGE_TYPE_INDIRECTLY_2: Option<Type> = None; static STATIC_CHANGE_TYPE_INDIRECTLY_2: Option<Type> = None;
} }

24
tests/incremental/hashes/struct_constructors.rs
View file

@ -90,9 +90,9 @@ pub fn add_field_regular_struct() -> RegularStruct {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,optimized_mir,typeck")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,optimized_mir,typeck")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn add_field_regular_struct() -> RegularStruct { pub fn add_field_regular_struct() -> RegularStruct {
let struct1 = RegularStruct { let struct1 = RegularStruct {
@ -185,15 +185,9 @@ pub mod change_constructor_path_indirectly_regular_struct {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::RegularStruct2 as Struct; use super::RegularStruct2 as Struct;
#[rustc_clean( #[rustc_clean(cfg="cfail2", except="fn_sig,hir_owner_nodes,optimized_mir,typeck")]
cfg="cfail2",
except="fn_sig,hir_owner,hir_owner_nodes,optimized_mir,typeck"
)]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean( #[rustc_clean(cfg="cfail5", except="fn_sig,hir_owner_nodes,optimized_mir,typeck")]
cfg="cfail5",
except="fn_sig,hir_owner,hir_owner_nodes,optimized_mir,typeck"
)]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub fn function() -> Struct { pub fn function() -> Struct {
Struct { Struct {
@ -251,15 +245,9 @@ pub mod change_constructor_path_indirectly_tuple_struct {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::TupleStruct2 as Struct; use super::TupleStruct2 as Struct;
#[rustc_clean( #[rustc_clean(cfg="cfail5", except="fn_sig,hir_owner_nodes,optimized_mir,typeck")]
cfg="cfail5",
except="fn_sig,hir_owner,hir_owner_nodes,optimized_mir,typeck"
)]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
#[rustc_clean( #[rustc_clean(cfg="cfail2", except="fn_sig,hir_owner_nodes,optimized_mir,typeck")]
cfg="cfail2",
except="fn_sig,hir_owner,hir_owner_nodes,optimized_mir,typeck"
)]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
pub fn function() -> Struct { pub fn function() -> Struct {
Struct(0, 1, 2) Struct(0, 1, 2)

66
tests/incremental/hashes/struct_defs.rs
View file

@ -51,9 +51,9 @@ struct LayoutC;
struct TupleStructFieldType(i32); struct TupleStructFieldType(i32);
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
// Note that changing the type of a field does not change the type of the struct or enum, but // Note that changing the type of a field does not change the type of the struct or enum, but
// adding/removing fields or changing a fields name or visibility does. // adding/removing fields or changing a fields name or visibility does.
@ -68,9 +68,9 @@ struct TupleStructFieldType(
struct TupleStructAddField(i32); struct TupleStructAddField(i32);
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,type_of", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,type_of", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,type_of", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,type_of", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct TupleStructAddField( struct TupleStructAddField(
i32, i32,
@ -86,7 +86,7 @@ struct TupleStructFieldVisibility( char);
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="type_of")] #[rustc_clean(cfg="cfail2", except="type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct TupleStructFieldVisibility(pub char); struct TupleStructFieldVisibility(pub char);
@ -97,9 +97,9 @@ struct TupleStructFieldVisibility(pub char);
struct RecordStructFieldType { x: f32 } struct RecordStructFieldType { x: f32 }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
// Note that changing the type of a field does not change the type of the struct or enum, but // Note that changing the type of a field does not change the type of the struct or enum, but
// adding/removing fields or changing a fields name or visibility does. // adding/removing fields or changing a fields name or visibility does.
@ -114,9 +114,9 @@ struct RecordStructFieldType {
struct RecordStructFieldName { x: f32 } struct RecordStructFieldName { x: f32 }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,type_of", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,type_of", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,type_of", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,type_of", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct RecordStructFieldName { y: f32 } struct RecordStructFieldName { y: f32 }
@ -127,9 +127,9 @@ struct RecordStructFieldName { y: f32 }
struct RecordStructAddField { x: f32 } struct RecordStructAddField { x: f32 }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,type_of", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,type_of", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,type_of", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,type_of", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct RecordStructAddField { struct RecordStructAddField {
x: f32, x: f32,
@ -144,7 +144,7 @@ struct RecordStructFieldVisibility { x: f32 }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2", except="type_of")] #[rustc_clean(cfg="cfail2", except="type_of")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes,type_of")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes,type_of")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct RecordStructFieldVisibility { pub x: f32 } struct RecordStructFieldVisibility { pub x: f32 }
@ -155,9 +155,9 @@ struct RecordStructFieldVisibility { pub x: f32 }
struct AddLifetimeParameter<'a>(&'a f32, &'a f64); struct AddLifetimeParameter<'a>(&'a f32, &'a f64);
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,type_of,generics_of", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,type_of,generics_of", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,type_of,generics_of", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,type_of,generics_of", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct AddLifetimeParameter<'a, 'b>(&'a f32, &'b f64); struct AddLifetimeParameter<'a, 'b>(&'a f32, &'b f64);
@ -168,9 +168,9 @@ struct AddLifetimeParameter<'a, 'b>(&'a f32, &'b f64);
struct AddLifetimeParameterBound<'a, 'b>(&'a f32, &'b f64); struct AddLifetimeParameterBound<'a, 'b>(&'a f32, &'b f64);
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,predicates_of", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,predicates_of", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,predicates_of", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,predicates_of", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct AddLifetimeParameterBound<'a, 'b: 'a>( struct AddLifetimeParameterBound<'a, 'b: 'a>(
&'a f32, &'a f32,
@ -181,9 +181,9 @@ struct AddLifetimeParameterBound<'a, 'b: 'a>(
struct AddLifetimeParameterBoundWhereClause<'a, 'b>(&'a f32, &'b f64); struct AddLifetimeParameterBoundWhereClause<'a, 'b>(&'a f32, &'b f64);
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,predicates_of", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,predicates_of", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,predicates_of", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,predicates_of", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct AddLifetimeParameterBoundWhereClause<'a, 'b>( struct AddLifetimeParameterBoundWhereClause<'a, 'b>(
&'a f32, &'a f32,
@ -197,9 +197,9 @@ struct AddLifetimeParameterBoundWhereClause<'a, 'b>(
struct AddTypeParameter<T1>(T1, T1); struct AddTypeParameter<T1>(T1, T1);
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,type_of,generics_of,predicates_of", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,type_of,generics_of,predicates_of", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,type_of,generics_of,predicates_of", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,type_of,generics_of,predicates_of", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct AddTypeParameter<T1, T2>( struct AddTypeParameter<T1, T2>(
// The field contains the parent's Generics, so it's dirty even though its // The field contains the parent's Generics, so it's dirty even though its
@ -215,9 +215,9 @@ struct AddTypeParameter<T1, T2>(
struct AddTypeParameterBound<T>(T); struct AddTypeParameterBound<T>(T);
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,predicates_of", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,predicates_of", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,predicates_of", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,predicates_of", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct AddTypeParameterBound<T: Send>( struct AddTypeParameterBound<T: Send>(
T T
@ -228,9 +228,9 @@ struct AddTypeParameterBound<T: Send>(
struct AddTypeParameterBoundWhereClause<T>(T); struct AddTypeParameterBoundWhereClause<T>(T);
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,predicates_of", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,predicates_of", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,predicates_of", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,predicates_of", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct AddTypeParameterBoundWhereClause<T>( struct AddTypeParameterBoundWhereClause<T>(
T T
@ -257,7 +257,7 @@ struct Visibility;
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(cfg="cfail5", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail5", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub struct Visibility; pub struct Visibility;
@ -271,9 +271,9 @@ mod tuple_struct_change_field_type_indirectly {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::ReferencedType2 as FieldType; use super::ReferencedType2 as FieldType;
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct TupleStruct( struct TupleStruct(
FieldType FieldType
@ -288,9 +288,9 @@ mod record_struct_change_field_type_indirectly {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::ReferencedType2 as FieldType; use super::ReferencedType2 as FieldType;
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct RecordStruct { struct RecordStruct {
_x: FieldType _x: FieldType
@ -310,9 +310,9 @@ mod change_trait_bound_indirectly {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::ReferencedTrait2 as Trait; use super::ReferencedTrait2 as Trait;
#[rustc_clean(except="hir_owner,hir_owner_nodes,predicates_of", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,predicates_of", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,predicates_of", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,predicates_of", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct Struct<T: Trait>(T); struct Struct<T: Trait>(T);
} }
@ -324,9 +324,9 @@ mod change_trait_bound_indirectly_in_where_clause {
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
use super::ReferencedTrait2 as Trait; use super::ReferencedTrait2 as Trait;
#[rustc_clean(except="hir_owner,hir_owner_nodes,predicates_of", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,predicates_of", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,predicates_of", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,predicates_of", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
struct Struct<T>(T) where T : Trait; struct Struct<T>(T) where T : Trait;
} }

398
tests/incremental/hashes/trait_defs.rs
View file

File diff suppressed because it is too large Load diff

100
tests/incremental/hashes/trait_impls.rs
View file

@ -32,9 +32,9 @@ impl ChangeMethodNameTrait for Foo {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,associated_item_def_ids", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,associated_item_def_ids", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub trait ChangeMethodNameTrait { pub trait ChangeMethodNameTrait {
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
@ -43,9 +43,9 @@ pub trait ChangeMethodNameTrait {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,associated_item_def_ids", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,associated_item_def_ids", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl ChangeMethodNameTrait for Foo { impl ChangeMethodNameTrait for Foo {
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
@ -141,18 +141,18 @@ pub trait ChangeMethodSelfnessTrait {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl ChangeMethodSelfnessTrait for Foo { impl ChangeMethodSelfnessTrait for Foo {
#[rustc_clean( #[rustc_clean(
except="hir_owner,hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir", except="hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir",
cfg="cfail2", cfg="cfail2",
)] )]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean( #[rustc_clean(
except="hir_owner,hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir", except="hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir",
cfg="cfail5", cfg="cfail5",
)] )]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
@ -179,18 +179,18 @@ pub trait RemoveMethodSelfnessTrait {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl RemoveMethodSelfnessTrait for Foo { impl RemoveMethodSelfnessTrait for Foo {
#[rustc_clean( #[rustc_clean(
except="hir_owner,hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir", except="hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir",
cfg="cfail2", cfg="cfail2",
)] )]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean( #[rustc_clean(
except="hir_owner,hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir", except="hir_owner_nodes,associated_item,generics_of,fn_sig,typeck,optimized_mir",
cfg="cfail5", cfg="cfail5",
)] )]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
@ -206,9 +206,9 @@ pub trait ChangeMethodSelfmutnessTrait {
#[cfg(any(cfail1,cfail4))] #[cfg(any(cfail1,cfail4))]
impl ChangeMethodSelfmutnessTrait for Foo { impl ChangeMethodSelfmutnessTrait for Foo {
// ----------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
// ------------------------- // -------------------------
// ----------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
// ------------------------- // -------------------------
fn method_name(& self) {} fn method_name(& self) {}
} }
@ -224,9 +224,9 @@ pub trait ChangeMethodSelfmutnessTrait {
#[rustc_clean(cfg="cfail5")] #[rustc_clean(cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl ChangeMethodSelfmutnessTrait for Foo { impl ChangeMethodSelfmutnessTrait for Foo {
#[rustc_clean(except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
fn method_name(&mut self) {} fn method_name(&mut self) {}
} }
@ -249,9 +249,9 @@ pub trait ChangeItemKindTrait {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,associated_item_def_ids", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,associated_item_def_ids", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl ChangeItemKindTrait for Foo { impl ChangeItemKindTrait for Foo {
type name = (); type name = ();
@ -277,9 +277,9 @@ pub trait RemoveItemTrait {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,associated_item_def_ids", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,associated_item_def_ids", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl RemoveItemTrait for Foo { impl RemoveItemTrait for Foo {
type TypeName = (); type TypeName = ();
@ -304,9 +304,9 @@ pub trait AddItemTrait {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,associated_item_def_ids", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,associated_item_def_ids", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,associated_item_def_ids", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl AddItemTrait for Foo { impl AddItemTrait for Foo {
type TypeName = (); type TypeName = ();
@ -317,9 +317,9 @@ impl AddItemTrait for Foo {
#[cfg(any(cfail1,cfail4))] #[cfg(any(cfail1,cfail4))]
pub trait ChangeHasValueTrait { pub trait ChangeHasValueTrait {
//-------------------------------------------------------------- //----------------------------------------------------
//-------------------------- //--------------------------
//-------------------------------------------------------------- //----------------------------------------------------
//-------------------------- //--------------------------
fn method_name() ; fn method_name() ;
} }
@ -330,14 +330,14 @@ impl ChangeHasValueTrait for Foo {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner_nodes", cfg="cfail2")] #[rustc_clean(cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner_nodes", cfg="cfail5")] #[rustc_clean(cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
pub trait ChangeHasValueTrait { pub trait ChangeHasValueTrait {
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
fn method_name() { } fn method_name() { }
} }
@ -359,9 +359,9 @@ pub trait AddDefaultTrait {
#[cfg(any(cfail1,cfail4))] #[cfg(any(cfail1,cfail4))]
impl AddDefaultTrait for Foo { impl AddDefaultTrait for Foo {
// ------------------------------------------------------------- // ---------------------------------------------------
// ------------------------- // -------------------------
// ------------------------------------------------------------- // ---------------------------------------------------
// ------------------------- // -------------------------
fn method_name() { } fn method_name() { }
} }
@ -372,9 +372,9 @@ impl AddDefaultTrait for Foo {
#[rustc_clean(cfg="cfail5")] #[rustc_clean(cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl AddDefaultTrait for Foo { impl AddDefaultTrait for Foo {
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
default fn method_name() { } default fn method_name() { }
} }
@ -388,9 +388,9 @@ pub trait AddArgumentTrait {
#[cfg(any(cfail1,cfail4))] #[cfg(any(cfail1,cfail4))]
impl AddArgumentTrait for Foo { impl AddArgumentTrait for Foo {
// ----------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
// ------------------------- // -------------------------
// ----------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
// ------------------------- // -------------------------
fn method_name(&self ) { } fn method_name(&self ) { }
} }
@ -406,9 +406,9 @@ pub trait AddArgumentTrait {
#[rustc_clean(cfg="cfail5")] #[rustc_clean(cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl AddArgumentTrait for Foo { impl AddArgumentTrait for Foo {
#[rustc_clean(except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
fn method_name(&self, _x: u32) { } fn method_name(&self, _x: u32) { }
} }
@ -422,9 +422,9 @@ pub trait ChangeArgumentTypeTrait {
#[cfg(any(cfail1,cfail4))] #[cfg(any(cfail1,cfail4))]
impl ChangeArgumentTypeTrait for Foo { impl ChangeArgumentTypeTrait for Foo {
// ----------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
// ------------------------- // -------------------------
// ----------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------
// ------------------------- // -------------------------
fn method_name(&self, _x: u32 ) { } fn method_name(&self, _x: u32 ) { }
} }
@ -440,9 +440,9 @@ pub trait ChangeArgumentTypeTrait {
#[rustc_clean(cfg="cfail5")] #[rustc_clean(cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl ChangeArgumentTypeTrait for Foo { impl ChangeArgumentTypeTrait for Foo {
#[rustc_clean(except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,fn_sig,typeck,optimized_mir", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
fn method_name(&self, _x: char) { } fn method_name(&self, _x: char) { }
} }
@ -462,18 +462,18 @@ impl AddTypeParameterToImpl<u32> for Bar<u32> {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,generics_of,impl_trait_ref", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,generics_of,impl_trait_ref", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,generics_of,impl_trait_ref", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,generics_of,impl_trait_ref", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl<TTT> AddTypeParameterToImpl<TTT> for Bar<TTT> { impl<TTT> AddTypeParameterToImpl<TTT> for Bar<TTT> {
#[rustc_clean( #[rustc_clean(
except="hir_owner,hir_owner_nodes,generics_of,fn_sig,type_of,typeck,optimized_mir", except="hir_owner_nodes,generics_of,fn_sig,type_of,typeck,optimized_mir",
cfg="cfail2", cfg="cfail2",
)] )]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean( #[rustc_clean(
except="hir_owner,hir_owner_nodes,generics_of,fn_sig,type_of,typeck,optimized_mir", except="hir_owner_nodes,generics_of,fn_sig,type_of,typeck,optimized_mir",
cfg="cfail5", cfg="cfail5",
)] )]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
@ -493,9 +493,9 @@ impl ChangeSelfTypeOfImpl for u32 {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes,impl_trait_ref", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes,impl_trait_ref", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes,impl_trait_ref", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes,impl_trait_ref", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl ChangeSelfTypeOfImpl for u64 { impl ChangeSelfTypeOfImpl for u64 {
#[rustc_clean(except="fn_sig,typeck,optimized_mir", cfg="cfail2")] #[rustc_clean(except="fn_sig,typeck,optimized_mir", cfg="cfail2")]
@ -518,9 +518,9 @@ impl<T> AddLifetimeBoundToImplParameter for T {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl<T: 'static> AddLifetimeBoundToImplParameter for T { impl<T: 'static> AddLifetimeBoundToImplParameter for T {
#[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail2")]
@ -543,9 +543,9 @@ impl<T> AddTraitBoundToImplParameter for T {
} }
#[cfg(not(any(cfail1,cfail4)))] #[cfg(not(any(cfail1,cfail4)))]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail2")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail2")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
#[rustc_clean(except="hir_owner,hir_owner_nodes", cfg="cfail5")] #[rustc_clean(except="hir_owner_nodes", cfg="cfail5")]
#[rustc_clean(cfg="cfail6")] #[rustc_clean(cfg="cfail6")]
impl<T: Clone> AddTraitBoundToImplParameter for T { impl<T: Clone> AddTraitBoundToImplParameter for T {
#[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail2")]

32
tests/incremental/hashes/type_defs.rs
View file

@ -24,7 +24,7 @@
type ChangePrimitiveType = i32; type ChangePrimitiveType = i32;
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type ChangePrimitiveType = i64; type ChangePrimitiveType = i64;
@ -35,7 +35,7 @@ type ChangePrimitiveType = i64;
type ChangeMutability = &'static i32; type ChangeMutability = &'static i32;
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type ChangeMutability = &'static mut i32; type ChangeMutability = &'static mut i32;
@ -46,7 +46,7 @@ type ChangeMutability = &'static mut i32;
type ChangeLifetime<'a> = (&'static i32, &'a i32); type ChangeLifetime<'a> = (&'static i32, &'a i32);
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type ChangeLifetime<'a> = (&'a i32, &'a i32); type ChangeLifetime<'a> = (&'a i32, &'a i32);
@ -60,7 +60,7 @@ struct Struct2;
type ChangeTypeStruct = Struct1; type ChangeTypeStruct = Struct1;
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type ChangeTypeStruct = Struct2; type ChangeTypeStruct = Struct2;
@ -71,7 +71,7 @@ type ChangeTypeStruct = Struct2;
type ChangeTypeTuple = (u32, u64); type ChangeTypeTuple = (u32, u64);
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type ChangeTypeTuple = (u32, i64); type ChangeTypeTuple = (u32, i64);
@ -91,7 +91,7 @@ enum Enum2 {
type ChangeTypeEnum = Enum1; type ChangeTypeEnum = Enum1;
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type ChangeTypeEnum = Enum2; type ChangeTypeEnum = Enum2;
@ -102,7 +102,7 @@ type ChangeTypeEnum = Enum2;
type AddTupleField = (i32, i64); type AddTupleField = (i32, i64);
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type AddTupleField = (i32, i64, i16); type AddTupleField = (i32, i64, i16);
@ -113,7 +113,7 @@ type AddTupleField = (i32, i64, i16);
type ChangeNestedTupleField = (i32, (i64, i16)); type ChangeNestedTupleField = (i32, (i64, i16));
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type ChangeNestedTupleField = (i32, (i64, i8)); type ChangeNestedTupleField = (i32, (i64, i8));
@ -124,7 +124,7 @@ type ChangeNestedTupleField = (i32, (i64, i8));
type AddTypeParam<T1> = (T1, T1); type AddTypeParam<T1> = (T1, T1);
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type AddTypeParam<T1, T2> = (T1, T2); type AddTypeParam<T1, T2> = (T1, T2);
@ -135,7 +135,7 @@ type AddTypeParam<T1, T2> = (T1, T2);
type AddTypeParamBound<T1> = (T1, u32); type AddTypeParamBound<T1> = (T1, u32);
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type AddTypeParamBound<T1: Clone> = (T1, u32); type AddTypeParamBound<T1: Clone> = (T1, u32);
@ -146,7 +146,7 @@ type AddTypeParamBound<T1: Clone> = (T1, u32);
type AddTypeParamBoundWhereClause<T1> where T1: Clone = (T1, u32); type AddTypeParamBoundWhereClause<T1> where T1: Clone = (T1, u32);
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type AddTypeParamBoundWhereClause<T1> where T1: Clone+Copy = (T1, u32); type AddTypeParamBoundWhereClause<T1> where T1: Clone+Copy = (T1, u32);
@ -157,7 +157,7 @@ type AddTypeParamBoundWhereClause<T1> where T1: Clone+Copy = (T1, u32);
type AddLifetimeParam<'a> = (&'a u32, &'a u32); type AddLifetimeParam<'a> = (&'a u32, &'a u32);
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type AddLifetimeParam<'a, 'b> = (&'a u32, &'b u32); type AddLifetimeParam<'a, 'b> = (&'a u32, &'b u32);
@ -168,7 +168,7 @@ type AddLifetimeParam<'a, 'b> = (&'a u32, &'b u32);
type AddLifetimeParamBound<'a, 'b> = (&'a u32, &'b u32); type AddLifetimeParamBound<'a, 'b> = (&'a u32, &'b u32);
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type AddLifetimeParamBound<'a, 'b: 'a> = (&'a u32, &'b u32); type AddLifetimeParamBound<'a, 'b: 'a> = (&'a u32, &'b u32);
@ -181,7 +181,7 @@ where 'b: 'a
= (&'a u32, &'b u32, &'c u32); = (&'a u32, &'b u32, &'c u32);
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type AddLifetimeParamBoundWhereClause<'a, 'b, 'c> type AddLifetimeParamBoundWhereClause<'a, 'b, 'c>
where 'b: 'a, where 'b: 'a,
@ -200,7 +200,7 @@ mod change_trait_bound_indirectly {
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
use super::ReferencedTrait2 as Trait; use super::ReferencedTrait2 as Trait;
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type ChangeTraitBoundIndirectly<T: Trait> = (T, u32); type ChangeTraitBoundIndirectly<T: Trait> = (T, u32);
} }
@ -214,7 +214,7 @@ mod change_trait_bound_indirectly_in_where_clause {
#[cfg(not(cfail1))] #[cfg(not(cfail1))]
use super::ReferencedTrait2 as Trait; use super::ReferencedTrait2 as Trait;
#[rustc_clean(cfg="cfail2", except="hir_owner,hir_owner_nodes")] #[rustc_clean(cfg="cfail2", except="hir_owner_nodes")]
#[rustc_clean(cfg="cfail3")] #[rustc_clean(cfg="cfail3")]
type ChangeTraitBoundIndirectly<T> where T : Trait = (T, u32); type ChangeTraitBoundIndirectly<T> where T : Trait = (T, u32);
} }