Auto merge of #67721 - JohnTitor:rollup-o8zm4r9, r=JohnTitor

Rollup of 10 pull requests

Successful merges:

 - #64273 (Stabilize attribute macros on inline modules)
 - #67287 (typeck: note other end-point when checking range pats)
 - #67564 (docs: Iterator adapters have unspecified results after a panic)
 - #67622 (Some keyword documentation.)
 - #67657 (Clean up const-hack PRs now that const if / match exist.)
 - #67677 (resolve: Minor cleanup of duplicate macro reexports)
 - #67687 (Do not ICE on lifetime error involving closures)
 - #67698 (Move reachable_set and diagnostic_items to librustc_passes.)
 - #67701 (tidy: Enforce formatting rather than just check it if `--bless` is specified)
 - #67715 (Typo fix)

Failed merges:

r? @ghost

Author: bors

src/bootstrap/test.rs

@@ -736,7 +736,7 @@ impl Step for Tidy {
 
         if builder.config.channel == "dev" || builder.config.channel == "nightly" {
             builder.info("fmt check");
-            crate::format::format(&builder.build, true);
+            crate::format::format(&builder.build, !builder.config.cmd.bless());
         }
     }
 

src/libcore/iter/mod.rs

@@ -216,6 +216,11 @@
 //! Common iterator adapters include [`map`], [`take`], and [`filter`].
 //! For more, see their documentation.
 //!
+//! If an iterator adapter panics, the iterator will be in an unspecified (but
+//! memory safe) state.  This state is also not guaranteed to stay the same
+//! across versions of Rust, so you should avoid relying on the exact values
+//! returned by an iterator which panicked.
+//!
 //! [`map`]: trait.Iterator.html#method.map
 //! [`take`]: trait.Iterator.html#method.take
 //! [`filter`]: trait.Iterator.html#method.filter

src/libcore/lib.rs

@@ -71,6 +71,8 @@
 #![feature(cfg_target_has_atomic)]
 #![feature(concat_idents)]
 #![feature(const_fn)]
+#![feature(const_if_match)]
+#![feature(const_panic)]
 #![feature(const_fn_union)]
 #![feature(const_generics)]
 #![feature(const_ptr_offset_from)]

src/libcore/mem/manually_drop.rs

