diff --git a/.gitignore b/.gitignore index 309fbd95345a4..57407a2399a2f 100644 --- a/.gitignore +++ b/.gitignore @@ -95,7 +95,6 @@ config.stamp keywords.md lexer.ml src/etc/dl -src/librustc_llvm/llvmdeps.rs tmp.*.rs version.md version.ml diff --git a/src/Cargo.lock b/src/Cargo.lock index cde93b1a6a617..ae82c07cfcf1f 100644 --- a/src/Cargo.lock +++ b/src/Cargo.lock @@ -2014,7 +2014,6 @@ version = "0.0.0" dependencies = [ "build_helper 0.1.0", "cc 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)", - "env_logger 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)", "html-diff 0.0.5 (registry+https://github.com/rust-lang/crates.io-index)", "log 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)", "pulldown-cmark 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/src/bootstrap/doc.rs b/src/bootstrap/doc.rs index 9186699a3b583..3c12cfc4c7ffd 100644 --- a/src/bootstrap/doc.rs +++ b/src/bootstrap/doc.rs @@ -159,7 +159,7 @@ impl Step for CargoBook { let target = self.target; let name = self.name; - let src = PathBuf::from("src/tools/cargo/src/doc/book"); + let src = build.src.join("src/tools/cargo/src/doc/book"); let out = build.doc_out(target); t!(fs::create_dir_all(&out)); diff --git a/src/bootstrap/native.rs b/src/bootstrap/native.rs index ac068ebe65178..a5408ee381bbb 100644 --- a/src/bootstrap/native.rs +++ b/src/bootstrap/native.rs @@ -316,7 +316,7 @@ impl Step for TestHelpers { .warnings(false) .debug(false) .file(build.src.join("src/rt/rust_test_helpers.c")) - .compile("librust_test_helpers.a"); + .compile("rust_test_helpers"); } } diff --git a/src/liballoc_jemalloc/build.rs b/src/liballoc_jemalloc/build.rs index a41a04d7cd4f6..de5006ad3960a 100644 --- a/src/liballoc_jemalloc/build.rs +++ b/src/liballoc_jemalloc/build.rs @@ -140,6 +140,6 @@ fn main() { cc::Build::new() .flag("-fvisibility=hidden") .file("pthread_atfork_dummy.c") - .compile("libpthread_atfork_dummy.a"); + .compile("pthread_atfork_dummy"); } } diff --git a/src/libcompiler_builtins b/src/libcompiler_builtins index 02b3734a5ba6d..18feaccbfd0df 160000 --- a/src/libcompiler_builtins +++ b/src/libcompiler_builtins @@ -1 +1 @@ -Subproject commit 02b3734a5ba6de984eb5a02c50860cc014e58d56 +Subproject commit 18feaccbfd0dfbd5ab5d0a2a6eac9c04be667266 diff --git a/src/libproc_macro/lib.rs b/src/libproc_macro/lib.rs index 22f788e34ecff..4a6841aedca12 100644 --- a/src/libproc_macro/lib.rs +++ b/src/libproc_macro/lib.rs @@ -95,7 +95,7 @@ impl FromStr for TokenStream { // notify the expansion info that it is unhygienic let mark = Mark::fresh(mark); mark.set_expn_info(expn_info); - let span = call_site.with_ctxt(SyntaxContext::empty().apply_mark(mark)); + let span = call_site.with_ctxt(call_site.ctxt().apply_mark(mark)); let stream = parse::parse_stream_from_source_str(name, src, sess, Some(span)); Ok(__internal::token_stream_wrap(stream)) }) diff --git a/src/libprofiler_builtins/build.rs b/src/libprofiler_builtins/build.rs index 8508b2dae2c56..dd88dd933f691 100644 --- a/src/libprofiler_builtins/build.rs +++ b/src/libprofiler_builtins/build.rs @@ -56,5 +56,5 @@ fn main() { cfg.file(Path::new("../libcompiler_builtins/compiler-rt/lib/profile").join(src)); } - cfg.compile("libprofiler-rt.a"); + cfg.compile("profiler-rt"); } diff --git a/src/librustc/hir/map/definitions.rs b/src/librustc/hir/map/definitions.rs index dfa675f2e9351..7c2f0bc3cef84 100644 --- a/src/librustc/hir/map/definitions.rs +++ b/src/librustc/hir/map/definitions.rs @@ -575,7 +575,8 @@ impl Definitions { self.node_to_def_index.insert(node_id, index); } - if expansion.is_modern() { + let expansion = expansion.modern(); + if expansion != Mark::root() { self.expansions.insert(index, expansion); } diff --git a/src/librustc/ich/impls_hir.rs b/src/librustc/ich/impls_hir.rs index bccef6dc91bcd..77bf3da679dd7 100644 --- a/src/librustc/ich/impls_hir.rs +++ b/src/librustc/ich/impls_hir.rs @@ -884,13 +884,13 @@ impl<'gcx> HashStable> for hir::Item { fn hash_stable(&self, hcx: &mut StableHashingContext<'gcx>, hasher: &mut StableHasher) { - let (is_const, hash_spans) = match self.node { + let is_const = match self.node { hir::ItemStatic(..) | hir::ItemConst(..) => { - (true, hcx.hash_spans()) + true } hir::ItemFn(_, _, constness, ..) => { - (constness == hir::Constness::Const, hcx.hash_spans()) + constness == hir::Constness::Const } hir::ItemUse(..) | hir::ItemExternCrate(..) | @@ -904,7 +904,7 @@ impl<'gcx> HashStable> for hir::Item { hir::ItemEnum(..) | hir::ItemStruct(..) | hir::ItemUnion(..) => { - (false, false) + false } }; @@ -919,13 +919,11 @@ impl<'gcx> HashStable> for hir::Item { } = *self; hcx.hash_hir_item_like(attrs, is_const, |hcx| { - hcx.while_hashing_spans(hash_spans, |hcx| { - name.hash_stable(hcx, hasher); - attrs.hash_stable(hcx, hasher); - node.hash_stable(hcx, hasher); - vis.hash_stable(hcx, hasher); - span.hash_stable(hcx, hasher); - }); + name.hash_stable(hcx, hasher); + attrs.hash_stable(hcx, hasher); + node.hash_stable(hcx, hasher); + vis.hash_stable(hcx, hasher); + span.hash_stable(hcx, hasher); }); } } diff --git a/src/librustc/ich/mod.rs b/src/librustc/ich/mod.rs index cd0749a686511..cbd76ee14db38 100644 --- a/src/librustc/ich/mod.rs +++ b/src/librustc/ich/mod.rs @@ -28,8 +28,6 @@ mod impls_syntax; pub const ATTR_DIRTY: &'static str = "rustc_dirty"; pub const ATTR_CLEAN: &'static str = "rustc_clean"; -pub const ATTR_DIRTY_METADATA: &'static str = "rustc_metadata_dirty"; -pub const ATTR_CLEAN_METADATA: &'static str = "rustc_metadata_clean"; pub const ATTR_IF_THIS_CHANGED: &'static str = "rustc_if_this_changed"; pub const ATTR_THEN_THIS_WOULD_NEED: &'static str = "rustc_then_this_would_need"; pub const ATTR_PARTITION_REUSED: &'static str = "rustc_partition_reused"; @@ -41,8 +39,6 @@ pub const DEP_GRAPH_ASSERT_ATTRS: &'static [&'static str] = &[ ATTR_THEN_THIS_WOULD_NEED, ATTR_DIRTY, ATTR_CLEAN, - ATTR_DIRTY_METADATA, - ATTR_CLEAN_METADATA, ATTR_PARTITION_REUSED, ATTR_PARTITION_TRANSLATED, ]; @@ -53,8 +49,6 @@ pub const IGNORED_ATTRIBUTES: &'static [&'static str] = &[ ATTR_THEN_THIS_WOULD_NEED, ATTR_DIRTY, ATTR_CLEAN, - ATTR_DIRTY_METADATA, - ATTR_CLEAN_METADATA, ATTR_PARTITION_REUSED, ATTR_PARTITION_TRANSLATED, ]; diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs index 6fadafc7b97ae..514b29120a96a 100644 --- a/src/librustc/infer/error_reporting/mod.rs +++ b/src/librustc/infer/error_reporting/mod.rs @@ -555,6 +555,39 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { fn cmp(&self, t1: Ty<'tcx>, t2: Ty<'tcx>) -> (DiagnosticStyledString, DiagnosticStyledString) { + fn equals<'tcx>(a: &Ty<'tcx>, b: &Ty<'tcx>) -> bool { + match (&a.sty, &b.sty) { + (a, b) if *a == *b => true, + (&ty::TyInt(_), &ty::TyInfer(ty::InferTy::IntVar(_))) | + (&ty::TyInfer(ty::InferTy::IntVar(_)), &ty::TyInt(_)) | + (&ty::TyInfer(ty::InferTy::IntVar(_)), &ty::TyInfer(ty::InferTy::IntVar(_))) | + (&ty::TyFloat(_), &ty::TyInfer(ty::InferTy::FloatVar(_))) | + (&ty::TyInfer(ty::InferTy::FloatVar(_)), &ty::TyFloat(_)) | + (&ty::TyInfer(ty::InferTy::FloatVar(_)), + &ty::TyInfer(ty::InferTy::FloatVar(_))) => true, + _ => false, + } + } + + fn push_ty_ref<'tcx>(r: &ty::Region<'tcx>, + tnm: &ty::TypeAndMut<'tcx>, + s: &mut DiagnosticStyledString) { + let r = &format!("{}", r); + s.push_highlighted(format!("&{}{}{}", + r, + if r == "" { + "" + } else { + " " + }, + if tnm.mutbl == hir::MutMutable { + "mut " + } else { + "" + })); + s.push_normal(format!("{}", tnm.ty)); + } + match (&t1.sty, &t2.sty) { (&ty::TyAdt(def1, sub1), &ty::TyAdt(def2, sub2)) => { let mut values = (DiagnosticStyledString::new(), DiagnosticStyledString::new()); @@ -672,6 +705,29 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { DiagnosticStyledString::highlighted(format!("{}", t2))) } } + + // When finding T != &T, hightlight only the borrow + (&ty::TyRef(r1, ref tnm1), _) if equals(&tnm1.ty, &t2) => { + let mut values = (DiagnosticStyledString::new(), DiagnosticStyledString::new()); + push_ty_ref(&r1, tnm1, &mut values.0); + values.1.push_normal(format!("{}", t2)); + values + } + (_, &ty::TyRef(r2, ref tnm2)) if equals(&t1, &tnm2.ty) => { + let mut values = (DiagnosticStyledString::new(), DiagnosticStyledString::new()); + values.0.push_normal(format!("{}", t1)); + push_ty_ref(&r2, tnm2, &mut values.1); + values + } + + // When encountering &T != &mut T, highlight only the borrow + (&ty::TyRef(r1, ref tnm1), &ty::TyRef(r2, ref tnm2)) if equals(&tnm1.ty, &tnm2.ty) => { + let mut values = (DiagnosticStyledString::new(), DiagnosticStyledString::new()); + push_ty_ref(&r1, tnm1, &mut values.0); + push_ty_ref(&r2, tnm2, &mut values.1); + values + } + _ => { if t1 == t2 { // The two types are the same, elide and don't highlight. diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index ef4a1c8c39949..1008da1e937a5 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -222,6 +222,12 @@ declare_lint! { "detect mut variables which don't need to be mutable" } +declare_lint! { + pub COERCE_NEVER, + Deny, + "detect coercion to !" +} + /// Does nothing as a lint pass, but registers some `Lint`s /// which are used by other parts of the compiler. #[derive(Copy, Clone)] @@ -263,7 +269,8 @@ impl LintPass for HardwiredLints { LATE_BOUND_LIFETIME_ARGUMENTS, DEPRECATED, UNUSED_UNSAFE, - UNUSED_MUT + UNUSED_MUT, + COERCE_NEVER ) } } diff --git a/src/librustc/middle/cstore.rs b/src/librustc/middle/cstore.rs index 5d7141949e389..4be23fb711d77 100644 --- a/src/librustc/middle/cstore.rs +++ b/src/librustc/middle/cstore.rs @@ -175,32 +175,6 @@ impl EncodedMetadata { } } -/// The hash for some metadata that (when saving) will be exported -/// from this crate, or which (when importing) was exported by an -/// upstream crate. -#[derive(Debug, RustcEncodable, RustcDecodable, Copy, Clone)] -pub struct EncodedMetadataHash { - pub def_index: u32, - pub hash: ich::Fingerprint, -} - -/// The hash for some metadata that (when saving) will be exported -/// from this crate, or which (when importing) was exported by an -/// upstream crate. -#[derive(Debug, RustcEncodable, RustcDecodable, Clone)] -pub struct EncodedMetadataHashes { - // Stable content hashes for things in crate metadata, indexed by DefIndex. - pub hashes: Vec, -} - -impl EncodedMetadataHashes { - pub fn new() -> EncodedMetadataHashes { - EncodedMetadataHashes { - hashes: Vec::new(), - } - } -} - /// The backend's way to give the crate store access to the metadata in a library. /// Note that it returns the raw metadata bytes stored in the library file, whether /// it is compressed, uncompressed, some weird mix, etc. @@ -286,7 +260,7 @@ pub trait CrateStore { tcx: TyCtxt<'a, 'tcx, 'tcx>, link_meta: &LinkMeta, reachable: &NodeSet) - -> (EncodedMetadata, EncodedMetadataHashes); + -> EncodedMetadata; fn metadata_encoding_version(&self) -> &[u8]; } @@ -370,7 +344,7 @@ impl CrateStore for DummyCrateStore { tcx: TyCtxt<'a, 'tcx, 'tcx>, link_meta: &LinkMeta, reachable: &NodeSet) - -> (EncodedMetadata, EncodedMetadataHashes) { + -> EncodedMetadata { bug!("encode_metadata") } fn metadata_encoding_version(&self) -> &[u8] { bug!("metadata_encoding_version") } diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 630832372704a..6dade7694ab60 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -1072,8 +1072,6 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options, "attempt to recover from parse errors (experimental)"), incremental: Option = (None, parse_opt_string, [UNTRACKED], "enable incremental compilation (experimental)"), - incremental_cc: bool = (false, parse_bool, [UNTRACKED], - "enable cross-crate incremental compilation (even more experimental)"), incremental_queries: bool = (true, parse_bool, [UNTRACKED], "enable incremental compilation support for queries (experimental)"), incremental_info: bool = (false, parse_bool, [UNTRACKED], diff --git a/src/librustc/traits/mod.rs b/src/librustc/traits/mod.rs index a3a5c26ec186a..8d1bba4332276 100644 --- a/src/librustc/traits/mod.rs +++ b/src/librustc/traits/mod.rs @@ -282,7 +282,7 @@ pub type SelectionResult<'tcx, T> = Result, SelectionError<'tcx>>; /// ### The type parameter `N` /// /// See explanation on `VtableImplData`. -#[derive(Clone)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub enum Vtable<'tcx, N> { /// Vtable identifying a particular impl. VtableImpl(VtableImplData<'tcx, N>), @@ -327,14 +327,14 @@ pub enum Vtable<'tcx, N> { /// is `Obligation`, as one might expect. During trans, however, this /// is `()`, because trans only requires a shallow resolution of an /// impl, and nested obligations are satisfied later. -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable)] pub struct VtableImplData<'tcx, N> { pub impl_def_id: DefId, pub substs: &'tcx Substs<'tcx>, pub nested: Vec } -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable)] pub struct VtableGeneratorData<'tcx, N> { pub closure_def_id: DefId, pub substs: ty::ClosureSubsts<'tcx>, @@ -343,7 +343,7 @@ pub struct VtableGeneratorData<'tcx, N> { pub nested: Vec } -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable)] pub struct VtableClosureData<'tcx, N> { pub closure_def_id: DefId, pub substs: ty::ClosureSubsts<'tcx>, @@ -352,20 +352,20 @@ pub struct VtableClosureData<'tcx, N> { pub nested: Vec } -#[derive(Clone)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub struct VtableAutoImplData { pub trait_def_id: DefId, pub nested: Vec } -#[derive(Clone)] +#[derive(Clone, RustcEncodable, RustcDecodable)] pub struct VtableBuiltinData { pub nested: Vec } /// A vtable for some object-safe trait `Foo` automatically derived /// for the object type `Foo`. -#[derive(PartialEq,Eq,Clone)] +#[derive(PartialEq, Eq, Clone, RustcEncodable, RustcDecodable)] pub struct VtableObjectData<'tcx, N> { /// `Foo` upcast to the obligation trait. This will be some supertrait of `Foo`. pub upcast_trait_ref: ty::PolyTraitRef<'tcx>, @@ -378,7 +378,7 @@ pub struct VtableObjectData<'tcx, N> { pub nested: Vec, } -#[derive(Clone, PartialEq, Eq)] +#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable)] pub struct VtableFnPointerData<'tcx, N> { pub fn_ty: Ty<'tcx>, pub nested: Vec diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index 56754bbc13ed4..385cf0ecd8512 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -24,7 +24,7 @@ use hir::map::DefPathHash; use lint::{self, Lint}; use ich::{StableHashingContext, NodeIdHashingMode}; use middle::const_val::ConstVal; -use middle::cstore::{CrateStore, LinkMeta, EncodedMetadataHashes}; +use middle::cstore::{CrateStore, LinkMeta}; use middle::cstore::EncodedMetadata; use middle::free_region::FreeRegionMap; use middle::lang_items; @@ -1242,7 +1242,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { impl<'a, 'tcx> TyCtxt<'a, 'tcx, 'tcx> { pub fn encode_metadata(self, link_meta: &LinkMeta, reachable: &NodeSet) - -> (EncodedMetadata, EncodedMetadataHashes) + -> EncodedMetadata { self.cstore.encode_metadata(self, link_meta, reachable) } diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 591d1525c827a..07573a48c03ee 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -2302,9 +2302,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } pub fn item_name(self, id: DefId) -> InternedString { - if let Some(id) = self.hir.as_local_node_id(id) { - self.hir.name(id).as_str() - } else if id.index == CRATE_DEF_INDEX { + if id.index == CRATE_DEF_INDEX { self.original_crate_name(id.krate).as_str() } else { let def_key = self.def_key(id); diff --git a/src/librustc_incremental/persist/data.rs b/src/librustc_incremental/persist/data.rs index 08f9dba2ba162..d7d142aac75cc 100644 --- a/src/librustc_incremental/persist/data.rs +++ b/src/librustc_incremental/persist/data.rs @@ -11,9 +11,6 @@ //! The data that we will serialize and deserialize. use rustc::dep_graph::{WorkProduct, WorkProductId}; -use rustc::hir::map::DefPathHash; -use rustc::middle::cstore::EncodedMetadataHash; -use rustc_data_structures::fx::FxHashMap; #[derive(Debug, RustcEncodable, RustcDecodable)] pub struct SerializedWorkProduct { @@ -23,39 +20,3 @@ pub struct SerializedWorkProduct { /// work-product data itself pub work_product: WorkProduct, } - -/// Data for use when downstream crates get recompiled. -#[derive(Debug, RustcEncodable, RustcDecodable)] -pub struct SerializedMetadataHashes { - /// For each def-id defined in this crate that appears in the - /// metadata, we hash all the inputs that were used when producing - /// the metadata. We save this after compilation is done. Then, - /// when some downstream crate is being recompiled, it can compare - /// the hashes we saved against the hashes that it saw from - /// before; this will tell it which of the items in this crate - /// changed, which in turn implies what items in the downstream - /// crate need to be recompiled. - /// - /// Note that we store the def-ids here. This is because we don't - /// reload this file when we recompile this crate, we will just - /// regenerate it completely with the current hashes and new def-ids. - /// - /// Then downstream creates will load up their - /// `SerializedDepGraph`, which may contain `MetaData(X)` nodes - /// where `X` refers to some item in this crate. That `X` will be - /// a `DefPathIndex` that gets retracted to the current `DefId` - /// (matching the one found in this structure). - pub entry_hashes: Vec, - - /// For each DefIndex (as it occurs in SerializedMetadataHash), this - /// map stores the DefPathIndex (as it occurs in DefIdDirectory), so - /// that we can find the new DefId for a SerializedMetadataHash in a - /// subsequent compilation session. - /// - /// This map is only needed for running auto-tests using the - /// #[rustc_metadata_dirty] and #[rustc_metadata_clean] attributes, and - /// is only populated if -Z query-dep-graph is specified. It will be - /// empty otherwise. Importing crates are perfectly happy with just having - /// the DefIndex. - pub index_map: FxHashMap -} diff --git a/src/librustc_incremental/persist/dirty_clean.rs b/src/librustc_incremental/persist/dirty_clean.rs index e871c0dbdab13..7c3f903f22846 100644 --- a/src/librustc_incremental/persist/dirty_clean.rs +++ b/src/librustc_incremental/persist/dirty_clean.rs @@ -23,21 +23,6 @@ //! Errors are reported if we are in the suitable configuration but //! the required condition is not met. //! -//! The `#[rustc_metadata_dirty]` and `#[rustc_metadata_clean]` attributes -//! can be used to check the incremental compilation hash (ICH) values of -//! metadata exported in rlibs. -//! -//! - If a node is marked with `#[rustc_metadata_clean(cfg="rev2")]` we -//! check that the metadata hash for that node is the same for "rev2" -//! it was for "rev1". -//! - If a node is marked with `#[rustc_metadata_dirty(cfg="rev2")]` we -//! check that the metadata hash for that node is *different* for "rev2" -//! than it was for "rev1". -//! -//! Note that the metadata-testing attributes must never specify the -//! first revision. This would lead to a crash since there is no -//! previous revision to compare things to. -//! use std::collections::HashSet; use std::iter::FromIterator; @@ -49,10 +34,9 @@ use rustc::hir::map::Node as HirNode; use rustc::hir::def_id::DefId; use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::hir::intravisit; -use rustc::ich::{Fingerprint, ATTR_DIRTY, ATTR_CLEAN, ATTR_DIRTY_METADATA, - ATTR_CLEAN_METADATA}; +use rustc::ich::{ATTR_DIRTY, ATTR_CLEAN}; use syntax::ast::{self, Attribute, NestedMetaItem}; -use rustc_data_structures::fx::{FxHashSet, FxHashMap}; +use rustc_data_structures::fx::FxHashSet; use syntax_pos::Span; use rustc::ty::TyCtxt; @@ -553,157 +537,6 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for DirtyCleanVisitor<'a, 'tcx> { } } -pub fn check_dirty_clean_metadata<'a, 'tcx>( - tcx: TyCtxt<'a, 'tcx, 'tcx>, - prev_metadata_hashes: &FxHashMap, - current_metadata_hashes: &FxHashMap) -{ - if !tcx.sess.opts.debugging_opts.query_dep_graph { - return; - } - - tcx.dep_graph.with_ignore(||{ - let krate = tcx.hir.krate(); - let mut dirty_clean_visitor = DirtyCleanMetadataVisitor { - tcx, - prev_metadata_hashes, - current_metadata_hashes, - checked_attrs: FxHashSet(), - }; - intravisit::walk_crate(&mut dirty_clean_visitor, krate); - - let mut all_attrs = FindAllAttrs { - tcx, - attr_names: vec![ATTR_DIRTY_METADATA, ATTR_CLEAN_METADATA], - found_attrs: vec![], - }; - intravisit::walk_crate(&mut all_attrs, krate); - - // Note that we cannot use the existing "unused attribute"-infrastructure - // here, since that is running before trans. This is also the reason why - // all trans-specific attributes are `Whitelisted` in syntax::feature_gate. - all_attrs.report_unchecked_attrs(&dirty_clean_visitor.checked_attrs); - }); -} - -pub struct DirtyCleanMetadataVisitor<'a, 'tcx: 'a, 'm> { - tcx: TyCtxt<'a, 'tcx, 'tcx>, - prev_metadata_hashes: &'m FxHashMap, - current_metadata_hashes: &'m FxHashMap, - checked_attrs: FxHashSet, -} - -impl<'a, 'tcx, 'm> intravisit::Visitor<'tcx> for DirtyCleanMetadataVisitor<'a, 'tcx, 'm> { - - fn nested_visit_map<'this>(&'this mut self) -> intravisit::NestedVisitorMap<'this, 'tcx> { - intravisit::NestedVisitorMap::All(&self.tcx.hir) - } - - fn visit_item(&mut self, item: &'tcx hir::Item) { - self.check_item(item.id, item.span); - intravisit::walk_item(self, item); - } - - fn visit_variant(&mut self, - variant: &'tcx hir::Variant, - generics: &'tcx hir::Generics, - parent_id: ast::NodeId) { - if let Some(e) = variant.node.disr_expr { - self.check_item(e.node_id, variant.span); - } - - intravisit::walk_variant(self, variant, generics, parent_id); - } - - fn visit_variant_data(&mut self, - variant_data: &'tcx hir::VariantData, - _: ast::Name, - _: &'tcx hir::Generics, - _parent_id: ast::NodeId, - span: Span) { - if self.tcx.hir.find(variant_data.id()).is_some() { - // VariantData that represent structs or tuples don't have a - // separate entry in the HIR map and checking them would error, - // so only check if this is an enum or union variant. - self.check_item(variant_data.id(), span); - } - - intravisit::walk_struct_def(self, variant_data); - } - - fn visit_trait_item(&mut self, item: &'tcx hir::TraitItem) { - self.check_item(item.id, item.span); - intravisit::walk_trait_item(self, item); - } - - fn visit_impl_item(&mut self, item: &'tcx hir::ImplItem) { - self.check_item(item.id, item.span); - intravisit::walk_impl_item(self, item); - } - - fn visit_foreign_item(&mut self, i: &'tcx hir::ForeignItem) { - self.check_item(i.id, i.span); - intravisit::walk_foreign_item(self, i); - } - - fn visit_struct_field(&mut self, s: &'tcx hir::StructField) { - self.check_item(s.id, s.span); - intravisit::walk_struct_field(self, s); - } -} - -impl<'a, 'tcx, 'm> DirtyCleanMetadataVisitor<'a, 'tcx, 'm> { - - fn check_item(&mut self, item_id: ast::NodeId, item_span: Span) { - let def_id = self.tcx.hir.local_def_id(item_id); - - for attr in self.tcx.get_attrs(def_id).iter() { - if attr.check_name(ATTR_DIRTY_METADATA) { - if check_config(self.tcx, attr) { - if self.checked_attrs.insert(attr.id) { - self.assert_state(false, def_id, item_span); - } - } - } else if attr.check_name(ATTR_CLEAN_METADATA) { - if check_config(self.tcx, attr) { - if self.checked_attrs.insert(attr.id) { - self.assert_state(true, def_id, item_span); - } - } - } - } - } - - fn assert_state(&self, should_be_clean: bool, def_id: DefId, span: Span) { - let item_path = self.tcx.item_path_str(def_id); - debug!("assert_state({})", item_path); - - if let Some(&prev_hash) = self.prev_metadata_hashes.get(&def_id) { - let hashes_are_equal = prev_hash == self.current_metadata_hashes[&def_id]; - - if should_be_clean && !hashes_are_equal { - self.tcx.sess.span_err( - span, - &format!("Metadata hash of `{}` is dirty, but should be clean", - item_path)); - } - - let should_be_dirty = !should_be_clean; - if should_be_dirty && hashes_are_equal { - self.tcx.sess.span_err( - span, - &format!("Metadata hash of `{}` is clean, but should be dirty", - item_path)); - } - } else { - self.tcx.sess.span_err( - span, - &format!("Could not find previous metadata hash of `{}`", - item_path)); - } - } -} - /// Given a `#[rustc_dirty]` or `#[rustc_clean]` attribute, scan /// for a `cfg="foo"` attribute and check whether we have a cfg /// flag called `foo`. @@ -759,7 +592,6 @@ fn expect_associated_value(tcx: TyCtxt, item: &NestedMetaItem) -> ast::Name { } } - // A visitor that collects all #[rustc_dirty]/#[rustc_clean] attributes from // the HIR. It is used to verfiy that we really ran checks for all annotated // nodes. diff --git a/src/librustc_incremental/persist/fs.rs b/src/librustc_incremental/persist/fs.rs index 4141137a7db96..2a8cfb7e91d71 100644 --- a/src/librustc_incremental/persist/fs.rs +++ b/src/librustc_incremental/persist/fs.rs @@ -131,7 +131,6 @@ use rand::{thread_rng, Rng}; const LOCK_FILE_EXT: &'static str = ".lock"; const DEP_GRAPH_FILENAME: &'static str = "dep-graph.bin"; const WORK_PRODUCTS_FILENAME: &'static str = "work-products.bin"; -const METADATA_HASHES_FILENAME: &'static str = "metadata.bin"; const QUERY_CACHE_FILENAME: &'static str = "query-cache.bin"; // We encode integers using the following base, so they are shorter than decimal @@ -148,10 +147,6 @@ pub fn work_products_path(sess: &Session) -> PathBuf { in_incr_comp_dir_sess(sess, WORK_PRODUCTS_FILENAME) } -pub fn metadata_hash_export_path(sess: &Session) -> PathBuf { - in_incr_comp_dir_sess(sess, METADATA_HASHES_FILENAME) -} - pub fn query_cache_path(sess: &Session) -> PathBuf { in_incr_comp_dir_sess(sess, QUERY_CACHE_FILENAME) } diff --git a/src/librustc_incremental/persist/load.rs b/src/librustc_incremental/persist/load.rs index e4bc6b7339efc..5907f00e3dc48 100644 --- a/src/librustc_incremental/persist/load.rs +++ b/src/librustc_incremental/persist/load.rs @@ -11,12 +11,9 @@ //! Code to save/load the dep-graph from files. use rustc::dep_graph::{PreviousDepGraph, SerializedDepGraph}; -use rustc::hir::svh::Svh; -use rustc::ich::Fingerprint; use rustc::session::Session; use rustc::ty::TyCtxt; use rustc::ty::maps::OnDiskCache; -use rustc::util::nodemap::DefIdMap; use rustc_serialize::Decodable as RustcDecodable; use rustc_serialize::opaque::Decoder; use std::path::Path; @@ -106,64 +103,6 @@ fn delete_dirty_work_product(tcx: TyCtxt, work_product::delete_workproduct_files(tcx.sess, &swp.work_product); } -pub fn load_prev_metadata_hashes(tcx: TyCtxt) -> DefIdMap { - let mut output = DefIdMap(); - - if !tcx.sess.opts.debugging_opts.query_dep_graph { - // Previous metadata hashes are only needed for testing. - return output - } - - debug!("load_prev_metadata_hashes() - Loading previous metadata hashes"); - - let file_path = metadata_hash_export_path(tcx.sess); - - if !file_path.exists() { - debug!("load_prev_metadata_hashes() - Couldn't find file containing \ - hashes at `{}`", file_path.display()); - return output - } - - debug!("load_prev_metadata_hashes() - File: {}", file_path.display()); - - let (data, start_pos) = match file_format::read_file(tcx.sess, &file_path) { - Ok(Some(data_and_pos)) => data_and_pos, - Ok(None) => { - debug!("load_prev_metadata_hashes() - File produced by incompatible \ - compiler version: {}", file_path.display()); - return output - } - Err(err) => { - debug!("load_prev_metadata_hashes() - Error reading file `{}`: {}", - file_path.display(), err); - return output - } - }; - - debug!("load_prev_metadata_hashes() - Decoding hashes"); - let mut decoder = Decoder::new(&data, start_pos); - let _ = Svh::decode(&mut decoder).unwrap(); - let serialized_hashes = SerializedMetadataHashes::decode(&mut decoder).unwrap(); - - debug!("load_prev_metadata_hashes() - Mapping DefIds"); - - assert_eq!(serialized_hashes.index_map.len(), serialized_hashes.entry_hashes.len()); - let def_path_hash_to_def_id = tcx.def_path_hash_to_def_id.as_ref().unwrap(); - - for serialized_hash in serialized_hashes.entry_hashes { - let def_path_hash = serialized_hashes.index_map[&serialized_hash.def_index]; - if let Some(&def_id) = def_path_hash_to_def_id.get(&def_path_hash) { - let old = output.insert(def_id, serialized_hash.hash); - assert!(old.is_none(), "already have hash for {:?}", def_id); - } - } - - debug!("load_prev_metadata_hashes() - successfully loaded {} hashes", - serialized_hashes.index_map.len()); - - output -} - pub fn load_dep_graph(sess: &Session) -> PreviousDepGraph { let empty = PreviousDepGraph::new(SerializedDepGraph::new()); diff --git a/src/librustc_incremental/persist/save.rs b/src/librustc_incremental/persist/save.rs index a438ac42838db..6eaa14a50f40f 100644 --- a/src/librustc_incremental/persist/save.rs +++ b/src/librustc_incremental/persist/save.rs @@ -9,14 +9,9 @@ // except according to those terms. use rustc::dep_graph::{DepGraph, DepKind}; -use rustc::hir::def_id::{DefId, DefIndex}; -use rustc::hir::svh::Svh; -use rustc::ich::Fingerprint; -use rustc::middle::cstore::EncodedMetadataHashes; use rustc::session::Session; use rustc::ty::TyCtxt; use rustc::util::common::time; -use rustc::util::nodemap::DefIdMap; use rustc_data_structures::fx::FxHashMap; use rustc_serialize::Encodable as RustcEncodable; use rustc_serialize::opaque::Encoder; @@ -30,11 +25,7 @@ use super::dirty_clean; use super::file_format; use super::work_product; -use super::load::load_prev_metadata_hashes; - -pub fn save_dep_graph<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, - metadata_hashes: &EncodedMetadataHashes, - svh: Svh) { +pub fn save_dep_graph<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { debug!("save_dep_graph()"); let _ignore = tcx.dep_graph.in_ignore(); let sess = tcx.sess; @@ -42,27 +33,6 @@ pub fn save_dep_graph<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, return; } - // We load the previous metadata hashes now before overwriting the file - // (if we need them for testing). - let prev_metadata_hashes = if tcx.sess.opts.debugging_opts.query_dep_graph { - load_prev_metadata_hashes(tcx) - } else { - DefIdMap() - }; - - let mut current_metadata_hashes = FxHashMap(); - - if sess.opts.debugging_opts.incremental_cc || - sess.opts.debugging_opts.query_dep_graph { - save_in(sess, - metadata_hash_export_path(sess), - |e| encode_metadata_hashes(tcx, - svh, - metadata_hashes, - &mut current_metadata_hashes, - e)); - } - time(sess.time_passes(), "persist query result cache", || { save_in(sess, query_cache_path(sess), @@ -78,9 +48,6 @@ pub fn save_dep_graph<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, } dirty_clean::check_dirty_clean_annotations(tcx); - dirty_clean::check_dirty_clean_metadata(tcx, - &prev_metadata_hashes, - ¤t_metadata_hashes); } pub fn save_work_products(sess: &Session, dep_graph: &DepGraph) { @@ -258,43 +225,6 @@ fn encode_dep_graph(tcx: TyCtxt, Ok(()) } -fn encode_metadata_hashes(tcx: TyCtxt, - svh: Svh, - metadata_hashes: &EncodedMetadataHashes, - current_metadata_hashes: &mut FxHashMap, - encoder: &mut Encoder) - -> io::Result<()> { - assert_eq!(metadata_hashes.hashes.len(), - metadata_hashes.hashes.iter().map(|x| (x.def_index, ())).collect::>().len()); - - let mut serialized_hashes = SerializedMetadataHashes { - entry_hashes: metadata_hashes.hashes.to_vec(), - index_map: FxHashMap() - }; - - if tcx.sess.opts.debugging_opts.query_dep_graph { - for serialized_hash in &serialized_hashes.entry_hashes { - let def_id = DefId::local(DefIndex::from_u32(serialized_hash.def_index)); - - // Store entry in the index_map - let def_path_hash = tcx.def_path_hash(def_id); - serialized_hashes.index_map.insert(def_id.index.as_u32(), def_path_hash); - - // Record hash in current_metadata_hashes - current_metadata_hashes.insert(def_id, serialized_hash.hash); - } - - debug!("save: stored index_map (len={}) for serialized hashes", - serialized_hashes.index_map.len()); - } - - // Encode everything. - svh.encode(encoder)?; - serialized_hashes.encode(encoder)?; - - Ok(()) -} - fn encode_work_products(dep_graph: &DepGraph, encoder: &mut Encoder) -> io::Result<()> { let work_products: Vec<_> = dep_graph diff --git a/src/librustc_lint/lib.rs b/src/librustc_lint/lib.rs index b4d439f0ba809..fc05f8f0dc245 100644 --- a/src/librustc_lint/lib.rs +++ b/src/librustc_lint/lib.rs @@ -247,6 +247,10 @@ pub fn register_builtins(store: &mut lint::LintStore, sess: Option<&Session>) { id: LintId::of(SAFE_PACKED_BORROWS), reference: "issue #46043 ", }, + FutureIncompatibleInfo { + id: LintId::of(COERCE_NEVER), + reference: "issue #46325 ", + }, ]); diff --git a/src/librustc_llvm/build.rs b/src/librustc_llvm/build.rs index 141a9a8d704d2..f294ceb3f3832 100644 --- a/src/librustc_llvm/build.rs +++ b/src/librustc_llvm/build.rs @@ -154,13 +154,13 @@ fn main() { } for component in &components { - let mut flag = String::from("-DLLVM_COMPONENT_"); + let mut flag = String::from("LLVM_COMPONENT_"); flag.push_str(&component.to_uppercase()); - cfg.flag(&flag); + cfg.define(&flag, None); } if env::var_os("LLVM_RUSTLLVM").is_some() { - cfg.flag("-DLLVM_RUSTLLVM"); + cfg.define("LLVM_RUSTLLVM", None); } build_helper::rerun_if_changed_anything_in_dir(Path::new("../rustllvm")); @@ -169,7 +169,7 @@ fn main() { .file("../rustllvm/ArchiveWrapper.cpp") .cpp(true) .cpp_link_stdlib(None) // we handle this below - .compile("librustllvm.a"); + .compile("rustllvm"); let (llvm_kind, llvm_link_arg) = detect_llvm_link(major, minor, &llvm_config); diff --git a/src/librustc_llvm/ffi.rs b/src/librustc_llvm/ffi.rs index dd64d76bc0c51..1c2fa1bbb4848 100644 --- a/src/librustc_llvm/ffi.rs +++ b/src/librustc_llvm/ffi.rs @@ -505,17 +505,13 @@ pub mod debuginfo { pub enum ModuleBuffer {} -// Link to our native llvm bindings (things that we need to use the C++ api -// for) and because llvm is written in C++ we need to link against libstdc++ -// -// You'll probably notice that there is an omission of all LLVM libraries -// from this location. This is because the set of LLVM libraries that we -// link to is mostly defined by LLVM, and the `llvm-config` tool is used to -// figure out the exact set of libraries. To do this, the build system -// generates an llvmdeps.rs file next to this one which will be -// automatically updated whenever LLVM is updated to include an up-to-date -// set of the libraries we need to link to LLVM for. -#[link(name = "rustllvm", kind = "static")] // not quite true but good enough +// This annotation is primarily needed for MSVC where attributes like +// dllimport/dllexport are applied and need to be correct for everything to +// link successfully. The #[link] annotation here says "these symbols are +// included statically" which means that they're all exported with dllexport +// and from the rustc_llvm dynamic library. Otherwise the rustc_trans dynamic +// library would not be able to access these symbols. +#[link(name = "rustllvm", kind = "static")] extern "C" { // Create and destroy contexts. pub fn LLVMContextCreate() -> ContextRef; diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs index 1f671adf4f8a4..911b4dac4e13a 100644 --- a/src/librustc_metadata/cstore_impl.rs +++ b/src/librustc_metadata/cstore_impl.rs @@ -17,8 +17,7 @@ use schema; use rustc::ty::maps::QueryConfig; use rustc::middle::cstore::{CrateStore, DepKind, MetadataLoader, LinkMeta, - LoadedMacro, EncodedMetadata, - EncodedMetadataHashes, NativeLibraryKind}; + LoadedMacro, EncodedMetadata, NativeLibraryKind}; use rustc::middle::stability::DeprecationEntry; use rustc::hir::def; use rustc::session::{CrateDisambiguator, Session}; @@ -498,7 +497,7 @@ impl CrateStore for cstore::CStore { tcx: TyCtxt<'a, 'tcx, 'tcx>, link_meta: &LinkMeta, reachable: &NodeSet) - -> (EncodedMetadata, EncodedMetadataHashes) + -> EncodedMetadata { encoder::encode_metadata(tcx, link_meta, reachable) } diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index de6bb9ea738be..6cfa324797c5d 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -14,12 +14,10 @@ use isolated_encoder::IsolatedEncoder; use schema::*; use rustc::middle::cstore::{LinkMeta, LinkagePreference, NativeLibrary, - EncodedMetadata, EncodedMetadataHashes, - EncodedMetadataHash}; + EncodedMetadata}; use rustc::hir::def::CtorKind; use rustc::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefIndex, DefId, LOCAL_CRATE}; -use rustc::hir::map::definitions::{DefPathTable, GlobalMetaDataKind}; -use rustc::ich::Fingerprint; +use rustc::hir::map::definitions::DefPathTable; use rustc::middle::dependency_format::Linkage; use rustc::middle::lang_items; use rustc::mir; @@ -57,9 +55,6 @@ pub struct EncodeContext<'a, 'tcx: 'a> { lazy_state: LazyState, type_shorthands: FxHashMap, usize>, predicate_shorthands: FxHashMap, usize>, - - pub metadata_hashes: EncodedMetadataHashes, - pub compute_ich: bool, } macro_rules! encoder_methods { @@ -239,22 +234,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { // Encodes something that corresponds to a single DepNode::GlobalMetaData // and registers the Fingerprint in the `metadata_hashes` map. pub fn tracked<'x, DATA, R>(&'x mut self, - def_index: DefIndex, op: fn(&mut IsolatedEncoder<'x, 'a, 'tcx>, DATA) -> R, data: DATA) -> R { - let mut entry_builder = IsolatedEncoder::new(self); - let ret = op(&mut entry_builder, data); - let (fingerprint, this) = entry_builder.finish(); - - if let Some(fingerprint) = fingerprint { - this.metadata_hashes.hashes.push(EncodedMetadataHash { - def_index: def_index.as_u32(), - hash: fingerprint, - }) - } - - ret + op(&mut IsolatedEncoder::new(self), data) } fn encode_info_for_items(&mut self) -> Index { @@ -320,30 +303,16 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { fn encode_crate_root(&mut self) -> Lazy { let mut i = self.position(); - let tcx = self.tcx; - let global_metadata_def_index = move |kind: GlobalMetaDataKind| { - kind.def_index(tcx.hir.definitions().def_path_table()) - }; - - let crate_deps = self.tracked( - global_metadata_def_index(GlobalMetaDataKind::CrateDeps), - IsolatedEncoder::encode_crate_deps, - ()); + let crate_deps = self.tracked(IsolatedEncoder::encode_crate_deps, ()); let dylib_dependency_formats = self.tracked( - global_metadata_def_index(GlobalMetaDataKind::DylibDependencyFormats), IsolatedEncoder::encode_dylib_dependency_formats, ()); let dep_bytes = self.position() - i; // Encode the language items. i = self.position(); - let lang_items = self.tracked( - global_metadata_def_index(GlobalMetaDataKind::LangItems), - IsolatedEncoder::encode_lang_items, - ()); - + let lang_items = self.tracked(IsolatedEncoder::encode_lang_items, ()); let lang_items_missing = self.tracked( - global_metadata_def_index(GlobalMetaDataKind::LangItemsMissing), IsolatedEncoder::encode_lang_items_missing, ()); let lang_item_bytes = self.position() - i; @@ -351,7 +320,6 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { // Encode the native libraries used i = self.position(); let native_libraries = self.tracked( - global_metadata_def_index(GlobalMetaDataKind::NativeLibraries), IsolatedEncoder::encode_native_libraries, ()); let native_lib_bytes = self.position() - i; @@ -368,16 +336,12 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { // Encode the def IDs of impls, for coherence checking. i = self.position(); - let impls = self.tracked( - global_metadata_def_index(GlobalMetaDataKind::Impls), - IsolatedEncoder::encode_impls, - ()); + let impls = self.tracked(IsolatedEncoder::encode_impls, ()); let impl_bytes = self.position() - i; // Encode exported symbols info. i = self.position(); let exported_symbols = self.tracked( - global_metadata_def_index(GlobalMetaDataKind::ExportedSymbols), IsolatedEncoder::encode_exported_symbols, self.exported_symbols); let exported_symbols_bytes = self.position() - i; @@ -430,11 +394,6 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { let total_bytes = self.position(); - self.metadata_hashes.hashes.push(EncodedMetadataHash { - def_index: global_metadata_def_index(GlobalMetaDataKind::Krate).as_u32(), - hash: Fingerprint::from_smaller_hash(link_meta.crate_hash.as_u64()) - }); - if self.tcx.sess.meta_stats() { let mut zero_bytes = 0; for e in self.opaque.cursor.get_ref() { @@ -1663,7 +1622,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for ImplVisitor<'a, 'tcx> { pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, link_meta: &LinkMeta, exported_symbols: &NodeSet) - -> (EncodedMetadata, EncodedMetadataHashes) + -> EncodedMetadata { let mut cursor = Cursor::new(vec![]); cursor.write_all(METADATA_HEADER).unwrap(); @@ -1671,11 +1630,7 @@ pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // Will be filled with the root position after encoding everything. cursor.write_all(&[0, 0, 0, 0]).unwrap(); - let compute_ich = (tcx.sess.opts.debugging_opts.query_dep_graph || - tcx.sess.opts.debugging_opts.incremental_cc) && - tcx.sess.opts.build_dep_graph(); - - let (root, metadata_hashes) = { + let root = { let mut ecx = EncodeContext { opaque: opaque::Encoder::new(&mut cursor), tcx, @@ -1684,8 +1639,6 @@ pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, lazy_state: LazyState::NoNode, type_shorthands: Default::default(), predicate_shorthands: Default::default(), - metadata_hashes: EncodedMetadataHashes::new(), - compute_ich, }; // Encode the rustc version string in a predictable location. @@ -1693,8 +1646,7 @@ pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // Encode all the entries and extra information in the crate, // culminating in the `CrateRoot` which points to all of it. - let root = ecx.encode_crate_root(); - (root, ecx.metadata_hashes) + ecx.encode_crate_root() }; let mut result = cursor.into_inner(); @@ -1706,7 +1658,7 @@ pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, result[header + 2] = (pos >> 8) as u8; result[header + 3] = (pos >> 0) as u8; - (EncodedMetadata { raw_data: result }, metadata_hashes) + EncodedMetadata { raw_data: result } } pub fn get_repr_options<'a, 'tcx, 'gcx>(tcx: &TyCtxt<'a, 'tcx, 'gcx>, did: DefId) -> ReprOptions { diff --git a/src/librustc_metadata/index_builder.rs b/src/librustc_metadata/index_builder.rs index 46706bba96d6d..f218268914300 100644 --- a/src/librustc_metadata/index_builder.rs +++ b/src/librustc_metadata/index_builder.rs @@ -62,7 +62,6 @@ use isolated_encoder::IsolatedEncoder; use rustc::hir; use rustc::hir::def_id::DefId; -use rustc::middle::cstore::EncodedMetadataHash; use rustc::ty::TyCtxt; use syntax::ast; @@ -128,19 +127,10 @@ impl<'a, 'b, 'tcx> IndexBuilder<'a, 'b, 'tcx> { // unclear whether that would be a win since hashing is cheap enough. let _task = tcx.dep_graph.in_ignore(); - let ecx: &'x mut EncodeContext<'b, 'tcx> = &mut *self.ecx; - let mut entry_builder = IsolatedEncoder::new(ecx); + let mut entry_builder = IsolatedEncoder::new(self.ecx); let entry = op(&mut entry_builder, data); let entry = entry_builder.lazy(&entry); - let (fingerprint, ecx) = entry_builder.finish(); - if let Some(hash) = fingerprint { - ecx.metadata_hashes.hashes.push(EncodedMetadataHash { - def_index: id.index.as_u32(), - hash, - }); - } - self.items.record(id, entry); } diff --git a/src/librustc_metadata/isolated_encoder.rs b/src/librustc_metadata/isolated_encoder.rs index 7dc50fe29df07..689c190966ee8 100644 --- a/src/librustc_metadata/isolated_encoder.rs +++ b/src/librustc_metadata/isolated_encoder.rs @@ -10,12 +10,7 @@ use encoder::EncodeContext; use schema::{Lazy, LazySeq}; - -use rustc::ich::{StableHashingContext, Fingerprint}; use rustc::ty::TyCtxt; - -use rustc_data_structures::accumulate_vec::AccumulateVec; -use rustc_data_structures::stable_hasher::{StableHasher, HashStable}; use rustc_serialize::Encodable; /// The IsolatedEncoder provides facilities to write to crate metadata while @@ -23,148 +18,47 @@ use rustc_serialize::Encodable; pub struct IsolatedEncoder<'a, 'b: 'a, 'tcx: 'b> { pub tcx: TyCtxt<'b, 'tcx, 'tcx>, ecx: &'a mut EncodeContext<'b, 'tcx>, - hcx: Option<(StableHashingContext<'tcx>, StableHasher)>, } impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { pub fn new(ecx: &'a mut EncodeContext<'b, 'tcx>) -> Self { let tcx = ecx.tcx; - let compute_ich = ecx.compute_ich; IsolatedEncoder { tcx, ecx, - hcx: if compute_ich { - // We are always hashing spans for things in metadata because - // don't know if a downstream crate will use them or not. - // Except when -Zquery-dep-graph is specified because we don't - // want to mess up our tests. - let hcx = if tcx.sess.opts.debugging_opts.query_dep_graph { - tcx.create_stable_hashing_context() - } else { - tcx.create_stable_hashing_context().force_span_hashing() - }; - - Some((hcx, StableHasher::new())) - } else { - None - } - } - } - - pub fn finish(self) -> (Option, &'a mut EncodeContext<'b, 'tcx>) { - if let Some((_, hasher)) = self.hcx { - (Some(hasher.finish()), self.ecx) - } else { - (None, self.ecx) } } pub fn lazy(&mut self, value: &T) -> Lazy - where T: Encodable + HashStable> + where T: Encodable { - if let Some((ref mut hcx, ref mut hasher)) = self.hcx { - value.hash_stable(hcx, hasher); - debug!("metadata-hash: {:?}", hasher); - } self.ecx.lazy(value) } pub fn lazy_seq(&mut self, iter: I) -> LazySeq where I: IntoIterator, - T: Encodable + HashStable> + T: Encodable { - if let Some((ref mut hcx, ref mut hasher)) = self.hcx { - let iter = iter.into_iter(); - let (lower_bound, upper_bound) = iter.size_hint(); - - if upper_bound == Some(lower_bound) { - lower_bound.hash_stable(hcx, hasher); - let mut num_items_hashed = 0; - let ret = self.ecx.lazy_seq(iter.inspect(|item| { - item.hash_stable(hcx, hasher); - num_items_hashed += 1; - })); - - // Sometimes items in a sequence are filtered out without being - // hashed (e.g. for &[ast::Attribute]) and this code path cannot - // handle that correctly, so we want to make sure we didn't hit - // it by accident. - if lower_bound != num_items_hashed { - bug!("Hashed a different number of items ({}) than expected ({})", - num_items_hashed, - lower_bound); - } - debug!("metadata-hash: {:?}", hasher); - ret - } else { - // Collect into a vec so we know the length of the sequence - let items: AccumulateVec<[T; 32]> = iter.collect(); - items.hash_stable(hcx, hasher); - debug!("metadata-hash: {:?}", hasher); - self.ecx.lazy_seq(items) - } - } else { - self.ecx.lazy_seq(iter) - } + self.ecx.lazy_seq(iter) } pub fn lazy_seq_ref<'x, I, T>(&mut self, iter: I) -> LazySeq where I: IntoIterator, - T: 'x + Encodable + HashStable> + T: 'x + Encodable { - if let Some((ref mut hcx, ref mut hasher)) = self.hcx { - let iter = iter.into_iter(); - let (lower_bound, upper_bound) = iter.size_hint(); - - if upper_bound == Some(lower_bound) { - lower_bound.hash_stable(hcx, hasher); - let mut num_items_hashed = 0; - let ret = self.ecx.lazy_seq_ref(iter.inspect(|item| { - item.hash_stable(hcx, hasher); - num_items_hashed += 1; - })); - - // Sometimes items in a sequence are filtered out without being - // hashed (e.g. for &[ast::Attribute]) and this code path cannot - // handle that correctly, so we want to make sure we didn't hit - // it by accident. - if lower_bound != num_items_hashed { - bug!("Hashed a different number of items ({}) than expected ({})", - num_items_hashed, - lower_bound); - } - debug!("metadata-hash: {:?}", hasher); - ret - } else { - // Collect into a vec so we know the length of the sequence - let items: AccumulateVec<[&'x T; 32]> = iter.collect(); - items.hash_stable(hcx, hasher); - debug!("metadata-hash: {:?}", hasher); - self.ecx.lazy_seq_ref(items.iter().map(|x| *x)) - } - } else { - self.ecx.lazy_seq_ref(iter) - } + self.ecx.lazy_seq_ref(iter) } pub fn lazy_seq_from_slice(&mut self, slice: &[T]) -> LazySeq - where T: Encodable + HashStable> + where T: Encodable { - if let Some((ref mut hcx, ref mut hasher)) = self.hcx { - slice.hash_stable(hcx, hasher); - debug!("metadata-hash: {:?}", hasher); - } self.ecx.lazy_seq_ref(slice.iter()) } pub fn lazy_seq_ref_from_slice(&mut self, slice: &[&T]) -> LazySeq - where T: Encodable + HashStable> + where T: Encodable { - if let Some((ref mut hcx, ref mut hasher)) = self.hcx { - slice.hash_stable(hcx, hasher); - debug!("metadata-hash: {:?}", hasher); - } self.ecx.lazy_seq_ref(slice.iter().map(|x| *x)) } } diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 3243152527ffc..85e2144f6cd79 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -1560,6 +1560,15 @@ impl<'a> Resolver<'a> { } } + fn macro_def(&self, mut ctxt: SyntaxContext) -> DefId { + loop { + match self.macro_defs.get(&ctxt.outer()) { + Some(&def_id) => return def_id, + None => ctxt.remove_mark(), + }; + } + } + /// Entry point to crate resolution. pub fn resolve_crate(&mut self, krate: &Crate) { ImportResolver { resolver: self }.finalize_imports(); @@ -1663,7 +1672,7 @@ impl<'a> Resolver<'a> { module = match self.ribs[ns][i].kind { ModuleRibKind(module) => module, - MacroDefinition(def) if def == self.macro_defs[&ident.ctxt.outer()] => { + MacroDefinition(def) if def == self.macro_def(ident.ctxt) => { // If an invocation of this macro created `ident`, give up on `ident` // and switch to `ident`'s source from the macro definition. ident.ctxt.remove_mark(); @@ -1830,7 +1839,7 @@ impl<'a> Resolver<'a> { // If an invocation of this macro created `ident`, give up on `ident` // and switch to `ident`'s source from the macro definition. MacroDefinition(def) => { - if def == self.macro_defs[&ident.ctxt.outer()] { + if def == self.macro_def(ident.ctxt) { ident.ctxt.remove_mark(); } } diff --git a/src/librustc_trans/base.rs b/src/librustc_trans/base.rs index b7408681ed0c8..62738222a8c01 100644 --- a/src/librustc_trans/base.rs +++ b/src/librustc_trans/base.rs @@ -39,7 +39,7 @@ use metadata; use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; use rustc::middle::lang_items::StartFnLangItem; use rustc::middle::trans::{Linkage, Visibility, Stats}; -use rustc::middle::cstore::{EncodedMetadata, EncodedMetadataHashes}; +use rustc::middle::cstore::EncodedMetadata; use rustc::ty::{self, Ty, TyCtxt}; use rustc::ty::layout::{self, Align, TyLayout, LayoutOf}; use rustc::ty::maps::Providers; @@ -602,8 +602,7 @@ fn write_metadata<'a, 'gcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>, llmod_id: &str, link_meta: &LinkMeta, exported_symbols: &NodeSet) - -> (ContextRef, ModuleRef, - EncodedMetadata, EncodedMetadataHashes) { + -> (ContextRef, ModuleRef, EncodedMetadata) { use std::io::Write; use flate2::Compression; use flate2::write::DeflateEncoder; @@ -635,13 +634,12 @@ fn write_metadata<'a, 'gcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>, if kind == MetadataKind::None { return (metadata_llcx, metadata_llmod, - EncodedMetadata::new(), - EncodedMetadataHashes::new()); + EncodedMetadata::new()); } - let (metadata, hashes) = tcx.encode_metadata(link_meta, exported_symbols); + let metadata = tcx.encode_metadata(link_meta, exported_symbols); if kind == MetadataKind::Uncompressed { - return (metadata_llcx, metadata_llmod, metadata, hashes); + return (metadata_llcx, metadata_llmod, metadata); } assert!(kind == MetadataKind::Compressed); @@ -669,7 +667,7 @@ fn write_metadata<'a, 'gcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>, let directive = CString::new(directive).unwrap(); llvm::LLVMSetModuleInlineAsm(metadata_llmod, directive.as_ptr()) } - return (metadata_llcx, metadata_llmod, metadata, hashes); + return (metadata_llcx, metadata_llmod, metadata); } pub struct ValueIter { @@ -720,7 +718,7 @@ pub fn trans_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let shared_ccx = SharedCrateContext::new(tcx); // Translate the metadata. let llmod_id = "metadata"; - let (metadata_llcx, metadata_llmod, metadata, metadata_incr_hashes) = + let (metadata_llcx, metadata_llmod, metadata) = time(tcx.sess.time_passes(), "write metadata", || { write_metadata(tcx, llmod_id, &link_meta, &exported_symbol_node_ids) }); @@ -756,9 +754,7 @@ pub fn trans_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ongoing_translation.submit_pre_translated_module_to_llvm(tcx, metadata_module); ongoing_translation.translation_finished(tcx); - assert_and_save_dep_graph(tcx, - metadata_incr_hashes, - link_meta); + assert_and_save_dep_graph(tcx); ongoing_translation.check_for_errors(tcx.sess); @@ -932,24 +928,18 @@ pub fn trans_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, ongoing_translation.check_for_errors(tcx.sess); - assert_and_save_dep_graph(tcx, - metadata_incr_hashes, - link_meta); + assert_and_save_dep_graph(tcx); ongoing_translation } -fn assert_and_save_dep_graph<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, - metadata_incr_hashes: EncodedMetadataHashes, - link_meta: LinkMeta) { +fn assert_and_save_dep_graph<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { time(tcx.sess.time_passes(), "assert dep graph", || rustc_incremental::assert_dep_graph(tcx)); time(tcx.sess.time_passes(), "serialize dep graph", - || rustc_incremental::save_dep_graph(tcx, - &metadata_incr_hashes, - link_meta.crate_hash)); + || rustc_incremental::save_dep_graph(tcx)); } #[inline(never)] // give this a place in the profiler diff --git a/src/librustc_trans_utils/trans_crate.rs b/src/librustc_trans_utils/trans_crate.rs index 8dc81a3d687dc..645898601614b 100644 --- a/src/librustc_trans_utils/trans_crate.rs +++ b/src/librustc_trans_utils/trans_crate.rs @@ -201,7 +201,7 @@ impl TransCrate for MetadataOnlyTransCrate { .fingerprint_of(&DepNode::new_no_params(DepKind::Krate)); let link_meta = build_link_meta(crate_hash); let exported_symbols = ::find_exported_symbols(tcx); - let (metadata, _hashes) = tcx.encode_metadata(&link_meta, &exported_symbols); + let metadata = tcx.encode_metadata(&link_meta, &exported_symbols); OngoingCrateTranslation { metadata: metadata, diff --git a/src/librustc_typeck/check/coercion.rs b/src/librustc_typeck/check/coercion.rs index 94422f93e5922..3e725d7ef415c 100644 --- a/src/librustc_typeck/check/coercion.rs +++ b/src/librustc_typeck/check/coercion.rs @@ -66,6 +66,7 @@ use rustc::hir; use rustc::hir::def_id::DefId; use rustc::infer::{Coercion, InferResult, InferOk}; use rustc::infer::type_variable::TypeVariableOrigin; +use rustc::lint; use rustc::traits::{self, ObligationCause, ObligationCauseCode}; use rustc::ty::adjustment::{Adjustment, Adjust, AutoBorrow}; use rustc::ty::{self, LvaluePreference, TypeAndMut, @@ -754,7 +755,15 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> { // type, but only if the source expression diverges. if target.is_never() && expr_diverges.always() { debug!("permit coercion to `!` because expr diverges"); - return Ok(target); + if self.can_eq(self.param_env, source, target).is_err() { + self.tcx.lint_node( + lint::builtin::COERCE_NEVER, + expr.id, + expr.span, + &format!("cannot coerce `{}` to !", source) + ); + return Ok(target); + } } let cause = self.cause(expr.span, ObligationCauseCode::ExprAssignable); diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml index 55d2df5f28bd9..eca3ebe9130fd 100644 --- a/src/librustdoc/Cargo.toml +++ b/src/librustdoc/Cargo.toml @@ -11,7 +11,6 @@ path = "lib.rs" doctest = false [dependencies] -env_logger = { version = "0.4", default-features = false } log = "0.3" pulldown-cmark = { version = "0.1.0", default-features = false } html-diff = "0.0.5" diff --git a/src/librustdoc/build.rs b/src/librustdoc/build.rs index 97c9ca1e2d27c..276825bd31a75 100644 --- a/src/librustdoc/build.rs +++ b/src/librustdoc/build.rs @@ -27,6 +27,6 @@ fn main() { .warnings(false) .include(src_dir) .warnings(false) - .compile("libhoedown.a"); + .compile("hoedown"); } diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index 820c3e856dbb1..85c1796ecef39 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -332,74 +332,10 @@ pub fn build_impl(cx: &DocContext, did: DefId, ret: &mut Vec) { let predicates = tcx.predicates_of(did); let trait_items = tcx.associated_items(did).filter_map(|item| { - match item.kind { - ty::AssociatedKind::Const => { - let default = if item.defaultness.has_value() { - Some(print_inlined_const(cx, item.def_id)) - } else { - None - }; - Some(clean::Item { - name: Some(item.name.clean(cx)), - inner: clean::AssociatedConstItem( - tcx.type_of(item.def_id).clean(cx), - default, - ), - source: tcx.def_span(item.def_id).clean(cx), - attrs: clean::Attributes::default(), - visibility: None, - stability: tcx.lookup_stability(item.def_id).clean(cx), - deprecation: tcx.lookup_deprecation(item.def_id).clean(cx), - def_id: item.def_id - }) - } - ty::AssociatedKind::Method => { - if item.vis != ty::Visibility::Public && associated_trait.is_none() { - return None - } - let mut cleaned = item.clean(cx); - cleaned.inner = match cleaned.inner.clone() { - clean::TyMethodItem(clean::TyMethod { - unsafety, decl, generics, abi - }) => { - let constness = if tcx.is_const_fn(item.def_id) { - hir::Constness::Const - } else { - hir::Constness::NotConst - }; - - clean::MethodItem(clean::Method { - unsafety, - constness, - decl, - generics, - abi, - }) - } - ref r => panic!("not a tymethod: {:?}", r), - }; - Some(cleaned) - } - ty::AssociatedKind::Type => { - let typedef = clean::Typedef { - type_: tcx.type_of(item.def_id).clean(cx), - generics: clean::Generics { - lifetimes: vec![], - type_params: vec![], - where_predicates: vec![] - } - }; - Some(clean::Item { - name: Some(item.name.clean(cx)), - inner: clean::TypedefItem(typedef, true), - source: tcx.def_span(item.def_id).clean(cx), - attrs: clean::Attributes::default(), - visibility: None, - stability: tcx.lookup_stability(item.def_id).clean(cx), - deprecation: tcx.lookup_deprecation(item.def_id).clean(cx), - def_id: item.def_id - }) - } + if associated_trait.is_some() || item.vis == ty::Visibility::Public { + Some(item.clean(cx)) + } else { + None } }).collect::>(); let polarity = tcx.impl_polarity(did); diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 538737e7fe4d9..be7bd3d5510ef 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1595,7 +1595,12 @@ impl<'tcx> Clean for ty::AssociatedItem { let inner = match self.kind { ty::AssociatedKind::Const => { let ty = cx.tcx.type_of(self.def_id); - AssociatedConstItem(ty.clean(cx), None) + let default = if self.defaultness.has_value() { + Some(inline::print_inlined_const(cx, self.def_id)) + } else { + None + }; + AssociatedConstItem(ty.clean(cx), default) } ty::AssociatedKind::Method => { let generics = (cx.tcx.generics_of(self.def_id), @@ -1626,18 +1631,21 @@ impl<'tcx> Clean for ty::AssociatedItem { } let provided = match self.container { - ty::ImplContainer(_) => false, + ty::ImplContainer(_) => true, ty::TraitContainer(_) => self.defaultness.has_value() }; if provided { + let constness = if cx.tcx.is_const_fn(self.def_id) { + hir::Constness::Const + } else { + hir::Constness::NotConst + }; MethodItem(Method { unsafety: sig.unsafety(), generics, decl, abi: sig.abi(), - - // trait methods cannot (currently, at least) be const - constness: hir::Constness::NotConst, + constness, }) } else { TyMethodItem(TyMethod { @@ -1651,14 +1659,14 @@ impl<'tcx> Clean for ty::AssociatedItem { ty::AssociatedKind::Type => { let my_name = self.name.clean(cx); - let mut bounds = if let ty::TraitContainer(did) = self.container { + if let ty::TraitContainer(did) = self.container { // When loading a cross-crate associated type, the bounds for this type // are actually located on the trait/impl itself, so we need to load // all of the generics from there and then look for bounds that are // applied to this associated type in question. let predicates = cx.tcx.predicates_of(did); let generics = (cx.tcx.generics_of(did), &predicates).clean(cx); - generics.where_predicates.iter().filter_map(|pred| { + let mut bounds = generics.where_predicates.iter().filter_map(|pred| { let (name, self_type, trait_, bounds) = match *pred { WherePredicate::BoundPredicate { ty: QPath { ref name, ref self_type, ref trait_ }, @@ -1676,34 +1684,45 @@ impl<'tcx> Clean for ty::AssociatedItem { _ => return None, } Some(bounds) - }).flat_map(|i| i.iter().cloned()).collect::>() - } else { - vec![] - }; + }).flat_map(|i| i.iter().cloned()).collect::>(); + // Our Sized/?Sized bound didn't get handled when creating the generics + // because we didn't actually get our whole set of bounds until just now + // (some of them may have come from the trait). If we do have a sized + // bound, we remove it, and if we don't then we add the `?Sized` bound + // at the end. + match bounds.iter().position(|b| b.is_sized_bound(cx)) { + Some(i) => { bounds.remove(i); } + None => bounds.push(TyParamBound::maybe_sized(cx)), + } - // Our Sized/?Sized bound didn't get handled when creating the generics - // because we didn't actually get our whole set of bounds until just now - // (some of them may have come from the trait). If we do have a sized - // bound, we remove it, and if we don't then we add the `?Sized` bound - // at the end. - match bounds.iter().position(|b| b.is_sized_bound(cx)) { - Some(i) => { bounds.remove(i); } - None => bounds.push(TyParamBound::maybe_sized(cx)), - } + let ty = if self.defaultness.has_value() { + Some(cx.tcx.type_of(self.def_id)) + } else { + None + }; - let ty = if self.defaultness.has_value() { - Some(cx.tcx.type_of(self.def_id)) + AssociatedTypeItem(bounds, ty.clean(cx)) } else { - None - }; - - AssociatedTypeItem(bounds, ty.clean(cx)) + TypedefItem(Typedef { + type_: cx.tcx.type_of(self.def_id).clean(cx), + generics: Generics { + lifetimes: Vec::new(), + type_params: Vec::new(), + where_predicates: Vec::new(), + }, + }, true) + } } }; + let visibility = match self.container { + ty::ImplContainer(_) => self.vis.clean(cx), + ty::TraitContainer(_) => None, + }; + Item { name: Some(self.name.clean(cx)), - visibility: Some(Inherited), + visibility, stability: get_stability(cx, self.def_id), deprecation: get_deprecation(cx, self.def_id), def_id: self.def_id, diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index cf557b1c661d6..b8a0b334b86af 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -2621,7 +2621,8 @@ fn assoc_const(w: &mut fmt::Formatter, ty: &clean::Type, _default: Option<&String>, link: AssocItemLink) -> fmt::Result { - write!(w, "const {}: {}", + write!(w, "{}const {}: {}", + VisSpace(&it.visibility), naive_assoc_href(it, link), it.name.as_ref().unwrap(), ty)?; diff --git a/src/librustdoc/html/static/rustdoc.css b/src/librustdoc/html/static/rustdoc.css index d7f4674908c58..7efe7e1ae3eb3 100644 --- a/src/librustdoc/html/static/rustdoc.css +++ b/src/librustdoc/html/static/rustdoc.css @@ -920,6 +920,12 @@ span.since { border-color: transparent black transparent transparent; } +.important-traits .tooltip .tooltiptext { + background-color: white; + color: black; + border: 1px solid #000; +} + pre.rust { position: relative; } diff --git a/src/libsyntax/feature_gate.rs b/src/libsyntax/feature_gate.rs index 89d1a3699e8a6..80be2a85e5261 100644 --- a/src/libsyntax/feature_gate.rs +++ b/src/libsyntax/feature_gate.rs @@ -742,18 +742,6 @@ pub const BUILTIN_ATTRIBUTES: &'static [(&'static str, AttributeType, AttributeG is just used for rustc unit tests \ and will never be stable", cfg_fn!(rustc_attrs))), - ("rustc_metadata_dirty", Whitelisted, Gated(Stability::Unstable, - "rustc_attrs", - "the `#[rustc_metadata_dirty]` attribute \ - is just used for rustc unit tests \ - and will never be stable", - cfg_fn!(rustc_attrs))), - ("rustc_metadata_clean", Whitelisted, Gated(Stability::Unstable, - "rustc_attrs", - "the `#[rustc_metadata_clean]` attribute \ - is just used for rustc unit tests \ - and will never be stable", - cfg_fn!(rustc_attrs))), ("rustc_partition_reused", Whitelisted, Gated(Stability::Unstable, "rustc_attrs", "this attribute \ diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index 951163d35fa0f..6f20104dda5d7 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -73,6 +73,13 @@ impl<'a> StringReader<'a> { fn mk_sp(&self, lo: BytePos, hi: BytePos) -> Span { unwrap_or!(self.override_span, Span::new(lo, hi, NO_EXPANSION)) } + fn mk_ident(&self, string: &str) -> Ident { + let mut ident = Ident::from_str(string); + if let Some(span) = self.override_span { + ident.ctxt = span.ctxt(); + } + ident + } fn next_token(&mut self) -> TokenAndSpan where Self: Sized { let res = self.try_next_token(); @@ -1103,7 +1110,7 @@ impl<'a> StringReader<'a> { token::Underscore } else { // FIXME: perform NFKC normalization here. (Issue #2253) - token::Ident(Ident::from_str(string)) + token::Ident(self.mk_ident(string)) } })); } @@ -1286,13 +1293,13 @@ impl<'a> StringReader<'a> { // expansion purposes. See #12512 for the gory details of why // this is necessary. let ident = self.with_str_from(start, |lifetime_name| { - Ident::from_str(&format!("'{}", lifetime_name)) + self.mk_ident(&format!("'{}", lifetime_name)) }); // Conjure up a "keyword checking ident" to make sure that // the lifetime name is not a keyword. let keyword_checking_ident = self.with_str_from(start, |lifetime_name| { - Ident::from_str(lifetime_name) + self.mk_ident(lifetime_name) }); let keyword_checking_token = &token::Ident(keyword_checking_ident); let last_bpos = self.pos; diff --git a/src/test/compile-fail-fulldeps/proc-macro/lints_in_proc_macros.rs b/src/test/compile-fail-fulldeps/proc-macro/lints_in_proc_macros.rs index b1fb7d42d8683..773b16b945f07 100644 --- a/src/test/compile-fail-fulldeps/proc-macro/lints_in_proc_macros.rs +++ b/src/test/compile-fail-fulldeps/proc-macro/lints_in_proc_macros.rs @@ -23,5 +23,5 @@ fn main() { bang_proc_macro2!(); //~^ ERROR cannot find value `foobar2` in this scope //~^^ did you mean `foobar`? - println!("{}", x); + println!("{}", x); //~ ERROR cannot find value `x` in this scope } diff --git a/src/test/compile-fail/coerce-to-bang-cast.rs b/src/test/compile-fail/coerce-to-bang-cast.rs index 0479f5cce6537..0d5bf6cd68cb8 100644 --- a/src/test/compile-fail/coerce-to-bang-cast.rs +++ b/src/test/compile-fail/coerce-to-bang-cast.rs @@ -12,8 +12,11 @@ fn foo(x: usize, y: !, z: usize) { } +#[deny(coerce_never)] fn cast_a() { let y = {return; 22} as !; + //~^ ERROR cannot coerce `i32` to ! + //~| hard error } fn cast_b() { diff --git a/src/test/compile-fail/coerce-to-bang.rs b/src/test/compile-fail/coerce-to-bang.rs index 870665bb49ee6..2cf568777d475 100644 --- a/src/test/compile-fail/coerce-to-bang.rs +++ b/src/test/compile-fail/coerce-to-bang.rs @@ -9,6 +9,7 @@ // except according to those terms. #![feature(never_type)] +#![deny(coerce_never)] fn foo(x: usize, y: !, z: usize) { } @@ -17,6 +18,8 @@ fn call_foo_a() { // the coercion to `!`, but within same expression. Not clear that // these are the rules we want. foo(return, 22, 44); + //~^ ERROR cannot coerce `{integer}` to ! + //~| hard error } fn call_foo_b() { @@ -36,6 +39,8 @@ fn call_foo_d() { let b = 22; let c = 44; foo(a, b, c); // ... and hence a reference to `a` is expected to diverge. + //~^ ERROR cannot coerce `{integer}` to ! + //~| hard error } fn call_foo_e() { @@ -75,6 +80,8 @@ fn tuple_a() { fn tuple_b() { // Divergence happens before coercion: OK let x: (usize, !, usize) = (return, 44, 66); + //~^ ERROR cannot coerce `{integer}` to ! + //~| hard error } fn tuple_c() { diff --git a/src/test/compile-fail/diverging-fn-tail-35849.rs b/src/test/compile-fail/diverging-fn-tail-35849.rs index 3a27c08413328..a91c000bbf712 100644 --- a/src/test/compile-fail/diverging-fn-tail-35849.rs +++ b/src/test/compile-fail/diverging-fn-tail-35849.rs @@ -8,9 +8,13 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn _converge() -> ! { - 42 //~ ERROR mismatched types +#[deny(coerce_never)] +fn assert_sizeof() -> ! { + unsafe { + ::std::mem::transmute::(panic!()) + //~^ ERROR cannot coerce `[u8; 8]` to ! + //~| hard error + } } fn main() { } - diff --git a/src/test/incremental/hashes/call_expressions.rs b/src/test/incremental/hashes/call_expressions.rs index b49609cbd17a2..a62d84fedf3aa 100644 --- a/src/test/incremental/hashes/call_expressions.rs +++ b/src/test/incremental/hashes/call_expressions.rs @@ -38,8 +38,6 @@ pub fn change_callee_function() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_callee_function() { callee2(1, 2) } @@ -55,8 +53,6 @@ pub fn change_argument_function() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_argument_function() { callee1(1, 3) } @@ -74,8 +70,8 @@ mod change_callee_indirectly_function { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] + + pub fn change_callee_indirectly_function() { callee(1, 2) } @@ -98,8 +94,6 @@ pub fn change_callee_method() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_callee_method() { let s = Struct; s.method2('x', true); @@ -117,8 +111,6 @@ pub fn change_argument_method() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_argument_method() { let s = Struct; s.method1('y', true); @@ -136,8 +128,6 @@ pub fn change_ufcs_callee_method() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_ufcs_callee_method() { let s = Struct; Struct::method2(&s, 'x', true); @@ -155,8 +145,6 @@ pub fn change_argument_method_ufcs() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_argument_method_ufcs() { let s = Struct; Struct::method1(&s, 'x', false); @@ -174,8 +162,6 @@ pub fn change_to_ufcs() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] // One might think this would be expanded in the HirBody/Mir, but it actually // results in slightly different Hir/Mir. pub fn change_to_ufcs() { @@ -198,8 +184,8 @@ pub mod change_ufcs_callee_indirectly { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] + + pub fn change_ufcs_callee_indirectly() { let s = Struct; Struct::method1(&s, 'q', false) diff --git a/src/test/incremental/hashes/closure_expressions.rs b/src/test/incremental/hashes/closure_expressions.rs index 38fe5cdffebd0..4abc77e0ab64d 100644 --- a/src/test/incremental/hashes/closure_expressions.rs +++ b/src/test/incremental/hashes/closure_expressions.rs @@ -36,8 +36,6 @@ fn change_closure_body() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_closure_body() { let _ = || 3u32; } @@ -56,8 +54,6 @@ fn add_parameter() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_parameter() { let x = 0u32; let _ = |x: u32| x + 1; @@ -76,8 +72,6 @@ fn change_parameter_pattern() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_parameter_pattern() { let _ = |&x: &u32| x; } @@ -95,8 +89,6 @@ fn add_move() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_move() { let _ = move || 1; } @@ -115,8 +107,6 @@ fn add_type_ascription_to_parameter() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_type_ascription_to_parameter() { let closure = |x: u32| x + 1u32; let _: u32 = closure(1); @@ -136,8 +126,6 @@ fn change_parameter_type() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_parameter_type() { let closure = |x: u16| (x as u64) + 1; let _ = closure(1); diff --git a/src/test/incremental/hashes/consts.rs b/src/test/incremental/hashes/consts.rs index 65acfb82da66f..496ae4276f863 100644 --- a/src/test/incremental/hashes/consts.rs +++ b/src/test/incremental/hashes/consts.rs @@ -32,8 +32,6 @@ const CONST_VISIBILITY: u8 = 0; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub const CONST_VISIBILITY: u8 = 0; @@ -44,8 +42,6 @@ const CONST_CHANGE_TYPE_1: i32 = 0; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] const CONST_CHANGE_TYPE_1: u32 = 0; @@ -56,15 +52,12 @@ const CONST_CHANGE_TYPE_2: Option = None; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] const CONST_CHANGE_TYPE_2: Option = None; // Change value between simple literals --------------------------------------- #[rustc_clean(cfg="cfail2", except="HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] const CONST_CHANGE_VALUE_1: i16 = { #[cfg(cfail1)] { 1 } @@ -77,8 +70,6 @@ const CONST_CHANGE_VALUE_1: i16 = { // Change value between expressions ------------------------------------------- #[rustc_clean(cfg="cfail2", except="HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] const CONST_CHANGE_VALUE_2: i16 = { #[cfg(cfail1)] { 1 + 1 } @@ -89,8 +80,6 @@ const CONST_CHANGE_VALUE_2: i16 = { #[rustc_clean(cfg="cfail2", except="HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] const CONST_CHANGE_VALUE_3: i16 = { #[cfg(cfail1)] { 2 + 3 } @@ -101,8 +90,6 @@ const CONST_CHANGE_VALUE_3: i16 = { #[rustc_clean(cfg="cfail2", except="HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] const CONST_CHANGE_VALUE_4: i16 = { #[cfg(cfail1)] { 1 + 2 * 3 } @@ -125,13 +112,9 @@ mod const_change_type_indirectly { #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] const CONST_CHANGE_TYPE_INDIRECTLY_1: Type = Type; #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] const CONST_CHANGE_TYPE_INDIRECTLY_2: Option = None; } diff --git a/src/test/incremental/hashes/enum_constructors.rs b/src/test/incremental/hashes/enum_constructors.rs index e38fd58d7d277..f38d18646306e 100644 --- a/src/test/incremental/hashes/enum_constructors.rs +++ b/src/test/incremental/hashes/enum_constructors.rs @@ -47,8 +47,6 @@ pub fn change_field_value_struct_like() -> Enum { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_field_value_struct_like() -> Enum { Enum::Struct { x: 0, @@ -72,8 +70,6 @@ pub fn change_field_order_struct_like() -> Enum { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] // FIXME(michaelwoerister):Interesting. I would have thought that that changes the MIR. And it // would if it were not all constants pub fn change_field_order_struct_like() -> Enum { @@ -113,8 +109,6 @@ pub fn change_constructor_path_struct_like() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_constructor_path_struct_like() { let _ = Enum2::Struct { x: 0, @@ -138,8 +132,6 @@ pub fn change_constructor_variant_struct_like() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_constructor_variant_struct_like() { let _ = Enum2::Struct2 { x: 0, @@ -162,8 +154,6 @@ pub mod change_constructor_path_indirectly_struct_like { TypeckTables" )] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn function() -> TheEnum { TheEnum::Struct { x: 0, @@ -184,8 +174,6 @@ pub mod change_constructor_variant_indirectly_struct_like { #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn function() -> Enum2 { Variant { x: 0, @@ -205,8 +193,6 @@ pub fn change_field_value_tuple_like() -> Enum { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_field_value_tuple_like() -> Enum { Enum::Tuple(0, 1, 3) } @@ -225,8 +211,6 @@ pub fn change_constructor_path_tuple_like() { except="HirBody,MirOptimized,MirValidated,TypeckTables" )] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_constructor_path_tuple_like() { let _ = Enum2::Tuple(0, 1, 2); } @@ -245,8 +229,6 @@ pub fn change_constructor_variant_tuple_like() { except="HirBody,MirOptimized,MirValidated,TypeckTables" )] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_constructor_variant_tuple_like() { let _ = Enum2::Tuple2(0, 1, 2); } @@ -265,8 +247,6 @@ pub mod change_constructor_path_indirectly_tuple_like { TypeckTables" )] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn function() -> TheEnum { TheEnum::Tuple(0, 1, 2) } @@ -284,8 +264,6 @@ pub mod change_constructor_variant_indirectly_tuple_like { #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn function() -> Enum2 { Variant(0, 1, 2) } @@ -313,7 +291,6 @@ pub fn change_constructor_path_c_like() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_constructor_path_c_like() { let _ = Clike2::B; } @@ -329,8 +306,6 @@ pub fn change_constructor_variant_c_like() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_constructor_variant_c_like() { let _ = Clike::C; } @@ -349,8 +324,6 @@ pub mod change_constructor_path_indirectly_c_like { TypeckTables" )] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn function() -> TheEnum { TheEnum::B } @@ -368,8 +341,6 @@ pub mod change_constructor_variant_indirectly_c_like { #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn function() -> Clike { Variant } diff --git a/src/test/incremental/hashes/enum_defs.rs b/src/test/incremental/hashes/enum_defs.rs index 22393fad3d074..dbb7aca1924d3 100644 --- a/src/test/incremental/hashes/enum_defs.rs +++ b/src/test/incremental/hashes/enum_defs.rs @@ -39,11 +39,7 @@ enum EnumVisibility { A } #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub enum EnumVisibility { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] A } @@ -59,13 +55,8 @@ enum EnumChangeNameCStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeNameCStyleVariant { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] Variant1, - #[rustc_metadata_clean(cfg="cfail3")] Variant2Changed, } @@ -81,8 +72,6 @@ enum EnumChangeNameTupleStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeNameTupleStyleVariant { Variant1, Variant2Changed(u32, f32), @@ -100,8 +89,6 @@ enum EnumChangeNameStructStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeNameStructStyleVariant { Variant1, Variant2Changed { a: u32, b: f32 }, @@ -119,16 +106,10 @@ enum EnumChangeValueCStyleVariant0 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeValueCStyleVariant0 { Variant1, - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] Variant2 = - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] 22, } @@ -141,8 +122,6 @@ enum EnumChangeValueCStyleVariant1 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeValueCStyleVariant1 { Variant1, Variant2 = 11, @@ -159,8 +138,6 @@ enum EnumAddCStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumAddCStyleVariant { Variant1, Variant2, @@ -178,8 +155,6 @@ enum EnumRemoveCStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumRemoveCStyleVariant { Variant1, } @@ -195,8 +170,6 @@ enum EnumAddTupleStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumAddTupleStyleVariant { Variant1, Variant2(u32, f32), @@ -214,8 +187,6 @@ enum EnumRemoveTupleStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumRemoveTupleStyleVariant { Variant1, } @@ -231,8 +202,6 @@ enum EnumAddStructStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumAddStructStyleVariant { Variant1, Variant2 { a: u32, b: f32 }, @@ -250,8 +219,6 @@ enum EnumRemoveStructStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumRemoveStructStyleVariant { Variant1, } @@ -267,12 +234,8 @@ enum EnumChangeFieldTypeTupleStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeFieldTypeTupleStyleVariant { Variant1(u32, - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] u64), } @@ -288,14 +251,10 @@ enum EnumChangeFieldTypeStructStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeFieldTypeStructStyleVariant { Variant1, Variant2 { a: u32, - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] b: u64 }, } @@ -311,8 +270,6 @@ enum EnumChangeFieldNameStructStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeFieldNameStructStyleVariant { Variant1 { a: u32, c: u32 }, } @@ -328,15 +285,9 @@ enum EnumChangeOrderTupleStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeOrderTupleStyleVariant { Variant1( - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] u64, - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] u32), } @@ -351,8 +302,6 @@ enum EnumChangeFieldOrderStructStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeFieldOrderStructStyleVariant { Variant1 { b: f32, a: u32 }, } @@ -368,8 +317,6 @@ enum EnumAddFieldTupleStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumAddFieldTupleStyleVariant { Variant1(u32, u32, u32), } @@ -385,8 +332,6 @@ enum EnumAddFieldStructStyleVariant { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumAddFieldStructStyleVariant { Variant1 { a: u32, b: u32, c: u32 }, } @@ -403,8 +348,6 @@ enum EnumAddMustUse { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[must_use] enum EnumAddMustUse { Variant1, @@ -423,8 +366,6 @@ enum EnumAddReprC { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[repr(C)] enum EnumAddReprC { Variant1, @@ -442,8 +383,6 @@ enum EnumChangeNameOfTypeParameter { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeNameOfTypeParameter { Variant1(T), } @@ -460,8 +399,6 @@ enum EnumAddTypeParameter { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumAddTypeParameter { Variant1(S), Variant2(T), @@ -478,8 +415,6 @@ enum EnumChangeNameOfLifetimeParameter<'a> { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2", except="PredicatesOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumChangeNameOfLifetimeParameter<'b> { Variant1(&'b u32), } @@ -496,8 +431,6 @@ enum EnumAddLifetimeParameter<'a> { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2", except="PredicatesOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumAddLifetimeParameter<'a, 'b> { Variant1(&'a u32), Variant2(&'b u32), @@ -515,8 +448,6 @@ enum EnumAddLifetimeParameterBound<'a, 'b> { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2", except="GenericsOfItem,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumAddLifetimeParameterBound<'a, 'b: 'a> { Variant1(&'a u32), Variant2(&'b u32), @@ -532,8 +463,6 @@ enum EnumAddLifetimeBoundToParameter<'a, T> { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2", except="TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumAddLifetimeBoundToParameter<'a, T: 'a> { Variant1(T), Variant2(&'a u32), @@ -550,8 +479,6 @@ enum EnumAddTraitBound { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumAddTraitBound { Variant1(T), } @@ -568,8 +495,6 @@ enum EnumAddLifetimeParameterBoundWhere<'a, 'b> { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2", except="GenericsOfItem,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumAddLifetimeParameterBoundWhere<'a, 'b> where 'b: 'a { Variant1(&'a u32), Variant2(&'b u32), @@ -587,8 +512,6 @@ enum EnumAddLifetimeBoundToParameterWhere<'a, T> { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2", except="TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumAddLifetimeBoundToParameterWhere<'a, T> where T: 'a { Variant1(T), Variant2(&'a u32), @@ -605,8 +528,6 @@ enum EnumAddTraitBoundWhere { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumAddTraitBoundWhere where T: Sync { Variant1(T), } @@ -623,21 +544,11 @@ enum EnumSwapUsageTypeParameters { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumSwapUsageTypeParameters { - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] Variant1 { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] a: B }, - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] Variant2 { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] a: A }, } @@ -654,21 +565,11 @@ enum EnumSwapUsageLifetimeParameters<'a, 'b> { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] enum EnumSwapUsageLifetimeParameters<'a, 'b> { - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] Variant1 { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] a: &'b u32 }, - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] Variant2 { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] b: &'a u32 }, } @@ -689,14 +590,8 @@ mod change_field_type_indirectly_tuple_style { #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] enum TupleStyle { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] Variant1( - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] FieldType ) } @@ -713,14 +608,8 @@ mod change_field_type_indirectly_struct_style { #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] enum StructStyle { - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] Variant1 { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] a: FieldType } } @@ -742,8 +631,6 @@ mod change_trait_bound_indirectly { #[rustc_clean(cfg="cfail2", except="Hir,HirBody,PredicatesOfItem")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] enum Enum { Variant1(T) } @@ -760,8 +647,6 @@ mod change_trait_bound_indirectly_where { #[rustc_clean(cfg="cfail2", except="Hir,HirBody,PredicatesOfItem")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] enum Enum where T: Trait { Variant1(T) } diff --git a/src/test/incremental/hashes/exported_vs_not.rs b/src/test/incremental/hashes/exported_vs_not.rs index d7aba563edf87..985c064f6a0a2 100644 --- a/src/test/incremental/hashes/exported_vs_not.rs +++ b/src/test/incremental/hashes/exported_vs_not.rs @@ -28,8 +28,6 @@ pub fn body_not_exported_to_metadata() -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn body_not_exported_to_metadata() -> u32 { 2 } @@ -49,8 +47,6 @@ pub fn body_exported_to_metadata_because_of_inline() -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[inline] pub fn body_exported_to_metadata_because_of_inline() -> u32 { 2 @@ -71,8 +67,6 @@ pub fn body_exported_to_metadata_because_of_generic() -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[inline] pub fn body_exported_to_metadata_because_of_generic() -> u32 { 2 diff --git a/src/test/incremental/hashes/extern_mods.rs b/src/test/incremental/hashes/extern_mods.rs index ec5e088088c9b..7ccb452b7ed26 100644 --- a/src/test/incremental/hashes/extern_mods.rs +++ b/src/test/incremental/hashes/extern_mods.rs @@ -36,8 +36,6 @@ extern { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] extern { pub fn change_function_name2(c: i64) -> i32; } @@ -53,11 +51,7 @@ extern { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] extern { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn change_parameter_name(d: i64) -> i32; } @@ -72,11 +66,7 @@ extern { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] extern { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn change_parameter_type(c: i32) -> i32; } @@ -91,11 +81,7 @@ extern { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] extern { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn change_return_type(c: i32) -> i8; } @@ -110,11 +96,7 @@ extern { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] extern { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn add_parameter(c: i32, d: i32) -> i32; } @@ -129,11 +111,7 @@ extern { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] extern { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn add_return_type(c: i32) -> i32; } @@ -148,11 +126,7 @@ extern { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] extern { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn make_function_variadic(c: i32, ...); } @@ -167,11 +141,7 @@ extern "C" { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] extern "rust-call" { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn change_calling_convention(c: i32); } @@ -186,11 +156,7 @@ extern { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] extern { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn make_function_public(c: i32); } @@ -205,8 +171,6 @@ extern { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] extern { pub fn add_function1(c: i32); pub fn add_function2(); @@ -224,8 +188,6 @@ extern { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[link_args = "-foo -bar -baz"] extern { pub fn change_link_args(c: i32); @@ -243,8 +205,6 @@ extern { #[cfg(not(cfail1))] #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[link(name = "bar")] extern { pub fn change_link_name(c: i32); @@ -262,11 +222,7 @@ mod indirectly_change_parameter_type { #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] extern { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn indirectly_change_parameter_type(c: c_int); } } @@ -282,11 +238,7 @@ mod indirectly_change_return_type { #[rustc_dirty(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] extern { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn indirectly_change_return_type() -> c_int; } } diff --git a/src/test/incremental/hashes/for_loops.rs b/src/test/incremental/hashes/for_loops.rs index bae3c9bf5965d..763b0cd05d4f9 100644 --- a/src/test/incremental/hashes/for_loops.rs +++ b/src/test/incremental/hashes/for_loops.rs @@ -40,8 +40,6 @@ fn change_loop_body() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_loop_body() { let mut _x = 0; for _ in 0..1 { @@ -67,8 +65,6 @@ fn change_iteration_variable_name() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_iteration_variable_name() { let mut _x = 0; for _a in 0..1 { @@ -94,8 +90,6 @@ fn change_iteration_variable_pattern() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_iteration_variable_pattern() { let mut _x = 0; for &_i in &[0, 1, 2] { @@ -121,8 +115,6 @@ fn change_iterable() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_iterable() { let mut _x = 0; for _ in &[0, 1, 3] { @@ -147,8 +139,6 @@ fn add_break() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_break() { let mut _x = 0; for _ in 0..1 { @@ -174,8 +164,6 @@ fn add_loop_label() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_loop_label() { let mut _x = 0; 'label: for _ in 0..1 { @@ -201,8 +189,6 @@ fn add_loop_label_to_break() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_loop_label_to_break() { let mut _x = 0; 'label: for _ in 0..1 { @@ -230,8 +216,6 @@ fn change_break_label() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_break_label() { let mut _x = 0; 'outer: for _ in 0..1 { @@ -259,8 +243,6 @@ fn add_loop_label_to_continue() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_loop_label_to_continue() { let mut _x = 0; 'label: for _ in 0..1 { @@ -288,8 +270,6 @@ fn change_continue_label() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_continue_label() { let mut _x = 0; 'outer: for _ in 0..1 { @@ -317,8 +297,6 @@ fn change_continue_to_break() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_continue_to_break() { let mut _x = 0; for _ in 0..1 { diff --git a/src/test/incremental/hashes/function_interfaces.rs b/src/test/incremental/hashes/function_interfaces.rs index 2fe3f0d5d1fe0..b3eb566367c72 100644 --- a/src/test/incremental/hashes/function_interfaces.rs +++ b/src/test/incremental/hashes/function_interfaces.rs @@ -37,8 +37,6 @@ fn add_parameter() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_parameter(p: i32) {} @@ -50,8 +48,6 @@ fn add_return_type() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] // The type doesn't change, so metadata is the same -#[rustc_metadata_clean(cfg="cfail3")] fn add_return_type() -> () {} @@ -63,8 +59,6 @@ fn type_of_parameter(p: i32) {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn type_of_parameter(p: i64) {} @@ -76,8 +70,6 @@ fn type_of_parameter_ref(p: &i32) {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn type_of_parameter_ref(p: &mut i32) {} @@ -89,8 +81,6 @@ fn order_of_parameters(p1: i32, p2: i64) {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn order_of_parameters(p2: i64, p1: i32) {} @@ -102,8 +92,6 @@ fn make_unsafe() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] unsafe fn make_unsafe() {} @@ -115,8 +103,6 @@ fn make_extern() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] extern fn make_extern() {} @@ -128,8 +114,6 @@ extern "C" fn make_intrinsic() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] extern "rust-intrinsic" fn make_intrinsic() {} @@ -141,8 +125,6 @@ fn type_parameter() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn type_parameter() {} @@ -154,8 +136,6 @@ fn lifetime_parameter() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -// #[rustc_metadata_dirty(cfg="cfail2")] -- Unused lifetime params don't show up in the type? -#[rustc_metadata_clean(cfg="cfail3")] fn lifetime_parameter<'a>() {} @@ -167,8 +147,6 @@ fn trait_bound() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn trait_bound() {} @@ -180,8 +158,6 @@ fn builtin_bound() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn builtin_bound() {} @@ -193,8 +169,6 @@ fn lifetime_bound<'a, T>() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn lifetime_bound<'a, T: 'a>() {} @@ -206,8 +180,6 @@ fn second_trait_bound() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn second_trait_bound() {} @@ -219,8 +191,6 @@ fn second_builtin_bound() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn second_builtin_bound() {} @@ -232,8 +202,6 @@ fn second_lifetime_bound<'a, 'b, T: 'a>() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn second_lifetime_bound<'a, 'b, T: 'a + 'b>() {} @@ -245,8 +213,6 @@ fn inline() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[inline] fn inline() {} @@ -260,8 +226,6 @@ fn inline_never() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[inline(never)] fn inline_never() {} @@ -274,8 +238,6 @@ fn no_mangle() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[no_mangle] fn no_mangle() {} @@ -288,8 +250,6 @@ fn linkage() {} #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[linkage="weak_odr"] fn linkage() {} @@ -304,8 +264,6 @@ fn return_impl_trait() -> i32 { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn return_impl_trait() -> impl Clone { 0 } @@ -321,8 +279,6 @@ fn change_return_impl_trait() -> impl Clone { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] // The actual type is the same, so: clean -#[rustc_metadata_clean(cfg="cfail3")] fn change_return_impl_trait() -> impl Copy { 0u32 } @@ -341,8 +297,6 @@ mod change_return_type_indirectly { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn indirect_return_type() -> ReturnType { ReturnType {} } @@ -359,8 +313,6 @@ mod change_parameter_type_indirectly { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn indirect_parameter_type(p: ParameterType) {} } @@ -378,8 +330,6 @@ mod change_trait_bound_indirectly { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn indirect_trait_bound(p: T) {} } @@ -394,7 +344,5 @@ mod change_trait_bound_indirectly_in_where_clause { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn indirect_trait_bound_where(p: T) where T: Trait {} } diff --git a/src/test/incremental/hashes/if_expressions.rs b/src/test/incremental/hashes/if_expressions.rs index 3cd8308c30b45..d6878028cfae2 100644 --- a/src/test/incremental/hashes/if_expressions.rs +++ b/src/test/incremental/hashes/if_expressions.rs @@ -38,8 +38,6 @@ pub fn change_condition(x: bool) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_condition(x: bool) -> u32 { if !x { return 1 @@ -61,8 +59,6 @@ pub fn change_then_branch(x: bool) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_then_branch(x: bool) -> u32 { if x { return 2 @@ -86,8 +82,6 @@ pub fn change_else_branch(x: bool) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_else_branch(x: bool) -> u32 { if x { 1 @@ -113,8 +107,6 @@ pub fn add_else_branch(x: bool) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn add_else_branch(x: bool) -> u32 { let mut ret = 1; @@ -141,8 +133,6 @@ pub fn change_condition_if_let(x: Option) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_condition_if_let(x: Option) -> u32 { if let Some(_) = x { return 1 @@ -166,8 +156,6 @@ pub fn change_then_branch_if_let(x: Option) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_then_branch_if_let(x: Option) -> u32 { if let Some(x) = x { return x + 1 @@ -191,8 +179,6 @@ pub fn change_else_branch_if_let(x: Option) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_else_branch_if_let(x: Option) -> u32 { if let Some(x) = x { x @@ -218,8 +204,6 @@ pub fn add_else_branch_if_let(x: Option) -> u32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn add_else_branch_if_let(x: Option) -> u32 { let mut ret = 1; diff --git a/src/test/incremental/hashes/indexing_expressions.rs b/src/test/incremental/hashes/indexing_expressions.rs index 5a81d3a9edf45..715146146f148 100644 --- a/src/test/incremental/hashes/indexing_expressions.rs +++ b/src/test/incremental/hashes/indexing_expressions.rs @@ -36,8 +36,6 @@ fn change_simple_index(slice: &[u32]) -> u32 { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_simple_index(slice: &[u32]) -> u32 { slice[4] } @@ -55,8 +53,6 @@ fn change_lower_bound(slice: &[u32]) -> &[u32] { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_lower_bound(slice: &[u32]) -> &[u32] { &slice[2..5] } @@ -74,8 +70,6 @@ fn change_upper_bound(slice: &[u32]) -> &[u32] { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_upper_bound(slice: &[u32]) -> &[u32] { &slice[3..7] } @@ -93,8 +87,6 @@ fn add_lower_bound(slice: &[u32]) -> &[u32] { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_lower_bound(slice: &[u32]) -> &[u32] { &slice[3..4] } @@ -112,8 +104,6 @@ fn add_upper_bound(slice: &[u32]) -> &[u32] { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_upper_bound(slice: &[u32]) -> &[u32] { &slice[3..7] } @@ -131,8 +121,6 @@ fn change_mutability(slice: &mut [u32]) -> u32 { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_mutability(slice: &mut [u32]) -> u32 { (&slice[3..5])[0] } @@ -150,8 +138,6 @@ fn exclusive_to_inclusive_range(slice: &[u32]) -> &[u32] { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn exclusive_to_inclusive_range(slice: &[u32]) -> &[u32] { &slice[3..=7] } diff --git a/src/test/incremental/hashes/inherent_impls.rs b/src/test/incremental/hashes/inherent_impls.rs index 403ea905681e8..c8c2fa5e8c813 100644 --- a/src/test/incremental/hashes/inherent_impls.rs +++ b/src/test/incremental/hashes/inherent_impls.rs @@ -36,11 +36,8 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,AssociatedItemDefIds")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn method_name2() { } } @@ -55,13 +52,9 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn method_body() { println!("Hello, world!"); } @@ -80,13 +73,9 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] #[inline] pub fn method_body_inlined() { println!("Hello, world!"); @@ -103,13 +92,9 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean(cfg="cfail2", except="AssociatedItems,Hir,HirBody")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method_privacy() { } } @@ -122,13 +107,9 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_dirty(cfg="cfail2", except="TypeOfItem,PredicatesOfItem")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn method_selfness(&self) { } } @@ -141,16 +122,12 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean( cfg="cfail2", except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirValidated" )] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn method_selfmutness(&mut self) { } } @@ -165,17 +142,12 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,AssociatedItemDefIds")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn add_method_to_impl1(&self) { } #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn add_method_to_impl2(&self) { } } @@ -190,16 +162,12 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean( cfg="cfail2", except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirValidated" )] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn add_method_parameter(&self, _: i32) { } } @@ -214,13 +182,9 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn change_method_parameter_name(&self, b: i64) { } } @@ -235,15 +199,11 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean( cfg="cfail2", except="Hir,HirBody,FnSignature,MirOptimized,MirValidated,TypeckTables")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn change_method_return_type(&self) -> u8 { 0 } } @@ -258,13 +218,9 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] #[inline] pub fn make_method_inline(&self) -> u8 { 0 } } @@ -280,13 +236,9 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn change_method_parameter_order(&self, b: i64, a: i64) { } } @@ -301,16 +253,12 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean( cfg="cfail2", except="Hir,HirBody,FnSignature,TypeckTables,MirOptimized,MirValidated" )] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub unsafe fn make_method_unsafe(&self) { } } @@ -325,13 +273,9 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean(cfg="cfail2", except="Hir,HirBody,FnSignature,TypeckTables")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub extern fn make_method_extern(&self) { } } @@ -346,13 +290,9 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean(cfg="cfail2", except="Hir,HirBody,FnSignature,TypeckTables")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub extern "system" fn change_method_calling_convention(&self) { } } @@ -367,8 +307,6 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { // Warning: Note that `TypeckTables` are coming up clean here. // The addition or removal of lifetime parameters that don't @@ -381,8 +319,6 @@ impl Foo { // `TypeckTables` appear dirty, that might be the cause. -nmatsakis #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn add_lifetime_parameter_to_method<'a>(&self) { } } @@ -397,8 +333,6 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { // Warning: Note that `TypeckTables` are coming up clean here. // The addition or removal of type parameters that don't appear in @@ -414,8 +348,6 @@ impl Foo { except="Hir,HirBody,GenericsOfItem,PredicatesOfItem,TypeOfItem", )] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn add_type_parameter_to_method(&self) { } } @@ -430,16 +362,12 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean( cfg="cfail2", except="Hir,HirBody,GenericsOfItem,PredicatesOfItem,TypeOfItem,TypeckTables" )] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn add_lifetime_bound_to_lifetime_param_of_method<'a, 'b: 'a>(&self) { } } @@ -454,8 +382,6 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { // Warning: Note that `TypeckTables` are coming up clean here. // The addition or removal of bounds that don't appear in the @@ -469,8 +395,6 @@ impl Foo { #[rustc_clean(cfg="cfail2", except="Hir,HirBody,GenericsOfItem,PredicatesOfItem,\ TypeOfItem")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn add_lifetime_bound_to_type_param_of_method<'a, T: 'a>(&self) { } } @@ -485,8 +409,6 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { // Warning: Note that `TypeckTables` are coming up clean here. // The addition or removal of bounds that don't appear in the @@ -499,8 +421,6 @@ impl Foo { // appear dirty, that might be the cause. -nmatsakis #[rustc_clean(cfg="cfail2", except="Hir,HirBody,PredicatesOfItem")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn add_trait_bound_to_type_param_of_method(&self) { } } @@ -515,13 +435,9 @@ impl Foo { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Foo { #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] #[no_mangle] pub fn add_no_mangle_to_method(&self) { } } @@ -539,16 +455,12 @@ impl Bar { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,GenericsOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Bar { #[rustc_clean( cfg="cfail2", except="GenericsOfItem,FnSignature,TypeckTables,TypeOfItem,MirOptimized,MirValidated" )] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn add_type_parameter_to_impl(&self) { } } @@ -563,13 +475,9 @@ impl Bar { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Bar { #[rustc_clean(cfg="cfail2", except="FnSignature,MirOptimized,MirValidated,TypeckTables")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn change_impl_self_type(&self) { } } @@ -584,13 +492,9 @@ impl Bar { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Bar { #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn add_lifetime_bound_to_impl_parameter(&self) { } } @@ -605,13 +509,9 @@ impl Bar { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl Bar { #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn add_trait_bound_to_impl_parameter(&self) { } } diff --git a/src/test/incremental/hashes/inline_asm.rs b/src/test/incremental/hashes/inline_asm.rs index a1057c036d6c4..0947239c573c2 100644 --- a/src/test/incremental/hashes/inline_asm.rs +++ b/src/test/incremental/hashes/inline_asm.rs @@ -48,8 +48,6 @@ fn change_template(a: i32) -> i32 { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] fn change_template(a: i32) -> i32 { let c: i32; @@ -88,8 +86,6 @@ fn change_output(a: i32) -> i32 { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] fn change_output(a: i32) -> i32 { let mut _out1: i32 = 0; @@ -128,8 +124,6 @@ fn change_input(_a: i32, _b: i32) -> i32 { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] fn change_input(_a: i32, _b: i32) -> i32 { let _out; @@ -167,8 +161,6 @@ fn change_input_constraint(_a: i32, _b: i32) -> i32 { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] fn change_input_constraint(_a: i32, _b: i32) -> i32 { let _out; @@ -206,8 +198,6 @@ fn change_clobber(_a: i32) -> i32 { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] fn change_clobber(_a: i32) -> i32 { let _out; @@ -245,8 +235,6 @@ fn change_options(_a: i32) -> i32 { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] fn change_options(_a: i32) -> i32 { let _out; diff --git a/src/test/incremental/hashes/let_expressions.rs b/src/test/incremental/hashes/let_expressions.rs index dd8bd8fcff24c..f3bddc669842b 100644 --- a/src/test/incremental/hashes/let_expressions.rs +++ b/src/test/incremental/hashes/let_expressions.rs @@ -51,8 +51,6 @@ pub fn add_type() { #[rustc_clean(cfg="cfail2", except="HirBody,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn add_type() { let _x: u32 = 2u32; } @@ -69,8 +67,6 @@ pub fn change_type() { #[rustc_clean(cfg="cfail2", except="HirBody,TypeckTables,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_type() { let _x: u8 = 2; } @@ -87,8 +83,6 @@ pub fn change_mutability_of_reference_type() { #[rustc_clean(cfg="cfail2", except="HirBody,TypeckTables,MirValidated")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_mutability_of_reference_type() { let _x: &mut u64; } @@ -105,8 +99,6 @@ pub fn change_mutability_of_slot() { #[rustc_clean(cfg="cfail2", except="HirBody,TypeckTables,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_mutability_of_slot() { let _x: u64 = 0; } @@ -123,8 +115,6 @@ pub fn change_simple_binding_to_pattern() { #[rustc_clean(cfg="cfail2", except="HirBody,TypeckTables,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_simple_binding_to_pattern() { let (_a, _b) = (0u8, 'x'); } @@ -141,8 +131,6 @@ pub fn change_name_in_pattern() { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_name_in_pattern() { let (_a, _c) = (1u8, 'y'); } @@ -159,8 +147,6 @@ pub fn add_ref_in_pattern() { #[rustc_clean(cfg="cfail2", except="HirBody,TypeckTables,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn add_ref_in_pattern() { let (ref _a, _b) = (1u8, 'y'); } @@ -177,8 +163,6 @@ pub fn add_amp_in_pattern() { #[rustc_clean(cfg="cfail2", except="HirBody,TypeckTables,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn add_amp_in_pattern() { let (&_a, _b) = (&1u8, 'y'); } @@ -195,8 +179,6 @@ pub fn change_mutability_of_binding_in_pattern() { #[rustc_clean(cfg="cfail2", except="HirBody,TypeckTables,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_mutability_of_binding_in_pattern() { let (mut _a, _b) = (99u8, 'q'); } @@ -213,8 +195,6 @@ pub fn add_initializer() { #[rustc_clean(cfg="cfail2", except="HirBody,TypeckTables,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn add_initializer() { let _x: i16 = 3i16; } @@ -231,8 +211,6 @@ pub fn change_initializer() { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_initializer() { let _x = 5u16; } diff --git a/src/test/incremental/hashes/loop_expressions.rs b/src/test/incremental/hashes/loop_expressions.rs index da43ef3c461b7..8d015288757bf 100644 --- a/src/test/incremental/hashes/loop_expressions.rs +++ b/src/test/incremental/hashes/loop_expressions.rs @@ -40,8 +40,6 @@ fn change_loop_body() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_loop_body() { let mut _x = 0; loop { @@ -66,8 +64,6 @@ fn add_break() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_break() { let mut _x = 0; loop { @@ -93,8 +89,6 @@ fn add_loop_label() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_loop_label() { let mut _x = 0; 'label: loop { @@ -120,8 +114,6 @@ fn add_loop_label_to_break() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_loop_label_to_break() { let mut _x = 0; 'label: loop { @@ -149,8 +141,6 @@ fn change_break_label() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_break_label() { let mut _x = 0; 'outer: loop { @@ -178,8 +168,6 @@ fn add_loop_label_to_continue() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_loop_label_to_continue() { let mut _x = 0; 'label: loop { @@ -207,8 +195,6 @@ fn change_continue_label() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_continue_label() { let mut _x = 0; 'outer: loop { @@ -236,8 +222,6 @@ fn change_continue_to_break() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_continue_to_break() { let mut _x = 0; loop { diff --git a/src/test/incremental/hashes/match_expressions.rs b/src/test/incremental/hashes/match_expressions.rs index 0d1444b376156..38edd675cc637 100644 --- a/src/test/incremental/hashes/match_expressions.rs +++ b/src/test/incremental/hashes/match_expressions.rs @@ -39,8 +39,6 @@ pub fn add_arm(x: u32) -> u32 { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn add_arm(x: u32) -> u32 { match x { 0 => 0, @@ -66,8 +64,6 @@ pub fn change_order_of_arms(x: u32) -> u32 { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_order_of_arms(x: u32) -> u32 { match x { 1 => 1, @@ -92,8 +88,6 @@ pub fn add_guard_clause(x: u32, y: bool) -> u32 { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn add_guard_clause(x: u32, y: bool) -> u32 { match x { 0 => 0, @@ -118,8 +112,6 @@ pub fn change_guard_clause(x: u32, y: bool) -> u32 { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_guard_clause(x: u32, y: bool) -> u32 { match x { 0 => 0, @@ -144,8 +136,6 @@ pub fn add_at_binding(x: u32) -> u32 { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn add_at_binding(x: u32) -> u32 { match x { 0 => 0, @@ -170,8 +160,6 @@ pub fn change_name_of_at_binding(x: u32) -> u32 { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_name_of_at_binding(x: u32) -> u32 { match x { 0 => 0, @@ -195,8 +183,6 @@ pub fn change_simple_name_to_pattern(x: u32) -> u32 { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_simple_name_to_pattern(x: u32) -> u32 { match (x, x & 1) { (0, 0) => 0, @@ -220,8 +206,6 @@ pub fn change_name_in_pattern(x: u32) -> u32 { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_name_in_pattern(x: u32) -> u32 { match (x, x & 1) { (b, 0) => 0, @@ -245,8 +229,6 @@ pub fn change_mutability_of_binding_in_pattern(x: u32) -> u32 { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_mutability_of_binding_in_pattern(x: u32) -> u32 { match (x, x & 1) { (mut a, 0) => 0, @@ -269,8 +251,6 @@ pub fn add_ref_to_binding_in_pattern(x: u32) -> u32 { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn add_ref_to_binding_in_pattern(x: u32) -> u32 { match (x, x & 1) { (ref a, 0) => 0, @@ -293,8 +273,6 @@ pub fn add_amp_to_binding_in_pattern(x: u32) -> u32 { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn add_amp_to_binding_in_pattern(x: u32) -> u32 { match (&x, x & 1) { (&a, 0) => 0, @@ -318,8 +296,6 @@ pub fn change_rhs_of_arm(x: u32) -> u32 { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_rhs_of_arm(x: u32) -> u32 { match x { 0 => 0, @@ -344,8 +320,6 @@ pub fn add_alternative_to_arm(x: u32) -> u32 { #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn add_alternative_to_arm(x: u32) -> u32 { match x { 0 | 7 => 0, diff --git a/src/test/incremental/hashes/panic_exprs.rs b/src/test/incremental/hashes/panic_exprs.rs index cddd4ae286b02..c76c10f2ab443 100644 --- a/src/test/incremental/hashes/panic_exprs.rs +++ b/src/test/incremental/hashes/panic_exprs.rs @@ -36,8 +36,6 @@ pub fn indexing(slice: &[u8]) -> u8 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn indexing(slice: &[u8]) -> u8 { slice[100] } @@ -52,8 +50,6 @@ pub fn arithmetic_overflow_plus(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn arithmetic_overflow_plus(val: i32) -> i32 { val + 1 } @@ -68,8 +64,6 @@ pub fn arithmetic_overflow_minus(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn arithmetic_overflow_minus(val: i32) -> i32 { val - 1 } @@ -84,8 +78,6 @@ pub fn arithmetic_overflow_mult(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn arithmetic_overflow_mult(val: i32) -> i32 { val * 2 } @@ -100,8 +92,6 @@ pub fn arithmetic_overflow_negation(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn arithmetic_overflow_negation(val: i32) -> i32 { -val } @@ -116,8 +106,6 @@ pub fn division_by_zero(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn division_by_zero(val: i32) -> i32 { 2 / val } @@ -131,8 +119,6 @@ pub fn mod_by_zero(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn mod_by_zero(val: i32) -> i32 { 2 % val } @@ -147,8 +133,6 @@ pub fn shift_left(val: i32, shift: usize) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn shift_left(val: i32, shift: usize) -> i32 { val << shift } @@ -163,8 +147,6 @@ pub fn shift_right(val: i32, shift: usize) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn shift_right(val: i32, shift: usize) -> i32 { val >> shift } @@ -181,8 +163,6 @@ pub fn bitwise(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn bitwise(val: i32) -> i32 { !val & 0x101010101 | 0x45689 ^ 0x2372382 } @@ -197,8 +177,6 @@ pub fn logical(val1: bool, val2: bool, val3: bool) -> bool { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn logical(val1: bool, val2: bool, val3: bool) -> bool { val1 && val2 || val3 } diff --git a/src/test/incremental/hashes/panic_exprs_no_overflow_checks.rs b/src/test/incremental/hashes/panic_exprs_no_overflow_checks.rs index 01fb9e9c1e1a2..8402da04091ec 100644 --- a/src/test/incremental/hashes/panic_exprs_no_overflow_checks.rs +++ b/src/test/incremental/hashes/panic_exprs_no_overflow_checks.rs @@ -43,8 +43,6 @@ pub fn indexing(slice: &[u8]) -> u8 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn indexing(slice: &[u8]) -> u8 { slice[100] } @@ -60,8 +58,6 @@ pub fn arithmetic_overflow_plus_inherit(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[rustc_inherit_overflow_checks] pub fn arithmetic_overflow_plus_inherit(val: i32) -> i32 { val + 1 @@ -78,8 +74,6 @@ pub fn arithmetic_overflow_minus_inherit(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[rustc_inherit_overflow_checks] pub fn arithmetic_overflow_minus_inherit(val: i32) -> i32 { val - 1 @@ -96,8 +90,6 @@ pub fn arithmetic_overflow_mult_inherit(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[rustc_inherit_overflow_checks] pub fn arithmetic_overflow_mult_inherit(val: i32) -> i32 { val * 2 @@ -114,8 +106,6 @@ pub fn arithmetic_overflow_negation_inherit(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[rustc_inherit_overflow_checks] pub fn arithmetic_overflow_negation_inherit(val: i32) -> i32 { -val @@ -131,8 +121,6 @@ pub fn division_by_zero(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn division_by_zero(val: i32) -> i32 { 2 / val } @@ -146,8 +134,6 @@ pub fn mod_by_zero(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirValidated,MirOptimized")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn mod_by_zero(val: i32) -> i32 { 2 % val } @@ -165,8 +151,6 @@ pub fn bitwise(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn bitwise(val: i32) -> i32 { !val & 0x101010101 | 0x45689 ^ 0x2372382 << 1 >> 1 } @@ -181,8 +165,6 @@ pub fn logical(val1: bool, val2: bool, val3: bool) -> bool { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn logical(val1: bool, val2: bool, val3: bool) -> bool { val1 && val2 || val3 } @@ -196,8 +178,6 @@ pub fn arithmetic_overflow_plus(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn arithmetic_overflow_plus(val: i32) -> i32 { val + 1 } @@ -212,8 +192,6 @@ pub fn arithmetic_overflow_minus(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn arithmetic_overflow_minus(val: i32) -> i32 { val - 1 } @@ -228,8 +206,6 @@ pub fn arithmetic_overflow_mult(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn arithmetic_overflow_mult(val: i32) -> i32 { val * 2 } @@ -244,8 +220,6 @@ pub fn arithmetic_overflow_negation(val: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn arithmetic_overflow_negation(val: i32) -> i32 { -val } diff --git a/src/test/incremental/hashes/statics.rs b/src/test/incremental/hashes/statics.rs index 7a4123190dde3..e729a2c039e4c 100644 --- a/src/test/incremental/hashes/statics.rs +++ b/src/test/incremental/hashes/statics.rs @@ -34,8 +34,6 @@ static STATIC_VISIBILITY: u8 = 0; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub static STATIC_VISIBILITY: u8 = 0; @@ -46,8 +44,6 @@ static STATIC_MUTABILITY: u8 = 0; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] static mut STATIC_MUTABILITY: u8 = 0; @@ -58,8 +54,6 @@ static STATIC_LINKAGE: u8 = 0; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[linkage="weak_odr"] static STATIC_LINKAGE: u8 = 0; @@ -71,8 +65,6 @@ static STATIC_NO_MANGLE: u8 = 0; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[no_mangle] static STATIC_NO_MANGLE: u8 = 0; @@ -84,8 +76,6 @@ static STATIC_THREAD_LOCAL: u8 = 0; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[thread_local] static STATIC_THREAD_LOCAL: u8 = 0; @@ -97,8 +87,6 @@ static STATIC_CHANGE_TYPE_1: i16 = 0; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] static STATIC_CHANGE_TYPE_1: u64 = 0; @@ -109,16 +97,12 @@ static STATIC_CHANGE_TYPE_2: Option = None; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] static STATIC_CHANGE_TYPE_2: Option = None; // Change value between simple literals --------------------------------------- #[rustc_clean(cfg="cfail2", except="HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] static STATIC_CHANGE_VALUE_1: i16 = { #[cfg(cfail1)] { 1 } @@ -131,8 +115,6 @@ static STATIC_CHANGE_VALUE_1: i16 = { // Change value between expressions ------------------------------------------- #[rustc_clean(cfg="cfail2", except="HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] static STATIC_CHANGE_VALUE_2: i16 = { #[cfg(cfail1)] { 1 + 1 } @@ -143,8 +125,6 @@ static STATIC_CHANGE_VALUE_2: i16 = { #[rustc_clean(cfg="cfail2", except="HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] static STATIC_CHANGE_VALUE_3: i16 = { #[cfg(cfail1)] { 2 + 3 } @@ -155,8 +135,6 @@ static STATIC_CHANGE_VALUE_3: i16 = { #[rustc_clean(cfg="cfail2", except="HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] static STATIC_CHANGE_VALUE_4: i16 = { #[cfg(cfail1)] { 1 + 2 * 3 } @@ -179,13 +157,9 @@ mod static_change_type_indirectly { #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] static STATIC_CHANGE_TYPE_INDIRECTLY_1: Type = Type; #[rustc_clean(cfg="cfail2", except="Hir,HirBody,TypeOfItem")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] static STATIC_CHANGE_TYPE_INDIRECTLY_2: Option = None; } diff --git a/src/test/incremental/hashes/struct_constructors.rs b/src/test/incremental/hashes/struct_constructors.rs index 67362e31b2502..a16f4a2fdfd65 100644 --- a/src/test/incremental/hashes/struct_constructors.rs +++ b/src/test/incremental/hashes/struct_constructors.rs @@ -44,8 +44,6 @@ pub fn change_field_value_regular_struct() -> RegularStruct { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_field_value_regular_struct() -> RegularStruct { RegularStruct { x: 0, @@ -69,8 +67,6 @@ pub fn change_field_order_regular_struct() -> RegularStruct { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_field_order_regular_struct() -> RegularStruct { RegularStruct { y: 4, @@ -99,8 +95,6 @@ pub fn add_field_regular_struct() -> RegularStruct { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn add_field_regular_struct() -> RegularStruct { let struct1 = RegularStruct { x: 3, @@ -136,8 +130,6 @@ pub fn change_field_label_regular_struct() -> RegularStruct { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_field_label_regular_struct() -> RegularStruct { let struct1 = RegularStruct { x: 3, @@ -173,8 +165,6 @@ pub fn change_constructor_path_regular_struct() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_constructor_path_regular_struct() { let _ = RegularStruct2 { x: 0, @@ -197,8 +187,6 @@ pub mod change_constructor_path_indirectly_regular_struct { except="FnSignature,Hir,HirBody,MirOptimized,MirValidated,TypeckTables" )] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn function() -> Struct { Struct { x: 0, @@ -221,8 +209,6 @@ pub fn change_field_value_tuple_struct() -> TupleStruct { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_field_value_tuple_struct() -> TupleStruct { TupleStruct(0, 1, 3) } @@ -240,8 +226,6 @@ pub fn change_constructor_path_tuple_struct() { #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="HirBody,MirOptimized,MirValidated,TypeckTables")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn change_constructor_path_tuple_struct() { let _ = TupleStruct2(0, 1, 2); } @@ -260,8 +244,6 @@ pub mod change_constructor_path_indirectly_tuple_struct { except="FnSignature,Hir,HirBody,MirOptimized,MirValidated,TypeckTables" )] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub fn function() -> Struct { Struct(0, 1, 2) } diff --git a/src/test/incremental/hashes/struct_defs.rs b/src/test/incremental/hashes/struct_defs.rs index 16ca71b6cd32d..d89d779c849c3 100644 --- a/src/test/incremental/hashes/struct_defs.rs +++ b/src/test/incremental/hashes/struct_defs.rs @@ -45,8 +45,6 @@ pub struct LayoutPacked; #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[repr(packed)] pub struct LayoutPacked; @@ -64,8 +62,6 @@ struct LayoutC; #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] #[repr(C)] struct LayoutC; @@ -86,13 +82,9 @@ struct TupleStructFieldType(i32); #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] // 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. struct TupleStructFieldType( - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] u32 ); @@ -113,13 +105,8 @@ struct TupleStructAddField(i32); #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] struct TupleStructAddField( - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] i32, - #[rustc_metadata_clean(cfg="cfail3")] u32 ); @@ -140,8 +127,6 @@ struct TupleStructFieldVisibility(char); #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] struct TupleStructFieldVisibility(pub char); @@ -161,13 +146,9 @@ struct RecordStructFieldType { x: f32 } #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] // 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. struct RecordStructFieldType { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] x: u64 } @@ -188,8 +169,6 @@ struct RecordStructFieldName { x: f32 } #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] struct RecordStructFieldName { y: f32 } @@ -209,13 +188,8 @@ struct RecordStructAddField { x: f32 } #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] struct RecordStructAddField { - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] x: f32, - #[rustc_metadata_clean(cfg="cfail3")] y: () } @@ -235,11 +209,7 @@ struct RecordStructFieldVisibility { x: f32 } #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] struct RecordStructFieldVisibility { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] pub x: f32 } @@ -260,8 +230,6 @@ struct AddLifetimeParameter<'a>(&'a f32, &'a f64); #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] struct AddLifetimeParameter<'a, 'b>(&'a f32, &'b f64); @@ -281,14 +249,8 @@ struct AddLifetimeParameterBound<'a, 'b>(&'a f32, &'b f64); #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] struct AddLifetimeParameterBound<'a, 'b: 'a>( - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] &'a f32, - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] &'b f64 ); @@ -306,14 +268,8 @@ struct AddLifetimeParameterBoundWhereClause<'a, 'b>(&'a f32, &'b f64); #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] struct AddLifetimeParameterBoundWhereClause<'a, 'b>( - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] &'a f32, - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] &'b f64) where 'b: 'a; @@ -334,16 +290,10 @@ struct AddTypeParameter(T1, T1); #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] struct AddTypeParameter( // The field contains the parent's Generics, so it's dirty even though its // type hasn't changed. - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] T1, - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] T2 ); @@ -364,11 +314,7 @@ struct AddTypeParameterBound(T); #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] struct AddTypeParameterBound( - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] T ); @@ -387,11 +333,7 @@ struct AddTypeParameterBoundWhereClause(T); #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] struct AddTypeParameterBoundWhereClause( - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] T ) where T: Sync; @@ -411,7 +353,6 @@ struct AddTypeParameterBoundWhereClause( #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] pub struct EmptyStruct; @@ -431,8 +372,6 @@ struct Visibility; #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub struct Visibility; struct ReferencedType1; @@ -455,11 +394,7 @@ mod tuple_struct_change_field_type_indirectly { #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] struct TupleStruct( - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] FieldType ); } @@ -482,11 +417,7 @@ mod record_struct_change_field_type_indirectly { #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] struct RecordStruct { - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] _x: FieldType } } @@ -514,8 +445,6 @@ mod change_trait_bound_indirectly { #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] struct Struct(T); } @@ -536,7 +465,5 @@ mod change_trait_bound_indirectly_in_where_clause { #[rustc_clean(label="TypeOfItem", cfg="cfail3")] #[rustc_clean(label="GenericsOfItem", cfg="cfail3")] #[rustc_clean(label="PredicatesOfItem", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] struct Struct(T) where T : Trait; } diff --git a/src/test/incremental/hashes/trait_defs.rs b/src/test/incremental/hashes/trait_defs.rs index 108363a464519..e09659be75599 100644 --- a/src/test/incremental/hashes/trait_defs.rs +++ b/src/test/incremental/hashes/trait_defs.rs @@ -39,7 +39,6 @@ trait TraitVisibility { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] pub trait TraitVisibility { } @@ -51,8 +50,6 @@ trait TraitUnsafety { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] unsafe trait TraitUnsafety { } @@ -65,8 +62,6 @@ trait TraitAddMethod { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub trait TraitAddMethod { fn method(); } @@ -82,8 +77,6 @@ trait TraitChangeMethodName { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeMethodName { fn methodChanged(); } @@ -99,13 +92,9 @@ trait TraitAddReturnType { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddReturnType { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method() -> u32; } @@ -120,13 +109,9 @@ trait TraitChangeReturnType { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeReturnType { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method() -> u64; } @@ -141,13 +126,9 @@ trait TraitAddParameterToMethod { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddParameterToMethod { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(a: u32); } @@ -163,22 +144,16 @@ trait TraitChangeMethodParameterName { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeMethodParameterName { // FIXME(#38501) This should preferably always be clean. #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(b: u32); #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn with_default(y: i32) {} } @@ -193,13 +168,9 @@ trait TraitChangeMethodParameterType { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeMethodParameterType { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(a: i64); } @@ -214,13 +185,9 @@ trait TraitChangeMethodParameterTypeRef { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeMethodParameterTypeRef { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(a: &mut i32); } @@ -235,13 +202,9 @@ trait TraitChangeMethodParametersOrder { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeMethodParametersOrder { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(b: i64, a: i32); } @@ -256,13 +219,9 @@ trait TraitAddMethodAutoImplementation { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddMethodAutoImplementation { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method() { } } @@ -278,8 +237,6 @@ trait TraitChangeOrderOfMethods { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeOrderOfMethods { fn method1(); fn method0(); @@ -296,13 +253,9 @@ trait TraitChangeModeSelfRefToMut { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeModeSelfRefToMut { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(&mut self); } @@ -316,15 +269,11 @@ trait TraitChangeModeSelfOwnToMut: Sized { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeModeSelfOwnToMut: Sized { #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(mut self) {} } @@ -338,13 +287,9 @@ trait TraitChangeModeSelfOwnToRef { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeModeSelfOwnToRef { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(&self); } @@ -359,13 +304,9 @@ trait TraitAddUnsafeModifier { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddUnsafeModifier { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] unsafe fn method(); } @@ -380,13 +321,9 @@ trait TraitAddExternModifier { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddExternModifier { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] extern fn method(); } @@ -401,13 +338,9 @@ trait TraitChangeExternCToRustIntrinsic { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeExternCToRustIntrinsic { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] extern "rust-intrinsic" fn method(); } @@ -422,13 +355,9 @@ trait TraitAddTypeParameterToMethod { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddTypeParameterToMethod { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(); } @@ -443,13 +372,9 @@ trait TraitAddLifetimeParameterToMethod { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddLifetimeParameterToMethod { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method<'a>(); } @@ -468,13 +393,9 @@ trait TraitAddTraitBoundToMethodTypeParameter { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddTraitBoundToMethodTypeParameter { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(); } @@ -489,13 +410,9 @@ trait TraitAddBuiltinBoundToMethodTypeParameter { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddBuiltinBoundToMethodTypeParameter { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(); } @@ -510,13 +427,9 @@ trait TraitAddLifetimeBoundToMethodLifetimeParameter { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddLifetimeBoundToMethodLifetimeParameter { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method<'a, 'b: 'a>(a: &'a u32, b: &'b u32); } @@ -531,13 +444,9 @@ trait TraitAddSecondTraitBoundToMethodTypeParameter { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSecondTraitBoundToMethodTypeParameter { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(); } @@ -552,13 +461,9 @@ trait TraitAddSecondBuiltinBoundToMethodTypeParameter { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSecondBuiltinBoundToMethodTypeParameter { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(); } @@ -573,13 +478,9 @@ trait TraitAddSecondLifetimeBoundToMethodLifetimeParameter { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSecondLifetimeBoundToMethodLifetimeParameter { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method<'a, 'b, 'c: 'a + 'b>(a: &'a u32, b: &'b u32, c: &'c u32); } @@ -591,16 +492,12 @@ trait TraitAddAssociatedType { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(); } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddAssociatedType { type Associated; @@ -623,13 +520,9 @@ trait TraitAddTraitBoundToAssociatedType { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddTraitBoundToAssociatedType { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] type Associated: ReferencedTrait0; fn method(); @@ -648,13 +541,9 @@ trait TraitAddLifetimeBoundToAssociatedType<'a> { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddLifetimeBoundToAssociatedType<'a> { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] type Associated: 'a; fn method(); @@ -673,13 +562,9 @@ trait TraitAddDefaultToAssociatedType { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddDefaultToAssociatedType { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] type Associated = ReferenceType0; fn method(); @@ -696,8 +581,6 @@ trait TraitAddAssociatedConstant { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddAssociatedConstant { const Value: u32; @@ -717,19 +600,13 @@ trait TraitAddInitializerToAssociatedConstant { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddInitializerToAssociatedConstant { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] const Value: u32 = 1; #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(); } @@ -746,19 +623,13 @@ trait TraitChangeTypeOfAssociatedConstant { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeTypeOfAssociatedConstant { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] const Value: f64; #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(); } @@ -771,8 +642,6 @@ trait TraitAddSuperTrait { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSuperTrait : ReferencedTrait0 { } @@ -784,8 +653,6 @@ trait TraitAddBuiltiBound { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddBuiltiBound : Send { } @@ -797,8 +664,6 @@ trait TraitAddStaticLifetimeBound { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddStaticLifetimeBound : 'static { } @@ -810,8 +675,6 @@ trait TraitAddTraitAsSecondBound : ReferencedTrait0 { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddTraitAsSecondBound : ReferencedTrait0 + ReferencedTrait1 { } #[cfg(cfail1)] @@ -820,8 +683,6 @@ trait TraitAddTraitAsSecondBoundFromBuiltin : Send { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddTraitAsSecondBoundFromBuiltin : Send + ReferencedTrait0 { } @@ -833,8 +694,6 @@ trait TraitAddBuiltinBoundAsSecondBound : ReferencedTrait0 { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddBuiltinBoundAsSecondBound : ReferencedTrait0 + Send { } #[cfg(cfail1)] @@ -843,8 +702,6 @@ trait TraitAddBuiltinBoundAsSecondBoundFromBuiltin : Send { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddBuiltinBoundAsSecondBoundFromBuiltin: Send + Copy { } @@ -856,8 +713,6 @@ trait TraitAddStaticBoundAsSecondBound : ReferencedTrait0 { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddStaticBoundAsSecondBound : ReferencedTrait0 + 'static { } #[cfg(cfail1)] @@ -866,8 +721,6 @@ trait TraitAddStaticBoundAsSecondBoundFromBuiltin : Send { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddStaticBoundAsSecondBoundFromBuiltin : Send + 'static { } @@ -879,8 +732,6 @@ trait TraitAddTypeParameterToTrait { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddTypeParameterToTrait { } @@ -892,8 +743,6 @@ trait TraitAddLifetimeParameterToTrait { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddLifetimeParameterToTrait<'a> { } @@ -905,8 +754,6 @@ trait TraitAddTraitBoundToTypeParameterOfTrait { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddTraitBoundToTypeParameterOfTrait { } @@ -918,8 +765,6 @@ trait TraitAddLifetimeBoundToTypeParameterOfTrait<'a, T> { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddLifetimeBoundToTypeParameterOfTrait<'a, T: 'a> { } @@ -931,8 +776,6 @@ trait TraitAddLifetimeBoundToLifetimeParameterOfTrait<'a, 'b> { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddLifetimeBoundToLifetimeParameterOfTrait<'a: 'b, 'b> { } @@ -944,8 +787,6 @@ trait TraitAddBuiltinBoundToTypeParameterOfTrait { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddBuiltinBoundToTypeParameterOfTrait { } @@ -957,8 +798,6 @@ trait TraitAddSecondTypeParameterToTrait { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSecondTypeParameterToTrait { } @@ -970,8 +809,6 @@ trait TraitAddSecondLifetimeParameterToTrait<'a> { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSecondLifetimeParameterToTrait<'a, 'b> { } @@ -983,8 +820,6 @@ trait TraitAddSecondTraitBoundToTypeParameterOfTrait { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSecondTraitBoundToTypeParameterOfTrait { } @@ -996,8 +831,6 @@ trait TraitAddSecondLifetimeBoundToTypeParameterOfTrait<'a, 'b, T: 'a> { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSecondLifetimeBoundToTypeParameterOfTrait<'a, 'b, T: 'a + 'b> { } @@ -1009,8 +842,6 @@ trait TraitAddSecondLifetimeBoundToLifetimeParameterOfTrait<'a: 'b, 'b, 'c> { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSecondLifetimeBoundToLifetimeParameterOfTrait<'a: 'b + 'c, 'b, 'c> { } @@ -1022,8 +853,6 @@ trait TraitAddSecondBuiltinBoundToTypeParameterOfTrait { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSecondBuiltinBoundToTypeParameterOfTrait { } @@ -1041,8 +870,6 @@ trait TraitAddTraitBoundToTypeParameterOfTraitWhere { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddTraitBoundToTypeParameterOfTraitWhere where T: ReferencedTrait0 { } @@ -1054,8 +881,6 @@ trait TraitAddLifetimeBoundToTypeParameterOfTraitWhere<'a, T> { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddLifetimeBoundToTypeParameterOfTraitWhere<'a, T> where T: 'a { } @@ -1067,8 +892,6 @@ trait TraitAddLifetimeBoundToLifetimeParameterOfTraitWhere<'a, 'b> { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddLifetimeBoundToLifetimeParameterOfTraitWhere<'a, 'b> where 'a: 'b { } @@ -1080,8 +903,6 @@ trait TraitAddBuiltinBoundToTypeParameterOfTraitWhere { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddBuiltinBoundToTypeParameterOfTraitWhere where T: Send { } @@ -1093,8 +914,6 @@ trait TraitAddSecondTraitBoundToTypeParameterOfTraitWhere where T: Referenced #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSecondTraitBoundToTypeParameterOfTraitWhere where T: ReferencedTrait0 + ReferencedTrait1 { } @@ -1107,8 +926,6 @@ trait TraitAddSecondLifetimeBoundToTypeParameterOfTraitWhere<'a, 'b, T> where T: #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSecondLifetimeBoundToTypeParameterOfTraitWhere<'a, 'b, T> where T: 'a + 'b { } @@ -1120,8 +937,6 @@ trait TraitAddSecondLifetimeBoundToLifetimeParameterOfTraitWhere<'a, 'b, 'c> whe #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSecondLifetimeBoundToLifetimeParameterOfTraitWhere<'a, 'b, 'c> where 'a: 'b + 'c { } @@ -1133,8 +948,6 @@ trait TraitAddSecondBuiltinBoundToTypeParameterOfTraitWhere where T: Send { } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] trait TraitAddSecondBuiltinBoundToTypeParameterOfTraitWhere where T: Send + Sync { } @@ -1147,13 +960,9 @@ mod change_return_type_of_method_indirectly_use { #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeReturnType { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method() -> ReturnType; } } @@ -1169,13 +978,9 @@ mod change_method_parameter_type_indirectly_by_use { #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeArgType { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(a: ArgType); } } @@ -1191,13 +996,9 @@ mod change_method_parameter_type_bound_indirectly_by_use { #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeBoundOfMethodTypeParameter { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(a: T); } } @@ -1214,13 +1015,9 @@ mod change_method_parameter_type_bound_indirectly_by_use_where { #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeBoundOfMethodTypeParameterWhere { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method(a: T) where T: Bound; } } @@ -1236,8 +1033,6 @@ mod change_method_type_parameter_bound_indirectly { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeTraitBound { fn method(a: T); } @@ -1255,8 +1050,6 @@ mod change_method_type_parameter_bound_indirectly_where { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] trait TraitChangeTraitBoundWhere where T: Bound { fn method(a: T); } diff --git a/src/test/incremental/hashes/trait_impls.rs b/src/test/incremental/hashes/trait_impls.rs index 06c8eb6a878f0..eb31175b6f257 100644 --- a/src/test/incremental/hashes/trait_impls.rs +++ b/src/test/incremental/hashes/trait_impls.rs @@ -43,22 +43,16 @@ impl ChangeMethodNameTrait for Foo { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub trait ChangeMethodNameTrait { #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail3")] fn method_name2(); } #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl ChangeMethodNameTrait for Foo { #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail3")] fn method_name2() { } } @@ -78,15 +72,11 @@ impl ChangeMethodBodyTrait for Foo { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl ChangeMethodBodyTrait for Foo { #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method_name() { () } @@ -109,15 +99,11 @@ impl ChangeMethodBodyTraitInlined for Foo { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl ChangeMethodBodyTraitInlined for Foo { #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] #[inline] fn method_name() { panic!() @@ -144,13 +130,9 @@ pub trait ChangeMethodSelfnessTrait { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl ChangeMethodSelfnessTrait for Foo { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method_name(&self) { () } @@ -176,13 +158,9 @@ pub trait RemoveMethodSelfnessTrait { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl RemoveMethodSelfnessTrait for Foo { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method_name() {} } @@ -206,13 +184,9 @@ pub trait ChangeMethodSelfmutnessTrait { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl ChangeMethodSelfmutnessTrait for Foo { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method_name(&mut self) {} } @@ -236,8 +210,6 @@ pub trait ChangeItemKindTrait { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl ChangeItemKindTrait for Foo { type name = (); } @@ -264,8 +236,6 @@ pub trait RemoveItemTrait { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl RemoveItemTrait for Foo { type TypeName = (); } @@ -291,8 +261,6 @@ pub trait AddItemTrait { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl AddItemTrait for Foo { type TypeName = (); fn method_name() { } @@ -313,21 +281,15 @@ impl ChangeHasValueTrait for Foo { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub trait ChangeHasValueTrait { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method_name() { } } #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl ChangeHasValueTrait for Foo { fn method_name() { } } @@ -346,13 +308,9 @@ impl AddDefaultTrait for Foo { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl AddDefaultTrait for Foo { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] default fn method_name() { } } @@ -376,13 +334,9 @@ pub trait AddArgumentTrait { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl AddArgumentTrait for Foo { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method_name(&self, _x: u32) { } } @@ -406,13 +360,9 @@ pub trait ChangeArgumentTypeTrait { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl ChangeArgumentTypeTrait for Foo { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn method_name(&self, _x: char) { } } @@ -433,13 +383,9 @@ impl AddTypeParameterToImpl for Bar { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl AddTypeParameterToImpl for Bar { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn id(t: T) -> T { t } } @@ -458,13 +404,9 @@ impl ChangeSelfTypeOfImpl for u32 { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl ChangeSelfTypeOfImpl for u64 { #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn id(self) -> Self { self } } @@ -483,13 +425,9 @@ impl AddLifetimeBoundToImplParameter for T { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl AddLifetimeBoundToImplParameter for T { #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn id(self) -> Self { self } } @@ -508,13 +446,9 @@ impl AddTraitBoundToImplParameter for T { #[cfg(not(cfail1))] #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_dirty(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl AddTraitBoundToImplParameter for T { #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_clean(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] fn id(self) -> Self { self } } @@ -533,13 +467,9 @@ impl AddNoMangleToMethod for Foo { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl AddNoMangleToMethod for Foo { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] #[no_mangle] fn add_no_mangle_to_method(&self) { } } @@ -558,13 +488,9 @@ impl MakeMethodInline for Foo { #[cfg(not(cfail1))] #[rustc_clean(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] impl MakeMethodInline for Foo { #[rustc_dirty(label="Hir", cfg="cfail2")] #[rustc_clean(label="Hir", cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] #[inline] fn make_method_inline(&self) -> u8 { 0 } } diff --git a/src/test/incremental/hashes/type_defs.rs b/src/test/incremental/hashes/type_defs.rs index b0a93eea523cf..59346f5fdb23e 100644 --- a/src/test/incremental/hashes/type_defs.rs +++ b/src/test/incremental/hashes/type_defs.rs @@ -37,7 +37,6 @@ type ChangePrimitiveType = i32; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type ChangePrimitiveType = i64; @@ -49,7 +48,6 @@ type ChangeMutability = &'static i32; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type ChangeMutability = &'static mut i32; @@ -61,7 +59,6 @@ type ChangeLifetime<'a> = (&'static i32, &'a i32); #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type ChangeLifetime<'a> = (&'a i32, &'a i32); @@ -76,7 +73,6 @@ type ChangeTypeStruct = Struct1; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type ChangeTypeStruct = Struct2; @@ -88,7 +84,6 @@ type ChangeTypeTuple = (u32, u64); #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type ChangeTypeTuple = (u32, i64); @@ -109,7 +104,6 @@ type ChangeTypeEnum = Enum1; #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type ChangeTypeEnum = Enum2; @@ -121,7 +115,6 @@ type AddTupleField = (i32, i64); #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type AddTupleField = (i32, i64, i16); @@ -133,7 +126,6 @@ type ChangeNestedTupleField = (i32, (i64, i16)); #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type ChangeNestedTupleField = (i32, (i64, i8)); @@ -145,7 +137,6 @@ type AddTypeParam = (T1, T1); #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type AddTypeParam = (T1, T2); @@ -157,7 +148,6 @@ type AddTypeParamBound = (T1, u32); #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type AddTypeParamBound = (T1, u32); @@ -169,7 +159,6 @@ type AddTypeParamBoundWhereClause where T1: Clone = (T1, u32); #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type AddTypeParamBoundWhereClause where T1: Clone+Copy = (T1, u32); @@ -181,7 +170,6 @@ type AddLifetimeParam<'a> = (&'a u32, &'a u32); #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type AddLifetimeParam<'a, 'b> = (&'a u32, &'b u32); @@ -193,7 +181,6 @@ type AddLifetimeParamBound<'a, 'b> = (&'a u32, &'b u32); #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type AddLifetimeParamBound<'a, 'b: 'a> = (&'a u32, &'b u32); @@ -207,7 +194,6 @@ where 'b: 'a #[cfg(not(cfail1))] #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail3")] type AddLifetimeParamBoundWhereClause<'a, 'b, 'c> where 'b: 'a, 'c: 'a @@ -227,8 +213,6 @@ mod change_trait_bound_indirectly { #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] type ChangeTraitBoundIndirectly = (T, u32); } @@ -243,7 +227,5 @@ mod change_trait_bound_indirectly_in_where_clause { #[rustc_clean(cfg="cfail2", except="Hir,HirBody")] #[rustc_clean(cfg="cfail3")] - #[rustc_metadata_dirty(cfg="cfail2")] - #[rustc_metadata_clean(cfg="cfail3")] type ChangeTraitBoundIndirectly where T : Trait = (T, u32); } diff --git a/src/test/incremental/hashes/unary_and_binary_exprs.rs b/src/test/incremental/hashes/unary_and_binary_exprs.rs index 351039c678024..ec4ae62b12b13 100644 --- a/src/test/incremental/hashes/unary_and_binary_exprs.rs +++ b/src/test/incremental/hashes/unary_and_binary_exprs.rs @@ -34,8 +34,6 @@ pub fn const_negation() -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn const_negation() -> i32 { -1 } @@ -51,8 +49,6 @@ pub fn const_bitwise_not() -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn const_bitwise_not() -> i32 { !99 } @@ -68,8 +64,6 @@ pub fn var_negation(x: i32, y: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn var_negation(x: i32, y: i32) -> i32 { -y } @@ -85,8 +79,6 @@ pub fn var_bitwise_not(x: i32, y: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn var_bitwise_not(x: i32, y: i32) -> i32 { !y } @@ -102,8 +94,6 @@ pub fn var_deref(x: &i32, y: &i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated,TypeckTables", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn var_deref(x: &i32, y: &i32) -> i32 { *y } @@ -119,8 +109,6 @@ pub fn first_const_add() -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn first_const_add() -> i32 { 2 + 3 } @@ -136,8 +124,6 @@ pub fn second_const_add() -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn second_const_add() -> i32 { 1 + 3 } @@ -153,8 +139,6 @@ pub fn first_var_add(a: i32, b: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn first_var_add(a: i32, b: i32) -> i32 { b + 2 } @@ -170,8 +154,6 @@ pub fn second_var_add(a: i32, b: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn second_var_add(a: i32, b: i32) -> i32 { 1 + b } @@ -187,8 +169,6 @@ pub fn plus_to_minus(a: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn plus_to_minus(a: i32) -> i32 { 1 - a } @@ -204,8 +184,6 @@ pub fn plus_to_mult(a: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn plus_to_mult(a: i32) -> i32 { 1 * a } @@ -221,8 +199,6 @@ pub fn plus_to_div(a: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn plus_to_div(a: i32) -> i32 { 1 / a } @@ -238,8 +214,6 @@ pub fn plus_to_mod(a: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn plus_to_mod(a: i32) -> i32 { 1 % a } @@ -255,8 +229,6 @@ pub fn and_to_or(a: bool, b: bool) -> bool { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn and_to_or(a: bool, b: bool) -> bool { a || b } @@ -272,8 +244,6 @@ pub fn bitwise_and_to_bitwise_or(a: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn bitwise_and_to_bitwise_or(a: i32) -> i32 { 1 | a } @@ -289,8 +259,6 @@ pub fn bitwise_and_to_bitwise_xor(a: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn bitwise_and_to_bitwise_xor(a: i32) -> i32 { 1 ^ a } @@ -306,8 +274,6 @@ pub fn bitwise_and_to_lshift(a: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn bitwise_and_to_lshift(a: i32) -> i32 { a << 1 } @@ -323,8 +289,6 @@ pub fn bitwise_and_to_rshift(a: i32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn bitwise_and_to_rshift(a: i32) -> i32 { a >> 1 } @@ -340,8 +304,6 @@ pub fn eq_to_uneq(a: i32) -> bool { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn eq_to_uneq(a: i32) -> bool { a != 1 } @@ -357,8 +319,6 @@ pub fn eq_to_lt(a: i32) -> bool { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn eq_to_lt(a: i32) -> bool { a < 1 } @@ -374,8 +334,6 @@ pub fn eq_to_gt(a: i32) -> bool { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn eq_to_gt(a: i32) -> bool { a > 1 } @@ -391,8 +349,6 @@ pub fn eq_to_le(a: i32) -> bool { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn eq_to_le(a: i32) -> bool { a <= 1 } @@ -408,8 +364,6 @@ pub fn eq_to_ge(a: i32) -> bool { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn eq_to_ge(a: i32) -> bool { a >= 1 } @@ -427,8 +381,6 @@ pub fn type_cast(a: u8) -> u64 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated,TypeckTables", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn type_cast(a: u8) -> u64 { let b = a as u32; let c = b as u64; @@ -446,8 +398,6 @@ pub fn value_cast(a: u32) -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn value_cast(a: u32) -> i32 { 2 as i32 } @@ -466,8 +416,6 @@ pub fn lvalue() -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn lvalue() -> i32 { let mut x = 10; let mut y = 11; @@ -488,8 +436,6 @@ pub fn rvalue() -> i32 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn rvalue() -> i32 { let mut x = 10; x = 8; @@ -507,8 +453,6 @@ pub fn index_to_slice(s: &[u8], i: usize, j: usize) -> u8 { #[cfg(not(cfail1))] #[rustc_clean(except="HirBody,MirOptimized,MirValidated", cfg="cfail2")] #[rustc_clean(cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] pub fn index_to_slice(s: &[u8], i: usize, j: usize) -> u8 { s[j] } diff --git a/src/test/incremental/hashes/while_let_loops.rs b/src/test/incremental/hashes/while_let_loops.rs index f4fd7e709b4b1..eae5aea651075 100644 --- a/src/test/incremental/hashes/while_let_loops.rs +++ b/src/test/incremental/hashes/while_let_loops.rs @@ -40,8 +40,6 @@ fn change_loop_body() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_loop_body() { let mut _x = 0; while let Some(0u32) = None { @@ -67,8 +65,6 @@ fn change_loop_condition() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_loop_condition() { let mut _x = 0; while let Some(1u32) = None { @@ -93,8 +89,6 @@ fn add_break() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_break() { let mut _x = 0; while let Some(0u32) = None { @@ -120,8 +114,6 @@ fn add_loop_label() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_loop_label() { let mut _x = 0; 'label: while let Some(0u32) = None { @@ -147,8 +139,6 @@ fn add_loop_label_to_break() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_loop_label_to_break() { let mut _x = 0; 'label: while let Some(0u32) = None { @@ -176,8 +166,6 @@ fn change_break_label() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_break_label() { let mut _x = 0; 'outer: while let Some(0u32) = None { @@ -205,8 +193,6 @@ fn add_loop_label_to_continue() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_loop_label_to_continue() { let mut _x = 0; 'label: while let Some(0u32) = None { @@ -234,8 +220,6 @@ fn change_continue_label() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_continue_label() { let mut _x = 0; 'outer: while let Some(0u32) = None { @@ -263,8 +247,6 @@ fn change_continue_to_break() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_continue_to_break() { let mut _x = 0; while let Some(0u32) = None { diff --git a/src/test/incremental/hashes/while_loops.rs b/src/test/incremental/hashes/while_loops.rs index aa70d7e9fc112..6b1898e401b24 100644 --- a/src/test/incremental/hashes/while_loops.rs +++ b/src/test/incremental/hashes/while_loops.rs @@ -40,8 +40,6 @@ fn change_loop_body() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_loop_body() { let mut _x = 0; while true { @@ -67,8 +65,6 @@ fn change_loop_condition() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_loop_condition() { let mut _x = 0; while false { @@ -93,8 +89,6 @@ fn add_break() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_break() { let mut _x = 0; while true { @@ -120,8 +114,6 @@ fn add_loop_label() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_loop_label() { let mut _x = 0; 'label: while true { @@ -147,8 +139,6 @@ fn add_loop_label_to_break() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_loop_label_to_break() { let mut _x = 0; 'label: while true { @@ -176,8 +166,6 @@ fn change_break_label() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_break_label() { let mut _x = 0; 'outer: while true { @@ -205,8 +193,6 @@ fn add_loop_label_to_continue() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn add_loop_label_to_continue() { let mut _x = 0; 'label: while true { @@ -234,8 +220,6 @@ fn change_continue_label() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_continue_label() { let mut _x = 0; 'outer: while true { @@ -263,8 +247,6 @@ fn change_continue_to_break() { #[rustc_clean(label="Hir", cfg="cfail3")] #[rustc_dirty(label="HirBody", cfg="cfail2")] #[rustc_clean(label="HirBody", cfg="cfail3")] -#[rustc_metadata_clean(cfg="cfail2")] -#[rustc_metadata_clean(cfg="cfail3")] fn change_continue_to_break() { let mut _x = 0; while true { diff --git a/src/test/incremental/remapped_paths_cc/main.rs b/src/test/incremental/remapped_paths_cc/main.rs index 432d8a1b444f3..ce7f5792cea9e 100644 --- a/src/test/incremental/remapped_paths_cc/main.rs +++ b/src/test/incremental/remapped_paths_cc/main.rs @@ -9,7 +9,7 @@ // except according to those terms. // revisions:rpass1 rpass2 rpass3 -// compile-flags: -Z query-dep-graph -g -Zincremental-cc +// compile-flags: -Z query-dep-graph -g // aux-build:extern_crate.rs // This test case makes sure that we detect if paths emitted into debuginfo diff --git a/src/test/incremental/unchecked_dirty_clean_metadata.rs b/src/test/incremental/unchecked_dirty_clean_metadata.rs deleted file mode 100644 index 917c2c9dbce4f..0000000000000 --- a/src/test/incremental/unchecked_dirty_clean_metadata.rs +++ /dev/null @@ -1,35 +0,0 @@ -// Copyright 2017 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 or the MIT license -// , at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -// revisions: rpass1 cfail2 -// compile-flags: -Z query-dep-graph - -#![allow(warnings)] -#![feature(rustc_attrs)] - -// Sanity check for the dirty-clean system. We add -// #[rustc_metadata_dirty]/#[rustc_metadata_clean] attributes in places that -// are not checked and make sure that this causes an error. - -fn main() { - - #[rustc_metadata_dirty(cfg="cfail2")] - //[cfail2]~^ ERROR found unchecked #[rustc_dirty]/#[rustc_clean] attribute - { - // empty block - } - - #[rustc_metadata_clean(cfg="cfail2")] - //[cfail2]~^ ERROR found unchecked #[rustc_dirty]/#[rustc_clean] attribute - { - // empty block - } -} - diff --git a/src/test/mir-opt/lower_128bit_debug_test.rs b/src/test/mir-opt/lower_128bit_debug_test.rs index 134a868f933fb..ccc6e75a1b42e 100644 --- a/src/test/mir-opt/lower_128bit_debug_test.rs +++ b/src/test/mir-opt/lower_128bit_debug_test.rs @@ -11,37 +11,6 @@ // compile-flags: -Z lower_128bit_ops -C debug_assertions=yes #![feature(i128_type)] -#![feature(lang_items)] - -#[lang="i128_div"] -fn i128_div(_x: i128, _y: i128) -> i128 { 3 } -#[lang="u128_div"] -fn u128_div(_x: u128, _y: u128) -> u128 { 4 } -#[lang="i128_rem"] -fn i128_rem(_x: i128, _y: i128) -> i128 { 5 } -#[lang="u128_rem"] -fn u128_rem(_x: u128, _y: u128) -> u128 { 6 } - -#[lang="i128_addo"] -fn i128_addo(_x: i128, _y: i128) -> (i128, bool) { (0, false) } -#[lang="u128_addo"] -fn u128_addo(_x: u128, _y: u128) -> (u128, bool) { (1, false) } -#[lang="i128_subo"] -fn i128_subo(_x: i128, _y: i128) -> (i128, bool) { (2, false) } -#[lang="u128_subo"] -fn u128_subo(_x: u128, _y: u128) -> (u128, bool) { (3, false) } -#[lang="i128_mulo"] -fn i128_mulo(_x: i128, _y: i128) -> (i128, bool) { (4, false) } -#[lang="u128_mulo"] -fn u128_mulo(_x: u128, _y: u128) -> (u128, bool) { (5, false) } -#[lang="i128_shlo"] -fn i128_shlo(_x: i128, _y: u128) -> (i128, bool) { (6, false) } -#[lang="u128_shlo"] -fn u128_shlo(_x: u128, _y: u128) -> (u128, bool) { (6, false) } -#[lang="i128_shro"] -fn i128_shro(_x: i128, _y: u128) -> (i128, bool) { (7, false) } -#[lang="u128_shro"] -fn u128_shro(_x: u128, _y: u128) -> (u128, bool) { (8, false) } fn test_signed(mut x: i128) -> i128 { x += 1; @@ -66,31 +35,31 @@ fn test_unsigned(mut x: u128) -> u128 { } fn main() { - test_signed(-200); - test_unsigned(200); + assert_eq!(test_signed(-222), -1); + assert_eq!(test_unsigned(200), 2); } // END RUST SOURCE // START rustc.test_signed.Lower128Bit.after.mir -// _2 = const i128_addo(_1, const 1i128) -> bb10; +// _2 = const compiler_builtins::int::addsub::rust_i128_addo(_1, const 1i128) -> bb10; // ... // _1 = move (_2.0: i128); -// _3 = const i128_subo(_1, const 2i128) -> bb11; +// _3 = const compiler_builtins::int::addsub::rust_i128_subo(_1, const 2i128) -> bb11; // ... // _1 = move (_3.0: i128); -// _4 = const i128_mulo(_1, const 3i128) -> bb12; +// _4 = const compiler_builtins::int::mul::rust_i128_mulo(_1, const 3i128) -> bb12; // ... // _1 = move (_4.0: i128); // ... -// _1 = const i128_div(_1, const 4i128) -> bb13; +// _1 = const compiler_builtins::int::sdiv::rust_i128_div(_1, const 4i128) -> bb13; // ... -// _1 = const i128_rem(_1, const 5i128) -> bb15; +// _1 = const compiler_builtins::int::sdiv::rust_i128_rem(_1, const 5i128) -> bb15; // ... // _1 = move (_13.0: i128); // ... // _17 = const 7i32 as u128 (Misc); -// _14 = const i128_shro(_1, move _17) -> bb16; +// _14 = const compiler_builtins::int::shift::rust_i128_shro(_1, move _17) -> bb16; // ... // _1 = move (_14.0: i128); // ... @@ -103,30 +72,30 @@ fn main() { // assert(!move (_13.1: bool), "attempt to shift left with overflow") -> bb8; // ... // _16 = const 6i32 as u128 (Misc); -// _13 = const i128_shlo(_1, move _16) -> bb14; +// _13 = const compiler_builtins::int::shift::rust_i128_shlo(_1, move _16) -> bb14; // ... // assert(!move (_14.1: bool), "attempt to shift right with overflow") -> bb9; // END rustc.test_signed.Lower128Bit.after.mir // START rustc.test_unsigned.Lower128Bit.after.mir -// _2 = const u128_addo(_1, const 1u128) -> bb8; +// _2 = const compiler_builtins::int::addsub::rust_u128_addo(_1, const 1u128) -> bb8; // ... // _1 = move (_2.0: u128); -// _3 = const u128_subo(_1, const 2u128) -> bb9; +// _3 = const compiler_builtins::int::addsub::rust_u128_subo(_1, const 2u128) -> bb9; // ... // _1 = move (_3.0: u128); -// _4 = const u128_mulo(_1, const 3u128) -> bb10; +// _4 = const compiler_builtins::int::mul::rust_u128_mulo(_1, const 3u128) -> bb10; // ... // _1 = move (_4.0: u128); // ... -// _1 = const u128_div(_1, const 4u128) -> bb11; +// _1 = const compiler_builtins::int::udiv::rust_u128_div(_1, const 4u128) -> bb11; // ... -// _1 = const u128_rem(_1, const 5u128) -> bb13; +// _1 = const compiler_builtins::int::udiv::rust_u128_rem(_1, const 5u128) -> bb13; // ... // _1 = move (_7.0: u128); // ... // _11 = const 7i32 as u128 (Misc); -// _8 = const u128_shro(_1, move _11) -> bb14; +// _8 = const compiler_builtins::int::shift::rust_u128_shro(_1, move _11) -> bb14; // ... // _1 = move (_8.0: u128); // ... @@ -139,7 +108,7 @@ fn main() { // assert(!move (_7.1: bool), "attempt to shift left with overflow") -> bb6; // ... // _10 = const 6i32 as u128 (Misc); -// _7 = const u128_shlo(_1, move _10) -> bb12; +// _7 = const compiler_builtins::int::shift::rust_u128_shlo(_1, move _10) -> bb12; // ... // assert(!move (_8.1: bool), "attempt to shift right with overflow") -> bb7; // END rustc.test_unsigned.Lower128Bit.after.mir diff --git a/src/test/mir-opt/lower_128bit_test.rs b/src/test/mir-opt/lower_128bit_test.rs index 5de75014f0efb..dc6beb436db21 100644 --- a/src/test/mir-opt/lower_128bit_test.rs +++ b/src/test/mir-opt/lower_128bit_test.rs @@ -11,36 +11,6 @@ // compile-flags: -Z lower_128bit_ops -C debug_assertions=no #![feature(i128_type)] -#![feature(lang_items)] - -#[lang="i128_add"] -fn i128_add(_x: i128, _y: i128) -> i128 { 0 } -#[lang="u128_add"] -fn u128_add(_x: u128, _y: u128) -> u128 { 0 } -#[lang="i128_sub"] -fn i128_sub(_x: i128, _y: i128) -> i128 { 1 } -#[lang="u128_sub"] -fn u128_sub(_x: u128, _y: u128) -> u128 { 1 } -#[lang="i128_mul"] -fn i128_mul(_x: i128, _y: i128) -> i128 { 2 } -#[lang="u128_mul"] -fn u128_mul(_x: u128, _y: u128) -> u128 { 2 } -#[lang="i128_div"] -fn i128_div(_x: i128, _y: i128) -> i128 { 3 } -#[lang="u128_div"] -fn u128_div(_x: u128, _y: u128) -> u128 { 4 } -#[lang="i128_rem"] -fn i128_rem(_x: i128, _y: i128) -> i128 { 5 } -#[lang="u128_rem"] -fn u128_rem(_x: u128, _y: u128) -> u128 { 6 } -#[lang="i128_shl"] -fn i128_shl(_x: i128, _y: u32) -> i128 { 7 } -#[lang="u128_shl"] -fn u128_shl(_x: u128, _y: u32) -> u128 { 7 } -#[lang="i128_shr"] -fn i128_shr(_x: i128, _y: u32) -> i128 { 8 } -#[lang="u128_shr"] -fn u128_shr(_x: u128, _y: u32) -> u128 { 9 } fn test_signed(mut x: i128) -> i128 { x += 1; @@ -65,44 +35,44 @@ fn test_unsigned(mut x: u128) -> u128 { } fn main() { - test_signed(-200); - test_unsigned(200); + assert_eq!(test_signed(-222), -1); + assert_eq!(test_unsigned(200), 2); } // END RUST SOURCE // START rustc.test_signed.Lower128Bit.after.mir -// _1 = const i128_add(_1, const 1i128) -> bb7; +// _1 = const compiler_builtins::int::addsub::rust_i128_add(_1, const 1i128) -> bb7; // ... -// _1 = const i128_div(_1, const 4i128) -> bb8; +// _1 = const compiler_builtins::int::sdiv::rust_i128_div(_1, const 4i128) -> bb8; // ... -// _1 = const i128_rem(_1, const 5i128) -> bb11; +// _1 = const compiler_builtins::int::sdiv::rust_i128_rem(_1, const 5i128) -> bb11; // ... -// _1 = const i128_mul(_1, const 3i128) -> bb5; +// _1 = const compiler_builtins::int::mul::rust_i128_mul(_1, const 3i128) -> bb5; // ... -// _1 = const i128_sub(_1, const 2i128) -> bb6; +// _1 = const compiler_builtins::int::addsub::rust_i128_sub(_1, const 2i128) -> bb6; // ... // _11 = const 7i32 as u32 (Misc); -// _1 = const i128_shr(_1, move _11) -> bb9; +// _1 = const compiler_builtins::int::shift::rust_i128_shr(_1, move _11) -> bb9; // ... // _12 = const 6i32 as u32 (Misc); -// _1 = const i128_shl(_1, move _12) -> bb10; +// _1 = const compiler_builtins::int::shift::rust_i128_shl(_1, move _12) -> bb10; // END rustc.test_signed.Lower128Bit.after.mir // START rustc.test_unsigned.Lower128Bit.after.mir -// _1 = const u128_add(_1, const 1u128) -> bb5; +// _1 = const compiler_builtins::int::addsub::rust_u128_add(_1, const 1u128) -> bb5; // ... -// _1 = const u128_div(_1, const 4u128) -> bb6; +// _1 = const compiler_builtins::int::udiv::rust_u128_div(_1, const 4u128) -> bb6; // ... -// _1 = const u128_rem(_1, const 5u128) -> bb9; +// _1 = const compiler_builtins::int::udiv::rust_u128_rem(_1, const 5u128) -> bb9; // ... -// _1 = const u128_mul(_1, const 3u128) -> bb3; +// _1 = const compiler_builtins::int::mul::rust_u128_mul(_1, const 3u128) -> bb3; // ... -// _1 = const u128_sub(_1, const 2u128) -> bb4; +// _1 = const compiler_builtins::int::addsub::rust_u128_sub(_1, const 2u128) -> bb4; // ... // _5 = const 7i32 as u32 (Misc); -// _1 = const u128_shr(_1, move _5) -> bb7; +// _1 = const compiler_builtins::int::shift::rust_u128_shr(_1, move _5) -> bb7; // ... // _6 = const 6i32 as u32 (Misc); -// _1 = const u128_shl(_1, move _6) -> bb8; +// _1 = const compiler_builtins::int::shift::rust_u128_shl(_1, move _6) -> bb8; // END rustc.test_unsigned.Lower128Bit.after.mir diff --git a/src/test/run-pass-fulldeps/proc-macro/auxiliary/issue-42708.rs b/src/test/run-pass-fulldeps/proc-macro/auxiliary/issue-42708.rs new file mode 100644 index 0000000000000..58b4b2a5293b3 --- /dev/null +++ b/src/test/run-pass-fulldeps/proc-macro/auxiliary/issue-42708.rs @@ -0,0 +1,28 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// no-prefer-dynamic + +#![crate_type = "proc-macro"] +#![feature(proc_macro)] + +extern crate proc_macro; + +use proc_macro::TokenStream; + +#[proc_macro_derive(Test)] +pub fn derive(_input: TokenStream) -> TokenStream { + "fn f(s: S) { s.x }".parse().unwrap() +} + +#[proc_macro_attribute] +pub fn attr_test(_attr: TokenStream, input: TokenStream) -> TokenStream { + input +} diff --git a/src/test/run-pass-fulldeps/proc-macro/issue-42708.rs b/src/test/run-pass-fulldeps/proc-macro/issue-42708.rs new file mode 100644 index 0000000000000..e53e94ae475b2 --- /dev/null +++ b/src/test/run-pass-fulldeps/proc-macro/issue-42708.rs @@ -0,0 +1,36 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// aux-build:issue-42708.rs +// ignore-stage1 + +#![feature(decl_macro, proc_macro)] +#![allow(unused)] + +extern crate issue_42708; + +macro m() { + #[derive(issue_42708::Test)] + struct S { x: () } + + #[issue_42708::attr_test] + struct S2 { x: () } + + #[derive(Clone)] + struct S3 { x: () } + + fn g(s: S, s2: S2, s3: S3) { + (s.x, s2.x, s3.x); + } +} + +m!(); + +fn main() {} diff --git a/src/test/run-pass/diverging-fn-tail-35849.rs b/src/test/run-pass/diverging-fn-tail-35849.rs index 6c05a02e7183c..dfd99bcc9fb47 100644 --- a/src/test/run-pass/diverging-fn-tail-35849.rs +++ b/src/test/run-pass/diverging-fn-tail-35849.rs @@ -8,6 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +#[allow(coerce_never)] fn assert_sizeof() -> ! { unsafe { ::std::mem::transmute::(panic!()) @@ -15,4 +16,3 @@ fn assert_sizeof() -> ! { } fn main() { } - diff --git a/src/test/rustdoc/inline_cross/assoc-items.rs b/src/test/rustdoc/inline_cross/assoc-items.rs new file mode 100644 index 0000000000000..95d936883ffa9 --- /dev/null +++ b/src/test/rustdoc/inline_cross/assoc-items.rs @@ -0,0 +1,57 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +// aux-build:assoc-items.rs +// build-aux-docs +// ignore-cross-compile + +#![crate_name = "foo"] + +extern crate assoc_items; + +// @has foo/struct.MyStruct.html +// @!has - 'PrivateConst' +// @has - '//*[@id="associatedconstant.PublicConst"]' 'pub const PublicConst: u8' +// @has - '//*[@class="docblock"]' 'PublicConst: u8 = 123' +// @has - '//*[@class="docblock"]' 'docs for PublicConst' +// @!has - 'private_method' +// @has - '//*[@id="method.public_method"]' 'pub fn public_method()' +// @has - '//*[@class="docblock"]' 'docs for public_method' +// @has - '//*[@id="associatedconstant.ConstNoDefault"]' 'const ConstNoDefault: i16' +// @has - '//*[@class="docblock"]' 'ConstNoDefault: i16 = -123' +// @has - '//*[@class="docblock"]' 'dox for ConstNoDefault' +// @has - '//*[@id="associatedconstant.ConstWithDefault"]' 'const ConstWithDefault: u16' +// @has - '//*[@class="docblock"]' 'ConstWithDefault: u16 = 12345' +// @has - '//*[@class="docblock"]' 'docs for ConstWithDefault' +// @has - '//*[@id="associatedtype.TypeNoDefault"]' 'type TypeNoDefault = i32' +// @has - '//*[@class="docblock"]' 'dox for TypeNoDefault' +// @has - '//*[@id="associatedtype.TypeWithDefault"]' 'type TypeWithDefault = u32' +// @has - '//*[@class="docblock"]' 'docs for TypeWithDefault' +// @has - '//*[@id="method.method_no_default"]' 'fn method_no_default()' +// @has - '//*[@class="docblock"]' 'dox for method_no_default' +// @has - '//*[@id="method.method_with_default"]' 'fn method_with_default()' +// @has - '//*[@class="docblock"]' 'docs for method_with_default' +pub use assoc_items::MyStruct; + +// @has foo/trait.MyTrait.html +// @has - '//*[@id="associatedconstant.ConstNoDefault"]' 'const ConstNoDefault: i16' +// @has - '//*[@class="docblock"]' 'docs for ConstNoDefault' +// @has - '//*[@id="associatedconstant.ConstWithDefault"]' 'const ConstWithDefault: u16' +// @has - '//*[@class="docblock"]' 'ConstWithDefault: u16 = 12345' +// @has - '//*[@class="docblock"]' 'docs for ConstWithDefault' +// @has - '//*[@id="associatedtype.TypeNoDefault"]' 'type TypeNoDefault' +// @has - '//*[@class="docblock"]' 'docs for TypeNoDefault' +// @has - '//*[@id="associatedtype.TypeWithDefault"]' 'type TypeWithDefault = u32' +// @has - '//*[@class="docblock"]' 'docs for TypeWithDefault' +// @has - '//*[@id="tymethod.method_no_default"]' 'fn method_no_default()' +// @has - '//*[@class="docblock"]' 'docs for method_no_default' +// @has - '//*[@id="method.method_with_default"]' 'fn method_with_default()' +// @has - '//*[@class="docblock"]' 'docs for method_with_default' +pub use assoc_items::MyTrait; diff --git a/src/test/rustdoc/inline_cross/auxiliary/assoc-items.rs b/src/test/rustdoc/inline_cross/auxiliary/assoc-items.rs new file mode 100644 index 0000000000000..e955526900e99 --- /dev/null +++ b/src/test/rustdoc/inline_cross/auxiliary/assoc-items.rs @@ -0,0 +1,48 @@ +// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +#![feature(associated_type_defaults)] + +pub struct MyStruct; + +impl MyStruct { + /// docs for PrivateConst + const PrivateConst: i8 = -123; + /// docs for PublicConst + pub const PublicConst: u8 = 123; + /// docs for private_method + fn private_method() {} + /// docs for public_method + pub fn public_method() {} +} + +pub trait MyTrait { + /// docs for ConstNoDefault + const ConstNoDefault: i16; + /// docs for ConstWithDefault + const ConstWithDefault: u16 = 12345; + /// docs for TypeNoDefault + type TypeNoDefault; + /// docs for TypeWithDefault + type TypeWithDefault = u32; + /// docs for method_no_default + fn method_no_default(); + /// docs for method_with_default + fn method_with_default() {} +} + +impl MyTrait for MyStruct { + /// dox for ConstNoDefault + const ConstNoDefault: i16 = -12345; + /// dox for TypeNoDefault + type TypeNoDefault = i32; + /// dox for method_no_default + fn method_no_default() {} +} diff --git a/src/test/ui/reachable/expr_unary.rs b/src/test/ui/reachable/expr_unary.rs index 6cff3ff964439..ad12cb876fe9b 100644 --- a/src/test/ui/reachable/expr_unary.rs +++ b/src/test/ui/reachable/expr_unary.rs @@ -12,11 +12,14 @@ #![allow(unused_assignments)] #![allow(dead_code)] #![deny(unreachable_code)] +#![deny(coerce_never)] #![feature(never_type)] fn foo() { let x: ! = ! { return; 22 }; //~ ERROR unreachable - //~^ ERROR cannot apply unary operator `!` to type `!` + //~^ ERROR cannot coerce + //~| hard error + //~| ERROR cannot apply unary operator `!` to type `!` } fn main() { } diff --git a/src/test/ui/reachable/expr_unary.stderr b/src/test/ui/reachable/expr_unary.stderr index f14824728a70c..39120f0bdf980 100644 --- a/src/test/ui/reachable/expr_unary.stderr +++ b/src/test/ui/reachable/expr_unary.stderr @@ -1,7 +1,7 @@ error: unreachable expression - --> $DIR/expr_unary.rs:18:28 + --> $DIR/expr_unary.rs:19:28 | -18 | let x: ! = ! { return; 22 }; //~ ERROR unreachable +19 | let x: ! = ! { return; 22 }; //~ ERROR unreachable | ^^ | note: lint level defined here @@ -10,11 +10,25 @@ note: lint level defined here 14 | #![deny(unreachable_code)] | ^^^^^^^^^^^^^^^^ +error: cannot coerce `{integer}` to ! + --> $DIR/expr_unary.rs:19:28 + | +19 | let x: ! = ! { return; 22 }; //~ ERROR unreachable + | ^^ + | +note: lint level defined here + --> $DIR/expr_unary.rs:15:9 + | +15 | #![deny(coerce_never)] + | ^^^^^^^^^^^^ + = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release! + = note: for more information, see issue #46325 + error[E0600]: cannot apply unary operator `!` to type `!` - --> $DIR/expr_unary.rs:18:16 + --> $DIR/expr_unary.rs:19:16 | -18 | let x: ! = ! { return; 22 }; //~ ERROR unreachable +19 | let x: ! = ! { return; 22 }; //~ ERROR unreachable | ^^^^^^^^^^^^^^^^ -error: aborting due to 2 previous errors +error: aborting due to 3 previous errors