Rollup of 8 pull requests

src/ci/docker/dist-android/Dockerfile

@@ -23,6 +23,7 @@ ENV TARGETS=$TARGETS,x86_64-linux-android
 
 ENV RUST_CONFIGURE_ARGS \
  --enable-extended \
+ --enable-profiler \
  --arm-linux-androideabi-ndk=/android/ndk/arm-14 \
  --armv7-linux-androideabi-ndk=/android/ndk/arm-14 \
  --thumbv7neon-linux-androideabi-ndk=/android/ndk/arm-14 \

src/librustc/hir/map/mod.rs

@@ -346,7 +346,7 @@ impl<'hir> Map<'hir> {
  }
 
  fn get_entry(&self, id: HirId) -> Entry<'hir> {
- if id.local_id == ItemLocalId::from_u32_const(0) {
+ if id.local_id == ItemLocalId::from_u32(0) {
  let owner = self.tcx.hir_owner(id.owner_def_id());
  Entry { parent: owner.parent, node: owner.node }
  } else {

src/librustc/lib.rs

@@ -26,6 +26,9 @@
 #![feature(bool_to_option)]
 #![feature(box_patterns)]
 #![feature(box_syntax)]
+#![feature(const_if_match)]
+#![feature(const_fn)]
+#![feature(const_panic)]
 #![feature(const_transmute)]
 #![feature(core_intrinsics)]
 #![feature(drain_filter)]

src/librustc/ty/context.rs

@@ -23,7 +23,6 @@ use crate::mir::{
 };
 use crate::traits;
 use crate::traits::{Clause, Clauses, Goal, GoalKind, Goals};
-use crate::ty::free_region_map::FreeRegionMap;
 use crate::ty::layout::{LayoutDetails, TargetDataLayout, VariantIdx};
 use crate::ty::query;
 use crate::ty::steal::Steal;
@@ -416,11 +415,6 @@ pub struct TypeckTables<'tcx> {
  /// this field will be set to `true`.
  pub tainted_by_errors: bool,
 
- /// Stores the free-region relationships that were deduced from
- /// its where-clauses and parameter types. These are then
- /// read-again by borrowck.
- pub free_region_map: FreeRegionMap<'tcx>,
-
  /// All the opaque types that are restricted to concrete types
  /// by this function.
  pub concrete_opaque_types: FxHashMap<DefId, ResolvedOpaqueTy<'tcx>>,
@@ -456,7 +450,6 @@ impl<'tcx> TypeckTables<'tcx> {
  coercion_casts: Default::default(),
  used_trait_imports: Lrc::new(Default::default()),
  tainted_by_errors: false,
- free_region_map: Default::default(),
  concrete_opaque_types: Default::default(),
  upvar_list: Default::default(),
  generator_interior_types: Default::default(),
@@ -719,7 +712,6 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for TypeckTables<'tcx> {
 
  ref used_trait_imports,
  tainted_by_errors,
- ref free_region_map,
  ref concrete_opaque_types,
  ref upvar_list,
  ref generator_interior_types,
@@ -757,7 +749,6 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for TypeckTables<'tcx> {
  coercion_casts.hash_stable(hcx, hasher);
  used_trait_imports.hash_stable(hcx, hasher);
  tainted_by_errors.hash_stable(hcx, hasher);
- free_region_map.hash_stable(hcx, hasher);
  concrete_opaque_types.hash_stable(hcx, hasher);
  upvar_list.hash_stable(hcx, hasher);
  generator_interior_types.hash_stable(hcx, hasher);

src/librustc/ty/layout.rs

@@ -1409,12 +1409,15 @@ impl<'tcx> LayoutCx<'tcx, TyCtxt<'tcx>> {
  // locals as part of the prefix. We compute the layout of all of
  // these fields at once to get optimal packing.
  let discr_index = substs.as_generator().prefix_tys(def_id, tcx).count();
- // FIXME(eddyb) set the correct vaidity range for the discriminant.
- let discr_layout = self.layout_of(substs.as_generator().discr_ty(tcx))?;
- let discr = match &discr_layout.abi {
- Abi::Scalar(s) => s.clone(),
- _ => bug!(),
- };
+
+ // `info.variant_fields` already accounts for the reserved variants, so no need to add them.
+ let max_discr = (info.variant_fields.len() - 1) as u128;
+ let discr_int = Integer::fit_unsigned(max_discr);
+ let discr_int_ty = discr_int.to_ty(tcx, false);
+ let discr = Scalar { value: Primitive::Int(discr_int, false), valid_range: 0..=max_discr };
+ let discr_layout = self.tcx.intern_layout(LayoutDetails::scalar(self, discr.clone()));
+ let discr_layout = TyLayout { ty: discr_int_ty, details: discr_layout };
+
  let promoted_layouts = ineligible_locals
  .iter()
  .map(|local| subst_field(info.field_tys[local]))

src/librustc/ty/mod.rs

@@ -1700,7 +1700,7 @@ rustc_index::newtype_index! {
 }
 
 impl UniverseIndex {
- pub const ROOT: UniverseIndex = UniverseIndex::from_u32_const(0);
+ pub const ROOT: UniverseIndex = UniverseIndex::from_u32(0);
 
  /// Returns the "next" universe index in order -- this new index
  /// is considered to extend all previous universes. This

src/librustc_ast/lib.rs

@@ -7,7 +7,9 @@
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/", test(attr(deny(warnings))))]
 #![feature(bool_to_option)]
 #![feature(box_syntax)]
+#![feature(const_if_match)]
 #![feature(const_fn)] // For the `transmute` in `P::new`
+#![feature(const_panic)]
 #![feature(const_transmute)]
 #![feature(crate_visibility_modifier)]
 #![feature(label_break_value)]

src/librustc_ast/node_id.rs

@@ -12,7 +12,7 @@ rustc_index::newtype_index! {
 rustc_data_structures::define_id_collections!(NodeMap, NodeSet, NodeId);
 
 /// `NodeId` used to represent the root of the crate.
-pub const CRATE_NODE_ID: NodeId = NodeId::from_u32_const(0);
+pub const CRATE_NODE_ID: NodeId = NodeId::from_u32(0);
 
 /// When parsing and doing expansions, we initially give all AST nodes this AST
 /// node value. Then later, in the renumber pass, we renumber them to have

src/librustc_ast_pretty/pprust.rs

@@ -148,12 +148,19 @@ pub fn to_string(f: impl FnOnce(&mut State<'_>)) -> String {
 
 // This makes comma-separated lists look slightly nicer,
 // and also addresses a specific regression described in issue #63896.
-fn tt_prepend_space(tt: &TokenTree) -> bool {
+fn tt_prepend_space(tt: &TokenTree, prev: &TokenTree) -> bool {
  match tt {
  TokenTree::Token(token) => match token.kind {
  token::Comma => false,
  _ => true,
  },
+ TokenTree::Delimited(_, DelimToken::Paren, _) => match prev {
+ TokenTree::Token(token) => match token.kind {
+ token::Ident(_, _) => false,
+ _ => true,
+ },
+ _ => true,
+ },
  _ => true,
  }
 }
@@ -650,11 +657,14 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
  }
 
  fn print_tts(&mut self, tts: tokenstream::TokenStream, convert_dollar_crate: bool) {
- for (i, tt) in tts.into_trees().enumerate() {
- if i != 0 && tt_prepend_space(&tt) {
+ let mut iter = tts.into_trees().peekable();
+ while let Some(tt) = iter.next() {
+ let show_space =
+ if let Some(next) = iter.peek() { tt_prepend_space(next, &tt) } else { false };
+ self.print_tt(tt, convert_dollar_crate);
+ if show_space {
  self.space();
  }
- self.print_tt(tt, convert_dollar_crate);
  }
  }
 

src/librustc_error_codes/error_codes/E0308.md

@@ -1,10 +1,6 @@
-This error occurs when the compiler was unable to infer the concrete type of a
-variable. It can occur for several cases, the most common of which is a
-mismatch in the expected type that the compiler inferred for a variable's
-initializing expression, and the actual type explicitly assigned to the
-variable.
+Expected type did not match the received type.
 
-For example:
+Erroneous code example:
 
 ```compile_fail,E0308
 let x: i32 = "I am not a number!";
@@ -15,3 +11,9 @@ let x: i32 = "I am not a number!";
 // |
 // type `i32` assigned to variable `x`
 ```
+
+This error occurs when the compiler was unable to infer the concrete type of a
+variable. It can occur for several cases, the most common of which is a
+mismatch in the expected type that the compiler inferred for a variable's
+initializing expression, and the actual type explicitly assigned to the
+variable.

src/librustc_expand/base.rs

@@ -921,6 +921,7 @@ pub struct ExpansionData {
 pub struct ExtCtxt<'a> {
  pub parse_sess: &'a ParseSess,
  pub ecfg: expand::ExpansionConfig<'a>,
+ pub reduced_recursion_limit: Option<usize>,
  pub root_path: PathBuf,
  pub resolver: &'a mut dyn Resolver,
  pub current_expansion: ExpansionData,
@@ -936,6 +937,7 @@ impl<'a> ExtCtxt<'a> {
  ExtCtxt {
  parse_sess,
  ecfg,
+ reduced_recursion_limit: None,
  root_path: PathBuf::new(),
  resolver,
  current_expansion: ExpansionData {

src/librustc_expand/expand.rs

@@ -15,7 +15,7 @@ use rustc_ast::util::map_in_place::MapInPlace;
 use rustc_ast::visit::{self, AssocCtxt, Visitor};
 use rustc_ast_pretty::pprust;
 use rustc_attr::{self as attr, is_builtin_attr, HasAttrs};
-use rustc_errors::{Applicability, FatalError, PResult};
+use rustc_errors::{Applicability, PResult};
 use rustc_feature::Features;
 use rustc_parse::configure;
 use rustc_parse::parser::Parser;
@@ -645,7 +645,6 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
  ))
  .emit();
  self.cx.trace_macros_diag();
- FatalError.raise();
  }
 
  /// A macro's expansion does not fit in this fragment kind.
@@ -665,8 +664,17 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
  invoc: Invocation,
  ext: &SyntaxExtensionKind,
  ) -> ExpandResult<AstFragment, Invocation> {
- if self.cx.current_expansion.depth > self.cx.ecfg.recursion_limit {
- self.error_recursion_limit_reached();
+ let recursion_limit =
+ self.cx.reduced_recursion_limit.unwrap_or(self.cx.ecfg.recursion_limit);
+ if self.cx.current_expansion.depth > recursion_limit {
+ if self.cx.reduced_recursion_limit.is_none() {
+ self.error_recursion_limit_reached();
+ }
+
+ // Reduce the recursion limit by half each time it triggers.
+ self.cx.reduced_recursion_limit = Some(recursion_limit / 2);
+
+ return ExpandResult::Ready(invoc.fragment_kind.dummy(invoc.span()));
  }
 
  let (fragment_kind, span) = (invoc.fragment_kind, invoc.span());

src/librustc_hir/hir_id.rs

@@ -71,7 +71,7 @@ rustc_data_structures::impl_stable_hash_via_hash!(ItemLocalId);
 
 /// The `HirId` corresponding to `CRATE_NODE_ID` and `CRATE_DEF_INDEX`.
 pub const CRATE_HIR_ID: HirId =
- HirId { owner: CRATE_DEF_INDEX, local_id: ItemLocalId::from_u32_const(0) };
+ HirId { owner: CRATE_DEF_INDEX, local_id: ItemLocalId::from_u32(0) };
 
 pub const DUMMY_HIR_ID: HirId = HirId { owner: CRATE_DEF_INDEX, local_id: DUMMY_ITEM_LOCAL_ID };
 

src/librustc_hir/lib.rs

@@ -3,7 +3,9 @@
 //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/hir.html
 
 #![feature(crate_visibility_modifier)]
+#![feature(const_if_match)]
 #![feature(const_fn)] // For the unsizing cast on `&[]`
+#![feature(const_panic)]
 #![feature(in_band_lifetimes)]
 #![feature(specialization)]
 #![recursion_limit = "256"]

src/librustc_index/lib.rs

@@ -1,4 +1,7 @@
 #![feature(allow_internal_unstable)]
+#![feature(const_if_match)]
+#![feature(const_fn)]
+#![feature(const_panic)]
 #![feature(unboxed_closures)]
 #![feature(test)]
 #![feature(fn_traits)]

src/librustc_index/vec.rs

@@ -120,62 +120,44 @@ macro_rules! newtype_index {
  impl $type {
  $v const MAX_AS_U32: u32 = $max;
 
- $v const MAX: Self = Self::from_u32_const($max);
+ $v const MAX: Self = Self::from_u32($max);
 
  #[inline]
- $v fn from_usize(value: usize) -> Self {
+ $v const fn from_usize(value: usize) -> Self {
  assert!(value <= ($max as usize));
  unsafe {
  Self::from_u32_unchecked(value as u32)
  }
  }
 
  #[inline]
- $v fn from_u32(value: u32) -> Self {
+ $v const fn from_u32(value: u32) -> Self {
  assert!(value <= $max);
  unsafe {
  Self::from_u32_unchecked(value)
  }
  }
 
- /// Hacky variant of `from_u32` for use in constants.
- /// This version checks the "max" constraint by using an
- /// invalid array dereference.
- #[inline]
- $v const fn from_u32_const(value: u32) -> Self {
- // This will fail at const eval time unless `value <=
- // max` is true (in which case we get the index 0).
- // It will also fail at runtime, of course, but in a
- // kind of wacky way.
- let _ = ["out of range value used"][
- !(value <= $max) as usize
- ];
-
- unsafe {
- Self { private: value }
- }
- }
-
  #[inline]
  $v const unsafe fn from_u32_unchecked(value: u32) -> Self {
  Self { private: value }
  }
 
  /// Extracts the value of this index as an integer.
  #[inline]
- $v fn index(self) -> usize {
+ $v const fn index(self) -> usize {
  self.as_usize()
  }
 
  /// Extracts the value of this index as a `u32`.
  #[inline]
- $v fn as_u32(self) -> u32 {
+ $v const fn as_u32(self) -> u32 {
  self.private
  }
 
  /// Extracts the value of this index as a `usize`.
  #[inline]
- $v fn as_usize(self) -> usize {
+ $v const fn as_usize(self) -> usize {
  self.as_u32() as usize
  }
  }
@@ -500,7 +482,7 @@ macro_rules! newtype_index {
  const $name:ident = $constant:expr,
  $($tokens:tt)*) => (
  $(#[doc = $doc])*
- $v const $name: $type = $type::from_u32_const($constant);
+ $v const $name: $type = $type::from_u32($constant);
  $crate::newtype_index!(
  @derives [$($derives,)*]
  @attrs [$(#[$attrs])*]

src/librustc_infer/infer/error_reporting/mod.rs

@@ -49,7 +49,7 @@ use super::lexical_region_resolve::RegionResolutionError;
 use super::region_constraints::GenericKind;
 use super::{InferCtxt, RegionVariableOrigin, SubregionOrigin, TypeTrace, ValuePairs};
 
-use crate::infer::{self, SuppressRegionErrors};
+use crate::infer;
 use crate::traits::error_reporting::report_object_safety_error;
 use crate::traits::{
  IfExpressionCause, MatchExpressionArmCause, ObligationCause, ObligationCauseCode,
@@ -372,17 +372,8 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  &self,
  region_scope_tree: &region::ScopeTree,
  errors: &Vec<RegionResolutionError<'tcx>>,
- suppress: SuppressRegionErrors,
  ) {
- debug!(
- "report_region_errors(): {} errors to start, suppress = {:?}",
- errors.len(),
- suppress
- );
-
- if suppress.suppressed() {
- return;
- }
+ debug!("report_region_errors(): {} errors to start", errors.len());
 
  // try to pre-process the errors, which will group some of them
  // together into a `ProcessedErrors` group:

src/librustc_infer/infer/error_reporting/nice_region_error/different_lifetimes.rs

@@ -3,6 +3,8 @@
 
 use crate::infer::error_reporting::nice_region_error::util::AnonymousParamInfo;
 use crate::infer::error_reporting::nice_region_error::NiceRegionError;
+use crate::infer::lexical_region_resolve::RegionResolutionError;
+use crate::infer::SubregionOrigin;
 use rustc::util::common::ErrorReported;
 
 use rustc_errors::struct_span_err;
@@ -47,6 +49,15 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
  pub(super) fn try_report_anon_anon_conflict(&self) -> Option<ErrorReported> {
  let (span, sub, sup) = self.regions()?;
 
+ if let Some(RegionResolutionError::ConcreteFailure(
+ SubregionOrigin::ReferenceOutlivesReferent(..),
+ ..,
+ )) = self.error
+ {
+ // This error doesn't make much sense in this case.
+ return None;
+ }
+
  // Determine whether the sub and sup consist of both anonymous (elided) regions.
  let anon_reg_sup = self.tcx().is_suitable_region(sup)?;