@@ -121,7 +121,7 @@ impl<T: ?Sized> ManuallyDrop<T> {
     /// This function runs the destructor of the contained value and thus the wrapped value
     /// now represents uninitialized data. It is up to the user of this method to ensure the
     /// uninitialized data is not actually used.
-    /// In particular, this function can only be called called at most once
+    /// In particular, this function can only be called at most once
     /// for a given instance of `ManuallyDrop<T>`.
     ///
     /// [`ManuallyDrop::into_inner`]: #method.into_inner

src/libcore/num/mod.rs

@@ -1416,18 +1416,14 @@ $EndFeature, "
 ```"),
             #[stable(feature = "no_panic_abs", since = "1.13.0")]
             #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+            #[allow_internal_unstable(const_if_match)]
             #[inline]
             pub const fn wrapping_abs(self) -> Self {
-                // sign is -1 (all ones) for negative numbers, 0 otherwise.
-                let sign = self >> ($BITS - 1);
-                // For positive self, sign == 0 so the expression is simply
-                // (self ^ 0).wrapping_sub(0) == self == abs(self).
-                //
-                // For negative self, self ^ sign == self ^ all_ones.
-                // But all_ones ^ self == all_ones - self == -1 - self.
-                // So for negative numbers, (self ^ sign).wrapping_sub(sign) is
-                // (-1 - self).wrapping_sub(-1) == -self == abs(self).
-                (self ^ sign).wrapping_sub(sign)
+                 if self.is_negative() {
+                     self.wrapping_neg()
+                 } else {
+                     self
+                 }
             }
         }
 
@@ -1713,8 +1709,13 @@ assert_eq!(", stringify!($SelfT), "::MIN.overflowing_neg(), (", stringify!($Self
             #[inline]
             #[stable(feature = "wrapping", since = "1.7.0")]
             #[rustc_const_stable(feature = "const_int_methods", since = "1.32.0")]
+            #[allow_internal_unstable(const_if_match)]
             pub const fn overflowing_neg(self) -> (Self, bool) {
-                ((!self).wrapping_add(1), self == Self::min_value())
+                if self == Self::min_value() {
+                    (Self::min_value(), true)
+                } else {
+                    (-self, false)
+                }
             }
         }
 
@@ -2041,7 +2042,11 @@ $EndFeature, "
             #[rustc_const_unstable(feature = "const_int_sign", issue = "53718")]
             #[inline]
             pub const fn signum(self) -> Self {
-                (self > 0) as Self - (self < 0) as Self
+                match self {
+                    n if n > 0 =>  1,
+                    0          =>  0,
+                    _          => -1,
+                }
             }
         }
 

src/libcore/ptr/const_ptr.rs

@@ -288,10 +288,7 @@ impl<T: ?Sized> *const T {
         T: Sized,
     {
         let pointee_size = mem::size_of::<T>();
-        let ok = 0 < pointee_size && pointee_size <= isize::max_value() as usize;
-        // assert that the pointee size is valid in a const eval compatible way
-        // FIXME: do this with a real assert at some point
-        [()][(!ok) as usize];
+        assert!(0 < pointee_size && pointee_size <= isize::max_value() as usize);
         intrinsics::ptr_offset_from(self, origin)
     }
 

src/librustc/lib.rs

@@ -95,24 +95,7 @@ pub mod hir;
 pub mod ich;
 pub mod infer;
 pub mod lint;
-
-pub mod middle {
-    pub mod cstore;
-    pub mod dependency_format;
-    pub mod diagnostic_items;
-    pub mod exported_symbols;
-    pub mod free_region;
-    pub mod lang_items;
-    pub mod lib_features;
-    pub mod privacy;
-    pub mod reachable;
-    pub mod recursion_limit;
-    pub mod region;
-    pub mod resolve_lifetime;
-    pub mod stability;
-    pub mod weak_lang_items;
-}
-
+pub mod middle;
 pub mod mir;
 pub use rustc_session as session;
 pub mod traits;

src/librustc/middle/mod.rs

@@ -0,0 +1,35 @@
+pub mod cstore;
+pub mod dependency_format;
+pub mod exported_symbols;
+pub mod free_region;
+pub mod lang_items;
+pub mod lib_features {
+    use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+    use syntax::symbol::Symbol;
+
+    #[derive(HashStable)]
+    pub struct LibFeatures {
+        // A map from feature to stabilisation version.
+        pub stable: FxHashMap<Symbol, Symbol>,
+        pub unstable: FxHashSet<Symbol>,
+    }
+
+    impl LibFeatures {
+        pub fn to_vec(&self) -> Vec<(Symbol, Option<Symbol>)> {
+            let mut all_features: Vec<_> = self
+                .stable
+                .iter()
+                .map(|(f, s)| (*f, Some(*s)))
+                .chain(self.unstable.iter().map(|f| (*f, None)))
+                .collect();
+            all_features.sort_unstable_by_key(|f| f.0.as_str());
+            all_features
+        }
+    }
+}
+pub mod privacy;
+pub mod recursion_limit;
+pub mod region;
+pub mod resolve_lifetime;
+pub mod stability;
+pub mod weak_lang_items;

src/librustc/query/mod.rs

@@ -510,7 +510,7 @@ rustc_queries! {
     }
 
     Other {
-        query reachable_set(_: CrateNum) -> ReachableSet {
+        query reachable_set(_: CrateNum) -> Lrc<HirIdSet> {
             desc { "reachability" }
         }
 

src/librustc/ty/context.rs

@@ -2751,22 +2751,10 @@ pub fn provide(providers: &mut ty::query::Providers<'_>) {
         assert_eq!(id, LOCAL_CRATE);
         tcx.crate_name
     };
-    providers.get_lib_features = |tcx, id| {
-        assert_eq!(id, LOCAL_CRATE);
-        tcx.arena.alloc(middle::lib_features::collect(tcx))
-    };
     providers.get_lang_items = |tcx, id| {
         assert_eq!(id, LOCAL_CRATE);
         tcx.arena.alloc(middle::lang_items::collect(tcx))
     };
-    providers.diagnostic_items = |tcx, id| {
-        assert_eq!(id, LOCAL_CRATE);
-        middle::diagnostic_items::collect(tcx)
-    };
-    providers.all_diagnostic_items = |tcx, id| {
-        assert_eq!(id, LOCAL_CRATE);
-        middle::diagnostic_items::collect_all(tcx)
-    };
     providers.maybe_unused_trait_import = |tcx, id| tcx.maybe_unused_trait_imports.contains(&id);
     providers.maybe_unused_extern_crates = |tcx, cnum| {
         assert_eq!(cnum, LOCAL_CRATE);

src/librustc/ty/query/mod.rs

@@ -10,7 +10,6 @@ use crate::middle::exported_symbols::{ExportedSymbol, SymbolExportLevel};
 use crate::middle::lang_items::{LangItem, LanguageItems};
 use crate::middle::lib_features::LibFeatures;
 use crate::middle::privacy::AccessLevels;
-use crate::middle::reachable::ReachableSet;
 use crate::middle::region;
 use crate::middle::resolve_lifetime::{ObjectLifetimeDefault, Region, ResolveLifetimes};
 use crate::middle::stability::{self, DeprecationEntry};
@@ -37,7 +36,7 @@ use crate::ty::subst::SubstsRef;
 use crate::ty::util::NeedsDrop;
 use crate::ty::{self, AdtSizedConstraint, CrateInherentImpls, ParamEnvAnd, Ty, TyCtxt};
 use crate::util::common::ErrorReported;
-use crate::util::nodemap::{DefIdMap, DefIdSet};
+use crate::util::nodemap::{DefIdMap, DefIdSet, HirIdSet};
 use rustc_data_structures::profiling::ProfileCategory::*;
 
 use rustc_data_structures::fingerprint::Fingerprint;

src/librustc_codegen_ssa/back/symbol_export.rs

@@ -65,7 +65,6 @@ fn reachable_non_generics_provider(
 
     let mut reachable_non_generics: DefIdMap<_> = tcx
         .reachable_set(LOCAL_CRATE)
-        .0
         .iter()
         .filter_map(|&hir_id| {
             // We want to ignore some FFI functions that are not exposed from
@@ -313,7 +312,7 @@ fn upstream_monomorphizations_for_provider(
 
 fn is_unreachable_local_definition_provider(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
     if let Some(hir_id) = tcx.hir().as_local_hir_id(def_id) {
-        !tcx.reachable_set(LOCAL_CRATE).0.contains(&hir_id)
+        !tcx.reachable_set(LOCAL_CRATE).contains(&hir_id)
     } else {
         bug!("is_unreachable_local_definition called with non-local DefId: {:?}", def_id)
     }

src/librustc_interface/passes.rs

@@ -10,7 +10,7 @@ use rustc::hir::def_id::{CrateNum, LOCAL_CRATE};
 use rustc::hir::lowering::lower_crate;
 use rustc::lint;
 use rustc::middle::cstore::{CrateStore, MetadataLoader, MetadataLoaderDyn};
-use rustc::middle::{self, reachable, resolve_lifetime, stability};
+use rustc::middle::{self, resolve_lifetime, stability};
 use rustc::session::config::{self, CrateType, Input, OutputFilenames, OutputType};
 use rustc::session::config::{PpMode, PpSourceMode};
 use rustc::session::search_paths::PathKind;
@@ -678,14 +678,12 @@ pub fn default_provide(providers: &mut ty::query::Providers<'_>) {
     plugin::build::provide(providers);
     hir::provide(providers);
     mir::provide(providers);
-    reachable::provide(providers);
     resolve_lifetime::provide(providers);
     rustc_privacy::provide(providers);
     typeck::provide(providers);
     ty::provide(providers);
     traits::provide(providers);
     stability::provide(providers);
-    reachable::provide(providers);
     rustc_passes::provide(providers);
     rustc_traits::provide(providers);
     middle::region::provide(providers);

src/librustc_mir/borrow_check/diagnostics/conflict_errors.rs

@@ -882,9 +882,27 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                 err.span_label(
                     drop_span,
                     format!(
-                        "...but `{}` will be dropped here, when the function `{}` returns",
+                        "...but `{}` will be dropped here, when the {} returns",
                         name,
-                        self.infcx.tcx.hir().name(fn_hir_id),
+                        self.infcx
+                            .tcx
+                            .hir()
+                            .opt_name(fn_hir_id)
+                            .map(|name| format!("function `{}`", name))
+                            .unwrap_or_else(|| {
+                                match &self
+                                    .infcx
+                                    .tcx
+                                    .typeck_tables_of(self.mir_def_id)
+                                    .node_type(fn_hir_id)
+                                    .kind
+                                {
+                                    ty::Closure(..) => "enclosing closure",
+                                    ty::Generator(..) => "enclosing generator",
+                                    kind => bug!("expected closure or generator, found {:?}", kind),
+                                }
+                                .to_string()
+                            })
                     ),
                 );
 

src/librustc/middle/diagnostic_items.rs src/librustc_passes/diagnostic_items.rs

@@ -9,12 +9,13 @@
 //!
 //! * Compiler internal types like `Ty` and `TyCtxt`
 
-use crate::hir::def_id::{DefId, LOCAL_CRATE};
-use crate::ty::TyCtxt;
-use crate::util::nodemap::FxHashMap;
+use rustc::hir::def_id::{DefId, LOCAL_CRATE};
+use rustc::ty::query::Providers;
+use rustc::ty::TyCtxt;
+use rustc::util::nodemap::FxHashMap;
 
-use crate::hir;
-use crate::hir::itemlikevisit::ItemLikeVisitor;
+use rustc::hir;
+use rustc::hir::itemlikevisit::ItemLikeVisitor;
 use syntax::ast;
 use syntax::symbol::{sym, Symbol};
 
@@ -93,7 +94,7 @@ fn extract(attrs: &[ast::Attribute]) -> Option<Symbol> {
 }
 
 /// Traverse and collect the diagnostic items in the current
-pub fn collect<'tcx>(tcx: TyCtxt<'tcx>) -> &'tcx FxHashMap<Symbol, DefId> {
+fn collect<'tcx>(tcx: TyCtxt<'tcx>) -> &'tcx FxHashMap<Symbol, DefId> {
     // Initialize the collector.
     let mut collector = DiagnosticItemCollector::new(tcx);
 
@@ -104,7 +105,7 @@ pub fn collect<'tcx>(tcx: TyCtxt<'tcx>) -> &'tcx FxHashMap<Symbol, DefId> {
 }
 
 /// Traverse and collect all the diagnostic items in all crates.
-pub fn collect_all<'tcx>(tcx: TyCtxt<'tcx>) -> &'tcx FxHashMap<Symbol, DefId> {
+fn collect_all<'tcx>(tcx: TyCtxt<'tcx>) -> &'tcx FxHashMap<Symbol, DefId> {
     // Initialize the collector.
     let mut collector = FxHashMap::default();
 
@@ -117,3 +118,14 @@ pub fn collect_all<'tcx>(tcx: TyCtxt<'tcx>) -> &'tcx FxHashMap<Symbol, DefId> {
 
     tcx.arena.alloc(collector)
 }
+
+pub fn provide(providers: &mut Providers<'_>) {
+    providers.diagnostic_items = |tcx, id| {
+        assert_eq!(id, LOCAL_CRATE);
+        collect(tcx)
+    };
+    providers.all_diagnostic_items = |tcx, id| {
+        assert_eq!(id, LOCAL_CRATE);
+        collect_all(tcx)
+    };
+}

src/librustc_passes/lib.rs

@@ -22,17 +22,23 @@ use rustc::ty::query::Providers;
 pub mod ast_validation;
 mod check_const;
 pub mod dead;
+mod diagnostic_items;
 pub mod entry;
 pub mod hir_stats;
 mod intrinsicck;
 pub mod layout_test;
+mod lib_features;
 mod liveness;
 pub mod loops;
+mod reachable;
 
 pub fn provide(providers: &mut Providers<'_>) {
     check_const::provide(providers);
+    diagnostic_items::provide(providers);
     entry::provide(providers);
+    lib_features::provide(providers);
     loops::provide(providers);
     liveness::provide(providers);
     intrinsicck::provide(providers);
+    reachable::provide(providers);
 }