Rollup of 9 pull requests

compiler/rustc_expand/src/expand.rs

@@ -301,6 +301,8 @@ pub enum InvocationKind {
  },
  Attr {
  attr: ast::Attribute,
+ // Re-insertion position for inert attributes.
+ pos: usize,
  item: Annotatable,
  // Required for resolving derive helper attributes.
  derives: Vec<Path>,
@@ -690,7 +692,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
  }
  _ => unreachable!(),
  },
- InvocationKind::Attr { attr, mut item, derives } => match ext {
+ InvocationKind::Attr { attr, pos, mut item, derives } => match ext {
  SyntaxExtensionKind::Attr(expander) => {
  self.gate_proc_macro_input(&item);
  self.gate_proc_macro_attr_item(span, &item);
@@ -721,7 +723,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
  ExpandResult::Retry(item) => {
  // Reassemble the original invocation for retrying.
  return ExpandResult::Retry(Invocation {
- kind: InvocationKind::Attr { attr, item, derives },
+ kind: InvocationKind::Attr { attr, pos, item, derives },
  ..invoc
  });
  }
@@ -739,7 +741,7 @@ impl<'a, 'b> MacroExpander<'a, 'b> {
  if *mark_used {
  self.cx.sess.mark_attr_used(&attr);
  }
- item.visit_attrs(|attrs| attrs.push(attr));
+ item.visit_attrs(|attrs| attrs.insert(pos, attr));
  fragment_kind.expect_from_annotatables(iter::once(item))
  }
  _ => unreachable!(),
@@ -1000,17 +1002,20 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
 
  fn collect_attr(
  &mut self,
- (attr, derives): (ast::Attribute, Vec<Path>),
+ (attr, pos, derives): (ast::Attribute, usize, Vec<Path>),
  item: Annotatable,
  kind: AstFragmentKind,
  ) -> AstFragment {
- self.collect(kind, InvocationKind::Attr { attr, item, derives })
+ self.collect(kind, InvocationKind::Attr { attr, pos, item, derives })
  }
 
  /// If `item` is an attribute invocation, remove the attribute and return it together with
- /// derives following it. We have to collect the derives in order to resolve legacy derive
- /// helpers (helpers written before derives that introduce them).
- fn take_first_attr(&mut self, item: &mut impl HasAttrs) -> Option<(ast::Attribute, Vec<Path>)> {
+ /// its position and derives following it. We have to collect the derives in order to resolve
+ /// legacy derive helpers (helpers written before derives that introduce them).
+ fn take_first_attr(
+ &mut self,
+ item: &mut impl HasAttrs,
+ ) -> Option<(ast::Attribute, usize, Vec<Path>)> {
  let mut attr = None;
 
  item.visit_attrs(|attrs| {
@@ -1033,7 +1038,7 @@ impl<'a, 'b> InvocationCollector<'a, 'b> {
  })
  .collect();
 
- (attr, following_derives)
+ (attr, attr_pos, following_derives)
  })
  });
 

compiler/rustc_infer/src/infer/error_reporting/mod.rs

@@ -50,6 +50,7 @@ use super::region_constraints::GenericKind;
 use super::{InferCtxt, RegionVariableOrigin, SubregionOrigin, TypeTrace, ValuePairs};
 
 use crate::infer;
+use crate::infer::error_reporting::nice_region_error::find_anon_type::find_anon_type;
 use crate::traits::error_reporting::report_object_safety_error;
 use crate::traits::{
  IfExpressionCause, MatchExpressionArmCause, ObligationCause, ObligationCauseCode,
@@ -179,7 +180,14 @@ fn msg_span_from_early_bound_and_free_regions(
  }
  ty::ReFree(ref fr) => match fr.bound_region {
  ty::BrAnon(idx) => {
- (format!("the anonymous lifetime #{} defined on", idx + 1), tcx.hir().span(node))
+ if let Some((ty, _)) = find_anon_type(tcx, region, &fr.bound_region) {
+ ("the anonymous lifetime defined on".to_string(), ty.span)
+ } else {
+ (
+ format!("the anonymous lifetime #{} defined on", idx + 1),
+ tcx.hir().span(node),
+ )
+ }
  }
  _ => (
  format!("the lifetime `{}` as defined on", region),
@@ -1484,13 +1492,16 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  for (key, values) in types.iter() {
  let count = values.len();
  let kind = key.descr();
+ let mut returned_async_output_error = false;
  for sp in values {
  err.span_label(
  *sp,
  format!(
  "{}{}{} {}{}",
- if sp.is_desugaring(DesugaringKind::Async) {
- "the `Output` of this `async fn`'s "
+ if sp.is_desugaring(DesugaringKind::Async)
+ && !returned_async_output_error
+ {
+ "checked the `Output` of this `async fn`, "
  } else if count == 1 {
  "the "
  } else {
@@ -1502,6 +1513,12 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
  pluralize!(count),
  ),
  );
+ if sp.is_desugaring(DesugaringKind::Async)
+ && returned_async_output_error == false
+ {
+ err.note("while checking the return type of the `async fn`");
+ returned_async_output_error = true;
+ }
  }
  }
  }

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/different_lifetimes.rs

@@ -1,6 +1,7 @@
 //! Error Reporting for Anonymous Region Lifetime Errors
 //! where both the regions are anonymous.
 
+use crate::infer::error_reporting::nice_region_error::find_anon_type::find_anon_type;
 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;
@@ -66,9 +67,9 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
  let scope_def_id_sub = anon_reg_sub.def_id;
  let bregion_sub = anon_reg_sub.boundregion;
 
- let ty_sup = self.find_anon_type(sup, &bregion_sup)?;
+ let ty_sup = find_anon_type(self.tcx(), sup, &bregion_sup)?;
 
- let ty_sub = self.find_anon_type(sub, &bregion_sub)?;
+ let ty_sub = find_anon_type(self.tcx(), sub, &bregion_sub)?;
 
  debug!(
  "try_report_anon_anon_conflict: found_param1={:?} sup={:?} br1={:?}",

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/find_anon_type.rs

@@ -1,72 +1,68 @@
-use crate::infer::error_reporting::nice_region_error::NiceRegionError;
 use rustc_hir as hir;
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::Node;
 use rustc_middle::hir::map::Map;
 use rustc_middle::middle::resolve_lifetime as rl;
 use rustc_middle::ty::{self, Region, TyCtxt};
 
-impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
- /// This function calls the `visit_ty` method for the parameters
- /// corresponding to the anonymous regions. The `nested_visitor.found_type`
- /// contains the anonymous type.
- ///
- /// # Arguments
- /// region - the anonymous region corresponding to the anon_anon conflict
- /// br - the bound region corresponding to the above region which is of type `BrAnon(_)`
- ///
- /// # Example
- /// ```
- /// fn foo(x: &mut Vec<&u8>, y: &u8)
- /// { x.push(y); }
- /// ```
- /// The function returns the nested type corresponding to the anonymous region
- /// for e.g., `&u8` and Vec<`&u8`.
- pub(super) fn find_anon_type(
- &self,
- region: Region<'tcx>,
- br: &ty::BoundRegionKind,
- ) -> Option<(&hir::Ty<'tcx>, &hir::FnDecl<'tcx>)> {
- if let Some(anon_reg) = self.tcx().is_suitable_region(region) {
- let hir_id = self.tcx().hir().local_def_id_to_hir_id(anon_reg.def_id);
- let fndecl = match self.tcx().hir().get(hir_id) {
- Node::Item(&hir::Item { kind: hir::ItemKind::Fn(ref m, ..), .. })
- | Node::TraitItem(&hir::TraitItem {
- kind: hir::TraitItemKind::Fn(ref m, ..),
- ..
- })
- | Node::ImplItem(&hir::ImplItem {
- kind: hir::ImplItemKind::Fn(ref m, ..), ..
- }) => &m.decl,
- _ => return None,
- };
+/// This function calls the `visit_ty` method for the parameters
+/// corresponding to the anonymous regions. The `nested_visitor.found_type`
+/// contains the anonymous type.
+///
+/// # Arguments
+/// region - the anonymous region corresponding to the anon_anon conflict
+/// br - the bound region corresponding to the above region which is of type `BrAnon(_)`
+///
+/// # Example
+/// ```
+/// fn foo(x: &mut Vec<&u8>, y: &u8)
+/// { x.push(y); }
+/// ```
+/// The function returns the nested type corresponding to the anonymous region
+/// for e.g., `&u8` and Vec<`&u8`.
+pub(crate) fn find_anon_type(
+ tcx: TyCtxt<'tcx>,
+ region: Region<'tcx>,
+ br: &ty::BoundRegionKind,
+) -> Option<(&'tcx hir::Ty<'tcx>, &'tcx hir::FnDecl<'tcx>)> {
+ if let Some(anon_reg) = tcx.is_suitable_region(region) {
+ let hir_id = tcx.hir().local_def_id_to_hir_id(anon_reg.def_id);
+ let fndecl = match tcx.hir().get(hir_id) {
+ Node::Item(&hir::Item { kind: hir::ItemKind::Fn(ref m, ..), .. })
+ | Node::TraitItem(&hir::TraitItem {
+ kind: hir::TraitItemKind::Fn(ref m, ..), ..
+ })
+ | Node::ImplItem(&hir::ImplItem { kind: hir::ImplItemKind::Fn(ref m, ..), .. }) => {
+ &m.decl
+ }
+ _ => return None,
+ };
 
- fndecl
- .inputs
- .iter()
- .find_map(|arg| self.find_component_for_bound_region(arg, br))
- .map(|ty| (ty, &**fndecl))
- } else {
- None
- }
+ fndecl
+ .inputs
+ .iter()
+ .find_map(|arg| find_component_for_bound_region(tcx, arg, br))
+ .map(|ty| (ty, &**fndecl))
+ } else {
+ None
  }
+}
 
- // This method creates a FindNestedTypeVisitor which returns the type corresponding
- // to the anonymous region.
- fn find_component_for_bound_region(
- &self,
- arg: &'tcx hir::Ty<'tcx>,
- br: &ty::BoundRegionKind,
- ) -> Option<&'tcx hir::Ty<'tcx>> {
- let mut nested_visitor = FindNestedTypeVisitor {
- tcx: self.tcx(),
- bound_region: *br,
- found_type: None,
- current_index: ty::INNERMOST,
- };
- nested_visitor.visit_ty(arg);
- nested_visitor.found_type
- }
+// This method creates a FindNestedTypeVisitor which returns the type corresponding
+// to the anonymous region.
+fn find_component_for_bound_region(
+ tcx: TyCtxt<'tcx>,
+ arg: &'tcx hir::Ty<'tcx>,
+ br: &ty::BoundRegionKind,
+) -> Option<&'tcx hir::Ty<'tcx>> {
+ let mut nested_visitor = FindNestedTypeVisitor {
+ tcx,
+ bound_region: *br,
+ found_type: None,
+ current_index: ty::INNERMOST,
+ };
+ nested_visitor.visit_ty(arg);
+ nested_visitor.found_type
 }
 
 // The FindNestedTypeVisitor captures the corresponding `hir::Ty` of the

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/mod.rs

@@ -6,7 +6,7 @@ use rustc_middle::ty::{self, TyCtxt};
 use rustc_span::source_map::Span;
 
 mod different_lifetimes;
-mod find_anon_type;
+pub mod find_anon_type;
 mod named_anon_conflict;
 mod placeholder_error;
 mod static_impl_trait;

compiler/rustc_infer/src/infer/error_reporting/nice_region_error/named_anon_conflict.rs

@@ -1,5 +1,6 @@
 //! Error Reporting for Anonymous Region Lifetime Errors
 //! where one region is named and the other is anonymous.
+use crate::infer::error_reporting::nice_region_error::find_anon_type::find_anon_type;
 use crate::infer::error_reporting::nice_region_error::NiceRegionError;
 use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder};
 use rustc_hir::intravisit::Visitor;
@@ -74,7 +75,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> {
  return None;
  }
 
- if let Some((_, fndecl)) = self.find_anon_type(anon, &br) {
+ if let Some((_, fndecl)) = find_anon_type(self.tcx(), anon, &br) {
  if self.is_self_anon(is_first, scope_def_id) {
  return None;
  }

compiler/rustc_interface/src/tests.rs

@@ -557,8 +557,9 @@ fn test_debugging_options_tracking_hash() {
  tracked!(function_sections, Some(false));
  tracked!(human_readable_cgu_names, true);
  tracked!(inline_in_all_cgus, Some(true));
- tracked!(inline_mir_threshold, 123);
- tracked!(inline_mir_hint_threshold, 123);
+ tracked!(inline_mir, Some(true));
+ tracked!(inline_mir_threshold, Some(123));
+ tracked!(inline_mir_hint_threshold, Some(123));
  tracked!(insert_sideeffect, true);
  tracked!(instrument_coverage, true);
  tracked!(instrument_mcount, true);

compiler/rustc_mir/src/transform/inline.rs

@@ -37,21 +37,27 @@ struct CallSite<'tcx> {
  source_info: SourceInfo,
 }
 
+/// Returns true if MIR inlining is enabled in the current compilation session.
+crate fn is_enabled(tcx: TyCtxt<'_>) -> bool {
+ if tcx.sess.opts.debugging_opts.instrument_coverage {
+ // Since `Inline` happens after `InstrumentCoverage`, the function-specific coverage
+ // counters can be invalidated, such as by merging coverage counter statements from
+ // a pre-inlined function into a different function. This kind of change is invalid,
+ // so inlining must be skipped. Note: This check is performed here so inlining can
+ // be disabled without preventing other optimizations (regardless of `mir_opt_level`).
+ return false;
+ }
+
+ if let Some(enabled) = tcx.sess.opts.debugging_opts.inline_mir {
+ return enabled;
+ }
+
+ tcx.sess.opts.debugging_opts.mir_opt_level >= 2
+}
+
 impl<'tcx> MirPass<'tcx> for Inline {
  fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
- // If you change this optimization level, also change the level in
- // `mir_drops_elaborated_and_const_checked` for the call to `mir_inliner_callees`.
- // Otherwise you will get an ICE about stolen MIR.
- if tcx.sess.opts.debugging_opts.mir_opt_level < 2 {
- return;
- }
-
- if tcx.sess.opts.debugging_opts.instrument_coverage {
- // Since `Inline` happens after `InstrumentCoverage`, the function-specific coverage
- // counters can be invalidated, such as by merging coverage counter statements from
- // a pre-inlined function into a different function. This kind of change is invalid,
- // so inlining must be skipped. Note: This check is performed here so inlining can
- // be disabled without preventing other optimizations (regardless of `mir_opt_level`).
+ if !is_enabled(tcx) {
  return;
  }
 
@@ -310,9 +316,9 @@ impl Inliner<'tcx> {
  }
 
  let mut threshold = if hinted {
- self.tcx.sess.opts.debugging_opts.inline_mir_hint_threshold
+ self.tcx.sess.opts.debugging_opts.inline_mir_hint_threshold.unwrap_or(100)
  } else {
- self.tcx.sess.opts.debugging_opts.inline_mir_threshold
+ self.tcx.sess.opts.debugging_opts.inline_mir_threshold.unwrap_or(50)
  };
 
  if codegen_fn_attrs.flags.contains(CodegenFnAttrFlags::NAKED) {

compiler/rustc_mir/src/transform/mod.rs

@@ -429,8 +429,7 @@ fn mir_drops_elaborated_and_const_checked<'tcx>(
  let def = ty::WithOptConstParam::unknown(did);
 
  // Do not compute the mir call graph without said call graph actually being used.
- // Keep this in sync with the mir inliner's optimization level.
- if tcx.sess.opts.debugging_opts.mir_opt_level >= 2 {
+ if inline::is_enabled(tcx) {
  let _ = tcx.mir_inliner_callees(ty::InstanceDef::Item(def));
  }
  }

compiler/rustc_session/src/options.rs

@@ -957,9 +957,11 @@ options! {DebuggingOptions, DebuggingSetter, basic_debugging_options,
  (default: no)"),
  incremental_verify_ich: bool = (false, parse_bool, [UNTRACKED],
  "verify incr. comp. hashes of green query instances (default: no)"),
- inline_mir_threshold: usize = (50, parse_uint, [TRACKED],
+ inline_mir: Option<bool> = (None, parse_opt_bool, [TRACKED],
+ "enable MIR inlining (default: no)"),
+ inline_mir_threshold: Option<usize> = (None, parse_opt_uint, [TRACKED],
  "a default MIR inlining threshold (default: 50)"),
- inline_mir_hint_threshold: usize = (100, parse_uint, [TRACKED],
+ inline_mir_hint_threshold: Option<usize> = (None, parse_opt_uint, [TRACKED],
  "inlining threshold for functions with inline hint (default: 100)"),
  inline_in_all_cgus: Option<bool> = (None, parse_opt_bool, [TRACKED],
  "control whether `#[inline]` functions are in all CGUs"),