Auto merge of rust-lang#108211 - matthiaskrgr:rollup-e59onmm, r=matth…

…iaskrgr Rollup of 6 pull requests Successful merges: - rust-lang#108031 (Don't recover lifetimes/labels containing emojis as character literals) - rust-lang#108046 (Don't allow evaluating queries that were fed in a previous compiler run) - rust-lang#108162 (Don't eagerly convert principal to string) - rust-lang#108186 (Deny non-lifetime bound vars in `for<..> ||` closure binders) - rust-lang#108197 (Update cargo) - rust-lang#108205 (link to llvm changes that prompted the special cases) Failed merges: r? `@ghost` `@rustbot` modify labels: rollup
rust-lang-ci · Feb 18, 2023 · 3eb5c45 · 3eb5c45
2 parents 3701bdc 6c91efd
commit 3eb5c45
Show file tree

Hide file tree

Showing 39 changed files with 428 additions and 158 deletions.
diff --git a/Cargo.lock b/Cargo.lock
@@ -782,7 782,7 @@ dependencies = [
  "declare_clippy_lint",
  "if_chain",
  "itertools",
- "pulldown-cmark 0.9.2",
  "pulldown-cmark",
  "quine-mc_cluskey",
  "regex-syntax",
  "rustc-semver",
@@ -2555,7 2555,7 @@ dependencies = [
  "memchr",
  "once_cell",
  "opener",
- "pulldown-cmark 0.9.2",
  "pulldown-cmark",
  "regex",
  "serde",
  "serde_json",
@@ -2572,7 2572,7 @@ dependencies = [
  "anyhow",
  "handlebars 3.5.5",
  "pretty_assertions",
- "pulldown-cmark 0.7.2",
  "pulldown-cmark",
  "same-file",
  "serde_json",
  "url",
@@ -3269,17 3269,6 @@ dependencies = [
  "cc",
 ]
 
-[[package]]
-name = "pulldown-cmark"
-version = "0.7.2"
-source = "registry https://github.com/rust-lang/crates.io-index"
-checksum = "ca36dea94d187597e104a5c8e4b07576a8a45aa5db48a65e12940d3eb7461f55"
-dependencies = [
- "bitflags",
- "memchr",
- "unicase",
-]
-
 [[package]]
 name = "pulldown-cmark"
 version = "0.9.2"
@@ -4583,7 4572,7 @@ name = "rustc_resolve"
 version = "0.0.0"
 dependencies = [
  "bitflags",
- "pulldown-cmark 0.9.2",
  "pulldown-cmark",
  "rustc_arena",
  "rustc_ast",
  "rustc_ast_pretty",

diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
@@ -145,8 145,13 @@ pub unsafe fn create_module<'ll>(
  let llvm_version = llvm_util::get_version();
  if llvm_version < (16, 0, 0) {
  if sess.target.arch == "s390x" {
  // LLVM 16 data layout changed to always set 64-bit vector alignment,
  // which is conditional in earlier LLVM versions.
  // https://reviews.llvm.org/D131158 for the discussion.
  target_data_layout = target_data_layout.replace("-v128:64", "");
  } else if sess.target.arch == "riscv64" {
  // LLVM 16 introduced this change so as to produce more efficient code.
  // See https://reviews.llvm.org/D116735 for the discussion.
  target_data_layout = target_data_layout.replace("-n32:64-", "-n64-");
  }
  }

diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
@@ -471,6 471,8 @@ pub enum StashKey {
  /// When an invalid lifetime e.g. `'2` should be reinterpreted
  /// as a char literal in the parser
  LifetimeIsChar,
  /// When an invalid lifetime e.g. `'🐱` contains emoji.
  LifetimeContainsEmoji,
  /// Maybe there was a typo where a comma was forgotten before
  /// FRU syntax
  MaybeFruTypo,

diff --git a/compiler/rustc_feature/src/active.rs b/compiler/rustc_feature/src/active.rs
@@ -474,7 474,7 @@ declare_features! (
  /// Allows using the `non_exhaustive_omitted_patterns` lint.
  (active, non_exhaustive_omitted_patterns_lint, "1.57.0", Some(89554), None),
  /// Allows `for<T>` binders in where-clauses
- (incomplete, non_lifetime_binders, "CURRENT_RUSTC_VERSION", Some(1), None),
  (incomplete, non_lifetime_binders, "CURRENT_RUSTC_VERSION", Some(108185), None),
  /// Allows making `dyn Trait` well-formed even if `Trait` is not object safe.
  /// In that case, `dyn Trait: Trait` does not hold. Moreover, coercions and
  /// casts in safe Rust to `dyn Trait` for such a `Trait` is also forbidden.

diff --git a/compiler/rustc_hir_analysis/src/astconv/mod.rs b/compiler/rustc_hir_analysis/src/astconv/mod.rs
@@ -252,6 252,10 @@ impl<'o, 'tcx> dyn AstConv<'tcx> 'o {
  // (*) -- not late-bound, won't change
  }
 
  Some(rbv::ResolvedArg::Error(_)) => {
  bug!("only ty/ct should resolve as ResolvedArg::Error")
  }
 
  None => {
  self.re_infer(def, lifetime.ident.span).unwrap_or_else(|| {
  debug!(?lifetime, "unelided lifetime in signature");
@@ -2689,6 2693,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> 'o {
  let index = generics.param_def_id_to_index[&def_id.to_def_id()];
  tcx.mk_ty_param(index, tcx.hir().ty_param_name(def_id))
  }
  Some(rbv::ResolvedArg::Error(guar)) => tcx.ty_error_with_guaranteed(guar),
  arg => bug!("unexpected bound var resolution for {hir_id:?}: {arg:?}"),
  }
  }
@@ -2893,22 2898,14 @@ impl<'o, 'tcx> dyn AstConv<'tcx> 'o {
  hir::TyKind::BareFn(bf) => {
  require_c_abi_if_c_variadic(tcx, bf.decl, bf.abi, ast_ty.span);
 
- let fn_ptr_ty = tcx.mk_fn_ptr(self.ty_of_fn(
  tcx.mk_fn_ptr(self.ty_of_fn(
  ast_ty.hir_id,
  bf.unsafety,
  bf.abi,
  bf.decl,
  None,
  Some(ast_ty),
- ));
-
- if let Some(guar) =
- deny_non_region_late_bound(tcx, bf.generic_params, "function pointer")
- {
- tcx.ty_error_with_guaranteed(guar)
- } else {
- fn_ptr_ty
- }
  ))
  }
  hir::TyKind::TraitObject(bounds, lifetime, repr) => {
  self.maybe_lint_bare_trait(ast_ty, in_path);
@@ -2917,21 2914,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> 'o {
  TraitObjectSyntax::DynStar => ty::DynStar,
  };
 
- let object_ty = self.conv_object_ty_poly_trait_ref(
- ast_ty.span,
- bounds,
- lifetime,
- borrowed,
- repr,
- );
-
- if let Some(guar) = bounds.iter().find_map(|trait_ref| {
- deny_non_region_late_bound(tcx, trait_ref.bound_generic_params, "trait object")
- }) {
- tcx.ty_error_with_guaranteed(guar)
- } else {
- object_ty
- }
  self.conv_object_ty_poly_trait_ref(ast_ty.span, bounds, lifetime, borrowed, repr)
  }
  hir::TyKind::Path(hir::QPath::Resolved(maybe_qself, path)) => {
  debug!(?maybe_qself, ?path);
@@ -3392,24 3375,3 @@ impl<'o, 'tcx> dyn AstConv<'tcx> 'o {
  }
  }
 }
-
-fn deny_non_region_late_bound(
- tcx: TyCtxt<'_>,
- params: &[hir::GenericParam<'_>],
- where_: &str,
-) -> Option<ErrorGuaranteed> {
- params.iter().find_map(|bad_param| {
- let what = match bad_param.kind {
- hir::GenericParamKind::Type { .. } => "type",
- hir::GenericParamKind::Const { .. } => "const",
- hir::GenericParamKind::Lifetime { .. } => return None,
- };
-
- let mut diag = tcx.sess.struct_span_err(
- bad_param.span,
- format!("late-bound {what} parameter not allowed on {where_} types"),
- );
-
- Some(if tcx.features().non_lifetime_binders { diag.emit() } else { diag.delay_as_bug() })
- })
-}
diff --git a/compiler/rustc_hir_analysis/src/collect/generics_of.rs b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
@@ -398,7 398,12 @@ fn has_late_bound_regions<'tcx>(tcx: TyCtxt<'tcx>, node: Node<'tcx>) -> Option<S
  Some(rbv::ResolvedArg::StaticLifetime | rbv::ResolvedArg::EarlyBound(..)) => {}
  Some(rbv::ResolvedArg::LateBound(debruijn, _, _))
  if debruijn < self.outer_index => {}
- Some(rbv::ResolvedArg::LateBound(..) | rbv::ResolvedArg::Free(..)) | None => {
  Some(
  rbv::ResolvedArg::LateBound(..)
  | rbv::ResolvedArg::Free(..)
  | rbv::ResolvedArg::Error(_),
  )
  | None => {
  self.has_late_bound_regions = Some(lt.ident.span);
  }
  }

diff --git a/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs b/compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs
@@ -50,7 50,7 @@ impl RegionExt for ResolvedArg {
 
  fn id(&self) -> Option<DefId> {
  match *self {
- ResolvedArg::StaticLifetime => None,
  ResolvedArg::StaticLifetime | ResolvedArg::Error(_) => None,
 
  ResolvedArg::EarlyBound(id)
  | ResolvedArg::LateBound(_, _, id)
@@ -336,7 336,57 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
  }
  }
  }
 
  fn visit_poly_trait_ref_inner(
  &mut self,
  trait_ref: &'tcx hir::PolyTraitRef<'tcx>,
  non_lifetime_binder_allowed: NonLifetimeBinderAllowed,
  ) {
  debug!("visit_poly_trait_ref(trait_ref={:?})", trait_ref);
 
  let (mut binders, scope_type) = self.poly_trait_ref_binder_info();
 
  let initial_bound_vars = binders.len() as u32;
  let mut bound_vars: FxIndexMap<LocalDefId, ResolvedArg> = FxIndexMap::default();
  let binders_iter =
  trait_ref.bound_generic_params.iter().enumerate().map(|(late_bound_idx, param)| {
  let pair = ResolvedArg::late(initial_bound_vars late_bound_idx as u32, param);
  let r = late_arg_as_bound_arg(self.tcx, &pair.1, param);
  bound_vars.insert(pair.0, pair.1);
  r
  });
  binders.extend(binders_iter);
 
  if let NonLifetimeBinderAllowed::Deny(where_) = non_lifetime_binder_allowed {
  deny_non_region_late_bound(self.tcx, &mut bound_vars, where_);
  }
 
  debug!(?binders);
  self.record_late_bound_vars(trait_ref.trait_ref.hir_ref_id, binders);
 
  // Always introduce a scope here, even if this is in a where clause and
  // we introduced the binders around the bounded Ty. In that case, we
  // just reuse the concatenation functionality also present in nested trait
  // refs.
  let scope = Scope::Binder {
  hir_id: trait_ref.trait_ref.hir_ref_id,
  bound_vars,
  s: self.scope,
  scope_type,
  where_bound_origin: None,
  };
  self.with(scope, |this| {
  walk_list!(this, visit_generic_param, trait_ref.bound_generic_params);
  this.visit_trait_ref(&trait_ref.trait_ref);
  });
  }
 }
 
 enum NonLifetimeBinderAllowed {
  Deny(&'static str),
  Allow,
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
  type NestedFilter = nested_filter::OnlyBodies;
 
@@ -400,7 450,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
  }
  }
 
- let (bound_vars, binders): (FxIndexMap<LocalDefId, ResolvedArg>, Vec<_>) =
  let (mut bound_vars, binders): (FxIndexMap<LocalDefId, ResolvedArg>, Vec<_>) =
  bound_generic_params
  .iter()
  .enumerate()
@@ -411,6 461,8 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
  })
  .unzip();
 
  deny_non_region_late_bound(self.tcx, &mut bound_vars, "closures");
 
  self.record_late_bound_vars(e.hir_id, binders);
  let scope = Scope::Binder {
  hir_id: e.hir_id,
@@ -567,7 619,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
  fn visit_ty(&mut self, ty: &'tcx hir::Ty<'tcx>) {
  match ty.kind {
  hir::TyKind::BareFn(c) => {
- let (bound_vars, binders): (FxIndexMap<LocalDefId, ResolvedArg>, Vec<_>) = c
  let (mut bound_vars, binders): (FxIndexMap<LocalDefId, ResolvedArg>, Vec<_>) = c
  .generic_params
  .iter()
  .enumerate()
@@ -577,6 629,9 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
  (pair, r)
  })
  .unzip();
 
  deny_non_region_late_bound(self.tcx, &mut bound_vars, "function pointer types");
 
  self.record_late_bound_vars(ty.hir_id, binders);
  let scope = Scope::Binder {
  hir_id: ty.hir_id,
@@ -596,7 651,10 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
  let scope = Scope::TraitRefBoundary { s: self.scope };
  self.with(scope, |this| {
  for bound in bounds {
- this.visit_poly_trait_ref(bound);
  this.visit_poly_trait_ref_inner(
  bound,
  NonLifetimeBinderAllowed::Deny("trait object types"),
  );
  }
  });
  match lifetime.res {
@@ -967,39 1025,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
  }
 
  fn visit_poly_trait_ref(&mut self, trait_ref: &'tcx hir::PolyTraitRef<'tcx>) {
- debug!("visit_poly_trait_ref(trait_ref={:?})", trait_ref);
-
- let (mut binders, scope_type) = self.poly_trait_ref_binder_info();
-
- let initial_bound_vars = binders.len() as u32;
- let mut bound_vars: FxIndexMap<LocalDefId, ResolvedArg> = FxIndexMap::default();
- let binders_iter =
- trait_ref.bound_generic_params.iter().enumerate().map(|(late_bound_idx, param)| {
- let pair = ResolvedArg::late(initial_bound_vars late_bound_idx as u32, param);
- let r = late_arg_as_bound_arg(self.tcx, &pair.1, param);
- bound_vars.insert(pair.0, pair.1);
- r
- });
- binders.extend(binders_iter);
-
- debug!(?binders);
- self.record_late_bound_vars(trait_ref.trait_ref.hir_ref_id, binders);
-
- // Always introduce a scope here, even if this is in a where clause and
- // we introduced the binders around the bounded Ty. In that case, we
- // just reuse the concatenation functionality also present in nested trait
- // refs.
- let scope = Scope::Binder {
- hir_id: trait_ref.trait_ref.hir_ref_id,
- bound_vars,
- s: self.scope,
- scope_type,
- where_bound_origin: None,
- };
- self.with(scope, |this| {
- walk_list!(this, visit_generic_param, trait_ref.bound_generic_params);
- this.visit_trait_ref(&trait_ref.trait_ref);
- });
  self.visit_poly_trait_ref_inner(trait_ref, NonLifetimeBinderAllowed::Allow);
  }
 }
 
@@ -1364,7 1390,9 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
  return;
  }
 
- span_bug!(self.tcx.hir().span(hir_id), "could not resolve {param_def_id:?}",);
  self.tcx
  .sess
  .delay_span_bug(self.tcx.hir().span(hir_id), "could not resolve {param_def_id:?}");
  }
 
  #[instrument(level = "debug", skip(self))]
@@ -1915,3 1943,37 @@ fn is_late_bound_map(
  }
  }
 }
 
 pub fn deny_non_region_late_bound(
  tcx: TyCtxt<'_>,
  bound_vars: &mut FxIndexMap<LocalDefId, ResolvedArg>,
  where_: &str,
 ) {
  let mut first = true;
 
  for (var, arg) in bound_vars {
  let Node::GenericParam(param) = tcx.hir().get_by_def_id(*var) else {
  bug!();
  };
 
  let what = match param.kind {
  hir::GenericParamKind::Type { .. } => "type",
  hir::GenericParamKind::Const { .. } => "const",
  hir::GenericParamKind::Lifetime { .. } => continue,
  };
 
  let mut diag = tcx.sess.struct_span_err(
  param.span,
  format!("late-bound {what} parameter not allowed on {where_}"),
  );
 
  let guar = if tcx.features().non_lifetime_binders && first {
  diag.emit()
  } else {
  diag.delay_as_bug()
  };
 
  first = false;
  *arg = ResolvedArg::Error(guar);
  }
 }